8720 lines
281 KiB
Ruby
8720 lines
281 KiB
Ruby
# rbreadline.rb -- a general facility for reading lines of input
|
|
# with emacs style editing and completion.
|
|
|
|
#
|
|
# Inspired by GNU Readline, translation to Ruby
|
|
# Copyright (C) 2009 by Park Heesob phasis@gmail.com
|
|
#
|
|
|
|
=begin
|
|
Copyright (c) 2009, Park Heesob
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice, this
|
|
list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright notice
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
* Neither the name of Park Heesob nor the names of its contributors
|
|
may be used to endorse or promote products derived from this software
|
|
without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
|
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
=end
|
|
|
|
|
|
class Fixnum
|
|
def ord; self; end
|
|
end
|
|
|
|
module RbReadline
|
|
require 'etc'
|
|
|
|
RL_LIBRARY_VERSION = "5.2"
|
|
RL_READLINE_VERSION = 0x0502
|
|
RB_READLINE_VERSION = "0.2.0"
|
|
|
|
EOF = "\xFF"
|
|
ESC = "\C-["
|
|
PAGE = "\C-L"
|
|
SPACE = "\x20"
|
|
RETURN = "\C-M"
|
|
ABORT_CHAR = "\C-G"
|
|
TAB = "\t"
|
|
RUBOUT = "x7f"
|
|
NEWLINE = "\n"
|
|
|
|
DEFAULT_BUFFER_SIZE = 256
|
|
DEFAULT_MAX_KILLS = 10
|
|
|
|
MB_FIND_NONZERO = 1
|
|
MB_FIND_ANY = 0
|
|
MB_LEN_MAX = 4
|
|
|
|
DEFAULT_INPUTRC = "~/.inputrc"
|
|
SYS_INPUTRC = "/etc/inputrc"
|
|
|
|
UpCase = 1
|
|
DownCase = 2
|
|
CapCase = 3
|
|
|
|
# Possible history errors passed to hist_error.
|
|
EVENT_NOT_FOUND = 0
|
|
BAD_WORD_SPEC = 1
|
|
SUBST_FAILED = 2
|
|
BAD_MODIFIER = 3
|
|
NO_PREV_SUBST = 4
|
|
|
|
# Possible definitions for history starting point specification.
|
|
ANCHORED_SEARCH = 1
|
|
NON_ANCHORED_SEARCH = 0
|
|
|
|
# Possible definitions for what style of writing the history file we want.
|
|
HISTORY_APPEND = 0
|
|
HISTORY_OVERWRITE = 1
|
|
|
|
# Input error; can be returned by (*rl_getc_function) if readline is reading
|
|
# a top-level command (RL_ISSTATE (RL_STATE_READCMD)).
|
|
READERR = 0xFE.chr
|
|
|
|
# Definitions available for use by readline clients.
|
|
RL_PROMPT_START_IGNORE = 1.chr
|
|
RL_PROMPT_END_IGNORE = 2.chr
|
|
|
|
# Possible values for do_replace argument to rl_filename_quoting_function,
|
|
# called by rl_complete_internal.
|
|
NO_MATCH = 0
|
|
SINGLE_MATCH = 1
|
|
MULT_MATCH = 2
|
|
|
|
# Callback data for reading numeric arguments
|
|
NUM_SAWMINUS = 0x01
|
|
NUM_SAWDIGITS = 0x02
|
|
NUM_READONE = 0x04
|
|
|
|
# A context for reading key sequences longer than a single character when
|
|
# using the callback interface.
|
|
KSEQ_DISPATCHED = 0x01
|
|
KSEQ_SUBSEQ = 0x02
|
|
KSEQ_RECURSIVE = 0x04
|
|
|
|
# Possible state values for rl_readline_state
|
|
RL_STATE_NONE = 0x000000 # no state before first call
|
|
|
|
RL_STATE_INITIALIZING = 0x000001 # initializing
|
|
RL_STATE_INITIALIZED = 0x000002 # initialization done
|
|
RL_STATE_TERMPREPPED = 0x000004 # terminal is prepped
|
|
RL_STATE_READCMD = 0x000008 # reading a command key
|
|
RL_STATE_METANEXT = 0x000010 # reading input after ESC
|
|
RL_STATE_DISPATCHING = 0x000020 # dispatching to a command
|
|
RL_STATE_MOREINPUT = 0x000040 # reading more input in a command function
|
|
RL_STATE_ISEARCH = 0x000080 # doing incremental search
|
|
RL_STATE_NSEARCH = 0x000100 # doing non-inc search
|
|
RL_STATE_SEARCH = 0x000200 # doing a history search
|
|
RL_STATE_NUMERICARG = 0x000400 # reading numeric argument
|
|
RL_STATE_MACROINPUT = 0x000800 # getting input from a macro
|
|
RL_STATE_MACRODEF = 0x001000 # defining keyboard macro
|
|
RL_STATE_OVERWRITE = 0x002000 # overwrite mode
|
|
RL_STATE_COMPLETING = 0x004000 # doing completion
|
|
RL_STATE_SIGHANDLER = 0x008000 # in readline sighandler
|
|
RL_STATE_UNDOING = 0x010000 # doing an undo
|
|
RL_STATE_INPUTPENDING = 0x020000 # rl_execute_next called
|
|
RL_STATE_TTYCSAVED = 0x040000 # tty special chars saved
|
|
RL_STATE_CALLBACK = 0x080000 # using the callback interface
|
|
RL_STATE_VIMOTION = 0x100000 # reading vi motion arg
|
|
RL_STATE_MULTIKEY = 0x200000 # reading multiple-key command
|
|
RL_STATE_VICMDONCE = 0x400000 # entered vi command mode at least once
|
|
|
|
RL_STATE_DONE = 0x800000 # done accepted line
|
|
|
|
NO_BELL = 0
|
|
AUDIBLE_BELL = 1
|
|
VISIBLE_BELL = 2
|
|
# The actions that undo knows how to undo. Notice that UNDO_DELETE means
|
|
# to insert some text, and UNDO_INSERT means to delete some text. I.e.,
|
|
# the code tells undo what to undo, not how to undo it.
|
|
UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END = 0,1,2,3
|
|
|
|
# Definitions used when searching the line for characters.
|
|
# NOTE: it is necessary that opposite directions are inverses
|
|
FTO = 1 # forward to
|
|
BTO = -1 # backward to
|
|
FFIND = 2 # forward find
|
|
BFIND = -2 # backward find
|
|
|
|
# Possible values for the found_quote flags word used by the completion
|
|
# functions. It says what kind of (shell-like) quoting we found anywhere
|
|
# in the line.
|
|
RL_QF_SINGLE_QUOTE = 0x01
|
|
RL_QF_DOUBLE_QUOTE = 0x02
|
|
RL_QF_BACKSLASH = 0x04
|
|
RL_QF_OTHER_QUOTE = 0x08
|
|
|
|
KEYMAP_SIZE = 257
|
|
ANYOTHERKEY = KEYMAP_SIZE-1
|
|
|
|
@hConsoleHandle = nil
|
|
@MessageBeep = nil
|
|
|
|
RL_IM_INSERT = 1
|
|
RL_IM_OVERWRITE = 0
|
|
RL_IM_DEFAULT = RL_IM_INSERT
|
|
@no_mode = -1
|
|
@vi_mode = 0
|
|
@emacs_mode = 1
|
|
ISFUNC = 0
|
|
ISKMAP = 1
|
|
ISMACR = 2
|
|
|
|
HISTORY_WORD_DELIMITERS = " \t\n;&()|<>"
|
|
HISTORY_QUOTE_CHARACTERS = "\"'`"
|
|
|
|
RL_SEARCH_ISEARCH = 0x01 # incremental search
|
|
RL_SEARCH_NSEARCH = 0x02 # non-incremental search
|
|
RL_SEARCH_CSEARCH = 0x04 # intra-line char search
|
|
|
|
# search flags
|
|
SF_REVERSE = 0x01
|
|
SF_FOUND = 0x02
|
|
SF_FAILED = 0x04
|
|
|
|
@slashify_in_quotes = "\\`\"$"
|
|
|
|
@sigint_proc = nil
|
|
@sigint_blocked = false
|
|
|
|
@rl_prep_term_function = :rl_prep_terminal
|
|
@rl_deprep_term_function = :rl_deprep_terminal
|
|
|
|
@_rl_history_saved_point = -1
|
|
|
|
@rl_max_kills = DEFAULT_MAX_KILLS
|
|
@rl_kill_ring = nil
|
|
@rl_kill_index = 0
|
|
@rl_kill_ring_length = 0
|
|
|
|
@pending_bytes = ''
|
|
@stored_count = 0
|
|
|
|
@_rl_isearch_terminators = nil
|
|
@_rl_iscxt = nil
|
|
@last_isearch_string = nil
|
|
@last_isearch_string_len = 0
|
|
@default_isearch_terminators = "\033\012"
|
|
@_rl_history_preserve_point = false
|
|
@terminal_prepped = false
|
|
@otio = nil
|
|
|
|
@msg_saved_prompt = false
|
|
|
|
@_rl_nscxt = nil
|
|
@noninc_search_string = nil
|
|
@noninc_history_pos = 0
|
|
@prev_line_found = nil
|
|
|
|
rl_history_search_len = 0
|
|
rl_history_search_pos = 0
|
|
history_search_string = nil
|
|
history_string_size = 0
|
|
|
|
@_rl_tty_chars = Struct.new(:t_eol,:t_eol2,:t_erase,:t_werase,:t_kill,:t_reprint,:t_intr,:t_eof,
|
|
:t_quit,:t_susp,:t_dsusp,:t_start,:t_stop,:t_lnext,:t_flush,:t_status).new
|
|
@_rl_last_tty_chars = nil
|
|
|
|
# Variables exported by this file.
|
|
# The character that represents the start of a history expansion
|
|
# request. This is usually `!'.
|
|
@history_expansion_char = ?!
|
|
|
|
# The character that invokes word substitution if found at the start of
|
|
# a line. This is usually `^'.
|
|
@history_subst_char = ?^
|
|
|
|
# During tokenization, if this character is seen as the first character
|
|
# of a word, then it, and all subsequent characters upto a newline are
|
|
# ignored. For a Bourne shell, this should be '#'. Bash special cases
|
|
# the interactive comment character to not be a comment delimiter.
|
|
@history_comment_char = ?\0
|
|
|
|
# The list of characters which inhibit the expansion of text if found
|
|
# immediately following history_expansion_char.
|
|
@history_no_expand_chars = " \t\n\r="
|
|
|
|
# If set to a non-zero value, single quotes inhibit history expansion.
|
|
# The default is 0.
|
|
@history_quotes_inhibit_expansion = 0
|
|
|
|
# Used to split words by history_tokenize_internal.
|
|
@history_word_delimiters = HISTORY_WORD_DELIMITERS
|
|
|
|
# If set, this points to a function that is called to verify that a
|
|
# particular history expansion should be performed.
|
|
@history_inhibit_expansion_function = nil
|
|
|
|
@rl_event_hook = nil
|
|
# The visible cursor position. If you print some text, adjust this.
|
|
# NOTE: _rl_last_c_pos is used as a buffer index when not in a locale
|
|
# supporting multibyte characters, and an absolute cursor position when
|
|
# in such a locale. This is an artifact of the donated multibyte support.
|
|
# Care must be taken when modifying its value.
|
|
@_rl_last_c_pos = 0
|
|
@_rl_last_v_pos = 0
|
|
|
|
@cpos_adjusted = false
|
|
@cpos_buffer_position = 0
|
|
|
|
# Number of lines currently on screen minus 1.
|
|
@_rl_vis_botlin = 0
|
|
|
|
# Variables used only in this file.
|
|
# The last left edge of text that was displayed. This is used when
|
|
# doing horizontal scrolling. It shifts in thirds of a screenwidth.
|
|
@last_lmargin = 0
|
|
|
|
# The line display buffers. One is the line currently displayed on
|
|
# the screen. The other is the line about to be displayed.
|
|
@visible_line = nil
|
|
@invisible_line = nil
|
|
|
|
# A buffer for `modeline' messages.
|
|
@msg_buf = 0.chr * 128
|
|
|
|
# Non-zero forces the redisplay even if we thought it was unnecessary.
|
|
@forced_display = false
|
|
|
|
# Default and initial buffer size. Can grow.
|
|
@line_size = 1024
|
|
|
|
# Variables to keep track of the expanded prompt string, which may
|
|
# include invisible characters.
|
|
|
|
@local_prompt = nil
|
|
@local_prompt_prefix = nil
|
|
@local_prompt_len = 0
|
|
@prompt_visible_length = 0
|
|
@prompt_prefix_length = 0
|
|
|
|
# The number of invisible characters in the line currently being
|
|
# displayed on the screen.
|
|
@visible_wrap_offset = 0
|
|
|
|
# The number of invisible characters in the prompt string. Static so it
|
|
# can be shared between rl_redisplay and update_line
|
|
@wrap_offset = 0
|
|
|
|
@prompt_last_invisible = 0
|
|
|
|
# The length (buffer offset) of the first line of the last (possibly
|
|
# multi-line) buffer displayed on the screen.
|
|
@visible_first_line_len = 0
|
|
|
|
# Number of invisible characters on the first physical line of the prompt.
|
|
# Only valid when the number of physical characters in the prompt exceeds
|
|
# (or is equal to) _rl_screenwidth.
|
|
@prompt_invis_chars_first_line = 0
|
|
|
|
@prompt_last_screen_line = 0
|
|
|
|
@prompt_physical_chars = 0
|
|
|
|
# Variables to save and restore prompt and display information.
|
|
|
|
# These are getting numerous enough that it's time to create a struct.
|
|
|
|
@saved_local_prompt = nil
|
|
@saved_local_prefix = nil
|
|
@saved_last_invisible = 0
|
|
@saved_visible_length = 0
|
|
@saved_prefix_length = 0
|
|
@saved_local_length = 0
|
|
@saved_invis_chars_first_line = 0
|
|
@saved_physical_chars = 0
|
|
|
|
@inv_lbreaks = nil
|
|
@vis_lbreaks = nil
|
|
@_rl_wrapped_line = nil
|
|
|
|
@term_buffer = nil
|
|
@term_string_buffer = nil
|
|
|
|
@tcap_initialized = false
|
|
|
|
# While we are editing the history, this is the saved
|
|
# version of the original line.
|
|
@_rl_saved_line_for_history = nil
|
|
|
|
# An array of HIST_ENTRY. This is where we store the history.
|
|
@the_history = nil
|
|
@history_base = 1
|
|
|
|
# Non-zero means that we have enforced a limit on the amount of
|
|
# history that we save.
|
|
@history_stifled = false
|
|
|
|
# If HISTORY_STIFLED is non-zero, then this is the maximum number of
|
|
# entries to remember.
|
|
@history_max_entries = 0
|
|
@max_input_history = 0 # backwards compatibility
|
|
|
|
# The current location of the interactive history pointer. Just makes
|
|
# life easier for outside callers.
|
|
@history_offset = 0
|
|
|
|
# The number of strings currently stored in the history list.
|
|
@history_length = 0
|
|
|
|
@_rl_vi_last_command = 'i' # default `.' puts you in insert mode
|
|
|
|
# Non-zero means enter insertion mode.
|
|
@_rl_vi_doing_insert = 0
|
|
|
|
# Command keys which do movement for xxx_to commands.
|
|
@vi_motion = " hl^$0ftFT;,%wbeWBE|"
|
|
|
|
# Keymap used for vi replace characters. Created dynamically since
|
|
# rarely used.
|
|
@vi_replace_map = nil
|
|
|
|
# The number of characters inserted in the last replace operation.
|
|
@vi_replace_count = 0
|
|
|
|
# If non-zero, we have text inserted after a c[motion] command that put
|
|
# us implicitly into insert mode. Some people want this text to be
|
|
# attached to the command so that it is `redoable' with `.'.
|
|
@vi_continued_command = false
|
|
@vi_insert_buffer = nil
|
|
@vi_insert_buffer_size = 0
|
|
|
|
@_rl_vi_last_repeat = 1
|
|
@_rl_vi_last_arg_sign = 1
|
|
@_rl_vi_last_motion = 0
|
|
@_rl_vi_last_search_char = 0
|
|
@_rl_vi_last_replacement = 0
|
|
|
|
@_rl_vi_last_key_before_insert = 0
|
|
|
|
@vi_redoing = 0
|
|
|
|
# Text modification commands. These are the `redoable' commands.
|
|
@vi_textmod = "_*\\AaIiCcDdPpYyRrSsXx~"
|
|
|
|
# Arrays for the saved marks.
|
|
@vi_mark_chars = Array.new(26,-1)
|
|
|
|
@emacs_standard_keymap = {
|
|
"\C-@" => :rl_set_mark ,
|
|
"\C-a" => :rl_beg_of_line ,
|
|
"\C-b" => :rl_backward_char ,
|
|
"\C-d" => :rl_delete ,
|
|
"\C-e" => :rl_end_of_line ,
|
|
"\C-f" => :rl_forward_char ,
|
|
"\C-g" => :rl_abort ,
|
|
"\C-h" => :rl_rubout ,
|
|
"\C-i" => :rl_complete ,
|
|
"\C-j" => :rl_newline ,
|
|
"\C-k" => :rl_kill_line ,
|
|
"\C-l" => :rl_clear_screen ,
|
|
"\C-m" => :rl_newline ,
|
|
"\C-n" => :rl_get_next_history ,
|
|
"\C-p" => :rl_get_previous_history ,
|
|
"\C-q" => :rl_quoted_insert ,
|
|
"\C-r" => :rl_reverse_search_history ,
|
|
"\C-s" => :rl_forward_search_history ,
|
|
"\C-t" => :rl_transpose_chars ,
|
|
"\C-u" => :rl_unix_line_discard ,
|
|
"\C-v" => :rl_quoted_insert ,
|
|
"\C-w" => :rl_unix_word_rubout ,
|
|
"\C-y" => :rl_yank ,
|
|
"\C-]" => :rl_char_search ,
|
|
"\C-_" => :rl_undo_command ,
|
|
"\x7F" => :rl_rubout ,
|
|
"\e\C-g" => :rl_abort ,
|
|
"\e\C-h" => :rl_backward_kill_word ,
|
|
"\e\C-i" => :rl_tab_insert ,
|
|
"\e\C-j" => :rl_vi_editing_mode ,
|
|
"\e\C-m" => :rl_vi_editing_mode ,
|
|
"\e\C-r" => :rl_revert_line ,
|
|
"\e\C-y" => :rl_yank_nth_arg ,
|
|
"\e\C-[" => :rl_complete ,
|
|
"\e\C-]" => :rl_backward_char_search ,
|
|
"\e " => :rl_set_mark ,
|
|
"\e#" => :rl_insert_comment ,
|
|
"\e&" => :rl_tilde_expand ,
|
|
"\e*" => :rl_insert_completions ,
|
|
"\e-" => :rl_digit_argument ,
|
|
"\e." => :rl_yank_last_arg ,
|
|
"\e0" => :rl_digit_argument ,
|
|
"\e1" => :rl_digit_argument ,
|
|
"\e2" => :rl_digit_argument ,
|
|
"\e3" => :rl_digit_argument ,
|
|
"\e4" => :rl_digit_argument ,
|
|
"\e5" => :rl_digit_argument ,
|
|
"\e6" => :rl_digit_argument ,
|
|
"\e7" => :rl_digit_argument ,
|
|
"\e8" => :rl_digit_argument ,
|
|
"\e9" => :rl_digit_argument ,
|
|
"\e<" => :rl_beginning_of_history ,
|
|
"\e=" => :rl_possible_completions ,
|
|
"\e>" => :rl_end_of_history ,
|
|
"\e?" => :rl_possible_completions ,
|
|
"\eB" => :rl_backward_word ,
|
|
"\eC" => :rl_capitalize_word ,
|
|
"\eD" => :rl_kill_word ,
|
|
"\eF" => :rl_forward_word ,
|
|
"\eL" => :rl_downcase_word ,
|
|
"\eN" => :rl_noninc_forward_search ,
|
|
"\eP" => :rl_noninc_reverse_search ,
|
|
"\eR" => :rl_revert_line ,
|
|
"\eT" => :rl_transpose_words ,
|
|
"\eU" => :rl_upcase_word ,
|
|
"\eY" => :rl_yank_pop ,
|
|
"\e\\" => :rl_delete_horizontal_space ,
|
|
"\e_" => :rl_yank_last_arg ,
|
|
"\eb" => :rl_backward_word ,
|
|
"\ec" => :rl_capitalize_word ,
|
|
"\ed" => :rl_kill_word ,
|
|
"\ef" => :rl_forward_word ,
|
|
"\el" => :rl_downcase_word ,
|
|
"\en" => :rl_noninc_forward_search ,
|
|
"\ep" => :rl_noninc_reverse_search ,
|
|
"\er" => :rl_revert_line ,
|
|
"\et" => :rl_transpose_words ,
|
|
"\eu" => :rl_upcase_word ,
|
|
"\ey" => :rl_yank_pop ,
|
|
"\e~" => :rl_tilde_expand ,
|
|
"\377" => :rl_backward_kill_word ,
|
|
|
|
"\C-x\C-g" => :rl_abort ,
|
|
"\C-x\C-r" => :rl_re_read_init_file ,
|
|
"\C-x\C-u" => :rl_undo_command ,
|
|
"\C-x\C-x" => :rl_exchange_point_and_mark ,
|
|
"\C-x(" => :rl_start_kbd_macro ,
|
|
"\C-x)" => :rl_end_kbd_macro ,
|
|
"\C-xE" => :rl_call_last_kbd_macro ,
|
|
"\C-xe" => :rl_call_last_kbd_macro ,
|
|
"\C-x\x7F" => :rl_backward_kill_line
|
|
}
|
|
|
|
@vi_movement_keymap = {
|
|
"\C-d" => :rl_vi_eof_maybe ,
|
|
"\C-e" => :rl_emacs_editing_mode ,
|
|
"\C-g" => :rl_abort ,
|
|
"\C-h" => :rl_backward_char ,
|
|
"\C-j" => :rl_newline ,
|
|
"\C-k" => :rl_kill_line ,
|
|
"\C-l" => :rl_clear_screen ,
|
|
"\C-m" => :rl_newline ,
|
|
"\C-n" => :rl_get_next_history ,
|
|
"\C-p" => :rl_get_previous_history ,
|
|
"\C-q" => :rl_quoted_insert ,
|
|
"\C-r" => :rl_reverse_search_history ,
|
|
"\C-s" => :rl_forward_search_history ,
|
|
"\C-t" => :rl_transpose_chars ,
|
|
"\C-u" => :rl_unix_line_discard ,
|
|
"\C-v" => :rl_quoted_insert ,
|
|
"\C-w" => :rl_unix_word_rubout ,
|
|
"\C-y" => :rl_yank ,
|
|
"\C-_" => :rl_vi_undo ,
|
|
" " => :rl_forward_char ,
|
|
"#" => :rl_insert_comment ,
|
|
"$" => :rl_end_of_line ,
|
|
"%" => :rl_vi_match ,
|
|
"&" => :rl_vi_tilde_expand ,
|
|
"*" => :rl_vi_complete ,
|
|
"+" => :rl_get_next_history ,
|
|
"," => :rl_vi_char_search ,
|
|
"-" => :rl_get_previous_history ,
|
|
"." => :rl_vi_redo ,
|
|
"/" => :rl_vi_search ,
|
|
"0" => :rl_beg_of_line ,
|
|
"1" => :rl_vi_arg_digit ,
|
|
"2" => :rl_vi_arg_digit ,
|
|
"3" => :rl_vi_arg_digit ,
|
|
"4" => :rl_vi_arg_digit ,
|
|
"5" => :rl_vi_arg_digit ,
|
|
"6" => :rl_vi_arg_digit ,
|
|
"7" => :rl_vi_arg_digit ,
|
|
"8" => :rl_vi_arg_digit ,
|
|
"9" => :rl_vi_arg_digit ,
|
|
"" => :rl_vi_char_search ,
|
|
"=" => :rl_vi_complete ,
|
|
"?" => :rl_vi_search ,
|
|
"A" => :rl_vi_append_eol ,
|
|
"B" => :rl_vi_prev_word ,
|
|
"C" => :rl_vi_change_to ,
|
|
"D" => :rl_vi_delete_to ,
|
|
"E" => :rl_vi_end_word ,
|
|
"F" => :rl_vi_char_search ,
|
|
"G" => :rl_vi_fetch_history ,
|
|
"I" => :rl_vi_insert_beg ,
|
|
"N" => :rl_vi_search_again ,
|
|
"P" => :rl_vi_put ,
|
|
"R" => :rl_vi_replace ,
|
|
"S" => :rl_vi_subst ,
|
|
"T" => :rl_vi_char_search ,
|
|
"U" => :rl_revert_line ,
|
|
"W" => :rl_vi_next_word ,
|
|
"X" => :rl_vi_rubout ,
|
|
"Y" => :rl_vi_yank_to ,
|
|
"\\" => :rl_vi_complete ,
|
|
"^" => :rl_vi_first_print ,
|
|
"_" => :rl_vi_yank_arg ,
|
|
"`" => :rl_vi_goto_mark ,
|
|
"a" => :rl_vi_append_mode ,
|
|
"b" => :rl_vi_prev_word ,
|
|
"c" => :rl_vi_change_to ,
|
|
"d" => :rl_vi_delete_to ,
|
|
"e" => :rl_vi_end_word ,
|
|
"f" => :rl_vi_char_search ,
|
|
"h" => :rl_backward_char ,
|
|
"i" => :rl_vi_insertion_mode ,
|
|
"j" => :rl_get_next_history ,
|
|
"k" => :rl_get_previous_history ,
|
|
"l" => :rl_forward_char ,
|
|
"m" => :rl_vi_set_mark ,
|
|
"n" => :rl_vi_search_again ,
|
|
"p" => :rl_vi_put ,
|
|
"r" => :rl_vi_change_char ,
|
|
"s" => :rl_vi_subst ,
|
|
"t" => :rl_vi_char_search ,
|
|
"u" => :rl_vi_undo ,
|
|
"w" => :rl_vi_next_word ,
|
|
"x" => :rl_vi_delete ,
|
|
"y" => :rl_vi_yank_to ,
|
|
"|" => :rl_vi_column ,
|
|
"~" => :rl_vi_change_case
|
|
}
|
|
|
|
@vi_insertion_keymap = {
|
|
"\C-a" => :rl_insert ,
|
|
"\C-b" => :rl_insert ,
|
|
"\C-c" => :rl_insert ,
|
|
"\C-d" => :rl_vi_eof_maybe ,
|
|
"\C-e" => :rl_insert ,
|
|
"\C-f" => :rl_insert ,
|
|
"\C-g" => :rl_insert ,
|
|
"\C-h" => :rl_rubout ,
|
|
"\C-i" => :rl_complete ,
|
|
"\C-j" => :rl_newline ,
|
|
"\C-k" => :rl_insert ,
|
|
"\C-l" => :rl_insert ,
|
|
"\C-m" => :rl_newline ,
|
|
"\C-n" => :rl_insert ,
|
|
"\C-o" => :rl_insert ,
|
|
"\C-p" => :rl_insert ,
|
|
"\C-q" => :rl_insert ,
|
|
"\C-r" => :rl_reverse_search_history ,
|
|
"\C-s" => :rl_forward_search_history ,
|
|
"\C-t" => :rl_transpose_chars ,
|
|
"\C-u" => :rl_unix_line_discard ,
|
|
"\C-v" => :rl_quoted_insert ,
|
|
"\C-w" => :rl_unix_word_rubout ,
|
|
"\C-x" => :rl_insert ,
|
|
"\C-y" => :rl_yank ,
|
|
"\C-z" => :rl_insert ,
|
|
# "\C-[" => :rl_vi_movement_mode,
|
|
# XXX: NOT IMPLEMENTED
|
|
"\C-\\" => :rl_insert ,
|
|
"\C-]" => :rl_insert ,
|
|
"\C-^" => :rl_insert ,
|
|
"\C-_" => :rl_vi_undo ,
|
|
"\x7F" => :rl_rubout
|
|
}
|
|
|
|
@rl_library_version = RL_LIBRARY_VERSION
|
|
|
|
@rl_readline_version = RL_READLINE_VERSION
|
|
|
|
@rl_readline_name = "other"
|
|
|
|
@rl_getc_function = :rl_getc
|
|
|
|
# Non-zero tells rl_delete_text and rl_insert_text to not add to
|
|
# the undo list.
|
|
@_rl_doing_an_undo = false
|
|
|
|
# How many unclosed undo groups we currently have.
|
|
@_rl_undo_group_level = 0
|
|
|
|
# The current undo list for THE_LINE.
|
|
@rl_undo_list = nil
|
|
|
|
# Application-specific redisplay function.
|
|
@rl_redisplay_function = :rl_redisplay
|
|
|
|
# Global variables declared here.
|
|
# What YOU turn on when you have handled all redisplay yourself.
|
|
@rl_display_fixed = false
|
|
|
|
@_rl_suppress_redisplay = 0
|
|
@_rl_want_redisplay = false
|
|
|
|
# The stuff that gets printed out before the actual text of the line.
|
|
# This is usually pointing to rl_prompt.
|
|
@rl_display_prompt = nil
|
|
|
|
# True if this is `real' readline as opposed to some stub substitute.
|
|
@rl_gnu_readline_p = true
|
|
|
|
for i in 32 .. 255
|
|
@emacs_standard_keymap[i.chr] = :rl_insert unless @emacs_standard_keymap[i.chr]
|
|
@vi_insertion_keymap[i.chr] = :rl_insert unless @vi_insertion_keymap[i.chr]
|
|
end
|
|
# A pointer to the keymap that is currently in use.
|
|
# By default, it is the standard emacs keymap.
|
|
@_rl_keymap = @emacs_standard_keymap
|
|
|
|
|
|
# The current style of editing.
|
|
@rl_editing_mode = @emacs_mode
|
|
|
|
# The current insert mode: input (the default) or overwrite
|
|
@rl_insert_mode = RL_IM_DEFAULT
|
|
|
|
# Non-zero if we called this function from _rl_dispatch(). It's present
|
|
# so functions can find out whether they were called from a key binding
|
|
# or directly from an application.
|
|
@rl_dispatching = false
|
|
|
|
# Non-zero if the previous command was a kill command.
|
|
@_rl_last_command_was_kill = false
|
|
|
|
# The current value of the numeric argument specified by the user.
|
|
@rl_numeric_arg = 1
|
|
|
|
# Non-zero if an argument was typed.
|
|
@rl_explicit_arg = false
|
|
|
|
# Temporary value used while generating the argument.
|
|
@rl_arg_sign = 1
|
|
|
|
# Non-zero means we have been called at least once before.
|
|
@rl_initialized = false
|
|
|
|
# Flags word encapsulating the current readline state.
|
|
@rl_readline_state = RL_STATE_NONE
|
|
|
|
# The current offset in the current input line.
|
|
@rl_point = 0
|
|
|
|
# Mark in the current input line.
|
|
@rl_mark = 0
|
|
|
|
# Length of the current input line.
|
|
@rl_end = 0
|
|
|
|
# Make this non-zero to return the current input_line.
|
|
@rl_done = false
|
|
|
|
# The last function executed by readline.
|
|
@rl_last_func = nil
|
|
|
|
# Top level environment for readline_internal ().
|
|
@readline_top_level = nil
|
|
|
|
# The streams we interact with.
|
|
@_rl_in_stream = nil
|
|
@_rl_out_stream = nil
|
|
|
|
# The names of the streams that we do input and output to.
|
|
@rl_instream = nil
|
|
@rl_outstream = nil
|
|
|
|
@pop_index = 0
|
|
@push_index = 0
|
|
@ibuffer = 0.chr * 512
|
|
@ibuffer_len = @ibuffer.length - 1
|
|
|
|
|
|
# Non-zero means echo characters as they are read. Defaults to no echo
|
|
# set to 1 if there is a controlling terminal, we can get its attributes,
|
|
# and the attributes include `echo'. Look at rltty.c:prepare_terminal_settings
|
|
# for the code that sets it.
|
|
@readline_echoing_p = false
|
|
|
|
# Current prompt.
|
|
@rl_prompt = nil
|
|
@rl_visible_prompt_length = 0
|
|
|
|
# Set to non-zero by calling application if it has already printed rl_prompt
|
|
# and does not want readline to do it the first time.
|
|
@rl_already_prompted = false
|
|
|
|
# The number of characters read in order to type this complete command.
|
|
@rl_key_sequence_length = 0
|
|
|
|
# If non-zero, then this is the address of a function to call just
|
|
# before readline_internal_setup () prints the first prompt.
|
|
@rl_startup_hook = nil
|
|
|
|
# If non-zero, this is the address of a function to call just before
|
|
# readline_internal_setup () returns and readline_internal starts
|
|
# reading input characters.
|
|
@rl_pre_input_hook = nil
|
|
|
|
# The character that can generate an EOF. Really read from
|
|
# the terminal driver... just defaulted here.
|
|
@_rl_eof_char = "\cD"
|
|
|
|
# Non-zero makes this the next keystroke to read.
|
|
@rl_pending_input = 0
|
|
|
|
# Pointer to a useful terminal name.
|
|
@rl_terminal_name = nil
|
|
|
|
# Non-zero means to always use horizontal scrolling in line display.
|
|
@_rl_horizontal_scroll_mode = false
|
|
|
|
# Non-zero means to display an asterisk at the starts of history lines
|
|
# which have been modified.
|
|
@_rl_mark_modified_lines = false
|
|
|
|
# The style of `bell' notification preferred. This can be set to NO_BELL,
|
|
# AUDIBLE_BELL, or VISIBLE_BELL.
|
|
@_rl_bell_preference = AUDIBLE_BELL
|
|
|
|
# String inserted into the line by rl_insert_comment ().
|
|
@_rl_comment_begin = nil
|
|
|
|
# Keymap holding the function currently being executed.
|
|
@rl_executing_keymap = nil
|
|
|
|
# Keymap we're currently using to dispatch.
|
|
@_rl_dispatching_keymap = nil
|
|
|
|
# Non-zero means to erase entire line, including prompt, on empty input lines.
|
|
@rl_erase_empty_line = false
|
|
|
|
# Non-zero means to read only this many characters rather than up to a
|
|
# character bound to accept-line.
|
|
@rl_num_chars_to_read = 0
|
|
|
|
# Line buffer and maintenence.
|
|
@rl_line_buffer = nil
|
|
|
|
# Key sequence `contexts'
|
|
@_rl_kscxt = nil
|
|
|
|
# Non-zero means do not parse any lines other than comments and
|
|
# parser directives.
|
|
@_rl_parsing_conditionalized_out = false
|
|
|
|
# Non-zero means to convert characters with the meta bit set to
|
|
# escape-prefixed characters so we can indirect through
|
|
# emacs_meta_keymap or vi_escape_keymap.
|
|
@_rl_convert_meta_chars_to_ascii = true
|
|
|
|
# Non-zero means to output characters with the meta bit set directly
|
|
# rather than as a meta-prefixed escape sequence.
|
|
@_rl_output_meta_chars = false
|
|
|
|
# Non-zero means to look at the termios special characters and bind
|
|
# them to equivalent readline functions at startup.
|
|
@_rl_bind_stty_chars = true
|
|
|
|
@rl_completion_display_matches_hook = nil
|
|
|
|
XOK = 1
|
|
|
|
@_rl_term_clreol = nil
|
|
@_rl_term_clrpag = nil
|
|
@_rl_term_cr = nil
|
|
@_rl_term_backspace = nil
|
|
@_rl_term_goto = nil
|
|
@_rl_term_pc = nil
|
|
|
|
# Non-zero if we determine that the terminal can do character insertion.
|
|
@_rl_terminal_can_insert = false
|
|
|
|
# How to insert characters.
|
|
@_rl_term_im = nil
|
|
@_rl_term_ei = nil
|
|
@_rl_term_ic = nil
|
|
@_rl_term_ip = nil
|
|
@_rl_term_IC = nil
|
|
|
|
# How to delete characters.
|
|
@_rl_term_dc = nil
|
|
@_rl_term_DC = nil
|
|
|
|
@_rl_term_forward_char = nil
|
|
|
|
# How to go up a line.
|
|
@_rl_term_up = nil
|
|
|
|
# A visible bell; char if the terminal can be made to flash the screen.
|
|
@_rl_visible_bell = nil
|
|
|
|
# Non-zero means the terminal can auto-wrap lines.
|
|
@_rl_term_autowrap = true
|
|
|
|
# Non-zero means that this terminal has a meta key.
|
|
@term_has_meta = 0
|
|
|
|
# The sequences to write to turn on and off the meta key, if this
|
|
# terminal has one.
|
|
@_rl_term_mm = nil
|
|
@_rl_term_mo = nil
|
|
|
|
# The key sequences output by the arrow keys, if this terminal has any.
|
|
@_rl_term_ku = nil
|
|
@_rl_term_kd = nil
|
|
@_rl_term_kr = nil
|
|
@_rl_term_kl = nil
|
|
|
|
# How to initialize and reset the arrow keys, if this terminal has any.
|
|
@_rl_term_ks = nil
|
|
@_rl_term_ke = nil
|
|
|
|
# The key sequences sent by the Home and End keys, if any.
|
|
@_rl_term_kh = nil
|
|
@_rl_term_kH = nil
|
|
@_rl_term_at7 = nil
|
|
|
|
# Delete key
|
|
@_rl_term_kD = nil
|
|
|
|
# Insert key
|
|
@_rl_term_kI = nil
|
|
|
|
# Cursor control
|
|
@_rl_term_vs = nil # very visible
|
|
@_rl_term_ve = nil # normal
|
|
|
|
# Variables that hold the screen dimensions, used by the display code.
|
|
@_rl_screenwidth = @_rl_screenheight = @_rl_screenchars = 0
|
|
|
|
# Non-zero means the user wants to enable the keypad.
|
|
@_rl_enable_keypad = false
|
|
|
|
# Non-zero means the user wants to enable a meta key.
|
|
@_rl_enable_meta = true
|
|
|
|
# ****************************************************************
|
|
#
|
|
# Completion matching, from readline's point of view.
|
|
#
|
|
# ****************************************************************
|
|
|
|
# Variables known only to the readline library.
|
|
|
|
# If non-zero, non-unique completions always show the list of matches.
|
|
@_rl_complete_show_all = false
|
|
|
|
# If non-zero, non-unique completions show the list of matches, unless it
|
|
# is not possible to do partial completion and modify the line.
|
|
@_rl_complete_show_unmodified = false
|
|
|
|
# If non-zero, completed directory names have a slash appended.
|
|
@_rl_complete_mark_directories = true
|
|
|
|
# If non-zero, the symlinked directory completion behavior introduced in
|
|
# readline-4.2a is disabled, and symlinks that point to directories have
|
|
# a slash appended (subject to the value of _rl_complete_mark_directories).
|
|
# This is user-settable via the mark-symlinked-directories variable.
|
|
@_rl_complete_mark_symlink_dirs = false
|
|
|
|
# If non-zero, completions are printed horizontally in alphabetical order,
|
|
# like `ls -x'.
|
|
@_rl_print_completions_horizontally = false
|
|
|
|
@_rl_completion_case_fold = false
|
|
|
|
# If non-zero, don't match hidden files (filenames beginning with a `.' on
|
|
# Unix) when doing filename completion.
|
|
@_rl_match_hidden_files = true
|
|
|
|
# Global variables available to applications using readline.
|
|
|
|
# Non-zero means add an additional character to each filename displayed
|
|
# during listing completion iff rl_filename_completion_desired which helps
|
|
# to indicate the type of file being listed.
|
|
@rl_visible_stats = false
|
|
|
|
# If non-zero, then this is the address of a function to call when
|
|
# completing on a directory name. The function is called with
|
|
# the address of a string (the current directory name) as an arg.
|
|
@rl_directory_completion_hook = nil
|
|
|
|
@rl_directory_rewrite_hook = nil
|
|
|
|
# Non-zero means readline completion functions perform tilde expansion.
|
|
@rl_complete_with_tilde_expansion = false
|
|
|
|
# Pointer to the generator function for completion_matches ().
|
|
# NULL means to use rl_filename_completion_function (), the default filename
|
|
# completer.
|
|
@rl_completion_entry_function = nil
|
|
|
|
# Pointer to alternative function to create matches.
|
|
# Function is called with TEXT, START, and END.
|
|
# START and END are indices in RL_LINE_BUFFER saying what the boundaries
|
|
# of TEXT are.
|
|
# If this function exists and returns NULL then call the value of
|
|
# rl_completion_entry_function to try to match, otherwise use the
|
|
# array of strings returned.
|
|
@rl_attempted_completion_function = nil
|
|
|
|
# Non-zero means to suppress normal filename completion after the
|
|
# user-specified completion function has been called.
|
|
@rl_attempted_completion_over = false
|
|
|
|
# Set to a character indicating the type of completion being performed
|
|
# by rl_complete_internal, available for use by application completion
|
|
# functions.
|
|
@rl_completion_type = 0
|
|
|
|
# Up to this many items will be displayed in response to a
|
|
# possible-completions call. After that, we ask the user if
|
|
# she is sure she wants to see them all. A negative value means
|
|
# don't ask.
|
|
@rl_completion_query_items = 100
|
|
|
|
@_rl_page_completions = 1
|
|
|
|
# The basic list of characters that signal a break between words for the
|
|
# completer routine. The contents of this variable is what breaks words
|
|
# in the shell, i.e. " \t\n\"\\'`@$><="
|
|
@rl_basic_word_break_characters = " \t\n\"\\'`@$><=|&{(" # })
|
|
|
|
# List of basic quoting characters.
|
|
@rl_basic_quote_characters = "\"'"
|
|
|
|
# The list of characters that signal a break between words for
|
|
# rl_complete_internal. The default list is the contents of
|
|
# rl_basic_word_break_characters.
|
|
@rl_completer_word_break_characters = nil
|
|
|
|
# Hook function to allow an application to set the completion word
|
|
# break characters before readline breaks up the line. Allows
|
|
# position-dependent word break characters.
|
|
@rl_completion_word_break_hook = nil
|
|
|
|
# List of characters which can be used to quote a substring of the line.
|
|
# Completion occurs on the entire substring, and within the substring
|
|
# rl_completer_word_break_characters are treated as any other character,
|
|
# unless they also appear within this list.
|
|
@rl_completer_quote_characters = nil
|
|
|
|
# List of characters that should be quoted in filenames by the completer.
|
|
@rl_filename_quote_characters = nil
|
|
|
|
# List of characters that are word break characters, but should be left
|
|
# in TEXT when it is passed to the completion function. The shell uses
|
|
# this to help determine what kind of completing to do.
|
|
@rl_special_prefixes = nil
|
|
|
|
# If non-zero, then disallow duplicates in the matches.
|
|
@rl_ignore_completion_duplicates = true
|
|
|
|
# Non-zero means that the results of the matches are to be treated
|
|
# as filenames. This is ALWAYS zero on entry, and can only be changed
|
|
# within a completion entry finder function.
|
|
@rl_filename_completion_desired = false
|
|
|
|
# Non-zero means that the results of the matches are to be quoted using
|
|
# double quotes (or an application-specific quoting mechanism) if the
|
|
# filename contains any characters in rl_filename_quote_chars. This is
|
|
# ALWAYS non-zero on entry, and can only be changed within a completion
|
|
# entry finder function.
|
|
@rl_filename_quoting_desired = true
|
|
|
|
# This function, if defined, is called by the completer when real
|
|
# filename completion is done, after all the matching names have been
|
|
# generated. It is passed a (char**) known as matches in the code below.
|
|
# It consists of a NULL-terminated array of pointers to potential
|
|
# matching strings. The 1st element (matches[0]) is the maximal
|
|
# substring that is common to all matches. This function can re-arrange
|
|
# the list of matches as required, but all elements of the array must be
|
|
# free()'d if they are deleted. The main intent of this function is
|
|
# to implement FIGNORE a la SunOS csh.
|
|
@rl_ignore_some_completions_function = nil
|
|
|
|
# Set to a function to quote a filename in an application-specific fashion.
|
|
# Called with the text to quote, the type of match found (single or multiple)
|
|
# and a pointer to the quoting character to be used, which the function can
|
|
# reset if desired.
|
|
#rl_filename_quoting_function = rl_quote_filename
|
|
|
|
# Function to call to remove quoting characters from a filename. Called
|
|
# before completion is attempted, so the embedded quotes do not interfere
|
|
# with matching names in the file system. Readline doesn't do anything
|
|
# with this it's set only by applications.
|
|
@rl_filename_dequoting_function = nil
|
|
|
|
# Function to call to decide whether or not a word break character is
|
|
# quoted. If a character is quoted, it does not break words for the
|
|
# completer.
|
|
@rl_char_is_quoted_p = nil
|
|
|
|
# If non-zero, the completion functions don't append anything except a
|
|
# possible closing quote. This is set to 0 by rl_complete_internal and
|
|
# may be changed by an application-specific completion function.
|
|
@rl_completion_suppress_append = false
|
|
|
|
# Character appended to completed words when at the end of the line. The
|
|
# default is a space.
|
|
@rl_completion_append_character = ' '
|
|
|
|
# If non-zero, the completion functions don't append any closing quote.
|
|
# This is set to 0 by rl_complete_internal and may be changed by an
|
|
# application-specific completion function.
|
|
@rl_completion_suppress_quote = false
|
|
|
|
# Set to any quote character readline thinks it finds before any application
|
|
# completion function is called.
|
|
@rl_completion_quote_character = 0
|
|
|
|
# Set to a non-zero value if readline found quoting anywhere in the word to
|
|
# be completed set before any application completion function is called.
|
|
@rl_completion_found_quote = false
|
|
|
|
# If non-zero, a slash will be appended to completed filenames that are
|
|
# symbolic links to directory names, subject to the value of the
|
|
# mark-directories variable (which is user-settable). This exists so
|
|
# that application completion functions can override the user's preference
|
|
# (set via the mark-symlinked-directories variable) if appropriate.
|
|
# It's set to the value of _rl_complete_mark_symlink_dirs in
|
|
# rl_complete_internal before any application-specific completion
|
|
# function is called, so without that function doing anything, the user's
|
|
# preferences are honored.
|
|
@rl_completion_mark_symlink_dirs = false
|
|
|
|
# If non-zero, inhibit completion (temporarily).
|
|
@rl_inhibit_completion = false
|
|
|
|
# Variables local to this file.
|
|
|
|
# Local variable states what happened during the last completion attempt.
|
|
@completion_changed_buffer = nil
|
|
|
|
# Non-zero means treat 0200 bit in terminal input as Meta bit.
|
|
@_rl_meta_flag = false
|
|
|
|
# Stack of previous values of parsing_conditionalized_out.
|
|
@if_stack = []
|
|
@if_stack_depth = 0
|
|
|
|
|
|
# The last key bindings file read.
|
|
@last_readline_init_file = nil
|
|
|
|
# The file we're currently reading key bindings from.
|
|
@current_readline_init_file = nil
|
|
@current_readline_init_include_level = 0
|
|
@current_readline_init_lineno = 0
|
|
|
|
ENV["HOME"] ||= ENV["HOMEDRIVE"]+ENV["HOMEPATH"]
|
|
|
|
@directory = nil
|
|
@filename = nil
|
|
@dirname = nil
|
|
@users_dirname = nil
|
|
@filename_len = 0
|
|
|
|
attr_accessor :rl_attempted_completion_function,:rl_deprep_term_function,
|
|
:rl_event_hook,:rl_attempted_completion_over,:rl_basic_quote_characters,
|
|
:rl_basic_word_break_characters,:rl_completer_quote_characters,
|
|
:rl_completer_word_break_characters,:rl_completion_append_character,
|
|
:rl_filename_quote_characters,:rl_instream,:rl_library_version,:rl_outstream,
|
|
:rl_readline_name,:history_length,:history_base
|
|
|
|
module_function
|
|
# Okay, now we write the entry_function for filename completion. In the
|
|
# general case. Note that completion in the shell is a little different
|
|
# because of all the pathnames that must be followed when looking up the
|
|
# completion for a command.
|
|
def rl_filename_completion_function(text, state)
|
|
# If we don't have any state, then do some initialization.
|
|
if (state == 0)
|
|
# If we were interrupted before closing the directory or reading
|
|
#all of its contents, close it.
|
|
if(@directory)
|
|
@directory.close
|
|
@directory = nil
|
|
end
|
|
text.delete!(0.chr)
|
|
@filename = text.dup
|
|
if text.length == 0
|
|
text = "."
|
|
end
|
|
@dirname = File.dirname(text)
|
|
# We aren't done yet. We also support the "~user" syntax.
|
|
|
|
# Save the version of the directory that the user typed.
|
|
@users_dirname = @dirname.dup
|
|
|
|
if (@dirname[0] == ?~)
|
|
@dirname = File.expand_path(@dirname)
|
|
end
|
|
|
|
# The directory completion hook should perform any necessary
|
|
# dequoting.
|
|
if (@rl_directory_completion_hook && send(rl_directory_completion_hook,@dirname))
|
|
@users_dirname = @dirname.dup
|
|
elsif (@rl_completion_found_quote && @rl_filename_dequoting_function)
|
|
# delete single and double quotes
|
|
@temp = send(@rl_filename_dequoting_function,@users_dirname, @rl_completion_quote_character)
|
|
@users_dirname = temp
|
|
end
|
|
|
|
@directory = Dir.new(@dirname)
|
|
|
|
# Now dequote a non-null filename.
|
|
if (@filename && @filename.length>0 && @rl_completion_found_quote && @rl_filename_dequoting_function)
|
|
# delete single and double quotes
|
|
temp = send(@rl_filename_dequoting_function,@filename, @rl_completion_quote_character)
|
|
@filename = temp
|
|
end
|
|
|
|
@filename_len = @filename.length
|
|
@rl_filename_completion_desired = true
|
|
end
|
|
|
|
# At this point we should entertain the possibility of hacking wildcarded
|
|
# filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
|
|
# contains globbing characters, then build an array of directories, and
|
|
# then map over that list while completing.
|
|
# *** UNIMPLEMENTED ***
|
|
|
|
# Now that we have some state, we can read the directory.
|
|
entry = nil
|
|
while(@directory && (entry = @directory.read))
|
|
d_name = entry
|
|
# Special case for no filename. If the user has disabled the
|
|
# `match-hidden-files' variable, skip filenames beginning with `.'.
|
|
#All other entries except "." and ".." match.
|
|
if (@filename_len == 0)
|
|
if (!@_rl_match_hidden_files && d_name[0]==?.)
|
|
next
|
|
end
|
|
if (d_name != '.' && d_name != '..')
|
|
break
|
|
end
|
|
else
|
|
# Otherwise, if these match up to the length of filename, then
|
|
# it is a match.
|
|
|
|
if (@_rl_completion_case_fold)
|
|
break if d_name =~ /^#{Regexp.escape(@filename)}/i
|
|
else
|
|
break if d_name =~ /^#{Regexp.escape(@filename)}/
|
|
end
|
|
end
|
|
end
|
|
|
|
if entry.nil?
|
|
if @directory
|
|
@directory.close
|
|
@directory = nil
|
|
end
|
|
@dirname = nil
|
|
@filename = nil
|
|
@users_dirname = nil
|
|
|
|
return nil
|
|
else
|
|
if (@dirname != '.')
|
|
if (@rl_complete_with_tilde_expansion && @users_dirname[0] == ?~)
|
|
temp = @dirname
|
|
if(temp[-1] != ?/)
|
|
temp += '/'
|
|
end
|
|
else
|
|
temp = @users_dirname
|
|
if(temp[-1] != ?/)
|
|
temp += '/'
|
|
end
|
|
end
|
|
temp += entry
|
|
else
|
|
temp = entry.dup
|
|
end
|
|
return (temp)
|
|
end
|
|
end
|
|
|
|
# A completion function for usernames.
|
|
# TEXT contains a partial username preceded by a random
|
|
# character (usually `~').
|
|
def rl_username_completion_function(text, state)
|
|
return nil if RUBY_PLATFORM =~ /mswin|mingw/
|
|
|
|
if (state == 0)
|
|
first_char = text[0]
|
|
first_char_loc = (text[0] == ?~ ? 1 : 0)
|
|
|
|
username = text[first_char_loc..-1]
|
|
namelen = username.length
|
|
Etc.setpwent()
|
|
end
|
|
|
|
while (entry = Etc.getpwent())
|
|
# Null usernames should result in all users as possible completions.
|
|
break if (namelen == 0 || entry.name =~ /^#{username}/ )
|
|
end
|
|
|
|
if entry.nil?
|
|
Etc.endpwent()
|
|
return nil
|
|
else
|
|
value = text.dup
|
|
value[first_char_loc..-1] = entry.name
|
|
|
|
if (first_char == ?~)
|
|
@rl_filename_completion_desired = true
|
|
end
|
|
|
|
return (value)
|
|
end
|
|
end
|
|
|
|
#*************************************************************
|
|
#
|
|
# Application-callable completion match generator functions
|
|
#
|
|
#*************************************************************
|
|
|
|
# Return an array of (char *) which is a list of completions for TEXT.
|
|
# If there are no completions, return a NULL pointer.
|
|
# The first entry in the returned array is the substitution for TEXT.
|
|
# The remaining entries are the possible completions.
|
|
# The array is terminated with a NULL pointer.
|
|
#
|
|
# ENTRY_FUNCTION is a function of two args, and returns a (char *).
|
|
# The first argument is TEXT.
|
|
# The second is a state argument it should be zero on the first call, and
|
|
# non-zero on subsequent calls. It returns a NULL pointer to the caller
|
|
# when there are no more matches.
|
|
#
|
|
def rl_completion_matches(text, entry_function)
|
|
matches = 0
|
|
match_list_size = 10
|
|
match_list = []
|
|
match_list[1] = nil
|
|
while (string = send(entry_function, text, matches))
|
|
match_list[matches+=1] = string
|
|
match_list[matches+1] = nil
|
|
end
|
|
|
|
# If there were any matches, then look through them finding out the
|
|
# lowest common denominator. That then becomes match_list[0].
|
|
if (matches!=0)
|
|
compute_lcd_of_matches(match_list, matches, text)
|
|
else # There were no matches.
|
|
match_list = nil
|
|
end
|
|
return (match_list)
|
|
end
|
|
|
|
def _rl_to_lower(char)
|
|
char.nil? ? nil : char.chr.downcase
|
|
end
|
|
|
|
# Find the common prefix of the list of matches, and put it into
|
|
# matches[0].
|
|
def compute_lcd_of_matches(match_list, matches, text)
|
|
# If only one match, just use that. Otherwise, compare each
|
|
# member of the list with the next, finding out where they
|
|
# stop matching.
|
|
if (matches == 1)
|
|
match_list[0] = match_list[1]
|
|
match_list[1] = nil
|
|
return 1
|
|
end
|
|
|
|
i = 1
|
|
low = 100000
|
|
while(i<matches)
|
|
if (@_rl_completion_case_fold)
|
|
si = 0
|
|
while((c1 = _rl_to_lower(match_list[i][si])) &&
|
|
(c2 = _rl_to_lower(match_list[i + 1][si])))
|
|
if !@rl_byte_oriented
|
|
if(!_rl_compare_chars(match_list[i],si,match_list[i+1],si))
|
|
break
|
|
elsif ((v = _rl_get_char_len(match_list[i][si..-1])) > 1)
|
|
si += v - 1
|
|
end
|
|
else
|
|
break if (c1 != c2)
|
|
end
|
|
si += 1
|
|
end
|
|
else
|
|
si = 0
|
|
while((c1 = match_list[i][si]) &&
|
|
(c2 = match_list[i + 1][si]))
|
|
if !@rl_byte_oriented
|
|
if(!_rl_compare_chars(match_list[i],si,match_list[i+1],si))
|
|
break
|
|
elsif ((v = _rl_get_char_len(match_list[i][si..-1])) > 1)
|
|
si += v - 1
|
|
end
|
|
else
|
|
break if (c1 != c2)
|
|
end
|
|
si += 1
|
|
end
|
|
end
|
|
|
|
if (low > si)
|
|
low = si
|
|
end
|
|
i += 1
|
|
end
|
|
|
|
# If there were multiple matches, but none matched up to even the
|
|
# first character, and the user typed something, use that as the
|
|
# value of matches[0].
|
|
if (low == 0 && text && text.length>0 )
|
|
match_list[0] = text.dup
|
|
else
|
|
# XXX - this might need changes in the presence of multibyte chars
|
|
|
|
# If we are ignoring case, try to preserve the case of the string
|
|
# the user typed in the face of multiple matches differing in case.
|
|
if (@_rl_completion_case_fold)
|
|
|
|
# We're making an assumption here:
|
|
# IF we're completing filenames AND
|
|
# the application has defined a filename dequoting function AND
|
|
# we found a quote character AND
|
|
# the application has requested filename quoting
|
|
# THEN
|
|
# we assume that TEXT was dequoted before checking against
|
|
# the file system and needs to be dequoted here before we
|
|
# check against the list of matches
|
|
# FI
|
|
if (@rl_filename_completion_desired &&
|
|
@rl_filename_dequoting_function &&
|
|
@rl_completion_found_quote &&
|
|
@rl_filename_quoting_desired)
|
|
|
|
dtext = send(@rl_filename_dequoting_function,text, @rl_completion_quote_character)
|
|
text = dtext
|
|
end
|
|
|
|
# sort the list to get consistent answers.
|
|
match_list = [match_list[0]] + match_list[1..-1].sort
|
|
|
|
si = text.length
|
|
if (si <= low)
|
|
for i in 1 .. matches
|
|
if match_list[i][0,si] == text
|
|
match_list[0] = match_list[i][0,low]
|
|
break
|
|
end
|
|
# no casematch, use first entry
|
|
if (i > matches)
|
|
match_list[0] = match_list[1][0,low]
|
|
end
|
|
end
|
|
else
|
|
# otherwise, just use the text the user typed.
|
|
match_list[0] = text[0,low]
|
|
end
|
|
else
|
|
match_list[0] = match_list[1][0,low]
|
|
end
|
|
end
|
|
|
|
return matches
|
|
end
|
|
|
|
|
|
def rl_vi_editing_mode(count, key)
|
|
_rl_set_insert_mode(RL_IM_INSERT, 1) # vi mode ignores insert mode
|
|
@rl_editing_mode = @vi_mode
|
|
rl_vi_insertion_mode(1, key)
|
|
0
|
|
end
|
|
|
|
# Switching from one mode to the other really just involves
|
|
# switching keymaps.
|
|
def rl_vi_insertion_mode(count, key)
|
|
@_rl_keymap = @vi_insertion_keymap
|
|
@_rl_vi_last_key_before_insert = key
|
|
0
|
|
end
|
|
|
|
def rl_emacs_editing_mode(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
|
|
0
|
|
end
|
|
|
|
# Function for the rest of the library to use to set insert/overwrite mode.
|
|
def _rl_set_insert_mode(im, force)
|
|
@rl_insert_mode = im
|
|
end
|
|
|
|
# Toggle overwrite mode. A positive explicit argument selects overwrite
|
|
# mode. A negative or zero explicit argument selects insert mode.
|
|
def rl_overwrite_mode(count, key)
|
|
if (!@rl_explicit_arg)
|
|
_rl_set_insert_mode(@rl_insert_mode ^ 1, 0)
|
|
elsif (count > 0)
|
|
_rl_set_insert_mode(RL_IM_OVERWRITE, 0)
|
|
else
|
|
_rl_set_insert_mode(RL_IM_INSERT, 0)
|
|
end
|
|
0
|
|
end
|
|
|
|
|
|
# A function for simple tilde expansion.
|
|
def rl_tilde_expand(ignore, key)
|
|
_end = @rl_point
|
|
start = _end - 1
|
|
|
|
if (@rl_point == @rl_end && @rl_line_buffer[@rl_point] == ?~ )
|
|
homedir = File.expand_path("~")
|
|
_rl_replace_text(homedir, start, _end)
|
|
return (0)
|
|
elsif (@rl_line_buffer[start] != ?~)
|
|
while(!whitespace(@rl_line_buffer[start,1]) && start >= 0)
|
|
start -= 1
|
|
end
|
|
start+=1
|
|
end
|
|
|
|
_end = start
|
|
begin
|
|
_end+=1
|
|
end while(!whitespace(@rl_line_buffer[_end,1]) && _end < @rl_end)
|
|
|
|
if (whitespace(@rl_line_buffer[_end,1]) || _end >= @rl_end)
|
|
_end-=1
|
|
end
|
|
|
|
# If the first character of the current word is a tilde, perform
|
|
#tilde expansion and insert the result. If not a tilde, do
|
|
# nothing.
|
|
if (@rl_line_buffer[start] == ?~)
|
|
|
|
len = _end - start + 1
|
|
temp = @rl_line_buffer[start,len]
|
|
homedir = File.expand_path(temp)
|
|
temp = nil
|
|
|
|
_rl_replace_text(homedir, start, _end)
|
|
end
|
|
0
|
|
end
|
|
|
|
# Clean up the terminal and readline state after catching a signal, before
|
|
# resending it to the calling application.
|
|
def rl_cleanup_after_signal()
|
|
_rl_clean_up_for_exit()
|
|
if (@rl_deprep_term_function)
|
|
send(@rl_deprep_term_function)
|
|
end
|
|
rl_clear_pending_input()
|
|
rl_clear_signals()
|
|
end
|
|
|
|
def _rl_clean_up_for_exit()
|
|
if @readline_echoing_p
|
|
_rl_move_vert(@_rl_vis_botlin)
|
|
@_rl_vis_botlin = 0
|
|
@rl_outstream.flush
|
|
rl_restart_output(1, 0)
|
|
end
|
|
end
|
|
|
|
# Move the cursor from _rl_last_c_pos to NEW, which are buffer indices.
|
|
# (Well, when we don't have multibyte characters, _rl_last_c_pos is a
|
|
# buffer index.)
|
|
# DATA is the contents of the screen line of interest; i.e., where
|
|
# the movement is being done.
|
|
def _rl_move_cursor_relative(new, data, start=0)
|
|
|
|
woff = w_offset(@_rl_last_v_pos, @wrap_offset)
|
|
cpos = @_rl_last_c_pos
|
|
|
|
if !@rl_byte_oriented
|
|
dpos = _rl_col_width(data, start, start+new)
|
|
|
|
if (dpos > @prompt_last_invisible) # XXX - don't use woff here
|
|
dpos -= woff
|
|
# Since this will be assigned to _rl_last_c_pos at the end (more
|
|
# precisely, _rl_last_c_pos == dpos when this function returns),
|
|
# let the caller know.
|
|
@cpos_adjusted = true
|
|
end
|
|
else
|
|
dpos = new
|
|
end
|
|
# If we don't have to do anything, then return.
|
|
if (cpos == dpos)
|
|
return
|
|
end
|
|
|
|
if @hConsoleHandle
|
|
csbi = 0.chr * 24
|
|
@GetConsoleScreenBufferInfo.Call(@hConsoleHandle,csbi)
|
|
x,y = csbi[4,4].unpack('SS')
|
|
x = dpos
|
|
@SetConsoleCursorPosition.Call(@hConsoleHandle,y*65536+x)
|
|
@_rl_last_c_pos = dpos
|
|
return
|
|
end
|
|
|
|
# It may be faster to output a CR, and then move forwards instead
|
|
# of moving backwards.
|
|
# i == current physical cursor position.
|
|
if !@rl_byte_oriented
|
|
i = @_rl_last_c_pos
|
|
else
|
|
i = @_rl_last_c_pos - woff
|
|
end
|
|
|
|
if (dpos == 0 || cr_faster(dpos, @_rl_last_c_pos) ||
|
|
(@_rl_term_autowrap && i == @_rl_screenwidth))
|
|
@rl_outstream.write(@_rl_term_cr)
|
|
cpos = @_rl_last_c_pos = 0
|
|
end
|
|
|
|
if (cpos < dpos)
|
|
# Move the cursor forward. We do it by printing the command
|
|
# to move the cursor forward if there is one, else print that
|
|
# portion of the output buffer again. Which is cheaper?
|
|
|
|
# The above comment is left here for posterity. It is faster
|
|
# to print one character (non-control) than to print a control
|
|
# sequence telling the terminal to move forward one character.
|
|
# That kind of control is for people who don't know what the
|
|
# data is underneath the cursor.
|
|
|
|
# However, we need a handle on where the current display position is
|
|
# in the buffer for the immediately preceding comment to be true.
|
|
# In multibyte locales, we don't currently have that info available.
|
|
# Without it, we don't know where the data we have to display begins
|
|
# in the buffer and we have to go back to the beginning of the screen
|
|
# line. In this case, we can use the terminal sequence to move forward
|
|
# if it's available.
|
|
if !@rl_byte_oriented
|
|
if (@_rl_term_forward_char)
|
|
@rl_outstream.write(@_rl_term_forward_char * (dpos-cpos))
|
|
else
|
|
@rl_outstream.write(@_rl_term_cr)
|
|
@rl_outstream.write(data[start,new])
|
|
end
|
|
else
|
|
@rl_outstream.write(data[start+cpos,new-cpos])
|
|
end
|
|
elsif (cpos > dpos)
|
|
_rl_backspace(cpos - dpos)
|
|
end
|
|
@_rl_last_c_pos = dpos
|
|
end
|
|
|
|
|
|
# PWP: move the cursor up or down.
|
|
def _rl_move_vert(to)
|
|
if (@_rl_last_v_pos == to || to > @_rl_screenheight)
|
|
return
|
|
end
|
|
|
|
if ((delta = to - @_rl_last_v_pos) > 0)
|
|
@rl_outstream.write("\n"*delta)
|
|
@rl_outstream.write("\r")
|
|
@_rl_last_c_pos = 0
|
|
else
|
|
if(@_rl_term_up)
|
|
@rl_outstream.write(@_rl_term_up*(-delta))
|
|
end
|
|
end
|
|
@_rl_last_v_pos = to # Now TO is here
|
|
end
|
|
|
|
def rl_setstate(x)
|
|
(@rl_readline_state |= (x))
|
|
end
|
|
|
|
def rl_unsetstate(x)
|
|
(@rl_readline_state &= ~(x))
|
|
end
|
|
|
|
def rl_isstate(x)
|
|
(@rl_readline_state & (x))!=0
|
|
end
|
|
|
|
# Clear any pending input pushed with rl_execute_next()
|
|
def rl_clear_pending_input()
|
|
@rl_pending_input = 0
|
|
rl_unsetstate(RL_STATE_INPUTPENDING)
|
|
0
|
|
end
|
|
|
|
def rl_restart_output(count, key)
|
|
0
|
|
end
|
|
|
|
def rl_clear_signals()
|
|
if Signal.list['WINCH']
|
|
trap "WINCH",@def_proc
|
|
end
|
|
end
|
|
|
|
def rl_set_signals()
|
|
if Signal.list['WINCH']
|
|
@def_proc = trap "WINCH",Proc.new{rl_sigwinch_handler(0)}
|
|
end
|
|
end
|
|
|
|
# Current implementation:
|
|
# \001 (^A) start non-visible characters
|
|
# \002 (^B) end non-visible characters
|
|
# all characters except \001 and \002 (following a \001) are copied to
|
|
# the returned string all characters except those between \001 and
|
|
# \002 are assumed to be `visible'.
|
|
def expand_prompt(pmt)
|
|
# Short-circuit if we can.
|
|
if (@rl_byte_oriented && pmt[RL_PROMPT_START_IGNORE].nil?)
|
|
r = pmt.dup
|
|
lp = r.length
|
|
lip = 0
|
|
niflp = 0
|
|
vlp = lp
|
|
return [r,lp,lip,niflp,vlp]
|
|
end
|
|
|
|
l = pmt.length
|
|
ret = ''
|
|
invfl = 0 # invisible chars in first line of prompt
|
|
invflset = 0 # we only want to set invfl once
|
|
|
|
igstart = 0
|
|
rl = 0
|
|
ignoring = false
|
|
last = ninvis = physchars = 0
|
|
for pi in 0 ... pmt.length
|
|
# This code strips the invisible character string markers
|
|
#RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE
|
|
if (!ignoring && pmt[pi,1] == RL_PROMPT_START_IGNORE) # XXX - check ignoring?
|
|
ignoring = true
|
|
igstart = pi
|
|
next
|
|
elsif (ignoring && pmt[pi,1] == RL_PROMPT_END_IGNORE)
|
|
ignoring = false
|
|
if (pi != (igstart + 1))
|
|
last = ret.length - 1
|
|
end
|
|
next
|
|
else
|
|
if !@rl_byte_oriented
|
|
pind = pi
|
|
ind = _rl_find_next_mbchar(pmt, pind, 1, MB_FIND_NONZERO)
|
|
l = ind - pind
|
|
while (l>0)
|
|
l-=1
|
|
ret << pmt[pi]
|
|
pi += 1
|
|
end
|
|
if (!ignoring)
|
|
rl += ind - pind
|
|
physchars += _rl_col_width(pmt, pind, ind)
|
|
else
|
|
ninvis += ind - pind
|
|
end
|
|
pi-=1 # compensate for later increment
|
|
else
|
|
ret << pmt[pi]
|
|
if (!ignoring)
|
|
rl+=1 # visible length byte counter
|
|
physchars+=1
|
|
else
|
|
ninvis+=1 # invisible chars byte counter
|
|
end
|
|
|
|
if (invflset == 0 && rl >= @_rl_screenwidth)
|
|
invfl = ninvis
|
|
invflset = 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if (rl < @_rl_screenwidth)
|
|
invfl = ninvis
|
|
end
|
|
lp = rl
|
|
lip = last
|
|
niflp = invfl
|
|
vlp = physchars
|
|
return [ret,lp,lip,niflp,vlp]
|
|
end
|
|
|
|
|
|
#*
|
|
#* Expand the prompt string into the various display components, if
|
|
#* necessary.
|
|
#*
|
|
#* local_prompt = expanded last line of string in rl_display_prompt
|
|
#* (portion after the final newline)
|
|
#* local_prompt_prefix = portion before last newline of rl_display_prompt,
|
|
#* expanded via expand_prompt
|
|
#* prompt_visible_length = number of visible characters in local_prompt
|
|
#* prompt_prefix_length = number of visible characters in local_prompt_prefix
|
|
#*
|
|
#* This function is called once per call to readline(). It may also be
|
|
#* called arbitrarily to expand the primary prompt.
|
|
#*
|
|
#* The return value is the number of visible characters on the last line
|
|
#* of the (possibly multi-line) prompt.
|
|
#*
|
|
def rl_expand_prompt(prompt)
|
|
@local_prompt = @local_prompt_prefix = nil
|
|
@local_prompt_len = 0
|
|
@prompt_last_invisible = @prompt_invis_chars_first_line = 0
|
|
@prompt_visible_length = @prompt_physical_chars = 0
|
|
|
|
if (prompt.nil? || prompt == '')
|
|
return (0)
|
|
end
|
|
|
|
pi = prompt.rindex("\n")
|
|
if pi.nil?
|
|
# The prompt is only one logical line, though it might wrap.
|
|
@local_prompt,@prompt_visible_length,@prompt_last_invisible,@prompt_invis_chars_first_line,@prompt_physical_chars =
|
|
expand_prompt(prompt)
|
|
@local_prompt_prefix = nil
|
|
@local_prompt_len = @local_prompt ? @local_prompt.length : 0
|
|
return (@prompt_visible_length)
|
|
else
|
|
# The prompt spans multiple lines.
|
|
pi += 1 if prompt.length!=pi+1
|
|
t = pi
|
|
@local_prompt,@prompt_visible_length,@prompt_last_invisible,_,@prompt_physical_chars = expand_prompt(prompt[pi..-1])
|
|
c = prompt[t]
|
|
prompt[t] = 0.chr
|
|
# The portion of the prompt string up to and including the
|
|
#final newline is now null-terminated.
|
|
@local_prompt_prefix,@prompt_prefix_length,_,@prompt_invis_chars_first_line, = expand_prompt(prompt)
|
|
prompt[t] = c
|
|
@local_prompt_len = @local_prompt ? @local_prompt.length : 0
|
|
return (@prompt_prefix_length)
|
|
end
|
|
end
|
|
|
|
# Set up the prompt and expand it. Called from readline() and
|
|
# rl_callback_handler_install ().
|
|
def rl_set_prompt(prompt)
|
|
@rl_prompt = prompt ? prompt.dup : nil
|
|
@rl_display_prompt = @rl_prompt ? @rl_prompt : ""
|
|
@rl_visible_prompt_length = rl_expand_prompt(@rl_prompt)
|
|
0
|
|
end
|
|
|
|
def get_term_capabilities(buffer)
|
|
hash = {}
|
|
`infocmp -C`.split(':').select{|x| x =~ /(.*)=(.*)/ and hash[$1]=$2.gsub('\\E',"\e").gsub(/\^(.)/){($1[0].ord ^ ((?a..?z).include?($1[0]) ? 0x60 : 0x40)).chr}}
|
|
@_rl_term_at7 = hash["@7"]
|
|
@_rl_term_DC = hash["DC"]
|
|
@_rl_term_IC = hash["IC"]
|
|
@_rl_term_clreol = hash["ce"]
|
|
@_rl_term_clrpag = hash["cl"]
|
|
@_rl_term_cr = hash["cr"]
|
|
@_rl_term_dc = hash["dc"]
|
|
@_rl_term_ei = hash["ei"]
|
|
@_rl_term_ic = hash["ic"]
|
|
@_rl_term_im = hash["im"]
|
|
@_rl_term_kD = hash["kD"]
|
|
@_rl_term_kH = hash["kH"]
|
|
@_rl_term_kI = hash["kI"]
|
|
@_rl_term_kd = hash["kd"]
|
|
@_rl_term_ke = hash["ke"]
|
|
@_rl_term_kh = hash["kh"]
|
|
@_rl_term_kl = hash["kl"]
|
|
@_rl_term_kr = hash["kr"]
|
|
@_rl_term_ks = hash["ks"]
|
|
@_rl_term_ku = hash["ku"]
|
|
@_rl_term_backspace = hash["le"]
|
|
@_rl_term_mm = hash["mm"]
|
|
@_rl_term_mo = hash["mo"]
|
|
@_rl_term_forward_char = hash["nd"]
|
|
@_rl_term_pc = hash["pc"]
|
|
@_rl_term_up = hash["up"]
|
|
@_rl_visible_bell = hash["vb"]
|
|
@_rl_term_vs = hash["vs"]
|
|
@_rl_term_ve = hash["ve"]
|
|
@tcap_initialized = true
|
|
end
|
|
|
|
# Set the environment variables LINES and COLUMNS to lines and cols,
|
|
# respectively.
|
|
def sh_set_lines_and_columns(lines, cols)
|
|
ENV["LINES"] = lines.to_s
|
|
ENV["COLUMNS"] = cols.to_s
|
|
end
|
|
|
|
# Get readline's idea of the screen size. TTY is a file descriptor open
|
|
# to the terminal. If IGNORE_ENV is true, we do not pay attention to the
|
|
# values of $LINES and $COLUMNS. The tests for TERM_STRING_BUFFER being
|
|
# non-null serve to check whether or not we have initialized termcap.
|
|
def _rl_get_screen_size(tty, ignore_env)
|
|
|
|
if @hConsoleHandle
|
|
csbi = 0.chr * 24
|
|
@GetConsoleScreenBufferInfo.Call(@hConsoleHandle,csbi)
|
|
wc,wr = csbi[0,4].unpack('SS')
|
|
# wr,wc, = `mode con`.scan(/\d+\n/).map{|x| x.to_i}
|
|
@_rl_screenwidth = wc
|
|
@_rl_screenheight = wr
|
|
else
|
|
wr,wc = `stty size `.split(' ').map{|x| x.to_i}
|
|
@_rl_screenwidth = wc
|
|
@_rl_screenheight = wr
|
|
if ignore_env==0 && ENV['LINES']
|
|
@_rl_screenheight = ENV['LINES'].to_i
|
|
end
|
|
if ignore_env==0 && ENV['COLUMNS']
|
|
@_rl_screenwidth = ENV['COLUMNS'].to_i
|
|
end
|
|
end
|
|
|
|
# If all else fails, default to 80x24 terminal.
|
|
if @_rl_screenwidth.nil? || @_rl_screenwidth <= 1
|
|
@_rl_screenwidth = 80
|
|
end
|
|
if @_rl_screenheight.nil? || @_rl_screenheight <= 0
|
|
@_rl_screenheight = 24
|
|
end
|
|
# If we're being compiled as part of bash, set the environment
|
|
# variables $LINES and $COLUMNS to new values. Otherwise, just
|
|
# do a pair of putenv () or setenv () calls.
|
|
sh_set_lines_and_columns(@_rl_screenheight, @_rl_screenwidth)
|
|
|
|
if !@_rl_term_autowrap
|
|
@_rl_screenwidth-=1
|
|
end
|
|
@_rl_screenchars = @_rl_screenwidth * @_rl_screenheight
|
|
end
|
|
|
|
def tgetflag(name)
|
|
`infocmp -C -r`.scan(/\w{2}/).include?(name)
|
|
end
|
|
|
|
# Return the function (or macro) definition which would be invoked via
|
|
# KEYSEQ if executed in MAP. If MAP is NULL, then the current keymap is
|
|
# used. TYPE, if non-NULL, is a pointer to an int which will receive the
|
|
# type of the object pointed to. One of ISFUNC (function), ISKMAP (keymap),
|
|
# or ISMACR (macro).
|
|
def rl_function_of_keyseq(keyseq, map, type)
|
|
map ||= @_rl_keymap
|
|
map[keyseq]
|
|
end
|
|
|
|
# Bind the key sequence represented by the string KEYSEQ to
|
|
# the arbitrary pointer DATA. TYPE says what kind of data is
|
|
# pointed to by DATA, right now this can be a function (ISFUNC),
|
|
# a macro (ISMACR), or a keymap (ISKMAP). This makes new keymaps
|
|
# as necessary. The initial place to do bindings is in MAP.
|
|
def rl_generic_bind(type, keyseq, data, map)
|
|
map[keyseq] = data
|
|
0
|
|
end
|
|
|
|
# Bind the key sequence represented by the string KEYSEQ to
|
|
# FUNCTION. This makes new keymaps as necessary. The initial
|
|
# place to do bindings is in MAP.
|
|
def rl_bind_keyseq_in_map(keyseq, function, map)
|
|
rl_generic_bind(ISFUNC, keyseq, function, map)
|
|
end
|
|
|
|
|
|
# Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. Right
|
|
# now, this is always used to attempt to bind the arrow keys, hence the
|
|
# check for rl_vi_movement_mode.
|
|
def rl_bind_keyseq_if_unbound_in_map(keyseq, default_func, kmap)
|
|
if (keyseq)
|
|
func = rl_function_of_keyseq(keyseq, kmap, nil)
|
|
if (func.nil? || func == :rl_vi_movement_mode)
|
|
return (rl_bind_keyseq_in_map(keyseq, default_func, kmap))
|
|
else
|
|
return 1
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
def rl_bind_keyseq_if_unbound(keyseq, default_func)
|
|
rl_bind_keyseq_if_unbound_in_map(keyseq, default_func, @_rl_keymap)
|
|
end
|
|
|
|
# Bind the arrow key sequences from the termcap description in MAP.
|
|
def bind_termcap_arrow_keys(map)
|
|
xkeymap = @_rl_keymap
|
|
@_rl_keymap = map
|
|
|
|
rl_bind_keyseq_if_unbound(@_rl_term_ku, :rl_get_previous_history)
|
|
rl_bind_keyseq_if_unbound(@_rl_term_kd, :rl_get_next_history)
|
|
rl_bind_keyseq_if_unbound(@_rl_term_kr, :rl_forward_char)
|
|
rl_bind_keyseq_if_unbound(@_rl_term_kl, :rl_backward_char)
|
|
|
|
rl_bind_keyseq_if_unbound(@_rl_term_kh, :rl_beg_of_line) # Home
|
|
rl_bind_keyseq_if_unbound(@_rl_term_at7, :rl_end_of_line) # End
|
|
|
|
rl_bind_keyseq_if_unbound(@_rl_term_kD, :rl_delete)
|
|
rl_bind_keyseq_if_unbound(@_rl_term_kI, :rl_overwrite_mode)
|
|
|
|
@_rl_keymap = xkeymap
|
|
end
|
|
|
|
def _rl_init_terminal_io(terminal_name)
|
|
term = terminal_name ? terminal_name : ENV["TERM"]
|
|
@_rl_term_clrpag = @_rl_term_cr = @_rl_term_clreol = nil
|
|
tty = @rl_instream ? @rl_instream.fileno : 0
|
|
|
|
if no_terminal?
|
|
term = "dumb"
|
|
@_rl_bind_stty_chars = false
|
|
end
|
|
|
|
@term_string_buffer ||= 0.chr * 2032
|
|
|
|
@term_buffer ||= 0.chr * 4080
|
|
|
|
buffer = @term_string_buffer
|
|
|
|
tgetent_ret = (term != "dumb") ? 1 : -1
|
|
|
|
if (tgetent_ret <= 0)
|
|
buffer = @term_buffer = @term_string_buffer = nil
|
|
|
|
@_rl_term_autowrap = false # used by _rl_get_screen_size
|
|
|
|
# Allow calling application to set default height and width, using
|
|
#rl_set_screen_size
|
|
if (@_rl_screenwidth <= 0 || @_rl_screenheight <= 0)
|
|
_rl_get_screen_size(tty, 0)
|
|
end
|
|
|
|
# Defaults.
|
|
if (@_rl_screenwidth <= 0 || @_rl_screenheight <= 0)
|
|
@_rl_screenwidth = 79
|
|
@_rl_screenheight = 24
|
|
end
|
|
|
|
# Everything below here is used by the redisplay code (tputs).
|
|
@_rl_screenchars = @_rl_screenwidth * @_rl_screenheight
|
|
@_rl_term_cr = "\r"
|
|
@_rl_term_im = @_rl_term_ei = @_rl_term_ic = @_rl_term_IC = nil
|
|
@_rl_term_up = @_rl_term_dc = @_rl_term_DC = @_rl_visible_bell = nil
|
|
@_rl_term_ku = @_rl_term_kd = @_rl_term_kl = @_rl_term_kr = nil
|
|
@_rl_term_kh = @_rl_term_kH = @_rl_term_kI = @_rl_term_kD = nil
|
|
@_rl_term_ks = @_rl_term_ke = @_rl_term_at7 = nil
|
|
@_rl_term_mm = @_rl_term_mo = nil
|
|
@_rl_term_ve = @_rl_term_vs = nil
|
|
@_rl_term_forward_char = nil
|
|
@_rl_terminal_can_insert = @term_has_meta = false
|
|
|
|
# Reasonable defaults for tgoto(). Readline currently only uses
|
|
# tgoto if _rl_term_IC or _rl_term_DC is defined, but just in case we
|
|
# change that later...
|
|
@_rl_term_backspace = "\b"
|
|
|
|
return 0
|
|
end
|
|
|
|
get_term_capabilities(buffer)
|
|
|
|
@_rl_term_cr ||= "\r"
|
|
@_rl_term_autowrap = !!(tgetflag("am") && tgetflag("xn"))
|
|
|
|
# Allow calling application to set default height and width, using
|
|
# rl_set_screen_size
|
|
if (@_rl_screenwidth <= 0 || @_rl_screenheight <= 0)
|
|
_rl_get_screen_size(tty, 0)
|
|
end
|
|
|
|
# "An application program can assume that the terminal can do
|
|
# character insertion if *any one of* the capabilities `IC',
|
|
# `im', `ic' or `ip' is provided." But we can't do anything if
|
|
# only `ip' is provided, so...
|
|
@_rl_terminal_can_insert = !!(@_rl_term_IC || @_rl_term_im || @_rl_term_ic)
|
|
|
|
# Check to see if this terminal has a meta key and clear the capability
|
|
# variables if there is none.
|
|
@term_has_meta = !!(tgetflag("km") || tgetflag("MT"))
|
|
if !@term_has_meta
|
|
@_rl_term_mm = @_rl_term_mo = nil
|
|
end
|
|
|
|
# Attempt to find and bind the arrow keys. Do not override already
|
|
# bound keys in an overzealous attempt, however.
|
|
|
|
bind_termcap_arrow_keys(@emacs_standard_keymap)
|
|
|
|
bind_termcap_arrow_keys(@vi_movement_keymap)
|
|
bind_termcap_arrow_keys(@vi_insertion_keymap)
|
|
|
|
return 0
|
|
end
|
|
|
|
# New public way to set the system default editing chars to their readline
|
|
# equivalents.
|
|
def rl_tty_set_default_bindings(kmap)
|
|
h = Hash[*`stty -a `.scan(/(\w+) = ([^;]+);/).flatten]
|
|
h.each {|k,v| v.gsub!(/\^(.)/){($1[0].ord ^ ((?a..?z).include?($1[0]) ? 0x60 : 0x40)).chr}}
|
|
kmap[h['erase']] = :rl_rubout
|
|
kmap[h['kill']] = :rl_unix_line_discard
|
|
kmap[h['werase']] = :rl_unix_word_rubout
|
|
kmap[h['lnext']] = :rl_quoted_insert
|
|
end
|
|
|
|
# If this system allows us to look at the values of the regular
|
|
# input editing characters, then bind them to their readline
|
|
# equivalents, iff the characters are not bound to keymaps.
|
|
def readline_default_bindings()
|
|
if @_rl_bind_stty_chars
|
|
rl_tty_set_default_bindings(@_rl_keymap)
|
|
end
|
|
end
|
|
|
|
def _rl_init_eightbit()
|
|
|
|
end
|
|
|
|
|
|
# Do key bindings from a file. If FILENAME is NULL it defaults
|
|
# to the first non-null filename from this list:
|
|
# 1. the filename used for the previous call
|
|
# 2. the value of the shell variable `INPUTRC'
|
|
# 3. ~/.inputrc
|
|
# 4. /etc/inputrc
|
|
# If the file existed and could be opened and read, 0 is returned,
|
|
# otherwise errno is returned.
|
|
def rl_read_init_file(filename)
|
|
|
|
|
|
=begin
|
|
# Default the filename.
|
|
filename ||= @last_readline_init_file
|
|
filename ||= ENV["INPUTRC"]
|
|
if (filename.nil? || filename == '')
|
|
filename = DEFAULT_INPUTRC
|
|
# Try to read DEFAULT_INPUTRC; fall back to SYS_INPUTRC on failure
|
|
if (_rl_read_init_file(filename, 0) == 0)
|
|
return 0
|
|
end
|
|
filename = SYS_INPUTRC
|
|
end
|
|
|
|
if RUBY_PLATFORM =~ /mswin|mingw/
|
|
return 0 if (_rl_read_init_file(filename, 0) == 0)
|
|
filename = "~/_inputrc"
|
|
end
|
|
return (_rl_read_init_file(filename, 0))
|
|
=end
|
|
#
|
|
# This code is too problematic at the moment
|
|
# Just hardcode things and move on
|
|
#
|
|
return 0
|
|
end
|
|
|
|
def _rl_read_init_file(filename, include_level)
|
|
@current_readline_init_file = filename
|
|
@current_readline_init_include_level = include_level
|
|
|
|
openname = File.expand_path(filename)
|
|
begin
|
|
buffer = File.open(openname).read
|
|
rescue
|
|
return -1
|
|
end
|
|
|
|
if (include_level == 0 && filename != @last_readline_init_file)
|
|
@last_readline_init_file = filename.dup
|
|
end
|
|
|
|
@currently_reading_init_file = true
|
|
|
|
# Loop over the lines in the file. Lines that start with `#' are
|
|
# comments; all other lines are commands for readline initialization.
|
|
@current_readline_init_lineno = 1
|
|
|
|
buffer.each_line do |line|
|
|
line.strip!
|
|
next if line =~ /^#/
|
|
next if line == ''
|
|
rl_parse_and_bind(line)
|
|
end
|
|
|
|
return 0
|
|
end
|
|
|
|
# Push _rl_parsing_conditionalized_out, and set parser state based
|
|
# on ARGS.
|
|
def parser_if(args)
|
|
# Push parser state.
|
|
@if_stack << @_rl_parsing_conditionalized_out
|
|
|
|
# If parsing is turned off, then nothing can turn it back on except
|
|
# for finding the matching endif. In that case, return right now.
|
|
if @_rl_parsing_conditionalized_out
|
|
return 0
|
|
end
|
|
|
|
args.downcase!
|
|
# Handle "$if term=foo" and "$if mode=emacs" constructs. If this
|
|
# isn't term=foo, or mode=emacs, then check to see if the first
|
|
# word in ARGS is the same as the value stored in rl_readline_name.
|
|
if (@rl_terminal_name && args =~ /^term=/)
|
|
# Terminals like "aaa-60" are equivalent to "aaa".
|
|
tname = @rl_terminal_name.downcase.gsub(/-.*$/,'')
|
|
|
|
# Test the `long' and `short' forms of the terminal name so that
|
|
#if someone has a `sun-cmd' and does not want to have bindings
|
|
#that will be executed if the terminal is a `sun', they can put
|
|
#`$if term=sun-cmd' into their .inputrc.
|
|
@_rl_parsing_conditionalized_out = (args[5..-1] != tname && args[5..-1] != @rl_terminal_name.downcase)
|
|
elsif args =~ /^mode=/
|
|
if args[5..-1] == "emacs"
|
|
mode = @emacs_mode
|
|
elsif args[5..-1] == "vi"
|
|
$stderr.puts "*** Warning: vi-mode not supported, switching back to emacs mode"
|
|
mode = @emacs_mode
|
|
else
|
|
mode = @no_mode
|
|
end
|
|
@_rl_parsing_conditionalized_out = (mode != @rl_editing_mode)
|
|
# Check to see if the first word in ARGS is the same as the
|
|
# value stored in rl_readline_name.
|
|
elsif (args == @rl_readline_name)
|
|
@_rl_parsing_conditionalized_out = false
|
|
else
|
|
@_rl_parsing_conditionalized_out = true
|
|
end
|
|
return 0
|
|
end
|
|
|
|
# Invert the current parser state if there is anything on the stack.
|
|
def parser_else(args)
|
|
if @if_stack.empty?
|
|
#_rl_init_file_error ("$else found without matching $if")
|
|
return 0
|
|
end
|
|
|
|
# Check the previous (n) levels of the stack to make sure that
|
|
# we haven't previously turned off parsing.
|
|
return 0 if @if_stack.detect {|x| x }
|
|
|
|
# Invert the state of parsing if at top level.
|
|
@_rl_parsing_conditionalized_out = !@_rl_parsing_conditionalized_out
|
|
return 0
|
|
end
|
|
|
|
# Terminate a conditional, popping the value of
|
|
# _rl_parsing_conditionalized_out from the stack.
|
|
def parser_endif(args)
|
|
if (@if_stack.length>0)
|
|
@_rl_parsing_conditionalized_out = @if_stack.pop
|
|
else
|
|
#_rl_init_file_error ("$endif without matching $if")
|
|
end
|
|
0
|
|
end
|
|
|
|
def parser_include(args)
|
|
return 0 if (@_rl_parsing_conditionalized_out)
|
|
|
|
old_init_file = @current_readline_init_file
|
|
old_line_number = @current_readline_init_lineno
|
|
old_include_level = @current_readline_init_include_level
|
|
|
|
r = _rl_read_init_file(args, old_include_level + 1)
|
|
|
|
@current_readline_init_file = old_init_file
|
|
@current_readline_init_lineno = old_line_number
|
|
@current_readline_init_include_level = old_include_level
|
|
|
|
return r
|
|
end
|
|
|
|
# Handle a parser directive. STATEMENT is the line of the directive
|
|
# without any leading `$'.
|
|
def handle_parser_directive(statement)
|
|
|
|
directive,args = statement.split(' ')
|
|
|
|
case directive.downcase
|
|
when "if"
|
|
parser_if(args)
|
|
return 0
|
|
when "endif"
|
|
parser_endif(args)
|
|
return 0
|
|
when "else"
|
|
parser_else(args)
|
|
return 0
|
|
when "include"
|
|
parser_include(args)
|
|
return 0
|
|
end
|
|
|
|
#_rl_init_file_error("unknown parser directive")
|
|
return 1
|
|
end
|
|
|
|
|
|
def rl_variable_bind(name,value)
|
|
case name
|
|
when "bind-tty-special-chars"
|
|
@_rl_bind_stty_chars = value.nil? || value=='1' || value == 'on'
|
|
when "blink-matching-paren"
|
|
@rl_blink_matching_paren = value.nil? || value=='1' || value == 'on'
|
|
when "byte-oriented"
|
|
@rl_byte_oriented = value.nil? || value=='1' || value == 'on'
|
|
when "completion-ignore-case"
|
|
@_rl_completion_case_fold = value.nil? || value=='1' || value == 'on'
|
|
when "convert-meta"
|
|
@_rl_convert_meta_chars_to_ascii = value.nil? || value=='1' || value == 'on'
|
|
when "disable-completion"
|
|
@rl_inhibit_completion = value.nil? || value=='1' || value == 'on'
|
|
when "enable-keypad"
|
|
@_rl_enable_keypad = value.nil? || value=='1' || value == 'on'
|
|
when "expand-tilde"
|
|
@rl_complete_with_tilde_expansion = value.nil? || value=='1' || value == 'on'
|
|
when "history-preserve-point"
|
|
@_rl_history_preserve_point = value.nil? || value=='1' || value == 'on'
|
|
when "horizontal-scroll-mode"
|
|
@_rl_horizontal_scroll_mode = value.nil? || value=='1' || value == 'on'
|
|
when "input-meta"
|
|
@_rl_meta_flag = value.nil? || value=='1' || value == 'on'
|
|
when "mark-directories"
|
|
@_rl_complete_mark_directories = value.nil? || value=='1' || value == 'on'
|
|
when "mark-modified-lines"
|
|
@_rl_mark_modified_lines = value.nil? || value=='1' || value == 'on'
|
|
when "mark-symlinked-directories"
|
|
@_rl_complete_mark_symlink_dirs = value.nil? || value=='1' || value == 'on'
|
|
when "match-hidden-files"
|
|
@_rl_match_hidden_files = value.nil? || value=='1' || value == 'on'
|
|
when "meta-flag"
|
|
@_rl_meta_flag = value.nil? || value=='1' || value == 'on'
|
|
when "output-meta"
|
|
@_rl_output_meta_chars = value.nil? || value=='1' || value == 'on'
|
|
when "page-completions"
|
|
@_rl_page_completions = value.nil? || value=='1' || value == 'on'
|
|
when "prefer-visible-bell"
|
|
@_rl_prefer_visible_bell = value.nil? || value=='1' || value == 'on'
|
|
when "print-completions-horizontally"
|
|
@_rl_print_completions_horizontally = value.nil? || value=='1' || value == 'on'
|
|
when "show-all-if-ambiguous"
|
|
@_rl_complete_show_all = value.nil? || value=='1' || value == 'on'
|
|
when "show-all-if-unmodified"
|
|
@_rl_complete_show_unmodified = value.nil? || value=='1' || value == 'on'
|
|
when "visible-stats"
|
|
@rl_visible_stats = value.nil? || value=='1' || value == 'on'
|
|
when "bell-style"
|
|
case value
|
|
when "none","off"
|
|
@_rl_bell_preference = NO_BELL
|
|
when "audible", "on"
|
|
@_rl_bell_preference = AUDIBLE_BELL
|
|
when "visible"
|
|
@_rl_bell_preference = VISIBLE_BELL
|
|
else
|
|
@_rl_bell_preference = AUDIBLE_BELL
|
|
end
|
|
when "comment-begin"
|
|
@_rl_comment_begin = value.dup
|
|
when "completion-query-items"
|
|
@rl_completion_query_items = value.to_i
|
|
when "editing-mode"
|
|
case value
|
|
when "vi"
|
|
$stderr.puts "*** Warning: vi editing-mode not supported, switching back to emacs"
|
|
#@_rl_keymap = @vi_insertion_keymap
|
|
#@rl_editing_mode = @vi_mode
|
|
@_rl_keymap = @emacs_standard_keymap
|
|
@rl_editing_mode = @emacs_mode
|
|
when "emacs"
|
|
@_rl_keymap = @emacs_standard_keymap
|
|
@rl_editing_mode = @emacs_mode
|
|
end
|
|
when "isearch-terminators"
|
|
@_rl_isearch_terminators = instance_eval(value)
|
|
when "keymap"
|
|
case value
|
|
when "emacs","emacs-standard","emacs-meta","emacs-ctlx"
|
|
@_rl_keymap = @emacs_standard_keymap
|
|
when "vi","vi-move","vi-command"
|
|
@_rl_keymap = @vi_movement_keymap
|
|
when "vi-insert"
|
|
@_rl_keymap = @vi_insertion_keymap
|
|
end
|
|
end
|
|
end
|
|
|
|
def rl_named_function(name)
|
|
case name
|
|
when "accept-line"
|
|
return :rl_newline
|
|
when "arrow-key-prefix"
|
|
return :rl_arrow_keys
|
|
when "backward-delete-char"
|
|
return :rl_rubout
|
|
when "character-search"
|
|
return :rl_char_search
|
|
when "character-search-backward"
|
|
return :rl_backward_char_search
|
|
when "copy-region-as-kill"
|
|
return :rl_copy_region_to_kill
|
|
when "delete-char"
|
|
return :rl_delete
|
|
when "delete-char-or-list"
|
|
return :rl_delete_or_show_completions
|
|
when "forward-backward-delete-char"
|
|
return :rl_rubout_or_delete
|
|
when "kill-whole-line"
|
|
return :rl_kill_full_line
|
|
when "non-incremental-forward-search-history"
|
|
return :rl_noninc_forward_search
|
|
when "non-incremental-reverse-search-history"
|
|
return :rl_noninc_reverse_search
|
|
when "non-incremental-forward-search-history-again"
|
|
return :rl_noninc_forward_search_again
|
|
when "non-incremental-reverse-search-history-again"
|
|
return :rl_noninc_reverse_search_again
|
|
when "redraw-current-line"
|
|
return :rl_refresh_line
|
|
when "self-insert"
|
|
return :rl_insert
|
|
when "undo"
|
|
return :rl_undo_command
|
|
when "beginning-of-line"
|
|
return :rl_beg_of_line
|
|
else
|
|
if name =~ /^[-a-z]+$/
|
|
return ('rl_'+name.gsub('-','_')).to_sym
|
|
end
|
|
end
|
|
nil
|
|
end
|
|
|
|
# Bind KEY to FUNCTION. Returns non-zero if KEY is out of range.
|
|
def rl_bind_key(key, function)
|
|
@_rl_keymap[key] = function
|
|
@rl_binding_keymap = @_rl_keymap
|
|
0
|
|
end
|
|
|
|
# Read the binding command from STRING and perform it.
|
|
# A key binding command looks like: Keyname: function-name\0,
|
|
# a variable binding command looks like: set variable value.
|
|
# A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark.
|
|
def rl_parse_and_bind(string)
|
|
|
|
# If this is a parser directive, act on it.
|
|
if (string[0,1] == ?$)
|
|
handle_parser_directive(string[1..-1])
|
|
return 0
|
|
end
|
|
|
|
# If we aren't supposed to be parsing right now, then we're done.
|
|
return 0 if @_rl_parsing_conditionalized_out
|
|
|
|
if string =~ /^set/i
|
|
_,var,value = string.downcase.split(' ')
|
|
rl_variable_bind(var, value)
|
|
return 0
|
|
end
|
|
|
|
key,funname = string.split(/\s*:\s*/)
|
|
|
|
begin
|
|
key = instance_eval(key)
|
|
rl_bind_key(key, rl_named_function(funname))
|
|
rescue ::Exception => e
|
|
$stderr.puts "[-] RbReadline error parsing inputrc: #{e} '#{key}'"
|
|
end
|
|
|
|
0
|
|
end
|
|
|
|
|
|
def _rl_enable_meta_key()
|
|
if(@term_has_meta && @_rl_term_mm)
|
|
@_rl_out_stream.write(@_rl_term_mm)
|
|
end
|
|
end
|
|
|
|
def rl_set_keymap_from_edit_mode()
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
@_rl_keymap = @emacs_standard_keymap
|
|
elsif (@rl_editing_mode == @vi_mode)
|
|
@_rl_keymap = @vi_insertion_keymap
|
|
end
|
|
end
|
|
|
|
def rl_get_keymap_name_from_edit_mode()
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
"emacs"
|
|
elsif (@rl_editing_mode == @vi_mode)
|
|
"vi"
|
|
else
|
|
"none"
|
|
end
|
|
end
|
|
|
|
# Bind some common arrow key sequences in MAP.
|
|
def bind_arrow_keys_internal(map)
|
|
xkeymap = @_rl_keymap
|
|
@_rl_keymap = map
|
|
|
|
if RUBY_PLATFORM =~ /mswin|mingw/
|
|
rl_bind_keyseq_if_unbound("\340H", :rl_get_previous_history) # Up
|
|
rl_bind_keyseq_if_unbound("\340P", :rl_get_next_history) # Down
|
|
rl_bind_keyseq_if_unbound("\340M", :rl_forward_char) # Right
|
|
rl_bind_keyseq_if_unbound("\340K", :rl_backward_char) # Left
|
|
rl_bind_keyseq_if_unbound("\340G", :rl_beg_of_line) # Home
|
|
rl_bind_keyseq_if_unbound("\340O", :rl_end_of_line) # End
|
|
rl_bind_keyseq_if_unbound("\340s", :rl_backward_word) # Ctrl-Left
|
|
rl_bind_keyseq_if_unbound("\340t", :rl_forward_word) # Ctrl-Right
|
|
rl_bind_keyseq_if_unbound("\340S", :rl_delete) # Delete
|
|
rl_bind_keyseq_if_unbound("\340R", :rl_overwrite_mode) # Insert
|
|
else
|
|
rl_bind_keyseq_if_unbound("\033[A", :rl_get_previous_history)
|
|
rl_bind_keyseq_if_unbound("\033[B", :rl_get_next_history)
|
|
rl_bind_keyseq_if_unbound("\033[C", :rl_forward_char)
|
|
rl_bind_keyseq_if_unbound("\033[D", :rl_backward_char)
|
|
rl_bind_keyseq_if_unbound("\033[H", :rl_beg_of_line)
|
|
rl_bind_keyseq_if_unbound("\033[F", :rl_end_of_line)
|
|
|
|
rl_bind_keyseq_if_unbound("\033OA", :rl_get_previous_history)
|
|
rl_bind_keyseq_if_unbound("\033OB", :rl_get_next_history)
|
|
rl_bind_keyseq_if_unbound("\033OC", :rl_forward_char)
|
|
rl_bind_keyseq_if_unbound("\033OD", :rl_backward_char)
|
|
rl_bind_keyseq_if_unbound("\033OH", :rl_beg_of_line)
|
|
rl_bind_keyseq_if_unbound("\033OF", :rl_end_of_line)
|
|
end
|
|
|
|
@_rl_keymap = xkeymap
|
|
end
|
|
|
|
# Try and bind the common arrow key prefixes after giving termcap and
|
|
# the inputrc file a chance to bind them and create `real' keymaps
|
|
# for the arrow key prefix.
|
|
def bind_arrow_keys()
|
|
bind_arrow_keys_internal(@emacs_standard_keymap)
|
|
bind_arrow_keys_internal(@vi_movement_keymap)
|
|
bind_arrow_keys_internal(@vi_insertion_keymap)
|
|
end
|
|
|
|
# Initialize the entire state of the world.
|
|
def readline_initialize_everything()
|
|
# Set up input and output if they are not already set up.
|
|
@rl_instream ||= $stdin
|
|
|
|
@rl_outstream ||= $stdout
|
|
|
|
# Bind _rl_in_stream and _rl_out_stream immediately. These values
|
|
# may change, but they may also be used before readline_internal ()
|
|
# is called.
|
|
@_rl_in_stream = @rl_instream
|
|
@_rl_out_stream = @rl_outstream
|
|
|
|
# Allocate data structures.
|
|
@rl_line_buffer ||= 0.chr * DEFAULT_BUFFER_SIZE
|
|
|
|
# Initialize the terminal interface.
|
|
@rl_terminal_name ||= ENV["TERM"]
|
|
_rl_init_terminal_io(@rl_terminal_name)
|
|
|
|
# Bind tty characters to readline functions.
|
|
readline_default_bindings()
|
|
|
|
# Decide whether we should automatically go into eight-bit mode.
|
|
_rl_init_eightbit()
|
|
|
|
# Read in the init file.
|
|
rl_read_init_file(nil)
|
|
|
|
# XXX
|
|
if (@_rl_horizontal_scroll_mode && @_rl_term_autowrap)
|
|
@_rl_screenwidth -= 1
|
|
@_rl_screenchars -= @_rl_screenheight
|
|
end
|
|
|
|
# Override the effect of any `set keymap' assignments in the
|
|
# inputrc file.
|
|
rl_set_keymap_from_edit_mode()
|
|
|
|
# Try to bind a common arrow key prefix, if not already bound.
|
|
bind_arrow_keys()
|
|
|
|
# Enable the meta key, if this terminal has one.
|
|
if @_rl_enable_meta
|
|
_rl_enable_meta_key()
|
|
end
|
|
|
|
# If the completion parser's default word break characters haven't
|
|
# been set yet, then do so now.
|
|
@rl_completer_word_break_characters ||= @rl_basic_word_break_characters
|
|
end
|
|
|
|
def _rl_init_line_state()
|
|
@rl_point = @rl_end = @rl_mark = 0
|
|
@rl_line_buffer = 0.chr * @rl_line_buffer.length
|
|
end
|
|
|
|
# Set the history pointer back to the last entry in the history.
|
|
def _rl_start_using_history()
|
|
using_history()
|
|
@_rl_saved_line_for_history = nil
|
|
end
|
|
|
|
|
|
def cr_faster(new, cur)
|
|
(new + 1) < (cur - new)
|
|
end
|
|
|
|
#* _rl_last_c_pos is an absolute cursor position in multibyte locales and a
|
|
# buffer index in others. This macro is used when deciding whether the
|
|
# current cursor position is in the middle of a prompt string containing
|
|
# invisible characters.
|
|
def prompt_ending_index()
|
|
if !@rl_byte_oriented
|
|
@prompt_physical_chars
|
|
else
|
|
(@prompt_last_invisible+1)
|
|
end
|
|
end
|
|
|
|
# Initialize the VISIBLE_LINE and INVISIBLE_LINE arrays, and their associated
|
|
# arrays of line break markers. MINSIZE is the minimum size of VISIBLE_LINE
|
|
# and INVISIBLE_LINE; if it is greater than LINE_SIZE, LINE_SIZE is
|
|
# increased. If the lines have already been allocated, this ensures that
|
|
# they can hold at least MINSIZE characters.
|
|
def init_line_structures(minsize)
|
|
if @invisible_line.nil? # initialize it
|
|
if (@line_size < minsize)
|
|
@line_size = minsize
|
|
end
|
|
@visible_line = 0.chr * @line_size
|
|
@invisible_line = 0.chr * @line_size # 1.chr
|
|
elsif (@line_size < minsize) # ensure it can hold MINSIZE chars
|
|
@line_size *= 2
|
|
if (@line_size < minsize)
|
|
@line_size = minsize
|
|
end
|
|
@visible_line << 0.chr * (@line_size - @visible_line.length)
|
|
@invisible_line << 1.chr * (@line_size - @invisible_line.length)
|
|
end
|
|
@visible_line[minsize,@line_size-minsize] = 0.chr * (@line_size-minsize)
|
|
@invisible_line[minsize,@line_size-minsize] = 1.chr * (@line_size-minsize)
|
|
|
|
if @vis_lbreaks.nil?
|
|
@inv_lbreaks = []
|
|
@vis_lbreaks = []
|
|
@_rl_wrapped_line = []
|
|
@inv_lbreaks[0] = @vis_lbreaks[0] = 0
|
|
end
|
|
end
|
|
|
|
# Return the history entry at the current position, as determined by
|
|
# history_offset. If there is no entry there, return a NULL pointer.
|
|
def current_history()
|
|
return ((@history_offset == @history_length) || @the_history.nil?) ?
|
|
nil : @the_history[@history_offset]
|
|
end
|
|
|
|
def meta_char(c)
|
|
c > "\x7f" && c <= "\xff"
|
|
end
|
|
|
|
def ctrl_char(c)
|
|
c < "\x20"
|
|
end
|
|
|
|
def isprint(c)
|
|
c >= "\x20" && c < "\x7f"
|
|
end
|
|
|
|
def whitespace(c)
|
|
(c == ' ' || c == "\t")
|
|
end
|
|
|
|
def w_offset(line, offset)
|
|
((line) == 0 ? offset : 0)
|
|
end
|
|
|
|
def vis_llen(l)
|
|
((l) > @_rl_vis_botlin ? 0 : (@vis_lbreaks[l+1] - @vis_lbreaks[l]))
|
|
end
|
|
|
|
def inv_llen(l)
|
|
(@inv_lbreaks[l+1] - @inv_lbreaks[l])
|
|
end
|
|
|
|
def vis_chars(line)
|
|
@visible_line[@vis_lbreaks[line] .. -1]
|
|
end
|
|
|
|
def vis_pos(line)
|
|
@vis_lbreaks[line]
|
|
end
|
|
|
|
def vis_line(line)
|
|
((line) > @_rl_vis_botlin) ? "" : vis_chars(line)
|
|
end
|
|
|
|
def inv_line(line)
|
|
@invisible_line[@inv_lbreaks[line] .. -1]
|
|
end
|
|
|
|
def m_offset(margin, offset)
|
|
((margin) == 0 ? offset : 0)
|
|
end
|
|
|
|
|
|
# PWP: update_line() is based on finding the middle difference of each
|
|
# line on the screen; vis:
|
|
#
|
|
# /old first difference
|
|
# /beginning of line | /old last same /old EOL
|
|
# v v v v
|
|
# old: eddie> Oh, my little gruntle-buggy is to me, as lurgid as
|
|
# new: eddie> Oh, my little buggy says to me, as lurgid as
|
|
# ^ ^ ^ ^
|
|
# \beginning of line | \new last same \new end of line
|
|
# \new first difference
|
|
#
|
|
# All are character pointers for the sake of speed. Special cases for
|
|
# no differences, as well as for end of line additions must be handled.
|
|
#
|
|
# Could be made even smarter, but this works well enough
|
|
def update_line(old, ostart, new, current_line, omax, nmax, inv_botlin)
|
|
# If we're at the right edge of a terminal that supports xn, we're
|
|
# ready to wrap around, so do so. This fixes problems with knowing
|
|
# the exact cursor position and cut-and-paste with certain terminal
|
|
# emulators. In this calculation, TEMP is the physical screen
|
|
# position of the cursor.
|
|
if @encoding == 'X'
|
|
old.force_encoding('ASCII-8BIT')
|
|
new.force_encoding('ASCII-8BIT')
|
|
end
|
|
|
|
if !@rl_byte_oriented
|
|
temp = @_rl_last_c_pos
|
|
else
|
|
temp = @_rl_last_c_pos - w_offset(@_rl_last_v_pos, @visible_wrap_offset)
|
|
end
|
|
if (temp == @_rl_screenwidth && @_rl_term_autowrap && !@_rl_horizontal_scroll_mode &&
|
|
@_rl_last_v_pos == current_line - 1)
|
|
|
|
if (!@rl_byte_oriented)
|
|
# This fixes only double-column characters, but if the wrapped
|
|
# character comsumes more than three columns, spaces will be
|
|
# inserted in the string buffer.
|
|
if (@_rl_wrapped_line[current_line] > 0)
|
|
_rl_clear_to_eol(@_rl_wrapped_line[current_line])
|
|
end
|
|
|
|
if new[0] != ?\0
|
|
case @encoding
|
|
when 'E'
|
|
wc = new.scan(/./me)[0]
|
|
ret = wc.length
|
|
tempwidth = wc.length
|
|
when 'S'
|
|
wc = new.scan(/./ms)[0]
|
|
ret = wc.length
|
|
tempwidth = wc.length
|
|
when 'U'
|
|
wc = new.scan(/./mu)[0]
|
|
ret = wc.length
|
|
tempwidth = wc.unpack('U').first >= 0x1000 ? 2 : 1
|
|
when 'X'
|
|
wc = new[0..-1].force_encoding(@encoding_name)[0]
|
|
ret = wc.bytesize
|
|
tempwidth = wc.ord >= 0x1000 ? 2 : 1
|
|
else
|
|
ret = 1
|
|
tempwidth = 1
|
|
end
|
|
else
|
|
tempwidth = 0
|
|
end
|
|
|
|
if (tempwidth > 0)
|
|
bytes = ret
|
|
@rl_outstream.write(new[0,bytes])
|
|
@_rl_last_c_pos = tempwidth
|
|
@_rl_last_v_pos+=1
|
|
|
|
if old[ostart] != ?\0
|
|
case @encoding
|
|
when 'E'
|
|
wc = old[ostart..-1].scan(/./me)[0]
|
|
ret = wc.length
|
|
when 'S'
|
|
wc = old[ostart..-1].scan(/./ms)[0]
|
|
ret = wc.length
|
|
when 'U'
|
|
wc = old[ostart..-1].scan(/./mu)[0]
|
|
ret = wc.length
|
|
when 'X'
|
|
wc = old[ostart..-1].force_encoding(@encoding_name)[0]
|
|
ret = wc.bytesize
|
|
end
|
|
else
|
|
ret = 0
|
|
end
|
|
if (ret != 0 && bytes != 0)
|
|
if ret != bytes
|
|
len = old[ostart..-1].index(0.chr,ret)
|
|
old[ostart+bytes,len-ret] = old[ostart+ret,len-ret]
|
|
end
|
|
old[ostart,bytes] = new[0,bytes]
|
|
end
|
|
else
|
|
@rl_outstream.write(' ')
|
|
@_rl_last_c_pos = 1
|
|
@_rl_last_v_pos+=1
|
|
if (old[ostart] != ?\0 && new[0] != ?\0)
|
|
old[ostart] = new[0]
|
|
end
|
|
end
|
|
|
|
else
|
|
if (new[0] != ?\0)
|
|
@rl_outstream.write(new[0,1])
|
|
else
|
|
@rl_outstream.write(' ')
|
|
end
|
|
@_rl_last_c_pos = 1
|
|
@_rl_last_v_pos+=1
|
|
if (old[ostart]!= ?\0 && new[0] != ?\0)
|
|
old[ostart] = new[0]
|
|
end
|
|
end
|
|
end
|
|
|
|
# Find first difference.
|
|
if (!@rl_byte_oriented)
|
|
# See if the old line is a subset of the new line, so that the
|
|
# only change is adding characters.
|
|
if (index = old.index(0.chr)) && omax+ostart>index
|
|
omax = index - ostart
|
|
end
|
|
if (index = new.index(0.chr)) && nmax>index
|
|
nmax = index
|
|
end
|
|
|
|
temp = (omax < nmax) ? omax : nmax
|
|
if old[ostart,temp]==new[0,temp]
|
|
ofd = temp
|
|
nfd = temp
|
|
else
|
|
if (omax == nmax && new[0,omax]==old[ostart,omax])
|
|
ofd = omax
|
|
nfd = nmax
|
|
else
|
|
new_offset = 0
|
|
old_offset = ostart
|
|
ofd = 0
|
|
nfd = 0
|
|
while(ofd < omax && old[ostart+ofd] != ?\0 &&
|
|
_rl_compare_chars(old, old_offset, new, new_offset))
|
|
|
|
old_offset = _rl_find_next_mbchar(old, old_offset, 1, MB_FIND_ANY)
|
|
new_offset = _rl_find_next_mbchar(new, new_offset, 1, MB_FIND_ANY)
|
|
ofd = old_offset - ostart
|
|
nfd = new_offset
|
|
end
|
|
end
|
|
end
|
|
else
|
|
ofd = 0
|
|
nfd = 0
|
|
while(ofd < omax && old[ostart+ofd] != ?\0 && old[ostart+ofd] == new[nfd])
|
|
ofd += 1
|
|
nfd += 1
|
|
end
|
|
end
|
|
|
|
|
|
# Move to the end of the screen line. ND and OD are used to keep track
|
|
# of the distance between ne and new and oe and old, respectively, to
|
|
# move a subtraction out of each loop.
|
|
oe = old.index(0.chr,ostart+ofd) - ostart
|
|
if oe.nil? || oe>omax
|
|
oe = omax
|
|
end
|
|
|
|
ne = new.index(0.chr,nfd)
|
|
if ne.nil? || ne>omax
|
|
ne = nmax
|
|
end
|
|
|
|
# If no difference, continue to next line.
|
|
if (ofd == oe && nfd == ne)
|
|
return
|
|
end
|
|
|
|
|
|
wsatend = true # flag for trailing whitespace
|
|
|
|
if (!@rl_byte_oriented)
|
|
|
|
ols = _rl_find_prev_mbchar(old, ostart+oe, MB_FIND_ANY) - ostart
|
|
nls = _rl_find_prev_mbchar(new, ne, MB_FIND_ANY)
|
|
while ((ols > ofd) && (nls > nfd))
|
|
|
|
if (!_rl_compare_chars(old, ostart+ols, new, nls))
|
|
break
|
|
end
|
|
if (old[ostart+ols] == ?\x20)
|
|
wsatend = false
|
|
end
|
|
|
|
ols = _rl_find_prev_mbchar(old, ols+ostart, MB_FIND_ANY) - ostart
|
|
nls = _rl_find_prev_mbchar(new, nls, MB_FIND_ANY)
|
|
end
|
|
else
|
|
ols = oe - 1 # find last same
|
|
nls = ne - 1
|
|
while ((ols > ofd) && (nls > nfd) && old[ostart+ols] == new[nls])
|
|
if (old[ostart+ols] != ?\x20 )
|
|
wsatend = false
|
|
end
|
|
ols-=1
|
|
nls-=1
|
|
end
|
|
end
|
|
|
|
if (wsatend)
|
|
ols = oe
|
|
nls = ne
|
|
elsif (!_rl_compare_chars(old, ostart+ols, new, nls))
|
|
if (old[ostart+ols] != ?\0) # don't step past the NUL
|
|
if !@rl_byte_oriented
|
|
ols = _rl_find_next_mbchar(old, ostart+ols, 1, MB_FIND_ANY) - ostart
|
|
else
|
|
ols+=1
|
|
end
|
|
end
|
|
if (new[nls] != ?\0 )
|
|
if !@rl_byte_oriented
|
|
nls = _rl_find_next_mbchar(new, nls, 1, MB_FIND_ANY)
|
|
else
|
|
nls+=1
|
|
end
|
|
end
|
|
end
|
|
|
|
# count of invisible characters in the current invisible line.
|
|
current_invis_chars = w_offset(current_line, @wrap_offset)
|
|
if (@_rl_last_v_pos != current_line)
|
|
_rl_move_vert(current_line)
|
|
if (@rl_byte_oriented && current_line == 0 && @visible_wrap_offset!=0)
|
|
@_rl_last_c_pos += @visible_wrap_offset
|
|
end
|
|
end
|
|
|
|
# If this is the first line and there are invisible characters in the
|
|
# prompt string, and the prompt string has not changed, and the current
|
|
# cursor position is before the last invisible character in the prompt,
|
|
# and the index of the character to move to is past the end of the prompt
|
|
# string, then redraw the entire prompt string. We can only do this
|
|
# reliably if the terminal supports a `cr' capability.
|
|
|
|
# This is not an efficiency hack -- there is a problem with redrawing
|
|
# portions of the prompt string if they contain terminal escape
|
|
# sequences (like drawing the `unbold' sequence without a corresponding
|
|
# `bold') that manifests itself on certain terminals.
|
|
|
|
lendiff = @local_prompt_len
|
|
|
|
if (current_line == 0 && !@_rl_horizontal_scroll_mode &&
|
|
@_rl_term_cr && lendiff > @prompt_visible_length && @_rl_last_c_pos > 0 &&
|
|
ofd >= lendiff && @_rl_last_c_pos < prompt_ending_index())
|
|
@rl_outstream.write(@_rl_term_cr)
|
|
_rl_output_some_chars(@local_prompt,0,lendiff)
|
|
if !@rl_byte_oriented
|
|
# We take wrap_offset into account here so we can pass correct
|
|
# information to _rl_move_cursor_relative.
|
|
@_rl_last_c_pos = _rl_col_width(@local_prompt, 0, lendiff) - @wrap_offset
|
|
@cpos_adjusted = true
|
|
else
|
|
@_rl_last_c_pos = lendiff
|
|
end
|
|
end
|
|
|
|
# When this function returns, _rl_last_c_pos is correct, and an absolute
|
|
# cursor postion in multibyte mode, but a buffer index when not in a
|
|
# multibyte locale.
|
|
_rl_move_cursor_relative(ofd, old, ostart)
|
|
|
|
if (current_line == 0 && !@rl_byte_oriented && @_rl_last_c_pos == @prompt_physical_chars)
|
|
@cpos_adjusted = true
|
|
end
|
|
|
|
# if (len (new) > len (old))
|
|
# lendiff == difference in buffer
|
|
# col_lendiff == difference on screen
|
|
# When not using multibyte characters, these are equal
|
|
lendiff = (nls - nfd) - (ols - ofd)
|
|
if !@rl_byte_oriented
|
|
col_lendiff = _rl_col_width(new, nfd, nls) - _rl_col_width(old, ostart+ofd, ostart+ols)
|
|
else
|
|
col_lendiff = lendiff
|
|
end
|
|
|
|
# If we are changing the number of invisible characters in a line, and
|
|
# the spot of first difference is before the end of the invisible chars,
|
|
# lendiff needs to be adjusted.
|
|
if (current_line == 0 && !@_rl_horizontal_scroll_mode &&
|
|
current_invis_chars != @visible_wrap_offset)
|
|
if !@rl_byte_oriented
|
|
lendiff += @visible_wrap_offset - current_invis_chars
|
|
col_lendiff += @visible_wrap_offset - current_invis_chars
|
|
else
|
|
lendiff += @visible_wrap_offset - current_invis_chars
|
|
col_lendiff = lendiff
|
|
end
|
|
end
|
|
|
|
# Insert (diff (len (old), len (new)) ch.
|
|
temp = ne - nfd
|
|
if !@rl_byte_oriented
|
|
col_temp = _rl_col_width(new,nfd,ne)
|
|
else
|
|
col_temp = temp
|
|
end
|
|
if (col_lendiff > 0) # XXX - was lendiff
|
|
|
|
# Non-zero if we're increasing the number of lines.
|
|
gl = current_line >= @_rl_vis_botlin && inv_botlin > @_rl_vis_botlin
|
|
# Sometimes it is cheaper to print the characters rather than
|
|
# use the terminal's capabilities. If we're growing the number
|
|
# of lines, make sure we actually cause the new line to wrap
|
|
# around on auto-wrapping terminals.
|
|
if (@_rl_terminal_can_insert && ((2 * col_temp) >= col_lendiff || @_rl_term_IC) && (!@_rl_term_autowrap || !gl))
|
|
|
|
# If lendiff > prompt_visible_length and _rl_last_c_pos == 0 and
|
|
# _rl_horizontal_scroll_mode == 1, inserting the characters with
|
|
# _rl_term_IC or _rl_term_ic will screw up the screen because of the
|
|
# invisible characters. We need to just draw them.
|
|
if (old[ostart+ols,1] != ?\0 && (!@_rl_horizontal_scroll_mode || @_rl_last_c_pos > 0 ||
|
|
lendiff <= @prompt_visible_length || current_invis_chars==0))
|
|
|
|
insert_some_chars(new[nfd..-1], lendiff, col_lendiff)
|
|
@_rl_last_c_pos += col_lendiff
|
|
elsif ((@rl_byte_oriented) && old[ostart+ols] == ?\0 && lendiff > 0)
|
|
# At the end of a line the characters do not have to
|
|
# be "inserted". They can just be placed on the screen.
|
|
# However, this screws up the rest of this block, which
|
|
# assumes you've done the insert because you can.
|
|
_rl_output_some_chars(new,nfd, lendiff)
|
|
@_rl_last_c_pos += col_lendiff
|
|
else
|
|
# We have horizontal scrolling and we are not inserting at
|
|
# the end. We have invisible characters in this line. This
|
|
# is a dumb update.
|
|
_rl_output_some_chars(new,nfd, temp)
|
|
@_rl_last_c_pos += col_temp
|
|
return
|
|
end
|
|
# Copy (new) chars to screen from first diff to last match.
|
|
temp = nls - nfd
|
|
if ((temp - lendiff) > 0)
|
|
_rl_output_some_chars(new,(nfd + lendiff),temp - lendiff)
|
|
# XXX -- this bears closer inspection. Fixes a redisplay bug
|
|
# reported against bash-3.0-alpha by Andreas Schwab involving
|
|
# multibyte characters and prompt strings with invisible
|
|
# characters, but was previously disabled.
|
|
@_rl_last_c_pos += _rl_col_width(new,nfd+lendiff, nfd+lendiff+temp-col_lendiff)
|
|
end
|
|
else
|
|
# cannot insert chars, write to EOL
|
|
_rl_output_some_chars(new,nfd, temp)
|
|
@_rl_last_c_pos += col_temp
|
|
# If we're in a multibyte locale and were before the last invisible
|
|
# char in the current line (which implies we just output some invisible
|
|
# characters) we need to adjust _rl_last_c_pos, since it represents
|
|
# a physical character position.
|
|
end
|
|
else # Delete characters from line.
|
|
# If possible and inexpensive to use terminal deletion, then do so.
|
|
if (@_rl_term_dc && (2 * col_temp) >= -col_lendiff)
|
|
|
|
# If all we're doing is erasing the invisible characters in the
|
|
# prompt string, don't bother. It screws up the assumptions
|
|
# about what's on the screen.
|
|
if (@_rl_horizontal_scroll_mode && @_rl_last_c_pos == 0 &&
|
|
-lendiff == @visible_wrap_offset)
|
|
col_lendiff = 0
|
|
end
|
|
|
|
if (col_lendiff!=0)
|
|
delete_chars(-col_lendiff) # delete (diff) characters
|
|
end
|
|
|
|
# Copy (new) chars to screen from first diff to last match
|
|
temp = nls - nfd
|
|
if (temp > 0)
|
|
_rl_output_some_chars(new,nfd, temp)
|
|
@_rl_last_c_pos += _rl_col_width(new,nfd,nfd+temp)
|
|
end
|
|
|
|
# Otherwise, print over the existing material.
|
|
else
|
|
if (temp > 0)
|
|
_rl_output_some_chars(new,nfd, temp)
|
|
@_rl_last_c_pos += col_temp # XXX
|
|
end
|
|
|
|
lendiff = (oe) - (ne)
|
|
if !@rl_byte_oriented
|
|
col_lendiff = _rl_col_width(old, ostart, ostart+oe) - _rl_col_width(new, 0, ne)
|
|
else
|
|
col_lendiff = lendiff
|
|
end
|
|
|
|
if (col_lendiff!=0)
|
|
if (@_rl_term_autowrap && current_line < inv_botlin)
|
|
space_to_eol(col_lendiff)
|
|
else
|
|
_rl_clear_to_eol(col_lendiff)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# Basic redisplay algorithm.
|
|
def rl_redisplay()
|
|
return if !@readline_echoing_p
|
|
|
|
_rl_wrapped_multicolumn = 0
|
|
|
|
@rl_display_prompt ||= ""
|
|
|
|
if (@invisible_line.nil? || @vis_lbreaks.nil?)
|
|
init_line_structures(0)
|
|
rl_on_new_line()
|
|
end
|
|
|
|
# Draw the line into the buffer.
|
|
@cpos_buffer_position = -1
|
|
|
|
line = @invisible_line
|
|
out = inv_botlin = 0
|
|
|
|
# Mark the line as modified or not. We only do this for history
|
|
# lines.
|
|
modmark = 0
|
|
if (@_rl_mark_modified_lines && current_history() && @rl_undo_list)
|
|
line[out] = '*'
|
|
out += 1
|
|
line[out] = 0.chr
|
|
modmark = 1
|
|
end
|
|
|
|
# If someone thought that the redisplay was handled, but the currently
|
|
# visible line has a different modification state than the one about
|
|
# to become visible, then correct the caller's misconception.
|
|
if (@visible_line[0,1] != @invisible_line[0,1])
|
|
@rl_display_fixed = false
|
|
end
|
|
|
|
# If the prompt to be displayed is the `primary' readline prompt (the
|
|
# one passed to readline()), use the values we have already expanded.
|
|
# If not, use what's already in rl_display_prompt. WRAP_OFFSET is the
|
|
# number of non-visible characters in the prompt string.
|
|
if (@rl_display_prompt == @rl_prompt || @local_prompt)
|
|
|
|
if (@local_prompt_prefix && @forced_display)
|
|
_rl_output_some_chars(@local_prompt_prefix,0,@local_prompt_prefix.length)
|
|
end
|
|
if (@local_prompt_len > 0)
|
|
|
|
temp = @local_prompt_len + out + 2
|
|
if (temp >= @line_size)
|
|
@line_size = (temp + 1024) - (temp % 1024)
|
|
if @visible_line.length >= @line_size
|
|
@visible_line = @visible_line[0,@line_size]
|
|
else
|
|
@visible_line += 0.chr * (@line_size-@visible_line.length)
|
|
end
|
|
|
|
if @invisible_line.length >= @line_size
|
|
@invisible_line = @invisible_line[0,@line_size]
|
|
else
|
|
@invisible_line += 0.chr * (@line_size-@invisible_line.length)
|
|
end
|
|
if @encoding=='X'
|
|
@visible_line.force_encoding('ASCII-8BIT')
|
|
@invisible_line.force_encoding('ASCII-8BIT')
|
|
end
|
|
line = @invisible_line
|
|
end
|
|
line[out,@local_prompt_len] = @local_prompt
|
|
out += @local_prompt_len
|
|
end
|
|
line[out] = 0.chr
|
|
@wrap_offset = @local_prompt_len - @prompt_visible_length
|
|
else
|
|
prompt_this_line = @rl_display_prompt.rindex("\n")
|
|
if prompt_this_line.nil?
|
|
prompt_this_line = 0
|
|
else
|
|
prompt_this_line+=1
|
|
|
|
pmtlen = prompt_this_line # temp var
|
|
if (@forced_display)
|
|
_rl_output_some_chars(@rl_display_prompt,0,pmtlen)
|
|
# Make sure we are at column zero even after a newline,
|
|
#regardless of the state of terminal output processing.
|
|
if (pmtlen < 2 || @rl_display_prompt[prompt_this_line-2] != ?\r)
|
|
cr()
|
|
end
|
|
end
|
|
end
|
|
|
|
@prompt_physical_chars = pmtlen = @rl_display_prompt.length - prompt_this_line
|
|
temp = pmtlen + out + 2
|
|
if (temp >= @line_size)
|
|
@line_size = (temp + 1024) - (temp % 1024)
|
|
if @visible_line.length >= @line_size
|
|
@visible_line = @visible_line[0,@line_size]
|
|
else
|
|
@visible_line += 0.chr * (@line_size-@visible_line.length)
|
|
end
|
|
|
|
if @invisible_line.length >= @line_size
|
|
@invisible_line = @invisible_line[0,@line_size]
|
|
else
|
|
@invisible_line += 0.chr * (@line_size-@invisible_line.length)
|
|
end
|
|
if @encoding=='X'
|
|
@visible_line.force_encoding('ASCII-8BIT')
|
|
@invisible_line.force_encoding('ASCII-8BIT')
|
|
end
|
|
|
|
line = @invisible_line
|
|
end
|
|
line[out,pmtlen] = @rl_display_prompt[prompt_this_line,pmtlen]
|
|
out += pmtlen
|
|
line[out] = 0.chr
|
|
@wrap_offset = @prompt_invis_chars_first_line = 0
|
|
end
|
|
# inv_lbreaks[i] is where line i starts in the buffer.
|
|
@inv_lbreaks[newlines = 0] = 0
|
|
lpos = @prompt_physical_chars + modmark
|
|
|
|
@_rl_wrapped_line = Array.new(@visible_line.length,0)
|
|
num = 0
|
|
|
|
# prompt_invis_chars_first_line is the number of invisible characters in
|
|
# the first physical line of the prompt.
|
|
# wrap_offset - prompt_invis_chars_first_line is the number of invis
|
|
# chars on the second line.
|
|
|
|
# what if lpos is already >= _rl_screenwidth before we start drawing the
|
|
# contents of the command line?
|
|
while (lpos >= @_rl_screenwidth)
|
|
# fix from Darin Johnson <darin@acuson.com> for prompt string with
|
|
# invisible characters that is longer than the screen width. The
|
|
# prompt_invis_chars_first_line variable could be made into an array
|
|
# saying how many invisible characters there are per line, but that's
|
|
# probably too much work for the benefit gained. How many people have
|
|
# prompts that exceed two physical lines?
|
|
# Additional logic fix from Edward Catmur <ed@catmur.co.uk>
|
|
if (!@rl_byte_oriented)
|
|
n0 = num
|
|
temp = @local_prompt_len
|
|
while (num < temp)
|
|
z = _rl_col_width(@local_prompt, n0, num)
|
|
if (z > @_rl_screenwidth)
|
|
num = _rl_find_prev_mbchar(@local_prompt, num, MB_FIND_ANY)
|
|
break
|
|
elsif (z == @_rl_screenwidth)
|
|
break
|
|
end
|
|
num+=1
|
|
end
|
|
temp = num
|
|
else
|
|
temp = ((newlines + 1) * @_rl_screenwidth)
|
|
end
|
|
|
|
# Now account for invisible characters in the current line.
|
|
temp += (@local_prompt_prefix.nil? ? ((newlines == 0) ? @prompt_invis_chars_first_line :
|
|
((newlines == 1) ? @wrap_offset : 0)) :
|
|
((newlines == 0) ? @wrap_offset : 0))
|
|
|
|
@inv_lbreaks[newlines+=1] = temp
|
|
if !@rl_byte_oriented
|
|
lpos -= _rl_col_width(@local_prompt, n0, num)
|
|
else
|
|
lpos -= @_rl_screenwidth
|
|
end
|
|
end
|
|
@prompt_last_screen_line = newlines
|
|
|
|
# Draw the rest of the line (after the prompt) into invisible_line, keeping
|
|
# track of where the cursor is (cpos_buffer_position), the number of the line containing
|
|
# the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin).
|
|
# It maintains an array of line breaks for display (inv_lbreaks).
|
|
# This handles expanding tabs for display and displaying meta characters.
|
|
lb_linenum = 0
|
|
_in = 0
|
|
if !@rl_byte_oriented && @rl_end>0
|
|
case @encoding
|
|
when 'E'
|
|
wc = @rl_line_buffer[0,@rl_end].scan(/./me)[0]
|
|
wc_bytes = wc ? wc.length : 1
|
|
when 'S'
|
|
wc = @rl_line_buffer[0,@rl_end].scan(/./ms)[0]
|
|
wc_bytes = wc ? wc.length : 1
|
|
when 'U'
|
|
wc = @rl_line_buffer[0,@rl_end].scan(/./mu)[0]
|
|
wc_bytes = wc ? wc.length : 1
|
|
when 'X'
|
|
wc = @rl_line_buffer[0,@rl_end].force_encoding(@encoding_name)[0,1]
|
|
wc_bytes = wc ? wc.bytesize : 1
|
|
end
|
|
else
|
|
wc_bytes = 1
|
|
end
|
|
|
|
while(_in < @rl_end)
|
|
|
|
c = @rl_line_buffer[_in,1]
|
|
if(c == 0.chr)
|
|
@rl_end = _in
|
|
break
|
|
end
|
|
if (!@rl_byte_oriented)
|
|
case @encoding
|
|
when 'U'
|
|
wc_width = wc && wc.unpack('U').first >= 0x1000 ? 2 : 1
|
|
when 'X'
|
|
wc_width = wc && wc.ord > 0x1000 ? 2 : 1
|
|
else
|
|
wc_width = wc ? wc.length : 1
|
|
end
|
|
end
|
|
if (out + 8 >= @line_size) # XXX - 8 for \t
|
|
@line_size *= 2
|
|
if @visible_line.length>=@line_size
|
|
@visible_line = @visible_line[0,@line_size]
|
|
else
|
|
@visible_line += 0.chr * (@line_size-@visible_line.length)
|
|
end
|
|
if @invisible_line.length>=@line_size
|
|
@invisible_line = @invisible_line[0,@line_size]
|
|
else
|
|
@invisible_line += 0.chr * (@line_size-@invisible_line.length)
|
|
end
|
|
line = @invisible_line
|
|
end
|
|
|
|
if (_in == @rl_point)
|
|
@cpos_buffer_position = out
|
|
lb_linenum = newlines
|
|
end
|
|
if (false && meta_char(c))
|
|
if (!@_rl_output_meta_chars && false)
|
|
line[out,4] = "\\%03o" % c.ord
|
|
|
|
if (lpos + 4 >= @_rl_screenwidth)
|
|
temp = @_rl_screenwidth - lpos
|
|
@inv_lbreaks[newlines+=1] = out + temp
|
|
lpos = 4 - temp
|
|
else
|
|
lpos += 4
|
|
end
|
|
out += 4
|
|
else
|
|
line[out] = c
|
|
out += 1
|
|
lpos+=1
|
|
if (lpos >= @_rl_screenwidth)
|
|
@inv_lbreaks[newlines+=1] = out
|
|
@_rl_wrapped_line[newlines] = _rl_wrapped_multicolumn
|
|
lpos = 0
|
|
end
|
|
end
|
|
|
|
elsif (c == "\t")
|
|
|
|
newout = out + 8 - lpos % 8
|
|
temp = newout - out
|
|
if (lpos + temp >= @_rl_screenwidth)
|
|
temp2 = @_rl_screenwidth - lpos
|
|
@inv_lbreaks[newlines+=1] = out + temp2
|
|
lpos = temp - temp2
|
|
while (out < newout)
|
|
line[out] = ' '
|
|
out += 1
|
|
end
|
|
|
|
else
|
|
|
|
while (out < newout)
|
|
line[out] = ' '
|
|
out += 1
|
|
end
|
|
lpos += temp
|
|
end
|
|
|
|
elsif (c == "\n" && !@_rl_horizontal_scroll_mode && @_rl_term_up)
|
|
line[out] = 0.chr # XXX - sentinel
|
|
out += 1
|
|
@inv_lbreaks[newlines+=1] = out
|
|
lpos = 0
|
|
elsif (ctrl_char(c) || c == RUBOUT)
|
|
line[out] = '^'
|
|
out += 1
|
|
lpos+=1
|
|
if (lpos >= @_rl_screenwidth)
|
|
@inv_lbreaks[newlines+=1] = out
|
|
@_rl_wrapped_line[newlines] = _rl_wrapped_multicolumn
|
|
lpos = 0
|
|
end
|
|
line[out] = ctrl_char(c) ? (c[0].ord|0x40).chr.upcase : '?'
|
|
out += 1
|
|
lpos+=1
|
|
if (lpos >= @_rl_screenwidth)
|
|
@inv_lbreaks[newlines+=1] = out
|
|
@_rl_wrapped_line[newlines] = _rl_wrapped_multicolumn
|
|
lpos = 0
|
|
end
|
|
else
|
|
|
|
if (!@rl_byte_oriented)
|
|
_rl_wrapped_multicolumn = 0
|
|
if (@_rl_screenwidth < lpos + wc_width)
|
|
for i in lpos ... @_rl_screenwidth
|
|
# The space will be removed in update_line()
|
|
line[out] = ' '
|
|
out += 1
|
|
_rl_wrapped_multicolumn+=1
|
|
lpos+=1
|
|
if (lpos >= @_rl_screenwidth)
|
|
@inv_lbreaks[newlines+=1] = out
|
|
@_rl_wrapped_line[newlines] = _rl_wrapped_multicolumn
|
|
lpos = 0
|
|
end
|
|
end
|
|
end
|
|
if (_in == @rl_point)
|
|
@cpos_buffer_position = out
|
|
lb_linenum = newlines
|
|
end
|
|
line[out,wc_bytes] = @rl_line_buffer[_in,wc_bytes]
|
|
out += wc_bytes
|
|
for i in 0 ... wc_width
|
|
lpos+=1
|
|
if (lpos >= @_rl_screenwidth)
|
|
@inv_lbreaks[newlines+=1] = out
|
|
@_rl_wrapped_line[newlines] = _rl_wrapped_multicolumn
|
|
lpos = 0
|
|
end
|
|
end
|
|
else
|
|
line[out] = c
|
|
out += 1
|
|
lpos+=1
|
|
if (lpos >= @_rl_screenwidth)
|
|
@inv_lbreaks[newlines+=1] = out
|
|
@_rl_wrapped_line[newlines] = _rl_wrapped_multicolumn
|
|
lpos = 0
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
if (!@rl_byte_oriented)
|
|
_in += wc_bytes
|
|
case @encoding
|
|
when 'E'
|
|
wc = @rl_line_buffer[_in,@rl_end - _in].scan(/./me)[0]
|
|
wc_bytes = wc ? wc.length : 1
|
|
when 'S'
|
|
wc = @rl_line_buffer[_in,@rl_end - _in].scan(/./ms)[0]
|
|
wc_bytes = wc ? wc.length : 1
|
|
when 'U'
|
|
wc = @rl_line_buffer[_in,@rl_end - _in].scan(/./mu)[0]
|
|
wc_bytes = wc ? wc.length : 1
|
|
when 'X'
|
|
wc = @rl_line_buffer[_in,@rl_end - _in].force_encoding(@encoding_name)[0,1]
|
|
wc_bytes = wc ? wc.bytesize : 1
|
|
end
|
|
|
|
else
|
|
_in+=1
|
|
end
|
|
end
|
|
|
|
line[out] = 0.chr
|
|
|
|
if (@cpos_buffer_position < 0)
|
|
@cpos_buffer_position = out
|
|
lb_linenum = newlines
|
|
end
|
|
|
|
inv_botlin = lb_botlin = newlines
|
|
@inv_lbreaks[newlines+1] = out
|
|
cursor_linenum = lb_linenum
|
|
|
|
# CPOS_BUFFER_POSITION == position in buffer where cursor should be placed.
|
|
# CURSOR_LINENUM == line number where the cursor should be placed.
|
|
|
|
# PWP: now is when things get a bit hairy. The visible and invisible
|
|
# line buffers are really multiple lines, which would wrap every
|
|
# (screenwidth - 1) characters. Go through each in turn, finding
|
|
# the changed region and updating it. The line order is top to bottom.
|
|
|
|
# If we can move the cursor up and down, then use multiple lines,
|
|
# otherwise, let long lines display in a single terminal line, and
|
|
# horizontally scroll it.
|
|
|
|
if (!@_rl_horizontal_scroll_mode && @_rl_term_up)
|
|
if (!@rl_display_fixed || @forced_display)
|
|
@forced_display = false
|
|
# If we have more than a screenful of material to display, then
|
|
# only display a screenful. We should display the last screen,
|
|
# not the first.
|
|
if (out >= @_rl_screenchars)
|
|
if (!@rl_byte_oriented)
|
|
out = _rl_find_prev_mbchar(line, @_rl_screenchars, MB_FIND_ANY)
|
|
else
|
|
out = @_rl_screenchars - 1
|
|
end
|
|
end
|
|
|
|
# The first line is at character position 0 in the buffer. The
|
|
# second and subsequent lines start at inv_lbreaks[N], offset by
|
|
# OFFSET (which has already been calculated above).
|
|
|
|
# For each line in the buffer, do the updating display.
|
|
for linenum in 0 .. inv_botlin
|
|
# This can lead us astray if we execute a program that changes
|
|
#the locale from a non-multibyte to a multibyte one.
|
|
o_cpos = @_rl_last_c_pos
|
|
@cpos_adjusted = false
|
|
update_line(@visible_line,vis_pos(linenum), inv_line(linenum), linenum,
|
|
vis_llen(linenum), inv_llen(linenum), inv_botlin)
|
|
|
|
if (linenum == 0 && !@rl_byte_oriented &&
|
|
!@cpos_adjusted &&
|
|
@_rl_last_c_pos != o_cpos &&
|
|
@_rl_last_c_pos > @wrap_offset &&
|
|
o_cpos < @prompt_last_invisible)
|
|
@_rl_last_c_pos -= @wrap_offset
|
|
end
|
|
|
|
# If this is the line with the prompt, we might need to
|
|
# compensate for invisible characters in the new line. Do
|
|
# this only if there is not more than one new line (which
|
|
# implies that we completely overwrite the old visible line)
|
|
# and the new line is shorter than the old. Make sure we are
|
|
# at the end of the new line before clearing.
|
|
if (linenum == 0 &&
|
|
inv_botlin == 0 && @_rl_last_c_pos == out &&
|
|
(@wrap_offset > @visible_wrap_offset) &&
|
|
(@_rl_last_c_pos < @visible_first_line_len))
|
|
if !@rl_byte_oriented
|
|
nleft = @_rl_screenwidth - @_rl_last_c_pos
|
|
else
|
|
nleft = @_rl_screenwidth + @wrap_offset - @_rl_last_c_pos
|
|
end
|
|
if (nleft!=0)
|
|
_rl_clear_to_eol(nleft)
|
|
end
|
|
end
|
|
|
|
# Since the new first line is now visible, save its length.
|
|
if (linenum == 0)
|
|
@visible_first_line_len = (inv_botlin > 0) ? @inv_lbreaks[1] : out - @wrap_offset
|
|
end
|
|
end
|
|
|
|
# We may have deleted some lines. If so, clear the left over
|
|
# blank ones at the bottom out.
|
|
if (@_rl_vis_botlin > inv_botlin)
|
|
while(linenum <= @_rl_vis_botlin)
|
|
tt = vis_chars(linenum)
|
|
_rl_move_vert(linenum)
|
|
_rl_move_cursor_relative(0, tt)
|
|
_rl_clear_to_eol((linenum == @_rl_vis_botlin) ? tt.length : @_rl_screenwidth)
|
|
linenum += 1
|
|
end
|
|
end
|
|
@_rl_vis_botlin = inv_botlin
|
|
|
|
# CHANGED_SCREEN_LINE is set to 1 if we have moved to a
|
|
# different screen line during this redisplay.
|
|
changed_screen_line = @_rl_last_v_pos != cursor_linenum
|
|
if (changed_screen_line)
|
|
_rl_move_vert(cursor_linenum)
|
|
# If we moved up to the line with the prompt using _rl_term_up,
|
|
# the physical cursor position on the screen stays the same,
|
|
# but the buffer position needs to be adjusted to account
|
|
# for invisible characters.
|
|
if (@rl_byte_oriented && cursor_linenum == 0 && @wrap_offset!=0)
|
|
@_rl_last_c_pos += @wrap_offset
|
|
end
|
|
end
|
|
# We have to reprint the prompt if it contains invisible
|
|
# characters, since it's not generally OK to just reprint
|
|
# the characters from the current cursor position. But we
|
|
# only need to reprint it if the cursor is before the last
|
|
# invisible character in the prompt string.
|
|
nleft = @prompt_visible_length + @wrap_offset
|
|
if (cursor_linenum == 0 && @wrap_offset > 0 && @_rl_last_c_pos > 0 &&
|
|
@_rl_last_c_pos < prompt_ending_index() && @local_prompt)
|
|
if (@_rl_term_cr)
|
|
@rl_outstream.write(@_rl_term_cr)
|
|
end
|
|
_rl_output_some_chars(@local_prompt,0,nleft)
|
|
if !@rl_byte_oriented
|
|
@_rl_last_c_pos = _rl_col_width(@local_prompt, 0, nleft) - @wrap_offset
|
|
else
|
|
@_rl_last_c_pos = nleft
|
|
end
|
|
end
|
|
|
|
# Where on that line? And where does that line start
|
|
# in the buffer?
|
|
pos = @inv_lbreaks[cursor_linenum]
|
|
# nleft == number of characters in the line buffer between the
|
|
# start of the line and the desired cursor position.
|
|
nleft = @cpos_buffer_position - pos
|
|
|
|
# NLEFT is now a number of characters in a buffer. When in a
|
|
# multibyte locale, however, _rl_last_c_pos is an absolute cursor
|
|
# position that doesn't take invisible characters in the prompt
|
|
# into account. We use a fudge factor to compensate.
|
|
|
|
# Since _rl_backspace() doesn't know about invisible characters in the
|
|
# prompt, and there's no good way to tell it, we compensate for
|
|
# those characters here and call _rl_backspace() directly.
|
|
|
|
if (@wrap_offset!=0 && cursor_linenum == 0 && nleft < @_rl_last_c_pos)
|
|
# TX == new physical cursor position in multibyte locale.
|
|
if !@rl_byte_oriented
|
|
tx = _rl_col_width(@visible_line, pos, pos+nleft) - @visible_wrap_offset
|
|
else
|
|
tx = nleft
|
|
end
|
|
if (@_rl_last_c_pos > tx)
|
|
_rl_backspace(@_rl_last_c_pos - tx) # XXX
|
|
@_rl_last_c_pos = tx
|
|
end
|
|
end
|
|
# We need to note that in a multibyte locale we are dealing with
|
|
# _rl_last_c_pos as an absolute cursor position, but moving to a
|
|
# point specified by a buffer position (NLEFT) that doesn't take
|
|
# invisible characters into account.
|
|
if !@rl_byte_oriented
|
|
_rl_move_cursor_relative(nleft, @invisible_line,pos)
|
|
elsif (nleft != @_rl_last_c_pos)
|
|
_rl_move_cursor_relative(nleft, @invisible_line,pos)
|
|
end
|
|
end
|
|
|
|
else # Do horizontal scrolling.
|
|
|
|
# Always at top line.
|
|
@_rl_last_v_pos = 0
|
|
|
|
# Compute where in the buffer the displayed line should start. This
|
|
# will be LMARGIN.
|
|
|
|
# The number of characters that will be displayed before the cursor.
|
|
ndisp = @cpos_buffer_position - @wrap_offset
|
|
nleft = @prompt_visible_length + @wrap_offset
|
|
# Where the new cursor position will be on the screen. This can be
|
|
# longer than SCREENWIDTH; if it is, lmargin will be adjusted.
|
|
phys_c_pos = @cpos_buffer_position - (@last_lmargin!=0 ? @last_lmargin : @wrap_offset)
|
|
t = @_rl_screenwidth / 3
|
|
|
|
# If the number of characters had already exceeded the screenwidth,
|
|
#last_lmargin will be > 0.
|
|
|
|
# If the number of characters to be displayed is more than the screen
|
|
# width, compute the starting offset so that the cursor is about
|
|
# two-thirds of the way across the screen.
|
|
if (phys_c_pos > @_rl_screenwidth - 2)
|
|
lmargin = @cpos_buffer_position - (2 * t)
|
|
if (lmargin < 0)
|
|
lmargin = 0
|
|
end
|
|
# If the left margin would be in the middle of a prompt with
|
|
# invisible characters, don't display the prompt at all.
|
|
if (@wrap_offset!=0 && lmargin > 0 && lmargin < nleft)
|
|
lmargin = nleft
|
|
end
|
|
elsif (ndisp < @_rl_screenwidth - 2) # XXX - was -1
|
|
lmargin = 0
|
|
elsif (phys_c_pos < 1)
|
|
# If we are moving back towards the beginning of the line and
|
|
# the last margin is no longer correct, compute a new one.
|
|
lmargin = ((@cpos_buffer_position - 1) / t) * t # XXX
|
|
if (@wrap_offset!=0 && lmargin > 0 && lmargin < nleft)
|
|
lmargin = nleft
|
|
end
|
|
else
|
|
lmargin = @last_lmargin
|
|
end
|
|
|
|
# If the first character on the screen isn't the first character
|
|
#in the display line, indicate this with a special character.
|
|
if (lmargin > 0)
|
|
line[lmargin] = '<'
|
|
end
|
|
|
|
# If SCREENWIDTH characters starting at LMARGIN do not encompass
|
|
# the whole line, indicate that with a special character at the
|
|
# right edge of the screen. If LMARGIN is 0, we need to take the
|
|
# wrap offset into account.
|
|
t = lmargin + m_offset(lmargin, @wrap_offset) + @_rl_screenwidth
|
|
if (t < out)
|
|
line[t - 1] = '>'
|
|
end
|
|
if (!@rl_display_fixed || @forced_display || lmargin != @last_lmargin)
|
|
|
|
@forced_display = false
|
|
update_line(@visible_line,@last_lmargin,@invisible_line[lmargin..-1],
|
|
0,
|
|
@_rl_screenwidth + @visible_wrap_offset,
|
|
@_rl_screenwidth + (lmargin ? 0 : @wrap_offset),
|
|
0)
|
|
# If the visible new line is shorter than the old, but the number
|
|
# of invisible characters is greater, and we are at the end of
|
|
# the new line, we need to clear to eol.
|
|
t = @_rl_last_c_pos - m_offset(lmargin, @wrap_offset)
|
|
if ((m_offset(lmargin, @wrap_offset) > @visible_wrap_offset) &&
|
|
(@_rl_last_c_pos == out) &&
|
|
t < @visible_first_line_len)
|
|
|
|
nleft = @_rl_screenwidth - t
|
|
_rl_clear_to_eol(nleft)
|
|
end
|
|
@visible_first_line_len = out - lmargin - m_offset(lmargin, @wrap_offset)
|
|
if (@visible_first_line_len > @_rl_screenwidth)
|
|
@visible_first_line_len = @_rl_screenwidth
|
|
end
|
|
_rl_move_cursor_relative(@cpos_buffer_position - lmargin, @invisible_line ,lmargin)
|
|
@last_lmargin = lmargin
|
|
end
|
|
end
|
|
@rl_outstream.flush
|
|
|
|
# Swap visible and non-visible lines.
|
|
@visible_line,@invisible_line = @invisible_line,@visible_line
|
|
@vis_lbreaks,@inv_lbreaks = @inv_lbreaks,@vis_lbreaks
|
|
|
|
@rl_display_fixed = false
|
|
# If we are displaying on a single line, and last_lmargin is > 0, we
|
|
# are not displaying any invisible characters, so set visible_wrap_offset
|
|
# to 0.
|
|
if (@_rl_horizontal_scroll_mode && @last_lmargin!=0)
|
|
@visible_wrap_offset = 0
|
|
else
|
|
@visible_wrap_offset = @wrap_offset
|
|
end
|
|
end
|
|
|
|
# Tell the update routines that we have moved onto a new (empty) line.
|
|
def rl_on_new_line()
|
|
if (@visible_line)
|
|
@visible_line[0] = 0.chr
|
|
end
|
|
@_rl_last_c_pos = @_rl_last_v_pos = 0
|
|
@_rl_vis_botlin = @last_lmargin = 0
|
|
if (@vis_lbreaks)
|
|
@vis_lbreaks[0] = @vis_lbreaks[1] = 0
|
|
end
|
|
@visible_wrap_offset = 0
|
|
0
|
|
end
|
|
|
|
def rl_reset_line_state()
|
|
rl_on_new_line()
|
|
|
|
@rl_display_prompt = @rl_prompt ? @rl_prompt : ""
|
|
@forced_display = true
|
|
0
|
|
end
|
|
|
|
def _rl_vi_initialize_line
|
|
rl_unsetstate(RL_STATE_VICMDONCE)
|
|
end
|
|
|
|
# Initialize readline (and terminal if not already).
|
|
def rl_initialize()
|
|
# If we have never been called before, initialize the
|
|
# terminal and data structures.
|
|
if (!@rl_initialized)
|
|
rl_setstate(RL_STATE_INITIALIZING)
|
|
readline_initialize_everything()
|
|
rl_unsetstate(RL_STATE_INITIALIZING)
|
|
@rl_initialized = true
|
|
rl_setstate(RL_STATE_INITIALIZED)
|
|
end
|
|
|
|
# Initalize the current line information.
|
|
_rl_init_line_state()
|
|
|
|
# We aren't done yet. We haven't even gotten started yet!
|
|
@rl_done = false
|
|
rl_unsetstate(RL_STATE_DONE)
|
|
|
|
# Tell the history routines what is going on.
|
|
_rl_start_using_history()
|
|
|
|
# Make the display buffer match the state of the line.
|
|
rl_reset_line_state()
|
|
|
|
# No such function typed yet.
|
|
@rl_last_func = nil
|
|
|
|
# Parsing of key-bindings begins in an enabled state.
|
|
@_rl_parsing_conditionalized_out = 0
|
|
|
|
if (@rl_editing_mode == @vi_mode)
|
|
_rl_vi_initialize_line()
|
|
end
|
|
# Each line starts in insert mode (the default).
|
|
_rl_set_insert_mode(RL_IM_DEFAULT, 1)
|
|
|
|
return 0
|
|
end
|
|
|
|
def _rl_strip_prompt(pmt)
|
|
return expand_prompt(pmt).first
|
|
end
|
|
|
|
def _rl_col_width(string,start,_end)
|
|
return 0 if _end <= start
|
|
|
|
index = string.index(0.chr)
|
|
str = index ? string[0,index] : string
|
|
width = 0
|
|
|
|
case @encoding
|
|
when 'N'
|
|
return (_end - start)
|
|
when 'U'
|
|
str[start ... _end].scan(/./mu).each {|s| width += s.unpack('U').first >= 0x1000 ? 2 : 1 }
|
|
when 'S'
|
|
str[start ... _end].scan(/./ms).each {|s| width += s.length }
|
|
when 'E'
|
|
str[start ... _end].scan(/./me).each {|s| width += s.length }
|
|
when 'X'
|
|
tmp = str[start ... _end]
|
|
return 0 if not tmp
|
|
tmp.force_encoding(@encoding_name).codepoints.each {|s| width += s > 0x1000 ? 2 : 1 }
|
|
end
|
|
width
|
|
end
|
|
|
|
# Write COUNT characters from STRING to the output stream.
|
|
def _rl_output_some_chars(string,start,count)
|
|
@_rl_out_stream.write(string[start,count])
|
|
end
|
|
|
|
# Tell the update routines that we have moved onto a new line with the
|
|
# prompt already displayed. Code originally from the version of readline
|
|
# distributed with CLISP. rl_expand_prompt must have already been called
|
|
# (explicitly or implicitly). This still doesn't work exactly right.
|
|
def rl_on_new_line_with_prompt()
|
|
# Initialize visible_line and invisible_line to ensure that they can hold
|
|
# the already-displayed prompt.
|
|
prompt_size = @rl_prompt.length + 1
|
|
init_line_structures(prompt_size)
|
|
|
|
# Make sure the line structures hold the already-displayed prompt for
|
|
# redisplay.
|
|
lprompt = @local_prompt ? @local_prompt : @rl_prompt
|
|
@visible_line[0,lprompt.length] = lprompt
|
|
@invisible_line[0,lprompt.length] = lprompt
|
|
|
|
# If the prompt contains newlines, take the last tail.
|
|
prompt_last_line = rl_prompt.rindex("\n")
|
|
if prompt_last_line.nil?
|
|
prompt_last_line = @rl_prompt
|
|
else
|
|
prompt_last_line = @rl_prompt[prompt_last_line..-1]
|
|
end
|
|
l = prompt_last_line.length
|
|
if !@rl_byte_oriented
|
|
@_rl_last_c_pos = _rl_col_width(prompt_last_line, 0, l)
|
|
else
|
|
@_rl_last_c_pos = l
|
|
end
|
|
|
|
# Dissect prompt_last_line into screen lines. Note that here we have
|
|
# to use the real screenwidth. Readline's notion of screenwidth might be
|
|
# one less, see terminal.c.
|
|
real_screenwidth = @_rl_screenwidth + (@_rl_term_autowrap ? 0 : 1)
|
|
@_rl_last_v_pos = l / real_screenwidth
|
|
# If the prompt length is a multiple of real_screenwidth, we don't know
|
|
# whether the cursor is at the end of the last line, or already at the
|
|
# beginning of the next line. Output a newline just to be safe.
|
|
if (l > 0 && (l % real_screenwidth) == 0)
|
|
_rl_output_some_chars("\n",0,1)
|
|
end
|
|
@last_lmargin = 0
|
|
|
|
newlines = 0
|
|
i = 0
|
|
while (i <= l)
|
|
@_rl_vis_botlin = newlines
|
|
@vis_lbreaks[newlines] = i
|
|
newlines += 1
|
|
i += real_screenwidth
|
|
end
|
|
@vis_lbreaks[newlines] = l
|
|
@visible_wrap_offset = 0
|
|
|
|
@rl_display_prompt = @rl_prompt # XXX - make sure it's set
|
|
|
|
return 0
|
|
end
|
|
|
|
def readline_internal_setup()
|
|
@_rl_in_stream = @rl_instream
|
|
@_rl_out_stream = @rl_outstream
|
|
|
|
if (@rl_startup_hook)
|
|
send(@rl_startup_hook)
|
|
end
|
|
|
|
# If we're not echoing, we still want to at least print a prompt, because
|
|
# rl_redisplay will not do it for us. If the calling application has a
|
|
# custom redisplay function, though, let that function handle it.
|
|
if (!@readline_echoing_p && @rl_redisplay_function == :rl_redisplay)
|
|
if (@rl_prompt && !@rl_already_prompted)
|
|
nprompt = _rl_strip_prompt(@rl_prompt)
|
|
@_rl_out_stream.write(nprompt)
|
|
@_rl_out_stream.flush
|
|
end
|
|
else
|
|
if (@rl_prompt && @rl_already_prompted)
|
|
rl_on_new_line_with_prompt()
|
|
else
|
|
rl_on_new_line()
|
|
end
|
|
send(@rl_redisplay_function)
|
|
end
|
|
|
|
if (@rl_editing_mode == @vi_mode)
|
|
rl_vi_insertion_mode(1, 'i')
|
|
end
|
|
if (@rl_pre_input_hook)
|
|
send(@rl_pre_input_hook)
|
|
end
|
|
end
|
|
|
|
# Create a default argument.
|
|
def _rl_reset_argument()
|
|
@rl_numeric_arg = @rl_arg_sign = 1
|
|
@rl_explicit_arg = false
|
|
@_rl_argcxt = 0
|
|
end
|
|
|
|
# Ring the terminal bell.
|
|
def rl_ding()
|
|
if @MessageBeep
|
|
@MessageBeep.Call(0)
|
|
elsif @readline_echoing_p
|
|
if @_rl_bell_preference == VISIBLE_BELL
|
|
if (@_rl_visible_bell)
|
|
@_rl_out_stream.write(@_rl_visible_bell.chr)
|
|
else
|
|
$stderr.write("\007")
|
|
$stderr.flush
|
|
end
|
|
elsif @_rl_bell_preference == AUDIBLE_BELL
|
|
$stderr.write("\007")
|
|
$stderr.flush
|
|
end
|
|
return 0
|
|
end
|
|
return -1
|
|
end
|
|
|
|
def _rl_search_getchar(cxt)
|
|
# Read a key and decide how to proceed.
|
|
rl_setstate(RL_STATE_MOREINPUT)
|
|
c = cxt.lastc = rl_read_key()
|
|
rl_unsetstate(RL_STATE_MOREINPUT)
|
|
if !@rl_byte_oriented
|
|
cxt.mb = ""
|
|
c = cxt.lastc = _rl_read_mbstring(cxt.lastc, cxt.mb, MB_LEN_MAX)
|
|
end
|
|
c
|
|
end
|
|
|
|
def endsrch_char(c)
|
|
((ctrl_char(c) || meta_char(c) || (c) == RUBOUT) && ((c) != "\C-G"))
|
|
end
|
|
|
|
# Process just-read character C according to isearch context CXT. Return
|
|
# -1 if the caller should just free the context and return, 0 if we should
|
|
# break out of the loop, and 1 if we should continue to read characters.
|
|
def _rl_isearch_dispatch(cxt, c)
|
|
f = nil
|
|
|
|
# Translate the keys we do something with to opcodes.
|
|
if (c && @_rl_keymap[c])
|
|
f = @_rl_keymap[c]
|
|
if (f == :rl_reverse_search_history)
|
|
cxt.lastc = (cxt.sflags & SF_REVERSE)!=0 ? -1 : -2
|
|
elsif (f == :rl_forward_search_history)
|
|
cxt.lastc = (cxt.sflags & SF_REVERSE)!=0 ? -2 : -1
|
|
elsif (f == :rl_rubout)
|
|
cxt.lastc = -3
|
|
elsif (c == "\C-G")
|
|
cxt.lastc = -4
|
|
elsif (c == "\C-W") # XXX
|
|
cxt.lastc = -5
|
|
elsif (c == "\C-Y") # XXX
|
|
cxt.lastc = -6
|
|
end
|
|
end
|
|
|
|
# The characters in isearch_terminators (set from the user-settable
|
|
# variable isearch-terminators) are used to terminate the search but
|
|
# not subsequently execute the character as a command. The default
|
|
# value is "\033\012" (ESC and C-J).
|
|
if (cxt.lastc.class == ::String and cxt.search_terminators.include?(cxt.lastc))
|
|
# ESC still terminates the search, but if there is pending
|
|
#input or if input arrives within 0.1 seconds (on systems
|
|
#with select(2)) it is used as a prefix character
|
|
#with rl_execute_next. WATCH OUT FOR THIS! This is intended
|
|
#to allow the arrow keys to be used like ^F and ^B are used
|
|
#to terminate the search and execute the movement command.
|
|
#XXX - since _rl_input_available depends on the application-
|
|
#settable keyboard timeout value, this could alternatively
|
|
#use _rl_input_queued(100000)
|
|
if (cxt.lastc == ESC && _rl_input_available())
|
|
rl_execute_next(ESC)
|
|
end
|
|
return (0)
|
|
end
|
|
|
|
if !@rl_byte_oriented
|
|
if (cxt.lastc.class == String && (cxt.mb.length == 1) && endsrch_char(cxt.lastc))
|
|
# This sets rl_pending_input to c; it will be picked up the next
|
|
# time rl_read_key is called.
|
|
rl_execute_next(cxt.lastc)
|
|
return (0)
|
|
end
|
|
elsif (cxt.lastc.class == String && endsrch_char(cxt.lastc))
|
|
# This sets rl_pending_input to LASTC; it will be picked up the next
|
|
# time rl_read_key is called.
|
|
rl_execute_next(cxt.lastc)
|
|
return (0)
|
|
end
|
|
|
|
# Now dispatch on the character. `Opcodes' affect the search string or
|
|
# state. Other characters are added to the string.
|
|
case (cxt.lastc)
|
|
|
|
# search again
|
|
when -1
|
|
if (cxt.search_string_index == 0)
|
|
# XXX: This variable is not defined
|
|
# if (last_isearch_string)
|
|
if(false)
|
|
cxt.search_string_size = 64 + last_isearch_string_len
|
|
cxt.search_string = last_isearch_string.dup
|
|
cxt.search_string_index = last_isearch_string_len
|
|
rl_display_search(cxt.search_string, (cxt.sflags & SF_REVERSE)!=0, -1)
|
|
else
|
|
return (1)
|
|
end
|
|
elsif (cxt.sflags & SF_REVERSE)!=0
|
|
cxt.sline_index-=1
|
|
elsif (cxt.sline_index != cxt.sline_len)
|
|
cxt.sline_index+=1
|
|
else
|
|
rl_ding()
|
|
end
|
|
|
|
# switch directions
|
|
when -2
|
|
cxt.direction = -cxt.direction
|
|
if (cxt.direction < 0)
|
|
cxt.sflags |= SF_REVERSE
|
|
else
|
|
cxt.sflags &= ~SF_REVERSE
|
|
end
|
|
# delete character from search string.
|
|
when -3 # C-H, DEL
|
|
# This is tricky. To do this right, we need to keep a
|
|
# stack of search positions for the current search, with
|
|
# sentinels marking the beginning and end. But this will
|
|
# do until we have a real isearch-undo.
|
|
if (cxt.search_string_index == 0)
|
|
rl_ding()
|
|
else
|
|
cxt.search_string[cxt.search_string_index-=1] = 0.chr
|
|
end
|
|
when -4 # C-G, abort
|
|
rl_replace_line(cxt.lines[cxt.save_line], false)
|
|
@rl_point = cxt.save_point
|
|
@rl_mark = cxt.save_mark
|
|
rl_restore_prompt()
|
|
rl_clear_message()
|
|
return -1
|
|
when -5 # C-W
|
|
# skip over portion of line we already matched and yank word
|
|
wstart = @rl_point + cxt.search_string_index
|
|
if (wstart >= @rl_end)
|
|
rl_ding()
|
|
else
|
|
# if not in a word, move to one.
|
|
cval = _rl_char_value(@rl_line_buffer, wstart)
|
|
if (!_rl_walphabetic(cval))
|
|
rl_ding()
|
|
else
|
|
if !@rl_byte_oriented
|
|
n = _rl_find_next_mbchar(@rl_line_buffer, wstart, 1, MB_FIND_NONZERO)
|
|
else
|
|
n = wstart+1
|
|
end
|
|
while (n < @rl_end)
|
|
cval = _rl_char_value(@rl_line_buffer, n)
|
|
break if !_rl_walphabetic(cval)
|
|
if !@rl_byte_oriented
|
|
n = _rl_find_next_mbchar(@rl_line_buffer, n, 1, MB_FIND_NONZERO)
|
|
else
|
|
n = n+1
|
|
end
|
|
end
|
|
wlen = n - wstart + 1
|
|
if (cxt.search_string_index + wlen + 1 >= cxt.search_string_size)
|
|
cxt.search_string_size += wlen + 1
|
|
end
|
|
cxt.search_string[cxt.search_string_index..-1] = @rl_line_buffer[wstart,wlen]
|
|
cxt.search_string_index += wlen
|
|
end
|
|
end
|
|
|
|
when -6 # C-Y
|
|
# skip over portion of line we already matched and yank rest
|
|
wstart = @rl_point + cxt.search_string_index
|
|
if (wstart >= @rl_end)
|
|
rl_ding()
|
|
else
|
|
n = @rl_end - wstart + 1
|
|
if (cxt.search_string_index + n + 1 >= cxt.search_string_size)
|
|
cxt.search_string_size += n + 1
|
|
end
|
|
cxt.search_string[cxt.search_string_index..-1] = @rl_line_buffer[wstart,n]
|
|
end
|
|
|
|
# Add character to search string and continue search.
|
|
else
|
|
if (cxt.search_string_index + 2 >= cxt.search_string_size)
|
|
cxt.search_string_size += 128
|
|
end
|
|
if !@rl_byte_oriented
|
|
for j in 0 ... cxt.mb.length
|
|
cxt.search_string << cxt.mb[j,1]
|
|
cxt.search_string_index += 1
|
|
end
|
|
else
|
|
cxt.search_string << c
|
|
cxt.search_string_index += 1
|
|
end
|
|
end
|
|
|
|
while (cxt.sflags &= ~(SF_FOUND|SF_FAILED))!=0
|
|
limit = cxt.sline_len - cxt.search_string_index + 1
|
|
# Search the current line.
|
|
while ((cxt.sflags & SF_REVERSE)!=0 ? (cxt.sline_index >= 0) : (cxt.sline_index < limit))
|
|
|
|
if (cxt.search_string[0,cxt.search_string_index] == cxt.sline[cxt.sline_index,cxt.search_string_index])
|
|
cxt.sflags |= SF_FOUND
|
|
break
|
|
else
|
|
cxt.sline_index += cxt.direction
|
|
end
|
|
end
|
|
break if (cxt.sflags & SF_FOUND)!=0
|
|
|
|
# Move to the next line, but skip new copies of the line
|
|
# we just found and lines shorter than the string we're
|
|
# searching for.
|
|
begin
|
|
# Move to the next line.
|
|
cxt.history_pos += cxt.direction
|
|
|
|
# At limit for direction?
|
|
if ((cxt.sflags & SF_REVERSE)!=0 ? (cxt.history_pos < 0) : (cxt.history_pos == cxt.hlen))
|
|
cxt.sflags |= SF_FAILED
|
|
break
|
|
end
|
|
|
|
# We will need these later.
|
|
cxt.sline = cxt.lines[cxt.history_pos]
|
|
cxt.sline_len = cxt.sline.length
|
|
end while ((cxt.prev_line_found && cxt.prev_line_found == cxt.lines[cxt.history_pos]) ||
|
|
(cxt.search_string_index > cxt.sline_len))
|
|
|
|
break if (cxt.sflags & SF_FAILED)!=0
|
|
|
|
# Now set up the line for searching...
|
|
cxt.sline_index = (cxt.sflags & SF_REVERSE)!=0 ? cxt.sline_len - cxt.search_string_index : 0
|
|
end
|
|
|
|
if (cxt.sflags & SF_FAILED)!=0
|
|
# We cannot find the search string. Ding the bell.
|
|
rl_ding()
|
|
cxt.history_pos = cxt.last_found_line
|
|
return 1
|
|
end
|
|
|
|
# We have found the search string. Just display it. But don't
|
|
# actually move there in the history list until the user accepts
|
|
# the location.
|
|
if (cxt.sflags & SF_FOUND)!=0
|
|
cxt.prev_line_found = cxt.lines[cxt.history_pos]
|
|
if (cxt.prev_line_found)
|
|
rl_replace_line(cxt.lines[cxt.history_pos], false)
|
|
end
|
|
@rl_point = cxt.sline_index
|
|
cxt.last_found_line = cxt.history_pos
|
|
rl_display_search(cxt.search_string, (cxt.sflags & SF_REVERSE)!=0, (cxt.history_pos == cxt.save_line) ? -1 : cxt.history_pos)
|
|
end
|
|
1
|
|
end
|
|
|
|
# How to clear things from the "echo-area".
|
|
def rl_clear_message()
|
|
@rl_display_prompt = @rl_prompt
|
|
if (@msg_saved_prompt)
|
|
rl_restore_prompt()
|
|
@msg_saved_prompt = nil
|
|
end
|
|
send(@rl_redisplay_function)
|
|
0
|
|
end
|
|
|
|
def _rl_isearch_fini(cxt)
|
|
# First put back the original state.
|
|
@rl_line_buffer = cxt.lines[cxt.save_line].dup
|
|
rl_restore_prompt()
|
|
|
|
# Save the search string for possible later use.
|
|
@last_isearch_string = cxt.search_string
|
|
@last_isearch_string_len = cxt.search_string_index
|
|
cxt.search_string = nil
|
|
|
|
if (cxt.last_found_line < cxt.save_line)
|
|
rl_get_previous_history(cxt.save_line - cxt.last_found_line, 0)
|
|
else
|
|
rl_get_next_history(cxt.last_found_line - cxt.save_line, 0)
|
|
end
|
|
|
|
# If the string was not found, put point at the end of the last matching
|
|
# line. If last_found_line == orig_line, we didn't find any matching
|
|
# history lines at all, so put point back in its original position.
|
|
if (cxt.sline_index < 0)
|
|
|
|
if (cxt.last_found_line == cxt.save_line)
|
|
cxt.sline_index = cxt.save_point
|
|
else
|
|
cxt.sline_index = @rl_line_buffer.delete(0.chr).length
|
|
end
|
|
@rl_mark = cxt.save_mark
|
|
end
|
|
|
|
@rl_point = cxt.sline_index
|
|
# Don't worry about where to put the mark here; rl_get_previous_history
|
|
# and rl_get_next_history take care of it.
|
|
rl_clear_message()
|
|
end
|
|
|
|
|
|
def _rl_isearch_cleanup(cxt, r)
|
|
if (r >= 0)
|
|
_rl_isearch_fini(cxt)
|
|
end
|
|
ctx = nil
|
|
@_rl_iscxt = nil
|
|
|
|
rl_unsetstate(RL_STATE_ISEARCH)
|
|
|
|
r != 0
|
|
end
|
|
|
|
# Do the command associated with KEY in MAP.
|
|
# If the associated command is really a keymap, then read
|
|
# another key, and dispatch into that map.
|
|
def _rl_dispatch(key, map)
|
|
@_rl_dispatching_keymap = map
|
|
return _rl_dispatch_subseq(key, map, false)
|
|
end
|
|
|
|
|
|
def _rl_dispatch_subseq(key, map, got_subseq)
|
|
func = map[key]
|
|
if (func)
|
|
@rl_executing_keymap = map
|
|
|
|
@rl_dispatching = true
|
|
rl_setstate(RL_STATE_DISPATCHING)
|
|
send(map[key],@rl_numeric_arg * @rl_arg_sign, key)
|
|
rl_unsetstate(RL_STATE_DISPATCHING)
|
|
@rl_dispatching = false
|
|
if (@rl_pending_input == 0 && map[key] != :rl_digit_argument)
|
|
@rl_last_func = map[key]
|
|
end
|
|
else
|
|
if(map.keys.detect{|x| x =~ /^#{Regexp.escape(key)}/})
|
|
key += _rl_subseq_getchar(key)
|
|
return _rl_dispatch_subseq(key,map,got_subseq)
|
|
elsif(key.length>1 && key[1] < ?\x7F)
|
|
_rl_abort_internal()
|
|
return -1
|
|
else
|
|
@rl_dispatching = true
|
|
rl_setstate(RL_STATE_DISPATCHING)
|
|
send(:rl_insert,@rl_numeric_arg * @rl_arg_sign, key)
|
|
rl_unsetstate(RL_STATE_DISPATCHING)
|
|
@rl_dispatching = false
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Add KEY to the buffer of characters to be read. Returns 1 if the
|
|
# character was stuffed correctly; 0 otherwise.
|
|
def rl_stuff_char(key)
|
|
return 0 if (ibuffer_space() == 0)
|
|
|
|
if (key == EOF)
|
|
key = NEWLINE
|
|
@rl_pending_input = EOF
|
|
rl_setstate(RL_STATE_INPUTPENDING)
|
|
end
|
|
@ibuffer[@push_index] = key
|
|
@push_index += 1
|
|
if (@push_index >= @ibuffer_len)
|
|
@push_index = 0
|
|
end
|
|
|
|
return 1
|
|
end
|
|
|
|
begin
|
|
# Cygwin will look like Windows, but we want to treat it like a Posix OS:
|
|
raise LoadError, "Cygwin is a Posix OS." if RUBY_PLATFORM =~ /\bcygwin\b/i
|
|
raise LoadError, "Not Windows" if RUBY_PLATFORM !~ /mswin|mingw/
|
|
|
|
if RUBY_VERSION < '1.9.1'
|
|
require 'Win32API'
|
|
else
|
|
require 'dl'
|
|
class Win32API
|
|
DLL = {}
|
|
TYPEMAP = {"0" => DL::TYPE_VOID, "S" => DL::TYPE_VOIDP, "I" => DL::TYPE_LONG}
|
|
|
|
def initialize(dllname, func, import, export = "0")
|
|
@proto = [import].join.tr("VPpNnLlIi", "0SSI").sub(/^(.)0*$/, '\1')
|
|
handle = DLL[dllname] ||= DL.dlopen(dllname)
|
|
@func = DL::CFunc.new(handle[func], TYPEMAP[export.tr("VPpNnLlIi", "0SSI")], func)
|
|
end
|
|
|
|
def call(*args)
|
|
import = @proto.split("")
|
|
args.each_with_index do |x, i|
|
|
args[i], = [x == 0 ? nil : x].pack("p").unpack("l!*") if import[i] == "S"
|
|
args[i], = [x].pack("I").unpack("i") if import[i] == "I"
|
|
end
|
|
ret, = @func.call(args)
|
|
return ret || 0
|
|
end
|
|
|
|
alias Call call
|
|
end
|
|
end
|
|
|
|
STD_OUTPUT_HANDLE = -11
|
|
STD_INPUT_HANDLE = -10
|
|
KEY_EVENT = 1
|
|
VK_SHIFT = 0x10
|
|
VK_MENU = 0x12
|
|
VK_LMENU = 0xA4
|
|
VK_RMENU = 0xA5
|
|
|
|
LEFT_CTRL_PRESSED = 0x0008
|
|
RIGHT_CTRL_PRESSED = 0x0004
|
|
LEFT_ALT_PRESSED = 0x0002
|
|
RIGHT_ALT_PRESSED = 0x0001
|
|
|
|
@getch = Win32API.new("msvcrt", "_getch", [], 'I')
|
|
@kbhit = Win32API.new("msvcrt", "_kbhit", [], 'I')
|
|
@GetStdHandle = Win32API.new("kernel32","GetStdHandle",['L'],'L')
|
|
@SetConsoleCursorPosition = Win32API.new("kernel32","SetConsoleCursorPosition",['L','L'],'L')
|
|
@GetConsoleScreenBufferInfo = Win32API.new("kernel32","GetConsoleScreenBufferInfo",['L','P'],'L')
|
|
@FillConsoleOutputCharacter = Win32API.new("kernel32","FillConsoleOutputCharacter",['L','L','L','L','P'],'L')
|
|
@ReadConsoleInput = Win32API.new( "kernel32", "ReadConsoleInput", ['L', 'P', 'L', 'P'], 'L' )
|
|
@MessageBeep = Win32API.new("user32","MessageBeep",['L'],'L')
|
|
@GetKeyboardState = Win32API.new("user32","GetKeyboardState",['P'],'L')
|
|
@GetKeyState = Win32API.new("user32","GetKeyState",['L'],'L')
|
|
@hConsoleHandle = @GetStdHandle.Call(STD_OUTPUT_HANDLE)
|
|
@hConsoleInput = @GetStdHandle.Call(STD_INPUT_HANDLE)
|
|
@pending_count = 0
|
|
@pending_key = nil
|
|
|
|
begin
|
|
case `chcp`.scan(/\d+$/).first.to_i
|
|
when 936,949,950,51932,51936,50225
|
|
@encoding = "E"
|
|
when 932,50220,50221,20222
|
|
@encoding = "S"
|
|
when 65001
|
|
@encoding = "U"
|
|
else
|
|
@encoding = "N"
|
|
end
|
|
rescue
|
|
@encoding = "N"
|
|
end
|
|
|
|
def rl_getc(stream)
|
|
c = @getch.Call
|
|
alt = (@GetKeyState.call(VK_LMENU) & 0x80) != 0
|
|
if c==0 || c==0xE0
|
|
r = c.chr + @getch.Call.chr
|
|
else
|
|
r = c.chr
|
|
end
|
|
r = "\e"+r if alt
|
|
r
|
|
end
|
|
|
|
def rl_gather_tyi()
|
|
chars_avail = @kbhit.Call
|
|
return 0 if(chars_avail<=0)
|
|
k = send(@rl_getc_function,@rl_instream)
|
|
rl_stuff_char(k)
|
|
return 1
|
|
end
|
|
|
|
rescue LoadError # If we're not on Windows try...
|
|
|
|
if ENV["LANG"] =~ /\.UTF-8/
|
|
@encoding = "U"
|
|
elsif ENV["LANG"] =~ /\.EUC/
|
|
@encoding = "E"
|
|
elsif ENV["LANG"] =~ /\.SHIFT/
|
|
@encoding = "S"
|
|
else
|
|
@encoding = "N"
|
|
end
|
|
|
|
def rl_getc(stream)
|
|
begin
|
|
c = stream.read(1)
|
|
rescue Errno::EINTR
|
|
c = rl_getc(stream)
|
|
end
|
|
return c ? c : EOF
|
|
end
|
|
|
|
def rl_gather_tyi()
|
|
chars_avail = 0
|
|
result = select([@rl_instream],nil,nil,0.1)
|
|
return 0 if result.nil?
|
|
k = send(@rl_getc_function,@rl_instream)
|
|
rl_stuff_char(k)
|
|
return 1
|
|
end
|
|
end
|
|
|
|
if(Object.const_defined?('Encoding') and Encoding.respond_to?('default_external'))
|
|
@encoding = "X" # ruby 1.9.x or greater
|
|
@encoding_name = Encoding.default_external.to_s
|
|
end
|
|
|
|
@rl_byte_oriented = @encoding == "N"
|
|
|
|
# Read a key, including pending input.
|
|
def rl_read_key()
|
|
@rl_key_sequence_length+=1
|
|
|
|
if (@rl_pending_input!=0)
|
|
c = @rl_pending_input
|
|
rl_clear_pending_input()
|
|
else
|
|
# If the user has an event function, then call it periodically.
|
|
if (@rl_event_hook)
|
|
while (@rl_event_hook && (c=rl_get_char()).nil?)
|
|
|
|
send(@rl_event_hook)
|
|
if (@rl_done) # XXX - experimental
|
|
return ("\n")
|
|
end
|
|
if (rl_gather_tyi() < 0) # XXX - EIO
|
|
@rl_done = true
|
|
return ("\n")
|
|
end
|
|
end
|
|
|
|
else
|
|
|
|
if (c=rl_get_char()).nil?
|
|
c = send(@rl_getc_function,@rl_instream)
|
|
end
|
|
end
|
|
end
|
|
|
|
return (c)
|
|
end
|
|
|
|
|
|
# Return the amount of space available in the buffer for stuffing
|
|
# characters.
|
|
def ibuffer_space()
|
|
if (@pop_index > @push_index)
|
|
return (@pop_index - @push_index - 1)
|
|
else
|
|
return (@ibuffer_len - (@push_index - @pop_index))
|
|
end
|
|
end
|
|
|
|
# Get a key from the buffer of characters to be read.
|
|
# Return the key in KEY.
|
|
# Result is KEY if there was a key, or 0 if there wasn't.
|
|
def rl_get_char()
|
|
if (@push_index == @pop_index)
|
|
return nil
|
|
end
|
|
key = @ibuffer[@pop_index]
|
|
@pop_index += 1
|
|
|
|
if (@pop_index >= @ibuffer_len)
|
|
@pop_index = 0
|
|
end
|
|
|
|
return key
|
|
end
|
|
|
|
# Stuff KEY into the *front* of the input buffer.
|
|
# Returns non-zero if successful, zero if there is
|
|
# no space left in the buffer.
|
|
def _rl_unget_char(key)
|
|
if (ibuffer_space()!=0)
|
|
@pop_index-=1
|
|
if (@pop_index < 0)
|
|
@pop_index = @ibuffer_len - 1
|
|
end
|
|
@ibuffer[@pop_index] = key
|
|
return (1)
|
|
end
|
|
return (0)
|
|
end
|
|
|
|
def _rl_subseq_getchar(key)
|
|
if (key == ESC)
|
|
rl_setstate(RL_STATE_METANEXT)
|
|
end
|
|
rl_setstate(RL_STATE_MOREINPUT)
|
|
k = rl_read_key()
|
|
rl_unsetstate(RL_STATE_MOREINPUT)
|
|
if (key == ESC)
|
|
rl_unsetstate(RL_STATE_METANEXT)
|
|
end
|
|
|
|
return k
|
|
end
|
|
|
|
# Clear to the end of the line. COUNT is the minimum
|
|
# number of character spaces to clear,
|
|
def _rl_clear_to_eol(count)
|
|
if (@_rl_term_clreol)
|
|
@rl_outstream.write(@_rl_term_clreol)
|
|
elsif (count!=0)
|
|
space_to_eol(count)
|
|
end
|
|
end
|
|
|
|
# Clear to the end of the line using spaces. COUNT is the minimum
|
|
# number of character spaces to clear,
|
|
def space_to_eol(count)
|
|
if @hConsoleHandle
|
|
csbi = 0.chr * 24
|
|
@GetConsoleScreenBufferInfo.Call(@hConsoleHandle,csbi)
|
|
cursor_pos = csbi[4,4].unpack('L').first
|
|
written = 0.chr * 4
|
|
@FillConsoleOutputCharacter.Call(@hConsoleHandle,0x20,count,cursor_pos,written)
|
|
else
|
|
@rl_outstream.write(' ' * count)
|
|
end
|
|
@_rl_last_c_pos += count
|
|
end
|
|
|
|
def _rl_clear_screen()
|
|
if (@_rl_term_clrpag)
|
|
@rl_outstream.write(@_rl_term_clrpag)
|
|
else
|
|
rl_crlf()
|
|
end
|
|
end
|
|
|
|
# Move the cursor back.
|
|
def _rl_backspace(count)
|
|
if (@_rl_term_backspace)
|
|
@_rl_out_stream.write(@_rl_term_backspace * count)
|
|
else
|
|
@_rl_out_stream.write("\b"*count)
|
|
end
|
|
0
|
|
end
|
|
|
|
# Move to the start of the next line.
|
|
def rl_crlf()
|
|
if (@_rl_term_cr)
|
|
@_rl_out_stream.write(@_rl_term_cr)
|
|
end
|
|
@_rl_out_stream.write("\n")
|
|
return 0
|
|
end
|
|
|
|
# Move to the start of the current line.
|
|
def cr()
|
|
if (@_rl_term_cr)
|
|
@_rl_out_stream.write(@_rl_term_cr)
|
|
@_rl_last_c_pos = 0
|
|
end
|
|
end
|
|
|
|
def _rl_erase_entire_line()
|
|
cr()
|
|
_rl_clear_to_eol(0)
|
|
cr()
|
|
@rl_outstream.flush
|
|
end
|
|
|
|
def _rl_internal_char_cleanup()
|
|
# In vi mode, when you exit insert mode, the cursor moves back
|
|
# over the previous character. We explicitly check for that here.
|
|
if (@rl_editing_mode == @vi_mode && @_rl_keymap == @vi_movement_keymap)
|
|
rl_vi_check()
|
|
end
|
|
|
|
if (@rl_num_chars_to_read!=0 && @rl_end >= @rl_num_chars_to_read)
|
|
send(@rl_redisplay_function)
|
|
@_rl_want_redisplay = false
|
|
rl_newline(1, "\n")
|
|
end
|
|
|
|
if (!@rl_done)
|
|
send(@rl_redisplay_function)
|
|
@_rl_want_redisplay = false
|
|
end
|
|
|
|
# If the application writer has told us to erase the entire line if
|
|
# the only character typed was something bound to rl_newline, do so.
|
|
if (@rl_erase_empty_line && @rl_done && @rl_last_func == :rl_newline &&
|
|
@rl_point == 0 && @rl_end == 0)
|
|
_rl_erase_entire_line()
|
|
end
|
|
end
|
|
|
|
def readline_internal_charloop()
|
|
lastc = -1
|
|
eof_found = false
|
|
|
|
while (!@rl_done)
|
|
lk = @_rl_last_command_was_kill
|
|
|
|
# send(rl_redisplay_function)
|
|
# @_rl_want_redisplay = false
|
|
|
|
if (@rl_pending_input == 0)
|
|
# Then initialize the argument and number of keys read.
|
|
_rl_reset_argument()
|
|
@rl_key_sequence_length = 0
|
|
end
|
|
|
|
rl_setstate(RL_STATE_READCMD)
|
|
c = rl_read_key()
|
|
rl_unsetstate(RL_STATE_READCMD)
|
|
# look at input.c:rl_getc() for the circumstances under which this will
|
|
#be returned; punt immediately on read error without converting it to
|
|
#a newline.
|
|
if (c == READERR)
|
|
eof_found = true
|
|
break
|
|
end
|
|
|
|
# EOF typed to a non-blank line is a <NL>.
|
|
if (c == EOF && @rl_end!=0)
|
|
c = NEWLINE
|
|
end
|
|
|
|
# The character _rl_eof_char typed to blank line, and not as the
|
|
#previous character is interpreted as EOF.
|
|
if (((c == @_rl_eof_char && lastc != c) || c == EOF) && @rl_end==0)
|
|
eof_found = true
|
|
break
|
|
end
|
|
lastc = c
|
|
if _rl_dispatch(c, @_rl_keymap)== -1
|
|
next
|
|
end
|
|
|
|
# If there was no change in _rl_last_command_was_kill, then no kill
|
|
#has taken place. Note that if input is pending we are reading
|
|
#a prefix command, so nothing has changed yet.
|
|
if (@rl_pending_input == 0 && lk == @_rl_last_command_was_kill)
|
|
@_rl_last_command_was_kill = false
|
|
end
|
|
_rl_internal_char_cleanup()
|
|
end
|
|
|
|
eof_found
|
|
end
|
|
|
|
# How to abort things.
|
|
def _rl_abort_internal()
|
|
rl_ding()
|
|
rl_clear_message()
|
|
_rl_reset_argument()
|
|
rl_clear_pending_input()
|
|
|
|
rl_unsetstate(RL_STATE_MACRODEF)
|
|
|
|
@rl_last_func = nil
|
|
#throw :readline_top_level
|
|
send(@rl_redisplay_function)
|
|
@_rl_want_redisplay = false
|
|
0
|
|
end
|
|
|
|
def rl_abort(count, key)
|
|
_rl_abort_internal()
|
|
end
|
|
|
|
def rl_vi_check()
|
|
if (@rl_point!=0 && @rl_point == @rl_end)
|
|
@rl_point-=1
|
|
end
|
|
0
|
|
end
|
|
|
|
def readline_internal_teardown(eof)
|
|
# Restore the original of this history line, iff the line that we
|
|
# are editing was originally in the history, AND the line has changed.
|
|
entry = current_history()
|
|
|
|
if (entry && @rl_undo_list)
|
|
temp = @rl_line_buffer.delete(0.chr).dup
|
|
rl_revert_line(1, 0)
|
|
entry = replace_history_entry(where_history(), @rl_line_buffer, nil)
|
|
entry = nil
|
|
|
|
@rl_line_buffer = temp+0.chr
|
|
temp = nil
|
|
end
|
|
|
|
# At any rate, it is highly likely that this line has an undo list. Get
|
|
# rid of it now.
|
|
if (@rl_undo_list)
|
|
rl_free_undo_list()
|
|
end
|
|
# Restore normal cursor, if available.
|
|
_rl_set_insert_mode(RL_IM_INSERT, 0)
|
|
|
|
(eof ? nil : @rl_line_buffer.delete(0.chr))
|
|
end
|
|
|
|
# Read a line of input from the global rl_instream, doing output on
|
|
# the global rl_outstream.
|
|
# If rl_prompt is non-null, then that is our prompt.
|
|
def readline_internal()
|
|
readline_internal_setup()
|
|
eof = readline_internal_charloop()
|
|
readline_internal_teardown(eof)
|
|
end
|
|
|
|
# Read a line of input. Prompt with PROMPT. An empty PROMPT means
|
|
# none. A return value of NULL means that EOF was encountered.
|
|
def readline(prompt)
|
|
# If we are at EOF return a NULL string.
|
|
if (@rl_pending_input == EOF)
|
|
rl_clear_pending_input()
|
|
return nil
|
|
end
|
|
|
|
rl_set_prompt(prompt)
|
|
|
|
rl_initialize()
|
|
@readline_echoing_p = true
|
|
if (@rl_prep_term_function)
|
|
send(@rl_prep_term_function,@_rl_meta_flag)
|
|
end
|
|
rl_set_signals()
|
|
|
|
value = readline_internal()
|
|
if(@rl_deprep_term_function)
|
|
send(@rl_deprep_term_function)
|
|
end
|
|
|
|
rl_clear_signals()
|
|
|
|
value
|
|
end
|
|
|
|
# Increase the size of RL_LINE_BUFFER until it has enough space to hold
|
|
# LEN characters.
|
|
def rl_extend_line_buffer(len)
|
|
while (len >= @rl_line_buffer.length)
|
|
@rl_line_buffer << 0.chr * DEFAULT_BUFFER_SIZE
|
|
end
|
|
@the_line = @rl_line_buffer
|
|
end
|
|
|
|
# Insert a string of text into the line at point. This is the only
|
|
# way that you should do insertion. _rl_insert_char () calls this
|
|
# function. Returns the number of characters inserted.
|
|
def rl_insert_text(string)
|
|
string.delete!(0.chr)
|
|
l = string.length
|
|
return 0 if (l == 0)
|
|
|
|
if (@rl_end + l >= @rl_line_buffer.length)
|
|
rl_extend_line_buffer(@rl_end + l)
|
|
end
|
|
@rl_line_buffer[@rl_point,0] = string
|
|
|
|
# Remember how to undo this if we aren't undoing something.
|
|
if (!@_rl_doing_an_undo)
|
|
# If possible and desirable, concatenate the undos.
|
|
if ((l == 1) &&
|
|
@rl_undo_list &&
|
|
(@rl_undo_list.what == UNDO_INSERT) &&
|
|
(@rl_undo_list.end == @rl_point) &&
|
|
(@rl_undo_list.end - @rl_undo_list.start < 20))
|
|
@rl_undo_list.end+=1
|
|
else
|
|
rl_add_undo(UNDO_INSERT, @rl_point, @rl_point + l, nil)
|
|
end
|
|
end
|
|
@rl_point += l
|
|
@rl_end += l
|
|
if @rl_line_buffer.length <= @rl_end
|
|
@rl_line_buffer << 0.chr * (@rl_end - @rl_line_buffer.length + 1)
|
|
else
|
|
@rl_line_buffer[@rl_end] = "\0"
|
|
end
|
|
l
|
|
end
|
|
|
|
def alloc_undo_entry(what, start, _end, text)
|
|
temp = Struct.new(:what,:start,:end,:text,:next).new
|
|
temp.what = what
|
|
temp.start = start
|
|
temp.end = _end
|
|
temp.text = text
|
|
temp.next = nil
|
|
temp
|
|
end
|
|
|
|
#* Remember how to undo something. Concatenate some undos if that
|
|
# seems right.
|
|
def rl_add_undo(what, start, _end, text)
|
|
temp = alloc_undo_entry(what, start, _end, text)
|
|
temp.next = @rl_undo_list
|
|
@rl_undo_list = temp
|
|
end
|
|
|
|
|
|
# Delete the string between FROM and TO. FROM is inclusive, TO is not.
|
|
# Returns the number of characters deleted.
|
|
def rl_delete_text(from, to)
|
|
|
|
# Fix it if the caller is confused.
|
|
if (from > to)
|
|
from,to = to,from
|
|
end
|
|
|
|
# fix boundaries
|
|
if (to > @rl_end)
|
|
to = @rl_end
|
|
if (from > to)
|
|
from = to
|
|
end
|
|
end
|
|
if (from < 0)
|
|
from = 0
|
|
end
|
|
text = rl_copy_text(from, to)
|
|
diff = to - from
|
|
@rl_line_buffer[from...to] = ''
|
|
@rl_line_buffer << 0.chr * diff
|
|
# Remember how to undo this delete.
|
|
if (!@_rl_doing_an_undo)
|
|
rl_add_undo(UNDO_DELETE, from, to, text)
|
|
else
|
|
text = nil
|
|
end
|
|
@rl_end -= diff
|
|
@rl_line_buffer[@rl_end] = 0.chr
|
|
return (diff)
|
|
end
|
|
|
|
def rl_copy_text(from, to)
|
|
return @rl_line_buffer[from...to]
|
|
end
|
|
|
|
# Fix up point so that it is within the line boundaries after killing
|
|
# text. If FIX_MARK_TOO is non-zero, the mark is forced within line
|
|
# boundaries also.
|
|
|
|
def __rl_fix_point(x)
|
|
if (x > @rl_end)
|
|
@rl_end
|
|
elsif (x < 0)
|
|
0
|
|
else
|
|
x
|
|
end
|
|
end
|
|
|
|
def _rl_fix_point(fix_mark_too)
|
|
@rl_point = __rl_fix_point(@rl_point)
|
|
if (fix_mark_too)
|
|
@rl_mark = __rl_fix_point(@rl_mark)
|
|
end
|
|
end
|
|
|
|
# Begin a group. Subsequent undos are undone as an atomic operation.
|
|
def rl_begin_undo_group()
|
|
rl_add_undo(UNDO_BEGIN, 0, 0, nil)
|
|
@_rl_undo_group_level+=1
|
|
0
|
|
end
|
|
|
|
# End an undo group started with rl_begin_undo_group ().
|
|
def rl_end_undo_group()
|
|
rl_add_undo(UNDO_END, 0, 0, nil)
|
|
@_rl_undo_group_level-=1
|
|
0
|
|
end
|
|
|
|
def rl_free_undo_list()
|
|
replace_history_data(-1, @rl_undo_list, nil)
|
|
@rl_undo_list = nil
|
|
end
|
|
|
|
# Replace the contents of the line buffer between START and END with
|
|
# TEXT. The operation is undoable. To replace the entire line in an
|
|
# undoable mode, use _rl_replace_text(text, 0, rl_end)
|
|
def _rl_replace_text(text, start, _end)
|
|
rl_begin_undo_group()
|
|
rl_delete_text(start, _end + 1)
|
|
@rl_point = start
|
|
n = rl_insert_text(text)
|
|
rl_end_undo_group()
|
|
n
|
|
end
|
|
|
|
# Replace the current line buffer contents with TEXT. If CLEAR_UNDO is
|
|
# non-zero, we free the current undo list.
|
|
def rl_replace_line(text, clear_undo)
|
|
len = text.delete(0.chr).length
|
|
@rl_line_buffer = text.dup + 0.chr
|
|
@rl_end = len
|
|
if (clear_undo)
|
|
rl_free_undo_list()
|
|
end
|
|
_rl_fix_point(true)
|
|
end
|
|
|
|
|
|
# Replace the DATA in the specified history entries, replacing OLD with
|
|
# NEW. WHICH says which one(s) to replace: WHICH == -1 means to replace
|
|
# all of the history entries where entry->data == OLD; WHICH == -2 means
|
|
# to replace the `newest' history entry where entry->data == OLD; and
|
|
# WHICH >= 0 means to replace that particular history entry's data, as
|
|
# long as it matches OLD.
|
|
def replace_history_data(which,old, new)
|
|
new = new.dup if new
|
|
if (which < -2 || which >= @history_length || @history_length == 0 || @the_history.nil?)
|
|
return
|
|
end
|
|
if (which >= 0)
|
|
entry = @the_history[which]
|
|
if (entry && entry.data == old)
|
|
entry.data = new
|
|
end
|
|
return
|
|
end
|
|
|
|
last = -1
|
|
for i in 0 ... @history_length
|
|
entry = @the_history[i]
|
|
if entry.nil?
|
|
next
|
|
end
|
|
if (entry.data == old)
|
|
last = i
|
|
if (which == -1)
|
|
entry.data = new
|
|
end
|
|
end
|
|
end
|
|
if (which == -2 && last >= 0)
|
|
entry = @the_history[last]
|
|
entry.data = new # XXX - we don't check entry->old
|
|
end
|
|
end
|
|
|
|
# Move forward COUNT bytes.
|
|
def rl_forward_byte(count, key)
|
|
if (count < 0)
|
|
return (rl_backward_byte(-count, key))
|
|
end
|
|
if (count > 0)
|
|
_end = @rl_point + count
|
|
lend = @rl_end > 0 ? @rl_end - ((@rl_editing_mode == @vi_mode)?1:0) : @rl_end
|
|
if (_end > lend)
|
|
@rl_point = lend
|
|
rl_ding()
|
|
else
|
|
@rl_point = _end
|
|
end
|
|
end
|
|
|
|
if (@rl_end < 0)
|
|
@rl_end = 0
|
|
end
|
|
return 0
|
|
end
|
|
|
|
# Move forward COUNT characters.
|
|
def rl_forward_char(count, key)
|
|
if @rl_byte_oriented
|
|
return (rl_forward_byte(count, key))
|
|
end
|
|
if (count < 0)
|
|
return (rl_backward_char(-count, key))
|
|
end
|
|
if (count > 0)
|
|
point = _rl_find_next_mbchar(@rl_line_buffer, @rl_point, count, MB_FIND_NONZERO)
|
|
if (@rl_end <= point && @rl_editing_mode == @vi_mode)
|
|
point = _rl_find_prev_mbchar(@rl_line_buffer, @rl_end, MB_FIND_NONZERO)
|
|
end
|
|
if (@rl_point == point)
|
|
rl_ding()
|
|
end
|
|
@rl_point = point
|
|
if (@rl_end < 0)
|
|
@rl_end = 0
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Backwards compatibility.
|
|
def rl_forward(count, key)
|
|
rl_forward_char(count, key)
|
|
end
|
|
|
|
# Move backward COUNT bytes.
|
|
def rl_backward_byte(count, key)
|
|
if (count < 0)
|
|
return (rl_forward_byte(-count, key))
|
|
end
|
|
if (count > 0)
|
|
if (@rl_point < count)
|
|
@rl_point = 0
|
|
rl_ding()
|
|
else
|
|
@rl_point -= count
|
|
end
|
|
end
|
|
|
|
if (@rl_point < 0)
|
|
@rl_point = 0
|
|
end
|
|
0
|
|
end
|
|
|
|
# Move backward COUNT characters.
|
|
def rl_backward_char(count, key)
|
|
if @rl_byte_oriented
|
|
return (rl_backward_byte(count, key))
|
|
end
|
|
if (count < 0)
|
|
return (rl_forward_char(-count, key))
|
|
end
|
|
|
|
if (count > 0)
|
|
point = @rl_point
|
|
while (count > 0 && point > 0)
|
|
point = _rl_find_prev_mbchar(@rl_line_buffer, point, MB_FIND_NONZERO)
|
|
count-=1
|
|
end
|
|
if (count > 0)
|
|
@rl_point = 0
|
|
rl_ding()
|
|
else
|
|
@rl_point = point
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Backwards compatibility.
|
|
def rl_backward(count, key)
|
|
rl_backward_char(count, key)
|
|
end
|
|
|
|
# Move to the beginning of the line.
|
|
def rl_beg_of_line(count, key)
|
|
@rl_point = 0
|
|
0
|
|
end
|
|
|
|
# Move to the end of the line.
|
|
def rl_end_of_line(count, key)
|
|
@rl_point = @rl_end
|
|
0
|
|
end
|
|
|
|
def _rl_char_value(buf,ind)
|
|
buf[ind,1]
|
|
end
|
|
|
|
@_rl_allow_pathname_alphabetic_chars = false
|
|
@pathname_alphabetic_chars = '/-_=~.#$'
|
|
|
|
def rl_alphabetic(c)
|
|
if c =~ /\w/
|
|
return true
|
|
end
|
|
|
|
return !!(@_rl_allow_pathname_alphabetic_chars &&
|
|
@pathname_alphabetic_chars[c])
|
|
end
|
|
|
|
def _rl_walphabetic(c)
|
|
rl_alphabetic(c)
|
|
end
|
|
|
|
# Move forward a word. We do what Emacs does. Handles multibyte chars.
|
|
def rl_forward_word(count, key)
|
|
if (count < 0)
|
|
return (rl_backward_word(-count, key))
|
|
end
|
|
|
|
while (count>0)
|
|
return 0 if (@rl_point == @rl_end)
|
|
|
|
# If we are not in a word, move forward until we are in one.
|
|
# Then, move forward until we hit a non-alphabetic character.
|
|
c = _rl_char_value(@rl_line_buffer, @rl_point)
|
|
|
|
if (!_rl_walphabetic(c))
|
|
if !@rl_byte_oriented
|
|
@rl_point = _rl_find_next_mbchar(@rl_line_buffer, @rl_point, 1, MB_FIND_NONZERO)
|
|
else
|
|
@rl_point += 1
|
|
end
|
|
while (@rl_point < @rl_end)
|
|
c = _rl_char_value(@rl_line_buffer, @rl_point)
|
|
if (_rl_walphabetic(c))
|
|
break
|
|
end
|
|
if !@rl_byte_oriented
|
|
@rl_point = _rl_find_next_mbchar(@rl_line_buffer, @rl_point, 1, MB_FIND_NONZERO)
|
|
else
|
|
@rl_point += 1
|
|
end
|
|
end
|
|
end
|
|
|
|
return 0 if (@rl_point == @rl_end)
|
|
|
|
if !@rl_byte_oriented
|
|
@rl_point = _rl_find_next_mbchar(@rl_line_buffer, @rl_point, 1, MB_FIND_NONZERO)
|
|
else
|
|
@rl_point += 1
|
|
end
|
|
while (@rl_point < @rl_end)
|
|
c = _rl_char_value(@rl_line_buffer, @rl_point)
|
|
if (!_rl_walphabetic(c))
|
|
break
|
|
end
|
|
if !@rl_byte_oriented
|
|
@rl_point = _rl_find_next_mbchar(@rl_line_buffer, @rl_point, 1, MB_FIND_NONZERO)
|
|
else
|
|
@rl_point += 1
|
|
end
|
|
end
|
|
count -= 1
|
|
end
|
|
0
|
|
end
|
|
|
|
# Move backward a word. We do what Emacs does. Handles multibyte chars.
|
|
def rl_backward_word(count, key)
|
|
if (count < 0)
|
|
return (rl_forward_word(-count, key))
|
|
end
|
|
while (count>0)
|
|
return 0 if (@rl_point == 0)
|
|
|
|
# Like rl_forward_word (), except that we look at the characters
|
|
# just before point.
|
|
_p = !@rl_byte_oriented ? _rl_find_prev_mbchar(@rl_line_buffer, @rl_point, MB_FIND_NONZERO):(@rl_point-1)
|
|
c = _rl_char_value(@rl_line_buffer, _p)
|
|
if (!_rl_walphabetic(c))
|
|
@rl_point = _p
|
|
while (@rl_point > 0)
|
|
_p = !@rl_byte_oriented ? _rl_find_prev_mbchar(@rl_line_buffer, @rl_point, MB_FIND_NONZERO):(@rl_point-1)
|
|
c = _rl_char_value(@rl_line_buffer, _p)
|
|
if (_rl_walphabetic(c))
|
|
break
|
|
end
|
|
@rl_point = _p
|
|
end
|
|
end
|
|
while (@rl_point>0)
|
|
_p = !@rl_byte_oriented ? _rl_find_prev_mbchar(@rl_line_buffer, @rl_point, MB_FIND_NONZERO):(@rl_point-1)
|
|
c = _rl_char_value(@rl_line_buffer, _p)
|
|
if (!_rl_walphabetic(c))
|
|
break
|
|
else
|
|
@rl_point = _p
|
|
end
|
|
end
|
|
count -= 1
|
|
end
|
|
0
|
|
end
|
|
|
|
# return the `current display line' of the cursor -- the number of lines to
|
|
# move up to get to the first screen line of the current readline line.
|
|
def _rl_current_display_line()
|
|
# Find out whether or not there might be invisible characters in the
|
|
# editing buffer.
|
|
if (@rl_display_prompt == @rl_prompt)
|
|
nleft = @_rl_last_c_pos - @_rl_screenwidth - @rl_visible_prompt_length
|
|
else
|
|
nleft = @_rl_last_c_pos - @_rl_screenwidth
|
|
end
|
|
|
|
if (nleft > 0)
|
|
ret = 1 + nleft / @_rl_screenwidth
|
|
else
|
|
ret = 0
|
|
end
|
|
|
|
ret
|
|
end
|
|
|
|
# Actually update the display, period.
|
|
def rl_forced_update_display()
|
|
if (@visible_line)
|
|
@visible_line.gsub!(/[^\x00]/,0.chr)
|
|
end
|
|
rl_on_new_line()
|
|
@forced_display=true if !@forced_display
|
|
send(@rl_redisplay_function)
|
|
0
|
|
end
|
|
|
|
|
|
# Clear the current line. Numeric argument to C-l does this.
|
|
def rl_refresh_line(ignore1, ignore2)
|
|
curr_line = _rl_current_display_line()
|
|
|
|
_rl_move_vert(curr_line)
|
|
_rl_move_cursor_relative(0, @rl_line_buffer) # XXX is this right
|
|
|
|
_rl_clear_to_eol(0) # arg of 0 means to not use spaces
|
|
|
|
rl_forced_update_display()
|
|
@rl_display_fixed = true
|
|
|
|
0
|
|
end
|
|
|
|
# C-l typed to a line without quoting clears the screen, and then reprints
|
|
# the prompt and the current input line. Given a numeric arg, redraw only
|
|
# the current line.
|
|
def rl_clear_screen(count, key)
|
|
if (@rl_explicit_arg)
|
|
rl_refresh_line(count, key)
|
|
return 0
|
|
end
|
|
|
|
_rl_clear_screen() # calls termcap function to clear screen
|
|
rl_forced_update_display()
|
|
@rl_display_fixed = true
|
|
0
|
|
end
|
|
|
|
# Restore the _rl_saved_line_for_history if there is one.
|
|
def rl_maybe_unsave_line()
|
|
if (@_rl_saved_line_for_history)
|
|
# Can't call with `1' because rl_undo_list might point to an undo
|
|
# list from a history entry, as in rl_replace_from_history() below.
|
|
rl_replace_line(@_rl_saved_line_for_history.line, false)
|
|
@rl_undo_list = @_rl_saved_line_for_history.data
|
|
@_rl_saved_line_for_history = nil
|
|
@rl_point = @rl_end # rl_replace_line sets rl_end
|
|
else
|
|
rl_ding()
|
|
end
|
|
0
|
|
end
|
|
|
|
# Save the current line in _rl_saved_line_for_history.
|
|
def rl_maybe_save_line()
|
|
if @_rl_saved_line_for_history.nil?
|
|
@_rl_saved_line_for_history = Struct.new(:line,:timestamp,:data).new
|
|
@_rl_saved_line_for_history.line = @rl_line_buffer.dup
|
|
@_rl_saved_line_for_history.timestamp = nil
|
|
@_rl_saved_line_for_history.data = @rl_undo_list
|
|
end
|
|
0
|
|
end
|
|
|
|
# Returns the magic number which says what history element we are
|
|
# looking at now. In this implementation, it returns history_offset.
|
|
def where_history()
|
|
@history_offset
|
|
end
|
|
|
|
# Make the history entry at WHICH have LINE and DATA. This returns
|
|
# the old entry so you can dispose of the data. In the case of an
|
|
# invalid WHICH, a NULL pointer is returned.
|
|
def replace_history_entry (which, line, data)
|
|
if (which < 0 || which >= @history_length)
|
|
return nil
|
|
end
|
|
temp = Struct.new(:line,:timestamp,:data).new
|
|
old_value = @the_history[which]
|
|
temp.line = line.delete(0.chr)
|
|
temp.data = data
|
|
temp.timestamp = old_value.timestamp.dup
|
|
@the_history[which] = temp
|
|
old_value
|
|
end
|
|
|
|
# Perhaps put back the current line if it has changed.
|
|
def rl_maybe_replace_line()
|
|
temp = current_history()
|
|
# If the current line has changed, save the changes.
|
|
if (temp && temp.data != @rl_undo_list)
|
|
temp = replace_history_entry(where_history(), @rl_line_buffer, @rl_undo_list)
|
|
end
|
|
0
|
|
end
|
|
|
|
# Back up history_offset to the previous history entry, and return
|
|
# a pointer to that entry. If there is no previous entry then return
|
|
# a NULL pointer.
|
|
def previous_history()
|
|
@history_offset!=0 ? @the_history[@history_offset-=1] : nil
|
|
end
|
|
|
|
# Move history_offset forward to the next history entry, and return
|
|
# a pointer to that entry. If there is no next entry then return a
|
|
# NULL pointer.
|
|
def next_history()
|
|
(@history_offset == @history_length) ? nil : @the_history[@history_offset+=1]
|
|
end
|
|
|
|
# Get the previous item out of our interactive history, making it the current
|
|
# line. If there is no previous history, just ding.
|
|
def rl_get_previous_history(count, key)
|
|
if (count < 0)
|
|
return (rl_get_next_history(-count, key))
|
|
end
|
|
if (count == 0)
|
|
return 0
|
|
end
|
|
# either not saved by rl_newline or at end of line, so set appropriately.
|
|
if (@_rl_history_saved_point == -1 && (@rl_point!=0 || @rl_end!=0))
|
|
@_rl_history_saved_point = (@rl_point == @rl_end) ? -1 : @rl_point
|
|
end
|
|
|
|
# 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 = nil
|
|
while (count>0)
|
|
temp = previous_history()
|
|
if temp.nil?
|
|
break
|
|
end
|
|
old_temp = temp
|
|
count -= 1
|
|
end
|
|
|
|
# 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.nil? && old_temp)
|
|
temp = old_temp
|
|
end
|
|
|
|
if temp.nil?
|
|
rl_ding()
|
|
else
|
|
rl_replace_from_history(temp, 0)
|
|
_rl_history_set_point()
|
|
end
|
|
|
|
0
|
|
end
|
|
|
|
def _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
|
|
end
|
|
if (@rl_editing_mode == @vi_mode && @_rl_keymap != @vi_insertion_keymap)
|
|
@rl_point = 0
|
|
end
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
@rl_mark = (@rl_point == @rl_end ? 0 : @rl_end)
|
|
end
|
|
end
|
|
|
|
# Move down to the next history line.
|
|
def rl_get_next_history(count, key)
|
|
if (count < 0)
|
|
return (rl_get_previous_history(-count, key))
|
|
end
|
|
if (count == 0)
|
|
return 0
|
|
end
|
|
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!=0 || @rl_end!=0))
|
|
@_rl_history_saved_point = (@rl_point == @rl_end) ? -1 : @rl_point
|
|
end
|
|
temp = nil
|
|
while (count>0)
|
|
temp = next_history()
|
|
if temp.nil?
|
|
break
|
|
end
|
|
count -= 1
|
|
end
|
|
|
|
if temp.nil?
|
|
rl_maybe_unsave_line()
|
|
else
|
|
rl_replace_from_history(temp, 0)
|
|
_rl_history_set_point()
|
|
end
|
|
0
|
|
end
|
|
|
|
def rl_arrow_keys(count, c)
|
|
rl_setstate(RL_STATE_MOREINPUT)
|
|
ch = rl_read_key()
|
|
rl_unsetstate(RL_STATE_MOREINPUT)
|
|
|
|
case (ch.upcase)
|
|
when 'A'
|
|
rl_get_previous_history(count, ch)
|
|
when 'B'
|
|
rl_get_next_history(count, ch)
|
|
when 'C'
|
|
rl_forward_byte(count, ch)
|
|
when 'D'
|
|
rl_backward_byte(count, ch)
|
|
else
|
|
rl_ding()
|
|
end
|
|
0
|
|
end
|
|
|
|
def _rl_any_typein()
|
|
return (@push_index != @pop_index)
|
|
end
|
|
|
|
def _rl_insert_typein(c)
|
|
string = c
|
|
|
|
while ((key = rl_get_char()) &&
|
|
@_rl_keymap[key] == :rl_insert)
|
|
string << key
|
|
end
|
|
if (key)
|
|
_rl_unget_char(key)
|
|
end
|
|
rl_insert_text(string)
|
|
end
|
|
|
|
# Insert the character C at the current location, moving point forward.
|
|
# If C introduces a multibyte sequence, we read the whole sequence and
|
|
# then insert the multibyte char into the line buffer.
|
|
def _rl_insert_char(count, c)
|
|
return 0 if (count <= 0)
|
|
|
|
incoming = ''
|
|
|
|
if @rl_byte_oriented
|
|
incoming << c
|
|
incoming_length = 1
|
|
else
|
|
@pending_bytes << c
|
|
if _rl_get_char_len(@pending_bytes) == -2
|
|
return 1
|
|
else
|
|
incoming = @pending_bytes
|
|
@pending_bytes = ''
|
|
incoming_length = incoming.length
|
|
end
|
|
end
|
|
|
|
if(count>1)
|
|
string = incoming * count
|
|
rl_insert_text(string)
|
|
string = nil
|
|
return 0
|
|
end
|
|
|
|
if @rl_byte_oriented
|
|
# We are inserting a single character.
|
|
#If there is pending input, then make a string of all of the
|
|
#pending characters that are bound to rl_insert, and insert
|
|
#them all.
|
|
if (_rl_any_typein())
|
|
_rl_insert_typein(c)
|
|
else
|
|
rl_insert_text(c)
|
|
end
|
|
else
|
|
rl_insert_text(incoming)
|
|
end
|
|
|
|
return 0
|
|
end
|
|
|
|
# Overwrite the character at point (or next COUNT characters) with C.
|
|
# If C introduces a multibyte character sequence, read the entire sequence
|
|
# before starting the overwrite loop.
|
|
def _rl_overwrite_char(count, c)
|
|
|
|
# Read an entire multibyte character sequence to insert COUNT times.
|
|
if (count > 0 && !@rl_byte_oriented)
|
|
mbkey = ''
|
|
k = _rl_read_mbstring(c, mbkey, MB_LEN_MAX)
|
|
end
|
|
rl_begin_undo_group()
|
|
|
|
count.times do
|
|
if !@rl_byte_oriented
|
|
rl_insert_text(mbkey)
|
|
else
|
|
_rl_insert_char(1, c)
|
|
end
|
|
if (@rl_point < @rl_end)
|
|
rl_delete(1, c)
|
|
end
|
|
end
|
|
|
|
rl_end_undo_group()
|
|
|
|
return 0
|
|
end
|
|
|
|
def rl_insert(count, c)
|
|
((@rl_insert_mode == RL_IM_INSERT) ? _rl_insert_char(count, c) :
|
|
_rl_overwrite_char(count, c))
|
|
end
|
|
|
|
|
|
# Insert the next typed character verbatim.
|
|
def _rl_insert_next(count)
|
|
rl_setstate(RL_STATE_MOREINPUT)
|
|
c = rl_read_key()
|
|
rl_unsetstate(RL_STATE_MOREINPUT)
|
|
|
|
_rl_insert_char(count, c)
|
|
end
|
|
|
|
def rl_quoted_insert(count, key)
|
|
_rl_insert_next(count)
|
|
end
|
|
|
|
# Insert a tab character.
|
|
def rl_tab_insert(count, key)
|
|
_rl_insert_char(count, "\t")
|
|
end
|
|
|
|
def _rl_vi_save_insert(up)
|
|
if (up.nil? || up.what != UNDO_INSERT)
|
|
if (@vi_insert_buffer_size >= 1)
|
|
@vi_insert_buffer[0] = 0.chr
|
|
end
|
|
return
|
|
end
|
|
start = up.start
|
|
_end = up.end
|
|
len = _end - start + 1
|
|
@vi_insert_buffer = @rl_line_buffer[start,len-1]
|
|
end
|
|
|
|
def _rl_vi_done_inserting()
|
|
if (@_rl_vi_doing_insert)
|
|
|
|
# The `C', `s', and `S' commands set this.
|
|
rl_end_undo_group()
|
|
# Now, the text between rl_undo_list->next->start and
|
|
# rl_undo_list->next->end is what was inserted while in insert
|
|
# mode. It gets copied to VI_INSERT_BUFFER because it depends
|
|
# on absolute indices into the line which may change (though they
|
|
# probably will not).
|
|
@_rl_vi_doing_insert = 0
|
|
_rl_vi_save_insert(@rl_undo_list.next)
|
|
@vi_continued_command = 1
|
|
else
|
|
if ((@_rl_vi_last_key_before_insert == 'i' || @_rl_vi_last_key_before_insert == 'a') && @rl_undo_list)
|
|
_rl_vi_save_insert(@rl_undo_list)
|
|
|
|
# XXX - Other keys probably need to be checked.
|
|
elsif (@_rl_vi_last_key_before_insert == 'C')
|
|
rl_end_undo_group()
|
|
end
|
|
while (@_rl_undo_group_level > 0)
|
|
rl_end_undo_group()
|
|
end
|
|
@vi_continued_command = 0
|
|
end
|
|
end
|
|
|
|
# Is the command C a VI mode text modification command?
|
|
def _rl_vi_textmod_command(c)
|
|
return @vi_textmod[c]
|
|
end
|
|
|
|
def _rl_vi_reset_last()
|
|
@_rl_vi_last_command = 'i'
|
|
@_rl_vi_last_repeat = 1
|
|
@_rl_vi_last_arg_sign = 1
|
|
@_rl_vi_last_motion = 0
|
|
end
|
|
|
|
def _rl_update_final()
|
|
full_lines = false
|
|
# If the cursor is the only thing on an otherwise-blank last line,
|
|
# compensate so we don't print an extra CRLF.
|
|
if (@_rl_vis_botlin && @_rl_last_c_pos == 0 &&
|
|
@visible_line[@vis_lbreaks[@_rl_vis_botlin]] == ?\0 )
|
|
@_rl_vis_botlin-=1
|
|
full_lines = true
|
|
end
|
|
_rl_move_vert(@_rl_vis_botlin)
|
|
# If we've wrapped lines, remove the final xterm line-wrap flag.
|
|
if (full_lines && @_rl_term_autowrap && (vis_llen(@_rl_vis_botlin) == @_rl_screenwidth))
|
|
last_line = @visible_line[@vis_lbreaks[@_rl_vis_botlin]..-1]
|
|
@cpos_buffer_position = -1 # don't know where we are in buffer
|
|
_rl_move_cursor_relative(@_rl_screenwidth - 1, last_line) # XXX
|
|
_rl_clear_to_eol(0)
|
|
@rl_outstream.write(last_line[@_rl_screenwidth - 1,1])
|
|
end
|
|
@_rl_vis_botlin = 0
|
|
rl_crlf()
|
|
@rl_outstream.flush
|
|
@rl_display_fixed = true if !@rl_display_fixed
|
|
end
|
|
|
|
|
|
# What to do when a NEWLINE is pressed. We accept the whole line.
|
|
# KEY is the key that invoked this command. I guess it could have
|
|
# meaning in the future.
|
|
def rl_newline(count, key)
|
|
@rl_done = true
|
|
|
|
if (@_rl_history_preserve_point)
|
|
@_rl_history_saved_point = (@rl_point == @rl_end) ? 1 : @rl_point
|
|
end
|
|
rl_setstate(RL_STATE_DONE)
|
|
|
|
if (@rl_editing_mode == @vi_mode)
|
|
_rl_vi_done_inserting()
|
|
if (_rl_vi_textmod_command(@_rl_vi_last_command).nil?) # XXX
|
|
_rl_vi_reset_last()
|
|
end
|
|
end
|
|
# If we've been asked to erase empty lines, suppress the final update,
|
|
# since _rl_update_final calls rl_crlf().
|
|
if (@rl_erase_empty_line && @rl_point == 0 && @rl_end == 0)
|
|
return 0
|
|
end
|
|
if @readline_echoing_p
|
|
_rl_update_final()
|
|
end
|
|
0
|
|
end
|
|
|
|
# What to do for some uppercase characters, like meta characters,
|
|
# and some characters appearing in emacs_ctlx_keymap. This function
|
|
# is just a stub, you bind keys to it and the code in _rl_dispatch ()
|
|
# is special cased.
|
|
def rl_do_lowercase_version(ignore1, ignore2)
|
|
0
|
|
end
|
|
|
|
def rl_character_len(c, pos)
|
|
if (meta_char(c))
|
|
return ((!@_rl_output_meta_chars) ? 4 : 1)
|
|
end
|
|
if (c == "\t")
|
|
return (((pos | 7) + 1) - pos)
|
|
end
|
|
if (ctrl_char(c) || c == RUBOUT)
|
|
return (2)
|
|
end
|
|
|
|
return ((isprint(c)) ? 1 : 2)
|
|
end
|
|
|
|
# This is different from what vi does, so the code's not shared. Emacs
|
|
# rubout in overwrite mode has one oddity: it replaces a control
|
|
# character that's displayed as two characters (^X) with two spaces.
|
|
def _rl_overwrite_rubout(count, key)
|
|
if (@rl_point == 0)
|
|
rl_ding()
|
|
return 1
|
|
end
|
|
|
|
opoint = @rl_point
|
|
|
|
# L == number of spaces to insert
|
|
l = 0
|
|
count.times do
|
|
rl_backward_char(1, key)
|
|
l += rl_character_len(@rl_line_buffer[@rl_point,1], @rl_point) # not exactly right
|
|
end
|
|
|
|
rl_begin_undo_group()
|
|
|
|
if (count > 1 || @rl_explicit_arg)
|
|
rl_kill_text(opoint, @rl_point)
|
|
else
|
|
rl_delete_text(opoint, @rl_point)
|
|
end
|
|
# Emacs puts point at the beginning of the sequence of spaces.
|
|
if (@rl_point < @rl_end)
|
|
opoint = @rl_point
|
|
_rl_insert_char(l, ' ')
|
|
@rl_point = opoint
|
|
end
|
|
|
|
rl_end_undo_group()
|
|
|
|
0
|
|
end
|
|
|
|
# Rubout the character behind point.
|
|
def rl_rubout(count, key)
|
|
if (count < 0)
|
|
return (rl_delete(-count, key))
|
|
end
|
|
if (@rl_point==0)
|
|
rl_ding()
|
|
return -1
|
|
end
|
|
|
|
if (@rl_insert_mode == RL_IM_OVERWRITE)
|
|
return (_rl_overwrite_rubout(count, key))
|
|
end
|
|
_rl_rubout_char(count, key)
|
|
end
|
|
|
|
|
|
# Quick redisplay hack when erasing characters at the end of the line.
|
|
def _rl_erase_at_end_of_line(l)
|
|
_rl_backspace(l)
|
|
@rl_outstream.write(' '*l)
|
|
_rl_backspace(l)
|
|
@_rl_last_c_pos -= l
|
|
@visible_line[@_rl_last_c_pos,l] = 0.chr * l
|
|
@rl_display_fixed = true if !@rl_display_fixed
|
|
end
|
|
|
|
def _rl_rubout_char(count, key)
|
|
# Duplicated code because this is called from other parts of the library.
|
|
if (count < 0)
|
|
return (rl_delete(-count, key))
|
|
end
|
|
if (@rl_point == 0)
|
|
rl_ding()
|
|
return -1
|
|
end
|
|
|
|
orig_point = @rl_point
|
|
if (count > 1 || @rl_explicit_arg)
|
|
rl_backward_char(count, key)
|
|
rl_kill_text(orig_point, @rl_point)
|
|
elsif (@rl_byte_oriented)
|
|
c = @rl_line_buffer[@rl_point-=1,1]
|
|
rl_delete_text(@rl_point, orig_point)
|
|
# The erase-at-end-of-line hack is of questionable merit now.
|
|
if (@rl_point == @rl_end && isprint(c) && @_rl_last_c_pos!=0)
|
|
l = rl_character_len(c, @rl_point)
|
|
_rl_erase_at_end_of_line(l)
|
|
end
|
|
else
|
|
@rl_point = _rl_find_prev_mbchar(@rl_line_buffer, @rl_point, MB_FIND_NONZERO)
|
|
rl_delete_text(@rl_point, orig_point)
|
|
end
|
|
|
|
0
|
|
end
|
|
|
|
# Delete the character under the cursor. Given a numeric argument,
|
|
# kill that many characters instead.
|
|
def rl_delete(count, key)
|
|
if (count < 0)
|
|
return (_rl_rubout_char(-count, key))
|
|
end
|
|
if (@rl_point == @rl_end)
|
|
rl_ding()
|
|
return -1
|
|
end
|
|
|
|
if (count > 1 || @rl_explicit_arg)
|
|
xpoint = @rl_point
|
|
rl_forward_byte(count, key)
|
|
|
|
rl_kill_text(xpoint, @rl_point)
|
|
@rl_point = xpoint
|
|
else
|
|
if !@rl_byte_oriented
|
|
xpoint =_rl_find_next_mbchar(@rl_line_buffer, @rl_point, 1, MB_FIND_NONZERO)
|
|
else
|
|
xpoint = @rl_point + 1
|
|
end
|
|
|
|
rl_delete_text(@rl_point, xpoint)
|
|
end
|
|
0
|
|
end
|
|
|
|
# Add TEXT to the kill ring, allocating a new kill ring slot as necessary.
|
|
# This uses TEXT directly, so the caller must not free it. If APPEND is
|
|
# non-zero, and the last command was a kill, the text is appended to the
|
|
# current kill ring slot, otherwise prepended.
|
|
def _rl_copy_to_kill_ring(text, append)
|
|
# First, find the slot to work with.
|
|
if (!@_rl_last_command_was_kill)
|
|
# Get a new slot.
|
|
if @rl_kill_ring.nil?
|
|
# If we don't have any defined, then make one.
|
|
@rl_kill_ring_length = 1
|
|
@rl_kill_ring = Array.new(@rl_kill_ring_length+1)
|
|
@rl_kill_ring[slot = 0] = nil
|
|
else
|
|
# We have to add a new slot on the end, unless we have
|
|
# exceeded the max limit for remembering kills.
|
|
slot = @rl_kill_ring_length
|
|
if (slot == @rl_max_kills)
|
|
@rl_kill_ring[0,slot] = @rl_kill_ring[1,slot]
|
|
else
|
|
slot = @rl_kill_ring_length += 1
|
|
end
|
|
@rl_kill_ring[slot-=1] = nil
|
|
end
|
|
else
|
|
slot = @rl_kill_ring_length - 1
|
|
end
|
|
|
|
# If the last command was a kill, prepend or append.
|
|
if (@_rl_last_command_was_kill && @rl_editing_mode != @vi_mode)
|
|
old = @rl_kill_ring[slot]
|
|
|
|
if (append)
|
|
new = old + text
|
|
else
|
|
new = text + old
|
|
end
|
|
old = nil
|
|
text = nil
|
|
@rl_kill_ring[slot] = new
|
|
else
|
|
@rl_kill_ring[slot] = text
|
|
end
|
|
|
|
@rl_kill_index = slot
|
|
0
|
|
end
|
|
|
|
# The way to kill something. This appends or prepends to the last
|
|
# kill, if the last command was a kill command. if FROM is less
|
|
# than TO, then the text is appended, otherwise prepended. If the
|
|
# last command was not a kill command, then a new slot is made for
|
|
# this kill.
|
|
def rl_kill_text(from, to)
|
|
# Is there anything to kill?
|
|
if (from == to)
|
|
@_rl_last_command_was_kill = true if !@_rl_last_command_was_kill
|
|
return 0
|
|
end
|
|
text = rl_copy_text(from, to)
|
|
|
|
# Delete the copied text from the line.
|
|
rl_delete_text(from, to)
|
|
_rl_copy_to_kill_ring(text, from < to)
|
|
@_rl_last_command_was_kill = true if !@_rl_last_command_was_kill
|
|
0
|
|
end
|
|
|
|
# This does what C-w does in Unix. We can't prevent people from
|
|
# using behaviour that they expect.
|
|
def rl_unix_word_rubout(count, key)
|
|
if (@rl_point == 0)
|
|
rl_ding()
|
|
else
|
|
orig_point = @rl_point
|
|
if (count <= 0)
|
|
count = 1
|
|
end
|
|
|
|
while (count>0)
|
|
while (@rl_point>0 && whitespace(@rl_line_buffer[@rl_point - 1,1]))
|
|
@rl_point-=1
|
|
end
|
|
|
|
while (@rl_point>0 && !whitespace(@rl_line_buffer[@rl_point - 1,1]))
|
|
@rl_point-=1
|
|
end
|
|
count -= 1
|
|
end
|
|
|
|
rl_kill_text(orig_point, @rl_point)
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
@rl_mark = @rl_point
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# This deletes one filename component in a Unix pathname. That is, it
|
|
# deletes backward to directory separator (`/') or whitespace.
|
|
def rl_unix_filename_rubout(count, key)
|
|
if (@rl_point == 0)
|
|
rl_ding()
|
|
else
|
|
orig_point = @rl_point
|
|
if (count <= 0)
|
|
count = 1
|
|
end
|
|
|
|
while (count>0)
|
|
|
|
c = @rl_line_buffer[@rl_point - 1,1]
|
|
while (@rl_point>0 && (whitespace(c) || c == '/'))
|
|
@rl_point-=1
|
|
c = @rl_line_buffer[@rl_point - 1,1]
|
|
end
|
|
|
|
while (@rl_point>0 && !whitespace(c) && c != '/')
|
|
@rl_point-=1
|
|
c = @rl_line_buffer[@rl_point - 1,1]
|
|
end
|
|
count -= 1
|
|
end
|
|
|
|
rl_kill_text(orig_point, @rl_point)
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
@rl_mark = @rl_point
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Delete the character under the cursor, unless the insertion
|
|
# point is at the end of the line, in which case the character
|
|
# behind the cursor is deleted. COUNT is obeyed and may be used
|
|
# to delete forward or backward that many characters.
|
|
def rl_rubout_or_delete(count, key)
|
|
if (@rl_end != 0 && @rl_point == @rl_end)
|
|
return (_rl_rubout_char(count, key))
|
|
else
|
|
return (rl_delete(count, key))
|
|
end
|
|
end
|
|
|
|
# Delete all spaces and tabs around point.
|
|
def rl_delete_horizontal_space(count, ignore)
|
|
start = @rl_point
|
|
|
|
while (@rl_point!=0 && whitespace(@rl_line_buffer[@rl_point - 1]))
|
|
@rl_point-=1
|
|
end
|
|
start = @rl_point
|
|
while (@rl_point < @rl_end && whitespace(@rl_line_buffer[@rl_point]))
|
|
@rl_point+=1
|
|
end
|
|
if (start != @rl_point)
|
|
rl_delete_text(start, @rl_point)
|
|
@rl_point = start
|
|
end
|
|
if (@rl_point < 0)
|
|
@rl_point = 0
|
|
end
|
|
0
|
|
end
|
|
|
|
# List the possible completions. See description of rl_complete ().
|
|
def rl_possible_completions(ignore, invoking_key)
|
|
rl_complete_internal('?')
|
|
end
|
|
|
|
# Like the tcsh editing function delete-char-or-list. The eof character
|
|
# is caught before this is invoked, so this really does the same thing as
|
|
# delete-char-or-list-or-eof, as long as it's bound to the eof character.
|
|
def rl_delete_or_show_completions(count, key)
|
|
if (@rl_end != 0 && @rl_point == @rl_end)
|
|
return (rl_possible_completions(count, key))
|
|
else
|
|
return (rl_delete(count, key))
|
|
end
|
|
end
|
|
|
|
# Turn the current line into a comment in shell history.
|
|
# A K*rn shell style function.
|
|
def rl_insert_comment(count, key)
|
|
rl_beg_of_line(1, key)
|
|
@rl_comment_text = @_rl_comment_begin ? @_rl_comment_begin : '#'
|
|
|
|
if (!@rl_explicit_arg)
|
|
rl_insert_text(@rl_comment_text)
|
|
else
|
|
@rl_comment_len = @rl_comment_text.length
|
|
if @rl_comment_text[0,@rl_comment_len] == @rl_line_buffer[0,@rl_comment_len]
|
|
rl_delete_text(@rl_point, @rl_point + @rl_comment_len)
|
|
else
|
|
rl_insert_text(@rl_comment_text)
|
|
end
|
|
end
|
|
|
|
send(@rl_redisplay_function)
|
|
rl_newline(1, "\n")
|
|
0
|
|
end
|
|
|
|
def alloc_history_entry(string, ts)
|
|
temp = Struct.new(:line,:data,:timestamp).new
|
|
temp.line = string ? string.delete(0.chr) : string
|
|
temp.data = nil
|
|
temp.timestamp = ts
|
|
|
|
return temp
|
|
end
|
|
|
|
def hist_inittime()
|
|
t = Time.now.to_i
|
|
ts = "X%u" % t
|
|
ret = ts.dup
|
|
ret[0] = @history_comment_char
|
|
|
|
ret
|
|
end
|
|
|
|
# Place STRING at the end of the history list. The data field
|
|
# is set to NULL.
|
|
def add_history(string)
|
|
if (@history_stifled && (@history_length == @history_max_entries))
|
|
# If the history is stifled, and history_length is zero,
|
|
# and it equals history_max_entries, we don't save items.
|
|
return if (@history_length == 0)
|
|
@the_history.shift
|
|
else
|
|
if @the_history.nil?
|
|
@the_history = []
|
|
@history_length = 1
|
|
else
|
|
@history_length+=1
|
|
end
|
|
end
|
|
|
|
temp = alloc_history_entry(string, hist_inittime())
|
|
@the_history[@history_length] = nil
|
|
@the_history[@history_length - 1] = temp
|
|
end
|
|
|
|
def using_history()
|
|
@history_offset = @history_length
|
|
end
|
|
|
|
# Set default values for readline word completion. These are the variables
|
|
# that application completion functions can change or inspect.
|
|
def set_completion_defaults(what_to_do)
|
|
# Only the completion entry function can change these.
|
|
@rl_filename_completion_desired = false
|
|
@rl_filename_quoting_desired = true
|
|
@rl_completion_type = what_to_do
|
|
@rl_completion_suppress_append = @rl_completion_suppress_quote = false
|
|
|
|
# The completion entry function may optionally change this.
|
|
@rl_completion_mark_symlink_dirs = @_rl_complete_mark_symlink_dirs
|
|
end
|
|
|
|
def _rl_find_completion_word()
|
|
_end = @rl_point
|
|
found_quote = 0
|
|
delimiter = 0.chr
|
|
quote_char = 0.chr
|
|
|
|
brkchars = nil
|
|
if @rl_completion_word_break_hook
|
|
brkchars = send(@rl_completion_word_break_hook)
|
|
end
|
|
if brkchars.nil?
|
|
brkchars = @rl_completer_word_break_characters
|
|
end
|
|
if (@rl_completer_quote_characters)
|
|
# We have a list of characters which can be used in pairs to
|
|
# quote substrings for the completer. Try to find the start
|
|
# of an unclosed quoted substring.
|
|
# FOUND_QUOTE is set so we know what kind of quotes we found.
|
|
scan = 0
|
|
pass_next = false
|
|
while scan < _end
|
|
if (pass_next)
|
|
pass_next = false
|
|
next
|
|
end
|
|
|
|
# Shell-like semantics for single quotes -- don't allow backslash
|
|
# to quote anything in single quotes, especially not the closing
|
|
# quote. If you don't like this, take out the check on the value
|
|
# of quote_char.
|
|
if (quote_char != "'" && @rl_line_buffer[scan] == ?\\)
|
|
pass_next = true
|
|
found_quote |= RL_QF_BACKSLASH
|
|
next
|
|
end
|
|
|
|
if (quote_char != 0.chr)
|
|
# Ignore everything until the matching close quote char.
|
|
if (@rl_line_buffer[scan,1] == quote_char)
|
|
# Found matching close. Abandon this substring.
|
|
quote_char = 0.chr
|
|
@rl_point = _end
|
|
end
|
|
|
|
elsif (@rl_completer_quote_characters.include?(@rl_line_buffer[scan,1]))
|
|
|
|
# Found start of a quoted substring.
|
|
quote_char = @rl_line_buffer[scan,1]
|
|
@rl_point = scan + 1
|
|
# Shell-like quoting conventions.
|
|
if (quote_char == "'")
|
|
found_quote |= RL_QF_SINGLE_QUOTE
|
|
elsif (quote_char == '"')
|
|
found_quote |= RL_QF_DOUBLE_QUOTE
|
|
else
|
|
found_quote |= RL_QF_OTHER_QUOTE
|
|
end
|
|
end
|
|
if !@rl_byte_oriented
|
|
scan = _rl_find_next_mbchar(@rl_line_buffer, scan, 1, MB_FIND_ANY)
|
|
else
|
|
scan += 1
|
|
end
|
|
end
|
|
end
|
|
|
|
if (@rl_point == _end && quote_char == 0.chr)
|
|
|
|
# We didn't find an unclosed quoted substring upon which to do
|
|
# completion, so use the word break characters to find the
|
|
# substring on which to complete.
|
|
|
|
|
|
while (@rl_point = !@rl_byte_oriented ?
|
|
_rl_find_prev_mbchar(@rl_line_buffer, @rl_point, MB_FIND_ANY):(@rl_point-1))>0
|
|
|
|
scan = @rl_line_buffer[@rl_point,1]
|
|
if !brkchars.include?(scan)
|
|
next
|
|
end
|
|
# Call the application-specific function to tell us whether
|
|
# this word break character is quoted and should be skipped.
|
|
if (@rl_char_is_quoted_p && found_quote!=0 &&
|
|
send(@rl_char_is_quoted_p,@rl_line_buffer, @rl_point))
|
|
next
|
|
end
|
|
|
|
# Convoluted code, but it avoids an n^2 algorithm with calls
|
|
# to char_is_quoted.
|
|
break
|
|
end
|
|
end
|
|
|
|
# If we are at an unquoted word break, then advance past it.
|
|
scan = @rl_line_buffer[@rl_point,1]
|
|
|
|
# If there is an application-specific function to say whether or not
|
|
# a character is quoted and we found a quote character, let that
|
|
# function decide whether or not a character is a word break, even
|
|
# if it is found in rl_completer_word_break_characters. Don't bother
|
|
# if we're at the end of the line, though.
|
|
if (scan != 0.chr)
|
|
if (@rl_char_is_quoted_p)
|
|
isbrk = (found_quote == 0 ||
|
|
!send(@rl_char_is_quoted_p,@rl_line_buffer, @rl_point)) &&
|
|
brkchars.include?(scan)
|
|
else
|
|
isbrk = brkchars.include?(scan)
|
|
end
|
|
|
|
if (isbrk)
|
|
# If the character that caused the word break was a quoting
|
|
# character, then remember it as the delimiter.
|
|
if (@rl_basic_quote_characters &&
|
|
@rl_basic_quote_characters.include?(scan) &&
|
|
(_end - @rl_point) > 1)
|
|
delimiter = scan
|
|
end
|
|
|
|
# If the character isn't needed to determine something special
|
|
# about what kind of completion to perform, then advance past it.
|
|
if (@rl_special_prefixes.nil? || !@rl_special_prefixes.include?(scan) )
|
|
@rl_point+=1
|
|
end
|
|
end
|
|
end
|
|
|
|
return [quote_char,found_quote!=0,delimiter]
|
|
end
|
|
|
|
def gen_completion_matches(text, start, _end, our_func, found_quote, quote_char)
|
|
@rl_completion_found_quote = found_quote
|
|
@rl_completion_quote_character = quote_char
|
|
|
|
# If the user wants to TRY to complete, but then wants to give
|
|
# up and use the default completion function, they set the
|
|
# variable rl_attempted_completion_function.
|
|
if (@rl_attempted_completion_function)
|
|
matches = Readline.send(@rl_attempted_completion_function,text, start, _end)
|
|
if (matches || @rl_attempted_completion_over)
|
|
@rl_attempted_completion_over = false
|
|
return (matches)
|
|
end
|
|
end
|
|
# XXX -- filename dequoting moved into rl_filename_completion_function
|
|
|
|
matches = rl_completion_matches(text, our_func)
|
|
matches
|
|
end
|
|
|
|
# Filter out duplicates in MATCHES. This frees up the strings in
|
|
# MATCHES.
|
|
def remove_duplicate_matches(matches)
|
|
# Sort the items.
|
|
# Sort the array without matches[0], since we need it to
|
|
# stay in place no matter what.
|
|
if matches.length>0
|
|
matches[1..-2] = matches[1..-2].sort.uniq
|
|
end
|
|
matches
|
|
end
|
|
|
|
def postprocess_matches(matchesp, matching_filenames)
|
|
matches = matchesp
|
|
|
|
return 0 if matches.nil?
|
|
|
|
# It seems to me that in all the cases we handle we would like
|
|
# to ignore duplicate possiblilities. Scan for the text to
|
|
# insert being identical to the other completions.
|
|
if (@rl_ignore_completion_duplicates)
|
|
remove_duplicate_matches(matches)
|
|
end
|
|
|
|
# If we are matching filenames, then here is our chance to
|
|
# do clever processing by re-examining the list. Call the
|
|
# ignore function with the array as a parameter. It can
|
|
# munge the array, deleting matches as it desires.
|
|
if (@rl_ignore_some_completions_function && matching_filenames)
|
|
nmatch = matches.length
|
|
send(@rl_ignore_some_completions_function,matches)
|
|
if (matches.nil? || matches[0].nil?)
|
|
matches = nil
|
|
return 0
|
|
else
|
|
# If we removed some matches, recompute the common prefix.
|
|
i = matches.length
|
|
if (i > 1 && i < nmatch)
|
|
t = matches[0]
|
|
compute_lcd_of_matches(matches, i - 1, t)
|
|
end
|
|
end
|
|
end
|
|
|
|
matchesp = matches
|
|
1
|
|
end
|
|
|
|
def insert_all_matches(matches, point, qc)
|
|
rl_begin_undo_group()
|
|
# remove any opening quote character; make_quoted_replacement will add
|
|
# it back.
|
|
if (qc && qc.length>0 && point>0 && @rl_line_buffer[point - 1,1] == qc)
|
|
point-=1
|
|
end
|
|
rl_delete_text(point, @rl_point)
|
|
@rl_point = point
|
|
if (matches[1])
|
|
i = 1
|
|
while(matches[i])
|
|
rp = make_quoted_replacement(matches[i], SINGLE_MATCH, qc)
|
|
rl_insert_text(rp)
|
|
rl_insert_text(" ")
|
|
if (rp != matches[i])
|
|
rp = nil
|
|
end
|
|
i += 1
|
|
end
|
|
else
|
|
rp = make_quoted_replacement(matches[0], SINGLE_MATCH, qc)
|
|
rl_insert_text(rp)
|
|
rl_insert_text(" ")
|
|
if (rp != matches[0])
|
|
rp = nil
|
|
end
|
|
end
|
|
rl_end_undo_group()
|
|
end
|
|
|
|
def make_quoted_replacement(match, mtype, qc)
|
|
# If we are doing completion on quoted substrings, and any matches
|
|
# contain any of the completer_word_break_characters, then auto-
|
|
# matically prepend the substring with a quote character (just pick
|
|
# the first one from the list of such) if it does not already begin
|
|
# with a quote string. FIXME: Need to remove any such automatically
|
|
# inserted quote character when it no longer is necessary, such as
|
|
# if we change the string we are completing on and the new set of
|
|
# matches don't require a quoted substring.
|
|
replacement = match
|
|
|
|
should_quote = match && @rl_completer_quote_characters &&
|
|
@rl_filename_completion_desired &&
|
|
@rl_filename_quoting_desired
|
|
|
|
if (should_quote)
|
|
should_quote = should_quote && (qc.nil? || qc == 0.chr ||
|
|
(@rl_completer_quote_characters && @rl_completer_quote_characters.include?(qc)))
|
|
end
|
|
|
|
if (should_quote)
|
|
|
|
# If there is a single match, see if we need to quote it.
|
|
# This also checks whether the common prefix of several
|
|
# matches needs to be quoted.
|
|
should_quote = @rl_filename_quote_characters ?
|
|
!!match[@rl_filename_quote_characters] :
|
|
false
|
|
|
|
do_replace = should_quote ? mtype : NO_MATCH
|
|
# Quote the replacement, since we found an embedded
|
|
# word break character in a potential match.
|
|
if (do_replace != NO_MATCH && @rl_filename_quoting_function)
|
|
replacement = send(@rl_filename_quoting_function,match, do_replace, qc)
|
|
end
|
|
end
|
|
replacement
|
|
end
|
|
|
|
|
|
def insert_match(match, start, mtype, qc)
|
|
oqc = qc
|
|
replacement = make_quoted_replacement(match, mtype, qc)
|
|
|
|
# Now insert the match.
|
|
if (replacement)
|
|
# Don't double an opening quote character.
|
|
if (qc && qc.length>0 && start!=0 && @rl_line_buffer[start - 1,1] == qc &&
|
|
replacement[0,1] == qc)
|
|
start-=1
|
|
# If make_quoted_replacement changed the quoting character, remove
|
|
# the opening quote and insert the (fully-quoted) replacement.
|
|
elsif (qc && (qc != oqc) && start!=0 && @rl_line_buffer[start - 1,1] == oqc &&
|
|
replacement[0,1] != oqc)
|
|
start-=1
|
|
end
|
|
_rl_replace_text(replacement, start, @rl_point - 1)
|
|
if (replacement != match)
|
|
replacement = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
# Return the portion of PATHNAME that should be output when listing
|
|
# possible completions. If we are hacking filename completion, we
|
|
# are only interested in the basename, the portion following the
|
|
# final slash. Otherwise, we return what we were passed. Since
|
|
# printing empty strings is not very informative, if we're doing
|
|
# filename completion, and the basename is the empty string, we look
|
|
# for the previous slash and return the portion following that. If
|
|
# there's no previous slash, we just return what we were passed.
|
|
def printable_part(pathname)
|
|
if (!@rl_filename_completion_desired) # don't need to do anything
|
|
return (pathname)
|
|
end
|
|
|
|
temp = pathname.rindex('/')
|
|
return pathname if temp.nil?
|
|
File.basename(pathname)
|
|
end
|
|
|
|
def fnprint(to_print)
|
|
printed_len = 0
|
|
|
|
case @encoding
|
|
when 'E'
|
|
arr = to_print.scan(/./me)
|
|
when 'S'
|
|
arr = to_print.scan(/./ms)
|
|
when 'U'
|
|
arr = to_print.scan(/./mu)
|
|
when 'X'
|
|
arr = to_print.dup.force_encoding(@encoding_name).chars
|
|
else
|
|
arr = to_print.scan(/./m)
|
|
end
|
|
|
|
arr.each do |s|
|
|
if(ctrl_char(s))
|
|
@rl_outstream.write('^'+(s[0].ord|0x40).chr.upcase)
|
|
printed_len += 2
|
|
elsif s == RUBOUT
|
|
@rl_outstream.write('^?')
|
|
printed_len += 2
|
|
else
|
|
@rl_outstream.write(s)
|
|
if @encoding=='U'
|
|
printed_len += s.unpack('U').first >= 0x1000 ? 2 : 1
|
|
elsif @encoding=='X'
|
|
printed_len += s.ord >= 0x1000 ? 2 : 1
|
|
else
|
|
printed_len += s.length
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
printed_len
|
|
end
|
|
|
|
def _rl_internal_pager(lines)
|
|
@rl_outstream.puts "--More--"
|
|
@rl_outstream.flush
|
|
i = get_y_or_n(1)
|
|
_rl_erase_entire_line()
|
|
if (i == 0)
|
|
return -1
|
|
elsif (i == 2)
|
|
return (lines - 1)
|
|
else
|
|
return 0
|
|
end
|
|
end
|
|
|
|
def path_isdir(filename)
|
|
return File.directory?(filename)
|
|
end
|
|
|
|
# Return the character which best describes FILENAME.
|
|
# `@' for symbolic links
|
|
# `/' for directories
|
|
# `*' for executables
|
|
# `=' for sockets
|
|
# `|' for FIFOs
|
|
# `%' for character special devices
|
|
# `#' for block special devices
|
|
def stat_char(filename)
|
|
return nil if !File.exists?(filename)
|
|
|
|
return '/' if File.directory?(filename)
|
|
return '%' if File.chardev?(filename)
|
|
return '#' if File.blockdev?(filename)
|
|
return '@' if File.symlink?(filename)
|
|
return '=' if File.socket?(filename)
|
|
return '|' if File.pipe?(filename)
|
|
return '*' if File.executable?(filename)
|
|
nil
|
|
end
|
|
|
|
|
|
# Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
|
|
# are using it, check for and output a single character for `special'
|
|
# filenames. Return the number of characters we output.
|
|
def print_filename(to_print, full_pathname)
|
|
extension_char = 0.chr
|
|
printed_len = fnprint(to_print)
|
|
|
|
if (@rl_filename_completion_desired && (@rl_visible_stats || @_rl_complete_mark_directories))
|
|
|
|
# If to_print != full_pathname, to_print is the basename of the
|
|
# path passed. In this case, we try to expand the directory
|
|
# name before checking for the stat character.
|
|
if (to_print != full_pathname)
|
|
|
|
if full_pathname.nil? || full_pathname.length==0
|
|
dn = "/"
|
|
else
|
|
dn = File.dirname(full_pathname)
|
|
end
|
|
s = File.expand_path(dn)
|
|
if (@rl_directory_completion_hook)
|
|
send(@rl_directory_completion_hook,s)
|
|
end
|
|
|
|
slen = s.length
|
|
tlen = to_print.length
|
|
new_full_pathname = s.dup
|
|
if (s[-1] == ?/ )
|
|
slen-=1
|
|
else
|
|
new_full_pathname[slen] = ?/
|
|
end
|
|
new_full_pathname[slen .. -1] = '/' + to_print
|
|
|
|
if (@rl_visible_stats)
|
|
extension_char = stat_char(new_full_pathname)
|
|
else
|
|
if (path_isdir(new_full_pathname))
|
|
extension_char = '/'
|
|
end
|
|
end
|
|
|
|
new_full_pathname = nil
|
|
|
|
else
|
|
|
|
s = File.expand_path(full_pathname)
|
|
if (@rl_visible_stats)
|
|
extension_char = stat_char(s)
|
|
else
|
|
if (path_isdir(s))
|
|
extension_char = '/'
|
|
end
|
|
end
|
|
end
|
|
s = nil
|
|
if (extension_char)
|
|
@rl_outstream.write(extension_char)
|
|
printed_len+=1
|
|
end
|
|
end
|
|
|
|
printed_len
|
|
end
|
|
|
|
# The user must press "y" or "n". Non-zero return means "y" pressed.
|
|
def get_y_or_n(for_pager)
|
|
while(true)
|
|
|
|
rl_setstate(RL_STATE_MOREINPUT)
|
|
c = rl_read_key()
|
|
rl_unsetstate(RL_STATE_MOREINPUT)
|
|
|
|
if (c == 'y' || c == 'Y' || c == ' ')
|
|
return (1)
|
|
end
|
|
if (c == 'n' || c == 'N' || c == RUBOUT)
|
|
return (0)
|
|
end
|
|
if (c == ABORT_CHAR)
|
|
_rl_abort_internal()
|
|
end
|
|
if (for_pager && (c == NEWLINE || c == RETURN))
|
|
return (2)
|
|
end
|
|
if (for_pager && (c == 'q' || c == 'Q'))
|
|
return (0)
|
|
end
|
|
rl_ding()
|
|
end
|
|
end
|
|
|
|
# Compute width of STRING when displayed on screen by print_filename
|
|
def fnwidth(string)
|
|
left = string.length + 1
|
|
width = pos = 0
|
|
while (string[pos] && string[pos] != ?\0)
|
|
if (ctrl_char(string[0,1]) || string[0,1] == RUBOUT)
|
|
width += 2
|
|
pos+=1
|
|
else
|
|
case @encoding
|
|
when 'E'
|
|
wc = string[pos,left-pos].scan(/./me)[0]
|
|
bytes = wc.length
|
|
tempwidth = wc.length
|
|
when 'S'
|
|
wc = string[pos,left-pos].scan(/./ms)[0]
|
|
bytes = wc.length
|
|
tempwidth = wc.length
|
|
when 'U'
|
|
wc = string[pos,left-pos].scan(/./mu)[0]
|
|
bytes = wc.length
|
|
tempwidth = wc.unpack('U').first >= 0x1000 ? 2 : 1
|
|
when 'X'
|
|
wc = string[pos,left-pos].force_encoding(@encoding_name)[0]
|
|
bytes = wc.bytesize
|
|
tempwidth = wc.ord >= 0x1000 ? 2 : 1
|
|
else
|
|
wc = string[pos,left-pos].scan(/./m)[0]
|
|
bytes = wc.length
|
|
tempwidth = wc.length
|
|
end
|
|
clen = bytes
|
|
pos += clen
|
|
w = tempwidth
|
|
width += (w >= 0) ? w : 1
|
|
end
|
|
end
|
|
width
|
|
end
|
|
|
|
# Display MATCHES, a list of matching filenames in argv format. This
|
|
# handles the simple case -- a single match -- first. If there is more
|
|
# than one match, we compute the number of strings in the list and the
|
|
# length of the longest string, which will be needed by the display
|
|
# function. If the application wants to handle displaying the list of
|
|
# matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the
|
|
# address of a function, and we just call it. If we're handling the
|
|
# display ourselves, we just call rl_display_match_list. We also check
|
|
# that the list of matches doesn't exceed the user-settable threshold,
|
|
# and ask the user if he wants to see the list if there are more matches
|
|
# than RL_COMPLETION_QUERY_ITEMS.
|
|
def display_matches(matches)
|
|
# Move to the last visible line of a possibly-multiple-line command.
|
|
_rl_move_vert(@_rl_vis_botlin)
|
|
|
|
# Handle simple case first. What if there is only one answer?
|
|
if matches[1].nil?
|
|
temp = printable_part(matches[0])
|
|
rl_crlf()
|
|
print_filename(temp, matches[0])
|
|
rl_crlf()
|
|
rl_forced_update_display()
|
|
@rl_display_fixed = true
|
|
return
|
|
end
|
|
|
|
# There is more than one answer. Find out how many there are,
|
|
# and find the maximum printed length of a single entry.
|
|
max = 0
|
|
i = 1
|
|
while(matches[i])
|
|
temp = printable_part(matches[i])
|
|
len = fnwidth(temp)
|
|
|
|
if (len > max)
|
|
max = len
|
|
end
|
|
i += 1
|
|
end
|
|
len = i - 1
|
|
|
|
# If the caller has defined a display hook, then call that now.
|
|
if (@rl_completion_display_matches_hook)
|
|
send(@rl_completion_display_matches_hook,matches, len, max)
|
|
return
|
|
end
|
|
|
|
# If there are many items, then ask the user if she really wants to
|
|
# see them all.
|
|
if (@rl_completion_query_items > 0 && len >= @rl_completion_query_items)
|
|
|
|
rl_crlf()
|
|
@rl_outstream.write("Display all #{len} possibilities? (y or n)")
|
|
@rl_outstream.flush
|
|
if (get_y_or_n(false)==0)
|
|
rl_crlf()
|
|
|
|
rl_forced_update_display()
|
|
@rl_display_fixed = true
|
|
|
|
return
|
|
end
|
|
end
|
|
|
|
rl_display_match_list(matches, len, max)
|
|
|
|
rl_forced_update_display()
|
|
@rl_display_fixed = true
|
|
end
|
|
|
|
# Complete the word at or before point.
|
|
# WHAT_TO_DO says what to do with the completion.
|
|
# `?' means list the possible completions.
|
|
# TAB means do standard completion.
|
|
# `*' means insert all of the possible completions.
|
|
# `!' means to do standard completion, and list all possible completions if
|
|
# there is more than one.
|
|
# `@' means to do standard completion, and list all possible completions if
|
|
# there is more than one and partial completion is not possible.
|
|
def rl_complete_internal(what_to_do)
|
|
rl_setstate(RL_STATE_COMPLETING)
|
|
set_completion_defaults(what_to_do)
|
|
|
|
saved_line_buffer = @rl_line_buffer ? @rl_line_buffer.delete(0.chr) : nil
|
|
our_func = @rl_completion_entry_function ?
|
|
@rl_completion_entry_function : :rl_filename_completion_function
|
|
# We now look backwards for the start of a filename/variable word.
|
|
_end = @rl_point
|
|
found_quote = false
|
|
delimiter = 0.chr
|
|
quote_char = 0.chr
|
|
|
|
if (@rl_point!=0)
|
|
# This (possibly) changes rl_point. If it returns a non-zero char,
|
|
# we know we have an open quote.
|
|
quote_char,found_quote,delimiter = _rl_find_completion_word()
|
|
end
|
|
|
|
start = @rl_point
|
|
@rl_point = _end
|
|
|
|
text = rl_copy_text(start, _end)
|
|
matches = gen_completion_matches(text, start, _end, our_func, found_quote, quote_char)
|
|
# nontrivial_lcd is set if the common prefix adds something to the word
|
|
# being completed.
|
|
nontrivial_lcd = !!(matches && text != matches[0])
|
|
text = nil
|
|
if matches.nil?
|
|
rl_ding()
|
|
saved_line_buffer = nil
|
|
@completion_changed_buffer = false
|
|
rl_unsetstate(RL_STATE_COMPLETING)
|
|
return 0
|
|
end
|
|
|
|
# If we are matching filenames, the attempted completion function will
|
|
# have set rl_filename_completion_desired to a non-zero value. The basic
|
|
# rl_filename_completion_function does this.
|
|
i = @rl_filename_completion_desired
|
|
if (postprocess_matches(matches, i) == 0)
|
|
rl_ding()
|
|
saved_line_buffer = nil
|
|
@completion_changed_buffer = false
|
|
rl_unsetstate(RL_STATE_COMPLETING)
|
|
return 0
|
|
end
|
|
|
|
case (what_to_do)
|
|
|
|
when TAB,'!','@'
|
|
# Insert the first match with proper quoting.
|
|
if (matches[0])
|
|
insert_match(matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, quote_char)
|
|
end
|
|
# If there are more matches, ring the bell to indicate.
|
|
# If we are in vi mode, Posix.2 says to not ring the bell.
|
|
# If the `show-all-if-ambiguous' variable is set, display
|
|
# all the matches immediately. Otherwise, if this was the
|
|
# only match, and we are hacking files, check the file to
|
|
# see if it was a directory. If so, and the `mark-directories'
|
|
# variable is set, add a '/' to the name. If not, and we
|
|
# are at the end of the line, then add a space.
|
|
if (matches[1])
|
|
if (what_to_do == '!')
|
|
display_matches(matches)
|
|
elsif (what_to_do == '@')
|
|
if (!nontrivial_lcd)
|
|
display_matches(matches)
|
|
end
|
|
elsif (@rl_editing_mode != @vi_mode)
|
|
rl_ding() # There are other matches remaining.
|
|
end
|
|
else
|
|
append_to_match(matches[0], delimiter, quote_char, nontrivial_lcd)
|
|
end
|
|
when '*'
|
|
insert_all_matches(matches, start, quote_char)
|
|
when '?'
|
|
display_matches(matches)
|
|
else
|
|
$stderr.write("\r\nreadline: bad value #{what_to_do} for what_to_do in rl_complete\n")
|
|
rl_ding()
|
|
saved_line_buffer = nil
|
|
rl_unsetstate(RL_STATE_COMPLETING)
|
|
return 1
|
|
end
|
|
|
|
matches = nil
|
|
|
|
# Check to see if the line has changed through all of this manipulation.
|
|
if (saved_line_buffer)
|
|
@completion_changed_buffer = @rl_line_buffer.delete(0.chr) != saved_line_buffer
|
|
saved_line_buffer = nil
|
|
end
|
|
|
|
rl_unsetstate(RL_STATE_COMPLETING)
|
|
0
|
|
end
|
|
|
|
# Complete the word at or before point. You have supplied the function
|
|
# that does the initial simple matching selection algorithm (see
|
|
# rl_completion_matches ()). The default is to do filename completion.
|
|
def rl_complete(ignore, invoking_key)
|
|
if (@rl_inhibit_completion)
|
|
return (_rl_insert_char(ignore, invoking_key))
|
|
elsif (@rl_last_func == :rl_complete && !@completion_changed_buffer)
|
|
return (rl_complete_internal('?'))
|
|
elsif (@_rl_complete_show_all)
|
|
return (rl_complete_internal('!'))
|
|
elsif (@_rl_complete_show_unmodified)
|
|
return (rl_complete_internal('@'))
|
|
else
|
|
return (rl_complete_internal(TAB))
|
|
end
|
|
end
|
|
|
|
# Return the history entry which is logically at OFFSET in the history array.
|
|
# OFFSET is relative to history_base.
|
|
def history_get(offset)
|
|
local_index = offset - @history_base
|
|
return (local_index >= @history_length || local_index < 0 || @the_history.nil?) ?
|
|
nil : @the_history[local_index]
|
|
end
|
|
|
|
def rl_replace_from_history(entry, flags)
|
|
# Can't call with `1' because rl_undo_list might point to an undo list
|
|
# from a history entry, just like we're setting up here.
|
|
rl_replace_line(entry.line, false)
|
|
@rl_undo_list = entry.data
|
|
@rl_point = @rl_end
|
|
@rl_mark = 0
|
|
|
|
if (@rl_editing_mode == @vi_mode)
|
|
@rl_point = 0
|
|
@rl_mark = @rl_end
|
|
end
|
|
end
|
|
|
|
# Remove history element WHICH from the history. The removed
|
|
# element is returned to you so you can free the line, data,
|
|
# and containing structure.
|
|
def remove_history(which)
|
|
if (which < 0 || which >= @history_length || @history_length == 0 || @the_history.nil?)
|
|
return nil
|
|
end
|
|
return_value = @the_history[which]
|
|
@the_history.delete_at(which)
|
|
@history_length-=1
|
|
return_value
|
|
end
|
|
|
|
def block_sigint()
|
|
return if @sigint_blocked
|
|
#@sigint_proc = Signal.trap("INT","IGNORE")
|
|
@sigint_blocked = true
|
|
end
|
|
|
|
def release_sigint()
|
|
return if !@sigint_blocked
|
|
#Signal.trap("INT",@sigint_proc)
|
|
@sigint_blocked = false
|
|
end
|
|
|
|
def save_tty_chars()
|
|
@_rl_last_tty_chars = @_rl_tty_chars
|
|
h = Hash[*`stty -a `.scan(/(\w+) = ([^;]+);/).flatten]
|
|
h.each {|k,v| v.gsub!(/\^(.)/){($1[0].ord ^ ((?a..?z).include?($1[0]) ? 0x60 : 0x40)).chr}}
|
|
@_rl_tty_chars.t_erase = h['erase']
|
|
@_rl_tty_chars.t_kill = h['kill']
|
|
@_rl_tty_chars.t_intr = h['intr']
|
|
@_rl_tty_chars.t_quit = h['quit']
|
|
@_rl_tty_chars.t_start = h['start']
|
|
@_rl_tty_chars.t_stop = h['stop']
|
|
@_rl_tty_chars.t_eof = h['eof']
|
|
@_rl_tty_chars.t_eol = "\n"
|
|
@_rl_tty_chars.t_eol2 = h['eol2']
|
|
@_rl_tty_chars.t_susp = h['susp']
|
|
@_rl_tty_chars.t_dsusp = h['dsusp']
|
|
@_rl_tty_chars.t_reprint = h['rprnt']
|
|
@_rl_tty_chars.t_flush = h['flush']
|
|
@_rl_tty_chars.t_werase = h['werase']
|
|
@_rl_tty_chars.t_lnext = h['lnext']
|
|
@_rl_tty_chars.t_status = -1
|
|
@otio = `stty -g `
|
|
end
|
|
|
|
def _rl_bind_tty_special_chars(kmap)
|
|
kmap[@_rl_tty_chars.t_erase] = :rl_rubout
|
|
kmap[@_rl_tty_chars.t_kill] = :rl_unix_line_discard
|
|
kmap[@_rl_tty_chars.t_werase] = :rl_unix_word_rubout
|
|
kmap[@_rl_tty_chars.t_lnext] = :rl_quoted_insert
|
|
end
|
|
|
|
def prepare_terminal_settings(meta_flag)
|
|
@readline_echoing_p = (`stty -a `.scan(/-*echo\b/).first == 'echo')
|
|
|
|
# First, the basic settings to put us into character-at-a-time, no-echo
|
|
# input mode.
|
|
setting = " -echo -icrnl cbreak"
|
|
|
|
# If this terminal doesn't care how the 8th bit is used, then we can
|
|
# use it for the meta-key. If only one of even or odd parity is
|
|
# specified, then the terminal is using parity, and we cannot.
|
|
if (`stty -a `.scan(/-parenb\b/).first == '-parenb')
|
|
setting << " pass8"
|
|
end
|
|
|
|
setting << " -ixoff"
|
|
|
|
rl_bind_key(@_rl_tty_chars.t_start, :rl_restart_output)
|
|
@_rl_eof_char = @_rl_tty_chars.t_eof
|
|
|
|
#setting << " -isig"
|
|
|
|
`stty #{setting} `
|
|
end
|
|
|
|
def _rl_control_keypad(on)
|
|
if on && @_rl_term_ks
|
|
@_rl_out_stream.write(@_rl_term_ks)
|
|
elsif !on && @_rl_term_ke
|
|
@_rl_out_stream.write(@_rl_term_ke)
|
|
end
|
|
end
|
|
|
|
# Rebind all of the tty special chars that readline worries about back
|
|
# to self-insert. Call this before saving the current terminal special
|
|
# chars with save_tty_chars(). This only works on POSIX termios or termio
|
|
# systems.
|
|
def rl_tty_unset_default_bindings(kmap)
|
|
# Don't bother before we've saved the tty special chars at least once.
|
|
return if (!rl_isstate(RL_STATE_TTYCSAVED))
|
|
|
|
kmap[@_rl_tty_chars.t_erase] = :rl_insert
|
|
kmap[@_rl_tty_chars.t_kill] = :rl_insert
|
|
kmap[@_rl_tty_chars.t_lnext] = :rl_insert
|
|
kmap[@_rl_tty_chars.t_werase] = :rl_insert
|
|
end
|
|
|
|
def rl_prep_terminal(meta_flag)
|
|
if no_terminal?
|
|
@readline_echoing_p = true
|
|
return
|
|
end
|
|
|
|
return if (@terminal_prepped)
|
|
|
|
# Try to keep this function from being INTerrupted.
|
|
block_sigint()
|
|
|
|
if (@_rl_bind_stty_chars)
|
|
# If editing in vi mode, make sure we restore the bindings in the
|
|
# insertion keymap no matter what keymap we ended up in.
|
|
if (@rl_editing_mode == @vi_mode)
|
|
rl_tty_unset_default_bindings(@vi_insertion_keymap)
|
|
else
|
|
rl_tty_unset_default_bindings(@_rl_keymap)
|
|
end
|
|
end
|
|
|
|
save_tty_chars()
|
|
|
|
rl_setstate(RL_STATE_TTYCSAVED)
|
|
if (@_rl_bind_stty_chars)
|
|
|
|
# If editing in vi mode, make sure we set the bindings in the
|
|
# insertion keymap no matter what keymap we ended up in.
|
|
if (@rl_editing_mode == @vi_mode)
|
|
_rl_bind_tty_special_chars(@vi_insertion_keymap)
|
|
else
|
|
_rl_bind_tty_special_chars(@_rl_keymap)
|
|
end
|
|
end
|
|
|
|
prepare_terminal_settings(meta_flag)
|
|
|
|
if (@_rl_enable_keypad)
|
|
_rl_control_keypad(true)
|
|
end
|
|
@rl_outstream.flush
|
|
@terminal_prepped = true
|
|
rl_setstate(RL_STATE_TERMPREPPED)
|
|
|
|
release_sigint()
|
|
end
|
|
|
|
# Restore the terminal's normal settings and modes.
|
|
def rl_deprep_terminal()
|
|
return if ENV["TERM"].nil?
|
|
return if (!@terminal_prepped)
|
|
|
|
# Try to keep this function from being interrupted.
|
|
block_sigint()
|
|
|
|
if (@_rl_enable_keypad)
|
|
_rl_control_keypad(false)
|
|
end
|
|
|
|
@rl_outstream.flush
|
|
|
|
# restore terminal setting
|
|
`stty #{@otio} `
|
|
|
|
@terminal_prepped = false
|
|
rl_unsetstate(RL_STATE_TERMPREPPED)
|
|
|
|
release_sigint()
|
|
end
|
|
|
|
# Set the mark at POSITION.
|
|
def _rl_set_mark_at_pos(position)
|
|
return -1 if (position > @rl_end)
|
|
@rl_mark = position
|
|
0
|
|
end
|
|
|
|
# A bindable command to set the mark.
|
|
def rl_set_mark(count, key)
|
|
_rl_set_mark_at_pos(@rl_explicit_arg ? count : @rl_point)
|
|
end
|
|
|
|
# Kill from here to the end of the line. If DIRECTION is negative, kill
|
|
# back to the line start instead.
|
|
def rl_kill_line (direction, ignore)
|
|
if (direction < 0)
|
|
return (rl_backward_kill_line(1, ignore))
|
|
else
|
|
orig_point = @rl_point
|
|
rl_end_of_line(1, ignore)
|
|
if (orig_point != @rl_point)
|
|
rl_kill_text(orig_point, @rl_point)
|
|
end
|
|
@rl_point = orig_point
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
@rl_mark = @rl_point
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Kill backwards to the start of the line. If DIRECTION is negative, kill
|
|
# forwards to the line end instead.
|
|
def rl_backward_kill_line(direction, ignore)
|
|
if (direction < 0)
|
|
return (rl_kill_line(1, ignore))
|
|
else
|
|
if (@rl_point==0)
|
|
rl_ding()
|
|
else
|
|
orig_point = @rl_point
|
|
rl_beg_of_line(1, ignore)
|
|
if (@rl_point != orig_point)
|
|
rl_kill_text(orig_point, @rl_point)
|
|
end
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
@rl_mark = @rl_point
|
|
end
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Kill the whole line, no matter where point is.
|
|
def rl_kill_full_line(count, ignore)
|
|
rl_begin_undo_group()
|
|
@rl_point = 0
|
|
rl_kill_text(@rl_point, @rl_end)
|
|
@rl_mark = 0
|
|
rl_end_undo_group()
|
|
0
|
|
end
|
|
|
|
# Search backwards through the history looking for a string which is typed
|
|
# interactively. Start with the current line.
|
|
def rl_reverse_search_history(sign, key)
|
|
rl_search_history(-sign, key)
|
|
end
|
|
|
|
# Search forwards through the history looking for a string which is typed
|
|
# interactively. Start with the current line.
|
|
def rl_forward_search_history(sign, key)
|
|
rl_search_history(sign, key)
|
|
end
|
|
|
|
# Search through the history looking for an interactively typed string.
|
|
# This is analogous to i-search. We start the search in the current line.
|
|
# DIRECTION is which direction to search; >= 0 means forward, < 0 means
|
|
# backwards.
|
|
def rl_search_history(direction, invoking_key)
|
|
rl_setstate(RL_STATE_ISEARCH)
|
|
cxt = _rl_isearch_init(direction)
|
|
|
|
rl_display_search(cxt.search_string, (cxt.sflags & SF_REVERSE)!=0, -1)
|
|
|
|
# If we are using the callback interface, all we do is set up here and
|
|
# return. The key is that we leave RL_STATE_ISEARCH set.
|
|
if (rl_isstate(RL_STATE_CALLBACK))
|
|
return (0)
|
|
end
|
|
|
|
r = -1
|
|
while(true)
|
|
c = _rl_search_getchar(cxt)
|
|
# We might want to handle EOF here (c == 0)
|
|
r = _rl_isearch_dispatch(cxt, cxt.lastc)
|
|
break if (r <= 0)
|
|
end
|
|
|
|
# The searching is over. The user may have found the string that she
|
|
# was looking for, or else she may have exited a failing search. If
|
|
# LINE_INDEX is -1, then that shows that the string searched for was
|
|
# not found. We use this to determine where to place rl_point.
|
|
_rl_isearch_cleanup(cxt, r)
|
|
end
|
|
|
|
def _rl_scxt_alloc(type, flags)
|
|
cxt = Struct.new(:type,:sflags,:search_string,:search_string_index,:search_string_size,:lines,:allocated_line,
|
|
:hlen,:hindex,:save_point,:save_mark,:save_line,:last_found_line,:prev_line_found,:save_undo_list,:history_pos,
|
|
:direction,:lastc,:sline,:sline_len,:sline_index,:search_terminators, :mb).new
|
|
|
|
cxt.type = type
|
|
cxt.sflags = flags
|
|
|
|
cxt.search_string = nil
|
|
cxt.search_string_size = cxt.search_string_index = 0
|
|
|
|
cxt.lines = nil
|
|
cxt.allocated_line = nil
|
|
cxt.hlen = cxt.hindex = 0
|
|
|
|
cxt.save_point = @rl_point
|
|
cxt.save_mark = @rl_mark
|
|
cxt.save_line = where_history()
|
|
cxt.last_found_line = cxt.save_line
|
|
cxt.prev_line_found = nil
|
|
|
|
cxt.save_undo_list = nil
|
|
|
|
cxt.history_pos = 0
|
|
cxt.direction = 0
|
|
|
|
cxt.lastc = 0
|
|
|
|
cxt.sline = nil
|
|
cxt.sline_len = cxt.sline_index = 0
|
|
|
|
cxt.search_terminators = nil
|
|
|
|
cxt
|
|
end
|
|
|
|
def history_list()
|
|
@the_history
|
|
end
|
|
|
|
def _rl_isearch_init(direction)
|
|
cxt = _rl_scxt_alloc(RL_SEARCH_ISEARCH, 0)
|
|
if (direction < 0)
|
|
cxt.sflags |= SF_REVERSE
|
|
end
|
|
|
|
cxt.search_terminators = @_rl_isearch_terminators ? @_rl_isearch_terminators :
|
|
@default_isearch_terminators
|
|
|
|
# Create an arrary of pointers to the lines that we want to search.
|
|
hlist = history_list()
|
|
rl_maybe_replace_line()
|
|
i = 0
|
|
if (hlist)
|
|
i += 1 while(hlist[i])
|
|
end
|
|
|
|
# Allocate space for this many lines, +1 for the current input line,
|
|
# and remember those lines.
|
|
cxt.hlen = i
|
|
cxt.lines = Array.new(cxt.hlen+1)
|
|
for i in 0 ... cxt.hlen
|
|
cxt.lines[i] = hlist[i].line
|
|
end
|
|
|
|
if (@_rl_saved_line_for_history)
|
|
cxt.lines[i] = @_rl_saved_line_for_history.line.dup
|
|
else
|
|
# Keep track of this so we can free it.
|
|
cxt.allocated_line = @rl_line_buffer.dup
|
|
cxt.lines[i] = cxt.allocated_line
|
|
end
|
|
|
|
cxt.hlen+=1
|
|
|
|
# The line where we start the search.
|
|
cxt.history_pos = cxt.save_line
|
|
|
|
rl_save_prompt()
|
|
|
|
# Initialize search parameters.
|
|
cxt.search_string_size = 128
|
|
cxt.search_string_index = 0
|
|
cxt.search_string = 0.chr * cxt.search_string_size
|
|
|
|
# Normalize DIRECTION into 1 or -1.
|
|
cxt.direction = (direction >= 0) ? 1 : -1
|
|
|
|
cxt.sline = @rl_line_buffer
|
|
cxt.sline_len = cxt.sline.delete(0.chr).length
|
|
cxt.sline_index = @rl_point
|
|
|
|
@_rl_iscxt = cxt # save globally
|
|
cxt
|
|
end
|
|
|
|
def rl_save_prompt()
|
|
@saved_local_prompt = @local_prompt
|
|
@saved_local_prefix = @local_prompt_prefix
|
|
@saved_prefix_length = @prompt_prefix_length
|
|
@saved_local_length = @local_prompt_len
|
|
@saved_last_invisible = @prompt_last_invisible
|
|
@saved_visible_length = @prompt_visible_length
|
|
@saved_invis_chars_first_line = @prompt_invis_chars_first_line
|
|
@saved_physical_chars = @prompt_physical_chars
|
|
|
|
@local_prompt = @local_prompt_prefix = nil
|
|
@local_prompt_len = 0
|
|
@prompt_last_invisible = @prompt_visible_length = @prompt_prefix_length = 0
|
|
@prompt_invis_chars_first_line = @prompt_physical_chars = 0
|
|
end
|
|
|
|
def rl_restore_prompt()
|
|
@local_prompt = nil
|
|
@local_prompt_prefix = nil
|
|
|
|
@local_prompt = @saved_local_prompt
|
|
@local_prompt_prefix = @saved_local_prefix
|
|
@local_prompt_len = @saved_local_length
|
|
@prompt_prefix_length = @saved_prefix_length
|
|
@prompt_last_invisible = @saved_last_invisible
|
|
@prompt_visible_length = @saved_visible_length
|
|
@prompt_invis_chars_first_line = @saved_invis_chars_first_line
|
|
@prompt_physical_chars = @saved_physical_chars
|
|
|
|
# can test saved_local_prompt to see if prompt info has been saved.
|
|
@saved_local_prompt = @saved_local_prefix = nil
|
|
@saved_local_length = 0
|
|
@saved_last_invisible = @saved_visible_length = @saved_prefix_length = 0
|
|
@saved_invis_chars_first_line = @saved_physical_chars = 0
|
|
end
|
|
|
|
def rl_message(msg_buf)
|
|
@rl_display_prompt = msg_buf
|
|
if @saved_local_prompt.nil?
|
|
rl_save_prompt()
|
|
@msg_saved_prompt = true
|
|
end
|
|
@local_prompt,@prompt_visible_length,@prompt_last_invisible,@prompt_invis_chars_first_line,@prompt_physical_chars =
|
|
expand_prompt(msg_buf)
|
|
@local_prompt_prefix = nil
|
|
@local_prompt_len = @local_prompt ? @local_prompt.length : 0
|
|
send(@rl_redisplay_function)
|
|
0
|
|
end
|
|
|
|
# Display the current state of the search in the echo-area.
|
|
# SEARCH_STRING contains the string that is being searched for,
|
|
# DIRECTION is zero for forward, or non-zero for reverse,
|
|
# WHERE is the history list number of the current line. If it is
|
|
# -1, then this line is the starting one.
|
|
def rl_display_search(search_string, reverse_p, where)
|
|
message = '('
|
|
if (reverse_p)
|
|
message << "reverse-"
|
|
end
|
|
message << "i-search)`"
|
|
|
|
if (search_string)
|
|
message << search_string
|
|
end
|
|
message << "': "
|
|
|
|
rl_message(message)
|
|
message = nil
|
|
send(@rl_redisplay_function)
|
|
end
|
|
|
|
# Transpose the characters at point. If point is at the end of the line,
|
|
# then transpose the characters before point.
|
|
def rl_transpose_chars(count, key)
|
|
return 0 if (count == 0)
|
|
|
|
if (@rl_point==0 || @rl_end < 2)
|
|
rl_ding()
|
|
return -1
|
|
end
|
|
|
|
rl_begin_undo_group()
|
|
|
|
if (@rl_point == @rl_end)
|
|
if !@rl_byte_oriented
|
|
@rl_point = _rl_find_prev_mbchar(@rl_line_buffer, @rl_point, MB_FIND_NONZERO)
|
|
else
|
|
@rl_point -= 1
|
|
end
|
|
count = 1
|
|
end
|
|
|
|
prev_point = @rl_point
|
|
if !@rl_byte_oriented
|
|
@rl_point = _rl_find_prev_mbchar(@rl_line_buffer, @rl_point, MB_FIND_NONZERO)
|
|
else
|
|
@rl_point -= 1
|
|
end
|
|
|
|
char_length = prev_point - @rl_point
|
|
dummy = @rl_line_buffer[@rl_point,char_length]
|
|
|
|
rl_delete_text(@rl_point, @rl_point + char_length)
|
|
|
|
@rl_point += count
|
|
_rl_fix_point(0)
|
|
rl_insert_text(dummy)
|
|
rl_end_undo_group()
|
|
dummy = nil
|
|
0
|
|
end
|
|
|
|
# Here is C-u doing what Unix does. You don't *have* to use these
|
|
# key-bindings. We have a choice of killing the entire line, or
|
|
# killing from where we are to the start of the line. We choose the
|
|
# latter, because if you are a Unix weenie, then you haven't backspaced
|
|
# into the line at all, and if you aren't, then you know what you are
|
|
# doing.
|
|
def rl_unix_line_discard(count, key)
|
|
if (@rl_point == 0)
|
|
rl_ding()
|
|
else
|
|
rl_kill_text(@rl_point, 0)
|
|
@rl_point = 0
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
@rl_mark = @rl_point
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Yank back the last killed text. This ignores arguments.
|
|
def rl_yank(count, ignore)
|
|
if @rl_kill_ring.nil?
|
|
_rl_abort_internal()
|
|
return -1
|
|
end
|
|
_rl_set_mark_at_pos(@rl_point)
|
|
rl_insert_text(@rl_kill_ring[@rl_kill_index])
|
|
0
|
|
end
|
|
|
|
# If the last command was yank, or yank_pop, and the text just
|
|
# before point is identical to the current kill item, then
|
|
# delete that text from the line, rotate the index down, and
|
|
# yank back some other text.
|
|
def rl_yank_pop(count, key)
|
|
if (((@rl_last_func != :rl_yank_pop) && (@rl_last_func != :rl_yank)) ||
|
|
@rl_kill_ring.nil?)
|
|
_rl_abort_internal()
|
|
return -1
|
|
end
|
|
|
|
l = @rl_kill_ring[@rl_kill_index].length
|
|
n = @rl_point - l
|
|
if (n >= 0 && @rl_line_buffer[n,l] == @rl_kill_ring[@rl_kill_index][0,l])
|
|
rl_delete_text(n, @rl_point)
|
|
@rl_point = n
|
|
@rl_kill_index-=1
|
|
if (@rl_kill_index < 0)
|
|
@rl_kill_index = @rl_kill_ring_length - 1
|
|
end
|
|
rl_yank(1, 0)
|
|
return 0
|
|
else
|
|
_rl_abort_internal()
|
|
return -1
|
|
end
|
|
end
|
|
|
|
# Yank the COUNTh argument from the previous history line, skipping
|
|
# HISTORY_SKIP lines before looking for the `previous line'.
|
|
def rl_yank_nth_arg_internal(count, ignore, history_skip)
|
|
pos = where_history()
|
|
if (history_skip>0)
|
|
history_skip.times { entry = previous_history() }
|
|
end
|
|
entry = previous_history()
|
|
history_set_pos(pos)
|
|
if entry.nil?
|
|
rl_ding()
|
|
return -1
|
|
end
|
|
|
|
arg = history_arg_extract(count, count, entry.line)
|
|
if (arg.nil? || arg=='')
|
|
rl_ding()
|
|
arg = nil
|
|
return -1
|
|
end
|
|
|
|
rl_begin_undo_group()
|
|
|
|
_rl_set_mark_at_pos(@rl_point)
|
|
|
|
# Vi mode always inserts a space before yanking the argument, and it
|
|
# inserts it right *after* rl_point.
|
|
if (@rl_editing_mode == @vi_mode)
|
|
rl_vi_append_mode(1, ignore)
|
|
rl_insert_text(" ")
|
|
end
|
|
|
|
rl_insert_text(arg)
|
|
arg = nil
|
|
rl_end_undo_group()
|
|
return 0
|
|
end
|
|
|
|
# Yank the COUNTth argument from the previous history line.
|
|
def rl_yank_nth_arg(count, ignore)
|
|
rl_yank_nth_arg_internal(count, ignore, 0)
|
|
end
|
|
|
|
# Yank the last argument from the previous history line. This `knows'
|
|
# how rl_yank_nth_arg treats a count of `$'. With an argument, this
|
|
# behaves the same as rl_yank_nth_arg.
|
|
@history_skip = 0
|
|
@explicit_arg_p = false
|
|
@count_passed = 1
|
|
@direction = 1
|
|
@undo_needed = false
|
|
|
|
def rl_yank_last_arg(count, key)
|
|
if (@rl_last_func != :rl_yank_last_arg)
|
|
@history_skip = 0
|
|
@explicit_arg_p = @rl_explicit_arg
|
|
@count_passed = count
|
|
@direction = 1
|
|
else
|
|
if (@undo_needed)
|
|
rl_do_undo()
|
|
end
|
|
if (count < 1)
|
|
@direction = -@direction
|
|
end
|
|
@history_skip += @direction
|
|
if (@history_skip < 0)
|
|
@history_skip = 0
|
|
end
|
|
end
|
|
|
|
if (@explicit_arg_p)
|
|
retval = rl_yank_nth_arg_internal(@count_passed, key, @history_skip)
|
|
else
|
|
retval = rl_yank_nth_arg_internal('$', key, @history_skip)
|
|
end
|
|
@undo_needed = retval == 0
|
|
retval
|
|
end
|
|
|
|
def _rl_char_search_internal(count, dir, smbchar, len)
|
|
pos = @rl_point
|
|
inc = (dir < 0) ? -1 : 1
|
|
while (count!=0)
|
|
if ((dir < 0 && pos <= 0) || (dir > 0 && pos >= @rl_end))
|
|
rl_ding()
|
|
return -1
|
|
end
|
|
pos = (inc > 0) ? _rl_find_next_mbchar(@rl_line_buffer, pos, 1, MB_FIND_ANY) :
|
|
_rl_find_prev_mbchar(@rl_line_buffer, pos, MB_FIND_ANY)
|
|
begin
|
|
if (_rl_is_mbchar_matched(@rl_line_buffer, pos, @rl_end, smbchar, len)!=0)
|
|
count-=1
|
|
if (dir < 0)
|
|
@rl_point = (dir == BTO) ? pos+1 : pos
|
|
else
|
|
@rl_point = (dir == FTO) ? pos-1 : pos
|
|
end
|
|
break
|
|
end
|
|
prepos = pos
|
|
end while ((dir < 0) ? (pos = _rl_find_prev_mbchar(@rl_line_buffer, pos, MB_FIND_ANY)) != prepos :
|
|
(pos = _rl_find_next_mbchar(@rl_line_buffer, pos, 1, MB_FIND_ANY)) != prepos)
|
|
end
|
|
0
|
|
end
|
|
|
|
def _rl_char_search(count, fdir, bdir)
|
|
mbchar = ''
|
|
mb_len = _rl_read_mbchar(mbchar, MB_LEN_MAX)
|
|
|
|
if (count < 0)
|
|
return (_rl_char_search_internal(-count, bdir, mbchar, mb_len))
|
|
else
|
|
return (_rl_char_search_internal(count, fdir, mbchar, mb_len))
|
|
end
|
|
end
|
|
|
|
def rl_char_search(count, key)
|
|
_rl_char_search(count, FFIND, BFIND)
|
|
end
|
|
|
|
# Undo the next thing in the list. Return 0 if there
|
|
# is nothing to undo, or non-zero if there was.
|
|
def trans(i)
|
|
((i) == -1 ? @rl_point : ((i) == -2 ? @rl_end : (i)))
|
|
end
|
|
|
|
def rl_do_undo()
|
|
start = _end = waiting_for_begin = 0
|
|
begin
|
|
return 0 if @rl_undo_list.nil?
|
|
|
|
@_rl_doing_an_undo = true
|
|
rl_setstate(RL_STATE_UNDOING)
|
|
|
|
# To better support vi-mode, a start or end value of -1 means
|
|
# rl_point, and a value of -2 means rl_end.
|
|
if (@rl_undo_list.what == UNDO_DELETE || @rl_undo_list.what == UNDO_INSERT)
|
|
start = trans(@rl_undo_list.start)
|
|
_end = trans(@rl_undo_list.end)
|
|
end
|
|
|
|
case (@rl_undo_list.what)
|
|
# Undoing deletes means inserting some text.
|
|
when UNDO_DELETE
|
|
@rl_point = start
|
|
rl_insert_text(@rl_undo_list.text)
|
|
@rl_undo_list.text = nil
|
|
|
|
# Undoing inserts means deleting some text.
|
|
when UNDO_INSERT
|
|
rl_delete_text(start, _end)
|
|
@rl_point = start
|
|
# Undoing an END means undoing everything 'til we get to a BEGIN.
|
|
when UNDO_END
|
|
waiting_for_begin+=1
|
|
# Undoing a BEGIN means that we are done with this group.
|
|
when UNDO_BEGIN
|
|
if (waiting_for_begin!=0)
|
|
waiting_for_begin-=1
|
|
else
|
|
rl_ding()
|
|
end
|
|
end
|
|
|
|
@_rl_doing_an_undo = false
|
|
rl_unsetstate(RL_STATE_UNDOING)
|
|
|
|
release = @rl_undo_list
|
|
@rl_undo_list = @rl_undo_list.next
|
|
replace_history_data(-1, release, @rl_undo_list)
|
|
release = nil
|
|
end while (waiting_for_begin!=0)
|
|
|
|
1
|
|
end
|
|
|
|
|
|
|
|
# Do some undoing of things that were done.
|
|
def rl_undo_command(count, key)
|
|
if (count < 0)
|
|
return 0 # Nothing to do.
|
|
end
|
|
while (count>0)
|
|
if (rl_do_undo())
|
|
count-=1
|
|
else
|
|
rl_ding()
|
|
break
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Delete the word at point, saving the text in the kill ring.
|
|
def rl_kill_word(count, key)
|
|
if (count < 0)
|
|
return (rl_backward_kill_word(-count, key))
|
|
else
|
|
orig_point = @rl_point
|
|
rl_forward_word(count, key)
|
|
|
|
if (@rl_point != orig_point)
|
|
rl_kill_text(orig_point, @rl_point)
|
|
end
|
|
|
|
@rl_point = orig_point
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
rl_mark = @rl_point
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Rubout the word before point, placing it on the kill ring.
|
|
def rl_backward_kill_word(count, ignore)
|
|
if (count < 0)
|
|
return (rl_kill_word(-count, ignore))
|
|
else
|
|
orig_point = @rl_point
|
|
rl_backward_word(count, ignore)
|
|
if (@rl_point != orig_point)
|
|
rl_kill_text(orig_point, @rl_point)
|
|
end
|
|
if (@rl_editing_mode == @emacs_mode)
|
|
@rl_mark = @rl_point
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
# Revert the current line to its previous state.
|
|
def rl_revert_line(count, key)
|
|
if @rl_undo_list.nil?
|
|
rl_ding()
|
|
else
|
|
while (@rl_undo_list)
|
|
rl_do_undo()
|
|
end
|
|
if (@rl_editing_mode == @vi_mode)
|
|
@rl_point = @rl_mark = 0 # rl_end should be set correctly
|
|
end
|
|
end
|
|
0
|
|
end
|
|
|
|
def rl_backward_char_search (count, key)
|
|
_rl_char_search(count, BFIND, FFIND)
|
|
end
|
|
|
|
def rl_insert_completions(ignore, invoking_key)
|
|
rl_complete_internal('*')
|
|
end
|
|
|
|
def _rl_arg_init()
|
|
rl_save_prompt()
|
|
@_rl_argcxt = 0
|
|
rl_setstate(RL_STATE_NUMERICARG)
|
|
end
|
|
|
|
def _rl_arg_getchar()
|
|
rl_message("(arg: #{@rl_arg_sign * @rl_numeric_arg}) ")
|
|
rl_setstate(RL_STATE_MOREINPUT)
|
|
c = rl_read_key()
|
|
rl_unsetstate(RL_STATE_MOREINPUT)
|
|
c
|
|
end
|
|
|
|
# Process C as part of the current numeric argument. Return -1 if the
|
|
# argument should be aborted, 0 if we should not read any more chars, and
|
|
# 1 if we should continue to read chars.
|
|
def _rl_arg_dispatch(cxt, c)
|
|
key = c
|
|
|
|
# If we see a key bound to `universal-argument' after seeing digits,
|
|
# it ends the argument but is otherwise ignored.
|
|
if (@_rl_keymap[c] == :rl_universal_argument)
|
|
if ((cxt & NUM_SAWDIGITS) == 0)
|
|
@rl_numeric_arg *= 4
|
|
return 1
|
|
elsif (rl_isstate(RL_STATE_CALLBACK))
|
|
@_rl_argcxt |= NUM_READONE
|
|
return 0 # XXX
|
|
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))
|
|
end
|
|
end
|
|
|
|
#c = (c[0].ord & ~0x80).chr
|
|
r = c[1,1]
|
|
if (r>='0' && r<='9')
|
|
r = r.to_i
|
|
@rl_numeric_arg = @rl_explicit_arg ? (@rl_numeric_arg * 10) + r : r
|
|
@rl_explicit_arg = 1
|
|
@_rl_argcxt |= NUM_SAWDIGITS
|
|
elsif (c == '-' && !@rl_explicit_arg)
|
|
@rl_numeric_arg = 1
|
|
@_rl_argcxt |= NUM_SAWMINUS
|
|
@rl_arg_sign = -1
|
|
else
|
|
# Make M-- command equivalent to M--1 command.
|
|
if ((@_rl_argcxt & NUM_SAWMINUS)!=0 && @rl_numeric_arg == 1 && !@rl_explicit_arg)
|
|
@rl_explicit_arg = 1
|
|
end
|
|
rl_restore_prompt()
|
|
rl_clear_message()
|
|
rl_unsetstate(RL_STATE_NUMERICARG)
|
|
|
|
r = _rl_dispatch(key, @_rl_keymap)
|
|
if (rl_isstate(RL_STATE_CALLBACK))
|
|
# At worst, this will cause an extra redisplay. Otherwise,
|
|
# we have to wait until the next character comes in.
|
|
if (!@rl_done)
|
|
send(@rl_redisplay_function)
|
|
end
|
|
r = 0
|
|
end
|
|
return r
|
|
end
|
|
1
|
|
end
|
|
|
|
def _rl_arg_overflow()
|
|
if (@rl_numeric_arg > 1000000)
|
|
@_rl_argcxt = 0
|
|
@rl_explicit_arg = @rl_numeric_arg = 0
|
|
rl_ding()
|
|
rl_restore_prompt()
|
|
rl_clear_message()
|
|
rl_unsetstate(RL_STATE_NUMERICARG)
|
|
return 1
|
|
end
|
|
0
|
|
end
|
|
|
|
# Handle C-u style numeric args, as well as M--, and M-digits.
|
|
def rl_digit_loop()
|
|
while (true)
|
|
return 1 if _rl_arg_overflow()!=0
|
|
c = _rl_arg_getchar()
|
|
if (c >= "\xFE")
|
|
_rl_abort_internal()
|
|
return -1
|
|
end
|
|
r = _rl_arg_dispatch(@_rl_argcxt, c)
|
|
break if (r <= 0 || !rl_isstate(RL_STATE_NUMERICARG))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
# Start a numeric argument with initial value KEY
|
|
def rl_digit_argument(ignore, key)
|
|
_rl_arg_init()
|
|
if (rl_isstate(RL_STATE_CALLBACK))
|
|
_rl_arg_dispatch(@_rl_argcxt, key)
|
|
rl_message("(arg: #{@rl_arg_sign * @rl_numeric_arg}) ")
|
|
return 0
|
|
else
|
|
rl_execute_next(key)
|
|
return (rl_digit_loop())
|
|
end
|
|
end
|
|
|
|
# Make C be the next command to be executed.
|
|
def rl_execute_next(c)
|
|
@rl_pending_input = c
|
|
rl_setstate(RL_STATE_INPUTPENDING)
|
|
0
|
|
end
|
|
|
|
# Meta-< goes to the start of the history.
|
|
def rl_beginning_of_history(count, key)
|
|
rl_get_previous_history(1 + where_history(), key)
|
|
end
|
|
|
|
# Meta-> goes to the end of the history. (The current line).
|
|
def rl_end_of_history(count, key)
|
|
rl_maybe_replace_line()
|
|
using_history()
|
|
rl_maybe_unsave_line()
|
|
0
|
|
end
|
|
|
|
# Uppercase the word at point.
|
|
def rl_upcase_word(count, key)
|
|
rl_change_case(count, UpCase)
|
|
end
|
|
|
|
# Lowercase the word at point.
|
|
def rl_downcase_word(count, key)
|
|
rl_change_case(count, DownCase)
|
|
end
|
|
|
|
# Upcase the first letter, downcase the rest.
|
|
def rl_capitalize_word(count, key)
|
|
rl_change_case(count, CapCase)
|
|
end
|
|
|
|
# Save an undo entry for the text from START to END.
|
|
def rl_modifying(start, _end)
|
|
if (start > _end)
|
|
start,_end = _end,start
|
|
end
|
|
|
|
if (start != _end)
|
|
temp = rl_copy_text(start, _end)
|
|
rl_begin_undo_group()
|
|
rl_add_undo(UNDO_DELETE, start, _end, temp)
|
|
rl_add_undo(UNDO_INSERT, start, _end, nil)
|
|
rl_end_undo_group()
|
|
end
|
|
0
|
|
end
|
|
|
|
# The meaty function.
|
|
# Change the case of COUNT words, performing OP on them.
|
|
# OP is one of UpCase, DownCase, or CapCase.
|
|
# If a negative argument is given, leave point where it started,
|
|
# otherwise, leave it where it moves to.
|
|
def rl_change_case(count, op)
|
|
start = @rl_point
|
|
rl_forward_word(count, 0)
|
|
_end = @rl_point
|
|
|
|
if (op != UpCase && op != DownCase && op != CapCase)
|
|
rl_ding()
|
|
return -1
|
|
end
|
|
|
|
if (count < 0)
|
|
start,_end = _end,start
|
|
end
|
|
|
|
# We are going to modify some text, so let's prepare to undo it.
|
|
rl_modifying(start, _end)
|
|
|
|
inword = false
|
|
while (start < _end)
|
|
c = _rl_char_value(@rl_line_buffer, start)
|
|
# This assumes that the upper and lower case versions are the same width.
|
|
if !@rl_byte_oriented
|
|
_next = _rl_find_next_mbchar(@rl_line_buffer, start, 1, MB_FIND_NONZERO)
|
|
else
|
|
_next = start + 1
|
|
end
|
|
|
|
if (!_rl_walphabetic(c))
|
|
inword = false
|
|
start = _next
|
|
next
|
|
end
|
|
|
|
if (op == CapCase)
|
|
nop = inword ? DownCase : UpCase
|
|
inword = true
|
|
else
|
|
nop = op
|
|
end
|
|
if (isascii(c))
|
|
nc = (nop == UpCase) ? c.upcase : c.downcase
|
|
@rl_line_buffer[start] = nc
|
|
end
|
|
|
|
start = _next
|
|
end
|
|
|
|
@rl_point = _end
|
|
0
|
|
end
|
|
|
|
def isascii(c)
|
|
int_val = c[0].to_i # 1.8 + 1.9 compat.
|
|
return (int_val < 128 && int_val > 0)
|
|
end
|
|
|
|
# Search non-interactively through the history list. DIR < 0 means to
|
|
# search backwards through the history of previous commands; otherwise
|
|
# the search is for commands subsequent to the current position in the
|
|
# history list. PCHAR is the character to use for prompting when reading
|
|
# the search string; if not specified (0), it defaults to `:'.
|
|
def noninc_search(dir, pchar)
|
|
cxt = _rl_nsearch_init(dir, pchar)
|
|
if (rl_isstate(RL_STATE_CALLBACK))
|
|
return (0)
|
|
end
|
|
# Read the search string.
|
|
r = 0
|
|
while (true)
|
|
c = _rl_search_getchar(cxt)
|
|
if (c == 0.chr)
|
|
break
|
|
end
|
|
r = _rl_nsearch_dispatch(cxt, c)
|
|
if (r < 0)
|
|
return 1
|
|
elsif (r == 0)
|
|
break
|
|
end
|
|
end
|
|
|
|
r = _rl_nsearch_dosearch(cxt)
|
|
(r >= 0) ? _rl_nsearch_cleanup(cxt, r) : (r != 1)
|
|
end
|
|
|
|
# Search forward through the history list for a string. If the vi-mode
|
|
# code calls this, KEY will be `?'.
|
|
def rl_noninc_forward_search(count, key)
|
|
noninc_search(1, (key == '?') ? '?' : nil)
|
|
end
|
|
|
|
# Reverse search the history list for a string. If the vi-mode code
|
|
# calls this, KEY will be `/'.
|
|
def rl_noninc_reverse_search(count, key)
|
|
noninc_search(-1, (key == '/') ? '/' : nil)
|
|
end
|
|
|
|
# Make the data from the history entry ENTRY be the contents of the
|
|
# current line. This doesn't do anything with rl_point; the caller
|
|
# must set it.
|
|
def make_history_line_current(entry)
|
|
_rl_replace_text(entry.line, 0, @rl_end)
|
|
_rl_fix_point(1)
|
|
if (@rl_editing_mode == @vi_mode)
|
|
# POSIX.2 says that the `U' command doesn't affect the copy of any
|
|
# command lines to the edit line. We're going to implement that by
|
|
# making the undo list start after the matching line is copied to the
|
|
# current editing buffer.
|
|
rl_free_undo_list()
|
|
end
|
|
if (@_rl_saved_line_for_history)
|
|
@_rl_saved_line_for_history = nil
|
|
end
|
|
end
|
|
|
|
# Make the current history item be the one at POS, an absolute index.
|
|
# Returns zero if POS is out of range, else non-zero.
|
|
def history_set_pos(pos)
|
|
if (pos > @history_length || pos < 0 || @the_history.nil?)
|
|
return (0)
|
|
end
|
|
@history_offset = pos
|
|
1
|
|
end
|
|
|
|
# Do an anchored search for string through the history in DIRECTION.
|
|
def history_search_prefix (string, direction)
|
|
history_search_internal(string, direction, ANCHORED_SEARCH)
|
|
end
|
|
|
|
# Search for STRING in the history list. DIR is < 0 for searching
|
|
# backwards. POS is an absolute index into the history list at
|
|
# which point to begin searching.
|
|
def history_search_pos(string, dir, pos)
|
|
old = where_history()
|
|
history_set_pos(pos)
|
|
if (history_search(string, dir) == -1)
|
|
history_set_pos(old)
|
|
return (-1)
|
|
end
|
|
ret = where_history()
|
|
history_set_pos(old)
|
|
ret
|
|
end
|
|
|
|
# Search the history list for STRING starting at absolute history position
|
|
# POS. If STRING begins with `^', the search must match STRING at the
|
|
# beginning of a history line, otherwise a full substring match is performed
|
|
# for STRING. DIR < 0 means to search backwards through the history list,
|
|
# DIR >= 0 means to search forward.
|
|
def noninc_search_from_pos(string, pos, dir)
|
|
return 1 if (pos < 0)
|
|
|
|
old = where_history()
|
|
return -1 if (history_set_pos(pos) == 0)
|
|
|
|
rl_setstate(RL_STATE_SEARCH)
|
|
if (string[0,1] == '^')
|
|
ret = history_search_prefix(string + 1, dir)
|
|
else
|
|
ret = history_search(string, dir)
|
|
end
|
|
rl_unsetstate(RL_STATE_SEARCH)
|
|
|
|
if (ret != -1)
|
|
ret = where_history()
|
|
end
|
|
history_set_pos(old)
|
|
ret
|
|
end
|
|
|
|
# Search for a line in the history containing STRING. If DIR is < 0, the
|
|
# search is backwards through previous entries, else through subsequent
|
|
# entries. Returns 1 if the search was successful, 0 otherwise.
|
|
def noninc_dosearch(string, dir)
|
|
if (string.nil? || string == '' || @noninc_history_pos < 0)
|
|
rl_ding()
|
|
return 0
|
|
end
|
|
|
|
pos = noninc_search_from_pos(string, @noninc_history_pos + dir, dir)
|
|
if (pos == -1)
|
|
# Search failed, current history position unchanged.
|
|
rl_maybe_unsave_line()
|
|
rl_clear_message()
|
|
@rl_point = 0
|
|
rl_ding()
|
|
return 0
|
|
end
|
|
|
|
@noninc_history_pos = pos
|
|
|
|
oldpos = where_history()
|
|
history_set_pos(@noninc_history_pos)
|
|
entry = current_history()
|
|
if (@rl_editing_mode != @vi_mode)
|
|
history_set_pos(oldpos)
|
|
end
|
|
make_history_line_current(entry)
|
|
@rl_point = 0
|
|
@rl_mark = @rl_end
|
|
rl_clear_message()
|
|
1
|
|
end
|
|
|
|
def _rl_make_prompt_for_search(pchar)
|
|
rl_save_prompt()
|
|
|
|
# We've saved the prompt, and can do anything with the various prompt
|
|
# strings we need before they're restored. We want the unexpanded
|
|
# portion of the prompt string after any final newline.
|
|
_p = @rl_prompt ? @rl_prompt.rindex("\n") : nil
|
|
if _p.nil?
|
|
len = (@rl_prompt && @rl_prompt.length>0 ) ? @rl_prompt.length : 0
|
|
if (len>0)
|
|
pmt = @rl_prompt.dup
|
|
else
|
|
pmt = ''
|
|
end
|
|
pmt << pchar
|
|
else
|
|
_p+=1
|
|
pmt = @rl_prompt[_p..-1]
|
|
pmt << pchar
|
|
end
|
|
|
|
# will be overwritten by expand_prompt, called from rl_message
|
|
@prompt_physical_chars = @saved_physical_chars + 1
|
|
pmt
|
|
end
|
|
|
|
def _rl_nsearch_init(dir, pchar)
|
|
cxt = _rl_scxt_alloc(RL_SEARCH_NSEARCH, 0)
|
|
if (dir < 0)
|
|
cxt.sflags |= SF_REVERSE # not strictly needed
|
|
end
|
|
cxt.direction = dir
|
|
cxt.history_pos = cxt.save_line
|
|
rl_maybe_save_line()
|
|
# Clear the undo list, since reading the search string should create its
|
|
# own undo list, and the whole list will end up being freed when we
|
|
# finish reading the search string.
|
|
@rl_undo_list = nil
|
|
|
|
# Use the line buffer to read the search string.
|
|
@rl_line_buffer[0] = 0.chr
|
|
@rl_end = @rl_point = 0
|
|
|
|
_p = _rl_make_prompt_for_search(pchar ? pchar : ':')
|
|
rl_message(_p)
|
|
_p = nil
|
|
|
|
rl_setstate(RL_STATE_NSEARCH)
|
|
@_rl_nscxt = cxt
|
|
cxt
|
|
end
|
|
|
|
def _rl_nsearch_cleanup(cxt, r)
|
|
cxt = nil
|
|
@_rl_nscxt = nil
|
|
rl_unsetstate(RL_STATE_NSEARCH)
|
|
r != 1
|
|
end
|
|
|
|
def _rl_nsearch_abort(cxt)
|
|
rl_maybe_unsave_line()
|
|
rl_clear_message()
|
|
@rl_point = cxt.save_point
|
|
@rl_mark = cxt.save_mark
|
|
rl_restore_prompt()
|
|
rl_unsetstate(RL_STATE_NSEARCH)
|
|
end
|
|
|
|
# Process just-read character C according to search context CXT. Return -1
|
|
# if the caller should abort the search, 0 if we should break out of the
|
|
# loop, and 1 if we should continue to read characters.
|
|
def _rl_nsearch_dispatch(cxt, c)
|
|
case (c)
|
|
when "\C-W"
|
|
rl_unix_word_rubout(1, c)
|
|
when "\C-W"
|
|
rl_unix_line_discard(1, c)
|
|
when RETURN,NEWLINE
|
|
return 0
|
|
when "\C-H",RUBOUT
|
|
if (@rl_point == 0)
|
|
_rl_nsearch_abort(cxt)
|
|
return -1
|
|
end
|
|
_rl_rubout_char(1, c)
|
|
when "\C-C","\C-G"
|
|
rl_ding()
|
|
_rl_nsearch_abort(cxt)
|
|
return -1
|
|
else
|
|
if !@rl_byte_oriented
|
|
rl_insert_text(cxt.mb)
|
|
else
|
|
_rl_insert_char(1, c)
|
|
end
|
|
end
|
|
|
|
send(@rl_redisplay_function)
|
|
1
|
|
end
|
|
|
|
# Perform one search according to CXT, using NONINC_SEARCH_STRING. Return
|
|
# -1 if the search should be aborted, any other value means to clean up
|
|
# using _rl_nsearch_cleanup (). Returns 1 if the search was successful,
|
|
# 0 otherwise.
|
|
def _rl_nsearch_dosearch(cxt)
|
|
@rl_mark = cxt.save_mark
|
|
|
|
# If rl_point == 0, we want to re-use the previous search string and
|
|
# start from the saved history position. If there's no previous search
|
|
# string, punt.
|
|
if (@rl_point == 0)
|
|
if @noninc_search_string.nil?
|
|
rl_ding()
|
|
rl_restore_prompt()
|
|
rl_unsetstate(RL_STATE_NSEARCH)
|
|
return -1
|
|
end
|
|
else
|
|
# We want to start the search from the current history position.
|
|
@noninc_history_pos = cxt.save_line
|
|
@noninc_search_string = @rl_line_buffer.dup
|
|
|
|
# If we don't want the subsequent undo list generated by the search
|
|
#matching a history line to include the contents of the search string,
|
|
#we need to clear rl_line_buffer here. For now, we just clear the
|
|
#undo list generated by reading the search string. (If the search
|
|
#fails, the old undo list will be restored by rl_maybe_unsave_line.)
|
|
rl_free_undo_list()
|
|
end
|
|
|
|
rl_restore_prompt()
|
|
noninc_dosearch(@noninc_search_string, cxt.direction)
|
|
end
|
|
|
|
# Transpose the words at point. If point is at the end of the line,
|
|
# transpose the two words before point.
|
|
def rl_transpose_words(count, key)
|
|
orig_point = @rl_point
|
|
|
|
return if (count==0)
|
|
|
|
# Find the two words.
|
|
rl_forward_word(count, key)
|
|
w2_end = @rl_point
|
|
rl_backward_word(1, key)
|
|
w2_beg = @rl_point
|
|
rl_backward_word(count, key)
|
|
w1_beg = @rl_point
|
|
rl_forward_word(1, key)
|
|
w1_end = @rl_point
|
|
|
|
# Do some check to make sure that there really are two words.
|
|
if ((w1_beg == w2_beg) || (w2_beg < w1_end))
|
|
rl_ding()
|
|
@rl_point = orig_point
|
|
return -1
|
|
end
|
|
|
|
# Get the text of the words.
|
|
word1 = rl_copy_text(w1_beg, w1_end)
|
|
word2 = rl_copy_text(w2_beg, w2_end)
|
|
|
|
# We are about to do many insertions and deletions. Remember them
|
|
# as one operation.
|
|
rl_begin_undo_group()
|
|
|
|
# Do the stuff at word2 first, so that we don't have to worry
|
|
# about word1 moving.
|
|
@rl_point = w2_beg
|
|
rl_delete_text(w2_beg, w2_end)
|
|
rl_insert_text(word1)
|
|
|
|
@rl_point = w1_beg
|
|
rl_delete_text(w1_beg, w1_end)
|
|
rl_insert_text(word2)
|
|
|
|
# This is exactly correct since the text before this point has not
|
|
# changed in length.
|
|
@rl_point = w2_end
|
|
|
|
# I think that does it.
|
|
rl_end_undo_group()
|
|
word1 = nil
|
|
word2 = nil
|
|
|
|
0
|
|
end
|
|
|
|
# Re-read the current keybindings file.
|
|
def rl_re_read_init_file(count, ignore)
|
|
r = rl_read_init_file(nil)
|
|
rl_set_keymap_from_edit_mode()
|
|
r
|
|
end
|
|
|
|
# Exchange the position of mark and point.
|
|
def rl_exchange_point_and_mark(count, key)
|
|
if (@rl_mark > @rl_end)
|
|
@rl_mark = -1
|
|
end
|
|
if (@rl_mark == -1)
|
|
rl_ding()
|
|
return -1
|
|
else
|
|
@rl_point, @rl_mark = @rl_mark, @rl_point
|
|
end
|
|
0
|
|
end
|
|
|
|
# A convenience function for displaying a list of strings in
|
|
# columnar format on readline's output stream. MATCHES is the list
|
|
# of strings, in argv format, LEN is the number of strings in MATCHES,
|
|
# and MAX is the length of the longest string in MATCHES.
|
|
def rl_display_match_list(matches, len, max)
|
|
# How many items of MAX length can we fit in the screen window?
|
|
max += 2
|
|
limit = @_rl_screenwidth / max
|
|
if (limit != 1 && (limit * max == @_rl_screenwidth))
|
|
limit-=1
|
|
end
|
|
# Avoid a possible floating exception. If max > _rl_screenwidth,
|
|
# limit will be 0 and a divide-by-zero fault will result.
|
|
if (limit == 0)
|
|
limit = 1
|
|
end
|
|
# How many iterations of the printing loop?
|
|
count = (len + (limit - 1)) / limit
|
|
|
|
# Watch out for special case. If LEN is less than LIMIT, then
|
|
# just do the inner printing loop.
|
|
# 0 < len <= limit implies count = 1.
|
|
|
|
# Sort the items if they are not already sorted.
|
|
if (!@rl_ignore_completion_duplicates)
|
|
matches[1,len] = matches[1,len].sort
|
|
end
|
|
rl_crlf()
|
|
|
|
lines = 0
|
|
if (!@_rl_print_completions_horizontally)
|
|
# Print the sorted items, up-and-down alphabetically, like ls.
|
|
for i in 1 .. count
|
|
l = i
|
|
for j in 0 ... limit
|
|
if (l > len || matches[l].nil?)
|
|
break
|
|
else
|
|
temp = printable_part(matches[l])
|
|
printed_len = print_filename(temp, matches[l])
|
|
|
|
if (j + 1 < limit)
|
|
@rl_outstream.write(' '*(max - printed_len))
|
|
end
|
|
end
|
|
l += count
|
|
end
|
|
rl_crlf()
|
|
lines+=1
|
|
if (@_rl_page_completions && lines >= (@_rl_screenheight - 1) && i < count)
|
|
lines = _rl_internal_pager(lines)
|
|
return if (lines < 0)
|
|
end
|
|
end
|
|
else
|
|
# Print the sorted items, across alphabetically, like ls -x.
|
|
i = 1
|
|
while(matches[i])
|
|
temp = printable_part(matches[i])
|
|
printed_len = print_filename(temp, matches[i])
|
|
# Have we reached the end of this line?
|
|
if (matches[i+1])
|
|
if ((limit > 1) && (i % limit) == 0)
|
|
rl_crlf()
|
|
lines+=1
|
|
if (@_rl_page_completions && lines >= @_rl_screenheight - 1)
|
|
lines = _rl_internal_pager(lines)
|
|
return if (lines < 0)
|
|
end
|
|
else
|
|
@rl_outstream.write(' '*(max - printed_len))
|
|
end
|
|
end
|
|
i += 1
|
|
end
|
|
rl_crlf()
|
|
end
|
|
end
|
|
|
|
# Append any necessary closing quote and a separator character to the
|
|
# just-inserted match. If the user has specified that directories
|
|
# should be marked by a trailing `/', append one of those instead. The
|
|
# default trailing character is a space. Returns the number of characters
|
|
# appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
|
|
# has them) and don't add a suffix for a symlink to a directory. A
|
|
# nontrivial match is one that actually adds to the word being completed.
|
|
# The variable rl_completion_mark_symlink_dirs controls this behavior
|
|
# (it's initially set to the what the user has chosen, indicated by the
|
|
# value of _rl_complete_mark_symlink_dirs, but may be modified by an
|
|
# application's completion function).
|
|
def append_to_match(text, delimiter, quote_char, nontrivial_match)
|
|
temp_string = 0.chr * 4
|
|
temp_string_index = 0
|
|
if (quote_char && @rl_point>0 && !@rl_completion_suppress_quote &&
|
|
@rl_line_buffer[@rl_point - 1,1] != quote_char)
|
|
temp_string[temp_string_index] = quote_char
|
|
temp_string_index += 1
|
|
end
|
|
if (delimiter != 0.chr)
|
|
temp_string[temp_string_index] = delimiter
|
|
temp_string_index += 1
|
|
elsif (!@rl_completion_suppress_append && @rl_completion_append_character)
|
|
temp_string[temp_string_index] = @rl_completion_append_character
|
|
temp_string_index += 1
|
|
end
|
|
temp_string[temp_string_index] = 0.chr
|
|
temp_string_index += 1
|
|
|
|
if (@rl_filename_completion_desired)
|
|
filename = File.expand_path(text)
|
|
s = (nontrivial_match && !@rl_completion_mark_symlink_dirs) ?
|
|
File.lstat(filename) : File.stat(filename)
|
|
if s.directory?
|
|
if @_rl_complete_mark_directories
|
|
# This is clumsy. Avoid putting in a double slash if point
|
|
# is at the end of the line and the previous character is a
|
|
# slash.
|
|
if (@rl_point>0 && @rl_line_buffer[@rl_point] == ?\0 && @rl_line_buffer[@rl_point - 1] == ?/ )
|
|
|
|
elsif (@rl_line_buffer[@rl_point] != ?/ )
|
|
rl_insert_text("/")
|
|
end
|
|
end
|
|
# Don't add anything if the filename is a symlink and resolves to a
|
|
# directory.
|
|
elsif s.symlink? && File.stat(filename).directory?
|
|
|
|
else
|
|
if (@rl_point == @rl_end && temp_string_index>0)
|
|
rl_insert_text(temp_string)
|
|
end
|
|
end
|
|
filename = nil
|
|
else
|
|
if (@rl_point == @rl_end && temp_string_index>0)
|
|
rl_insert_text(temp_string)
|
|
end
|
|
end
|
|
temp_string_index
|
|
end
|
|
|
|
# Stifle the history list, remembering only MAX number of lines.
|
|
def stifle_history(max)
|
|
max = 0 if (max < 0)
|
|
|
|
if (@history_length > max)
|
|
@the_history.slice!(0,(@history_length - max))
|
|
@history_length = max
|
|
end
|
|
|
|
@history_stifled = true
|
|
@max_input_history = @history_max_entries = max
|
|
end
|
|
|
|
# Stop stifling the history. This returns the previous maximum
|
|
# number of history entries. The value is positive if the history
|
|
# was stifled, negative if it wasn't.
|
|
def unstifle_history()
|
|
if (@history_stifled)
|
|
@history_stifled = false
|
|
return (@history_max_entries)
|
|
else
|
|
return (-@history_max_entries)
|
|
end
|
|
end
|
|
|
|
def history_is_stifled()
|
|
return (@history_stifled)
|
|
end
|
|
|
|
def clear_history()
|
|
@the_history = nil
|
|
@history_offset = @history_length = 0
|
|
end
|
|
|
|
# Insert COUNT characters from STRING to the output stream at column COL.
|
|
def insert_some_chars(string, count, col)
|
|
if @hConsoleHandle
|
|
_rl_output_some_chars(string,0,count)
|
|
else
|
|
# DEBUGGING
|
|
if (@rl_byte_oriented)
|
|
if (count != col)
|
|
$stderr.write("readline: debug: insert_some_chars: count (#{count}) != col (#{col})\n");
|
|
end
|
|
end
|
|
# If IC is defined, then we do not have to "enter" insert mode.
|
|
#if (@_rl_term_IC)
|
|
# buffer = tgoto(@_rl_term_IC, 0, col)
|
|
# @_rl_out_stream.write(buffer)
|
|
# _rl_output_some_chars(string,0,count)
|
|
#else
|
|
# If we have to turn on insert-mode, then do so.
|
|
if (@_rl_term_im)
|
|
@_rl_out_stream.write(@_rl_term_im)
|
|
end
|
|
# If there is a special command for inserting characters, then
|
|
# use that first to open up the space.
|
|
if (@_rl_term_ic)
|
|
@_rl_out_stream.write(@_rl_term_ic * count)
|
|
end
|
|
|
|
# Print the text.
|
|
_rl_output_some_chars(string,0, count)
|
|
|
|
# If there is a string to turn off insert mode, we had best use
|
|
# it now.
|
|
if (@_rl_term_ei)
|
|
@_rl_out_stream.write(@_rl_term_ei)
|
|
end
|
|
#end
|
|
end
|
|
end
|
|
|
|
# Delete COUNT characters from the display line.
|
|
def delete_chars(count)
|
|
return if (count > @_rl_screenwidth) # XXX
|
|
|
|
if @hConsoleHandle.nil?
|
|
#if (@_rl_term_DC)
|
|
# buffer = tgoto(_rl_term_DC, count, count);
|
|
# @_rl_out_stream.write(buffer * count)
|
|
#else
|
|
if (@_rl_term_dc)
|
|
@_rl_out_stream.write(@_rl_term_dc * count)
|
|
end
|
|
#end
|
|
end
|
|
end
|
|
|
|
# adjust pointed byte and find mbstate of the point of string.
|
|
# adjusted point will be point <= adjusted_point, and returns
|
|
# differences of the byte(adjusted_point - point).
|
|
# if point is invalied (point < 0 || more than string length),
|
|
# it returns -1
|
|
def _rl_adjust_point(string, point)
|
|
|
|
length = string.length
|
|
return -1 if (point < 0)
|
|
return -1 if (length < point)
|
|
|
|
pos = 0
|
|
|
|
case @encoding
|
|
when 'E'
|
|
pos = string.scan(/./me).inject(0){|r,x| r<point ? r += x.length : r }
|
|
when 'S'
|
|
pos = string.scan(/./ms).inject(0){|r,x| r<point ? r += x.length : r }
|
|
when 'U'
|
|
pos = string.scan(/./mu).inject(0){|r,x| r<point ? r += x.length : r }
|
|
when 'X'
|
|
pos = string.dup.force_encoding(@encoding_name).chars.inject(0){|r,x| r<point ? r += x.bytesize : r }
|
|
else
|
|
pos = point
|
|
end
|
|
pos - point
|
|
end
|
|
|
|
# Find next `count' characters started byte point of the specified seed.
|
|
# If flags is MB_FIND_NONZERO, we look for non-zero-width multibyte
|
|
# characters.
|
|
def _rl_find_next_mbchar(string, seed, count, flags)
|
|
if @encoding == 'N'
|
|
return (seed + count)
|
|
end
|
|
seed = 0 if seed < 0
|
|
return seed if count <= 0
|
|
|
|
point = seed + _rl_adjust_point(string,seed)
|
|
if (seed < point)
|
|
count -= 1
|
|
end
|
|
|
|
case @encoding
|
|
when 'E'
|
|
point += string[point..-1].scan(/./me)[0,count].to_s.length
|
|
when 'S'
|
|
point += string[point..-1].scan(/./ms)[0,count].to_s.length
|
|
when 'U'
|
|
point += string[point..-1].scan(/./mu)[0,count].to_s.length
|
|
when 'X'
|
|
point += string[point..-1].force_encoding(@encoding_name)[0,count].bytesize
|
|
else
|
|
point += count
|
|
end
|
|
if flags == MB_FIND_NONZERO
|
|
point = string.length if point>=string.length
|
|
end
|
|
point
|
|
end
|
|
|
|
# Find previous character started byte point of the specified seed.
|
|
# Returned point will be point <= seed. If flags is MB_FIND_NONZERO,
|
|
# we look for non-zero-width multibyte characters.
|
|
def _rl_find_prev_mbchar(string, seed, flags)
|
|
if @encoding == 'N'
|
|
return ((seed == 0) ? seed : seed - 1)
|
|
end
|
|
|
|
length = string.length
|
|
if seed < 0
|
|
return 0
|
|
elsif length < seed
|
|
return length
|
|
end
|
|
|
|
case @encoding
|
|
when 'E'
|
|
string[0,seed].scan(/./me)[0..-2].to_s.length
|
|
when 'S'
|
|
string[0,seed].scan(/./ms)[0..-2].to_s.length
|
|
when 'U'
|
|
string[0,seed].scan(/./mu)[0..-2].to_s.length
|
|
when 'X'
|
|
string[0,seed].force_encoding(@encoding_name)[0..-2].bytesize
|
|
end
|
|
end
|
|
|
|
# compare the specified two characters. If the characters matched,
|
|
# return true. Otherwise return false.
|
|
def _rl_compare_chars(buf1, pos1, buf2, pos2)
|
|
return false if buf1[pos1].nil? || buf2[pos2].nil?
|
|
case @encoding
|
|
when 'E'
|
|
buf1[pos1..-1].scan(/./me)[0] == buf2[pos2..-1].scan(/./me)[0]
|
|
when 'S'
|
|
buf1[pos1..-1].scan(/./ms)[0] == buf2[pos2..-1].scan(/./ms)[0]
|
|
when 'U'
|
|
buf1[pos1..-1].scan(/./mu)[0] == buf2[pos2..-1].scan(/./mu)[0]
|
|
when 'X'
|
|
buf1[pos1..-1].force_encoding(@encoding_name)[0] == buf2[pos2..-1].force_encoding(@encoding_name)[0]
|
|
else
|
|
buf1[pos1] == buf2[pos2]
|
|
end
|
|
end
|
|
|
|
# return the number of bytes parsed from the multibyte sequence starting
|
|
# at src, if a non-L'\0' wide character was recognized. It returns 0,
|
|
# if a L'\0' wide character was recognized. It returns (size_t)(-1),
|
|
# if an invalid multibyte sequence was encountered. It returns (size_t)(-2)
|
|
# if it couldn't parse a complete multibyte character.
|
|
def _rl_get_char_len(src)
|
|
return 0 if src[0,1] == ?\0 || src.length==0
|
|
case @encoding
|
|
when 'E'
|
|
len = src.scan(/./me)[0].to_s.length
|
|
when 'S'
|
|
len = src.scan(/./ms)[0].to_s.length
|
|
when 'U'
|
|
len = src.scan(/./mu)[0].to_s.length
|
|
when 'X'
|
|
src = src.dup.force_encoding(@encoding_name)
|
|
len = src.valid_encoding? ? src[0,1].bytesize : 0
|
|
else
|
|
len = 1
|
|
end
|
|
len==0 ? -2 : len
|
|
end
|
|
|
|
# read multibyte char
|
|
def _rl_read_mbchar(mbchar, size)
|
|
mb_len = 0
|
|
while (mb_len < size)
|
|
rl_setstate(RL_STATE_MOREINPUT)
|
|
mbchar << rl_read_key()
|
|
mb_len += 1
|
|
rl_unsetstate(RL_STATE_MOREINPUT)
|
|
case @encoding
|
|
when 'E'
|
|
break unless mbchar.scan(/./me).empty?
|
|
when 'S'
|
|
break unless mbchar.scan(/./ms).empty?
|
|
when 'U'
|
|
break unless mbchar.scan(/./mu).empty?
|
|
when 'X'
|
|
break if mbchar.dup.force_encoding(@encoding_name).valid_encoding?
|
|
end
|
|
end
|
|
mb_len
|
|
end
|
|
|
|
# Read a multibyte-character string whose first character is FIRST into
|
|
# the buffer MB of length MLEN. Returns the last character read, which
|
|
# may be FIRST. Used by the search functions, among others. Very similar
|
|
# to _rl_read_mbchar.
|
|
def _rl_read_mbstring(first, mb, mlen)
|
|
c = first
|
|
for i in 0 ... mlen
|
|
mb << c
|
|
if _rl_get_char_len(mb) == -2
|
|
# Read more for multibyte character
|
|
rl_setstate(RL_STATE_MOREINPUT)
|
|
c = rl_read_key()
|
|
rl_unsetstate(RL_STATE_MOREINPUT)
|
|
else
|
|
break
|
|
end
|
|
end
|
|
c
|
|
end
|
|
|
|
def _rl_is_mbchar_matched(string, seed, _end, mbchar, length)
|
|
return 0 if ((_end - seed) < length)
|
|
|
|
for i in 0 ... length
|
|
if (string[seed + i] != mbchar[i])
|
|
return 0
|
|
end
|
|
end
|
|
1
|
|
end
|
|
|
|
# Redraw the last line of a multi-line prompt that may possibly contain
|
|
# terminal escape sequences. Called with the cursor at column 0 of the
|
|
# line to draw the prompt on.
|
|
def redraw_prompt(t)
|
|
oldp = @rl_display_prompt
|
|
rl_save_prompt()
|
|
|
|
@rl_display_prompt = t
|
|
@local_prompt,@prompt_visible_length,@prompt_last_invisible,@prompt_invis_chars_first_line,@prompt_physical_chars =
|
|
expand_prompt(t)
|
|
@local_prompt_prefix = nil
|
|
@local_prompt_len = @local_prompt ? @local_prompt.length : 0
|
|
|
|
rl_forced_update_display()
|
|
|
|
@rl_display_prompt = oldp
|
|
rl_restore_prompt()
|
|
end
|
|
|
|
# Redisplay the current line after a SIGWINCH is received.
|
|
def _rl_redisplay_after_sigwinch()
|
|
# Clear the current line and put the cursor at column 0. Make sure
|
|
# the right thing happens if we have wrapped to a new screen line.
|
|
if @_rl_term_cr
|
|
@rl_outstream.write(@_rl_term_cr)
|
|
@_rl_last_c_pos = 0
|
|
if @_rl_term_clreol
|
|
@rl_outstream.write(@_rl_term_clreol)
|
|
else
|
|
space_to_eol(@_rl_screenwidth)
|
|
@rl_outstream.write(@_rl_term_cr)
|
|
end
|
|
|
|
if @_rl_last_v_pos > 0
|
|
_rl_move_vert(0)
|
|
end
|
|
else
|
|
rl_crlf()
|
|
end
|
|
|
|
# Redraw only the last line of a multi-line prompt.
|
|
t = @rl_display_prompt.index("\n")
|
|
if t
|
|
redraw_prompt(@rl_display_prompt[(t+1)..-1])
|
|
else
|
|
rl_forced_update_display()
|
|
end
|
|
end
|
|
|
|
def rl_resize_terminal()
|
|
if @readline_echoing_p
|
|
_rl_get_screen_size(@rl_instream.fileno, 1)
|
|
if @rl_redisplay_function != :rl_redisplay
|
|
rl_forced_update_display()
|
|
else
|
|
_rl_redisplay_after_sigwinch()
|
|
end
|
|
end
|
|
end
|
|
|
|
def rl_sigwinch_handler(sig)
|
|
rl_setstate(RL_STATE_SIGHANDLER)
|
|
rl_resize_terminal()
|
|
rl_unsetstate(RL_STATE_SIGHANDLER)
|
|
end
|
|
|
|
|
|
|
|
module_function :rl_attempted_completion_function,:rl_deprep_term_function,
|
|
:rl_event_hook,:rl_attempted_completion_over,:rl_basic_quote_characters,
|
|
:rl_basic_word_break_characters,:rl_completer_quote_characters,
|
|
:rl_completer_word_break_characters,:rl_completion_append_character,
|
|
:rl_filename_quote_characters,:rl_instream,:rl_library_version,:rl_outstream,
|
|
:rl_readline_name,
|
|
:rl_attempted_completion_function=,:rl_deprep_term_function=,
|
|
:rl_event_hook=,:rl_attempted_completion_over=,:rl_basic_quote_characters=,
|
|
:rl_basic_word_break_characters=,:rl_completer_quote_characters=,
|
|
:rl_completer_word_break_characters=,:rl_completion_append_character=,
|
|
:rl_filename_quote_characters=,:rl_instream=,:rl_library_version=,:rl_outstream=,
|
|
:rl_readline_name=,:history_length,:history_base
|
|
|
|
def no_terminal?
|
|
term = ENV["TERM"]
|
|
term.nil? || (term == 'dumb') || (term == 'cygwin' && RUBY_PLATFORM =~ /mswin|mingw/)
|
|
end
|
|
private :no_terminal?
|
|
|
|
end
|
|
|