/* 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; }