1 /* 2 * Copyright (C) 1984-2009 Mark Nudelman 3 * 4 * You may distribute under the terms of either the GNU General Public 5 * License or the Less License, as specified in the README file. 6 * 7 * For more information about less, or for information on how to 8 * contact the author, see the README file. 9 */ 10 11 12 /* 13 * Functions which manipulate the command buffer. 14 * Used only by command() and related functions. 15 */ 16 17 #include "less.h" 18 #include "cmd.h" 19 #include "charset.h" 20 #if HAVE_STAT 21 #include <sys/stat.h> 22 #endif 23 24 extern int sc_width; 25 extern int utf_mode; 26 27 static char cmdbuf[CMDBUF_SIZE]; /* Buffer for holding a multi-char command */ 28 static int cmd_col; /* Current column of the cursor */ 29 static int prompt_col; /* Column of cursor just after prompt */ 30 static char *cp; /* Pointer into cmdbuf */ 31 static int cmd_offset; /* Index into cmdbuf of first displayed char */ 32 static int literal; /* Next input char should not be interpreted */ 33 34 #if TAB_COMPLETE_FILENAME 35 static int cmd_complete(); 36 /* 37 * These variables are statics used by cmd_complete. 38 */ 39 static int in_completion = 0; 40 static char *tk_text; 41 static char *tk_original; 42 static char *tk_ipoint; 43 static char *tk_trial; 44 static struct textlist tk_tlist; 45 #endif 46 47 static int cmd_left(); 48 static int cmd_right(); 49 50 #if SPACES_IN_FILENAMES 51 public char openquote = '"'; 52 public char closequote = '"'; 53 #endif 54 55 #if CMD_HISTORY 56 57 /* History file */ 58 #define HISTFILE_FIRST_LINE ".less-history-file:" 59 #define HISTFILE_SEARCH_SECTION ".search" 60 #define HISTFILE_SHELL_SECTION ".shell" 61 62 /* 63 * A mlist structure represents a command history. 64 */ 65 struct mlist 66 { 67 struct mlist *next; 68 struct mlist *prev; 69 struct mlist *curr_mp; 70 char *string; 71 int modified; 72 }; 73 74 /* 75 * These are the various command histories that exist. 76 */ 77 struct mlist mlist_search = 78 { &mlist_search, &mlist_search, &mlist_search, NULL, 0 }; 79 public void * constant ml_search = (void *) &mlist_search; 80 81 struct mlist mlist_examine = 82 { &mlist_examine, &mlist_examine, &mlist_examine, NULL, 0 }; 83 public void * constant ml_examine = (void *) &mlist_examine; 84 85 #if SHELL_ESCAPE || PIPEC 86 struct mlist mlist_shell = 87 { &mlist_shell, &mlist_shell, &mlist_shell, NULL, 0 }; 88 public void * constant ml_shell = (void *) &mlist_shell; 89 #endif 90 91 #else /* CMD_HISTORY */ 92 93 /* If CMD_HISTORY is off, these are just flags. */ 94 public void * constant ml_search = (void *)1; 95 public void * constant ml_examine = (void *)2; 96 #if SHELL_ESCAPE || PIPEC 97 public void * constant ml_shell = (void *)3; 98 #endif 99 100 #endif /* CMD_HISTORY */ 101 102 /* 103 * History for the current command. 104 */ 105 static struct mlist *curr_mlist = NULL; 106 static int curr_cmdflags; 107 108 static char cmd_mbc_buf[MAX_UTF_CHAR_LEN]; 109 static int cmd_mbc_buf_len; 110 static int cmd_mbc_buf_index; 111 112 113 /* 114 * Reset command buffer (to empty). 115 */ 116 public void 117 cmd_reset() 118 { 119 cp = cmdbuf; 120 *cp = '\0'; 121 cmd_col = 0; 122 cmd_offset = 0; 123 literal = 0; 124 cmd_mbc_buf_len = 0; 125 } 126 127 /* 128 * Clear command line. 129 */ 130 public void 131 clear_cmd() 132 { 133 cmd_col = prompt_col = 0; 134 cmd_mbc_buf_len = 0; 135 } 136 137 /* 138 * Display a string, usually as a prompt for input into the command buffer. 139 */ 140 public void 141 cmd_putstr(s) 142 char *s; 143 { 144 LWCHAR prev_ch = 0; 145 LWCHAR ch; 146 char *endline = s + strlen(s); 147 while (*s != '\0') 148 { 149 char *ns = s; 150 ch = step_char(&ns, +1, endline); 151 while (s < ns) 152 putchr(*s++); 153 if (!utf_mode) 154 { 155 cmd_col++; 156 prompt_col++; 157 } else if (!is_composing_char(ch) && 158 !is_combining_char(prev_ch, ch)) 159 { 160 int width = is_wide_char(ch) ? 2 : 1; 161 cmd_col += width; 162 prompt_col += width; 163 } 164 prev_ch = ch; 165 } 166 } 167 168 /* 169 * How many characters are in the command buffer? 170 */ 171 public int 172 len_cmdbuf() 173 { 174 char *s = cmdbuf; 175 char *endline = s + strlen(s); 176 int len = 0; 177 178 while (*s != '\0') 179 { 180 step_char(&s, +1, endline); 181 len++; 182 } 183 return (len); 184 } 185 186 /* 187 * Common part of cmd_step_right() and cmd_step_left(). 188 */ 189 static char * 190 cmd_step_common(p, ch, len, pwidth, bswidth) 191 char *p; 192 LWCHAR ch; 193 int len; 194 int *pwidth; 195 int *bswidth; 196 { 197 char *pr; 198 199 if (len == 1) 200 { 201 pr = prchar((int) ch); 202 if (pwidth != NULL || bswidth != NULL) 203 { 204 int len = strlen(pr); 205 if (pwidth != NULL) 206 *pwidth = len; 207 if (bswidth != NULL) 208 *bswidth = len; 209 } 210 } else 211 { 212 pr = prutfchar(ch); 213 if (pwidth != NULL || bswidth != NULL) 214 { 215 if (is_composing_char(ch)) 216 { 217 if (pwidth != NULL) 218 *pwidth = 0; 219 if (bswidth != NULL) 220 *bswidth = 0; 221 } else if (is_ubin_char(ch)) 222 { 223 int len = strlen(pr); 224 if (pwidth != NULL) 225 *pwidth = len; 226 if (bswidth != NULL) 227 *bswidth = len; 228 } else 229 { 230 LWCHAR prev_ch = step_char(&p, -1, cmdbuf); 231 if (is_combining_char(prev_ch, ch)) 232 { 233 if (pwidth != NULL) 234 *pwidth = 0; 235 if (bswidth != NULL) 236 *bswidth = 0; 237 } else 238 { 239 if (pwidth != NULL) 240 *pwidth = is_wide_char(ch) 241 ? 2 242 : 1; 243 if (bswidth != NULL) 244 *bswidth = 1; 245 } 246 } 247 } 248 } 249 250 return (pr); 251 } 252 253 /* 254 * Step a pointer one character right in the command buffer. 255 */ 256 static char * 257 cmd_step_right(pp, pwidth, bswidth) 258 char **pp; 259 int *pwidth; 260 int *bswidth; 261 { 262 char *p = *pp; 263 LWCHAR ch = step_char(pp, +1, p + strlen(p)); 264 265 return cmd_step_common(p, ch, *pp - p, pwidth, bswidth); 266 } 267 268 /* 269 * Step a pointer one character left in the command buffer. 270 */ 271 static char * 272 cmd_step_left(pp, pwidth, bswidth) 273 char **pp; 274 int *pwidth; 275 int *bswidth; 276 { 277 char *p = *pp; 278 LWCHAR ch = step_char(pp, -1, cmdbuf); 279 280 return cmd_step_common(*pp, ch, p - *pp, pwidth, bswidth); 281 } 282 283 /* 284 * Repaint the line from cp onwards. 285 * Then position the cursor just after the char old_cp (a pointer into cmdbuf). 286 */ 287 static void 288 cmd_repaint(old_cp) 289 char *old_cp; 290 { 291 /* 292 * Repaint the line from the current position. 293 */ 294 clear_eol(); 295 while (*cp != '\0') 296 { 297 char *np = cp; 298 int width; 299 char *pr = cmd_step_right(&np, &width, NULL); 300 if (cmd_col + width >= sc_width) 301 break; 302 cp = np; 303 putstr(pr); 304 cmd_col += width; 305 } 306 while (*cp != '\0') 307 { 308 char *np = cp; 309 int width; 310 char *pr = cmd_step_right(&np, &width, NULL); 311 if (width > 0) 312 break; 313 cp = np; 314 putstr(pr); 315 } 316 317 /* 318 * Back up the cursor to the correct position. 319 */ 320 while (cp > old_cp) 321 cmd_left(); 322 } 323 324 /* 325 * Put the cursor at "home" (just after the prompt), 326 * and set cp to the corresponding char in cmdbuf. 327 */ 328 static void 329 cmd_home() 330 { 331 while (cmd_col > prompt_col) 332 { 333 int width, bswidth; 334 335 cmd_step_left(&cp, &width, &bswidth); 336 while (bswidth-- > 0) 337 putbs(); 338 cmd_col -= width; 339 } 340 341 cp = &cmdbuf[cmd_offset]; 342 } 343 344 /* 345 * Shift the cmdbuf display left a half-screen. 346 */ 347 static void 348 cmd_lshift() 349 { 350 char *s; 351 char *save_cp; 352 int cols; 353 354 /* 355 * Start at the first displayed char, count how far to the 356 * right we'd have to move to reach the center of the screen. 357 */ 358 s = cmdbuf + cmd_offset; 359 cols = 0; 360 while (cols < (sc_width - prompt_col) / 2 && *s != '\0') 361 { 362 int width; 363 cmd_step_right(&s, &width, NULL); 364 cols += width; 365 } 366 while (*s != '\0') 367 { 368 int width; 369 char *ns = s; 370 cmd_step_right(&ns, &width, NULL); 371 if (width > 0) 372 break; 373 s = ns; 374 } 375 376 cmd_offset = s - cmdbuf; 377 save_cp = cp; 378 cmd_home(); 379 cmd_repaint(save_cp); 380 } 381 382 /* 383 * Shift the cmdbuf display right a half-screen. 384 */ 385 static void 386 cmd_rshift() 387 { 388 char *s; 389 char *save_cp; 390 int cols; 391 392 /* 393 * Start at the first displayed char, count how far to the 394 * left we'd have to move to traverse a half-screen width 395 * of displayed characters. 396 */ 397 s = cmdbuf + cmd_offset; 398 cols = 0; 399 while (cols < (sc_width - prompt_col) / 2 && s > cmdbuf) 400 { 401 int width; 402 cmd_step_left(&s, &width, NULL); 403 cols += width; 404 } 405 406 cmd_offset = s - cmdbuf; 407 save_cp = cp; 408 cmd_home(); 409 cmd_repaint(save_cp); 410 } 411 412 /* 413 * Move cursor right one character. 414 */ 415 static int 416 cmd_right() 417 { 418 char *pr; 419 char *ncp; 420 int width; 421 422 if (*cp == '\0') 423 { 424 /* Already at the end of the line. */ 425 return (CC_OK); 426 } 427 ncp = cp; 428 pr = cmd_step_right(&ncp, &width, NULL); 429 if (cmd_col + width >= sc_width) 430 cmd_lshift(); 431 else if (cmd_col + width == sc_width - 1 && cp[1] != '\0') 432 cmd_lshift(); 433 cp = ncp; 434 cmd_col += width; 435 putstr(pr); 436 while (*cp != '\0') 437 { 438 pr = cmd_step_right(&ncp, &width, NULL); 439 if (width > 0) 440 break; 441 putstr(pr); 442 cp = ncp; 443 } 444 return (CC_OK); 445 } 446 447 /* 448 * Move cursor left one character. 449 */ 450 static int 451 cmd_left() 452 { 453 char *ncp; 454 int width, bswidth; 455 456 if (cp <= cmdbuf) 457 { 458 /* Already at the beginning of the line */ 459 return (CC_OK); 460 } 461 ncp = cp; 462 while (ncp > cmdbuf) 463 { 464 cmd_step_left(&ncp, &width, &bswidth); 465 if (width > 0) 466 break; 467 } 468 if (cmd_col < prompt_col + width) 469 cmd_rshift(); 470 cp = ncp; 471 cmd_col -= width; 472 while (bswidth-- > 0) 473 putbs(); 474 return (CC_OK); 475 } 476 477 /* 478 * Insert a char into the command buffer, at the current position. 479 */ 480 static int 481 cmd_ichar(cs, clen) 482 char *cs; 483 int clen; 484 { 485 char *s; 486 487 if (strlen(cmdbuf) + clen >= sizeof(cmdbuf)-1) 488 { 489 /* No room in the command buffer for another char. */ 490 bell(); 491 return (CC_ERROR); 492 } 493 494 /* 495 * Make room for the new character (shift the tail of the buffer right). 496 */ 497 for (s = &cmdbuf[strlen(cmdbuf)]; s >= cp; s--) 498 s[clen] = s[0]; 499 /* 500 * Insert the character into the buffer. 501 */ 502 for (s = cp; s < cp + clen; s++) 503 *s = *cs++; 504 /* 505 * Reprint the tail of the line from the inserted char. 506 */ 507 cmd_repaint(cp); 508 cmd_right(); 509 return (CC_OK); 510 } 511 512 /* 513 * Backspace in the command buffer. 514 * Delete the char to the left of the cursor. 515 */ 516 static int 517 cmd_erase() 518 { 519 register char *s; 520 int clen; 521 522 if (cp == cmdbuf) 523 { 524 /* 525 * Backspace past beginning of the buffer: 526 * this usually means abort the command. 527 */ 528 return (CC_QUIT); 529 } 530 /* 531 * Move cursor left (to the char being erased). 532 */ 533 s = cp; 534 cmd_left(); 535 clen = s - cp; 536 537 /* 538 * Remove the char from the buffer (shift the buffer left). 539 */ 540 for (s = cp; ; s++) 541 { 542 s[0] = s[clen]; 543 if (s[0] == '\0') 544 break; 545 } 546 547 /* 548 * Repaint the buffer after the erased char. 549 */ 550 cmd_repaint(cp); 551 552 /* 553 * We say that erasing the entire command string causes us 554 * to abort the current command, if CF_QUIT_ON_ERASE is set. 555 */ 556 if ((curr_cmdflags & CF_QUIT_ON_ERASE) && cp == cmdbuf && *cp == '\0') 557 return (CC_QUIT); 558 return (CC_OK); 559 } 560 561 /* 562 * Delete the char under the cursor. 563 */ 564 static int 565 cmd_delete() 566 { 567 if (*cp == '\0') 568 { 569 /* At end of string; there is no char under the cursor. */ 570 return (CC_OK); 571 } 572 /* 573 * Move right, then use cmd_erase. 574 */ 575 cmd_right(); 576 cmd_erase(); 577 return (CC_OK); 578 } 579 580 /* 581 * Delete the "word" to the left of the cursor. 582 */ 583 static int 584 cmd_werase() 585 { 586 if (cp > cmdbuf && cp[-1] == ' ') 587 { 588 /* 589 * If the char left of cursor is a space, 590 * erase all the spaces left of cursor (to the first non-space). 591 */ 592 while (cp > cmdbuf && cp[-1] == ' ') 593 (void) cmd_erase(); 594 } else 595 { 596 /* 597 * If the char left of cursor is not a space, 598 * erase all the nonspaces left of cursor (the whole "word"). 599 */ 600 while (cp > cmdbuf && cp[-1] != ' ') 601 (void) cmd_erase(); 602 } 603 return (CC_OK); 604 } 605 606 /* 607 * Delete the "word" under the cursor. 608 */ 609 static int 610 cmd_wdelete() 611 { 612 if (*cp == ' ') 613 { 614 /* 615 * If the char under the cursor is a space, 616 * delete it and all the spaces right of cursor. 617 */ 618 while (*cp == ' ') 619 (void) cmd_delete(); 620 } else 621 { 622 /* 623 * If the char under the cursor is not a space, 624 * delete it and all nonspaces right of cursor (the whole word). 625 */ 626 while (*cp != ' ' && *cp != '\0') 627 (void) cmd_delete(); 628 } 629 return (CC_OK); 630 } 631 632 /* 633 * Delete all chars in the command buffer. 634 */ 635 static int 636 cmd_kill() 637 { 638 if (cmdbuf[0] == '\0') 639 { 640 /* Buffer is already empty; abort the current command. */ 641 return (CC_QUIT); 642 } 643 cmd_offset = 0; 644 cmd_home(); 645 *cp = '\0'; 646 cmd_repaint(cp); 647 648 /* 649 * We say that erasing the entire command string causes us 650 * to abort the current command, if CF_QUIT_ON_ERASE is set. 651 */ 652 if (curr_cmdflags & CF_QUIT_ON_ERASE) 653 return (CC_QUIT); 654 return (CC_OK); 655 } 656 657 /* 658 * Select an mlist structure to be the current command history. 659 */ 660 public void 661 set_mlist(mlist, cmdflags) 662 void *mlist; 663 int cmdflags; 664 { 665 #if CMD_HISTORY 666 curr_mlist = (struct mlist *) mlist; 667 curr_cmdflags = cmdflags; 668 669 /* Make sure the next up-arrow moves to the last string in the mlist. */ 670 if (curr_mlist != NULL) 671 curr_mlist->curr_mp = curr_mlist; 672 #endif 673 } 674 675 #if CMD_HISTORY 676 /* 677 * Move up or down in the currently selected command history list. 678 */ 679 static int 680 cmd_updown(action) 681 int action; 682 { 683 char *s; 684 685 if (curr_mlist == NULL) 686 { 687 /* 688 * The current command has no history list. 689 */ 690 bell(); 691 return (CC_OK); 692 } 693 cmd_home(); 694 clear_eol(); 695 /* 696 * Move curr_mp to the next/prev entry. 697 */ 698 if (action == EC_UP) 699 curr_mlist->curr_mp = curr_mlist->curr_mp->prev; 700 else 701 curr_mlist->curr_mp = curr_mlist->curr_mp->next; 702 /* 703 * Copy the entry into cmdbuf and echo it on the screen. 704 */ 705 s = curr_mlist->curr_mp->string; 706 if (s == NULL) 707 s = ""; 708 strcpy(cmdbuf, s); 709 for (cp = cmdbuf; *cp != '\0'; ) 710 cmd_right(); 711 return (CC_OK); 712 } 713 #endif 714 715 /* 716 * Add a string to a history list. 717 */ 718 public void 719 cmd_addhist(mlist, cmd) 720 struct mlist *mlist; 721 char *cmd; 722 { 723 #if CMD_HISTORY 724 struct mlist *ml; 725 726 /* 727 * Don't save a trivial command. 728 */ 729 if (strlen(cmd) == 0) 730 return; 731 732 /* 733 * Save the command unless it's a duplicate of the 734 * last command in the history. 735 */ 736 ml = mlist->prev; 737 if (ml == mlist || strcmp(ml->string, cmd) != 0) 738 { 739 /* 740 * Did not find command in history. 741 * Save the command and put it at the end of the history list. 742 */ 743 ml = (struct mlist *) ecalloc(1, sizeof(struct mlist)); 744 ml->string = save(cmd); 745 ml->next = mlist; 746 ml->prev = mlist->prev; 747 mlist->prev->next = ml; 748 mlist->prev = ml; 749 } 750 /* 751 * Point to the cmd just after the just-accepted command. 752 * Thus, an UPARROW will always retrieve the previous command. 753 */ 754 mlist->curr_mp = ml->next; 755 #endif 756 } 757 758 /* 759 * Accept the command in the command buffer. 760 * Add it to the currently selected history list. 761 */ 762 public void 763 cmd_accept() 764 { 765 #if CMD_HISTORY 766 /* 767 * Nothing to do if there is no currently selected history list. 768 */ 769 if (curr_mlist == NULL) 770 return; 771 cmd_addhist(curr_mlist, cmdbuf); 772 curr_mlist->modified = 1; 773 #endif 774 } 775 776 /* 777 * Try to perform a line-edit function on the command buffer, 778 * using a specified char as a line-editing command. 779 * Returns: 780 * CC_PASS The char does not invoke a line edit function. 781 * CC_OK Line edit function done. 782 * CC_QUIT The char requests the current command to be aborted. 783 */ 784 static int 785 cmd_edit(c) 786 int c; 787 { 788 int action; 789 int flags; 790 791 #if TAB_COMPLETE_FILENAME 792 #define not_in_completion() in_completion = 0 793 #else 794 #define not_in_completion() 795 #endif 796 797 /* 798 * See if the char is indeed a line-editing command. 799 */ 800 flags = 0; 801 #if CMD_HISTORY 802 if (curr_mlist == NULL) 803 /* 804 * No current history; don't accept history manipulation cmds. 805 */ 806 flags |= EC_NOHISTORY; 807 #endif 808 #if TAB_COMPLETE_FILENAME 809 if (curr_mlist == ml_search) 810 /* 811 * In a search command; don't accept file-completion cmds. 812 */ 813 flags |= EC_NOCOMPLETE; 814 #endif 815 816 action = editchar(c, flags); 817 818 switch (action) 819 { 820 case EC_RIGHT: 821 not_in_completion(); 822 return (cmd_right()); 823 case EC_LEFT: 824 not_in_completion(); 825 return (cmd_left()); 826 case EC_W_RIGHT: 827 not_in_completion(); 828 while (*cp != '\0' && *cp != ' ') 829 cmd_right(); 830 while (*cp == ' ') 831 cmd_right(); 832 return (CC_OK); 833 case EC_W_LEFT: 834 not_in_completion(); 835 while (cp > cmdbuf && cp[-1] == ' ') 836 cmd_left(); 837 while (cp > cmdbuf && cp[-1] != ' ') 838 cmd_left(); 839 return (CC_OK); 840 case EC_HOME: 841 not_in_completion(); 842 cmd_offset = 0; 843 cmd_home(); 844 cmd_repaint(cp); 845 return (CC_OK); 846 case EC_END: 847 not_in_completion(); 848 while (*cp != '\0') 849 cmd_right(); 850 return (CC_OK); 851 case EC_INSERT: 852 not_in_completion(); 853 return (CC_OK); 854 case EC_BACKSPACE: 855 not_in_completion(); 856 return (cmd_erase()); 857 case EC_LINEKILL: 858 not_in_completion(); 859 return (cmd_kill()); 860 case EC_W_BACKSPACE: 861 not_in_completion(); 862 return (cmd_werase()); 863 case EC_DELETE: 864 not_in_completion(); 865 return (cmd_delete()); 866 case EC_W_DELETE: 867 not_in_completion(); 868 return (cmd_wdelete()); 869 case EC_LITERAL: 870 literal = 1; 871 return (CC_OK); 872 #if CMD_HISTORY 873 case EC_UP: 874 case EC_DOWN: 875 not_in_completion(); 876 return (cmd_updown(action)); 877 #endif 878 #if TAB_COMPLETE_FILENAME 879 case EC_F_COMPLETE: 880 case EC_B_COMPLETE: 881 case EC_EXPAND: 882 return (cmd_complete(action)); 883 #endif 884 case EC_NOACTION: 885 return (CC_OK); 886 default: 887 not_in_completion(); 888 return (CC_PASS); 889 } 890 } 891 892 #if TAB_COMPLETE_FILENAME 893 /* 894 * Insert a string into the command buffer, at the current position. 895 */ 896 static int 897 cmd_istr(str) 898 char *str; 899 { 900 char *s; 901 int action; 902 char *endline = str + strlen(str); 903 904 for (s = str; *s != '\0'; ) 905 { 906 char *os = s; 907 step_char(&s, +1, endline); 908 action = cmd_ichar(os, s - os); 909 if (action != CC_OK) 910 { 911 bell(); 912 return (action); 913 } 914 } 915 return (CC_OK); 916 } 917 918 /* 919 * Find the beginning and end of the "current" word. 920 * This is the word which the cursor (cp) is inside or at the end of. 921 * Return pointer to the beginning of the word and put the 922 * cursor at the end of the word. 923 */ 924 static char * 925 delimit_word() 926 { 927 char *word; 928 #if SPACES_IN_FILENAMES 929 char *p; 930 int delim_quoted = 0; 931 int meta_quoted = 0; 932 char *esc = get_meta_escape(); 933 int esclen = strlen(esc); 934 #endif 935 936 /* 937 * Move cursor to end of word. 938 */ 939 if (*cp != ' ' && *cp != '\0') 940 { 941 /* 942 * Cursor is on a nonspace. 943 * Move cursor right to the next space. 944 */ 945 while (*cp != ' ' && *cp != '\0') 946 cmd_right(); 947 } else if (cp > cmdbuf && cp[-1] != ' ') 948 { 949 /* 950 * Cursor is on a space, and char to the left is a nonspace. 951 * We're already at the end of the word. 952 */ 953 ; 954 #if 0 955 } else 956 { 957 /* 958 * Cursor is on a space and char to the left is a space. 959 * Huh? There's no word here. 960 */ 961 return (NULL); 962 #endif 963 } 964 /* 965 * Find the beginning of the word which the cursor is in. 966 */ 967 if (cp == cmdbuf) 968 return (NULL); 969 #if SPACES_IN_FILENAMES 970 /* 971 * If we have an unbalanced quote (that is, an open quote 972 * without a corresponding close quote), we return everything 973 * from the open quote, including spaces. 974 */ 975 for (word = cmdbuf; word < cp; word++) 976 if (*word != ' ') 977 break; 978 if (word >= cp) 979 return (cp); 980 for (p = cmdbuf; p < cp; p++) 981 { 982 if (meta_quoted) 983 { 984 meta_quoted = 0; 985 } else if (esclen > 0 && p + esclen < cp && 986 strncmp(p, esc, esclen) == 0) 987 { 988 meta_quoted = 1; 989 p += esclen - 1; 990 } else if (delim_quoted) 991 { 992 if (*p == closequote) 993 delim_quoted = 0; 994 } else /* (!delim_quoted) */ 995 { 996 if (*p == openquote) 997 delim_quoted = 1; 998 else if (*p == ' ') 999 word = p+1; 1000 } 1001 } 1002 #endif 1003 return (word); 1004 } 1005 1006 /* 1007 * Set things up to enter completion mode. 1008 * Expand the word under the cursor into a list of filenames 1009 * which start with that word, and set tk_text to that list. 1010 */ 1011 static void 1012 init_compl() 1013 { 1014 char *word; 1015 char c; 1016 1017 /* 1018 * Get rid of any previous tk_text. 1019 */ 1020 if (tk_text != NULL) 1021 { 1022 free(tk_text); 1023 tk_text = NULL; 1024 } 1025 /* 1026 * Find the original (uncompleted) word in the command buffer. 1027 */ 1028 word = delimit_word(); 1029 if (word == NULL) 1030 return; 1031 /* 1032 * Set the insertion point to the point in the command buffer 1033 * where the original (uncompleted) word now sits. 1034 */ 1035 tk_ipoint = word; 1036 /* 1037 * Save the original (uncompleted) word 1038 */ 1039 if (tk_original != NULL) 1040 free(tk_original); 1041 tk_original = (char *) ecalloc(cp-word+1, sizeof(char)); 1042 strncpy(tk_original, word, cp-word); 1043 /* 1044 * Get the expanded filename. 1045 * This may result in a single filename, or 1046 * a blank-separated list of filenames. 1047 */ 1048 c = *cp; 1049 *cp = '\0'; 1050 if (*word != openquote) 1051 { 1052 tk_text = fcomplete(word); 1053 } else 1054 { 1055 char *qword = shell_quote(word+1); 1056 if (qword == NULL) 1057 tk_text = fcomplete(word+1); 1058 else 1059 { 1060 tk_text = fcomplete(qword); 1061 free(qword); 1062 } 1063 } 1064 *cp = c; 1065 } 1066 1067 /* 1068 * Return the next word in the current completion list. 1069 */ 1070 static char * 1071 next_compl(action, prev) 1072 int action; 1073 char *prev; 1074 { 1075 switch (action) 1076 { 1077 case EC_F_COMPLETE: 1078 return (forw_textlist(&tk_tlist, prev)); 1079 case EC_B_COMPLETE: 1080 return (back_textlist(&tk_tlist, prev)); 1081 } 1082 /* Cannot happen */ 1083 return ("?"); 1084 } 1085 1086 /* 1087 * Complete the filename before (or under) the cursor. 1088 * cmd_complete may be called multiple times. The global in_completion 1089 * remembers whether this call is the first time (create the list), 1090 * or a subsequent time (step thru the list). 1091 */ 1092 static int 1093 cmd_complete(action) 1094 int action; 1095 { 1096 char *s; 1097 1098 if (!in_completion || action == EC_EXPAND) 1099 { 1100 /* 1101 * Expand the word under the cursor and 1102 * use the first word in the expansion 1103 * (or the entire expansion if we're doing EC_EXPAND). 1104 */ 1105 init_compl(); 1106 if (tk_text == NULL) 1107 { 1108 bell(); 1109 return (CC_OK); 1110 } 1111 if (action == EC_EXPAND) 1112 { 1113 /* 1114 * Use the whole list. 1115 */ 1116 tk_trial = tk_text; 1117 } else 1118 { 1119 /* 1120 * Use the first filename in the list. 1121 */ 1122 in_completion = 1; 1123 init_textlist(&tk_tlist, tk_text); 1124 tk_trial = next_compl(action, (char*)NULL); 1125 } 1126 } else 1127 { 1128 /* 1129 * We already have a completion list. 1130 * Use the next/previous filename from the list. 1131 */ 1132 tk_trial = next_compl(action, tk_trial); 1133 } 1134 1135 /* 1136 * Remove the original word, or the previous trial completion. 1137 */ 1138 while (cp > tk_ipoint) 1139 (void) cmd_erase(); 1140 1141 if (tk_trial == NULL) 1142 { 1143 /* 1144 * There are no more trial completions. 1145 * Insert the original (uncompleted) filename. 1146 */ 1147 in_completion = 0; 1148 if (cmd_istr(tk_original) != CC_OK) 1149 goto fail; 1150 } else 1151 { 1152 /* 1153 * Insert trial completion. 1154 */ 1155 if (cmd_istr(tk_trial) != CC_OK) 1156 goto fail; 1157 /* 1158 * If it is a directory, append a slash. 1159 */ 1160 if (is_dir(tk_trial)) 1161 { 1162 if (cp > cmdbuf && cp[-1] == closequote) 1163 (void) cmd_erase(); 1164 s = lgetenv("LESSSEPARATOR"); 1165 if (s == NULL) 1166 s = PATHNAME_SEP; 1167 if (cmd_istr(s) != CC_OK) 1168 goto fail; 1169 } 1170 } 1171 1172 return (CC_OK); 1173 1174 fail: 1175 in_completion = 0; 1176 bell(); 1177 return (CC_OK); 1178 } 1179 1180 #endif /* TAB_COMPLETE_FILENAME */ 1181 1182 /* 1183 * Process a single character of a multi-character command, such as 1184 * a number, or the pattern of a search command. 1185 * Returns: 1186 * CC_OK The char was accepted. 1187 * CC_QUIT The char requests the command to be aborted. 1188 * CC_ERROR The char could not be accepted due to an error. 1189 */ 1190 public int 1191 cmd_char(c) 1192 int c; 1193 { 1194 int action; 1195 int len; 1196 1197 if (!utf_mode) 1198 { 1199 cmd_mbc_buf[0] = c; 1200 len = 1; 1201 } else 1202 { 1203 /* Perform strict validation in all possible cases. */ 1204 if (cmd_mbc_buf_len == 0) 1205 { 1206 retry: 1207 cmd_mbc_buf_index = 1; 1208 *cmd_mbc_buf = c; 1209 if (IS_ASCII_OCTET(c)) 1210 cmd_mbc_buf_len = 1; 1211 else if (IS_UTF8_LEAD(c)) 1212 { 1213 cmd_mbc_buf_len = utf_len(c); 1214 return (CC_OK); 1215 } else 1216 { 1217 /* UTF8_INVALID or stray UTF8_TRAIL */ 1218 bell(); 1219 return (CC_ERROR); 1220 } 1221 } else if (IS_UTF8_TRAIL(c)) 1222 { 1223 cmd_mbc_buf[cmd_mbc_buf_index++] = c; 1224 if (cmd_mbc_buf_index < cmd_mbc_buf_len) 1225 return (CC_OK); 1226 if (!is_utf8_well_formed(cmd_mbc_buf)) 1227 { 1228 /* complete, but not well formed (non-shortest form), sequence */ 1229 cmd_mbc_buf_len = 0; 1230 bell(); 1231 return (CC_ERROR); 1232 } 1233 } else 1234 { 1235 /* Flush incomplete (truncated) sequence. */ 1236 cmd_mbc_buf_len = 0; 1237 bell(); 1238 /* Handle new char. */ 1239 goto retry; 1240 } 1241 1242 len = cmd_mbc_buf_len; 1243 cmd_mbc_buf_len = 0; 1244 } 1245 1246 if (literal) 1247 { 1248 /* 1249 * Insert the char, even if it is a line-editing char. 1250 */ 1251 literal = 0; 1252 return (cmd_ichar(cmd_mbc_buf, len)); 1253 } 1254 1255 /* 1256 * See if it is a line-editing character. 1257 */ 1258 if (in_mca() && len == 1) 1259 { 1260 action = cmd_edit(c); 1261 switch (action) 1262 { 1263 case CC_OK: 1264 case CC_QUIT: 1265 return (action); 1266 case CC_PASS: 1267 break; 1268 } 1269 } 1270 1271 /* 1272 * Insert the char into the command buffer. 1273 */ 1274 return (cmd_ichar(cmd_mbc_buf, len)); 1275 } 1276 1277 /* 1278 * Return the number currently in the command buffer. 1279 */ 1280 public LINENUM 1281 cmd_int(frac) 1282 long *frac; 1283 { 1284 char *p; 1285 LINENUM n = 0; 1286 int err; 1287 1288 for (p = cmdbuf; *p >= '0' && *p <= '9'; p++) 1289 n = (n * 10) + (*p - '0'); 1290 *frac = 0; 1291 if (*p++ == '.') 1292 { 1293 *frac = getfraction(&p, NULL, &err); 1294 /* {{ do something if err is set? }} */ 1295 } 1296 return (n); 1297 } 1298 1299 /* 1300 * Return a pointer to the command buffer. 1301 */ 1302 public char * 1303 get_cmdbuf() 1304 { 1305 return (cmdbuf); 1306 } 1307 1308 #if CMD_HISTORY 1309 /* 1310 * Return the last (most recent) string in the current command history. 1311 */ 1312 public char * 1313 cmd_lastpattern() 1314 { 1315 if (curr_mlist == NULL) 1316 return (NULL); 1317 return (curr_mlist->curr_mp->prev->string); 1318 } 1319 #endif 1320 1321 #if CMD_HISTORY 1322 /* 1323 * Get the name of the history file. 1324 */ 1325 static char * 1326 histfile_name() 1327 { 1328 char *home; 1329 char *name; 1330 int len; 1331 1332 /* See if filename is explicitly specified by $LESSHISTFILE. */ 1333 name = lgetenv("LESSHISTFILE"); 1334 if (name != NULL && *name != '\0') 1335 { 1336 if (strcmp(name, "-") == 0 || strcmp(name, "/dev/null") == 0) 1337 /* $LESSHISTFILE == "-" means don't use a history file. */ 1338 return (NULL); 1339 return (save(name)); 1340 } 1341 1342 /* Otherwise, file is in $HOME. */ 1343 home = lgetenv("HOME"); 1344 if (home == NULL || *home == '\0') 1345 { 1346 #if OS2 1347 home = lgetenv("INIT"); 1348 if (home == NULL || *home == '\0') 1349 #endif 1350 return (NULL); 1351 } 1352 len = strlen(home) + strlen(LESSHISTFILE) + 2; 1353 name = (char *) ecalloc(len, sizeof(char)); 1354 SNPRINTF2(name, len, "%s/%s", home, LESSHISTFILE); 1355 return (name); 1356 } 1357 #endif /* CMD_HISTORY */ 1358 1359 /* 1360 * Initialize history from a .lesshist file. 1361 */ 1362 public void 1363 init_cmdhist() 1364 { 1365 #if CMD_HISTORY 1366 struct mlist *ml = NULL; 1367 char line[CMDBUF_SIZE]; 1368 char *filename; 1369 FILE *f; 1370 char *p; 1371 1372 filename = histfile_name(); 1373 if (filename == NULL) 1374 return; 1375 f = fopen(filename, "r"); 1376 free(filename); 1377 if (f == NULL) 1378 return; 1379 if (fgets(line, sizeof(line), f) == NULL || 1380 strncmp(line, HISTFILE_FIRST_LINE, strlen(HISTFILE_FIRST_LINE)) != 0) 1381 { 1382 fclose(f); 1383 return; 1384 } 1385 while (fgets(line, sizeof(line), f) != NULL) 1386 { 1387 for (p = line; *p != '\0'; p++) 1388 { 1389 if (*p == '\n' || *p == '\r') 1390 { 1391 *p = '\0'; 1392 break; 1393 } 1394 } 1395 if (strcmp(line, HISTFILE_SEARCH_SECTION) == 0) 1396 ml = &mlist_search; 1397 else if (strcmp(line, HISTFILE_SHELL_SECTION) == 0) 1398 { 1399 #if SHELL_ESCAPE || PIPEC 1400 ml = &mlist_shell; 1401 #else 1402 ml = NULL; 1403 #endif 1404 } else if (*line == '"') 1405 { 1406 if (ml != NULL) 1407 cmd_addhist(ml, line+1); 1408 } 1409 } 1410 fclose(f); 1411 #endif /* CMD_HISTORY */ 1412 } 1413 1414 /* 1415 * 1416 */ 1417 #if CMD_HISTORY 1418 static void 1419 save_mlist(ml, f) 1420 struct mlist *ml; 1421 FILE *f; 1422 { 1423 int histsize = 0; 1424 int n; 1425 char *s; 1426 1427 s = lgetenv("LESSHISTSIZE"); 1428 if (s != NULL) 1429 histsize = atoi(s); 1430 if (histsize == 0) 1431 histsize = 100; 1432 1433 ml = ml->prev; 1434 for (n = 0; n < histsize; n++) 1435 { 1436 if (ml->string == NULL) 1437 break; 1438 ml = ml->prev; 1439 } 1440 for (ml = ml->next; ml->string != NULL; ml = ml->next) 1441 fprintf(f, "\"%s\n", ml->string); 1442 } 1443 #endif /* CMD_HISTORY */ 1444 1445 /* 1446 * 1447 */ 1448 public void 1449 save_cmdhist() 1450 { 1451 #if CMD_HISTORY 1452 char *filename; 1453 FILE *f; 1454 int modified = 0; 1455 1456 filename = histfile_name(); 1457 if (filename == NULL) 1458 return; 1459 if (mlist_search.modified) 1460 modified = 1; 1461 #if SHELL_ESCAPE || PIPEC 1462 if (mlist_shell.modified) 1463 modified = 1; 1464 #endif 1465 if (!modified) 1466 return; 1467 f = fopen(filename, "w"); 1468 free(filename); 1469 if (f == NULL) 1470 return; 1471 #if HAVE_FCHMOD 1472 { 1473 /* Make history file readable only by owner. */ 1474 int do_chmod = 1; 1475 #if HAVE_STAT 1476 struct stat statbuf; 1477 int r = fstat(fileno(f), &statbuf); 1478 if (r < 0 || !S_ISREG(statbuf.st_mode)) 1479 /* Don't chmod if not a regular file. */ 1480 do_chmod = 0; 1481 #endif 1482 if (do_chmod) 1483 fchmod(fileno(f), 0600); 1484 } 1485 #endif 1486 1487 fprintf(f, "%s\n", HISTFILE_FIRST_LINE); 1488 1489 fprintf(f, "%s\n", HISTFILE_SEARCH_SECTION); 1490 save_mlist(&mlist_search, f); 1491 1492 #if SHELL_ESCAPE || PIPEC 1493 fprintf(f, "%s\n", HISTFILE_SHELL_SECTION); 1494 save_mlist(&mlist_shell, f); 1495 #endif 1496 1497 fclose(f); 1498 #endif /* CMD_HISTORY */ 1499 } 1500