Import the latest version of the 44BSD C-shell -- tcsh-6.09.

1 files changed, 723 insertions, 0 deletions

diff --git a/contrib/tcsh/glob.c b/contrib/tcsh/glob.c
new file mode 100644
index 0000000..01dee4d
--- /dev/null
+++ b/contrib/tcsh/glob.c
@@ -0,0 +1,723 @@
+/*
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)glob.c	5.12 (Berkeley) 6/24/91";
+#endif /* LIBC_SCCS and not lint */
+/*
+ * Glob: the interface is a superset of the one defined in POSIX 1003.2,
+ * draft 9.
+ *
+ * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
+ *
+ * Optional extra services, controlled by flags not defined by POSIX:
+ *
+ * GLOB_QUOTE:
+ *	Escaping convention: \ inhibits any special meaning the following
+ *	character might have (except \ at end of string is retained).
+ * GLOB_MAGCHAR:
+ *	Set in gl_flags if pattern contained a globbing character.
+ * GLOB_ALTNOT:
+ *	Use ^ instead of ! for "not".
+ * gl_matchc:
+ *	Number of matches in the current invocation of glob.
+ */
+
+#ifdef notdef
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <ctype.h>
+typedef void * ptr_t;
+#endif
+#ifdef WINNT
+	#pragma warning(disable:4244)
+#endif /* WINNT */
+
+#define Char __Char
+#include "sh.h"
+#undef Char
+#undef QUOTE
+#undef TILDE
+#undef META
+#undef CHAR
+#undef ismeta
+#undef Strchr
+
+#include "glob.h"
+
+#ifndef S_ISDIR
+#define S_ISDIR(a)	(((a) & S_IFMT) == S_IFDIR)
+#endif
+
+#if !defined(S_ISLNK) && defined(S_IFLNK)
+#define S_ISLNK(a)	(((a) & S_IFMT) == S_IFLNK)
+#endif
+
+#if !defined(S_ISLNK) && !defined(lstat)
+#define lstat stat
+#endif
+
+typedef unsigned short Char;
+
+static	int	 glob1 		__P((Char *, glob_t *, int));
+static	int	 glob2		__P((Char *, Char *, Char *, glob_t *, int));
+static	int	 glob3		__P((Char *, Char *, Char *, Char *,
+				     glob_t *, int));
+static	int	 globextend	__P((Char *, glob_t *));
+static	int	 match		__P((Char *, Char *, Char *, int));
+#ifndef __clipper__
+static	int	 compare	__P((const ptr_t, const ptr_t));
+#endif
+static 	DIR	*Opendir	__P((Char *));
+#ifdef S_IFLNK
+static	int	 Lstat		__P((Char *, struct stat *));
+#endif
+static	int	 Stat		__P((Char *, struct stat *sb));
+static 	Char 	*Strchr		__P((Char *, int));
+#ifdef DEBUG
+static	void	 qprintf	__P((Char *));
+#endif
+
+#define	DOLLAR		'$'
+#define	DOT		'.'
+#define	EOS		'\0'
+#define	LBRACKET	'['
+#define	NOT		'!'
+#define ALTNOT		'^'
+#define	QUESTION	'?'
+#define	QUOTE		'\\'
+#define	RANGE		'-'
+#define	RBRACKET	']'
+#define	SEP		'/'
+#define	STAR		'*'
+#define	TILDE		'~'
+#define	UNDERSCORE	'_'
+
+#define	M_META		0x8000
+#define M_PROTECT	0x4000
+#define	M_MASK		0xffff
+#define	M_ASCII		0x00ff
+
+#define	CHAR(c)		((c)&M_ASCII)
+#define	META(c)		((c)|M_META)
+#define	M_ALL		META('*')
+#define	M_END		META(']')
+#define	M_NOT		META('!')
+#define	M_ALTNOT	META('^')
+#define	M_ONE		META('?')
+#define	M_RNG		META('-')
+#define	M_SET		META('[')
+#define	ismeta(c)	(((c)&M_META) != 0)
+
+#ifndef BUFSIZE
+#define GLOBBUFLEN	MAXPATHLEN
+#else
+#define GLOBBUFLEN	BUFSIZE
+#endif
+
+int
+globcharcoll(c1, c2)
+    int c1, c2;
+{
+#if defined(NLS) && defined(LC_COLLATE) && !defined(NOSTRCOLL)
+    char s1[2], s2[2];
+
+    if (c1 == c2)
+	return (0);
+    s1[0] = c1;
+    s2[0] = c2;
+    s1[1] = s2[1] = '\0';
+    return strcoll(s1, s2);
+#else
+    return (c1 - c2);
+#endif
+}
+
+/*
+ * Need to dodge two kernel bugs:
+ * opendir("") != opendir(".")
+ * NAMEI_BUG: on plain files trailing slashes are ignored in some kernels.
+ *            POSIX specifies that they should be ignored in directories.
+ */
+
+static DIR *
+Opendir(str)
+    register Char *str;
+{
+    char    buf[GLOBBUFLEN];
+    register char *dc = buf;
+#if defined(hpux) || defined(__hpux)
+    struct stat st;
+#endif
+
+    if (!*str)
+	return (opendir("."));
+    while ((*dc++ = *str++) != '\0')
+	continue;
+#if defined(hpux) || defined(__hpux)
+    /*
+     * Opendir on some device files hangs, so avoid it
+     */
+    if (stat(buf, &st) == -1 || !S_ISDIR(st.st_mode))
+	return NULL;
+#endif
+    return (opendir(buf));
+}
+
+#ifdef S_IFLNK
+static int
+Lstat(fn, sb)
+    register Char *fn;
+    struct stat *sb;
+{
+    char    buf[GLOBBUFLEN];
+    register char *dc = buf;
+
+    while ((*dc++ = *fn++) != '\0')
+	continue;
+# ifdef NAMEI_BUG
+    {
+	int     st;
+
+	st = lstat(buf, sb);
+	if (*buf)
+	    dc--;
+	return (*--dc == '/' && !S_ISDIR(sb->st_mode) ? -1 : st);
+    }
+# else
+    return (lstat(buf, sb));
+# endif	/* NAMEI_BUG */
+}
+#else
+#define Lstat Stat
+#endif /* S_IFLNK */
+
+static int
+Stat(fn, sb)
+    register Char *fn;
+    struct stat *sb;
+{
+    char    buf[GLOBBUFLEN];
+    register char *dc = buf;
+
+    while ((*dc++ = *fn++) != '\0')
+	continue;
+#ifdef NAMEI_BUG
+    {
+	int     st;
+
+	st = stat(buf, sb);
+	if (*buf)
+	    dc--;
+	return (*--dc == '/' && !S_ISDIR(sb->st_mode) ? -1 : st);
+    }
+#else
+    return (stat(buf, sb));
+#endif /* NAMEI_BUG */
+}
+
+static Char *
+Strchr(str, ch)
+    Char *str;
+    int ch;
+{
+    do
+	if (*str == ch)
+	    return (str);
+    while (*str++);
+    return (NULL);
+}
+
+#ifdef DEBUG
+static void
+qprintf(s)
+Char *s;
+{
+    Char *p;
+
+    for (p = s; *p; p++)
+	printf("%c", *p & 0xff);
+    printf("\n");
+    for (p = s; *p; p++)
+	printf("%c", *p & M_PROTECT ? '"' : ' ');
+    printf("\n");
+    for (p = s; *p; p++)
+	printf("%c", *p & M_META ? '_' : ' ');
+    printf("\n");
+}
+#endif /* DEBUG */
+
+static int
+compare(p, q)
+    const ptr_t  p, q;
+{
+#if defined(NLS) && !defined(NOSTRCOLL)
+    errno = 0;  /* strcoll sets errno, another brain-damage */
+ 
+    return (strcoll(*(char **) p, *(char **) q));
+#else
+    return (strcmp(*(char **) p, *(char **) q));
+#endif /* NLS && !NOSTRCOLL */
+}
+
+/*
+ * The main glob() routine: compiles the pattern (optionally processing
+ * quotes), calls glob1() to do the real pattern matching, and finally
+ * sorts the list (unless unsorted operation is requested).  Returns 0
+ * if things went well, nonzero if errors occurred.  It is not an error
+ * to find no matches.
+ */
+int
+glob(pattern, flags, errfunc, pglob)
+    const char *pattern;
+    int     flags;
+    int     (*errfunc) __P((const char *, int));
+    glob_t *pglob;
+{
+    int     err, oldpathc;
+    Char *bufnext, *bufend, *compilebuf, m_not;
+    const unsigned char *compilepat, *patnext;
+    int     c, not;
+    Char patbuf[GLOBBUFLEN + 1], *qpatnext;
+    int     no_match;
+
+    patnext = (unsigned char *) pattern;
+    if (!(flags & GLOB_APPEND)) {
+	pglob->gl_pathc = 0;
+	pglob->gl_pathv = NULL;
+	if (!(flags & GLOB_DOOFFS))
+	    pglob->gl_offs = 0;
+    }
+    pglob->gl_flags = flags & ~GLOB_MAGCHAR;
+    pglob->gl_errfunc = errfunc;
+    oldpathc = pglob->gl_pathc;
+    pglob->gl_matchc = 0;
+
+    if (pglob->gl_flags & GLOB_ALTNOT) {
+	not = ALTNOT;
+	m_not = M_ALTNOT;
+    }
+    else {
+	not = NOT;
+	m_not = M_NOT;
+    }
+
+    bufnext = patbuf;
+    bufend = bufnext + GLOBBUFLEN;
+    compilebuf = bufnext;
+    compilepat = patnext;
+
+    no_match = *patnext == not;
+    if (no_match)
+	patnext++;
+
+    if (flags & GLOB_QUOTE) {
+	/* Protect the quoted characters */
+	while (bufnext < bufend && (c = *patnext++) != EOS) 
+	    if (c == QUOTE) {
+		if ((c = *patnext++) == EOS) {
+		    c = QUOTE;
+		    --patnext;
+		}
+		*bufnext++ = (Char) (c | M_PROTECT);
+	    }
+	    else
+		*bufnext++ = (Char) c;
+    }
+    else 
+	while (bufnext < bufend && (c = *patnext++) != EOS) 
+	    *bufnext++ = (Char) c;
+    *bufnext = EOS;
+
+    bufnext = patbuf;
+    qpatnext = patbuf;
+    /* we don't need to check for buffer overflow any more */
+    while ((c = *qpatnext++) != EOS) {
+	switch (c) {
+	case LBRACKET:
+	    c = *qpatnext;
+	    if (c == not)
+		++qpatnext;
+	    if (*qpatnext == EOS ||
+		Strchr(qpatnext + 1, RBRACKET) == NULL) {
+		*bufnext++ = LBRACKET;
+		if (c == not)
+		    --qpatnext;
+		break;
+	    }
+	    pglob->gl_flags |= GLOB_MAGCHAR;
+	    *bufnext++ = M_SET;
+	    if (c == not)
+		*bufnext++ = m_not;
+	    c = *qpatnext++;
+	    do {
+		*bufnext++ = CHAR(c);
+		if (*qpatnext == RANGE &&
+		    (c = qpatnext[1]) != RBRACKET) {
+		    *bufnext++ = M_RNG;
+		    *bufnext++ = CHAR(c);
+		    qpatnext += 2;
+		}
+	    } while ((c = *qpatnext++) != RBRACKET);
+	    *bufnext++ = M_END;
+	    break;
+	case QUESTION:
+	    pglob->gl_flags |= GLOB_MAGCHAR;
+	    *bufnext++ = M_ONE;
+	    break;
+	case STAR:
+	    pglob->gl_flags |= GLOB_MAGCHAR;
+	    /* collapse adjacent stars to one, to avoid
+	     * exponential behavior
+	     */
+	    if (bufnext == patbuf || bufnext[-1] != M_ALL)
+		*bufnext++ = M_ALL;
+	    break;
+	default:
+	    *bufnext++ = CHAR(c);
+	    break;
+	}
+    }
+    *bufnext = EOS;
+#ifdef DEBUG
+    qprintf(patbuf);
+#endif
+
+    if ((err = glob1(patbuf, pglob, no_match)) != 0)
+	return (err);
+
+    /*
+     * If there was no match we are going to append the pattern 
+     * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified
+     * and the pattern did not contain any magic characters
+     * GLOB_NOMAGIC is there just for compatibility with csh.
+     */
+    if (pglob->gl_pathc == oldpathc && 
+	((flags & GLOB_NOCHECK) || 
+	 ((flags & GLOB_NOMAGIC) && !(pglob->gl_flags & GLOB_MAGCHAR)))) {
+	if (!(flags & GLOB_QUOTE)) {
+	    Char *dp = compilebuf;
+	    const unsigned char *sp = compilepat;
+
+	    while ((*dp++ = *sp++) != '\0')
+		continue;
+	}
+	else {
+	    /*
+	     * copy pattern, interpreting quotes; this is slightly different
+	     * than the interpretation of quotes above -- which should prevail?
+	     */
+	    while (*compilepat != EOS) {
+		if (*compilepat == QUOTE) {
+		    if (*++compilepat == EOS)
+			--compilepat;
+		}
+		*compilebuf++ = (unsigned char) *compilepat++;
+	    }
+	    *compilebuf = EOS;
+	}
+	return (globextend(patbuf, pglob));
+    }
+    else if (!(flags & GLOB_NOSORT))
+	qsort((char *) (pglob->gl_pathv + pglob->gl_offs + oldpathc),
+	      pglob->gl_pathc - oldpathc, sizeof(char *),
+	      (int (*) __P((const void *, const void *))) compare);
+    return (0);
+}
+
+static int
+glob1(pattern, pglob, no_match)
+    Char *pattern;
+    glob_t *pglob;
+    int     no_match;
+{
+    Char pathbuf[GLOBBUFLEN + 1];
+
+    /*
+     * a null pathname is invalid -- POSIX 1003.1 sect. 2.4.
+     */
+    if (*pattern == EOS)
+	return (0);
+    return (glob2(pathbuf, pathbuf, pattern, pglob, no_match));
+}
+
+/*
+ * functions glob2 and glob3 are mutually recursive; there is one level
+ * of recursion for each segment in the pattern that contains one or
+ * more meta characters.
+ */
+static int
+glob2(pathbuf, pathend, pattern, pglob, no_match)
+    Char *pathbuf, *pathend, *pattern;
+    glob_t *pglob;
+    int     no_match;
+{
+    struct stat sbuf;
+    int anymeta;
+    Char *p, *q;
+
+    /*
+     * loop over pattern segments until end of pattern or until segment with
+     * meta character found.
+     */
+    anymeta = 0;
+    for (;;) {
+	if (*pattern == EOS) {	/* end of pattern? */
+	    *pathend = EOS;
+
+	    if (Lstat(pathbuf, &sbuf))
+		return (0);
+
+	    if (((pglob->gl_flags & GLOB_MARK) &&
+		 pathend[-1] != SEP) &&
+		(S_ISDIR(sbuf.st_mode)
+#ifdef S_IFLNK
+		 || (S_ISLNK(sbuf.st_mode) &&
+		     (Stat(pathbuf, &sbuf) == 0) &&
+		     S_ISDIR(sbuf.st_mode))
+#endif
+		 )) {
+		*pathend++ = SEP;
+		*pathend = EOS;
+	    }
+	    ++pglob->gl_matchc;
+	    return (globextend(pathbuf, pglob));
+	}
+
+	/* find end of next segment, copy tentatively to pathend */
+	q = pathend;
+	p = pattern;
+	while (*p != EOS && *p != SEP) {
+	    if (ismeta(*p))
+		anymeta = 1;
+	    *q++ = *p++;
+	}
+
+	if (!anymeta) {		/* no expansion, do next segment */
+	    pathend = q;
+	    pattern = p;
+	    while (*pattern == SEP)
+		*pathend++ = *pattern++;
+	}
+	else			/* need expansion, recurse */
+	    return (glob3(pathbuf, pathend, pattern, p, pglob, no_match));
+    }
+    /* NOTREACHED */
+}
+
+
+static int
+glob3(pathbuf, pathend, pattern, restpattern, pglob, no_match)
+    Char *pathbuf, *pathend, *pattern, *restpattern;
+    glob_t *pglob;
+    int     no_match;
+{
+    extern int errno;
+    DIR    *dirp;
+    struct dirent *dp;
+    int     err;
+    Char m_not = (pglob->gl_flags & GLOB_ALTNOT) ? M_ALTNOT : M_NOT;
+    char cpathbuf[GLOBBUFLEN], *ptr;;
+
+    *pathend = EOS;
+    errno = 0;
+
+    if (!(dirp = Opendir(pathbuf))) {
+	/* todo: don't call for ENOENT or ENOTDIR? */
+	for (ptr = cpathbuf; (*ptr++ = (char) *pathbuf++) != EOS;)
+	    continue;
+	if ((pglob->gl_errfunc && (*pglob->gl_errfunc) (cpathbuf, errno)) ||
+	    (pglob->gl_flags & GLOB_ERR))
+	    return (GLOB_ABEND);
+	else
+	    return (0);
+    }
+
+    err = 0;
+
+    /* search directory for matching names */
+    while ((dp = readdir(dirp)) != NULL) {
+	register unsigned char *sc;
+	register Char *dc;
+
+	/* initial DOT must be matched literally */
+	if (dp->d_name[0] == DOT && *pattern != DOT)
+	    continue;
+	for (sc = (unsigned char *) dp->d_name, dc = pathend; 
+	     (*dc++ = *sc++) != '\0';)
+	    continue;
+	if (match(pathend, pattern, restpattern, (int) m_not) == no_match) {
+	    *pathend = EOS;
+	    continue;
+	}
+	err = glob2(pathbuf, --dc, restpattern, pglob, no_match);
+	if (err)
+	    break;
+    }
+    /* todo: check error from readdir? */
+    (void) closedir(dirp);
+    return (err);
+}
+
+
+/*
+ * Extend the gl_pathv member of a glob_t structure to accomodate a new item,
+ * add the new item, and update gl_pathc.
+ *
+ * This assumes the BSD realloc, which only copies the block when its size
+ * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
+ * behavior.
+ *
+ * Return 0 if new item added, error code if memory couldn't be allocated.
+ *
+ * Invariant of the glob_t structure:
+ *	Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
+ *	 gl_pathv points to (gl_offs + gl_pathc + 1) items.
+ */
+static int
+globextend(path, pglob)
+    Char *path;
+    glob_t *pglob;
+{
+    register char **pathv;
+    register int i;
+    unsigned int newsize;
+    char   *copy;
+    Char *p;
+
+    newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
+    pathv = (char **) (pglob->gl_pathv ?
+		       xrealloc((ptr_t) pglob->gl_pathv, (size_t) newsize) :
+		       xmalloc((size_t) newsize));
+    if (pathv == NULL)
+	return (GLOB_NOSPACE);
+
+    if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
+	/* first time around -- clear initial gl_offs items */
+	pathv += pglob->gl_offs;
+	for (i = pglob->gl_offs; --i >= 0;)
+	    *--pathv = NULL;
+    }
+    pglob->gl_pathv = pathv;
+
+    for (p = path; *p++;)
+	continue;
+    if ((copy = (char *) xmalloc((size_t) (p - path))) != NULL) {
+	register char *dc = copy;
+	register Char *sc = path;
+
+	while ((*dc++ = *sc++) != '\0')
+	    continue;
+	pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
+    }
+    pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
+    return ((copy == NULL) ? GLOB_NOSPACE : 0);
+}
+
+
+/*
+ * pattern matching function for filenames.  Each occurrence of the *
+ * pattern causes a recursion level.
+ */
+static  int
+match(name, pat, patend, m_not)
+    register Char *name, *pat, *patend;
+    int m_not;
+{
+    int ok, negate_range;
+    Char c, k;
+
+    while (pat < patend) {
+	c = *pat++;
+	switch (c & M_MASK) {
+	case M_ALL:
+	    if (pat == patend)
+		return (1);
+	    do 
+		if (match(name, pat, patend, m_not))
+		    return (1);
+	    while (*name++ != EOS);
+	    return (0);
+	case M_ONE:
+	    if (*name++ == EOS)
+		return (0);
+	    break;
+	case M_SET:
+	    ok = 0;
+	    if ((k = *name++) == EOS)
+		return (0);
+	    if ((negate_range = ((*pat & M_MASK) == m_not)) != 0)
+		++pat;
+	    while (((c = *pat++) & M_MASK) != M_END) {
+		if ((*pat & M_MASK) == M_RNG) {
+		    if (globcharcoll(CHAR(c), CHAR(k)) <= 0 &&
+			globcharcoll(CHAR(k), CHAR(pat[1])) <= 0)
+			ok = 1;
+		    pat += 2;
+		}
+		else if (c == k)
+		    ok = 1;
+	    }
+	    if (ok == negate_range)
+		return (0);
+	    break;
+	default:
+	    k = *name++;
+	    if (samecase(k) != samecase(c))
+		return (0);
+	    break;
+	}
+    }
+    return (*name == EOS);
+}
+
+/* free allocated data belonging to a glob_t structure */
+void
+globfree(pglob)
+    glob_t *pglob;
+{
+    register int i;
+    register char **pp;
+
+    if (pglob->gl_pathv != NULL) {
+	pp = pglob->gl_pathv + pglob->gl_offs;
+	for (i = pglob->gl_pathc; i--; ++pp)
+	    if (*pp)
+		xfree((ptr_t) *pp), *pp = NULL;
+	xfree((ptr_t) pglob->gl_pathv), pglob->gl_pathv = NULL;
+    }
+}