contrib/tcsh-6/sh.glob.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/sh.glob.c,v 3.76 2008/06/19 15:20:56 christos Exp $ */
   2 /*
   3  * sh.glob.c: Regular expression expansion
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 #include "sh.h"
  34
  35 RCSID("$tcsh: sh.glob.c,v 3.76 2008/06/19 15:20:56 christos Exp $")
  36
  37 #include "tc.h"
  38 #include "tw.h"
  39
  40 #include "glob.h"
  41
  42 /*
  43  * Values for gflag
  44  */
  45 #define G_NONE  0               /* No globbing needed                   */
  46 #define G_GLOB  1               /* string contains *?[] characters      */
  47 #define G_CSH   2               /* string contains ~`{ characters       */
  48
  49 #define GLOBSPACE       100     /* Alloc increment                      */
  50
  51
  52 #define LBRC '{'
  53 #define RBRC '}'
  54 #define LBRK '['
  55 #define RBRK ']'
  56 #define EOS '\0'
  57
  58 /*
  59  * globbing is now done in two stages. In the first pass we expand
  60  * csh globbing idioms ~`{ and then we proceed doing the normal
  61  * globbing if needed ?*[
  62  *
  63  * Csh type globbing is handled in globexpand() and the rest is
  64  * handled in glob() which is part of the 4.4BSD libc.
  65  *
  66  */
  67 static  Char     *globtilde     (Char *);
  68 static  Char     *handleone     (Char *, Char **, int);
  69 static  Char    **libglob       (Char **);
  70 static  Char    **globexpand    (Char **, int);
  71 static  int       globbrace     (const Char *, Char ***);
  72 static  void      expbrace      (Char ***, Char ***, int);
  73 static  void      pword         (struct blk_buf *, struct Strbuf *);
  74 static  void      backeval      (struct blk_buf *, struct Strbuf *, Char *,
  75                                  int);
  76 static Char *
  77 globtilde(Char *s)
  78 {
  79     Char *name, *u, *home, *res;
  80
  81     u = s;
  82     for (s++; *s && *s != '/' && *s != ':'; s++)
  83         continue;
  84     name = Strnsave(u + 1, s - (u + 1));
  85     cleanup_push(name, xfree);
  86     home = gethdir(name);
  87     if (home == NULL) {
  88         if (adrof(STRnonomatch)) {
  89             cleanup_until(name);
  90             return u;
  91         }
  92         if (*name)
  93             stderror(ERR_UNKUSER, short2str(name));
  94         else
  95             stderror(ERR_NOHOME);
  96     }
  97     cleanup_until(name);
  98     if (home[0] == '/' && home[1] == '\0' && s[0] == '/')
  99         res = Strsave(s);
 100     else
 101         res = Strspl(home, s);
 102     xfree(home);
 103     xfree(u);
 104     return res;
 105 }
 106
 107 /* Returns a newly allocated string, old or NULL */
 108 Char *
 109 globequal(Char *old)
 110 {
 111     int     dig;
 112     const Char *dir;
 113     Char    *b;
 114
 115     /*
 116      * kfk - 17 Jan 1984 - stack hack allows user to get at arbitrary dir names
 117      * in stack. PWP: let =foobar pass through (for X windows)
 118      */
 119     if (old[1] == '-' && (old[2] == '\0' || old[2] == '/')) {
 120         /* =- */
 121         const Char *olddir = varval (STRowd);
 122
 123         if (olddir && *olddir &&
 124             !dcwd->di_next->di_name && !dcwd->di_prev->di_name)
 125             return Strspl(olddir, &old[2]);
 126         dig = -1;
 127         b = &old[2];
 128     }
 129     else if (Isdigit(old[1])) {
 130         /* =<number> */
 131         dig = old[1] - '0';
 132         for (b = &old[2]; Isdigit(*b); b++)
 133             dig = dig * 10 + (*b - '0');
 134         if (*b != '\0' && *b != '/')
 135             /* =<number>foobar */
 136             return old;
 137     }
 138     else
 139         /* =foobar */
 140         return old;
 141
 142     dir = getstakd(dig);
 143     if (dir == NULL)
 144         return NULL;
 145     return Strspl(dir, b);
 146 }
 147
 148 static int
 149 globbrace(const Char *s, Char ***bl)
 150 {
 151     struct Strbuf gbuf = Strbuf_INIT;
 152     struct blk_buf bb = BLK_BUF_INIT;
 153     int     i;
 154     const Char *p, *pm, *pe, *pl;
 155     size_t prefix_len;
 156
 157     /* copy part up to the brace */
 158     for (p = s; *p != LBRC; p++)
 159         ;
 160     prefix_len = p - s;
 161
 162     /* check for balanced braces */
 163     for (i = 0, pe = ++p; *pe; pe++)
 164         if (*pe == LBRK) {
 165             /* Ignore everything between [] */
 166             for (++pe; *pe != RBRK && *pe != EOS; pe++)
 167                 continue;
 168             if (*pe == EOS)
 169                 return (-RBRK);
 170         }
 171         else if (*pe == LBRC)
 172             i++;
 173         else if (*pe == RBRC) {
 174             if (i == 0)
 175                 break;
 176             i--;
 177         }
 178
 179     if (i != 0 || *pe == '\0')
 180         return (-RBRC);
 181
 182     Strbuf_appendn(&gbuf, s, prefix_len);
 183
 184     for (i = 0, pl = pm = p; pm <= pe; pm++)
 185         switch (*pm) {
 186         case LBRK:
 187             for (++pm; *pm != RBRK && *pm != EOS; pm++)
 188                 continue;
 189             if (*pm == EOS) {
 190                 bb_cleanup(&bb);
 191                 xfree(gbuf.s);
 192                 return (-RBRK);
 193             }
 194             break;
 195         case LBRC:
 196             i++;
 197             break;
 198         case RBRC:
 199             if (i) {
 200                 i--;
 201                 break;
 202             }
 203             /* FALLTHROUGH */
 204         case ',':
 205             if (i && *pm == ',')
 206                 break;
 207             else {
 208                 gbuf.len = prefix_len;
 209                 Strbuf_appendn(&gbuf, pl, pm - pl);
 210                 Strbuf_append(&gbuf, pe + 1);
 211                 Strbuf_terminate(&gbuf);
 212                 bb_append(&bb, Strsave(gbuf.s));
 213                 pl = pm + 1;
 214             }
 215             break;
 216         default:
 217             break;
 218         }
 219     *bl = bb_finish(&bb);
 220     xfree(gbuf.s);
 221     return bb.len;
 222 }
 223
 224
 225 static void
 226 expbrace(Char ***nvp, Char ***elp, int size)
 227 {
 228     Char **vl, **el, **nv, *s;
 229
 230     vl = nv = *nvp;
 231     if (elp != NULL)
 232         el = *elp;
 233     else
 234         el = vl + blklen(vl);
 235
 236     for (s = *vl; s; s = *++vl) {
 237         Char  **vp, **bp;
 238
 239         /* leave {} untouched for find */
 240         if (s[0] == '{' && (s[1] == '\0' || (s[1] == '}' && s[2] == '\0')))
 241             continue;
 242         if (Strchr(s, '{') != NULL) {
 243             Char  **bl = NULL;
 244             int     len;
 245
 246             if ((len = globbrace(s, &bl)) < 0)
 247                 stderror(ERR_MISSING, -len);
 248             xfree(s);
 249             if (len == 1) {
 250                 *vl-- = *bl;
 251                 xfree(bl);
 252                 continue;
 253             }
 254             if (&el[len] >= &nv[size]) {
 255                 size_t l, e;
 256                 l = &el[len] - &nv[size];
 257                 size += GLOBSPACE > l ? GLOBSPACE : l;
 258                 l = vl - nv;
 259                 e = el - nv;
 260                 nv = xrealloc(nv, size * sizeof(Char *));
 261                 *nvp = nv; /* To keep cleanups working */
 262                 vl = nv + l;
 263                 el = nv + e;
 264             }
 265             /* nv vl   el     bl
 266              * |  |    |      |
 267              * -.--..--       x--
 268              *   |            len
 269              *   vp
 270              */
 271             vp = vl--;
 272             *vp = *bl;
 273             len--;
 274             for (bp = el; bp != vp; bp--)
 275                 bp[len] = *bp;
 276             el += len;
 277             /* nv vl    el bl
 278              * |  |     |  |
 279              * -.-x  ---    --
 280              *   |len
 281              *   vp
 282              */
 283             vp++;
 284             for (bp = bl + 1; *bp; *vp++ = *bp++)
 285                 continue;
 286             xfree(bl);
 287         }
 288
 289     }
 290     if (elp != NULL)
 291         *elp = el;
 292 }
 293
 294 static Char **
 295 globexpand(Char **v, int noglob)
 296 {
 297     Char   *s;
 298     Char  ***fnv, **vl, **el;
 299     int     size = GLOBSPACE;
 300
 301
 302     fnv = xmalloc(sizeof(Char ***));
 303     *fnv = vl = xmalloc(sizeof(Char *) * size);
 304     *vl = NULL;
 305     cleanup_push(fnv, blk_indirect_cleanup);
 306
 307     /*
 308      * Step 1: expand backquotes.
 309      */
 310     while ((s = *v++) != '\0') {
 311         if (Strchr(s, '`')) {
 312             int     i;
 313             Char **expanded;
 314
 315             expanded = dobackp(s, 0);
 316             for (i = 0; expanded[i] != NULL; i++) {
 317                 *vl++ = expanded[i];
 318                 if (vl == &(*fnv)[size]) {
 319                     size += GLOBSPACE;
 320                     *fnv = xrealloc(*fnv, size * sizeof(Char *));
 321                     vl = &(*fnv)[size - GLOBSPACE];
 322                 }
 323             }
 324             xfree(expanded);
 325         }
 326         else {
 327             *vl++ = Strsave(s);
 328             if (vl == &(*fnv)[size]) {
 329                 size += GLOBSPACE;
 330                 *fnv = xrealloc(*fnv, size * sizeof(Char *));
 331                 vl = &(*fnv)[size - GLOBSPACE];
 332             }
 333         }
 334         *vl = NULL;
 335     }
 336
 337     if (noglob)
 338         goto done;
 339
 340     /*
 341      * Step 2: expand braces
 342      */
 343     el = vl;
 344     expbrace(fnv, &el, size);
 345
 346
 347     /*
 348      * Step 3: expand ~ =
 349      */
 350     vl = *fnv;
 351     for (s = *vl; s; s = *++vl)
 352         switch (*s) {
 353             Char *ns;
 354         case '~':
 355             *vl = globtilde(s);
 356             break;
 357         case '=':
 358             if ((ns = globequal(s)) == NULL) {
 359                 if (!adrof(STRnonomatch))
 360                     stderror(ERR_DEEP); /* Error */
 361             }
 362             if (ns && ns != s) {
 363                 /* Expansion succeeded */
 364                 xfree(s);
 365                 *vl = ns;
 366             }
 367             break;
 368         default:
 369             break;
 370         }
 371     vl = *fnv;
 372
 373     /*
 374      * Step 4: expand .. if the variable symlinks==expand is set
 375      */
 376     if (symlinks == SYM_EXPAND) {
 377         for (s = *vl; s; s = *++vl) {
 378             *vl = dnormalize(s, 1);
 379             xfree(s);
 380         }
 381     }
 382
 383  done:
 384     cleanup_ignore(fnv);
 385     cleanup_until(fnv);
 386     vl = *fnv;
 387     xfree(fnv);
 388     return vl;
 389 }
 390
 391 static Char *
 392 handleone(Char *str, Char **vl, int action)
 393 {
 394     size_t chars;
 395     Char **t, *p, *strp;
 396
 397     switch (action) {
 398     case G_ERROR:
 399         setname(short2str(str));
 400         blkfree(vl);
 401         stderror(ERR_NAME | ERR_AMBIG);
 402         break;
 403     case G_APPEND:
 404         chars = 0;
 405         for (t = vl; (p = *t++) != NULL; chars++)
 406             chars += Strlen(p);
 407         str = xmalloc(chars * sizeof(Char));
 408         for (t = vl, strp = str; (p = *t++) != '\0'; chars++) {
 409             while (*p)
 410                  *strp++ = *p++ & TRIM;
 411             *strp++ = ' ';
 412         }
 413         *--strp = '\0';
 414         blkfree(vl);
 415         break;
 416     case G_IGNORE:
 417         str = Strsave(strip(*vl));
 418         blkfree(vl);
 419         break;
 420     default:
 421         break;
 422     }
 423     return (str);
 424 }
 425
 426 static Char **
 427 libglob(Char **vl)
 428 {
 429     int     gflgs = GLOB_QUOTE | GLOB_NOMAGIC | GLOB_ALTNOT;
 430     glob_t  globv;
 431     char   *ptr;
 432     int     nonomatch = adrof(STRnonomatch) != 0, magic = 0, match = 0;
 433
 434     if (!vl || !vl[0])
 435         return(vl);
 436
 437     globv.gl_offs = 0;
 438     globv.gl_pathv = 0;
 439     globv.gl_pathc = 0;
 440
 441     if (nonomatch)
 442         gflgs |= GLOB_NOCHECK;
 443
 444     do {
 445         ptr = short2qstr(*vl);
 446         switch (glob(ptr, gflgs, 0, &globv)) {
 447         case GLOB_ABEND:
 448             globfree(&globv);
 449             setname(ptr);
 450             stderror(ERR_NAME | ERR_GLOB);
 451             /* NOTREACHED */
 452         case GLOB_NOSPACE:
 453             globfree(&globv);
 454             stderror(ERR_NOMEM);
 455             /* NOTREACHED */
 456         default:
 457             break;
 458         }
 459         if (globv.gl_flags & GLOB_MAGCHAR) {
 460             match |= (globv.gl_matchc != 0);
 461             magic = 1;
 462         }
 463         gflgs |= GLOB_APPEND;
 464     }
 465     while (*++vl);
 466     vl = (globv.gl_pathc == 0 || (magic && !match && !nonomatch)) ?
 467         NULL : blk2short(globv.gl_pathv);
 468     globfree(&globv);
 469     return (vl);
 470 }
 471
 472 Char   *
 473 globone(Char *str, int action)
 474 {
 475     Char   *v[2], **vl, **vo;
 476     int gflg, noglob;
 477
 478     noglob = adrof(STRnoglob) != 0;
 479     v[0] = str;
 480     v[1] = 0;
 481     gflg = tglob(v);
 482     if (gflg == G_NONE)
 483         return (strip(Strsave(str)));
 484
 485     if (gflg & G_CSH) {
 486         /*
 487          * Expand back-quote, tilde and brace
 488          */
 489         vo = globexpand(v, noglob);
 490         if (noglob || (gflg & G_GLOB) == 0) {
 491             vl = vo;
 492             goto result;
 493         }
 494         cleanup_push(vo, blk_cleanup);
 495     }
 496     else if (noglob || (gflg & G_GLOB) == 0)
 497         return (strip(Strsave(str)));
 498     else
 499         vo = v;
 500
 501     vl = libglob(vo);
 502     if (gflg & G_CSH) {
 503         if (vl != vo)
 504             cleanup_until(vo);
 505         else
 506             cleanup_ignore(vo);
 507     }
 508     if (vl == NULL) {
 509         setname(short2str(str));
 510         stderror(ERR_NAME | ERR_NOMATCH);
 511     }
 512  result:
 513     if (vl[0] == NULL) {
 514         xfree(vl);
 515         return (Strsave(STRNULL));
 516     }
 517     if (vl[1])
 518         return (handleone(str, vl, action));
 519     else {
 520         str = strip(*vl);
 521         xfree(vl);
 522         return (str);
 523     }
 524 }
 525
 526 Char  **
 527 globall(Char **v, int gflg)
 528 {
 529     Char  **vl, **vo;
 530     int noglob;
 531
 532     if (!v || !v[0])
 533         return saveblk(v);
 534
 535     noglob = adrof(STRnoglob) != 0;
 536
 537     if (gflg & G_CSH)
 538         /*
 539          * Expand back-quote, tilde and brace
 540          */
 541         vl = vo = globexpand(v, noglob);
 542     else
 543         vl = vo = saveblk(v);
 544
 545     if (!noglob && (gflg & G_GLOB)) {
 546         cleanup_push(vo, blk_cleanup);
 547         vl = libglob(vo);
 548         if (vl == vo)
 549             cleanup_ignore(vo);
 550         cleanup_until(vo);
 551     }
 552     else
 553         trim(vl);
 554
 555     return vl;
 556 }
 557
 558 Char **
 559 glob_all_or_error(Char **v)
 560 {
 561     int gflag;
 562
 563     gflag = tglob(v);
 564     if (gflag) {
 565         v = globall(v, gflag);
 566         if (v == NULL)
 567             stderror(ERR_NAME | ERR_NOMATCH);
 568     } else {
 569         v = saveblk(v);
 570         trim(v);
 571     }
 572     return v;
 573 }
 574
 575 void
 576 rscan(Char **t, void (*f) (Char))
 577 {
 578     Char *p;
 579
 580     while ((p = *t++) != '\0')
 581         while (*p)
 582             (*f) (*p++);
 583 }
 584
 585 void
 586 trim(Char **t)
 587 {
 588     Char *p;
 589
 590     while ((p = *t++) != '\0')
 591         while (*p)
 592             *p++ &= TRIM;
 593 }
 594
 595 int
 596 tglob(Char **t)
 597 {
 598     int gflag;
 599     const Char *p;
 600
 601     gflag = 0;
 602     while ((p = *t++) != '\0') {
 603         if (*p == '~' || *p == '=')
 604             gflag |= G_CSH;
 605         else if (*p == '{' &&
 606                  (p[1] == '\0' || (p[1] == '}' && p[2] == '\0')))
 607             continue;
 608         while (*p != '\0') {
 609             if (*p == '`') {
 610                 gflag |= G_CSH;
 611 #ifdef notdef
 612                 /*
 613                  * We do want to expand echo `echo '*'`, so we don't\
 614                  * use this piece of code anymore.
 615                  */
 616                 p++;
 617                 while (*p && *p != '`')
 618                     if (*p++ == '\\') {
 619                         if (*p)         /* Quoted chars */
 620                             p++;
 621                         else
 622                             break;
 623                     }
 624                 if (!*p)                /* The matching ` */
 625                     break;
 626 #endif
 627             }
 628             else if (*p == '{')
 629                 gflag |= G_CSH;
 630             else if (isglob(*p))
 631                 gflag |= G_GLOB;
 632             else if (symlinks == SYM_EXPAND &&
 633                 p[1] && ISDOTDOT(p) && (p == *(t-1) || *(p-1) == '/') )
 634                 gflag |= G_CSH;
 635             p++;
 636         }
 637     }
 638     return gflag;
 639 }
 640
 641 /*
 642  * Command substitute cp.  If literal, then this is a substitution from a
 643  * << redirection, and so we should not crunch blanks and tabs, separating
 644  * words only at newlines.
 645  */
 646 Char  **
 647 dobackp(Char *cp, int literal)
 648 {
 649     struct Strbuf word = Strbuf_INIT;
 650     struct blk_buf bb = BLK_BUF_INIT;
 651     Char *lp, *rp, *ep;
 652
 653     cleanup_push(&bb, bb_cleanup);
 654     cleanup_push(&word, Strbuf_cleanup);
 655     for (;;) {
 656         for (lp = cp; *lp != '\0' && *lp != '`'; lp++)
 657             ;
 658         Strbuf_appendn(&word, cp, lp - cp);
 659         if (*lp == 0)
 660             break;
 661         lp++;
 662         for (rp = lp; *rp && *rp != '`'; rp++)
 663             if (*rp == '\\') {
 664                 rp++;
 665                 if (!*rp)
 666                     goto oops;
 667             }
 668         if (!*rp) {
 669         oops:
 670             cleanup_until(&bb);
 671             stderror(ERR_UNMATCHED, '`');
 672         }
 673         ep = Strnsave(lp, rp - lp);
 674         cleanup_push(ep, xfree);
 675         backeval(&bb, &word, ep, literal);
 676         cleanup_until(ep);
 677         cp = rp + 1;
 678     }
 679     if (word.len != 0)
 680         pword(&bb, &word);
 681     cleanup_ignore(&bb);
 682     cleanup_until(&bb);
 683     return bb_finish(&bb);
 684 }
 685
 686
 687 static void
 688 backeval(struct blk_buf *bb, struct Strbuf *word, Char *cp, int literal)
 689 {
 690     int icnt;
 691     Char c, *ip;
 692     struct command faket;
 693     int    hadnl;
 694     int     pvec[2], quoted;
 695     Char   *fakecom[2], ibuf[BUFSIZE];
 696     char    tibuf[BUFSIZE];
 697
 698     hadnl = 0;
 699     icnt = 0;
 700     quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
 701     faket.t_dtyp = NODE_COMMAND;
 702     faket.t_dflg = F_BACKQ;
 703     faket.t_dlef = 0;
 704     faket.t_drit = 0;
 705     faket.t_dspr = 0;
 706     faket.t_dcom = fakecom;
 707     fakecom[0] = STRfakecom1;
 708     fakecom[1] = 0;
 709
 710     /*
 711      * We do the psave job to temporarily change the current job so that the
 712      * following fork is considered a separate job.  This is so that when
 713      * backquotes are used in a builtin function that calls glob the "current
 714      * job" is not corrupted.  We only need one level of pushed jobs as long as
 715      * we are sure to fork here.
 716      */
 717     psavejob();
 718     cleanup_push(&faket, psavejob_cleanup); /* faket is only a marker */
 719
 720     /*
 721      * It would be nicer if we could integrate this redirection more with the
 722      * routines in sh.sem.c by doing a fake execute on a builtin function that
 723      * was piped out.
 724      */
 725     mypipe(pvec);
 726     cleanup_push(&pvec[0], open_cleanup);
 727     cleanup_push(&pvec[1], open_cleanup);
 728     if (pfork(&faket, -1) == 0) {
 729         jmp_buf_t osetexit;
 730         struct command *t;
 731         size_t omark;
 732
 733         xclose(pvec[0]);
 734         (void) dmove(pvec[1], 1);
 735         (void) dmove(SHDIAG,  2);
 736         initdesc();
 737         closem();
 738         arginp = cp;
 739         for (arginp = cp; *cp; cp++) {
 740             *cp &= TRIM;
 741             if (is_set(STRcsubstnonl) && (*cp == '\n' || *cp == '\r'))
 742                 *cp = ' ';
 743         }
 744
 745         /*
 746          * In the child ``forget'' everything about current aliases or
 747          * eval vectors.
 748          */
 749         alvec = NULL;
 750         evalvec = NULL;
 751         alvecp = NULL;
 752         evalp = NULL;
 753
 754         omark = cleanup_push_mark();
 755         getexit(osetexit);
 756         for (;;) {
 757             (void) setexit();
 758             justpr = 0;
 759
 760             if (haderr) {
 761                 /* unwind */
 762                 doneinp = 0;
 763                 cleanup_pop_mark(omark);
 764                 resexit(osetexit);
 765                 reset();
 766             }
 767             if (seterr) {
 768                 xfree(seterr);
 769                 seterr = NULL;
 770             }
 771
 772             (void) lex(&paraml);
 773             cleanup_push(&paraml, lex_cleanup);
 774             if (seterr)
 775                 stderror(ERR_OLD);
 776             alias(&paraml);
 777             t = syntax(paraml.next, &paraml, 0);
 778             cleanup_push(t, syntax_cleanup);
 779             if (seterr)
 780                 stderror(ERR_OLD);
 781 #ifdef SIGTSTP
 782             signal(SIGTSTP, SIG_IGN);
 783 #endif
 784 #ifdef SIGTTIN
 785             signal(SIGTTIN, SIG_IGN);
 786 #endif
 787 #ifdef SIGTTOU
 788             signal(SIGTTOU, SIG_IGN);
 789 #endif
 790             execute(t, -1, NULL, NULL, TRUE);
 791
 792             cleanup_until(&paraml);
 793         }
 794     }
 795     cleanup_until(&pvec[1]);
 796     c = 0;
 797     ip = NULL;
 798     do {
 799         int     cnt = 0;
 800         char   *tmp;
 801
 802         tmp = tibuf;
 803         for (;;) {
 804             while (icnt == 0) {
 805                 int     i, eof;
 806
 807                 ip = ibuf;
 808                 icnt = xread(pvec[0], tmp, tibuf + BUFSIZE - tmp);
 809                 eof = 0;
 810                 if (icnt <= 0) {
 811                     if (tmp == tibuf)
 812                         goto eof;
 813                     icnt = 0;
 814                     eof = 1;
 815                 }
 816                 icnt += tmp - tibuf;
 817                 i = 0;
 818                 tmp = tibuf;
 819                 while (tmp < tibuf + icnt) {
 820                     int len;
 821
 822                     len = normal_mbtowc(&ip[i], tmp, tibuf + icnt - tmp);
 823                     if (len == -1) {
 824                         reset_mbtowc();
 825                         if (!eof && (size_t)(tibuf + icnt - tmp) < MB_CUR_MAX) {
 826                             break; /* Maybe a partial character */
 827                         }
 828                         ip[i] = (unsigned char) *tmp | INVALID_BYTE; /* Error */
 829                     }
 830                     if (len <= 0)
 831                         len = 1;
 832                     i++;
 833                     tmp += len;
 834                 }
 835                 if (tmp != tibuf)
 836                     memmove (tibuf, tmp, tibuf + icnt - tmp);
 837                 tmp = tibuf + (tibuf + icnt - tmp);
 838                 icnt = i;
 839             }
 840             if (hadnl)
 841                 break;
 842             --icnt;
 843             c = (*ip++ & TRIM);
 844             if (c == 0)
 845                 break;
 846 #if defined(WINNT_NATIVE) || defined(__CYGWIN__)
 847             if (c == '\r')
 848                 c = ' ';
 849 #endif /* WINNT_NATIVE || __CYGWIN__ */
 850             if (c == '\n') {
 851                 /*
 852                  * Continue around the loop one more time, so that we can eat
 853                  * the last newline without terminating this word.
 854                  */
 855                 hadnl = 1;
 856                 continue;
 857             }
 858             if (!quoted && (c == ' ' || c == '\t'))
 859                 break;
 860             cnt++;
 861             Strbuf_append1(word, c | quoted);
 862         }
 863         /*
 864          * Unless at end-of-file, we will form a new word here if there were
 865          * characters in the word, or in any case when we take text literally.
 866          * If we didn't make empty words here when literal was set then we
 867          * would lose blank lines.
 868          */
 869         if (c != 0 && (cnt || literal))
 870             pword(bb, word);
 871         hadnl = 0;
 872     } while (c > 0);
 873  eof:
 874     cleanup_until(&pvec[0]);
 875     pwait();
 876     cleanup_until(&faket); /* psavejob_cleanup(); */
 877 }
 878
 879 static void
 880 pword(struct blk_buf *bb, struct Strbuf *word)
 881 {
 882     Char *s;
 883
 884     s = Strbuf_finish(word);
 885     bb_append(bb, s);
 886     *word = Strbuf_init;
 887 }
 888
 889 int
 890 Gmatch(const Char *string, const Char *pattern)
 891 {
 892     return Gnmatch(string, pattern, NULL);
 893 }
 894
 895 int
 896 Gnmatch(const Char *string, const Char *pattern, const Char **endstr)
 897 {
 898     Char ***fblk, **p;
 899     const Char *tstring = string;
 900     int    gpol = 1, gres = 0;
 901
 902     if (*pattern == '^') {
 903         gpol = 0;
 904         pattern++;
 905     }
 906
 907     fblk = xmalloc(sizeof(Char ***));
 908     *fblk = xmalloc(GLOBSPACE * sizeof(Char *));
 909     (*fblk)[0] = Strsave(pattern);
 910     (*fblk)[1] = NULL;
 911
 912     cleanup_push(fblk, blk_indirect_cleanup);
 913     expbrace(fblk, NULL, GLOBSPACE);
 914
 915     if (endstr == NULL)
 916         /* Exact matches only */
 917         for (p = *fblk; *p; p++)
 918             gres |= t_pmatch(string, *p, &tstring, 1) == 2 ? 1 : 0;
 919     else {
 920         const Char *end;
 921
 922         /* partial matches */
 923         end = Strend(string);
 924         for (p = *fblk; *p; p++)
 925             if (t_pmatch(string, *p, &tstring, 1) != 0) {
 926                 gres |= 1;
 927                 if (end > tstring)
 928                     end = tstring;
 929             }
 930         *endstr = end;
 931     }
 932
 933     cleanup_until(fblk);
 934     return(gres == gpol);
 935 }
 936
 937 /* t_pmatch():
 938  *      Return 2 on exact match,
 939  *      Return 1 on substring match.
 940  *      Return 0 on no match.
 941  *      *estr will point to the end of the longest exact or substring match.
 942  */
 943 int
 944 t_pmatch(const Char *string, const Char *pattern, const Char **estr, int cs)
 945 {
 946     Char stringc, patternc, rangec;
 947     int     match, negate_range;
 948     const Char *pestr, *nstring;
 949
 950     for (nstring = string;; string = nstring) {
 951         stringc = *nstring++ & TRIM;
 952         patternc = *pattern++ & TRIM;
 953         switch (patternc) {
 954         case '\0':
 955             *estr = string;
 956             return (stringc == '\0' ? 2 : 1);
 957         case '?':
 958             if (stringc == 0)
 959                 return (0);
 960             break;
 961         case '*':
 962             if (!*pattern) {
 963                 *estr = Strend(string);
 964                 return (2);
 965             }
 966             pestr = NULL;
 967
 968             for (;;) {
 969                 switch(t_pmatch(string, pattern, estr, cs)) {
 970                 case 0:
 971                     break;
 972                 case 1:
 973                     pestr = *estr;/*FIXME: does not guarantee longest match */
 974                     break;
 975                 case 2:
 976                     return 2;
 977                 default:
 978                     abort();    /* Cannot happen */
 979                 }
 980                 stringc = *string++ & TRIM;
 981                 if (!stringc)
 982                     break;
 983             }
 984
 985             if (pestr) {
 986                 *estr = pestr;
 987                 return 1;
 988             }
 989             else
 990                 return 0;
 991
 992         case '[':
 993             match = 0;
 994             if ((negate_range = (*pattern == '^')) != 0)
 995                 pattern++;
 996             while ((rangec = *pattern++ & TRIM) != '\0') {
 997                 if (rangec == ']')
 998                     break;
 999                 if (match)
1000                     continue;
1001                 if (*pattern == '-' && pattern[1] != ']') {
1002                     Char rangec2;
1003                     pattern++;
1004                     rangec2 = *pattern++ & TRIM;
1005                     match = (globcharcoll(stringc, rangec2, 0) <= 0 &&
1006                         globcharcoll(rangec, stringc, 0) <= 0);
1007                 }
1008                 else
1009                     match = (stringc == rangec);
1010             }
1011             if (rangec == '\0')
1012                 stderror(ERR_NAME | ERR_MISSING, ']');
1013             if ((!match) && (stringc == '\0'))
1014                 return (0);
1015             if (match == negate_range)
1016                 return (0);
1017             break;
1018         default:
1019             if (cs ? patternc  != stringc
1020                 : Tolower(patternc) != Tolower(stringc))
1021                 return (0);
1022             break;
1023         }
1024     }
1025 }