tw.init.c revision 231990 
1/* $Header: /p/tcsh/cvsroot/tcsh/tw.init.c,v 3.42 2011/04/17 14:49:30 christos Exp $ */
2/*
3 * tw.init.c: Handle lists of things to complete
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
35RCSID("$tcsh: tw.init.c,v 3.42 2011/04/17 14:49:30 christos Exp $")
36
37#include "tw.h"
38#include "ed.h"
39#include "tc.h"
40#include "sh.proc.h"
41
42#define TW_INCR	128
43
44typedef struct {
45    Char **list, 			/* List of command names	*/
46	  *buff;			/* Space holding command names	*/
47    size_t nlist, 			/* Number of items		*/
48           nbuff,			/* Current space in name buf	*/
49           tlist,			/* Total space in list		*/
50	   tbuff;			/* Total space in name buf	*/
51} stringlist_t;
52
53
54static struct varent *tw_vptr = NULL;	/* Current shell variable 	*/
55static Char **tw_env = NULL;		/* Current environment variable */
56static const Char *tw_word;		/* Current word pointer		*/
57static struct KeyFuncs *tw_bind = NULL;	/* List of the bindings		*/
58#ifndef HAVENOLIMIT
59static struct limits *tw_limit = NULL;	/* List of the resource limits	*/
60#endif /* HAVENOLIMIT */
61static int tw_index = 0;		/* signal and job index		*/
62static DIR   *tw_dir_fd = NULL;		/* Current directory descriptor	*/
63static int    tw_cmd_got = 0;		/* What we need to do		*/
64static stringlist_t tw_cmd  = { NULL, NULL, 0, 0, 0, 0 };
65static stringlist_t tw_item = { NULL, NULL, 0, 0, 0, 0 };
66#define TW_FL_CMD	0x01
67#define TW_FL_ALIAS	0x02
68#define TW_FL_BUILTIN	0x04
69#define TW_FL_SORT	0x08
70#define TW_FL_REL	0x10
71
72static struct {				/* Current element pointer	*/
73    size_t cur;				/* Current element number	*/
74    Char **pathv;			/* Current element in path	*/
75    DIR   *dfd;				/* Current directory descriptor	*/
76} tw_cmd_state;
77
78
79#define SETDIR(dfd) \
80    { \
81	tw_dir_fd = dfd; \
82	if (tw_dir_fd != NULL) \
83	    rewinddir(tw_dir_fd); \
84    }
85
86#define CLRDIR(dfd) \
87    if (dfd != NULL) { \
88	pintr_disabled++; \
89	xclosedir(dfd); \
90	dfd = NULL; \
91	disabled_cleanup(&pintr_disabled); \
92    }
93
94static Char	*tw_str_add		(stringlist_t *, size_t);
95static void	 tw_str_free		(stringlist_t *);
96static int       tw_dir_next		(struct Strbuf *, DIR *);
97static void	 tw_cmd_add 		(const Char *name);
98static void 	 tw_cmd_cmd		(void);
99static void	 tw_cmd_builtin		(void);
100static void	 tw_cmd_alias		(void);
101static void	 tw_cmd_sort		(void);
102static void 	 tw_vptr_start		(struct varent *);
103
104
105/* tw_str_add():
106 *	Add an item to the string list
107 */
108static Char *
109tw_str_add(stringlist_t *sl, size_t len)
110{
111    Char *ptr;
112
113    if (sl->tlist <= sl->nlist) {
114	pintr_disabled++;
115	sl->tlist += TW_INCR;
116	sl->list = xrealloc(sl->list, sl->tlist * sizeof(Char *));
117	disabled_cleanup(&pintr_disabled);
118    }
119    if (sl->tbuff <= sl->nbuff + len) {
120	size_t i;
121
122	ptr = sl->buff;
123	pintr_disabled++;
124	sl->tbuff += TW_INCR + len;
125	sl->buff = xrealloc(sl->buff, sl->tbuff * sizeof(Char));
126	/* Re-thread the new pointer list, if changed */
127	if (ptr != NULL && ptr != sl->buff) {
128	    intptr_t offs = sl->buff - ptr;
129	    for (i = 0; i < sl->nlist; i++)
130		sl->list[i] += offs;
131	}
132	disabled_cleanup(&pintr_disabled);
133    }
134    ptr = sl->list[sl->nlist++] = &sl->buff[sl->nbuff];
135    sl->nbuff += len;
136    return ptr;
137} /* tw_str_add */
138
139
140/* tw_str_free():
141 *	Free a stringlist
142 */
143static void
144tw_str_free(stringlist_t *sl)
145{
146    pintr_disabled++;
147    if (sl->list) {
148	xfree(sl->list);
149	sl->list = NULL;
150	sl->tlist = sl->nlist = 0;
151    }
152    if (sl->buff) {
153	xfree(sl->buff);
154	sl->buff = NULL;
155	sl->tbuff = sl->nbuff = 0;
156    }
157    disabled_cleanup(&pintr_disabled);
158} /* end tw_str_free */
159
160
161static int
162tw_dir_next(struct Strbuf *res, DIR *dfd)
163{
164    struct dirent *dirp;
165
166    if (dfd == NULL)
167	return 0;
168
169    if ((dirp = readdir(dfd)) != NULL) {
170	Strbuf_append(res, str2short(dirp->d_name));
171	return 1;
172    }
173    return 0;
174} /* end tw_dir_next */
175
176
177/* tw_cmd_add():
178 *	Add the name to the command list
179 */
180static void
181tw_cmd_add(const Char *name)
182{
183    size_t len;
184
185    len = Strlen(name) + 2;
186    (void) Strcpy(tw_str_add(&tw_cmd, len), name);
187} /* end tw_cmd_add */
188
189
190/* tw_cmd_free():
191 *	Free the command list
192 */
193void
194tw_cmd_free(void)
195{
196    CLRDIR(tw_dir_fd)
197    tw_str_free(&tw_cmd);
198    tw_cmd_got = 0;
199} /* end tw_cmd_free */
200
201/* tw_cmd_cmd():
202 *	Add system commands to the command list
203 */
204static void
205tw_cmd_cmd(void)
206{
207    DIR *dirp;
208    struct dirent *dp;
209    Char *dir = NULL, *name;
210    Char **pv;
211    struct varent *v = adrof(STRpath);
212    struct varent *recexec = adrof(STRrecognize_only_executables);
213    size_t len;
214
215
216    if (v == NULL || v->vec == NULL) /* if no path */
217	return;
218
219    for (pv = v->vec; *pv; pv++) {
220	if (pv[0][0] != '/') {
221	    tw_cmd_got |= TW_FL_REL;
222	    continue;
223	}
224
225	if ((dirp = opendir(short2str(*pv))) == NULL)
226	    continue;
227
228	cleanup_push(dirp, opendir_cleanup);
229	if (recexec) {
230	    dir = Strspl(*pv, STRslash);
231	    cleanup_push(dir, xfree);
232	}
233	while ((dp = readdir(dirp)) != NULL) {
234#if defined(_UWIN) || defined(__CYGWIN__)
235	    /* Turn foo.{exe,com,bat} into foo since UWIN's readdir returns
236	     * the file with the .exe, .com, .bat extension
237	     *
238	     * Same for Cygwin, but only for .exe and .com extension.
239	     */
240	    len = strlen(dp->d_name);
241	    if (len > 4 && (strcmp(&dp->d_name[len - 4], ".exe") == 0 ||
242#ifndef __CYGWIN__
243		strcmp(&dp->d_name[len - 4], ".bat") == 0 ||
244#endif /* !__CYGWIN__ */
245		strcmp(&dp->d_name[len - 4], ".com") == 0))
246		dp->d_name[len - 4] = '\0';
247#endif /* _UWIN || __CYGWIN__ */
248	    /* the call to executable() may make this a bit slow */
249	    name = str2short(dp->d_name);
250	    if (dp->d_ino == 0 || (recexec && !executable(dir, name, 0)))
251		continue;
252            len = Strlen(name);
253            if (name[0] == '#' ||	/* emacs temp files	*/
254		name[0] == '.' ||	/* .files		*/
255		name[len - 1] == '~' ||	/* emacs backups	*/
256		name[len - 1] == '%')	/* textedit backups	*/
257                continue;		/* Ignore!		*/
258            tw_cmd_add(name);
259	}
260	cleanup_until(dirp);
261    }
262} /* end tw_cmd_cmd */
263
264
265/* tw_cmd_builtin():
266 *	Add builtins to the command list
267 */
268static void
269tw_cmd_builtin(void)
270{
271    const struct biltins *bptr;
272
273    for (bptr = bfunc; bptr < &bfunc[nbfunc]; bptr++)
274	if (bptr->bname)
275	    tw_cmd_add(str2short(bptr->bname));
276#ifdef WINNT_NATIVE
277    for (bptr = nt_bfunc; bptr < &nt_bfunc[nt_nbfunc]; bptr++)
278	if (bptr->bname)
279	    tw_cmd_add(str2short(bptr->bname));
280#endif /* WINNT_NATIVE*/
281} /* end tw_cmd_builtin */
282
283
284/* tw_cmd_alias():
285 *	Add aliases to the command list
286 */
287static void
288tw_cmd_alias(void)
289{
290    struct varent *p;
291    struct varent *c;
292
293    p = &aliases;
294    for (;;) {
295	while (p->v_left)
296	    p = p->v_left;
297x:
298	if (p->v_parent == 0) /* is it the header? */
299	    return;
300	if (p->v_name)
301	    tw_cmd_add(p->v_name);
302	if (p->v_right) {
303	    p = p->v_right;
304	    continue;
305	}
306	do {
307	    c = p;
308	    p = p->v_parent;
309	} while (p->v_right == c);
310	goto x;
311    }
312} /* end tw_cmd_alias */
313
314
315/* tw_cmd_sort():
316 *	Sort the command list removing duplicate elements
317 */
318static void
319tw_cmd_sort(void)
320{
321    size_t fwd, i;
322
323    pintr_disabled++;
324    /* sort the list. */
325    qsort(tw_cmd.list, tw_cmd.nlist, sizeof(Char *), fcompare);
326
327    /* get rid of multiple entries */
328    for (i = 0, fwd = 0; i + 1 < tw_cmd.nlist; i++) {
329	if (Strcmp(tw_cmd.list[i], tw_cmd.list[i + 1]) == 0) /* garbage */
330	    fwd++;		/* increase the forward ref. count */
331	else if (fwd)
332	    tw_cmd.list[i - fwd] = tw_cmd.list[i];
333    }
334    /* Fix fencepost error -- Theodore Ts'o <tytso@athena.mit.edu> */
335    if (fwd)
336	tw_cmd.list[i - fwd] = tw_cmd.list[i];
337    tw_cmd.nlist -= fwd;
338    disabled_cleanup(&pintr_disabled);
339} /* end tw_cmd_sort */
340
341
342/* tw_cmd_start():
343 *	Get the command list and sort it, if not done yet.
344 *	Reset the current pointer to the beginning of the command list
345 */
346/*ARGSUSED*/
347void
348tw_cmd_start(DIR *dfd, const Char *pat)
349{
350    static Char *defpath[] = { STRNULL, 0 };
351    USE(pat);
352    SETDIR(dfd)
353    if ((tw_cmd_got & TW_FL_CMD) == 0) {
354	tw_cmd_free();
355	tw_cmd_cmd();
356	tw_cmd_got |= TW_FL_CMD;
357    }
358    if ((tw_cmd_got & TW_FL_ALIAS) == 0) {
359	tw_cmd_alias();
360	tw_cmd_got &= ~TW_FL_SORT;
361	tw_cmd_got |= TW_FL_ALIAS;
362    }
363    if ((tw_cmd_got & TW_FL_BUILTIN) == 0) {
364	tw_cmd_builtin();
365	tw_cmd_got &= ~TW_FL_SORT;
366	tw_cmd_got |= TW_FL_BUILTIN;
367    }
368    if ((tw_cmd_got & TW_FL_SORT) == 0) {
369	tw_cmd_sort();
370	tw_cmd_got |= TW_FL_SORT;
371    }
372
373    tw_cmd_state.cur = 0;
374    CLRDIR(tw_cmd_state.dfd)
375    if (tw_cmd_got & TW_FL_REL) {
376	struct varent *vp = adrof(STRpath);
377	if (vp && vp->vec)
378	    tw_cmd_state.pathv = vp->vec;
379	else
380	    tw_cmd_state.pathv = defpath;
381    }
382    else
383	tw_cmd_state.pathv = defpath;
384} /* tw_cmd_start */
385
386
387/* tw_cmd_next():
388 *	Return the next element in the command list or
389 *	Look for commands in the relative path components
390 */
391int
392tw_cmd_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
393{
394    int ret = 0;
395    Char *ptr;
396
397    if (tw_cmd_state.cur < tw_cmd.nlist) {
398	*flags = TW_DIR_OK;
399	Strbuf_append(res, tw_cmd.list[tw_cmd_state.cur++]);
400	return 1;
401    }
402
403    /*
404     * We need to process relatives in the path.
405     */
406    while ((tw_cmd_state.dfd == NULL ||
407	    (res->len = 0, ret = tw_dir_next(res, tw_cmd_state.dfd)) == 0) &&
408	   *tw_cmd_state.pathv != NULL) {
409
410        CLRDIR(tw_cmd_state.dfd)
411
412	while (*tw_cmd_state.pathv && tw_cmd_state.pathv[0][0] == '/')
413	    tw_cmd_state.pathv++;
414	if ((ptr = *tw_cmd_state.pathv) != 0) {
415	    res->len = 0;
416	    Strbuf_append(res, ptr);
417	    ret = 1;
418	    /*
419	     * We complete directories only on '.' should that
420	     * be changed?
421	     */
422	    dir->len = 0;
423	    if (ptr[0] == '\0' || (ptr[0] == '.' && ptr[1] == '\0')) {
424		tw_cmd_state.dfd = opendir(".");
425		*flags = TW_DIR_OK | TW_EXEC_CHK;
426	    }
427	    else {
428		Strbuf_append(dir, *tw_cmd_state.pathv);
429		Strbuf_append1(dir, '/');
430		tw_cmd_state.dfd = opendir(short2str(*tw_cmd_state.pathv));
431		*flags = TW_EXEC_CHK;
432	    }
433	    Strbuf_terminate(dir);
434	    tw_cmd_state.pathv++;
435	}
436    }
437    return ret;
438} /* end tw_cmd_next */
439
440
441/* tw_vptr_start():
442 *	Find the first variable in the variable list
443 */
444static void
445tw_vptr_start(struct varent *c)
446{
447    tw_vptr = c;		/* start at beginning of variable list */
448
449    for (;;) {
450	while (tw_vptr->v_left)
451	    tw_vptr = tw_vptr->v_left;
452x:
453	if (tw_vptr->v_parent == 0) {	/* is it the header? */
454	    tw_vptr = NULL;
455	    return;
456	}
457	if (tw_vptr->v_name)
458	    return;		/* found first one */
459	if (tw_vptr->v_right) {
460	    tw_vptr = tw_vptr->v_right;
461	    continue;
462	}
463	do {
464	    c = tw_vptr;
465	    tw_vptr = tw_vptr->v_parent;
466	} while (tw_vptr->v_right == c);
467	goto x;
468    }
469} /* end tw_shvar_start */
470
471
472/* tw_shvar_next():
473 *	Return the next shell variable
474 */
475/*ARGSUSED*/
476int
477tw_shvar_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
478{
479    struct varent *p;
480    struct varent *c;
481
482    USE(flags);
483    USE(dir);
484    if ((p = tw_vptr) == NULL)
485	return 0;		/* just in case */
486
487    Strbuf_append(res, p->v_name); /* we know that this name is here now */
488
489    /* now find the next one */
490    for (;;) {
491	if (p->v_right) {	/* if we can go right */
492	    p = p->v_right;
493	    while (p->v_left)
494		p = p->v_left;
495	}
496	else {			/* else go up */
497	    do {
498		c = p;
499		p = p->v_parent;
500	    } while (p->v_right == c);
501	}
502	if (p->v_parent == 0) {	/* is it the header? */
503	    tw_vptr = NULL;
504	    return 1;
505	}
506	if (p->v_name) {
507	    tw_vptr = p;	/* save state for the next call */
508	    return 1;
509	}
510    }
511} /* end tw_shvar_next */
512
513
514/* tw_envvar_next():
515 *	Return the next environment variable
516 */
517/*ARGSUSED*/
518int
519tw_envvar_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
520{
521    const Char *ps;
522
523    USE(flags);
524    USE(dir);
525    if (tw_env == NULL || *tw_env == NULL)
526	return 0;
527    for (ps = *tw_env; *ps && *ps != '='; ps++)
528	continue;
529    Strbuf_appendn(res, *tw_env, ps - *tw_env);
530    tw_env++;
531    return 1;
532} /* end tw_envvar_next */
533
534
535/* tw_var_start():
536 *	Begin the list of the shell and environment variables
537 */
538/*ARGSUSED*/
539void
540tw_var_start(DIR *dfd, const Char *pat)
541{
542    USE(pat);
543    SETDIR(dfd)
544    tw_vptr_start(&shvhed);
545    tw_env = STR_environ;
546} /* end tw_var_start */
547
548
549/* tw_alias_start():
550 *	Begin the list of the shell aliases
551 */
552/*ARGSUSED*/
553void
554tw_alias_start(DIR *dfd, const Char *pat)
555{
556    USE(pat);
557    SETDIR(dfd)
558    tw_vptr_start(&aliases);
559    tw_env = NULL;
560} /* tw_alias_start */
561
562
563/* tw_complete_start():
564 *	Begin the list of completions
565 */
566/*ARGSUSED*/
567void
568tw_complete_start(DIR *dfd, const Char *pat)
569{
570    USE(pat);
571    SETDIR(dfd)
572    tw_vptr_start(&completions);
573    tw_env = NULL;
574} /* end tw_complete_start */
575
576
577/* tw_var_next():
578 *	Return the next shell or environment variable
579 */
580int
581tw_var_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
582{
583    int ret = 0;
584
585    if (tw_vptr)
586	ret = tw_shvar_next(res, dir, flags);
587    if (ret == 0 && tw_env)
588	ret = tw_envvar_next(res, dir, flags);
589    return ret;
590} /* end tw_var_next */
591
592
593/* tw_logname_start():
594 *	Initialize lognames to the beginning of the list
595 */
596/*ARGSUSED*/
597void
598tw_logname_start(DIR *dfd, const Char *pat)
599{
600    USE(pat);
601    SETDIR(dfd)
602#ifdef HAVE_GETPWENT
603    (void) setpwent();	/* Open passwd file */
604#endif
605} /* end tw_logname_start */
606
607
608/* tw_logname_next():
609 *	Return the next entry from the passwd file
610 */
611/*ARGSUSED*/
612int
613tw_logname_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
614{
615    struct passwd *pw;
616
617    /*
618     * We don't want to get interrupted inside getpwent()
619     * because the yellow pages code is not interruptible,
620     * and if we call endpwent() immediatetely after
621     * (in pintr()) we may be freeing an invalid pointer
622     */
623    USE(flags);
624    USE(dir);
625    pintr_disabled++;
626#ifdef HAVE_GETPWENT
627    pw = getpwent();
628#else
629    pw = NULL;
630#endif
631    disabled_cleanup(&pintr_disabled);
632
633    if (pw == NULL) {
634#ifdef YPBUGS
635	fix_yp_bugs();
636#endif
637	return 0;
638    }
639    Strbuf_append(res, str2short(pw->pw_name));
640    return 1;
641} /* end tw_logname_next */
642
643
644/* tw_logname_end():
645 *	Close the passwd file to finish the logname list
646 */
647void
648tw_logname_end(void)
649{
650#ifdef YPBUGS
651    fix_yp_bugs();
652#endif
653#ifdef HAVE_GETPWENT
654   (void) endpwent();
655#endif
656} /* end tw_logname_end */
657
658
659/* tw_grpname_start():
660 *	Initialize grpnames to the beginning of the list
661 */
662/*ARGSUSED*/
663void
664tw_grpname_start(DIR *dfd, const Char *pat)
665{
666    USE(pat);
667    SETDIR(dfd)
668#if !defined(_VMS_POSIX) && !defined(_OSD_POSIX) && !defined(WINNT_NATIVE) && !defined (__ANDROID__)
669    (void) setgrent();	/* Open group file */
670#endif /* !_VMS_POSIX && !_OSD_POSIX && !WINNT_NATIVE */
671} /* end tw_grpname_start */
672
673
674/* tw_grpname_next():
675 *	Return the next entry from the group file
676 */
677/*ARGSUSED*/
678int
679tw_grpname_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
680{
681    struct group *gr;
682
683    /*
684     * We don't want to get interrupted inside getgrent()
685     * because the yellow pages code is not interruptible,
686     * and if we call endgrent() immediatetely after
687     * (in pintr()) we may be freeing an invalid pointer
688     */
689    USE(flags);
690    USE(dir);
691    pintr_disabled++;
692#if !defined(_VMS_POSIX) && !defined(_OSD_POSIX) && !defined(WINNT_NATIVE) && !defined(__ANDROID__)
693    errno = 0;
694    while ((gr = getgrent()) == NULL && errno == EINTR) {
695	handle_pending_signals();
696	errno = 0;
697    }
698#else /* _VMS_POSIX || _OSD_POSIX || WINNT_NATIVE */
699    gr = NULL;
700#endif /* !_VMS_POSIX && !_OSD_POSIX && !WINNT_NATIVE */
701    disabled_cleanup(&pintr_disabled);
702
703    if (gr == NULL) {
704#ifdef YPBUGS
705	fix_yp_bugs();
706#endif
707	return 0;
708    }
709    Strbuf_append(res, str2short(gr->gr_name));
710    return 1;
711} /* end tw_grpname_next */
712
713
714/* tw_grpname_end():
715 *	Close the group file to finish the groupname list
716 */
717void
718tw_grpname_end(void)
719{
720#ifdef YPBUGS
721    fix_yp_bugs();
722#endif
723#if !defined(_VMS_POSIX) && !defined(_OSD_POSIX) && !defined(WINNT_NATIVE) && !defined (__ANDROID__)
724   (void) endgrent();
725#endif /* !_VMS_POSIX && !_OSD_POSIX && !WINNT_NATIVE */
726} /* end tw_grpname_end */
727
728/* tw_file_start():
729 *	Initialize the directory for the file list
730 */
731/*ARGSUSED*/
732void
733tw_file_start(DIR *dfd, const Char *pat)
734{
735    struct varent *vp;
736    USE(pat);
737    SETDIR(dfd)
738    if ((vp = adrof(STRcdpath)) != NULL)
739	tw_env = vp->vec;
740} /* end tw_file_start */
741
742
743/* tw_file_next():
744 *	Return the next file in the directory
745 */
746int
747tw_file_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
748{
749    int ret = tw_dir_next(res, tw_dir_fd);
750    if (ret == 0 && (*flags & TW_DIR_OK) != 0) {
751	CLRDIR(tw_dir_fd)
752	while (tw_env && *tw_env)
753	    if ((tw_dir_fd = opendir(short2str(*tw_env))) != NULL)
754		break;
755	    else
756		tw_env++;
757
758	if (tw_dir_fd) {
759	    dir->len = 0;
760	    Strbuf_append(dir, *tw_env++);
761	    Strbuf_append1(dir, '/');
762	    Strbuf_terminate(dir);
763	    ret = tw_dir_next(res, tw_dir_fd);
764	}
765    }
766    return ret;
767} /* end tw_file_next */
768
769
770/* tw_dir_end():
771 *	Clear directory related lists
772 */
773void
774tw_dir_end(void)
775{
776   CLRDIR(tw_dir_fd)
777   CLRDIR(tw_cmd_state.dfd)
778} /* end tw_dir_end */
779
780
781/* tw_item_free():
782 *	Free the item list
783 */
784void
785tw_item_free(void)
786{
787    tw_str_free(&tw_item);
788} /* end tw_item_free */
789
790
791/* tw_item_get():
792 *	Return the list of items
793 */
794Char **
795tw_item_get(void)
796{
797    return tw_item.list;
798} /* end tw_item_get */
799
800
801/* tw_item_add():
802 *	Return a new item for a Strbuf_terminate()'d s
803 */
804void
805tw_item_add(const struct Strbuf *s)
806{
807    Char *p;
808
809    p = tw_str_add(&tw_item, s->len + 1);
810    Strcpy(p, s->s);
811} /* tw_item_add */
812
813
814/* tw_item_find():
815 *      Find the string if it exists in the item list
816 *	end return it.
817 */
818Char *
819tw_item_find(Char *str)
820{
821    size_t i;
822
823    if (tw_item.list == NULL || str == NULL)
824	return NULL;
825
826    for (i = 0; i < tw_item.nlist; i++)
827	if (tw_item.list[i] != NULL && Strcmp(tw_item.list[i], str) == 0)
828	    return tw_item.list[i];
829    return NULL;
830} /* end tw_item_find */
831
832
833/* tw_vl_start():
834 *	Initialize a variable list
835 */
836void
837tw_vl_start(DIR *dfd, const Char *pat)
838{
839    SETDIR(dfd)
840    if ((tw_vptr = adrof(pat)) != NULL) {
841	tw_env = tw_vptr->vec;
842	tw_vptr = NULL;
843    }
844    else
845	tw_env = NULL;
846} /* end tw_vl_start */
847
848
849/*
850 * Initialize a word list
851 */
852void
853tw_wl_start(DIR *dfd, const Char *pat)
854{
855    SETDIR(dfd);
856    tw_word = pat;
857} /* end tw_wl_start */
858
859
860/*
861 * Return the next word from the word list
862 */
863/*ARGSUSED*/
864int
865tw_wl_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
866{
867    const Char *p;
868
869    USE(dir);
870    USE(flags);
871    if (tw_word == NULL || tw_word[0] == '\0')
872	return 0;
873
874    while (*tw_word && Isspace(*tw_word)) tw_word++;
875
876    for (p = tw_word; *tw_word && !Isspace(*tw_word); tw_word++)
877	continue;
878    if (tw_word == p)
879	return 0;
880    Strbuf_appendn(res, p, tw_word - p);
881    if (*tw_word)
882	tw_word++;
883    return 1;
884} /* end tw_wl_next */
885
886
887/* tw_bind_start():
888 *	Begin the list of the shell bindings
889 */
890/*ARGSUSED*/
891void
892tw_bind_start(DIR *dfd, const Char *pat)
893{
894    USE(pat);
895    SETDIR(dfd)
896    tw_bind = FuncNames;
897} /* end tw_bind_start */
898
899
900/* tw_bind_next():
901 *	Begin the list of the shell bindings
902 */
903/*ARGSUSED*/
904int
905tw_bind_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
906{
907    USE(dir);
908    USE(flags);
909    if (tw_bind && tw_bind->name) {
910	const char *ptr;
911
912	for (ptr = tw_bind->name; *ptr != '\0'; ptr++)
913	    Strbuf_append1(res, *ptr);
914	tw_bind++;
915	return 1;
916    }
917    return 0;
918} /* end tw_bind_next */
919
920
921/* tw_limit_start():
922 *	Begin the list of the shell limitings
923 */
924/*ARGSUSED*/
925void
926tw_limit_start(DIR *dfd, const Char *pat)
927{
928    USE(pat);
929    SETDIR(dfd)
930#ifndef HAVENOLIMIT
931    tw_limit = limits;
932#endif /* ! HAVENOLIMIT */
933} /* end tw_limit_start */
934
935
936/* tw_limit_next():
937 *	Begin the list of the shell limitings
938 */
939/*ARGSUSED*/
940int
941tw_limit_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
942{
943    USE(dir);
944    USE(flags);
945#ifndef HAVENOLIMIT
946    if (tw_limit && tw_limit->limname) {
947	const char *ptr;
948
949	for (ptr = tw_limit->limname; *ptr != '\0'; ptr++)
950	    Strbuf_append1(res, *ptr);
951	tw_limit++;
952	return 1;
953    }
954#endif /* ! HAVENOLIMIT */
955    return 0;
956} /* end tw_limit_next */
957
958
959/* tw_sig_start():
960 *	Begin the list of the shell sigings
961 */
962/*ARGSUSED*/
963void
964tw_sig_start(DIR *dfd, const Char *pat)
965{
966    USE(pat);
967    SETDIR(dfd)
968    tw_index = 0;
969} /* end tw_sig_start */
970
971
972/* tw_sig_next():
973 *	Begin the list of the shell sigings
974 */
975/*ARGSUSED*/
976int
977tw_sig_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
978{
979    USE(dir);
980    USE(flags);
981    for (;tw_index < nsig; tw_index++) {
982	const char *ptr;
983
984	if (mesg[tw_index].iname == NULL)
985	    continue;
986
987	for (ptr = mesg[tw_index].iname; *ptr != '\0'; ptr++)
988	    Strbuf_append1(res, *ptr);
989	tw_index++;
990	return 1;
991    }
992    return 0;
993} /* end tw_sig_next */
994
995
996/* tw_job_start():
997 *	Begin the list of the shell jobings
998 */
999/*ARGSUSED*/
1000void
1001tw_job_start(DIR *dfd, const Char *pat)
1002{
1003    USE(pat);
1004    SETDIR(dfd)
1005    tw_index = 1;
1006} /* end tw_job_start */
1007
1008
1009/* tw_job_next():
1010 *	Begin the list of the shell jobings
1011 */
1012/*ARGSUSED*/
1013int
1014tw_job_next(struct Strbuf *res, struct Strbuf *dir, int *flags)
1015{
1016    struct process *j;
1017
1018    USE(dir);
1019    USE(flags);
1020    for (;tw_index <= pmaxindex; tw_index++) {
1021	for (j = proclist.p_next; j != NULL; j = j->p_next)
1022	    if (j->p_index == tw_index && j->p_procid == j->p_jobid)
1023		break;
1024	if (j == NULL)
1025	    continue;
1026	Strbuf_append(res, j->p_command);
1027	tw_index++;
1028	return 1;
1029    }
1030    return 0;
1031} /* end tw_job_next */
1032