contrib/tcsh-6/tw.comp.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/tw.comp.c,v 1.44 2014/07/24 10:50:15 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.44 2014/07/24 10:50:15 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 *, int);
  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, int exact)
 252 {
 253     const Char *estr;
 254     int rv = exact ? Gmatch(str, pat) : Gnmatch(str, pat, &estr);
 255 #ifdef TDEBUG
 256     xprintf("G%smatch(%s, ", exact ? "" : "n", short2str(str));
 257     xprintf("%s, ", short2str(pat));
 258     xprintf("%s) = %d [%" TCSH_PTRDIFF_T_FMT "d]\n", short2str(estr), rv,
 259         estr - str);
 260 #endif /* TDEBUG */
 261     return (int) (rv ? estr - str : -1);
 262 }
 263
 264
 265 /* tw_result():
 266  *      Return what the completion action should be depending on the
 267  *      string
 268  */
 269 static int
 270 tw_result(const Char *act, Char **pat)
 271 {
 272     int looking;
 273     static Char* res = NULL;
 274     Char *p;
 275
 276     if (res != NULL)
 277         xfree(res), res = NULL;
 278
 279     switch (act[0] & ~QUOTE) {
 280     case 'X':
 281         looking = TW_COMPLETION;
 282         break;
 283     case 'S':
 284         looking = TW_SIGNAL;
 285         break;
 286     case 'a':
 287         looking = TW_ALIAS;
 288         break;
 289     case 'b':
 290         looking = TW_BINDING;
 291         break;
 292     case 'c':
 293         looking = TW_COMMAND;
 294         break;
 295     case 'C':
 296         looking = TW_PATH | TW_COMMAND;
 297         break;
 298     case 'd':
 299         looking = TW_DIRECTORY;
 300         break;
 301     case 'D':
 302         looking = TW_PATH | TW_DIRECTORY;
 303         break;
 304     case 'e':
 305         looking = TW_ENVVAR;
 306         break;
 307     case 'f':
 308         looking = TW_FILE;
 309         break;
 310 #ifdef COMPAT
 311     case 'p':
 312 #endif /* COMPAT */
 313     case 'F':
 314         looking = TW_PATH | TW_FILE;
 315         break;
 316     case 'g':
 317         looking = TW_GRPNAME;
 318         break;
 319     case 'j':
 320         looking = TW_JOB;
 321         break;
 322     case 'l':
 323         looking = TW_LIMIT;
 324         break;
 325     case 'n':
 326         looking = TW_NONE;
 327         break;
 328     case 's':
 329         looking = TW_SHELLVAR;
 330         break;
 331     case 't':
 332         looking = TW_TEXT;
 333         break;
 334     case 'T':
 335         looking = TW_PATH | TW_TEXT;
 336         break;
 337     case 'v':
 338         looking = TW_VARIABLE;
 339         break;
 340     case 'u':
 341         looking = TW_USER;
 342         break;
 343     case 'x':
 344         looking = TW_EXPLAIN;
 345         break;
 346
 347     case '$':
 348         *pat = res = Strsave(&act[1]);
 349         (void) strip(res);
 350         return(TW_VARLIST);
 351
 352     case '(':
 353         *pat = res = Strsave(&act[1]);
 354         if ((p = Strchr(res, ')')) != NULL)
 355             *p = '\0';
 356         (void) strip(res);
 357         return TW_WORDLIST;
 358
 359     case '`':
 360         res = Strsave(act);
 361         if ((p = Strchr(&res[1], '`')) != NULL)
 362             *++p = '\0';
 363
 364         if (didfds == 0) {
 365             /*
 366              * Make sure that we have some file descriptors to
 367              * play with, so that the processes have at least 0, 1, 2
 368              * open
 369              */
 370             (void) dcopy(SHIN, 0);
 371             (void) dcopy(SHOUT, 1);
 372             (void) dcopy(SHDIAG, 2);
 373         }
 374         if ((p = globone(res, G_APPEND)) != NULL) {
 375             xfree(res), res = NULL;
 376             *pat = res = Strsave(p);
 377             xfree(p);
 378             return TW_WORDLIST;
 379         }
 380         return TW_ZERO;
 381
 382     default:
 383         stderror(ERR_COMPCOM, short2str(act));
 384         return TW_ZERO;
 385     }
 386
 387     switch (act[1] & ~QUOTE) {
 388     case '\0':
 389         return looking;
 390
 391     case ':':
 392         *pat = res = Strsave(&act[2]);
 393         (void) strip(res);
 394         return looking;
 395
 396     default:
 397         stderror(ERR_COMPCOM, short2str(act));
 398         return TW_ZERO;
 399     }
 400 } /* end tw_result */
 401
 402
 403 /* tw_dollar():
 404  *      Expand $<n> args in buffer
 405  */
 406 static const Char *
 407 tw_dollar(const Char *str, Char **wl, size_t nwl, Char **result, Char sep,
 408           const char *msg)
 409 {
 410     struct Strbuf buf = Strbuf_INIT;
 411     Char *res;
 412     const Char *sp;
 413
 414     for (sp = str; *sp && *sp != sep;)
 415         if (sp[0] == '$' && sp[1] == ':' && Isdigit(sp[sp[2] == '-' ? 3 : 2])) {
 416             int num, neg = 0;
 417             sp += 2;
 418             if (*sp == '-') {
 419                 neg = 1;
 420                 sp++;
 421             }
 422             for (num = *sp++ - '0'; Isdigit(*sp); num += 10 * num + *sp++ - '0')
 423                 continue;
 424             if (neg)
 425                 num = nwl - num - 1;
 426             if (num >= 0 && (size_t)num < nwl)
 427                 Strbuf_append(&buf, wl[num]);
 428         }
 429         else
 430             Strbuf_append1(&buf, *sp++);
 431
 432     res = Strbuf_finish(&buf);
 433
 434     if (*sp++ == sep) {
 435         *result = res;
 436         return sp;
 437     }
 438
 439     xfree(res);
 440     /* Truncates data if WIDE_STRINGS */
 441     stderror(ERR_COMPMIS, (int)sep, msg, short2str(str));
 442     return --sp;
 443 } /* end tw_dollar */
 444
 445
 446 /* tw_complete():
 447  *      Return the appropriate completion for the command
 448  *
 449  *      valid completion strings are:
 450  *      p/<range>/<completion>/[<suffix>/]      positional
 451  *      c/<pattern>/<completion>/[<suffix>/]    current word ignore pattern
 452  *      C/<pattern>/<completion>/[<suffix>/]    current word with pattern
 453  *      n/<pattern>/<completion>/[<suffix>/]    next word
 454  *      N/<pattern>/<completion>/[<suffix>/]    next-next word
 455  */
 456 int
 457 tw_complete(const Char *line, Char **word, Char **pat, int looking, eChar *suf)
 458 {
 459     Char *buf, **vec, **wl;
 460     static Char nomatch[2] = { (Char) ~0, 0x00 };
 461     const Char *ptr;
 462     size_t wordno;
 463     int n;
 464
 465     buf = Strsave(line);
 466     cleanup_push(buf, xfree);
 467     /* Single-character words, empty current word, terminating NULL */
 468     wl = xmalloc(((Strlen(line) + 1) / 2 + 2) * sizeof (*wl));
 469     cleanup_push(wl, xfree);
 470
 471     /* find the command */
 472     if ((wl[0] = tw_tok(buf)) == NULL || wl[0] == INVPTR) {
 473         cleanup_until(buf);
 474         return TW_ZERO;
 475     }
 476
 477     /*
 478      * look for hardwired command completions using a globbing
 479      * search and for arguments using a normal search.
 480      */
 481     if ((vec = tw_find(wl[0], &completions, (looking == TW_COMMAND)))
 482         == NULL) {
 483         cleanup_until(buf);
 484         return looking;
 485     }
 486
 487     /* tokenize the line one more time :-( */
 488     for (wordno = 1; (wl[wordno] = tw_tok(NULL)) != NULL &&
 489                       wl[wordno] != INVPTR; wordno++)
 490         continue;
 491
 492     if (wl[wordno] == INVPTR) {         /* Found a meta character */
 493         cleanup_until(buf);
 494         return TW_ZERO;                 /* de-activate completions */
 495     }
 496 #ifdef TDEBUG
 497     {
 498         size_t i;
 499         for (i = 0; i < wordno; i++)
 500             xprintf("'%s' ", short2str(wl[i]));
 501         xprintf("\n");
 502     }
 503 #endif /* TDEBUG */
 504
 505     /* if the current word is empty move the last word to the next */
 506     if (**word == '\0') {
 507         wl[wordno] = *word;
 508         wordno++;
 509     }
 510     wl[wordno] = NULL;
 511
 512
 513 #ifdef TDEBUG
 514     xprintf("\r\n");
 515     xprintf("  w#: %lu\n", (unsigned long)wordno);
 516     xprintf("line: %s\n", short2str(line));
 517     xprintf(" cmd: %s\n", short2str(wl[0]));
 518     xprintf("word: %s\n", short2str(*word));
 519     xprintf("last: %s\n", wordno >= 2 ? short2str(wl[wordno-2]) : "n/a");
 520     xprintf("this: %s\n", wordno >= 1 ? short2str(wl[wordno-1]) : "n/a");
 521 #endif /* TDEBUG */
 522
 523     for (;vec != NULL && (ptr = vec[0]) != NULL; vec++) {
 524         Char  *ran,             /* The pattern or range X/<range>/XXXX/ */
 525               *com,             /* The completion X/XXXXX/<completion>/ */
 526              *pos = NULL;       /* scratch pointer                      */
 527         int   cmd, res;
 528         Char  sep;              /* the command and separator characters */
 529         int   exact;
 530
 531         if (ptr[0] == '\0')
 532             continue;
 533
 534 #ifdef TDEBUG
 535         xprintf("match %s\n", short2str(ptr));
 536 #endif /* TDEBUG */
 537
 538         switch (cmd = ptr[0]) {
 539         case 'N':
 540             pos = (wordno < 3) ? nomatch : wl[wordno - 3];
 541             break;
 542         case 'n':
 543             pos = (wordno < 2) ? nomatch : wl[wordno - 2];
 544             break;
 545         case 'c':
 546         case 'C':
 547             pos = (wordno < 1) ? nomatch : wl[wordno - 1];
 548             break;
 549         case 'p':
 550             break;
 551         default:
 552             stderror(ERR_COMPINV, CGETS(27, 1, "command"), cmd);
 553             return TW_ZERO;
 554         }
 555
 556         sep = ptr[1];
 557         if (!Ispunct(sep)) {
 558             /* Truncates data if WIDE_STRINGS */
 559             stderror(ERR_COMPINV, CGETS(27, 2, "separator"), (int)sep);
 560             return TW_ZERO;
 561         }
 562
 563         ptr = tw_dollar(&ptr[2], wl, wordno, &ran, sep,
 564                         CGETS(27, 3, "pattern"));
 565         cleanup_push(ran, xfree);
 566         if (ran[0] == '\0')     /* check for empty pattern (disallowed) */
 567         {
 568             stderror(ERR_COMPINC, cmd == 'p' ?  CGETS(27, 4, "range") :
 569                      CGETS(27, 3, "pattern"), "");
 570             return TW_ZERO;
 571         }
 572
 573         ptr = tw_dollar(ptr, wl, wordno, &com, sep,
 574                         CGETS(27, 5, "completion"));
 575         cleanup_push(com, xfree);
 576
 577         if (*ptr != '\0') {
 578             if (*ptr == sep)
 579                 *suf = CHAR_ERR;
 580             else
 581                 *suf = *ptr;
 582         }
 583         else
 584             *suf = '\0';
 585
 586 #ifdef TDEBUG
 587         xprintf("command:    %c\nseparator:  %c\n", cmd, (int)sep);
 588         xprintf("pattern:    %s\n", short2str(ran));
 589         xprintf("completion: %s\n", short2str(com));
 590         xprintf("suffix:     ");
 591         switch (*suf) {
 592         case 0:
 593             xprintf("*auto suffix*\n");
 594             break;
 595         case CHAR_ERR:
 596             xprintf("*no suffix*\n");
 597             break;
 598         default:
 599             xprintf("%c\n", (int)*suf);
 600             break;
 601         }
 602 #endif /* TDEBUG */
 603
 604         exact = 0;
 605         switch (cmd) {
 606         case 'p':                       /* positional completion */
 607 #ifdef TDEBUG
 608             xprintf("p: tw_pos(%s, %lu) = ", short2str(ran),
 609                     (unsigned long)wordno - 1);
 610             xprintf("%d\n", tw_pos(ran, wordno - 1));
 611 #endif /* TDEBUG */
 612             if (!tw_pos(ran, wordno - 1)) {
 613                 cleanup_until(ran);
 614                 continue;
 615             }
 616             break;
 617
 618         case 'N':                       /* match with the next-next word */
 619         case 'n':                       /* match with the next word */
 620             exact = 1;
 621             /*FALLTHROUGH*/
 622         case 'c':                       /* match with the current word */
 623         case 'C':
 624 #ifdef TDEBUG
 625             xprintf("%c: ", cmd);
 626 #endif /* TDEBUG */
 627             if ((n = tw_match(pos, ran, exact)) < 0) {
 628                 cleanup_until(ran);
 629                 continue;
 630             }
 631             if (cmd == 'c')
 632                 *word += n;
 633             break;
 634
 635         default:
 636             abort();                   /* Cannot happen */
 637         }
 638         tsetenv(STRCOMMAND_LINE, line);
 639         res = tw_result(com, pat);
 640         Unsetenv(STRCOMMAND_LINE);
 641         cleanup_until(buf);
 642         return res;
 643     }
 644     cleanup_until(buf);
 645     *suf = '\0';
 646     return TW_ZERO;
 647 } /* end tw_complete */