1 /* $Header: /p/tcsh/cvsroot/tcsh/tw.comp.c,v 1.41 2006/03/02 18:46:45 christos Exp $ */ 2 /* 3 * tw.comp.c: File completion builtin 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: tw.comp.c,v 1.41 2006/03/02 18:46:45 christos Exp $") 36 37 #include "tw.h" 38 #include "ed.h" 39 #include "tc.h" 40 41 /* #define TDEBUG */ 42 struct varent completions; 43 44 static int tw_result (const Char *, Char **); 45 static Char **tw_find (Char *, struct varent *, int); 46 static Char *tw_tok (Char *); 47 static int tw_pos (Char *, int); 48 static void tw_pr (Char **); 49 static int tw_match (const Char *, const Char *); 50 static void tw_prlist (struct varent *); 51 static const Char *tw_dollar (const Char *,Char **, size_t, Char **, 52 Char, const char *); 53 54 /* docomplete(): 55 * Add or list completions in the completion list 56 */ 57 /*ARGSUSED*/ 58 void 59 docomplete(Char **v, struct command *t) 60 { 61 struct varent *vp; 62 Char *p; 63 Char **pp; 64 65 USE(t); 66 v++; 67 p = *v++; 68 if (p == 0) 69 tw_prlist(&completions); 70 else if (*v == 0) { 71 vp = adrof1(strip(p), &completions); 72 if (vp && vp->vec) 73 tw_pr(vp->vec), xputchar('\n'); 74 else 75 { 76 #ifdef TDEBUG 77 xprintf("tw_find(%s) \n", short2str(strip(p))); 78 #endif /* TDEBUG */ 79 pp = tw_find(strip(p), &completions, FALSE); 80 if (pp) 81 tw_pr(pp), xputchar('\n'); 82 } 83 } 84 else 85 set1(strip(p), saveblk(v), &completions, VAR_READWRITE); 86 } /* end docomplete */ 87 88 89 /* douncomplete(): 90 * Remove completions from the completion list 91 */ 92 /*ARGSUSED*/ 93 void 94 douncomplete(Char **v, struct command *t) 95 { 96 USE(t); 97 unset1(v, &completions); 98 } /* end douncomplete */ 99 100 101 /* tw_prlist(): 102 * Pretty print a list of variables 103 */ 104 static void 105 tw_prlist(struct varent *p) 106 { 107 struct varent *c; 108 109 for (;;) { 110 while (p->v_left) 111 p = p->v_left; 112 x: 113 if (p->v_parent == 0) /* is it the header? */ 114 break; 115 if (setintr) { 116 int old_pintr_disabled; 117 118 pintr_push_enable(&old_pintr_disabled); 119 cleanup_until(&old_pintr_disabled); 120 } 121 xprintf("%s\t", short2str(p->v_name)); 122 if (p->vec) 123 tw_pr(p->vec); 124 xputchar('\n'); 125 if (p->v_right) { 126 p = p->v_right; 127 continue; 128 } 129 do { 130 c = p; 131 p = p->v_parent; 132 } while (p->v_right == c); 133 goto x; 134 } 135 } /* end tw_prlist */ 136 137 138 /* tw_pr(): 139 * Pretty print a completion, adding single quotes around 140 * a completion argument and collapsing multiple spaces to one. 141 */ 142 static void 143 tw_pr(Char **cmp) 144 { 145 int sp, osp; 146 Char *ptr; 147 148 for (; *cmp; cmp++) { 149 xputchar('\''); 150 for (osp = 0, ptr = *cmp; *ptr; ptr++) { 151 sp = Isspace(*ptr); 152 if (sp && osp) 153 continue; 154 xputwchar(*ptr); 155 osp = sp; 156 } 157 xputchar('\''); 158 if (cmp[1]) 159 xputchar(' '); 160 } 161 } /* end tw_pr */ 162 163 164 /* tw_find(): 165 * Find the first matching completion. 166 * For commands we only look at names that start with - 167 */ 168 static Char ** 169 tw_find(Char *nam, struct varent *vp, int cmd) 170 { 171 Char **rv; 172 173 for (vp = vp->v_left; vp; vp = vp->v_right) { 174 if (vp->v_left && (rv = tw_find(nam, vp, cmd)) != NULL) 175 return rv; 176 if (cmd) { 177 if (vp->v_name[0] != '-') 178 continue; 179 if (Gmatch(nam, &vp->v_name[1]) && vp->vec != NULL) 180 return vp->vec; 181 } 182 else 183 if (Gmatch(nam, vp->v_name) && vp->vec != NULL) 184 return vp->vec; 185 } 186 return NULL; 187 } /* end tw_find */ 188 189 190 /* tw_pos(): 191 * Return true if the position is within the specified range 192 */ 193 static int 194 tw_pos(Char *ran, int wno) 195 { 196 Char *p; 197 198 if (ran[0] == '*' && ran[1] == '\0') 199 return 1; 200 201 for (p = ran; *p && *p != '-'; p++) 202 continue; 203 204 if (*p == '\0') /* range == <number> */ 205 return wno == getn(ran); 206 207 if (ran == p) /* range = - <number> */ 208 return wno <= getn(&ran[1]); 209 *p++ = '\0'; 210 211 if (*p == '\0') /* range = <number> - */ 212 return getn(ran) <= wno; 213 else /* range = <number> - <number> */ 214 return (getn(ran) <= wno) && (wno <= getn(p)); 215 } /* end tw_pos */ 216 217 218 /* tw_tok(): 219 * Return the next word from string, unquoteing it. 220 */ 221 static Char * 222 tw_tok(Char *str) 223 { 224 static Char *bf = NULL; 225 226 if (str != NULL) 227 bf = str; 228 229 /* skip leading spaces */ 230 for (; *bf && Isspace(*bf); bf++) 231 continue; 232 233 for (str = bf; *bf && !Isspace(*bf); bf++) { 234 if (ismetahash(*bf)) 235 return INVPTR; 236 *bf = *bf & ~QUOTE; 237 } 238 if (*bf != '\0') 239 *bf++ = '\0'; 240 241 return *str ? str : NULL; 242 } /* end tw_tok */ 243 244 245 /* tw_match(): 246 * Match a string against the pattern given. 247 * and return the number of matched characters 248 * in a prefix of the string. 249 */ 250 static int 251 tw_match(const Char *str, const Char *pat) 252 { 253 const Char *estr; 254 int rv = Gnmatch(str, pat, &estr); 255 #ifdef TDEBUG 256 xprintf("Gnmatch(%s, ", short2str(str)); 257 xprintf("%s, ", short2str(pat)); 258 xprintf("%s) = %d [%d]\n", short2str(estr), rv, estr - str); 259 #endif /* TDEBUG */ 260 return (int) (rv ? estr - str : -1); 261 } 262 263 264 /* tw_result(): 265 * Return what the completion action should be depending on the 266 * string 267 */ 268 static int 269 tw_result(const Char *act, Char **pat) 270 { 271 int looking; 272 static Char* res = NULL; 273 Char *p; 274 275 if (res != NULL) 276 xfree(res), res = NULL; 277 278 switch (act[0] & ~QUOTE) { 279 case 'X': 280 looking = TW_COMPLETION; 281 break; 282 case 'S': 283 looking = TW_SIGNAL; 284 break; 285 case 'a': 286 looking = TW_ALIAS; 287 break; 288 case 'b': 289 looking = TW_BINDING; 290 break; 291 case 'c': 292 looking = TW_COMMAND; 293 break; 294 case 'C': 295 looking = TW_PATH | TW_COMMAND; 296 break; 297 case 'd': 298 looking = TW_DIRECTORY; 299 break; 300 case 'D': 301 looking = TW_PATH | TW_DIRECTORY; 302 break; 303 case 'e': 304 looking = TW_ENVVAR; 305 break; 306 case 'f': 307 looking = TW_FILE; 308 break; 309 #ifdef COMPAT 310 case 'p': 311 #endif /* COMPAT */ 312 case 'F': 313 looking = TW_PATH | TW_FILE; 314 break; 315 case 'g': 316 looking = TW_GRPNAME; 317 break; 318 case 'j': 319 looking = TW_JOB; 320 break; 321 case 'l': 322 looking = TW_LIMIT; 323 break; 324 case 'n': 325 looking = TW_NONE; 326 break; 327 case 's': 328 looking = TW_SHELLVAR; 329 break; 330 case 't': 331 looking = TW_TEXT; 332 break; 333 case 'T': 334 looking = TW_PATH | TW_TEXT; 335 break; 336 case 'v': 337 looking = TW_VARIABLE; 338 break; 339 case 'u': 340 looking = TW_USER; 341 break; 342 case 'x': 343 looking = TW_EXPLAIN; 344 break; 345 346 case '$': 347 *pat = res = Strsave(&act[1]); 348 (void) strip(res); 349 return(TW_VARLIST); 350 351 case '(': 352 *pat = res = Strsave(&act[1]); 353 if ((p = Strchr(res, ')')) != NULL) 354 *p = '\0'; 355 (void) strip(res); 356 return TW_WORDLIST; 357 358 case '`': 359 res = Strsave(act); 360 if ((p = Strchr(&res[1], '`')) != NULL) 361 *++p = '\0'; 362 363 if (didfds == 0) { 364 /* 365 * Make sure that we have some file descriptors to 366 * play with, so that the processes have at least 0, 1, 2 367 * open 368 */ 369 (void) dcopy(SHIN, 0); 370 (void) dcopy(SHOUT, 1); 371 (void) dcopy(SHDIAG, 2); 372 } 373 if ((p = globone(res, G_APPEND)) != NULL) { 374 xfree(res), res = NULL; 375 *pat = res = Strsave(p); 376 xfree(p); 377 return TW_WORDLIST; 378 } 379 return TW_ZERO; 380 381 default: 382 stderror(ERR_COMPCOM, short2str(act)); 383 return TW_ZERO; 384 } 385 386 switch (act[1] & ~QUOTE) { 387 case '\0': 388 return looking; 389 390 case ':': 391 *pat = res = Strsave(&act[2]); 392 (void) strip(res); 393 return looking; 394 395 default: 396 stderror(ERR_COMPCOM, short2str(act)); 397 return TW_ZERO; 398 } 399 } /* end tw_result */ 400 401 402 /* tw_dollar(): 403 * Expand $<n> args in buffer 404 */ 405 static const Char * 406 tw_dollar(const Char *str, Char **wl, size_t nwl, Char **result, Char sep, 407 const char *msg) 408 { 409 struct Strbuf buf = Strbuf_INIT; 410 Char *res; 411 const Char *sp; 412 413 for (sp = str; *sp && *sp != sep;) 414 if (sp[0] == '$' && sp[1] == ':' && Isdigit(sp[sp[2] == '-' ? 3 : 2])) { 415 int num, neg = 0; 416 sp += 2; 417 if (*sp == '-') { 418 neg = 1; 419 sp++; 420 } 421 for (num = *sp++ - '0'; Isdigit(*sp); num += 10 * num + *sp++ - '0') 422 continue; 423 if (neg) 424 num = nwl - num - 1; 425 if (num >= 0 && (size_t)num < nwl) 426 Strbuf_append(&buf, wl[num]); 427 } 428 else 429 Strbuf_append1(&buf, *sp++); 430 431 res = Strbuf_finish(&buf); 432 433 if (*sp++ == sep) { 434 *result = res; 435 return sp; 436 } 437 438 xfree(res); 439 /* Truncates data if WIDE_STRINGS */ 440 stderror(ERR_COMPMIS, (int)sep, msg, short2str(str)); 441 return --sp; 442 } /* end tw_dollar */ 443 444 445 /* tw_complete(): 446 * Return the appropriate completion for the command 447 * 448 * valid completion strings are: 449 * p/<range>/<completion>/[<suffix>/] positional 450 * c/<pattern>/<completion>/[<suffix>/] current word ignore pattern 451 * C/<pattern>/<completion>/[<suffix>/] current word with pattern 452 * n/<pattern>/<completion>/[<suffix>/] next word 453 * N/<pattern>/<completion>/[<suffix>/] next-next word 454 */ 455 int 456 tw_complete(const Char *line, Char **word, Char **pat, int looking, eChar *suf) 457 { 458 Char *buf, **vec, **wl; 459 static Char nomatch[2] = { (Char) ~0, 0x00 }; 460 const Char *ptr; 461 size_t wordno; 462 int n; 463 464 buf = Strsave(line); 465 cleanup_push(buf, xfree); 466 /* Single-character words, empty current word, terminating NULL */ 467 wl = xmalloc(((Strlen(line) + 1) / 2 + 2) * sizeof (*wl)); 468 cleanup_push(wl, xfree); 469 470 /* find the command */ 471 if ((wl[0] = tw_tok(buf)) == NULL || wl[0] == INVPTR) { 472 cleanup_until(buf); 473 return TW_ZERO; 474 } 475 476 /* 477 * look for hardwired command completions using a globbing 478 * search and for arguments using a normal search. 479 */ 480 if ((vec = tw_find(wl[0], &completions, (looking == TW_COMMAND))) 481 == NULL) { 482 cleanup_until(buf); 483 return looking; 484 } 485 486 /* tokenize the line one more time :-( */ 487 for (wordno = 1; (wl[wordno] = tw_tok(NULL)) != NULL && 488 wl[wordno] != INVPTR; wordno++) 489 continue; 490 491 if (wl[wordno] == INVPTR) { /* Found a meta character */ 492 cleanup_until(buf); 493 return TW_ZERO; /* de-activate completions */ 494 } 495 #ifdef TDEBUG 496 { 497 size_t i; 498 for (i = 0; i < wordno; i++) 499 xprintf("'%s' ", short2str(wl[i])); 500 xprintf("\n"); 501 } 502 #endif /* TDEBUG */ 503 504 /* if the current word is empty move the last word to the next */ 505 if (**word == '\0') { 506 wl[wordno] = *word; 507 wordno++; 508 } 509 wl[wordno] = NULL; 510 511 512 #ifdef TDEBUG 513 xprintf("\r\n"); 514 xprintf(" w#: %lu\n", (unsigned long)wordno); 515 xprintf("line: %s\n", short2str(line)); 516 xprintf(" cmd: %s\n", short2str(wl[0])); 517 xprintf("word: %s\n", short2str(*word)); 518 xprintf("last: %s\n", wordno >= 2 ? short2str(wl[wordno-2]) : "n/a"); 519 xprintf("this: %s\n", wordno >= 1 ? short2str(wl[wordno-1]) : "n/a"); 520 #endif /* TDEBUG */ 521 522 for (;vec != NULL && (ptr = vec[0]) != NULL; vec++) { 523 Char *ran, /* The pattern or range X/<range>/XXXX/ */ 524 *com, /* The completion X/XXXXX/<completion>/ */ 525 *pos = NULL; /* scratch pointer */ 526 int cmd, res; 527 Char sep; /* the command and separator characters */ 528 529 if (ptr[0] == '\0') 530 continue; 531 532 #ifdef TDEBUG 533 xprintf("match %s\n", short2str(ptr)); 534 #endif /* TDEBUG */ 535 536 switch (cmd = ptr[0]) { 537 case 'N': 538 pos = (wordno < 3) ? nomatch : wl[wordno - 3]; 539 break; 540 case 'n': 541 pos = (wordno < 2) ? nomatch : wl[wordno - 2]; 542 break; 543 case 'c': 544 case 'C': 545 pos = (wordno < 1) ? nomatch : wl[wordno - 1]; 546 break; 547 case 'p': 548 break; 549 default: 550 stderror(ERR_COMPINV, CGETS(27, 1, "command"), cmd); 551 return TW_ZERO; 552 } 553 554 sep = ptr[1]; 555 if (!Ispunct(sep)) { 556 /* Truncates data if WIDE_STRINGS */ 557 stderror(ERR_COMPINV, CGETS(27, 2, "separator"), (int)sep); 558 return TW_ZERO; 559 } 560 561 ptr = tw_dollar(&ptr[2], wl, wordno, &ran, sep, 562 CGETS(27, 3, "pattern")); 563 cleanup_push(ran, xfree); 564 if (ran[0] == '\0') /* check for empty pattern (disallowed) */ 565 { 566 stderror(ERR_COMPINC, cmd == 'p' ? CGETS(27, 4, "range") : 567 CGETS(27, 3, "pattern"), ""); 568 return TW_ZERO; 569 } 570 571 ptr = tw_dollar(ptr, wl, wordno, &com, sep, 572 CGETS(27, 5, "completion")); 573 cleanup_push(com, xfree); 574 575 if (*ptr != '\0') { 576 if (*ptr == sep) 577 *suf = CHAR_ERR; 578 else 579 *suf = *ptr; 580 } 581 else 582 *suf = '\0'; 583 584 #ifdef TDEBUG 585 xprintf("command: %c\nseparator: %c\n", cmd, (int)sep); 586 xprintf("pattern: %s\n", short2str(ran)); 587 xprintf("completion: %s\n", short2str(com)); 588 xprintf("suffix: "); 589 switch (*suf) { 590 case 0: 591 xprintf("*auto suffix*\n"); 592 break; 593 case CHAR_ERR: 594 xprintf("*no suffix*\n"); 595 break; 596 default: 597 xprintf("%c\n", (int)*suf); 598 break; 599 } 600 #endif /* TDEBUG */ 601 602 switch (cmd) { 603 case 'p': /* positional completion */ 604 #ifdef TDEBUG 605 xprintf("p: tw_pos(%s, %lu) = ", short2str(ran), 606 (unsigned long)wordno - 1); 607 xprintf("%d\n", tw_pos(ran, wordno - 1)); 608 #endif /* TDEBUG */ 609 if (!tw_pos(ran, wordno - 1)) { 610 cleanup_until(ran); 611 continue; 612 } 613 break; 614 615 case 'N': /* match with the next-next word */ 616 case 'n': /* match with the next word */ 617 case 'c': /* match with the current word */ 618 case 'C': 619 #ifdef TDEBUG 620 xprintf("%c: ", cmd); 621 #endif /* TDEBUG */ 622 if ((n = tw_match(pos, ran)) < 0) { 623 cleanup_until(ran); 624 continue; 625 } 626 if (cmd == 'c') 627 *word += n; 628 break; 629 630 default: 631 abort(); /* Cannot happen */ 632 } 633 res = tw_result(com, pat); 634 cleanup_until(buf); 635 return res; 636 } 637 cleanup_until(buf); 638 *suf = '\0'; 639 return TW_ZERO; 640 } /* end tw_complete */ 641