//glob.c - filename generation

//

// © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

//

/*

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 1992-1997 Paul Falstad

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and to distribute modified versions of this software for any

 * purpose, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * In no event shall Paul Falstad or the Zsh Development Group be liable

 * to any party for direct, indirect, special, incidental, or consequential

 * damages arising out of the use of this software and its documentation,

 * even if Paul Falstad and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Paul Falstad and the Zsh Development Group specifically disclaim any

 * warranties, including, but not limited to, the implied warranties of

 * merchantability and fitness for a particular purpose.  The software

 * provided hereunder is on an "as is" basis, and Paul Falstad and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "zsh.mdh"

#include "glob.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

#if defined(OFF_T_IS_64_BIT) && defined(__GNUC__)

# define ALIGN64 __attribute__((aligned(8)))

#else

# define ALIGN64

#endif

/* flag for CSHNULLGLOB */

typedef struct gmatch *Gmatch;

struct gmatch {

    char *name;

    off_t size ALIGN64;

    long atime;

    long mtime;

    long ctime;

    long links;

    off_t _size ALIGN64;

    long _atime;

    long _mtime;

    long _ctime;

    long _links;

};

#define GS_NAME   1

#define GS_DEPTH  2

#define GS_SIZE   4

#define GS_ATIME  8

#define GS_MTIME 16

#define GS_CTIME 32

#define GS_LINKS 64

#define GS_SHIFT  5

#define GS__SIZE  (GS_SIZE << GS_SHIFT)

#define GS__ATIME (GS_ATIME << GS_SHIFT)

#define GS__MTIME (GS_MTIME << GS_SHIFT)

#define GS__CTIME (GS_CTIME << GS_SHIFT)

#define GS__LINKS (GS_LINKS << GS_SHIFT)

#define GS_DESC  4096

#define GS_NORMAL (GS_SIZE | GS_ATIME | GS_MTIME | GS_CTIME | GS_LINKS)

#define GS_LINKED (GS_NORMAL << GS_SHIFT)

/**/

int badcshglob;

/**/

int pathpos;		/* position in pathbuf (needed by pattern code) */

/**/

char *pathbuf;		/* pathname buffer (needed by pattern code) */

typedef struct stat *Statptr;	 /* This makes the Ultrix compiler happy.  Go figure. */

/* modifier for unit conversions */

#define TT_DAYS 0

#define TT_HOURS 1

#define TT_MINS 2

#define TT_WEEKS 3

#define TT_MONTHS 4

#define TT_SECONDS 5

#define TT_BYTES 0

#define TT_POSIX_BLOCKS 1

#define TT_KILOBYTES 2

#define TT_MEGABYTES 3

typedef int (*TestMatchFunc) _((char *, struct stat *, off_t, char *));

struct qual {

    struct qual *next;		/* Next qualifier, must match                */

    struct qual *or;		/* Alternative set of qualifiers to match    */

    TestMatchFunc func;		/* Function to call to test match            */

    off_t data ALIGN64;		/* Argument passed to function               */

    int sense;			/* Whether asserting or negating             */

    int amc;			/* Flag for which time to test (a, m, c)     */

    int range;			/* Whether to test <, > or = (as per signum) */

    int units;			/* Multiplier for time or size, respectively */

    char *sdata;		/* currently only: expression to eval        */

};

/* Prefix, suffix for doing zle trickery */

/**/

mod_export char *glob_pre, *glob_suf;

/* struct to easily save/restore current state */

struct globdata {

    int gd_pathpos;

    char *gd_pathbuf;

    int gd_matchsz;		/* size of matchbuf                     */

    int gd_matchct;		/* number of matches found              */

    int gd_pathbufsz;		/* size of pathbuf			*/

    int gd_pathbufcwd;		/* where did we chdir()'ed		*/

    Gmatch gd_matchbuf;		/* array of matches                     */

    Gmatch gd_matchptr;		/* &matchbuf[matchct]                   */

    char *gd_colonmod;		/* colon modifiers in qualifier list    */

    /* Qualifiers pertaining to current pattern */

    struct qual *gd_quals;

    /* Other state values for current pattern */

    int gd_qualct, gd_qualorct;

    int gd_range, gd_amc, gd_units;

    int gd_gf_nullglob, gd_gf_markdirs, gd_gf_noglobdots, gd_gf_listtypes;

    int gd_gf_numsort;

    int gd_gf_follow, gd_gf_sorts, gd_gf_nsorts, gd_gf_sortlist[11];

    char *gd_glob_pre, *gd_glob_suf;

};

/* The variable with the current globbing state and convenience macros */

static struct globdata curglobdata;

#define matchsz       (curglobdata.gd_matchsz)

#define matchct       (curglobdata.gd_matchct)

#define pathbufsz     (curglobdata.gd_pathbufsz)

#define pathbufcwd    (curglobdata.gd_pathbufcwd)

#define matchbuf      (curglobdata.gd_matchbuf)

#define matchptr      (curglobdata.gd_matchptr)

#define colonmod      (curglobdata.gd_colonmod)

#define quals         (curglobdata.gd_quals)

#define qualct        (curglobdata.gd_qualct)

#define qualorct      (curglobdata.gd_qualorct)

#define g_range       (curglobdata.gd_range)

#define g_amc         (curglobdata.gd_amc)

#define g_units       (curglobdata.gd_units)

#define gf_nullglob   (curglobdata.gd_gf_nullglob)

#define gf_markdirs   (curglobdata.gd_gf_markdirs)

#define gf_noglobdots (curglobdata.gd_gf_noglobdots)

#define gf_listtypes  (curglobdata.gd_gf_listtypes)

#define gf_numsort    (curglobdata.gd_gf_numsort)

#define gf_follow     (curglobdata.gd_gf_follow)

#define gf_sorts      (curglobdata.gd_gf_sorts)

#define gf_nsorts     (curglobdata.gd_gf_nsorts)

#define gf_sortlist   (curglobdata.gd_gf_sortlist)

/* and macros for save/restore */

#define save_globstate(N) \

  do { \

    memcpy(&(N), &curglobdata, sizeof(struct globdata)); \

    (N).gd_pathpos = pathpos; \

    (N).gd_pathbuf = pathbuf; \

    (N).gd_pathbufsz = 0; \

    (N).gd_glob_pre = glob_pre; \

    (N).gd_glob_suf = glob_suf; \

    pathbuf = NULL; \

  } while (0)

#define restore_globstate(N) \

  do { \

    zfree(pathbuf, pathbufsz); \

    memcpy(&curglobdata, &(N), sizeof(struct globdata)); \

    pathpos = (N).gd_pathpos; \

    pathbuf = (N).gd_pathbuf; \

    glob_pre = (N).gd_glob_pre; \

    glob_suf = (N).gd_glob_suf; \

  } while (0)

/* pathname component in filename patterns */

struct complist {

    Complist next;

    Patprog pat;

    int closure;		/* 1 if this is a (foo/)# */

    int follow; 		/* 1 to go thru symlinks */

};

/* Next character after one which may be a Meta (x is any char *) */

#define METANEXT(x)	(*(x) == Meta ? (x)+2 : (x)+1)

/*

 * Increment pointer which may be on a Meta (x is a pointer variable),

 * returning the incremented value (i.e. like pre-increment).

 */

#define METAINC(x)	((x) += (*(x) == Meta) ? 2 : 1)

/*

 * Return unmetafied char from string (x is any char *)

 */

#define UNMETA(x)	(*(x) == Meta ? (x)[1] ^ 32 : *(x))

/* Add a component to pathbuf: This keeps track of how    *

 * far we are into a file name, since each path component *

 * must be matched separately.                            */

/**/

static void

addpath(char *s, int l)

{

    DPUTS(!pathbuf, "BUG: pathbuf not initialised");

    while (pathpos + l + 1 >= pathbufsz)

	pathbuf = realloc(pathbuf, pathbufsz *= 2);

    while (l--)

	pathbuf[pathpos++] = *s++;

    pathbuf[pathpos++] = '/';

    pathbuf[pathpos] = '\0';

}

/* stat the filename s appended to pathbuf.  l should be true for lstat,    *

 * false for stat.  If st is NULL, the file is only checked for existance.  *

 * s == "" is treated as s == ".".  This is necessary since on most systems *

 * foo/ can be used to reference a non-directory foo.  Returns nonzero if   *

 * the file does not exists.                                                */

/**/

static int

statfullpath(const char *s, struct stat *st, int l)

{

    char buf[PATH_MAX];

    DPUTS(strlen(s) + !*s + pathpos - pathbufcwd >= PATH_MAX,

	  "BUG: statfullpath(): pathname too long");

    strcpy(buf, pathbuf + pathbufcwd);

    strcpy(buf + pathpos - pathbufcwd, s);

    if (!*s && *buf) {

	/*

	 * Don't add the '.' if the path so far is empty, since

	 * then we get bogus empty strings inserted as files.

	 */

	buf[pathpos - pathbufcwd] = '.';

	buf[pathpos - pathbufcwd + 1] = '\0';

	l = 0;

    }

    unmetafy(buf, NULL);

    if (!st)

	return access(buf, F_OK) && (!l || readlink(buf, NULL, 0));

    return l ? lstat(buf, st) : stat(buf, st);

}

/* This may be set by qualifier functions to an array of strings to insert

 * into the list instead of the original string. */

char **inserts;

/* add a match to the list */

/**/

static void

insert(char *s, int checked)

{

    struct stat buf, buf2, *bp;

    char *news = s;

    int statted = 0;

    queue_signals();

    inserts = NULL;

    if (gf_listtypes || gf_markdirs) {

	/* Add the type marker to the end of the filename */

	mode_t mode;

	checked = statted = 1;

	if (statfullpath(s, &buf, 1)) {

	    unqueue_signals();

	    return;

	}

	mode = buf.st_mode;

	if (gf_follow) {

	    if (!S_ISLNK(mode) || statfullpath(s, &buf2, 0))

		memcpy(&buf2, &buf, sizeof(buf));

	    statted |= 2;

	    mode = buf2.st_mode;

	}

	if (gf_listtypes || S_ISDIR(mode)) {

	    int ll = strlen(s);

	    news = (char *) hcalloc(ll + 2);

	    strcpy(news, s);

	    news[ll] = file_type(mode);

	    news[ll + 1] = '\0';

	}

    }

    if (qualct || qualorct) {

	/* Go through the qualifiers, rejecting the file if appropriate */

	struct qual *qo, *qn;

	if (!statted && statfullpath(s, &buf, 1)) {

	    unqueue_signals();

	    return;

	}

	news = dyncat(pathbuf, news);

	statted = 1;

	qo = quals;

	for (qn = qo; qn && qn->func;) {

	    g_range = qn->range;

	    g_amc = qn->amc;

	    g_units = qn->units;

	    if ((qn->sense & 2) && !(statted & 2)) {

		/* If (sense & 2), we're following links */

		if (!S_ISLNK(buf.st_mode) || statfullpath(s, &buf2, 0))

		    memcpy(&buf2, &buf, sizeof(buf));

		statted |= 2;

	    }

	    bp = (qn->sense & 2) ? &buf2 : &buf;

	    /* Reject the file if the function returned zero *

	     * and the sense was positive (sense&1 == 0), or *

	     * vice versa.                                   */

	    if ((!((qn->func) (news, bp, qn->data, qn->sdata)) ^ qn->sense) & 1) {

		/* Try next alternative, or return if there are no more */

		if (!(qo = qo->or)) {

		    unqueue_signals();

		    return;

		}

		qn = qo;

		continue;

	    }

	    qn = qn->next;

	}

    } else if (!checked) {

	if (statfullpath(s, NULL, 1)) {

	    unqueue_signals();

	    return;

	}

	statted = 1;

	news = dyncat(pathbuf, news);

    } else

	news = dyncat(pathbuf, news);

    while (!inserts || (news = dupstring(*inserts++))) {

	if (colonmod) {

	    /* Handle the remainder of the qualifier:  e.g. (:r:s/foo/bar/). */

	    s = colonmod;

	    modify(&news, &s);

	}

	if (!statted && (gf_sorts & GS_NORMAL)) {

	    statfullpath(s, &buf, 1);

	    statted = 1;

	}

	if (!(statted & 2) && (gf_sorts & GS_LINKED)) {

	    if (statted) {

		if (!S_ISLNK(buf.st_mode) || statfullpath(s, &buf2, 0))

		    memcpy(&buf2, &buf, sizeof(buf));

	    } else if (statfullpath(s, &buf2, 0))

		statfullpath(s, &buf2, 1);

	    statted |= 2;

	}

	matchptr->name = news;

	if (statted & 1) {

	    matchptr->size = buf.st_size;

	    matchptr->atime = buf.st_atime;

	    matchptr->mtime = buf.st_mtime;

	    matchptr->ctime = buf.st_ctime;

	    matchptr->links = buf.st_nlink;

	}

	if (statted & 2) {

	    matchptr->_size = buf2.st_size;

	    matchptr->_atime = buf2.st_atime;

	    matchptr->_mtime = buf2.st_mtime;

	    matchptr->_ctime = buf2.st_ctime;

	    matchptr->_links = buf2.st_nlink;

	}

	matchptr++;

	if (++matchct == matchsz) {

	    matchbuf = (Gmatch )realloc((char *)matchbuf,

					sizeof(struct gmatch) * (matchsz *= 2));

	    matchptr = matchbuf + matchct;

	}

	if (!inserts)

	    break;

    }

    unqueue_signals();

}

/* Check to see if str is eligible for filename generation. */

/**/

mod_export int

haswilds(char *str)

{

    /* `[' and `]' are legal even if bad patterns are usually not. */

    if ((*str == Inbrack || *str == Outbrack) && !str[1])

	return 0;

    /* If % is immediately followed by ?, then that ? is     *

     * not treated as a wildcard.  This is so you don't have *

     * to escape job references such as %?foo.               */

    if (str[0] == '%' && str[1] == Quest)

	str[1] = '?';

    for (; *str; str++) {

	switch (*str) {

	    case Inpar:

	    case Bar:

	    case Star:

	    case Inbrack:

	    case Inang:

	    case Quest:

		return 1;

	    case Pound:

	    case Hat:

		if (isset(EXTENDEDGLOB))

		    return 1;

		break;

	}

    }

    return 0;

}

/* Do the globbing:  scanner is called recursively *

 * with successive bits of the path until we've    *

 * tried all of it.                                */

/**/

static void

scanner(Complist q)

{

    Patprog p;

    int closure;

    int pbcwdsav = pathbufcwd;

    int errssofar = errsfound;

    struct dirsav ds;

    ds.ino = ds.dev = 0;

    ds.dirname = NULL;

    ds.dirfd = ds.level = -1;

    if (!q)

	return;

    if ((closure = q->closure)) {

	/* (foo/)# - match zero or more dirs */

	if (q->closure == 2)	/* (foo/)## - match one or more dirs */

	    q->closure = 1;

	else

	    scanner(q->next);

    }

    p = q->pat;

    /* Now the actual matching for the current path section. */

    if (p->flags & PAT_PURES) {

	/*

	 * It's a straight string to the end of the path section.

	 */

	char *str = (char *)p + p->startoff;

	int l = p->patmlen;

	if (l + !l + pathpos - pathbufcwd >= PATH_MAX) {

	    int err;

	    if (l >= PATH_MAX)

		return;

	    err = lchdir(pathbuf + pathbufcwd, &ds, 0);

	    if (err == -1)

		return;

	    if (err) {

		zerr("current directory lost during glob", NULL, 0);

		return;

	    }

	    pathbufcwd = pathpos;

	}

	if (q->next) {

	    /* Not the last path section. Just add it to the path. */

	    int oppos = pathpos;

	    if (!errflag) {

		int add = 1;

		if (q->closure && *pathbuf) {

		    if (!strcmp(str, "."))

			add = 0;

		    else if (!strcmp(str, "..")) {

			struct stat sc, sr;

			add = (stat("/", &sr) || stat(pathbuf, &sc) ||

			       sr.st_ino != sc.st_ino ||

			       sr.st_dev != sc.st_dev);

		    }

		}

		if (add) {

		    addpath(str, l);

		    if (!closure || !statfullpath("", NULL, 1))

			scanner((q->closure) ? q : q->next);

		    pathbuf[pathpos = oppos] = '\0';

		}

	    }

	} else {

	    if (str[l])

		str = dupstrpfx(str, l);

	    insert(str, 0);

	}