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 35 RCSID("$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 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 * 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 */ 268 static void 269 tw_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 */ 287 static void 288 tw_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; 297 x: 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 */ 318 static void 319 tw_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*/ 347 void 348 tw_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 */ 391 int 392 tw_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 */ 444 static void 445 tw_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; 452 x: 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*/ 476 int 477 tw_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*/ 518 int 519 tw_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*/ 539 void 540 tw_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*/ 553 void 554 tw_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*/ 567 void 568 tw_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 */ 580 int 581 tw_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*/ 597 void 598 tw_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*/ 612 int 613 tw_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 */ 647 void 648 tw_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*/ 663 void 664 tw_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*/ 678 int 679 tw_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 */ 717 void 718 tw_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*/ 732 void 733 tw_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 */ 746 int 747 tw_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 */ 773 void 774 tw_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 */ 784 void 785 tw_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 */ 794 Char ** 795 tw_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 */ 804 void 805 tw_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 */ 818 Char * 819 tw_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 */ 836 void 837 tw_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 */ 852 void 853 tw_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*/ 864 int 865 tw_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*/ 891 void 892 tw_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*/ 904 int 905 tw_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*/ 925 void 926 tw_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*/ 940 int 941 tw_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*/ 963 void 964 tw_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*/ 976 int 977 tw_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*/ 1000 void 1001 tw_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*/ 1013 int 1014 tw_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