| /* misc.c -- miscellaneous bindable readline functions. */ |
| |
| /* Copyright (C) 1987-2002 Free Software Foundation, Inc. |
| |
| This file is part of the GNU Readline Library, a library for |
| reading lines of text with interactive input and history editing. |
| |
| The GNU Readline Library is free software; you can redistribute it |
| and/or modify it under the terms of the GNU General Public License |
| as published by the Free Software Foundation; either version 2, or |
| (at your option) any later version. |
| |
| The GNU Readline Library is distributed in the hope that it will be |
| useful, but WITHOUT ANY WARRANTY; without even the implied warranty |
| of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| The GNU General Public License is often shipped with GNU software, and |
| is generally kept in a file called COPYING or LICENSE. If you do not |
| have a copy of the license, write to the Free Software Foundation, |
| 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ |
| #define READLINE_LIBRARY |
| |
| #if defined (HAVE_CONFIG_H) |
| # include <config.h> |
| #endif |
| |
| #if defined (HAVE_UNISTD_H) |
| # include <unistd.h> |
| #endif /* HAVE_UNISTD_H */ |
| |
| #if defined (HAVE_STDLIB_H) |
| # include <stdlib.h> |
| #else |
| # include "ansi_stdlib.h" |
| #endif /* HAVE_STDLIB_H */ |
| |
| #if defined (HAVE_LOCALE_H) |
| # include <locale.h> |
| #endif |
| |
| #include <stdio.h> |
| |
| /* System-specific feature definitions and include files. */ |
| #include "rldefs.h" |
| #include "rlmbutil.h" |
| |
| /* Some standard library routines. */ |
| #include "readline.h" |
| #include "history.h" |
| |
| #include "rlprivate.h" |
| #include "rlshell.h" |
| #include "xmalloc.h" |
| |
| static int rl_digit_loop PARAMS((void)); |
| static void _rl_history_set_point PARAMS((void)); |
| |
| /* Forward declarations used in this file */ |
| void _rl_free_history_entry PARAMS((HIST_ENTRY *)); |
| |
| /* If non-zero, rl_get_previous_history and rl_get_next_history attempt |
| to preserve the value of rl_point from line to line. */ |
| int _rl_history_preserve_point = 0; |
| |
| /* Saved target point for when _rl_history_preserve_point is set. Special |
| value of -1 means that point is at the end of the line. */ |
| int _rl_history_saved_point = -1; |
| |
| /* **************************************************************** */ |
| /* */ |
| /* Numeric Arguments */ |
| /* */ |
| /* **************************************************************** */ |
| |
| /* Handle C-u style numeric args, as well as M--, and M-digits. */ |
| static int |
| rl_digit_loop () |
| { |
| int key, c, sawminus, sawdigits; |
| |
| rl_save_prompt (); |
| |
| RL_SETSTATE(RL_STATE_NUMERICARG); |
| sawminus = sawdigits = 0; |
| while (1) |
| { |
| if (rl_numeric_arg > 1000000) |
| { |
| sawdigits = rl_explicit_arg = rl_numeric_arg = 0; |
| rl_ding (); |
| rl_restore_prompt (); |
| rl_clear_message (); |
| RL_UNSETSTATE(RL_STATE_NUMERICARG); |
| return 1; |
| } |
| rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg); |
| RL_SETSTATE(RL_STATE_MOREINPUT); |
| key = c = rl_read_key (); |
| RL_UNSETSTATE(RL_STATE_MOREINPUT); |
| |
| if (c < 0) |
| { |
| _rl_abort_internal (); |
| return -1; |
| } |
| |
| /* If we see a key bound to `universal-argument' after seeing digits, |
| it ends the argument but is otherwise ignored. */ |
| if (_rl_keymap[c].type == ISFUNC && |
| _rl_keymap[c].function == rl_universal_argument) |
| { |
| if (sawdigits == 0) |
| { |
| rl_numeric_arg *= 4; |
| continue; |
| } |
| else |
| { |
| RL_SETSTATE(RL_STATE_MOREINPUT); |
| key = rl_read_key (); |
| RL_UNSETSTATE(RL_STATE_MOREINPUT); |
| rl_restore_prompt (); |
| rl_clear_message (); |
| RL_UNSETSTATE(RL_STATE_NUMERICARG); |
| return (_rl_dispatch (key, _rl_keymap)); |
| } |
| } |
| |
| c = UNMETA (c); |
| |
| if (_rl_digit_p (c)) |
| { |
| rl_numeric_arg = rl_explicit_arg ? (rl_numeric_arg * 10) + c - '0' : c - '0'; |
| sawdigits = rl_explicit_arg = 1; |
| } |
| else if (c == '-' && rl_explicit_arg == 0) |
| { |
| rl_numeric_arg = sawminus = 1; |
| rl_arg_sign = -1; |
| } |
| else |
| { |
| /* Make M-- command equivalent to M--1 command. */ |
| if (sawminus && rl_numeric_arg == 1 && rl_explicit_arg == 0) |
| rl_explicit_arg = 1; |
| rl_restore_prompt (); |
| rl_clear_message (); |
| RL_UNSETSTATE(RL_STATE_NUMERICARG); |
| return (_rl_dispatch (key, _rl_keymap)); |
| } |
| } |
| |
| /*NOTREACHED*/ |
| } |
| |
| /* Add the current digit to the argument in progress. */ |
| int |
| rl_digit_argument (ignore, key) |
| int ignore, key; |
| { |
| rl_execute_next (key); |
| return (rl_digit_loop ()); |
| } |
| |
| /* What to do when you abort reading an argument. */ |
| int |
| rl_discard_argument () |
| { |
| rl_ding (); |
| rl_clear_message (); |
| _rl_init_argument (); |
| return 0; |
| } |
| |
| /* Create a default argument. */ |
| int |
| _rl_init_argument () |
| { |
| rl_numeric_arg = rl_arg_sign = 1; |
| rl_explicit_arg = 0; |
| return 0; |
| } |
| |
| /* C-u, universal argument. Multiply the current argument by 4. |
| Read a key. If the key has nothing to do with arguments, then |
| dispatch on it. If the key is the abort character then abort. */ |
| int |
| rl_universal_argument (count, key) |
| int count, key; |
| { |
| rl_numeric_arg *= 4; |
| return (rl_digit_loop ()); |
| } |
| |
| /* **************************************************************** */ |
| /* */ |
| /* History Utilities */ |
| /* */ |
| /* **************************************************************** */ |
| |
| /* We already have a history library, and that is what we use to control |
| the history features of readline. This is our local interface to |
| the history mechanism. */ |
| |
| /* While we are editing the history, this is the saved |
| version of the original line. */ |
| HIST_ENTRY *_rl_saved_line_for_history = (HIST_ENTRY *)NULL; |
| |
| /* Set the history pointer back to the last entry in the history. */ |
| void |
| _rl_start_using_history () |
| { |
| using_history (); |
| if (_rl_saved_line_for_history) |
| _rl_free_history_entry (_rl_saved_line_for_history); |
| |
| _rl_saved_line_for_history = (HIST_ENTRY *)NULL; |
| } |
| |
| /* Free the contents (and containing structure) of a HIST_ENTRY. */ |
| void |
| _rl_free_history_entry (entry) |
| HIST_ENTRY *entry; |
| { |
| if (entry == 0) |
| return; |
| if (entry->line) |
| free (entry->line); |
| free (entry); |
| } |
| |
| /* Perhaps put back the current line if it has changed. */ |
| int |
| rl_maybe_replace_line () |
| { |
| HIST_ENTRY *temp; |
| |
| temp = current_history (); |
| /* If the current line has changed, save the changes. */ |
| if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list)) |
| { |
| temp = replace_history_entry (where_history (), rl_line_buffer, (histdata_t)rl_undo_list); |
| free (temp->line); |
| free (temp); |
| } |
| return 0; |
| } |
| |
| /* Restore the _rl_saved_line_for_history if there is one. */ |
| int |
| rl_maybe_unsave_line () |
| { |
| if (_rl_saved_line_for_history) |
| { |
| rl_replace_line (_rl_saved_line_for_history->line, 0); |
| rl_undo_list = (UNDO_LIST *)_rl_saved_line_for_history->data; |
| _rl_free_history_entry (_rl_saved_line_for_history); |
| _rl_saved_line_for_history = (HIST_ENTRY *)NULL; |
| rl_point = rl_end; /* rl_replace_line sets rl_end */ |
| } |
| else |
| rl_ding (); |
| return 0; |
| } |
| |
| /* Save the current line in _rl_saved_line_for_history. */ |
| int |
| rl_maybe_save_line () |
| { |
| if (_rl_saved_line_for_history == 0) |
| { |
| _rl_saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY)); |
| _rl_saved_line_for_history->line = savestring (rl_line_buffer); |
| _rl_saved_line_for_history->data = (char *)rl_undo_list; |
| } |
| return 0; |
| } |
| |
| int |
| _rl_free_saved_history_line () |
| { |
| if (_rl_saved_line_for_history) |
| { |
| _rl_free_history_entry (_rl_saved_line_for_history); |
| _rl_saved_line_for_history = (HIST_ENTRY *)NULL; |
| } |
| return 0; |
| } |
| |
| static void |
| _rl_history_set_point () |
| { |
| rl_point = (_rl_history_preserve_point && _rl_history_saved_point != -1) |
| ? _rl_history_saved_point |
| : rl_end; |
| if (rl_point > rl_end) |
| rl_point = rl_end; |
| |
| #if defined (VI_MODE) |
| if (rl_editing_mode == vi_mode) |
| rl_point = 0; |
| #endif /* VI_MODE */ |
| |
| if (rl_editing_mode == emacs_mode) |
| rl_mark = (rl_point == rl_end ? 0 : rl_end); |
| } |
| |
| void |
| rl_replace_from_history (entry, flags) |
| HIST_ENTRY *entry; |
| int flags; /* currently unused */ |
| { |
| rl_replace_line (entry->line, 0); |
| rl_undo_list = (UNDO_LIST *)entry->data; |
| rl_point = rl_end; |
| rl_mark = 0; |
| |
| #if defined (VI_MODE) |
| if (rl_editing_mode == vi_mode) |
| { |
| rl_point = 0; |
| rl_mark = rl_end; |
| } |
| #endif |
| } |
| |
| /* **************************************************************** */ |
| /* */ |
| /* History Commands */ |
| /* */ |
| /* **************************************************************** */ |
| |
| /* Meta-< goes to the start of the history. */ |
| int |
| rl_beginning_of_history (count, key) |
| int count, key; |
| { |
| return (rl_get_previous_history (1 + where_history (), key)); |
| } |
| |
| /* Meta-> goes to the end of the history. (The current line). */ |
| int |
| rl_end_of_history (count, key) |
| int count, key; |
| { |
| rl_maybe_replace_line (); |
| using_history (); |
| rl_maybe_unsave_line (); |
| return 0; |
| } |
| |
| /* Move down to the next history line. */ |
| int |
| rl_get_next_history (count, key) |
| int count, key; |
| { |
| HIST_ENTRY *temp; |
| |
| if (count < 0) |
| return (rl_get_previous_history (-count, key)); |
| |
| if (count == 0) |
| return 0; |
| |
| rl_maybe_replace_line (); |
| |
| /* either not saved by rl_newline or at end of line, so set appropriately. */ |
| if (_rl_history_saved_point == -1 && (rl_point || rl_end)) |
| _rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point; |
| |
| temp = (HIST_ENTRY *)NULL; |
| while (count) |
| { |
| temp = next_history (); |
| if (!temp) |
| break; |
| --count; |
| } |
| |
| if (temp == 0) |
| rl_maybe_unsave_line (); |
| else |
| { |
| rl_replace_from_history (temp, 0); |
| _rl_history_set_point (); |
| } |
| return 0; |
| } |
| |
| /* Get the previous item out of our interactive history, making it the current |
| line. If there is no previous history, just ding. */ |
| int |
| rl_get_previous_history (count, key) |
| int count, key; |
| { |
| HIST_ENTRY *old_temp, *temp; |
| |
| if (count < 0) |
| return (rl_get_next_history (-count, key)); |
| |
| if (count == 0) |
| return 0; |
| |
| /* either not saved by rl_newline or at end of line, so set appropriately. */ |
| if (_rl_history_saved_point == -1 && (rl_point || rl_end)) |
| _rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point; |
| |
| /* If we don't have a line saved, then save this one. */ |
| rl_maybe_save_line (); |
| |
| /* If the current line has changed, save the changes. */ |
| rl_maybe_replace_line (); |
| |
| temp = old_temp = (HIST_ENTRY *)NULL; |
| while (count) |
| { |
| temp = previous_history (); |
| if (temp == 0) |
| break; |
| |
| old_temp = temp; |
| --count; |
| } |
| |
| /* If there was a large argument, and we moved back to the start of the |
| history, that is not an error. So use the last value found. */ |
| if (!temp && old_temp) |
| temp = old_temp; |
| |
| if (temp == 0) |
| rl_ding (); |
| else |
| { |
| rl_replace_from_history (temp, 0); |
| _rl_history_set_point (); |
| } |
| return 0; |
| } |
| |
| /* **************************************************************** */ |
| /* */ |
| /* Editing Modes */ |
| /* */ |
| /* **************************************************************** */ |
| /* How to toggle back and forth between editing modes. */ |
| int |
| rl_vi_editing_mode (count, key) |
| int count, key; |
| { |
| #if defined (VI_MODE) |
| _rl_set_insert_mode (RL_IM_INSERT, 1); /* vi mode ignores insert mode */ |
| rl_editing_mode = vi_mode; |
| rl_vi_insertion_mode (1, key); |
| #endif /* VI_MODE */ |
| |
| return 0; |
| } |
| |
| int |
| rl_emacs_editing_mode (count, key) |
| int count, key; |
| { |
| rl_editing_mode = emacs_mode; |
| _rl_set_insert_mode (RL_IM_INSERT, 1); /* emacs mode default is insert mode */ |
| _rl_keymap = emacs_standard_keymap; |
| return 0; |
| } |
| |
| /* Function for the rest of the library to use to set insert/overwrite mode. */ |
| void |
| _rl_set_insert_mode (im, force) |
| int im, force; |
| { |
| #ifdef CURSOR_MODE |
| _rl_set_cursor (im, force); |
| #endif |
| |
| rl_insert_mode = im; |
| } |
| |
| /* Toggle overwrite mode. A positive explicit argument selects overwrite |
| mode. A negative or zero explicit argument selects insert mode. */ |
| int |
| rl_overwrite_mode (count, key) |
| int count, key; |
| { |
| if (rl_explicit_arg == 0) |
| _rl_set_insert_mode (rl_insert_mode ^ 1, 0); |
| else if (count > 0) |
| _rl_set_insert_mode (RL_IM_OVERWRITE, 0); |
| else |
| _rl_set_insert_mode (RL_IM_INSERT, 0); |
| |
| return 0; |
| } |