contrib/tcsh-6/tw.comp.c

   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 */