2 * Copyright (C) 1984-2005 Mark Nudelman
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.
7 * For more information about less, or for information on how to
8 * contact the author, see the README file.
13 * Functions which manipulate the command buffer.
14 * Used only by command() and related functions.
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 */
34 #if TAB_COMPLETE_FILENAME
35 static int cmd_complete();
37 * These variables are statics used by cmd_complete.
39 static int in_completion = 0;
41 static char *tk_original;
42 static char *tk_ipoint;
43 static char *tk_trial;
44 static struct textlist tk_tlist;
47 static int cmd_left();
48 static int cmd_right();
50 #if SPACES_IN_FILENAMES
51 public char openquote = '"';
52 public char closequote = '"';
58 #define HISTFILE_FIRST_LINE ".less-history-file:"
59 #define HISTFILE_SEARCH_SECTION ".search"
60 #define HISTFILE_SHELL_SECTION ".shell"
63 * A mlist structure represents a command history.
69 struct mlist *curr_mp;
74 * These are the various command histories that exist.
76 struct mlist mlist_search =
77 { &mlist_search, &mlist_search, &mlist_search, NULL };
78 public void * constant ml_search = (void *) &mlist_search;
80 struct mlist mlist_examine =
81 { &mlist_examine, &mlist_examine, &mlist_examine, NULL };
82 public void * constant ml_examine = (void *) &mlist_examine;
84 #if SHELL_ESCAPE || PIPEC
85 struct mlist mlist_shell =
86 { &mlist_shell, &mlist_shell, &mlist_shell, NULL };
87 public void * constant ml_shell = (void *) &mlist_shell;
90 #else /* CMD_HISTORY */
92 /* If CMD_HISTORY is off, these are just flags. */
93 public void * constant ml_search = (void *)1;
94 public void * constant ml_examine = (void *)2;
95 #if SHELL_ESCAPE || PIPEC
96 public void * constant ml_shell = (void *)3;
99 #endif /* CMD_HISTORY */
102 * History for the current command.
104 static struct mlist *curr_mlist = NULL;
105 static int curr_cmdflags;
107 static char cmd_mbc_buf[MAX_UTF_CHAR_LEN];
108 static int cmd_mbc_buf_len;
109 static int cmd_mbc_buf_index;
113 * Reset command buffer (to empty).
127 * Clear command line on display.
133 cmd_col = prompt_col = 0;
138 * Display a string, usually as a prompt for input into the command buffer.
146 char *endline = s + strlen(s);
150 ch = step_char(&ns, +1, endline);
157 } else if (!is_composing_char(ch) &&
158 !is_combining_char(prev_ch, ch))
160 int width = is_wide_char(ch) ? 2 : 1;
169 * How many characters are in the command buffer?
175 char *endline = s + strlen(s);
180 step_char(&s, +1, endline);
187 * Common part of cmd_step_right() and cmd_step_left().
190 cmd_step_common(p, ch, len, pwidth, bswidth)
201 pr = prchar((int) ch);
202 if (pwidth != NULL || bswidth != NULL)
204 int len = strlen(pr);
213 if (pwidth != NULL || bswidth != NULL)
215 if (is_composing_char(ch))
221 } else if (is_ubin_char(ch))
223 int len = strlen(pr);
230 LWCHAR prev_ch = step_char(&p, -1, cmdbuf);
231 if (is_combining_char(prev_ch, ch))
240 *pwidth = is_wide_char(ch)
254 * Step a pointer one character right in the command buffer.
257 cmd_step_right(pp, pwidth, bswidth)
263 LWCHAR ch = step_char(pp, +1, p + strlen(p));
265 return cmd_step_common(p, ch, *pp - p, pwidth, bswidth);
269 * Step a pointer one character left in the command buffer.
272 cmd_step_left(pp, pwidth, bswidth)
278 LWCHAR ch = step_char(pp, -1, cmdbuf);
280 return cmd_step_common(*pp, ch, p - *pp, pwidth, bswidth);
284 * Repaint the line from cp onwards.
285 * Then position the cursor just after the char old_cp (a pointer into cmdbuf).
292 * Repaint the line from the current position.
299 char *pr = cmd_step_right(&np, &width, NULL);
300 if (cmd_col + width >= sc_width)
310 char *pr = cmd_step_right(&np, &width, NULL);
318 * Back up the cursor to the correct position.
325 * Put the cursor at "home" (just after the prompt),
326 * and set cp to the corresponding char in cmdbuf.
331 while (cmd_col > prompt_col)
335 cmd_step_left(&cp, &width, &bswidth);
336 while (bswidth-- > 0)
341 cp = &cmdbuf[cmd_offset];
345 * Shift the cmdbuf display left a half-screen.
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.
358 s = cmdbuf + cmd_offset;
360 while (cols < (sc_width - prompt_col) / 2 && *s != '\0')
363 cmd_step_right(&s, &width, NULL);
370 cmd_step_right(&ns, &width, NULL);
376 cmd_offset = s - cmdbuf;
379 cmd_repaint(save_cp);
383 * Shift the cmdbuf display right a half-screen.
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.
397 s = cmdbuf + cmd_offset;
399 while (cols < (sc_width - prompt_col) / 2 && s > cmdbuf)
402 cmd_step_left(&s, &width, NULL);
406 cmd_offset = s - cmdbuf;
409 cmd_repaint(save_cp);
413 * Move cursor right one character.
424 /* Already at the end of the line. */
428 pr = cmd_step_right(&ncp, &width, NULL);
429 if (cmd_col + width >= sc_width)
431 else if (cmd_col + width == sc_width - 1 && cp[1] != '\0')
438 pr = cmd_step_right(&ncp, &width, NULL);
448 * Move cursor left one character.
458 /* Already at the beginning of the line */
464 cmd_step_left(&ncp, &width, &bswidth);
468 if (cmd_col < prompt_col + width)
472 while (bswidth-- > 0)
478 * Insert a char into the command buffer, at the current position.
487 if (strlen(cmdbuf) + clen >= sizeof(cmdbuf)-1)
489 /* No room in the command buffer for another char. */
495 * Make room for the new character (shift the tail of the buffer right).
497 for (s = &cmdbuf[strlen(cmdbuf)]; s >= cp; s--)
500 * Insert the character into the buffer.
502 for (s = cp; s < cp + clen; s++)
505 * Reprint the tail of the line from the inserted char.
513 * Backspace in the command buffer.
514 * Delete the char to the left of the cursor.
525 * Backspace past beginning of the buffer:
526 * this usually means abort the command.
531 * Move cursor left (to the char being erased).
538 * Remove the char from the buffer (shift the buffer left).
548 * Repaint the buffer after the erased char.
553 * We say that erasing the entire command string causes us
554 * to abort the current command, if CF_QUIT_ON_ERASE is set.
556 if ((curr_cmdflags & CF_QUIT_ON_ERASE) && cp == cmdbuf && *cp == '\0')
562 * Delete the char under the cursor.
569 /* At end of string; there is no char under the cursor. */
573 * Move right, then use cmd_erase.
581 * Delete the "word" to the left of the cursor.
586 if (cp > cmdbuf && cp[-1] == ' ')
589 * If the char left of cursor is a space,
590 * erase all the spaces left of cursor (to the first non-space).
592 while (cp > cmdbuf && cp[-1] == ' ')
597 * If the char left of cursor is not a space,
598 * erase all the nonspaces left of cursor (the whole "word").
600 while (cp > cmdbuf && cp[-1] != ' ')
607 * Delete the "word" under the cursor.
615 * If the char under the cursor is a space,
616 * delete it and all the spaces right of cursor.
623 * If the char under the cursor is not a space,
624 * delete it and all nonspaces right of cursor (the whole word).
626 while (*cp != ' ' && *cp != '\0')
633 * Delete all chars in the command buffer.
638 if (cmdbuf[0] == '\0')
640 /* Buffer is already empty; abort the current command. */
649 * We say that erasing the entire command string causes us
650 * to abort the current command, if CF_QUIT_ON_ERASE is set.
652 if (curr_cmdflags & CF_QUIT_ON_ERASE)
658 * Select an mlist structure to be the current command history.
661 set_mlist(mlist, cmdflags)
665 curr_mlist = (struct mlist *) mlist;
666 curr_cmdflags = cmdflags;
668 /* Make sure the next up-arrow moves to the last string in the mlist. */
669 if (curr_mlist != NULL)
670 curr_mlist->curr_mp = curr_mlist;
675 * Move up or down in the currently selected command history list.
683 if (curr_mlist == NULL)
686 * The current command has no history list.
694 * Move curr_mp to the next/prev entry.
697 curr_mlist->curr_mp = curr_mlist->curr_mp->prev;
699 curr_mlist->curr_mp = curr_mlist->curr_mp->next;
701 * Copy the entry into cmdbuf and echo it on the screen.
703 s = curr_mlist->curr_mp->string;
707 for (cp = cmdbuf; *cp != '\0'; )
714 * Add a string to a history list.
717 cmd_addhist(mlist, cmd)
725 * Don't save a trivial command.
727 if (strlen(cmd) == 0)
731 * Save the command unless it's a duplicate of the
732 * last command in the history.
735 if (ml == mlist || strcmp(ml->string, cmd) != 0)
738 * Did not find command in history.
739 * Save the command and put it at the end of the history list.
741 ml = (struct mlist *) ecalloc(1, sizeof(struct mlist));
742 ml->string = save(cmd);
744 ml->prev = mlist->prev;
745 mlist->prev->next = ml;
749 * Point to the cmd just after the just-accepted command.
750 * Thus, an UPARROW will always retrieve the previous command.
752 mlist->curr_mp = ml->next;
757 * Accept the command in the command buffer.
758 * Add it to the currently selected history list.
765 * Nothing to do if there is no currently selected history list.
767 if (curr_mlist == NULL)
769 cmd_addhist(curr_mlist, cmdbuf);
774 * Try to perform a line-edit function on the command buffer,
775 * using a specified char as a line-editing command.
777 * CC_PASS The char does not invoke a line edit function.
778 * CC_OK Line edit function done.
779 * CC_QUIT The char requests the current command to be aborted.
788 #if TAB_COMPLETE_FILENAME
789 #define not_in_completion() in_completion = 0
791 #define not_in_completion()
795 * See if the char is indeed a line-editing command.
799 if (curr_mlist == NULL)
801 * No current history; don't accept history manipulation cmds.
803 flags |= EC_NOHISTORY;
805 #if TAB_COMPLETE_FILENAME
806 if (curr_mlist == ml_search)
808 * In a search command; don't accept file-completion cmds.
810 flags |= EC_NOCOMPLETE;
813 action = editchar(c, flags);
819 return (cmd_right());
825 while (*cp != '\0' && *cp != ' ')
832 while (cp > cmdbuf && cp[-1] == ' ')
834 while (cp > cmdbuf && cp[-1] != ' ')
853 return (cmd_erase());
859 return (cmd_werase());
862 return (cmd_delete());
865 return (cmd_wdelete());
873 return (cmd_updown(action));
875 #if TAB_COMPLETE_FILENAME
879 return (cmd_complete(action));
889 #if TAB_COMPLETE_FILENAME
891 * Insert a string into the command buffer, at the current position.
899 char *endline = str + strlen(str);
901 for (s = str; *s != '\0'; )
904 step_char(&s, +1, endline);
905 action = cmd_ichar(os, s - os);
916 * Find the beginning and end of the "current" word.
917 * This is the word which the cursor (cp) is inside or at the end of.
918 * Return pointer to the beginning of the word and put the
919 * cursor at the end of the word.
925 #if SPACES_IN_FILENAMES
927 int delim_quoted = 0;
929 char *esc = get_meta_escape();
930 int esclen = strlen(esc);
934 * Move cursor to end of word.
936 if (*cp != ' ' && *cp != '\0')
939 * Cursor is on a nonspace.
940 * Move cursor right to the next space.
942 while (*cp != ' ' && *cp != '\0')
944 } else if (cp > cmdbuf && cp[-1] != ' ')
947 * Cursor is on a space, and char to the left is a nonspace.
948 * We're already at the end of the word.
955 * Cursor is on a space and char to the left is a space.
956 * Huh? There's no word here.
962 * Find the beginning of the word which the cursor is in.
966 #if SPACES_IN_FILENAMES
968 * If we have an unbalanced quote (that is, an open quote
969 * without a corresponding close quote), we return everything
970 * from the open quote, including spaces.
972 for (word = cmdbuf; word < cp; word++)
977 for (p = cmdbuf; p < cp; p++)
982 } else if (esclen > 0 && p + esclen < cp &&
983 strncmp(p, esc, esclen) == 0)
987 } else if (delim_quoted)
989 if (*p == closequote)
991 } else /* (!delim_quoted) */
1004 * Set things up to enter completion mode.
1005 * Expand the word under the cursor into a list of filenames
1006 * which start with that word, and set tk_text to that list.
1015 * Get rid of any previous tk_text.
1017 if (tk_text != NULL)
1023 * Find the original (uncompleted) word in the command buffer.
1025 word = delimit_word();
1029 * Set the insertion point to the point in the command buffer
1030 * where the original (uncompleted) word now sits.
1034 * Save the original (uncompleted) word
1036 if (tk_original != NULL)
1038 tk_original = (char *) ecalloc(cp-word+1, sizeof(char));
1039 strncpy(tk_original, word, cp-word);
1041 * Get the expanded filename.
1042 * This may result in a single filename, or
1043 * a blank-separated list of filenames.
1047 if (*word != openquote)
1049 tk_text = fcomplete(word);
1052 char *qword = shell_quote(word+1);
1054 tk_text = fcomplete(word+1);
1057 tk_text = fcomplete(qword);
1065 * Return the next word in the current completion list.
1068 next_compl(action, prev)
1075 return (forw_textlist(&tk_tlist, prev));
1077 return (back_textlist(&tk_tlist, prev));
1084 * Complete the filename before (or under) the cursor.
1085 * cmd_complete may be called multiple times. The global in_completion
1086 * remembers whether this call is the first time (create the list),
1087 * or a subsequent time (step thru the list).
1090 cmd_complete(action)
1095 if (!in_completion || action == EC_EXPAND)
1098 * Expand the word under the cursor and
1099 * use the first word in the expansion
1100 * (or the entire expansion if we're doing EC_EXPAND).
1103 if (tk_text == NULL)
1108 if (action == EC_EXPAND)
1111 * Use the whole list.
1117 * Use the first filename in the list.
1120 init_textlist(&tk_tlist, tk_text);
1121 tk_trial = next_compl(action, (char*)NULL);
1126 * We already have a completion list.
1127 * Use the next/previous filename from the list.
1129 tk_trial = next_compl(action, tk_trial);
1133 * Remove the original word, or the previous trial completion.
1135 while (cp > tk_ipoint)
1138 if (tk_trial == NULL)
1141 * There are no more trial completions.
1142 * Insert the original (uncompleted) filename.
1145 if (cmd_istr(tk_original) != CC_OK)
1150 * Insert trial completion.
1152 if (cmd_istr(tk_trial) != CC_OK)
1155 * If it is a directory, append a slash.
1157 if (is_dir(tk_trial))
1159 if (cp > cmdbuf && cp[-1] == closequote)
1161 s = lgetenv("LESSSEPARATOR");
1164 if (cmd_istr(s) != CC_OK)
1177 #endif /* TAB_COMPLETE_FILENAME */
1180 * Process a single character of a multi-character command, such as
1181 * a number, or the pattern of a search command.
1183 * CC_OK The char was accepted.
1184 * CC_QUIT The char requests the command to be aborted.
1185 * CC_ERROR The char could not be accepted due to an error.
1200 /* Perform strict validation in all possible cases. */
1201 if (cmd_mbc_buf_len == 0)
1204 cmd_mbc_buf_index = 1;
1206 if (IS_ASCII_OCTET(c))
1207 cmd_mbc_buf_len = 1;
1208 else if (IS_UTF8_LEAD(c))
1210 cmd_mbc_buf_len = utf_len(c);
1214 /* UTF8_INVALID or stray UTF8_TRAIL */
1218 } else if (IS_UTF8_TRAIL(c))
1220 cmd_mbc_buf[cmd_mbc_buf_index++] = c;
1221 if (cmd_mbc_buf_index < cmd_mbc_buf_len)
1223 if (!is_utf8_well_formed(cmd_mbc_buf))
1225 /* complete, but not well formed (non-shortest form), sequence */
1226 cmd_mbc_buf_len = 0;
1232 /* Flush incomplete (truncated) sequence. */
1233 cmd_mbc_buf_len = 0;
1235 /* Handle new char. */
1239 len = cmd_mbc_buf_len;
1240 cmd_mbc_buf_len = 0;
1246 * Insert the char, even if it is a line-editing char.
1249 return (cmd_ichar(cmd_mbc_buf, len));
1253 * See if it is a line-editing character.
1255 if (in_mca() && len == 1)
1257 action = cmd_edit(c);
1269 * Insert the char into the command buffer.
1271 return (cmd_ichar(cmd_mbc_buf, len));
1275 * Return the number currently in the command buffer.
1283 for (p = cmdbuf; *p != '\0'; p++)
1284 n = (10 * n) + (*p - '0');
1289 * Return a pointer to the command buffer.
1299 * Get the name of the history file.
1308 /* See if filename is explicitly specified by $LESSHISTFILE. */
1309 name = lgetenv("LESSHISTFILE");
1310 if (name != NULL && *name != '\0')
1312 if (strcmp(name, "-") == 0)
1313 /* $LESSHISTFILE == "-" means don't use a history file. */
1315 return (save(name));
1318 /* Otherwise, file is in $HOME. */
1319 home = lgetenv("HOME");
1320 if (home == NULL || *home == '\0')
1323 home = lgetenv("INIT");
1324 if (home == NULL || *home == '\0')
1328 len = strlen(home) + strlen(LESSHISTFILE) + 2;
1329 name = (char *) ecalloc(len, sizeof(char));
1330 SNPRINTF2(name, len, "%s/%s", home, LESSHISTFILE);
1333 #endif /* CMD_HISTORY */
1336 * Initialize history from a .lesshist file.
1342 struct mlist *ml = NULL;
1343 char line[CMDBUF_SIZE];
1348 filename = histfile_name();
1349 if (filename == NULL)
1351 f = fopen(filename, "r");
1355 if (fgets(line, sizeof(line), f) == NULL ||
1356 strncmp(line, HISTFILE_FIRST_LINE, strlen(HISTFILE_FIRST_LINE)) != 0)
1361 while (fgets(line, sizeof(line), f) != NULL)
1363 for (p = line; *p != '\0'; p++)
1365 if (*p == '\n' || *p == '\r')
1371 if (strcmp(line, HISTFILE_SEARCH_SECTION) == 0)
1373 #if SHELL_ESCAPE || PIPEC
1374 else if (strcmp(line, HISTFILE_SHELL_SECTION) == 0)
1377 else if (*line == '"')
1380 cmd_addhist(ml, line+1);
1384 #endif /* CMD_HISTORY */
1400 s = lgetenv("LESSHISTSIZE");
1407 for (n = 0; n < histsize; n++)
1409 if (ml->string == NULL)
1413 for (ml = ml->next; ml->string != NULL; ml = ml->next)
1414 fprintf(f, "\"%s\n", ml->string);
1416 #endif /* CMD_HISTORY */
1428 filename = histfile_name();
1429 if (filename == NULL)
1431 f = fopen(filename, "w");
1436 /* Make history file readable only by owner. */
1437 fchmod(fileno(f), 0600);
1440 fprintf(f, "%s\n", HISTFILE_FIRST_LINE);
1442 fprintf(f, "%s\n", HISTFILE_SEARCH_SECTION);
1443 save_mlist(&mlist_search, f);
1445 #if SHELL_ESCAPE || PIPEC
1446 fprintf(f, "%s\n", HISTFILE_SHELL_SECTION);
1447 save_mlist(&mlist_shell, f);
1451 #endif /* CMD_HISTORY */