bnx: Remove unused code
[dragonfly.git] / contrib / tcsh-6 / sh.glob.c
CommitLineData
57e3f2b5 1/* $Header: /p/tcsh/cvsroot/tcsh/sh.glob.c,v 3.76 2008/06/19 15:20:56 christos Exp $ */
7d8fb588
MS
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
57e3f2b5 35RCSID("$tcsh: sh.glob.c,v 3.76 2008/06/19 15:20:56 christos Exp $")
7d8fb588
MS
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 (!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
472Char *
473globone(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
526Char **
527globall(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
558Char **
559glob_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
575void
576rscan(Char **t, void (*f) (Char))
577{
578 Char *p;
579
580 while ((p = *t++) != '\0')
581 while (*p)
582 (*f) (*p++);
583}
584
585void
586trim(Char **t)
587{
588 Char *p;
589
590 while ((p = *t++) != '\0')
591 while (*p)
592 *p++ &= TRIM;
593}
594
595int
596tglob(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 */
646Char **
647dobackp(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:
57e3f2b5 670 cleanup_until(&bb);
7d8fb588
MS
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
687static void
688backeval(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;
57e3f2b5 846#if defined(WINNT_NATIVE) || defined(__CYGWIN__)
7d8fb588
MS
847 if (c == '\r')
848 c = ' ';
57e3f2b5 849#endif /* WINNT_NATIVE || __CYGWIN__ */
7d8fb588
MS
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
879static void
880pword(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
889int
890Gmatch(const Char *string, const Char *pattern)
891{
892 return Gnmatch(string, pattern, NULL);
893}
894
895int
896Gnmatch(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 */
943int
944t_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}