Class: Reline::LineEditor

# File 'lib/reline/line_editor.rb', line 1376

private def buffer_empty?
  current_line.empty? and @buffer_of_lines.size == 1
end

# File 'lib/reline/line_editor.rb', line 8

attr_reader :byte_pointer

# File 'lib/reline/line_editor.rb', line 1364

def byte_pointer=(val)
  @byte_pointer = val
end

# File 'lib/reline/line_editor.rb', line 11

attr_accessor :completion_append_character

# File 'lib/reline/line_editor.rb', line 10

attr_accessor :completion_proc

# File 'lib/reline/line_editor.rb', line 9

attr_accessor :confirm_multiline_termination_proc

# File 'lib/reline/line_editor.rb', line 15

attr_accessor :dig_perfect_match_proc

# File 'lib/reline/line_editor.rb', line 221

def eof?
  @eof
end

# File 'lib/reline/line_editor.rb', line 1380

def finished?
  @finished
end

# File 'lib/reline/line_editor.rb', line 16

attr_writer :output

# File 'lib/reline/line_editor.rb', line 12

attr_accessor :output_modifier_proc

# File 'lib/reline/line_editor.rb', line 13

attr_accessor :prompt_proc

# File 'lib/reline/line_editor.rb', line 936

private def argumentable?(method_obj)
  method_obj and method_obj.parameters.any? { |param| param[0] == :key and param[1] == :arg }
end

# File 'lib/reline/line_editor.rb', line 1550

alias_method :backward_char, :ed_prev_char

# File 'lib/reline/line_editor.rb', line 1828

alias_method :backward_delete_char, :em_delete_prev_char

# File 'lib/reline/line_editor.rb', line 1966

alias_method :backward_kill_word, :ed_delete_prev_word

# File 'lib/reline/line_editor.rb', line 1946

alias_method :backward_word, :ed_prev_word

# File 'lib/reline/line_editor.rb', line 1559

alias_method :beginning_of_line, :ed_move_to_beg

# File 'lib/reline/line_editor.rb', line 1395

private def byteinsert(str, byte_pointer, other)
  new_str = str.byteslice(0, byte_pointer)
  new_str << other
  new_str << str.byteslice(byte_pointer, str.bytesize)
  new_str
end

# File 'lib/reline/line_editor.rb', line 1389

private def byteslice!(str, byte_pointer, size)
  new_str = str.byteslice(0, byte_pointer)
  new_str << str.byteslice(byte_pointer + size, str.bytesize)
  [new_str, str.byteslice(byte_pointer, size)]
end

# File 'lib/reline/line_editor.rb', line 310

private def calculate_nearest_cursor(cursor)
  line_to_calc = current_line
  new_cursor_max = calculate_width(line_to_calc)
  new_cursor = 0
  new_byte_pointer = 0
  height = 1
  max_width = screen_width
  if @config.editing_mode_is?(:vi_command)
    last_byte_size = Reline::Unicode.get_prev_mbchar_size(line_to_calc, line_to_calc.bytesize)
    if last_byte_size > 0
      last_mbchar = line_to_calc.byteslice(line_to_calc.bytesize - last_byte_size, last_byte_size)
      last_width = Reline::Unicode.get_mbchar_width(last_mbchar)
      end_of_line_cursor = new_cursor_max - last_width
    else
    end_of_line_cursor = new_cursor_max
    end
  else
  end_of_line_cursor = new_cursor_max
  end
  line_to_calc.grapheme_clusters.each do |gc|
    mbchar = gc.encode(Encoding::UTF_8)
    mbchar_width = Reline::Unicode.get_mbchar_width(mbchar)
    now = new_cursor + mbchar_width
    if now > end_of_line_cursor or now > cursor
      break
    end
    new_cursor += mbchar_width
    if new_cursor > max_width * height
      height += 1
    end
    new_byte_pointer += gc.bytesize
  end
  @byte_pointer = new_byte_pointer
end

# File 'lib/reline/line_editor.rb', line 400

def calculate_overlay_levels(overlay_levels)
  levels = []
  overlay_levels.each do |x, w, l|
    levels.fill(l, x, w)
  end
  levels
end

# File 'lib/reline/line_editor.rb', line 1402

private def calculate_width(str, allow_escape_code = false)
  Reline::Unicode.calculate_width(str, allow_escape_code)
end

# File 'lib/reline/line_editor.rb', line 1149

def call_completion_proc
  result = retrieve_completion_block(true)
  pre, target, post = result
  result = call_completion_proc_with_checking_args(pre, target, post)
  Reline.core.instance_variable_set(:@completion_quote_character, nil)
  result
end

# File 'lib/reline/line_editor.rb', line 1157

def call_completion_proc_with_checking_args(pre, target, post)
  if @completion_proc and target
    argnum = @completion_proc.parameters.inject(0) { |result, item|
      case item.first
      when :req, :opt
        result + 1
      when :rest
        break 3
      end
    }
    case argnum
    when 1
      result = @completion_proc.(target)
    when 2
      result = @completion_proc.(target, pre)
    when 3..Float::INFINITY
      result = @completion_proc.(target, pre, post)
    end
  end
  result
end

# File 'lib/reline/line_editor.rb', line 2006

alias_method :capitalize_word, :em_capitol_case

# File 'lib/reline/line_editor.rb', line 96

private def check_mode_string
  if @config.show_mode_in_prompt
    if @config.editing_mode_is?(:vi_command)
      @config.vi_cmd_mode_string
    elsif @config.editing_mode_is?(:vi_insert)
      @config.vi_ins_mode_string
    elsif @config.editing_mode_is?(:emacs)
      @config.emacs_mode_string
    else
      '?'
    end
  end
end

# File 'lib/reline/line_editor.rb', line 110

private def check_multiline_prompt(buffer, mode_string)
  if @vi_arg
    prompt = "(arg: #{@vi_arg}) "
  elsif @searching_prompt
    prompt = @searching_prompt
  else
    prompt = @prompt
  end
  if !@is_multiline
    mode_string = check_mode_string
    prompt = mode_string + prompt if mode_string
    [prompt] + [''] * (buffer.size - 1)
  elsif @prompt_proc
    prompt_list = @prompt_proc.(buffer).map { |pr| pr.gsub("\n", "\\n") }
    prompt_list.map!{ prompt } if @vi_arg or @searching_prompt
    prompt_list = [prompt] if prompt_list.empty?
    prompt_list = prompt_list.map{ |pr| mode_string + pr } if mode_string
    prompt = prompt_list[@line_index]
    prompt = prompt_list[0] if prompt.nil?
    prompt = prompt_list.last if prompt.nil?
    if buffer.size > prompt_list.size
      (buffer.size - prompt_list.size).times do
        prompt_list << prompt_list.last
      end
    end
    prompt_list
  else
    prompt = mode_string + prompt if mode_string
    [prompt] * buffer.size
  end
end

# File 'lib/reline/line_editor.rb', line 966

private def cleanup_waiting
  @waiting_proc = nil
  @vi_waiting_operator = nil
  @vi_waiting_operator_arg = nil
  @searching_prompt = nil
  @drop_terminate_spaces = false
end

# File 'lib/reline/line_editor.rb', line 448

def clear_dialogs
  @dialogs.each do |dialog|
    dialog.contents = nil
    dialog.trap_key = nil
  end
end

# File 'lib/reline/line_editor.rb', line 549

private def clear_rendered_screen_cache
  @rendered_screen.lines = []
  @rendered_screen.cursor_y = 0
end

# File 'lib/reline/line_editor.rb', line 1930

alias_method :clear_screen, :ed_clear_screen

# File 'lib/reline/line_editor.rb', line 1422

private def complete(_key)
  return if @config.disable_completion

  process_insert(force: true)
  if @config.autocompletion
    @completion_state = CompletionState::NORMAL
    @completion_occurs = move_completed_list(:down)
  else
    @completion_journey_state = nil
    result = call_completion_proc
    if result.is_a?(Array)
      @completion_occurs = true
      perform_completion(result)
    end
  end
end

# File 'lib/reline/line_editor.rb', line 1439

private def completion_journey_move(direction)
  return if @config.disable_completion

  process_insert(force: true)
  @completion_state = CompletionState::NORMAL
  @completion_occurs = move_completed_list(direction)
end

# File 'lib/reline/line_editor.rb', line 1455

private def completion_journey_up(_key)
  completion_journey_move(:up) if @config.autocompletion
end

# File 'lib/reline/line_editor.rb', line 1303

def confirm_multiline_termination
  temp_buffer = @buffer_of_lines.dup
  @confirm_multiline_termination_proc.(temp_buffer.join("\n") + "\n")
end

# File 'lib/reline/line_editor.rb', line 2044

private def copy_for_vi(text)
  if @config.editing_mode_is?(:vi_insert) or @config.editing_mode_is?(:vi_command)
    @vi_clipboard = text
  end
end

# File 'lib/reline/line_editor.rb', line 306

def current_byte_pointer_cursor
  calculate_width(current_line.byteslice(0, @byte_pointer))
end

# File 'lib/reline/line_editor.rb', line 1200

def current_line
  @buffer_of_lines[@line_index]
end

# File 'lib/reline/line_editor.rb', line 1892

alias_method :delete_char, :em_delete

# File 'lib/reline/line_editor.rb', line 1906

alias_method :delete_char_or_list, :em_delete_or_list

# File 'lib/reline/line_editor.rb', line 1330

def delete_text(start = nil, length = nil)
  if start.nil? and length.nil?
    if @buffer_of_lines.size == 1
      @buffer_of_lines[@line_index] = ''
      @byte_pointer = 0
    elsif @line_index == (@buffer_of_lines.size - 1) and @line_index > 0
      @buffer_of_lines.pop
      @line_index -= 1
      @byte_pointer = 0
    elsif @line_index < (@buffer_of_lines.size - 1)
      @buffer_of_lines.delete_at(@line_index)
      @byte_pointer = 0
    end
  elsif not start.nil? and not length.nil?
    if current_line
      before = current_line.byteslice(0, start)
      after = current_line.byteslice(start + length, current_line.bytesize)
      set_current_line(before + after)
    end
  elsif start.is_a?(Range)
    range = start
    first = range.first
    last = range.last
    last = current_line.bytesize - 1 if last > current_line.bytesize
    last += current_line.bytesize if last < 0
    first += current_line.bytesize if first < 0
    range = range.exclude_end? ? first...last : first..last
    line = current_line.bytes.reject.with_index{ |c, i| range.include?(i) }.map{ |c| c.chr(Encoding::ASCII_8BIT) }.join.force_encoding(encoding)
    set_current_line(line)
  else
    set_current_line(current_line.byteslice(0, start))
  end
end

# File 'lib/reline/line_editor.rb', line 872

def dialog_proc_scope_completion_journey_data
  return nil unless @completion_journey_state
  line_index = @completion_journey_state.line_index
  pre_lines = @buffer_of_lines[0...line_index].map { |line| line + "\n" }
  post_lines = @buffer_of_lines[(line_index + 1)..-1].map { |line| line + "\n" }
  DialogProcScope::CompletionJourneyData.new(
    pre_lines.join + @completion_journey_state.pre,
    @completion_journey_state.post + post_lines.join,
    @completion_journey_state.list,
    @completion_journey_state.pointer
  )
end

# File 'lib/reline/line_editor.rb', line 700

private def dialog_range(dialog, dialog_y)
  x_range = dialog.column...dialog.column + dialog.width
  y_range = dialog_y + dialog.vertical_offset...dialog_y + dialog.vertical_offset + dialog.contents.size
  [x_range, y_range]
end

# File 'lib/reline/line_editor.rb', line 2019

alias_method :downcase_word, :em_lower_case

# File 'lib/reline/line_editor.rb', line 2297

private def ed_argument_digit(key)
  if @vi_arg.nil?
    if key.chr.to_i.zero?
      if key.anybits?(0b10000000)
        unescaped_key = key ^ 0b10000000
        unless unescaped_key.chr.to_i.zero?
          @vi_arg = unescaped_key.chr.to_i
        end
      end
    else
      @vi_arg = key.chr.to_i
    end
  else
    @vi_arg = @vi_arg * 10 + key.chr.to_i
  end
end

# File 'lib/reline/line_editor.rb', line 1924

private def ed_clear_screen(key)
  Reline::IOGate.clear_screen
  @screen_size = Reline::IOGate.get_screen_size
  @rendered_screen.base_y = 0
  clear_rendered_screen_cache
end

# File 'lib/reline/line_editor.rb', line 2243

private def ed_delete_next_char(key, arg: 1)
  byte_size = Reline::Unicode.get_next_mbchar_size(current_line, @byte_pointer)
  unless current_line.empty? || byte_size == 0
    line, mbchar = byteslice!(current_line, @byte_pointer, byte_size)
    copy_for_vi(mbchar)
    if @byte_pointer > 0 && current_line.bytesize == @byte_pointer + byte_size
      byte_size = Reline::Unicode.get_prev_mbchar_size(line, @byte_pointer)
      set_current_line(line, @byte_pointer - byte_size)
    else
      set_current_line(line, @byte_pointer)
    end
  end
  arg -= 1
  ed_delete_next_char(key, arg: arg) if arg > 0
end

# File 'lib/reline/line_editor.rb', line 2155

private def ed_delete_prev_char(key, arg: 1)
  deleted = +''
  arg.times do
    if @byte_pointer > 0
      byte_size = Reline::Unicode.get_prev_mbchar_size(current_line, @byte_pointer)
      @byte_pointer -= byte_size
      line, mbchar = byteslice!(current_line, @byte_pointer, byte_size)
      set_current_line(line)
      deleted.prepend(mbchar)
    end
  end
  copy_for_vi(deleted)
end

# File 'lib/reline/line_editor.rb', line 1958

private def ed_delete_prev_word(key)
  if @byte_pointer > 0
    byte_size = Reline::Unicode.em_backward_word(current_line, @byte_pointer)
    line, word = byteslice!(current_line, @byte_pointer - byte_size, byte_size)
    set_current_line(line, @byte_pointer - byte_size)
    @kill_ring.append(word, true)
  end
end

# File 'lib/reline/line_editor.rb', line 1507

alias_method :ed_digit, :ed_insert

# File 'lib/reline/line_editor.rb', line 1482

private def ed_insert(key)
  if key.instance_of?(String)
    begin
      key.encode(Encoding::UTF_8)
    rescue Encoding::UndefinedConversionError
      return
    end
    str = key
  else
    begin
      key.chr.encode(Encoding::UTF_8)
    rescue Encoding::UndefinedConversionError
      return
    end
    str = key.chr
  end
  if @in_pasting
    @continuous_insertion_buffer << str
    return
  elsif not @continuous_insertion_buffer.empty?
    process_insert
  end

  insert_text(str)
end

# File 'lib/reline/line_editor.rb', line 1835

private def ed_kill_line(key)
  if current_line.bytesize > @byte_pointer
    line, deleted = byteslice!(current_line, @byte_pointer, current_line.bytesize - @byte_pointer)
    set_current_line(line, line.bytesize)
    @kill_ring.append(deleted)
  elsif @byte_pointer == current_line.bytesize and @buffer_of_lines.size > @line_index + 1
    set_current_line(current_line + @buffer_of_lines.delete_at(@line_index + 1), current_line.bytesize)
  end
end

# File 'lib/reline/line_editor.rb', line 1556

private def ed_move_to_beg(key)
  @byte_pointer = 0
end

# File 'lib/reline/line_editor.rb', line 1562

private def ed_move_to_end(key)
  @byte_pointer = current_line.bytesize
end

# File 'lib/reline/line_editor.rb', line 1785

private def ed_newline(key)
  process_insert(force: true)
  if @is_multiline
    if @config.editing_mode_is?(:vi_command)
      if @line_index < (@buffer_of_lines.size - 1)
        ed_next_history(key) # means cursor down
      else
        # should check confirm_multiline_termination to finish?
        finish
      end
    else
      if @line_index == (@buffer_of_lines.size - 1)
        if confirm_multiline_termination
          finish
        else
          key_newline(key)
        end
      else
        # should check confirm_multiline_termination to finish?
        @line_index = @buffer_of_lines.size - 1
        @byte_pointer = current_line.bytesize
        finish
      end
    end
  else
    finish
  end
end

# File 'lib/reline/line_editor.rb', line 1526

private def ed_next_char(key, arg: 1)
  byte_size = Reline::Unicode.get_next_mbchar_size(current_line, @byte_pointer)
  if (@byte_pointer < current_line.bytesize)
    @byte_pointer += byte_size
  elsif @config.editing_mode_is?(:emacs) and @byte_pointer == current_line.bytesize and @line_index < @buffer_of_lines.size - 1
    @byte_pointer = 0
    @line_index += 1
  end
  arg -= 1
  ed_next_char(key, arg: arg) if arg > 0
end

# File 'lib/reline/line_editor.rb', line 1768

private def ed_next_history(key, arg: 1)
  if @line_index < (@buffer_of_lines.size - 1)
    cursor = current_byte_pointer_cursor
    @line_index += 1
    calculate_nearest_cursor(cursor)
    return
  end
  move_history(
    (@history_pointer || Reline::HISTORY.size) + 1,
    line: :start,
    cursor: @config.editing_mode_is?(:vi_command) ? :start : :end,
  )
  arg -= 1
  ed_next_history(key, arg: arg) if arg > 0
end

# File 'lib/reline/line_editor.rb', line 1539

private def ed_prev_char(key, arg: 1)
  if @byte_pointer > 0
    byte_size = Reline::Unicode.get_prev_mbchar_size(current_line, @byte_pointer)
    @byte_pointer -= byte_size
  elsif @config.editing_mode_is?(:emacs) and @byte_pointer == 0 and @line_index > 0
    @line_index -= 1
    @byte_pointer = current_line.bytesize
  end
  arg -= 1
  ed_prev_char(key, arg: arg) if arg > 0
end

# File 'lib/reline/line_editor.rb', line 1751

private def ed_prev_history(key, arg: 1)
  if @line_index > 0
    cursor = current_byte_pointer_cursor
    @line_index -= 1
    calculate_nearest_cursor(cursor)
    return
  end
  move_history(
    (@history_pointer || Reline::HISTORY.size) - 1,
    line: :end,
    cursor: @config.editing_mode_is?(:vi_command) ? :start : :end,
  )
  arg -= 1
  ed_prev_history(key, arg: arg) if arg > 0
end

# File 'lib/reline/line_editor.rb', line 1940

private def ed_prev_word(key)
  if @byte_pointer > 0
    byte_size = Reline::Unicode.em_backward_word(current_line, @byte_pointer)
    @byte_pointer -= byte_size
  end
end

# File 'lib/reline/line_editor.rb', line 1510

private def ed_quoted_insert(str, arg: 1)
  @waiting_proc = proc { |key|
    arg.times do
      if key == "\C-j".ord or key == "\C-m".ord
        key_newline(key)
      elsif key == 0
        # Ignore NUL.
      else
        ed_insert(key)
      end
    end
    @waiting_proc = nil
  }
end

# File 'lib/reline/line_editor.rb', line 1714

private def ed_search_next_history(key, arg: 1)
  substr = prev_action_state_value(:search_history) == :empty ? '' : current_line.byteslice(0, @byte_pointer)
  return if @history_pointer.nil?

  history_range = @history_pointer + 1...Reline::HISTORY.size
  h_pointer, line_index = search_history(substr, history_range)
  return if h_pointer.nil? and not substr.empty?

  move_history(h_pointer, line: line_index || :start, cursor: substr.empty? ? :end : @byte_pointer)
  arg -= 1
  set_next_action_state(:search_history, :empty) if substr.empty?
  ed_search_next_history(key, arg: arg) if arg > 0
end

# File 'lib/reline/line_editor.rb', line 1699

private def ed_search_prev_history(key, arg: 1)
  substr = prev_action_state_value(:search_history) == :empty ? '' : current_line.byteslice(0, @byte_pointer)
  return if @history_pointer == 0
  return if @history_pointer.nil? && substr.empty? && !current_line.empty?

  history_range = 0...(@history_pointer || Reline::HISTORY.size)
  h_pointer, line_index = search_history(substr, history_range.reverse_each)
  return unless h_pointer
  move_history(h_pointer, line: line_index || :start, cursor: substr.empty? ? :end : @byte_pointer)
  arg -= 1
  set_next_action_state(:search_history, :empty) if substr.empty?
  ed_search_prev_history(key, arg: arg) if arg > 0
end

# File 'lib/reline/line_editor.rb', line 1968

private def ed_transpose_chars(key)
  if @byte_pointer > 0
    if @byte_pointer < current_line.bytesize
      byte_size = Reline::Unicode.get_next_mbchar_size(current_line, @byte_pointer)
      @byte_pointer += byte_size
    end
    back1_byte_size = Reline::Unicode.get_prev_mbchar_size(current_line, @byte_pointer)
    if (@byte_pointer - back1_byte_size) > 0
      back2_byte_size = Reline::Unicode.get_prev_mbchar_size(current_line, @byte_pointer - back1_byte_size)
      back2_pointer = @byte_pointer - back1_byte_size - back2_byte_size
      line, back2_mbchar = byteslice!(current_line, back2_pointer, back2_byte_size)
      set_current_line(byteinsert(line, @byte_pointer - back2_byte_size, back2_mbchar))
    end
  end
end

# File 'lib/reline/line_editor.rb', line 1985

private def ed_transpose_words(key)
  left_word_start, middle_start, right_word_start, after_start = Reline::Unicode.ed_transpose_words(current_line, @byte_pointer)
  before = current_line.byteslice(0, left_word_start)
  left_word = current_line.byteslice(left_word_start, middle_start - left_word_start)
  middle = current_line.byteslice(middle_start, right_word_start - middle_start)
  right_word = current_line.byteslice(right_word_start, after_start - right_word_start)
  after = current_line.byteslice(after_start, current_line.bytesize - after_start)
  return if left_word.empty? or right_word.empty?
  from_head_to_left_word = before + right_word + middle + left_word
  set_current_line(from_head_to_left_word + after, from_head_to_left_word.bytesize)
end

# File 'lib/reline/line_editor.rb', line 1461

private def ed_unassigned(key) end

# File 'lib/reline/line_editor.rb', line 798

def editing_mode
  @config.editing_mode
end

# File 'lib/reline/line_editor.rb', line 1998

private def em_capitol_case(key)
  if current_line.bytesize > @byte_pointer
    byte_size, new_str = Reline::Unicode.em_forward_word_with_capitalization(current_line, @byte_pointer)
    before = current_line.byteslice(0, @byte_pointer)
    after = current_line.byteslice((@byte_pointer + byte_size)..-1)
    set_current_line(before + new_str + after, @byte_pointer + new_str.bytesize)
  end
end

# File 'lib/reline/line_editor.rb', line 1879

private def em_delete(key)
  if buffer_empty? and key == "\C-d".ord
    @eof = true
    finish
  elsif @byte_pointer < current_line.bytesize
    splitted_last = current_line.byteslice(@byte_pointer, current_line.bytesize)
    mbchar = splitted_last.grapheme_clusters.first
    line, = byteslice!(current_line, @byte_pointer, mbchar.bytesize)
    set_current_line(line)
  elsif @byte_pointer == current_line.bytesize and @buffer_of_lines.size > @line_index + 1
    set_current_line(current_line + @buffer_of_lines.delete_at(@line_index + 1), current_line.bytesize)
  end
end

# File 'lib/reline/line_editor.rb', line 1948

private def em_delete_next_word(key)
  if current_line.bytesize > @byte_pointer
    byte_size = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
    line, word = byteslice!(current_line, @byte_pointer, byte_size)
    set_current_line(line)
    @kill_ring.append(word)
  end
end

# File 'lib/reline/line_editor.rb', line 1894

private def em_delete_or_list(key)
  if current_line.empty? or @byte_pointer < current_line.bytesize
    em_delete(key)
  elsif !@config.autocompletion # show completed list
    result = call_completion_proc
    if result.is_a?(Array)
      _preposing, target = retrieve_completion_block
      candidates = filter_normalize_candidates(target, result)
      menu(candidates)
    end
  end
end

# File 'lib/reline/line_editor.rb', line 1814

private def em_delete_prev_char(key, arg: 1)
  arg.times do
    if @byte_pointer == 0 and @line_index > 0
      @byte_pointer = @buffer_of_lines[@line_index - 1].bytesize
      @buffer_of_lines[@line_index - 1] += @buffer_of_lines.delete_at(@line_index)
      @line_index -= 1
    elsif @byte_pointer > 0
      byte_size = Reline::Unicode.get_prev_mbchar_size(current_line, @byte_pointer)
      line, = byteslice!(current_line, @byte_pointer - byte_size, byte_size)
      set_current_line(line, @byte_pointer - byte_size)
    end
  end
  process_auto_indent
end

# File 'lib/reline/line_editor.rb', line 2459

private def em_exchange_mark(key)
  return unless @mark_pointer
  new_pointer = [@byte_pointer, @line_index]
  @byte_pointer, @line_index = @mark_pointer
  @mark_pointer = new_pointer
end

# File 'lib/reline/line_editor.rb', line 1871

private def em_kill_line(key)
  if current_line.size > 0
    @kill_ring.append(current_line.dup, true)
    set_current_line('', 0)
  end
end

# File 'lib/reline/line_editor.rb', line 2034

private def em_kill_region(key)
  if @byte_pointer > 0
    byte_size = Reline::Unicode.em_big_backward_word(current_line, @byte_pointer)
    line, deleted = byteslice!(current_line, @byte_pointer - byte_size, byte_size)
    set_current_line(line, @byte_pointer - byte_size)
    @kill_ring.append(deleted, true)
  end
end

# File 'lib/reline/line_editor.rb', line 2008

private def em_lower_case(key)
  if current_line.bytesize > @byte_pointer
    byte_size = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
    part = current_line.byteslice(@byte_pointer, byte_size).grapheme_clusters.map { |mbchar|
      mbchar =~ /[A-Z]/ ? mbchar.downcase : mbchar
    }.join
    rest = current_line.byteslice((@byte_pointer + byte_size)..-1)
    line = current_line.byteslice(0, @byte_pointer) + part
    set_current_line(line + rest, line.bytesize)
  end
end

# File 'lib/reline/line_editor.rb', line 1932

private def em_next_word(key)
  if current_line.bytesize > @byte_pointer
    byte_size = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
    @byte_pointer += byte_size
  end
end

# File 'lib/reline/line_editor.rb', line 2454

private def em_set_mark(key)
  @mark_pointer = [@byte_pointer, @line_index]
end

# File 'lib/reline/line_editor.rb', line 2021

private def em_upper_case(key)
  if current_line.bytesize > @byte_pointer
    byte_size = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
    part = current_line.byteslice(@byte_pointer, byte_size).grapheme_clusters.map { |mbchar|
      mbchar =~ /[a-z]/ ? mbchar.upcase : mbchar
    }.join
    rest = current_line.byteslice((@byte_pointer + byte_size)..-1)
    line = current_line.byteslice(0, @byte_pointer) + part
    set_current_line(line + rest, line.bytesize)
  end
end

# File 'lib/reline/line_editor.rb', line 1908

private def em_yank(key)
  yanked = @kill_ring.yank
  insert_text(yanked) if yanked
end

# File 'lib/reline/line_editor.rb', line 1914

private def em_yank_pop(key)
  yanked, prev_yank = @kill_ring.yank_pop
  if yanked
    line, = byteslice!(current_line, @byte_pointer - prev_yank.bytesize, prev_yank.bytesize)
    set_current_line(line, @byte_pointer - prev_yank.bytesize)
    insert_text(yanked)
  end
end

# File 'lib/reline/line_editor.rb', line 2467

private def emacs_editing_mode(key)
  @config.editing_mode = :emacs
end

# File 'lib/reline/line_editor.rb', line 85

def encoding
  io_gate.encoding
end

# File 'lib/reline/line_editor.rb', line 1565

alias_method :end_of_line, :ed_move_to_end

# File 'lib/reline/line_editor.rb', line 2465

alias_method :exchange_point_and_mark, :em_exchange_mark

# File 'lib/reline/line_editor.rb', line 806

private def filter_normalize_candidates(target, list)
  target = target.downcase if @config.completion_ignore_case
  list.select do |item|
    next unless item

    unless Encoding.compatible?(target.encoding, item.encoding)
      # Crash with Encoding::CompatibilityError is required by readline-ext/test/readline/test_readline.rb
      # TODO: fix the test
      raise Encoding::CompatibilityError, "#{target.encoding.name} is not compatible with #{item.encoding.name}"
    end

    if @config.completion_ignore_case
      item.downcase.start_with?(target)
    else
      item.start_with?(target)
    end
  end.map do |item|
    item.unicode_normalize
  rescue Encoding::CompatibilityError
    item
  end.uniq
end

# File 'lib/reline/line_editor.rb', line 217

def finalize
  Signal.trap('INT', @old_trap)
end

# File 'lib/reline/line_editor.rb', line 1384

def finish
  @finished = true
  @config.reset
end

# File 'lib/reline/line_editor.rb', line 1537

alias_method :forward_char, :ed_next_char

# File 'lib/reline/line_editor.rb', line 1687

alias_method :forward_search_history, :vi_search_next

# File 'lib/reline/line_editor.rb', line 1938

alias_method :forward_word, :em_next_word

# File 'lib/reline/line_editor.rb', line 1567

private def generate_searcher(search_key)
  search_word = String.new(encoding: encoding)
  multibyte_buf = String.new(encoding: 'ASCII-8BIT')
  hit_pointer = nil
  lambda do |key|
    search_again = false
    case key
    when "\C-h".ord, "\C-?".ord
      grapheme_clusters = search_word.grapheme_clusters
      if grapheme_clusters.size > 0
        grapheme_clusters.pop
        search_word = grapheme_clusters.join
      end
    when "\C-r".ord, "\C-s".ord
      search_again = true if search_key == key
      search_key = key
    else
      multibyte_buf << key
      if multibyte_buf.dup.force_encoding(encoding).valid_encoding?
        search_word << multibyte_buf.dup.force_encoding(encoding)
        multibyte_buf.clear
      end
    end
    hit = nil
    if not search_word.empty? and @line_backup_in_history&.include?(search_word)
      hit_pointer = Reline::HISTORY.size
      hit = @line_backup_in_history
    else
      if search_again
        if search_word.empty? and Reline.last_incremental_search
          search_word = Reline.last_incremental_search
        end
        if @history_pointer
          case search_key
          when "\C-r".ord
            history_pointer_base = 0
            history = Reline::HISTORY[0..(@history_pointer - 1)]
          when "\C-s".ord
            history_pointer_base = @history_pointer + 1
            history = Reline::HISTORY[(@history_pointer + 1)..-1]
          end
        else
          history_pointer_base = 0
          history = Reline::HISTORY
        end
      elsif @history_pointer
        case search_key
        when "\C-r".ord
          history_pointer_base = 0
          history = Reline::HISTORY[0..@history_pointer]
        when "\C-s".ord
          history_pointer_base = @history_pointer
          history = Reline::HISTORY[@history_pointer..-1]
        end
      else
        history_pointer_base = 0
        history = Reline::HISTORY
      end
      case search_key
      when "\C-r".ord
        hit_index = history.rindex { |item|
          item.include?(search_word)
        }
      when "\C-s".ord
        hit_index = history.index { |item|
          item.include?(search_word)
        }
      end
      if hit_index
        hit_pointer = history_pointer_base + hit_index
        hit = Reline::HISTORY[hit_pointer]
      end
    end
    case search_key
    when "\C-r".ord
      prompt_name = 'reverse-i-search'
    when "\C-s".ord
      prompt_name = 'i-search'
    end
    prompt_name = "failed #{prompt_name}" unless hit
    [search_word, prompt_name, hit_pointer]
  end
end

# File 'lib/reline/line_editor.rb', line 186

private def handle_interrupted
  return unless @interrupted

  @interrupted = false
  clear_dialogs
  render
  cursor_to_bottom_offset = @rendered_screen.lines.size - @rendered_screen.cursor_y
  Reline::IOGate.scroll_down cursor_to_bottom_offset
  Reline::IOGate.move_cursor_column 0
  clear_rendered_screen_cache
  case @old_trap
  when 'DEFAULT', 'SYSTEM_DEFAULT'
    raise Interrupt
  when 'IGNORE'
    # Do nothing
  when 'EXIT'
    exit
  else
    @old_trap.call if @old_trap.respond_to?(:call)
  end
end

# File 'lib/reline/line_editor.rb', line 174

private def handle_resized
  return unless @resized

  @screen_size = Reline::IOGate.get_screen_size
  @resized = false
  scroll_into_view
  Reline::IOGate.move_cursor_up @rendered_screen.cursor_y
  @rendered_screen.base_y = Reline::IOGate.cursor_pos.y
  clear_rendered_screen_cache
  render
end

# File 'lib/reline/line_editor.rb', line 169

def handle_signal
  handle_interrupted
  handle_resized
end

# File 'lib/reline/line_editor.rb', line 1712

alias_method :history_search_backward, :ed_search_prev_history

# File 'lib/reline/line_editor.rb', line 1727

alias_method :history_search_forward, :ed_search_next_history

# File 'lib/reline/line_editor.rb', line 940

private def inclusive?(method_obj)
  # If a motion method with the keyword argument "inclusive" follows the
  # operator, it must contain the character at the cursor position.
  method_obj and method_obj.parameters.any? { |param| param[0] == :key and param[1] == :inclusive }
end

# File 'lib/reline/line_editor.rb', line 1651

private def incremental_search_history(key)
  backup = @buffer_of_lines.dup, @line_index, @byte_pointer, @history_pointer, @line_backup_in_history
  searcher = generate_searcher(key)
  @searching_prompt = "(reverse-i-search)`': "
  termination_keys = ["\C-j".ord]
  termination_keys.concat(@config.isearch_terminators.chars.map(&:ord)) if @config.isearch_terminators
  @waiting_proc = ->(k) {
    chr = k.is_a?(String) ? k : k.chr(Encoding::ASCII_8BIT)
    if k == "\C-g".ord
      # cancel search and restore buffer
      @buffer_of_lines, @line_index, @byte_pointer, @history_pointer, @line_backup_in_history = backup
      @searching_prompt = nil
      @waiting_proc = nil
    elsif !termination_keys.include?(k) && (chr.match?(/[[:print:]]/) || k == "\C-h".ord || k == "\C-?".ord || k == "\C-r".ord || k == "\C-s".ord)
      search_word, prompt_name, hit_pointer = searcher.call(k)
      Reline.last_incremental_search = search_word
      @searching_prompt = "(%s)`%s'" % [prompt_name, search_word]
      @searching_prompt += ': ' unless @is_multiline
      move_history(hit_pointer, line: :end, cursor: :end) if hit_pointer
    else
      # terminaton_keys and other keys will terminalte
      move_history(@history_pointer, line: :end, cursor: :start)
      @searching_prompt = nil
      @waiting_proc = nil
    end
  }
end

# File 'lib/reline/line_editor.rb', line 1070

def input_key(key)
  save_old_buffer
  @config.reset_oneshot_key_bindings
  @dialogs.each do |dialog|
    if key.char.instance_of?(Symbol) and key.char == dialog.name
      return
    end
  end
  if key.char.nil?
    process_insert(force: true)
    @eof = buffer_empty?
    finish
    return
  end
  @completion_occurs = false

  if key.char.is_a?(Symbol)
    process_key(key.char, key.char)
  else
    normal_char(key)
  end

  @prev_action_state, @next_action_state = @next_action_state, NullActionState

  unless @completion_occurs
    @completion_state = CompletionState::NORMAL
    @completion_journey_state = nil
  end

  push_input_lines unless @undoing
  @undoing = false

  if @in_pasting
    clear_dialogs
    return
  end

  modified = @old_buffer_of_lines != @buffer_of_lines
  if !@completion_occurs && modified && !@config.disable_completion && @config.autocompletion
    # Auto complete starts only when edited
    process_insert(force: true)
    @completion_journey_state = retrieve_completion_journey_state
  end
  modified
end

# File 'lib/reline/line_editor.rb', line 1308

def insert_multiline_text(text)
  save_old_buffer
  pre = @buffer_of_lines[@line_index].byteslice(0, @byte_pointer)
  post = @buffer_of_lines[@line_index].byteslice(@byte_pointer..)
  lines = (pre + Reline::Unicode.safe_encode(text, encoding).gsub(/\r\n?/, "\n") + post).split("\n", -1)
  lines << '' if lines.empty?
  @buffer_of_lines[@line_index, 1] = lines
  @line_index += lines.size - 1
  @byte_pointer = @buffer_of_lines[@line_index].bytesize - post.bytesize
  push_input_lines
end

# File 'lib/reline/line_editor.rb', line 279

private def insert_new_line(cursor_line, next_line)
  @buffer_of_lines.insert(@line_index + 1, String.new(next_line, encoding: encoding))
  @buffer_of_lines[@line_index] = cursor_line
  @line_index += 1
  @byte_pointer = 0
  if @auto_indent_proc && !@in_pasting
    if next_line.empty?
      (
        # For compatibility, use this calculation instead of just `process_auto_indent @line_index - 1, cursor_dependent: false`
        indent1 = @auto_indent_proc.(@buffer_of_lines.take(@line_index - 1).push(''), @line_index - 1, 0, true)
        indent2 = @auto_indent_proc.(@buffer_of_lines.take(@line_index), @line_index - 1, @buffer_of_lines[@line_index - 1].bytesize, false)
        indent = indent2 || indent1
        @buffer_of_lines[@line_index - 1] = ' ' * indent + @buffer_of_lines[@line_index - 1].gsub(/\A\s*/, '')
      )
      process_auto_indent @line_index, add_newline: true
    else
      process_auto_indent @line_index - 1, cursor_dependent: false
      process_auto_indent @line_index, add_newline: true # Need for compatibility
      process_auto_indent @line_index, cursor_dependent: false
    end
  end
end

# File 'lib/reline/line_editor.rb', line 1320

def insert_text(text)
  if @buffer_of_lines[@line_index].bytesize == @byte_pointer
    @buffer_of_lines[@line_index] += text
  else
    @buffer_of_lines[@line_index] = byteinsert(@buffer_of_lines[@line_index], @byte_pointer, text)
  end
  @byte_pointer += text.bytesize
  process_auto_indent
end

# File 'lib/reline/line_editor.rb', line 81

def io_gate
  Reline::IOGate
end

# File 'lib/reline/line_editor.rb', line 1406

private def key_delete(key)
  if @config.editing_mode_is?(:vi_insert)
    ed_delete_next_char(key)
  elsif @config.editing_mode_is?(:emacs)
    em_delete(key)
  end
end

# File 'lib/reline/line_editor.rb', line 1414

private def key_newline(key)
  if @is_multiline
    next_line = current_line.byteslice(@byte_pointer, current_line.bytesize - @byte_pointer)
    cursor_line = current_line.byteslice(0, @byte_pointer)
    insert_new_line(cursor_line, next_line)
  end
end

# File 'lib/reline/line_editor.rb', line 1844

alias_method :kill_line, :ed_kill_line

# File 'lib/reline/line_editor.rb', line 1877

alias_method :kill_whole_line, :em_kill_line

# File 'lib/reline/line_editor.rb', line 1956

alias_method :kill_word, :em_delete_next_word

# File 'lib/reline/line_editor.rb', line 1196

def line()
  @buffer_of_lines.join("\n") unless eof?
end

# File 'lib/reline/line_editor.rb', line 802

private def menu(list)
  @menu_info = MenuInfo.new(list)
end

# File 'lib/reline/line_editor.rb', line 1447

private def menu_complete(_key)
  completion_journey_move(:down)
end

# File 'lib/reline/line_editor.rb', line 1451

private def menu_complete_backward(_key)
  completion_journey_move(:up)
end

# File 'lib/reline/line_editor.rb', line 353

def modified_lines
  with_cache(__method__, whole_lines, finished?) do |whole, complete|
    modify_lines(whole, complete)
  end
end

# File 'lib/reline/line_editor.rb', line 790

private def modify_lines(before, complete)
  if after = @output_modifier_proc&.call("#{before.join("\n")}\n", complete: complete)
    after.lines("\n").map { |l| l.chomp('') }
  else
    before.map { |l| Reline::Unicode.escape_for_print(l) }
  end
end

# File 'lib/reline/line_editor.rb', line 885

private def move_completed_list(direction)
  @completion_journey_state ||= retrieve_completion_journey_state
  return false unless @completion_journey_state

  if (delta = { up: -1, down: +1 }[direction])
    @completion_journey_state.pointer = (@completion_journey_state.pointer + delta) % @completion_journey_state.list.size
  end
  completed = @completion_journey_state.list[@completion_journey_state.pointer]
  set_current_line(@completion_journey_state.pre + completed + @completion_journey_state.post, @completion_journey_state.pre.bytesize + completed.bytesize)
  true
end

# File 'lib/reline/line_editor.rb', line 1729

private def move_history(history_pointer, line:, cursor:)
  history_pointer ||= Reline::HISTORY.size
  return if history_pointer < 0 || history_pointer > Reline::HISTORY.size
  old_history_pointer = @history_pointer || Reline::HISTORY.size
  if old_history_pointer == Reline::HISTORY.size
    @line_backup_in_history = whole_buffer
  else
    Reline::HISTORY[old_history_pointer] = whole_buffer
  end
  if history_pointer == Reline::HISTORY.size
    buf = @line_backup_in_history
    @history_pointer = @line_backup_in_history = nil
  else
    buf = Reline::HISTORY[history_pointer]
    @history_pointer = history_pointer
  end
  @buffer_of_lines = buf.split("\n")
  @buffer_of_lines = [String.new(encoding: encoding)] if @buffer_of_lines.empty?
  @line_index = line == :start ? 0 : line == :end ? @buffer_of_lines.size - 1 : line
  @byte_pointer = cursor == :start ? 0 : cursor == :end ? current_line.bytesize : cursor
end