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