39
40#include "tw.h"
41#include "ed.h"
42#include "tc.h"
43
44#include <assert.h>
45
46#ifdef WINNT_NATIVE
47#include "nt.const.h"
48#endif /* WINNT_NATIVE */
49#define EVEN(x) (((x) & 1) != 1)
50
51#define DOT_NONE 0 /* Don't display dot files */
52#define DOT_NOT 1 /* Don't display dot or dot-dot */
53#define DOT_ALL 2 /* Display all dot files */
54
55/* TW_NONE, TW_COMMAND, TW_VARIABLE, TW_LOGNAME, */
56/* TW_FILE, TW_DIRECTORY, TW_VARLIST, TW_USER, */
57/* TW_COMPLETION, TW_ALIAS, TW_SHELLVAR, TW_ENVVAR, */
58/* TW_BINDING, TW_WORDLIST, TW_LIMIT, TW_SIGNAL */
59/* TW_JOB, TW_EXPLAIN, TW_TEXT, TW_GRPNAME */
60static void (*const tw_start_entry[]) (DIR *, const Char *) = {
61 tw_file_start, tw_cmd_start, tw_var_start, tw_logname_start,
62 tw_file_start, tw_file_start, tw_vl_start, tw_logname_start,
63 tw_complete_start, tw_alias_start, tw_var_start, tw_var_start,
64 tw_bind_start, tw_wl_start, tw_limit_start, tw_sig_start,
65 tw_job_start, tw_file_start, tw_file_start, tw_grpname_start
66};
67
68static int (*const tw_next_entry[]) (struct Strbuf *, struct Strbuf *,
69 int *) = {
70 tw_file_next, tw_cmd_next, tw_var_next, tw_logname_next,
71 tw_file_next, tw_file_next, tw_var_next, tw_logname_next,
72 tw_var_next, tw_var_next, tw_shvar_next, tw_envvar_next,
73 tw_bind_next, tw_wl_next, tw_limit_next, tw_sig_next,
74 tw_job_next, tw_file_next, tw_file_next, tw_grpname_next
75};
76
77static void (*const tw_end_entry[]) (void) = {
78 tw_dir_end, tw_dir_end, tw_dir_end, tw_logname_end,
79 tw_dir_end, tw_dir_end, tw_dir_end, tw_logname_end,
80 tw_dir_end, tw_dir_end, tw_dir_end, tw_dir_end,
81 tw_dir_end, tw_dir_end, tw_dir_end, tw_dir_end,
82 tw_dir_end, tw_dir_end, tw_dir_end, tw_grpname_end
83};
84
85/* #define TDEBUG */
86
87/* Set to TRUE if recexact is set and an exact match is found
88 * along with other, longer, matches.
89 */
90
91int curchoice = -1;
92
93int match_unique_match = FALSE;
94int non_unique_match = FALSE;
95static int SearchNoDirErr = 0; /* t_search returns -2 if dir is unreadable */
96
97/* state so if a completion is interrupted, the input line doesn't get
98 nuked */
99int InsideCompletion = 0;
100
101/* do the expand or list on the command line -- SHOULD BE REPLACED */
102
103static void extract_dir_and_name (const Char *, struct Strbuf *,
104 Char **);
105static int insert_meta (const Char *, const Char *,
106 const Char *, int);
107static int tilde (struct Strbuf *, Char *);
108static int expand_dir (const Char *, struct Strbuf *, DIR **,
109 COMMAND);
110static int nostat (Char *);
111static Char filetype (Char *, Char *);
112static int t_glob (Char ***, int);
113static int c_glob (Char ***);
114static int is_prefix (Char *, Char *);
115static int is_prefixmatch (Char *, Char *, int);
116static int is_suffix (Char *, Char *);
117static int recognize (struct Strbuf *, const Char *, size_t,
118 int, int, int);
119static int ignored (Char *);
120static int isadirectory (const Char *, const Char *);
121static int tw_collect_items (COMMAND, int, struct Strbuf *,
122 struct Strbuf *, Char *, const Char *,
123 int);
124static int tw_collect (COMMAND, int, struct Strbuf *,
125 struct Strbuf *, Char *, Char *, int,
126 DIR *);
127static Char tw_suffix (int, const Char *, Char *);
128static void tw_fixword (int, struct Strbuf *, Char *, Char *);
129static void tw_list_items (int, int, int);
130static void add_scroll_tab (Char *);
131static void choose_scroll_tab (struct Strbuf *, int);
132static void free_scroll_tab (void);
133static int find_rows (Char *[], int, int);
134
135#ifdef notdef
136/*
137 * If we find a set command, then we break a=b to a= and word becomes
138 * b else, we don't break a=b. [don't use that; splits words badly and
139 * messes up tw_complete()]
140 */
141#define isaset(c, w) ((w)[-1] == '=' && \
142 ((c)[0] == 's' && (c)[1] == 'e' && (c)[2] == 't' && \
143 ((c[3] == ' ' || (c)[3] == '\t'))))
144#endif
145
146/* TRUE if character must be quoted */
147#define tricky(w) (cmap(w, _META | _DOL | _QF | _QB | _ESC | _GLOB) && w != '#')
148/* TRUE if double quotes don't protect character */
149#define tricky_dq(w) (cmap(w, _DOL | _QB))
150
151/* tenematch():
152 * Return:
153 * > 1: No. of items found
154 * = 1: Exactly one match / spelling corrected
155 * = 0: No match / spelling was correct
156 * < 0: Error (incl spelling correction impossible)
157 */
158int
159tenematch(Char *inputline, int num_read, COMMAND command)
160{
161 struct Strbuf qline = Strbuf_INIT;
162 Char qu = 0, *pat = STRNULL;
163 size_t wp, word, wordp, cmd_start, oword = 0, ocmd_start = 0;
164 Char *str_end, *cp;
165 Char *word_start;
166 Char *oword_start = NULL;
167 eChar suf = 0;
168 int looking; /* what we are looking for */
169 int search_ret; /* what search returned for debugging */
170 int backq = 0;
171
172 str_end = &inputline[num_read];
173 cleanup_push(&qline, Strbuf_cleanup);
174
175 word_start = inputline;
176 word = cmd_start = 0;
177 for (cp = inputline; cp < str_end; cp++) {
178 if (!cmap(qu, _ESC)) {
179 if (cmap(*cp, _QF|_ESC)) {
180 if (qu == 0 || qu == *cp) {
181 qu ^= *cp;
182 continue;
183 }
184 }
185 if (qu != '\'' && cmap(*cp, _QB)) {
186 if ((backq ^= 1) != 0) {
187 ocmd_start = cmd_start;
188 oword_start = word_start;
189 oword = word;
190 word_start = cp + 1;
191 word = cmd_start = qline.len + 1;
192 }
193 else {
194 cmd_start = ocmd_start;
195 word_start = oword_start;
196 word = oword;
197 }
198 Strbuf_append1(&qline, *cp);
199 continue;
200 }
201 }
202 if (iscmdmeta(*cp))
203 cmd_start = qline.len + 1;
204
205 /* Don't quote '/' to make the recognize stuff work easily */
206 /* Don't quote '$' in double quotes */
207
208 if (cmap(*cp, _ESC) && cp < str_end - 1 && cp[1] == HIST)
209 Strbuf_append1(&qline, *++cp | QUOTE);
210 else if (qu && (tricky(*cp) || *cp == '~') && !(qu == '\"' && tricky_dq(*cp)))
211 Strbuf_append1(&qline, *cp | QUOTE);
212 else
213 Strbuf_append1(&qline, *cp);
214 if (ismetahash(qline.s[qline.len - 1])
215 /* || isaset(qline.s + cmd_start, qline.s + qline.len) */)
216 word = qline.len, word_start = cp + 1;
217 if (cmap(qu, _ESC))
218 qu = 0;
219 }
220 Strbuf_terminate(&qline);
221 wp = qline.len;
222
223 /*
224 * SPECIAL HARDCODED COMPLETIONS:
225 * first word of command -> TW_COMMAND
226 * everything else -> TW_ZERO
227 *
228 */
229 looking = starting_a_command(qline.s + word - 1, qline.s) ?
230 TW_COMMAND : TW_ZERO;
231
232 wordp = word;
233
234#ifdef TDEBUG
235 {
236 const Char *p;
237
238 xprintf(CGETS(30, 1, "starting_a_command %d\n"), looking);
239 xprintf("\ncmd_start:%S:\n", qline.s + cmd_start);
240 xprintf("qline:%S:\n", qline.s);
241 xprintf("qline:");
242 for (p = qline.s; *p; p++)
243 xprintf("%c", *p & QUOTE ? '-' : ' ');
244 xprintf(":\n");
245 xprintf("word:%S:\n", qline.s + word);
246 xprintf("word:");
247 for (p = qline.s + word; *p; p++)
248 xprintf("%c", *p & QUOTE ? '-' : ' ');
249 xprintf(":\n");
250 }
251#endif
252
253 if ((looking == TW_COMMAND || looking == TW_ZERO) &&
254 (command == RECOGNIZE || command == LIST || command == SPELL ||
255 command == RECOGNIZE_SCROLL)) {
256 Char *p;
257
258#ifdef TDEBUG
259 xprintf(CGETS(30, 2, "complete %d "), looking);
260#endif
261 p = qline.s + wordp;
262 looking = tw_complete(qline.s + cmd_start, &p, &pat, looking, &suf);
263 wordp = p - qline.s;
264#ifdef TDEBUG
265 xprintf(CGETS(30, 3, "complete %d %S\n"), looking, pat);
266#endif
267 }
268
269 switch (command) {
270 Char *bptr;
271 Char *items[2], **ptr;
272 int i, count;
273
274 case RECOGNIZE:
275 case RECOGNIZE_SCROLL:
276 case RECOGNIZE_ALL: {
277 struct Strbuf wordbuf = Strbuf_INIT;
278 Char *slshp;
279
280 if (adrof(STRautocorrect)) {
281 if ((slshp = Strrchr(qline.s + wordp, '/')) != NULL &&
282 slshp[1] != '\0') {
283 SearchNoDirErr = 1;
284 for (bptr = qline.s + wordp; bptr < slshp; bptr++) {
285 /*
286 * do not try to correct spelling of words containing
287 * globbing characters
288 */
289 if (isglob(*bptr)) {
290 SearchNoDirErr = 0;
291 break;
292 }
293 }
294 }
295 }
296 else
297 slshp = STRNULL;
298 Strbuf_append(&wordbuf, qline.s + wordp);
299 Strbuf_terminate(&wordbuf);
300 cleanup_push(&wordbuf, Strbuf_cleanup);
301 search_ret = t_search(&wordbuf, command, looking, 1, pat, suf);
302 qline.len = wordp;
303 Strbuf_append(&qline, wordbuf.s);
304 Strbuf_terminate(&qline);
305 cleanup_until(&wordbuf);
306 SearchNoDirErr = 0;
307
308 if (search_ret == -2) {
309 Char *rword;
310
311 rword = Strsave(slshp);
312 cleanup_push(rword, xfree);
313 if (slshp != STRNULL)
314 *slshp = '\0';
315 wordbuf = Strbuf_init;
316 Strbuf_append(&wordbuf, qline.s + wordp);
317 Strbuf_terminate(&wordbuf);
318 cleanup_push(&wordbuf, Strbuf_cleanup);
319 search_ret = spell_me(&wordbuf, looking, pat, suf);
320 if (search_ret == 1) {
321 Strbuf_append(&wordbuf, rword);
322 Strbuf_terminate(&wordbuf);
323 wp = wordp + wordbuf.len;
324 search_ret = t_search(&wordbuf, command, looking, 1, pat, suf);
325 }
326 qline.len = wordp;
327 Strbuf_append(&qline, wordbuf.s);
328 Strbuf_terminate(&qline);
329 cleanup_until(rword);
330 }
331 if (qline.s[wp] != '\0' &&
332 insert_meta(word_start, str_end, qline.s + word, !qu) < 0)
333 goto err; /* error inserting */
334 break;
335 }
336
337 case SPELL: {
338 struct Strbuf wordbuf = Strbuf_INIT;
339
340 for (bptr = word_start; bptr < str_end; bptr++) {
341 /*
342 * do not try to correct spelling of words containing globbing
343 * characters
344 */
345 if (isglob(*bptr)) {
346 search_ret = 0;
347 goto end;
348 }
349 }
350 Strbuf_append(&wordbuf, qline.s + wordp);
351 Strbuf_terminate(&wordbuf);
352 cleanup_push(&wordbuf, Strbuf_cleanup);
353 search_ret = spell_me(&wordbuf, looking, pat, suf);
354 qline.len = wordp;
355 Strbuf_append(&qline, wordbuf.s);
356 Strbuf_terminate(&qline);
357 cleanup_until(&wordbuf);
358 if (search_ret == 1) {
359 if (insert_meta(word_start, str_end, qline.s + word, !qu) < 0)
360 goto err; /* error inserting */
361 }
362 break;
363 }
364
365 case PRINT_HELP:
366 do_help(qline.s + cmd_start);
367 search_ret = 1;
368 break;
369
370 case GLOB:
371 case GLOB_EXPAND:
372 items[0] = Strsave(qline.s + wordp);
373 items[1] = NULL;
374 cleanup_push(items[0], xfree);
375 ptr = items;
376 count = (looking == TW_COMMAND && Strchr(qline.s + wordp, '/') == 0) ?
377 c_glob(&ptr) :
378 t_glob(&ptr, looking == TW_COMMAND);
379 cleanup_until(items[0]);
380 if (ptr != items)
381 cleanup_push(ptr, blk_cleanup);
382 if (count > 0) {
383 if (command == GLOB)
384 print_by_column(STRNULL, ptr, count, 0);
385 else {
386 DeleteBack(str_end - word_start);/* get rid of old word */
387 for (i = 0; i < count; i++)
388 if (ptr[i] && *ptr[i]) {
389 (void) quote(ptr[i]);
390 if (insert_meta(0, 0, ptr[i], 0) < 0 ||
391 InsertStr(STRspace) < 0) {
392 if (ptr != items)
393 cleanup_until(ptr);
394 goto err; /* error inserting */
395 }
396 }
397 }
398 }
399 if (ptr != items)
400 cleanup_until(ptr);
401 search_ret = count;
402 break;
403
404 case VARS_EXPAND:
405 bptr = dollar(qline.s + word);
406 if (bptr != NULL) {
407 if (insert_meta(word_start, str_end, bptr, !qu) < 0) {
408 xfree(bptr);
409 goto err; /* error inserting */
410 }
411 xfree(bptr);
412 search_ret = 1;
413 break;
414 }
415 search_ret = 0;
416 break;
417
418 case PATH_NORMALIZE:
419 if ((bptr = dnormalize(qline.s + wordp, symlinks == SYM_IGNORE ||
420 symlinks == SYM_EXPAND)) != NULL) {
421 if (insert_meta(word_start, str_end, bptr, !qu) < 0) {
422 xfree(bptr);
423 goto err; /* error inserting */
424 }
425 xfree(bptr);
426 search_ret = 1;
427 break;
428 }
429 search_ret = 0;
430 break;
431
432 case COMMAND_NORMALIZE: {
433 Char *p;
434 int found;
435
|
437
438 if (!found) {
439 xfree(p);
440 search_ret = 0;
441 break;
442 }
443 if (insert_meta(word_start, str_end, p, !qu) < 0) {
444 xfree(p);
445 goto err; /* error inserting */
446 }
447 xfree(p);
448 search_ret = 1;
449 break;
450 }
451
452 case LIST:
453 case LIST_ALL: {
454 struct Strbuf wordbuf = Strbuf_INIT;
455
456 Strbuf_append(&wordbuf, qline.s + wordp);
457 Strbuf_terminate(&wordbuf);
458 cleanup_push(&wordbuf, Strbuf_cleanup);
459 search_ret = t_search(&wordbuf, LIST, looking, 1, pat, suf);
460 qline.len = wordp;
461 Strbuf_append(&qline, wordbuf.s);
462 Strbuf_terminate(&qline);
463 cleanup_until(&wordbuf);
464 break;
465 }
466
467 default:
468 xprintf(CGETS(30, 4, "%s: Internal match error.\n"), progname);
469 search_ret = 1;
470 }
471 end:
472 cleanup_until(&qline);
473 return search_ret;
474
475 err:
476 cleanup_until(&qline);
477 return -1;
478} /* end tenematch */
479
480
481/* t_glob():
482 * Return a list of files that match the pattern
483 */
484static int
485t_glob(Char ***v, int cmd)
486{
487 jmp_buf_t osetexit;
488 int gflag;
489
490 if (**v == 0)
491 return (0);
492 gflag = tglob(*v);
493 if (gflag) {
494 size_t omark;
495
496 getexit(osetexit); /* make sure to come back here */
497 omark = cleanup_push_mark();
498 if (setexit() == 0)
499 *v = globall(*v, gflag);
500 cleanup_pop_mark(omark);
501 resexit(osetexit);
502 if (haderr) {
503 haderr = 0;
504 NeedsRedraw = 1;
505 return (-1);
506 }
507 if (*v == 0)
508 return (0);
509 }
510 else
511 return (0);
512
513 if (cmd) {
514 Char **av = *v, *p;
515 int fwd, i;
516
517 for (i = 0, fwd = 0; av[i] != NULL; i++)
518 if (!executable(NULL, av[i], 0)) {
519 fwd++;
520 p = av[i];
521 av[i] = NULL;
522 xfree(p);
523 }
524 else if (fwd)
525 av[i - fwd] = av[i];
526
527 if (fwd)
528 av[i - fwd] = av[i];
529 }
530
531 return blklen(*v);
532} /* end t_glob */
533
534
535/* c_glob():
536 * Return a list of commands that match the pattern
537 */
538static int
539c_glob(Char ***v)
540{
541 struct blk_buf av = BLK_BUF_INIT;
542 struct Strbuf cmd = Strbuf_INIT, dir = Strbuf_INIT;
543 Char *pat = **v;
544 int flag;
545
546 if (pat == NULL)
547 return (0);
548
549 cleanup_push(&av, bb_cleanup);
550 cleanup_push(&cmd, Strbuf_cleanup);
551 cleanup_push(&dir, Strbuf_cleanup);
552
553 tw_cmd_start(NULL, NULL);
554 while (cmd.len = 0, tw_cmd_next(&cmd, &dir, &flag) != 0) {
555 Strbuf_terminate(&cmd);
556 if (Gmatch(cmd.s, pat))
557 bb_append(&av, Strsave(cmd.s));
558 }
559 tw_dir_end();
560 *v = bb_finish(&av);
561 cleanup_ignore(&av);
562 cleanup_until(&av);
563
564 return av.len;
565} /* end c_glob */
566
567
568/* insert_meta():
569 * change the word before the cursor.
570 * cp must point to the start of the unquoted word.
571 * cpend to the end of it.
572 * word is the text that has to be substituted.
573 * strategy:
574 * try to keep all the quote characters of the user's input.
575 * change quote type only if necessary.
576 */
577static int
578insert_meta(const Char *cp, const Char *cpend, const Char *word,
579 int closequotes)
580{
581 struct Strbuf buffer = Strbuf_INIT;
582 Char *bptr;
583 const Char *wptr;
584 int in_sync = (cp != NULL);
585 Char qu = 0;
586 int ndel = (int) (cp ? cpend - cp : 0);
587 Char w, wq;
588 int res;
589
590 for (wptr = word;;) {
591 if (cp >= cpend)
592 in_sync = 0;
593 if (in_sync && !cmap(qu, _ESC) && cmap(*cp, _QF|_ESC))
594 if (qu == 0 || qu == *cp) {
595 qu ^= *cp;
596 Strbuf_append1(&buffer, *cp++);
597 continue;
598 }
599 w = *wptr;
600 if (w == 0)
601 break;
602
603 wq = w & QUOTE;
604 w &= ~QUOTE;
605
606 if (cmap(w, _ESC | _QF))
607 wq = QUOTE; /* quotes are always quoted */
608
609 if (!wq && qu && tricky(w) && !(qu == '\"' && tricky_dq(w))) {
610 /* We have to unquote the character */
611 in_sync = 0;
612 if (cmap(qu, _ESC))
613 buffer.s[buffer.len - 1] = w;
614 else {
615 Strbuf_append1(&buffer, qu);
616 Strbuf_append1(&buffer, w);
617 if (wptr[1] == 0)
618 qu = 0;
619 else
620 Strbuf_append1(&buffer, qu);
621 }
622 } else if (qu && w == qu) {
623 in_sync = 0;
624 if (buffer.len != 0 && buffer.s[buffer.len - 1] == qu) {
625 /* User misunderstanding :) */
626 buffer.s[buffer.len - 1] = '\\';
627 Strbuf_append1(&buffer, w);
628 qu = 0;
629 } else {
630 Strbuf_append1(&buffer, qu);
631 Strbuf_append1(&buffer, '\\');
632 Strbuf_append1(&buffer, w);
633 Strbuf_append1(&buffer, qu);
634 }
635 }
636 else if (wq && qu == '\"' && tricky_dq(w)) {
637 in_sync = 0;
638 Strbuf_append1(&buffer, qu);
639 Strbuf_append1(&buffer, '\\');
640 Strbuf_append1(&buffer, w);
641 Strbuf_append1(&buffer, qu);
642 } else if (wq &&
643 ((!qu && (tricky(w) || (w == HISTSUB && buffer.len == 0))) ||
644 (!cmap(qu, _ESC) && w == HIST))) {
645 in_sync = 0;
646 Strbuf_append1(&buffer, '\\');
647 Strbuf_append1(&buffer, w);
648 } else {
649 if (in_sync && *cp++ != w)
650 in_sync = 0;
651 Strbuf_append1(&buffer, w);
652 }
653 wptr++;
654 if (cmap(qu, _ESC))
655 qu = 0;
656 }
657 if (closequotes && qu && !cmap(qu, _ESC))
658 Strbuf_append1(&buffer, w);
659 bptr = Strbuf_finish(&buffer);
660 if (ndel)
661 DeleteBack(ndel);
662 res = InsertStr(bptr);
663 xfree(bptr);
664 return res;
665} /* end insert_meta */
666
667
668
669/* is_prefix():
670 * return true if check matches initial chars in template
671 * This differs from PWB imatch in that if check is null
672 * it matches anything
673 */
674static int
675is_prefix(Char *check, Char *template)
676{
677 for (; *check; check++, template++)
678 if ((*check & TRIM) != (*template & TRIM))
679 return (FALSE);
680 return (TRUE);
681} /* end is_prefix */
682
683
684/* is_prefixmatch():
685 * return true if check matches initial chars in template
686 * This differs from PWB imatch in that if check is null
687 * it matches anything
688 * and matches on shortening of commands
689 */
690static int
691is_prefixmatch(Char *check, Char *template, int igncase)
692{
693 Char MCH1, MCH2;
694
695 for (; *check; check++, template++) {
696 if ((*check & TRIM) != (*template & TRIM)) {
697 MCH1 = (*check & TRIM);
698 MCH2 = (*template & TRIM);
699 MCH1 = Isupper(MCH1) ? Tolower(MCH1) : MCH1;
700 MCH2 = Isupper(MCH2) ? Tolower(MCH2) : MCH2;
701 if (MCH1 != MCH2) {
702 if (!igncase && ((*check & TRIM) == '-' ||
703 (*check & TRIM) == '.' ||
704 (*check & TRIM) == '_')) {
705 MCH1 = MCH2 = (*check & TRIM);
706 if (MCH1 == '_') {
707 MCH2 = '-';
708 } else if (MCH1 == '-') {
709 MCH2 = '_';
710 }
711 for (;*template && (*template & TRIM) != MCH1 &&
712 (*template & TRIM) != MCH2; template++)
713 continue;
714 if (!*template) {
715 return (FALSE);
716 }
717 } else {
718 return (FALSE);
719 }
720 }
721 }
722 }
723 return (TRUE);
724} /* end is_prefixmatch */
725
726
727/* is_suffix():
728 * Return true if the chars in template appear at the
729 * end of check, I.e., are it's suffix.
730 */
731static int
732is_suffix(Char *check, Char *template)
733{
734 Char *t, *c;
735
736 t = Strend(template);
737 c = Strend(check);
738 for (;;) {
739 if (t == template)
740 return 1;
741 if (c == check || (*--t & TRIM) != (*--c & TRIM))
742 return 0;
743 }
744} /* end is_suffix */
745
746
747/* ignored():
748 * Return true if this is an ignored item
749 */
750static int
751ignored(Char *item)
752{
753 struct varent *vp;
754 Char **cp;
755
756 if ((vp = adrof(STRfignore)) == NULL || (cp = vp->vec) == NULL)
757 return (FALSE);
758 for (; *cp != NULL; cp++)
759 if (is_suffix(item, *cp))
760 return (TRUE);
761 return (FALSE);
762} /* end ignored */
763
764
765
766/* starting_a_command():
767 * return true if the command starting at wordstart is a command
768 */
769int
770starting_a_command(Char *wordstart, Char *inputline)
771{
772 Char *ptr, *ncmdstart;
773 int count, bsl;
774 static Char
775 cmdstart[] = {'`', ';', '&', '(', '|', '\0'},
776 cmdalive[] = {' ', '\t', '\'', '"', '<', '>', '\0'};
777
778 /*
779 * Find if the number of backquotes is odd or even.
780 */
781 for (ptr = wordstart, count = 0;
782 ptr >= inputline;
783 count += (*ptr-- == '`'))
784 continue;
785 /*
786 * if the number of backquotes is even don't include the backquote char in
787 * the list of command starting delimiters [if it is zero, then it does not
788 * matter]
789 */
790 ncmdstart = cmdstart + EVEN(count);
791
792 /*
793 * look for the characters previous to this word if we find a command
794 * starting delimiter we break. if we find whitespace and another previous
795 * word then we are not a command
796 *
797 * count is our state machine: 0 looking for anything 1 found white-space
798 * looking for non-ws
799 */
800 for (count = 0; wordstart >= inputline; wordstart--) {
801 if (*wordstart == '\0')
802 continue;
803 if (Strchr(ncmdstart, *wordstart)) {
804 for (ptr = wordstart, bsl = 0; *(--ptr) == '\\'; bsl++);
805 if (bsl & 1) {
806 wordstart--;
807 continue;
808 } else
809 break;
810 }
811 /*
812 * found white space
813 */
814 if ((ptr = Strchr(cmdalive, *wordstart)) != NULL)
815 count = 1;
816 if (count == 1 && !ptr)
817 return (FALSE);
818 }
819
820 if (wordstart > inputline)
821 switch (*wordstart) {
822 case '&': /* Look for >& */
823 while (wordstart > inputline &&
824 (*--wordstart == ' ' || *wordstart == '\t'))
825 continue;
826 if (*wordstart == '>')
827 return (FALSE);
828 break;
829 case '(': /* check for foreach, if etc. */
830 while (wordstart > inputline &&
831 (*--wordstart == ' ' || *wordstart == '\t'))
832 continue;
833 if (!iscmdmeta(*wordstart) &&
834 (*wordstart != ' ' && *wordstart != '\t'))
835 return (FALSE);
836 break;
837 default:
838 break;
839 }
840 return (TRUE);
841} /* end starting_a_command */
842
843
844/* recognize():
845 * Object: extend what user typed up to an ambiguity.
846 * Algorithm:
847 * On first match, copy full item (assume it'll be the only match)
848 * On subsequent matches, shorten exp_name to the first
849 * character mismatch between exp_name and item.
850 * If we shorten it back to the prefix length, stop searching.
851 */
852static int
853recognize(struct Strbuf *exp_name, const Char *item, size_t name_length,
854 int numitems, int enhanced, int igncase)
855{
856 Char MCH1, MCH2;
857 Char *x;
858 const Char *ent;
859 size_t len = 0;
860
861 if (numitems == 1) { /* 1st match */
862 exp_name->len = 0;
863 Strbuf_append(exp_name, item);
864 Strbuf_terminate(exp_name);
865 return (0);
866 }
867 if (!enhanced && !igncase) {
868 for (x = exp_name->s, ent = item; *x && (*x & TRIM) == (*ent & TRIM);
869 x++, ent++)
870 len++;
871 } else {
872 for (x = exp_name->s, ent = item; *x; x++, ent++) {
873 MCH1 = *x & TRIM;
874 MCH2 = *ent & TRIM;
875 MCH1 = Isupper(MCH1) ? Tolower(MCH1) : MCH1;
876 MCH2 = Isupper(MCH2) ? Tolower(MCH2) : MCH2;
877 if (MCH1 != MCH2)
878 break;
879 len++;
880 }
881 if (*x || !*ent) /* Shorter or exact match */
882 memcpy(exp_name->s, item, len * sizeof(*exp_name->s));
883 }
884 *x = '\0'; /* Shorten at 1st char diff */
885 exp_name->len = x - exp_name->s;
886 if (!(match_unique_match || is_set(STRrecexact) || (enhanced && *ent)) && len == name_length) /* Ambiguous to prefix? */
887 return (-1); /* So stop now and save time */
888 return (0);
889} /* end recognize */
890
891
892/* tw_collect_items():
893 * Collect items that match target.
894 * SPELL command:
895 * Returns the spelling distance of the closest match.
896 * else
897 * Returns the number of items found.
898 * If none found, but some ignored items were found,
899 * It returns the -number of ignored items.
900 */
901static int
902tw_collect_items(COMMAND command, int looking, struct Strbuf *exp_dir,
903 struct Strbuf *exp_name, Char *target, const Char *pat,
904 int flags)
905{
906 int done = FALSE; /* Search is done */
907 int showdots; /* Style to show dot files */
908 int nignored = 0; /* Number of fignored items */
909 int numitems = 0; /* Number of matched items */
910 size_t name_length = Strlen(target); /* Length of prefix (file name) */
911 int exec_check = flags & TW_EXEC_CHK;/* need to check executability */
912 int dir_check = flags & TW_DIR_CHK; /* Need to check for directories */
913 int text_check = flags & TW_TEXT_CHK;/* Need to check for non-directories */
914 int dir_ok = flags & TW_DIR_OK; /* Ignore directories? */
915 int gpat = flags & TW_PAT_OK; /* Match against a pattern */
916 int ignoring = flags & TW_IGN_OK; /* Use fignore? */
917 int d = 4, nd; /* Spelling distance */
918 Char *ptr;
919 struct varent *vp;
920 struct Strbuf buf = Strbuf_INIT, item = Strbuf_INIT;
921 int enhanced = 0;
922 int cnt = 0;
923 int igncase = 0;
924
925
926 flags = 0;
927
928 showdots = DOT_NONE;
929 if ((ptr = varval(STRlistflags)) != STRNULL)
930 while (*ptr)
931 switch (*ptr++) {
932 case 'a':
933 showdots = DOT_ALL;
934 break;
935 case 'A':
936 showdots = DOT_NOT;
937 break;
938 default:
939 break;
940 }
941
942 cleanup_push(&item, Strbuf_cleanup);
943 cleanup_push(&buf, Strbuf_cleanup);
944 while (!done &&
945 (item.len = 0,
946 tw_next_entry[looking](&item, exp_dir, &flags) != 0)) {
947 Strbuf_terminate(&item);
948#ifdef TDEBUG
949 xprintf("item = %S\n", item.s);
950#endif
951 switch (looking) {
952 case TW_FILE:
953 case TW_DIRECTORY:
954 case TW_TEXT:
955 /*
956 * Don't match . files on null prefix match
957 */
958 if (showdots == DOT_NOT && (ISDOT(item.s) || ISDOTDOT(item.s)))
959 done = TRUE;
960 if (name_length == 0 && item.s[0] == '.' && showdots == DOT_NONE)
961 done = TRUE;
962 break;
963
964 case TW_COMMAND:
965#if defined(_UWIN) || defined(__CYGWIN__)
966 /*
967 * Turn foo.{exe,com,bat,cmd} into foo since UWIN's readdir returns
968 * the file with the .exe, .com, .bat, .cmd extension
969 */
970 {
971 static const char *rext[] = { ".exe", ".bat", ".com", ".cmd" };
972 size_t exti = Strlen(item.s);
973
974 if (exti > 4) {
975 char *ext = short2str(&item.s[exti -= 4]);
976 size_t i;
977
978 for (i = 0; i < sizeof(rext) / sizeof(rext[0]); i++)
979 if (strcasecmp(ext, rext[i]) == 0) {
980 item.len = exti;
981 Strbuf_terminate(&item);
982 break;
983 }
984 }
985 }
986#endif /* _UWIN || __CYGWIN__ */
987 exec_check = flags & TW_EXEC_CHK;
988 dir_ok = flags & TW_DIR_OK;
989 break;
990
991 default:
992 break;
993 }
994
995 if (done) {
996 done = FALSE;
997 continue;
998 }
999
1000 switch (command) {
1001
1002 case SPELL: /* correct the spelling of the last bit */
1003 if (name_length == 0) {/* zero-length word can't be misspelled */
1004 exp_name->len = 0; /* (not trying is important for ~) */
1005 Strbuf_terminate(exp_name);
1006 d = 0;
1007 done = TRUE;
1008 break;
1009 }
1010 if (gpat && !Gmatch(item.s, pat))
1011 break;
1012 /*
1013 * Swapped the order of the spdist() arguments as suggested
1014 * by eeide@asylum.cs.utah.edu (Eric Eide)
1015 */
1016 nd = spdist(target, item.s); /* test the item against original */
1017 if (nd <= d && nd != 4) {
1018 if (!(exec_check && !executable(exp_dir->s, item.s, dir_ok))) {
1019 exp_name->len = 0;
1020 Strbuf_append(exp_name, item.s);
1021 Strbuf_terminate(exp_name);
1022 d = nd;
1023 if (d == 0) /* if found it exactly */
1024 done = TRUE;
1025 }
1026 }
1027 else if (nd == 4) {
1028 if (spdir(exp_name, exp_dir->s, item.s, target)) {
1029 if (exec_check &&
1030 !executable(exp_dir->s, exp_name->s, dir_ok))
1031 break;
1032#ifdef notdef
1033 /*
1034 * We don't want to stop immediately, because
1035 * we might find an exact/better match later.
1036 */
1037 d = 0;
1038 done = TRUE;
1039#endif
1040 d = 3;
1041 }
1042 }
1043 break;
1044
1045 case LIST:
1046 case RECOGNIZE:
1047 case RECOGNIZE_ALL:
1048 case RECOGNIZE_SCROLL:
1049
1050 if ((vp = adrof(STRcomplete)) != NULL && vp->vec != NULL) {
1051 Char **cp;
1052 for (cp = vp->vec; *cp; cp++) {
1053 if (Strcmp(*cp, STRigncase) == 0)
1054 igncase = 1;
1055 if (Strcmp(*cp, STRenhance) == 0)
1056 enhanced = 1;
1057 }
1058 }
1059
1060 if (enhanced || igncase) {
1061 if (!is_prefixmatch(target, item.s, igncase))
1062 break;
1063 } else {
1064 if (!is_prefix(target, item.s))
1065 break;
1066 }
1067
1068 if (exec_check && !executable(exp_dir->s, item.s, dir_ok))
1069 break;
1070
1071 if (dir_check && !isadirectory(exp_dir->s, item.s))
1072 break;
1073
1074 if (text_check && isadirectory(exp_dir->s, item.s))
1075 break;
1076
1077 /*
1078 * Only pattern match directories if we're checking
1079 * for directories.
1080 */
1081 if (gpat && !Gmatch(item.s, pat) &&
1082 (dir_check || !isadirectory(exp_dir->s, item.s)))
1083 break;
1084
1085 /*
1086 * Remove duplicates in command listing and completion
1087 * AFEB added code for TW_LOGNAME and TW_USER cases
1088 */
1089 if (looking == TW_COMMAND || looking == TW_LOGNAME
1090 || looking == TW_USER || command == LIST) {
1091 buf.len = 0;
1092 Strbuf_append(&buf, item.s);
1093 switch (looking) {
1094 case TW_COMMAND:
1095 if (!(dir_ok && exec_check))
1096 break;
1097 if (filetype(exp_dir->s, item.s) == '/')
1098 Strbuf_append1(&buf, '/');
1099 break;
1100
1101 case TW_FILE:
1102 case TW_DIRECTORY:
1103 Strbuf_append1(&buf, filetype(exp_dir->s, item.s));
1104 break;
1105
1106 default:
1107 break;
1108 }
1109 Strbuf_terminate(&buf);
1110 if ((looking == TW_COMMAND || looking == TW_USER
1111 || looking == TW_LOGNAME) && tw_item_find(buf.s))
1112 break;
1113 else {
1114 /* maximum length 1 (NULL) + 1 (~ or $) + 1 (filetype) */
1115 tw_item_add(&buf);
1116 if (command == LIST)
1117 numitems++;
1118 }
1119 }
1120
1121 if (command == RECOGNIZE || command == RECOGNIZE_ALL ||
1122 command == RECOGNIZE_SCROLL) {
1123 if (ignoring && ignored(item.s)) {
1124 nignored++;
1125 break;
1126 }
1127 else if (command == RECOGNIZE_SCROLL) {
1128 add_scroll_tab(item.s);
1129 cnt++;
1130 }
1131
1132 if (match_unique_match || is_set(STRrecexact)) {
1133 if (StrQcmp(target, item.s) == 0) { /* EXACT match */
1134 exp_name->len = 0;
1135 Strbuf_append(exp_name, item.s);
1136 Strbuf_terminate(exp_name);
1137 numitems = 1; /* fake into expanding */
1138 non_unique_match = TRUE;
1139 done = TRUE;
1140 break;
1141 }
1142 }
1143 if (recognize(exp_name, item.s, name_length, ++numitems,
1144 enhanced, igncase))
1145 if (command != RECOGNIZE_SCROLL)
1146 done = TRUE;
1147 if (enhanced && exp_name->len < name_length) {
1148 exp_name->len = 0;
1149 Strbuf_append(exp_name, target);
1150 Strbuf_terminate(exp_name);
1151 }
1152 }
1153 break;
1154
1155 default:
1156 break;
1157 }
1158#ifdef TDEBUG
1159 xprintf("done item = %S\n", item.s);
1160#endif
1161 }
1162 cleanup_until(&item);
1163
1164 if (command == RECOGNIZE_SCROLL) {
1165 if ((cnt <= curchoice) || (curchoice == -1)) {
1166 curchoice = -1;
1167 nignored = 0;
1168 numitems = 0;
1169 } else if (numitems > 1) {
1170 if (curchoice < -1)
1171 curchoice = cnt - 1;
1172 choose_scroll_tab(exp_name, cnt);
1173 numitems = 1;
1174 }
1175 }
1176 free_scroll_tab();
1177
1178 if (command == SPELL)
1179 return d;
1180 else {
1181 if (ignoring && numitems == 0 && nignored > 0)
1182 return -nignored;
1183 else
1184 return numitems;
1185 }
1186}
1187
1188
1189/* tw_suffix():
1190 * Find and return the appropriate suffix character
1191 */
1192/*ARGSUSED*/
1193static Char
1194tw_suffix(int looking, const Char *exp_dir, Char *exp_name)
1195{
1196 Char *ptr;
1197 struct varent *vp;
1198
1199 (void) strip(exp_name);
1200
1201 switch (looking) {
1202
1203 case TW_LOGNAME:
1204 return '/';
1205
1206 case TW_VARIABLE:
1207 /*
1208 * Don't consider array variables or empty variables
1209 */
1210 if ((vp = adrof(exp_name)) != NULL && vp->vec != NULL) {
1211 if ((ptr = vp->vec[0]) == NULL || *ptr == '\0' ||
1212 vp->vec[1] != NULL)
1213 return ' ';
1214 }
1215 else if ((ptr = tgetenv(exp_name)) == NULL || *ptr == '\0')
1216 return ' ';
1217
1218 return isadirectory(exp_dir, ptr) ? '/' : ' ';
1219
1220
1221 case TW_DIRECTORY:
1222 return '/';
1223
1224 case TW_COMMAND:
1225 case TW_FILE:
1226 return isadirectory(exp_dir, exp_name) ? '/' : ' ';
1227
1228 case TW_ALIAS:
1229 case TW_VARLIST:
1230 case TW_WORDLIST:
1231 case TW_SHELLVAR:
1232 case TW_ENVVAR:
1233 case TW_USER:
1234 case TW_BINDING:
1235 case TW_LIMIT:
1236 case TW_SIGNAL:
1237 case TW_JOB:
1238 case TW_COMPLETION:
1239 case TW_TEXT:
1240 case TW_GRPNAME:
1241 return ' ';
1242
1243 default:
1244 return '\0';
1245 }
1246} /* end tw_suffix */
1247
1248
1249/* tw_fixword():
1250 * Repair a word after a spalling or a recognizwe
1251 */
1252static void
1253tw_fixword(int looking, struct Strbuf *word, Char *dir, Char *exp_name)
1254{
1255 Char *ptr;
1256
1257 switch (looking) {
1258 case TW_LOGNAME:
1259 word->len = 0;
1260 Strbuf_append1(word, '~');
1261 break;
1262
1263 case TW_VARIABLE:
1264 if ((ptr = Strrchr(word->s, '$')) != NULL) {
1265 word->len = ptr + 1 - word->s; /* Delete after the dollar */
1266 } else
1267 word->len = 0;
1268 break;
1269
1270 case TW_DIRECTORY:
1271 case TW_FILE:
1272 case TW_TEXT:
1273 word->len = 0;
1274 Strbuf_append(word, dir); /* put back dir part */
1275 break;
1276
1277 default:
1278 word->len = 0;
1279 break;
1280 }
1281
1282 (void) quote(exp_name);
1283 Strbuf_append(word, exp_name); /* add extended name */
1284 Strbuf_terminate(word);
1285} /* end tw_fixword */
1286
1287
1288/* tw_collect():
1289 * Collect items. Return -1 in case we were interrupted or
1290 * the return value of tw_collect
1291 * This is really a wrapper for tw_collect_items, serving two
1292 * purposes:
1293 * 1. Handles interrupt cleanups.
1294 * 2. Retries if we had no matches, but there were ignored matches
1295 */
1296static int
1297tw_collect(COMMAND command, int looking, struct Strbuf *exp_dir,
1298 struct Strbuf *exp_name, Char *target, Char *pat, int flags,
1299 DIR *dir_fd)
1300{
1301 volatile int ni;
1302 jmp_buf_t osetexit;
1303
1304#ifdef TDEBUG
1305 xprintf("target = %S\n", target);
1306#endif
1307 ni = 0;
1308 getexit(osetexit);
1309 for (;;) {
1310 volatile size_t omark;
1311
1312 (*tw_start_entry[looking])(dir_fd, pat);
1313 InsideCompletion = 1;
1314 if (setexit()) {
1315 cleanup_pop_mark(omark);
1316 resexit(osetexit);
1317 /* interrupted, clean up */
1318 haderr = 0;
1319 ni = -1; /* flag error */
1320 break;
1321 }
1322 omark = cleanup_push_mark();
1323 ni = tw_collect_items(command, looking, exp_dir, exp_name, target, pat,
1324 ni >= 0 ? flags : flags & ~TW_IGN_OK);
1325 cleanup_pop_mark(omark);
1326 resexit(osetexit);
1327 if (ni >= 0)
1328 break;
1329 }
1330 InsideCompletion = 0;
1331#if defined(SOLARIS2) && defined(i386) && !defined(__GNUC__)
1332 /* Compiler bug? (from PWP) */
1333 if ((looking == TW_LOGNAME) || (looking == TW_USER))
1334 tw_logname_end();
1335 else if (looking == TW_GRPNAME)
1336 tw_grpname_end();
1337 else
1338 tw_dir_end();
1339#else /* !(SOLARIS2 && i386 && !__GNUC__) */
1340 (*tw_end_entry[looking])();
1341#endif /* !(SOLARIS2 && i386 && !__GNUC__) */
1342 return(ni);
1343} /* end tw_collect */
1344
1345
1346/* tw_list_items():
1347 * List the items that were found
1348 *
1349 * NOTE instead of looking at numerical vars listmax and listmaxrows
1350 * we can look at numerical var listmax, and have a string value
1351 * listmaxtype (or similar) than can have values 'items' and 'rows'
1352 * (by default interpreted as 'items', for backwards compatibility)
1353 */
1354static void
1355tw_list_items(int looking, int numitems, int list_max)
1356{
1357 Char *ptr;
1358 int max_items = 0;
1359 int max_rows = 0;
1360
1361 if (numitems == 0)
1362 return;
1363
1364 if ((ptr = varval(STRlistmax)) != STRNULL) {
1365 while (*ptr) {
1366 if (!Isdigit(*ptr)) {
1367 max_items = 0;
1368 break;
1369 }
1370 max_items = max_items * 10 + *ptr++ - '0';
1371 }
1372 if ((max_items > 0) && (numitems > max_items) && list_max)
1373 max_items = numitems;
1374 else
1375 max_items = 0;
1376 }
1377
1378 if (max_items == 0 && (ptr = varval(STRlistmaxrows)) != STRNULL) {
1379 int rows;
1380
1381 while (*ptr) {
1382 if (!Isdigit(*ptr)) {
1383 max_rows = 0;
1384 break;
1385 }
1386 max_rows = max_rows * 10 + *ptr++ - '0';
1387 }
1388 if (max_rows != 0 && looking != TW_JOB)
1389 rows = find_rows(tw_item_get(), numitems, TRUE);
1390 else
1391 rows = numitems; /* underestimate for lines wider than the termH */
1392 if ((max_rows > 0) && (rows > max_rows) && list_max)
1393 max_rows = rows;
1394 else
1395 max_rows = 0;
1396 }
1397
1398
1399 if (max_items || max_rows) {
1400 char tc, *sname;
1401 const char *name;
1402 int maxs;
1403
1404 if (max_items) {
1405 name = CGETS(30, 5, "items");
1406 maxs = max_items;
1407 }
1408 else {
1409 name = CGETS(30, 6, "rows");
1410 maxs = max_rows;
1411 }
1412
1413 sname = strsave(name);
1414 cleanup_push(sname, xfree);
1415 xprintf(CGETS(30, 7, "There are %d %s, list them anyway? [n/y] "),
1416 maxs, sname);
1417 cleanup_until(sname);
1418 flush();
1419 /* We should be in Rawmode here, so no \n to catch */
1420 (void) xread(SHIN, &tc, 1);
1421 xprintf("%c\r\n", tc); /* echo the char, do a newline */
1422 /*
1423 * Perhaps we should use the yesexpr from the
1424 * actual locale
1425 */
1426 if (strchr(CGETS(30, 13, "Yy"), tc) == NULL)
1427 return;
1428 }
1429
1430 if (looking != TW_SIGNAL)
1431 qsort(tw_item_get(), numitems, sizeof(Char *), fcompare);
1432 if (looking != TW_JOB)
1433 print_by_column(STRNULL, tw_item_get(), numitems, TRUE);
1434 else {
1435 /*
1436 * print one item on every line because jobs can have spaces
1437 * and it is confusing.
1438 */
1439 int i;
1440 Char **w = tw_item_get();
1441
1442 for (i = 0; i < numitems; i++) {
1443 xprintf("%S", w[i]);
1444 if (Tty_raw_mode)
1445 xputchar('\r');
1446 xputchar('\n');
1447 }
1448 }
1449} /* end tw_list_items */
1450
1451
1452/* t_search():
1453 * Perform a RECOGNIZE, LIST or SPELL command on string "word".
1454 *
1455 * Return value:
1456 * >= 0: SPELL command: "distance" (see spdist())
1457 * other: No. of items found
1458 * < 0: Error (message or beep is output)
1459 */
1460/*ARGSUSED*/
1461int
1462t_search(struct Strbuf *word, COMMAND command, int looking, int list_max,
1463 Char *pat, eChar suf)
1464{
1465 int numitems, /* Number of items matched */
1466 flags = 0, /* search flags */
1467 gpat = pat[0] != '\0', /* Glob pattern search */
1468 res; /* Return value */
1469 struct Strbuf exp_dir = Strbuf_INIT;/* dir after ~ expansion */
1470 struct Strbuf dir = Strbuf_INIT; /* /x/y/z/ part in /x/y/z/f */
1471 struct Strbuf exp_name = Strbuf_INIT;/* the recognized (extended) */
1472 Char *name, /* f part in /d/d/d/f name */
1473 *target; /* Target to expand/correct/list */
1474 DIR *dir_fd = NULL;
1475
1476 /*
1477 * bugfix by Marty Grossman (grossman@CC5.BBN.COM): directory listing can
1478 * dump core when interrupted
1479 */
1480 tw_item_free();
1481
1482 non_unique_match = FALSE; /* See the recexact code below */
1483
1484 extract_dir_and_name(word->s, &dir, &name);
1485 cleanup_push(&dir, Strbuf_cleanup);
1486 cleanup_push(&name, xfree_indirect);
1487
1488 /*
1489 * SPECIAL HARDCODED COMPLETIONS:
1490 * foo$variable -> TW_VARIABLE
1491 * ~user -> TW_LOGNAME
1492 *
1493 */
1494 if ((*word->s == '~') && (Strchr(word->s, '/') == NULL)) {
1495 looking = TW_LOGNAME;
1496 target = name;
1497 gpat = 0; /* Override pattern mechanism */
1498 }
1499 else if ((target = Strrchr(name, '$')) != 0 &&
1500 (Strchr(name, '/') == NULL)) {
1501 target++;
1502 looking = TW_VARIABLE;
1503 gpat = 0; /* Override pattern mechanism */
1504 }
1505 else
1506 target = name;
1507
1508 /*
1509 * Try to figure out what we should be looking for
1510 */
1511 if (looking & TW_PATH) {
1512 gpat = 0; /* pattern holds the pathname to be used */
1513 Strbuf_append(&exp_dir, pat);
1514 if (exp_dir.len != 0 && exp_dir.s[exp_dir.len - 1] != '/')
1515 Strbuf_append1(&exp_dir, '/');
1516 Strbuf_append(&exp_dir, dir.s);
1517 }
1518 Strbuf_terminate(&exp_dir);
1519 cleanup_push(&exp_dir, Strbuf_cleanup);
1520
1521 switch (looking & ~TW_PATH) {
1522 case TW_NONE:
1523 res = -1;
1524 goto err_dir;
1525
1526 case TW_ZERO:
1527 looking = TW_FILE;
1528 break;
1529
1530 case TW_COMMAND:
1531 if (Strchr(word->s, '/') || (looking & TW_PATH)) {
1532 looking = TW_FILE;
1533 flags |= TW_EXEC_CHK;
1534 flags |= TW_DIR_OK;
1535 }
1536#ifdef notdef
1537 /* PWP: don't even bother when doing ALL of the commands */
1538 if (looking == TW_COMMAND && word->len == 0) {
1539 res = -1;
1540 goto err_dir;
1541 }
1542#endif
1543 break;
1544
1545
1546 case TW_VARLIST:
1547 case TW_WORDLIST:
1548 gpat = 0; /* pattern holds the name of the variable */
1549 break;
1550
1551 case TW_EXPLAIN:
1552 if (command == LIST && pat != NULL) {
1553 xprintf("%S", pat);
1554 if (Tty_raw_mode)
1555 xputchar('\r');
1556 xputchar('\n');
1557 }
1558 res = 2;
1559 goto err_dir;
1560
1561 default:
1562 break;
1563 }
1564
1565 /*
1566 * let fignore work only when we are not using a pattern
1567 */
1568 flags |= (gpat == 0) ? TW_IGN_OK : TW_PAT_OK;
1569
1570#ifdef TDEBUG
1571 xprintf(CGETS(30, 8, "looking = %d\n"), looking);
1572#endif
1573
1574 switch (looking) {
1575 Char *user_name;
1576
1577 case TW_ALIAS:
1578 case TW_SHELLVAR:
1579 case TW_ENVVAR:
1580 case TW_BINDING:
1581 case TW_LIMIT:
1582 case TW_SIGNAL:
1583 case TW_JOB:
1584 case TW_COMPLETION:
1585 case TW_GRPNAME:
1586 break;
1587
1588
1589 case TW_VARIABLE:
1590 if ((res = expand_dir(dir.s, &exp_dir, &dir_fd, command)) != 0)
1591 goto err_dir;
1592 break;
1593
1594 case TW_DIRECTORY:
1595 flags |= TW_DIR_CHK;
1596
1597#ifdef notyet
1598 /*
1599 * This is supposed to expand the directory stack.
1600 * Problems:
1601 * 1. Slow
1602 * 2. directories with the same name
1603 */
1604 flags |= TW_DIR_OK;
1605#endif
1606#ifdef notyet
1607 /*
1608 * Supposed to do delayed expansion, but it is inconsistent
1609 * from a user-interface point of view, since it does not
1610 * immediately obey addsuffix
1611 */
1612 if ((res = expand_dir(dir.s, &exp_dir, &dir_fd, command)) != 0)
1613 goto err_dir;
1614 if (isadirectory(exp_dir.s, name)) {
1615 if (exp_dir.len != 0 || name[0] != '\0') {
1616 Strbuf_append(&dir, name);
1617 if (dir.s[dir.len - 1] != '/')
1618 Strbuf_append1(&dir, '/');
1619 Strbuf_terminate(&dir);
1620 if ((res = expand_dir(dir.s, &exp_dir, &dir_fd, command)) != 0)
1621 goto err_dir;
1622 if (word->len != 0 && word->s[word->len - 1] != '/') {
1623 Strbuf_append1(word, '/');
1624 Strbuf_terminate(word);
1625 }
1626 name[0] = '\0';
1627 }
1628 }
1629#endif
1630 if ((res = expand_dir(dir.s, &exp_dir, &dir_fd, command)) != 0)
1631 goto err_dir;
1632 break;
1633
1634 case TW_TEXT:
1635 flags |= TW_TEXT_CHK;
1636 /*FALLTHROUGH*/
1637 case TW_FILE:
1638 if ((res = expand_dir(dir.s, &exp_dir, &dir_fd, command)) != 0)
1639 goto err_dir;
1640 break;
1641
1642 case TW_PATH | TW_TEXT:
1643 case TW_PATH | TW_FILE:
1644 case TW_PATH | TW_DIRECTORY:
1645 case TW_PATH | TW_COMMAND:
1646 if ((dir_fd = opendir(short2str(exp_dir.s))) == NULL) {
1647 if (command == RECOGNIZE)
1648 xprintf("\n");
1649 xprintf("%S: %s", exp_dir.s, strerror(errno));
1650 if (command != RECOGNIZE)
1651 xprintf("\n");
1652 NeedsRedraw = 1;
1653 res = -1;
1654 goto err_dir;
1655 }
1656 if (exp_dir.len != 0 && exp_dir.s[exp_dir.len - 1] != '/') {
1657 Strbuf_append1(&exp_dir, '/');
1658 Strbuf_terminate(&exp_dir);
1659 }
1660
1661 looking &= ~TW_PATH;
1662
1663 switch (looking) {
1664 case TW_TEXT:
1665 flags |= TW_TEXT_CHK;
1666 break;
1667
1668 case TW_FILE:
1669 break;
1670
1671 case TW_DIRECTORY:
1672 flags |= TW_DIR_CHK;
1673 break;
1674
1675 case TW_COMMAND:
1676 xfree(name);
1677 target = name = Strsave(word->s); /* so it can match things */
1678 break;
1679
1680 default:
1681 abort(); /* Cannot happen */
1682 break;
1683 }
1684 break;
1685
1686 case TW_LOGNAME:
1687 user_name = word->s + 1;
1688 goto do_user;
1689
1690 /*FALLTHROUGH*/
1691 case TW_USER:
1692 user_name = word->s;
1693 do_user:
1694 /*
1695 * Check if the spelling was already correct
1696 * From: Rob McMahon <cudcv@cu.warwick.ac.uk>
1697 */
1698 if (command == SPELL && xgetpwnam(short2str(user_name)) != NULL) {
1699#ifdef YPBUGS
1700 fix_yp_bugs();
1701#endif /* YPBUGS */
1702 res = 0;
1703 goto err_dir;
1704 }
1705 xfree(name);
1706 target = name = Strsave(user_name);
1707 break;
1708
1709 case TW_COMMAND:
1710 case TW_VARLIST:
1711 case TW_WORDLIST:
1712 target = name = Strsave(word->s); /* so it can match things */
1713 break;
1714
1715 default:
1716 xprintf(CGETS(30, 9,
1717 "\n%s internal error: I don't know what I'm looking for!\n"),
1718 progname);
1719 NeedsRedraw = 1;
1720 res = -1;
1721 goto err_dir;
1722 }
1723
1724 cleanup_push(&exp_name, Strbuf_cleanup);
1725 numitems = tw_collect(command, looking, &exp_dir, &exp_name, target, pat,
1726 flags, dir_fd);
1727 if (numitems == -1)
1728 goto end;
1729
1730 switch (command) {
1731 case RECOGNIZE:
1732 case RECOGNIZE_ALL:
1733 case RECOGNIZE_SCROLL:
1734 if (numitems <= 0)
1735 break;
1736
1737 Strbuf_terminate(&exp_name);
1738 tw_fixword(looking, word, dir.s, exp_name.s);
1739
1740 if (!match_unique_match && is_set(STRaddsuffix) && numitems == 1) {
1741 switch (suf) {
1742 case 0: /* Automatic suffix */
1743 Strbuf_append1(word,
1744 tw_suffix(looking, exp_dir.s, exp_name.s));
1745 break;
1746
1747 case CHAR_ERR: /* No suffix */
1748 break;
1749
1750 default: /* completion specified suffix */
1751 Strbuf_append1(word, suf);
1752 break;
1753 }
1754 Strbuf_terminate(word);
1755 }
1756 break;
1757
1758 case LIST:
1759 tw_list_items(looking, numitems, list_max);
1760 tw_item_free();
1761 break;
1762
1763 case SPELL:
1764 Strbuf_terminate(&exp_name);
1765 tw_fixword(looking, word, dir.s, exp_name.s);
1766 break;
1767
1768 default:
1769 xprintf("Bad tw_command\n");
1770 numitems = 0;
1771 }
1772 end:
1773 res = numitems;
1774 err_dir:
1775 cleanup_until(&dir);
1776 return res;
1777} /* end t_search */
1778
1779
1780/* extract_dir_and_name():
1781 * parse full path in file into 2 parts: directory and file names
1782 * Should leave final slash (/) at end of dir.
1783 */
1784static void
1785extract_dir_and_name(const Char *path, struct Strbuf *dir, Char **name)
1786{
1787 Char *p;
1788
1789 p = Strrchr(path, '/');
1790#ifdef WINNT_NATIVE
1791 if (p == NULL)
1792 p = Strrchr(path, ':');
1793#endif /* WINNT_NATIVE */
1794 if (p == NULL)
1795 *name = Strsave(path);
1796 else {
1797 p++;
1798 *name = Strsave(p);
1799 Strbuf_appendn(dir, path, p - path);
1800 }
1801 Strbuf_terminate(dir);
1802} /* end extract_dir_and_name */
1803
1804
1805/* dollar():
1806 * expand "/$old1/$old2/old3/"
1807 * to "/value_of_old1/value_of_old2/old3/"
1808 */
1809Char *
1810dollar(const Char *old)
1811{
1812 struct Strbuf buf = Strbuf_INIT;
1813
1814 while (*old) {
1815 if (*old != '$')
1816 Strbuf_append1(&buf, *old++);
1817 else {
1818 if (expdollar(&buf, &old, QUOTE) == 0) {
1819 xfree(buf.s);
1820 return NULL;
1821 }
1822 }
1823 }
1824 return Strbuf_finish(&buf);
1825} /* end dollar */
1826
1827
1828/* tilde():
1829 * expand ~person/foo to home_directory_of_person/foo
1830 * or =<stack-entry> to <dir in stack entry>
1831 */
1832static int
1833tilde(struct Strbuf *new, Char *old)
1834{
1835 Char *o, *p;
1836
1837 new->len = 0;
1838 switch (old[0]) {
1839 case '~': {
1840 Char *name, *home;
1841
1842 old++;
1843 for (o = old; *o && *o != '/'; o++)
1844 continue;
1845 name = Strnsave(old, o - old);
1846 home = gethdir(name);
1847 xfree(name);
1848 if (home == NULL)
1849 goto err;
1850 Strbuf_append(new, home);
1851 xfree(home);
1852 /* If the home directory expands to "/", we do
1853 * not want to create "//" by appending a slash from o.
1854 */
1855 if (new->s[0] == '/' && new->len == 1 && *o == '/')
1856 ++o;
1857 Strbuf_append(new, o);
1858 break;
1859 }
1860
1861 case '=':
1862 if ((p = globequal(old)) == NULL)
1863 goto err;
1864 if (p != old) {
1865 Strbuf_append(new, p);
1866 xfree(p);
1867 break;
1868 }
1869 /*FALLTHROUGH*/
1870
1871 default:
1872 Strbuf_append(new, old);
1873 break;
1874 }
1875 Strbuf_terminate(new);
1876 return 0;
1877
1878 err:
1879 Strbuf_terminate(new);
1880 return -1;
1881} /* end tilde */
1882
1883
1884/* expand_dir():
1885 * Open the directory given, expanding ~user and $var
1886 * Optionally normalize the path given
1887 */
1888static int
1889expand_dir(const Char *dir, struct Strbuf *edir, DIR **dfd, COMMAND cmd)
1890{
1891 Char *nd = NULL;
1892 Char *tdir;
1893
1894 tdir = dollar(dir);
1895 cleanup_push(tdir, xfree);
1896 if (tdir == NULL ||
1897 (tilde(edir, tdir) != 0) ||
1898 !(nd = dnormalize(edir->len ? edir->s : STRdot,
1899 symlinks == SYM_IGNORE || symlinks == SYM_EXPAND)) ||
1900 ((*dfd = opendir(short2str(nd))) == NULL)) {
1901 xfree(nd);
1902 if (cmd == SPELL || SearchNoDirErr) {
1903 cleanup_until(tdir);
1904 return (-2);
1905 }
1906 /*
1907 * From: Amos Shapira <amoss@cs.huji.ac.il>
1908 * Print a better message when completion fails
1909 */
1910 xprintf("\n%S %s\n", edir->len ? edir->s : (tdir ? tdir : dir),
1911 (errno == ENOTDIR ? CGETS(30, 10, "not a directory") :
1912 (errno == ENOENT ? CGETS(30, 11, "not found") :
1913 CGETS(30, 12, "unreadable"))));
1914 NeedsRedraw = 1;
1915 cleanup_until(tdir);
1916 return (-1);
1917 }
1918 cleanup_until(tdir);
1919 if (nd) {
1920 if (*dir != '\0') {
1921 int slash;
1922
1923 /*
1924 * Copy and append a / if there was one
1925 */
1926 slash = edir->len != 0 && edir->s[edir->len - 1] == '/';
1927 edir->len = 0;
1928 Strbuf_append(edir, nd);
1929 if (slash != 0 && edir->s[edir->len - 1] != '/')
1930 Strbuf_append1(edir, '/');
1931 Strbuf_terminate(edir);
1932 }
1933 xfree(nd);
1934 }
1935 return 0;
1936} /* end expand_dir */
1937
1938
1939/* nostat():
1940 * Returns true if the directory should not be stat'd,
1941 * false otherwise.
1942 * This way, things won't grind to a halt when you complete in /afs
1943 * or very large directories.
1944 */
1945static int
1946nostat(Char *dir)
1947{
1948 struct varent *vp;
1949 Char **cp;
1950
1951 if ((vp = adrof(STRnostat)) == NULL || (cp = vp->vec) == NULL)
1952 return FALSE;
1953 for (; *cp != NULL; cp++) {
1954 if (Strcmp(*cp, STRstar) == 0)
1955 return TRUE;
1956 if (Gmatch(dir, *cp))
1957 return TRUE;
1958 }
1959 return FALSE;
1960} /* end nostat */
1961
1962
1963/* filetype():
1964 * Return a character that signifies a filetype
1965 * symbology from 4.3 ls command.
1966 */
1967static Char
1968filetype(Char *dir, Char *file)
1969{
1970 if (dir) {
1971 Char *path;
1972 char *ptr;
1973 struct stat statb;
1974
1975 if (nostat(dir)) return(' ');
1976
1977 path = Strspl(dir, file);
1978 ptr = short2str(path);
1979 xfree(path);
1980
1981 if (lstat(ptr, &statb) != -1) {
1982#ifdef S_ISLNK
1983 if (S_ISLNK(statb.st_mode)) { /* Symbolic link */
1984 if (adrof(STRlistlinks)) {
1985 if (stat(ptr, &statb) == -1)
1986 return ('&');
1987 else if (S_ISDIR(statb.st_mode))
1988 return ('>');
1989 else
1990 return ('@');
1991 }
1992 else
1993 return ('@');
1994 }
1995#endif
1996#ifdef S_ISSOCK
1997 if (S_ISSOCK(statb.st_mode)) /* Socket */
1998 return ('=');
1999#endif
2000#ifdef S_ISFIFO
2001 if (S_ISFIFO(statb.st_mode)) /* Named Pipe */
2002 return ('|');
2003#endif
2004#ifdef S_ISHIDDEN
2005 if (S_ISHIDDEN(statb.st_mode)) /* Hidden Directory [aix] */
2006 return ('+');
2007#endif
2008#ifdef S_ISCDF
2009 {
2010 struct stat hpstatb;
2011 char *p2;
2012
2013 p2 = strspl(ptr, "+"); /* Must append a '+' and re-stat(). */
2014 if ((stat(p2, &hpstatb) != -1) && S_ISCDF(hpstatb.st_mode)) {
2015 xfree(p2);
2016 return ('+'); /* Context Dependent Files [hpux] */
2017 }
2018 xfree(p2);
2019 }
2020#endif
2021#ifdef S_ISNWK
2022 if (S_ISNWK(statb.st_mode)) /* Network Special [hpux] */
2023 return (':');
2024#endif
2025#ifdef S_ISCHR
2026 if (S_ISCHR(statb.st_mode)) /* char device */
2027 return ('%');
2028#endif
2029#ifdef S_ISBLK
2030 if (S_ISBLK(statb.st_mode)) /* block device */
2031 return ('#');
2032#endif
2033#ifdef S_ISDIR
2034 if (S_ISDIR(statb.st_mode)) /* normal Directory */
2035 return ('/');
2036#endif
2037 if (statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
2038 return ('*');
2039 }
2040 }
2041 return (' ');
2042} /* end filetype */
2043
2044
2045/* isadirectory():
2046 * Return trus if the file is a directory
2047 */
2048static int
2049isadirectory(const Char *dir, const Char *file)
2050 /* return 1 if dir/file is a directory */
2051 /* uses stat rather than lstat to get dest. */
2052{
2053 if (dir) {
2054 Char *path;
2055 char *cpath;
2056 struct stat statb;
2057
2058 path = Strspl(dir, file);
2059 cpath = short2str(path);
2060 xfree(path);
2061 if (stat(cpath, &statb) >= 0) { /* resolve through symlink */
2062#ifdef S_ISSOCK
2063 if (S_ISSOCK(statb.st_mode)) /* Socket */
2064 return 0;
2065#endif
2066#ifdef S_ISFIFO
2067 if (S_ISFIFO(statb.st_mode)) /* Named Pipe */
2068 return 0;
2069#endif
2070 if (S_ISDIR(statb.st_mode)) /* normal Directory */
2071 return 1;
2072 }
2073 }
2074 return 0;
2075} /* end isadirectory */
2076
2077
2078
2079/* find_rows():
2080 * Return how many rows needed to print sorted down columns
2081 */
2082static int
2083find_rows(Char *items[], int count, int no_file_suffix)
2084{
2085 int i, columns, rows;
2086 unsigned int maxwidth = 0;
2087
2088 for (i = 0; i < count; i++) /* find widest string */
2089 maxwidth = max(maxwidth, (unsigned int) Strlen(items[i]));
2090
2091 maxwidth += no_file_suffix ? 1 : 2; /* for the file tag and space */
2092 columns = (TermH + 1) / maxwidth; /* PWP: terminal size change */
2093 if (!columns)
2094 columns = 1;
2095 rows = (count + (columns - 1)) / columns;
2096
2097 return rows;
2098} /* end rows_needed_by_print_by_column */
2099
2100
2101/* print_by_column():
2102 * Print sorted down columns or across columns when the first
2103 * word of $listflags shell variable contains 'x'.
2104 *
2105 */
2106void
2107print_by_column(Char *dir, Char *items[], int count, int no_file_suffix)
2108{
2109 int i, r, c, columns, rows;
2110 size_t w;
2111 unsigned int wx, maxwidth = 0;
2112 Char *val;
2113 int across;
2114
2115 lbuffed = 0; /* turn off line buffering */
2116
2117
2118 across = ((val = varval(STRlistflags)) != STRNULL) &&
2119 (Strchr(val, 'x') != NULL);
2120
2121 for (i = 0; i < count; i++) { /* find widest string */
2122 maxwidth = max(maxwidth, (unsigned int) NLSStringWidth(items[i]));
2123 }
2124
2125 maxwidth += no_file_suffix ? 1 : 2; /* for the file tag and space */
2126 columns = TermH / maxwidth; /* PWP: terminal size change */
2127 if (!columns || !isatty(didfds ? 1 : SHOUT))
2128 columns = 1;
2129 rows = (count + (columns - 1)) / columns;
2130
2131 i = -1;
2132 for (r = 0; r < rows; r++) {
2133 for (c = 0; c < columns; c++) {
2134 i = across ? (i + 1) : (c * rows + r);
2135
2136 if (i < count) {
2137 wx = 0;
2138 w = Strlen(items[i]);
2139
2140#ifdef COLOR_LS_F
2141 if (no_file_suffix) {
2142 /* Print the command name */
2143 Char f = items[i][w - 1];
2144 items[i][w - 1] = 0;
2145 print_with_color(items[i], w - 1, f);
2146 items[i][w - 1] = f;
2147 }
2148 else {
2149 /* Print filename followed by '/' or '*' or ' ' */
2150 print_with_color(items[i], w, filetype(dir, items[i]));
2151 wx++;
2152 }
2153#else /* ifndef COLOR_LS_F */
2154 if (no_file_suffix) {
2155 /* Print the command name */
2156 xprintf("%S", items[i]);
2157 }
2158 else {
2159 /* Print filename followed by '/' or '*' or ' ' */
2160 xprintf("%-S%c", items[i], filetype(dir, items[i]));
2161 wx++;
2162 }
2163#endif /* COLOR_LS_F */
2164
2165 if (c < (columns - 1)) { /* Not last column? */
2166 w = NLSStringWidth(items[i]) + wx;
2167 for (; w < maxwidth; w++)
2168 xputchar(' ');
2169 }
2170 }
2171 else if (across)
2172 break;
2173 }
2174 if (Tty_raw_mode)
2175 xputchar('\r');
2176 xputchar('\n');
2177 }
2178
2179 lbuffed = 1; /* turn back on line buffering */
2180 flush();
2181} /* end print_by_column */
2182
2183
2184/* StrQcmp():
2185 * Compare strings ignoring the quoting chars
2186 */
2187int
2188StrQcmp(const Char *str1, const Char *str2)
2189{
2190 for (; *str1 && samecase(*str1 & TRIM) == samecase(*str2 & TRIM);
2191 str1++, str2++)
2192 continue;
2193 /*
2194 * The following case analysis is necessary so that characters which look
2195 * negative collate low against normal characters but high against the
2196 * end-of-string NUL.
2197 */
2198 if (*str1 == '\0' && *str2 == '\0')
2199 return (0);
2200 else if (*str1 == '\0')
2201 return (-1);
2202 else if (*str2 == '\0')
2203 return (1);
2204 else
2205 return ((*str1 & TRIM) - (*str2 & TRIM));
2206} /* end StrQcmp */
2207
2208
2209/* fcompare():
2210 * Comparison routine for qsort, (Char **, Char **)
2211 */
2212int
2213fcompare(const void *xfile1, const void *xfile2)
2214{
2215 const Char *const *file1 = xfile1, *const *file2 = xfile2;
2216
2217 return collate(*file1, *file2);
2218} /* end fcompare */
2219
2220
2221/* catn():
2222 * Concatenate src onto tail of des.
2223 * Des is a string whose maximum length is count.
2224 * Always null terminate.
2225 */
2226void
2227catn(Char *des, const Char *src, int count)
2228{
2229 while (*des && --count > 0)
2230 des++;
2231 while (--count > 0)
2232 if ((*des++ = *src++) == 0)
2233 return;
2234 *des = '\0';
2235} /* end catn */
2236
2237
2238/* copyn():
2239 * like strncpy but always leave room for trailing \0
2240 * and always null terminate.
2241 */
2242void
2243copyn(Char *des, const Char *src, size_t count)
2244{
2245 while (--count != 0)
2246 if ((*des++ = *src++) == 0)
2247 return;
2248 *des = '\0';
2249} /* end copyn */
2250
2251
2252/* tgetenv():
2253 * like it's normal string counter-part
2254 */
2255Char *
2256tgetenv(Char *str)
2257{
2258 Char **var;
2259 size_t len;
2260 int res;
2261
2262 len = Strlen(str);
2263 /* Search the STR_environ for the entry matching str. */
2264 for (var = STR_environ; var != NULL && *var != NULL; var++)
2265 if (Strlen(*var) >= len && (*var)[len] == '=') {
2266 /* Temporarily terminate the string so we can copy the variable
2267 name. */
2268 (*var)[len] = '\0';
2269 res = StrQcmp(*var, str);
2270 /* Restore the '=' and return a pointer to the value of the
2271 environment variable. */
2272 (*var)[len] = '=';
2273 if (res == 0)
2274 return (&((*var)[len + 1]));
2275 }
2276 return (NULL);
2277} /* end tgetenv */
2278
2279
2280struct scroll_tab_list *scroll_tab = 0;
2281
2282static void
2283add_scroll_tab(Char *item)
2284{
2285 struct scroll_tab_list *new_scroll;
2286
2287 new_scroll = xmalloc(sizeof(struct scroll_tab_list));
2288 new_scroll->element = Strsave(item);
2289 new_scroll->next = scroll_tab;
2290 scroll_tab = new_scroll;
2291}
2292
2293static void
2294choose_scroll_tab(struct Strbuf *exp_name, int cnt)
2295{
2296 struct scroll_tab_list *loop;
2297 int tmp = cnt;
2298 Char **ptr;
2299
2300 ptr = xmalloc(sizeof(Char *) * cnt);
2301 cleanup_push(ptr, xfree);
2302
2303 for(loop = scroll_tab; loop && (tmp >= 0); loop = loop->next)
2304 ptr[--tmp] = loop->element;
2305
2306 qsort(ptr, cnt, sizeof(Char *), fcompare);
2307
2308 exp_name->len = 0;
2309 Strbuf_append(exp_name, ptr[curchoice]);
2310 Strbuf_terminate(exp_name);
2311 cleanup_until(ptr);
2312}
2313
2314static void
2315free_scroll_tab(void)
2316{
2317 struct scroll_tab_list *loop;
2318
2319 while(scroll_tab) {
2320 loop = scroll_tab;
2321 scroll_tab = scroll_tab->next;
2322 xfree(loop->element);
2323 xfree(loop);
2324 }
2325}
|