2 * Copyright (C) 1984-2012 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, see the README file.
12 * Functions which manipulate the command buffer.
13 * Used only by command() and related functions.
26 static char cmdbuf[CMDBUF_SIZE]; /* Buffer for holding a multi-char command */
27 static int cmd_col; /* Current column of the cursor */
28 static int prompt_col; /* Column of cursor just after prompt */
29 static char *cp; /* Pointer into cmdbuf */
30 static int cmd_offset; /* Index into cmdbuf of first displayed char */
31 static int literal; /* Next input char should not be interpreted */
32 static int updown_match = -1; /* Prefix length in up/down movement */
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;
75 * These are the various command histories that exist.
77 struct mlist mlist_search =
78 { &mlist_search, &mlist_search, &mlist_search, NULL, 0 };
79 public void * constant ml_search = (void *) &mlist_search;
81 struct mlist mlist_examine =
82 { &mlist_examine, &mlist_examine, &mlist_examine, NULL, 0 };
83 public void * constant ml_examine = (void *) &mlist_examine;
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;
91 #else /* CMD_HISTORY */
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;
100 #endif /* CMD_HISTORY */
103 * History for the current command.
105 static struct mlist *curr_mlist = NULL;
106 static int curr_cmdflags;
108 static char cmd_mbc_buf[MAX_UTF_CHAR_LEN];
109 static int cmd_mbc_buf_len;
110 static int cmd_mbc_buf_index;
114 * Reset command buffer (to empty).
129 * Clear command line.
134 cmd_col = prompt_col = 0;
140 * Display a string, usually as a prompt for input into the command buffer.
148 char *endline = s + strlen(s);
152 ch = step_char(&ns, +1, endline);
159 } else if (!is_composing_char(ch) &&
160 !is_combining_char(prev_ch, ch))
162 int width = is_wide_char(ch) ? 2 : 1;
171 * How many characters are in the command buffer?
177 char *endline = s + strlen(s);
182 step_char(&s, +1, endline);
189 * Common part of cmd_step_right() and cmd_step_left().
192 cmd_step_common(p, ch, len, pwidth, bswidth)
203 pr = prchar((int) ch);
204 if (pwidth != NULL || bswidth != NULL)
206 int len = strlen(pr);
215 if (pwidth != NULL || bswidth != NULL)
217 if (is_composing_char(ch))
223 } else if (is_ubin_char(ch))
225 int len = strlen(pr);
232 LWCHAR prev_ch = step_char(&p, -1, cmdbuf);
233 if (is_combining_char(prev_ch, ch))
242 *pwidth = is_wide_char(ch)
256 * Step a pointer one character right in the command buffer.
259 cmd_step_right(pp, pwidth, bswidth)
265 LWCHAR ch = step_char(pp, +1, p + strlen(p));
267 return cmd_step_common(p, ch, *pp - p, pwidth, bswidth);
271 * Step a pointer one character left in the command buffer.
274 cmd_step_left(pp, pwidth, bswidth)
280 LWCHAR ch = step_char(pp, -1, cmdbuf);
282 return cmd_step_common(*pp, ch, p - *pp, pwidth, bswidth);
286 * Repaint the line from cp onwards.
287 * Then position the cursor just after the char old_cp (a pointer into cmdbuf).
294 * Repaint the line from the current position.
301 char *pr = cmd_step_right(&np, &width, NULL);
302 if (cmd_col + width >= sc_width)
312 char *pr = cmd_step_right(&np, &width, NULL);
320 * Back up the cursor to the correct position.
327 * Put the cursor at "home" (just after the prompt),
328 * and set cp to the corresponding char in cmdbuf.
333 while (cmd_col > prompt_col)
337 cmd_step_left(&cp, &width, &bswidth);
338 while (bswidth-- > 0)
343 cp = &cmdbuf[cmd_offset];
347 * Shift the cmdbuf display left a half-screen.
357 * Start at the first displayed char, count how far to the
358 * right we'd have to move to reach the center of the screen.
360 s = cmdbuf + cmd_offset;
362 while (cols < (sc_width - prompt_col) / 2 && *s != '\0')
365 cmd_step_right(&s, &width, NULL);
372 cmd_step_right(&ns, &width, NULL);
378 cmd_offset = s - cmdbuf;
381 cmd_repaint(save_cp);
385 * Shift the cmdbuf display right a half-screen.
395 * Start at the first displayed char, count how far to the
396 * left we'd have to move to traverse a half-screen width
397 * of displayed characters.
399 s = cmdbuf + cmd_offset;
401 while (cols < (sc_width - prompt_col) / 2 && s > cmdbuf)
404 cmd_step_left(&s, &width, NULL);
408 cmd_offset = s - cmdbuf;
411 cmd_repaint(save_cp);
415 * Move cursor right one character.
426 /* Already at the end of the line. */
430 pr = cmd_step_right(&ncp, &width, NULL);
431 if (cmd_col + width >= sc_width)
433 else if (cmd_col + width == sc_width - 1 && cp[1] != '\0')
440 pr = cmd_step_right(&ncp, &width, NULL);
450 * Move cursor left one character.
460 /* Already at the beginning of the line */
466 cmd_step_left(&ncp, &width, &bswidth);
470 if (cmd_col < prompt_col + width)
474 while (bswidth-- > 0)
480 * Insert a char into the command buffer, at the current position.
489 if (strlen(cmdbuf) + clen >= sizeof(cmdbuf)-1)
491 /* No room in the command buffer for another char. */
497 * Make room for the new character (shift the tail of the buffer right).
499 for (s = &cmdbuf[strlen(cmdbuf)]; s >= cp; s--)
502 * Insert the character into the buffer.
504 for (s = cp; s < cp + clen; s++)
507 * Reprint the tail of the line from the inserted char.
516 * Backspace in the command buffer.
517 * Delete the char to the left of the cursor.
528 * Backspace past beginning of the buffer:
529 * this usually means abort the command.
534 * Move cursor left (to the char being erased).
541 * Remove the char from the buffer (shift the buffer left).
551 * Repaint the buffer after the erased char.
557 * We say that erasing the entire command string causes us
558 * to abort the current command, if CF_QUIT_ON_ERASE is set.
560 if ((curr_cmdflags & CF_QUIT_ON_ERASE) && cp == cmdbuf && *cp == '\0')
566 * Delete the char under the cursor.
573 /* At end of string; there is no char under the cursor. */
577 * Move right, then use cmd_erase.
585 * Delete the "word" to the left of the cursor.
590 if (cp > cmdbuf && cp[-1] == ' ')
593 * If the char left of cursor is a space,
594 * erase all the spaces left of cursor (to the first non-space).
596 while (cp > cmdbuf && cp[-1] == ' ')
601 * If the char left of cursor is not a space,
602 * erase all the nonspaces left of cursor (the whole "word").
604 while (cp > cmdbuf && cp[-1] != ' ')
611 * Delete the "word" under the cursor.
619 * If the char under the cursor is a space,
620 * delete it and all the spaces right of cursor.
627 * If the char under the cursor is not a space,
628 * delete it and all nonspaces right of cursor (the whole word).
630 while (*cp != ' ' && *cp != '\0')
637 * Delete all chars in the command buffer.
642 if (cmdbuf[0] == '\0')
644 /* Buffer is already empty; abort the current command. */
654 * We say that erasing the entire command string causes us
655 * to abort the current command, if CF_QUIT_ON_ERASE is set.
657 if (curr_cmdflags & CF_QUIT_ON_ERASE)
663 * Select an mlist structure to be the current command history.
666 set_mlist(mlist, cmdflags)
671 curr_mlist = (struct mlist *) mlist;
672 curr_cmdflags = cmdflags;
674 /* Make sure the next up-arrow moves to the last string in the mlist. */
675 if (curr_mlist != NULL)
676 curr_mlist->curr_mp = curr_mlist;
682 * Move up or down in the currently selected command history list.
683 * Only consider entries whose first updown_match chars are equal to
684 * cmdbuf's corresponding chars.
693 if (curr_mlist == NULL)
696 * The current command has no history list.
702 if (updown_match < 0)
704 updown_match = cp - cmdbuf;
708 * Find the next history entry which matches.
710 for (ml = curr_mlist->curr_mp;;)
712 ml = (action == EC_UP) ? ml->prev : ml->next;
713 if (ml == curr_mlist)
716 * We reached the end (or beginning) of the list.
720 if (strncmp(cmdbuf, ml->string, updown_match) == 0)
723 * This entry matches; stop here.
724 * Copy the entry into cmdbuf and echo it on the screen.
726 curr_mlist->curr_mp = ml;
733 for (cp = cmdbuf; *cp != '\0'; )
739 * We didn't find a history entry that matches.
747 * Add a string to a history list.
750 cmd_addhist(mlist, cmd)
758 * Don't save a trivial command.
760 if (strlen(cmd) == 0)
764 * Save the command unless it's a duplicate of the
765 * last command in the history.
768 if (ml == mlist || strcmp(ml->string, cmd) != 0)
771 * Did not find command in history.
772 * Save the command and put it at the end of the history list.
774 ml = (struct mlist *) ecalloc(1, sizeof(struct mlist));
775 ml->string = save(cmd);
777 ml->prev = mlist->prev;
778 mlist->prev->next = ml;
782 * Point to the cmd just after the just-accepted command.
783 * Thus, an UPARROW will always retrieve the previous command.
785 mlist->curr_mp = ml->next;
790 * Accept the command in the command buffer.
791 * Add it to the currently selected history list.
798 * Nothing to do if there is no currently selected history list.
800 if (curr_mlist == NULL)
802 cmd_addhist(curr_mlist, cmdbuf);
803 curr_mlist->modified = 1;
808 * Try to perform a line-edit function on the command buffer,
809 * using a specified char as a line-editing command.
811 * CC_PASS The char does not invoke a line edit function.
812 * CC_OK Line edit function done.
813 * CC_QUIT The char requests the current command to be aborted.
822 #if TAB_COMPLETE_FILENAME
823 #define not_in_completion() in_completion = 0
825 #define not_in_completion()
829 * See if the char is indeed a line-editing command.
833 if (curr_mlist == NULL)
835 * No current history; don't accept history manipulation cmds.
837 flags |= EC_NOHISTORY;
839 #if TAB_COMPLETE_FILENAME
840 if (curr_mlist == ml_search)
842 * In a search command; don't accept file-completion cmds.
844 flags |= EC_NOCOMPLETE;
847 action = editchar(c, flags);
853 return (cmd_right());
859 while (*cp != '\0' && *cp != ' ')
866 while (cp > cmdbuf && cp[-1] == ' ')
868 while (cp > cmdbuf && cp[-1] != ' ')
887 return (cmd_erase());
897 return (cmd_werase());
900 return (cmd_delete());
903 return (cmd_wdelete());
911 return (cmd_updown(action));
913 #if TAB_COMPLETE_FILENAME
917 return (cmd_complete(action));
927 #if TAB_COMPLETE_FILENAME
929 * Insert a string into the command buffer, at the current position.
937 char *endline = str + strlen(str);
939 for (s = str; *s != '\0'; )
942 step_char(&s, +1, endline);
943 action = cmd_ichar(os, s - os);
954 * Find the beginning and end of the "current" word.
955 * This is the word which the cursor (cp) is inside or at the end of.
956 * Return pointer to the beginning of the word and put the
957 * cursor at the end of the word.
963 #if SPACES_IN_FILENAMES
965 int delim_quoted = 0;
967 char *esc = get_meta_escape();
968 int esclen = strlen(esc);
972 * Move cursor to end of word.
974 if (*cp != ' ' && *cp != '\0')
977 * Cursor is on a nonspace.
978 * Move cursor right to the next space.
980 while (*cp != ' ' && *cp != '\0')
982 } else if (cp > cmdbuf && cp[-1] != ' ')
985 * Cursor is on a space, and char to the left is a nonspace.
986 * We're already at the end of the word.
993 * Cursor is on a space and char to the left is a space.
994 * Huh? There's no word here.
1000 * Find the beginning of the word which the cursor is in.
1004 #if SPACES_IN_FILENAMES
1006 * If we have an unbalanced quote (that is, an open quote
1007 * without a corresponding close quote), we return everything
1008 * from the open quote, including spaces.
1010 for (word = cmdbuf; word < cp; word++)
1015 for (p = cmdbuf; p < cp; p++)
1020 } else if (esclen > 0 && p + esclen < cp &&
1021 strncmp(p, esc, esclen) == 0)
1025 } else if (delim_quoted)
1027 if (*p == closequote)
1029 } else /* (!delim_quoted) */
1031 if (*p == openquote)
1042 * Set things up to enter completion mode.
1043 * Expand the word under the cursor into a list of filenames
1044 * which start with that word, and set tk_text to that list.
1053 * Get rid of any previous tk_text.
1055 if (tk_text != NULL)
1061 * Find the original (uncompleted) word in the command buffer.
1063 word = delimit_word();
1067 * Set the insertion point to the point in the command buffer
1068 * where the original (uncompleted) word now sits.
1072 * Save the original (uncompleted) word
1074 if (tk_original != NULL)
1076 tk_original = (char *) ecalloc(cp-word+1, sizeof(char));
1077 strncpy(tk_original, word, cp-word);
1079 * Get the expanded filename.
1080 * This may result in a single filename, or
1081 * a blank-separated list of filenames.
1085 if (*word != openquote)
1087 tk_text = fcomplete(word);
1093 char *qword = shell_quote(word+1);
1096 tk_text = fcomplete(word+1);
1099 tk_text = fcomplete(qword);
1107 * Return the next word in the current completion list.
1110 next_compl(action, prev)
1117 return (forw_textlist(&tk_tlist, prev));
1119 return (back_textlist(&tk_tlist, prev));
1126 * Complete the filename before (or under) the cursor.
1127 * cmd_complete may be called multiple times. The global in_completion
1128 * remembers whether this call is the first time (create the list),
1129 * or a subsequent time (step thru the list).
1132 cmd_complete(action)
1137 if (!in_completion || action == EC_EXPAND)
1140 * Expand the word under the cursor and
1141 * use the first word in the expansion
1142 * (or the entire expansion if we're doing EC_EXPAND).
1145 if (tk_text == NULL)
1150 if (action == EC_EXPAND)
1153 * Use the whole list.
1159 * Use the first filename in the list.
1162 init_textlist(&tk_tlist, tk_text);
1163 tk_trial = next_compl(action, (char*)NULL);
1168 * We already have a completion list.
1169 * Use the next/previous filename from the list.
1171 tk_trial = next_compl(action, tk_trial);
1175 * Remove the original word, or the previous trial completion.
1177 while (cp > tk_ipoint)
1180 if (tk_trial == NULL)
1183 * There are no more trial completions.
1184 * Insert the original (uncompleted) filename.
1187 if (cmd_istr(tk_original) != CC_OK)
1192 * Insert trial completion.
1194 if (cmd_istr(tk_trial) != CC_OK)
1197 * If it is a directory, append a slash.
1199 if (is_dir(tk_trial))
1201 if (cp > cmdbuf && cp[-1] == closequote)
1203 s = lgetenv("LESSSEPARATOR");
1206 if (cmd_istr(s) != CC_OK)
1219 #endif /* TAB_COMPLETE_FILENAME */
1222 * Process a single character of a multi-character command, such as
1223 * a number, or the pattern of a search command.
1225 * CC_OK The char was accepted.
1226 * CC_QUIT The char requests the command to be aborted.
1227 * CC_ERROR The char could not be accepted due to an error.
1242 /* Perform strict validation in all possible cases. */
1243 if (cmd_mbc_buf_len == 0)
1246 cmd_mbc_buf_index = 1;
1248 if (IS_ASCII_OCTET(c))
1249 cmd_mbc_buf_len = 1;
1250 else if (IS_UTF8_LEAD(c))
1252 cmd_mbc_buf_len = utf_len(c);
1256 /* UTF8_INVALID or stray UTF8_TRAIL */
1260 } else if (IS_UTF8_TRAIL(c))
1262 cmd_mbc_buf[cmd_mbc_buf_index++] = c;
1263 if (cmd_mbc_buf_index < cmd_mbc_buf_len)
1265 if (!is_utf8_well_formed(cmd_mbc_buf))
1267 /* complete, but not well formed (non-shortest form), sequence */
1268 cmd_mbc_buf_len = 0;
1274 /* Flush incomplete (truncated) sequence. */
1275 cmd_mbc_buf_len = 0;
1277 /* Handle new char. */
1281 len = cmd_mbc_buf_len;
1282 cmd_mbc_buf_len = 0;
1288 * Insert the char, even if it is a line-editing char.
1291 return (cmd_ichar(cmd_mbc_buf, len));
1295 * See if it is a line-editing character.
1297 if (in_mca() && len == 1)
1299 action = cmd_edit(c);
1311 * Insert the char into the command buffer.
1313 return (cmd_ichar(cmd_mbc_buf, len));
1317 * Return the number currently in the command buffer.
1327 for (p = cmdbuf; *p >= '0' && *p <= '9'; p++)
1328 n = (n * 10) + (*p - '0');
1332 *frac = getfraction(&p, NULL, &err);
1333 /* {{ do something if err is set? }} */
1339 * Return a pointer to the command buffer.
1349 * Return the last (most recent) string in the current command history.
1354 if (curr_mlist == NULL)
1356 return (curr_mlist->curr_mp->prev->string);
1362 * Get the name of the history file.
1371 /* See if filename is explicitly specified by $LESSHISTFILE. */
1372 name = lgetenv("LESSHISTFILE");
1373 if (name != NULL && *name != '\0')
1375 if (strcmp(name, "-") == 0 || strcmp(name, "/dev/null") == 0)
1376 /* $LESSHISTFILE == "-" means don't use a history file. */
1378 return (save(name));
1381 /* Otherwise, file is in $HOME. */
1382 home = lgetenv("HOME");
1383 if (home == NULL || *home == '\0')
1386 home = lgetenv("INIT");
1387 if (home == NULL || *home == '\0')
1391 len = strlen(home) + strlen(LESSHISTFILE) + 2;
1392 name = (char *) ecalloc(len, sizeof(char));
1393 SNPRINTF2(name, len, "%s/%s", home, LESSHISTFILE);
1396 #endif /* CMD_HISTORY */
1399 * Initialize history from a .lesshist file.
1405 struct mlist *ml = NULL;
1406 char line[CMDBUF_SIZE];
1411 filename = histfile_name();
1412 if (filename == NULL)
1414 f = fopen(filename, "r");
1418 if (fgets(line, sizeof(line), f) == NULL ||
1419 strncmp(line, HISTFILE_FIRST_LINE, strlen(HISTFILE_FIRST_LINE)) != 0)
1424 while (fgets(line, sizeof(line), f) != NULL)
1426 for (p = line; *p != '\0'; p++)
1428 if (*p == '\n' || *p == '\r')
1434 if (strcmp(line, HISTFILE_SEARCH_SECTION) == 0)
1436 else if (strcmp(line, HISTFILE_SHELL_SECTION) == 0)
1438 #if SHELL_ESCAPE || PIPEC
1443 } else if (*line == '"')
1446 cmd_addhist(ml, line+1);
1450 #endif /* CMD_HISTORY */
1466 s = lgetenv("LESSHISTSIZE");
1473 for (n = 0; n < histsize; n++)
1475 if (ml->string == NULL)
1479 for (ml = ml->next; ml->string != NULL; ml = ml->next)
1480 fprintf(f, "\"%s\n", ml->string);
1482 #endif /* CMD_HISTORY */
1495 if (mlist_search.modified)
1497 #if SHELL_ESCAPE || PIPEC
1498 if (mlist_shell.modified)
1503 filename = histfile_name();
1504 if (filename == NULL)
1506 f = fopen(filename, "w");
1512 /* Make history file readable only by owner. */
1515 struct stat statbuf;
1516 int r = fstat(fileno(f), &statbuf);
1517 if (r < 0 || !S_ISREG(statbuf.st_mode))
1518 /* Don't chmod if not a regular file. */
1522 fchmod(fileno(f), 0600);
1526 fprintf(f, "%s\n", HISTFILE_FIRST_LINE);
1528 fprintf(f, "%s\n", HISTFILE_SEARCH_SECTION);
1529 save_mlist(&mlist_search, f);
1531 #if SHELL_ESCAPE || PIPEC
1532 fprintf(f, "%s\n", HISTFILE_SHELL_SECTION);
1533 save_mlist(&mlist_shell, f);
1537 #endif /* CMD_HISTORY */