gcc/java/jcf-path.c

   1 /* Handle CLASSPATH, -classpath, and path searching.
   2    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
   3    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 2, 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 COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.
  21
  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.  */
  25
  26 /* Written by Tom Tromey <tromey@cygnus.com>, October 1998.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32
  33 #include <dirent.h>
  34
  35 #include "jcf.h"
  36
  37 /* By default, colon separates directories in a path.  */
  38 #ifndef PATH_SEPARATOR
  39 #define PATH_SEPARATOR ':'
  40 #endif
  41
  42 #ifndef DIR_SEPARATOR
  43 #define DIR_SEPARATOR '/'
  44 #endif
  45
  46 #ifndef DIR_UP
  47 #define DIR_UP ".."
  48 #endif
  49
  50 \f
  51
  52 /* Possible flag values.  */
  53 #define FLAG_SYSTEM 1
  54 #define FLAG_ZIP    2
  55
  56 /* We keep linked lists of directory names.  A ``directory'' can be
  57    either an ordinary directory or a .zip file.  */
  58 struct entry
  59 {
  60   char *name;
  61   int flags;
  62   struct entry *next;
  63 };
  64
  65 static void free_entry (struct entry **);
  66 static void append_entry (struct entry **, struct entry *);
  67 static void add_entry (struct entry **, const char *, int);
  68 static void add_path (struct entry **, const char *, int);
  69
  70 /* We support several different ways to set the class path.
  71
  72    built-in system directory (only libgcj.jar)
  73    CLASSPATH environment variable
  74    -classpath option overrides $CLASSPATH
  75    -CLASSPATH option is a synonym for -classpath (for compatibility)
  76    -bootclasspath overrides built-in
  77    -extdirs sets the extensions directory path (overrides built-in)
  78    -I prepends path to list
  79
  80    We implement this by keeping several path lists, and then simply
  81    ignoring the ones which are not relevant.  */
  82
  83 /* This holds all the -I directories.  */
  84 static struct entry *include_dirs;
  85
  86 /* This holds the CLASSPATH environment variable.  */
  87 static struct entry *classpath_env;
  88
  89 /* This holds the -classpath command-line option.  */
  90 static struct entry *classpath_user;
  91
  92 /* This holds the default directories.  Some of these will have the
  93    "system" flag set.  */
  94 static struct entry *sys_dirs;
  95
  96 /* This holds the extensions path entries.  */
  97 static struct entry *extensions;
  98
  99 /* This is the sealed list.  It is just a combination of other lists.  */
 100 static struct entry *sealed;
 101
 102 /* We keep track of the longest path we've seen.  */
 103 static int longest_path = 0;
 104
 105 \f
 106
 107 static void
 108 free_entry (struct entry **entp)
 109 {
 110   struct entry *e, *n;
 111
 112   for (e = *entp; e; e = n)
 113     {
 114       n = e->next;
 115       free (e->name);
 116       free (e);
 117     }
 118   *entp = NULL;
 119 }
 120
 121 static void
 122 append_entry (struct entry **entp, struct entry *ent)
 123 {
 124   /* It doesn't matter if this is slow, since it is run only at
 125      startup, and then infrequently.  */
 126   struct entry *e;
 127
 128   /* Find end of list.  */
 129   for (e = *entp; e && e->next; e = e->next)
 130     ;
 131
 132   if (e)
 133     e->next = ent;
 134   else
 135     *entp = ent;
 136 }
 137
 138 static void
 139 add_entry (struct entry **entp, const char *filename, int is_system)
 140 {
 141   int len;
 142   struct entry *n;
 143
 144   n = ALLOC (sizeof (struct entry));
 145   n->flags = is_system ? FLAG_SYSTEM : 0;
 146   n->next = NULL;
 147
 148   len = strlen (filename);
 149   if (len > 4 && (strcmp (filename + len - 4, ".zip") == 0
 150                   || strcmp (filename + len - 4, ".jar") == 0))
 151     {
 152       n->flags |= FLAG_ZIP;
 153       /* If the user uses -classpath then he'll have to include
 154          libgcj.jar in the value.  We check for this in a simplistic
 155          way.  Symlinks will fool this test.  This is only used for
 156          -MM and -MMD, so it probably isn't terribly important.  */
 157       if (! strcmp (filename, LIBGCJ_ZIP_FILE))
 158         n->flags |= FLAG_SYSTEM;
 159     }
 160
 161   /* Note that we add a trailing separator to `.zip' names as well.
 162      This is a little hack that lets the searching code in jcf-io.c
 163      work more easily.  Eww.  */
 164   if (filename[len - 1] != '/' && filename[len - 1] != DIR_SEPARATOR)
 165     {
 166       char *f2 = alloca (len + 2);
 167       strcpy (f2, filename);
 168       f2[len] = DIR_SEPARATOR;
 169       f2[len + 1] = '\0';
 170       n->name = xstrdup (f2);
 171       ++len;
 172     }
 173   else
 174     n->name = xstrdup (filename);
 175
 176   if (len > longest_path)
 177     longest_path = len;
 178
 179   append_entry (entp, n);
 180 }
 181
 182 static void
 183 add_path (struct entry **entp, const char *cp, int is_system)
 184 {
 185   const char *startp, *endp;
 186
 187   if (cp)
 188     {
 189       char *buf = alloca (strlen (cp) + 3);
 190       startp = endp = cp;
 191       while (1)
 192         {
 193           if (! *endp || *endp == PATH_SEPARATOR)
 194             {
 195               if (endp == startp)
 196                 {
 197                   buf[0] = '.';
 198                   buf[1] = DIR_SEPARATOR;
 199                   buf[2] = '\0';
 200                 }
 201               else
 202                 {
 203                   strncpy (buf, startp, endp - startp);
 204                   buf[endp - startp] = '\0';
 205                 }
 206               add_entry (entp, buf, is_system);
 207               if (! *endp)
 208                 break;
 209               ++endp;
 210               startp = endp;
 211             }
 212           else
 213             ++endp;
 214         }
 215     }
 216 }
 217
 218 static int init_done = 0;
 219
 220 /* Initialize the path module.  */
 221 void
 222 jcf_path_init (void)
 223 {
 224   char *cp;
 225   char *try, sep[2];
 226   struct stat stat_b;
 227   int found = 0, len;
 228
 229   if (init_done)
 230     return;
 231   init_done = 1;
 232
 233   sep[0] = DIR_SEPARATOR;
 234   sep[1] = '\0';
 235
 236   GET_ENVIRONMENT (cp, "GCC_EXEC_PREFIX");
 237   if (cp)
 238     {
 239       try = alloca (strlen (cp) + 50);
 240       /* The exec prefix can be something like
 241          /usr/local/bin/../lib/gcc-lib/.  We want to change this
 242          into a pointer to the share/java directory.  We support two
 243          configurations: one where prefix and exec-prefix are the
 244          same, and one where exec-prefix is `prefix/SOMETHING'.  */
 245       strcpy (try, cp);
 246       strcat (try, DIR_UP);
 247       strcat (try, sep);
 248       strcat (try, DIR_UP);
 249       strcat (try, sep);
 250       len = strlen (try);
 251
 252       strcpy (try + len, "share");
 253       strcat (try, sep);
 254       strcat (try, "java");
 255       strcat (try, sep);
 256       strcat (try, "libgcj-" DEFAULT_TARGET_VERSION ".jar");
 257       if (! stat (try, &stat_b))
 258         {
 259           add_entry (&sys_dirs, try, 1);
 260           found = 1;
 261           strcpy (&try[strlen (try)
 262                       - strlen ("libgcj-" DEFAULT_TARGET_VERSION ".jar")],
 263                   sep);
 264           strcat (try, "ext");
 265           strcat (try, sep);
 266           if (! stat (try, &stat_b))
 267             jcf_path_extdirs_arg (try);
 268         }
 269       else
 270         {
 271           strcpy (try + len, DIR_UP);
 272           strcat (try, sep);
 273           strcat (try, "share");
 274           strcat (try, sep);
 275           strcat (try, "java");
 276           strcat (try, sep);
 277           strcat (try, "libgcj-" DEFAULT_TARGET_VERSION ".jar");
 278           if (! stat (try, &stat_b))
 279             {
 280               add_entry (&sys_dirs, try, 1);
 281               found = 1;
 282               strcpy (&try[strlen (try)
 283                           - strlen ("libgcj-" DEFAULT_TARGET_VERSION ".jar")],
 284                       sep);
 285               strcat (try, "ext");
 286               strcat (try, sep);
 287               if (! stat (try, &stat_b))
 288                 jcf_path_extdirs_arg (try);
 289             }
 290         }
 291     }
 292   if (! found)
 293     {
 294       /* Desperation: use the installed one.  */
 295       char *extdirs;
 296       add_entry (&sys_dirs, LIBGCJ_ZIP_FILE, 1);
 297       extdirs = alloca (strlen (LIBGCJ_ZIP_FILE) + 1);
 298       strcpy (extdirs, LIBGCJ_ZIP_FILE);
 299       strcpy (&extdirs[strlen (LIBGCJ_ZIP_FILE)
 300                       - strlen ("libgcj-" DEFAULT_TARGET_VERSION ".jar")],
 301               "ext");
 302       strcat (extdirs, sep);
 303       if (! stat (extdirs, &stat_b))
 304         jcf_path_extdirs_arg (extdirs);
 305     }
 306
 307   GET_ENVIRONMENT (cp, "CLASSPATH");
 308   add_path (&classpath_env, cp, 0);
 309 }
 310
 311 /* Call this when -classpath is seen on the command line.
 312    This overrides only the $CLASSPATH environment variable.
 313  */
 314 void
 315 jcf_path_classpath_arg (const char *path)
 316 {
 317   free_entry (&classpath_user);
 318   add_path (&classpath_user, path, 0);
 319 }
 320
 321 /* Call this when -bootclasspath is seen on the command line.
 322  */
 323 void
 324 jcf_path_bootclasspath_arg (const char *path)
 325 {
 326   free_entry (&sys_dirs);
 327   add_path (&sys_dirs, path, 1);
 328 }
 329
 330 /* Call this when -extdirs is seen on the command line.
 331  */
 332 void
 333 jcf_path_extdirs_arg (const char *cp)
 334 {
 335   const char *startp, *endp;
 336
 337   free_entry (&extensions);
 338
 339   if (cp)
 340     {
 341       char *buf = alloca (strlen (cp) + 3);
 342       startp = endp = cp;
 343       while (1)
 344         {
 345           if (! *endp || *endp == PATH_SEPARATOR)
 346             {
 347               if (endp == startp)
 348                 return;
 349
 350               strncpy (buf, startp, endp - startp);
 351               buf[endp - startp] = '\0';
 352
 353               {
 354                 DIR *dirp = NULL;
 355                 int dirname_length = strlen (buf);
 356
 357                 dirp = opendir (buf);
 358                 if (dirp == NULL)
 359                   return;
 360
 361                 for (;;)
 362                   {
 363                     struct dirent *direntp = readdir (dirp);
 364
 365                     if (!direntp)
 366                       break;
 367
 368                     if (direntp->d_name[0] != '.')
 369                       {
 370                         char *name = alloca (dirname_length
 371                                              + strlen (direntp->d_name) + 2);
 372                         strcpy (name, buf);
 373                         if (name[dirname_length-1] != DIR_SEPARATOR)
 374                           {
 375                             name[dirname_length] = DIR_SEPARATOR;
 376                             name[dirname_length+1] = 0;
 377                           }
 378                         strcat (name, direntp->d_name);
 379                         add_entry (&extensions, name, 0);
 380                       }
 381                   }
 382               }
 383
 384               if (! *endp)
 385                 break;
 386               ++endp;
 387               startp = endp;
 388             }
 389           else
 390             ++endp;
 391         }
 392     }
 393 }
 394
 395 /* Call this when -I is seen on the command line.  */
 396 void
 397 jcf_path_include_arg (const char *path)
 398 {
 399   add_entry (&include_dirs, path, 0);
 400 }
 401
 402 /* We `seal' the path by linking everything into one big list.  Then
 403    we provide a way to iterate through the sealed list.  If PRINT is
 404    true then we print the final class path to stderr.  */
 405 void
 406 jcf_path_seal (int print)
 407 {
 408   struct entry *secondary;
 409
 410   sealed = include_dirs;
 411   include_dirs = NULL;
 412
 413   if (classpath_user)
 414     {
 415       secondary = classpath_user;
 416       classpath_user = NULL;
 417     }
 418   else
 419     {
 420       if (! classpath_env)
 421         add_entry (&classpath_env, ".", 0);
 422
 423       secondary = classpath_env;
 424       classpath_env = NULL;
 425     }
 426
 427
 428   free_entry (&classpath_user);
 429   free_entry (&classpath_env);
 430
 431   append_entry (&sealed, secondary);
 432   append_entry (&sealed, sys_dirs);
 433   append_entry (&sealed, extensions);
 434   sys_dirs = NULL;
 435   extensions = NULL;
 436
 437   if (print)
 438     {
 439       struct entry *ent;
 440       fprintf (stderr, "Class path starts here:\n");
 441       for (ent = sealed; ent; ent = ent->next)
 442         {
 443           fprintf (stderr, "    %s", ent->name);
 444           if ((ent->flags & FLAG_SYSTEM))
 445             fprintf (stderr, " (system)");
 446           if ((ent->flags & FLAG_ZIP))
 447             fprintf (stderr, " (zip)");
 448           fprintf (stderr, "\n");
 449         }
 450     }
 451 }
 452
 453 void *
 454 jcf_path_start (void)
 455 {
 456   return (void *) sealed;
 457 }
 458
 459 void *
 460 jcf_path_next (void *x)
 461 {
 462   struct entry *ent = (struct entry *) x;
 463   return (void *) ent->next;
 464 }
 465
 466 /* We guarantee that the return path will either be a zip file, or it
 467    will end with a directory separator.  */
 468 char *
 469 jcf_path_name (void *x)
 470 {
 471   struct entry *ent = (struct entry *) x;
 472   return ent->name;
 473 }
 474
 475 int
 476 jcf_path_is_zipfile (void *x)
 477 {
 478   struct entry *ent = (struct entry *) x;
 479   return (ent->flags & FLAG_ZIP);
 480 }
 481
 482 int
 483 jcf_path_is_system (void *x)
 484 {
 485   struct entry *ent = (struct entry *) x;
 486   return (ent->flags & FLAG_SYSTEM);
 487 }
 488
 489 int
 490 jcf_path_max_len (void)
 491 {
 492   return longest_path;
 493 }