/contrib/tcsh/sh.glob.c

   1/* $Header: /p/tcsh/cvsroot/tcsh/sh.glob.c,v 3.82 2011/02/27 00:15:17 christos Exp $ */
   2/*
   3 * sh.glob.c: Regular expression expansion
   4 */
   5/*-
   6 * Copyright (c) 1980, 1991 The Regents of the University of California.
   7 * All rights reserved.
   8 *
   9 * Redistribution and use in source and binary forms, with or without
  10 * modification, are permitted provided that the following conditions
  11 * are met:
  12 * 1. Redistributions of source code must retain the above copyright
  13 *    notice, this list of conditions and the following disclaimer.
  14 * 2. Redistributions in binary form must reproduce the above copyright
  15 *    notice, this list of conditions and the following disclaimer in the
  16 *    documentation and/or other materials provided with the distribution.
  17 * 3. Neither the name of the University nor the names of its contributors
  18 *    may be used to endorse or promote products derived from this software
  19 *    without specific prior written permission.
  20 *
  21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31 * SUCH DAMAGE.
  32 */
  33#include "sh.h"
  34
  35RCSID("$tcsh: sh.glob.c,v 3.82 2011/02/27 00:15:17 christos Exp $")
  36
  37#include "tc.h"
  38#include "tw.h"
  39
  40#include "glob.h"
  41
  42/*
  43 * Values for gflag
  44 */
  45#define	G_NONE	0		/* No globbing needed			*/
  46#define	G_GLOB	1		/* string contains *?[] characters	*/
  47#define	G_CSH	2		/* string contains ~`{ characters	*/
  48
  49#define	GLOBSPACE	100	/* Alloc increment			*/
  50
  51
  52#define LBRC '{'
  53#define RBRC '}'
  54#define LBRK '['
  55#define RBRK ']'
  56#define EOS '\0'
  57
  58/*
  59 * globbing is now done in two stages. In the first pass we expand
  60 * csh globbing idioms ~`{ and then we proceed doing the normal
  61 * globbing if needed ?*[
  62 *
  63 * Csh type globbing is handled in globexpand() and the rest is
  64 * handled in glob() which is part of the 4.4BSD libc.
  65 *
  66 */
  67static	Char	 *globtilde	(Char *);
  68static	Char     *handleone	(Char *, Char **, int);
  69static	Char	**libglob	(Char **);
  70static	Char	**globexpand	(Char **, int);
  71static	int	  globbrace	(const Char *, Char ***);
  72static  void	  expbrace	(Char ***, Char ***, int);
  73static	void	  pword		(struct blk_buf *, struct Strbuf *);
  74static	void	  backeval	(struct blk_buf *, struct Strbuf *, Char *,
  75				 int);
  76static Char *
  77globtilde(Char *s)
  78{
  79    Char *name, *u, *home, *res;
  80
  81    u = s;
  82    for (s++; *s && *s != '/' && *s != ':'; s++)
  83	continue;
  84    name = Strnsave(u + 1, s - (u + 1));
  85    cleanup_push(name, xfree);
  86    home = gethdir(name);
  87    if (home == NULL) {
  88	if (adrof(STRnonomatch)) {
  89	    cleanup_until(name);
  90	    return u;
  91	}
  92	if (*name)
  93	    stderror(ERR_UNKUSER, short2str(name));
  94	else
  95	    stderror(ERR_NOHOME);
  96    }
  97    cleanup_until(name);
  98    if (home[0] == '/' && home[1] == '\0' && s[0] == '/')
  99	res = Strsave(s);
 100    else
 101	res = Strspl(home, s);
 102    xfree(home);
 103    xfree(u);
 104    return res;
 105}
 106
 107/* Returns a newly allocated string, old or NULL */
 108Char *
 109globequal(Char *old)
 110{
 111    int     dig;
 112    const Char *dir;
 113    Char    *b;
 114
 115    /*
 116     * kfk - 17 Jan 1984 - stack hack allows user to get at arbitrary dir names
 117     * in stack. PWP: let =foobar pass through (for X windows)
 118     */
 119    if (old[1] == '-' && (old[2] == '\0' || old[2] == '/')) {
 120	/* =- */
 121	const Char *olddir = varval (STRowd);
 122
 123	if (olddir && *olddir &&
 124	    !dcwd->di_next->di_name && !dcwd->di_prev->di_name)
 125	    return Strspl(olddir, &old[2]);
 126	dig = -1;
 127	b = &old[2];
 128    }
 129    else if (Isdigit(old[1])) {
 130	/* =<number> */
 131	dig = old[1] - '0';
 132	for (b = &old[2]; Isdigit(*b); b++)
 133	    dig = dig * 10 + (*b - '0');
 134	if (*b != '\0' && *b != '/')
 135	    /* =<number>foobar */
 136	    return old;
 137    }
 138    else
 139	/* =foobar */
 140	return old;
 141
 142    dir = getstakd(dig);
 143    if (dir == NULL)
 144	return NULL;
 145    return Strspl(dir, b);
 146}
 147
 148static int
 149globbrace(const Char *s, Char ***bl)
 150{
 151    struct Strbuf gbuf = Strbuf_INIT;
 152    struct blk_buf bb = BLK_BUF_INIT;
 153    int     i;
 154    const Char *p, *pm, *pe, *pl;
 155    size_t prefix_len;
 156
 157    /* copy part up to the brace */
 158    for (p = s; *p != LBRC; p++)
 159	;
 160    prefix_len = p - s;
 161
 162    /* check for balanced braces */
 163    for (i = 0, pe = ++p; *pe; pe++)
 164	if (*pe == LBRK) {
 165	    /* Ignore everything between [] */
 166	    for (++pe; *pe != RBRK && *pe != EOS; pe++)
 167		continue;
 168	    if (*pe == EOS)
 169		return (-RBRK);
 170	}
 171	else if (*pe == LBRC)
 172	    i++;
 173	else if (*pe == RBRC) {
 174	    if (i == 0)
 175		break;
 176	    i--;
 177	}
 178
 179    if (i != 0 || *pe == '\0')
 180	return (-RBRC);
 181
 182    Strbuf_appendn(&gbuf, s, prefix_len);
 183
 184    for (i = 0, pl = pm = p; pm <= pe; pm++)
 185	switch (*pm) {
 186	case LBRK:
 187	    for (++pm; *pm != RBRK && *pm != EOS; pm++)
 188		continue;
 189	    if (*pm == EOS) {
 190		bb_cleanup(&bb);
 191		xfree(gbuf.s);
 192		return (-RBRK);
 193	    }
 194	    break;
 195	case LBRC:
 196	    i++;
 197	    break;
 198	case RBRC:
 199	    if (i) {
 200		i--;
 201		break;
 202	    }
 203	    /* FALLTHROUGH */
 204	case ',':
 205	    if (i && *pm == ',')
 206		break;
 207	    else {
 208		gbuf.len = prefix_len;
 209		Strbuf_appendn(&gbuf, pl, pm - pl);
 210		Strbuf_append(&gbuf, pe + 1);
 211		Strbuf_terminate(&gbuf);
 212		bb_append(&bb, Strsave(gbuf.s));
 213		pl = pm + 1;
 214	    }
 215	    break;
 216	default:
 217	    break;
 218	}
 219    *bl = bb_finish(&bb);
 220    xfree(gbuf.s);
 221    return bb.len;
 222}
 223
 224
 225static void
 226expbrace(Char ***nvp, Char ***elp, int size)
 227{
 228    Char **vl, **el, **nv, *s;
 229
 230    vl = nv = *nvp;
 231    if (elp != NULL)
 232	el = *elp;
 233    else
 234	el = vl + blklen(vl);
 235
 236    for (s = *vl; s; s = *++vl) {
 237	Char  **vp, **bp;
 238
 239	/* leave {} untouched for find */
 240	if (s[0] == '{' && (s[1] == '\0' || (s[1] == '}' && s[2] == '\0')))
 241	    continue;
 242	if (Strchr(s, '{') != NULL) {
 243	    Char  **bl = NULL;
 244	    int     len;
 245
 246	    if ((len = globbrace(s, &bl)) < 0)
 247		stderror(ERR_MISSING, -len);
 248	    xfree(s);
 249	    if (len == 1) {
 250		*vl-- = *bl;
 251		xfree(bl);
 252		continue;
 253	    }
 254	    if (&el[len] >= &nv[size]) {
 255		size_t l, e;
 256		l = &el[len] - &nv[size];
 257		size += GLOBSPACE > l ? GLOBSPACE : l;
 258		l = vl - nv;
 259		e = el - nv;
 260		nv = xrealloc(nv, size * sizeof(Char *));
 261		*nvp = nv; /* To keep cleanups working */
 262		vl = nv + l;
 263		el = nv + e;
 264	    }
 265	    /* nv vl   el     bl
 266	     * |  |    |      |
 267	     * -.--..--	      x--
 268	     *   |            len
 269	     *   vp
 270	     */
 271	    vp = vl--;
 272	    *vp = *bl;
 273	    len--;
 274	    for (bp = el; bp != vp; bp--)
 275		bp[len] = *bp;
 276	    el += len;
 277	    /* nv vl    el bl
 278	     * |  |     |  |
 279	     * -.-x  ---    --
 280	     *   |len
 281	     *   vp
 282	     */
 283	    vp++;
 284	    for (bp = bl + 1; *bp; *vp++ = *bp++)
 285		continue;
 286	    xfree(bl);
 287	}
 288
 289    }
 290    if (elp != NULL)
 291	*elp = el;
 292}
 293
 294static Char **
 295globexpand(Char **v, int noglob)
 296{
 297    Char   *s;
 298    Char  ***fnv, **vl, **el;
 299    int     size = GLOBSPACE;
 300
 301
 302    fnv = xmalloc(sizeof(Char ***));
 303    *fnv = vl = xmalloc(sizeof(Char *) * size);
 304    *vl = NULL;
 305    cleanup_push(fnv, blk_indirect_cleanup);
 306
 307    /*
 308     * Step 1: expand backquotes.
 309     */
 310    while ((s = *v++) != '\0') {
 311	if (Strchr(s, '`')) {
 312	    int     i;
 313	    Char **expanded;
 314
 315	    expanded = dobackp(s, 0);
 316	    for (i = 0; expanded[i] != NULL; i++) {
 317		*vl++ = expanded[i];
 318		if (vl == &(*fnv)[size]) {
 319		    size += GLOBSPACE;
 320		    *fnv = xrealloc(*fnv, size * sizeof(Char *));
 321		    vl = &(*fnv)[size - GLOBSPACE];
 322		}
 323	    }
 324	    xfree(expanded);
 325	}
 326	else {
 327	    *vl++ = Strsave(s);
 328	    if (vl == &(*fnv)[size]) {
 329		size += GLOBSPACE;
 330		*fnv = xrealloc(*fnv, size * sizeof(Char *));
 331		vl = &(*fnv)[size - GLOBSPACE];
 332	    }
 333	}
 334	*vl = NULL;
 335    }
 336
 337    if (noglob)
 338	goto done;
 339
 340    /*
 341     * Step 2: expand braces
 342     */
 343    el = vl;
 344    expbrace(fnv, &el, size);
 345
 346
 347    /*
 348     * Step 3: expand ~ =
 349     */
 350    vl = *fnv;
 351    for (s = *vl; s; s = *++vl)
 352	switch (*s) {
 353	    Char *ns;
 354	case '~':
 355	    *vl = globtilde(s);
 356	    break;
 357	case '=':
 358	    if ((ns = globequal(s)) == NULL) {
 359		if (!adrof(STRnonomatch))
 360		    stderror(ERR_DEEP); /* Error */
 361	    }
 362	    if (ns && ns != s) {
 363		/* Expansion succeeded */
 364		xfree(s);
 365		*vl = ns;
 366	    }
 367	    break;
 368	default:
 369	    break;
 370	}
 371    vl = *fnv;
 372
 373    /*
 374     * Step 4: expand .. if the variable symlinks==expand is set
 375     */
 376    if (symlinks == SYM_EXPAND) {
 377	for (s = *vl; s; s = *++vl) {
 378	    *vl = dnormalize(s, 1);
 379	    xfree(s);
 380	}
 381    }
 382
 383 done:
 384    cleanup_ignore(fnv);
 385    cleanup_until(fnv);
 386    vl = *fnv;
 387    xfree(fnv);
 388    return vl;
 389}
 390
 391static Char *
 392handleone(Char *str, Char **vl, int action)
 393{
 394    size_t chars;
 395    Char **t, *p, *strp;
 396
 397    switch (action) {
 398    case G_ERROR:
 399	setname(short2str(str));
 400	blkfree(vl);
 401	stderror(ERR_NAME | ERR_AMBIG);
 402	break;
 403    case G_APPEND:
 404	chars = 0;
 405	for (t = vl; (p = *t++) != NULL; chars++)
 406	    chars += Strlen(p);
 407	str = xmalloc(chars * sizeof(Char));
 408	for (t = vl, strp = str; (p = *t++) != '\0'; chars++) {
 409	    while (*p)
 410		 *strp++ = *p++ & TRIM;
 411	    *strp++ = ' ';
 412	}
 413	*--strp = '\0';
 414	blkfree(vl);
 415	break;
 416    case G_IGNORE:
 417	str = Strsave(strip(*vl));
 418	blkfree(vl);
 419	break;
 420    default:
 421	break;
 422    }
 423    return (str);
 424}
 425
 426static Char **
 427libglob(Char **vl)
 428{
 429    int     gflgs = GLOB_QUOTE | GLOB_NOMAGIC | GLOB_ALTNOT;
 430    glob_t  globv;
 431    char   *ptr;
 432    int     nonomatch = adrof(STRnonomatch) != 0, magic = 0, match = 0;
 433
 434    if (adrof(STRglobdot))
 435       gflgs |= GLOB_DOT;
 436
 437    if (adrof(STRglobstar))
 438       gflgs |= GLOB_STAR;
 439
 440    if (!vl || !vl[0])
 441	return(vl);
 442
 443    globv.gl_offs = 0;
 444    globv.gl_pathv = 0;
 445    globv.gl_pathc = 0;
 446
 447    if (nonomatch)
 448	gflgs |= GLOB_NOCHECK;
 449
 450    do {
 451	ptr = short2qstr(*vl);
 452	switch (glob(ptr, gflgs, 0, &globv)) {
 453	case GLOB_ABEND:
 454	    globfree(&globv);
 455	    setname(ptr);
 456	    stderror(ERR_NAME | ERR_GLOB);
 457	    /* NOTREACHED */
 458	case GLOB_NOSPACE:
 459	    globfree(&globv);
 460	    stderror(ERR_NOMEM);
 461	    /* NOTREACHED */
 462	default:
 463	    break;
 464	}
 465	if (globv.gl_flags & GLOB_MAGCHAR) {
 466	    match |= (globv.gl_matchc != 0);
 467	    magic = 1;
 468	}
 469	gflgs |= GLOB_APPEND;
 470    }
 471    while (*++vl);
 472    vl = (globv.gl_pathc == 0 || (magic && !match && !nonomatch)) ? 
 473	NULL : blk2short(globv.gl_pathv);
 474    globfree(&globv);
 475    return (vl);
 476}
 477
 478Char   *
 479globone(Char *str, int action)
 480{
 481    Char   *v[2], **vl, **vo;
 482    int gflg, noglob;
 483
 484    noglob = adrof(STRnoglob) != 0;
 485    v[0] = str;
 486    v[1] = 0;
 487    gflg = tglob(v);
 488    if (gflg == G_NONE)
 489	return (strip(Strsave(str)));
 490
 491    if (gflg & G_CSH) {
 492	/*
 493	 * Expand back-quote, tilde and brace
 494	 */
 495	vo = globexpand(v, noglob);
 496	if (noglob || (gflg & G_GLOB) == 0) {
 497	    vl = vo;
 498	    goto result;
 499	}
 500	cleanup_push(vo, blk_cleanup);
 501    }
 502    else if (noglob || (gflg & G_GLOB) == 0)
 503	return (strip(Strsave(str)));
 504    else
 505	vo = v;
 506
 507    vl = libglob(vo);
 508    if (gflg & G_CSH) {
 509    	if (vl != vo)
 510	    cleanup_until(vo);
 511	else
 512	    cleanup_ignore(vo);
 513    }
 514    if (vl == NULL) {
 515	setname(short2str(str));
 516	stderror(ERR_NAME | ERR_NOMATCH);
 517    }
 518 result:
 519    if (vl && vl[0] == NULL) {
 520	xfree(vl);
 521	return (Strsave(STRNULL));
 522    }
 523    if (vl && vl[1]) 
 524	return (handleone(str, vl, action));
 525    else {
 526	str = strip(*vl);
 527	xfree(vl);
 528	return (str);
 529    }
 530}
 531
 532Char  **
 533globall(Char **v, int gflg)
 534{
 535    Char  **vl, **vo;
 536    int noglob;
 537
 538    if (!v || !v[0])
 539	return saveblk(v);
 540
 541    noglob = adrof(STRnoglob) != 0;
 542
 543    if (gflg & G_CSH)
 544	/*
 545	 * Expand back-quote, tilde and brace
 546	 */
 547	vl = vo = globexpand(v, noglob);
 548    else
 549	vl = vo = saveblk(v);
 550
 551    if (!noglob && (gflg & G_GLOB)) {
 552	cleanup_push(vo, blk_cleanup);
 553	vl = libglob(vo);
 554	if (vl == vo)
 555	    cleanup_ignore(vo);
 556	cleanup_until(vo);
 557    }
 558    else
 559	trim(vl);
 560
 561    return vl;
 562}
 563
 564Char **
 565glob_all_or_error(Char **v)
 566{
 567    int gflag;
 568
 569    gflag = tglob(v);
 570    if (gflag) {
 571	v = globall(v, gflag);
 572	if (v == NULL)
 573	    stderror(ERR_NAME | ERR_NOMATCH);
 574    } else {
 575	v = saveblk(v);
 576	trim(v);
 577    }
 578    return v;
 579}
 580
 581void
 582rscan(Char **t, void (*f) (Char))
 583{
 584    Char *p;
 585
 586    while ((p = *t++) != '\0')
 587	while (*p)
 588	    (*f) (*p++);
 589}
 590
 591void
 592trim(Char **t)
 593{
 594    Char *p;
 595
 596    while ((p = *t++) != '\0')
 597	while (*p)
 598	    *p++ &= TRIM;
 599}
 600
 601int
 602tglob(Char **t)
 603{
 604    int gflag;
 605    const Char *p;
 606
 607    gflag = 0;
 608    while ((p = *t++) != '\0') {
 609	if (*p == '~' || *p == '=')
 610	    gflag |= G_CSH;
 611	else if (*p == '{' &&
 612		 (p[1] == '\0' || (p[1] == '}' && p[2] == '\0')))
 613	    continue;
 614	while (*p != '\0') {
 615	    if (*p == '`') {
 616		gflag |= G_CSH;
 617#ifdef notdef
 618		/*
 619		 * We do want to expand echo `echo '*'`, so we don't\
 620		 * use this piece of code anymore.
 621		 */
 622		p++;
 623		while (*p && *p != '`') 
 624		    if (*p++ == '\\') {
 625			if (*p)		/* Quoted chars */
 626			    p++;
 627			else
 628			    break;
 629		    }
 630		if (!*p)		/* The matching ` */
 631		    break;
 632#endif
 633	    }
 634	    else if (*p == '{')
 635		gflag |= G_CSH;
 636	    else if (isglob(*p))
 637		gflag |= G_GLOB;
 638	    else if (symlinks == SYM_EXPAND && 
 639		p[1] && ISDOTDOT(p) && (p == *(t-1) || *(p-1) == '/') )
 640	    	gflag |= G_CSH;
 641	    p++;
 642	}
 643    }
 644    return gflag;
 645}
 646
 647/*
 648 * Command substitute cp.  If literal, then this is a substitution from a
 649 * << redirection, and so we should not crunch blanks and tabs, separating
 650 * words only at newlines.
 651 */
 652Char  **
 653dobackp(Char *cp, int literal)
 654{
 655    struct Strbuf word = Strbuf_INIT;
 656    struct blk_buf bb = BLK_BUF_INIT;
 657    Char *lp, *rp, *ep;
 658
 659    cleanup_push(&bb, bb_cleanup);
 660    cleanup_push(&word, Strbuf_cleanup);
 661    for (;;) {
 662	for (lp = cp; *lp != '\0' && *lp != '`'; lp++)
 663	    ;
 664	Strbuf_appendn(&word, cp, lp - cp);
 665	if (*lp == 0)
 666	    break;
 667	lp++;
 668	for (rp = lp; *rp && *rp != '`'; rp++)
 669	    if (*rp == '\\') {
 670		rp++;
 671		if (!*rp)
 672		    goto oops;
 673	    }
 674	if (!*rp) {
 675	oops:
 676	    cleanup_until(&bb);
 677	    stderror(ERR_UNMATCHED, '`');
 678	}
 679	ep = Strnsave(lp, rp - lp);
 680	cleanup_push(ep, xfree);
 681	backeval(&bb, &word, ep, literal);
 682	cleanup_until(ep);
 683	cp = rp + 1;
 684    }
 685    if (word.len != 0)
 686	pword(&bb, &word);
 687    cleanup_ignore(&bb);
 688    cleanup_until(&bb);
 689    return bb_finish(&bb);
 690}
 691
 692
 693static void
 694backeval(struct blk_buf *bb, struct Strbuf *word, Char *cp, int literal)
 695{
 696    ssize_t icnt;
 697    Char c, *ip;
 698    struct command faket;
 699    int    hadnl;
 700    int     pvec[2], quoted;
 701    Char   *fakecom[2], ibuf[BUFSIZE];
 702    char    tibuf[BUFSIZE];
 703
 704    hadnl = 0;
 705    icnt = 0;
 706    quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
 707    faket.t_dtyp = NODE_COMMAND;
 708    faket.t_dflg = F_BACKQ;
 709    faket.t_dlef = 0;
 710    faket.t_drit = 0;
 711    faket.t_dspr = 0;
 712    faket.t_dcom = fakecom;
 713    fakecom[0] = STRfakecom1;
 714    fakecom[1] = 0;
 715
 716    /*
 717     * We do the psave job to temporarily change the current job so that the
 718     * following fork is considered a separate job.  This is so that when
 719     * backquotes are used in a builtin function that calls glob the "current
 720     * job" is not corrupted.  We only need one level of pushed jobs as long as
 721     * we are sure to fork here.
 722     */
 723    psavejob();
 724    cleanup_push(&faket, psavejob_cleanup); /* faket is only a marker */
 725
 726    /*
 727     * It would be nicer if we could integrate this redirection more with the
 728     * routines in sh.sem.c by doing a fake execute on a builtin function that
 729     * was piped out.
 730     */
 731    mypipe(pvec);
 732    cleanup_push(&pvec[0], open_cleanup);
 733    cleanup_push(&pvec[1], open_cleanup);
 734    if (pfork(&faket, -1) == 0) {
 735	jmp_buf_t osetexit;
 736	struct command *t;
 737	size_t omark;
 738
 739	xclose(pvec[0]);
 740	(void) dmove(pvec[1], 1);
 741	(void) dmove(SHDIAG,  2);
 742	initdesc();
 743	closem();
 744	arginp = cp;
 745	for (arginp = cp; *cp; cp++) {
 746	    *cp &= TRIM;
 747	    if (is_set(STRcsubstnonl) && (*cp == '\n' || *cp == '\r'))
 748		*cp = ' ';
 749	}
 750
 751        /*
 752	 * In the child ``forget'' everything about current aliases or
 753	 * eval vectors.
 754	 */
 755	alvec = NULL;
 756	evalvec = NULL;
 757	alvecp = NULL;
 758	evalp = NULL;
 759
 760	omark = cleanup_push_mark();
 761	getexit(osetexit);
 762	for (;;) {
 763	    (void) setexit();
 764	    justpr = 0;
 765	    
 766	    if (haderr) {
 767		/* unwind */
 768		doneinp = 0;
 769		cleanup_pop_mark(omark);
 770		resexit(osetexit);
 771		reset();
 772	    }
 773	    if (seterr) {
 774		xfree(seterr);
 775		seterr = NULL;
 776	    }
 777
 778	    (void) lex(&paraml);
 779	    cleanup_push(&paraml, lex_cleanup);
 780	    if (seterr)
 781		stderror(ERR_OLD);
 782	    alias(&paraml);
 783	    t = syntax(paraml.next, &paraml, 0);
 784	    if (t == NULL)
 785		return;
 786	    cleanup_push(t, syntax_cleanup);
 787	    /* The F_BACKQ flag must set so the job output is correct if
 788	     * printexitvalue is set.  If it's not set, the job output
 789	     * will have "Exit N" appended where N is the exit status. */
 790	    t->t_dflg = F_BACKQ|F_NOFORK;
 791	    if (seterr)
 792		stderror(ERR_OLD);
 793#ifdef SIGTSTP
 794	    signal(SIGTSTP, SIG_IGN);
 795#endif
 796#ifdef SIGTTIN
 797	    signal(SIGTTIN, SIG_IGN);
 798#endif
 799#ifdef SIGTTOU
 800	    signal(SIGTTOU, SIG_IGN);
 801#endif
 802	    execute(t, -1, NULL, NULL, TRUE);
 803
 804	    cleanup_until(&paraml);
 805	}
 806    }
 807    cleanup_until(&pvec[1]);
 808    c = 0;
 809    ip = NULL;
 810    do {
 811	ssize_t     cnt = 0;
 812	char   *tmp;
 813
 814	tmp = tibuf;
 815	for (;;) {
 816	    while (icnt == 0) {
 817		int     i, eof;
 818
 819		ip = ibuf;
 820		icnt = xread(pvec[0], tmp, tibuf + BUFSIZE - tmp);
 821		eof = 0;
 822		if (icnt <= 0) {
 823		    if (tmp == tibuf)
 824			goto eof;
 825		    icnt = 0;
 826		    eof = 1;
 827		}
 828		icnt += tmp - tibuf;
 829		i = 0;
 830		tmp = tibuf;
 831		while (tmp < tibuf + icnt) {
 832		    int len;
 833
 834		    len = normal_mbtowc(&ip[i], tmp, tibuf + icnt - tmp);
 835		    if (len == -1) {
 836		        reset_mbtowc();
 837		        if (!eof && (size_t)(tibuf + icnt - tmp) < MB_CUR_MAX) {
 838			    break; /* Maybe a partial character */
 839			}
 840			ip[i] = (unsigned char) *tmp | INVALID_BYTE; /* Error */
 841		    }
 842		    if (len <= 0)
 843		        len = 1;
 844		    i++;
 845		    tmp += len;
 846		}
 847		if (tmp != tibuf)
 848		    memmove (tibuf, tmp, tibuf + icnt - tmp);
 849		tmp = tibuf + (tibuf + icnt - tmp);
 850		icnt = i;
 851	    }
 852	    if (hadnl)
 853		break;
 854	    --icnt;
 855	    c = (*ip++ & TRIM);
 856	    if (c == 0)
 857		break;
 858#if defined(WINNT_NATIVE) || defined(__CYGWIN__)
 859	    if (c == '\r')
 860	    	c = ' ';
 861#endif /* WINNT_NATIVE || __CYGWIN__ */
 862	    if (c == '\n') {
 863		/*
 864		 * Continue around the loop one more time, so that we can eat
 865		 * the last newline without terminating this word.
 866		 */
 867		hadnl = 1;
 868		continue;
 869	    }
 870	    if (!quoted && (c == ' ' || c == '\t'))
 871		break;
 872	    cnt++;
 873	    Strbuf_append1(word, c | quoted);
 874	}
 875	/*
 876	 * Unless at end-of-file, we will form a new word here if there were
 877	 * characters in the word, or in any case when we take text literally.
 878	 * If we didn't make empty words here when literal was set then we
 879	 * would lose blank lines.
 880	 */
 881	if (c != 0 && (cnt || literal))
 882	    pword(bb, word);
 883	hadnl = 0;
 884    } while (c > 0);
 885 eof:
 886    cleanup_until(&pvec[0]);
 887    pwait();
 888    cleanup_until(&faket); /* psavejob_cleanup(); */
 889}
 890
 891static void
 892pword(struct blk_buf *bb, struct Strbuf *word)
 893{
 894    Char *s;
 895
 896    s = Strbuf_finish(word);
 897    bb_append(bb, s);
 898    *word = Strbuf_init;
 899}
 900
 901int
 902Gmatch(const Char *string, const Char *pattern)
 903{
 904    return Gnmatch(string, pattern, NULL);
 905}
 906
 907int
 908Gnmatch(const Char *string, const Char *pattern, const Char **endstr)
 909{
 910    Char ***fblk, **p;
 911    const Char *tstring = string;
 912    int	   gpol = 1, gres = 0;
 913
 914    if (*pattern == '^') {
 915	gpol = 0;
 916	pattern++;
 917    }
 918
 919    fblk = xmalloc(sizeof(Char ***));
 920    *fblk = xmalloc(GLOBSPACE * sizeof(Char *));
 921    (*fblk)[0] = Strsave(pattern);
 922    (*fblk)[1] = NULL;
 923
 924    cleanup_push(fblk, blk_indirect_cleanup);
 925    expbrace(fblk, NULL, GLOBSPACE);
 926
 927    if (endstr == NULL)
 928	/* Exact matches only */
 929	for (p = *fblk; *p; p++) 
 930	    gres |= t_pmatch(string, *p, &tstring, 1) == 2 ? 1 : 0;
 931    else {
 932	const Char *end;
 933
 934	/* partial matches */
 935        end = Strend(string);
 936	for (p = *fblk; *p; p++)
 937	    if (t_pmatch(string, *p, &tstring, 1) != 0) {
 938		gres |= 1;
 939		if (end > tstring)
 940		    end = tstring;
 941	    }
 942	*endstr = end;
 943    }
 944
 945    cleanup_until(fblk);
 946    return(gres == gpol);
 947} 
 948
 949/* t_pmatch():
 950 *	Return 2 on exact match, 	
 951 *	Return 1 on substring match.
 952 *	Return 0 on no match.
 953 *	*estr will point to the end of the longest exact or substring match.
 954 */
 955int
 956t_pmatch(const Char *string, const Char *pattern, const Char **estr, int cs)
 957{
 958    Char stringc, patternc, rangec;
 959    int     match, negate_range;
 960    const Char *pestr, *nstring;
 961
 962    for (nstring = string;; string = nstring) {
 963	stringc = *nstring++ & TRIM;
 964	patternc = *pattern++ & TRIM;
 965	switch (patternc) {
 966	case '\0':
 967	    *estr = string;
 968	    return (stringc == '\0' ? 2 : 1);
 969	case '?':
 970	    if (stringc == 0)
 971		return (0);
 972	    break;
 973	case '*':
 974	    if (!*pattern) {
 975		*estr = Strend(string);
 976		return (2);
 977	    }
 978	    pestr = NULL;
 979
 980	    for (;;) {
 981		switch(t_pmatch(string, pattern, estr, cs)) {
 982		case 0:
 983		    break;
 984		case 1:
 985		    pestr = *estr;/*FIXME: does not guarantee longest match */
 986		    break;
 987		case 2:
 988		    return 2;
 989		default:
 990		    abort();	/* Cannot happen */
 991		}
 992		stringc = *string++ & TRIM;
 993		if (!stringc)
 994		    break;
 995	    }
 996
 997	    if (pestr) {
 998		*estr = pestr;
 999		return 1;
1000	    }
1001	    else
1002		return 0;
1003
1004	case '[':
1005	    match = 0;
1006	    if ((negate_range = (*pattern == '^')) != 0)
1007		pattern++;
1008	    while ((rangec = *pattern++ & TRIM) != '\0') {
1009		if (rangec == ']')
1010		    break;
1011		if (match)
1012		    continue;
1013		if (*pattern == '-' && pattern[1] != ']') {
1014		    Char rangec2;
1015		    pattern++;
1016		    rangec2 = *pattern++ & TRIM;
1017		    match = (globcharcoll(stringc, rangec2, 0) <= 0 &&
1018			globcharcoll(rangec, stringc, 0) <= 0);
1019		}
1020		else 
1021		    match = (stringc == rangec);
1022	    }
1023	    if (rangec == '\0')
1024		stderror(ERR_NAME | ERR_MISSING, ']');
1025	    if ((!match) && (stringc == '\0'))
1026		return (0);
1027	    if (match == negate_range)
1028		return (0);
1029	    break;
1030	default:
1031	    if (cs ? patternc  != stringc
1032		: Tolower(patternc) != Tolower(stringc))
1033		return (0);
1034	    break;
1035	}
1036    }
1037}