contrib/tcsh/sh.glob.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/sh.glob.c,v 3.95 2016/08/01 16:21:09 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.95 2016/08/01 16:21:09 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 #if INVALID_BYTE != 0
 599             if ((*p & INVALID_BYTE) != INVALID_BYTE)    /* *p < INVALID_BYTE */
 600 #endif
 601                 *p &= TRIM;
 602             p++;
 603         }
 604 }
 605
 606 int
 607 tglob(Char **t)
 608 {
 609     int gflag;
 610     const Char *p;
 611
 612     gflag = 0;
 613     while ((p = *t++) != '\0') {
 614         if (*p == '~' || *p == '=')
 615             gflag |= G_CSH;
 616         else if (*p == '{' &&
 617                  (p[1] == '\0' || (p[1] == '}' && p[2] == '\0')))
 618             continue;
 619         while (*p != '\0') {
 620             if (*p == '`') {
 621                 gflag |= G_CSH;
 622 #ifdef notdef
 623                 /*
 624                  * We do want to expand echo `echo '*'`, so we don't\
 625                  * use this piece of code anymore.
 626                  */
 627                 p++;
 628                 while (*p && *p != '`')
 629                     if (*p++ == '\\') {
 630                         if (*p)         /* Quoted chars */
 631                             p++;
 632                         else
 633                             break;
 634                     }
 635                 if (!*p)                /* The matching ` */
 636                     break;
 637 #endif
 638             }
 639             else if (*p == '{')
 640                 gflag |= G_CSH;
 641             else if (isglob(*p))
 642                 gflag |= G_GLOB;
 643             else if (symlinks == SYM_EXPAND &&
 644                 p[1] && ISDOTDOT(p) && (p == *(t-1) || *(p-1) == '/') )
 645                 gflag |= G_CSH;
 646             p++;
 647         }
 648     }
 649     return gflag;
 650 }
 651
 652 /*
 653  * Command substitute cp.  If literal, then this is a substitution from a
 654  * << redirection, and so we should not crunch blanks and tabs, separating
 655  * words only at newlines.
 656  */
 657 Char  **
 658 dobackp(Char *cp, int literal)
 659 {
 660     struct Strbuf word = Strbuf_INIT;
 661     struct blk_buf bb = BLK_BUF_INIT;
 662     Char *lp, *rp, *ep;
 663
 664     cleanup_push(&bb, bb_cleanup);
 665     cleanup_push(&word, Strbuf_cleanup);
 666     for (;;) {
 667         for (lp = cp; *lp != '\0' && *lp != '`'; lp++)
 668             ;
 669         Strbuf_appendn(&word, cp, lp - cp);
 670         if (*lp == 0)
 671             break;
 672         lp++;
 673         for (rp = lp; *rp && *rp != '`'; rp++)
 674             if (*rp == '\\') {
 675                 rp++;
 676                 if (!*rp)
 677                     goto oops;
 678             }
 679         if (!*rp) {
 680         oops:
 681             cleanup_until(&bb);
 682             stderror(ERR_UNMATCHED, '`');
 683         }
 684         ep = Strnsave(lp, rp - lp);
 685         cleanup_push(ep, xfree);
 686         backeval(&bb, &word, ep, literal);
 687         cleanup_until(ep);
 688         cp = rp + 1;
 689     }
 690     if (word.len != 0)
 691         pword(&bb, &word);
 692     cleanup_ignore(&bb);
 693     cleanup_until(&bb);
 694     return bb_finish(&bb);
 695 }
 696
 697
 698 static void
 699 backeval(struct blk_buf *bb, struct Strbuf *word, Char *cp, int literal)
 700 {
 701     ssize_t icnt;
 702     Char c, *ip;
 703     struct command faket;
 704     int    hadnl;
 705     int     pvec[2], quoted;
 706     Char   *fakecom[2], ibuf[BUFSIZE];
 707
 708     hadnl = 0;
 709     icnt = 0;
 710     if (!literal) {
 711         for (ip = cp; (*ip & QUOTE) != 0; ip++)
 712                 continue;
 713         quoted = *ip == '\0';
 714     } else
 715         quoted = literal;
 716     faket.t_dtyp = NODE_COMMAND;
 717     faket.t_dflg = F_BACKQ;
 718     faket.t_dlef = 0;
 719     faket.t_drit = 0;
 720     faket.t_dspr = 0;
 721     faket.t_dcom = fakecom;
 722     fakecom[0] = STRfakecom1;
 723     fakecom[1] = 0;
 724
 725     /*
 726      * We do the psave job to temporarily change the current job so that the
 727      * following fork is considered a separate job.  This is so that when
 728      * backquotes are used in a builtin function that calls glob the "current
 729      * job" is not corrupted.  We only need one level of pushed jobs as long as
 730      * we are sure to fork here.
 731      */
 732     psavejob();
 733     cleanup_push(&faket, psavejob_cleanup); /* faket is only a marker */
 734
 735     /*
 736      * It would be nicer if we could integrate this redirection more with the
 737      * routines in sh.sem.c by doing a fake execute on a builtin function that
 738      * was piped out.
 739      */
 740     mypipe(pvec);
 741     cleanup_push(&pvec[0], open_cleanup);
 742     cleanup_push(&pvec[1], open_cleanup);
 743     if (pfork(&faket, -1) == 0) {
 744         jmp_buf_t osetexit;
 745         struct command *t;
 746         size_t omark;
 747
 748         xclose(pvec[0]);
 749         (void) dmove(pvec[1], 1);
 750         (void) dmove(SHDIAG,  2);
 751         initdesc();
 752         closem();
 753         arginp = cp;
 754         for (arginp = cp; *cp; cp++) {
 755             *cp &= TRIM;
 756             if (is_set(STRcsubstnonl) && (*cp == '\n' || *cp == '\r'))
 757                 *cp = ' ';
 758         }
 759
 760         /*
 761          * In the child ``forget'' everything about current aliases or
 762          * eval vectors.
 763          */
 764         alvec = NULL;
 765         evalvec = NULL;
 766         alvecp = NULL;
 767         evalp = NULL;
 768
 769         omark = cleanup_push_mark();
 770         getexit(osetexit);
 771         for (;;) {
 772             struct wordent paraml1;
 773             initlex(&paraml1);
 774
 775             (void) setexit();
 776             justpr = 0;
 777
 778             if (haderr) {
 779                 /* unwind */
 780                 doneinp = 0;
 781                 cleanup_pop_mark(omark);
 782                 resexit(osetexit);
 783                 reset();
 784             }
 785             if (seterr) {
 786                 xfree(seterr);
 787                 seterr = NULL;
 788             }
 789
 790             freelex(&paraml1);
 791             (void) lex(&paraml1);
 792             cleanup_push(&paraml1, lex_cleanup);
 793             if (seterr)
 794                 stderror(ERR_OLD);
 795             alias(&paraml1);
 796             t = syntax(paraml1.next, &paraml1, 0);
 797             cleanup_push(t, syntax_cleanup);
 798             /* The F_BACKQ flag must set so the job output is correct if
 799              * printexitvalue is set.  If it's not set, the job output
 800              * will have "Exit N" appended where N is the exit status. */
 801             if (t)
 802                     t->t_dflg = F_BACKQ|F_NOFORK;
 803             if (seterr)
 804                 stderror(ERR_OLD);
 805 #ifdef SIGTSTP
 806             signal(SIGTSTP, SIG_IGN);
 807 #endif
 808 #ifdef SIGTTIN
 809             signal(SIGTTIN, SIG_IGN);
 810 #endif
 811 #ifdef SIGTTOU
 812             signal(SIGTTOU, SIG_IGN);
 813 #endif
 814             execute(t, -1, NULL, NULL, TRUE);
 815
 816             cleanup_until(&paraml1);
 817         }
 818     }
 819     cleanup_until(&pvec[1]);
 820     c = 0;
 821     ip = NULL;
 822     do {
 823         ssize_t     cnt = 0;
 824
 825         for (;;) {
 826             if (icnt == 0) {
 827                 ip = ibuf;
 828                 icnt = wide_read(pvec[0], ibuf, BUFSIZE, 0);
 829                 if (icnt <= 0)
 830                     goto eof;
 831             }
 832             if (hadnl)
 833                 break;
 834             --icnt;
 835             c = (*ip++ & TRIM);
 836             if (c == 0)
 837                 break;
 838 #if defined(WINNT_NATIVE) || defined(__CYGWIN__)
 839             if (c == '\r')
 840                 c = ' ';
 841 #endif /* WINNT_NATIVE || __CYGWIN__ */
 842             if (c == '\n') {
 843                 /*
 844                  * Continue around the loop one more time, so that we can eat
 845                  * the last newline without terminating this word.
 846                  */
 847                 hadnl = 1;
 848                 continue;
 849             }
 850             if (!quoted && (c == ' ' || c == '\t'))
 851                 break;
 852             cnt++;
 853             if (c == '\\' || quoted)
 854                 c |= QUOTE;
 855             Strbuf_append1(word, c);
 856         }
 857         /*
 858          * Unless at end-of-file, we will form a new word here if there were
 859          * characters in the word, or in any case when we take text literally.
 860          * If we didn't make empty words here when literal was set then we
 861          * would lose blank lines.
 862          */
 863         if (c != 0 && (cnt || literal))
 864             pword(bb, word);
 865         hadnl = 0;
 866     } while (c > 0);
 867  eof:
 868     cleanup_until(&pvec[0]);
 869     pwait();
 870     cleanup_until(&faket); /* psavejob_cleanup(); */
 871 }
 872
 873 static void
 874 pword(struct blk_buf *bb, struct Strbuf *word)
 875 {
 876     Char *s;
 877
 878     s = Strbuf_finish(word);
 879     bb_append(bb, s);
 880     *word = Strbuf_init;
 881 }
 882
 883 int
 884 Gmatch(const Char *string, const Char *pattern)
 885 {
 886     return Gnmatch(string, pattern, NULL);
 887 }
 888
 889 int
 890 Gnmatch(const Char *string, const Char *pattern, const Char **endstr)
 891 {
 892     Char ***fblk, **p;
 893     const Char *tstring = string;
 894     int    gpol = 1, gres = 0;
 895
 896     if (*pattern == '^') {
 897         gpol = 0;
 898         pattern++;
 899     }
 900
 901     fblk = xmalloc(sizeof(Char ***));
 902     *fblk = xmalloc(GLOBSPACE * sizeof(Char *));
 903     (*fblk)[0] = Strsave(pattern);
 904     (*fblk)[1] = NULL;
 905
 906     cleanup_push(fblk, blk_indirect_cleanup);
 907     expbrace(fblk, NULL, GLOBSPACE);
 908
 909     if (endstr == NULL)
 910         /* Exact matches only */
 911         for (p = *fblk; *p; p++)
 912             gres |= t_pmatch(string, *p, &tstring, 1) == 2 ? 1 : 0;
 913     else {
 914         const Char *end;
 915
 916         /* partial matches */
 917         end = Strend(string);
 918         for (p = *fblk; *p; p++)
 919             if (t_pmatch(string, *p, &tstring, 1) != 0) {
 920                 gres |= 1;
 921                 if (end > tstring)
 922                     end = tstring;
 923             }
 924         *endstr = end;
 925     }
 926
 927     cleanup_until(fblk);
 928     return(gres == gpol);
 929 }
 930
 931 /* t_pmatch():
 932  *      Return 2 on exact match,
 933  *      Return 1 on substring match.
 934  *      Return 0 on no match.
 935  *      *estr will point to the end of the longest exact or substring match.
 936  */
 937 int
 938 t_pmatch(const Char *string, const Char *pattern, const Char **estr, int cs)
 939 {
 940     Char stringc, patternc, rangec;
 941     int     match, negate_range;
 942     const Char *pestr, *nstring;
 943
 944     for (nstring = string;; string = nstring) {
 945         stringc = *nstring++ & TRIM;
 946         patternc = *pattern++ & TRIM;
 947         switch (patternc) {
 948         case '\0':
 949             *estr = string;
 950             return (stringc == '\0' ? 2 : 1);
 951         case '?':
 952             if (stringc == 0)
 953                 return (0);
 954             break;
 955         case '*':
 956             if (!*pattern) {
 957                 *estr = Strend(string);
 958                 return (2);
 959             }
 960             pestr = NULL;
 961
 962             for (;;) {
 963                 switch(t_pmatch(string, pattern, estr, cs)) {
 964                 case 0:
 965                     break;
 966                 case 1:
 967                     pestr = *estr;/*FIXME: does not guarantee longest match */
 968                     break;
 969                 case 2:
 970                     return 2;
 971                 default:
 972                     abort();    /* Cannot happen */
 973                 }
 974                 stringc = *string++ & TRIM;
 975                 if (!stringc)
 976                     break;
 977             }
 978
 979             if (pestr) {
 980                 *estr = pestr;
 981                 return 1;
 982             }
 983             else
 984                 return 0;
 985
 986         case '[':
 987             match = 0;
 988             if ((negate_range = (*pattern == '^')) != 0)
 989                 pattern++;
 990             while ((rangec = *pattern++ & TRIM) != '\0') {
 991                 if (rangec == ']')
 992                     break;
 993                 if (match)
 994                     continue;
 995                 if (*pattern == '-' && pattern[1] != ']') {
 996                     Char rangec2;
 997                     pattern++;
 998                     rangec2 = *pattern++ & TRIM;
 999                     match = (globcharcoll(stringc, rangec2, 0) <= 0 &&
1000                         globcharcoll(rangec, stringc, 0) <= 0);
1001                 }
1002                 else
1003                     match = (stringc == rangec);
1004             }
1005             if (rangec == '\0')
1006                 stderror(ERR_NAME | ERR_MISSING, ']');
1007             if ((!match) && (stringc == '\0'))
1008                 return (0);
1009             if (match == negate_range)
1010                 return (0);
1011             break;
1012         default:
1013             if (cs ? patternc  != stringc
1014                 : Tolower(patternc) != Tolower(stringc))
1015                 return (0);
1016             break;
1017         }
1018     }
1019 }