Commit | Line | Data |
---|---|---|
9255ee31 EZ |
1 | /* misc.c -- miscellaneous bindable readline functions. */ |
2 | ||
775e241e | 3 | /* Copyright (C) 1987-2015 Free Software Foundation, Inc. |
9255ee31 | 4 | |
cc88a640 JK |
5 | This file is part of the GNU Readline Library (Readline), a library |
6 | for reading lines of text with interactive input and history editing. | |
9255ee31 | 7 | |
cc88a640 JK |
8 | Readline is free software: you can redistribute it and/or modify |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation, either version 3 of the License, or | |
9255ee31 EZ |
11 | (at your option) any later version. |
12 | ||
cc88a640 JK |
13 | Readline is distributed in the hope that it will be useful, |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
9255ee31 EZ |
16 | GNU General Public License for more details. |
17 | ||
cc88a640 JK |
18 | You should have received a copy of the GNU General Public License |
19 | along with Readline. If not, see <http://www.gnu.org/licenses/>. | |
20 | */ | |
21 | ||
9255ee31 EZ |
22 | #define READLINE_LIBRARY |
23 | ||
24 | #if defined (HAVE_CONFIG_H) | |
25 | # include <config.h> | |
26 | #endif | |
27 | ||
28 | #if defined (HAVE_UNISTD_H) | |
29 | # include <unistd.h> | |
30 | #endif /* HAVE_UNISTD_H */ | |
31 | ||
32 | #if defined (HAVE_STDLIB_H) | |
33 | # include <stdlib.h> | |
34 | #else | |
35 | # include "ansi_stdlib.h" | |
36 | #endif /* HAVE_STDLIB_H */ | |
37 | ||
38 | #if defined (HAVE_LOCALE_H) | |
39 | # include <locale.h> | |
40 | #endif | |
41 | ||
42 | #include <stdio.h> | |
43 | ||
44 | /* System-specific feature definitions and include files. */ | |
45 | #include "rldefs.h" | |
46 | #include "rlmbutil.h" | |
47 | ||
48 | /* Some standard library routines. */ | |
49 | #include "readline.h" | |
50 | #include "history.h" | |
51 | ||
52 | #include "rlprivate.h" | |
53 | #include "rlshell.h" | |
54 | #include "xmalloc.h" | |
55 | ||
56 | static int rl_digit_loop PARAMS((void)); | |
57 | static void _rl_history_set_point PARAMS((void)); | |
58 | ||
59 | /* Forward declarations used in this file */ | |
60 | void _rl_free_history_entry PARAMS((HIST_ENTRY *)); | |
61 | ||
62 | /* If non-zero, rl_get_previous_history and rl_get_next_history attempt | |
63 | to preserve the value of rl_point from line to line. */ | |
64 | int _rl_history_preserve_point = 0; | |
65 | ||
5bdf8622 DJ |
66 | _rl_arg_cxt _rl_argcxt; |
67 | ||
9255ee31 EZ |
68 | /* Saved target point for when _rl_history_preserve_point is set. Special |
69 | value of -1 means that point is at the end of the line. */ | |
70 | int _rl_history_saved_point = -1; | |
71 | ||
72 | /* **************************************************************** */ | |
73 | /* */ | |
74 | /* Numeric Arguments */ | |
75 | /* */ | |
76 | /* **************************************************************** */ | |
77 | ||
5bdf8622 DJ |
78 | int |
79 | _rl_arg_overflow () | |
9255ee31 | 80 | { |
5bdf8622 DJ |
81 | if (rl_numeric_arg > 1000000) |
82 | { | |
83 | _rl_argcxt = 0; | |
84 | rl_explicit_arg = rl_numeric_arg = 0; | |
85 | rl_ding (); | |
86 | rl_restore_prompt (); | |
87 | rl_clear_message (); | |
88 | RL_UNSETSTATE(RL_STATE_NUMERICARG); | |
89 | return 1; | |
90 | } | |
91 | return 0; | |
92 | } | |
9255ee31 | 93 | |
5bdf8622 DJ |
94 | void |
95 | _rl_arg_init () | |
96 | { | |
9255ee31 | 97 | rl_save_prompt (); |
5bdf8622 | 98 | _rl_argcxt = 0; |
9255ee31 | 99 | RL_SETSTATE(RL_STATE_NUMERICARG); |
5bdf8622 | 100 | } |
9255ee31 | 101 | |
5bdf8622 DJ |
102 | int |
103 | _rl_arg_getchar () | |
104 | { | |
105 | int c; | |
9255ee31 | 106 | |
5bdf8622 DJ |
107 | rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg); |
108 | RL_SETSTATE(RL_STATE_MOREINPUT); | |
109 | c = rl_read_key (); | |
110 | RL_UNSETSTATE(RL_STATE_MOREINPUT); | |
9255ee31 | 111 | |
5bdf8622 DJ |
112 | return c; |
113 | } | |
9255ee31 | 114 | |
5bdf8622 DJ |
115 | /* Process C as part of the current numeric argument. Return -1 if the |
116 | argument should be aborted, 0 if we should not read any more chars, and | |
117 | 1 if we should continue to read chars. */ | |
118 | int | |
119 | _rl_arg_dispatch (cxt, c) | |
120 | _rl_arg_cxt cxt; | |
121 | int c; | |
122 | { | |
123 | int key, r; | |
124 | ||
125 | key = c; | |
126 | ||
127 | /* If we see a key bound to `universal-argument' after seeing digits, | |
128 | it ends the argument but is otherwise ignored. */ | |
775e241e | 129 | if (c >= 0 && _rl_keymap[c].type == ISFUNC && _rl_keymap[c].function == rl_universal_argument) |
5bdf8622 DJ |
130 | { |
131 | if ((cxt & NUM_SAWDIGITS) == 0) | |
9255ee31 | 132 | { |
5bdf8622 DJ |
133 | rl_numeric_arg *= 4; |
134 | return 1; | |
9255ee31 | 135 | } |
5bdf8622 DJ |
136 | else if (RL_ISSTATE (RL_STATE_CALLBACK)) |
137 | { | |
138 | _rl_argcxt |= NUM_READONE; | |
139 | return 0; /* XXX */ | |
140 | } | |
9255ee31 EZ |
141 | else |
142 | { | |
5bdf8622 DJ |
143 | RL_SETSTATE(RL_STATE_MOREINPUT); |
144 | key = rl_read_key (); | |
145 | RL_UNSETSTATE(RL_STATE_MOREINPUT); | |
9255ee31 EZ |
146 | rl_restore_prompt (); |
147 | rl_clear_message (); | |
148 | RL_UNSETSTATE(RL_STATE_NUMERICARG); | |
cc88a640 JK |
149 | if (key < 0) |
150 | return -1; | |
9255ee31 EZ |
151 | return (_rl_dispatch (key, _rl_keymap)); |
152 | } | |
153 | } | |
154 | ||
5bdf8622 | 155 | c = UNMETA (c); |
9255ee31 | 156 | |
5bdf8622 DJ |
157 | if (_rl_digit_p (c)) |
158 | { | |
159 | r = _rl_digit_value (c); | |
160 | rl_numeric_arg = rl_explicit_arg ? (rl_numeric_arg * 10) + r : r; | |
161 | rl_explicit_arg = 1; | |
162 | _rl_argcxt |= NUM_SAWDIGITS; | |
163 | } | |
164 | else if (c == '-' && rl_explicit_arg == 0) | |
165 | { | |
166 | rl_numeric_arg = 1; | |
167 | _rl_argcxt |= NUM_SAWMINUS; | |
168 | rl_arg_sign = -1; | |
169 | } | |
170 | else | |
171 | { | |
172 | /* Make M-- command equivalent to M--1 command. */ | |
173 | if ((_rl_argcxt & NUM_SAWMINUS) && rl_numeric_arg == 1 && rl_explicit_arg == 0) | |
174 | rl_explicit_arg = 1; | |
175 | rl_restore_prompt (); | |
176 | rl_clear_message (); | |
177 | RL_UNSETSTATE(RL_STATE_NUMERICARG); | |
178 | ||
179 | r = _rl_dispatch (key, _rl_keymap); | |
180 | if (RL_ISSTATE (RL_STATE_CALLBACK)) | |
181 | { | |
182 | /* At worst, this will cause an extra redisplay. Otherwise, | |
183 | we have to wait until the next character comes in. */ | |
184 | if (rl_done == 0) | |
185 | (*rl_redisplay_function) (); | |
186 | r = 0; | |
187 | } | |
188 | return r; | |
189 | } | |
190 | ||
191 | return 1; | |
9255ee31 EZ |
192 | } |
193 | ||
5bdf8622 DJ |
194 | /* Handle C-u style numeric args, as well as M--, and M-digits. */ |
195 | static int | |
196 | rl_digit_loop () | |
9255ee31 | 197 | { |
5bdf8622 DJ |
198 | int c, r; |
199 | ||
200 | while (1) | |
201 | { | |
202 | if (_rl_arg_overflow ()) | |
203 | return 1; | |
204 | ||
205 | c = _rl_arg_getchar (); | |
206 | ||
207 | if (c < 0) | |
208 | { | |
209 | _rl_abort_internal (); | |
210 | return -1; | |
211 | } | |
212 | ||
213 | r = _rl_arg_dispatch (_rl_argcxt, c); | |
214 | if (r <= 0 || (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)) | |
215 | break; | |
216 | } | |
cc88a640 JK |
217 | |
218 | return r; | |
9255ee31 EZ |
219 | } |
220 | ||
221 | /* Create a default argument. */ | |
5bdf8622 DJ |
222 | void |
223 | _rl_reset_argument () | |
9255ee31 EZ |
224 | { |
225 | rl_numeric_arg = rl_arg_sign = 1; | |
226 | rl_explicit_arg = 0; | |
5bdf8622 DJ |
227 | _rl_argcxt = 0; |
228 | } | |
229 | ||
230 | /* Start a numeric argument with initial value KEY */ | |
231 | int | |
232 | rl_digit_argument (ignore, key) | |
233 | int ignore, key; | |
234 | { | |
235 | _rl_arg_init (); | |
236 | if (RL_ISSTATE (RL_STATE_CALLBACK)) | |
237 | { | |
238 | _rl_arg_dispatch (_rl_argcxt, key); | |
239 | rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg); | |
240 | return 0; | |
241 | } | |
242 | else | |
243 | { | |
244 | rl_execute_next (key); | |
245 | return (rl_digit_loop ()); | |
246 | } | |
9255ee31 EZ |
247 | } |
248 | ||
249 | /* C-u, universal argument. Multiply the current argument by 4. | |
250 | Read a key. If the key has nothing to do with arguments, then | |
251 | dispatch on it. If the key is the abort character then abort. */ | |
252 | int | |
253 | rl_universal_argument (count, key) | |
254 | int count, key; | |
255 | { | |
5bdf8622 | 256 | _rl_arg_init (); |
9255ee31 | 257 | rl_numeric_arg *= 4; |
5bdf8622 DJ |
258 | |
259 | return (RL_ISSTATE (RL_STATE_CALLBACK) ? 0 : rl_digit_loop ()); | |
260 | } | |
261 | ||
262 | int | |
263 | _rl_arg_callback (cxt) | |
264 | _rl_arg_cxt cxt; | |
265 | { | |
266 | int c, r; | |
267 | ||
268 | c = _rl_arg_getchar (); | |
775e241e TT |
269 | if (c < 0) |
270 | return (1); /* EOF */ | |
5bdf8622 DJ |
271 | |
272 | if (_rl_argcxt & NUM_READONE) | |
273 | { | |
274 | _rl_argcxt &= ~NUM_READONE; | |
275 | rl_restore_prompt (); | |
276 | rl_clear_message (); | |
277 | RL_UNSETSTATE(RL_STATE_NUMERICARG); | |
278 | rl_execute_next (c); | |
279 | return 0; | |
280 | } | |
281 | ||
282 | r = _rl_arg_dispatch (cxt, c); | |
283 | return (r != 1); | |
284 | } | |
285 | ||
286 | /* What to do when you abort reading an argument. */ | |
287 | int | |
288 | rl_discard_argument () | |
289 | { | |
290 | rl_ding (); | |
291 | rl_clear_message (); | |
292 | _rl_reset_argument (); | |
293 | ||
294 | return 0; | |
9255ee31 EZ |
295 | } |
296 | ||
297 | /* **************************************************************** */ | |
298 | /* */ | |
299 | /* History Utilities */ | |
300 | /* */ | |
301 | /* **************************************************************** */ | |
302 | ||
303 | /* We already have a history library, and that is what we use to control | |
304 | the history features of readline. This is our local interface to | |
305 | the history mechanism. */ | |
306 | ||
307 | /* While we are editing the history, this is the saved | |
308 | version of the original line. */ | |
309 | HIST_ENTRY *_rl_saved_line_for_history = (HIST_ENTRY *)NULL; | |
310 | ||
311 | /* Set the history pointer back to the last entry in the history. */ | |
312 | void | |
313 | _rl_start_using_history () | |
314 | { | |
315 | using_history (); | |
316 | if (_rl_saved_line_for_history) | |
317 | _rl_free_history_entry (_rl_saved_line_for_history); | |
318 | ||
319 | _rl_saved_line_for_history = (HIST_ENTRY *)NULL; | |
320 | } | |
321 | ||
322 | /* Free the contents (and containing structure) of a HIST_ENTRY. */ | |
323 | void | |
324 | _rl_free_history_entry (entry) | |
325 | HIST_ENTRY *entry; | |
326 | { | |
327 | if (entry == 0) | |
328 | return; | |
5bdf8622 DJ |
329 | |
330 | FREE (entry->line); | |
331 | FREE (entry->timestamp); | |
332 | ||
cc88a640 | 333 | xfree (entry); |
9255ee31 EZ |
334 | } |
335 | ||
336 | /* Perhaps put back the current line if it has changed. */ | |
337 | int | |
338 | rl_maybe_replace_line () | |
339 | { | |
340 | HIST_ENTRY *temp; | |
341 | ||
342 | temp = current_history (); | |
343 | /* If the current line has changed, save the changes. */ | |
344 | if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list)) | |
345 | { | |
346 | temp = replace_history_entry (where_history (), rl_line_buffer, (histdata_t)rl_undo_list); | |
cc88a640 | 347 | xfree (temp->line); |
5bdf8622 | 348 | FREE (temp->timestamp); |
cc88a640 | 349 | xfree (temp); |
9255ee31 EZ |
350 | } |
351 | return 0; | |
352 | } | |
353 | ||
354 | /* Restore the _rl_saved_line_for_history if there is one. */ | |
355 | int | |
356 | rl_maybe_unsave_line () | |
357 | { | |
358 | if (_rl_saved_line_for_history) | |
359 | { | |
5bdf8622 DJ |
360 | /* Can't call with `1' because rl_undo_list might point to an undo |
361 | list from a history entry, as in rl_replace_from_history() below. */ | |
9255ee31 EZ |
362 | rl_replace_line (_rl_saved_line_for_history->line, 0); |
363 | rl_undo_list = (UNDO_LIST *)_rl_saved_line_for_history->data; | |
364 | _rl_free_history_entry (_rl_saved_line_for_history); | |
365 | _rl_saved_line_for_history = (HIST_ENTRY *)NULL; | |
366 | rl_point = rl_end; /* rl_replace_line sets rl_end */ | |
367 | } | |
368 | else | |
369 | rl_ding (); | |
370 | return 0; | |
371 | } | |
372 | ||
373 | /* Save the current line in _rl_saved_line_for_history. */ | |
374 | int | |
375 | rl_maybe_save_line () | |
376 | { | |
377 | if (_rl_saved_line_for_history == 0) | |
378 | { | |
379 | _rl_saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY)); | |
380 | _rl_saved_line_for_history->line = savestring (rl_line_buffer); | |
5bdf8622 | 381 | _rl_saved_line_for_history->timestamp = (char *)NULL; |
9255ee31 EZ |
382 | _rl_saved_line_for_history->data = (char *)rl_undo_list; |
383 | } | |
5bdf8622 | 384 | |
9255ee31 EZ |
385 | return 0; |
386 | } | |
387 | ||
388 | int | |
389 | _rl_free_saved_history_line () | |
390 | { | |
391 | if (_rl_saved_line_for_history) | |
392 | { | |
393 | _rl_free_history_entry (_rl_saved_line_for_history); | |
394 | _rl_saved_line_for_history = (HIST_ENTRY *)NULL; | |
395 | } | |
396 | return 0; | |
397 | } | |
398 | ||
399 | static void | |
400 | _rl_history_set_point () | |
401 | { | |
402 | rl_point = (_rl_history_preserve_point && _rl_history_saved_point != -1) | |
403 | ? _rl_history_saved_point | |
404 | : rl_end; | |
405 | if (rl_point > rl_end) | |
406 | rl_point = rl_end; | |
407 | ||
408 | #if defined (VI_MODE) | |
5bdf8622 | 409 | if (rl_editing_mode == vi_mode && _rl_keymap != vi_insertion_keymap) |
9255ee31 EZ |
410 | rl_point = 0; |
411 | #endif /* VI_MODE */ | |
412 | ||
413 | if (rl_editing_mode == emacs_mode) | |
414 | rl_mark = (rl_point == rl_end ? 0 : rl_end); | |
415 | } | |
416 | ||
417 | void | |
418 | rl_replace_from_history (entry, flags) | |
419 | HIST_ENTRY *entry; | |
420 | int flags; /* currently unused */ | |
421 | { | |
5bdf8622 DJ |
422 | /* Can't call with `1' because rl_undo_list might point to an undo list |
423 | from a history entry, just like we're setting up here. */ | |
9255ee31 EZ |
424 | rl_replace_line (entry->line, 0); |
425 | rl_undo_list = (UNDO_LIST *)entry->data; | |
426 | rl_point = rl_end; | |
427 | rl_mark = 0; | |
428 | ||
429 | #if defined (VI_MODE) | |
430 | if (rl_editing_mode == vi_mode) | |
431 | { | |
432 | rl_point = 0; | |
433 | rl_mark = rl_end; | |
434 | } | |
435 | #endif | |
cc88a640 JK |
436 | } |
437 | ||
438 | /* Process and free undo lists attached to each history entry prior to the | |
439 | current entry, inclusive, reverting each line to its saved state. This | |
440 | is destructive, and state about the current line is lost. This is not | |
441 | intended to be called while actively editing, and the current line is | |
442 | not assumed to have been added to the history list. */ | |
443 | void | |
444 | _rl_revert_all_lines () | |
445 | { | |
446 | int hpos; | |
447 | HIST_ENTRY *entry; | |
448 | UNDO_LIST *ul, *saved_undo_list; | |
449 | char *lbuf; | |
450 | ||
451 | lbuf = savestring (rl_line_buffer); | |
452 | saved_undo_list = rl_undo_list; | |
453 | hpos = where_history (); | |
454 | ||
455 | entry = (hpos == history_length) ? previous_history () : current_history (); | |
456 | while (entry) | |
457 | { | |
458 | if (ul = (UNDO_LIST *)entry->data) | |
459 | { | |
460 | if (ul == saved_undo_list) | |
461 | saved_undo_list = 0; | |
462 | /* Set up rl_line_buffer and other variables from history entry */ | |
463 | rl_replace_from_history (entry, 0); /* entry->line is now current */ | |
775e241e | 464 | entry->data = 0; /* entry->data is now current undo list */ |
cc88a640 JK |
465 | /* Undo all changes to this history entry */ |
466 | while (rl_undo_list) | |
467 | rl_do_undo (); | |
468 | /* And copy the reverted line back to the history entry, preserving | |
469 | the timestamp. */ | |
470 | FREE (entry->line); | |
471 | entry->line = savestring (rl_line_buffer); | |
cc88a640 JK |
472 | } |
473 | entry = previous_history (); | |
474 | } | |
475 | ||
476 | /* Restore history state */ | |
477 | rl_undo_list = saved_undo_list; /* may have been set to null */ | |
478 | history_set_pos (hpos); | |
479 | ||
480 | /* reset the line buffer */ | |
481 | rl_replace_line (lbuf, 0); | |
482 | _rl_set_the_line (); | |
483 | ||
484 | /* and clean up */ | |
485 | xfree (lbuf); | |
9255ee31 EZ |
486 | } |
487 | ||
775e241e TT |
488 | /* Free the history list, including private readline data and take care |
489 | of pointer aliases to history data. Resets rl_undo_list if it points | |
490 | to an UNDO_LIST * saved as some history entry's data member. This | |
491 | should not be called while editing is active. */ | |
492 | void | |
493 | rl_clear_history () | |
494 | { | |
495 | HIST_ENTRY **hlist, *hent; | |
496 | register int i; | |
497 | UNDO_LIST *ul, *saved_undo_list; | |
498 | ||
499 | saved_undo_list = rl_undo_list; | |
500 | hlist = history_list (); /* direct pointer, not copy */ | |
501 | ||
502 | for (i = 0; i < history_length; i++) | |
503 | { | |
504 | hent = hlist[i]; | |
505 | if (ul = (UNDO_LIST *)hent->data) | |
506 | { | |
507 | if (ul == saved_undo_list) | |
508 | saved_undo_list = 0; | |
509 | _rl_free_undo_list (ul); | |
510 | hent->data = 0; | |
511 | } | |
512 | _rl_free_history_entry (hent); | |
513 | } | |
514 | ||
515 | history_offset = history_length = 0; | |
516 | rl_undo_list = saved_undo_list; /* should be NULL */ | |
517 | } | |
518 | ||
9255ee31 EZ |
519 | /* **************************************************************** */ |
520 | /* */ | |
521 | /* History Commands */ | |
522 | /* */ | |
523 | /* **************************************************************** */ | |
524 | ||
525 | /* Meta-< goes to the start of the history. */ | |
526 | int | |
527 | rl_beginning_of_history (count, key) | |
528 | int count, key; | |
529 | { | |
530 | return (rl_get_previous_history (1 + where_history (), key)); | |
531 | } | |
532 | ||
533 | /* Meta-> goes to the end of the history. (The current line). */ | |
534 | int | |
535 | rl_end_of_history (count, key) | |
536 | int count, key; | |
537 | { | |
538 | rl_maybe_replace_line (); | |
539 | using_history (); | |
540 | rl_maybe_unsave_line (); | |
541 | return 0; | |
542 | } | |
543 | ||
544 | /* Move down to the next history line. */ | |
545 | int | |
546 | rl_get_next_history (count, key) | |
547 | int count, key; | |
548 | { | |
549 | HIST_ENTRY *temp; | |
550 | ||
551 | if (count < 0) | |
552 | return (rl_get_previous_history (-count, key)); | |
553 | ||
554 | if (count == 0) | |
555 | return 0; | |
556 | ||
557 | rl_maybe_replace_line (); | |
558 | ||
559 | /* either not saved by rl_newline or at end of line, so set appropriately. */ | |
560 | if (_rl_history_saved_point == -1 && (rl_point || rl_end)) | |
561 | _rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point; | |
562 | ||
563 | temp = (HIST_ENTRY *)NULL; | |
564 | while (count) | |
565 | { | |
566 | temp = next_history (); | |
567 | if (!temp) | |
568 | break; | |
569 | --count; | |
570 | } | |
571 | ||
572 | if (temp == 0) | |
573 | rl_maybe_unsave_line (); | |
574 | else | |
575 | { | |
576 | rl_replace_from_history (temp, 0); | |
577 | _rl_history_set_point (); | |
578 | } | |
579 | return 0; | |
580 | } | |
581 | ||
582 | /* Get the previous item out of our interactive history, making it the current | |
583 | line. If there is no previous history, just ding. */ | |
584 | int | |
585 | rl_get_previous_history (count, key) | |
586 | int count, key; | |
587 | { | |
588 | HIST_ENTRY *old_temp, *temp; | |
589 | ||
590 | if (count < 0) | |
591 | return (rl_get_next_history (-count, key)); | |
592 | ||
593 | if (count == 0) | |
594 | return 0; | |
595 | ||
596 | /* either not saved by rl_newline or at end of line, so set appropriately. */ | |
597 | if (_rl_history_saved_point == -1 && (rl_point || rl_end)) | |
598 | _rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point; | |
599 | ||
600 | /* If we don't have a line saved, then save this one. */ | |
601 | rl_maybe_save_line (); | |
602 | ||
603 | /* If the current line has changed, save the changes. */ | |
604 | rl_maybe_replace_line (); | |
605 | ||
606 | temp = old_temp = (HIST_ENTRY *)NULL; | |
607 | while (count) | |
608 | { | |
609 | temp = previous_history (); | |
610 | if (temp == 0) | |
611 | break; | |
612 | ||
613 | old_temp = temp; | |
614 | --count; | |
615 | } | |
616 | ||
617 | /* If there was a large argument, and we moved back to the start of the | |
618 | history, that is not an error. So use the last value found. */ | |
619 | if (!temp && old_temp) | |
620 | temp = old_temp; | |
621 | ||
622 | if (temp == 0) | |
623 | rl_ding (); | |
624 | else | |
625 | { | |
626 | rl_replace_from_history (temp, 0); | |
627 | _rl_history_set_point (); | |
628 | } | |
5bdf8622 | 629 | |
9255ee31 EZ |
630 | return 0; |
631 | } | |
632 | ||
633 | /* **************************************************************** */ | |
634 | /* */ | |
635 | /* Editing Modes */ | |
636 | /* */ | |
637 | /* **************************************************************** */ | |
638 | /* How to toggle back and forth between editing modes. */ | |
639 | int | |
640 | rl_vi_editing_mode (count, key) | |
641 | int count, key; | |
642 | { | |
643 | #if defined (VI_MODE) | |
644 | _rl_set_insert_mode (RL_IM_INSERT, 1); /* vi mode ignores insert mode */ | |
645 | rl_editing_mode = vi_mode; | |
cc88a640 | 646 | rl_vi_insert_mode (1, key); |
9255ee31 EZ |
647 | #endif /* VI_MODE */ |
648 | ||
649 | return 0; | |
650 | } | |
651 | ||
652 | int | |
653 | rl_emacs_editing_mode (count, key) | |
654 | int count, key; | |
655 | { | |
656 | rl_editing_mode = emacs_mode; | |
657 | _rl_set_insert_mode (RL_IM_INSERT, 1); /* emacs mode default is insert mode */ | |
658 | _rl_keymap = emacs_standard_keymap; | |
775e241e TT |
659 | |
660 | if (_rl_show_mode_in_prompt) | |
661 | _rl_reset_prompt (); | |
662 | ||
9255ee31 EZ |
663 | return 0; |
664 | } | |
665 | ||
666 | /* Function for the rest of the library to use to set insert/overwrite mode. */ | |
667 | void | |
668 | _rl_set_insert_mode (im, force) | |
669 | int im, force; | |
670 | { | |
671 | #ifdef CURSOR_MODE | |
672 | _rl_set_cursor (im, force); | |
673 | #endif | |
674 | ||
675 | rl_insert_mode = im; | |
676 | } | |
677 | ||
678 | /* Toggle overwrite mode. A positive explicit argument selects overwrite | |
679 | mode. A negative or zero explicit argument selects insert mode. */ | |
680 | int | |
681 | rl_overwrite_mode (count, key) | |
682 | int count, key; | |
683 | { | |
684 | if (rl_explicit_arg == 0) | |
685 | _rl_set_insert_mode (rl_insert_mode ^ 1, 0); | |
686 | else if (count > 0) | |
687 | _rl_set_insert_mode (RL_IM_OVERWRITE, 0); | |
688 | else | |
689 | _rl_set_insert_mode (RL_IM_INSERT, 0); | |
690 | ||
691 | return 0; | |
692 | } |