1 /* $Header: /p/tcsh/cvsroot/tcsh/sh.glob.c,v 3.74 2006/10/14 17:57:21 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.74 2006/10/14 17:57:21 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 stderror(ERR_UNMATCHED, '`'); 671 } 672 ep = Strnsave(lp, rp - lp); 673 cleanup_push(ep, xfree); 674 backeval(&bb, &word, ep, literal); 675 cleanup_until(ep); 676 cp = rp + 1; 677 } 678 if (word.len != 0) 679 pword(&bb, &word); 680 cleanup_ignore(&bb); 681 cleanup_until(&bb); 682 return bb_finish(&bb); 683 } 684 685 686 static void 687 backeval(struct blk_buf *bb, struct Strbuf *word, Char *cp, int literal) 688 { 689 int icnt; 690 Char c, *ip; 691 struct command faket; 692 int hadnl; 693 int pvec[2], quoted; 694 Char *fakecom[2], ibuf[BUFSIZE]; 695 char tibuf[BUFSIZE]; 696 697 hadnl = 0; 698 icnt = 0; 699 quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0; 700 faket.t_dtyp = NODE_COMMAND; 701 faket.t_dflg = F_BACKQ; 702 faket.t_dlef = 0; 703 faket.t_drit = 0; 704 faket.t_dspr = 0; 705 faket.t_dcom = fakecom; 706 fakecom[0] = STRfakecom1; 707 fakecom[1] = 0; 708 709 /* 710 * We do the psave job to temporarily change the current job so that the 711 * following fork is considered a separate job. This is so that when 712 * backquotes are used in a builtin function that calls glob the "current 713 * job" is not corrupted. We only need one level of pushed jobs as long as 714 * we are sure to fork here. 715 */ 716 psavejob(); 717 cleanup_push(&faket, psavejob_cleanup); /* faket is only a marker */ 718 719 /* 720 * It would be nicer if we could integrate this redirection more with the 721 * routines in sh.sem.c by doing a fake execute on a builtin function that 722 * was piped out. 723 */ 724 mypipe(pvec); 725 cleanup_push(&pvec[0], open_cleanup); 726 cleanup_push(&pvec[1], open_cleanup); 727 if (pfork(&faket, -1) == 0) { 728 jmp_buf_t osetexit; 729 struct command *t; 730 size_t omark; 731 732 xclose(pvec[0]); 733 (void) dmove(pvec[1], 1); 734 (void) dmove(SHDIAG, 2); 735 initdesc(); 736 closem(); 737 arginp = cp; 738 for (arginp = cp; *cp; cp++) { 739 *cp &= TRIM; 740 if (is_set(STRcsubstnonl) && (*cp == '\n' || *cp == '\r')) 741 *cp = ' '; 742 } 743 744 /* 745 * In the child ``forget'' everything about current aliases or 746 * eval vectors. 747 */ 748 alvec = NULL; 749 evalvec = NULL; 750 alvecp = NULL; 751 evalp = NULL; 752 753 omark = cleanup_push_mark(); 754 getexit(osetexit); 755 for (;;) { 756 (void) setexit(); 757 justpr = 0; 758 759 if (haderr) { 760 /* unwind */ 761 doneinp = 0; 762 cleanup_pop_mark(omark); 763 resexit(osetexit); 764 reset(); 765 } 766 if (seterr) { 767 xfree(seterr); 768 seterr = NULL; 769 } 770 771 (void) lex(¶ml); 772 cleanup_push(¶ml, lex_cleanup); 773 if (seterr) 774 stderror(ERR_OLD); 775 alias(¶ml); 776 t = syntax(paraml.next, ¶ml, 0); 777 cleanup_push(t, syntax_cleanup); 778 if (seterr) 779 stderror(ERR_OLD); 780 #ifdef SIGTSTP 781 signal(SIGTSTP, SIG_IGN); 782 #endif 783 #ifdef SIGTTIN 784 signal(SIGTTIN, SIG_IGN); 785 #endif 786 #ifdef SIGTTOU 787 signal(SIGTTOU, SIG_IGN); 788 #endif 789 execute(t, -1, NULL, NULL, TRUE); 790 791 cleanup_until(¶ml); 792 } 793 } 794 cleanup_until(&pvec[1]); 795 c = 0; 796 ip = NULL; 797 do { 798 int cnt = 0; 799 char *tmp; 800 801 tmp = tibuf; 802 for (;;) { 803 while (icnt == 0) { 804 int i, eof; 805 806 ip = ibuf; 807 icnt = xread(pvec[0], tmp, tibuf + BUFSIZE - tmp); 808 eof = 0; 809 if (icnt <= 0) { 810 if (tmp == tibuf) 811 goto eof; 812 icnt = 0; 813 eof = 1; 814 } 815 icnt += tmp - tibuf; 816 i = 0; 817 tmp = tibuf; 818 while (tmp < tibuf + icnt) { 819 int len; 820 821 len = normal_mbtowc(&ip[i], tmp, tibuf + icnt - tmp); 822 if (len == -1) { 823 reset_mbtowc(); 824 if (!eof && (size_t)(tibuf + icnt - tmp) < MB_CUR_MAX) { 825 break; /* Maybe a partial character */ 826 } 827 ip[i] = (unsigned char) *tmp | INVALID_BYTE; /* Error */ 828 } 829 if (len <= 0) 830 len = 1; 831 i++; 832 tmp += len; 833 } 834 if (tmp != tibuf) 835 memmove (tibuf, tmp, tibuf + icnt - tmp); 836 tmp = tibuf + (tibuf + icnt - tmp); 837 icnt = i; 838 } 839 if (hadnl) 840 break; 841 --icnt; 842 c = (*ip++ & TRIM); 843 if (c == 0) 844 break; 845 #ifdef WINNT_NATIVE 846 if (c == '\r') 847 c = ' '; 848 #endif /* WINNT_NATIVE */ 849 if (c == '\n') { 850 /* 851 * Continue around the loop one more time, so that we can eat 852 * the last newline without terminating this word. 853 */ 854 hadnl = 1; 855 continue; 856 } 857 if (!quoted && (c == ' ' || c == '\t')) 858 break; 859 cnt++; 860 Strbuf_append1(word, c | quoted); 861 } 862 /* 863 * Unless at end-of-file, we will form a new word here if there were 864 * characters in the word, or in any case when we take text literally. 865 * If we didn't make empty words here when literal was set then we 866 * would lose blank lines. 867 */ 868 if (c != 0 && (cnt || literal)) 869 pword(bb, word); 870 hadnl = 0; 871 } while (c > 0); 872 eof: 873 cleanup_until(&pvec[0]); 874 pwait(); 875 cleanup_until(&faket); /* psavejob_cleanup(); */ 876 } 877 878 static void 879 pword(struct blk_buf *bb, struct Strbuf *word) 880 { 881 Char *s; 882 883 s = Strbuf_finish(word); 884 bb_append(bb, s); 885 *word = Strbuf_init; 886 } 887 888 int 889 Gmatch(const Char *string, const Char *pattern) 890 { 891 return Gnmatch(string, pattern, NULL); 892 } 893 894 int 895 Gnmatch(const Char *string, const Char *pattern, const Char **endstr) 896 { 897 Char ***fblk, **p; 898 const Char *tstring = string; 899 int gpol = 1, gres = 0; 900 901 if (*pattern == '^') { 902 gpol = 0; 903 pattern++; 904 } 905 906 fblk = xmalloc(sizeof(Char ***)); 907 *fblk = xmalloc(GLOBSPACE * sizeof(Char *)); 908 (*fblk)[0] = Strsave(pattern); 909 (*fblk)[1] = NULL; 910 911 cleanup_push(fblk, blk_indirect_cleanup); 912 expbrace(fblk, NULL, GLOBSPACE); 913 914 if (endstr == NULL) 915 /* Exact matches only */ 916 for (p = *fblk; *p; p++) 917 gres |= t_pmatch(string, *p, &tstring, 1) == 2 ? 1 : 0; 918 else { 919 const Char *end; 920 921 /* partial matches */ 922 end = Strend(string); 923 for (p = *fblk; *p; p++) 924 if (t_pmatch(string, *p, &tstring, 1) != 0) { 925 gres |= 1; 926 if (end > tstring) 927 end = tstring; 928 } 929 *endstr = end; 930 } 931 932 cleanup_until(fblk); 933 return(gres == gpol); 934 } 935 936 /* t_pmatch(): 937 * Return 2 on exact match, 938 * Return 1 on substring match. 939 * Return 0 on no match. 940 * *estr will point to the end of the longest exact or substring match. 941 */ 942 int 943 t_pmatch(const Char *string, const Char *pattern, const Char **estr, int cs) 944 { 945 Char stringc, patternc, rangec; 946 int match, negate_range; 947 const Char *pestr, *nstring; 948 949 for (nstring = string;; string = nstring) { 950 stringc = *nstring++ & TRIM; 951 patternc = *pattern++ & TRIM; 952 switch (patternc) { 953 case '\0': 954 *estr = string; 955 return (stringc == '\0' ? 2 : 1); 956 case '?': 957 if (stringc == 0) 958 return (0); 959 break; 960 case '*': 961 if (!*pattern) { 962 *estr = Strend(string); 963 return (2); 964 } 965 pestr = NULL; 966 967 for (;;) { 968 switch(t_pmatch(string, pattern, estr, cs)) { 969 case 0: 970 break; 971 case 1: 972 pestr = *estr;/*FIXME: does not guarantee longest match */ 973 break; 974 case 2: 975 return 2; 976 default: 977 abort(); /* Cannot happen */ 978 } 979 stringc = *string++ & TRIM; 980 if (!stringc) 981 break; 982 } 983 984 if (pestr) { 985 *estr = pestr; 986 return 1; 987 } 988 else 989 return 0; 990 991 case '[': 992 match = 0; 993 if ((negate_range = (*pattern == '^')) != 0) 994 pattern++; 995 while ((rangec = *pattern++ & TRIM) != '\0') { 996 if (rangec == ']') 997 break; 998 if (match) 999 continue; 1000 if (*pattern == '-' && pattern[1] != ']') { 1001 Char rangec2; 1002 pattern++; 1003 rangec2 = *pattern++ & TRIM; 1004 match = (globcharcoll(stringc, rangec2, 0) <= 0 && 1005 globcharcoll(rangec, stringc, 0) <= 0); 1006 } 1007 else 1008 match = (stringc == rangec); 1009 } 1010 if (rangec == '\0') 1011 stderror(ERR_NAME | ERR_MISSING, ']'); 1012 if ((!match) && (stringc == '\0')) 1013 return (0); 1014 if (match == negate_range) 1015 return (0); 1016 break; 1017 default: 1018 if (cs ? patternc != stringc 1019 : Tolower(patternc) != Tolower(stringc)) 1020 return (0); 1021 break; 1022 } 1023 } 1024 } 1025