Import tcsh-6.17.00
[dragonfly.git] / contrib / tcsh-6 / tw.comp.c
CommitLineData
57e3f2b5 1/* $Header: /p/tcsh/cvsroot/tcsh/tw.comp.c,v 1.42 2007/10/01 21:52:00 christos Exp $ */
7d8fb588
MS
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
57e3f2b5 35RCSID("$tcsh: tw.comp.c,v 1.42 2007/10/01 21:52:00 christos Exp $")
7d8fb588
MS
36
37#include "tw.h"
38#include "ed.h"
39#include "tc.h"
40
41/* #define TDEBUG */
42struct varent completions;
43
44static int tw_result (const Char *, Char **);
45static Char **tw_find (Char *, struct varent *, int);
46static Char *tw_tok (Char *);
47static int tw_pos (Char *, int);
48static void tw_pr (Char **);
49static int tw_match (const Char *, const Char *);
50static void tw_prlist (struct varent *);
51static 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*/
58void
59docomplete(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*/
93void
94douncomplete(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 */
104static void
105tw_prlist(struct varent *p)
106{
107 struct varent *c;
108
109 for (;;) {
110 while (p->v_left)
111 p = p->v_left;
112x:
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 */
142static void
143tw_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 */
168static Char **
169tw_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 */
193static int
194tw_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 */
221static Char *
222tw_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 */
250static int
251tw_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 */
268static int
269tw_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 */
405static const Char *
406tw_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 */
455int
456tw_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 }
57e3f2b5 633 tsetenv(STRCOMMAND_LINE, line);
7d8fb588 634 res = tw_result(com, pat);
57e3f2b5 635 Unsetenv(STRCOMMAND_LINE);
7d8fb588
MS
636 cleanup_until(buf);
637 return res;
638 }
639 cleanup_until(buf);
640 *suf = '\0';
641 return TW_ZERO;
642} /* end tw_complete */