a7215f31fdbf29ef2f16e76b30bc34a001a1ccd1
[dragonfly.git] / contrib / tcsh-6 / sh.glob.c
1 /* $Header: /p/tcsh/cvsroot/tcsh/sh.glob.c,v 3.74 2006/10/14 17:57:21 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.74 2006/10/14 17:57:21 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             stderror(ERR_UNMATCHED, '`');
671         }
672         ep = Strnsave(lp, rp - lp);
673         cleanup_push(ep, xfree);
674         backeval(&bb, &word, ep, literal);
675         cleanup_until(ep);
676         cp = rp + 1;
677     }
678     if (word.len != 0)
679         pword(&bb, &word);
680     cleanup_ignore(&bb);
681     cleanup_until(&bb);
682     return bb_finish(&bb);
683 }
684
685
686 static void
687 backeval(struct blk_buf *bb, struct Strbuf *word, Char *cp, int literal)
688 {
689     int icnt;
690     Char c, *ip;
691     struct command faket;
692     int    hadnl;
693     int     pvec[2], quoted;
694     Char   *fakecom[2], ibuf[BUFSIZE];
695     char    tibuf[BUFSIZE];
696
697     hadnl = 0;
698     icnt = 0;
699     quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
700     faket.t_dtyp = NODE_COMMAND;
701     faket.t_dflg = F_BACKQ;
702     faket.t_dlef = 0;
703     faket.t_drit = 0;
704     faket.t_dspr = 0;
705     faket.t_dcom = fakecom;
706     fakecom[0] = STRfakecom1;
707     fakecom[1] = 0;
708
709     /*
710      * We do the psave job to temporarily change the current job so that the
711      * following fork is considered a separate job.  This is so that when
712      * backquotes are used in a builtin function that calls glob the "current
713      * job" is not corrupted.  We only need one level of pushed jobs as long as
714      * we are sure to fork here.
715      */
716     psavejob();
717     cleanup_push(&faket, psavejob_cleanup); /* faket is only a marker */
718
719     /*
720      * It would be nicer if we could integrate this redirection more with the
721      * routines in sh.sem.c by doing a fake execute on a builtin function that
722      * was piped out.
723      */
724     mypipe(pvec);
725     cleanup_push(&pvec[0], open_cleanup);
726     cleanup_push(&pvec[1], open_cleanup);
727     if (pfork(&faket, -1) == 0) {
728         jmp_buf_t osetexit;
729         struct command *t;
730         size_t omark;
731
732         xclose(pvec[0]);
733         (void) dmove(pvec[1], 1);
734         (void) dmove(SHDIAG,  2);
735         initdesc();
736         closem();
737         arginp = cp;
738         for (arginp = cp; *cp; cp++) {
739             *cp &= TRIM;
740             if (is_set(STRcsubstnonl) && (*cp == '\n' || *cp == '\r'))
741                 *cp = ' ';
742         }
743
744         /*
745          * In the child ``forget'' everything about current aliases or
746          * eval vectors.
747          */
748         alvec = NULL;
749         evalvec = NULL;
750         alvecp = NULL;
751         evalp = NULL;
752
753         omark = cleanup_push_mark();
754         getexit(osetexit);
755         for (;;) {
756             (void) setexit();
757             justpr = 0;
758             
759             if (haderr) {
760                 /* unwind */
761                 doneinp = 0;
762                 cleanup_pop_mark(omark);
763                 resexit(osetexit);
764                 reset();
765             }
766             if (seterr) {
767                 xfree(seterr);
768                 seterr = NULL;
769             }
770
771             (void) lex(&paraml);
772             cleanup_push(&paraml, lex_cleanup);
773             if (seterr)
774                 stderror(ERR_OLD);
775             alias(&paraml);
776             t = syntax(paraml.next, &paraml, 0);
777             cleanup_push(t, syntax_cleanup);
778             if (seterr)
779                 stderror(ERR_OLD);
780 #ifdef SIGTSTP
781             signal(SIGTSTP, SIG_IGN);
782 #endif
783 #ifdef SIGTTIN
784             signal(SIGTTIN, SIG_IGN);
785 #endif
786 #ifdef SIGTTOU
787             signal(SIGTTOU, SIG_IGN);
788 #endif
789             execute(t, -1, NULL, NULL, TRUE);
790
791             cleanup_until(&paraml);
792         }
793     }
794     cleanup_until(&pvec[1]);
795     c = 0;
796     ip = NULL;
797     do {
798         int     cnt = 0;
799         char   *tmp;
800
801         tmp = tibuf;
802         for (;;) {
803             while (icnt == 0) {
804                 int     i, eof;
805
806                 ip = ibuf;
807                 icnt = xread(pvec[0], tmp, tibuf + BUFSIZE - tmp);
808                 eof = 0;
809                 if (icnt <= 0) {
810                     if (tmp == tibuf)
811                         goto eof;
812                     icnt = 0;
813                     eof = 1;
814                 }
815                 icnt += tmp - tibuf;
816                 i = 0;
817                 tmp = tibuf;
818                 while (tmp < tibuf + icnt) {
819                     int len;
820
821                     len = normal_mbtowc(&ip[i], tmp, tibuf + icnt - tmp);
822                     if (len == -1) {
823                         reset_mbtowc();
824                         if (!eof && (size_t)(tibuf + icnt - tmp) < MB_CUR_MAX) {
825                             break; /* Maybe a partial character */
826                         }
827                         ip[i] = (unsigned char) *tmp | INVALID_BYTE; /* Error */
828                     }
829                     if (len <= 0)
830                         len = 1;
831                     i++;
832                     tmp += len;
833                 }
834                 if (tmp != tibuf)
835                     memmove (tibuf, tmp, tibuf + icnt - tmp);
836                 tmp = tibuf + (tibuf + icnt - tmp);
837                 icnt = i;
838             }
839             if (hadnl)
840                 break;
841             --icnt;
842             c = (*ip++ & TRIM);
843             if (c == 0)
844                 break;
845 #ifdef WINNT_NATIVE
846             if (c == '\r')
847                 c = ' ';
848 #endif /* WINNT_NATIVE */
849             if (c == '\n') {
850                 /*
851                  * Continue around the loop one more time, so that we can eat
852                  * the last newline without terminating this word.
853                  */
854                 hadnl = 1;
855                 continue;
856             }
857             if (!quoted && (c == ' ' || c == '\t'))
858                 break;
859             cnt++;
860             Strbuf_append1(word, c | quoted);
861         }
862         /*
863          * Unless at end-of-file, we will form a new word here if there were
864          * characters in the word, or in any case when we take text literally.
865          * If we didn't make empty words here when literal was set then we
866          * would lose blank lines.
867          */
868         if (c != 0 && (cnt || literal))
869             pword(bb, word);
870         hadnl = 0;
871     } while (c > 0);
872  eof:
873     cleanup_until(&pvec[0]);
874     pwait();
875     cleanup_until(&faket); /* psavejob_cleanup(); */
876 }
877
878 static void
879 pword(struct blk_buf *bb, struct Strbuf *word)
880 {
881     Char *s;
882
883     s = Strbuf_finish(word);
884     bb_append(bb, s);
885     *word = Strbuf_init;
886 }
887
888 int
889 Gmatch(const Char *string, const Char *pattern)
890 {
891     return Gnmatch(string, pattern, NULL);
892 }
893
894 int
895 Gnmatch(const Char *string, const Char *pattern, const Char **endstr)
896 {
897     Char ***fblk, **p;
898     const Char *tstring = string;
899     int    gpol = 1, gres = 0;
900
901     if (*pattern == '^') {
902         gpol = 0;
903         pattern++;
904     }
905
906     fblk = xmalloc(sizeof(Char ***));
907     *fblk = xmalloc(GLOBSPACE * sizeof(Char *));
908     (*fblk)[0] = Strsave(pattern);
909     (*fblk)[1] = NULL;
910
911     cleanup_push(fblk, blk_indirect_cleanup);
912     expbrace(fblk, NULL, GLOBSPACE);
913
914     if (endstr == NULL)
915         /* Exact matches only */
916         for (p = *fblk; *p; p++) 
917             gres |= t_pmatch(string, *p, &tstring, 1) == 2 ? 1 : 0;
918     else {
919         const Char *end;
920
921         /* partial matches */
922         end = Strend(string);
923         for (p = *fblk; *p; p++)
924             if (t_pmatch(string, *p, &tstring, 1) != 0) {
925                 gres |= 1;
926                 if (end > tstring)
927                     end = tstring;
928             }
929         *endstr = end;
930     }
931
932     cleanup_until(fblk);
933     return(gres == gpol);
934
935
936 /* t_pmatch():
937  *      Return 2 on exact match,        
938  *      Return 1 on substring match.
939  *      Return 0 on no match.
940  *      *estr will point to the end of the longest exact or substring match.
941  */
942 int
943 t_pmatch(const Char *string, const Char *pattern, const Char **estr, int cs)
944 {
945     Char stringc, patternc, rangec;
946     int     match, negate_range;
947     const Char *pestr, *nstring;
948
949     for (nstring = string;; string = nstring) {
950         stringc = *nstring++ & TRIM;
951         patternc = *pattern++ & TRIM;
952         switch (patternc) {
953         case '\0':
954             *estr = string;
955             return (stringc == '\0' ? 2 : 1);
956         case '?':
957             if (stringc == 0)
958                 return (0);
959             break;
960         case '*':
961             if (!*pattern) {
962                 *estr = Strend(string);
963                 return (2);
964             }
965             pestr = NULL;
966
967             for (;;) {
968                 switch(t_pmatch(string, pattern, estr, cs)) {
969                 case 0:
970                     break;
971                 case 1:
972                     pestr = *estr;/*FIXME: does not guarantee longest match */
973                     break;
974                 case 2:
975                     return 2;
976                 default:
977                     abort();    /* Cannot happen */
978                 }
979                 stringc = *string++ & TRIM;
980                 if (!stringc)
981                     break;
982             }
983
984             if (pestr) {
985                 *estr = pestr;
986                 return 1;
987             }
988             else
989                 return 0;
990
991         case '[':
992             match = 0;
993             if ((negate_range = (*pattern == '^')) != 0)
994                 pattern++;
995             while ((rangec = *pattern++ & TRIM) != '\0') {
996                 if (rangec == ']')
997                     break;
998                 if (match)
999                     continue;
1000                 if (*pattern == '-' && pattern[1] != ']') {
1001                     Char rangec2;
1002                     pattern++;
1003                     rangec2 = *pattern++ & TRIM;
1004                     match = (globcharcoll(stringc, rangec2, 0) <= 0 &&
1005                         globcharcoll(rangec, stringc, 0) <= 0);
1006                 }
1007                 else 
1008                     match = (stringc == rangec);
1009             }
1010             if (rangec == '\0')
1011                 stderror(ERR_NAME | ERR_MISSING, ']');
1012             if ((!match) && (stringc == '\0'))
1013                 return (0);
1014             if (match == negate_range)
1015                 return (0);
1016             break;
1017         default:
1018             if (cs ? patternc  != stringc
1019                 : Tolower(patternc) != Tolower(stringc))
1020                 return (0);
1021             break;
1022         }
1023     }
1024 }