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(¶ml); 773 cleanup_push(¶ml, lex_cleanup); 774 if (seterr) 775 stderror(ERR_OLD); 776 alias(¶ml); 777 t = syntax(paraml.next, ¶ml, 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(¶ml); 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 } 1026