Home | History | Annotate | Line # | Download | only in csh
glob.c revision 1.27 
      1 /* $NetBSD: glob.c,v 1.27 2013/07/16 17:47:43 christos Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 1980, 1991, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 #ifndef lint
     34 #if 0
     35 static char sccsid[] = "@(#)glob.c	8.1 (Berkeley) 5/31/93";
     36 #else
     37 __RCSID("$NetBSD: glob.c,v 1.27 2013/07/16 17:47:43 christos Exp $");
     38 #endif
     39 #endif /* not lint */
     40 
     41 #include <sys/param.h>
     42 
     43 #include <errno.h>
     44 #include <glob.h>
     45 #include <stdarg.h>
     46 #include <stddef.h>
     47 #include <stdlib.h>
     48 #include <string.h>
     49 #include <unistd.h>
     50 
     51 #include "csh.h"
     52 #include "extern.h"
     53 
     54 static int noglob;
     55 static int gargsiz, pargsiz;
     56 
     57 /*
     58  * Values for gflag
     59  */
     60 #define	G_NONE 0		/* No globbing needed			*/
     61 #define	G_GLOB 1		/* string contains *?[] characters	*/
     62 #define	G_CSH 2			/* string contains ~`{ characters	*/
     63 
     64 #define	GLOBSPACE 100		/* Alloc increment			*/
     65 
     66 #define LBRC '{'
     67 #define RBRC '}'
     68 #define LBRK '['
     69 #define RBRK ']'
     70 #define EOS '\0'
     71 
     72 Char **gargv = NULL;
     73 Char **pargv = NULL;
     74 long gargc = 0;
     75 long pargc = 0;
     76 
     77 /*
     78  * globbing is now done in two stages. In the first pass we expand
     79  * csh globbing idioms ~`{ and then we proceed doing the normal
     80  * globbing if needed ?*[
     81  *
     82  * Csh type globbing is handled in globexpand() and the rest is
     83  * handled in glob() which is part of the 4.4BSD libc.
     84  *
     85  */
     86 static Char *globtilde(Char **, Char *);
     87 static Char *handleone(Char *, Char **, int);
     88 static Char **libglob(Char **);
     89 static Char **globexpand(Char **);
     90 static int globbrace(Char *, Char *, Char ***);
     91 static void expbrace(Char ***, Char ***, size_t);
     92 static int pmatch(Char *, Char *);
     93 static void pword(void);
     94 static void psave(int);
     95 static void backeval(Char *, int);
     96 
     97 static Char *
     98 globtilde(Char **nv, Char *s)
     99 {
    100     Char gbuf[MAXPATHLEN], *b, *e, *gstart, *u;
    101 
    102     gstart = gbuf;
    103     *gstart++ = *s++;
    104     u = s;
    105     for (b = gstart, e = &gbuf[MAXPATHLEN - 1];
    106 	 *s && *s != '/' && *s != ':' && b < e;
    107 	 *b++ = *s++)
    108 	 continue;
    109     *b = EOS;
    110     if (gethdir(gstart)) {
    111 	blkfree(nv);
    112 	if (*gstart)
    113 	    stderror(ERR_UNKUSER, vis_str(gstart));
    114 	else
    115 	    stderror(ERR_NOHOME);
    116     }
    117     b = &gstart[Strlen(gstart)];
    118     while (*s)
    119 	*b++ = *s++;
    120     *b = EOS;
    121     --u;
    122     xfree((ptr_t) u);
    123     return (Strsave(gstart));
    124 }
    125 
    126 static int
    127 globbrace(Char *s, Char *p, Char ***bl)
    128 {
    129     Char gbuf[MAXPATHLEN];
    130     Char *lm, *pe, *pl, *pm, **nv, **vl;
    131     int i, len, size;
    132 
    133     size = GLOBSPACE;
    134     nv = vl = xmalloc(sizeof(Char *) * (size_t)size);
    135     *vl = NULL;
    136     len = 0;
    137     /* copy part up to the brace */
    138     for (lm = gbuf, p = s; *p != LBRC; *lm++ = *p++)
    139 	continue;
    140 
    141     /* check for balanced braces */
    142     for (i = 0, pe = ++p; *pe; pe++)
    143 	if (*pe == LBRK) {
    144 	    /* Ignore everything between [] */
    145 	    for (++pe; *pe != RBRK && *pe != EOS; pe++)
    146 		continue;
    147 	    if (*pe == EOS) {
    148 		blkfree(nv);
    149 		return (-RBRK);
    150 	    }
    151 	}
    152 	else if (*pe == LBRC)
    153 	    i++;
    154 	else if (*pe == RBRC) {
    155 	    if (i == 0)
    156 		break;
    157 	    i--;
    158 	}
    159 
    160     if (i != 0 || *pe == '\0') {
    161 	blkfree(nv);
    162 	return (-RBRC);
    163     }
    164 
    165     for (i = 0, pl = pm = p; pm <= pe; pm++)
    166 	switch (*pm) {
    167 	case LBRK:
    168 	    for (++pm; *pm != RBRK && *pm != EOS; pm++)
    169 		continue;
    170 	    if (*pm == EOS) {
    171 		*vl = NULL;
    172 		blkfree(nv);
    173 		return (-RBRK);
    174 	    }
    175 	    break;
    176 	case LBRC:
    177 	    i++;
    178 	    break;
    179 	case RBRC:
    180 	    if (i) {
    181 		i--;
    182 		break;
    183 	    }
    184 	    /* FALLTHROUGH */
    185 	case ',':
    186 	    if (i && *pm == ',')
    187 		break;
    188 	    else {
    189 		Char    savec = *pm;
    190 
    191 		*pm = EOS;
    192 		(void)Strcpy(lm, pl);
    193 		(void)Strcat(gbuf, pe + 1);
    194 		*pm = savec;
    195 		*vl++ = Strsave(gbuf);
    196 		len++;
    197 		pl = pm + 1;
    198 		if (vl == &nv[size]) {
    199 		    size += GLOBSPACE;
    200 		    nv = (Char **)xrealloc((ptr_t) nv,
    201 		        (size_t)size * sizeof(Char *));
    202 		    vl = &nv[size - GLOBSPACE];
    203 		}
    204 	    }
    205 	    break;
    206 	default:
    207 	    break;
    208 	}
    209     *vl = NULL;
    210     *bl = nv;
    211     return (len);
    212 }
    213 
    214 static void
    215 expbrace(Char ***nvp, Char ***elp, size_t size)
    216 {
    217     Char **ex, **nv, *s, **vl;
    218 
    219     vl = nv = *nvp;
    220     if (elp != NULL)
    221 	ex = *elp;
    222     else
    223 	for (ex = vl; *ex; ex++)
    224 	    continue;
    225 
    226     for (s = *vl; s; s = *++vl) {
    227 	Char *b, **bp, **vp;
    228 
    229 	/* leave {} untouched for find */
    230 	if (s[0] == '{' && (s[1] == '\0' || (s[1] == '}' && s[2] == '\0')))
    231 	    continue;
    232 	if ((b = Strchr(s, '{')) != NULL) {
    233 	    Char **bl;
    234 	    int len;
    235 
    236 	    if ((len = globbrace(s, b, &bl)) < 0) {
    237 		xfree((ptr_t)nv);
    238 		stderror(ERR_MISSING, -len);
    239 	    }
    240 	    xfree((ptr_t) s);
    241 	    if (len == 1) {
    242 		*vl-- = *bl;
    243 		xfree((ptr_t) bl);
    244 		continue;
    245 	    }
    246 	    len = blklen(bl);
    247 	    if (&ex[len] >= &nv[size]) {
    248 		ptrdiff_t l, e;
    249 
    250 		l = &ex[len] - &nv[size];
    251 		size += (size_t)(GLOBSPACE > l ? GLOBSPACE : l);
    252 		l = vl - nv;
    253 		e = ex - nv;
    254 		nv = (Char **)xrealloc((ptr_t)nv,
    255 		    (size_t)size * sizeof(Char *));
    256 		vl = nv + l;
    257 		ex = nv + e;
    258 	    }
    259 	    vp = vl--;
    260 	    *vp = *bl;
    261 	    len--;
    262 	    for (bp = ex; bp != vp; bp--)
    263 		bp[len] = *bp;
    264 	    ex += len;
    265 	    vp++;
    266 	    for (bp = bl + 1; *bp; *vp++ = *bp++)
    267 		continue;
    268 	    xfree((ptr_t)bl);
    269 	}
    270 
    271     }
    272     if (elp != NULL)
    273 	*elp = ex;
    274     *nvp = nv;
    275 }
    276 
    277 static Char **
    278 globexpand(Char **v)
    279 {
    280     Char **ex, **nv, *s, **vl;
    281     size_t size;
    282 
    283     size = GLOBSPACE;
    284     nv = vl = xmalloc(sizeof(Char *) * size);
    285     *vl = NULL;
    286 
    287     /*
    288      * Step 1: expand backquotes.
    289      */
    290     while ((s = *v++) != NULL) {
    291 	if (Strchr(s, '`')) {
    292 	    int i;
    293 
    294 	    (void) dobackp(s, 0);
    295 	    for (i = 0; i < pargc; i++) {
    296 		*vl++ = pargv[i];
    297 		if (vl == &nv[size]) {
    298 		    size += GLOBSPACE;
    299 		    nv = (Char **)xrealloc((ptr_t) nv,
    300 		        (size_t)size * sizeof(Char *));
    301 		    vl = &nv[size - GLOBSPACE];
    302 		}
    303 	    }
    304 	    xfree((ptr_t)pargv);
    305 	    pargv = NULL;
    306 	}
    307 	else {
    308 	    *vl++ = Strsave(s);
    309 	    if (vl == &nv[size]) {
    310 		size += GLOBSPACE;
    311 		nv = (Char **)xrealloc((ptr_t)nv,
    312 		    size * sizeof(Char *));
    313 		vl = &nv[size - GLOBSPACE];
    314 	    }
    315 	}
    316     }
    317     *vl = NULL;
    318 
    319     if (noglob)
    320 	return (nv);
    321 
    322     /*
    323      * Step 2: expand braces
    324      */
    325     ex = vl;
    326     expbrace(&nv, &ex, size);
    327 
    328     /*
    329      * Step 3: expand ~
    330      */
    331     vl = nv;
    332     for (s = *vl; s; s = *++vl)
    333 	if (*s == '~')
    334 	    *vl = globtilde(nv, s);
    335     vl = nv;
    336     return (vl);
    337 }
    338 
    339 static Char *
    340 handleone(Char *str, Char **vl, int action)
    341 {
    342     Char *cp, **vlp;
    343 
    344     vlp = vl;
    345     switch (action) {
    346     case G_ERROR:
    347 	setname(vis_str(str));
    348 	blkfree(vl);
    349 	stderror(ERR_NAME | ERR_AMBIG);
    350 	/* NOTREACHED */
    351     case G_APPEND:
    352 	trim(vlp);
    353 	str = Strsave(*vlp++);
    354 	do {
    355 	    cp = Strspl(str, STRspace);
    356 	    xfree((ptr_t)str);
    357 	    str = Strspl(cp, *vlp);
    358 	    xfree((ptr_t)cp);
    359 	}
    360 	while (*++vlp);
    361 	blkfree(vl);
    362 	break;
    363     case G_IGNORE:
    364 	str = Strsave(strip(*vlp));
    365 	blkfree(vl);
    366 	break;
    367     default:
    368 	break;
    369     }
    370     return (str);
    371 }
    372 
    373 static Char **
    374 libglob(Char **vl)
    375 {
    376     glob_t globv;
    377     char *ptr;
    378     int gflgs, magic, match, nonomatch;
    379 
    380     gflgs = GLOB_NOMAGIC;
    381     magic = 0;
    382     match = 0;
    383     nonomatch = adrof(STRnonomatch) != 0;
    384 
    385     if (!vl || !vl[0])
    386 	return (vl);
    387 
    388     globv.gl_offs = 0;
    389     globv.gl_pathv = 0;
    390     globv.gl_pathc = 0;
    391 
    392     if (nonomatch)
    393 	gflgs |= GLOB_NOCHECK;
    394 
    395     do {
    396 	ptr = short2qstr(*vl);
    397 	switch (glob(ptr, gflgs, 0, &globv)) {
    398 	case GLOB_ABORTED:
    399 	    setname(vis_str(*vl));
    400 	    stderror(ERR_NAME | ERR_GLOB);
    401 	    /* NOTREACHED */
    402 	case GLOB_NOSPACE:
    403 	    stderror(ERR_NOMEM);
    404 	    /* NOTREACHED */
    405 	default:
    406 	    break;
    407 	}
    408 	if (globv.gl_flags & GLOB_MAGCHAR) {
    409 	    match |= (globv.gl_matchc != 0);
    410 	    magic = 1;
    411 	}
    412 	gflgs |= GLOB_APPEND;
    413     }
    414     while (*++vl);
    415     vl = (globv.gl_pathc == 0 || (magic && !match && !nonomatch)) ?
    416 	NULL : blk2short(globv.gl_pathv);
    417     globfree(&globv);
    418     return (vl);
    419 }
    420 
    421 Char *
    422 globone(Char *str, int action)
    423 {
    424     Char *v[2], **vl, **vo;
    425     int gflg;
    426 
    427     noglob = adrof(STRnoglob) != 0;
    428     gflag = 0;
    429     v[0] = str;
    430     v[1] = 0;
    431     tglob(v);
    432     gflg = gflag;
    433     if (gflg == G_NONE)
    434 	return (strip(Strsave(str)));
    435 
    436     if (gflg & G_CSH) {
    437 	/*
    438 	 * Expand back-quote, tilde and brace
    439 	 */
    440 	vo = globexpand(v);
    441 	if (noglob || (gflg & G_GLOB) == 0) {
    442 	    if (vo[0] == NULL) {
    443 		xfree((ptr_t)vo);
    444 		return (Strsave(STRNULL));
    445 	    }
    446 	    if (vo[1] != NULL)
    447 		return (handleone(str, vo, action));
    448 	    else {
    449 		str = strip(vo[0]);
    450 		xfree((ptr_t) vo);
    451 		return (str);
    452 	    }
    453 	}
    454     }
    455     else if (noglob || (gflg & G_GLOB) == 0)
    456 	return (strip(Strsave(str)));
    457     else
    458 	vo = v;
    459 
    460     vl = libglob(vo);
    461     if ((gflg & G_CSH) && vl != vo)
    462 	blkfree(vo);
    463     if (vl == NULL) {
    464 	setname(vis_str(str));
    465 	stderror(ERR_NAME | ERR_NOMATCH);
    466     }
    467     if (vl[0] == NULL) {
    468 	xfree((ptr_t)vl);
    469 	return (Strsave(STRNULL));
    470     }
    471     if (vl[1] != NULL)
    472 	return (handleone(str, vl, action));
    473     else {
    474 	str = strip(*vl);
    475 	xfree((ptr_t)vl);
    476 	return (str);
    477     }
    478 }
    479 
    480 Char  **
    481 globall(Char **v)
    482 {
    483     Char **vl, **vo;
    484     int gflg;
    485 
    486     gflg = gflag;
    487     if (!v || !v[0]) {
    488 	gargv = saveblk(v);
    489 	gargc = blklen(gargv);
    490 	return (gargv);
    491     }
    492 
    493     noglob = adrof(STRnoglob) != 0;
    494 
    495     if (gflg & G_CSH)
    496 	/*
    497 	 * Expand back-quote, tilde and brace
    498 	 */
    499 	vl = vo = globexpand(v);
    500     else
    501 	vl = vo = saveblk(v);
    502 
    503     if (!noglob && (gflg & G_GLOB)) {
    504 	vl = libglob(vo);
    505 	if ((gflg & G_CSH) && vl != vo)
    506 	    blkfree(vo);
    507     }
    508     else
    509 	trim(vl);
    510 
    511     gargc = vl ? blklen(vl) : 0;
    512     return (gargv = vl);
    513 }
    514 
    515 void
    516 ginit(void)
    517 {
    518     gargsiz = GLOBSPACE;
    519     gargv = xmalloc(sizeof(Char *) * (size_t)gargsiz);
    520     gargv[0] = 0;
    521     gargc = 0;
    522 }
    523 
    524 void
    525 rscan(Char **t, void (*f)(int))
    526 {
    527     Char *p;
    528 
    529     while ((p = *t++) != NULL)
    530 	while (*p)
    531 	    (*f) (*p++);
    532 }
    533 
    534 void
    535 trim(Char **t)
    536 {
    537     Char *p;
    538 
    539     while ((p = *t++) != NULL)
    540 	while (*p)
    541 	    *p++ &= TRIM;
    542 }
    543 
    544 void
    545 tglob(Char **t)
    546 {
    547     Char *p, c;
    548 
    549     while ((p = *t++) != NULL) {
    550 	if (*p == '~' || *p == '=')
    551 	    gflag |= G_CSH;
    552 	else if (*p == '{' &&
    553 		 (p[1] == '\0' || (p[1] == '}' && p[2] == '\0')))
    554 	    continue;
    555 	while ((c = *p++) != '\0') {
    556 	    /*
    557 	     * eat everything inside the matching backquotes
    558 	     */
    559 	    if (c == '`') {
    560 		gflag |= G_CSH;
    561 		while (*p && *p != '`')
    562 		    if (*p++ == '\\') {
    563 			if (*p)		/* Quoted chars */
    564 			    p++;
    565 			else
    566 			    break;
    567 		    }
    568 		if (*p)			/* The matching ` */
    569 		    p++;
    570 		else
    571 		    break;
    572 	    }
    573 	    else if (c == '{')
    574 		gflag |= G_CSH;
    575 	    else if (isglob(c))
    576 		gflag |= G_GLOB;
    577 	}
    578     }
    579 }
    580 
    581 /*
    582  * Command substitute cp.  If literal, then this is a substitution from a
    583  * << redirection, and so we should not crunch blanks and tabs, separating
    584  * words only at newlines.
    585  */
    586 Char **
    587 dobackp(Char *cp, int literal)
    588 {
    589     Char word[MAXPATHLEN], *ep, *lp, *rp;
    590 
    591     if (pargv) {
    592 #ifdef notdef
    593 	abort();
    594 #endif
    595 	blkfree(pargv);
    596     }
    597     pargsiz = GLOBSPACE;
    598     pargv = xmalloc(sizeof(Char *) * (size_t)pargsiz);
    599     pargv[0] = NULL;
    600     pargcp = pargs = word;
    601     pargc = 0;
    602     pnleft = MAXPATHLEN - 4;
    603     for (;;) {
    604 	for (lp = cp; *lp != '`'; lp++) {
    605 	    if (*lp == 0) {
    606 		if (pargcp != pargs)
    607 		    pword();
    608 		return (pargv);
    609 	    }
    610 	    psave(*lp);
    611 	}
    612 	lp++;
    613 	for (rp = lp; *rp && *rp != '`'; rp++)
    614 	    if (*rp == '\\') {
    615 		rp++;
    616 		if (!*rp)
    617 		    goto oops;
    618 	    }
    619 	if (!*rp) {
    620 	oops:
    621 	    stderror(ERR_UNMATCHED, '`');
    622 	}
    623 	ep = Strsave(lp);
    624 	ep[rp - lp] = 0;
    625 	backeval(ep, literal);
    626 	cp = rp + 1;
    627     }
    628 }
    629 
    630 static void
    631 backeval(Char *cp, int literal)
    632 {
    633     struct command faket;
    634     char tibuf[BUFSIZE];
    635     Char ibuf[BUFSIZE], *fakecom[2], *ip;
    636     int pvec[2], c, quoted;
    637     ssize_t icnt;
    638     int hadnl;
    639 
    640     hadnl = 0;
    641     icnt = 0;
    642     quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
    643     faket.t_dtyp = NODE_COMMAND;
    644     faket.t_dflg = 0;
    645     faket.t_dlef = 0;
    646     faket.t_drit = 0;
    647     faket.t_dspr = 0;
    648     faket.t_dcom = fakecom;
    649     fakecom[0] = STRfakecom1;
    650     fakecom[1] = 0;
    651 
    652     /*
    653      * We do the psave job to temporarily change the current job so that the
    654      * following fork is considered a separate job.  This is so that when
    655      * backquotes are used in a builtin function that calls glob the "current
    656      * job" is not corrupted.  We only need one level of pushed jobs as long as
    657      * we are sure to fork here.
    658      */
    659     psavejob();
    660 
    661     /*
    662      * It would be nicer if we could integrate this redirection more with the
    663      * routines in sh.sem.c by doing a fake execute on a builtin function that
    664      * was piped out.
    665      */
    666     mypipe(pvec);
    667     if (pfork(&faket, -1) == 0) {
    668 	struct wordent fparaml;
    669 	struct command *t;
    670 
    671 	(void)close(pvec[0]);
    672 	(void)dmove(pvec[1], 1);
    673 	(void)dmove(SHERR, 2);
    674 	initdesc();
    675 	/*
    676 	 * Bugfix for nested backquotes by Michael Greim <greim (at) sbsvax.UUCP>,
    677 	 * posted to comp.bugs.4bsd 12 Sep. 1989.
    678 	 */
    679 	if (pargv)		/* mg, 21.dec.88 */
    680 	    blkfree(pargv), pargv = 0, pargsiz = 0;
    681 	/* mg, 21.dec.88 */
    682 	arginp = cp;
    683 	for (arginp = cp; *cp; cp++) {
    684 	    *cp &= TRIM;
    685 	    if (*cp == '\n' || *cp == '\r')
    686 		*cp = ';';
    687 	}
    688 
    689         /*
    690 	 * In the child ``forget'' everything about current aliases or
    691 	 * eval vectors.
    692 	 */
    693 	alvec = NULL;
    694 	evalvec = NULL;
    695 	alvecp = NULL;
    696 	evalp = NULL;
    697 	(void) lex(&fparaml);
    698 	if (seterr)
    699 	    stderror(ERR_OLD);
    700 	alias(&fparaml);
    701 	t = syntax(fparaml.next, &fparaml, 0);
    702 	if (seterr)
    703 	    stderror(ERR_OLD);
    704 	if (t)
    705 	    t->t_dflg |= F_NOFORK;
    706 	(void)signal(SIGTSTP, SIG_IGN);
    707 	(void)signal(SIGTTIN, SIG_IGN);
    708 	(void)signal(SIGTTOU, SIG_IGN);
    709 	execute(t, -1, NULL, NULL);
    710 	exitstat();
    711     }
    712     xfree((ptr_t)cp);
    713     (void)close(pvec[1]);
    714     c = 0;
    715     ip = NULL;
    716     do {
    717 	int cnt;
    718 
    719 	cnt = 0;
    720 
    721 	for (;;) {
    722 	    if (icnt == 0) {
    723 		int i;
    724 
    725 		ip = ibuf;
    726 		do
    727 		    icnt = read(pvec[0], tibuf, BUFSIZE);
    728 		while (icnt == -1 && errno == EINTR);
    729 		if (icnt <= 0) {
    730 		    c = -1;
    731 		    break;
    732 		}
    733 		for (i = 0; i < icnt; i++)
    734 		    ip[i] = (unsigned char) tibuf[i];
    735 	    }
    736 	    if (hadnl)
    737 		break;
    738 	    --icnt;
    739 	    c = (*ip++ & TRIM);
    740 	    if (c == 0)
    741 		break;
    742 	    if (c == '\n') {
    743 		/*
    744 		 * Continue around the loop one more time, so that we can eat
    745 		 * the last newline without terminating this word.
    746 		 */
    747 		hadnl = 1;
    748 		continue;
    749 	    }
    750 	    if (!quoted && (c == ' ' || c == '\t'))
    751 		break;
    752 	    cnt++;
    753 	    psave(c | quoted);
    754 	}
    755 	/*
    756 	 * Unless at end-of-file, we will form a new word here if there were
    757 	 * characters in the word, or in any case when we take text literally.
    758 	 * If we didn't make empty words here when literal was set then we
    759 	 * would lose blank lines.
    760 	 */
    761 	if (c != -1 && (cnt || literal))
    762 	    pword();
    763 	hadnl = 0;
    764     } while (c >= 0);
    765     (void)close(pvec[0]);
    766     pwait();
    767     prestjob();
    768 }
    769 
    770 static void
    771 psave(int c)
    772 {
    773     if (--pnleft <= 0)
    774 	stderror(ERR_WTOOLONG);
    775     *pargcp++ = (Char)c;
    776 }
    777 
    778 static void
    779 pword(void)
    780 {
    781     psave(0);
    782     if (pargc == pargsiz - 1) {
    783 	pargsiz += GLOBSPACE;
    784 	pargv = (Char **)xrealloc((ptr_t)pargv,
    785 	    (size_t)pargsiz * sizeof(Char *));
    786     }
    787     pargv[pargc++] = Strsave(pargs);
    788     pargv[pargc] = NULL;
    789     pargcp = pargs;
    790     pnleft = MAXPATHLEN - 4;
    791 }
    792 
    793 int
    794 Gmatch(Char *string, Char *pattern)
    795 {
    796     Char **blk, **p;
    797     int gpol, gres;
    798 
    799     gpol = 1;
    800     gres = 0;
    801 
    802     if (*pattern == '^') {
    803 	gpol = 0;
    804 	pattern++;
    805     }
    806 
    807     blk = xmalloc(GLOBSPACE * sizeof(Char *));
    808     blk[0] = Strsave(pattern);
    809     blk[1] = NULL;
    810 
    811     expbrace(&blk, NULL, GLOBSPACE);
    812 
    813     for (p = blk; *p; p++)
    814 	gres |= pmatch(string, *p);
    815 
    816     blkfree(blk);
    817     return(gres == gpol);
    818 }
    819 
    820 static int
    821 pmatch(Char *string, Char *pattern)
    822 {
    823     int match, negate_range;
    824     Char patternc, rangec, stringc;
    825 
    826     for (;; ++string) {
    827 	stringc = *string & TRIM;
    828 	patternc = *pattern++;
    829 	switch (patternc) {
    830 	case 0:
    831 	    return (stringc == 0);
    832 	case '?':
    833 	    if (stringc == 0)
    834 		return (0);
    835 	    break;
    836 	case '*':
    837 	    if (!*pattern)
    838 		return (1);
    839 	    while (*string)
    840 		if (Gmatch(string++, pattern))
    841 		    return (1);
    842 	    return (0);
    843 	case '[':
    844 	    match = 0;
    845 	    if ((negate_range = (*pattern == '^')) != 0)
    846 		pattern++;
    847 	    while ((rangec = *pattern++) != '\0') {
    848 		if (rangec == ']')
    849 		    break;
    850 		if (match)
    851 		    continue;
    852 		if (rangec == '-' && *(pattern-2) != '[' && *pattern  != ']') {
    853 		    match = (stringc <= (*pattern & TRIM) &&
    854 			      (*(pattern-2) & TRIM) <= stringc);
    855 		    pattern++;
    856 		}
    857 		else
    858 		    match = (stringc == (rangec & TRIM));
    859 	    }
    860 	    if (rangec == 0)
    861 		stderror(ERR_NAME | ERR_MISSING, ']');
    862 	    if (match == negate_range)
    863 		return (0);
    864 	    break;
    865 	default:
    866 	    if ((patternc & TRIM) != stringc)
    867 		return (0);
    868 	    break;
    869 
    870 	}
    871     }
    872 }
    873 
    874 void
    875 Gcat(Char *s1, Char *s2)
    876 {
    877     Char *p, *q;
    878     ptrdiff_t n;
    879 
    880     for (p = s1; *p++;)
    881 	continue;
    882     for (q = s2; *q++;)
    883 	continue;
    884     n = (p - s1) + (q - s2) - 1;
    885     if (++gargc >= gargsiz) {
    886 	gargsiz += GLOBSPACE;
    887 	gargv = (Char **)xrealloc((ptr_t)gargv,
    888 	    (size_t)gargsiz * sizeof(Char *));
    889     }
    890     gargv[gargc] = 0;
    891     p = gargv[gargc - 1] = xmalloc((size_t)n * sizeof(Char));
    892     for (q = s1; (*p++ = *q++) != '\0';)
    893 	continue;
    894     for (p--, q = s2; (*p++ = *q++) != '\0';)
    895 	continue;
    896 }
    897 
    898 #ifdef FILEC
    899 int
    900 sortscmp(const ptr_t a, const ptr_t b)
    901 {
    902 #if defined(NLS) && !defined(NOSTRCOLL)
    903     char buf[2048];
    904 #endif
    905 
    906     if (!a)			/* check for NULL */
    907 	return (b ? 1 : 0);
    908     if (!b)
    909 	return (-1);
    910 
    911     if (!*(Char **)a)			/* check for NULL */
    912 	return (*(Char **)b ? 1 : 0);
    913     if (!*(Char **)b)
    914 	return (-1);
    915 
    916 #if defined(NLS) && !defined(NOSTRCOLL)
    917     (void)strcpy(buf, short2str(*(Char **)a));
    918     return ((int)strcoll(buf, short2str(*(Char **)b)));
    919 #else
    920     return ((int)Strcmp(*(Char **)a, *(Char **)b));
    921 #endif
    922 }
    923 #endif /* FILEC */
    924