1 /* $NetBSD: edit.c,v 1.25 2010/06/05 03:02:37 sjg Exp $ */
2
3 /*
4 * Command line editing - common code
5 *
6 */
7 #include <sys/cdefs.h>
8
9 #ifndef lint
10 __RCSID("$NetBSD: edit.c,v 1.25 2010/06/05 03:02:37 sjg Exp $");
11 #endif
12
13
14 #include "config.h"
15 #ifdef EDIT
16
17 #include "sh.h"
18 #include "tty.h"
19 #define EXTERN
20 #include "edit.h"
21 #undef EXTERN
22 #ifdef OS_SCO /* SCO Unix 3.2v4.1 */
23 # include <sys/stream.h> /* needed for <sys/ptem.h> */
24 # include <sys/ptem.h> /* needed for struct winsize */
25 #endif /* OS_SCO */
26 #include <sys/ioctl.h>
27 #include <ctype.h>
28 #include "ksh_stat.h"
29
30
31 #if defined(TIOCGWINSZ)
32 static RETSIGTYPE x_sigwinch ARGS((int sig));
33 static int got_sigwinch;
34 static void check_sigwinch ARGS((void));
35 #endif /* TIOCGWINSZ */
36
37 static int x_file_glob ARGS((int flags, const char *str, int slen,
38 char ***wordsp));
39 static int x_command_glob ARGS((int flags, const char *str, int slen,
40 char ***wordsp));
41 static int x_locate_word ARGS((const char *buf, int buflen, int pos,
42 int *startp, int *is_command));
43
44 static char vdisable_c;
45
46
47 /* Called from main */
48 void
x_init()49 x_init()
50 {
51 /* set to -2 to force initial binding */
52 edchars.erase = edchars.kill = edchars.intr = edchars.quit
53 = edchars.eof = -2;
54 /* default value for deficient systems */
55 edchars.werase = 027; /* ^W */
56
57 #ifdef TIOCGWINSZ
58 # ifdef SIGWINCH
59 if (setsig(&sigtraps[SIGWINCH], x_sigwinch, SS_RESTORE_ORIG|SS_SHTRAP))
60 sigtraps[SIGWINCH].flags |= TF_SHELL_USES;
61 # endif /* SIGWINCH */
62 got_sigwinch = 1; /* force initial check */
63 check_sigwinch();
64 #endif /* TIOCGWINSZ */
65
66 #ifdef EMACS
67 x_init_emacs();
68 #endif /* EMACS */
69
70 /* Bizarreness to figure out how to disable
71 * a struct termios.c_cc[] char
72 */
73 #ifdef _POSIX_VDISABLE
74 if (_POSIX_VDISABLE >= 0)
75 vdisable_c = (char) _POSIX_VDISABLE;
76 else
77 /* `feature not available' */
78 vdisable_c = (char) 0377;
79 #else
80 # if defined(HAVE_PATHCONF) && defined(_PC_VDISABLE)
81 vdisable_c = fpathconf(tty_fd, _PC_VDISABLE);
82 # else
83 vdisable_c = (char) 0377; /* default to old BSD value */
84 # endif
85 #endif /* _POSIX_VDISABLE */
86 }
87
88 #if defined(TIOCGWINSZ)
89 static RETSIGTYPE
x_sigwinch(sig)90 x_sigwinch(sig)
91 int sig;
92 {
93 got_sigwinch = 1;
94 return RETSIGVAL;
95 }
96
97 static void
check_sigwinch(void)98 check_sigwinch ARGS((void))
99 {
100 if (got_sigwinch) {
101 struct winsize ws;
102
103 got_sigwinch = 0;
104 if (procpid == kshpid && ioctl(tty_fd, TIOCGWINSZ, &ws) >= 0) {
105 struct tbl *vp;
106
107 /* Do NOT export COLUMNS/LINES. Many applications
108 * check COLUMNS/LINES before checking ws.ws_col/row,
109 * so if the app is started with C/L in the environ
110 * and the window is then resized, the app won't
111 * see the change cause the environ doesn't change.
112 */
113 if (ws.ws_col) {
114 x_cols = ws.ws_col < MIN_COLS ? MIN_COLS
115 : ws.ws_col;
116
117 if ((vp = typeset("COLUMNS", 0, 0, 0, 0)))
118 setint(vp, (long) ws.ws_col);
119 }
120 if (ws.ws_row
121 && (vp = typeset("LINES", 0, 0, 0, 0)))
122 setint(vp, (long) ws.ws_row);
123 }
124 }
125 }
126 #endif /* TIOCGWINSZ */
127
128 /*
129 * read an edited command line
130 */
131 int
x_read(buf,len)132 x_read(buf, len)
133 char *buf;
134 size_t len;
135 {
136 int i;
137
138 x_mode(TRUE);
139 #ifdef EMACS
140 if (Flag(FEMACS) || Flag(FGMACS))
141 i = x_emacs(buf, len);
142 else
143 #endif
144 #ifdef VI
145 if (Flag(FVI))
146 i = x_vi(buf, len);
147 else
148 #endif
149 i = -1; /* internal error */
150 x_mode(FALSE);
151 #if defined(TIOCGWINSZ)
152 if (got_sigwinch)
153 check_sigwinch();
154 #endif /* TIOCGWINSZ */
155
156 return i;
157 }
158
159 /* tty I/O */
160
161 int
x_getc()162 x_getc()
163 {
164 #ifdef OS2
165 unsigned char c = _read_kbd(0, 1, 0);
166 return c == 0 ? 0xE0 : c;
167 #else /* OS2 */
168 char c;
169 int n;
170
171 while ((n = blocking_read(0, &c, 1)) < 0 && errno == EINTR)
172 if (trap) {
173 x_mode(FALSE);
174 runtraps(0);
175 x_mode(TRUE);
176 }
177 if (n != 1)
178 return -1;
179 return (int) (unsigned char) c;
180 #endif /* OS2 */
181 }
182
183 void
x_flush()184 x_flush()
185 {
186 shf_flush(shl_out);
187 }
188
189 void
x_putc(c)190 x_putc(c)
191 int c;
192 {
193 shf_putc(c, shl_out);
194 }
195
196 void
x_puts(s)197 x_puts(s)
198 const char *s;
199 {
200 while (*s != 0)
201 shf_putc(*s++, shl_out);
202 }
203
204 bool_t
x_mode(onoff)205 x_mode(onoff)
206 bool_t onoff;
207 {
208 static bool_t x_cur_mode;
209 bool_t prev;
210
211 if (x_cur_mode == onoff)
212 return x_cur_mode;
213 prev = x_cur_mode;
214 x_cur_mode = onoff;
215
216 if (onoff) {
217 TTY_state cb;
218 X_chars oldchars;
219
220 oldchars = edchars;
221 cb = tty_state;
222
223 #if defined(HAVE_TERMIOS_H) || defined(HAVE_TERMIO_H)
224 edchars.erase = cb.c_cc[VERASE];
225 edchars.kill = cb.c_cc[VKILL];
226 edchars.intr = cb.c_cc[VINTR];
227 edchars.quit = cb.c_cc[VQUIT];
228 edchars.eof = cb.c_cc[VEOF];
229 # ifdef VWERASE
230 edchars.werase = cb.c_cc[VWERASE];
231 # endif
232 # ifdef _CRAY2 /* brain-damaged terminal handler */
233 cb.c_lflag &= ~(ICANON|ECHO);
234 /* rely on print routine to map '\n' to CR,LF */
235 # else
236 cb.c_iflag &= ~(INLCR|ICRNL);
237 # ifdef _BSD_SYSV /* need to force CBREAK instead of RAW (need CRMOD on output) */
238 cb.c_lflag &= ~(ICANON|ECHO);
239 # else
240 # ifdef SWTCH /* need CBREAK to handle swtch char */
241 cb.c_lflag &= ~(ICANON|ECHO);
242 cb.c_lflag |= ISIG;
243 cb.c_cc[VINTR] = vdisable_c;
244 cb.c_cc[VQUIT] = vdisable_c;
245 # else
246 cb.c_lflag &= ~(ISIG|ICANON|ECHO);
247 # endif
248 # endif
249 # ifdef VLNEXT
250 /* osf/1 processes lnext when ~icanon */
251 cb.c_cc[VLNEXT] = vdisable_c;
252 # endif /* VLNEXT */
253 # ifdef VDISCARD
254 /* sunos 4.1.x & osf/1 processes discard(flush) when ~icanon */
255 cb.c_cc[VDISCARD] = vdisable_c;
256 # endif /* VDISCARD */
257 cb.c_cc[VTIME] = 0;
258 cb.c_cc[VMIN] = 1;
259 # endif /* _CRAY2 */
260 #else
261 /* Assume BSD tty stuff. */
262 edchars.erase = cb.sgttyb.sg_erase;
263 edchars.kill = cb.sgttyb.sg_kill;
264 cb.sgttyb.sg_flags &= ~ECHO;
265 cb.sgttyb.sg_flags |= CBREAK;
266 # ifdef TIOCGATC
267 edchars.intr = cb.lchars.tc_intrc;
268 edchars.quit = cb.lchars.tc_quitc;
269 edchars.eof = cb.lchars.tc_eofc;
270 edchars.werase = cb.lchars.tc_werasc;
271 cb.lchars.tc_suspc = -1;
272 cb.lchars.tc_dsuspc = -1;
273 cb.lchars.tc_lnextc = -1;
274 cb.lchars.tc_statc = -1;
275 cb.lchars.tc_intrc = -1;
276 cb.lchars.tc_quitc = -1;
277 cb.lchars.tc_rprntc = -1;
278 # else
279 edchars.intr = cb.tchars.t_intrc;
280 edchars.quit = cb.tchars.t_quitc;
281 edchars.eof = cb.tchars.t_eofc;
282 cb.tchars.t_intrc = -1;
283 cb.tchars.t_quitc = -1;
284 # ifdef TIOCGLTC
285 edchars.werase = cb.ltchars.t_werasc;
286 cb.ltchars.t_suspc = -1;
287 cb.ltchars.t_dsuspc = -1;
288 cb.ltchars.t_lnextc = -1;
289 cb.ltchars.t_rprntc = -1;
290 # endif
291 # endif /* TIOCGATC */
292 #endif /* HAVE_TERMIOS_H || HAVE_TERMIO_H */
293
294 set_tty(tty_fd, &cb, TF_WAIT);
295
296 #ifdef __CYGWIN__
297 if (edchars.eof == '\0')
298 edchars.eof = '\4';
299 #endif /* __CYGWIN__ */
300
301 /* Convert unset values to internal `unset' value */
302 if (edchars.erase == vdisable_c)
303 edchars.erase = -1;
304 if (edchars.kill == vdisable_c)
305 edchars.kill = -1;
306 if (edchars.intr == vdisable_c)
307 edchars.intr = -1;
308 if (edchars.quit == vdisable_c)
309 edchars.quit = -1;
310 if (edchars.eof == vdisable_c)
311 edchars.eof = -1;
312 if (edchars.werase == vdisable_c)
313 edchars.werase = -1;
314 if (memcmp(&edchars, &oldchars, sizeof(edchars)) != 0) {
315 #ifdef EMACS
316 x_emacs_keys(&edchars);
317 #endif
318 }
319 } else {
320 /* TF_WAIT doesn't seem to be necessary when leaving xmode */
321 set_tty(tty_fd, &tty_state, TF_NONE);
322 }
323
324 return prev;
325 }
326
327 /* NAME:
328 * promptlen - calculate the length of PS1 etc.
329 *
330 * DESCRIPTION:
331 * This function is based on a fix from guy@demon.co.uk
332 * It fixes a bug in that if PS1 contains '!', the length
333 * given by strlen() is probably wrong.
334 *
335 * RETURN VALUE:
336 * length
337 */
338 int
promptlen(cp,spp)339 promptlen(cp, spp)
340 const char *cp;
341 const char **spp;
342 {
343 int count = 0;
344 const char *sp = cp;
345 char delimiter = 0;
346 int indelimit = 0;
347
348 /* Undocumented AT&T ksh feature:
349 * If the second char in the prompt string is \r then the first char
350 * is taken to be a non-printing delimiter and any chars between two
351 * instances of the delimiter are not considered to be part of the
352 * prompt length
353 */
354 if (*cp && cp[1] == '\r') {
355 delimiter = *cp;
356 cp += 2;
357 }
358
359 for (; *cp; cp++) {
360 if (indelimit && *cp != delimiter)
361 ;
362 else if (*cp == '\n' || *cp == '\r') {
363 count = 0;
364 sp = cp + 1;
365 } else if (*cp == '\t') {
366 count = (count | 7) + 1;
367 } else if (*cp == '\b') {
368 if (count > 0)
369 count--;
370 } else if (*cp == delimiter)
371 indelimit = !indelimit;
372 else
373 count++;
374 }
375 if (spp)
376 *spp = sp;
377 return count;
378 }
379
380 void
set_editmode(ed)381 set_editmode(ed)
382 const char *ed;
383 {
384 static const enum sh_flag edit_flags[] = {
385 #ifdef EMACS
386 FEMACS, FGMACS,
387 #endif
388 #ifdef VI
389 FVI,
390 #endif
391 };
392 char *rcp;
393 size_t i;
394
395 if ((rcp = ksh_strrchr_dirsep(ed)))
396 ed = ++rcp;
397 for (i = 0; i < NELEM(edit_flags); i++)
398 if (strstr(ed, goptions[(int) edit_flags[i]].name)) {
399 change_flag(edit_flags[i], OF_SPECIAL, 1);
400 return;
401 }
402 }
403
404 /* ------------------------------------------------------------------------- */
405 /* Misc common code for vi/emacs */
406
407 /* Handle the commenting/uncommenting of a line.
408 * Returns:
409 * 1 if a carriage return is indicated (comment added)
410 * 0 if no return (comment removed)
411 * -1 if there is an error (not enough room for comment chars)
412 * If successful, *lenp contains the new length. Note: cursor should be
413 * moved to the start of the line after (un)commenting.
414 */
415 int
x_do_comment(buf,bsize,lenp)416 x_do_comment(buf, bsize, lenp)
417 char *buf;
418 int bsize;
419 int *lenp;
420 {
421 int i, j;
422 int len = *lenp;
423
424 if (len == 0)
425 return 1; /* somewhat arbitrary - it's what at&t ksh does */
426
427 /* Already commented? */
428 if (buf[0] == '#') {
429 int saw_nl = 0;
430
431 for (j = 0, i = 1; i < len; i++) {
432 if (!saw_nl || buf[i] != '#')
433 buf[j++] = buf[i];
434 saw_nl = buf[i] == '\n';
435 }
436 *lenp = j;
437 return 0;
438 } else {
439 int n = 1;
440
441 /* See if there's room for the #'s - 1 per \n */
442 for (i = 0; i < len; i++)
443 if (buf[i] == '\n')
444 n++;
445 if (len + n >= bsize)
446 return -1;
447 /* Now add them... */
448 for (i = len, j = len + n; --i >= 0; ) {
449 if (buf[i] == '\n')
450 buf[--j] = '#';
451 buf[--j] = buf[i];
452 }
453 buf[0] = '#';
454 *lenp += n;
455 return 1;
456 }
457 }
458
459 /* ------------------------------------------------------------------------- */
460 /* Common file/command completion code for vi/emacs */
461
462
463 static char *add_glob ARGS((const char *, int));
464 static void glob_table ARGS((const char *, XPtrV *, struct table *));
465 static void glob_path ARGS((int, const char *, XPtrV *, const char *));
466
467 #if 0 /* not used... */
468 int x_complete_word ARGS((const char *, int, int, int *, char **));
469 int
470 x_complete_word(str, slen, is_command, nwordsp, ret)
471 const char *str;
472 int slen;
473 int is_command;
474 int *nwordsp;
475 char **ret;
476 {
477 int nwords;
478 int prefix_len;
479 char **words;
480
481 nwords = (is_command ? x_command_glob : x_file_glob)(XCF_FULLPATH,
482 str, slen, &words);
483 *nwordsp = nwords;
484 if (nwords == 0) {
485 *ret = (char *) 0;
486 return -1;
487 }
488
489 prefix_len = x_longest_prefix(nwords, words);
490 *ret = str_nsave(words[0], prefix_len, ATEMP);
491 x_free_words(nwords, words);
492 return prefix_len;
493 }
494 #endif /* 0 */
495
496 void
x_print_expansions(nwords,words,is_command)497 x_print_expansions(nwords, words, is_command)
498 int nwords;
499 char *const *words;
500 int is_command;
501 {
502 int use_copy = 0;
503 int prefix_len;
504 XPtrV l;
505
506 l.beg = NULL;
507
508 /* Check if all matches are in the same directory (in this
509 * case, we want to omit the directory name)
510 */
511 if (!is_command
512 && (prefix_len = x_longest_prefix(nwords, words)) > 0)
513 {
514 int i;
515
516 /* Special case for 1 match (prefix is whole word) */
517 if (nwords == 1)
518 prefix_len = x_basename(words[0], (char *) 0);
519 /* Any (non-trailing) slashes in non-common word suffixes? */
520 for (i = 0; i < nwords; i++)
521 if (x_basename(words[i] + prefix_len, (char *) 0)
522 > prefix_len)
523 break;
524 /* All in same directory? */
525 if (i == nwords) {
526 while (prefix_len > 0
527 && !ISDIRSEP(words[0][prefix_len - 1]))
528 prefix_len--;
529 use_copy = 1;
530 XPinit(l, nwords + 1);
531 for (i = 0; i < nwords; i++)
532 XPput(l, words[i] + prefix_len);
533 XPput(l, (char *) 0);
534 }
535 }
536
537 /*
538 * Enumerate expansions
539 */
540 x_putc('\r');
541 x_putc('\n');
542 pr_list(use_copy ? (char **) XPptrv(l) : words);
543
544 if (use_copy)
545 XPfree(l); /* not x_free_words() */
546 }
547
548 /*
549 * Do file globbing:
550 * - appends * to (copy of) str if no globbing chars found
551 * - does expansion, checks for no match, etc.
552 * - sets *wordsp to array of matching strings
553 * - returns number of matching strings
554 */
555 static int
x_file_glob(flags,str,slen,wordsp)556 x_file_glob(flags, str, slen, wordsp)
557 int flags;
558 const char *str;
559 int slen;
560 char ***wordsp;
561 {
562 char *toglob;
563 char **words;
564 int nwords, i, idx, escaping;
565 XPtrV w;
566 struct source *s, *sold;
567
568 if (slen < 0)
569 return 0;
570
571 toglob = add_glob(str, slen);
572
573 /* remove all escaping backward slashes */
574 escaping = 0;
575 for(i = 0, idx = 0; toglob[i]; i++) {
576 if (toglob[i] == '\\' && !escaping) {
577 escaping = 1;
578 continue;
579 }
580
581 toglob[idx] = toglob[i];
582 idx++;
583 if (escaping) escaping = 0;
584 }
585 toglob[idx] = '\0';
586
587 /*
588 * Convert "foo*" (toglob) to an array of strings (words)
589 */
590 sold = source;
591 s = pushs(SWSTR, ATEMP);
592 s->start = s->str = toglob;
593 source = s;
594 if (yylex(ONEWORD) != LWORD) {
595 source = sold;
596 internal_errorf(0, "fileglob: substitute error");
597 return 0;
598 }
599 source = sold;
600 XPinit(w, 32);
601 expand(yylval.cp, &w, DOGLOB|DOTILDE|DOMARKDIRS);
602 XPput(w, NULL);
603 words = (char **) XPclose(w);
604
605 for (nwords = 0; words[nwords]; nwords++)
606 ;
607 if (nwords == 1) {
608 struct stat statb;
609
610 /* Check if globbing failed (returned glob pattern),
611 * but be careful (E.g. toglob == "ab*" when the file
612 * "ab*" exists is not an error).
613 * Also, check for empty result - happens if we tried
614 * to glob something which evaluated to an empty
615 * string (e.g., "$FOO" when there is no FOO, etc).
616 */
617 if ((strcmp(words[0], toglob) == 0
618 && stat(words[0], &statb) < 0)
619 || words[0][0] == '\0')
620 {
621 x_free_words(nwords, words);
622 words = NULL;
623 nwords = 0;
624 }
625 }
626 afree(toglob, ATEMP);
627
628 if (nwords) {
629 *wordsp = words;
630 } else if (words) {
631 x_free_words(nwords, words);
632 *wordsp = NULL;
633 }
634 return nwords;
635 }
636
637 /* Data structure used in x_command_glob() */
638 struct path_order_info {
639 char *word;
640 int base;
641 int path_order;
642 };
643
644 static int path_order_cmp(const void *aa, const void *bb);
645
646 /* Compare routine used in x_command_glob() */
647 static int
path_order_cmp(aa,bb)648 path_order_cmp(aa, bb)
649 const void *aa;
650 const void *bb;
651 {
652 const struct path_order_info *a = (const struct path_order_info *) aa;
653 const struct path_order_info *b = (const struct path_order_info *) bb;
654 int t;
655
656 t = FILECMP(a->word + a->base, b->word + b->base);
657 return t ? t : a->path_order - b->path_order;
658 }
659
660 static int
x_command_glob(flags,str,slen,wordsp)661 x_command_glob(flags, str, slen, wordsp)
662 int flags;
663 const char *str;
664 int slen;
665 char ***wordsp;
666 {
667 char *toglob;
668 char *pat;
669 char *fpath;
670 int nwords;
671 XPtrV w;
672 struct block *l;
673
674 if (slen < 0)
675 return 0;
676
677 toglob = add_glob(str, slen);
678
679 /* Convert "foo*" (toglob) to a pattern for future use */
680 pat = evalstr(toglob, DOPAT|DOTILDE);
681 afree(toglob, ATEMP);
682
683 XPinit(w, 32);
684
685 glob_table(pat, &w, &keywords);
686 glob_table(pat, &w, &aliases);
687 glob_table(pat, &w, &builtins);
688 for (l = e->loc; l; l = l->next)
689 glob_table(pat, &w, &l->funs);
690
691 glob_path(flags, pat, &w, path);
692 if ((fpath = str_val(global("FPATH"))) != null)
693 glob_path(flags, pat, &w, fpath);
694
695 nwords = XPsize(w);
696
697 if (!nwords) {
698 *wordsp = (char **) 0;
699 XPfree(w);
700 return 0;
701 }
702
703 /* Sort entries */
704 if (flags & XCF_FULLPATH) {
705 /* Sort by basename, then path order */
706 struct path_order_info *info;
707 struct path_order_info *last_info = 0;
708 char **words = (char **) XPptrv(w);
709 int path_order = 0;
710 int i;
711
712 info = (struct path_order_info *)
713 alloc(sizeof(struct path_order_info) * nwords, ATEMP);
714 for (i = 0; i < nwords; i++) {
715 info[i].word = words[i];
716 info[i].base = x_basename(words[i], (char *) 0);
717 if (!last_info || info[i].base != last_info->base
718 || FILENCMP(words[i],
719 last_info->word, info[i].base) != 0)
720 {
721 last_info = &info[i];
722 path_order++;
723 }
724 info[i].path_order = path_order;
725 }
726 qsort(info, nwords, sizeof(struct path_order_info),
727 path_order_cmp);
728 for (i = 0; i < nwords; i++)
729 words[i] = info[i].word;
730 afree((void *) info, ATEMP);
731 } else {
732 /* Sort and remove duplicate entries */
733 char **words = (char **) XPptrv(w);
734 int i, j;
735
736 qsortp(XPptrv(w), (size_t) nwords, xstrcmp);
737
738 for (i = j = 0; i < nwords - 1; i++) {
739 if (strcmp(words[i], words[i + 1]))
740 words[j++] = words[i];
741 else
742 afree(words[i], ATEMP);
743 }
744 words[j++] = words[i];
745 nwords = j;
746 w.cur = (void **) &words[j];
747 }
748
749 XPput(w, NULL);
750 *wordsp = (char **) XPclose(w);
751
752 return nwords;
753 }
754
755 #define IS_WORDC(c) !( ctype(c, C_LEX1) || (c) == '\'' || (c) == '"' \
756 || (c) == '`' || (c) == '=' || (c) == ':' )
757
758 static int
x_locate_word(buf,buflen,pos,startp,is_commandp)759 x_locate_word(buf, buflen, pos, startp, is_commandp)
760 const char *buf;
761 int buflen;
762 int pos;
763 int *startp;
764 int *is_commandp;
765 {
766 int p;
767 int start, end;
768
769 /* Bad call? Probably should report error */
770 if (pos < 0 || pos > buflen) {
771 *startp = pos;
772 *is_commandp = 0;
773 return 0;
774 }
775 /* The case where pos == buflen happens to take care of itself... */
776
777 start = pos;
778 /* Keep going backwards to start of word (has effect of allowing
779 * one blank after the end of a word)
780 */
781 for (; (start > 0 && IS_WORDC(buf[start - 1]))
782 || (start > 1 && buf[start-2] == '\\'); start--)
783 ;
784 /* Go forwards to end of word */
785 for (end = start; end < buflen && IS_WORDC(buf[end]); end++) {
786 if (buf[end] == '\\' && (end+1) < buflen)
787 end++;
788 }
789
790 if (is_commandp) {
791 int iscmd;
792
793 /* Figure out if this is a command */
794 for (p = start - 1; p >= 0 && isspace((unsigned char)buf[p]); p--)
795 ;
796 iscmd = p < 0 || strchr(";|&()`", buf[p]);
797 if (iscmd) {
798 /* If command has a /, path, etc. is not searched;
799 * only current directory is searched, which is just
800 * like file globbing.
801 */
802 for (p = start; p < end; p++)
803 if (ISDIRSEP(buf[p]))
804 break;
805 iscmd = p == end;
806 }
807 *is_commandp = iscmd;
808 }
809
810 *startp = start;
811
812 return end - start;
813 }
814
815 int
x_cf_glob(flags,buf,buflen,pos,startp,endp,wordsp,is_commandp)816 x_cf_glob(flags, buf, buflen, pos, startp, endp, wordsp, is_commandp)
817 int flags;
818 const char *buf;
819 int buflen;
820 int pos;
821 int *startp;
822 int *endp;
823 char ***wordsp;
824 int *is_commandp;
825 {
826 int len;
827 int nwords;
828 char **words;
829 int is_command;
830
831 len = x_locate_word(buf, buflen, pos, startp, &is_command);
832 if (!(flags & XCF_COMMAND))
833 is_command = 0;
834 /* Don't do command globing on zero length strings - it takes too
835 * long and isn't very useful. File globs are more likely to be
836 * useful, so allow these.
837 */
838 if (len == 0 && is_command)
839 return 0;
840
841 nwords = (is_command ? x_command_glob : x_file_glob)(flags,
842 buf + *startp, len, &words);
843 if (nwords == 0) {
844 *wordsp = (char **) 0;
845 return 0;
846 }
847
848 if (is_commandp)
849 *is_commandp = is_command;
850 *wordsp = words;
851 *endp = *startp + len;
852
853 return nwords;
854 }
855
856 /* Given a string, copy it and possibly add a '*' to the end. The
857 * new string is returned.
858 */
859 static char *
add_glob(str,slen)860 add_glob(str, slen)
861 const char *str;
862 int slen;
863 {
864 char *toglob;
865 char *s;
866 bool_t saw_slash = FALSE;
867
868 if (slen < 0)
869 return (char *) 0;
870
871 toglob = str_nsave(str, slen + 1, ATEMP); /* + 1 for "*" */
872 toglob[slen] = '\0';
873
874 /*
875 * If the pathname contains a wildcard (an unquoted '*',
876 * '?', or '['), or a ~username
877 * with no trailing slash, then it is globbed based on that
878 * value (i.e., without the appended '*').
879 */
880 for (s = toglob; *s; s++) {
881 if (*s == '\\' && s[1])
882 s++;
883 else if (*s == '*' || *s == '[' || *s == '?'
884 || (s[1] == '(' /*)*/ && strchr("*+?@!", *s)))
885 break;
886 else if (ISDIRSEP(*s))
887 saw_slash = TRUE;
888 }
889 if (!*s && (*toglob != '~' || saw_slash)) {
890 toglob[slen] = '*';
891 toglob[slen + 1] = '\0';
892 }
893
894 return toglob;
895 }
896
897 /*
898 * Find longest common prefix
899 */
900 int
x_longest_prefix(nwords,words)901 x_longest_prefix(nwords, words)
902 int nwords;
903 char *const *words;
904 {
905 int i, j;
906 int prefix_len;
907 char *p;
908
909 if (nwords <= 0)
910 return 0;
911
912 prefix_len = strlen(words[0]);
913 for (i = 1; i < nwords; i++)
914 for (j = 0, p = words[i]; j < prefix_len; j++)
915 if (FILECHCONV((unsigned char)p[j])
916 != FILECHCONV((unsigned char)words[0][j])) {
917 prefix_len = j;
918 break;
919 }
920 return prefix_len;
921 }
922
923 void
x_free_words(nwords,words)924 x_free_words(nwords, words)
925 int nwords;
926 char **words;
927 {
928 int i;
929
930 for (i = 0; i < nwords; i++)
931 if (words[i])
932 afree(words[i], ATEMP);
933 afree(words, ATEMP);
934 }
935
936 /* Return the offset of the basename of string s (which ends at se - need not
937 * be null terminated). Trailing slashes are ignored. If s is just a slash,
938 * then the offset is 0 (actually, length - 1).
939 * s Return
940 * /etc 1
941 * /etc/ 1
942 * /etc// 1
943 * /etc/fo 5
944 * foo 0
945 * /// 2
946 * 0
947 */
948 int
x_basename(s,se)949 x_basename(s, se)
950 const char *s;
951 const char *se;
952 {
953 const char *p;
954
955 if (se == (char *) 0)
956 se = s + strlen(s);
957 if (s == se)
958 return 0;
959
960 /* Skip trailing slashes */
961 for (p = se - 1; p > s && ISDIRSEP(*p); p--)
962 ;
963 for (; p > s && !ISDIRSEP(*p); p--)
964 ;
965 if (ISDIRSEP(*p) && p + 1 < se)
966 p++;
967
968 return p - s;
969 }
970
971 /*
972 * Apply pattern matching to a table: all table entries that match a pattern
973 * are added to wp.
974 */
975 static void
glob_table(pat,wp,tp)976 glob_table(pat, wp, tp)
977 const char *pat;
978 XPtrV *wp;
979 struct table *tp;
980 {
981 struct tstate ts;
982 struct tbl *te;
983
984 for (twalk(&ts, tp); (te = tnext(&ts)); ) {
985 if (gmatch(te->name, pat, FALSE))
986 XPput(*wp, str_save(te->name, ATEMP));
987 }
988 }
989
990 static void
glob_path(flags,pat,wp,xpath)991 glob_path(flags, pat, wp, xpath)
992 int flags;
993 const char *pat;
994 XPtrV *wp;
995 const char *xpath;
996 {
997 const char *sp, *p;
998 char *xp;
999 int staterr;
1000 int pathlen;
1001 int patlen;
1002 int oldsize, newsize, i, j;
1003 char **words;
1004 XString xs;
1005
1006 patlen = strlen(pat) + 1;
1007 sp = xpath;
1008 Xinit(xs, xp, patlen + 128, ATEMP);
1009 while (sp) {
1010 xp = Xstring(xs, xp);
1011 if (!(p = strchr(sp, PATHSEP)))
1012 p = sp + strlen(sp);
1013 pathlen = p - sp;
1014 if (pathlen) {
1015 /* Copy sp into xp, stuffing any MAGIC characters
1016 * on the way
1017 */
1018 const char *s = sp;
1019
1020 XcheckN(xs, xp, pathlen * 2);
1021 while (s < p) {
1022 if (ISMAGIC(*s))
1023 *xp++ = MAGIC;
1024 *xp++ = *s++;
1025 }
1026 *xp++ = DIRSEP;
1027 pathlen++;
1028 }
1029 sp = p;
1030 XcheckN(xs, xp, patlen);
1031 memcpy(xp, pat, patlen);
1032
1033 oldsize = XPsize(*wp);
1034 glob_str(Xstring(xs, xp), wp, 1); /* mark dirs */
1035 newsize = XPsize(*wp);
1036
1037 /* Check that each match is executable... */
1038 words = (char **) XPptrv(*wp);
1039 for (i = j = oldsize; i < newsize; i++) {
1040 staterr = 0;
1041 if ((search_access(words[i], X_OK, &staterr) >= 0)
1042 || (staterr == EISDIR)) {
1043 words[j] = words[i];
1044 if (!(flags & XCF_FULLPATH))
1045 memmove(words[j], words[j] + pathlen,
1046 strlen(words[j] + pathlen) + 1);
1047 j++;
1048 } else
1049 afree(words[i], ATEMP);
1050 }
1051 wp->cur = (void **) &words[j];
1052
1053 if (!*sp++)
1054 break;
1055 }
1056 Xfree(xs, xp);
1057 }
1058
1059 /*
1060 * if argument string contains any special characters, they will
1061 * be escaped and the result will be put into edit buffer by
1062 * keybinding-specific function
1063 */
1064 int
x_escape(s,len,putbuf_func)1065 x_escape(s, len, putbuf_func)
1066 const char *s;
1067 size_t len;
1068 int (*putbuf_func) ARGS((const char *, size_t));
1069 {
1070 size_t add, wlen;
1071 const char *ifs = str_val(local("IFS", 0));
1072 int rval=0;
1073
1074 for (add = 0, wlen = len; wlen - add > 0; add++) {
1075 if (strchr("\\$(){}[]?*&;#|<>\"'`", s[add]) || strchr(ifs, s[add])) {
1076 if (putbuf_func(s, add) != 0) {
1077 rval = -1;
1078 break;
1079 }
1080
1081 putbuf_func("\\", 1);
1082 putbuf_func(&s[add], 1);
1083
1084 add++;
1085 wlen -= add;
1086 s += add;
1087 add = -1; /* after the increment it will go to 0 */
1088 }
1089 }
1090 if (wlen > 0 && rval == 0)
1091 rval = putbuf_func(s, wlen);
1092
1093 return (rval);
1094 }
1095 #endif /* EDIT */
1096