/* $NetBSD: eval.c,v 1.15 2013/10/18 19:53:34 christos Exp $ */

/*

* Expansion - quoting, separation, substitution, globbing

*/

#include <sys/cdefs.h>

#ifndef lint

__RCSID("$NetBSD: eval.c,v 1.15 2013/10/18 19:53:34 christos Exp $");

#endif

#include <stdint.h>

#include <pwd.h>

#include "sh.h"

#include "ksh_dir.h"

#include "ksh_stat.h"

/*

* string expansion

*

* first pass: quoting, IFS separation, ~, ${}, $() and $(()) substitution.

* second pass: alternation ({,}), filename expansion (*?[]).

*/

/* expansion generator state */

typedef struct Expand {

/* int type; */ /* see expand() */

const char *str; /* string */

union {

const char **strv;/* string[] */

struct shf *shf;/* file */

} u; /* source */

struct tbl *var; /* variable in ${var..} */

short split; /* split "$@" / call waitlast $() */

} Expand;

#define XBASE 0 /* scanning original */

#define XSUB 1 /* expanding ${} string */

#define XARGSEP 2 /* ifs0 between "$*" */

#define XARG 3 /* expanding $*, $@ */

#define XCOM 4 /* expanding $() */

#define XNULLSUB 5 /* "$@" when $# is 0 (don't generate word) */

/* States used for field splitting */

#define IFS_WORD 0 /* word has chars (or quotes) */

#define IFS_WS 1 /* have seen IFS white-space */

#define IFS_NWS 2 /* have seen IFS non-white-space */

static int varsub ARGS((Expand *xp, char *sp, char *word, int *stypep, int *slenp));

static int comsub ARGS((Expand *xp, char *cp));

static char *trimsub ARGS((char *str, char *pat, int how));

static void glob ARGS((char *cp, XPtrV *wp, int markdirs));

static void globit ARGS((XString *xs, char **xpp, char *sp, XPtrV *wp,

int check));

static char *maybe_expand_tilde ARGS((char *p, XString *dsp, char **dpp,

int isassign));

static char *tilde ARGS((char *acp));

static char *homedir ARGS((char *name));

#ifdef BRACE_EXPAND

static void alt_expand ARGS((XPtrV *wp, char *start, char *exp_start,

char *end, int fdo));

#endif

/* compile and expand word */

char *

substitute(cp, f)

const char *cp;

int f;

{

struct source *s, *sold;

sold = source;

s = pushs(SWSTR, ATEMP);

s->start = s->str = cp;

source = s;

if (yylex(ONEWORD) != LWORD)

internal_errorf(1, "substitute");

source = sold;

afree(s, ATEMP);

return evalstr(yylval.cp, f);

}

/*

* expand arg-list

*/

char **

eval(ap, f)

register char **ap;

int f;

{

XPtrV w;

if (*ap == NULL)

return ap;

XPinit(w, 32);

XPput(w, NULL); /* space for shell name */

#ifdef SHARPBANG

XPput(w, NULL); /* and space for one arg */

#endif

while (*ap != NULL)

expand(*ap++, &w, f);

XPput(w, NULL);

#ifdef SHARPBANG

return (char **) XPclose(w) + 2;

#else

return (char **) XPclose(w) + 1;

#endif

}

/*

* expand string

*/

char *

evalstr(cp, f)

char *cp;

int f;

{

XPtrV w;

XPinit(w, 1);

expand(cp, &w, f);

cp = (XPsize(w) == 0) ? null : (char*) *XPptrv(w);

XPfree(w);

return cp;

}

/*

* expand string - return only one component

* used from iosetup to expand redirection files

*/

char *

evalonestr(cp, f)

register char *cp;

int f;

{

XPtrV w;

XPinit(w, 1);

expand(cp, &w, f);

switch (XPsize(w)) {

case 0:

cp = null;

break;

case 1:

cp = (char*) *XPptrv(w);

break;

default:

cp = evalstr(cp, f&~DOGLOB);

break;

}

XPfree(w);

return cp;

}

/* for nested substitution: ${var:=$var2} */

typedef struct SubType {

short stype; /* [=+-?%#] action after expanded word */

short base; /* begin position of expanded word */

short f; /* saved value of f (DOPAT, etc) */

struct tbl *var; /* variable for ${var..} */

short quote; /* saved value of quote (for ${..[%#]..}) */

struct SubType *prev; /* old type */

struct SubType *next; /* poped type (to avoid re-allocating) */

} SubType;

void

expand(cp, wp, f)

char *cp; /* input word */

register XPtrV *wp; /* output words */

int f; /* DO* flags */

{

register int UNINITIALIZED(c);

register int type; /* expansion type */

register int quote = 0; /* quoted */

XString ds; /* destination string */

register char *dp, *sp; /* dest., source */

int fdo, word; /* second pass flags; have word */

int doblank; /* field splitting of parameter/command subst */

Expand x; /* expansion variables */

SubType st_head, *st;

int UNINITIALIZED(newlines); /* For trailing newlines in COMSUB */

int saw_eq, tilde_ok;

int make_magic;

size_t len;

x.split = 0; /* XXX gcc */

x.str = NULL; /* XXX gcc */

x.u.strv = NULL;/* XXX gcc */

if (cp == NULL)

internal_errorf(1, "expand(NULL)");

/* for alias, readonly, set, typeset commands */

if ((f & DOVACHECK) && is_wdvarassign(cp)) {

f &= ~(DOVACHECK|DOBLANK|DOGLOB|DOTILDE);

f |= DOASNTILDE;

}

if (Flag(FNOGLOB))

f &= ~DOGLOB;

if (Flag(FMARKDIRS))

f |= DOMARKDIRS;

#ifdef BRACE_EXPAND

if (Flag(FBRACEEXPAND) && (f & DOGLOB))

f |= DOBRACE_;

#endif /* BRACE_EXPAND */

Xinit(ds, dp, 128, ATEMP); /* init dest. string */

type = XBASE;

sp = cp;

fdo = 0;

saw_eq = 0;

tilde_ok = (f & (DOTILDE|DOASNTILDE)) ? 1 : 0; /* must be 1/0 */

doblank = 0;

make_magic = 0;

word = (f&DOBLANK) ? IFS_WS : IFS_WORD;

st_head.next = (SubType *) 0;

st = &st_head;

while (1) {

Xcheck(ds, dp);

switch (type) {

case XBASE: /* original prefixed string */

c = *sp++;

switch (c) {

case EOS:

c = 0;

break;

case CHAR:

c = *sp++;

break;

case QCHAR:

quote |= 2; /* temporary quote */

c = *sp++;

break;

case OQUOTE:

word = IFS_WORD;

tilde_ok = 0;

quote = 1;

continue;

case CQUOTE:

quote = 0;

continue;

case COMSUB:

tilde_ok = 0;

if (f & DONTRUNCOMMAND) {

word = IFS_WORD;

*dp++ = '$'; *dp++ = '(';

while (*sp != '\0') {

Xcheck(ds, dp);

*dp++ = *sp++;

}

*dp++ = ')';

} else {

type = comsub(&x, sp);

if (type == XCOM && (f&DOBLANK))

doblank++;

sp = strchr(sp, 0) + 1;

newlines = 0;

}

continue;

case EXPRSUB:

word = IFS_WORD;

tilde_ok = 0;

if (f & DONTRUNCOMMAND) {

*dp++ = '$'; *dp++ = '('; *dp++ = '(';

while (*sp != '\0') {

Xcheck(ds, dp);

*dp++ = *sp++;

}

*dp++ = ')'; *dp++ = ')';

} else {

struct tbl v;

char *p;

v.flag = DEFINED|ISSET|INTEGER;

v.type = 10; /* not default */

v.name[0] = '\0';

v_evaluate(&v, substitute(sp, 0),

KSH_UNWIND_ERROR);

sp = strchr(sp, 0) + 1;

for (p = str_val(&v); *p; ) {

Xcheck(ds, dp);

*dp++ = *p++;

}

}

continue;

case OSUBST: /* ${{#}var{:}[=+-?#%]word} */

/* format is:

* OSUBST [{x] plain-variable-part \0

* compiled-word-part CSUBST [}x]

* This is were all syntax checking gets done...

*/

{

char *varname = ++sp; /* skip the { or x (}) */

int stype;

int slen;

slen = -1; /* XXX gcc */

sp = strchr(sp, '\0') + 1; /* skip variable */

type = varsub(&x, varname, sp, &stype, &slen);

if (type < 0) {

char endc;

char *str, *end;

end = (char *) wdscan(sp, CSUBST);

/* ({) the } or x is already skipped */

endc = *end;

*end = EOS;

str = snptreef((char *) 0, 64, "%S",

varname - 1);

*end = endc;

errorf("%s: bad substitution", str);

}

if (f&DOBLANK)

doblank++;

tilde_ok = 0;

if (type == XBASE) { /* expand? */

if (!st->next) {

SubType *newst;

newst = (SubType *) alloc(

sizeof(SubType), ATEMP);

newst->next = (SubType *) 0;

newst->prev = st;

st->next = newst;

}

st = st->next;

st->stype = stype;

st->base = Xsavepos(ds, dp);

st->f = f;

st->var = x.var;

st->quote = quote;

/* skip qualifier(s) */

if (stype)

sp += slen;

switch (stype & 0x7f) {

case '#':

case '%':

/* ! DOBLANK,DOBRACE_,DOTILDE */

f = DOPAT | (f&DONTRUNCOMMAND)

| DOTEMP_;

quote = 0;

/* Prepend open pattern (so |

* in a trim will work as

* expected)

*/

*dp++ = MAGIC;

*dp++ = '@' + 0x80;

break;

case '=':

/* Enabling tilde expansion

* after :'s here is

* non-standard ksh, but is

* consistent with rules for

* other assignments. Not

* sure what POSIX thinks of

* this.

* Not doing tilde expansion

* for integer variables is a

* non-POSIX thing - makes

* sense though, since ~ is

* a arithmetic operator.

*/

if (!(x.var->flag & INTEGER))

f |= DOASNTILDE|DOTILDE;

f |= DOTEMP_;

/* These will be done after the

* value has been assigned.

*/

f &= ~(DOBLANK|DOGLOB|DOBRACE_);

tilde_ok = 1;

break;

case '?':

f &= ~DOBLANK;

f |= DOTEMP_;

/* fall through */

default:

/* Enable tilde expansion */

tilde_ok = 1;

f |= DOTILDE;

}

} else

/* skip word */

sp = (char *) wdscan(sp, CSUBST);

continue;

}

case CSUBST: /* only get here if expanding word */

sp++; /* ({) skip the } or x */

tilde_ok = 0; /* in case of ${unset:-} */

*dp = '\0';

quote = st->quote;

f = st->f;

if (f&DOBLANK)

doblank--;

switch (st->stype&0x7f) {

case '#':

case '%':

/* Append end-pattern */

*dp++ = MAGIC; *dp++ = ')'; *dp = '\0';

dp = Xrestpos(ds, dp, st->base);

/* Must use st->var since calling

* global would break things

* like x[i+=1].

*/

x.str = trimsub(str_val(st->var),

dp, st->stype);

type = XSUB;

if (f&DOBLANK)

doblank++;

st = st->prev;

continue;

case '=':

/* Restore our position and substitute

* the value of st->var (may not be

* the assigned value in the presence

* of integer/right-adj/etc attributes).

*/

dp = Xrestpos(ds, dp, st->base);

/* Must use st->var since calling

* global would cause with things

* like x[i+=1] to be evaluated twice.

*/

/* Note: not exported by FEXPORT

* in at&t ksh.

*/

/* XXX POSIX says readonly is only

* fatal for special builtins (setstr

* does readonly check).

*/

len = strlen(dp) + 1;

setstr(st->var,

debunk((char *) alloc(len, ATEMP),

dp, len),

KSH_UNWIND_ERROR);

x.str = str_val(st->var);

type = XSUB;

if (f&DOBLANK)

doblank++;

st = st->prev;

continue;

case '?':

{

char *s = Xrestpos(ds, dp, st->base);

errorf("%s: %s", st->var->name,

dp == s ?

"parameter null or not set"

: (debunk(s, s, strlen(s) + 1), s));

}

}

st = st->prev;

type = XBASE;

continue;

case OPAT: /* open pattern: *(foo|bar) */

/* Next char is the type of pattern */

make_magic = 1;

c = *sp++ + 0x80;

break;

case SPAT: /* pattern separator (|) */

make_magic = 1;

c = '|';

break;

case CPAT: /* close pattern */

make_magic = 1;

c = /*(*/ ')';

break;

}

break;

case XNULLSUB:

/* Special case for "$@" (and "${foo[@]}") - no

* word is generated if $# is 0 (unless there is

* other stuff inside the quotes).

*/

type = XBASE;

if (f&DOBLANK) {

doblank--;

/* not really correct: x=; "$x$@" should

* generate a null argument and

* set A; "${@:+}" shouldn't.

*/

if (dp == Xstring(ds, dp))

word = IFS_WS;

}

continue;

case XSUB:

if ((c = *x.str++) == 0) {

type = XBASE;

if (f&DOBLANK)

doblank--;

continue;

}

break;

case XARGSEP:

type = XARG;

quote = 1;

case XARG:

if ((c = *x.str++) == '\0') {

/* force null words to be created so

* set -- '' 2 ''; foo "$@" will do

* the right thing

*/

if (quote && x.split)

word = IFS_WORD;

if ((x.str = *x.u.strv++) == NULL) {

type = XBASE;

if (f&DOBLANK)

doblank--;

continue;

}

c = ifs0;

if (c == 0) {

if (quote && !x.split)

continue;

c = ' ';

}

if (quote && x.split) {

/* terminate word for "$@" */

type = XARGSEP;

quote = 0;

}

}

break;

case XCOM:

if (newlines) { /* Spit out saved nl's */

c = '\n';

--newlines;

} else {

while ((c = shf_getc(x.u.shf)) == 0 || c == '\n')

if (c == '\n')

newlines++; /* Save newlines */

if (newlines && c != EOF) {

shf_ungetc(c, x.u.shf);

c = '\n';

--newlines;

}

}

if (c == EOF) {

newlines = 0;

shf_close(x.u.shf);

if (x.split)

subst_exstat = waitlast();

type = XBASE;

if (f&DOBLANK)

doblank--;

continue;

}

break;

}

/* check for end of word or IFS separation */

if (c == 0 || (!quote && (f & DOBLANK) && doblank && !make_magic

&& ctype(c, C_IFS)))

{

/* How words are broken up:

* | value of c

* word | ws nws 0

* -----------------------------------

* IFS_WORD w/WS w/NWS w

* IFS_WS -/WS w/NWS -

* IFS_NWS -/NWS w/NWS w

* (w means generate a word)

* Note that IFS_NWS/0 generates a word (at&t ksh

* doesn't do this, but POSIX does).

*/

if (word == IFS_WORD

|| (!ctype(c, C_IFSWS) && (c || word == IFS_NWS)))

{

char *p;

*dp++ = '\0';

p = Xclose(ds, dp);

#ifdef BRACE_EXPAND

if (fdo & DOBRACE_)

/* also does globbing */

alt_expand(wp, p, p,

p + Xlength(ds, (dp - 1)),

fdo | (f & DOMARKDIRS));

else

#endif /* BRACE_EXPAND */

if (fdo & DOGLOB)

glob(p, wp, f & DOMARKDIRS);

else if ((f & DOPAT) || !(fdo & DOMAGIC_))

XPput(*wp, p);

else

XPput(*wp, debunk(p, p, strlen(p) + 1));

fdo = 0;

saw_eq = 0;

tilde_ok = (f & (DOTILDE|DOASNTILDE)) ? 1 : 0;

if (c != 0)

Xinit(ds, dp, 128, ATEMP);

}

if (c == 0)

return;

if (word != IFS_NWS)

word = ctype(c, C_IFSWS) ? IFS_WS : IFS_NWS;

} else {

/* age tilde_ok info - ~ code tests second bit */

tilde_ok <<= 1;

/* mark any special second pass chars */

if (!quote)

switch (c) {

case '[':

case NOT:

case '-':

case ']':

/* For character classes - doesn't hurt

* to have magic !,-,]'s outside of

* [...] expressions.

*/

if (f & (DOPAT | DOGLOB)) {

fdo |= DOMAGIC_;

if (c == '[')

fdo |= f & DOGLOB;

*dp++ = MAGIC;

}

break;

case '*':

case '?':

if (f & (DOPAT | DOGLOB)) {

fdo |= DOMAGIC_ | (f & DOGLOB);

*dp++ = MAGIC;

}

break;

#ifdef BRACE_EXPAND

case OBRACE:

case ',':

case CBRACE:

if ((f & DOBRACE_) && (c == OBRACE

|| (fdo & DOBRACE_)))

{

fdo |= DOBRACE_|DOMAGIC_;

*dp++ = MAGIC;

}

break;

#endif /* BRACE_EXPAND */

case '=':

/* Note first unquoted = for ~ */

if (!(f & DOTEMP_) && !saw_eq) {

saw_eq = 1;

tilde_ok = 1;

}

break;

case PATHSEP: /* : */

/* Note unquoted : for ~ */

if (!(f & DOTEMP_) && (f & DOASNTILDE))

tilde_ok = 1;

break;

case '~':

/* tilde_ok is reset whenever

* any of ' " $( $(( ${ } are seen.

* Note that tilde_ok must be preserved

* through the sequence ${A=a=}~

*/

if (type == XBASE

&& (f & (DOTILDE|DOASNTILDE))

&& (tilde_ok & 2))

{

char *p, *dp_x;

dp_x = dp;

p = maybe_expand_tilde(sp,

&ds, &dp_x,

f & DOASNTILDE);

if (p) {

if (dp != dp_x)

word = IFS_WORD;

dp = dp_x;

sp = p;

continue;

}

}

break;

}

else

quote &= ~2; /* undo temporary */

if (make_magic) {

make_magic = 0;

fdo |= DOMAGIC_ | (f & DOGLOB);

*dp++ = MAGIC;

} else if (ISMAGIC(c)) {

fdo |= DOMAGIC_;

*dp++ = MAGIC;

}

*dp++ = c; /* save output char */

word = IFS_WORD;

}

}

}

/*

* Prepare to generate the string returned by ${} substitution.

*/

static int

varsub(xp, sp, word, stypep, slenp)

Expand *xp;

char *sp;

char *word;

int *stypep; /* becomes qualifier type */

int *slenp; /* " " len (=, :=, etc.) valid iff *stypep != 0 */

{

int c;

int state; /* next state: XBASE, XARG, XSUB, XNULLSUB */

int stype; /* substitution type */

int slen;

char *p;

struct tbl *vp;

if (sp[0] == '\0') /* Bad variable name */

return -1;

xp->var = NULL;

/* ${#var}, string length or array size */

if (sp[0] == '#' && (c = sp[1]) != '\0') {

int zero_ok = 0;

/* Can't have any modifiers for ${#...} */

if (*word != CSUBST)

return -1;

sp++;

/* Check for size of array */

if ((p=strchr(sp,'[')) && (p[1]=='*'||p[1]=='@') && p[2]==']') {

int n = 0;

vp = global(arrayname(sp));

if (vp->flag & (ISSET|ARRAY))

zero_ok = 1;

for (; vp; vp = vp->u.array)

if (vp->flag & ISSET) {

n++;

}

c = n; /* ksh88/ksh93 go for number, not max index */

} else if (c == '*' || c == '@')

c = e->loc->argc;

else {

p = str_val(global(sp));

zero_ok = p != null;

c = strlen(p);

}

if (Flag(FNOUNSET) && c == 0 && !zero_ok)

errorf("%s: parameter not set", sp);

*stypep = 0; /* unqualified variable/string substitution */

xp->str = str_save(ulton((unsigned long)c, 10), ATEMP);

return XSUB;

}

/* Check for qualifiers in word part */

stype = 0;

c = word[slen = 0] == CHAR ? word[1] : 0;

if (c == ':') {

slen += 2;

stype = 0x80;

c = word[slen + 0] == CHAR ? word[slen + 1] : 0;

}

if (ctype(c, C_SUBOP1)) {

slen += 2;

stype |= c;

} else if (ctype(c, C_SUBOP2)) { /* Note: ksh88 allows :%, :%%, etc */

slen += 2;

stype = c;

if (word[slen + 0] == CHAR && c == word[slen + 1]) {

stype |= 0x80;

slen += 2;

}

} else if (stype) /* : is not ok */

return -1;

if (!stype && *word != CSUBST)

return -1;

*stypep = stype;

*slenp = slen;

c = sp[0];

if (c == '*' || c == '@') {

switch (stype & 0x7f) {

case '=': /* can't assign to a vector */

case '%': /* can't trim a vector (yet) */

case '#':

return -1;

}

if (e->loc->argc == 0) {

xp->u.strv = NULL;

xp->str = null;

state = c == '@' ? XNULLSUB : XSUB;

} else {

char **t = &e->loc->argv[1];

xp->u.strv = (void *)(uintptr_t)t;

xp->str = *xp->u.strv++;

xp->split = c == '@'; /* $@ */

state = XARG;

}

} else {

if ((p=strchr(sp,'[')) && (p[1]=='*'||p[1]=='@') && p[2]==']') {

XPtrV wv;

switch (stype & 0x7f) {

case '=': /* can't assign to a vector */

case '%': /* can't trim a vector (yet) */

case '#':

return -1;

}

XPinit(wv, 32);

vp = global(arrayname(sp));

for (; vp; vp = vp->u.array) {

if (!(vp->flag&ISSET))

continue;

XPput(wv, str_val(vp));

}

if (XPsize(wv) == 0) {

xp->str = null;

state = p[1] == '@' ? XNULLSUB : XSUB;

XPfree(wv);

} else {

XPput(wv, 0);

xp->u.strv = (const char **) XPptrv(wv);

xp->str = *xp->u.strv++;

xp->split = p[1] == '@'; /* ${foo[@]} */

state = XARG;

}

} else {

/* Can't assign things like $! or $1 */

if ((stype & 0x7f) == '='

&& (ctype(*sp, C_VAR1) || digit(*sp)))

return -1;

xp->var = global(sp);

xp->str = str_val(xp->var);

state = XSUB;

}

}

c = stype&0x7f;

/* test the compiler's code generator */

if (ctype(c, C_SUBOP2) ||

(((stype&0x80) ? *xp->str=='\0' : xp->str==null) ? /* undef? */

c == '=' || c == '-' || c == '?' : c == '+'))

state = XBASE; /* expand word instead of variable value */

if (Flag(FNOUNSET) && xp->str == null

&& (ctype(c, C_SUBOP2) || (state != XBASE && c != '+')))

errorf("%s: parameter not set", sp);

return state;

}

/*

* Run the command in $(...) and read its output.

*/

static int

comsub(xp, cp)

register Expand *xp;

char *cp;

{

Source *s, *sold;

register struct op *t;

struct shf *shf;

s = pushs(SSTRING, ATEMP);

s->start = s->str = cp;

sold = source;

t = compile(s);

afree(s, ATEMP);

source = sold;

if (t == NULL)

return XBASE;

if (t != NULL && t->type == TCOM && /* $(<file) */

*t->args == NULL && *t->vars == NULL && t->ioact != NULL) {

register struct ioword *io = *t->ioact;

char *name;

if ((io->flag&IOTYPE) != IOREAD)

errorf("funny $() command: %s",

snptreef((char *) 0, 32, "%R", io));

shf = shf_open(name = evalstr(io->name, DOTILDE), O_RDONLY, 0,

SHF_MAPHI|SHF_CLEXEC);

if (shf == NULL)

errorf("%s: cannot open $() input", name);

xp->split = 0; /* no waitlast() */

} else {

int ofd1, pv[2];

openpipe(pv);

shf = shf_fdopen(pv[0], SHF_RD, (struct shf *) 0);

ofd1 = savefd(1, 0); /* fd 1 may be closed... */

if (pv[1] != 1) {

ksh_dup2(pv[1], 1, FALSE);

close(pv[1]);

}

execute(t, XFORK|XXCOM|XPIPEO);

restfd(1, ofd1);

startlast();

xp->split = 1; /* waitlast() */

}

xp->u.shf = shf;

return XCOM;

}

/*

* perform #pattern and %pattern substitution in ${}

*/

static char *

trimsub(str, pat, how)

register char *str;

char *pat;

int how;

{

register char *end = strchr(str, 0);

register char *p, c;

switch (how&0xff) { /* UCHAR_MAX maybe? */

case '#': /* shortest at beginning */

for (p = str; p <= end; p++) {

c = *p; *p = '\0';

if (gmatch(str, pat, FALSE)) {

*p = c;

return p;

}

*p = c;

}

break;

case '#'|0x80: /* longest match at beginning */

for (p = end; p >= str; p--) {

c = *p; *p = '\0';

if (gmatch(str, pat, FALSE)) {

*p = c;

return p;

}

*p = c;

}

break;

case '%': /* shortest match at end */

for (p = end; p >= str; p--) {

if (gmatch(p, pat, FALSE))

return str_nsave(str, p - str, ATEMP);

}

break;

case '%'|0x80: /* longest match at end */

for (p = str; p <= end; p++) {

if (gmatch(p, pat, FALSE))

return str_nsave(str, p - str, ATEMP);

}

break;

}

return str; /* no match, return string */

}

/*

* glob

* Name derived from V6's /etc/glob, the program that expanded filenames.

*/

/* XXX cp not const 'cause slashes are temporarily replaced with nulls... */

static void

glob(cp, wp, markdirs)

char *cp;

register XPtrV *wp;

int markdirs;

{

int oldsize = XPsize(*wp);

if (glob_str(cp, wp, markdirs) == 0)

XPput(*wp, debunk(cp, cp, strlen(cp) + 1));

else

qsortp(XPptrv(*wp) + oldsize, (size_t)(XPsize(*wp) - oldsize),

xstrcmp);

}

#define GF_NONE 0

#define GF_EXCHECK BIT(0) /* do existence check on file */

#define GF_GLOBBED BIT(1) /* some globbing has been done */

#define GF_MARKDIR BIT(2) /* add trailing / to directories */

/* Apply file globbing to cp and store the matching files in wp. Returns

* the number of matches found.

*/

int

glob_str(cp, wp, markdirs)

char *cp;

XPtrV *wp;

int markdirs;

{

int oldsize = XPsize(*wp);

XString xs;

char *xp;

Xinit(xs, xp, 256, ATEMP);

globit(&xs, &xp, cp, wp, markdirs ? GF_MARKDIR : GF_NONE);

Xfree(xs, xp);

return XPsize(*wp) - oldsize;

}

static void