[thirdparty/bash.git] / pathexp.c

/* pathexp.c -- The shell interface to the globbing library. */

/* Copyright (C) 1995 Free Software Foundation, Inc.

   This file is part of GNU Bash, the Bourne Again SHell.

   Bash 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.

   Bash 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 Bash; see the file COPYING.  If not, write to the Free Software
   Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */

#include "config.h"

#include "bashtypes.h"
#include <stdio.h>

#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif

#include "bashansi.h"

#include "shell.h"
#include "pathexp.h"
#include "flags.h"

#include <glob/strmatch.h>

#if defined (USE_POSIX_GLOB_LIBRARY)
#  include <glob.h>
typedef int posix_glob_errfunc_t __P((const char *, int));
#else
#  include <glob/glob.h>
#endif

/* Control whether * matches .files in globbing. */
int glob_dot_filenames;

/* Control whether the extended globbing features are enabled. */
int extended_glob = 0;

/* Return nonzero if STRING has any unquoted special globbing chars in it.  */
int
unquoted_glob_pattern_p (string)
     register char *string;
{
  register int c;
  int open;

  open = 0;
  while (c = *string++)
    {
      switch (c)
	{
	case '?':
	case '*':
	  return (1);

	case '[':
	  open++;
	  continue;

	case ']':
	  if (open)
	    return (1);
	  continue;

	case '+':
	case '@':
	case '!':
	  if (*string == '(')	/*)*/
	    return (1);
	  continue;

	case CTLESC:
	case '\\':
	  if (*string++ == '\0')
	    return (0);
	}
    }
  return (0);
}

/* PATHNAME can contain characters prefixed by CTLESC; this indicates
   that the character is to be quoted.  We quote it here in the style
   that the glob library recognizes.  If flags includes QGLOB_CVTNULL,
   we change quoted null strings (pathname[0] == CTLNUL) into empty
   strings (pathname[0] == 0).  If this is called after quote removal
   is performed, (flags & QGLOB_CVTNULL) should be 0; if called when quote
   removal has not been done (for example, before attempting to match a
   pattern while executing a case statement), flags should include
   QGLOB_CVTNULL.  If flags includes QGLOB_FILENAME, appropriate quoting
   to match a filename should be performed. */
char *
quote_string_for_globbing (pathname, qflags)
     const char *pathname;
     int qflags;
{
  char *temp;
  register int i, j;

  temp = (char *)xmalloc (strlen (pathname) + 1);

  if ((qflags & QGLOB_CVTNULL) && QUOTED_NULL (pathname))
    {
      temp[0] = '\0';
      return temp;
    }

  for (i = j = 0; pathname[i]; i++)
    {
      if (pathname[i] == CTLESC)
	{
	  if ((qflags & QGLOB_FILENAME) && pathname[i+1] == '/')
	    continue;
	  temp[j++] = '\\';
	}
      else
	temp[j++] = pathname[i];
    }
  temp[j] = '\0';

  return (temp);
}

char *
quote_globbing_chars (string)
     char *string;
{
  char *temp, *s, *t;

  temp = (char *)xmalloc (strlen (string) * 2 + 1);
  for (t = temp, s = string; *s; )
    {
      switch (*s)
	{
	case '*':
	case '[':
	case ']':
	case '?':
	case '\\':
	  *t++ = '\\';
	  break;
	case '+':
	case '@':
	case '!':
	  if (s[1] == '(')	/*(*/
	    *t++ = '\\';
	  break;
	}
      *t++ = *s++;
    }
  *t = '\0';
  return temp;
}

/* Call the glob library to do globbing on PATHNAME. */
char **
shell_glob_filename (pathname)
     const char *pathname;
{
#if defined (USE_POSIX_GLOB_LIBRARY)
  register int i;
  char *temp, **results;
  glob_t filenames;
  int glob_flags;

  temp = quote_string_for_globbing (pathname, QGLOB_FILENAME);

  filenames.gl_offs = 0;

#  if defined (GLOB_PERIOD)
  glob_flags = glob_dot_filenames ? GLOB_PERIOD : 0;
#  else
  glob_flags = 0;
#  endif /* !GLOB_PERIOD */

  glob_flags |= (GLOB_ERR | GLOB_DOOFFS);

  i = glob (temp, glob_flags, (posix_glob_errfunc_t *)NULL, &filenames);

  free (temp);

  if (i == GLOB_NOSPACE || i == GLOB_ABORTED)
    return ((char **)NULL);
  else if (i == GLOB_NOMATCH)
    filenames.gl_pathv = (char **)NULL;
  else if (i != 0)		/* other error codes not in POSIX.2 */
    filenames.gl_pathv = (char **)NULL;

  results = filenames.gl_pathv;

  if (results && ((GLOB_FAILED (results)) == 0))
    {
      if (should_ignore_glob_matches ())
	ignore_glob_matches (results);
      if (results && results[0])
	sort_char_array (results);
      else
	{
	  FREE (results);
	  results = (char **)NULL;
	}
    }

  return (results);

#else /* !USE_POSIX_GLOB_LIBRARY */

  char *temp, **results;

  noglob_dot_filenames = glob_dot_filenames == 0;

  temp = quote_string_for_globbing (pathname, QGLOB_FILENAME);

  results = glob_filename (temp);
  free (temp);

  if (results && ((GLOB_FAILED (results)) == 0))
    {
      if (should_ignore_glob_matches ())
	ignore_glob_matches (results);
      if (results && results[0])
	sort_char_array (results);
      else
	{
	  FREE (results);
	  results = (char **)&glob_error_return;
	}
    }

  return (results);
#endif /* !USE_POSIX_GLOB_LIBRARY */
}

/* Stuff for GLOBIGNORE. */

static struct ignorevar globignore =
{
  "GLOBIGNORE",
  (struct ign *)0,
  0,
  (char *)0,
  (sh_iv_item_func_t *)0,
};

/* Set up to ignore some glob matches because the value of GLOBIGNORE
   has changed.  If GLOBIGNORE is being unset, we also need to disable
   the globbing of filenames beginning with a `.'. */
void
setup_glob_ignore (name)
     char *name;
{
  char *v;

  v = get_string_value (name);
  setup_ignore_patterns (&globignore);

  if (globignore.num_ignores)
    glob_dot_filenames = 1;
  else if (v == 0)
    glob_dot_filenames = 0;
}

int
should_ignore_glob_matches ()
{
  return globignore.num_ignores;
}

/* Return 0 if NAME matches a pattern in the globignore.ignores list. */
static int
glob_name_is_acceptable (name)
     const char *name;
{
  struct ign *p;
  int flags;

  /* . and .. are never matched */
  if (name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')))
    return (0);

  flags = FNM_PATHNAME | FNMATCH_EXTFLAG;
  for (p = globignore.ignores; p->val; p++)
    {
      if (strmatch (p->val, (char *)name, flags) != FNM_NOMATCH)
	return (0);
    }
  return (1);
}

/* Internal function to test whether filenames in NAMES should be
   ignored.  NAME_FUNC is a pointer to a function to call with each
   name.  It returns non-zero if the name is acceptable to the particular
   ignore function which called _ignore_names; zero if the name should
   be removed from NAMES. */

static void
ignore_globbed_names (names, name_func)
     char **names;
     sh_ignore_func_t *name_func;
{
  char **newnames;
  int n, i;

  for (i = 0; names[i]; i++)
    ;
  newnames = alloc_array (i + 1);

  for (n = i = 0; names[i]; i++)
    {
      if ((*name_func) (names[i]))
	newnames[n++] = names[i];
      else
	free (names[i]);
    }

  newnames[n] = (char *)NULL;

  if (n == 0)
    {
      names[0] = (char *)NULL;
      free (newnames);
      return;
    }

  /* Copy the acceptable names from NEWNAMES back to NAMES and set the
     new array end. */
  for (n = 0; newnames[n]; n++)
    names[n] = newnames[n];
  names[n] = (char *)NULL;
  free (newnames);
}

void
ignore_glob_matches (names)
     char **names;
{
  if (globignore.num_ignores == 0)
    return;

  ignore_globbed_names (names, glob_name_is_acceptable);
}

void
setup_ignore_patterns (ivp)
     struct ignorevar *ivp;
{
  int numitems, maxitems, ptr;
  char *colon_bit, *this_ignoreval;
  struct ign *p;

  this_ignoreval = get_string_value (ivp->varname);

  /* If nothing has changed then just exit now. */
  if ((this_ignoreval && ivp->last_ignoreval && STREQ (this_ignoreval, ivp->last_ignoreval)) ||
      (!this_ignoreval && !ivp->last_ignoreval))
    return;

  /* Oops.  The ignore variable has changed.  Re-parse it. */
  ivp->num_ignores = 0;

  if (ivp->ignores)
    {
      for (p = ivp->ignores; p->val; p++)
	free(p->val);
      free (ivp->ignores);
      ivp->ignores = (struct ign *)NULL;
    }

  if (ivp->last_ignoreval)
    {
      free (ivp->last_ignoreval);
      ivp->last_ignoreval = (char *)NULL;
    }

  if (this_ignoreval == 0 || *this_ignoreval == '\0')
    return;

  ivp->last_ignoreval = savestring (this_ignoreval);

  numitems = maxitems = ptr = 0;

  while (colon_bit = extract_colon_unit (this_ignoreval, &ptr))
    {
      if (numitems + 1 >= maxitems)
	{
	  maxitems += 10;
	  ivp->ignores = (struct ign *)xrealloc (ivp->ignores, maxitems * sizeof (struct ign));
	}
      ivp->ignores[numitems].val = colon_bit;
      ivp->ignores[numitems].len = strlen (colon_bit);
      ivp->ignores[numitems].flags = 0;
      if (ivp->item_func)
	(*ivp->item_func) (&ivp->ignores[numitems]);
      numitems++;
    }
  ivp->ignores[numitems].val = (char *)NULL;
  ivp->num_ignores = numitems;
}
Commit	Line	Data
ccc6cda3 JA	1	/* pathexp.c -- The shell interface to the globbing library. */
	2
	3	/* Copyright (C) 1995 Free Software Foundation, Inc.
	4
	5	This file is part of GNU Bash, the Bourne Again SHell.
	6
	7	Bash is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
	9	Software Foundation; either version 2, or (at your option) any later
	10	version.
	11
	12	Bash is distributed in the hope that it will be useful, but WITHOUT ANY
	13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	for more details.
	16
	17	You should have received a copy of the GNU General Public License along
	18	with Bash; see the file COPYING. If not, write to the Free Software
bb70624e	19	Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
ccc6cda3 JA	20
	21	#include "config.h"
	22
	23	#include "bashtypes.h"
	24	#include <stdio.h>
	25
	26	#if defined (HAVE_UNISTD_H)
	27	# include <unistd.h>
	28	#endif
	29
	30	#include "bashansi.h"
	31
	32	#include "shell.h"
	33	#include "pathexp.h"
	34	#include "flags.h"
	35
f73dda09	36	#include <glob/strmatch.h>
b72432fd JA	37
	38	#if defined (USE_POSIX_GLOB_LIBRARY)
	39	# include <glob.h>
f73dda09	40	typedef int posix_glob_errfunc_t __P((const char *, int));
b72432fd JA	41	#else
	42	# include <glob/glob.h>
	43	#endif
ccc6cda3 JA	44
	45	/* Control whether * matches .files in globbing. */
	46	int glob_dot_filenames;
	47
cce855bc JA	48	/* Control whether the extended globbing features are enabled. */
	49	int extended_glob = 0;
	50
ccc6cda3 JA	51	/* Return nonzero if STRING has any unquoted special globbing chars in it. */
	52	int
	53	unquoted_glob_pattern_p (string)
	54	register char *string;
	55	{
	56	register int c;
	57	int open;
	58
	59	open = 0;
	60	while (c = *string++)
	61	{
	62	switch (c)
	63	{
	64	case '?':
	65	case '*':
	66	return (1);
	67
	68	case '[':
	69	open++;
	70	continue;
	71
	72	case ']':
	73	if (open)
	74	return (1);
	75	continue;
	76
cce855bc JA	77	case '+':
	78	case '@':
	79	case '!':
	80	if (string == '(') /)*/
	81	return (1);
	82	continue;
	83
ccc6cda3 JA	84	case CTLESC:
	85	case '\\':
	86	if (*string++ == '\0')
	87	return (0);
	88	}
	89	}
	90	return (0);
	91	}
	92
	93	/* PATHNAME can contain characters prefixed by CTLESC; this indicates
	94	that the character is to be quoted. We quote it here in the style
cce855bc	95	that the glob library recognizes. If flags includes QGLOB_CVTNULL,
ccc6cda3 JA	96	we change quoted null strings (pathname[0] == CTLNUL) into empty
ccc6cda3 JA	97	strings (pathname[0] == 0). If this is called after quote removal
cce855bc	98	is performed, (flags & QGLOB_CVTNULL) should be 0; if called when quote
ccc6cda3	99	removal has not been done (for example, before attempting to match a
cce855bc JA	100	pattern while executing a case statement), flags should include
	101	QGLOB_CVTNULL. If flags includes QGLOB_FILENAME, appropriate quoting
	102	to match a filename should be performed. */
ccc6cda3	103	char *
cce855bc	104	quote_string_for_globbing (pathname, qflags)
28ef6c31	105	const char *pathname;
cce855bc	106	int qflags;
ccc6cda3 JA	107	{
ccc6cda3 JA	108	char *temp;
cce855bc	109	register int i, j;
ccc6cda3	110
f73dda09	111	temp = (char *)xmalloc (strlen (pathname) + 1);
ccc6cda3	112
cce855bc	113	if ((qflags & QGLOB_CVTNULL) && QUOTED_NULL (pathname))
ccc6cda3 JA	114	{
	115	temp[0] = '\0';
	116	return temp;
	117	}
	118
cce855bc	119	for (i = j = 0; pathname[i]; i++)
ccc6cda3	120	{
cce855bc	121	if (pathname[i] == CTLESC)
28ef6c31 JA	122	{
	123	if ((qflags & QGLOB_FILENAME) && pathname[i+1] == '/')
	124	continue;
cce855bc	125	temp[j++] = '\\';
28ef6c31	126	}
cce855bc	127	else
28ef6c31	128	temp[j++] = pathname[i];
ccc6cda3	129	}
cce855bc	130	temp[j] = '\0';
ccc6cda3 JA	131
	132	return (temp);
	133	}
	134
	135	char *
	136	quote_globbing_chars (string)
	137	char *string;
	138	{
	139	char temp, s, *t;
	140
f73dda09	141	temp = (char )xmalloc (strlen (string) 2 + 1);
ccc6cda3 JA	142	for (t = temp, s = string; *s; )
	143	{
	144	switch (*s)
28ef6c31 JA	145	{
	146	case '*':
	147	case '[':
	148	case ']':
	149	case '?':
	150	case '\\':
	151	*t++ = '\\';
	152	break;
	153	case '+':
	154	case '@':
	155	case '!':
cce855bc JA	156	if (s[1] == '(') /(/
	157	*t++ = '\\';
	158	break;
28ef6c31	159	}
ccc6cda3 JA	160	t++ = s++;
	161	}
	162	*t = '\0';
	163	return temp;
	164	}
	165
	166	/* Call the glob library to do globbing on PATHNAME. */
	167	char **
	168	shell_glob_filename (pathname)
28ef6c31	169	const char *pathname;
ccc6cda3 JA	170	{
	171	#if defined (USE_POSIX_GLOB_LIBRARY)
	172	register int i;
28ef6c31	173	char temp, *results;
ccc6cda3 JA	174	glob_t filenames;
	175	int glob_flags;
	176
cce855bc	177	temp = quote_string_for_globbing (pathname, QGLOB_FILENAME);
ccc6cda3 JA	178
	179	filenames.gl_offs = 0;
	180
b72432fd	181	# if defined (GLOB_PERIOD)
ccc6cda3	182	glob_flags = glob_dot_filenames ? GLOB_PERIOD : 0;
b72432fd JA	183	# else
	184	glob_flags = 0;
	185	# endif /* !GLOB_PERIOD */
	186
ccc6cda3 JA	187	glob_flags \|= (GLOB_ERR \| GLOB_DOOFFS);
ccc6cda3 JA	188
f73dda09	189	i = glob (temp, glob_flags, (posix_glob_errfunc_t *)NULL, &filenames);
ccc6cda3 JA	190
	191	free (temp);
	192
28ef6c31	193	if (i == GLOB_NOSPACE \|\| i == GLOB_ABORTED)
ccc6cda3	194	return ((char **)NULL);
b72432fd JA	195	else if (i == GLOB_NOMATCH)
	196	filenames.gl_pathv = (char **)NULL;
	197	else if (i != 0) /* other error codes not in POSIX.2 */
cce855bc	198	filenames.gl_pathv = (char **)NULL;
ccc6cda3	199
bb70624e JA	200	results = filenames.gl_pathv;
	201
	202	if (results && ((GLOB_FAILED (results)) == 0))
	203	{
	204	if (should_ignore_glob_matches ())
	205	ignore_glob_matches (results);
	206	if (results && results[0])
	207	sort_char_array (results);
	208	else
	209	{
	210	FREE (results);
	211	results = (char **)NULL;
	212	}
	213	}
	214
	215	return (results);
ccc6cda3 JA	216
	217	#else /* !USE_POSIX_GLOB_LIBRARY */
	218
	219	char temp, *results;
	220
	221	noglob_dot_filenames = glob_dot_filenames == 0;
	222
cce855bc	223	temp = quote_string_for_globbing (pathname, QGLOB_FILENAME);
ccc6cda3 JA	224
	225	results = glob_filename (temp);
	226	free (temp);
	227
	228	if (results && ((GLOB_FAILED (results)) == 0))
	229	{
	230	if (should_ignore_glob_matches ())
	231	ignore_glob_matches (results);
	232	if (results && results[0])
	233	sort_char_array (results);
	234	else
	235	{
	236	FREE (results);
	237	results = (char **)&glob_error_return;
	238	}
	239	}
	240
	241	return (results);
	242	#endif /* !USE_POSIX_GLOB_LIBRARY */
	243	}
	244
	245	/* Stuff for GLOBIGNORE. */
	246
	247	static struct ignorevar globignore =
	248	{
	249	"GLOBIGNORE",
	250	(struct ign *)0,
	251	0,
	252	(char *)0,
f73dda09	253	(sh_iv_item_func_t *)0,
ccc6cda3 JA	254	};
	255
	256	/* Set up to ignore some glob matches because the value of GLOBIGNORE
	257	has changed. If GLOBIGNORE is being unset, we also need to disable
	258	the globbing of filenames beginning with a `.'. */
	259	void
	260	setup_glob_ignore (name)
	261	char *name;
	262	{
	263	char *v;
	264
	265	v = get_string_value (name);
	266	setup_ignore_patterns (&globignore);
	267
	268	if (globignore.num_ignores)
	269	glob_dot_filenames = 1;
	270	else if (v == 0)
	271	glob_dot_filenames = 0;
	272	}
	273
	274	int
	275	should_ignore_glob_matches ()
	276	{
	277	return globignore.num_ignores;
	278	}
	279
	280	/* Return 0 if NAME matches a pattern in the globignore.ignores list. */
	281	static int
	282	glob_name_is_acceptable (name)
f73dda09	283	const char *name;
ccc6cda3 JA	284	{
ccc6cda3 JA	285	struct ign *p;
cce855bc	286	int flags;
ccc6cda3 JA	287
	288	/* . and .. are never matched */
	289	if (name[0] == '.' && (name[1] == '\0' \|\| (name[1] == '.' && name[2] == '\0')))
	290	return (0);
	291
cce855bc	292	flags = FNM_PATHNAME \| FNMATCH_EXTFLAG;
ccc6cda3 JA	293	for (p = globignore.ignores; p->val; p++)
ccc6cda3 JA	294	{
f73dda09	295	if (strmatch (p->val, (char *)name, flags) != FNM_NOMATCH)
28ef6c31	296	return (0);
ccc6cda3 JA	297	}
	298	return (1);
	299	}
	300
	301	/* Internal function to test whether filenames in NAMES should be
	302	ignored. NAME_FUNC is a pointer to a function to call with each
	303	name. It returns non-zero if the name is acceptable to the particular
	304	ignore function which called _ignore_names; zero if the name should
	305	be removed from NAMES. */
	306
	307	static void
	308	ignore_globbed_names (names, name_func)
	309	char **names;
f73dda09	310	sh_ignore_func_t *name_func;
ccc6cda3 JA	311	{
	312	char **newnames;
	313	int n, i;
	314
	315	for (i = 0; names[i]; i++)
	316	;
bb70624e	317	newnames = alloc_array (i + 1);
ccc6cda3 JA	318
	319	for (n = i = 0; names[i]; i++)
	320	{
	321	if ((*name_func) (names[i]))
28ef6c31	322	newnames[n++] = names[i];
ccc6cda3 JA	323	else
	324	free (names[i]);
	325	}
	326
	327	newnames[n] = (char *)NULL;
	328
	329	if (n == 0)
	330	{
	331	names[0] = (char *)NULL;
	332	free (newnames);
	333	return;
	334	}
	335
	336	/* Copy the acceptable names from NEWNAMES back to NAMES and set the
	337	new array end. */
	338	for (n = 0; newnames[n]; n++)
	339	names[n] = newnames[n];
	340	names[n] = (char *)NULL;
d166f048	341	free (newnames);
ccc6cda3 JA	342	}
	343
	344	void
	345	ignore_glob_matches (names)
	346	char **names;
	347	{
	348	if (globignore.num_ignores == 0)
	349	return;
	350
	351	ignore_globbed_names (names, glob_name_is_acceptable);
	352	}
	353
	354	void
	355	setup_ignore_patterns (ivp)
	356	struct ignorevar *ivp;
	357	{
	358	int numitems, maxitems, ptr;
	359	char colon_bit, this_ignoreval;
	360	struct ign *p;
	361
	362	this_ignoreval = get_string_value (ivp->varname);
	363
	364	/* If nothing has changed then just exit now. */
	365	if ((this_ignoreval && ivp->last_ignoreval && STREQ (this_ignoreval, ivp->last_ignoreval)) \|\|
	366	(!this_ignoreval && !ivp->last_ignoreval))
	367	return;
	368
	369	/* Oops. The ignore variable has changed. Re-parse it. */
	370	ivp->num_ignores = 0;
	371
	372	if (ivp->ignores)
	373	{
	374	for (p = ivp->ignores; p->val; p++)
	375	free(p->val);
	376	free (ivp->ignores);
	377	ivp->ignores = (struct ign *)NULL;
	378	}
	379
	380	if (ivp->last_ignoreval)
	381	{
	382	free (ivp->last_ignoreval);
	383	ivp->last_ignoreval = (char *)NULL;
	384	}
	385
	386	if (this_ignoreval == 0 \|\| *this_ignoreval == '\0')
	387	return;
	388
	389	ivp->last_ignoreval = savestring (this_ignoreval);
	390
	391	numitems = maxitems = ptr = 0;
	392
	393	while (colon_bit = extract_colon_unit (this_ignoreval, &ptr))
	394	{
	395	if (numitems + 1 >= maxitems)
	396	{
	397	maxitems += 10;
	398	ivp->ignores = (struct ign )xrealloc (ivp->ignores, maxitems sizeof (struct ign));
	399	}
	400	ivp->ignores[numitems].val = colon_bit;
	401	ivp->ignores[numitems].len = strlen (colon_bit);
	402	ivp->ignores[numitems].flags = 0;
	403	if (ivp->item_func)
28ef6c31	404	(*ivp->item_func) (&ivp->ignores[numitems]);
ccc6cda3 JA	405	numitems++;
	406	}
	407	ivp->ignores[numitems].val = (char *)NULL;
	408	ivp->num_ignores = numitems;
	409	}