contrib/tcsh-6/sh.glob.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/sh.glob.c,v 3.82 2011/02/27 00:15:17 christos Exp $ */
   2 /*
   3  * sh.glob.c: Regular expression expansion
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 #include "sh.h"
  34
  35 RCSID("$tcsh: sh.glob.c,v 3.82 2011/02/27 00:15:17 christos Exp $")
  36
  37 #include "tc.h"
  38 #include "tw.h"
  39
  40 #include "glob.h"
  41
  42 /*
  43  * Values for gflag
  44  */
  45 #define G_NONE  0               /* No globbing needed                   */
  46 #define G_GLOB  1               /* string contains *?[] characters      */
  47 #define G_CSH   2               /* string contains ~`{ characters       */
  48
  49 #define GLOBSPACE       100     /* Alloc increment                      */
  50
  51
  52 #define LBRC '{'
  53 #define RBRC '}'
  54 #define LBRK '['
  55 #define RBRK ']'
  56 #define EOS '\0'
  57
  58 /*
  59  * globbing is now done in two stages. In the first pass we expand
  60  * csh globbing idioms ~`{ and then we proceed doing the normal
  61  * globbing if needed ?*[
  62  *
  63  * Csh type globbing is handled in globexpand() and the rest is
  64  * handled in glob() which is part of the 4.4BSD libc.
  65  *
  66  */
  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 (adrof(STRglobdot))
 435        gflgs |= GLOB_DOT;
 436
 437     if (adrof(STRglobstar))
 438        gflgs |= GLOB_STAR;
 439
 440     if (!vl || !vl[0])
 441         return(vl);
 442
 443     globv.gl_offs = 0;
 444     globv.gl_pathv = 0;
 445     globv.gl_pathc = 0;
 446
 447     if (nonomatch)
 448         gflgs |= GLOB_NOCHECK;
 449
 450     do {
 451         ptr = short2qstr(*vl);
 452         switch (glob(ptr, gflgs, 0, &globv)) {
 453         case GLOB_ABEND:
 454             globfree(&globv);
 455             setname(ptr);
 456             stderror(ERR_NAME | ERR_GLOB);
 457             /* NOTREACHED */
 458         case GLOB_NOSPACE:
 459             globfree(&globv);
 460             stderror(ERR_NOMEM);
 461             /* NOTREACHED */
 462         default:
 463             break;
 464         }
 465         if (globv.gl_flags & GLOB_MAGCHAR) {
 466             match |= (globv.gl_matchc != 0);
 467             magic = 1;
 468         }
 469         gflgs |= GLOB_APPEND;
 470     }
 471     while (*++vl);
 472     vl = (globv.gl_pathc == 0 || (magic && !match && !nonomatch)) ?
 473         NULL : blk2short(globv.gl_pathv);
 474     globfree(&globv);
 475     return (vl);
 476 }
 477
 478 Char   *
 479 globone(Char *str, int action)
 480 {
 481     Char   *v[2], **vl, **vo;
 482     int gflg, noglob;
 483
 484     noglob = adrof(STRnoglob) != 0;
 485     v[0] = str;
 486     v[1] = 0;
 487     gflg = tglob(v);
 488     if (gflg == G_NONE)
 489         return (strip(Strsave(str)));
 490
 491     if (gflg & G_CSH) {
 492         /*
 493          * Expand back-quote, tilde and brace
 494          */
 495         vo = globexpand(v, noglob);
 496         if (noglob || (gflg & G_GLOB) == 0) {
 497             vl = vo;
 498             goto result;
 499         }
 500         cleanup_push(vo, blk_cleanup);
 501     }
 502     else if (noglob || (gflg & G_GLOB) == 0)
 503         return (strip(Strsave(str)));
 504     else
 505         vo = v;
 506
 507     vl = libglob(vo);
 508     if (gflg & G_CSH) {
 509         if (vl != vo)
 510             cleanup_until(vo);
 511         else
 512             cleanup_ignore(vo);
 513     }
 514     if (vl == NULL) {
 515         setname(short2str(str));
 516         stderror(ERR_NAME | ERR_NOMATCH);
 517     }
 518  result:
 519     if (vl && vl[0] == NULL) {
 520         xfree(vl);
 521         return (Strsave(STRNULL));
 522     }
 523     if (vl && vl[1])
 524         return (handleone(str, vl, action));
 525     else {
 526         str = strip(*vl);
 527         xfree(vl);
 528         return (str);
 529     }
 530 }
 531
 532 Char  **
 533 globall(Char **v, int gflg)
 534 {
 535     Char  **vl, **vo;
 536     int noglob;
 537
 538     if (!v || !v[0])
 539         return saveblk(v);
 540
 541     noglob = adrof(STRnoglob) != 0;
 542
 543     if (gflg & G_CSH)
 544         /*
 545          * Expand back-quote, tilde and brace
 546          */
 547         vl = vo = globexpand(v, noglob);
 548     else
 549         vl = vo = saveblk(v);
 550
 551     if (!noglob && (gflg & G_GLOB)) {
 552         cleanup_push(vo, blk_cleanup);
 553         vl = libglob(vo);
 554         if (vl == vo)
 555             cleanup_ignore(vo);
 556         cleanup_until(vo);
 557     }
 558     else
 559         trim(vl);
 560
 561     return vl;
 562 }
 563
 564 Char **
 565 glob_all_or_error(Char **v)
 566 {
 567     int gflag;
 568
 569     gflag = tglob(v);
 570     if (gflag) {
 571         v = globall(v, gflag);
 572         if (v == NULL)
 573             stderror(ERR_NAME | ERR_NOMATCH);
 574     } else {
 575         v = saveblk(v);
 576         trim(v);
 577     }
 578     return v;
 579 }
 580
 581 void
 582 rscan(Char **t, void (*f) (Char))
 583 {
 584     Char *p;
 585
 586     while ((p = *t++) != '\0')
 587         while (*p)
 588             (*f) (*p++);
 589 }
 590
 591 void
 592 trim(Char **t)
 593 {
 594     Char *p;
 595
 596     while ((p = *t++) != '\0')
 597         while (*p)
 598             *p++ &= TRIM;
 599 }
 600
 601 int
 602 tglob(Char **t)
 603 {
 604     int gflag;
 605     const Char *p;
 606
 607     gflag = 0;
 608     while ((p = *t++) != '\0') {
 609         if (*p == '~' || *p == '=')
 610             gflag |= G_CSH;
 611         else if (*p == '{' &&
 612                  (p[1] == '\0' || (p[1] == '}' && p[2] == '\0')))
 613             continue;
 614         while (*p != '\0') {
 615             if (*p == '`') {
 616                 gflag |= G_CSH;
 617 #ifdef notdef
 618                 /*
 619                  * We do want to expand echo `echo '*'`, so we don't\
 620                  * use this piece of code anymore.
 621                  */
 622                 p++;
 623                 while (*p && *p != '`')
 624                     if (*p++ == '\\') {
 625                         if (*p)         /* Quoted chars */
 626                             p++;
 627                         else
 628                             break;
 629                     }
 630                 if (!*p)                /* The matching ` */
 631                     break;
 632 #endif
 633             }
 634             else if (*p == '{')
 635                 gflag |= G_CSH;
 636             else if (isglob(*p))
 637                 gflag |= G_GLOB;
 638             else if (symlinks == SYM_EXPAND &&
 639                 p[1] && ISDOTDOT(p) && (p == *(t-1) || *(p-1) == '/') )
 640                 gflag |= G_CSH;
 641             p++;
 642         }
 643     }
 644     return gflag;
 645 }
 646
 647 /*
 648  * Command substitute cp.  If literal, then this is a substitution from a
 649  * << redirection, and so we should not crunch blanks and tabs, separating
 650  * words only at newlines.
 651  */
 652 Char  **
 653 dobackp(Char *cp, int literal)
 654 {
 655     struct Strbuf word = Strbuf_INIT;
 656     struct blk_buf bb = BLK_BUF_INIT;
 657     Char *lp, *rp, *ep;
 658
 659     cleanup_push(&bb, bb_cleanup);
 660     cleanup_push(&word, Strbuf_cleanup);
 661     for (;;) {
 662         for (lp = cp; *lp != '\0' && *lp != '`'; lp++)
 663             ;
 664         Strbuf_appendn(&word, cp, lp - cp);
 665         if (*lp == 0)
 666             break;
 667         lp++;
 668         for (rp = lp; *rp && *rp != '`'; rp++)
 669             if (*rp == '\\') {
 670                 rp++;
 671                 if (!*rp)
 672                     goto oops;
 673             }
 674         if (!*rp) {
 675         oops:
 676             cleanup_until(&bb);
 677             stderror(ERR_UNMATCHED, '`');
 678         }
 679         ep = Strnsave(lp, rp - lp);
 680         cleanup_push(ep, xfree);
 681         backeval(&bb, &word, ep, literal);
 682         cleanup_until(ep);
 683         cp = rp + 1;
 684     }
 685     if (word.len != 0)
 686         pword(&bb, &word);
 687     cleanup_ignore(&bb);
 688     cleanup_until(&bb);
 689     return bb_finish(&bb);
 690 }
 691
 692
 693 static void
 694 backeval(struct blk_buf *bb, struct Strbuf *word, Char *cp, int literal)
 695 {
 696     ssize_t icnt;
 697     Char c, *ip;
 698     struct command faket;
 699     int    hadnl;
 700     int     pvec[2], quoted;
 701     Char   *fakecom[2], ibuf[BUFSIZE];
 702     char    tibuf[BUFSIZE];
 703
 704     hadnl = 0;
 705     icnt = 0;
 706     quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
 707     faket.t_dtyp = NODE_COMMAND;
 708     faket.t_dflg = F_BACKQ;
 709     faket.t_dlef = 0;
 710     faket.t_drit = 0;
 711     faket.t_dspr = 0;
 712     faket.t_dcom = fakecom;
 713     fakecom[0] = STRfakecom1;
 714     fakecom[1] = 0;
 715
 716     /*
 717      * We do the psave job to temporarily change the current job so that the
 718      * following fork is considered a separate job.  This is so that when
 719      * backquotes are used in a builtin function that calls glob the "current
 720      * job" is not corrupted.  We only need one level of pushed jobs as long as
 721      * we are sure to fork here.
 722      */
 723     psavejob();
 724     cleanup_push(&faket, psavejob_cleanup); /* faket is only a marker */
 725
 726     /*
 727      * It would be nicer if we could integrate this redirection more with the
 728      * routines in sh.sem.c by doing a fake execute on a builtin function that
 729      * was piped out.
 730      */
 731     mypipe(pvec);
 732     cleanup_push(&pvec[0], open_cleanup);
 733     cleanup_push(&pvec[1], open_cleanup);
 734     if (pfork(&faket, -1) == 0) {
 735         jmp_buf_t osetexit;
 736         struct command *t;
 737         size_t omark;
 738
 739         xclose(pvec[0]);
 740         (void) dmove(pvec[1], 1);
 741         (void) dmove(SHDIAG,  2);
 742         initdesc();
 743         closem();
 744         arginp = cp;
 745         for (arginp = cp; *cp; cp++) {
 746             *cp &= TRIM;
 747             if (is_set(STRcsubstnonl) && (*cp == '\n' || *cp == '\r'))
 748                 *cp = ' ';
 749         }
 750
 751         /*
 752          * In the child ``forget'' everything about current aliases or
 753          * eval vectors.
 754          */
 755         alvec = NULL;
 756         evalvec = NULL;
 757         alvecp = NULL;
 758         evalp = NULL;
 759
 760         omark = cleanup_push_mark();
 761         getexit(osetexit);
 762         for (;;) {
 763             (void) setexit();
 764             justpr = 0;
 765
 766             if (haderr) {
 767                 /* unwind */
 768                 doneinp = 0;
 769                 cleanup_pop_mark(omark);
 770                 resexit(osetexit);
 771                 reset();
 772             }
 773             if (seterr) {
 774                 xfree(seterr);
 775                 seterr = NULL;
 776             }
 777
 778             (void) lex(&paraml);
 779             cleanup_push(&paraml, lex_cleanup);
 780             if (seterr)
 781                 stderror(ERR_OLD);
 782             alias(&paraml);
 783             t = syntax(paraml.next, &paraml, 0);
 784             if (t == NULL)
 785                 return;
 786             cleanup_push(t, syntax_cleanup);
 787             /* The F_BACKQ flag must set so the job output is correct if
 788              * printexitvalue is set.  If it's not set, the job output
 789              * will have "Exit N" appended where N is the exit status. */
 790             t->t_dflg = F_BACKQ|F_NOFORK;
 791             if (seterr)
 792                 stderror(ERR_OLD);
 793 #ifdef SIGTSTP
 794             signal(SIGTSTP, SIG_IGN);
 795 #endif
 796 #ifdef SIGTTIN
 797             signal(SIGTTIN, SIG_IGN);
 798 #endif
 799 #ifdef SIGTTOU
 800             signal(SIGTTOU, SIG_IGN);
 801 #endif
 802             execute(t, -1, NULL, NULL, TRUE);
 803
 804             cleanup_until(&paraml);
 805         }
 806     }
 807     cleanup_until(&pvec[1]);
 808     c = 0;
 809     ip = NULL;
 810     do {
 811         ssize_t     cnt = 0;
 812         char   *tmp;
 813
 814         tmp = tibuf;
 815         for (;;) {
 816             while (icnt == 0) {
 817                 int     i, eof;
 818
 819                 ip = ibuf;
 820                 icnt = xread(pvec[0], tmp, tibuf + BUFSIZE - tmp);
 821                 eof = 0;
 822                 if (icnt <= 0) {
 823                     if (tmp == tibuf)
 824                         goto eof;
 825                     icnt = 0;
 826                     eof = 1;
 827                 }
 828                 icnt += tmp - tibuf;
 829                 i = 0;
 830                 tmp = tibuf;
 831                 while (tmp < tibuf + icnt) {
 832                     int len;
 833
 834                     len = normal_mbtowc(&ip[i], tmp, tibuf + icnt - tmp);
 835                     if (len == -1) {
 836                         reset_mbtowc();
 837                         if (!eof && (size_t)(tibuf + icnt - tmp) < MB_CUR_MAX) {
 838                             break; /* Maybe a partial character */
 839                         }
 840                         ip[i] = (unsigned char) *tmp | INVALID_BYTE; /* Error */
 841                     }
 842                     if (len <= 0)
 843                         len = 1;
 844                     i++;
 845                     tmp += len;
 846                 }
 847                 if (tmp != tibuf)
 848                     memmove (tibuf, tmp, tibuf + icnt - tmp);
 849                 tmp = tibuf + (tibuf + icnt - tmp);
 850                 icnt = i;
 851             }
 852             if (hadnl)
 853                 break;
 854             --icnt;
 855             c = (*ip++ & TRIM);
 856             if (c == 0)
 857                 break;
 858 #if defined(WINNT_NATIVE) || defined(__CYGWIN__)
 859             if (c == '\r')
 860                 c = ' ';
 861 #endif /* WINNT_NATIVE || __CYGWIN__ */
 862             if (c == '\n') {
 863                 /*
 864                  * Continue around the loop one more time, so that we can eat
 865                  * the last newline without terminating this word.
 866                  */
 867                 hadnl = 1;
 868                 continue;
 869             }
 870             if (!quoted && (c == ' ' || c == '\t'))
 871                 break;
 872             cnt++;
 873             Strbuf_append1(word, c | quoted);
 874         }
 875         /*
 876          * Unless at end-of-file, we will form a new word here if there were
 877          * characters in the word, or in any case when we take text literally.
 878          * If we didn't make empty words here when literal was set then we
 879          * would lose blank lines.
 880          */
 881         if (c != 0 && (cnt || literal))
 882             pword(bb, word);
 883         hadnl = 0;
 884     } while (c > 0);
 885  eof:
 886     cleanup_until(&pvec[0]);
 887     pwait();
 888     cleanup_until(&faket); /* psavejob_cleanup(); */
 889 }
 890
 891 static void
 892 pword(struct blk_buf *bb, struct Strbuf *word)
 893 {
 894     Char *s;
 895
 896     s = Strbuf_finish(word);
 897     bb_append(bb, s);
 898     *word = Strbuf_init;
 899 }
 900
 901 int
 902 Gmatch(const Char *string, const Char *pattern)
 903 {
 904     return Gnmatch(string, pattern, NULL);
 905 }
 906
 907 int
 908 Gnmatch(const Char *string, const Char *pattern, const Char **endstr)
 909 {
 910     Char ***fblk, **p;
 911     const Char *tstring = string;
 912     int    gpol = 1, gres = 0;
 913
 914     if (*pattern == '^') {
 915         gpol = 0;
 916         pattern++;
 917     }
 918
 919     fblk = xmalloc(sizeof(Char ***));
 920     *fblk = xmalloc(GLOBSPACE * sizeof(Char *));
 921     (*fblk)[0] = Strsave(pattern);
 922     (*fblk)[1] = NULL;
 923
 924     cleanup_push(fblk, blk_indirect_cleanup);
 925     expbrace(fblk, NULL, GLOBSPACE);
 926
 927     if (endstr == NULL)
 928         /* Exact matches only */
 929         for (p = *fblk; *p; p++)
 930             gres |= t_pmatch(string, *p, &tstring, 1) == 2 ? 1 : 0;
 931     else {
 932         const Char *end;
 933
 934         /* partial matches */
 935         end = Strend(string);
 936         for (p = *fblk; *p; p++)
 937             if (t_pmatch(string, *p, &tstring, 1) != 0) {
 938                 gres |= 1;
 939                 if (end > tstring)
 940                     end = tstring;
 941             }
 942         *endstr = end;
 943     }
 944
 945     cleanup_until(fblk);
 946     return(gres == gpol);
 947 }
 948
 949 /* t_pmatch():
 950  *      Return 2 on exact match,
 951  *      Return 1 on substring match.
 952  *      Return 0 on no match.
 953  *      *estr will point to the end of the longest exact or substring match.
 954  */
 955 int
 956 t_pmatch(const Char *string, const Char *pattern, const Char **estr, int cs)
 957 {
 958     Char stringc, patternc, rangec;
 959     int     match, negate_range;
 960     const Char *pestr, *nstring;
 961
 962     for (nstring = string;; string = nstring) {
 963         stringc = *nstring++ & TRIM;
 964         patternc = *pattern++ & TRIM;
 965         switch (patternc) {
 966         case '\0':
 967             *estr = string;
 968             return (stringc == '\0' ? 2 : 1);
 969         case '?':
 970             if (stringc == 0)
 971                 return (0);
 972             break;
 973         case '*':
 974             if (!*pattern) {
 975                 *estr = Strend(string);
 976                 return (2);
 977             }
 978             pestr = NULL;
 979
 980             for (;;) {
 981                 switch(t_pmatch(string, pattern, estr, cs)) {
 982                 case 0:
 983                     break;
 984                 case 1:
 985                     pestr = *estr;/*FIXME: does not guarantee longest match */
 986                     break;
 987                 case 2:
 988                     return 2;
 989                 default:
 990                     abort();    /* Cannot happen */
 991                 }
 992                 stringc = *string++ & TRIM;
 993                 if (!stringc)
 994                     break;
 995             }
 996
 997             if (pestr) {
 998                 *estr = pestr;
 999                 return 1;
1000             }
1001             else
1002                 return 0;
1003
1004         case '[':
1005             match = 0;
1006             if ((negate_range = (*pattern == '^')) != 0)
1007                 pattern++;
1008             while ((rangec = *pattern++ & TRIM) != '\0') {
1009                 if (rangec == ']')
1010                     break;
1011                 if (match)
1012                     continue;
1013                 if (*pattern == '-' && pattern[1] != ']') {
1014                     Char rangec2;
1015                     pattern++;
1016                     rangec2 = *pattern++ & TRIM;
1017                     match = (globcharcoll(stringc, rangec2, 0) <= 0 &&
1018                         globcharcoll(rangec, stringc, 0) <= 0);
1019                 }
1020                 else
1021                     match = (stringc == rangec);
1022             }
1023             if (rangec == '\0')
1024                 stderror(ERR_NAME | ERR_MISSING, ']');
1025             if ((!match) && (stringc == '\0'))
1026                 return (0);
1027             if (match == negate_range)
1028                 return (0);
1029             break;
1030         default:
1031             if (cs ? patternc  != stringc
1032                 : Tolower(patternc) != Tolower(stringc))
1033                 return (0);
1034             break;
1035         }
1036     }
1037 }