expr.c (build_jni_stub): Use the computed jni func type for variable meth.
[gcc.git] / gcc / java / jcf-parse.c
1 /* Parser for Java(TM) .class files.
2 Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
20
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. */
24
25 /* Written by Per Bothner <bothner@cygnus.com> */
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "tree.h"
32 #include "real.h"
33 #include "obstack.h"
34 #include "flags.h"
35 #include "java-except.h"
36 #include "input.h"
37 #include "javaop.h"
38 #include "java-tree.h"
39 #include "toplev.h"
40 #include "parse.h"
41 #include "ggc.h"
42 #include "debug.h"
43 #include "assert.h"
44 #include "tm_p.h"
45 #include "cgraph.h"
46 #include "vecprim.h"
47
48 #ifdef HAVE_LOCALE_H
49 #include <locale.h>
50 #endif
51
52 #ifdef HAVE_LANGINFO_CODESET
53 #include <langinfo.h>
54 #endif
55
56 /* A CONSTANT_Utf8 element is converted to an IDENTIFIER_NODE at parse time. */
57 #define JPOOL_UTF(JCF, INDEX) CPOOL_UTF(&(JCF)->cpool, INDEX)
58 #define JPOOL_UTF_LENGTH(JCF, INDEX) IDENTIFIER_LENGTH (JPOOL_UTF (JCF, INDEX))
59 #define JPOOL_UTF_DATA(JCF, INDEX) \
60 ((const unsigned char *) IDENTIFIER_POINTER (JPOOL_UTF (JCF, INDEX)))
61 #define HANDLE_CONSTANT_Utf8(JCF, INDEX, LENGTH) \
62 do { \
63 unsigned char save; unsigned char *text; \
64 JCF_FILL (JCF, (LENGTH)+1); /* Make sure we read 1 byte beyond string. */ \
65 text = (JCF)->read_ptr; \
66 save = text[LENGTH]; \
67 text[LENGTH] = 0; \
68 (JCF)->cpool.data[INDEX].t = get_identifier ((const char *) text); \
69 text[LENGTH] = save; \
70 JCF_SKIP (JCF, LENGTH); } while (0)
71
72 #include "jcf.h"
73
74 extern struct obstack temporary_obstack;
75
76 static GTY(()) tree parse_roots[3];
77
78 /* The FIELD_DECL for the current field. */
79 #define current_field parse_roots[0]
80
81 /* The METHOD_DECL for the current method. */
82 #define current_method parse_roots[1]
83
84 /* A list of TRANSLATION_UNIT_DECLs for the files to be compiled. */
85 #define current_file_list parse_roots[2]
86
87 /* Line 0 in current file, if compiling from bytecode. */
88 static location_t file_start_location;
89
90 /* The Java archive that provides main_class; the main input file. */
91 static GTY(()) struct JCF * main_jcf;
92
93 /* The number of source files passed to us by -fsource-filename and an
94 array of pointers to each name. Used by find_sourcefile(). */
95 static int num_files = 0;
96 static char **filenames;
97
98 static struct ZipFile *localToFile;
99
100 /* A map of byte offsets in the reflection data that are fields which
101 need renumbering. */
102 bitmap field_offsets;
103 bitmap_obstack bit_obstack;
104
105 /* Declarations of some functions used here. */
106 static void handle_innerclass_attribute (int count, JCF *, int len);
107 static tree give_name_to_class (JCF *jcf, int index);
108 static char *compute_class_name (struct ZipDirectory *zdir);
109 static int classify_zip_file (struct ZipDirectory *zdir);
110 static void parse_zip_file_entries (void);
111 static void process_zip_dir (FILE *);
112 static void parse_class_file (void);
113 static void handle_deprecated (void);
114 static void set_source_filename (JCF *, int);
115 static void jcf_parse (struct JCF*);
116 static void load_inner_classes (tree);
117 static void handle_annotation (JCF *jcf, int level);
118 static void java_layout_seen_class_methods (void);
119
120 /* Handle "Deprecated" attribute. */
121 static void
122 handle_deprecated (void)
123 {
124 if (current_field != NULL_TREE)
125 FIELD_DEPRECATED (current_field) = 1;
126 else if (current_method != NULL_TREE)
127 METHOD_DEPRECATED (current_method) = 1;
128 else if (current_class != NULL_TREE)
129 CLASS_DEPRECATED (TYPE_NAME (current_class)) = 1;
130 else
131 {
132 /* Shouldn't happen. */
133 gcc_unreachable ();
134 }
135 }
136
137 \f
138
139 /* Reverse a string. */
140 static char *
141 reverse (const char *s)
142 {
143 if (s == NULL)
144 return NULL;
145 else
146 {
147 int len = strlen (s);
148 char *d = xmalloc (len + 1);
149 const char *sp;
150 char *dp;
151
152 d[len] = 0;
153 for (dp = &d[0], sp = &s[len-1]; sp >= s; dp++, sp--)
154 *dp = *sp;
155
156 return d;
157 }
158 }
159
160 /* Compare two strings for qsort(). */
161 static int
162 cmpstringp (const void *p1, const void *p2)
163 {
164 /* The arguments to this function are "pointers to
165 pointers to char", but strcmp() arguments are "pointers
166 to char", hence the following cast plus dereference */
167
168 return strcmp(*(const char *const*) p1, *(const char *const*) p2);
169 }
170
171 /* Create an array of strings, one for each source file that we've
172 seen. fsource_filename can either be the name of a single .java
173 file or a file that contains a list of filenames separated by
174 newlines. */
175 void
176 java_read_sourcefilenames (const char *fsource_filename)
177 {
178 if (fsource_filename
179 && filenames == 0
180 && strlen (fsource_filename) > strlen (".java")
181 && strcmp ((fsource_filename
182 + strlen (fsource_filename)
183 - strlen (".java")),
184 ".java") != 0)
185 {
186 /* fsource_filename isn't a .java file but a list of filenames
187 separated by newlines */
188 FILE *finput = fopen (fsource_filename, "r");
189 int len = 0;
190 int longest_line = 0;
191
192 gcc_assert (finput);
193
194 /* Find out how many files there are, and how long the filenames are. */
195 while (! feof (finput))
196 {
197 int ch = getc (finput);
198 if (ch == '\n')
199 {
200 num_files++;
201 if (len > longest_line)
202 longest_line = len;
203 len = 0;
204 continue;
205 }
206 if (ch == EOF)
207 break;
208 len++;
209 }
210
211 rewind (finput);
212
213 /* Read the filenames. Put a pointer to each filename into the
214 array FILENAMES. */
215 {
216 char *linebuf = alloca (longest_line + 1);
217 int i = 0;
218 int charpos;
219
220 filenames = xmalloc (num_files * sizeof (char*));
221
222 charpos = 0;
223 for (;;)
224 {
225 int ch = getc (finput);
226 if (ch == EOF)
227 break;
228 if (ch == '\n')
229 {
230 linebuf[charpos] = 0;
231 gcc_assert (i < num_files);
232 /* ??? Perhaps we should use lrealpath() here. Doing
233 so would tidy up things like /../ but the rest of
234 gcc seems to assume relative pathnames, not
235 absolute pathnames. */
236 /* realname = lrealpath (linebuf); */
237 filenames[i++] = reverse (linebuf);
238 charpos = 0;
239 continue;
240 }
241 gcc_assert (charpos < longest_line);
242 linebuf[charpos++] = ch;
243 }
244
245 if (num_files > 1)
246 qsort (filenames, num_files, sizeof (char *), cmpstringp);
247 }
248 fclose (finput);
249 }
250 else
251 {
252 filenames = xmalloc (sizeof (char*));
253 filenames[0] = reverse (fsource_filename);
254 num_files = 1;
255 }
256 }
257
258 /* Given a relative pathname such as foo/bar.java, attempt to find a
259 longer pathname with the same suffix.
260
261 This is a best guess heuristic; with some weird class hierarchies we
262 may fail to pick the correct source file. For example, if we have
263 the filenames foo/bar.java and also foo/foo/bar.java, we do not
264 have enough information to know which one is the right match for
265 foo/bar.java. */
266
267 static const char *
268 find_sourcefile (const char *name)
269 {
270 int i = 0, j = num_files-1;
271 char *found = NULL;
272
273 if (filenames)
274 {
275 char *revname = reverse (name);
276
277 do
278 {
279 int k = (i+j) / 2;
280 int cmp = strncmp (revname, filenames[k], strlen (revname));
281 if (cmp == 0)
282 {
283 /* OK, so we found one. But is it a unique match? */
284 if ((k > i
285 && strncmp (revname, filenames[k-1], strlen (revname)) == 0)
286 || (k < j
287 && (strncmp (revname, filenames[k+1], strlen (revname))
288 == 0)))
289 ;
290 else
291 found = filenames[k];
292 break;
293 }
294 if (cmp > 0)
295 i = k+1;
296 else
297 j = k-1;
298 }
299 while (i <= j);
300
301 free (revname);
302 }
303
304 if (found && strlen (found) > strlen (name))
305 return reverse (found);
306 else
307 return name;
308 }
309
310 \f
311
312 /* Handle "SourceFile" attribute. */
313
314 static void
315 set_source_filename (JCF *jcf, int index)
316 {
317 tree sfname_id = get_name_constant (jcf, index);
318 const char *sfname = IDENTIFIER_POINTER (sfname_id);
319 const char *old_filename = input_filename;
320 int new_len = IDENTIFIER_LENGTH (sfname_id);
321 if (old_filename != NULL)
322 {
323 int old_len = strlen (old_filename);
324 /* Use the current input_filename (derived from the class name)
325 if it has a directory prefix, but otherwise matches sfname. */
326 if (old_len > new_len
327 && strcmp (sfname, old_filename + old_len - new_len) == 0
328 && (old_filename[old_len - new_len - 1] == '/'
329 || old_filename[old_len - new_len - 1] == '\\'))
330 {
331 #ifndef USE_MAPPED_LOCATION
332 input_filename = find_sourcefile (input_filename);
333 DECL_SOURCE_LOCATION (TYPE_NAME (current_class)) = input_location;
334 file_start_location = input_location;
335 #endif
336 return;
337 }
338 }
339 if (strchr (sfname, '/') == NULL && strchr (sfname, '\\') == NULL)
340 {
341 const char *class_name
342 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
343 char *dot = strrchr (class_name, '.');
344 if (dot != NULL)
345 {
346 /* Length of prefix, not counting final dot. */
347 int i = dot - class_name;
348 /* Concatenate current package prefix with new sfname. */
349 char *buf = XNEWVEC (char, i + new_len + 2); /* Space for '.' and '\0'. */
350 strcpy (buf + i + 1, sfname);
351 /* Copy package from class_name, replacing '.' by DIR_SEPARATOR.
352 Note we start at the end with the final package dot. */
353 for (; i >= 0; i--)
354 {
355 char c = class_name[i];
356 if (c == '.')
357 c = DIR_SEPARATOR;
358 buf[i] = c;
359 }
360 sfname_id = get_identifier (buf);
361 free (buf);
362 sfname = IDENTIFIER_POINTER (sfname_id);
363 }
364 }
365
366 sfname = find_sourcefile (sfname);
367 #ifdef USE_MAPPED_LOCATION
368 line_table->maps[line_table->used-1].to_file = sfname;
369 #else
370 input_filename = sfname;
371 DECL_SOURCE_LOCATION (TYPE_NAME (current_class)) = input_location;
372 file_start_location = input_location;
373 #endif
374 if (current_class == main_class) main_input_filename = sfname;
375 }
376
377
378 \f
379
380 /* Annotation handling.
381
382 The technique we use here is to copy the annotation data directly
383 from the input class file into the output file. We don't decode the
384 data at all, merely rewriting constant indexes whenever we come
385 across them: this is necessary because the constant pool in the
386 output file isn't the same as the constant pool in in the input.
387
388 The main advantage of this technique is that the resulting
389 annotation data is pointer-free, so it doesn't have to be relocated
390 at startup time. As a consequence of this, annotations have no
391 performance impact unless they are used. Also, this representation
392 is very dense. */
393
394
395 /* Expand TYPE_REFLECTION_DATA by DELTA bytes. Return the address of
396 the start of the newly allocated region. */
397
398 static unsigned char*
399 annotation_grow (int delta)
400 {
401 unsigned char **data = &TYPE_REFLECTION_DATA (current_class);
402 long *datasize = &TYPE_REFLECTION_DATASIZE (current_class);
403 long len = *datasize;
404
405 if (*data == NULL)
406 {
407 *data = xmalloc (delta);
408 }
409 else
410 {
411 int newlen = *datasize + delta;
412 if (floor_log2 (newlen) != floor_log2 (*datasize))
413 *data = xrealloc (*data, 2 << (floor_log2 (newlen)));
414 }
415 *datasize += delta;
416 return *data + len;
417 }
418
419 /* annotation_rewrite_TYPE. Rewrite various int types at p. Use Java
420 byte order (i.e. big endian.) */
421
422 static void
423 annotation_rewrite_byte (unsigned int n, unsigned char *p)
424 {
425 p[0] = n;
426 }
427
428 static void
429 annotation_rewrite_short (unsigned int n, unsigned char *p)
430 {
431 p[0] = n>>8;
432 p[1] = n;
433 }
434
435 static void
436 annotation_rewrite_int (unsigned int n, unsigned char *p)
437 {
438 p[0] = n>>24;
439 p[1] = n>>16;
440 p[2] = n>>8;
441 p[3] = n;
442 }
443
444 /* Read a 16-bit unsigned int in Java byte order (i.e. big
445 endian.) */
446
447 static uint16
448 annotation_read_short (unsigned char *p)
449 {
450 uint16 tmp = p[0];
451 tmp = (tmp << 8) | p[1];
452 return tmp;
453 }
454
455 /* annotation_write_TYPE. Rewrite various int types, appending them
456 to TYPE_REFLECTION_DATA. Use Java byte order (i.e. big
457 endian.) */
458
459 static void
460 annotation_write_byte (unsigned int n)
461 {
462 annotation_rewrite_byte (n, annotation_grow (1));
463 }
464
465 static void
466 annotation_write_short (unsigned int n)
467 {
468 annotation_rewrite_short (n, annotation_grow (2));
469 }
470
471 static void
472 annotation_write_int (unsigned int n)
473 {
474 annotation_rewrite_int (n, annotation_grow (4));
475 }
476
477 /* Create a 64-bit constant in the constant pool.
478
479 This is used for both integer and floating-point types. As a
480 consequence, it will not work if the target floating-point format
481 is anything other than IEEE-754. While this is arguably a bug, the
482 runtime library makes exactly the same assumption and it's unlikely
483 that Java will ever run on a non-IEEE machine. */
484
485 static int
486 handle_long_constant (JCF *jcf, CPool *cpool, enum cpool_tag kind,
487 int index, bool big_endian)
488 {
489 /* If we're on a 64-bit platform we can fit a long or double
490 into the same space as a jword. */
491 if (POINTER_SIZE >= 64)
492 index = find_constant1 (cpool, kind, JPOOL_LONG (jcf, index));
493
494 /* In a compiled program the constant pool is in native word
495 order. How weird is that??? */
496 else if (big_endian)
497 index = find_constant2 (cpool, kind,
498 JPOOL_INT (jcf, index),
499 JPOOL_INT (jcf, index+1));
500 else
501 index = find_constant2 (cpool, kind,
502 JPOOL_INT (jcf, index+1),
503 JPOOL_INT (jcf, index));
504
505 return index;
506 }
507
508 /* Given a class file and an index into its constant pool, create an
509 entry in the outgoing constant pool for the same item. */
510
511 static uint16
512 handle_constant (JCF *jcf, int index, enum cpool_tag purpose)
513 {
514 enum cpool_tag kind;
515 CPool *cpool = cpool_for_class (output_class);
516
517 if (index == 0)
518 return 0;
519
520 if (! CPOOL_INDEX_IN_RANGE (&jcf->cpool, index))
521 error ("<constant pool index %d not in range>", index);
522
523 kind = JPOOL_TAG (jcf, index);
524
525 if ((kind & ~CONSTANT_ResolvedFlag) != purpose)
526 {
527 if (purpose == CONSTANT_Class
528 && kind == CONSTANT_Utf8)
529 ;
530 else
531 error ("<constant pool index %d unexpected type", index);
532 }
533
534 switch (kind)
535 {
536 case CONSTANT_Class:
537 case CONSTANT_ResolvedClass:
538 {
539 /* For some reason I know not the what of, class names in
540 annotations are UTF-8 strings in the constant pool but
541 class names in EnclosingMethod attributes are real class
542 references. Set CONSTANT_LazyFlag here so that the VM
543 doesn't attempt to resolve them at class initialization
544 time. */
545 tree resolved_class, class_name;
546 resolved_class = get_class_constant (jcf, index);
547 class_name = build_internal_class_name (resolved_class);
548 index = alloc_name_constant (CONSTANT_Class | CONSTANT_LazyFlag,
549 (unmangle_classname
550 (IDENTIFIER_POINTER(class_name),
551 IDENTIFIER_LENGTH(class_name))));
552 break;
553 }
554 case CONSTANT_Utf8:
555 {
556 tree utf8 = get_constant (jcf, index);
557 if (purpose == CONSTANT_Class)
558 /* Create a constant pool entry for a type signature. This
559 one has '.' rather than '/' because it isn't going into a
560 class file, it's going into a compiled object.
561
562 This has to match the logic in
563 _Jv_ClassReader::prepare_pool_entry(). */
564 utf8 = unmangle_classname (IDENTIFIER_POINTER(utf8),
565 IDENTIFIER_LENGTH(utf8));
566 index = alloc_name_constant (kind, utf8);
567 }
568 break;
569
570 case CONSTANT_Long:
571 index = handle_long_constant (jcf, cpool, kind, index,
572 WORDS_BIG_ENDIAN);
573 break;
574
575 case CONSTANT_Double:
576 index = handle_long_constant (jcf, cpool, kind, index,
577 FLOAT_WORDS_BIG_ENDIAN);
578 break;
579
580 case CONSTANT_Float:
581 case CONSTANT_Integer:
582 index = find_constant1 (cpool, kind, JPOOL_INT (jcf, index));
583 break;
584
585 case CONSTANT_NameAndType:
586 {
587 uint16 name = JPOOL_USHORT1 (jcf, index);
588 uint16 sig = JPOOL_USHORT2 (jcf, index);
589 uint32 name_index = handle_constant (jcf, name, CONSTANT_Utf8);
590 uint32 sig_index = handle_constant (jcf, sig, CONSTANT_Class);
591 jword new_index = (name_index << 16) | sig_index;
592 index = find_constant1 (cpool, kind, new_index);
593 }
594 break;
595
596 default:
597 abort ();
598 }
599
600 return index;
601 }
602
603 /* Read an element_value structure from an annotation in JCF. Return
604 the constant pool index for the resulting constant pool entry. */
605
606 static int
607 handle_element_value (JCF *jcf, int level)
608 {
609 uint8 tag = JCF_readu (jcf);
610 int index = 0;
611
612 annotation_write_byte (tag);
613 switch (tag)
614 {
615 case 'B':
616 case 'C':
617 case 'S':
618 case 'Z':
619 case 'I':
620 {
621 uint16 cindex = JCF_readu2 (jcf);
622 index = handle_constant (jcf, cindex,
623 CONSTANT_Integer);
624 annotation_write_short (index);
625 }
626 break;
627 case 'D':
628 {
629 uint16 cindex = JCF_readu2 (jcf);
630 index = handle_constant (jcf, cindex,
631 CONSTANT_Double);
632 annotation_write_short (index);
633 }
634 break;
635 case 'F':
636 {
637 uint16 cindex = JCF_readu2 (jcf);
638 index = handle_constant (jcf, cindex,
639 CONSTANT_Float);
640 annotation_write_short (index);
641 }
642 break;
643 case 'J':
644 {
645 uint16 cindex = JCF_readu2 (jcf);
646 index = handle_constant (jcf, cindex,
647 CONSTANT_Long);
648 annotation_write_short (index);
649 }
650 break;
651 case 's':
652 {
653 uint16 cindex = JCF_readu2 (jcf);
654 /* Despite what the JVM spec says, compilers generate a Utf8
655 constant here, not a String. */
656 index = handle_constant (jcf, cindex,
657 CONSTANT_Utf8);
658 annotation_write_short (index);
659 }
660 break;
661
662 case 'e':
663 {
664 uint16 type_name_index = JCF_readu2 (jcf);
665 uint16 const_name_index = JCF_readu2 (jcf);
666 index = handle_constant (jcf, type_name_index,
667 CONSTANT_Class);
668 annotation_write_short (index);
669 index = handle_constant (jcf, const_name_index,
670 CONSTANT_Utf8);
671 annotation_write_short (index);
672 }
673 break;
674 case 'c':
675 {
676 uint16 class_info_index = JCF_readu2 (jcf);
677 index = handle_constant (jcf, class_info_index,
678 CONSTANT_Class);
679 annotation_write_short (index);
680 }
681 break;
682 case '@':
683 {
684 handle_annotation (jcf, level + 1);
685 }
686 break;
687 case '[':
688 {
689 uint16 n_array_elts = JCF_readu2 (jcf);
690 annotation_write_short (n_array_elts);
691 while (n_array_elts--)
692 handle_element_value (jcf, level + 1);
693 }
694 break;
695 default:
696 abort();
697 break;
698 }
699 return index;
700 }
701
702 /* Read an annotation structure from JCF. Write it to the
703 reflection_data field of the outgoing class. */
704
705 static void
706 handle_annotation (JCF *jcf, int level)
707 {
708 uint16 type_index = JCF_readu2 (jcf);
709 uint16 npairs = JCF_readu2 (jcf);
710 int index = handle_constant (jcf, type_index,
711 CONSTANT_Class);
712 annotation_write_short (index);
713 annotation_write_short (npairs);
714 while (npairs--)
715 {
716 uint16 name_index = JCF_readu2 (jcf);
717 index = handle_constant (jcf, name_index,
718 CONSTANT_Utf8);
719 annotation_write_short (index);
720 handle_element_value (jcf, level + 2);
721 }
722 }
723
724 /* Read an annotation count from JCF, and write the following
725 annotations to the reflection_data field of the outgoing class. */
726
727 static void
728 handle_annotations (JCF *jcf, int level)
729 {
730 uint16 num = JCF_readu2 (jcf);
731 annotation_write_short (num);
732 while (num--)
733 handle_annotation (jcf, level);
734 }
735
736 /* As handle_annotations(), but perform a sanity check that we write
737 the same number of bytes that we were expecting. */
738
739 static void
740 handle_annotation_attribute (int ATTRIBUTE_UNUSED index, JCF *jcf,
741 long length)
742 {
743 long old_datasize = TYPE_REFLECTION_DATASIZE (current_class);
744
745 handle_annotations (jcf, 0);
746
747 gcc_assert (old_datasize + length
748 == TYPE_REFLECTION_DATASIZE (current_class));
749 }
750
751 /* gcj permutes its fields array after generating annotation_data, so
752 we have to fixup field indexes for fields that have moved. Given
753 ARG, a VEC_int, fixup the field indexes in the reflection_data of
754 the outgoing class. We use field_offsets to tell us where the
755 fixups must go. */
756
757 void
758 rewrite_reflection_indexes (void *arg)
759 {
760 bitmap_iterator bi;
761 unsigned int offset;
762 VEC(int, heap) *map = arg;
763 unsigned char *data = TYPE_REFLECTION_DATA (current_class);
764
765 if (map)
766 {
767 EXECUTE_IF_SET_IN_BITMAP (field_offsets, 0, offset, bi)
768 {
769 uint16 index = annotation_read_short (data + offset);
770 annotation_rewrite_short
771 (VEC_index (int, map, index), data + offset);
772 }
773 }
774 }
775
776 /* Read the RuntimeVisibleAnnotations from JCF and write them to the
777 reflection_data of the outgoing class. */
778
779 static void
780 handle_member_annotations (int member_index, JCF *jcf,
781 const unsigned char *name ATTRIBUTE_UNUSED,
782 long len, jv_attr_type member_type)
783 {
784 int new_len = len + 1;
785 annotation_write_byte (member_type);
786 if (member_type != JV_CLASS_ATTR)
787 new_len += 2;
788 annotation_write_int (new_len);
789 annotation_write_byte (JV_ANNOTATIONS_KIND);
790 if (member_type == JV_FIELD_ATTR)
791 bitmap_set_bit (field_offsets, TYPE_REFLECTION_DATASIZE (current_class));
792 if (member_type != JV_CLASS_ATTR)
793 annotation_write_short (member_index);
794 handle_annotation_attribute (member_index, jcf, len);
795 }
796
797 /* Read the RuntimeVisibleParameterAnnotations from JCF and write them
798 to the reflection_data of the outgoing class. */
799
800 static void
801 handle_parameter_annotations (int member_index, JCF *jcf,
802 const unsigned char *name ATTRIBUTE_UNUSED,
803 long len, jv_attr_type member_type)
804 {
805 int new_len = len + 1;
806 uint8 num;
807 annotation_write_byte (member_type);
808 if (member_type != JV_CLASS_ATTR)
809 new_len += 2;
810 annotation_write_int (new_len);
811 annotation_write_byte (JV_PARAMETER_ANNOTATIONS_KIND);
812 if (member_type != JV_CLASS_ATTR)
813 annotation_write_short (member_index);
814 num = JCF_readu (jcf);
815 annotation_write_byte (num);
816 while (num--)
817 handle_annotations (jcf, 0);
818 }
819
820
821 /* Read the AnnotationDefault data from JCF and write them to the
822 reflection_data of the outgoing class. */
823
824 static void
825 handle_default_annotation (int member_index, JCF *jcf,
826 const unsigned char *name ATTRIBUTE_UNUSED,
827 long len, jv_attr_type member_type)
828 {
829 int new_len = len + 1;
830 annotation_write_byte (member_type);
831 if (member_type != JV_CLASS_ATTR)
832 new_len += 2;
833 annotation_write_int (new_len);
834 annotation_write_byte (JV_ANNOTATION_DEFAULT_KIND);
835 if (member_type != JV_CLASS_ATTR)
836 annotation_write_short (member_index);
837 handle_element_value (jcf, 0);
838 }
839
840 /* As above, for the EnclosingMethod attribute. */
841
842 static void
843 handle_enclosingmethod_attribute (int member_index, JCF *jcf,
844 const unsigned char *name ATTRIBUTE_UNUSED,
845 long len, jv_attr_type member_type)
846 {
847 int new_len = len + 1;
848 uint16 index;
849 annotation_write_byte (member_type);
850 if (member_type != JV_CLASS_ATTR)
851 new_len += 2;
852 annotation_write_int (new_len);
853 annotation_write_byte (JV_ENCLOSING_METHOD_KIND);
854 if (member_type != JV_CLASS_ATTR)
855 annotation_write_short (member_index);
856
857 index = JCF_readu2 (jcf);
858 index = handle_constant (jcf, index, CONSTANT_Class);
859 annotation_write_short (index);
860
861 index = JCF_readu2 (jcf);
862 index = handle_constant (jcf, index, CONSTANT_NameAndType);
863 annotation_write_short (index);
864 }
865
866 /* As above, for the Signature attribute. */
867
868 static void
869 handle_signature_attribute (int member_index, JCF *jcf,
870 const unsigned char *name ATTRIBUTE_UNUSED,
871 long len, jv_attr_type member_type)
872 {
873 int new_len = len + 1;
874 uint16 index;
875 annotation_write_byte (member_type);
876 if (member_type != JV_CLASS_ATTR)
877 new_len += 2;
878 annotation_write_int (new_len);
879 annotation_write_byte (JV_SIGNATURE_KIND);
880 if (member_type != JV_CLASS_ATTR)
881 annotation_write_short (member_index);
882
883 index = JCF_readu2 (jcf);
884 index = handle_constant (jcf, index, CONSTANT_Utf8);
885 annotation_write_short (index);
886 }
887
888 \f
889
890 #define HANDLE_SOURCEFILE(INDEX) set_source_filename (jcf, INDEX)
891
892 #define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
893 { tree super_class = SUPER==0 ? NULL_TREE : get_class_constant (jcf, SUPER); \
894 output_class = current_class = give_name_to_class (jcf, THIS); \
895 set_super_info (ACCESS_FLAGS, current_class, super_class, INTERFACES_COUNT);}
896
897 #define HANDLE_CLASS_INTERFACE(INDEX) \
898 add_interface (current_class, get_class_constant (jcf, INDEX))
899
900 #define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
901 { int sig_index = SIGNATURE; \
902 current_field = add_field (current_class, get_name_constant (jcf, NAME), \
903 parse_signature (jcf, sig_index), ACCESS_FLAGS); \
904 set_java_signature (TREE_TYPE (current_field), JPOOL_UTF (jcf, sig_index)); \
905 if ((ACCESS_FLAGS) & ACC_FINAL) \
906 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (current_field); \
907 }
908
909 #define HANDLE_END_FIELDS() \
910 (current_field = NULL_TREE)
911
912 #define HANDLE_CONSTANTVALUE(INDEX) \
913 { tree constant; int index = INDEX; \
914 if (JPOOL_TAG (jcf, index) == CONSTANT_String) { \
915 tree name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index)); \
916 constant = build_utf8_ref (name); \
917 } \
918 else \
919 constant = get_constant (jcf, index); \
920 set_constant_value (current_field, constant); }
921
922 #define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
923 (current_method = add_method (current_class, ACCESS_FLAGS, \
924 get_name_constant (jcf, NAME), \
925 get_name_constant (jcf, SIGNATURE)), \
926 DECL_LOCALVARIABLES_OFFSET (current_method) = 0, \
927 DECL_LINENUMBERS_OFFSET (current_method) = 0)
928
929 #define HANDLE_END_METHODS() \
930 { current_method = NULL_TREE; }
931
932 #define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
933 { DECL_MAX_STACK (current_method) = (MAX_STACK); \
934 DECL_MAX_LOCALS (current_method) = (MAX_LOCALS); \
935 DECL_CODE_LENGTH (current_method) = (CODE_LENGTH); \
936 DECL_CODE_OFFSET (current_method) = JCF_TELL (jcf); }
937
938 #define HANDLE_LOCALVARIABLETABLE_ATTRIBUTE(COUNT) \
939 { int n = (COUNT); \
940 DECL_LOCALVARIABLES_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
941 JCF_SKIP (jcf, n * 10); }
942
943 #define HANDLE_LINENUMBERTABLE_ATTRIBUTE(COUNT) \
944 { int n = (COUNT); \
945 DECL_LINENUMBERS_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
946 JCF_SKIP (jcf, n * 4); }
947
948 #define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \
949 { \
950 int n = COUNT; \
951 tree list = DECL_FUNCTION_THROWS (current_method); \
952 while (--n >= 0) \
953 { \
954 tree thrown_class = get_class_constant (jcf, JCF_readu2 (jcf)); \
955 list = tree_cons (NULL_TREE, thrown_class, list); \
956 } \
957 DECL_FUNCTION_THROWS (current_method) = nreverse (list); \
958 }
959
960 #define HANDLE_DEPRECATED_ATTRIBUTE() handle_deprecated ()
961
962 /* Link seen inner classes to their outer context and register the
963 inner class to its outer context. They will be later loaded. */
964 #define HANDLE_INNERCLASSES_ATTRIBUTE(COUNT) \
965 handle_innerclass_attribute (COUNT, jcf, attribute_length)
966
967 #define HANDLE_SYNTHETIC_ATTRIBUTE() \
968 { \
969 /* Irrelevant decls should have been nullified by the END macros. \
970 DECL_ARTIFICIAL on fields is used for something else (See \
971 PUSH_FIELD in java-tree.h) */ \
972 if (current_method) \
973 DECL_ARTIFICIAL (current_method) = 1; \
974 else if (current_field) \
975 FIELD_SYNTHETIC (current_field) = 1; \
976 else \
977 TYPE_SYNTHETIC (current_class) = 1; \
978 }
979
980 #define HANDLE_GCJCOMPILED_ATTRIBUTE() \
981 { \
982 if (current_class == object_type_node) \
983 jcf->right_zip = 1; \
984 }
985
986 #define HANDLE_RUNTIMEVISIBLEANNOTATIONS_ATTRIBUTE() \
987 { \
988 handle_member_annotations (index, jcf, name_data, attribute_length, attr_type); \
989 }
990
991 #define HANDLE_RUNTIMEINVISIBLEANNOTATIONS_ATTRIBUTE() \
992 { \
993 JCF_SKIP(jcf, attribute_length); \
994 }
995
996 #define HANDLE_RUNTIMEVISIBLEPARAMETERANNOTATIONS_ATTRIBUTE() \
997 { \
998 handle_parameter_annotations (index, jcf, name_data, attribute_length, attr_type); \
999 }
1000
1001 #define HANDLE_RUNTIMEINVISIBLEPARAMETERANNOTATIONS_ATTRIBUTE() \
1002 { \
1003 JCF_SKIP(jcf, attribute_length); \
1004 }
1005
1006 #define HANDLE_ANNOTATIONDEFAULT_ATTRIBUTE() \
1007 { \
1008 handle_default_annotation (index, jcf, name_data, attribute_length, attr_type); \
1009 }
1010
1011 #define HANDLE_ENCLOSINGMETHOD_ATTRIBUTE() \
1012 { \
1013 handle_enclosingmethod_attribute (index, jcf, name_data, \
1014 attribute_length, attr_type); \
1015 }
1016
1017 #define HANDLE_SIGNATURE_ATTRIBUTE() \
1018 { \
1019 handle_signature_attribute (index, jcf, name_data, \
1020 attribute_length, attr_type); \
1021 }
1022
1023 #include "jcf-reader.c"
1024
1025 tree
1026 parse_signature (JCF *jcf, int sig_index)
1027 {
1028 gcc_assert (sig_index > 0
1029 && sig_index < JPOOL_SIZE (jcf)
1030 && JPOOL_TAG (jcf, sig_index) == CONSTANT_Utf8);
1031
1032 return parse_signature_string (JPOOL_UTF_DATA (jcf, sig_index),
1033 JPOOL_UTF_LENGTH (jcf, sig_index));
1034 }
1035
1036 tree
1037 get_constant (JCF *jcf, int index)
1038 {
1039 tree value;
1040 int tag;
1041 if (index <= 0 || index >= JPOOL_SIZE(jcf))
1042 goto bad;
1043 tag = JPOOL_TAG (jcf, index);
1044 if ((tag & CONSTANT_ResolvedFlag) || tag == CONSTANT_Utf8)
1045 return jcf->cpool.data[index].t;
1046 switch (tag)
1047 {
1048 case CONSTANT_Integer:
1049 {
1050 jint num = JPOOL_INT(jcf, index);
1051 value = build_int_cst (int_type_node, num);
1052 break;
1053 }
1054 case CONSTANT_Long:
1055 {
1056 unsigned HOST_WIDE_INT num = JPOOL_UINT (jcf, index);
1057 unsigned HOST_WIDE_INT lo;
1058 HOST_WIDE_INT hi;
1059
1060 lshift_double (num, 0, 32, 64, &lo, &hi, 0);
1061 num = JPOOL_UINT (jcf, index+1);
1062 add_double (lo, hi, num, 0, &lo, &hi);
1063 value = build_int_cst_wide_type (long_type_node, lo, hi);
1064 break;
1065 }
1066
1067 case CONSTANT_Float:
1068 {
1069 jint num = JPOOL_INT(jcf, index);
1070 long buf = num;
1071 REAL_VALUE_TYPE d;
1072
1073 real_from_target_fmt (&d, &buf, &ieee_single_format);
1074 value = build_real (float_type_node, d);
1075 break;
1076 }
1077
1078 case CONSTANT_Double:
1079 {
1080 long buf[2], lo, hi;
1081 REAL_VALUE_TYPE d;
1082
1083 hi = JPOOL_UINT (jcf, index);
1084 lo = JPOOL_UINT (jcf, index+1);
1085
1086 if (FLOAT_WORDS_BIG_ENDIAN)
1087 buf[0] = hi, buf[1] = lo;
1088 else
1089 buf[0] = lo, buf[1] = hi;
1090
1091 real_from_target_fmt (&d, buf, &ieee_double_format);
1092 value = build_real (double_type_node, d);
1093 break;
1094 }
1095
1096 case CONSTANT_String:
1097 {
1098 tree name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
1099 const char *utf8_ptr = IDENTIFIER_POINTER (name);
1100 int utf8_len = IDENTIFIER_LENGTH (name);
1101 const unsigned char *utf8;
1102 int i;
1103
1104 /* Check for a malformed Utf8 string. */
1105 utf8 = (const unsigned char *) utf8_ptr;
1106 i = utf8_len;
1107 while (i > 0)
1108 {
1109 int char_len = UT8_CHAR_LENGTH (*utf8);
1110 if (char_len < 0 || char_len > 3 || char_len > i)
1111 fatal_error ("bad string constant");
1112
1113 utf8 += char_len;
1114 i -= char_len;
1115 }
1116
1117 /* Allocate a new string value. */
1118 value = build_string (utf8_len, utf8_ptr);
1119 TREE_TYPE (value) = build_pointer_type (string_type_node);
1120 }
1121 break;
1122 default:
1123 goto bad;
1124 }
1125 JPOOL_TAG (jcf, index) = tag | CONSTANT_ResolvedFlag;
1126 jcf->cpool.data[index].t = value;
1127 return value;
1128 bad:
1129 internal_error ("bad value constant type %d, index %d",
1130 JPOOL_TAG (jcf, index), index);
1131 }
1132
1133 tree
1134 get_name_constant (JCF *jcf, int index)
1135 {
1136 tree name = get_constant (jcf, index);
1137 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1138 return name;
1139 }
1140
1141 /* Handle reading innerclass attributes. If a nonzero entry (denoting
1142 a non anonymous entry) is found, We augment the inner class list of
1143 the outer context with the newly resolved innerclass. */
1144
1145 static void
1146 handle_innerclass_attribute (int count, JCF *jcf, int attribute_length)
1147 {
1148 int c = count;
1149
1150 annotation_write_byte (JV_CLASS_ATTR);
1151 annotation_write_int (attribute_length+1);
1152 annotation_write_byte (JV_INNER_CLASSES_KIND);
1153 annotation_write_short (count);
1154
1155 while (c--)
1156 {
1157 /* Read inner_class_info_index. This may be 0 */
1158 int icii = JCF_readu2 (jcf);
1159 /* Read outer_class_info_index. If the innerclasses attribute
1160 entry isn't a member (like an inner class) the value is 0. */
1161 int ocii = JCF_readu2 (jcf);
1162 /* Read inner_name_index. If the class we're dealing with is
1163 an anonymous class, it must be 0. */
1164 int ini = JCF_readu2 (jcf);
1165 /* Read the access flag. */
1166 int acc = JCF_readu2 (jcf);
1167
1168 annotation_write_short (handle_constant (jcf, icii, CONSTANT_Class));
1169 annotation_write_short (handle_constant (jcf, ocii, CONSTANT_Class));
1170 annotation_write_short (handle_constant (jcf, ini, CONSTANT_Utf8));
1171 annotation_write_short (acc);
1172
1173 /* If icii is 0, don't try to read the class. */
1174 if (icii >= 0)
1175 {
1176 tree class = get_class_constant (jcf, icii);
1177 tree decl = TYPE_NAME (class);
1178 /* Skip reading further if ocii is null */
1179 if (DECL_P (decl) && !CLASS_COMPLETE_P (decl) && ocii)
1180 {
1181 tree outer = TYPE_NAME (get_class_constant (jcf, ocii));
1182 tree alias = (ini ? get_name_constant (jcf, ini) : NULL_TREE);
1183 set_class_decl_access_flags (acc, decl);
1184 DECL_CONTEXT (decl) = outer;
1185 DECL_INNER_CLASS_LIST (outer) =
1186 tree_cons (decl, alias, DECL_INNER_CLASS_LIST (outer));
1187 CLASS_COMPLETE_P (decl) = 1;
1188 }
1189 }
1190 }
1191 }
1192
1193 static tree
1194 give_name_to_class (JCF *jcf, int i)
1195 {
1196 gcc_assert (i > 0
1197 && i < JPOOL_SIZE (jcf)
1198 && JPOOL_TAG (jcf, i) == CONSTANT_Class);
1199
1200 {
1201 tree package_name = NULL_TREE, tmp;
1202 tree this_class;
1203 int j = JPOOL_USHORT1 (jcf, i);
1204 /* verify_constant_pool confirmed that j is a CONSTANT_Utf8. */
1205 tree class_name = unmangle_classname ((const char *) JPOOL_UTF_DATA (jcf, j),
1206 JPOOL_UTF_LENGTH (jcf, j));
1207 this_class = lookup_class (class_name);
1208 #ifdef USE_MAPPED_LOCATION
1209 {
1210 tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
1211 const char *sfname = IDENTIFIER_POINTER (source_name);
1212 linemap_add (line_table, LC_ENTER, false, sfname, 0);
1213 input_location = linemap_line_start (line_table, 0, 1);
1214 file_start_location = input_location;
1215 DECL_SOURCE_LOCATION (TYPE_NAME (this_class)) = input_location;
1216 if (main_input_filename == NULL && jcf == main_jcf)
1217 main_input_filename = sfname;
1218 }
1219 #else
1220 if (! DECL_ARTIFICIAL (TYPE_NAME (this_class)))
1221 {
1222 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (this_class));
1223 if (main_input_filename == NULL && jcf == main_jcf)
1224 main_input_filename = input_filename;
1225 }
1226 #endif
1227
1228 jcf->cpool.data[i].t = this_class;
1229 JPOOL_TAG (jcf, i) = CONSTANT_ResolvedClass;
1230 split_qualified_name (&package_name, &tmp,
1231 DECL_NAME (TYPE_NAME (this_class)));
1232 TYPE_PACKAGE (this_class) = package_name;
1233 return this_class;
1234 }
1235 }
1236
1237 /* Get the class of the CONSTANT_Class whose constant pool index is I. */
1238
1239 tree
1240 get_class_constant (JCF *jcf, int i)
1241 {
1242 tree type;
1243 gcc_assert (i > 0
1244 && i < JPOOL_SIZE (jcf)
1245 && (JPOOL_TAG (jcf, i) & ~CONSTANT_ResolvedFlag) == CONSTANT_Class);
1246
1247 if (JPOOL_TAG (jcf, i) != CONSTANT_ResolvedClass)
1248 {
1249 int name_index = JPOOL_USHORT1 (jcf, i);
1250 /* verify_constant_pool confirmed that name_index is a CONSTANT_Utf8. */
1251 const char *name = (const char *) JPOOL_UTF_DATA (jcf, name_index);
1252 int nlength = JPOOL_UTF_LENGTH (jcf, name_index);
1253
1254 if (name[0] == '[') /* Handle array "classes". */
1255 type = TREE_TYPE (parse_signature_string ((const unsigned char *) name, nlength));
1256 else
1257 {
1258 tree cname = unmangle_classname (name, nlength);
1259 type = lookup_class (cname);
1260 }
1261 jcf->cpool.data[i].t = type;
1262 JPOOL_TAG (jcf, i) = CONSTANT_ResolvedClass;
1263 }
1264 else
1265 type = jcf->cpool.data[i].t;
1266 return type;
1267 }
1268
1269 /* Read a class with the fully qualified-name NAME.
1270 Return 1 iff we read the requested file.
1271 (It is still possible we failed if the file did not
1272 define the class it is supposed to.) */
1273
1274 int
1275 read_class (tree name)
1276 {
1277 JCF this_jcf, *jcf;
1278 tree icv, class = NULL_TREE;
1279 tree save_current_class = current_class;
1280 tree save_output_class = output_class;
1281 location_t save_location = input_location;
1282 JCF *save_current_jcf = current_jcf;
1283
1284 if ((icv = IDENTIFIER_CLASS_VALUE (name)) != NULL_TREE)
1285 {
1286 class = TREE_TYPE (icv);
1287 jcf = TYPE_JCF (class);
1288 }
1289 else
1290 jcf = NULL;
1291
1292 if (jcf == NULL)
1293 {
1294 const char* path_name;
1295 this_jcf.zipd = NULL;
1296 jcf = &this_jcf;
1297
1298 path_name = find_class (IDENTIFIER_POINTER (name),
1299 IDENTIFIER_LENGTH (name),
1300 &this_jcf);
1301 if (path_name == 0)
1302 return 0;
1303 else
1304 free(CONST_CAST (char *, path_name));
1305 }
1306
1307 current_jcf = jcf;
1308
1309 if (class == NULL_TREE || ! CLASS_PARSED_P (class))
1310 {
1311 output_class = current_class = class;
1312 if (JCF_SEEN_IN_ZIP (current_jcf))
1313 read_zip_member(current_jcf,
1314 current_jcf->zipd, current_jcf->zipd->zipf);
1315 jcf_parse (current_jcf);
1316 /* Parsing might change the class, in which case we have to
1317 put it back where we found it. */
1318 if (current_class != class && icv != NULL_TREE)
1319 TREE_TYPE (icv) = current_class;
1320 class = current_class;
1321 }
1322 layout_class (class);
1323 load_inner_classes (class);
1324
1325 output_class = save_output_class;
1326 current_class = save_current_class;
1327 input_location = save_location;
1328 current_jcf = save_current_jcf;
1329 return 1;
1330 }
1331
1332 /* Load CLASS_OR_NAME. CLASS_OR_NAME can be a mere identifier if
1333 called from the parser, otherwise it's a RECORD_TYPE node. If
1334 VERBOSE is 1, print error message on failure to load a class. */
1335 void
1336 load_class (tree class_or_name, int verbose)
1337 {
1338 tree name, saved;
1339 int class_loaded = 0;
1340 tree class_decl = NULL_TREE;
1341 bool is_compiled_class = false;
1342
1343 /* We've already failed, don't try again. */
1344 if (TREE_CODE (class_or_name) == RECORD_TYPE
1345 && TYPE_DUMMY (class_or_name))
1346 return;
1347
1348 /* class_or_name can be the name of the class we want to load */
1349 if (TREE_CODE (class_or_name) == IDENTIFIER_NODE)
1350 name = class_or_name;
1351 /* In some cases, it's a dependency that we process earlier that
1352 we though */
1353 else if (TREE_CODE (class_or_name) == TREE_LIST)
1354 name = TYPE_NAME (TREE_PURPOSE (class_or_name));
1355 /* Or it's a type in the making */
1356 else
1357 name = DECL_NAME (TYPE_NAME (class_or_name));
1358
1359 class_decl = IDENTIFIER_CLASS_VALUE (name);
1360 if (class_decl != NULL_TREE)
1361 {
1362 tree type = TREE_TYPE (class_decl);
1363 is_compiled_class
1364 = ((TYPE_JCF (type) && JCF_SEEN_IN_ZIP (TYPE_JCF (type)))
1365 || CLASS_FROM_CURRENTLY_COMPILED_P (type));
1366 }
1367
1368 saved = name;
1369
1370 /* If flag_verify_invocations is unset, we don't try to load a class
1371 unless we're looking for Object (which is fixed by the ABI) or
1372 it's a class that we're going to compile. */
1373 if (flag_verify_invocations
1374 || class_or_name == object_type_node
1375 || is_compiled_class
1376 || TREE_CODE (class_or_name) == IDENTIFIER_NODE)
1377 {
1378 while (1)
1379 {
1380 char *separator;
1381
1382 /* We've already loaded it. */
1383 if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE)
1384 {
1385 tree tmp_decl = IDENTIFIER_CLASS_VALUE (name);
1386 if (CLASS_PARSED_P (TREE_TYPE (tmp_decl)))
1387 break;
1388 }
1389
1390 if (read_class (name))
1391 break;
1392
1393 /* We failed loading name. Now consider that we might be looking
1394 for an inner class. */
1395 if ((separator = strrchr (IDENTIFIER_POINTER (name), '$'))
1396 || (separator = strrchr (IDENTIFIER_POINTER (name), '.')))
1397 {
1398 int c = *separator;
1399 *separator = '\0';
1400 name = get_identifier (IDENTIFIER_POINTER (name));
1401 *separator = c;
1402 }
1403 /* Otherwise, we failed, we bail. */
1404 else
1405 break;
1406 }
1407
1408 {
1409 /* have we found the class we're looking for? */
1410 tree type_decl = IDENTIFIER_CLASS_VALUE (saved);
1411 tree type = type_decl ? TREE_TYPE (type_decl) : NULL;
1412 class_loaded = type && CLASS_PARSED_P (type);
1413 }
1414 }
1415
1416 if (!class_loaded)
1417 {
1418 if (flag_verify_invocations || ! flag_indirect_dispatch)
1419 {
1420 if (verbose)
1421 error ("cannot find file for class %s", IDENTIFIER_POINTER (saved));
1422 }
1423 else if (verbose)
1424 {
1425 /* This is just a diagnostic during testing, not a real problem. */
1426 if (!quiet_flag)
1427 warning (0, "cannot find file for class %s",
1428 IDENTIFIER_POINTER (saved));
1429
1430 /* Fake it. */
1431 if (TREE_CODE (class_or_name) == RECORD_TYPE)
1432 {
1433 set_super_info (0, class_or_name, object_type_node, 0);
1434 TYPE_DUMMY (class_or_name) = 1;
1435 /* We won't be able to output any debug info for this class. */
1436 DECL_IGNORED_P (TYPE_NAME (class_or_name)) = 1;
1437 }
1438 }
1439 }
1440 }
1441
1442 /* Parse the .class file JCF. */
1443
1444 static void
1445 jcf_parse (JCF* jcf)
1446 {
1447 int i, code;
1448
1449 bitmap_clear (field_offsets);
1450
1451 if (jcf_parse_preamble (jcf) != 0)
1452 fatal_error ("not a valid Java .class file");
1453 code = jcf_parse_constant_pool (jcf);
1454 if (code != 0)
1455 fatal_error ("error while parsing constant pool");
1456 code = verify_constant_pool (jcf);
1457 if (code > 0)
1458 fatal_error ("error in constant pool entry #%d\n", code);
1459
1460 jcf_parse_class (jcf);
1461 if (main_class == NULL_TREE)
1462 main_class = current_class;
1463 if (! quiet_flag && TYPE_NAME (current_class))
1464 fprintf (stderr, " %s %s",
1465 (jcf->access_flags & ACC_INTERFACE) ? "interface" : "class",
1466 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
1467 if (CLASS_PARSED_P (current_class))
1468 {
1469 /* FIXME - where was first time */
1470 fatal_error ("reading class %s for the second time from %s",
1471 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))),
1472 jcf->filename);
1473 }
1474 CLASS_PARSED_P (current_class) = 1;
1475
1476 for (i = 1; i < JPOOL_SIZE(jcf); i++)
1477 {
1478 switch (JPOOL_TAG (jcf, i))
1479 {
1480 case CONSTANT_Class:
1481 get_class_constant (jcf, i);
1482 break;
1483 }
1484 }
1485
1486 code = jcf_parse_fields (jcf);
1487 if (code != 0)
1488 fatal_error ("error while parsing fields");
1489 code = jcf_parse_methods (jcf);
1490 if (code != 0)
1491 fatal_error ("error while parsing methods");
1492 code = jcf_parse_final_attributes (jcf);
1493 if (code != 0)
1494 fatal_error ("error while parsing final attributes");
1495
1496 if (TYPE_REFLECTION_DATA (current_class))
1497 annotation_write_byte (JV_DONE_ATTR);
1498
1499 #ifdef USE_MAPPED_LOCATION
1500 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1501 #endif
1502
1503 /* The fields of class_type_node are already in correct order. */
1504 if (current_class != class_type_node && current_class != object_type_node)
1505 TYPE_FIELDS (current_class) = nreverse (TYPE_FIELDS (current_class));
1506
1507 if (current_class == object_type_node)
1508 layout_class_methods (object_type_node);
1509 else
1510 all_class_list = tree_cons (NULL_TREE,
1511 TYPE_NAME (current_class), all_class_list );
1512 }
1513
1514 /* If we came across inner classes, load them now. */
1515 static void
1516 load_inner_classes (tree cur_class)
1517 {
1518 tree current;
1519 for (current = DECL_INNER_CLASS_LIST (TYPE_NAME (cur_class)); current;
1520 current = TREE_CHAIN (current))
1521 {
1522 tree name = DECL_NAME (TREE_PURPOSE (current));
1523 tree decl = IDENTIFIER_GLOBAL_VALUE (name);
1524 if (decl && ! CLASS_LOADED_P (TREE_TYPE (decl))
1525 && !CLASS_BEING_LAIDOUT (TREE_TYPE (decl)))
1526 load_class (name, 1);
1527 }
1528 }
1529
1530 static void
1531 duplicate_class_warning (const char *filename)
1532 {
1533 location_t warn_loc;
1534 #ifdef USE_MAPPED_LOCATION
1535 linemap_add (line_table, LC_RENAME, 0, filename, 0);
1536 warn_loc = linemap_line_start (line_table, 0, 1);
1537 #else
1538 warn_loc.file = filename;
1539 warn_loc.line = 0;
1540 #endif
1541 warning (0, "%Hduplicate class will only be compiled once", &warn_loc);
1542 }
1543
1544 static void
1545 java_layout_seen_class_methods (void)
1546 {
1547 tree previous_list = all_class_list;
1548 tree end = NULL_TREE;
1549 tree current;
1550
1551 while (1)
1552 {
1553 for (current = previous_list;
1554 current != end; current = TREE_CHAIN (current))
1555 {
1556 tree decl = TREE_VALUE (current);
1557 tree cls = TREE_TYPE (decl);
1558
1559 input_location = DECL_SOURCE_LOCATION (decl);
1560
1561 if (! CLASS_LOADED_P (cls))
1562 load_class (cls, 0);
1563
1564 layout_class_methods (cls);
1565 }
1566
1567 /* Note that new classes might have been added while laying out
1568 methods, changing the value of all_class_list. */
1569
1570 if (previous_list != all_class_list)
1571 {
1572 end = previous_list;
1573 previous_list = all_class_list;
1574 }
1575 else
1576 break;
1577 }
1578 }
1579
1580 static void
1581 parse_class_file (void)
1582 {
1583 tree method;
1584 location_t save_location = input_location;
1585
1586 java_layout_seen_class_methods ();
1587
1588 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (current_class));
1589 #ifdef USE_MAPPED_LOCATION
1590 {
1591 /* Re-enter the current file. */
1592 expanded_location loc = expand_location (input_location);
1593 linemap_add (line_table, LC_ENTER, 0, loc.file, loc.line);
1594 }
1595 #endif
1596 file_start_location = input_location;
1597 (*debug_hooks->start_source_file) (input_line, input_filename);
1598
1599 gen_indirect_dispatch_tables (current_class);
1600
1601 for (method = TYPE_METHODS (current_class);
1602 method != NULL_TREE; method = TREE_CHAIN (method))
1603 {
1604 JCF *jcf = current_jcf;
1605
1606 if (METHOD_ABSTRACT (method) || METHOD_DUMMY (method))
1607 continue;
1608
1609 if (METHOD_NATIVE (method))
1610 {
1611 tree arg;
1612 int decl_max_locals;
1613
1614 if (! flag_jni)
1615 continue;
1616 /* We need to compute the DECL_MAX_LOCALS. We need to take
1617 the wide types into account too. */
1618 for (arg = TYPE_ARG_TYPES (TREE_TYPE (method)), decl_max_locals = 0;
1619 arg != end_params_node;
1620 arg = TREE_CHAIN (arg), decl_max_locals += 1)
1621 {
1622 if (TREE_VALUE (arg) && TYPE_IS_WIDE (TREE_VALUE (arg)))
1623 decl_max_locals += 1;
1624 }
1625 DECL_MAX_LOCALS (method) = decl_max_locals;
1626 start_java_method (method);
1627 give_name_to_locals (jcf);
1628 *get_stmts () = build_jni_stub (method);
1629 end_java_method ();
1630 continue;
1631 }
1632
1633 if (DECL_CODE_OFFSET (method) == 0)
1634 {
1635 current_function_decl = method;
1636 error ("missing Code attribute");
1637 continue;
1638 }
1639
1640 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (current_class));
1641 if (DECL_LINENUMBERS_OFFSET (method))
1642 {
1643 int i;
1644 int min_line = 0;
1645 unsigned char *ptr;
1646 JCF_SEEK (jcf, DECL_LINENUMBERS_OFFSET (method));
1647 linenumber_count = i = JCF_readu2 (jcf);
1648 linenumber_table = ptr = jcf->read_ptr;
1649
1650 for (ptr += 2; --i >= 0; ptr += 4)
1651 {
1652 int line = GET_u2 (ptr);
1653 /* Set initial input_line to smallest linenumber.
1654 * Needs to be set before init_function_start. */
1655 if (min_line == 0 || line < min_line)
1656 min_line = line;
1657 }
1658 #ifdef USE_MAPPED_LOCATION
1659 if (min_line != 0)
1660 input_location = linemap_line_start (line_table, min_line, 1);
1661 #else
1662 if (min_line != 0)
1663 input_line = min_line;
1664 #endif
1665 }
1666 else
1667 {
1668 linenumber_table = NULL;
1669 linenumber_count = 0;
1670 }
1671
1672 start_java_method (method);
1673
1674 note_instructions (jcf, method);
1675
1676 give_name_to_locals (jcf);
1677
1678 /* Bump up start_label_pc_this_method so we get a unique label number
1679 and reset highest_label_pc_this_method. */
1680 if (highest_label_pc_this_method >= 0)
1681 {
1682 /* We adjust to the next multiple of 1000. This is just a frill
1683 so the last 3 digits of the label number match the bytecode
1684 offset, which might make debugging marginally more convenient. */
1685 start_label_pc_this_method
1686 = ((((start_label_pc_this_method + highest_label_pc_this_method)
1687 / 1000)
1688 + 1)
1689 * 1000);
1690 highest_label_pc_this_method = -1;
1691 }
1692
1693 /* Convert bytecode to trees. */
1694 expand_byte_code (jcf, method);
1695
1696 end_java_method ();
1697 }
1698
1699 finish_class ();
1700
1701 (*debug_hooks->end_source_file) (LOCATION_LINE (save_location));
1702 input_location = save_location;
1703 }
1704
1705 void
1706 add_predefined_file (tree name)
1707 {
1708 predef_filenames = tree_cons (NULL_TREE, name, predef_filenames);
1709 }
1710
1711 int
1712 predefined_filename_p (tree node)
1713 {
1714 tree iter;
1715
1716 for (iter = predef_filenames; iter != NULL_TREE; iter = TREE_CHAIN (iter))
1717 {
1718 if (TREE_VALUE (iter) == node)
1719 return 1;
1720 }
1721 return 0;
1722 }
1723
1724 /* Generate a function that does all static initialization for this
1725 translation unit. */
1726
1727 static void
1728 java_emit_static_constructor (void)
1729 {
1730 tree body = NULL;
1731
1732 emit_register_classes (&body);
1733 write_resource_constructor (&body);
1734
1735 if (body)
1736 cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
1737 }
1738
1739 void
1740 java_parse_file (int set_yydebug ATTRIBUTE_UNUSED)
1741 {
1742 int filename_count = 0;
1743 location_t save_location = input_location;
1744 char *file_list = NULL, *list, *next;
1745 tree node;
1746 FILE *finput = NULL;
1747 int in_quotes = 0;
1748
1749 bitmap_obstack_initialize (&bit_obstack);
1750 field_offsets = BITMAP_ALLOC (&bit_obstack);
1751
1752 if (flag_filelist_file)
1753 {
1754 int avail = 2000;
1755 finput = fopen (main_input_filename, "r");
1756 if (finput == NULL)
1757 fatal_error ("can't open %s: %m", input_filename);
1758 list = XNEWVEC (char, avail);
1759 next = list;
1760 for (;;)
1761 {
1762 int count;
1763 if (avail < 500)
1764 {
1765 count = next - list;
1766 avail = 2 * (count + avail);
1767 list = xrealloc (list, avail);
1768 next = list + count;
1769 avail = avail - count;
1770 }
1771 /* Subtract to to guarantee space for final '\0'. */
1772 count = fread (next, 1, avail - 1, finput);
1773 if (count == 0)
1774 {
1775 if (! feof (finput))
1776 fatal_error ("error closing %s: %m", input_filename);
1777 *next = '\0';
1778 break;
1779 }
1780 avail -= count;
1781 next += count;
1782 }
1783 fclose (finput);
1784 finput = NULL;
1785 file_list = list;
1786 }
1787 else
1788 list = CONST_CAST (char *, main_input_filename);
1789
1790 while (list)
1791 {
1792 for (next = list; ; )
1793 {
1794 char ch = *next;
1795 if (flag_filelist_file && ! in_quotes
1796 && (ch == '\n' || ch == '\r' || ch == '\t' || ch == ' '
1797 || ch == '&') /* FIXME */)
1798 {
1799 if (next == list)
1800 {
1801 next++;
1802 list = next;
1803 continue;
1804 }
1805 else
1806 {
1807 *next++ = '\0';
1808 break;
1809 }
1810 }
1811 if (flag_filelist_file && ch == '"')
1812 {
1813 in_quotes = ! in_quotes;
1814 *next++ = '\0';
1815 if (in_quotes)
1816 list = next;
1817 else
1818 break;
1819 }
1820 if (ch == '\0')
1821 {
1822 next = NULL;
1823 break;
1824 }
1825 next++;
1826 }
1827
1828 /* Exclude .java files. */
1829 if (strlen (list) > 5 && ! strcmp (list + strlen (list) - 5, ".java"))
1830 {
1831 /* Nothing. */
1832 }
1833 else if (list[0])
1834 {
1835 node = get_identifier (list);
1836
1837 filename_count++;
1838
1839 /* Exclude file that we see twice on the command line. */
1840
1841 if (IS_A_COMMAND_LINE_FILENAME_P (node))
1842 duplicate_class_warning (IDENTIFIER_POINTER (node));
1843 else
1844 {
1845 tree file_decl = build_decl (TRANSLATION_UNIT_DECL, node, NULL);
1846 TREE_CHAIN (file_decl) = current_file_list;
1847 current_file_list = file_decl;
1848 IS_A_COMMAND_LINE_FILENAME_P (node) = 1;
1849 }
1850 }
1851 list = next;
1852 }
1853
1854 if (file_list != NULL)
1855 free (file_list);
1856
1857 if (filename_count == 0)
1858 warning (0, "no input file specified");
1859
1860 if (resource_name)
1861 {
1862 const char *resource_filename;
1863
1864 /* Only one resource file may be compiled at a time. */
1865 assert (TREE_CHAIN (current_file_list) == NULL);
1866
1867 resource_filename = IDENTIFIER_POINTER (DECL_NAME (current_file_list));
1868 compile_resource_file (resource_name, resource_filename);
1869
1870 goto finish;
1871 }
1872
1873 current_jcf = main_jcf;
1874 current_file_list = nreverse (current_file_list);
1875 for (node = current_file_list; node; node = TREE_CHAIN (node))
1876 {
1877 unsigned char magic_string[4];
1878 char *real_path;
1879 uint32 magic = 0;
1880 tree name = DECL_NAME (node);
1881 tree real_file;
1882 const char *filename = IDENTIFIER_POINTER (name);
1883
1884 /* Skip already parsed files */
1885 real_path = lrealpath (filename);
1886 real_file = get_identifier (real_path);
1887 free (real_path);
1888 if (HAS_BEEN_ALREADY_PARSED_P (real_file))
1889 continue;
1890
1891 /* Close previous descriptor, if any */
1892 if (finput && fclose (finput))
1893 fatal_error ("can't close input file %s: %m", main_input_filename);
1894
1895 finput = fopen (filename, "rb");
1896 if (finput == NULL)
1897 fatal_error ("can't open %s: %m", filename);
1898
1899 #ifdef IO_BUFFER_SIZE
1900 setvbuf (finput, xmalloc (IO_BUFFER_SIZE),
1901 _IOFBF, IO_BUFFER_SIZE);
1902 #endif
1903
1904 /* Figure what kind of file we're dealing with */
1905 if (fread (magic_string, 1, 4, finput) == 4)
1906 {
1907 fseek (finput, 0L, SEEK_SET);
1908 magic = GET_u4 (magic_string);
1909 }
1910 if (magic == 0xcafebabe)
1911 {
1912 CLASS_FILE_P (node) = 1;
1913 current_jcf = ggc_alloc (sizeof (JCF));
1914 JCF_ZERO (current_jcf);
1915 current_jcf->read_state = finput;
1916 current_jcf->filbuf = jcf_filbuf_from_stdio;
1917 jcf_parse (current_jcf);
1918 DECL_SOURCE_LOCATION (node) = file_start_location;
1919 TYPE_JCF (current_class) = current_jcf;
1920 if (CLASS_FROM_CURRENTLY_COMPILED_P (current_class))
1921 {
1922 /* We've already compiled this class. */
1923 duplicate_class_warning (filename);
1924 continue;
1925 }
1926 CLASS_FROM_CURRENTLY_COMPILED_P (current_class) = 1;
1927 TREE_TYPE (node) = current_class;
1928 }
1929 else if (magic == (JCF_u4)ZIPMAGIC)
1930 {
1931 main_jcf = ggc_alloc (sizeof (JCF));
1932 JCF_ZERO (main_jcf);
1933 main_jcf->read_state = finput;
1934 main_jcf->filbuf = jcf_filbuf_from_stdio;
1935 #ifdef USE_MAPPED_LOCATION
1936 linemap_add (line_table, LC_ENTER, false, filename, 0);
1937 input_location = linemap_line_start (line_table, 0, 1);
1938 #endif
1939 if (open_in_zip (main_jcf, filename, NULL, 0) < 0)
1940 fatal_error ("bad zip/jar file %s", filename);
1941 localToFile = SeenZipFiles;
1942 /* Register all the classes defined there. */
1943 process_zip_dir (main_jcf->read_state);
1944 #ifdef USE_MAPPED_LOCATION
1945 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1946 #endif
1947 parse_zip_file_entries ();
1948 }
1949 else if (magic == (JCF_u4) ZIPEMPTYMAGIC)
1950 {
1951 /* Ignore an empty input jar. */
1952 }
1953 else
1954 {
1955 gcc_unreachable ();
1956 #if 0
1957 java_push_parser_context ();
1958 java_parser_context_save_global ();
1959
1960 parse_source_file_1 (real_file, filename, finput);
1961 java_parser_context_restore_global ();
1962 java_pop_parser_context (1);
1963 #ifdef USE_MAPPED_LOCATION
1964 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1965 #endif
1966 #endif
1967 }
1968 }
1969
1970 /* Do this before lowering any code. */
1971 for (node = current_file_list; node; node = TREE_CHAIN (node))
1972 {
1973 if (CLASS_FILE_P (node))
1974 java_mark_class_local (TREE_TYPE (node));
1975 }
1976
1977 for (node = current_file_list; node; node = TREE_CHAIN (node))
1978 {
1979 input_location = DECL_SOURCE_LOCATION (node);
1980 if (CLASS_FILE_P (node))
1981 {
1982 /* FIXME: These two flags really should be independent. We
1983 should be able to compile fully binary compatible, but
1984 with flag_verify_invocations on. */
1985 flag_verify_invocations = ! flag_indirect_dispatch;
1986 output_class = current_class = TREE_TYPE (node);
1987
1988 current_jcf = TYPE_JCF (current_class);
1989 layout_class (current_class);
1990 load_inner_classes (current_class);
1991 parse_class_file ();
1992 JCF_FINISH (current_jcf);
1993 }
1994 }
1995 input_location = save_location;
1996
1997 bitmap_obstack_release (&bit_obstack);
1998
1999 finish:
2000 /* Arrange for any necessary initialization to happen. */
2001 java_emit_static_constructor ();
2002
2003 /* Only finalize the compilation unit after we've told cgraph which
2004 functions have their addresses stored. */
2005 cgraph_finalize_compilation_unit ();
2006 cgraph_optimize ();
2007 }
2008
2009
2010 /* Return the name of the class corresponding to the name of the file
2011 in this zip entry. The result is newly allocated using ALLOC. */
2012 static char *
2013 compute_class_name (struct ZipDirectory *zdir)
2014 {
2015 char *class_name_in_zip_dir = ZIPDIR_FILENAME (zdir);
2016 char *class_name;
2017 int i;
2018 int filename_length = zdir->filename_length;
2019
2020 while (filename_length > 2 && strncmp (class_name_in_zip_dir, "./", 2) == 0)
2021 {
2022 class_name_in_zip_dir += 2;
2023 filename_length -= 2;
2024 }
2025
2026 filename_length -= strlen (".class");
2027 class_name = XNEWVEC (char, filename_length + 1);
2028 memcpy (class_name, class_name_in_zip_dir, filename_length);
2029 class_name [filename_length] = '\0';
2030
2031 for (i = 0; i < filename_length; i++)
2032 if (class_name[i] == '/')
2033 class_name[i] = '.';
2034
2035 return class_name;
2036 }
2037
2038 /* Return 0 if we should skip this entry, 1 if it is a .class file, 2
2039 if it is a property file of some sort. */
2040 static int
2041 classify_zip_file (struct ZipDirectory *zdir)
2042 {
2043 char *class_name_in_zip_dir = ZIPDIR_FILENAME (zdir);
2044
2045 if (zdir->filename_length > 6
2046 && !strncmp (&class_name_in_zip_dir[zdir->filename_length - 6],
2047 ".class", 6))
2048 return 1;
2049
2050 /* For now we drop the manifest, but not other information. */
2051 if (zdir->filename_length == 20
2052 && !strncmp (class_name_in_zip_dir, "META-INF/MANIFEST.MF", 20))
2053 return 0;
2054
2055 /* Drop directory entries. */
2056 if (zdir->filename_length > 0
2057 && class_name_in_zip_dir[zdir->filename_length - 1] == '/')
2058 return 0;
2059
2060 return 2;
2061 }
2062
2063 /* Process all class entries found in the zip file. */
2064 static void
2065 parse_zip_file_entries (void)
2066 {
2067 struct ZipDirectory *zdir;
2068 int i;
2069
2070 for (i = 0, zdir = (ZipDirectory *)localToFile->central_directory;
2071 i < localToFile->count; i++, zdir = ZIPDIR_NEXT (zdir))
2072 {
2073 tree class;
2074
2075 switch (classify_zip_file (zdir))
2076 {
2077 case 0:
2078 continue;
2079
2080 case 1:
2081 {
2082 char *class_name = compute_class_name (zdir);
2083 class = lookup_class (get_identifier (class_name));
2084 FREE (class_name);
2085 current_jcf = TYPE_JCF (class);
2086 output_class = current_class = class;
2087
2088 /* This is a dummy class, and now we're compiling it for
2089 real. */
2090 gcc_assert (! TYPE_DUMMY (class));
2091
2092 /* This is for a corner case where we have a superclass
2093 but no superclass fields.
2094
2095 This can happen if we earlier failed to lay out this
2096 class because its superclass was still in the process
2097 of being laid out; this occurs when we have recursive
2098 class dependencies via inner classes. Setting
2099 TYPE_SIZE to null here causes CLASS_LOADED_P to return
2100 false, so layout_class() will be called again. */
2101 if (TYPE_SIZE (class) && CLASSTYPE_SUPER (class)
2102 && integer_zerop (TYPE_SIZE (class)))
2103 TYPE_SIZE (class) = NULL_TREE;
2104
2105 if (! CLASS_LOADED_P (class))
2106 {
2107 if (! CLASS_PARSED_P (class))
2108 {
2109 read_zip_member (current_jcf, zdir, localToFile);
2110 jcf_parse (current_jcf);
2111 }
2112 layout_class (current_class);
2113 load_inner_classes (current_class);
2114 }
2115
2116 if (TYPE_SIZE (current_class) != error_mark_node)
2117 {
2118 parse_class_file ();
2119 free (current_jcf->buffer); /* No longer necessary */
2120 /* Note: there is a way to free this buffer right after a
2121 class seen in a zip file has been parsed. The idea is the
2122 set its jcf in such a way that buffer will be reallocated
2123 the time the code for the class will be generated. FIXME. */
2124 }
2125 }
2126 break;
2127
2128 case 2:
2129 {
2130 char *file_name, *class_name_in_zip_dir, *buffer;
2131 JCF *jcf;
2132 file_name = XNEWVEC (char, zdir->filename_length + 1);
2133 class_name_in_zip_dir = ZIPDIR_FILENAME (zdir);
2134 strncpy (file_name, class_name_in_zip_dir, zdir->filename_length);
2135 file_name[zdir->filename_length] = '\0';
2136 jcf = XNEW (JCF);
2137 JCF_ZERO (jcf);
2138 jcf->read_state = finput;
2139 jcf->filbuf = jcf_filbuf_from_stdio;
2140 jcf->classname = NULL;
2141 jcf->filename = file_name;
2142 jcf->zipd = zdir;
2143
2144 if (read_zip_member (jcf, zdir, localToFile) < 0)
2145 fatal_error ("error while reading %s from zip file", file_name);
2146
2147 buffer = XNEWVEC (char, zdir->filename_length + 1 +
2148 (jcf->buffer_end - jcf->buffer));
2149 strcpy (buffer, file_name);
2150 /* This is not a typo: we overwrite the trailing \0 of the
2151 file name; this is just how the data is laid out. */
2152 memcpy (buffer + zdir->filename_length,
2153 jcf->buffer, jcf->buffer_end - jcf->buffer);
2154
2155 compile_resource_data (file_name, buffer,
2156 jcf->buffer_end - jcf->buffer);
2157 JCF_FINISH (jcf);
2158 free (jcf);
2159 free (buffer);
2160 }
2161 break;
2162
2163 default:
2164 gcc_unreachable ();
2165 }
2166 }
2167 }
2168
2169 /* Read all the entries of the zip file, creates a class and a JCF. Sets the
2170 jcf up for further processing and link it to the created class. */
2171
2172 static void
2173 process_zip_dir (FILE *finput)
2174 {
2175 int i;
2176 ZipDirectory *zdir;
2177
2178 for (i = 0, zdir = (ZipDirectory *)localToFile->central_directory;
2179 i < localToFile->count; i++, zdir = ZIPDIR_NEXT (zdir))
2180 {
2181 char *class_name, *file_name, *class_name_in_zip_dir;
2182 tree class;
2183 JCF *jcf;
2184
2185 class_name_in_zip_dir = ZIPDIR_FILENAME (zdir);
2186
2187 /* Here we skip non-class files; we handle them later. */
2188 if (classify_zip_file (zdir) != 1)
2189 continue;
2190
2191 class_name = compute_class_name (zdir);
2192 file_name = XNEWVEC (char, zdir->filename_length+1);
2193 jcf = ggc_alloc (sizeof (JCF));
2194 JCF_ZERO (jcf);
2195
2196 strncpy (file_name, class_name_in_zip_dir, zdir->filename_length);
2197 file_name [zdir->filename_length] = '\0';
2198
2199 class = lookup_class (get_identifier (class_name));
2200
2201 if (CLASS_FROM_CURRENTLY_COMPILED_P (class))
2202 {
2203 /* We've already compiled this class. */
2204 duplicate_class_warning (file_name);
2205 continue;
2206 }
2207 /* This function is only called when processing a zip file seen
2208 on the command line. */
2209 CLASS_FROM_CURRENTLY_COMPILED_P (class) = 1;
2210
2211 jcf->read_state = finput;
2212 jcf->filbuf = jcf_filbuf_from_stdio;
2213 jcf->classname = class_name;
2214 jcf->filename = file_name;
2215 jcf->zipd = zdir;
2216
2217 TYPE_JCF (class) = jcf;
2218 }
2219 }
2220
2221 #include "gt-java-jcf-parse.h"
2222 #include "gtype-java.h"