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(¶ml1); 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(¶ml1); 791 (void) lex(¶ml1); 792 cleanup_push(¶ml1, lex_cleanup); 793 if (seterr) 794 stderror(ERR_OLD); 795 alias(¶ml1); 796 t = syntax(paraml1.next, ¶ml1, 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(¶ml1); 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 } 1020