Dead
[official-gcc.git] / gomp-20050608-branch / gcc / java / jcf-io.c
blobc8651b6715f78a9cd95f6090c3380c365dfbf154
1 /* Utility routines for finding and reading Java(TM) .class files.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005
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)
10 any later version.
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, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, 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. */
28 #include "config.h"
29 #include "system.h"
30 #include "coretypes.h"
31 #include "tm.h"
33 #include "jcf.h"
34 #include "tree.h"
35 #include "toplev.h"
36 #include "java-tree.h"
37 #include "hashtab.h"
38 #if JCF_USE_SCANDIR
39 #include <dirent.h>
40 #include <fnmatch.h>
41 #endif
43 #include "zlib.h"
45 /* DOS brain-damage */
46 #ifndef O_BINARY
47 #define O_BINARY 0 /* MS-DOS brain-damage */
48 #endif
50 int
51 jcf_unexpected_eof (JCF *jcf, int count ATTRIBUTE_UNUSED)
53 if (jcf->filename)
54 fprintf (stderr, "Premature end of .class file %s.\n", jcf->filename);
55 else
56 fprintf (stderr, "Premature end of .class file <stdin>.\n");
57 exit (-1);
60 void
61 jcf_trim_old_input (JCF *jcf)
63 int count = jcf->read_ptr - jcf->buffer;
64 if (count > 0)
66 memmove (jcf->buffer, jcf->read_ptr, jcf->read_end - jcf->read_ptr);
67 jcf->read_ptr -= count;
68 jcf->read_end -= count;
72 int
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;
90 if (count <= 0)
91 return 0;
92 if ((int) fread (jcf->read_end, 1, count, file) != count)
93 jcf_unexpected_eof (jcf, count);
94 jcf->read_end += count;
95 return 0;
98 #include "zipfile.h"
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.
107 ZipFile *
108 opendir_in_zip (const char *zipfile, int is_system)
110 struct ZipFile* zipf;
111 char magic [4];
112 int fd;
113 for (zipf = SeenZipFiles; zipf != NULL; zipf = zipf->next)
115 if (strcmp (zipf->name, zipfile) == 0)
116 return zipf;
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);
124 zipf->fd = fd;
125 if (fd < 0)
127 /* A missing zip file is not considered an error.
128 We may want to re-consider that. FIXME. */
129 zipf->count = 0;
130 zipf->dir_size = 0;
131 zipf->central_directory = NULL;
133 else
135 jcf_dependency_add_file (zipfile, is_system);
136 if (read (fd, magic, 4) != 4 || GET_u4 (magic) != (JCF_u4)ZIPMAGIC)
137 return NULL;
138 lseek (fd, 0L, SEEK_SET);
139 if (read_zip_archive (zipf) != 0)
140 return NULL;
143 SeenZipFiles = zipf;
144 return zipf;
147 /* Returns:
148 0: OK - zipmember found.
149 -1: Not found.
150 -2: Malformed archive.
154 open_in_zip (JCF *jcf, const char *zipfile, const char *zipmember,
155 int is_system)
157 ZipDirectory *zipd;
158 int i, len;
159 ZipFile *zipf = opendir_in_zip (zipfile, is_system);
161 if (zipf == NULL)
162 return -2;
164 if (!zipmember)
165 return 0;
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)
175 JCF_ZERO (jcf);
177 jcf->filename = xstrdup (zipfile);
178 jcf->classname = xstrdup (zipmember);
179 return read_zip_member(jcf, zipd, zipf);
182 return -1;
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 = zipd;
193 if (zipd->compression_method == Z_NO_COMPRESSION)
195 jcf->buffer = XNEWVEC (unsigned char, 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)
201 return -2;
203 else
205 char *buffer;
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 = XNEWVEC (unsigned char, 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 = XNEWVEC (char, 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)
222 return -2;
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);
228 free (buffer);
231 return 0;
234 const char *
235 open_class (const char *filename, JCF *jcf, int fd, const char *dep_name)
237 if (jcf)
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");
244 return NULL;
246 if (dep_name != NULL)
247 jcf_dependency_add_file (dep_name, 0);
248 JCF_ZERO (jcf);
249 jcf->buffer = XNEWVEC (unsigned char, 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");
258 return NULL;
260 close (fd);
261 jcf->filbuf = jcf_unexpected_eof;
263 else
264 close (fd);
265 return filename;
269 const char *
270 find_classfile (char *filename, JCF *jcf, const char *dep_name)
272 int fd = open (filename, O_RDONLY | O_BINARY);
273 if (fd < 0)
274 return NULL;
275 return open_class (filename, jcf, fd, dep_name);
278 #if JCF_USE_SCANDIR
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
282 dirent **). */
284 static int
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. */
293 static int
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. */
305 const char *dir;
306 /* The number of .java and .class files present, or -1 if we could
307 not, for some reason, obtain the list. */
308 int num_files;
309 /* The .java and .class files in the directory, in alphabetical
310 order. */
311 struct dirent **files;
312 } memoized_dirlist_entry;
314 /* A hash function for a memoized_dirlist_entry. */
315 static hashval_t
316 memoized_dirlist_hash (const void *entry)
318 const memoized_dirlist_entry *mde = (const memoized_dirlist_entry *) entry;
319 return htab_hash_string (mde->dir);
322 /* Returns true if ENTRY (a memoized_dirlist_entry *) corresponds to
323 the directory given by KEY (a char *) giving the directory
324 name. */
326 static int
327 memoized_dirlist_lookup_eq (const void *entry, const void *key)
329 return strcmp ((const char *) key,
330 ((const memoized_dirlist_entry *) entry)->dir) == 0;
333 /* A hash table mapping directory names to the lists of .java and
334 .class files in that directory. */
336 static htab_t memoized_dirlists;
338 #endif
340 /* Like stat, but avoids actually making the stat system call if we
341 know that it cannot succeed. FILENAME and BUF are as for stat. */
343 static int
344 caching_stat (char *filename, struct stat *buf)
346 #if JCF_USE_SCANDIR
347 char *sep;
348 char origsep = 0;
349 char *base;
350 memoized_dirlist_entry *dent;
351 void **slot;
352 struct memoized_dirlist_entry temp;
354 /* If the hashtable has not already been created, create it now. */
355 if (!memoized_dirlists)
356 memoized_dirlists = htab_create (37,
357 memoized_dirlist_hash,
358 memoized_dirlist_lookup_eq,
359 NULL);
361 /* Get the name of the directory. */
362 sep = strrchr (filename, DIR_SEPARATOR);
363 #ifdef DIR_SEPARATOR_2
364 if (! sep)
365 sep = strrchr (filename, DIR_SEPARATOR_2);
366 #endif
367 if (sep)
369 origsep = *sep;
370 *sep = '\0';
371 base = sep + 1;
373 else
374 base = filename;
376 /* Obtain the entry for this directory from the hash table. This
377 approach is ok since we know that the hash function only looks at
378 the directory name. */
379 temp.dir = filename;
380 temp.num_files = 0;
381 temp.files = NULL;
382 slot = htab_find_slot (memoized_dirlists, &temp, INSERT);
383 if (!*slot)
385 /* We have not already scanned this directory; scan it now. */
386 dent = XNEW (memoized_dirlist_entry);
387 dent->dir = xstrdup (filename);
388 /* Unfortunately, scandir is not fully standardized. In
389 particular, the type of the function pointer passed as the
390 third argument sometimes takes a "const struct dirent *"
391 parameter, and sometimes just a "struct dirent *". We cast
392 to (void *) and use __extension__ so that either way it is
393 quietly accepted. FIXME: scandir is not in POSIX. */
394 dent->num_files = __extension__ scandir (filename, &dent->files,
395 (void *) java_or_class_file,
396 alphasort);
397 *slot = dent;
399 else
400 dent = *((memoized_dirlist_entry **) slot);
402 /* Put the separator back. */
403 if (sep)
404 *sep = origsep;
406 /* If the file is not in the list, there is no need to stat it; it
407 does not exist. */
408 if (dent->num_files != -1
409 && !bsearch (base, dent->files, dent->num_files,
410 sizeof (struct dirent *), compare_path))
411 return -1;
412 #endif
414 return stat (filename, buf);
417 /* Returns 1 if the CLASSNAME (really a char *) matches the name
418 stored in TABLE_ENTRY (also a char *). */
420 static int
421 memoized_class_lookup_eq (const void *table_entry, const void *classname)
423 return strcmp ((const char *)classname, (const char *)table_entry) == 0;
426 /* A hash table keeping track of class names that were not found
427 during class lookup. (There is no need to cache the values
428 associated with names that were found; they are saved in
429 IDENTIFIER_CLASS_VALUE.) */
430 static htab_t memoized_class_lookups;
432 /* Returns a freshly malloc'd string with the fully qualified pathname
433 of the .class file for the class CLASSNAME. CLASSNAME must be
434 allocated in permanent storage; this function may retain a pointer
435 to it. Returns NULL on failure. If JCF != NULL, it is suitably
436 initialized. SOURCE_OK is true if we should also look for .java
437 file. */
439 const char *
440 find_class (const char *classname, int classname_length, JCF *jcf,
441 int source_ok)
443 int fd;
444 int i, k, java = -1, class = -1;
445 struct stat java_buf, class_buf;
446 char *dep_file;
447 void *entry;
448 char *java_buffer;
449 int buflen;
450 char *buffer;
451 hashval_t hash;
453 /* Create the hash table, if it does not already exist. */
454 if (!memoized_class_lookups)
455 memoized_class_lookups = htab_create (37,
456 htab_hash_string,
457 memoized_class_lookup_eq,
458 NULL);
460 /* Loop for this class in the hashtable. If it is present, we've
461 already looked for this class and failed to find it. */
462 hash = htab_hash_string (classname);
463 if (htab_find_with_hash (memoized_class_lookups, classname, hash))
464 return NULL;
466 /* Allocate and zero out the buffer, since we don't explicitly put a
467 null pointer when we're copying it below. */
468 buflen = jcf_path_max_len () + classname_length + 10;
469 buffer = ALLOC (buflen);
470 memset (buffer, 0, buflen);
472 java_buffer = alloca (buflen);
474 jcf->java_source = 0;
476 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
478 const char *path_name = jcf_path_name (entry);
479 if (class != 0)
481 int dir_len;
483 strcpy (buffer, path_name);
484 i = strlen (buffer);
486 /* This is right because we know that `.zip' entries will have a
487 trailing slash. See jcf-path.c. */
488 dir_len = i - 1;
490 for (k = 0; k < classname_length; k++, i++)
492 char ch = classname[k];
493 buffer[i] = ch == '.' ? '/' : ch;
495 strcpy (buffer+i, ".class");
497 if (jcf_path_is_zipfile (entry))
499 int err_code;
500 JCF _jcf;
501 buffer[dir_len] = '\0';
502 SOURCE_FRONTEND_DEBUG
503 (("Trying [...%s]:%s",
504 &buffer[dir_len-(dir_len > 15 ? 15 : dir_len)],
505 buffer+dir_len+1));
506 if (jcf == NULL)
507 jcf = &_jcf;
508 err_code = open_in_zip (jcf, buffer, buffer+dir_len+1,
509 jcf_path_is_system (entry));
510 if (err_code == 0)
512 /* Should we check if .zip is out-of-date wrt .java? */
513 buffer[dir_len] = '(';
514 strcpy (buffer+i, ".class)");
515 if (jcf == &_jcf)
516 JCF_FINISH (jcf);
517 return buffer;
519 else
520 continue;
522 class = caching_stat(buffer, &class_buf);
525 if (source_ok)
527 /* Compute name of .java file. */
528 int l, m;
529 strcpy (java_buffer, path_name);
530 l = strlen (java_buffer);
531 for (m = 0; m < classname_length; ++m)
532 java_buffer[m + l] = (classname[m] == '.'
533 ? DIR_SEPARATOR : classname[m]);
534 strcpy (java_buffer + m + l, ".java");
535 java = caching_stat (java_buffer, &java_buf);
536 if (java == 0)
537 break;
541 /* We preferably pick a class file if we have a chance. If the source
542 file is newer than the class file, we issue a warning and parse the
543 source file instead.
544 There should be a flag to allow people have the class file picked
545 up no matter what. FIXME. */
546 if (! java && ! class && java_buf.st_mtime > class_buf.st_mtime)
548 if (flag_newer)
549 warning (0, "source file for class %qs is newer than its matching class file. Source file %qs used instead", classname, java_buffer);
550 class = -1;
553 if (! java)
554 dep_file = java_buffer;
555 else
556 dep_file = buffer;
557 if (!class)
559 SOURCE_FRONTEND_DEBUG ((stderr, "[Class selected: %s]\n",
560 classname+classname_length-
561 (classname_length <= 30 ?
562 classname_length : 30)));
563 fd = JCF_OPEN_EXACT_CASE (buffer, O_RDONLY | O_BINARY);
564 if (fd >= 0)
565 goto found;
567 /* Give .java a try, if necessary */
568 if (!java)
570 strcpy (buffer, java_buffer);
571 SOURCE_FRONTEND_DEBUG ((stderr, "[Source selected: %s]\n",
572 classname+classname_length-
573 (classname_length <= 30 ?
574 classname_length : 30)));
575 fd = JCF_OPEN_EXACT_CASE (buffer, O_RDONLY);
576 if (fd >= 0)
578 jcf->java_source = 1;
579 goto found;
583 free (buffer);
585 /* Remember that this class could not be found so that we do not
586 have to look again. */
587 *htab_find_slot_with_hash (memoized_class_lookups, classname, hash, INSERT)
588 = (void *) classname;
590 return NULL;
591 found:
592 if (jcf->java_source)
594 JCF_ZERO (jcf); /* JCF_FINISH relies on this */
595 jcf->java_source = 1;
596 jcf->filename = xstrdup (buffer);
597 close (fd); /* We use STDIO for source file */
599 else
600 buffer = (char *) open_class (buffer, jcf, fd, dep_file);
601 jcf->classname = xstrdup (classname);
602 return buffer;
605 void
606 jcf_print_char (FILE *stream, int ch)
608 switch (ch)
610 case '\'':
611 case '\\':
612 case '\"':
613 fprintf (stream, "\\%c", ch);
614 break;
615 case '\n':
616 fprintf (stream, "\\n");
617 break;
618 case '\t':
619 fprintf (stream, "\\t");
620 break;
621 case '\r':
622 fprintf (stream, "\\r");
623 break;
624 default:
625 if (ch >= ' ' && ch < 127)
626 putc (ch, stream);
627 else if (ch < 256)
628 fprintf (stream, "\\%03x", ch);
629 else
630 fprintf (stream, "\\u%04x", ch);
634 /* Print UTF8 string at STR of length LENGTH bytes to STREAM. */
636 void
637 jcf_print_utf8 (FILE *stream, const unsigned char *str, int length)
639 const unsigned char * limit = str + length;
640 while (str < limit)
642 int ch = UTF8_GET (str, limit);
643 if (ch < 0)
645 fprintf (stream, "\\<invalid>");
646 return;
648 jcf_print_char (stream, ch);
652 /* Same as jcf_print_utf8, but print IN_CHAR as OUT_CHAR. */
654 void
655 jcf_print_utf8_replace (FILE *stream, const unsigned char *str, int length,
656 int in_char, int out_char)
658 const unsigned char *limit = str + length;
659 while (str < limit)
661 int ch = UTF8_GET (str, limit);
662 if (ch < 0)
664 fprintf (stream, "\\<invalid>");
665 return;
667 jcf_print_char (stream, ch == in_char ? out_char : ch);
671 /* Check that all the cross-references in the constant pool are
672 valid. Returns 0 on success.
673 Otherwise, returns the index of the (first) invalid entry.
674 Only checks internal consistency, but does not check that
675 any classes, fields, or methods are valid.*/
678 verify_constant_pool (JCF *jcf)
680 int i, n;
681 for (i = 1; i < JPOOL_SIZE (jcf); i++)
683 switch (JPOOL_TAG (jcf, i))
685 case CONSTANT_NameAndType:
686 n = JPOOL_USHORT2 (jcf, i);
687 if (n <= 0 || n >= JPOOL_SIZE(jcf)
688 || JPOOL_TAG (jcf, n) != CONSTANT_Utf8)
689 return i;
690 /* ... fall through ... */
691 case CONSTANT_Class:
692 case CONSTANT_String:
693 n = JPOOL_USHORT1 (jcf, i);
694 if (n <= 0 || n >= JPOOL_SIZE(jcf)
695 || JPOOL_TAG (jcf, n) != CONSTANT_Utf8)
696 return i;
697 break;
698 case CONSTANT_Fieldref:
699 case CONSTANT_Methodref:
700 case CONSTANT_InterfaceMethodref:
701 n = JPOOL_USHORT1 (jcf, i);
702 if (n <= 0 || n >= JPOOL_SIZE(jcf)
703 || JPOOL_TAG (jcf, n) != CONSTANT_Class)
704 return i;
705 n = JPOOL_USHORT2 (jcf, i);
706 if (n <= 0 || n >= JPOOL_SIZE(jcf)
707 || JPOOL_TAG (jcf, n) != CONSTANT_NameAndType)
708 return i;
709 break;
710 case CONSTANT_Long:
711 case CONSTANT_Double:
712 i++;
713 break;
714 case CONSTANT_Float:
715 case CONSTANT_Integer:
716 case CONSTANT_Utf8:
717 case CONSTANT_Unicode:
718 break;
719 default:
720 return i;
723 return 0;
726 void
727 format_uint (char *buffer, uint64 value, int base)
729 #define WRITE_BUF_SIZE (4 + sizeof(uint64) * 8)
730 char buf[WRITE_BUF_SIZE];
731 char *buf_ptr = buf+WRITE_BUF_SIZE; /* End of buf. */
732 int chars_written;
733 int i;
735 /* Now do the actual conversion, placing the result at the *end* of buf. */
736 /* Note this code does not pretend to be optimized. */
737 do {
738 int digit = value % base;
739 static const char digit_chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";
740 *--buf_ptr = digit_chars[digit];
741 value /= base;
742 } while (value != 0);
744 chars_written = buf+WRITE_BUF_SIZE - buf_ptr;
745 for (i = 0; i < chars_written; i++)
746 buffer[i] = *buf_ptr++;
747 buffer[i] = 0;
750 void
751 format_int (char *buffer, jlong value, int base)
753 uint64 abs_value;
754 if (value < 0)
756 abs_value = -(uint64)value;
757 *buffer++ = '-';
759 else
760 abs_value = (uint64) value;
761 format_uint (buffer, abs_value, base);