contrib/tcsh-6/tw.init.c

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