xref: /dragonfly/contrib/tcsh-6/sh.glob.c (revision 36a3d1d6) 
1 /* $Header: /p/tcsh/cvsroot/tcsh/sh.glob.c,v 3.76 2008/06/19 15:20:56 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 
35 RCSID("$tcsh: sh.glob.c,v 3.76 2008/06/19 15:20:56 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  */
67 static	Char	 *globtilde	(Char *);
68 static	Char     *handleone	(Char *, Char **, int);
69 static	Char	**libglob	(Char **);
70 static	Char	**globexpand	(Char **, int);
71 static	int	  globbrace	(const Char *, Char ***);
72 static  void	  expbrace	(Char ***, Char ***, int);
73 static	void	  pword		(struct blk_buf *, struct Strbuf *);
74 static	void	  backeval	(struct blk_buf *, struct Strbuf *, Char *,
75 				 int);
76 static Char *
77 globtilde(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 */
108 Char *
109 globequal(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 
148 static int
149 globbrace(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 
225 static void
226 expbrace(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 
294 static Char **
295 globexpand(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 
391 static Char *
392 handleone(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 
426 static Char **
427 libglob(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 (!vl || !vl[0])
435 	return(vl);
436 
437     globv.gl_offs = 0;
438     globv.gl_pathv = 0;
439     globv.gl_pathc = 0;
440 
441     if (nonomatch)
442 	gflgs |= GLOB_NOCHECK;
443 
444     do {
445 	ptr = short2qstr(*vl);
446 	switch (glob(ptr, gflgs, 0, &globv)) {
447 	case GLOB_ABEND:
448 	    globfree(&globv);
449 	    setname(ptr);
450 	    stderror(ERR_NAME | ERR_GLOB);
451 	    /* NOTREACHED */
452 	case GLOB_NOSPACE:
453 	    globfree(&globv);
454 	    stderror(ERR_NOMEM);
455 	    /* NOTREACHED */
456 	default:
457 	    break;
458 	}
459 	if (globv.gl_flags & GLOB_MAGCHAR) {
460 	    match |= (globv.gl_matchc != 0);
461 	    magic = 1;
462 	}
463 	gflgs |= GLOB_APPEND;
464     }
465     while (*++vl);
466     vl = (globv.gl_pathc == 0 || (magic && !match && !nonomatch)) ?
467 	NULL : blk2short(globv.gl_pathv);
468     globfree(&globv);
469     return (vl);
470 }
471 
472 Char   *
473 globone(Char *str, int action)
474 {
475     Char   *v[2], **vl, **vo;
476     int gflg, noglob;
477 
478     noglob = adrof(STRnoglob) != 0;
479     v[0] = str;
480     v[1] = 0;
481     gflg = tglob(v);
482     if (gflg == G_NONE)
483 	return (strip(Strsave(str)));
484 
485     if (gflg & G_CSH) {
486 	/*
487 	 * Expand back-quote, tilde and brace
488 	 */
489 	vo = globexpand(v, noglob);
490 	if (noglob || (gflg & G_GLOB) == 0) {
491 	    vl = vo;
492 	    goto result;
493 	}
494 	cleanup_push(vo, blk_cleanup);
495     }
496     else if (noglob || (gflg & G_GLOB) == 0)
497 	return (strip(Strsave(str)));
498     else
499 	vo = v;
500 
501     vl = libglob(vo);
502     if (gflg & G_CSH) {
503     	if (vl != vo)
504 	    cleanup_until(vo);
505 	else
506 	    cleanup_ignore(vo);
507     }
508     if (vl == NULL) {
509 	setname(short2str(str));
510 	stderror(ERR_NAME | ERR_NOMATCH);
511     }
512  result:
513     if (vl[0] == NULL) {
514 	xfree(vl);
515 	return (Strsave(STRNULL));
516     }
517     if (vl[1])
518 	return (handleone(str, vl, action));
519     else {
520 	str = strip(*vl);
521 	xfree(vl);
522 	return (str);
523     }
524 }
525 
526 Char  **
527 globall(Char **v, int gflg)
528 {
529     Char  **vl, **vo;
530     int noglob;
531 
532     if (!v || !v[0])
533 	return saveblk(v);
534 
535     noglob = adrof(STRnoglob) != 0;
536 
537     if (gflg & G_CSH)
538 	/*
539 	 * Expand back-quote, tilde and brace
540 	 */
541 	vl = vo = globexpand(v, noglob);
542     else
543 	vl = vo = saveblk(v);
544 
545     if (!noglob && (gflg & G_GLOB)) {
546 	cleanup_push(vo, blk_cleanup);
547 	vl = libglob(vo);
548 	if (vl == vo)
549 	    cleanup_ignore(vo);
550 	cleanup_until(vo);
551     }
552     else
553 	trim(vl);
554 
555     return vl;
556 }
557 
558 Char **
559 glob_all_or_error(Char **v)
560 {
561     int gflag;
562 
563     gflag = tglob(v);
564     if (gflag) {
565 	v = globall(v, gflag);
566 	if (v == NULL)
567 	    stderror(ERR_NAME | ERR_NOMATCH);
568     } else {
569 	v = saveblk(v);
570 	trim(v);
571     }
572     return v;
573 }
574 
575 void
576 rscan(Char **t, void (*f) (Char))
577 {
578     Char *p;
579 
580     while ((p = *t++) != '\0')
581 	while (*p)
582 	    (*f) (*p++);
583 }
584 
585 void
586 trim(Char **t)
587 {
588     Char *p;
589 
590     while ((p = *t++) != '\0')
591 	while (*p)
592 	    *p++ &= TRIM;
593 }
594 
595 int
596 tglob(Char **t)
597 {
598     int gflag;
599     const Char *p;
600 
601     gflag = 0;
602     while ((p = *t++) != '\0') {
603 	if (*p == '~' || *p == '=')
604 	    gflag |= G_CSH;
605 	else if (*p == '{' &&
606 		 (p[1] == '\0' || (p[1] == '}' && p[2] == '\0')))
607 	    continue;
608 	while (*p != '\0') {
609 	    if (*p == '`') {
610 		gflag |= G_CSH;
611 #ifdef notdef
612 		/*
613 		 * We do want to expand echo `echo '*'`, so we don't\
614 		 * use this piece of code anymore.
615 		 */
616 		p++;
617 		while (*p && *p != '`')
618 		    if (*p++ == '\\') {
619 			if (*p)		/* Quoted chars */
620 			    p++;
621 			else
622 			    break;
623 		    }
624 		if (!*p)		/* The matching ` */
625 		    break;
626 #endif
627 	    }
628 	    else if (*p == '{')
629 		gflag |= G_CSH;
630 	    else if (isglob(*p))
631 		gflag |= G_GLOB;
632 	    else if (symlinks == SYM_EXPAND &&
633 		p[1] && ISDOTDOT(p) && (p == *(t-1) || *(p-1) == '/') )
634 	    	gflag |= G_CSH;
635 	    p++;
636 	}
637     }
638     return gflag;
639 }
640 
641 /*
642  * Command substitute cp.  If literal, then this is a substitution from a
643  * << redirection, and so we should not crunch blanks and tabs, separating
644  * words only at newlines.
645  */
646 Char  **
647 dobackp(Char *cp, int literal)
648 {
649     struct Strbuf word = Strbuf_INIT;
650     struct blk_buf bb = BLK_BUF_INIT;
651     Char *lp, *rp, *ep;
652 
653     cleanup_push(&bb, bb_cleanup);
654     cleanup_push(&word, Strbuf_cleanup);
655     for (;;) {
656 	for (lp = cp; *lp != '\0' && *lp != '`'; lp++)
657 	    ;
658 	Strbuf_appendn(&word, cp, lp - cp);
659 	if (*lp == 0)
660 	    break;
661 	lp++;
662 	for (rp = lp; *rp && *rp != '`'; rp++)
663 	    if (*rp == '\\') {
664 		rp++;
665 		if (!*rp)
666 		    goto oops;
667 	    }
668 	if (!*rp) {
669 	oops:
670 	    cleanup_until(&bb);
671 	    stderror(ERR_UNMATCHED, '`');
672 	}
673 	ep = Strnsave(lp, rp - lp);
674 	cleanup_push(ep, xfree);
675 	backeval(&bb, &word, ep, literal);
676 	cleanup_until(ep);
677 	cp = rp + 1;
678     }
679     if (word.len != 0)
680 	pword(&bb, &word);
681     cleanup_ignore(&bb);
682     cleanup_until(&bb);
683     return bb_finish(&bb);
684 }
685 
686 
687 static void
688 backeval(struct blk_buf *bb, struct Strbuf *word, Char *cp, int literal)
689 {
690     int icnt;
691     Char c, *ip;
692     struct command faket;
693     int    hadnl;
694     int     pvec[2], quoted;
695     Char   *fakecom[2], ibuf[BUFSIZE];
696     char    tibuf[BUFSIZE];
697 
698     hadnl = 0;
699     icnt = 0;
700     quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
701     faket.t_dtyp = NODE_COMMAND;
702     faket.t_dflg = F_BACKQ;
703     faket.t_dlef = 0;
704     faket.t_drit = 0;
705     faket.t_dspr = 0;
706     faket.t_dcom = fakecom;
707     fakecom[0] = STRfakecom1;
708     fakecom[1] = 0;
709 
710     /*
711      * We do the psave job to temporarily change the current job so that the
712      * following fork is considered a separate job.  This is so that when
713      * backquotes are used in a builtin function that calls glob the "current
714      * job" is not corrupted.  We only need one level of pushed jobs as long as
715      * we are sure to fork here.
716      */
717     psavejob();
718     cleanup_push(&faket, psavejob_cleanup); /* faket is only a marker */
719 
720     /*
721      * It would be nicer if we could integrate this redirection more with the
722      * routines in sh.sem.c by doing a fake execute on a builtin function that
723      * was piped out.
724      */
725     mypipe(pvec);
726     cleanup_push(&pvec[0], open_cleanup);
727     cleanup_push(&pvec[1], open_cleanup);
728     if (pfork(&faket, -1) == 0) {
729 	jmp_buf_t osetexit;
730 	struct command *t;
731 	size_t omark;
732 
733 	xclose(pvec[0]);
734 	(void) dmove(pvec[1], 1);
735 	(void) dmove(SHDIAG,  2);
736 	initdesc();
737 	closem();
738 	arginp = cp;
739 	for (arginp = cp; *cp; cp++) {
740 	    *cp &= TRIM;
741 	    if (is_set(STRcsubstnonl) && (*cp == '\n' || *cp == '\r'))
742 		*cp = ' ';
743 	}
744 
745         /*
746 	 * In the child ``forget'' everything about current aliases or
747 	 * eval vectors.
748 	 */
749 	alvec = NULL;
750 	evalvec = NULL;
751 	alvecp = NULL;
752 	evalp = NULL;
753 
754 	omark = cleanup_push_mark();
755 	getexit(osetexit);
756 	for (;;) {
757 	    (void) setexit();
758 	    justpr = 0;
759 
760 	    if (haderr) {
761 		/* unwind */
762 		doneinp = 0;
763 		cleanup_pop_mark(omark);
764 		resexit(osetexit);
765 		reset();
766 	    }
767 	    if (seterr) {
768 		xfree(seterr);
769 		seterr = NULL;
770 	    }
771 
772 	    (void) lex(&paraml);
773 	    cleanup_push(&paraml, lex_cleanup);
774 	    if (seterr)
775 		stderror(ERR_OLD);
776 	    alias(&paraml);
777 	    t = syntax(paraml.next, &paraml, 0);
778 	    cleanup_push(t, syntax_cleanup);
779 	    if (seterr)
780 		stderror(ERR_OLD);
781 #ifdef SIGTSTP
782 	    signal(SIGTSTP, SIG_IGN);
783 #endif
784 #ifdef SIGTTIN
785 	    signal(SIGTTIN, SIG_IGN);
786 #endif
787 #ifdef SIGTTOU
788 	    signal(SIGTTOU, SIG_IGN);
789 #endif
790 	    execute(t, -1, NULL, NULL, TRUE);
791 
792 	    cleanup_until(&paraml);
793 	}
794     }
795     cleanup_until(&pvec[1]);
796     c = 0;
797     ip = NULL;
798     do {
799 	int     cnt = 0;
800 	char   *tmp;
801 
802 	tmp = tibuf;
803 	for (;;) {
804 	    while (icnt == 0) {
805 		int     i, eof;
806 
807 		ip = ibuf;
808 		icnt = xread(pvec[0], tmp, tibuf + BUFSIZE - tmp);
809 		eof = 0;
810 		if (icnt <= 0) {
811 		    if (tmp == tibuf)
812 			goto eof;
813 		    icnt = 0;
814 		    eof = 1;
815 		}
816 		icnt += tmp - tibuf;
817 		i = 0;
818 		tmp = tibuf;
819 		while (tmp < tibuf + icnt) {
820 		    int len;
821 
822 		    len = normal_mbtowc(&ip[i], tmp, tibuf + icnt - tmp);
823 		    if (len == -1) {
824 		        reset_mbtowc();
825 		        if (!eof && (size_t)(tibuf + icnt - tmp) < MB_CUR_MAX) {
826 			    break; /* Maybe a partial character */
827 			}
828 			ip[i] = (unsigned char) *tmp | INVALID_BYTE; /* Error */
829 		    }
830 		    if (len <= 0)
831 		        len = 1;
832 		    i++;
833 		    tmp += len;
834 		}
835 		if (tmp != tibuf)
836 		    memmove (tibuf, tmp, tibuf + icnt - tmp);
837 		tmp = tibuf + (tibuf + icnt - tmp);
838 		icnt = i;
839 	    }
840 	    if (hadnl)
841 		break;
842 	    --icnt;
843 	    c = (*ip++ & TRIM);
844 	    if (c == 0)
845 		break;
846 #if defined(WINNT_NATIVE) || defined(__CYGWIN__)
847 	    if (c == '\r')
848 	    	c = ' ';
849 #endif /* WINNT_NATIVE || __CYGWIN__ */
850 	    if (c == '\n') {
851 		/*
852 		 * Continue around the loop one more time, so that we can eat
853 		 * the last newline without terminating this word.
854 		 */
855 		hadnl = 1;
856 		continue;
857 	    }
858 	    if (!quoted && (c == ' ' || c == '\t'))
859 		break;
860 	    cnt++;
861 	    Strbuf_append1(word, c | quoted);
862 	}
863 	/*
864 	 * Unless at end-of-file, we will form a new word here if there were
865 	 * characters in the word, or in any case when we take text literally.
866 	 * If we didn't make empty words here when literal was set then we
867 	 * would lose blank lines.
868 	 */
869 	if (c != 0 && (cnt || literal))
870 	    pword(bb, word);
871 	hadnl = 0;
872     } while (c > 0);
873  eof:
874     cleanup_until(&pvec[0]);
875     pwait();
876     cleanup_until(&faket); /* psavejob_cleanup(); */
877 }
878 
879 static void
880 pword(struct blk_buf *bb, struct Strbuf *word)
881 {
882     Char *s;
883 
884     s = Strbuf_finish(word);
885     bb_append(bb, s);
886     *word = Strbuf_init;
887 }
888 
889 int
890 Gmatch(const Char *string, const Char *pattern)
891 {
892     return Gnmatch(string, pattern, NULL);
893 }
894 
895 int
896 Gnmatch(const Char *string, const Char *pattern, const Char **endstr)
897 {
898     Char ***fblk, **p;
899     const Char *tstring = string;
900     int	   gpol = 1, gres = 0;
901 
902     if (*pattern == '^') {
903 	gpol = 0;
904 	pattern++;
905     }
906 
907     fblk = xmalloc(sizeof(Char ***));
908     *fblk = xmalloc(GLOBSPACE * sizeof(Char *));
909     (*fblk)[0] = Strsave(pattern);
910     (*fblk)[1] = NULL;
911 
912     cleanup_push(fblk, blk_indirect_cleanup);
913     expbrace(fblk, NULL, GLOBSPACE);
914 
915     if (endstr == NULL)
916 	/* Exact matches only */
917 	for (p = *fblk; *p; p++)
918 	    gres |= t_pmatch(string, *p, &tstring, 1) == 2 ? 1 : 0;
919     else {
920 	const Char *end;
921 
922 	/* partial matches */
923         end = Strend(string);
924 	for (p = *fblk; *p; p++)
925 	    if (t_pmatch(string, *p, &tstring, 1) != 0) {
926 		gres |= 1;
927 		if (end > tstring)
928 		    end = tstring;
929 	    }
930 	*endstr = end;
931     }
932 
933     cleanup_until(fblk);
934     return(gres == gpol);
935 }
936 
937 /* t_pmatch():
938  *	Return 2 on exact match,
939  *	Return 1 on substring match.
940  *	Return 0 on no match.
941  *	*estr will point to the end of the longest exact or substring match.
942  */
943 int
944 t_pmatch(const Char *string, const Char *pattern, const Char **estr, int cs)
945 {
946     Char stringc, patternc, rangec;
947     int     match, negate_range;
948     const Char *pestr, *nstring;
949 
950     for (nstring = string;; string = nstring) {
951 	stringc = *nstring++ & TRIM;
952 	patternc = *pattern++ & TRIM;
953 	switch (patternc) {
954 	case '\0':
955 	    *estr = string;
956 	    return (stringc == '\0' ? 2 : 1);
957 	case '?':
958 	    if (stringc == 0)
959 		return (0);
960 	    break;
961 	case '*':
962 	    if (!*pattern) {
963 		*estr = Strend(string);
964 		return (2);
965 	    }
966 	    pestr = NULL;
967 
968 	    for (;;) {
969 		switch(t_pmatch(string, pattern, estr, cs)) {
970 		case 0:
971 		    break;
972 		case 1:
973 		    pestr = *estr;/*FIXME: does not guarantee longest match */
974 		    break;
975 		case 2:
976 		    return 2;
977 		default:
978 		    abort();	/* Cannot happen */
979 		}
980 		stringc = *string++ & TRIM;
981 		if (!stringc)
982 		    break;
983 	    }
984 
985 	    if (pestr) {
986 		*estr = pestr;
987 		return 1;
988 	    }
989 	    else
990 		return 0;
991 
992 	case '[':
993 	    match = 0;
994 	    if ((negate_range = (*pattern == '^')) != 0)
995 		pattern++;
996 	    while ((rangec = *pattern++ & TRIM) != '\0') {
997 		if (rangec == ']')
998 		    break;
999 		if (match)
1000 		    continue;
1001 		if (*pattern == '-' && pattern[1] != ']') {
1002 		    Char rangec2;
1003 		    pattern++;
1004 		    rangec2 = *pattern++ & TRIM;
1005 		    match = (globcharcoll(stringc, rangec2, 0) <= 0 &&
1006 			globcharcoll(rangec, stringc, 0) <= 0);
1007 		}
1008 		else
1009 		    match = (stringc == rangec);
1010 	    }
1011 	    if (rangec == '\0')
1012 		stderror(ERR_NAME | ERR_MISSING, ']');
1013 	    if ((!match) && (stringc == '\0'))
1014 		return (0);
1015 	    if (match == negate_range)
1016 		return (0);
1017 	    break;
1018 	default:
1019 	    if (cs ? patternc  != stringc
1020 		: Tolower(patternc) != Tolower(stringc))
1021 		return (0);
1022 	    break;
1023 	}
1024     }
1025 }
1026