/* Handle CLASSPATH, -classpath, and path searching. Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. Java and all Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. The Free Software Foundation is independent of Sun Microsystems, Inc. */ /* Written by Tom Tromey , October 1998. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "tm.h" #include #include "jcf.h" #ifndef DIR_UP #define DIR_UP ".." #endif /* Possible flag values. */ #define FLAG_SYSTEM 1 #define FLAG_ZIP 2 /* We keep linked lists of directory names. A ``directory'' can be either an ordinary directory or a .zip file. */ struct entry { char *name; int flags; struct entry *next; }; static void free_entry (struct entry **); static void append_entry (struct entry **, struct entry *); static void add_entry (struct entry **, const char *, int); static void add_path (struct entry **, const char *, int); /* We support several different ways to set the class path. built-in system directory (only libgcj.jar) CLASSPATH environment variable -classpath option overrides $CLASSPATH -CLASSPATH option is a synonym for -classpath (for compatibility) -bootclasspath overrides built-in -extdirs sets the extensions directory path (overrides built-in) -I prepends path to list We implement this by keeping several path lists, and then simply ignoring the ones which are not relevant. */ /* This holds all the -I directories. */ static struct entry *include_dirs; /* This holds the CLASSPATH environment variable. */ static struct entry *classpath_env; /* This holds the -classpath command-line option. */ static struct entry *classpath_user; /* This holds the default directories. Some of these will have the "system" flag set. */ static struct entry *sys_dirs; /* This holds the extensions path entries. */ static struct entry *extensions; /* This is the sealed list. It is just a combination of other lists. */ static struct entry *sealed; /* We keep track of the longest path we've seen. */ static int longest_path = 0; static void free_entry (struct entry **entp) { struct entry *e, *n; for (e = *entp; e; e = n) { n = e->next; free (e->name); free (e); } *entp = NULL; } static void append_entry (struct entry **entp, struct entry *ent) { /* It doesn't matter if this is slow, since it is run only at startup, and then infrequently. */ struct entry *e; /* Find end of list. */ for (e = *entp; e && e->next; e = e->next) ; if (e) e->next = ent; else *entp = ent; } static void add_entry (struct entry **entp, const char *filename, int is_system) { int len; struct entry *n; n = ALLOC (sizeof (struct entry)); n->flags = is_system ? FLAG_SYSTEM : 0; n->next = NULL; len = strlen (filename); if (len > 4 && (FILENAME_CMP (filename + len - 4, ".zip") == 0 || FILENAME_CMP (filename + len - 4, ".jar") == 0)) { n->flags |= FLAG_ZIP; /* If the user uses -classpath then he'll have to include libgcj.jar in the value. We check for this in a simplistic way. Symlinks will fool this test. This is only used for -MM and -MMD, so it probably isn't terribly important. */ if (! FILENAME_CMP (filename, LIBGCJ_ZIP_FILE)) n->flags |= FLAG_SYSTEM; } /* Note that we add a trailing separator to `.zip' names as well. This is a little hack that lets the searching code in jcf-io.c work more easily. Eww. */ if (! IS_DIR_SEPARATOR (filename[len - 1])) { char *f2 = alloca (len + 2); strcpy (f2, filename); f2[len] = DIR_SEPARATOR; f2[len + 1] = '\0'; n->name = xstrdup (f2); ++len; } else n->name = xstrdup (filename); if (len > longest_path) longest_path = len; append_entry (entp, n); } static void add_path (struct entry **entp, const char *cp, int is_system) { const char *startp, *endp; if (cp) { char *buf = alloca (strlen (cp) + 3); startp = endp = cp; while (1) { if (! *endp || *endp == PATH_SEPARATOR) { if (endp == startp) { buf[0] = '.'; buf[1] = DIR_SEPARATOR; buf[2] = '\0'; } else { strncpy (buf, startp, endp - startp); buf[endp - startp] = '\0'; } add_entry (entp, buf, is_system); if (! *endp) break; ++endp; startp = endp; } else ++endp; } } } static int init_done = 0; /* Initialize the path module. */ void jcf_path_init (void) { char *cp; char *try, sep[2]; struct stat stat_b; int found = 0, len; if (init_done) return; init_done = 1; sep[0] = DIR_SEPARATOR; sep[1] = '\0'; GET_ENVIRONMENT (cp, "GCC_EXEC_PREFIX"); if (cp) { try = alloca (strlen (cp) + 50); /* The exec prefix can be something like /usr/local/bin/../lib/gcc-lib/. We want to change this into a pointer to the share/java directory. We support two configurations: one where prefix and exec-prefix are the same, and one where exec-prefix is `prefix/SOMETHING'. */ strcpy (try, cp); strcat (try, DIR_UP); strcat (try, sep); strcat (try, DIR_UP); strcat (try, sep); len = strlen (try); strcpy (try + len, "share"); strcat (try, sep); strcat (try, "java"); strcat (try, sep); strcat (try, "libgcj-" DEFAULT_TARGET_VERSION ".jar"); if (! stat (try, &stat_b)) { add_entry (&sys_dirs, try, 1); found = 1; strcpy (&try[strlen (try) - strlen ("libgcj-" DEFAULT_TARGET_VERSION ".jar")], sep); strcat (try, "ext"); strcat (try, sep); if (! stat (try, &stat_b)) jcf_path_extdirs_arg (try); } else { strcpy (try + len, DIR_UP); strcat (try, sep); strcat (try, "share"); strcat (try, sep); strcat (try, "java"); strcat (try, sep); strcat (try, "libgcj-" DEFAULT_TARGET_VERSION ".jar"); if (! stat (try, &stat_b)) { add_entry (&sys_dirs, try, 1); found = 1; strcpy (&try[strlen (try) - strlen ("libgcj-" DEFAULT_TARGET_VERSION ".jar")], sep); strcat (try, "ext"); strcat (try, sep); if (! stat (try, &stat_b)) jcf_path_extdirs_arg (try); } } } if (! found) { /* Desperation: use the installed one. */ char *extdirs; add_entry (&sys_dirs, LIBGCJ_ZIP_FILE, 1); extdirs = alloca (strlen (LIBGCJ_ZIP_FILE) + 1); strcpy (extdirs, LIBGCJ_ZIP_FILE); strcpy (&extdirs[strlen (LIBGCJ_ZIP_FILE) - strlen ("libgcj-" DEFAULT_TARGET_VERSION ".jar")], "ext"); strcat (extdirs, sep); if (! stat (extdirs, &stat_b)) jcf_path_extdirs_arg (extdirs); } GET_ENVIRONMENT (cp, "CLASSPATH"); add_path (&classpath_env, cp, 0); } /* Call this when -classpath is seen on the command line. This overrides only the $CLASSPATH environment variable. */ void jcf_path_classpath_arg (const char *path) { free_entry (&classpath_user); add_path (&classpath_user, path, 0); } /* Call this when -bootclasspath is seen on the command line. */ void jcf_path_bootclasspath_arg (const char *path) { free_entry (&sys_dirs); add_path (&sys_dirs, path, 1); } /* Call this when -extdirs is seen on the command line. */ void jcf_path_extdirs_arg (const char *cp) { const char *startp, *endp; free_entry (&extensions); if (cp) { char *buf = alloca (strlen (cp) + 3); startp = endp = cp; while (1) { if (! *endp || *endp == PATH_SEPARATOR) { if (endp == startp) return; strncpy (buf, startp, endp - startp); buf[endp - startp] = '\0'; { DIR *dirp = NULL; int dirname_length = strlen (buf); dirp = opendir (buf); if (dirp == NULL) return; for (;;) { struct dirent *direntp = readdir (dirp); if (!direntp) break; if (direntp->d_name[0] != '.') { char *name = alloca (dirname_length + strlen (direntp->d_name) + 2); strcpy (name, buf); if (! IS_DIR_SEPARATOR (name[dirname_length-1])) { name[dirname_length] = DIR_SEPARATOR; name[dirname_length+1] = 0; } strcat (name, direntp->d_name); add_entry (&extensions, name, 0); } } } if (! *endp) break; ++endp; startp = endp; } else ++endp; } } } /* Call this when -I is seen on the command line. */ void jcf_path_include_arg (const char *path) { add_entry (&include_dirs, path, 0); } /* We `seal' the path by linking everything into one big list. Then we provide a way to iterate through the sealed list. If PRINT is true then we print the final class path to stderr. */ void jcf_path_seal (int print) { struct entry *secondary; sealed = include_dirs; include_dirs = NULL; if (classpath_user) { secondary = classpath_user; classpath_user = NULL; } else { if (! classpath_env) add_entry (&classpath_env, ".", 0); secondary = classpath_env; classpath_env = NULL; } free_entry (&classpath_user); free_entry (&classpath_env); append_entry (&sealed, secondary); append_entry (&sealed, sys_dirs); append_entry (&sealed, extensions); sys_dirs = NULL; extensions = NULL; if (print) { struct entry *ent; fprintf (stderr, "Class path starts here:\n"); for (ent = sealed; ent; ent = ent->next) { fprintf (stderr, " %s", ent->name); if ((ent->flags & FLAG_SYSTEM)) fprintf (stderr, " (system)"); if ((ent->flags & FLAG_ZIP)) fprintf (stderr, " (zip)"); fprintf (stderr, "\n"); } } } void * jcf_path_start (void) { return (void *) sealed; } void * jcf_path_next (void *x) { struct entry *ent = (struct entry *) x; return (void *) ent->next; } /* We guarantee that the return path will either be a zip file, or it will end with a directory separator. */ char * jcf_path_name (void *x) { struct entry *ent = (struct entry *) x; return ent->name; } int jcf_path_is_zipfile (void *x) { struct entry *ent = (struct entry *) x; return (ent->flags & FLAG_ZIP); } int jcf_path_is_system (void *x) { struct entry *ent = (struct entry *) x; return (ent->flags & FLAG_SYSTEM); } int jcf_path_max_len (void) { return longest_path; }