/* Handle CLASSPATH, -classpath, and path searching.   Copyright (C) 1998, 1999  Free Software Foundation, Inc.This program is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation; either version 2, or (at your option)any later version.This program is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See theGNU General Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU CC; see the file COPYING.  If not, write tothe Free Software Foundation, 59 Temple Place - Suite 330,Boston, MA 02111-1307, USA.  Java and all Java-based marks are trademarks or registered trademarksof Sun Microsystems, Inc. in the United States and other countries.The Free Software Foundation is independent of Sun Microsystems, Inc.  *//* Written by Tom Tromey <tromey@cygnus.com>, October 1998.  */#include "config.h"#include "system.h"#include "jcf.h"/* Some boilerplate that really belongs in a header.  */#ifndef GET_ENV_PATH_LIST#define GET_ENV_PATH_LIST(VAR,NAME)	do { (VAR) = getenv (NAME); } while (0)#endif/* By default, colon separates directories in a path.  */#ifndef PATH_SEPARATOR#define PATH_SEPARATOR ':'#endif#ifndef DIR_SEPARATOR#define DIR_SEPARATOR '/'#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;};/* We support several different ways to set the class path.   built-in system directory (only libgcj.zip)   CLASSPATH environment variable   -CLASSPATH overrides CLASSPATH   -classpath option - overrides CLASSPATH, -CLASSPATH, and 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_u;/* This holds the -classpath command-line option.  */static struct entry *classpath_l;/* This holds the default directories.  Some of these will have the   "system" flag set.  */static struct entry *sys_dirs;/* 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 voidfree_entry (entp)     struct entry **entp;{  struct entry *e, *n;  for (e = *entp; e; e = n)    {      n = e->next;      free (e->name);      free (e);    }  *entp = NULL;}static voidappend_entry (entp, ent)     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 voidadd_entry (entp, filename, is_system)     struct entry **entp;     char *filename;     int is_system;{  int len;  struct entry *n;  n = (struct entry *) ALLOC (sizeof (struct entry));  n->flags = is_system ? FLAG_SYSTEM : 0;  n->next = NULL;  len = strlen (filename);  if (len > 4 && (strcmp (filename + len - 4, ".zip") == 0		  || strcmp (filename + len - 4, ".jar") == 0))    {      n->flags |= FLAG_ZIP;      /* If the user uses -classpath then he'll have to include	 libgcj.zip 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 (! strcmp (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 (filename[len - 1] != '/' && filename[len - 1] != DIR_SEPARATOR)    {      char *f2 = (char *) alloca (len + 2);      strcpy (f2, filename);      f2[len] = DIR_SEPARATOR;      f2[len + 1] = '\0';      n->name = strdup (f2);      ++len;    }  else    n->name = strdup (filename);  if (len > longest_path)    longest_path = len;  append_entry (entp, n);}static voidadd_path (entp, cp, is_system)     struct entry **entp;     char *cp;     int is_system;{  char *startp, *endp;  if (cp)    {      char *buf = (char *) 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;	}    }}/* Initialize the path module.  */voidjcf_path_init (){  char *cp;  add_entry (&sys_dirs, ".", 0);  add_entry (&sys_dirs, LIBGCJ_ZIP_FILE, 1);  GET_ENV_PATH_LIST (cp, "CLASSPATH");  add_path (&classpath_env, cp, 0);}/* Call this when -classpath is seen on the command line.  */voidjcf_path_classpath_arg (path)     char *path;{  free_entry (&classpath_l);  add_path (&classpath_l, path, 0);}/* Call this when -CLASSPATH is seen on the command line.  */voidjcf_path_CLASSPATH_arg (path)     char *path;{  free_entry (&classpath_u);  add_path (&classpath_u, path, 0);}/* Call this when -I is seen on the command line.  */voidjcf_path_include_arg (path)     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.  */voidjcf_path_seal (){  int do_system = 1;  struct entry *secondary;  sealed = include_dirs;  include_dirs = NULL;  if (classpath_l)    {      secondary = classpath_l;      classpath_l = NULL;      do_system = 0;    }  else if (classpath_u)    {      secondary = classpath_u;      classpath_u = NULL;    }  else    {      secondary = classpath_env;      classpath_env = NULL;    }  free_entry (&classpath_l);  free_entry (&classpath_u);  free_entry (&classpath_env);  append_entry (&sealed, secondary);  if (do_system)    {      append_entry (&sealed, sys_dirs);      sys_dirs = NULL;    }  else    free_entry (&sys_dirs);}void *jcf_path_start (){  return (void *) sealed;}void *jcf_path_next (x)     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 (x)     void *x;{  struct entry *ent = (struct entry *) x;  return ent->name;}intjcf_path_is_zipfile (x)     void *x;{  struct entry *ent = (struct entry *) x;  return (ent->flags & FLAG_ZIP);}intjcf_path_is_system (x)     void *x;{  struct entry *ent = (struct entry *) x;  return (ent->flags & FLAG_SYSTEM);}intjcf_path_max_len (){  return longest_path;}