# zsh-vi-mode.zsh -- A better and friendly vi(vim) mode for Zsh

# https://github.com/jeffreytse/zsh-vi-mode

#

# Copyright (c) 2020 Jeffrey Tse

#

# Permission is hereby granted, free of charge, to any person obtaining a copy

# of this software and associated documentation files (the "Software"), to deal

# in the Software without restriction, including without limitation the rights

# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

# copies of the Software, and to permit persons to whom the Software is

# furnished to do so, subject to the following conditions:

#

# The above copyright notice and this permission notice shall be included in all

# copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

# SOFTWARE.

#

# All Settings

# Some of these variables should be set before sourcing this file.

#

# ZVM_CONFIG_FUNC

# the config function (default is `zvm_config`), if this config function

# exists, it will be called automatically, you can do some configurations

# in this aspect before you source this plugin.

#

# For example:

#

# ```zsh

# function zvm_config() {

# ZVM_LINE_INIT_MODE=$ZVM_MODE_INSERT

# ZVM_VI_INSERT_ESCAPE_BINDKEY=jk

# }

#

# source ~/zsh-vi-mode.zsh

# ```

#

# ZVM_INIT_MODE

# the plugin initial mode (default is doing the initialization when the first

# new command line is starting. For doing the initialization instantly, you

# can set it to `sourcing`.

#

# ZVM_VI_ESCAPE_BINDKEY

# the vi escape key for all modes (default is ^[ => <ESC>), you can set it

# to whatever you like, such as `jj`, `jk` and so on.

#

# ZVM_VI_INSERT_ESCAPE_BINDKEY

# the vi escape key of insert mode (default is $ZVM_VI_ESCAPE_BINDKEY), you

# can set it to whatever, such as `jj`, `jk` and so on.

#

# ZVM_VI_VISUAL_ESCAPE_BINDKEY

# the vi escape key of visual mode (default is $ZVM_VI_ESCAPE_BINDKEY), you

# can set it to whatever, such as `jj`, `jk` and so on.

#

# ZVM_VI_OPPEND_ESCAPE_BINDKEY

# the vi escape key of operator pendding mode (default is

# $ZVM_VI_ESCAPE_BINDKEY), you can set it to whatever, such as `jj`, `jk`

# and so on.

#

# ZVM_VI_INSERT_MODE_LEGACY_UNDO:

# using legacy undo behavior in vi insert mode

#

# ZVM_VI_HIGHLIGHT_FOREGROUND:

# the behavior of highlight foreground (surrounds, visual-line, etc) in vi mode

#

# ZVM_VI_HIGHLIGHT_BACKGROUND:

# the behavior of highlight background (surrounds, visual-line, etc) in vi mode

#

# ZVM_VI_HIGHLIGHT_EXTRASTYLE:

# the behavior of highlight extra style (i.e. bold, underline) in vi mode

#

# For example:

# ZVM_VI_HIGHLIGHT_FOREGROUND=green # Color name

# ZVM_VI_HIGHLIGHT_FOREGROUND=#008800 # Hex value

# ZVM_VI_HIGHLIGHT_BACKGROUND=red # Color name

# ZVM_VI_HIGHLIGHT_BACKGROUND=#ff0000 # Hex value

# ZVM_VI_HIGHLIGHT_EXTRASTYLE=bold,underline # bold and underline

#

# ZVM_VI_SURROUND_BINDKEY

# the key binding mode for surround operating (default is 'classic')

#

# 1. 'classic' mode (verb->s->surround):

# S" Add " for visual selection

# ys" Add " for visual selection

# cs"' Change " to '

# ds" Delete "

#

# 2. 's-prefix' mode (s->verb->surround):

# sa" Add " for visual selection

# sd" Delete "

# sr"' Change " to '

#

# How to select surround text object?

# vi" Select the text object inside the quotes

# va( Select the text object including the brackets

#

# Then you can do any operation for the selection:

#

# 1. Add surrounds for text object

# vi" -> S[ or sa[ => "object" -> "[object]"

#

# 2. Delete/Yank/Change text object

# di( or vi( -> d

# ca( or va( -> c

# yi( or vi( -> y

#

# ZVM_READKEY_ENGINE

# the readkey engine for reading and processing the key events, and the

# below engines are supported:

# ZVM_READKEY_ENGINE_NEX (Default)

# ZVM_READKEY_ENGINE_ZLE

#

# the NEX is a better engine for reading and handling the key events than

# the Zsh's ZLE engine, currently the NEX engine is at beta stage, and

# you can change to Zsh's ZLE engine if you want.

#

# ZVM_KEYTIMEOUT:

# the key input timeout for waiting for next key (default is 0.4 seconds)

#

# ZVM_ESCAPE_KEYTIMEOUT:

# the key input timeout for waiting for next key if it is beginning with

# an escape character (default is 0.03 seconds), and this option is just

# available for the NEX readkey engine

#

# ZVM_LINE_INIT_MODE

# the setting for init mode of command line (default is empty), empty will

# keep the last command mode, for the first command line it will be insert

# mode, you can also set it to a specific vi mode to alway keep the mode

# for each command line

#

# For example:

# ZVM_LINE_INIT_MODE=$ZVM_MODE_INSERT

# ZVM_LINE_INIT_MODE=$ZVM_MODE_NORMAL

#

# ZVM_LAZY_KEYBINDINGS:

# the setting for lazy keybindings (default is true), and lazy keybindings

# will postpone the keybindings of vicmd and visual keymaps to the first

# time entering normal mode

#

# ZVM_NORMAL_MODE_CURSOR:

# the prompt cursor in normal mode

#

# ZVM_INSERT_MODE_CURSOR:

# the prompt cursor in insert mode

#

# ZVM_VISUAL_MODE_CURSOR:

# the prompt cursor in visual mode

#

# ZVM_VISUAL_LINE_MODE_CURSOR:

# the prompt cursor in visual line mode

#

# ZVM_OPPEND_MODE_CURSOR:

# the prompt cursor in operator pending mode

#

# You can change the cursor style by below:

# ZVM_INSERT_MODE_CURSOR=$ZVM_CURSOR_BLOCK

#

# and the below cursor style are supported:

# ZVM_CURSOR_USER_DEFAULT

# ZVM_CURSOR_BLOCK

# ZVM_CURSOR_UNDERLINE

# ZVM_CURSOR_BEAM

# ZVM_CURSOR_BLINKING_BLOCK

# ZVM_CURSOR_BLINKING_UNDERLINE

# ZVM_CURSOR_BLINKING_BEAM

#

# ZVM_VI_EDITOR

# the editor to edit your command line (default is $EDITOR)

#

# ZVM_TMPDIR

# the temporary directory (default is $TMPDIR, otherwise it's /tmp)

#

# ZVM_TERM

# the term for handling terminal sequences, it's important for some

# terminal emulators to show cursor properly (default is $TERM)

#

# ZVM_CURSOR_STYLE_ENABLED

# enable the cursor style feature (default is true)

#

# Avoid sourcing plugin multiple times

command -v 'zvm_version' >/dev/null && return

# Plugin information

typeset -gr ZVM_NAME='zsh-vi-mode'

typeset -gr ZVM_DESCRIPTION='💻 A better and friendly vi(vim) mode plugin for ZSH.'

typeset -gr ZVM_REPOSITORY='https://github.com/jeffreytse/zsh-vi-mode'

typeset -gr ZVM_VERSION='0.11.0'

# Plugin initial status

ZVM_INIT_DONE=false

# Postpone reset prompt (i.e. postpone the widget `reset-prompt`)

# -1 (No postponing)

# >=0 (Postponing, the decimal value stands for calling times of `reset-prompt`)

ZVM_POSTPONE_RESET_PROMPT=-1

# Disable reset prompt (i.e. postpone the widget `reset-prompt`)

ZVM_RESET_PROMPT_DISABLED=false

# Operator pending mode

ZVM_OPPEND_MODE=false

# Insert mode could be

# `i` (insert)

# `a` (append)

# `I` (insert at the non-blank beginning of current line)

# `A` (append at the end of current line)

ZVM_INSERT_MODE='i'

# The mode could be the below value:

# `n` (normal)

# `i` (insert)

# `v` (visual)

# `vl` (visual-line)

ZVM_MODE=''

# The keys typed to invoke this widget, as a literal string

ZVM_KEYS=''

# The region hilight information

ZVM_REGION_HIGHLIGHT=()

# Default zvm readkey engines

ZVM_READKEY_ENGINE_NEX='nex'

ZVM_READKEY_ENGINE_ZLE='zle'

ZVM_READKEY_ENGINE_DEFAULT=$ZVM_READKEY_ENGINE_NEX

# Default alternative character for escape characters

ZVM_ESCAPE_SPACE='\s'

ZVM_ESCAPE_NEWLINE='^J'

# Default vi modes

ZVM_MODE_LAST=''

ZVM_MODE_NORMAL='n'

ZVM_MODE_INSERT='i'

ZVM_MODE_VISUAL='v'

ZVM_MODE_VISUAL_LINE='vl'

ZVM_MODE_REPLACE='r'

# Default cursor styles

ZVM_CURSOR_USER_DEFAULT='ud'

ZVM_CURSOR_BLOCK='bl'

ZVM_CURSOR_UNDERLINE='ul'

ZVM_CURSOR_BEAM='be'

ZVM_CURSOR_BLINKING_BLOCK='bbl'

ZVM_CURSOR_BLINKING_UNDERLINE='bul'

ZVM_CURSOR_BLINKING_BEAM='bbe'

# The commands need to be repeated

ZVM_REPEAT_MODE=false

ZVM_REPEAT_RESET=false

ZVM_REPEAT_COMMANDS=($ZVM_MODE_NORMAL i)

##########################################

# Initial all default settings

# Default config function

: ${ZVM_CONFIG_FUNC:='zvm_config'}

# Set the readkey engine (default is NEX engine)

: ${ZVM_READKEY_ENGINE:=$ZVM_READKEY_ENGINE_DEFAULT}

# Set key input timeout (default is 0.4 seconds)

: ${ZVM_KEYTIMEOUT:=0.4}

# Set the escape key timeout (default is 0.03 seconds)

: ${ZVM_ESCAPE_KEYTIMEOUT:=0.03}

# Set keybindings mode (default is true)

# The lazy keybindings will post the keybindings of vicmd and visual

# keymaps to the first time entering the normal mode

: ${ZVM_LAZY_KEYBINDINGS:=true}

# All keybindings for lazy loading

if $ZVM_LAZY_KEYBINDINGS; then

ZVM_LAZY_KEYBINDINGS_LIST=()

fi

# Set the cursor style in defferent vi modes, the value you could use

# the predefined value, such as $ZVM_CURSOR_BLOCK, $ZVM_CURSOR_BEAM,

# $ZVM_CURSOR_BLINKING_BLOCK and so on.

: ${ZVM_INSERT_MODE_CURSOR:=$ZVM_CURSOR_BEAM}

: ${ZVM_NORMAL_MODE_CURSOR:=$ZVM_CURSOR_BLOCK}

: ${ZVM_VISUAL_MODE_CURSOR:=$ZVM_CURSOR_BLOCK}

: ${ZVM_VISUAL_LINE_MODE_CURSOR:=$ZVM_CURSOR_BLOCK}

# Operator pending mode cursor style (default is underscore)

: ${ZVM_OPPEND_MODE_CURSOR:=$ZVM_CURSOR_UNDERLINE}

# Set the vi escape key (default is ^[ => <ESC>)

: ${ZVM_VI_ESCAPE_BINDKEY:=^[}

: ${ZVM_VI_INSERT_ESCAPE_BINDKEY:=$ZVM_VI_ESCAPE_BINDKEY}

: ${ZVM_VI_VISUAL_ESCAPE_BINDKEY:=$ZVM_VI_ESCAPE_BINDKEY}

: ${ZVM_VI_OPPEND_ESCAPE_BINDKEY:=$ZVM_VI_ESCAPE_BINDKEY}

# Set the line init mode (empty will keep the last mode)

# you can also set it to others, such as $ZVM_MODE_INSERT.

: ${ZVM_LINE_INIT_MODE:=$ZVM_MODE_LAST}

: ${ZVM_VI_INSERT_MODE_LEGACY_UNDO:=false}

: ${ZVM_VI_SURROUND_BINDKEY:=classic}

: ${ZVM_VI_HIGHLIGHT_BACKGROUND:=#cc0000}

: ${ZVM_VI_HIGHLIGHT_FOREGROUND:=#eeeeee}

: ${ZVM_VI_HIGHLIGHT_EXTRASTYLE:=default}

: ${ZVM_VI_EDITOR:=${EDITOR:-vim}}

: ${ZVM_TMPDIR:=${TMPDIR:-/tmp}}

# Set the term for handling terminal sequences, it's important for some

# terminal emulators to show cursor properly (default is $TERM)

: ${ZVM_TERM:=${TERM:-xterm-256color}}

# Enable the cursor style feature

: ${ZVM_CURSOR_STYLE_ENABLED:=true}

# All the extra commands

commands_array_names=(

zvm_before_init_commands

zvm_after_init_commands

zvm_before_select_vi_mode_commands

zvm_after_select_vi_mode_commands

zvm_before_lazy_keybindings_commands

zvm_after_lazy_keybindings_commands

)

for commands_array_name in $commands_array_names; do

# Ensure commands set to an empty array, if not already set.

if [[ -z "${(P)commands_array_name}" ]]; then

typeset -g -a $commands_array_name

fi

done

# All the handlers for switching keyword

zvm_switch_keyword_handlers=(

zvm_switch_number

zvm_switch_boolean

zvm_switch_operator

zvm_switch_weekday

zvm_switch_month

)

# History for switching keyword

zvm_switch_keyword_history=()

# Display version information

function zvm_version() {

local git_info=$(git show -s --format="(%h, %ci)" 2>/dev/null)

echo -e "$ZVM_NAME $ZVM_VERSION $git_info"

echo -e "\e[4m$ZVM_REPOSITORY\e[0m"

echo -e "$ZVM_DESCRIPTION"

}

# The widget wrapper

function zvm_widget_wrapper() {

local rawfunc=$1;

local func=$2;

local called=$3;

local -i retval

$called || { $rawfunc "${@:4}" }

$func "${@:4}"

return retval

}

# Define widget function

function zvm_define_widget() {

local widget=$1

local func=$2 || $1

local result=($(zle -l -L "${widget}"))

# Check if existing the same name

if [[ ${#result[@]} == 4 ]]; then

local rawfunc=${result[4]}

local wrapper="zvm_${widget}-wrapper"

# To avoid double calling, we need to check if the raw function

# has been called already in the custom widget function

local rawcode=$(declare -f $func 2>/dev/null)

local called=false

[[ "$rawcode" == *"\$rawfunc"* ]] && { called=true }

eval "$wrapper() { zvm_widget_wrapper $rawfunc $func $called \"\$@\" }"

func=$wrapper

fi

zle -N $widget $func

}

# Get the keys typed to invoke this widget, as a literal string

function zvm_keys() {

local keys=${ZVM_KEYS:-$KEYS}

# Append the prefix of keys if it is visual or visual-line mode

case "${ZVM_MODE}" in

$ZVM_MODE_VISUAL)

if [[ "$keys" != v* ]]; then

keys="v${keys}"

fi

;;

$ZVM_MODE_VISUAL_LINE)

if [[ "$keys" != V* ]]; then

keys="V${keys}"

fi

;;

esac

# Escape the newline and space characters, otherwise, we can't

# get the output from subshell correctly.

keys=${keys//$'\n'/$ZVM_ESCAPE_NEWLINE}

keys=${keys// /$ZVM_ESCAPE_SPACE}

echo $keys

}

# Find the widget on a specified bindkey

function zvm_find_bindkey_widget() {

local keymap=$1

local keys=$2

local prefix_mode=${3:-false}

retval=()

if $prefix_mode; then

local pos=0

local spos=3

local prefix_keys=

# Get the prefix keys

if [[ $prefix_keys ]]; then

prefix_keys=${prefix_keys:0:-1}

# If the last key is an escape key (e.g. \", \`, \\) we still

# need to remove the escape backslash `\`

if [[ ${prefix_keys: -1} == '\' ]]; then

prefix_keys=${prefix_keys:0:-1}

fi

fi

local result=$(bindkey -M ${keymap} -p "$prefix_keys")$'\n'

# Split string to array by newline

for ((i=$spos;i<$#result;i++)); do

# Save the last whitespace character of the line

# and continue continue handling while meeting `\n`

case "${result:$i:1}" in

' ') spos=$i; i=$i+1; continue;;

[$'\n']);;

*) continue;;

esac

# Check if it has the same prefix keys and retrieve the widgets

if [[ "${result:$((pos+1)):$#keys}" == "$keys" ]]; then

# Get the binding keys

local k=${result:$((pos+1)):$((spos-pos-2))}

# Escape spaces in key bindings (space -> $ZVM_ESCAPE_SPACE)

k=${k// /$ZVM_ESCAPE_SPACE}

retval+=($k ${result:$((spos+1)):$((i-spos-1))})

fi

# Save as new position

pos=$i+1

# Skip 3 characters

# One key and quotes at least (i.e \n"_" )

i=$i+3

done

else

local result=$(bindkey -M ${keymap} "$keys")

if [[ "${result: -14}" == ' undefined-key' ]]; then

return

fi

# Escape spaces in key bindings (space -> $ZVM_ESCAPE_SPACE)

for ((i=$#result;i>=0;i--)); do

# Backward find the first whitespace character

[[ "${result:$i:1}" == ' ' ]] || continue

# Retrieve the keys and widget

local k=${result:1:$i-2}

# Escape spaces in key bindings (space -> $ZVM_ESCAPE_SPACE)

k=${k// /$ZVM_ESCAPE_SPACE}

retval+=($k ${result:$i+1})

break

done

fi

}

# Read keys for retrieving widget

function zvm_readkeys() {

local keymap=$1

local key=${2:-$(zvm_keys)}

local keys=

local widget=

local result=

local pattern=

local timeout=

while :; do

# Keep reading key for escape character

if [[ "$key" == $'\e' ]]; then

while :; do

local k=

read -t $ZVM_ESCAPE_KEYTIMEOUT -k 1 k || break

key="${key}${k}"

done

fi

keys="${keys}${key}"

# Handle the pattern

if [[ -n "$key" ]]; then

# Transform the non-printed characters

local k=$(zvm_escape_non_printed_characters "${key}")

# Escape keys

# " -> \" It's a special character in bash syntax

# ` -> \` It's a special character in bash syntax

# <space> -> ` ` It's a special character in bash syntax

k=${k//\"/\\\"}

k=${k//\`/\\\`}

k=${k//$ZVM_ESCAPE_SPACE/ }

pattern="${pattern}${k}"

fi

# Find out widgets that match this key pattern

zvm_find_bindkey_widget $keymap "$pattern" true

result=(${retval[@]})

# Exit key input if there is only one widget matched

# or no more widget matched.

case ${#result[@]} in

2) key=; widget=${result[2]}; break;;

0) break;;

esac

# Evaluate the readkey timeout

# Special timeout for the escape sequence

if [[ "${keys}" == $'\e' ]]; then

timeout=$ZVM_ESCAPE_KEYTIMEOUT

# Check if there is any one custom escape sequence

for ((i=1; i<=${#result[@]}; i=i+2)); do

if [[ "${result[$i]}" =~ '^\^\[\[?[A-Z0-9]*~?\^\[' ]]; then

timeout=$ZVM_KEYTIMEOUT

break

fi

done

else

timeout=$ZVM_KEYTIMEOUT

fi

# Wait for reading next key, and we should save the widget

# as the final widget if it is full matching

key=

if [[ "${result[1]}" == "${pattern}" ]]; then

widget=${result[2]}

# Get current widget as final widget when reading key timeout

read -t $timeout -k 1 key || break

else

zvm_enter_oppend_mode

read -k 1 key

fi

done

# Exit operator pending mode

if $ZVM_OPPEND_MODE; then

zvm_exit_oppend_mode

fi

if [[ -z "$key" ]]; then

retval=(${keys} $widget)

else

retval=(${keys:0:-$#key} $widget $key)

fi

}

# Add key bindings

function zvm_bindkey() {

local keymap=$1

local keys=$2

local widget=$3

local params=$4

local key=

# We should bind keys with an existing widget

[[ -z $widget ]] && return

# If lazy keybindings is enabled, we need to add to the lazy list

if [[ ${ZVM_LAZY_KEYBINDINGS_LIST+x} && ${keymap} != viins ]]; then

keys=${keys//\"/\\\"}

keys=${keys//\`/\\\`}

ZVM_LAZY_KEYBINDINGS_LIST+=(

"${keymap} \"${keys}\" ${widget} \"${params}\""

)

return

fi

# Hanle the keybinding of NEX readkey engine

if [[ $ZVM_READKEY_ENGINE == $ZVM_READKEY_ENGINE_NEX ]]; then

# Get the first key (especially check if ctrl characters)

if [[ $#keys -gt 1 && "${keys:0:1}" == '^' ]]; then

key=${keys:0:2}

else

key=${keys:0:1}

# As any character that is not bound to one of the history control

# related functions, or self-insert or self-insert-unmeta, will

# cause the mode to be exited To prevent history search, so that

# we need to bind keys explicitly.

if [[ "$keymap" == "viins" ]]; then

bindkey -M isearch "${key}" self-insert

fi

fi

bindkey -M $keymap "${key}" zvm_readkeys_handler

fi

# Wrap params to a new widget

if [[ -n $params ]]; then

local suffix=$(zvm_string_to_hex $params)

eval "$widget:$suffix() { $widget $params }"

widget="$widget:$suffix"

zvm_define_widget $widget

fi

# Bind keys with with a widget

bindkey -M $keymap "${keys}" $widget

}

# Convert string to hexadecimal

function zvm_string_to_hex() {

}

# Escape non-printed characters

function zvm_escape_non_printed_characters() {

local str=

for ((i=0;i<$#1;i++)); do

local c=${1:$i:1}

if [[ "$c" < ' ' ]]; then

local ord=$(($(printf '%d' "'$c")+64))

c=$(printf \\$(printf '%03o' $ord))

str="${str}^${c}"

elif [[ "$c" == '' ]]; then

str="${str}^?"

elif [[ "$c" == '' ]]; then

str="${str}^@"

else

str="${str}${c}"

fi

done

# Escape the newline and space characters, otherwise, we can't

# get the output from subshell correctly.

str=${str// /$ZVM_ESCAPE_SPACE}

str=${str//$'\n'/$ZVM_ESCAPE_NEWLINE}

echo -n $str

}

# Backward remove characters of an emacs region in the line

function zvm_backward_kill_region() {

local bpos=$CURSOR-1 epos=$CURSOR

# Backward search the boundary of current region

for ((; bpos >= 0; bpos--)); do

# Break when cursor is at the beginning of line

[[ "${BUFFER:$bpos:1}" == $'\n' ]] && break

# Break when cursor is at the boundary of a word region

[[ "${BUFFER:$bpos:2}" =~ ^\ [^\ $'\n']$ ]] && break

done

bpos=$bpos+1

CUTBUFFER=${BUFFER:$bpos:$((epos-bpos))}

BUFFER="${BUFFER:0:$bpos}${BUFFER:$epos}"

CURSOR=$bpos

}

# Remove all characters between the cursor position and the

# beginning of the line.

function zvm_backward_kill_line() {

BUFFER=${BUFFER:$CURSOR:$#BUFFER}

CURSOR=0

}

# Remove all characters between the cursor position and the

# end of the line.

function zvm_forward_kill_line() {

BUFFER=${BUFFER:0:$CURSOR}

}

# Remove all characters of the line.

function zvm_kill_line() {

local ret=($(zvm_calc_selection $ZVM_MODE_VISUAL_LINE))

local bpos=${ret[1]} epos=${ret[2]}

CUTBUFFER=${BUFFER:$bpos:$((epos-bpos))}$'\n'

BUFFER="${BUFFER:0:$bpos}${BUFFER:$epos}"

CURSOR=$bpos

}

# Remove all characters of the whole line.

function zvm_kill_whole_line() {

local ret=($(zvm_calc_selection $ZVM_MODE_VISUAL_LINE))

local bpos=$ret[1] epos=$ret[2] cpos=$ret[3]

CUTBUFFER=${BUFFER:$bpos:$((epos-bpos))}$'\n'

# Adjust region range of deletion

if (( $epos < $#BUFFER )); then

epos=$epos+1

fi

BUFFER="${BUFFER:0:$bpos}${BUFFER:$epos}"

CURSOR=$cpos

}

# Exchange the point and mark

function zvm_exchange_point_and_mark() {

cursor=$MARK

MARK=$CURSOR CURSOR=$cursor

zvm_highlight

}

# Open line below

function zvm_open_line_below() {

local i=$CURSOR

# If there is a completion suffix, we should break at the

# postion of suffix begin, otherwise, it should break when

# forward finding out the first newline character.

for ((; i<$#BUFFER; i++)); do

if ((SUFFIX_ACTIVE == 1)) && ((i >= SUFFIX_BEGIN)); then

break

fi

if [[ "${BUFFER[$i]}" == $'\n' ]]; then

i=$((i-1))

break

fi

done

CURSOR=$i

LBUFFER+=$'\n'

zvm_reset_repeat_commands $ZVM_MODE_NORMAL o

zvm_select_vi_mode $ZVM_MODE_INSERT

}

# Open line above

function zvm_open_line_above() {

local i=$CURSOR

# Break when backward finding out the first newline character.

for ((; i>0; i--)); do

if [[ "${BUFFER[$i]}" == $'\n' ]]; then

break

fi

done

CURSOR=$i

LBUFFER+=$'\n'

CURSOR=$((CURSOR-1))

zvm_reset_repeat_commands $ZVM_MODE_NORMAL O

zvm_select_vi_mode $ZVM_MODE_INSERT

}

# Replace characters one by one (Replacing mode)

function zvm_vi_replace() {

if [[ $ZVM_MODE == $ZVM_MODE_NORMAL ]]; then

local cursor=$CURSOR

local cache=()

local cmds=()

local key=

zvm_select_vi_mode $ZVM_MODE_REPLACE

while :; do

# Read a character for replacing

zvm_update_cursor

# Redisplay the command line, this is to be called from within

# a user-defined widget to allow changes to become visible

zle -R

read -k 1 key

# Escape key will break the replacing process, and enter key

# will repace with a newline character.

case $(zvm_escape_non_printed_characters $key) in

'^['|$ZVM_VI_OPPEND_ESCAPE_BINDKEY) break;;

'^M') key=$'\n';;

esac

# If the key is backspace, we should move backward the cursor

if [[ $key == '' ]]; then

# Cursor position should not be less than zero

if ((cursor > 0)); then

cursor=$((cursor-1))

fi

# We should recover the character when cache size is not zero

if ((${#cache[@]} > 0)); then

key=${cache[-1]}

if [[ $key == '<I>' ]]; then

key=

fi

cache=(${cache[@]:0:-1})

BUFFER[$cursor+1]=$key

# Remove from commands

cmds=(${cmds[@]:0:-1})

fi

else

# If the key or the character at cursor is a newline character,

# or the cursor is at the end of buffer, we should insert the

# key instead of replacing with the key.

if [[ $key == $'\n' ||

$BUFFER[$cursor+1] == $'\n' ||

$BUFFER[$cursor+1] == ''

]]; then

cache+=('<I>')

LBUFFER+=$key

else

cache+=(${BUFFER[$cursor+1]})

BUFFER[$cursor+1]=$key

fi

cursor=$((cursor+1))

# Push to commands

cmds+=($key)

fi

# Update next cursor position

CURSOR=$cursor

zle redisplay

done

# The cursor position should go back one character after

# exiting the replace mode

zle vi-backward-char

zvm_select_vi_mode $ZVM_MODE_NORMAL

zvm_reset_repeat_commands $ZVM_MODE R $cmds

elif [[ $ZVM_MODE == $ZVM_MODE_VISUAL ]]; then

zvm_enter_visual_mode V

zvm_vi_change

elif [[ $ZVM_MODE == $ZVM_MODE_VISUAL_LINE ]]; then

zvm_vi_change

fi

}

# Replace characters in one time

function zvm_vi_replace_chars() {

local cmds=()

local key=

# Read a character for replacing

zvm_enter_oppend_mode

# Redisplay the command line, this is to be called from within

# a user-defined widget to allow changes to become visible

zle redisplay

zle -R

read -k 1 key

zvm_exit_oppend_mode

# Escape key will break the replacing process

case $(zvm_escape_non_printed_characters $key) in

$ZVM_VI_OPPEND_ESCAPE_BINDKEY)

zvm_exit_visual_mode

return

esac

if [[ $ZVM_MODE == $ZVM_MODE_NORMAL ]]; then

cmds+=($key)

BUFFER[$CURSOR+1]=$key

else

local ret=($(zvm_calc_selection))

local bpos=${ret[1]} epos=${ret[2]}

for ((bpos=bpos+1; bpos<=epos; bpos++)); do

# Newline character is no need to be replaced

if [[ $BUFFER[$bpos] == $'\n' ]]; then

cmds+=($'\n')

continue

fi

cmds+=($key)

BUFFER[$bpos]=$key

done

zvm_exit_visual_mode

fi

# Reset the repeat commands

zvm_reset_repeat_commands $ZVM_MODE r $cmds

}

# Substitute characters of selection

function zvm_vi_substitute() {

# Substitute one character in normal mode

if [[ $ZVM_MODE == $ZVM_MODE_NORMAL ]]; then

BUFFER="${BUFFER:0:$CURSOR}${BUFFER:$((CURSOR+1))}"

zvm_reset_repeat_commands $ZVM_MODE c 0 1

zvm_select_vi_mode $ZVM_MODE_INSERT

else

zvm_vi_change

fi

}

# Substitute all characters of a line

function zvm_vi_substitute_whole_line() {

zvm_select_vi_mode $ZVM_MODE_VISUAL_LINE false

zvm_vi_substitute

}

# Check if cursor is at an empty line

function zvm_is_empty_line() {

local cursor=${1:-$CURSOR}

if [[ ${BUFFER:$cursor:1} == $'\n' &&

${BUFFER:$((cursor-1)):1} == $'\n' ]]; then

return

fi

return 1

}

# Get the beginning and end position of selection

function zvm_selection() {

}

# Calculate the region of selection

function zvm_calc_selection() {

local ret=($(zvm_selection))

local bpos=${ret[1]} epos=${ret[2]} cpos=

# Save the current cursor position

cpos=$bpos

# Check if it is visual-line mode

if [[ "${1:-$ZVM_MODE}" == $ZVM_MODE_VISUAL_LINE ]]; then

# Extend the selection to whole line

for ((bpos=$bpos-1; $bpos>0; bpos--)); do

if [[ "${BUFFER:$bpos:1}" == $'\n' ]]; then

bpos=$((bpos+1))

break

fi

done

for ((epos=$epos-1; $epos<$#BUFFER; epos++)); do

if [[ "${BUFFER:$epos:1}" == $'\n' ]]; then

break

fi

done

# The begin position must not be less than zero

if (( bpos < 0 )); then

bpos=0

fi

###########################################

# Calculate the new cursor position, here we consider that

# the selection will be delected.

# Calculate the indent of current cursor line

for ((cpos=$((CURSOR-1)); $cpos>=0; cpos--)); do

[[ "${BUFFER:$cpos:1}" == $'\n' ]] && break

done

local indent=$((CURSOR-cpos-1))

# If the selection includes the last line, the cursor

# will move up to above line. Otherwise the cursor will

# keep in the same line.

local hpos= # Line head position

local rpos= # Reference position

if (( $epos < $#BUFFER )); then