/contrib/tcsh/tw.init.c

   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 */