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 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 Java and all Java-based marks are trademarks or registered trademarks
22 of Sun Microsystems, Inc. in the United States and other countries.
23 The Free Software Foundation is independent of Sun Microsystems, Inc. */
25 /* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
34 #include "java-tree.h"
35 #include "java-opcodes.h"
41 /* The output file. */
44 /* Nonzero on failure. */
45 static int found_error = 0;
47 /* Nonzero if we're generating JNI output. */
48 static int flag_jni = 0;
50 /* Directory to place resulting files in. Set by -d option. */
51 const char *output_directory = "";
53 /* Directory to place temporary file. Set by -td option. Currently unused. */
54 const char *temp_directory = "/tmp";
56 /* Number of friend functions we have to declare. */
57 static int friend_count;
59 /* A class can optionally have a `friend' function declared. If
60 non-NULL, this is that function. */
61 static char **friend_specs = NULL;
63 /* Number of lines we are prepending before the class. */
64 static int prepend_count;
66 /* We can prepend extra lines before the class's start. */
67 static char **prepend_specs = NULL;
69 /* Number of lines we are appending at the end of the class. */
72 /* We can append extra lines just before the class's end. */
73 static char **add_specs = NULL;
75 /* Number of lines we are appending after the class. */
76 static int append_count;
78 /* We can append extra lines after the class's end. */
79 static char **append_specs = NULL;
85 struct JCF *current_jcf;
87 /* This holds access information for the last field we examined. They
88 let us generate "private:", "public:", and "protected:" properly.
89 If 0 then we haven't previously examined any field. */
90 static JCF_u2 last_access;
92 /* Pass this macro the flags for a class and for a method. It will
93 return true if the method should be considered `final'. */
94 #define METHOD_IS_FINAL(Class, Method) \
95 (((Class) & ACC_FINAL) || ((Method) & (ACC_FINAL | ACC_PRIVATE)))
97 /* Pass this macro the flags for a method. It will return true if the
99 #define METHOD_IS_NATIVE(Method) \
100 ((Method) & ACC_NATIVE)
102 /* We keep a linked list of all method names we have seen. This lets
103 us determine if a method name and a field name are in conflict. */
108 unsigned char *signature;
110 struct method_name *next;
113 /* List of method names we've seen. */
114 static struct method_name *method_name_list;
116 static void print_field_info PARAMS ((FILE*, JCF*, int, int, JCF_u2));
117 static void print_mangled_classname PARAMS ((FILE*, JCF*, const char*, int));
118 static int print_cxx_classname PARAMS ((FILE*, const char*, JCF*, int));
119 static void print_method_info PARAMS ((FILE*, JCF*, int, int, JCF_u2));
120 static void print_c_decl PARAMS ((FILE*, JCF*, int, int, int, const char *,
122 static void print_stub_or_jni PARAMS ((FILE*, JCF*, int, int, int,
124 static void print_full_cxx_name PARAMS ((FILE*, JCF*, int, int, int,
126 static void decompile_method PARAMS ((FILE*, JCF*, int));
127 static void add_class_decl PARAMS ((FILE*, JCF*, JCF_u2));
129 static int java_float_finite PARAMS ((jfloat));
130 static int java_double_finite PARAMS ((jdouble));
131 static void print_name PARAMS ((FILE *, JCF *, int));
132 static void print_base_classname PARAMS ((FILE *, JCF *, int));
133 static int utf8_cmp PARAMS ((const unsigned char *, int, const char *));
134 static char *cxx_keyword_subst PARAMS ((const unsigned char *, int));
135 static void generate_access PARAMS ((FILE *, JCF_u2));
136 static int name_is_method_p PARAMS ((const unsigned char *, int));
137 static char *get_field_name PARAMS ((JCF *, int, JCF_u2));
138 static void print_field_name PARAMS ((FILE *, JCF *, int, JCF_u2));
139 static const unsigned char *super_class_name PARAMS ((JCF *, int *));
140 static void print_include PARAMS ((FILE *, const unsigned char *, int));
141 static const unsigned char *decode_signature_piece
142 PARAMS ((FILE *, const unsigned char *, const unsigned char *, int *));
143 static void print_class_decls PARAMS ((FILE *, JCF *, int));
144 static void usage PARAMS ((void)) ATTRIBUTE_NORETURN;
145 static void help PARAMS ((void)) ATTRIBUTE_NORETURN;
146 static void version PARAMS ((void)) ATTRIBUTE_NORETURN;
147 static int overloaded_jni_method_exists_p PARAMS ((const unsigned char *, int,
149 static void jni_print_char PARAMS ((FILE *, int));
151 JCF_u2 current_field_name;
152 JCF_u2 current_field_value;
153 JCF_u2 current_field_signature;
154 JCF_u2 current_field_flags;
156 #define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
157 ( current_field_name = (NAME), current_field_signature = (SIGNATURE), \
158 current_field_flags = (ACCESS_FLAGS), current_field_value = 0)
160 /* We pass over fields twice. The first time we just note the types
161 of the fields and then the start of the methods. Then we go back
162 and parse the fields for real. This is ugly. */
163 static int field_pass;
164 /* Likewise we pass over methods twice. The first time we generate
165 class decl information; the second time we generate actual method
167 static int method_pass;
169 #define HANDLE_END_FIELD() \
172 if (out && ! stubs && ! flag_jni) \
173 print_field_info (out, jcf, current_field_name, \
174 current_field_signature, \
175 current_field_flags); \
177 else if (! stubs && ! flag_jni) \
178 add_class_decl (out, jcf, current_field_signature);
180 #define HANDLE_CONSTANTVALUE(VALUEINDEX) current_field_value = (VALUEINDEX)
182 static int method_declared = 0;
183 static int method_access = 0;
184 static int method_printed = 0;
185 #define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
188 decompiled = 0; method_printed = 0; \
190 print_method_info (out, jcf, NAME, SIGNATURE, ACCESS_FLAGS); \
193 print_method_info (NULL, jcf, NAME, SIGNATURE, ACCESS_FLAGS); \
194 else if (! stubs) add_class_decl (out, jcf, SIGNATURE);
196 #define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
197 if (out && method_declared) decompile_method (out, jcf, CODE_LENGTH);
199 static int decompiled = 0;
200 #define HANDLE_END_METHOD() \
201 if (out && method_printed) fputs (decompiled || stubs ? "\n" : ";\n", out);
203 #include "jcf-reader.c"
205 /* Some useful constants. */
206 #define F_NAN_MASK 0x7f800000
207 #if (1 == HOST_FLOAT_WORDS_BIG_ENDIAN) && ! defined (HOST_WORDS_BIG_ENDIAN)
208 #define D_NAN_MASK 0x000000007ff00000LL
210 #define D_NAN_MASK 0x7ff0000000000000LL
213 /* Return 1 if F is not Inf or NaN. */
215 java_float_finite (f)
221 /* We happen to know that F_NAN_MASK will match all NaN values, and
222 also positive and negative infinity. That's why we only need one
223 test here. See The Java Language Specification, section 20.9. */
224 return (u.i & F_NAN_MASK) != F_NAN_MASK;
227 /* Return 1 if D is not Inf or NaN. */
229 java_double_finite (d)
235 /* Now check for all NaNs. */
236 return (u.l & D_NAN_MASK) != D_NAN_MASK;
239 /* Print a character, appropriately mangled for JNI. */
242 jni_print_char (stream, ch)
247 jcf_print_char (stream, ch);
248 else if (ch == '(' || ch == ')')
253 fputs ("_1", stream);
255 fputs ("_2", stream);
257 fputs ("_3", stream);
260 else if ((ch >= '0' && ch <= '9')
261 || (ch >= 'a' && ch <= 'z')
262 || (ch >= 'A' && ch <= 'Z'))
266 /* "Unicode" character. */
267 fprintf (stream, "_0%04x", ch);
271 /* Print a name from the class data. If the index does not point to a
272 string, an error results. */
275 DEFUN(print_name, (stream, jcf, name_index),
276 FILE* stream AND JCF* jcf AND int name_index)
278 if (JPOOL_TAG (jcf, name_index) != CONSTANT_Utf8)
280 fprintf (stream, "<not a UTF8 constant>");
284 jcf_print_utf8 (stream, JPOOL_UTF_DATA (jcf, name_index),
285 JPOOL_UTF_LENGTH (jcf, name_index));
288 /* For JNI we must correctly quote each character. */
289 const unsigned char *str = JPOOL_UTF_DATA (jcf, name_index);
290 int length = JPOOL_UTF_LENGTH (jcf, name_index);
291 const unsigned char *limit = str + length;
294 int ch = UTF8_GET (str, limit);
297 fprintf (stream, "\\<invalid>");
300 jni_print_char (stream, ch);
305 /* Print base name of class. The base name is everything after the
309 print_base_classname (stream, jcf, index)
314 int name_index = JPOOL_USHORT1 (jcf, index);
316 const unsigned char *s, *p, *limit;
318 s = JPOOL_UTF_DATA (jcf, name_index);
319 len = JPOOL_UTF_LENGTH (jcf, name_index);
324 int c = UTF8_GET (s, limit);
331 int ch = UTF8_GET (p, limit);
333 fputs ("::", stream);
335 jcf_print_char (stream, ch);
339 /* Return 0 if NAME is equal to STR, -1 if STR is "less" than NAME,
340 and 1 if STR is "greater" than NAME. */
343 utf8_cmp (str, length, name)
344 const unsigned char *str;
348 const unsigned char *limit = str + length;
351 for (i = 0; name[i]; ++i)
353 int ch = UTF8_GET (str, limit);
358 return str == limit ? 0 : 1;
361 /* This is a sorted list of all C++ keywords. */
363 static const char *cxx_keywords[] =
399 /* If NAME is the name of a C++ keyword, then return an override name.
400 This is a name that can be used in place of the keyword.
401 Otherwise, return NULL. The return value is malloc()d. */
404 cxx_keyword_subst (str, length)
405 const unsigned char *str;
408 int last = sizeof (cxx_keywords) / sizeof (const char *);
410 int mid = (last + first) / 2;
413 for (mid = (last + first) / 2;
415 old = mid, mid = (last + first) / 2)
417 int r = utf8_cmp (str, length, cxx_keywords[mid]);
421 char *str = xmalloc (9 + strlen (cxx_keywords[mid]));
422 strcpy (str, "__dummy_");
423 strcat (str, cxx_keywords[mid]);
434 /* Generate an access control keyword based on FLAGS. */
437 generate_access (stream, flags)
441 if ((flags & ACC_VISIBILITY) == last_access)
443 last_access = (flags & ACC_VISIBILITY);
448 fputs ("public: // actually package-private\n", stream);
451 fputs ("public:\n", stream);
454 fputs ("private:\n", stream);
457 fputs ("public: // actually protected\n", stream);
461 fprintf (stream, "#error unrecognized visibility %d\n",
462 (flags & ACC_VISIBILITY));
467 /* See if NAME is already the name of a method. */
469 name_is_method_p (name, length)
470 const unsigned char *name;
473 struct method_name *p;
475 for (p = method_name_list; p != NULL; p = p->next)
477 if (p->length == length && ! memcmp (p->name, name, length))
483 /* If there is already a method named NAME, whose signature is not
484 SIGNATURE, then return true. Otherwise return false. */
486 overloaded_jni_method_exists_p (name, length, signature, sig_length)
487 const unsigned char *name;
489 const char *signature;
492 struct method_name *p;
494 for (p = method_name_list; p != NULL; p = p->next)
496 if (p->length == length
497 && ! memcmp (p->name, name, length)
498 && (p->sig_length != sig_length
499 || memcmp (p->signature, signature, sig_length)))
505 /* Get name of a field. This handles renamings due to C++ clash. */
507 get_field_name (jcf, name_index, flags)
512 unsigned char *name = JPOOL_UTF_DATA (jcf, name_index);
513 int length = JPOOL_UTF_LENGTH (jcf, name_index);
516 if (name_is_method_p (name, length))
518 /* This field name matches a method. So override the name with
519 a dummy name. This is yucky, but it isn't clear what else to
520 do. FIXME: if the field is static, then we'll be in real
522 if ((flags & ACC_STATIC))
524 fprintf (stderr, "static field has same name as method\n");
529 override = xmalloc (length + 3);
530 memcpy (override, name, length);
531 strcpy (override + length, "__");
534 override = cxx_keyword_subst (name, length);
539 /* Print a field name. Convenience function for use with
542 print_field_name (stream, jcf, name_index, flags)
548 char *override = get_field_name (jcf, name_index, flags);
552 fputs (override, stream);
556 jcf_print_utf8 (stream, JPOOL_UTF_DATA (jcf, name_index),
557 JPOOL_UTF_LENGTH (jcf, name_index));
561 DEFUN(print_field_info, (stream, jcf, name_index, sig_index, flags),
562 FILE *stream AND JCF* jcf
563 AND int name_index AND int sig_index AND JCF_u2 flags)
565 char *override = NULL;
567 generate_access (stream, flags);
568 if (JPOOL_TAG (jcf, name_index) != CONSTANT_Utf8)
570 fprintf (stream, "<not a UTF8 constant>");
576 if ((flags & ACC_STATIC))
577 fputs ("static ", out);
579 if ((flags & ACC_FINAL))
581 if (current_field_value > 0)
586 switch (JPOOL_TAG (jcf, current_field_value))
588 case CONSTANT_Integer:
591 int most_negative = 0;
592 fputs ("const jint ", out);
593 print_field_name (out, jcf, name_index, 0);
595 num = JPOOL_INT (jcf, current_field_value);
596 /* We single out the most negative number to print
597 specially. This avoids later warnings from g++. */
598 if (num == (jint) 0x80000000)
603 format_int (buffer, (jlong) num, 10);
604 fprintf (out, "%sL%s;\n", buffer, most_negative ? " - 1" : "");
610 int most_negative = 0;
611 fputs ("const jlong ", out);
612 print_field_name (out, jcf, name_index, 0);
614 num = JPOOL_LONG (jcf, current_field_value);
615 /* We single out the most negative number to print
616 specially.. This avoids later warnings from g++. */
617 if (num == (jlong) 0x8000000000000000LL)
622 format_int (buffer, num, 10);
623 fprintf (out, "%sLL%s;\n", buffer, most_negative ? " - 1" :"");
628 jfloat fnum = JPOOL_FLOAT (jcf, current_field_value);
629 fputs ("const jfloat ", out);
630 print_field_name (out, jcf, name_index, 0);
631 if (! java_float_finite (fnum))
634 fprintf (out, " = %.10g;\n", fnum);
637 case CONSTANT_Double:
639 jdouble dnum = JPOOL_DOUBLE (jcf, current_field_value);
640 fputs ("const jdouble ", out);
641 print_field_name (out, jcf, name_index, 0);
642 if (! java_double_finite (dnum))
645 fprintf (out, " = %.17g;\n", dnum);
649 /* We can't print this as a constant, but we can still
650 print something sensible. */
660 override = get_field_name (jcf, name_index, flags);
661 print_c_decl (out, jcf, name_index, sig_index, 0, override, flags);
669 DEFUN(print_method_info, (stream, jcf, name_index, sig_index, flags),
670 FILE *stream AND JCF* jcf
671 AND int name_index AND int sig_index AND JCF_u2 flags)
673 const unsigned char *str;
674 int length, is_init = 0;
675 char *override = NULL;
678 method_access = flags;
679 if (stream && JPOOL_TAG (jcf, name_index) != CONSTANT_Utf8)
680 fprintf (stream, "<not a UTF8 constant>");
681 str = JPOOL_UTF_DATA (jcf, name_index);
682 length = JPOOL_UTF_LENGTH (jcf, name_index);
683 if (str[0] == '<' || str[0] == '$')
685 /* Ignore internally generated methods like <clinit> and
686 $finit$. However, treat <init> as a constructor. */
687 if (! utf8_cmp (str, length, "<init>"))
689 else if (! METHOD_IS_FINAL (jcf->access_flags, flags)
690 && ! (flags & ACC_STATIC))
692 /* FIXME: i18n bug here. Order of prints should not be
694 fprintf (stderr, "ignored method `");
695 jcf_print_utf8 (stderr, str, length);
696 fprintf (stderr, "' marked virtual\n");
705 struct method_name *nn;
707 nn = (struct method_name *) xmalloc (sizeof (struct method_name));
708 nn->name = (char *) xmalloc (length);
709 memcpy (nn->name, str, length);
711 nn->next = method_name_list;
712 nn->sig_length = JPOOL_UTF_LENGTH (jcf, sig_index);
713 nn->signature = (char *) xmalloc (nn->sig_length);
714 memcpy (nn->signature, JPOOL_UTF_DATA (jcf, sig_index),
716 method_name_list = nn;
719 /* If we're not printing, then the rest of this function doesn't
720 matter. This happens during the first method pass in JNI mode.
725 /* We don't worry about overrides in JNI mode. */
728 /* We can't generate a method whose name is a C++ reserved word.
729 We can't just ignore the function, because that will cause
730 incorrect code to be generated if the function is virtual
731 (not only for calls to this function for for other functions
732 after it in the vtbl). So we give it a dummy name instead. */
733 override = cxx_keyword_subst (str, length);
736 /* If the method is static or final, we can safely skip it.
737 If we don't skip it then we'll have problems since the
738 mangling will be wrong. FIXME. */
739 if (METHOD_IS_FINAL (jcf->access_flags, flags)
740 || (flags & ACC_STATIC))
748 if (! stubs && ! flag_jni)
752 generate_access (stream, flags);
755 if ((flags & ACC_STATIC))
756 fputs ("static ", out);
757 else if (! METHOD_IS_FINAL (jcf->access_flags, flags))
759 /* Don't print `virtual' if we have a constructor. */
761 fputs ("virtual ", out);
763 print_c_decl (out, jcf, name_index, sig_index, is_init, override, flags);
765 if ((flags & ACC_ABSTRACT))
772 if (METHOD_IS_NATIVE (flags))
775 print_stub_or_jni (out, jcf, name_index, sig_index,
776 is_init, override, flags);
784 /* Try to decompile a method body. Right now we just try to handle a
785 simple case that we can do. Expand as desired. */
787 decompile_method (out, jcf, code_len)
792 const unsigned char *codes = jcf->read_ptr;
794 uint16 name_and_type, name;
796 /* If the method is synchronized, don't touch it. */
797 if ((method_access & ACC_SYNCHRONIZED))
801 && codes[0] == OPCODE_aload_0
802 && codes[1] == OPCODE_getfield
803 && (codes[4] == OPCODE_areturn
804 || codes[4] == OPCODE_dreturn
805 || codes[4] == OPCODE_freturn
806 || codes[4] == OPCODE_ireturn
807 || codes[4] == OPCODE_lreturn))
809 /* Found code like `return FIELD'. */
810 fputs (" { return ", out);
811 index = (codes[2] << 8) | codes[3];
812 /* FIXME: ensure that tag is CONSTANT_Fieldref. */
813 /* FIXME: ensure that the field's class is this class. */
814 name_and_type = JPOOL_USHORT2 (jcf, index);
815 /* FIXME: ensure that tag is CONSTANT_NameAndType. */
816 name = JPOOL_USHORT1 (jcf, name_and_type);
818 print_field_name (out, jcf, name, 0);
822 else if (code_len == 2
823 && codes[0] == OPCODE_aload_0
824 && codes[1] == OPCODE_areturn)
826 /* Found `return this'. */
827 fputs (" { return this; }", out);
830 else if (code_len == 1 && codes[0] == OPCODE_return)
832 /* Found plain `return'. */
836 else if (code_len == 2
837 && codes[0] == OPCODE_aconst_null
838 && codes[1] == OPCODE_areturn)
840 /* Found `return null'. We don't want to depend on NULL being
842 fputs (" { return 0; }", out);
847 /* Print one piece of a signature. Returns pointer to next parseable
848 character on success, NULL on error. */
849 static const unsigned char *
850 decode_signature_piece (stream, signature, limit, need_space)
852 const unsigned char *signature, *limit;
858 switch (signature[0])
861 /* More spaghetti. */
864 for (signature++; (signature < limit
866 && *signature <= '9'); signature++)
871 ctype = "jbyteArray";
874 ctype = "jcharArray";
877 ctype = "jdoubleArray";
880 ctype = "jfloatArray";
886 ctype = "jshortArray";
889 ctype = "jlongArray";
892 ctype = "jbooleanArray";
895 /* We have a nested array. */
898 fputs ("JArray<", stream);
902 /* We have to generate a reference to JArray here, so that
903 our output matches what the compiler does. */
905 /* Space between `<' and `:' to avoid C++ digraphs. */
907 fputs ("JArray< ::", stream);
908 while (signature < limit && *signature != ';')
910 int ch = UTF8_GET (signature, limit);
914 fputs ("::", stream);
916 jcf_print_char (stream, ch);
920 fputs (" *> *", stream);
925 /* Unparseable signature. */
929 /* If the previous iterations left us with something to print,
930 print it. For JNI, we always print `jobjectArray' in the
932 if (flag_jni && ctype == NULL)
934 ctype = "jobjectArray";
937 /* The `printit' case will advance SIGNATURE for us. If we
938 don't go there, we must advance past the `;' ourselves. */
946 /* This shouldn't happen. */
949 case 'B': ctype = "jbyte"; goto printit;
950 case 'C': ctype = "jchar"; goto printit;
951 case 'D': ctype = "jdouble"; goto printit;
952 case 'F': ctype = "jfloat"; goto printit;
953 case 'I': ctype = "jint"; goto printit;
954 case 'J': ctype = "jlong"; goto printit;
955 case 'S': ctype = "jshort"; goto printit;
956 case 'Z': ctype = "jboolean"; goto printit;
957 case 'V': ctype = "void"; goto printit;
961 /* We know about certain types and special-case their
963 FIXME: something like java.lang.Exception should be
964 printed as `jthrowable', because it is a subclass. This
965 means that gcjh must read the entire hierarchy and
967 if (! strncmp (signature, "Ljava/lang/String;",
968 sizeof ("Ljava/lang/String;") -1))
970 else if (! strncmp (signature, "Ljava/lang/Class;",
971 sizeof ("Ljava/lang/Class;") - 1))
973 else if (! strncmp (signature, "Ljava/lang/Throwable;",
974 sizeof ("Ljava/lang/Throwable;") - 1))
975 ctype = "jthrowable";
976 else if (! strncmp (signature, "Ljava/lang/ref/WeakReference;",
977 sizeof ("Ljava/lang/ref/WeakReference;") - 1))
982 while (*signature && *signature != ';')
987 /* Print a leading "::" so we look in the right namespace. */
988 fputs ("::", stream);
990 while (*signature && *signature != ';')
992 int ch = UTF8_GET (signature, limit);
993 /* `$' is the separator for an inner class. */
994 if (ch == '/' || ch == '$')
995 fputs ("::", stream);
997 jcf_print_char (stream, ch);
999 fputs (" *", stream);
1000 if (*signature == ';')
1006 jni_print_char (stream, *signature++);
1011 fputs (ctype, stream);
1017 while (array_depth-- > 0)
1018 fputs ("> *", stream);
1025 DEFUN(print_c_decl, (stream, jcf, name_index, signature_index, is_init,
1026 name_override, flags),
1027 FILE* stream AND JCF* jcf
1028 AND int name_index AND int signature_index
1029 AND int is_init AND const char *name_override AND int flags)
1031 if (JPOOL_TAG (jcf, signature_index) != CONSTANT_Utf8)
1033 fprintf (stream, "<not a UTF8 constant>");
1038 int length = JPOOL_UTF_LENGTH (jcf, signature_index);
1039 const unsigned char *str0 = JPOOL_UTF_DATA (jcf, signature_index);
1040 register const unsigned char *str = str0;
1041 const unsigned char *limit = str + length;
1043 int is_method = str[0] == '(';
1044 const unsigned char *next;
1046 /* If printing a method, skip to the return signature and print
1047 that first. However, there is no return value if this is a
1049 if (is_method && ! is_init)
1059 /* If printing a field or an ordinary method, then print the
1060 "return value" now. */
1061 if (! is_method || ! is_init)
1063 next = decode_signature_piece (stream, str, limit, &need_space);
1066 fprintf (stderr, "unparseable signature: `%s'\n", str0);
1072 /* Now print the name of the thing. */
1074 fputs (" ", stream);
1075 print_full_cxx_name (stream, jcf, name_index,
1076 signature_index, is_init, name_override,
1081 /* Print the unqualified method name followed by the signature. */
1083 DEFUN(print_full_cxx_name, (stream, jcf, name_index, signature_index,
1084 is_init, name_override, flags),
1085 FILE* stream AND JCF* jcf
1086 AND int name_index AND int signature_index AND int is_init
1087 AND const char *name_override AND int flags)
1089 int length = JPOOL_UTF_LENGTH (jcf, signature_index);
1090 const unsigned char *str0 = JPOOL_UTF_DATA (jcf, signature_index);
1091 register const unsigned char *str = str0;
1092 const unsigned char *limit = str + length;
1094 int is_method = str[0] == '(';
1095 const unsigned char *next;
1098 fputs (name_override, stream);
1099 else if (name_index)
1101 /* Declare constructors specially. */
1103 print_base_classname (stream, jcf, jcf->this_class);
1105 print_name (stream, jcf, name_index);
1110 unsigned char *signature = JPOOL_UTF_DATA (jcf, signature_index);
1111 int sig_len = JPOOL_UTF_LENGTH (jcf, signature_index);
1112 if (overloaded_jni_method_exists_p (JPOOL_UTF_DATA (jcf, name_index),
1113 JPOOL_UTF_LENGTH (jcf, name_index),
1114 signature, sig_len))
1116 /* If this method is overloaded by another native method,
1117 then include the argument information in the mangled
1119 unsigned char *limit = signature + sig_len;
1120 fputs ("__", stream);
1121 while (signature < limit)
1123 int ch = UTF8_GET (signature, limit);
1124 jni_print_char (stream, ch);
1136 /* Have a method or a constructor. Print signature pieces
1138 fputs (" (", stream);
1142 /* In JNI mode, add extra arguments. */
1145 /* FIXME: it would be nice to know if we are printing a decl
1146 or a definition, and only print `env' for the latter. */
1147 fputs ("JNIEnv *env", stream);
1149 fputs ((flags & ACC_STATIC) ? ", jclass" : ", jobject", stream);
1152 fputs (", ", stream);
1155 while (str < limit && *str != ')')
1157 next = decode_signature_piece (stream, str, limit, &need_space);
1160 fprintf (stderr, "unparseable signature: `%s'\n", str0);
1165 if (next < limit && *next != ')')
1166 fputs (", ", stream);
1170 fputs (")", stream);
1174 /* This is a helper for print_stub_or_jni. */
1176 DEFUN (print_name_for_stub_or_jni, (stream, jcf, name_index, signature_index,
1177 is_init, name_override, flags),
1178 FILE *stream AND JCF *jcf
1179 AND int name_index AND int signature_index
1180 AND int is_init AND const char *name_override AND int flags)
1182 const char *const prefix = flag_jni ? "Java_" : "";
1183 print_cxx_classname (stream, prefix, jcf, jcf->this_class);
1184 fputs (flag_jni ? "_" : "::", stream);
1185 print_full_cxx_name (stream, jcf, name_index,
1186 signature_index, is_init, name_override,
1191 DEFUN(print_stub_or_jni, (stream, jcf, name_index, signature_index, is_init,
1192 name_override, flags),
1193 FILE* stream AND JCF* jcf
1194 AND int name_index AND int signature_index
1195 AND int is_init AND const char *name_override AND int flags)
1197 if (JPOOL_TAG (jcf, signature_index) != CONSTANT_Utf8)
1199 fprintf (stream, "<not a UTF8 constant>");
1204 int length = JPOOL_UTF_LENGTH (jcf, signature_index);
1205 const unsigned char *str0 = JPOOL_UTF_DATA (jcf, signature_index);
1206 register const unsigned char *str = str0;
1207 const unsigned char *limit = str + length;
1209 int is_method = str[0] == '(';
1210 const unsigned char *next;
1212 /* Don't print fields in the JNI case. */
1213 if (! is_method && flag_jni)
1216 if (flag_jni && ! stubs)
1217 fputs ("extern ", stream);
1219 /* If printing a method, skip to the return signature and print
1220 that first. However, there is no return value if this is a
1222 if (is_method && ! is_init)
1232 /* If printing a field or an ordinary method, then print the
1233 "return value" now. Note that a constructor can't be native,
1234 so we don't bother checking this in the JNI case. */
1235 if (! is_method || ! is_init)
1237 next = decode_signature_piece (stream, str, limit, &need_space);
1240 fprintf (stderr, "unparseable signature: `%s'\n", str0);
1246 /* When printing a JNI header we need to respect the space. In
1247 other cases we're just going to insert a newline anyway. */
1248 fputs (need_space && ! stubs ? " " : "\n", stream);
1250 /* Now print the name of the thing. */
1251 print_name_for_stub_or_jni (stream, jcf, name_index,
1252 signature_index, is_init, name_override,
1255 /* Print the body. */
1259 fputs ("\n{\n (*env)->FatalError (\"", stream);
1261 fputs ("\n{\n JvFail (\"", stream);
1262 print_name_for_stub_or_jni (stream, jcf, name_index,
1263 signature_index, is_init,
1266 fputs (" not implemented\");\n}\n\n", stream);
1272 DEFUN(print_mangled_classname, (stream, jcf, prefix, index),
1273 FILE *stream AND JCF *jcf AND const char *prefix AND int index)
1275 int name_index = JPOOL_USHORT1 (jcf, index);
1276 fputs (prefix, stream);
1277 jcf_print_utf8_replace (out,
1278 JPOOL_UTF_DATA (jcf, name_index),
1279 JPOOL_UTF_LENGTH (jcf, name_index),
1283 /* Print PREFIX, then a class name in C++ format. If the name refers
1284 to an array, ignore it and don't print PREFIX. Returns 1 if
1285 something was printed, 0 otherwise. */
1287 print_cxx_classname (stream, prefix, jcf, index)
1293 int name_index = JPOOL_USHORT1 (jcf, index);
1295 const unsigned char *s, *p, *limit;
1297 s = JPOOL_UTF_DATA (jcf, name_index);
1298 len = JPOOL_UTF_LENGTH (jcf, name_index);
1301 /* Explicitly omit arrays here. */
1303 c = UTF8_GET (p, limit);
1307 fputs (prefix, stream);
1309 /* Print a leading "::" so we look in the right namespace. */
1310 if (! flag_jni && ! stubs)
1311 fputs ("::", stream);
1315 c = UTF8_GET (s, limit);
1317 fputs (flag_jni ? "_" : "::", stream);
1319 jni_print_char (stream, c);
1325 int written_class_count = 0;
1327 /* Return name of superclass. If LEN is not NULL, fill it with length
1329 static const unsigned char *
1330 super_class_name (derived_jcf, len)
1334 int supername_index = JPOOL_USHORT1 (derived_jcf, derived_jcf->super_class);
1335 int supername_length = JPOOL_UTF_LENGTH (derived_jcf, supername_index);
1336 const unsigned char *supername =
1337 JPOOL_UTF_DATA (derived_jcf, supername_index);
1340 *len = supername_length;
1347 /* We keep track of all the `#include's we generate, so we can avoid
1352 struct include *next;
1355 /* List of all includes. */
1356 static struct include *all_includes = NULL;
1358 /* Generate a #include. */
1360 print_include (out, utf8, len)
1362 const unsigned char *utf8;
1365 struct include *incl;
1371 len = strlen (utf8);
1373 for (incl = all_includes; incl; incl = incl->next)
1375 /* We check the length because we might have a proper prefix. */
1376 if (len == (int) strlen (incl->name)
1377 && ! strncmp (incl->name, utf8, len))
1381 incl = (struct include *) xmalloc (sizeof (struct include));
1382 incl->name = xmalloc (len + 1);
1383 strncpy (incl->name, utf8, len);
1384 incl->name[len] = '\0';
1385 incl->next = all_includes;
1386 all_includes = incl;
1388 fputs ("#include <", out);
1389 jcf_print_utf8_replace (out, utf8, len,
1391 flag_jni ? '_' : '/');
1392 fputs (".h>\n", out);
1397 /* This is used to represent part of a package or class name. */
1400 /* The text of this part of the name. */
1402 /* True if this represents a class. */
1404 /* Linked list of all classes and packages inside this one. */
1405 struct namelet *subnamelets;
1406 /* Pointer to next sibling. */
1407 struct namelet *next;
1410 static void add_namelet PARAMS ((const unsigned char *,
1411 const unsigned char *, struct namelet *));
1412 static void print_namelet PARAMS ((FILE *, struct namelet *, int));
1414 /* The special root namelet. */
1415 static struct namelet root =
1423 /* This extracts the next name segment from the full UTF-8 encoded
1424 package or class name and links it into the tree. It does this
1427 add_namelet (name, name_limit, parent)
1428 const unsigned char *name, *name_limit;
1429 struct namelet *parent;
1431 const unsigned char *p;
1432 struct namelet *n = NULL, *np;
1434 /* We want to skip the standard namespaces that we assume the
1435 runtime already knows about. We only do this at the top level,
1436 though, hence the check for `root'. */
1437 if (parent == &root)
1439 #define JAVALANG "java/lang/"
1440 #define JAVAIO "java/io/"
1441 #define JAVAUTIL "java/util/"
1442 if ((name_limit - name >= (int) sizeof (JAVALANG) - 1
1443 && ! strncmp (name, JAVALANG, sizeof (JAVALANG) - 1))
1444 || (name_limit - name >= (int) sizeof (JAVAUTIL) - 1
1445 && ! strncmp (name, JAVAUTIL, sizeof (JAVAUTIL) - 1))
1446 || (name_limit - name >= (int) sizeof (JAVAIO) - 1
1447 && ! strncmp (name, JAVAIO, sizeof (JAVAIO) - 1)))
1451 for (p = name; p < name_limit && *p != '/' && *p != '$'; ++p)
1454 /* Search for this name beneath the PARENT node. */
1455 for (np = parent->subnamelets; np != NULL; np = np->next)
1457 /* We check the length because we might have a proper prefix. */
1458 if ((int) strlen (np->name) == p - name &&
1459 ! strncmp (name, np->name, p - name))
1468 n = (struct namelet *) xmalloc (sizeof (struct namelet));
1469 n->name = xmalloc (p - name + 1);
1470 strncpy (n->name, name, p - name);
1471 n->name[p - name] = '\0';
1472 n->is_class = (p == name_limit || *p == '$');
1473 n->subnamelets = NULL;
1474 n->next = parent->subnamelets;
1475 parent->subnamelets = n;
1478 /* We recurse if there is more text, and if the trailing piece does
1479 not represent an inner class. */
1480 if (p < name_limit && *p != '$')
1481 add_namelet (p + 1, name_limit, n);
1484 /* Print a single namelet. Destroys namelets while printing. */
1486 print_namelet (out, name, depth)
1488 struct namelet *name;
1496 for (i = 0; i < depth; ++i)
1498 fprintf (out, "%s %s", name->is_class ? "class" : "namespace",
1500 if (name->is_class && name->subnamelets == NULL)
1506 for (i = 0; i < depth; ++i)
1512 c = name->subnamelets;
1515 struct namelet *next = c->next;
1516 print_namelet (out, c, depth + 2);
1524 for (i = 0; i < depth; ++i)
1527 /* Only print a `;' when printing a class. C++ is evil. */
1537 /* This is called to add some classes to the list of classes for which
1538 we need decls. The signature argument can be a function
1541 add_class_decl (out, jcf, signature)
1546 const unsigned char *s = JPOOL_UTF_DATA (jcf, signature);
1547 int len = JPOOL_UTF_LENGTH (jcf, signature);
1549 /* Name of class we are processing. */
1550 int name_index = JPOOL_USHORT1 (jcf, jcf->this_class);
1551 int tlen = JPOOL_UTF_LENGTH (jcf, name_index);
1552 const char *tname = JPOOL_UTF_DATA (jcf, name_index);
1554 for (i = 0; i < len; ++i)
1556 int start, saw_dollar;
1558 /* If we see an array, then we include the array header. */
1561 print_include (out, "gcj/array", -1);
1565 /* We're looking for `L<stuff>;' -- everything else is
1571 for (start = ++i; i < len && s[i] != ';'; ++i)
1573 if (! saw_dollar && s[i] == '$' && out)
1576 /* If this class represents an inner class, then
1577 generate a `#include' for the outer class. However,
1578 don't generate the include if the outer class is the
1579 class we are processing. */
1580 if (i - start < tlen || strncmp (&s[start], tname, i - start))
1581 print_include (out, &s[start], i - start);
1586 /* If we saw an inner class, then the generated #include will
1587 declare the class. So in this case we needn't bother. */
1589 add_namelet (&s[start], &s[i], &root);
1593 /* Print declarations for all classes required by this class. Any
1594 class or package in the `java' package is assumed to be handled
1595 statically in libjava; we don't generate declarations for these.
1596 This makes the generated headers a bit easier to read. */
1598 print_class_decls (out, jcf, self)
1603 /* Make sure to always add the current class to the list of things
1604 that should be declared. */
1605 int name_index = JPOOL_USHORT1 (jcf, self);
1607 const unsigned char *s;
1609 s = JPOOL_UTF_DATA (jcf, name_index);
1610 len = JPOOL_UTF_LENGTH (jcf, name_index);
1611 add_namelet (s, s + len, &root);
1613 if (root.subnamelets)
1615 fputs ("extern \"Java\"\n{\n", out);
1616 /* We use an initial offset of 0 because the root namelet
1617 doesn't cause anything to print. */
1618 print_namelet (out, &root, 0);
1619 fputs ("};\n\n", out);
1626 DEFUN(process_file, (jcf, out),
1627 JCF *jcf AND FILE *out)
1630 uint32 field_start, method_end, method_start;
1636 if (jcf_parse_preamble (jcf) != 0)
1638 fprintf (stderr, "Not a valid Java .class file.\n");
1643 /* Parse and possibly print constant pool */
1644 code = jcf_parse_constant_pool (jcf);
1647 fprintf (stderr, "error while parsing constant pool\n");
1651 code = verify_constant_pool (jcf);
1654 fprintf (stderr, "error in constant pool entry #%d\n", code);
1659 jcf_parse_class (jcf);
1661 if (written_class_count++ == 0 && out)
1663 const char *cstart, *cstart2, *mode, *cend, *what, *jflag;
1678 mode = " -*- c++ -*-";
1684 fprintf (out, "%s DO NOT EDIT THIS FILE - it is machine generated%s%s\n\n",
1685 cstart, mode, cend);
1688 fprintf (out, "%s This file was created by `gcjh -stubs%s'.%s\n\
1690 %s This file is intended to give you a head start on implementing native\n\
1691 %s methods using %s.\n\
1692 %s Be aware: running `gcjh -stubs %s' once more for this class may\n\
1693 %s overwrite any edits you have made to this file.%s\n\n",
1694 cstart, jflag, mode,
1710 print_mangled_classname (out, jcf, "#ifndef __", jcf->this_class);
1711 fprintf (out, "__\n");
1713 print_mangled_classname (out, jcf, "#define __", jcf->this_class);
1714 fprintf (out, "__\n\n");
1718 fprintf (out, "#include <jni.h>\n\n");
1719 fprintf (out, "#ifdef __cplusplus\n");
1720 fprintf (out, "extern \"C\"\n");
1721 fprintf (out, "{\n");
1722 fprintf (out, "#endif\n");
1726 /* We do this to ensure that inline methods won't be
1727 `outlined' by g++. This works as long as method and
1728 fields are not added by the user. */
1729 fprintf (out, "#pragma interface\n");
1731 if (jcf->super_class)
1734 const unsigned char *supername =
1735 super_class_name (jcf, &super_length);
1738 print_include (out, supername, super_length);
1744 /* Strip off the ".class" portion of the name when printing
1745 the include file name. */
1746 int len = strlen (jcf->classname);
1747 if (len > 6 && ! strcmp (&jcf->classname[len - 6], ".class"))
1749 print_include (out, jcf->classname, len);
1750 print_include (out, "gcj/cni", -1);
1754 /* We want to parse the methods first. But we need to find where
1755 they start. So first we skip the fields, then parse the methods.
1756 Then we parse the fields and skip the methods. This is ugly, but
1757 not too bad since we need two full passes to get class decl
1758 information anyway. */
1760 field_start = JCF_TELL (jcf);
1761 jcf_parse_fields (jcf);
1763 method_start = JCF_TELL (jcf);
1765 jcf_parse_methods (jcf);
1770 if (out && ! flag_jni)
1773 print_class_decls (out, jcf, jcf->this_class);
1775 for (i = 0; i < prepend_count; ++i)
1776 fprintf (out, "%s\n", prepend_specs[i]);
1777 if (prepend_count > 0)
1782 if (! print_cxx_classname (out, "class ", jcf, jcf->this_class))
1784 fprintf (stderr, "class is of array type\n");
1788 if (jcf->super_class)
1790 if (! print_cxx_classname (out, " : public ",
1791 jcf, jcf->super_class))
1793 fprintf (stderr, "base class is of array type\n");
1799 fputs ("\n{\n", out);
1803 /* Now go back for second pass over methods and fields. */
1804 JCF_SEEK (jcf, method_start);
1806 jcf_parse_methods (jcf);
1807 method_end = JCF_TELL (jcf);
1810 JCF_SEEK (jcf, field_start);
1811 jcf_parse_fields (jcf);
1812 JCF_SEEK (jcf, method_end);
1814 jcf_parse_final_attributes (jcf);
1820 fprintf (out, "\n#ifdef __cplusplus\n");
1821 fprintf (out, "}\n");
1822 fprintf (out, "#endif\n");
1826 /* Generate friend decl if we still must. */
1827 for (i = 0; i < friend_count; ++i)
1828 fprintf (out, " friend %s\n", friend_specs[i]);
1830 /* Generate extra declarations. */
1833 for (i = 0; i < add_count; ++i)
1834 fprintf (out, " %s\n", add_specs[i]);
1837 fputs ("};\n", out);
1839 if (append_count > 0)
1841 for (i = 0; i < append_count; ++i)
1842 fprintf (out, "%s\n", append_specs[i]);
1845 print_mangled_classname (out, jcf,
1846 "\n#endif /* __", jcf->this_class);
1847 fprintf (out, "__ */\n");
1853 /* This is used to mark options with no short value. */
1854 #define LONG_OPT(Num) ((Num) + 128)
1856 #define OPT_classpath LONG_OPT (0)
1857 #define OPT_CLASSPATH LONG_OPT (1)
1858 #define OPT_HELP LONG_OPT (2)
1859 #define OPT_TEMP LONG_OPT (3)
1860 #define OPT_VERSION LONG_OPT (4)
1861 #define OPT_PREPEND LONG_OPT (5)
1862 #define OPT_FRIEND LONG_OPT (6)
1863 #define OPT_ADD LONG_OPT (7)
1864 #define OPT_APPEND LONG_OPT (8)
1865 #define OPT_M LONG_OPT (9)
1866 #define OPT_MM LONG_OPT (10)
1867 #define OPT_MG LONG_OPT (11)
1868 #define OPT_MD LONG_OPT (12)
1869 #define OPT_MMD LONG_OPT (13)
1871 static struct option options[] =
1873 { "classpath", required_argument, NULL, OPT_classpath },
1874 { "CLASSPATH", required_argument, NULL, OPT_CLASSPATH },
1875 { "help", no_argument, NULL, OPT_HELP },
1876 { "stubs", no_argument, &stubs, 1 },
1877 { "td", required_argument, NULL, OPT_TEMP },
1878 { "verbose", no_argument, NULL, 'v' },
1879 { "version", no_argument, NULL, OPT_VERSION },
1880 { "prepend", required_argument, NULL, OPT_PREPEND },
1881 { "friend", required_argument, NULL, OPT_FRIEND },
1882 { "add", required_argument, NULL, OPT_ADD },
1883 { "append", required_argument, NULL, OPT_APPEND },
1884 { "M", no_argument, NULL, OPT_M },
1885 { "MM", no_argument, NULL, OPT_MM },
1886 { "MG", no_argument, NULL, OPT_MG },
1887 { "MD", no_argument, NULL, OPT_MD },
1888 { "MMD", no_argument, NULL, OPT_MMD },
1889 { "jni", no_argument, &flag_jni, 1 },
1890 { NULL, no_argument, NULL, 0 }
1896 fprintf (stderr, "Try `gcjh --help' for more information.\n");
1903 printf ("Usage: gcjh [OPTION]... CLASS...\n\n");
1904 printf ("Generate C++ header files from .class files\n\n");
1905 printf (" -stubs Generate an implementation stub file\n");
1906 printf (" -jni Generate a JNI header or stub\n");
1908 printf (" -add TEXT Insert TEXT into class body\n");
1909 printf (" -append TEXT Insert TEXT after class declaration\n");
1910 printf (" -friend TEXT Insert TEXT as `friend' declaration\n");
1911 printf (" -prepend TEXT Insert TEXT before start of class\n");
1913 printf (" --classpath PATH Set path to find .class files\n");
1914 printf (" --CLASSPATH PATH Set path to find .class files\n");
1915 printf (" -IDIR Append directory to class path\n");
1916 printf (" -d DIRECTORY Set output directory name\n");
1917 printf (" -o FILE Set output file name\n");
1918 printf (" -td DIRECTORY Set temporary directory name\n");
1920 printf (" --help Print this help, then exit\n");
1921 printf (" --version Print version number, then exit\n");
1922 printf (" -v, --verbose Print extra information while running\n");
1924 printf (" -M Print all dependencies to stdout;\n");
1925 printf (" suppress ordinary output\n");
1926 printf (" -MM Print non-system dependencies to stdout;\n");
1927 printf (" suppress ordinary output\n");
1928 printf (" -MD Print all dependencies to stdout\n");
1929 printf (" -MMD Print non-system dependencies to stdout\n");
1930 /* We omit -MG until it is implemented. */
1932 printf ("For bug reporting instructions, please see:\n");
1933 printf ("%s.\n", GCCBUGURL);
1940 printf ("gcjh (%s)\n\n", version_string);
1941 printf ("Copyright (C) 1998, 1999 Free Software Foundation, Inc.\n");
1942 printf ("This is free software; see the source for copying conditions. There is NO\n");
1943 printf ("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
1948 DEFUN(main, (argc, argv),
1949 int argc AND char** argv)
1953 char *output_file = NULL;
1954 int emit_dependencies = 0, suppress_output = 0;
1959 fprintf (stderr, "gcjh: no classes specified\n");
1965 /* We use getopt_long_only to allow single `-' long options. For
1966 some of our options this is more natural. */
1967 while ((opt = getopt_long_only (argc, argv, "I:d:o:v", options, NULL)) != -1)
1972 /* Already handled. */
1976 output_file = optarg;
1980 output_directory = optarg;
1984 jcf_path_include_arg (optarg);
1992 jcf_path_classpath_arg (optarg);
1996 jcf_path_CLASSPATH_arg (optarg);
2004 temp_directory = optarg;
2012 if (prepend_count == 0)
2013 prepend_specs = (char**) ALLOC (argc * sizeof (char*));
2014 prepend_specs[prepend_count++] = optarg;
2018 if (friend_count == 0)
2019 friend_specs = (char**) ALLOC (argc * sizeof (char*));
2020 friend_specs[friend_count++] = optarg;
2025 add_specs = (char**) ALLOC (argc * sizeof (char*));
2026 add_specs[add_count++] = optarg;
2030 if (append_count == 0)
2031 append_specs = (char**) ALLOC (argc * sizeof (char*));
2032 append_specs[append_count++] = optarg;
2036 emit_dependencies = 1;
2037 suppress_output = 1;
2038 jcf_dependency_init (1);
2042 emit_dependencies = 1;
2043 suppress_output = 1;
2044 jcf_dependency_init (0);
2048 fprintf (stderr, "gcjh: `-MG' option is unimplemented\n");
2052 emit_dependencies = 1;
2053 jcf_dependency_init (1);
2057 emit_dependencies = 1;
2058 jcf_dependency_init (0);
2069 fprintf (stderr, "gcjh: no classes specified\n");
2075 if (output_file && emit_dependencies)
2077 fprintf (stderr, "gcjh: can't specify both -o and -MD\n");
2081 for (argi = optind; argi < argc; argi++)
2083 char *classname = argv[argi];
2084 char *current_output_file;
2085 const char *classfile_name;
2088 fprintf (stderr, "Processing %s\n", classname);
2090 jcf_dependency_reset ();
2091 classfile_name = find_class (classname, strlen (classname), &jcf, 0);
2092 if (classfile_name == NULL)
2094 fprintf (stderr, "%s: no such class\n", classname);
2098 fprintf (stderr, "Found in %s\n", classfile_name);
2101 if (strcmp (output_file, "-") == 0)
2103 else if (out == NULL)
2105 out = fopen (output_file, "w");
2109 perror (output_file);
2112 current_output_file = output_file;
2116 int dir_len = strlen (output_directory);
2117 int i, classname_length = strlen (classname);
2118 current_output_file = (char*) ALLOC (dir_len + classname_length + 5);
2119 strcpy (current_output_file, output_directory);
2120 if (dir_len > 0 && output_directory[dir_len-1] != '/')
2121 current_output_file[dir_len++] = '/';
2122 for (i = 0; classname[i] != '\0'; i++)
2124 char ch = classname[i];
2127 if (flag_jni && ch == '/')
2129 current_output_file[dir_len++] = ch;
2131 if (emit_dependencies)
2133 if (suppress_output)
2135 jcf_dependency_set_dep_file ("-");
2140 /* We use `.hd' and not `.d' to avoid clashes with
2141 dependency tracking from straight compilation. */
2142 strcpy (current_output_file + dir_len, ".hd");
2143 jcf_dependency_set_dep_file (current_output_file);
2146 strcpy (current_output_file + dir_len,
2147 stubs ? (flag_jni ? ".c" : ".cc") : ".h");
2148 jcf_dependency_set_target (current_output_file);
2149 if (! suppress_output)
2151 out = fopen (current_output_file, "w");
2154 perror (current_output_file);
2159 process_file (&jcf, out);
2161 if (current_output_file != output_file)
2162 free (current_output_file);
2163 jcf_dependency_write ();
2166 if (out != NULL && out != stdout)