1 /* Utility routines for finding and reading Java(TM) .class files.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GCC.
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 2, or (at your option)
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.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
30 #include "coretypes.h"
36 #include "java-tree.h"
45 /* DOS brain-damage */
47 #define O_BINARY 0 /* MS-DOS brain-damage */
51 jcf_unexpected_eof (JCF
*jcf
, int count ATTRIBUTE_UNUSED
)
54 fprintf (stderr
, "Premature end of .class file %s.\n", jcf
->filename
);
56 fprintf (stderr
, "Premature end of .class file <stdin>.\n");
61 jcf_trim_old_input (JCF
*jcf
)
63 int count
= jcf
->read_ptr
- jcf
->buffer
;
66 memmove (jcf
->buffer
, jcf
->read_ptr
, jcf
->read_end
- jcf
->read_ptr
);
67 jcf
->read_ptr
-= count
;
68 jcf
->read_end
-= count
;
73 jcf_filbuf_from_stdio (JCF
*jcf
, int count
)
75 FILE *file
= (FILE*) (jcf
->read_state
);
76 if (count
> jcf
->buffer_end
- jcf
->read_ptr
)
78 JCF_u4 old_read_ptr
= jcf
->read_ptr
- jcf
->buffer
;
79 JCF_u4 old_read_end
= jcf
->read_end
- jcf
->buffer
;
80 JCF_u4 old_size
= jcf
->buffer_end
- jcf
->buffer
;
81 JCF_u4 new_size
= (old_size
== 0 ? 2000 : 2 * old_size
) + count
;
82 unsigned char *new_buffer
= jcf
->buffer
== NULL
? ALLOC (new_size
)
83 : REALLOC (jcf
->buffer
, new_size
);
84 jcf
->buffer
= new_buffer
;
85 jcf
->buffer_end
= new_buffer
+ new_size
;
86 jcf
->read_ptr
= new_buffer
+ old_read_ptr
;
87 jcf
->read_end
= new_buffer
+ old_read_end
;
89 count
-= jcf
->read_end
- jcf
->read_ptr
;
92 if ((int) fread (jcf
->read_end
, 1, count
, file
) != count
)
93 jcf_unexpected_eof (jcf
, count
);
94 jcf
->read_end
+= count
;
100 struct ZipFile
*SeenZipFiles
= NULL
;
102 /* Open a zip file with the given name, and cache directory and file
103 descriptor. If the file is missing, treat it as an empty archive.
104 Return NULL if the .zip file is malformed.
108 opendir_in_zip (const char *zipfile
, int is_system
)
110 struct ZipFile
* zipf
;
113 for (zipf
= SeenZipFiles
; zipf
!= NULL
; zipf
= zipf
->next
)
115 if (strcmp (zipf
->name
, zipfile
) == 0)
119 zipf
= ALLOC (sizeof (struct ZipFile
) + strlen (zipfile
) + 1);
120 zipf
->next
= SeenZipFiles
;
121 zipf
->name
= (char*)(zipf
+1);
122 strcpy (zipf
->name
, zipfile
);
123 fd
= open (zipfile
, O_RDONLY
| O_BINARY
);
127 /* A missing zip file is not considered an error.
128 We may want to re-consider that. FIXME. */
131 zipf
->central_directory
= NULL
;
135 jcf_dependency_add_file (zipfile
, is_system
);
136 if (read (fd
, magic
, 4) != 4 || GET_u4 (magic
) != (JCF_u4
)ZIPMAGIC
)
138 lseek (fd
, 0L, SEEK_SET
);
139 if (read_zip_archive (zipf
) != 0)
148 0: OK - zipmember found.
150 -2: Malformed archive.
154 open_in_zip (JCF
*jcf
, const char *zipfile
, const char *zipmember
,
159 ZipFile
*zipf
= opendir_in_zip (zipfile
, is_system
);
167 len
= strlen (zipmember
);
169 zipd
= (struct ZipDirectory
*) zipf
->central_directory
;
170 for (i
= 0; i
< zipf
->count
; i
++, zipd
= ZIPDIR_NEXT (zipd
))
172 if (len
== zipd
->filename_length
&&
173 strncmp (ZIPDIR_FILENAME (zipd
), zipmember
, len
) == 0)
177 jcf
->filename
= xstrdup (zipfile
);
178 jcf
->classname
= xstrdup (zipmember
);
179 return read_zip_member(jcf
, zipd
, zipf
);
185 /* Read data from zip archive member. */
188 read_zip_member (JCF
*jcf
, ZipDirectory
*zipd
, ZipFile
*zipf
)
190 jcf
->filbuf
= jcf_unexpected_eof
;
191 jcf
->zipd
= (void *)zipd
;
193 if (zipd
->compression_method
== Z_NO_COMPRESSION
)
195 jcf
->buffer
= ALLOC (zipd
->size
);
196 jcf
->buffer_end
= jcf
->buffer
+ zipd
->size
;
197 jcf
->read_ptr
= jcf
->buffer
;
198 jcf
->read_end
= jcf
->buffer_end
;
199 if (lseek (zipf
->fd
, zipd
->filestart
, 0) < 0
200 || read (zipf
->fd
, jcf
->buffer
, zipd
->size
) != (long) zipd
->size
)
206 z_stream d_stream
; /* decompression stream */
207 d_stream
.zalloc
= (alloc_func
) 0;
208 d_stream
.zfree
= (free_func
) 0;
209 d_stream
.opaque
= (voidpf
) 0;
211 jcf
->buffer
= ALLOC (zipd
->uncompressed_size
);
212 d_stream
.next_out
= jcf
->buffer
;
213 d_stream
.avail_out
= zipd
->uncompressed_size
;
214 jcf
->buffer_end
= jcf
->buffer
+ zipd
->uncompressed_size
;
215 jcf
->read_ptr
= jcf
->buffer
;
216 jcf
->read_end
= jcf
->buffer_end
;
217 buffer
= ALLOC (zipd
->size
);
218 d_stream
.next_in
= (unsigned char *) buffer
;
219 d_stream
.avail_in
= zipd
->size
;
220 if (lseek (zipf
->fd
, zipd
->filestart
, 0) < 0
221 || read (zipf
->fd
, buffer
, zipd
->size
) != (long) zipd
->size
)
223 /* Handle NO_HEADER using undocumented zlib feature.
224 This is a very common hack. */
225 inflateInit2 (&d_stream
, -MAX_WBITS
);
226 inflate (&d_stream
, Z_NO_FLUSH
);
227 inflateEnd (&d_stream
);
235 open_class (const char *filename
, JCF
*jcf
, int fd
, const char *dep_name
)
239 struct stat stat_buf
;
240 if (fstat (fd
, &stat_buf
) != 0
241 || ! S_ISREG (stat_buf
.st_mode
))
243 perror ("Could not figure length of .class file");
246 if (dep_name
!= NULL
)
247 jcf_dependency_add_file (dep_name
, 0);
249 jcf
->buffer
= ALLOC (stat_buf
.st_size
);
250 jcf
->buffer_end
= jcf
->buffer
+ stat_buf
.st_size
;
251 jcf
->read_ptr
= jcf
->buffer
;
252 jcf
->read_end
= jcf
->buffer_end
;
253 jcf
->read_state
= NULL
;
254 jcf
->filename
= filename
;
255 if (read (fd
, jcf
->buffer
, stat_buf
.st_size
) != stat_buf
.st_size
)
257 perror ("Failed to read .class file");
261 jcf
->filbuf
= jcf_unexpected_eof
;
270 find_classfile (char *filename
, JCF
*jcf
, const char *dep_name
)
272 int fd
= open (filename
, O_RDONLY
| O_BINARY
);
275 return open_class (filename
, jcf
, fd
, dep_name
);
280 /* A comparison function (as for qsort) that compares KEY (a char *
281 giving the basename of a file) with the name stored in ENTRY (a
285 compare_path (const void *key
, const void *entry
)
287 return strcmp ((const char *) key
,
288 (*((const struct dirent
**) entry
))->d_name
);
291 /* Returns nonzero if ENTRY names a .java or .class file. */
294 java_or_class_file (const struct dirent
*entry
)
296 const char *base
= lbasename (entry
->d_name
);
297 return (fnmatch ("*.java", base
, 0) == 0 ||
298 fnmatch ("*.class", base
, 0) == 0);
301 /* Information about the files present in a particular directory. */
302 typedef struct memoized_dirlist_entry
304 /* The name of the directory. */
306 /* The number of .java and .class files present, or -1 if we could
307 not, for some reason, obtain the list. */
309 /* The .java and .class files in the directory, in alphabetical
311 struct dirent
**files
;
312 } memoized_dirlist_entry
;
314 /* Returns true if ENTRY (a memoized_dirlist_entry *) corresponds to
315 the directory given by KEY (a char *) giving the directory
319 memoized_dirlist_lookup_eq (const void *entry
, const void *key
)
321 return strcmp ((const char *) key
,
322 ((const memoized_dirlist_entry
*) entry
)->dir
) == 0;
325 /* A hash table mapping directory names to the lists of .java and
326 .class files in that directory. */
328 static htab_t memoized_dirlists
;
332 /* Like stat, but avoids actually making the stat system call if we
333 know that it cannot succeed. FILENAME and BUF are as for stat. */
336 caching_stat (char *filename
, struct stat
*buf
)
342 memoized_dirlist_entry
*dent
;
345 /* If the hashtable has not already been created, create it now. */
346 if (!memoized_dirlists
)
347 memoized_dirlists
= htab_create (37,
349 memoized_dirlist_lookup_eq
,
352 /* Get the name of the directory. */
353 sep
= strrchr (filename
, DIR_SEPARATOR
);
354 #ifdef DIR_SEPARATOR_2
356 sep
= strrchr (filename
, DIR_SEPARATOR_2
);
367 /* Obtain the entry for this directory from the hash table. */
368 slot
= htab_find_slot (memoized_dirlists
, filename
, INSERT
);
371 /* We have not already scanned this directory; scan it now. */
372 dent
= ((memoized_dirlist_entry
*)
373 ALLOC (sizeof (memoized_dirlist_entry
)));
374 dent
->dir
= xstrdup (filename
);
375 /* Unfortunately, scandir is not fully standardized. In
376 particular, the type of the function pointer passed as the
377 third argument sometimes takes a "const struct dirent *"
378 parameter, and sometimes just a "struct dirent *". We cast
379 to (void *) so that either way it is quietly accepted. */
380 dent
->num_files
= scandir (filename
, &dent
->files
,
381 (void *) java_or_class_file
,
386 dent
= *((memoized_dirlist_entry
**) slot
);
388 /* Put the separator back. */
392 /* If the file is not in the list, there is no need to stat it; it
394 if (dent
->num_files
!= -1
395 && !bsearch (base
, dent
->files
, dent
->num_files
,
396 sizeof (struct dirent
*), compare_path
))
400 return stat (filename
, buf
);
403 /* Returns 1 if the CLASSNAME (really a char *) matches the name
404 stored in TABLE_ENTRY (also a char *). */
407 memoized_class_lookup_eq (const void *table_entry
, const void *classname
)
409 return strcmp ((const char *)classname
, (const char *)table_entry
) == 0;
412 /* A hash table keeping track of class names that were not found
413 during class lookup. (There is no need to cache the values
414 associated with names that were found; they are saved in
415 IDENTIFIER_CLASS_VALUE.) */
416 static htab_t memoized_class_lookups
;
418 /* Returns a freshly malloc'd string with the fully qualified pathname
419 of the .class file for the class CLASSNAME. CLASSNAME must be
420 allocated in permanent storage; this function may retain a pointer
421 to it. Returns NULL on failure. If JCF != NULL, it is suitably
422 initialized. SOURCE_OK is true if we should also look for .java
426 find_class (const char *classname
, int classname_length
, JCF
*jcf
,
430 int i
, k
, java
= -1, class = -1;
431 struct stat java_buf
, class_buf
;
439 /* Create the hash table, if it does not already exist. */
440 if (!memoized_class_lookups
)
441 memoized_class_lookups
= htab_create (37,
443 memoized_class_lookup_eq
,
446 /* Loop for this class in the hashtable. If it is present, we've
447 already looked for this class and failed to find it. */
448 hash
= htab_hash_string (classname
);
449 if (htab_find_with_hash (memoized_class_lookups
, classname
, hash
))
452 /* Allocate and zero out the buffer, since we don't explicitly put a
453 null pointer when we're copying it below. */
454 buflen
= jcf_path_max_len () + classname_length
+ 10;
455 buffer
= ALLOC (buflen
);
456 memset (buffer
, 0, buflen
);
458 java_buffer
= alloca (buflen
);
460 jcf
->java_source
= 0;
462 for (entry
= jcf_path_start (); entry
!= NULL
; entry
= jcf_path_next (entry
))
464 const char *path_name
= jcf_path_name (entry
);
469 strcpy (buffer
, path_name
);
472 /* This is right because we know that `.zip' entries will have a
473 trailing slash. See jcf-path.c. */
476 for (k
= 0; k
< classname_length
; k
++, i
++)
478 char ch
= classname
[k
];
479 buffer
[i
] = ch
== '.' ? '/' : ch
;
481 strcpy (buffer
+i
, ".class");
483 if (jcf_path_is_zipfile (entry
))
487 buffer
[dir_len
] = '\0';
488 SOURCE_FRONTEND_DEBUG
489 (("Trying [...%s]:%s",
490 &buffer
[dir_len
-(dir_len
> 15 ? 15 : dir_len
)],
494 err_code
= open_in_zip (jcf
, buffer
, buffer
+dir_len
+1,
495 jcf_path_is_system (entry
));
498 /* Should we check if .zip is out-of-date wrt .java? */
499 buffer
[dir_len
] = '(';
500 strcpy (buffer
+i
, ".class)");
508 class = caching_stat(buffer
, &class_buf
);
513 /* Compute name of .java file. */
515 strcpy (java_buffer
, path_name
);
516 l
= strlen (java_buffer
);
517 for (m
= 0; m
< classname_length
; ++m
)
518 java_buffer
[m
+ l
] = (classname
[m
] == '.'
519 ? DIR_SEPARATOR
: classname
[m
]);
520 strcpy (java_buffer
+ m
+ l
, ".java");
521 java
= caching_stat (java_buffer
, &java_buf
);
527 /* We preferably pick a class file if we have a chance. If the source
528 file is newer than the class file, we issue a warning and parse the
530 There should be a flag to allow people have the class file picked
531 up no matter what. FIXME. */
532 if (! java
&& ! class && java_buf
.st_mtime
> class_buf
.st_mtime
)
535 warning ("source file for class `%s' is newer than its matching class file. Source file `%s' used instead", classname
, java_buffer
);
540 dep_file
= java_buffer
;
545 SOURCE_FRONTEND_DEBUG ((stderr
, "[Class selected: %s]\n",
546 classname
+classname_length
-
547 (classname_length
<= 30 ?
548 classname_length
: 30)));
549 fd
= JCF_OPEN_EXACT_CASE (buffer
, O_RDONLY
| O_BINARY
);
553 /* Give .java a try, if necessary */
556 strcpy (buffer
, java_buffer
);
557 SOURCE_FRONTEND_DEBUG ((stderr
, "[Source selected: %s]\n",
558 classname
+classname_length
-
559 (classname_length
<= 30 ?
560 classname_length
: 30)));
561 fd
= JCF_OPEN_EXACT_CASE (buffer
, O_RDONLY
);
564 jcf
->java_source
= 1;
571 /* Remember that this class could not be found so that we do not
572 have to look again. */
573 *htab_find_slot_with_hash (memoized_class_lookups
, classname
, hash
, INSERT
)
574 = (void *) classname
;
578 if (jcf
->java_source
)
580 JCF_ZERO (jcf
); /* JCF_FINISH relies on this */
581 jcf
->java_source
= 1;
582 jcf
->filename
= xstrdup (buffer
);
583 close (fd
); /* We use STDIO for source file */
586 buffer
= (char *) open_class (buffer
, jcf
, fd
, dep_file
);
587 jcf
->classname
= xstrdup (classname
);
592 jcf_print_char (FILE *stream
, int ch
)
599 fprintf (stream
, "\\%c", ch
);
602 fprintf (stream
, "\\n");
605 fprintf (stream
, "\\t");
608 fprintf (stream
, "\\r");
611 if (ch
>= ' ' && ch
< 127)
614 fprintf (stream
, "\\%03x", ch
);
616 fprintf (stream
, "\\u%04x", ch
);
620 /* Print UTF8 string at STR of length LENGTH bytes to STREAM. */
623 jcf_print_utf8 (FILE *stream
, const unsigned char *str
, int length
)
625 const unsigned char * limit
= str
+ length
;
628 int ch
= UTF8_GET (str
, limit
);
631 fprintf (stream
, "\\<invalid>");
634 jcf_print_char (stream
, ch
);
638 /* Same as jcf_print_utf8, but print IN_CHAR as OUT_CHAR. */
641 jcf_print_utf8_replace (FILE *stream
, const unsigned char *str
, int length
,
642 int in_char
, int out_char
)
644 const unsigned char *limit
= str
+ length
;
647 int ch
= UTF8_GET (str
, limit
);
650 fprintf (stream
, "\\<invalid>");
653 jcf_print_char (stream
, ch
== in_char
? out_char
: ch
);
657 /* Check that all the cross-references in the constant pool are
658 valid. Returns 0 on success.
659 Otherwise, returns the index of the (first) invalid entry.
660 Only checks internal consistency, but does not check that
661 any classes, fields, or methods are valid.*/
664 verify_constant_pool (JCF
*jcf
)
667 for (i
= 1; i
< JPOOL_SIZE (jcf
); i
++)
669 switch (JPOOL_TAG (jcf
, i
))
671 case CONSTANT_NameAndType
:
672 n
= JPOOL_USHORT2 (jcf
, i
);
673 if (n
<= 0 || n
>= JPOOL_SIZE(jcf
)
674 || JPOOL_TAG (jcf
, n
) != CONSTANT_Utf8
)
676 /* ... fall through ... */
678 case CONSTANT_String
:
679 n
= JPOOL_USHORT1 (jcf
, i
);
680 if (n
<= 0 || n
>= JPOOL_SIZE(jcf
)
681 || JPOOL_TAG (jcf
, n
) != CONSTANT_Utf8
)
684 case CONSTANT_Fieldref
:
685 case CONSTANT_Methodref
:
686 case CONSTANT_InterfaceMethodref
:
687 n
= JPOOL_USHORT1 (jcf
, i
);
688 if (n
<= 0 || n
>= JPOOL_SIZE(jcf
)
689 || JPOOL_TAG (jcf
, n
) != CONSTANT_Class
)
691 n
= JPOOL_USHORT2 (jcf
, i
);
692 if (n
<= 0 || n
>= JPOOL_SIZE(jcf
)
693 || JPOOL_TAG (jcf
, n
) != CONSTANT_NameAndType
)
697 case CONSTANT_Double
:
701 case CONSTANT_Integer
:
703 case CONSTANT_Unicode
:
713 format_uint (char *buffer
, uint64 value
, int base
)
715 #define WRITE_BUF_SIZE (4 + sizeof(uint64) * 8)
716 char buf
[WRITE_BUF_SIZE
];
717 char *buf_ptr
= buf
+WRITE_BUF_SIZE
; /* End of buf. */
721 /* Now do the actual conversion, placing the result at the *end* of buf. */
722 /* Note this code does not pretend to be optimized. */
724 int digit
= value
% base
;
725 static const char digit_chars
[] = "0123456789abcdefghijklmnopqrstuvwxyz";
726 *--buf_ptr
= digit_chars
[digit
];
728 } while (value
!= 0);
730 chars_written
= buf
+WRITE_BUF_SIZE
- buf_ptr
;
731 for (i
= 0; i
< chars_written
; i
++)
732 buffer
[i
] = *buf_ptr
++;
737 format_int (char *buffer
, jlong value
, int base
)
742 abs_value
= -(uint64
)value
;
746 abs_value
= (uint64
) value
;
747 format_uint (buffer
, abs_value
, base
);