gcc/java/jcf-path.c

   1 /* Handle CLASSPATH, -classpath, and path searching.
   2
   3    Copyright (C) 1998, 1999  Free Software Foundation, Inc.
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU CC; see the file COPYING.  If not, write to
  17 the Free Software Foundation, 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.
  19
  20 Java and all Java-based marks are trademarks or registered trademarks
  21 of Sun Microsystems, Inc. in the United States and other countries.
  22 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  23
  24 /* Written by Tom Tromey <tromey@cygnus.com>, October 1998.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28
  29 #include "jcf.h"
  30
  31 /* Some boilerplate that really belongs in a header.  */
  32
  33 #ifndef GET_ENV_PATH_LIST
  34 #define GET_ENV_PATH_LIST(VAR,NAME)     do { (VAR) = getenv (NAME); } while (0)
  35 #endif
  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 \f
  47
  48 /* Possible flag values.  */
  49 #define FLAG_SYSTEM 1
  50 #define FLAG_ZIP    2
  51
  52 /* We keep linked lists of directory names.  A ``directory'' can be
  53    either an ordinary directory or a .zip file.  */
  54 struct entry
  55 {
  56   char *name;
  57   int flags;
  58   struct entry *next;
  59 };
  60
  61 static void free_entry PROTO ((struct entry **));
  62 static void append_entry PROTO ((struct entry **, struct entry *));
  63 static void add_entry PROTO ((struct entry **, const char *, int));
  64 static void add_path PROTO ((struct entry **, const char *, int));
  65
  66 /* We support several different ways to set the class path.
  67
  68    built-in system directory (only libgcj.zip)
  69    CLASSPATH environment variable
  70    -CLASSPATH overrides CLASSPATH
  71    -classpath option - overrides CLASSPATH, -CLASSPATH, and built-in
  72    -I prepends path to list
  73
  74    We implement this by keeping several path lists, and then simply
  75    ignoring the ones which are not relevant.  */
  76
  77 /* This holds all the -I directories.  */
  78 static struct entry *include_dirs;
  79
  80 /* This holds the CLASSPATH environment variable.  */
  81 static struct entry *classpath_env;
  82
  83 /* This holds the -CLASSPATH command-line option.  */
  84 static struct entry *classpath_u;
  85
  86 /* This holds the -classpath command-line option.  */
  87 static struct entry *classpath_l;
  88
  89 /* This holds the default directories.  Some of these will have the
  90    "system" flag set.  */
  91 static struct entry *sys_dirs;
  92
  93 /* This is the sealed list.  It is just a combination of other lists.  */
  94 static struct entry *sealed;
  95
  96 /* We keep track of the longest path we've seen.  */
  97 static int longest_path = 0;
  98
  99 \f
 100
 101 static void
 102 free_entry (entp)
 103      struct entry **entp;
 104 {
 105   struct entry *e, *n;
 106
 107   for (e = *entp; e; e = n)
 108     {
 109       n = e->next;
 110       free (e->name);
 111       free (e);
 112     }
 113   *entp = NULL;
 114 }
 115
 116 static void
 117 append_entry (entp, ent)
 118      struct entry **entp;
 119      struct entry *ent;
 120 {
 121   /* It doesn't matter if this is slow, since it is run only at
 122      startup, and then infrequently.  */
 123   struct entry *e;
 124
 125   /* Find end of list.  */
 126   for (e = *entp; e && e->next; e = e->next)
 127     ;
 128
 129   if (e)
 130     e->next = ent;
 131   else
 132     *entp = ent;
 133 }
 134
 135 static void
 136 add_entry (entp, filename, is_system)
 137      struct entry **entp;
 138      const char *filename;
 139      int is_system;
 140 {
 141   int len;
 142   struct entry *n;
 143
 144   n = (struct entry *) 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.zip 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 = (char *) 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 (entp, cp, is_system)
 184      struct entry **entp;
 185      const char *cp;
 186      int is_system;
 187 {
 188   const char *startp, *endp;
 189
 190   if (cp)
 191     {
 192       char *buf = (char *) alloca (strlen (cp) + 3);
 193       startp = endp = cp;
 194       while (1)
 195         {
 196           if (! *endp || *endp == PATH_SEPARATOR)
 197             {
 198               if (endp == startp)
 199                 {
 200                   buf[0] = '.';
 201                   buf[1] = DIR_SEPARATOR;
 202                   buf[2] = '\0';
 203                 }
 204               else
 205                 {
 206                   strncpy (buf, startp, endp - startp);
 207                   buf[endp - startp] = '\0';
 208                 }
 209               add_entry (entp, buf, is_system);
 210               if (! *endp)
 211                 break;
 212               ++endp;
 213               startp = endp;
 214             }
 215           else
 216             ++endp;
 217         }
 218     }
 219 }
 220
 221 /* Initialize the path module.  */
 222 void
 223 jcf_path_init ()
 224 {
 225   char *cp;
 226
 227   add_entry (&sys_dirs, ".", 0);
 228   add_entry (&sys_dirs, LIBGCJ_ZIP_FILE, 1);
 229
 230   GET_ENV_PATH_LIST (cp, "CLASSPATH");
 231   add_path (&classpath_env, cp, 0);
 232 }
 233
 234 /* Call this when -classpath is seen on the command line.  */
 235 void
 236 jcf_path_classpath_arg (path)
 237      const char *path;
 238 {
 239   free_entry (&classpath_l);
 240   add_path (&classpath_l, path, 0);
 241 }
 242
 243 /* Call this when -CLASSPATH is seen on the command line.  */
 244 void
 245 jcf_path_CLASSPATH_arg (path)
 246      const char *path;
 247 {
 248   free_entry (&classpath_u);
 249   add_path (&classpath_u, path, 0);
 250 }
 251
 252 /* Call this when -I is seen on the command line.  */
 253 void
 254 jcf_path_include_arg (path)
 255      const char *path;
 256 {
 257   add_entry (&include_dirs, path, 0);
 258 }
 259
 260 /* We `seal' the path by linking everything into one big list.  Then
 261    we provide a way to iterate through the sealed list.  */
 262 void
 263 jcf_path_seal ()
 264 {
 265   int do_system = 1;
 266   struct entry *secondary;
 267
 268   sealed = include_dirs;
 269   include_dirs = NULL;
 270
 271   if (classpath_l)
 272     {
 273       secondary = classpath_l;
 274       classpath_l = NULL;
 275       do_system = 0;
 276     }
 277   else if (classpath_u)
 278     {
 279       secondary = classpath_u;
 280       classpath_u = NULL;
 281     }
 282   else
 283     {
 284       secondary = classpath_env;
 285       classpath_env = NULL;
 286     }
 287
 288   free_entry (&classpath_l);
 289   free_entry (&classpath_u);
 290   free_entry (&classpath_env);
 291
 292   append_entry (&sealed, secondary);
 293
 294   if (do_system)
 295     {
 296       append_entry (&sealed, sys_dirs);
 297       sys_dirs = NULL;
 298     }
 299   else
 300     free_entry (&sys_dirs);
 301 }
 302
 303 void *
 304 jcf_path_start ()
 305 {
 306   return (void *) sealed;
 307 }
 308
 309 void *
 310 jcf_path_next (x)
 311      void *x;
 312 {
 313   struct entry *ent = (struct entry *) x;
 314   return (void *) ent->next;
 315 }
 316
 317 /* We guarantee that the return path will either be a zip file, or it
 318    will end with a directory separator.  */
 319 char *
 320 jcf_path_name (x)
 321      void *x;
 322 {
 323   struct entry *ent = (struct entry *) x;
 324   return ent->name;
 325 }
 326
 327 int
 328 jcf_path_is_zipfile (x)
 329      void *x;
 330 {
 331   struct entry *ent = (struct entry *) x;
 332   return (ent->flags & FLAG_ZIP);
 333 }
 334
 335 int
 336 jcf_path_is_system (x)
 337      void *x;
 338 {
 339   struct entry *ent = (struct entry *) x;
 340   return (ent->flags & FLAG_SYSTEM);
 341 }
 342
 343 int
 344 jcf_path_max_len ()
 345 {
 346   return longest_path;
 347 }