diff --git a/src/vimode/modes/normalvimode.cpp b/src/vimode/modes/normalvimode.cpp
index 972b4642..12a8b866 100644
--- a/src/vimode/modes/normalvimode.cpp
+++ b/src/vimode/modes/normalvimode.cpp
@@ -1,4147 +1,4147 @@
 /*  This file is part of the KDE libraries and the Kate part.
  *
  *  Copyright (C) 2008-2009 Erlend Hamberg <ehamberg@gmail.com>
  *  Copyright (C) 2008 Evgeniy Ivanov <powerfox@kde.ru>
  *  Copyright (C) 2009 Paul Gideon Dann <pdgiddie@gmail.com>
  *  Copyright (C) 2011 Svyatoslav Kuzmich <svatoslav1@gmail.com>
  *  Copyright (C) 2012 - 2013 Simon St James <kdedevel@etotheipiplusone.com>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "katebuffer.h"
 #include "katecompletionwidget.h"
 #include "kateconfig.h"
 #include "kateglobal.h"
 #include "katepartdebug.h"
 #include "kateundomanager.h"
 #include <vimode/command.h>
 #include <vimode/emulatedcommandbar/emulatedcommandbar.h>
 #include "kateviewhelpers.h"
 #include "kateviewinternal.h"
 #include <vimode/globalstate.h>
 #include <vimode/inputmodemanager.h>
 #include <vimode/modes/insertvimode.h>
 #include <vimode/modes/replacevimode.h>
 #include <vimode/keymapper.h>
 #include <vimode/keyparser.h>
 #include <vimode/motion.h>
 #include <vimode/modes/normalvimode.h>
 #include <vimode/modes/visualvimode.h>
 #include <vimode/history.h>
 #include "katecmd.h"
 #include <ktexteditor/attribute.h>
 #include "kateviinputmode.h"
 #include <vimode/registers.h>
 #include <vimode/marks.h>
 #include <vimode/searcher.h>
 #include <vimode/macrorecorder.h>
 #include <vimode/lastchangerecorder.h>
 
 #include <QApplication>
 #include <QList>
 #include <KLocalizedString>
 
 using namespace KateVi;
 
 #define ADDCMD(STR, FUNC, FLGS) m_commands.push_back( \
         new Command( this, QStringLiteral(STR), &NormalViMode::FUNC, FLGS ) );
 
 #define ADDMOTION(STR, FUNC, FLGS) m_motions.push_back( \
         new Motion( this, QStringLiteral(STR), &NormalViMode::FUNC, FLGS ) );
 
 NormalViMode::NormalViMode(InputModeManager *viInputModeManager,
                            KTextEditor::ViewPrivate *view,
                            KateViewInternal *viewInternal)
     : ModeBase()
 {
     m_view = view;
     m_viewInternal = viewInternal;
     m_viInputModeManager = viInputModeManager;
     m_stickyColumn = -1;
     m_lastMotionWasVisualLineUpOrDown = false;
     m_currentMotionWasVisualLineUpOrDown = false;
 
     // FIXME: make configurable
     m_extraWordCharacters = QString();
     m_matchingItems[QStringLiteral("/*")] = QStringLiteral("*/");
     m_matchingItems[QStringLiteral("*/")] = QStringLiteral("-/*");
 
     m_matchItemRegex = generateMatchingItemRegex();
 
     m_scroll_count_limit = 1000; // Limit of count for scroll commands.
 
     initializeCommands();
     m_pendingResetIsDueToExit = false;
     m_isRepeatedTFcommand = false;
     m_lastMotionWasLinewiseInnerBlock = false;
     m_motionCanChangeWholeVisualModeSelection = false;
     resetParser(); // initialise with start configuration
 
     m_isUndo = false;
     connect(doc()->undoManager(), SIGNAL(undoStart(KTextEditor::Document*)),
             this, SLOT(undoBeginning()));
     connect(doc()->undoManager(), SIGNAL(undoEnd(KTextEditor::Document*)),
             this, SLOT(undoEnded()));
 
     updateYankHighlightAttrib();
     connect(view, SIGNAL(configChanged()),
             this, SLOT(updateYankHighlightAttrib()));
     connect(doc(), SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document*)),
             this, SLOT(clearYankHighlight()));
     connect(doc(), SIGNAL(aboutToDeleteMovingInterfaceContent(KTextEditor::Document*)),
             this, SLOT(aboutToDeleteMovingInterfaceContent()));
 }
 
 NormalViMode::~NormalViMode()
 {
     qDeleteAll(m_commands);
     qDeleteAll(m_motions);
     qDeleteAll(m_highlightedYanks);
 }
 
 /**
  * parses a key stroke to check if it's a valid (part of) a command
  * @return true if a command was completed and executed, false otherwise
  */
 bool NormalViMode::handleKeypress(const QKeyEvent *e)
 {
     const int keyCode = e->key();
 
     // ignore modifier keys alone
     if (keyCode == Qt::Key_Shift || keyCode == Qt::Key_Control
             || keyCode == Qt::Key_Alt || keyCode == Qt::Key_Meta) {
         return false;
     }
 
     clearYankHighlight();
 
     if (keyCode == Qt::Key_Escape || (keyCode == Qt::Key_C && e->modifiers() == Qt::ControlModifier) || (keyCode == Qt::Key_BracketLeft && e->modifiers() == Qt::ControlModifier)) {
         m_viInputModeManager->inputAdapter()->setCaretStyle(KateRenderer::Block);
         m_pendingResetIsDueToExit = true;
         // Vim in weird as if we e.g. i<ctrl-o><ctrl-c> it claims (in the status bar) to still be in insert mode,
         // but behaves as if it's in normal mode. I'm treating the status bar thing as a bug and just exiting
         // insert mode altogether.
         m_viInputModeManager->setTemporaryNormalMode(false);
         reset();
         return true;
     }
 
     const QChar key = KeyParser::self()->KeyEventToQChar(*e);
 
     const QChar lastChar = m_keys.isEmpty() ?  QChar::Null : m_keys.at(m_keys.size() - 1);
     const bool waitingForRegisterOrCharToSearch = this->waitingForRegisterOrCharToSearch();
 
     // Use replace caret when reading a character for "r"
     if (key == QLatin1Char('r') && !waitingForRegisterOrCharToSearch) {
         m_viInputModeManager->inputAdapter()->setCaretStyle(KateRenderer::Underline);
     }
 
     m_keysVerbatim.append(KeyParser::self()->decodeKeySequence(key));
 
     if ((keyCode >= Qt::Key_0 && keyCode <= Qt::Key_9 && lastChar != QLatin1Char('"'))          // key 0-9
             && (m_countTemp != 0 || keyCode != Qt::Key_0)                       // first digit can't be 0
             && (!waitingForRegisterOrCharToSearch) // Not in the middle of "find char" motions or replacing char.
             && e->modifiers() == Qt::NoModifier) {
 
         m_countTemp *= 10;
         m_countTemp += keyCode - Qt::Key_0;
 
         return true;
     } else if (m_countTemp != 0) {
         m_count = getCount() * m_countTemp;
         m_countTemp = 0;
         m_iscounted = true;
     }
 
     m_keys.append(key);
 
     if (m_viInputModeManager->macroRecorder()->isRecording() && key == QLatin1Char('q')) {
         // Need to special case this "finish macro" q, as the "begin macro" q
         // needs a parameter whereas the finish macro does not.
         m_viInputModeManager->macroRecorder()->stop();
         resetParser();
         return true;
     }
 
     if ((key == QLatin1Char('/') || key == QLatin1Char('?')) && !waitingForRegisterOrCharToSearch) {
         // Special case for "/" and "?": these should be motions, but this is complicated by
         // the fact that the user must interact with the search bar before the range of the
         // motion can be determined.
         // We hack around this by showing the search bar immediately, and, when the user has
         // finished interacting with it, have the search bar send a "synthetic" keypresses
         // that will either abort everything (if the search was aborted) or "complete" the motion
         // otherwise.
         m_positionWhenIncrementalSearchBegan = m_view->cursorPosition();
         if (key == QLatin1Char('/')) {
             commandSearchForward();
         } else {
             commandSearchBackward();
         }
         return true;
     }
 
     // Special case: "cw" and "cW" work the same as "ce" and "cE" if the cursor is
     // on a non-blank.  This is because Vim interprets "cw" as change-word, and a
     // word does not include the following white space. (:help cw in vim)
     if ((m_keys == QLatin1String("cw") || m_keys == QLatin1String("cW")) && !getCharUnderCursor().isSpace()) {
         // Special case of the special case: :-)
         // If the cursor is at the end of the current word rewrite to "cl"
         const bool isWORD = (m_keys.at(1) == QLatin1Char('W'));
         const KTextEditor::Cursor currentPosition(m_view->cursorPosition());
         const KTextEditor::Cursor endOfWordOrWORD = (isWORD ? findWORDEnd(currentPosition.line(), currentPosition.column() - 1, true) :
                                         findWordEnd(currentPosition.line(), currentPosition.column() - 1, true));
 
         if (currentPosition == endOfWordOrWORD) {
             m_keys = QStringLiteral("cl");
         } else {
             if (isWORD) {
                 m_keys = QStringLiteral("cE");
             } else {
                 m_keys = QStringLiteral("ce");
             }
         }
     }
 
     if (m_keys[ 0 ] == Qt::Key_QuoteDbl) {
         if (m_keys.size() < 2) {
             return true; // waiting for a register
         } else {
             QChar r = m_keys[ 1 ].toLower();
 
             if ((r >= QLatin1Char('0') && r <= QLatin1Char('9')) || (r >= QLatin1Char('a') && r <= QLatin1Char('z')) ||
                     r == QLatin1Char('_') || r == QLatin1Char('+') || r == QLatin1Char('*') || r == QLatin1Char('#') || r == QLatin1Char('^')) {
                 m_register = r;
                 m_keys.clear();
                 return true;
             } else {
                 resetParser();
                 return true;
             }
         }
     }
 
     // if we have any matching commands so far, check which ones still match
     if (!m_matchingCommands.isEmpty()) {
         int n = m_matchingCommands.size() - 1;
 
         // remove commands not matching anymore
         for (int i = n; i >= 0; i--) {
             if (!m_commands.at(m_matchingCommands.at(i))->matches(m_keys)) {
                 if (m_commands.at(m_matchingCommands.at(i))->needsMotion()) {
                     // "cache" command needing a motion for later
                     m_motionOperatorIndex = m_matchingCommands.at(i);
                 }
                 m_matchingCommands.remove(i);
             }
         }
 
         // check if any of the matching commands need a motion/text object, if so
         // push the current command length to m_awaitingMotionOrTextObject so one
         // knows where to split the command between the operator and the motion
         for (int i = 0; i < m_matchingCommands.size(); i++) {
             if (m_commands.at(m_matchingCommands.at(i))->needsMotion()) {
                 m_awaitingMotionOrTextObject.push(m_keys.size());
                 break;
             }
         }
     } else {
         // go through all registered commands and put possible matches in m_matchingCommands
         for (int i = 0; i < m_commands.size(); i++) {
             if (m_commands.at(i)->matches(m_keys)) {
                 m_matchingCommands.push_back(i);
                 if (m_commands.at(i)->needsMotion() && m_commands.at(i)->pattern().length() == m_keys.size()) {
                     m_awaitingMotionOrTextObject.push(m_keys.size());
                 }
             }
         }
     }
 
     // this indicates where in the command string one should start looking for a motion command
     int checkFrom = (m_awaitingMotionOrTextObject.isEmpty() ? 0 : m_awaitingMotionOrTextObject.top());
 
     // Use operator-pending caret when reading a motion for an operator
     // in normal mode. We need to check that we are indeed in normal mode
     // since visual mode inherits from it.
     if (m_viInputModeManager->getCurrentViMode() == ViMode::NormalMode &&
             !m_awaitingMotionOrTextObject.isEmpty()) {
         m_viInputModeManager->inputAdapter()->setCaretStyle(KateRenderer::Half);
     }
 
     // look for matching motion commands from position 'checkFrom'
     // FIXME: if checkFrom hasn't changed, only motions whose index is in
     // m_matchingMotions should be checked
     bool motionExecuted = false;
     if (checkFrom < m_keys.size()) {
         for (int i = 0; i < m_motions.size(); i++) {
             if (m_motions.at(i)->matches(m_keys.mid(checkFrom))) {
                 m_lastMotionWasLinewiseInnerBlock = false;
                 m_matchingMotions.push_back(i);
 
                 // if it matches exact, we have found the motion command to execute
                 if (m_motions.at(i)->matchesExact(m_keys.mid(checkFrom))) {
                     m_currentMotionWasVisualLineUpOrDown = false;
                     motionExecuted = true;
                     if (checkFrom == 0) {
                         // no command given before motion, just move the cursor to wherever
                         // the motion says it should go to
                         Range r = m_motions.at(i)->execute();
                         m_motionCanChangeWholeVisualModeSelection = m_motions.at(i)->canChangeWholeVisualModeSelection();
 
                         // jump over folding regions since we are just moving the cursor
                         int currLine = m_view->cursorPosition().line();
                         int delta = r.endLine - currLine;
                         int vline = m_view->textFolding().lineToVisibleLine(currLine);
                         r.endLine = m_view->textFolding().visibleLineToLine(qMax(vline + delta, 0) /* ensure we have a valid line */);
                         if (r.endLine >= doc()->lines()) {
                             r.endLine = doc()->lines() - 1;
                         }
 
                         // make sure the position is valid before moving the cursor there
                         // TODO: can this be simplified? :/
                         if (r.valid
                                 && r.endLine >= 0
                                 && (r.endLine == 0 || r.endLine <= doc()->lines() - 1)
                                 && r.endColumn >= 0) {
                             if (r.endColumn >= doc()->lineLength(r.endLine)
                                     && doc()->lineLength(r.endLine) > 0) {
                                 r.endColumn = doc()->lineLength(r.endLine) - 1;
                             }
 
                             goToPos(r);
 
                             // in the case of VisualMode we need to remember the motion commands as well.
                             if (!m_viInputModeManager->isAnyVisualMode()) {
                                 m_viInputModeManager->clearCurrentChangeLog();
                             }
                         } else {
                             qCDebug(LOG_KTE) << "Invalid position: (" << r.endLine << "," << r.endColumn << ")";
                         }
 
                         resetParser();
 
                         // if normal mode was started by using Ctrl-O in insert mode,
                         // it's time to go back to insert mode.
                         if (m_viInputModeManager->getTemporaryNormalMode()) {
                             startInsertMode();
                             m_viewInternal->repaint();
                         }
 
                         m_lastMotionWasVisualLineUpOrDown = m_currentMotionWasVisualLineUpOrDown;
 
                         break;
                     } else {
                         // execute the specified command and supply the position returned from
                         // the motion
 
                         m_commandRange = m_motions.at(i)->execute();
                         m_linewiseCommand = m_motions.at(i)->isLineWise();
 
                         // if we didn't get an explicit start position, use the current cursor position
                         if (m_commandRange.startLine == -1) {
                             KTextEditor::Cursor c(m_view->cursorPosition());
                             m_commandRange.startLine = c.line();
                             m_commandRange.startColumn = c.column();
                         }
 
                         // special case: When using the "w" motion in combination with an operator and
                         // the last word moved over is at the end of a line, the end of that word
                         // becomes the end of the operated text, not the first word in the next line.
                         if (m_motions.at(i)->pattern() == QLatin1String("w") || m_motions.at(i)->pattern() == QLatin1String("W")) {
                             if (m_commandRange.endLine != m_commandRange.startLine &&
                                     m_commandRange.endColumn == getFirstNonBlank(m_commandRange.endLine)) {
                                 m_commandRange.endLine--;
                                 m_commandRange.endColumn = doc()->lineLength(m_commandRange.endLine);
                             }
                         }
 
                         m_commandWithMotion = true;
 
                         if (m_commandRange.valid) {
                             executeCommand(m_commands.at(m_motionOperatorIndex));
                         } else {
                             qCDebug(LOG_KTE) << "Invalid range: "
                                               << "from (" << m_commandRange.startLine << "," << m_commandRange.startColumn << ")"
                                               << "to (" << m_commandRange.endLine << "," << m_commandRange.endColumn << ")";
                         }
 
                         if (m_viInputModeManager->getCurrentViMode() == ViMode::NormalMode) {
                             m_viInputModeManager->inputAdapter()->setCaretStyle(KateRenderer::Block);
                         }
                         m_commandWithMotion = false;
                         reset();
                         break;
                     }
                 }
             }
         }
     }
 
     if (this->waitingForRegisterOrCharToSearch()) {
         // If we are waiting for a char to search or a new register,
         // don't translate next character; we need the actual character so that e.g.
         // 'ab' is translated to 'fb' if the mappings 'a' -> 'f' and 'b' -> something else
         // exist.
         m_viInputModeManager->keyMapper()->setDoNotMapNextKeypress();
     }
 
     if (motionExecuted) {
         return true;
     }
 
     // if we have only one match, check if it is a perfect match and if so, execute it
     // if it's not waiting for a motion or a text object
     if (m_matchingCommands.size() == 1) {
         if (m_commands.at(m_matchingCommands.at(0))->matchesExact(m_keys)
                 && !m_commands.at(m_matchingCommands.at(0))->needsMotion()) {
 
             if (m_viInputModeManager->getCurrentViMode() == ViMode::NormalMode) {
                 m_viInputModeManager->inputAdapter()->setCaretStyle(KateRenderer::Block);
             }
 
             Command *cmd = m_commands.at(m_matchingCommands.at(0));
             executeCommand(cmd);
 
             // check if reset() should be called. some commands in visual mode should not end visual mode
             if (cmd->shouldReset()) {
                 reset();
                 m_view->setBlockSelection(false);
             }
             resetParser();
 
             return true;
         }
     } else if (m_matchingCommands.size() == 0 && m_matchingMotions.size() == 0) {
         resetParser();
         // A bit ugly:  we haven't made use of the key event,
         // but don't want "typeable" keypresses (e.g. a, b, 3, etc) to be marked
         // as unused as they will then be added to the document, but we don't
         // want to swallow all keys in case this was a shortcut.
         // So say we made use of it if and only if it was *not* a shortcut.
         return e->type() != QEvent::ShortcutOverride;
     }
 
     m_matchingMotions.clear();
     return true; // TODO - need to check this - it's currently required for making tests pass, but seems odd.
 }
 
 /**
  * (re)set to start configuration. This is done when a command is completed
  * executed or when a command is aborted
  */
 void NormalViMode::resetParser()
 {
     m_keys.clear();
     m_keysVerbatim.clear();
     m_count = 0;
     m_oneTimeCountOverride = -1;
     m_iscounted = false;
     m_countTemp = 0;
     m_register = QChar::Null;
     m_findWaitingForChar = false;
     m_matchingCommands.clear();
     m_matchingMotions.clear();
     m_awaitingMotionOrTextObject.clear();
     m_motionOperatorIndex = 0;
 
     m_commandWithMotion = false;
     m_linewiseCommand = true;
     m_deleteCommand = false;
 
     m_commandShouldKeepSelection = false;
 
     m_currentChangeEndMarker = KTextEditor::Cursor::invalid();
 
     if(m_viInputModeManager->getCurrentViMode() == ViMode::NormalMode) {
         m_viInputModeManager->inputAdapter()->setCaretStyle(KateRenderer::Block);
     }
 }
 
 // reset the command parser
 void NormalViMode::reset()
 {
     resetParser();
     m_commandRange.startLine = -1;
     m_commandRange.startColumn = -1;
 }
 
 void NormalViMode::beginMonitoringDocumentChanges()
 {
     connect(doc(), &KTextEditor::DocumentPrivate::textInserted,
             this, &NormalViMode::textInserted);
     connect(doc(), &KTextEditor::DocumentPrivate::textRemoved,
             this, &NormalViMode::textRemoved);
 }
 
 void NormalViMode::executeCommand(const Command *cmd)
 {
     const ViMode originalViMode = m_viInputModeManager->getCurrentViMode();
 
     cmd->execute();
 
     // if normal mode was started by using Ctrl-O in insert mode,
     // it's time to go back to insert mode.
     if (m_viInputModeManager->getTemporaryNormalMode()) {
         startInsertMode();
         m_viewInternal->repaint();
     }
 
     // if the command was a change, and it didn't enter insert mode, store the key presses so that
     // they can be repeated with '.'
     if (m_viInputModeManager->getCurrentViMode() != ViMode::InsertMode &&
         m_viInputModeManager->getCurrentViMode() != ViMode::ReplaceMode) {
         if (cmd->isChange() && !m_viInputModeManager->lastChangeRecorder()->isReplaying()) {
             m_viInputModeManager->storeLastChangeCommand();
         }
 
         // when we transition to visual mode, remember the command in the keys history (V, v, ctrl-v, ...)
         // this will later result in buffer filled with something like this "Vjj>" which we can use later with repeat "."
         const bool commandSwitchedToVisualMode = ((originalViMode == ViMode::NormalMode) && m_viInputModeManager->isAnyVisualMode());
         if (!commandSwitchedToVisualMode) {
             m_viInputModeManager->clearCurrentChangeLog();
         }
     }
 
     // make sure the cursor does not end up after the end of the line
     KTextEditor::Cursor c(m_view->cursorPosition());
     if (m_viInputModeManager->getCurrentViMode() == ViMode::NormalMode) {
         int lineLength = doc()->lineLength(c.line());
 
         if (c.column() >= lineLength) {
             if (lineLength == 0) {
                 c.setColumn(0);
             } else {
                 c.setColumn(lineLength - 1);
             }
         }
         updateCursor(c);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // COMMANDS AND OPERATORS
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * enter insert mode at the cursor position
  */
 
 bool NormalViMode::commandEnterInsertMode()
 {
     m_stickyColumn = -1;
     m_viInputModeManager->getViInsertMode()->setCount(getCount());
     return startInsertMode();
 }
 
 /**
  * enter insert mode after the current character
  */
 
 bool NormalViMode::commandEnterInsertModeAppend()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     c.setColumn(c.column() + 1);
 
     // if empty line, the cursor should start at column 0
     if (doc()->lineLength(c.line()) == 0) {
         c.setColumn(0);
     }
 
     // cursor should never be in a column > number of columns
     if (c.column() > doc()->lineLength(c.line())) {
         c.setColumn(doc()->lineLength(c.line()));
     }
 
     updateCursor(c);
 
     m_stickyColumn = -1;
     m_viInputModeManager->getViInsertMode()->setCount(getCount());
     return startInsertMode();
 }
 
 /**
  * start insert mode after the last character of the line
  */
 
 bool NormalViMode::commandEnterInsertModeAppendEOL()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     c.setColumn(doc()->lineLength(c.line()));
     updateCursor(c);
 
     m_stickyColumn = -1;
     m_viInputModeManager->getViInsertMode()->setCount(getCount());
     return startInsertMode();
 }
 
 bool NormalViMode::commandEnterInsertModeBeforeFirstNonBlankInLine()
 {
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     int c = getFirstNonBlank();
 
     cursor.setColumn(c);
     updateCursor(cursor);
 
     m_stickyColumn = -1;
     m_viInputModeManager->getViInsertMode()->setCount(getCount());
     return startInsertMode();
 }
 
 /**
  * enter insert mode at the last insert position
  */
 
 bool NormalViMode::commandEnterInsertModeLast()
 {
     KTextEditor::Cursor c = m_viInputModeManager->marks()->getInsertStopped();
     if (c.isValid()) {
         updateCursor(c);
     }
 
     m_stickyColumn = -1;
     return startInsertMode();
 }
 
 bool NormalViMode::commandEnterVisualLineMode()
 {
     if (m_viInputModeManager->getCurrentViMode() == VisualLineMode) {
         reset();
         return true;
     }
 
     return startVisualLineMode();
 }
 
 bool NormalViMode::commandEnterVisualBlockMode()
 {
     if (m_viInputModeManager->getCurrentViMode() == VisualBlockMode) {
         reset();
         return true;
     }
 
     return startVisualBlockMode();
 }
 
 bool NormalViMode::commandReselectVisual()
 {
     // start last visual mode and set start = `< and cursor = `>
     KTextEditor::Cursor c1 = m_viInputModeManager->marks()->getSelectionStart();
     KTextEditor::Cursor c2 = m_viInputModeManager->marks()->getSelectionFinish();
 
     // we should either get two valid cursors or two invalid cursors
     Q_ASSERT(c1.isValid() == c2.isValid());
 
     if (c1.isValid() && c2.isValid()) {
         m_viInputModeManager->getViVisualMode()->setStart(c1);
         bool returnValue = false;
 
         switch (m_viInputModeManager->getViVisualMode()->getLastVisualMode()) {
         case ViMode::VisualMode:
             returnValue = commandEnterVisualMode();
             break;
         case ViMode::VisualLineMode:
             returnValue = commandEnterVisualLineMode();
             break;
         case ViMode::VisualBlockMode:
             returnValue = commandEnterVisualBlockMode();
             break;
         default:
             Q_ASSERT("invalid visual mode");
         }
         m_viInputModeManager->getViVisualMode()->goToPos(c2);
         return returnValue;
     } else {
         error(QStringLiteral("No previous visual selection"));
     }
 
     return false;
 }
 
 bool NormalViMode::commandEnterVisualMode()
 {
     if (m_viInputModeManager->getCurrentViMode() == ViMode::VisualMode) {
         reset();
         return true;
     }
 
     return startVisualMode();
 }
 
 bool NormalViMode::commandToOtherEnd()
 {
     if (m_viInputModeManager->isAnyVisualMode()) {
         m_viInputModeManager->getViVisualMode()->switchStartEnd();
         return true;
     }
 
     return false;
 }
 
 bool NormalViMode::commandEnterReplaceMode()
 {
     m_stickyColumn = -1;
     m_viInputModeManager->getViReplaceMode()->setCount(getCount());
     return startReplaceMode();
 }
 
 bool NormalViMode::commandDeleteLine()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     Range r;
 
     r.startLine = c.line();
     r.endLine = c.line() + getCount() - 1;
 
     int column = c.column();
 
     bool ret = deleteRange(r, LineWise);
 
     c = m_view->cursorPosition();
     if (column > doc()->lineLength(c.line()) - 1) {
         column = doc()->lineLength(c.line()) - 1;
     }
     if (column < 0) {
         column = 0;
     }
 
     if (c.line() > doc()->lines() - 1) {
         c.setLine(doc()->lines() - 1);
     }
 
     c.setColumn(column);
     m_stickyColumn = -1;
     updateCursor(c);
 
     m_deleteCommand = true;
     return ret;
 }
 
 bool NormalViMode::commandDelete()
 {
     m_deleteCommand = true;
     return deleteRange(m_commandRange, getOperationMode());
 }
 
 bool NormalViMode::commandDeleteToEOL()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     OperationMode m = CharWise;
 
     m_commandRange.endColumn = KateVi::EOL;
     switch (m_viInputModeManager->getCurrentViMode()) {
     case ViMode::NormalMode:
         m_commandRange.startLine = c.line();
         m_commandRange.startColumn = c.column();
         m_commandRange.endLine = c.line() + getCount() - 1;
         break;
     case ViMode::VisualMode:
     case ViMode::VisualLineMode:
         m = LineWise;
         break;
     case ViMode::VisualBlockMode:
         m_commandRange.normalize();
         m = Block;
         break;
     default:
         /* InsertMode and ReplaceMode will never call this method. */
         Q_ASSERT(false);
     }
 
     bool r = deleteRange(m_commandRange, m);
 
     switch (m) {
     case CharWise:
         c.setColumn(doc()->lineLength(c.line()) - 1);
         break;
     case LineWise:
         c.setLine(m_commandRange.startLine);
         c.setColumn(getFirstNonBlank(qMin(doc()->lastLine(),
                                           m_commandRange.startLine)));
         break;
     case Block:
         c.setLine(m_commandRange.startLine);
         c.setColumn(m_commandRange.startColumn - 1);
         break;
     }
 
     // make sure cursor position is valid after deletion
     if (c.line() < 0) {
         c.setLine(0);
     }
     if (c.line() > doc()->lastLine()) {
         c.setLine(doc()->lastLine());
     }
     if (c.column() > doc()->lineLength(c.line()) - 1) {
         c.setColumn(doc()->lineLength(c.line()) - 1);
     }
     if (c.column() < 0) {
         c.setColumn(0);
     }
 
     updateCursor(c);
 
     m_deleteCommand = true;
     return r;
 }
 
 bool NormalViMode::commandMakeLowercase()
 {
     KTextEditor::Cursor c = m_view->cursorPosition();
 
     OperationMode m = getOperationMode();
     QString text = getRange(m_commandRange, m);
     if (m == LineWise) {
         text = text.left(text.size() - 1);    // don't need '\n' at the end;
     }
     QString lowerCase = text.toLower();
 
     m_commandRange.normalize();
     KTextEditor::Cursor start(m_commandRange.startLine, m_commandRange.startColumn);
     KTextEditor::Cursor end(m_commandRange.endLine, m_commandRange.endColumn);
     KTextEditor::Range range(start, end);
 
     doc()->replaceText(range, lowerCase, m == Block);
 
     if (m_viInputModeManager->getCurrentViMode() == ViMode::NormalMode) {
         updateCursor(start);
     } else {
         updateCursor(c);
     }
 
     return true;
 }
 
 bool NormalViMode::commandMakeLowercaseLine()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     if (doc()->lineLength(c.line()) == 0) {
         // Nothing to do.
         return true;
     }
 
     m_commandRange.startLine = c.line();
     m_commandRange.endLine = c.line() + getCount() - 1;
     m_commandRange.startColumn = 0;
     m_commandRange.endColumn = doc()->lineLength(c.line()) - 1;
 
     return commandMakeLowercase();
 }
 
 bool NormalViMode::commandMakeUppercase()
 {
     if (!m_commandRange.valid) {
         return false;
     }
     KTextEditor::Cursor c = m_view->cursorPosition();
     OperationMode m = getOperationMode();
     QString text = getRange(m_commandRange, m);
     if (m == LineWise) {
         text = text.left(text.size() - 1);    // don't need '\n' at the end;
     }
     QString upperCase = text.toUpper();
 
     m_commandRange.normalize();
     KTextEditor::Cursor start(m_commandRange.startLine, m_commandRange.startColumn);
     KTextEditor::Cursor end(m_commandRange.endLine, m_commandRange.endColumn);
     KTextEditor::Range range(start, end);
 
     doc()->replaceText(range, upperCase, m == Block);
     if (m_viInputModeManager->getCurrentViMode() == ViMode::NormalMode) {
         updateCursor(start);
     } else {
         updateCursor(c);
     }
 
     return true;
 }
 
 bool NormalViMode::commandMakeUppercaseLine()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     if (doc()->lineLength(c.line()) == 0) {
         // Nothing to do.
         return true;
     }
 
     m_commandRange.startLine = c.line();
     m_commandRange.endLine = c.line() + getCount() - 1;
     m_commandRange.startColumn = 0;
     m_commandRange.endColumn = doc()->lineLength(c.line()) - 1;
 
     return commandMakeUppercase();
 }
 
 bool NormalViMode::commandChangeCase()
 {
     switchView();
     QString text;
     KTextEditor::Range range;
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     // in visual mode, the range is from start position to end position...
     if (m_viInputModeManager->getCurrentViMode() == ViMode::VisualMode
             || m_viInputModeManager->getCurrentViMode() == ViMode::VisualBlockMode) {
         KTextEditor::Cursor c2 = m_viInputModeManager->getViVisualMode()->getStart();
 
         if (c2 > c) {
             c2.setColumn(c2.column() + 1);
         } else {
             c.setColumn(c.column() + 1);
         }
 
         range.setRange(c, c2);
         // ... in visual line mode, the range is from column 0 on the first line to
         // the line length of the last line...
     } else if (m_viInputModeManager->getCurrentViMode() == ViMode::VisualLineMode) {
         KTextEditor::Cursor c2 = m_viInputModeManager->getViVisualMode()->getStart();
 
         if (c2 > c) {
             c2.setColumn(doc()->lineLength(c2.line()));
             c.setColumn(0);
         } else {
             c.setColumn(doc()->lineLength(c.line()));
             c2.setColumn(0);
         }
 
         range.setRange(c, c2);
         // ... and in normal mode the range is from the current position to the
         // current position + count
     } else {
         KTextEditor::Cursor c2 = c;
         c2.setColumn(c.column() + getCount());
 
         if (c2.column() > doc()->lineLength(c.line())) {
             c2.setColumn(doc()->lineLength(c.line()));
         }
 
         range.setRange(c, c2);
     }
 
     bool block = m_viInputModeManager->getCurrentViMode() == ViMode::VisualBlockMode;
 
     // get the text the command should operate on
     text = doc()->text(range, block);
 
     // for every character, switch its case
     for (int i = 0; i < text.length(); i++) {
         if (text.at(i).isUpper()) {
             text[i] = text.at(i).toLower();
         } else if (text.at(i).isLower()) {
             text[i] = text.at(i).toUpper();
         }
     }
 
     // replace the old text with the modified text
     doc()->replaceText(range, text, block);
 
     // in normal mode, move the cursor to the right, in visual mode move the
     // cursor to the start of the selection
     if (m_viInputModeManager->getCurrentViMode() == ViMode::NormalMode) {
         updateCursor(range.end());
     } else {
         updateCursor(range.start());
     }
 
     return true;
 }
 
 bool NormalViMode::commandChangeCaseRange()
 {
     OperationMode m = getOperationMode();
     QString changedCase = getRange(m_commandRange, m);
     if (m == LineWise) {
         changedCase = changedCase.left(changedCase.size() - 1);    // don't need '\n' at the end;
     }
     KTextEditor::Range range = KTextEditor::Range(m_commandRange.startLine, m_commandRange.startColumn, m_commandRange.endLine, m_commandRange.endColumn);
     // get the text the command should operate on
     // for every character, switch its case
     for (int i = 0; i < changedCase.length(); i++) {
         if (changedCase.at(i).isUpper()) {
             changedCase[i] = changedCase.at(i).toLower();
         } else if (changedCase.at(i).isLower()) {
             changedCase[i] = changedCase.at(i).toUpper();
         }
     }
     doc()->replaceText(range, changedCase, m == Block);
     return true;
 }
 
 bool NormalViMode::commandChangeCaseLine()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     if (doc()->lineLength(c.line()) == 0) {
         // Nothing to do.
         return true;
     }
 
     m_commandRange.startLine = c.line();
     m_commandRange.endLine = c.line() + getCount() - 1;
     m_commandRange.startColumn = 0;
     m_commandRange.endColumn = doc()->lineLength(c.line()) - 1; // -1 is for excluding '\0'
 
     if (!commandChangeCaseRange()) {
         return false;
     }
 
     KTextEditor::Cursor start(m_commandRange.startLine, m_commandRange.startColumn);
     if (getCount() > 1) {
         updateCursor(c);
     } else {
         updateCursor(start);
     }
     return true;
 
 }
 
 bool NormalViMode::commandOpenNewLineUnder()
 {
     doc()->setUndoMergeAllEdits(true);
 
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     c.setColumn(doc()->lineLength(c.line()));
     updateCursor(c);
 
     doc()->newLine(m_view);
 
     m_stickyColumn = -1;
     startInsertMode();
     m_viInputModeManager->getViInsertMode()->setCount(getCount());
     m_viInputModeManager->getViInsertMode()->setCountedRepeatsBeginOnNewLine(true);
 
     return true;
 }
 
 bool NormalViMode::commandOpenNewLineOver()
 {
     doc()->setUndoMergeAllEdits(true);
 
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     if (c.line() == 0) {
         doc()->insertLine(0, QString());
         c.setColumn(0);
         c.setLine(0);
         updateCursor(c);
     } else {
         c.setLine(c.line() - 1);
         c.setColumn(getLine(c.line()).length());
         updateCursor(c);
         doc()->newLine(m_view);
     }
 
     m_stickyColumn = -1;
     startInsertMode();
     m_viInputModeManager->getViInsertMode()->setCount(getCount());
     m_viInputModeManager->getViInsertMode()->setCountedRepeatsBeginOnNewLine(true);
 
     return true;
 }
 
 bool NormalViMode::commandJoinLines()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     unsigned int from = c.line();
     unsigned int to = c.line() + ((getCount() == 1) ? 1 : getCount() - 1);
 
     // if we were given a range of lines, this information overrides the previous
     if (m_commandRange.startLine != -1 && m_commandRange.endLine != -1) {
         m_commandRange.normalize();
         c.setLine(m_commandRange.startLine);
         from = m_commandRange.startLine;
         to = m_commandRange.endLine;
     }
 
     if (to >= (unsigned int)doc()->lines()) {
         return false;
     }
 
     bool nonEmptyLineFound = false;
     for (unsigned int lineNum = from; lineNum <= to; lineNum++) {
         if (!doc()->line(lineNum).isEmpty()) {
             nonEmptyLineFound = true;
         }
     }
 
     const int firstNonWhitespaceOnLastLine = doc()->kateTextLine(to)->firstChar();
     QString leftTrimmedLastLine;
     if (firstNonWhitespaceOnLastLine != -1) {
         leftTrimmedLastLine = doc()->line(to).mid(firstNonWhitespaceOnLastLine);
     }
 
     joinLines(from, to);
 
     if (nonEmptyLineFound && leftTrimmedLastLine.isEmpty()) {
         // joinLines won't have added a trailing " ", whereas Vim does - follow suit.
         doc()->insertText(KTextEditor::Cursor(from, doc()->lineLength(from)), QLatin1String(" "));
     }
 
     // Position cursor just before first non-whitesspace character of what was the last line joined.
     c.setColumn(doc()->lineLength(from) - leftTrimmedLastLine.length() - 1);
     if (c.column() >= 0) {
         updateCursor(c);
     }
 
     m_deleteCommand = true;
     return true;
 }
 
 bool NormalViMode::commandChange()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     OperationMode m = getOperationMode();
 
     doc()->setUndoMergeAllEdits(true);
 
     commandDelete();
 
     if (m == LineWise) {
         // if we deleted several lines, insert an empty line and put the cursor there.
         doc()->insertLine(m_commandRange.startLine, QString());
         c.setLine(m_commandRange.startLine);
         c.setColumn(0);
     } else if (m == Block) {
         // block substitute can be simulated by first deleting the text
         // (done above) and then starting block prepend.
         return commandPrependToBlock();
     } else {
         if (m_commandRange.startLine < m_commandRange.endLine) {
             c.setLine(m_commandRange.startLine);
         }
         c.setColumn(m_commandRange.startColumn);
     }
 
     updateCursor(c);
     setCount(0); // The count was for the motion, not the insertion.
     commandEnterInsertMode();
 
     // correct indentation level
     if (m == LineWise) {
         m_view->align();
     }
 
     m_deleteCommand = true;
     return true;
 }
 
 bool NormalViMode::commandChangeToEOL()
 {
     commandDeleteToEOL();
 
     if (getOperationMode() == Block) {
         return commandPrependToBlock();
     }
 
     m_deleteCommand = true;
     return commandEnterInsertModeAppend();
 }
 
 bool NormalViMode::commandChangeLine()
 {
     m_deleteCommand = true;
     KTextEditor::Cursor c(m_view->cursorPosition());
     c.setColumn(0);
     updateCursor(c);
 
     doc()->setUndoMergeAllEdits(true);
 
     // if count >= 2 start by deleting the whole lines
     if (getCount() >= 2) {
         Range r(c.line(), 0, c.line() + getCount() - 2, 0, InclusiveMotion);
         deleteRange(r);
     }
 
     // ... then delete the _contents_ of the last line, but keep the line
     Range r(c.line(), c.column(), c.line(), doc()->lineLength(c.line()) - 1,
                   InclusiveMotion);
     deleteRange(r, CharWise, true);
 
     // ... then enter insert mode
     if (getOperationMode() == Block) {
         return commandPrependToBlock();
     }
     commandEnterInsertModeAppend();
 
     // correct indentation level
     m_view->align();
 
     return true;
 }
 
 bool NormalViMode::commandSubstituteChar()
 {
     if (commandDeleteChar()) {
         // The count is only used for deletion of chars; the inserted text is not repeated
         setCount(0);
         return commandEnterInsertMode();
     }
 
     m_deleteCommand = true;
     return false;
 }
 
 bool NormalViMode::commandSubstituteLine()
 {
     m_deleteCommand = true;
     return commandChangeLine();
 }
 
 bool NormalViMode::commandYank()
 {
     bool r = false;
     QString yankedText;
 
     OperationMode m = getOperationMode();
     yankedText = getRange(m_commandRange, m);
 
     highlightYank(m_commandRange, m);
 
     QChar  chosen_register =  getChosenRegister(ZeroRegister);
     fillRegister(chosen_register, yankedText, m);
     yankToClipBoard(chosen_register, yankedText);
 
     return r;
 }
 
 bool NormalViMode::commandYankLine()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     QString lines;
     int linenum = c.line();
 
     for (int i = 0; i < getCount(); i++) {
         lines.append(getLine(linenum + i) + QLatin1Char('\n'));
     }
 
     Range yankRange(linenum, 0, linenum + getCount() - 1, getLine(linenum + getCount() - 1).length(), InclusiveMotion);
     highlightYank(yankRange);
 
     QChar  chosen_register =  getChosenRegister(ZeroRegister);
     fillRegister(chosen_register, lines, LineWise);
     yankToClipBoard(chosen_register, lines);
 
     return true;
 }
 
 bool NormalViMode::commandYankToEOL()
 {
     OperationMode m = CharWise;
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     MotionType motion = m_commandRange.motionType;
     m_commandRange.endLine = c.line() + getCount() - 1;
     m_commandRange.endColumn = doc()->lineLength(m_commandRange.endLine) - 1;
     m_commandRange.motionType = InclusiveMotion;
 
     switch (m_viInputModeManager->getCurrentViMode()) {
     case ViMode::NormalMode:
         m_commandRange.startLine = c.line();
         m_commandRange.startColumn = c.column();
         break;
     case ViMode::VisualMode:
     case ViMode::VisualLineMode:
         m = LineWise;
         {
             VisualViMode *visual = static_cast<VisualViMode *>(this);
             visual->setStart(KTextEditor::Cursor(visual->getStart().line(), 0));
         }
         break;
     case ViMode::VisualBlockMode:
         m = Block;
         break;
     default:
         /* InsertMode and ReplaceMode will never call this method. */
         Q_ASSERT(false);
     }
 
     const QString &yankedText = getRange(m_commandRange, m);
     m_commandRange.motionType = motion;
     highlightYank(m_commandRange);
 
     QChar chosen_register =  getChosenRegister(ZeroRegister);
     fillRegister(chosen_register,  yankedText, m);
     yankToClipBoard(chosen_register, yankedText);
 
     return true;
 }
 
 // Insert the text in the given register after the cursor position.
 // This is the non-g version of paste, so the cursor will usually
 // end up on the last character of the pasted text, unless the text
 // was multi-line or linewise in which case it will end up
 // on the *first* character of the pasted text(!)
 // If linewise, will paste after the current line.
 bool NormalViMode::commandPaste()
 {
     return paste(AfterCurrentPosition, false, false);
 }
 
 // As with commandPaste, except that the text is pasted *at* the cursor position
 bool NormalViMode::commandPasteBefore()
 {
     return paste(AtCurrentPosition, false, false);
 }
 
 // As with commandPaste, except that the cursor will generally be placed *after* the
 // last pasted character (assuming the last pasted character is not at  the end of the line).
 // If linewise, cursor will be at the beginning of the line *after* the last line of pasted text,
 // unless that line is the last line of the document; then it will be placed at the beginning of the
 // last line pasted.
 bool NormalViMode::commandgPaste()
 {
     return paste(AfterCurrentPosition, true, false);
 }
 
 // As with commandgPaste, except that it pastes *at* the current cursor position or, if linewise,
 // at the current line.
 bool NormalViMode::commandgPasteBefore()
 {
     return paste(AtCurrentPosition, true, false);
 }
 
 bool NormalViMode::commandIndentedPaste()
 {
     return paste(AfterCurrentPosition, false, true);
 }
 
 bool NormalViMode::commandIndentedPasteBefore()
 {
     return paste(AtCurrentPosition, false, true);
 }
 
 bool NormalViMode::commandDeleteChar()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c.line(), c.column(), c.line(), c.column() + getCount(), ExclusiveMotion);
 
     if (m_commandRange.startLine != -1 && m_commandRange.startColumn != -1) {
         r = m_commandRange;
     } else {
         if (r.endColumn > doc()->lineLength(r.startLine)) {
             r.endColumn = doc()->lineLength(r.startLine);
         }
     }
 
     // should delete entire lines if in visual line mode and selection in visual block mode
     OperationMode m = CharWise;
     if (m_viInputModeManager->getCurrentViMode() == VisualLineMode) {
         m = LineWise;
     } else if (m_viInputModeManager->getCurrentViMode() == VisualBlockMode) {
         m = Block;
     }
 
     m_deleteCommand = true;
     return deleteRange(r, m);
 }
 
 bool NormalViMode::commandDeleteCharBackward()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     Range r(c.line(), c.column() - getCount(), c.line(), c.column(), ExclusiveMotion);
 
     if (m_commandRange.startLine != -1 && m_commandRange.startColumn != -1) {
         r = m_commandRange;
     } else {
         if (r.startColumn < 0) {
             r.startColumn = 0;
         }
     }
 
     // should delete entire lines if in visual line mode and selection in visual block mode
     OperationMode m = CharWise;
     if (m_viInputModeManager->getCurrentViMode() == VisualLineMode) {
         m = LineWise;
     } else if (m_viInputModeManager->getCurrentViMode() == VisualBlockMode) {
         m = Block;
     }
 
     m_deleteCommand = true;
     return deleteRange(r, m);
 }
 
 bool NormalViMode::commandReplaceCharacter()
 {
     QString key = KeyParser::self()->decodeKeySequence(m_keys.right(1));
 
     // Filter out some special keys.
     const int keyCode = KeyParser::self()->encoded2qt(m_keys.right(1));
     switch (keyCode) {
         case Qt::Key_Left: case Qt::Key_Right: case Qt::Key_Up:
         case Qt::Key_Down: case Qt::Key_Home: case Qt::Key_End:
         case Qt::Key_PageUp: case Qt::Key_PageDown: case Qt::Key_Delete:
         case Qt::Key_Insert: case Qt::Key_Backspace: case Qt::Key_CapsLock:
             return true;
         case Qt::Key_Return: case Qt::Key_Enter:
             key = QStringLiteral("\n");
     }
 
     bool r;
     if (m_viInputModeManager->isAnyVisualMode()) {
 
         OperationMode m = getOperationMode();
         QString text = getRange(m_commandRange, m);
 
         if (m == LineWise) {
             text = text.left(text.size() - 1);    // don't need '\n' at the end;
         }
 
         text.replace(QRegExp(QLatin1String("[^\n]")), key);
 
         m_commandRange.normalize();
         KTextEditor::Cursor start(m_commandRange.startLine, m_commandRange.startColumn);
         KTextEditor::Cursor end(m_commandRange.endLine, m_commandRange.endColumn);
         KTextEditor::Range range(start, end);
 
         r = doc()->replaceText(range, text, m == Block);
 
     } else {
         KTextEditor::Cursor c1(m_view->cursorPosition());
         KTextEditor::Cursor c2(m_view->cursorPosition());
 
         c2.setColumn(c2.column() + getCount());
 
         if (c2.column() > doc()->lineLength(m_view->cursorPosition().line())) {
             return false;
         }
 
         r = doc()->replaceText(KTextEditor::Range(c1, c2), key.repeated(getCount()));
         updateCursor(c1);
 
     }
     return r;
 }
 
 bool NormalViMode::commandSwitchToCmdLine()
 {
     QString initialText;
     if (m_viInputModeManager->isAnyVisualMode()) {
         // if in visual mode, make command range == visual selection
         m_viInputModeManager->getViVisualMode()->saveRangeMarks();
         initialText = QStringLiteral("'<,'>");
     } else if (getCount() != 1) {
         // if a count is given, the range [current line] to [current line] +
         // count should be prepended to the command line
         initialText = QLatin1String(".,.+") + QString::number(getCount() - 1);
     }
 
     m_viInputModeManager->inputAdapter()->showViModeEmulatedCommandBar();
     m_viInputModeManager->inputAdapter()->viModeEmulatedCommandBar()->init(EmulatedCommandBar::Command, initialText);
 
     m_commandShouldKeepSelection = true;
 
     return true;
 }
 
 bool NormalViMode::commandSearchBackward()
 {
     m_viInputModeManager->inputAdapter()->showViModeEmulatedCommandBar();
     m_viInputModeManager->inputAdapter()->viModeEmulatedCommandBar()->init(EmulatedCommandBar::SearchBackward);
     return true;
 }
 
 bool NormalViMode::commandSearchForward()
 {
     m_viInputModeManager->inputAdapter()->showViModeEmulatedCommandBar();
     m_viInputModeManager->inputAdapter()->viModeEmulatedCommandBar()->init(EmulatedCommandBar::SearchForward);
     return true;
 }
 
 bool NormalViMode::commandUndo()
 {
     // See BUG #328277
     m_viInputModeManager->clearCurrentChangeLog();
 
     if (doc()->undoCount() > 0) {
         const bool mapped = m_viInputModeManager->keyMapper()->isExecutingMapping();
 
         if (mapped)
             doc()->editEnd();
         doc()->undo();
         if (mapped)
             doc()->editBegin();
         if (m_viInputModeManager->isAnyVisualMode()) {
             m_viInputModeManager->getViVisualMode()->setStart(KTextEditor::Cursor(-1, -1));
             m_view->clearSelection();
             startNormalMode();
         }
         return true;
     }
     return false;
 }
 
 bool NormalViMode::commandRedo()
 {
     if (doc()->redoCount() > 0) {
         const bool mapped = m_viInputModeManager->keyMapper()->isExecutingMapping();
 
         if (mapped)
             doc()->editEnd();
         doc()->redo();
         if (mapped)
             doc()->editBegin();
         if (m_viInputModeManager->isAnyVisualMode()) {
             m_viInputModeManager->getViVisualMode()->setStart(KTextEditor::Cursor(-1, -1));
             m_view->clearSelection();
             startNormalMode();
         }
         return true;
     }
     return false;
 }
 
 bool NormalViMode::commandSetMark()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     QChar mark = m_keys.at(m_keys.size() - 1);
     m_viInputModeManager->marks()->setUserMark(mark, c);
 
     return true;
 }
 
 bool NormalViMode::commandIndentLine()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     doc()->indent(KTextEditor::Range(c.line(), 0, c.line() + getCount(), 0), 1);
 
     return true;
 }
 
 bool NormalViMode::commandUnindentLine()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     doc()->indent(KTextEditor::Range(c.line(), 0, c.line() + getCount(), 0), -1);
 
     return true;
 }
 
 bool NormalViMode::commandIndentLines()
 {
     const bool downwards = m_commandRange.startLine < m_commandRange.endLine;
 
     m_commandRange.normalize();
 
     int line1 = m_commandRange.startLine;
     int line2 = m_commandRange.endLine;
     int col = getLine(line2).length();
     doc()->indent(KTextEditor::Range(line1, 0, line2, col), getCount());
 
     if (downwards) {
         updateCursor(KTextEditor::Cursor(m_commandRange.startLine, m_commandRange.startColumn));
     } else {
         updateCursor(KTextEditor::Cursor(m_commandRange.endLine, m_commandRange.endColumn));
     }
     return true;
 }
 
 bool NormalViMode::commandUnindentLines()
 {
     const bool downwards = m_commandRange.startLine < m_commandRange.endLine;
 
     m_commandRange.normalize();
 
     int line1 = m_commandRange.startLine;
     int line2 = m_commandRange.endLine;
 
     doc()->indent(KTextEditor::Range(line1, 0, line2, doc()->lineLength(line2)), -getCount());
 
     if (downwards) {
         updateCursor(KTextEditor::Cursor(m_commandRange.startLine, m_commandRange.startColumn));
     } else {
         updateCursor(KTextEditor::Cursor(m_commandRange.endLine, m_commandRange.endColumn));
     }
     return true;
 }
 
 bool NormalViMode::commandScrollPageDown()
 {
     if (getCount() < m_scroll_count_limit) {
 
         for (int i = 0; i < getCount(); i++) {
             m_view->pageDown();
         }
     }
     return true;
 }
 
 bool NormalViMode::commandScrollPageUp()
 {
     if (getCount() < m_scroll_count_limit) {
         for (int i = 0; i < getCount(); i++) {
             m_view->pageUp();
         }
     }
     return true;
 
 }
 
 bool NormalViMode::commandScrollHalfPageUp()
 {
     if (getCount() < m_scroll_count_limit) {
         for (int i = 0; i < getCount(); i++) {
             m_viewInternal->pageUp(false, true);
         }
     }
     return true;
 }
 
 bool NormalViMode::commandScrollHalfPageDown()
 {
     if (getCount() < m_scroll_count_limit) {
         for (int i = 0; i < getCount(); i++) {
             m_viewInternal->pageDown(false, true);
         }
     }
     return true;
 }
 
 bool NormalViMode::commandCenterView(bool onFirst)
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     const int virtualCenterLine = m_viewInternal->startLine() + linesDisplayed() / 2;
     const int virtualCursorLine = m_view->textFolding().lineToVisibleLine(c.line());
 
     scrollViewLines(virtualCursorLine - virtualCenterLine);
     if (onFirst) {
         c.setColumn(getFirstNonBlank());
         updateCursor(c);
     }
     return true;
 }
 
 bool NormalViMode::commandCenterViewOnNonBlank()
 {
     return commandCenterView(true);
 }
 
 bool NormalViMode::commandCenterViewOnCursor()
 {
     return commandCenterView(false);
 }
 
 bool NormalViMode::commandTopView(bool onFirst)
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     const int virtualCenterLine = m_viewInternal->startLine();
     const int virtualCursorLine = m_view->textFolding().lineToVisibleLine(c.line());
 
     scrollViewLines(virtualCursorLine - virtualCenterLine);
     if (onFirst) {
         c.setColumn(getFirstNonBlank());
         updateCursor(c);
     }
     return true;
 }
 
 bool NormalViMode::commandTopViewOnNonBlank()
 {
     return commandTopView(true);
 }
 
 bool NormalViMode::commandTopViewOnCursor()
 {
     return commandTopView(false);
 }
 
 bool NormalViMode::commandBottomView(bool onFirst)
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     const int virtualCenterLine = m_viewInternal->endLine();
     const int virtualCursorLine = m_view->textFolding().lineToVisibleLine(c.line());
 
     scrollViewLines(virtualCursorLine - virtualCenterLine);
     if (onFirst) {
         c.setColumn(getFirstNonBlank());
         updateCursor(c);
     }
     return true;
 }
 
 bool NormalViMode::commandBottomViewOnNonBlank()
 {
     return commandBottomView(true);
 }
 
 bool NormalViMode::commandBottomViewOnCursor()
 {
     return commandBottomView(false);
 }
 
 bool NormalViMode::commandAbort()
 {
     m_pendingResetIsDueToExit = true;
     reset();
     return true;
 }
 
 bool NormalViMode::commandPrintCharacterCode()
 {
     QChar ch = getCharUnderCursor();
 
     if (ch == QChar::Null) {
         message(QStringLiteral("NUL"));
     } else {
 
         int code = ch.unicode();
 
         QString dec = QString::number(code);
         QString hex = QString::number(code, 16);
         QString oct = QString::number(code, 8);
         if (oct.length() < 3) {
             oct.prepend(QLatin1Char('0'));
         }
         if (code > 0x80 && code < 0x1000) {
             hex.prepend((code < 0x100 ? QLatin1String("00") : QLatin1String("0")));
         }
         message(i18n("'%1' %2,  Hex %3,  Octal %4", ch, dec, hex, oct));
     }
 
     return true;
 }
 
 bool NormalViMode::commandRepeatLastChange()
 {
     const int repeatCount = getCount();
     resetParser();
     if (repeatCount > 1) {
         m_oneTimeCountOverride = repeatCount;
     }
     doc()->editStart();
     m_viInputModeManager->repeatLastChange();
     doc()->editEnd();
 
     return true;
 }
 
 bool NormalViMode::commandAlignLine()
 {
     const int line = m_view->cursorPosition().line();
     KTextEditor::Range alignRange(KTextEditor::Cursor(line, 0), KTextEditor::Cursor(line, 0));
 
     doc()->align(m_view, alignRange);
 
     return true;
 }
 
 bool NormalViMode::commandAlignLines()
 {
     m_commandRange.normalize();
 
     KTextEditor::Cursor start(m_commandRange.startLine, 0);
     KTextEditor::Cursor end(m_commandRange.endLine, 0);
 
     doc()->align(m_view, KTextEditor::Range(start, end));
 
     return true;
 }
 
 bool NormalViMode::commandAddToNumber()
 {
     addToNumberUnderCursor(getCount());
 
     return true;
 }
 
 bool NormalViMode::commandSubtractFromNumber()
 {
     addToNumberUnderCursor(-getCount());
 
     return true;
 }
 
 bool NormalViMode::commandPrependToBlock()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     // move cursor to top left corner of selection
     m_commandRange.normalize();
     c.setColumn(m_commandRange.startColumn);
     c.setLine(m_commandRange.startLine);
     updateCursor(c);
 
     m_stickyColumn = -1;
     m_viInputModeManager->getViInsertMode()->setBlockPrependMode(m_commandRange);
     return startInsertMode();
 }
 
 bool NormalViMode::commandAppendToBlock()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     m_commandRange.normalize();
     if (m_stickyColumn == (unsigned int)KateVi::EOL) {   // append to EOL
         // move cursor to end of first line
         c.setLine(m_commandRange.startLine);
         c.setColumn(doc()->lineLength(c.line()));
         updateCursor(c);
         m_viInputModeManager->getViInsertMode()->setBlockAppendMode(m_commandRange, AppendEOL);
     } else {
         m_viInputModeManager->getViInsertMode()->setBlockAppendMode(m_commandRange, Append);
         // move cursor to top right corner of selection
         c.setColumn(m_commandRange.endColumn + 1);
         c.setLine(m_commandRange.startLine);
         updateCursor(c);
     }
 
     m_stickyColumn = -1;
 
     return startInsertMode();
 }
 
 bool NormalViMode::commandGoToNextJump()
 {
     KTextEditor::Cursor c = getNextJump(m_view->cursorPosition());
     updateCursor(c);
 
     return true;
 }
 
 bool NormalViMode::commandGoToPrevJump()
 {
     KTextEditor::Cursor c = getPrevJump(m_view->cursorPosition());
     updateCursor(c);
 
     return true;
 }
 
 bool NormalViMode::commandSwitchToLeftView()
 {
     switchView(Left);
     return true;
 }
 
 bool NormalViMode::commandSwitchToDownView()
 {
     switchView(Down);
     return true;
 }
 
 bool NormalViMode::commandSwitchToUpView()
 {
     switchView(Up);
     return true;
 }
 
 bool NormalViMode::commandSwitchToRightView()
 {
     switchView(Right);
     return true;
 }
 
 bool NormalViMode::commandSwitchToNextView()
 {
     switchView(Next);
     return true;
 }
 
 bool NormalViMode::commandSplitHoriz()
 {
     return executeKateCommand(QStringLiteral("split"));
 }
 
 bool NormalViMode::commandSplitVert()
 {
     return executeKateCommand(QStringLiteral("vsplit"));
 }
 
 bool NormalViMode::commandCloseView()
 {
     return executeKateCommand(QStringLiteral("close"));
 }
 
 bool NormalViMode::commandSwitchToNextTab()
 {
     QString command = QStringLiteral("bn");
 
     if (m_iscounted) {
         command = command + QLatin1Char(' ') + QString::number(getCount());
     }
 
     return executeKateCommand(command);
 }
 
 bool NormalViMode::commandSwitchToPrevTab()
 {
     QString command = QStringLiteral("bp");
 
     if (m_iscounted) {
         command = command + QLatin1Char(' ') + QString::number(getCount());
     }
 
     return executeKateCommand(command);
 }
 
 bool NormalViMode::commandFormatLine()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     reformatLines(c.line(), c.line() + getCount() - 1);
 
     return true;
 }
 
 bool NormalViMode::commandFormatLines()
 {
     reformatLines(m_commandRange.startLine, m_commandRange.endLine);
     return true;
 }
 
 bool NormalViMode::commandCollapseToplevelNodes()
 {
 #if 0
     //FIXME FOLDING
     doc()->foldingTree()->collapseToplevelNodes();
 #endif
     return true;
 }
 
 bool NormalViMode::commandStartRecordingMacro()
 {
     const QChar reg = m_keys[m_keys.size() - 1];
     m_viInputModeManager->macroRecorder()->start(reg);
     return true;
 }
 
 bool NormalViMode::commandReplayMacro()
 {
     // "@<registername>" will have been added to the log; it needs to be cleared
     // *before* we replay the macro keypresses, else it can cause an infinite loop
     // if the macro contains a "."
     m_viInputModeManager->clearCurrentChangeLog();
     const QChar reg = m_keys[m_keys.size() - 1];
     const unsigned int count = getCount();
     resetParser();
     doc()->editBegin();
     for (unsigned int i = 0; i < count; i++) {
         m_viInputModeManager->macroRecorder()->replay(reg);
     }
     doc()->editEnd();
     return true;
 }
 
 bool NormalViMode::commandCloseNocheck()
 {
     return executeKateCommand(QStringLiteral("q!"));
 }
 
 bool NormalViMode::commandCloseWrite()
 {
     return executeKateCommand(QStringLiteral("wq"));
 }
 
 bool NormalViMode::commandCollapseLocal()
 {
 #if 0
     //FIXME FOLDING
     KTextEditor::Cursor c(m_view->cursorPosition());
     doc()->foldingTree()->collapseOne(c.line(), c.column());
 #endif
     return true;
 }
 
 bool NormalViMode::commandExpandAll()
 {
 #if 0
     //FIXME FOLDING
     doc()->foldingTree()->expandAll();
 #endif
     return true;
 }
 
 bool NormalViMode::commandExpandLocal()
 {
 #if 0
     //FIXME FOLDING
     KTextEditor::Cursor c(m_view->cursorPosition());
     doc()->foldingTree()->expandOne(c.line() + 1, c.column());
 #endif
     return true;
 }
 
 bool NormalViMode::commandToggleRegionVisibility()
 {
 #if 0
     //FIXME FOLDING
     KTextEditor::Cursor c(m_view->cursorPosition());
     doc()->foldingTree()->toggleRegionVisibility(c.line());
 #endif
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MOTIONS
 ////////////////////////////////////////////////////////////////////////////////
 
 Range NormalViMode::motionDown()
 {
     return goLineDown();
 }
 
 Range NormalViMode::motionUp()
 {
     return goLineUp();
 }
 
 Range NormalViMode::motionLeft()
 {
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     m_stickyColumn = -1;
     Range r(cursor, ExclusiveMotion);
     r.endColumn -= getCount();
 
     if (r.endColumn < 0) {
         r.endColumn = 0;
     }
 
     return r;
 }
 
 Range NormalViMode::motionRight()
 {
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     m_stickyColumn = -1;
     Range r(cursor, ExclusiveMotion);
     r.endColumn += getCount();
 
     // make sure end position isn't > line length
     if (r.endColumn > doc()->lineLength(r.endLine)) {
         r.endColumn = doc()->lineLength(r.endLine);
     }
 
     return r;
 }
 
 Range NormalViMode::motionPageDown()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, InclusiveMotion);
     r.endLine += linesDisplayed();
 
     if (r.endLine >= doc()->lines()) {
         r.endLine = doc()->lines() - 1;
     }
     return r;
 }
 
 Range NormalViMode::motionPageUp()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, InclusiveMotion);
     r.endLine -= linesDisplayed();
 
     if (r.endLine < 0) {
         r.endLine = 0;
     }
     return r;
 }
 
 Range NormalViMode::motionHalfPageDown()
 {
     if (commandScrollHalfPageDown()) {
         KTextEditor::Cursor c = m_view->cursorPosition();
         m_commandRange.endLine = c.line();
         m_commandRange.endColumn = c.column();
         return m_commandRange;
     }
     return Range::invalid();
 }
 
 Range NormalViMode::motionHalfPageUp()
 {
     if (commandScrollHalfPageUp()) {
         KTextEditor::Cursor c = m_view->cursorPosition();
         m_commandRange.endLine = c.line();
         m_commandRange.endColumn = c.column();
         return m_commandRange;
     }
     return Range::invalid();
 }
 
 Range NormalViMode::motionDownToFirstNonBlank()
 {
     Range r = goLineDown();
     r.endColumn = getFirstNonBlank(r.endLine);
     return r;
 }
 
 Range NormalViMode::motionUpToFirstNonBlank()
 {
     Range r = goLineUp();
     r.endColumn = getFirstNonBlank(r.endLine);
     return r;
 }
 
 Range NormalViMode::motionWordForward()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, ExclusiveMotion);
 
     m_stickyColumn = -1;
 
     // Special case: If we're already on the very last character in the document, the motion should be
     // inclusive so the last character gets included
     if (c.line() == doc()->lines() - 1 && c.column() == doc()->lineLength(c.line()) - 1) {
         r.motionType = InclusiveMotion;
     } else {
         for (int i = 0; i < getCount(); i++) {
             c = findNextWordStart(c.line(), c.column());
 
             // stop when at the last char in the document
             if (!c.isValid()) {
                 c = doc()->documentEnd();
                 // if we still haven't "used up the count", make the motion inclusive, so that the last char
                 // is included
                 if (i < getCount()) {
                     r.motionType = InclusiveMotion;
                 }
                 break;
             }
         }
     }
 
     r.endColumn = c.column();
     r.endLine = c.line();
 
     return r;
 }
 
 Range NormalViMode::motionWordBackward()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, ExclusiveMotion);
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         c = findPrevWordStart(c.line(), c.column());
 
         if (!c.isValid()) {
             c = KTextEditor::Cursor(0, 0);
             break;
         }
     }
 
     r.endColumn = c.column();
     r.endLine = c.line();
 
     return r;
 }
 
 Range NormalViMode::motionWORDForward()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, ExclusiveMotion);
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         c = findNextWORDStart(c.line(), c.column());
 
         // stop when at the last char in the document
         if (c.line() == doc()->lines() - 1 && c.column() == doc()->lineLength(c.line()) - 1) {
             break;
         }
     }
 
     r.endColumn = c.column();
     r.endLine = c.line();
 
     return r;
 }
 
 Range NormalViMode::motionWORDBackward()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, ExclusiveMotion);
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         c = findPrevWORDStart(c.line(), c.column());
 
         if (!c.isValid()) {
             c = KTextEditor::Cursor(0, 0);
         }
     }
 
     r.endColumn = c.column();
     r.endLine = c.line();
 
     return r;
 }
 
 Range NormalViMode::motionToEndOfWord()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, InclusiveMotion);
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         c = findWordEnd(c.line(), c.column());
     }
 
     if (!c.isValid()) {
         c = doc()->documentEnd();
     }
 
     r.endColumn = c.column();
     r.endLine = c.line();
 
     return r;
 }
 
 Range NormalViMode::motionToEndOfWORD()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, InclusiveMotion);
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         c = findWORDEnd(c.line(), c.column());
     }
 
     if (!c.isValid()) {
         c = doc()->documentEnd();
     }
 
     r.endColumn = c.column();
     r.endLine = c.line();
 
     return r;
 }
 
 Range NormalViMode::motionToEndOfPrevWord()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, InclusiveMotion);
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         c = findPrevWordEnd(c.line(), c.column());
 
         if (c.isValid()) {
             r.endColumn = c.column();
             r.endLine = c.line();
         } else {
             r.endColumn = 0;
             r.endLine = 0;
             break;
         }
 
     }
 
     return r;
 }
 
 Range NormalViMode::motionToEndOfPrevWORD()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     Range r(c, InclusiveMotion);
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         c = findPrevWORDEnd(c.line(), c.column());
 
         if (c.isValid()) {
             r.endColumn = c.column();
             r.endLine = c.line();
         } else {
             r.endColumn = 0;
             r.endLine = 0;
             break;
         }
     }
 
     return r;
 }
 
 Range NormalViMode::motionToEOL()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     // set sticky column to a ridiculously high value so that the cursor will stick to EOL,
     // but only if it's a regular motion
     if (m_keys.size() == 1) {
         m_stickyColumn = KateVi::EOL;
     }
 
     unsigned int line = c.line() + (getCount() - 1);
     Range r(line, doc()->lineLength(line) - 1, InclusiveMotion);
 
     return r;
 }
 
 Range NormalViMode::motionToColumn0()
 {
     m_stickyColumn = -1;
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     Range r(cursor.line(), 0, ExclusiveMotion);
 
     return r;
 }
 
 Range NormalViMode::motionToFirstCharacterOfLine()
 {
     m_stickyColumn = -1;
 
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     int c = getFirstNonBlank();
 
     Range r(cursor.line(), c, ExclusiveMotion);
 
     return r;
 }
 
 Range NormalViMode::motionFindChar()
 {
     m_lastTFcommand = m_keys;
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     QString line = getLine();
 
     m_stickyColumn = -1;
 
     int matchColumn = cursor.column();
 
     for (int i = 0; i < getCount(); i++) {
         matchColumn = line.indexOf(m_keys.rightRef(1), matchColumn + 1);
         if (matchColumn == -1) {
             break;
         }
     }
 
     Range r;
 
     if (matchColumn != -1) {
         r.endColumn = matchColumn;
         r.endLine = cursor.line();
     } else {
         return Range::invalid();
     }
 
     return r;
 }
 
 Range NormalViMode::motionFindCharBackward()
 {
     m_lastTFcommand = m_keys;
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     QString line = getLine();
 
     m_stickyColumn = -1;
 
     int matchColumn = -1;
 
     int hits = 0;
     int i = cursor.column() - 1;
 
     while (hits != getCount() && i >= 0) {
         if (line.at(i) == m_keys.at(m_keys.size() - 1)) {
             hits++;
         }
 
         if (hits == getCount()) {
             matchColumn = i;
         }
 
         i--;
     }
 
     Range r(cursor, ExclusiveMotion);
 
     if (matchColumn != -1) {
         r.endColumn = matchColumn;
         r.endLine = cursor.line();
     } else {
         return Range::invalid();
     }
 
     return r;
 }
 
 Range NormalViMode::motionToChar()
 {
     m_lastTFcommand = m_keys;
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     QString line = getLine();
 
     m_stickyColumn = -1;
     Range r;
     r.endColumn = -1;
     r.endLine = -1;
 
     int matchColumn = cursor.column() + (m_isRepeatedTFcommand ? 2 : 1);
 
     for (int i = 0; i < getCount(); i++) {
         const int lastColumn = matchColumn;
         matchColumn = line.indexOf(m_keys.right(1), matchColumn + ((i > 0) ? 1 : 0));
         if (matchColumn == -1) {
             if (m_isRepeatedTFcommand) {
                 matchColumn = lastColumn;
             } else {
                 return Range::invalid();
             }
             break;
         }
     }
 
     r.endColumn = matchColumn - 1;
     r.endLine = cursor.line();
 
     m_isRepeatedTFcommand = false;
     return r;
 }
 
 Range NormalViMode::motionToCharBackward()
 {
     m_lastTFcommand = m_keys;
     KTextEditor::Cursor cursor(m_view->cursorPosition());
     QString line = getLine();
 
     const int originalColumn = cursor.column();
     m_stickyColumn = -1;
 
     int matchColumn = originalColumn - 1;
 
     int hits = 0;
     int i = cursor.column() - (m_isRepeatedTFcommand ? 2 : 1);
 
     Range r(cursor, ExclusiveMotion);
 
     while (hits != getCount() && i >= 0) {
         if (line.at(i) == m_keys.at(m_keys.size() - 1)) {
             hits++;
         }
 
         if (hits == getCount()) {
             matchColumn = i;
         }
 
         i--;
     }
 
     if (hits == getCount()) {
         r.endColumn = matchColumn + 1;
         r.endLine = cursor.line();
     } else {
         r.valid = false;
     }
 
     m_isRepeatedTFcommand = false;
 
     return r;
 }
 
 Range NormalViMode::motionRepeatlastTF()
 {
     if (!m_lastTFcommand.isEmpty()) {
         m_isRepeatedTFcommand = true;
         m_keys = m_lastTFcommand;
         if (m_keys.at(0) == QLatin1Char('f')) {
             return motionFindChar();
         } else if (m_keys.at(0) == QLatin1Char('F')) {
             return motionFindCharBackward();
         } else if (m_keys.at(0) == QLatin1Char('t')) {
             return motionToChar();
         } else if (m_keys.at(0) == QLatin1Char('T')) {
             return motionToCharBackward();
         }
     }
 
     // there was no previous t/f command
     return Range::invalid();
 }
 
 Range NormalViMode::motionRepeatlastTFBackward()
 {
     if (!m_lastTFcommand.isEmpty()) {
         m_isRepeatedTFcommand = true;
         m_keys = m_lastTFcommand;
         if (m_keys.at(0) == QLatin1Char('f')) {
             return motionFindCharBackward();
         } else if (m_keys.at(0) == QLatin1Char('F')) {
             return motionFindChar();
         } else if (m_keys.at(0) == QLatin1Char('t')) {
             return motionToCharBackward();
         } else if (m_keys.at(0) == QLatin1Char('T')) {
             return motionToChar();
         }
     }
 
     // there was no previous t/f command
     return Range::invalid();
 }
 
 Range NormalViMode::motionToLineFirst()
 {
     Range r(getCount() - 1, 0, InclusiveMotion);
     m_stickyColumn = -1;
 
     if (r.endLine > doc()->lines() - 1) {
         r.endLine = doc()->lines() - 1;
     }
     r.jump = true;
 
     return r;
 }
 
 Range NormalViMode::motionToLineLast()
 {
     Range r(doc()->lines() - 1, 0, InclusiveMotion);
     m_stickyColumn = -1;
 
     // don't use getCount() here, no count and a count of 1 is different here...
     if (m_count != 0) {
         r.endLine = m_count - 1;
     }
 
     if (r.endLine > doc()->lines() - 1) {
         r.endLine = doc()->lines() - 1;
     }
     r.jump = true;
 
     return r;
 }
 
 Range NormalViMode::motionToScreenColumn()
 {
     m_stickyColumn = -1;
 
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     int column = getCount() - 1;
 
     if (doc()->lineLength(c.line()) - 1 < (int)getCount() - 1) {
         column = doc()->lineLength(c.line()) - 1;
     }
 
     return Range(c.line(), column, ExclusiveMotion);
 }
 
 Range NormalViMode::motionToMark()
 {
     Range r;
 
     m_stickyColumn = -1;
 
     QChar reg = m_keys.at(m_keys.size() - 1);
 
     KTextEditor::Cursor c = m_viInputModeManager->marks()->getMarkPosition(reg);
     if (c.isValid()) {
         r.endLine = c.line();
         r.endColumn = c.column();
     } else {
         error(i18n("Mark not set: %1", m_keys.right(1)));
         r.valid = false;
     }
 
     r.jump = true;
 
     return r;
 }
 
 Range NormalViMode::motionToMarkLine()
 {
     Range r = motionToMark();
     r.endColumn = getFirstNonBlank(r.endLine);
     r.jump = true;
     m_stickyColumn = -1;
     return r;
 }
 
 Range NormalViMode::motionToMatchingItem()
 {
     Range r;
     int lines = doc()->lines();
 
     // If counted, then it's not a motion to matching item anymore,
     // but a motion to the N'th percentage of the document
     if (isCounted()) {
         int count = getCount();
         if (count > 100) {
             return r;
         }
         r.endLine = qRound(lines * count / 100.0) - 1;
         r.endColumn = 0;
         return r;
     }
 
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     QString l = getLine();
     int n1 = l.indexOf(m_matchItemRegex, c.column());
 
     m_stickyColumn = -1;
 
     if (n1 < 0) {
         return Range::invalid();
     }
 
     QRegExp brackets(QLatin1String("[(){}\\[\\]]"));
 
     // use Kate's built-in matching bracket finder for brackets
     if (brackets.indexIn(l, n1) == n1) {
         // findMatchingBracket requires us to move the cursor to the
         // first bracket, but we don't want the cursor to really move
         // in case this is e.g. a yank, so restore it to its original
         // position afterwards.
         c.setColumn(n1 + 1);
         const KTextEditor::Cursor oldCursorPos = m_view->cursorPosition();
         updateCursor(c);
 
         // find the matching one
         c = m_viewInternal->findMatchingBracket();
         if (c > m_view->cursorPosition()) {
             c.setColumn(c.column() - 1);
         }
         m_view->setCursorPosition(oldCursorPos);
     } else {
         // text item we want to find a matching item for
         int n2 = l.indexOf(QRegExp(QLatin1String("\\b|\\s|$")), n1);
         QString item = l.mid(n1, n2 - n1);
         QString matchingItem = m_matchingItems[ item ];
 
         int toFind = 1;
         int line = c.line();
         int column = n2 - item.length();
         bool reverse = false;
 
         if (matchingItem.left(1) == QLatin1String("-")) {
             matchingItem.remove(0, 1);   // remove the '-'
             reverse = true;
         }
 
         // make sure we don't hit the text item we started the search from
         if (column == 0 && reverse) {
             column -= item.length();
         }
 
         int itemIdx;
         int matchItemIdx;
 
         while (toFind > 0) {
             if (reverse) {
                 itemIdx = l.lastIndexOf(item, column - 1);
                 matchItemIdx = l.lastIndexOf(matchingItem, column - 1);
 
                 if (itemIdx != -1 && (matchItemIdx == -1 || itemIdx > matchItemIdx)) {
                     ++toFind;
                 }
             } else {
                 itemIdx = l.indexOf(item, column);
                 matchItemIdx = l.indexOf(matchingItem, column);
 
                 if (itemIdx != -1 && (matchItemIdx == -1 || itemIdx < matchItemIdx)) {
                     ++toFind;
                 }
             }
 
             if (matchItemIdx != -1 || itemIdx != -1) {
                 if (!reverse) {
                     column = qMin((unsigned int)itemIdx, (unsigned int)matchItemIdx);
                 } else {
                     column = qMax(itemIdx, matchItemIdx);
                 }
             }
 
             if (matchItemIdx != -1) {   // match on current line
                 if (matchItemIdx == column) {
                     --toFind;
                     c.setLine(line);
                     c.setColumn(column);
                 }
             } else { // no match, advance one line if possible
                 (reverse) ? --line : ++line;
                 column = 0;
 
                 if ((!reverse && line >= lines) || (reverse && line < 0)) {
                     r.valid = false;
                     break;
                 } else {
                     l = getLine(line);
                 }
             }
         }
     }
 
     r.endLine = c.line();
     r.endColumn = c.column();
     r.jump = true;
 
     return r;
 }
 
 Range NormalViMode::motionToNextBraceBlockStart()
 {
     Range r;
 
     m_stickyColumn = -1;
 
     int line = findLineStartingWitchChar(QLatin1Char('{'), getCount());
 
     if (line == -1) {
         return Range::invalid();
     }
 
     r.endLine = line;
     r.endColumn = 0;
     r.jump = true;
 
     if (motionWillBeUsedWithCommand()) {
         // Delete from cursor (inclusive) to the '{' (exclusive).
         // If we are on the first column, then delete the entire current line.
         r.motionType = ExclusiveMotion;
         if (m_view->cursorPosition().column() != 0) {
             r.endLine--;
             r.endColumn = doc()->lineLength(r.endLine);
         }
     }
 
     return r;
 }
 
 Range NormalViMode::motionToPreviousBraceBlockStart()
 {
     Range r;
 
     m_stickyColumn = -1;
 
     int line = findLineStartingWitchChar(QLatin1Char('{'), getCount(), false);
 
     if (line == -1) {
         return Range::invalid();
     }
 
     r.endLine = line;
     r.endColumn = 0;
     r.jump = true;
 
     if (motionWillBeUsedWithCommand()) {
         // With a command, do not include the { or the cursor position.
         r.motionType = ExclusiveMotion;
     }
 
     return r;
 }
 
 Range NormalViMode::motionToNextBraceBlockEnd()
 {
     Range r;
 
     m_stickyColumn = -1;
 
     int line = findLineStartingWitchChar(QLatin1Char('}'), getCount());
 
     if (line == -1) {
         return Range::invalid();
     }
 
     r.endLine = line;
     r.endColumn = 0;
     r.jump = true;
 
     if (motionWillBeUsedWithCommand()) {
         // Delete from cursor (inclusive) to the '}' (exclusive).
         // If we are on the first column, then delete the entire current line.
         r.motionType = ExclusiveMotion;
         if (m_view->cursorPosition().column() != 0) {
             r.endLine--;
             r.endColumn = doc()->lineLength(r.endLine);
         }
     }
 
     return r;
 }
 
 Range NormalViMode::motionToPreviousBraceBlockEnd()
 {
     Range r;
 
     m_stickyColumn = -1;
 
     int line = findLineStartingWitchChar(QLatin1Char('}'), getCount(), false);
 
     if (line == -1) {
         return Range::invalid();
     }
 
     r.endLine = line;
     r.endColumn = 0;
     r.jump = true;
 
     if (motionWillBeUsedWithCommand()) {
         r.motionType = ExclusiveMotion;
     }
 
     return r;
 }
 
 Range NormalViMode::motionToNextOccurrence()
 {
     const QString word = getWordUnderCursor();
     const Range match = m_viInputModeManager->searcher()->findWordForMotion(word, false, getWordRangeUnderCursor().start(), getCount());
     return Range(match.startLine, match.startColumn, ExclusiveMotion);
 }
 
 Range NormalViMode::motionToPrevOccurrence()
 {
     const QString word = getWordUnderCursor();
     const Range match = m_viInputModeManager->searcher()->findWordForMotion(word, true, getWordRangeUnderCursor().start(), getCount());
     return Range(match.startLine, match.startColumn, ExclusiveMotion);
 }
 
 Range NormalViMode::motionToFirstLineOfWindow()
 {
     int lines_to_go;
     if (linesDisplayed() <= (unsigned int) m_viewInternal->endLine()) {
         lines_to_go = m_viewInternal->endLine() - linesDisplayed() - m_view->cursorPosition().line() + 1;
     } else {
         lines_to_go = - m_view->cursorPosition().line();
     }
 
     Range r = goLineUpDown(lines_to_go);
     r.endColumn = getFirstNonBlank(r.endLine);
     return r;
 }
 
 Range NormalViMode::motionToMiddleLineOfWindow()
 {
     int lines_to_go;
     if (linesDisplayed() <= (unsigned int) m_viewInternal->endLine()) {
         lines_to_go = m_viewInternal->endLine() - linesDisplayed() / 2 - m_view->cursorPosition().line();
     } else {
         lines_to_go = m_viewInternal->endLine() / 2 - m_view->cursorPosition().line();
     }
 
     Range r = goLineUpDown(lines_to_go);
     r.endColumn = getFirstNonBlank(r.endLine);
     return r;
 }
 
 Range NormalViMode::motionToLastLineOfWindow()
 {
     int lines_to_go;
     if (linesDisplayed() <= (unsigned int) m_viewInternal->endLine()) {
         lines_to_go = m_viewInternal->endLine() - m_view->cursorPosition().line();
     } else {
         lines_to_go = m_viewInternal->endLine() - m_view->cursorPosition().line();
     }
 
     Range r = goLineUpDown(lines_to_go);
     r.endColumn = getFirstNonBlank(r.endLine);
     return r;
 }
 
 Range NormalViMode::motionToNextVisualLine()
 {
     return goVisualLineUpDown(getCount());
 }
 
 Range NormalViMode::motionToPrevVisualLine()
 {
     return goVisualLineUpDown(-getCount());
 }
 
 Range NormalViMode::motionToPreviousSentence()
 {
     KTextEditor::Cursor c = findSentenceStart();
     int linenum = c.line(), column;
     const bool skipSpaces = doc()->line(linenum).isEmpty();
 
     if (skipSpaces) {
         linenum--;
         if (linenum >= 0) {
             column = doc()->line(linenum).size() - 1;
         }
     } else {
         column = c.column();
     }
 
     for (int i = linenum; i >= 0; i--) {
         const QString &line = doc()->line(i);
 
         if (line.isEmpty() && !skipSpaces) {
             return Range(i, 0, InclusiveMotion);
         }
 
         if (column < 0 && !line.isEmpty()) {
             column = line.size() - 1;
         }
 
         for (int j = column; j >= 0; j--) {
             if (skipSpaces || QStringLiteral(".?!").indexOf(line.at(j)) != -1) {
                 c.setLine(i);
                 c.setColumn(j);
                 updateCursor(c);
                 c = findSentenceStart();
                 return Range(c, InclusiveMotion);
             }
         }
         column = line.size() - 1;
     }
     return Range(0, 0, InclusiveMotion);
 }
 
 Range NormalViMode::motionToNextSentence()
 {
     KTextEditor::Cursor c = findSentenceEnd();
     int linenum = c.line(), column = c.column() + 1;
     const bool skipSpaces = doc()->line(linenum).isEmpty();
 
     for (int i = linenum; i < doc()->lines(); i++) {
         const QString &line = doc()->line(i);
 
         if (line.isEmpty() && !skipSpaces) {
             return Range(i, 0, InclusiveMotion);
         }
 
         for (int j = column; j < line.size(); j++) {
             if (!line.at(j).isSpace()) {
                 return Range(i, j, InclusiveMotion);
             }
         }
         column = 0;
     }
 
     c = doc()->documentEnd();
     return Range(c, InclusiveMotion);
 }
 
 Range NormalViMode::motionToBeforeParagraph()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     int line = c.line();
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         // advance at least one line, but if there are consecutive blank lines
         // skip them all
         do {
             line--;
         } while (line >= 0 && getLine(line + 1).length() == 0);
         while (line > 0 && getLine(line).length() != 0) {
             line--;
         }
     }
 
     if (line < 0) {
         line = 0;
     }
 
     Range r(line, 0, InclusiveMotion);
 
     return r;
 }
 
 Range NormalViMode::motionToAfterParagraph()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     int line = c.line();
 
     m_stickyColumn = -1;
 
     for (int i = 0; i < getCount(); i++) {
         // advance at least one line, but if there are consecutive blank lines
         // skip them all
         do {
             line++;
         } while (line <= doc()->lines() - 1 && getLine(line - 1).length() == 0);
         while (line < doc()->lines() - 1 && getLine(line).length() != 0) {
             line++;
         }
     }
 
     if (line >= doc()->lines()) {
         line = doc()->lines() - 1;
     }
 
     // if we ended up on the last line, the cursor should be placed on the last column
     int column = (line == doc()->lines() - 1) ? qMax(getLine(line).length() - 1, 0) : 0;
 
     return Range(line, column, InclusiveMotion);
 }
 
 Range NormalViMode::motionToIncrementalSearchMatch()
 {
     return Range(m_positionWhenIncrementalSearchBegan.line(),
                        m_positionWhenIncrementalSearchBegan.column(),
                        m_view->cursorPosition().line(),
                        m_view->cursorPosition().column(), ExclusiveMotion);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TEXT OBJECTS
 ////////////////////////////////////////////////////////////////////////////////
 
 Range NormalViMode::textObjectAWord()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     KTextEditor::Cursor c1 = c;
 
     bool startedOnSpace = false;
     if (doc()->characterAt(c).isSpace()) {
         startedOnSpace = true;
     } else {
         c1 = findPrevWordStart(c.line(), c.column() + 1, true);
         if (!c1.isValid()) {
             c1 = KTextEditor::Cursor(0, 0);
         }
     }
     KTextEditor::Cursor c2 = KTextEditor::Cursor(c.line(), c.column() - 1);
     for (int i = 1; i <= getCount(); i++) {
         c2 = findWordEnd(c2.line(), c2.column());
     }
     if (!c1.isValid() || !c2.isValid()) {
         return Range::invalid();
     }
     // Adhere to some of Vim's bizarre rules of whether to swallow ensuing spaces or not.
     // Don't ask ;)
     const KTextEditor::Cursor nextWordStart = findNextWordStart(c2.line(), c2.column());
     if (nextWordStart.isValid() && nextWordStart.line() == c2.line()) {
         if (!startedOnSpace) {
             c2 = KTextEditor::Cursor(nextWordStart.line(), nextWordStart.column() - 1);
         }
     } else {
         c2 = KTextEditor::Cursor(c2.line(), doc()->lineLength(c2.line()) - 1);
     }
     bool swallowCarriageReturnAtEndOfLine = false;
     if (c2.line() != c.line() && c2.column() == doc()->lineLength(c2.line()) - 1) {
         // Greedily descend to the next line, so as to swallow the carriage return on this line.
         c2 = KTextEditor::Cursor(c2.line() + 1, 0);
         swallowCarriageReturnAtEndOfLine = true;
     }
     const bool swallowPrecedingSpaces = (c2.column() == doc()->lineLength(c2.line()) - 1 && !doc()->characterAt(c2).isSpace()) || startedOnSpace || swallowCarriageReturnAtEndOfLine;
     if (swallowPrecedingSpaces) {
         if (c1.column() != 0) {
             const KTextEditor::Cursor previousNonSpace = findPrevWordEnd(c.line(), c.column());
             if (previousNonSpace.isValid() && previousNonSpace.line() == c1.line()) {
                 c1 = KTextEditor::Cursor(previousNonSpace.line(), previousNonSpace.column() + 1);
             } else if (startedOnSpace || swallowCarriageReturnAtEndOfLine) {
                 c1 = KTextEditor::Cursor(c1.line(), 0);
             }
         }
     }
 
     return Range(c1, c2, !swallowCarriageReturnAtEndOfLine ? InclusiveMotion : ExclusiveMotion);
 }
 
 Range NormalViMode::textObjectInnerWord()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     KTextEditor::Cursor c1 = findPrevWordStart(c.line(), c.column() + 1, true);
     if (!c1.isValid()) {
         c1 = KTextEditor::Cursor(0, 0);
     }
     // need to start search in column-1 because it might be a one-character word
     KTextEditor::Cursor c2(c.line(), c.column() - 1);
 
     for (int i = 0; i < getCount(); i++) {
         c2 = findWordEnd(c2.line(), c2.column(), true);
     }
 
     if (!c2.isValid()) {
         c2 = doc()->documentEnd();
     }
 
     // sanity check
     if (c1.line() != c2.line() || c1.column() > c2.column()) {
         return Range::invalid();
     }
     return Range(c1, c2, InclusiveMotion);
 }
 
 Range NormalViMode::textObjectAWORD()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     KTextEditor::Cursor c1 = c;
 
     bool startedOnSpace = false;
     if (doc()->characterAt(c).isSpace()) {
         startedOnSpace = true;
     } else {
         c1 = findPrevWORDStart(c.line(), c.column() + 1, true);
         if (!c1.isValid()) {
             c1 = KTextEditor::Cursor(0, 0);
         }
     }
     KTextEditor::Cursor c2 = KTextEditor::Cursor(c.line(), c.column() - 1);
     for (int i = 1; i <= getCount(); i++) {
         c2 = findWORDEnd(c2.line(), c2.column());
     }
     if (!c1.isValid() || !c2.isValid()) {
         return Range::invalid();
     }
     // Adhere to some of Vim's bizarre rules of whether to swallow ensuing spaces or not.
     // Don't ask ;)
     const KTextEditor::Cursor nextWordStart = findNextWordStart(c2.line(), c2.column());
     if (nextWordStart.isValid() && nextWordStart.line() == c2.line()) {
         if (!startedOnSpace) {
             c2 = KTextEditor::Cursor(nextWordStart.line(), nextWordStart.column() - 1);
         }
     } else {
         c2 = KTextEditor::Cursor(c2.line(), doc()->lineLength(c2.line()) - 1);
     }
     bool swallowCarriageReturnAtEndOfLine = false;
     if (c2.line() != c.line() && c2.column() == doc()->lineLength(c2.line()) - 1) {
         // Greedily descend to the next line, so as to swallow the carriage return on this line.
         c2 = KTextEditor::Cursor(c2.line() + 1, 0);
         swallowCarriageReturnAtEndOfLine = true;
     }
     const bool swallowPrecedingSpaces = (c2.column() == doc()->lineLength(c2.line()) - 1 && !doc()->characterAt(c2).isSpace()) || startedOnSpace || swallowCarriageReturnAtEndOfLine;
     if (swallowPrecedingSpaces) {
         if (c1.column() != 0) {
             const KTextEditor::Cursor previousNonSpace = findPrevWORDEnd(c.line(), c.column());
             if (previousNonSpace.isValid() && previousNonSpace.line() == c1.line()) {
                 c1 = KTextEditor::Cursor(previousNonSpace.line(), previousNonSpace.column() + 1);
             } else if (startedOnSpace || swallowCarriageReturnAtEndOfLine) {
                 c1 = KTextEditor::Cursor(c1.line(), 0);
             }
         }
     }
 
     return Range(c1, c2, !swallowCarriageReturnAtEndOfLine ? InclusiveMotion : ExclusiveMotion);
 }
 
 Range NormalViMode::textObjectInnerWORD()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
 
     KTextEditor::Cursor c1 = findPrevWORDStart(c.line(), c.column() + 1, true);
     if (!c1.isValid()) {
         c1 = KTextEditor::Cursor(0, 0);
     }
     KTextEditor::Cursor c2(c);
 
     for (int i = 0; i < getCount(); i++) {
         c2 = findWORDEnd(c2.line(), c2.column(), true);
     }
 
     if (!c2.isValid()) {
         c2 = doc()->documentEnd();
     }
 
     // sanity check
     if (c1.line() != c2.line() || c1.column() > c2.column()) {
         return Range::invalid();
     }
     return Range(c1, c2, InclusiveMotion);
 }
 
 KTextEditor::Cursor NormalViMode::findSentenceStart()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     int linenum = c.line(), column = c.column();
     int prev = column;
 
     for (int i = linenum; i >= 0; i--) {
         const QString &line = doc()->line(i);
         if (i != linenum) {
             column = line.size() - 1;
         }
 
         // An empty line is the end of a paragraph.
         if (line.isEmpty()) {
             return KTextEditor::Cursor((i != linenum) ? i + 1 : i, prev);
         }
 
         prev = column;
         for (int j = column; j >= 0; j--) {
             if (line.at(j).isSpace()) {
                 int lastSpace = j--;
                 for (; j >= 0 && QStringLiteral("\"')]").indexOf(line.at(j)) != -1; j--);
 
                 if (j >= 0 && QStringLiteral(".!?").indexOf(line.at(j)) != -1) {
                     return KTextEditor::Cursor(i, prev);
                 }
                 j = lastSpace;
             } else
                 prev = j;
         }
     }
 
     return KTextEditor::Cursor(0, 0);
 }
 
 KTextEditor::Cursor NormalViMode::findSentenceEnd()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     int linenum = c.line(), column = c.column();
     int j = 0, prev = 0;
 
     for (int i = linenum; i < doc()->lines(); i++) {
         const QString &line = doc()->line(i);
 
         // An empty line is the end of a paragraph.
         if (line.isEmpty()) {
             return KTextEditor::Cursor(linenum, j);
         }
 
         // Iterating over the line to reach any '.', '!', '?'
         for (j = column; j < line.size(); j++) {
             if (QStringLiteral(".!?").indexOf(line.at(j)) != -1) {
                 prev = j++;
                 // Skip possible closing characters.
                 for (; j < line.size() && QString::fromLatin1("\"')]").indexOf(line.at(j)) != -1; j++);
 
                 if (j >= line.size()) {
                     return KTextEditor::Cursor(i, j - 1);
                 }
 
                 // And hopefully we're done...
                 if (line.at(j).isSpace()) {
                     return KTextEditor::Cursor(i, j - 1);
                 }
                 j = prev;
             }
         }
         linenum = i;
         prev = column;
         column = 0;
     }
 
     return KTextEditor::Cursor(linenum, j - 1);
 }
 
 KTextEditor::Cursor NormalViMode::findParagraphStart()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     const bool firstBlank = doc()->line(c.line()).isEmpty();
     int prev = c.line();
 
     for (int i = prev; i >= 0; i--) {
         if (doc()->line(i).isEmpty()) {
             if (i != prev) {
                 prev = i + 1;
             }
 
             /* Skip consecutive empty lines. */
             if (firstBlank) {
                 i--;
                 for (; i >= 0 && doc()->line(i).isEmpty(); i--, prev--);
             }
             return KTextEditor::Cursor(prev, 0);
         }
     }
     return KTextEditor::Cursor(0, 0);
 }
 
 KTextEditor::Cursor NormalViMode::findParagraphEnd()
 {
     KTextEditor::Cursor c(m_view->cursorPosition());
     int prev = c.line(), lines = doc()->lines();
     const bool firstBlank = doc()->line(prev).isEmpty();
 
     for (int i = prev; i < lines; i++) {
         if (doc()->line(i).isEmpty()) {
             if (i != prev) {
                 prev = i - 1;
             }
 
             /* Skip consecutive empty lines. */
             if (firstBlank) {
                 i++;
                 for (; i < lines && doc()->line(i).isEmpty(); i++, prev++);
             }
             int length = doc()->lineLength(prev);
             return KTextEditor::Cursor(prev, (length <= 0) ? 0 : length - 1);
         }
     }
     return doc()->documentEnd();
 }
 
 Range NormalViMode::textObjectInnerSentence()
 {
     Range r;
     KTextEditor::Cursor c1 = findSentenceStart();
     KTextEditor::Cursor c2 = findSentenceEnd();
     updateCursor(c1);
 
     r.startLine = c1.line();
     r.startColumn = c1.column();
     r.endLine = c2.line();
     r.endColumn = c2.column();
     return r;
 }
 
 Range NormalViMode::textObjectASentence()
 {
     int i;
     Range r = textObjectInnerSentence();
     const QString &line = doc()->line(r.endLine);
 
     // Skip whitespaces and tabs.
     for (i = r.endColumn + 1; i < line.size(); i++) {
         if (!line.at(i).isSpace()) {
             break;
         }
     }
     r.endColumn = i - 1;
 
     // Remove preceding spaces.
     if (r.startColumn != 0) {
         if (r.endColumn == line.size() - 1 && !line.at(r.endColumn).isSpace()) {
             const QString &line = doc()->line(r.startLine);
             for (i = r.startColumn - 1; i >= 0; i--) {
                 if (!line.at(i).isSpace()) {
                     break;
                 }
             }
             r.startColumn = i + 1;
         }
     }
     return r;
 }
 
 Range NormalViMode::textObjectInnerParagraph()
 {
     Range r;
     KTextEditor::Cursor c1 = findParagraphStart();
     KTextEditor::Cursor c2 = findParagraphEnd();
     updateCursor(c1);
 
     r.startLine = c1.line();
     r.startColumn = c1.column();
     r.endLine = c2.line();
     r.endColumn = c2.column();
     return r;
 }
 
 Range NormalViMode::textObjectAParagraph()
 {
     Range r = textObjectInnerParagraph();
     int lines = doc()->lines();
 
     if (r.endLine + 1 < lines) {
         // If the next line is empty, remove all subsequent empty lines.
         // Otherwise we'll grab the next paragraph.
         if (doc()->line(r.endLine + 1).isEmpty()) {
             for (int i = r.endLine + 1; i < lines && doc()->line(i).isEmpty(); i++) {
                 r.endLine++;
             }
             r.endColumn = 0;
         } else {
             KTextEditor::Cursor prev = m_view->cursorPosition();
             KTextEditor::Cursor c(r.endLine + 1, 0);
             updateCursor(c);
             c = findParagraphEnd();
             updateCursor(prev);
             r.endLine = c.line();
             r.endColumn = c.column();
         }
     } else if (doc()->lineLength(r.startLine) > 0) {
         // We went too far, but maybe we can grab previous empty lines.
         for (int i = r.startLine - 1; i >= 0 && doc()->line(i).isEmpty(); i--) {
             r.startLine--;
         }
         r.startColumn = 0;
         updateCursor(KTextEditor::Cursor(r.startLine, r.startColumn));
     } else {
         // We went too far and we're on empty lines, do nothing.
         return Range::invalid();
     }
     return r;
 }
 
 Range NormalViMode::textObjectAQuoteDouble()
 {
     return findSurroundingQuotes(QLatin1Char('"'), false);
 }
 
 Range NormalViMode::textObjectInnerQuoteDouble()
 {
     return findSurroundingQuotes(QLatin1Char('"'), true);
 }
 
 Range NormalViMode::textObjectAQuoteSingle()
 {
     return findSurroundingQuotes(QLatin1Char('\''), false);
 }
 
 Range NormalViMode::textObjectInnerQuoteSingle()
 {
     return findSurroundingQuotes(QLatin1Char('\''), true);
 }
 
 Range NormalViMode::textObjectABackQuote()
 {
     return findSurroundingQuotes(QLatin1Char('`'), false);
 }
 
 Range NormalViMode::textObjectInnerBackQuote()
 {
     return findSurroundingQuotes(QLatin1Char('`'), true);
 }
 
 Range NormalViMode::textObjectAParen()
 {
     return findSurroundingBrackets(QLatin1Char('('), QLatin1Char(')'), false,  QLatin1Char('('), QLatin1Char(')'));
 }
 
 Range NormalViMode::textObjectInnerParen()
 {
     return findSurroundingBrackets(QLatin1Char('('), QLatin1Char(')'), true, QLatin1Char('('), QLatin1Char(')'));
 }
 
 Range NormalViMode::textObjectABracket()
 {
     return findSurroundingBrackets(QLatin1Char('['), QLatin1Char(']'), false,  QLatin1Char('['), QLatin1Char(']'));
 }
 
 Range NormalViMode::textObjectInnerBracket()
 {
     return findSurroundingBrackets(QLatin1Char('['), QLatin1Char(']'), true, QLatin1Char('['), QLatin1Char(']'));
 }
 
 Range NormalViMode::textObjectACurlyBracket()
 {
     return findSurroundingBrackets(QLatin1Char('{'), QLatin1Char('}'), false,  QLatin1Char('{'), QLatin1Char('}'));
 }
 
 Range NormalViMode::textObjectInnerCurlyBracket()
 {
     const Range allBetweenCurlyBrackets = findSurroundingBrackets(QLatin1Char('{'), QLatin1Char('}'), true, QLatin1Char('{'), QLatin1Char('}'));
     // Emulate the behaviour of vim, which tries to leave the closing bracket on its own line
     // if it was originally on a line different to that of the opening bracket.
     Range innerCurlyBracket(allBetweenCurlyBrackets);
 
     if (innerCurlyBracket.startLine != innerCurlyBracket.endLine) {
         const bool openingBraceIsLastCharOnLine = innerCurlyBracket.startColumn == doc()->line(innerCurlyBracket.startLine).length();
         const bool stuffToDeleteIsAllOnEndLine = openingBraceIsLastCharOnLine &&
                 innerCurlyBracket.endLine == innerCurlyBracket.startLine + 1;
         const QString textLeadingClosingBracket = doc()->line(innerCurlyBracket.endLine).mid(0, innerCurlyBracket.endColumn + 1);
         const bool closingBracketHasLeadingNonWhitespace = !textLeadingClosingBracket.trimmed().isEmpty();
         if (stuffToDeleteIsAllOnEndLine) {
             if (!closingBracketHasLeadingNonWhitespace) {
                 // Nothing there to select - abort.
                 return Range::invalid();
             } else {
                 // Shift the beginning of the range to the start of the line containing the closing bracket.
                 innerCurlyBracket.startLine++;
                 innerCurlyBracket.startColumn = 0;
             }
         } else {
             if (openingBraceIsLastCharOnLine && !closingBracketHasLeadingNonWhitespace) {
                 innerCurlyBracket.startLine++;
                 innerCurlyBracket.startColumn = 0;
                 m_lastMotionWasLinewiseInnerBlock = true;
             }
             {
                 // The line containing the end bracket is left alone if the end bracket is preceded by just whitespace,
                 // else we need to delete everything (i.e. end up with "{}")
                 if (!closingBracketHasLeadingNonWhitespace) {
                     // Shrink the endpoint of the range so that it ends at the end of the line above,
                     // leaving the closing bracket on its own line.
                     innerCurlyBracket.endLine--;
                     innerCurlyBracket.endColumn = doc()->line(innerCurlyBracket.endLine).length();
                 }
             }
         }
 
     }
     return innerCurlyBracket;
 }
 
 Range NormalViMode::textObjectAInequalitySign()
 {
 
     return findSurroundingBrackets(QLatin1Char('<'), QLatin1Char('>'), false,  QLatin1Char('<'), QLatin1Char('>'));
 }
 
 Range NormalViMode::textObjectInnerInequalitySign()
 {
 
     return findSurroundingBrackets(QLatin1Char('<'), QLatin1Char('>'), true, QLatin1Char('<'), QLatin1Char('>'));
 }
 
 Range NormalViMode::textObjectAComma()
 {
     return textObjectComma(false);
 }
 
 Range NormalViMode::textObjectInnerComma()
 {
     return textObjectComma(true);
 }
 
 // add commands
 // when adding commands here, remember to add them to visual mode too (if applicable)
 void NormalViMode::initializeCommands()
 {
     ADDCMD("a", commandEnterInsertModeAppend, IS_CHANGE);
     ADDCMD("A", commandEnterInsertModeAppendEOL, IS_CHANGE);
     ADDCMD("i", commandEnterInsertMode, IS_CHANGE);
     ADDCMD("<insert>", commandEnterInsertMode, IS_CHANGE);
     ADDCMD("I", commandEnterInsertModeBeforeFirstNonBlankInLine, IS_CHANGE);
     ADDCMD("gi", commandEnterInsertModeLast, IS_CHANGE);
     ADDCMD("v", commandEnterVisualMode, 0);
     ADDCMD("V", commandEnterVisualLineMode, 0);
     ADDCMD("<c-v>", commandEnterVisualBlockMode, 0);
     ADDCMD("gv", commandReselectVisual, SHOULD_NOT_RESET);
     ADDCMD("o", commandOpenNewLineUnder, IS_CHANGE);
     ADDCMD("O", commandOpenNewLineOver, IS_CHANGE);
     ADDCMD("J", commandJoinLines, IS_CHANGE);
     ADDCMD("c", commandChange, IS_CHANGE | NEEDS_MOTION);
     ADDCMD("C", commandChangeToEOL, IS_CHANGE);
     ADDCMD("cc", commandChangeLine, IS_CHANGE);
     ADDCMD("s", commandSubstituteChar, IS_CHANGE);
     ADDCMD("S", commandSubstituteLine, IS_CHANGE);
     ADDCMD("dd", commandDeleteLine, IS_CHANGE);
     ADDCMD("d", commandDelete, IS_CHANGE | NEEDS_MOTION);
     ADDCMD("D", commandDeleteToEOL, IS_CHANGE);
     ADDCMD("x", commandDeleteChar, IS_CHANGE);
     ADDCMD("<delete>", commandDeleteChar, IS_CHANGE);
     ADDCMD("X", commandDeleteCharBackward, IS_CHANGE);
     ADDCMD("gu", commandMakeLowercase, IS_CHANGE | NEEDS_MOTION);
     ADDCMD("guu", commandMakeLowercaseLine, IS_CHANGE);
     ADDCMD("gU", commandMakeUppercase, IS_CHANGE | NEEDS_MOTION);
     ADDCMD("gUU", commandMakeUppercaseLine, IS_CHANGE);
     ADDCMD("y", commandYank, NEEDS_MOTION);
     ADDCMD("yy", commandYankLine, 0);
     ADDCMD("Y", commandYankToEOL, 0);
     ADDCMD("p", commandPaste, IS_CHANGE);
     ADDCMD("P", commandPasteBefore, IS_CHANGE);
     ADDCMD("gp", commandgPaste, IS_CHANGE);
     ADDCMD("gP", commandgPasteBefore, IS_CHANGE);
     ADDCMD("]p", commandIndentedPaste, IS_CHANGE);
     ADDCMD("[p", commandIndentedPasteBefore, IS_CHANGE);
     ADDCMD("r.", commandReplaceCharacter, IS_CHANGE | REGEX_PATTERN);
     ADDCMD("R", commandEnterReplaceMode, IS_CHANGE);
     ADDCMD(":", commandSwitchToCmdLine, 0);
     ADDCMD("u", commandUndo, 0);
     ADDCMD("<c-r>", commandRedo, 0);
     ADDCMD("U", commandRedo, 0);
     ADDCMD("m.", commandSetMark, REGEX_PATTERN);
     ADDCMD(">>", commandIndentLine, IS_CHANGE);
     ADDCMD("<<", commandUnindentLine, IS_CHANGE);
     ADDCMD(">", commandIndentLines, IS_CHANGE | NEEDS_MOTION);
     ADDCMD("<", commandUnindentLines, IS_CHANGE | NEEDS_MOTION);
     ADDCMD("<c-f>", commandScrollPageDown, 0);
     ADDCMD("<pagedown>", commandScrollPageDown, 0);
     ADDCMD("<c-b>", commandScrollPageUp, 0);
     ADDCMD("<pageup>", commandScrollPageUp, 0);
     ADDCMD("<c-u>", commandScrollHalfPageUp, 0);
     ADDCMD("<c-d>", commandScrollHalfPageDown, 0);
     ADDCMD("z.", commandCenterViewOnNonBlank, 0);
     ADDCMD("zz", commandCenterViewOnCursor, 0);
     ADDCMD("z<return>", commandTopViewOnNonBlank, 0);
     ADDCMD("zt", commandTopViewOnCursor, 0);
     ADDCMD("z-", commandBottomViewOnNonBlank, 0);
     ADDCMD("zb", commandBottomViewOnCursor, 0);
     ADDCMD("ga", commandPrintCharacterCode, SHOULD_NOT_RESET);
     ADDCMD(".", commandRepeatLastChange, 0);
     ADDCMD("==", commandAlignLine, IS_CHANGE);
     ADDCMD("=", commandAlignLines, IS_CHANGE | NEEDS_MOTION);
     ADDCMD("~", commandChangeCase, IS_CHANGE);
     ADDCMD("g~", commandChangeCaseRange, IS_CHANGE | NEEDS_MOTION);
     ADDCMD("g~~", commandChangeCaseLine, IS_CHANGE);
     ADDCMD("<c-a>", commandAddToNumber, IS_CHANGE);
     ADDCMD("<c-x>", commandSubtractFromNumber, IS_CHANGE);
     ADDCMD("<c-o>", commandGoToPrevJump, 0);
     ADDCMD("<c-i>", commandGoToNextJump, 0);
 
     ADDCMD("<c-w>h", commandSwitchToLeftView, 0);
     ADDCMD("<c-w><c-h>", commandSwitchToLeftView, 0);
     ADDCMD("<c-w><left>", commandSwitchToLeftView, 0);
     ADDCMD("<c-w>j", commandSwitchToDownView, 0);
     ADDCMD("<c-w><c-j>", commandSwitchToDownView, 0);
     ADDCMD("<c-w><down>", commandSwitchToDownView, 0);
     ADDCMD("<c-w>k", commandSwitchToUpView, 0);
     ADDCMD("<c-w><c-k>", commandSwitchToUpView, 0);
     ADDCMD("<c-w><up>", commandSwitchToUpView, 0);
     ADDCMD("<c-w>l", commandSwitchToRightView, 0);
     ADDCMD("<c-w><c-l>", commandSwitchToRightView, 0);
     ADDCMD("<c-w><right>", commandSwitchToRightView, 0);
     ADDCMD("<c-w>w", commandSwitchToNextView, 0);
     ADDCMD("<c-w><c-w>", commandSwitchToNextView, 0);
 
     ADDCMD("<c-w>s", commandSplitHoriz, 0);
     ADDCMD("<c-w>S", commandSplitHoriz, 0);
     ADDCMD("<c-w><c-s>", commandSplitHoriz, 0);
     ADDCMD("<c-w>v", commandSplitVert, 0);
     ADDCMD("<c-w><c-v>", commandSplitVert, 0);
     ADDCMD("<c-w>c", commandCloseView, 0);
 
     ADDCMD("gt", commandSwitchToNextTab, 0);
     ADDCMD("gT", commandSwitchToPrevTab, 0);
 
     ADDCMD("gqq", commandFormatLine, IS_CHANGE);
     ADDCMD("gq", commandFormatLines, IS_CHANGE | NEEDS_MOTION);
 
     ADDCMD("zo", commandExpandLocal, 0);
     ADDCMD("zc", commandCollapseLocal, 0);
     ADDCMD("za", commandToggleRegionVisibility, 0);
     ADDCMD("zr", commandExpandAll, 0);
     ADDCMD("zm", commandCollapseToplevelNodes, 0);
 
     ADDCMD("q.", commandStartRecordingMacro, REGEX_PATTERN);
     ADDCMD("@.", commandReplayMacro, REGEX_PATTERN);
 
     ADDCMD("ZZ", commandCloseWrite, 0);
     ADDCMD("ZQ", commandCloseNocheck, 0);
 
     // regular motions
     ADDMOTION("h", motionLeft, 0);
     ADDMOTION("<left>", motionLeft, 0);
     ADDMOTION("<backspace>", motionLeft, 0);
     ADDMOTION("j", motionDown, 0);
     ADDMOTION("<down>", motionDown, 0);
     ADDMOTION("<enter>", motionDownToFirstNonBlank, 0);
     ADDMOTION("<return>", motionDownToFirstNonBlank, 0);
     ADDMOTION("k", motionUp, 0);
     ADDMOTION("<up>", motionUp, 0);
     ADDMOTION("-", motionUpToFirstNonBlank, 0);
     ADDMOTION("l", motionRight, 0);
     ADDMOTION("<right>", motionRight, 0);
     ADDMOTION(" ", motionRight, 0);
     ADDMOTION("$", motionToEOL, 0);
     ADDMOTION("<end>", motionToEOL, 0);
     ADDMOTION("0", motionToColumn0, 0);
     ADDMOTION("<home>", motionToColumn0, 0);
     ADDMOTION("^", motionToFirstCharacterOfLine, 0);
     ADDMOTION("f.", motionFindChar, REGEX_PATTERN);
     ADDMOTION("F.", motionFindCharBackward, REGEX_PATTERN);
     ADDMOTION("t.", motionToChar, REGEX_PATTERN);
     ADDMOTION("T.", motionToCharBackward, REGEX_PATTERN);
     ADDMOTION(";", motionRepeatlastTF, 0);
     ADDMOTION(",", motionRepeatlastTFBackward, 0);
     ADDMOTION("n", motionFindNext, 0);
     ADDMOTION("N", motionFindPrev, 0);
     ADDMOTION("gg", motionToLineFirst, 0);
     ADDMOTION("G", motionToLineLast, 0);
     ADDMOTION("w", motionWordForward, IS_NOT_LINEWISE);
     ADDMOTION("W", motionWORDForward, IS_NOT_LINEWISE);
     ADDMOTION("<c-right>", motionWordForward, IS_NOT_LINEWISE);
     ADDMOTION("<c-left>", motionWordBackward, IS_NOT_LINEWISE);
     ADDMOTION("b", motionWordBackward, 0);
     ADDMOTION("B", motionWORDBackward, 0);
     ADDMOTION("e", motionToEndOfWord, 0);
     ADDMOTION("E", motionToEndOfWORD, 0);
     ADDMOTION("ge", motionToEndOfPrevWord, 0);
     ADDMOTION("gE", motionToEndOfPrevWORD, 0);
     ADDMOTION("|", motionToScreenColumn, 0);
     ADDMOTION("%", motionToMatchingItem, IS_NOT_LINEWISE);
     ADDMOTION("`[a-zA-Z^><\\.\\[\\]]", motionToMark, REGEX_PATTERN);
     ADDMOTION("'[a-zA-Z^><]", motionToMarkLine, REGEX_PATTERN);
     ADDMOTION("[[", motionToPreviousBraceBlockStart, IS_NOT_LINEWISE);
     ADDMOTION("]]", motionToNextBraceBlockStart, IS_NOT_LINEWISE);
     ADDMOTION("[]", motionToPreviousBraceBlockEnd, IS_NOT_LINEWISE);
     ADDMOTION("][", motionToNextBraceBlockEnd, IS_NOT_LINEWISE);
     ADDMOTION("*", motionToNextOccurrence, 0);
     ADDMOTION("#", motionToPrevOccurrence, 0);
     ADDMOTION("H", motionToFirstLineOfWindow, 0);
     ADDMOTION("M", motionToMiddleLineOfWindow, 0);
     ADDMOTION("L", motionToLastLineOfWindow, 0);
     ADDMOTION("gj", motionToNextVisualLine, 0);
     ADDMOTION("gk", motionToPrevVisualLine, 0);
     ADDMOTION("(", motionToPreviousSentence, 0 );
     ADDMOTION(")", motionToNextSentence, 0 );
     ADDMOTION("{", motionToBeforeParagraph, 0);
     ADDMOTION("}", motionToAfterParagraph, 0);
 
     // text objects
     ADDMOTION("iw", textObjectInnerWord, 0);
     ADDMOTION("aw", textObjectAWord, IS_NOT_LINEWISE);
     ADDMOTION("iW", textObjectInnerWORD, 0);
     ADDMOTION("aW", textObjectAWORD, IS_NOT_LINEWISE);
     ADDMOTION("is", textObjectInnerSentence, IS_NOT_LINEWISE );
     ADDMOTION("as", textObjectASentence, IS_NOT_LINEWISE );
     ADDMOTION("ip", textObjectInnerParagraph, IS_NOT_LINEWISE );
     ADDMOTION("ap", textObjectAParagraph, IS_NOT_LINEWISE );
     ADDMOTION("i\"", textObjectInnerQuoteDouble, IS_NOT_LINEWISE);
     ADDMOTION("a\"", textObjectAQuoteDouble, IS_NOT_LINEWISE);
     ADDMOTION("i'", textObjectInnerQuoteSingle, IS_NOT_LINEWISE);
     ADDMOTION("a'", textObjectAQuoteSingle, IS_NOT_LINEWISE);
     ADDMOTION("i`", textObjectInnerBackQuote, IS_NOT_LINEWISE);
     ADDMOTION("a`", textObjectABackQuote, IS_NOT_LINEWISE);
     ADDMOTION("i[()b]", textObjectInnerParen, REGEX_PATTERN | IS_NOT_LINEWISE);
     ADDMOTION("a[()b]", textObjectAParen, REGEX_PATTERN | IS_NOT_LINEWISE);
     ADDMOTION("i[{}B]", textObjectInnerCurlyBracket, REGEX_PATTERN | IS_NOT_LINEWISE);
     ADDMOTION("a[{}B]", textObjectACurlyBracket, REGEX_PATTERN | IS_NOT_LINEWISE);
     ADDMOTION("i[><]", textObjectInnerInequalitySign, REGEX_PATTERN | IS_NOT_LINEWISE);
     ADDMOTION("a[><]", textObjectAInequalitySign, REGEX_PATTERN | IS_NOT_LINEWISE);
     ADDMOTION("i[\\[\\]]", textObjectInnerBracket, REGEX_PATTERN | IS_NOT_LINEWISE);
     ADDMOTION("a[\\[\\]]", textObjectABracket, REGEX_PATTERN  | IS_NOT_LINEWISE);
     ADDMOTION("i,", textObjectInnerComma, IS_NOT_LINEWISE);
     ADDMOTION("a,", textObjectAComma, IS_NOT_LINEWISE);
 
     ADDMOTION("/<enter>", motionToIncrementalSearchMatch, IS_NOT_LINEWISE);
     ADDMOTION("?<enter>", motionToIncrementalSearchMatch, IS_NOT_LINEWISE);
 }
 
 QRegExp NormalViMode::generateMatchingItemRegex() const
 {
     QString pattern(QStringLiteral("\\[|\\]|\\{|\\}|\\(|\\)|"));
     QList<QString> keys = m_matchingItems.keys();
 
     for (int i = 0; i < keys.size(); i++) {
         QString s = m_matchingItems[ keys[ i ] ];
         s.replace(QRegExp(QLatin1String("^-")), QChar());
         s.replace(QRegExp(QLatin1String("\\*")), QStringLiteral("\\*"));
         s.replace(QRegExp(QLatin1String("\\+")), QStringLiteral("\\+"));
         s.replace(QRegExp(QLatin1String("\\[")), QStringLiteral("\\["));
         s.replace(QRegExp(QLatin1String("\\]")), QStringLiteral("\\]"));
         s.replace(QRegExp(QLatin1String("\\(")), QStringLiteral("\\("));
         s.replace(QRegExp(QLatin1String("\\)")), QStringLiteral("\\)"));
         s.replace(QRegExp(QLatin1String("\\{")), QStringLiteral("\\{"));
         s.replace(QRegExp(QLatin1String("\\}")), QStringLiteral("\\}"));
 
         pattern.append(s);
 
         if (i != keys.size() - 1) {
             pattern.append(QLatin1Char('|'));
         }
     }
 
     return QRegExp(pattern);
 }
 
 // returns the operation mode that should be used. this is decided by using the following heuristic:
 // 1. if we're in visual block mode, it should be Block
 // 2. if we're in visual line mode OR the range spans several lines, it should be LineWise
 // 3. if neither of these is true, CharWise is returned
 // 4. there are some motion that makes all operator charwise, if we have one of them mode will be CharWise
 OperationMode NormalViMode::getOperationMode() const
 {
     OperationMode m = CharWise;
 
     if (m_viInputModeManager->getCurrentViMode() == ViMode::VisualBlockMode) {
         m = Block;
     } else if (m_viInputModeManager->getCurrentViMode() == ViMode::VisualLineMode
                || (m_commandRange.startLine != m_commandRange.endLine
                    && m_viInputModeManager->getCurrentViMode() != ViMode::VisualMode)) {
         m = LineWise;
     }
 
     if (m_commandWithMotion && !m_linewiseCommand) {
         m = CharWise;
     }
 
     if (m_lastMotionWasLinewiseInnerBlock) {
         m = LineWise;
     }
 
     return m;
 }
 
 bool NormalViMode::paste(PasteLocation pasteLocation, bool isgPaste, bool isIndentedPaste)
 {
     KTextEditor::Cursor pasteAt(m_view->cursorPosition());
     KTextEditor::Cursor cursorAfterPaste = pasteAt;
     QChar reg = getChosenRegister(UnnamedRegister);
 
     OperationMode m = getRegisterFlag(reg);
     QString textToInsert = getRegisterContent(reg);
-    const bool isTextMultiLine = textToInsert.split(QStringLiteral("\n")).count() > 1;
+    const bool isTextMultiLine = textToInsert.count(QLatin1Char('\n')) > 0;
 
     // In temporary normal mode, p/P act as gp/gP.
     isgPaste |= m_viInputModeManager->getTemporaryNormalMode();
 
     if (textToInsert.isEmpty()) {
         error(i18n("Nothing in register %1", reg));
         return false;
     }
 
     if (getCount() > 1) {
         textToInsert = textToInsert.repeated(getCount());   // FIXME: does this make sense for blocks?
     }
 
     if (m == LineWise) {
         pasteAt.setColumn(0);
         if (isIndentedPaste) {
             // Note that this does indeed work if there is no non-whitespace on the current line or if
             // the line is empty!
             const QString leadingWhiteSpaceOnCurrentLine = doc()->line(pasteAt.line()).mid(0, doc()->line(pasteAt.line()).indexOf(QRegExp(QLatin1String("[^\\s]"))));
             const QString leadingWhiteSpaceOnFirstPastedLine = textToInsert.mid(0, textToInsert.indexOf(QRegExp(QLatin1String("[^\\s]"))));
             // QString has no "left trim" method, bizarrely.
             while (textToInsert[0].isSpace()) {
                 textToInsert = textToInsert.mid(1);
             }
             textToInsert.prepend(leadingWhiteSpaceOnCurrentLine);
             // Remove the last \n, temporarily: we're going to alter the indentation of each pasted line
             // by doing a search and replace on '\n's, but don't want to alter this one.
             textToInsert.chop(1);
             textToInsert.replace(QLatin1Char('\n') + leadingWhiteSpaceOnFirstPastedLine, QLatin1Char('\n') + leadingWhiteSpaceOnCurrentLine);
             textToInsert.append(QLatin1Char('\n')); // Re-add the temporarily removed last '\n'.
         }
         if (pasteLocation == AfterCurrentPosition) {
             textToInsert.chop(1);   // remove the last \n
             pasteAt.setColumn(doc()->lineLength(pasteAt.line()));     // paste after the current line and ...
             textToInsert.prepend(QLatin1Char('\n'));     // ... prepend a \n, so the text starts on a new line
 
             cursorAfterPaste.setLine(cursorAfterPaste.line() + 1);
         }
         if (isgPaste) {
-            cursorAfterPaste.setLine(cursorAfterPaste.line() + textToInsert.split(QStringLiteral("\n")).length() - 1);
+            cursorAfterPaste.setLine(cursorAfterPaste.line() + textToInsert.count(QLatin1Char('\n')));
         }
     } else {
         if (pasteLocation == AfterCurrentPosition) {
             // Move cursor forward one before we paste.  The position after the paste must also
             // be updated accordingly.
             if (getLine(pasteAt.line()).length() > 0) {
                 pasteAt.setColumn(pasteAt.column() + 1);
             }
             cursorAfterPaste = pasteAt;
         }
         const bool leaveCursorAtStartOfPaste = isTextMultiLine && !isgPaste;
         if (!leaveCursorAtStartOfPaste) {
             cursorAfterPaste = cursorPosAtEndOfPaste(pasteAt, textToInsert);
             if (!isgPaste) {
                 cursorAfterPaste.setColumn(cursorAfterPaste.column() - 1);
             }
         }
     }
 
     doc()->editBegin();
     if (m_view->selection()) {
         pasteAt = m_view->selectionRange().start();
         doc()->removeText(m_view->selectionRange());
     }
     doc()->insertText(pasteAt, textToInsert, m == Block);
     doc()->editEnd();
 
     if (cursorAfterPaste.line() >= doc()->lines()) {
         cursorAfterPaste.setLine(doc()->lines() - 1);
     }
     updateCursor(cursorAfterPaste);
 
     return true;
 }
 
 KTextEditor::Cursor NormalViMode::cursorPosAtEndOfPaste(const KTextEditor::Cursor &pasteLocation, const QString &pastedText) const
 {
     KTextEditor::Cursor cAfter = pasteLocation;
-    const QStringList textLines = pastedText.split(QStringLiteral("\n"));
+    const QStringList textLines = pastedText.split(QLatin1Char('\n'));
     if (textLines.length() == 1) {
         cAfter.setColumn(cAfter.column() + pastedText.length());
     } else {
         cAfter.setColumn(textLines.last().length() - 0);
         cAfter.setLine(cAfter.line() + textLines.length() - 1);
     }
     return cAfter;
 }
 
 void NormalViMode::joinLines(unsigned int from, unsigned int to) const
 {
     // make sure we don't try to join lines past the document end
     if (to >= (unsigned int)(doc()->lines())) {
         to = doc()->lines() - 1;
     }
 
     // joining one line is a no-op
     if (from == to) {
         return;
     }
 
     doc()->joinLines(from, to);
 }
 
 void NormalViMode::reformatLines(unsigned int from, unsigned int to) const
 {
     joinLines(from, to);
     doc()->wrapText(from, to);
 }
 
 int NormalViMode::getFirstNonBlank(int line) const
 {
     if (line < 0) {
         line = m_view->cursorPosition().line();
     }
 
     // doc()->plainKateTextLine returns NULL if the line is out of bounds.
     Kate::TextLine l = doc()->plainKateTextLine(line);
     Q_ASSERT(l);
 
     int c = l->firstChar();
     return (c < 0) ? 0 : c;
 }
 
 // Tries to shrinks toShrink so that it fits tightly around rangeToShrinkTo.
 void NormalViMode::shrinkRangeAroundCursor(Range &toShrink, const Range &rangeToShrinkTo) const
 {
     if (!toShrink.valid || !rangeToShrinkTo.valid) {
         return;
     }
     KTextEditor::Cursor cursorPos = m_view->cursorPosition();
     if (rangeToShrinkTo.startLine >= cursorPos.line()) {
         if (rangeToShrinkTo.startLine > cursorPos.line()) {
             // Does not surround cursor; aborting.
             return;
         }
         Q_ASSERT(rangeToShrinkTo.startLine == cursorPos.line());
         if (rangeToShrinkTo.startColumn > cursorPos.column()) {
             // Does not surround cursor; aborting.
             return;
         }
     }
     if (rangeToShrinkTo.endLine <= cursorPos.line()) {
         if (rangeToShrinkTo.endLine < cursorPos.line()) {
             // Does not surround cursor; aborting.
             return;
         }
         Q_ASSERT(rangeToShrinkTo.endLine == cursorPos.line());
         if (rangeToShrinkTo.endColumn < cursorPos.column()) {
             // Does not surround cursor; aborting.
             return;
         }
     }
 
     if (toShrink.startLine <= rangeToShrinkTo.startLine) {
         if (toShrink.startLine < rangeToShrinkTo.startLine) {
             toShrink.startLine = rangeToShrinkTo.startLine;
             toShrink.startColumn = rangeToShrinkTo.startColumn;
         }
         Q_ASSERT(toShrink.startLine == rangeToShrinkTo.startLine);
         if (toShrink.startColumn < rangeToShrinkTo.startColumn) {
             toShrink.startColumn = rangeToShrinkTo.startColumn;
         }
     }
     if (toShrink.endLine >= rangeToShrinkTo.endLine) {
         if (toShrink.endLine > rangeToShrinkTo.endLine) {
             toShrink.endLine = rangeToShrinkTo.endLine;
             toShrink.endColumn = rangeToShrinkTo.endColumn;
         }
         Q_ASSERT(toShrink.endLine == rangeToShrinkTo.endLine);
         if (toShrink.endColumn > rangeToShrinkTo.endColumn) {
             toShrink.endColumn = rangeToShrinkTo.endColumn;
         }
     }
 }
 
 Range NormalViMode::textObjectComma(bool inner) const
 {
     // Basic algorithm: look left and right of the cursor for all combinations
     // of enclosing commas and the various types of brackets, and pick the pair
     // closest to the cursor that surrounds the cursor.
     Range r(0, 0, m_view->doc()->lines(), m_view->doc()->line(m_view->doc()->lastLine()).length(), InclusiveMotion);
 
     shrinkRangeAroundCursor(r, findSurroundingQuotes(QLatin1Char(','), inner));
     shrinkRangeAroundCursor(r, findSurroundingBrackets(QLatin1Char('('), QLatin1Char(')'), inner, QLatin1Char('('), QLatin1Char(')')));
     shrinkRangeAroundCursor(r, findSurroundingBrackets(QLatin1Char('{'), QLatin1Char('}'), inner, QLatin1Char('{'), QLatin1Char('}')));
     shrinkRangeAroundCursor(r, findSurroundingBrackets(QLatin1Char(','), QLatin1Char(')'), inner, QLatin1Char('('), QLatin1Char(')')));
     shrinkRangeAroundCursor(r, findSurroundingBrackets(QLatin1Char(','), QLatin1Char(']'), inner, QLatin1Char('['), QLatin1Char(']')));
     shrinkRangeAroundCursor(r, findSurroundingBrackets(QLatin1Char(','), QLatin1Char('}'), inner, QLatin1Char('{'), QLatin1Char('}')));
     shrinkRangeAroundCursor(r, findSurroundingBrackets(QLatin1Char('('), QLatin1Char(','), inner, QLatin1Char('('), QLatin1Char(')')));
     shrinkRangeAroundCursor(r, findSurroundingBrackets(QLatin1Char('['), QLatin1Char(','), inner, QLatin1Char('['), QLatin1Char(']')));
     shrinkRangeAroundCursor(r, findSurroundingBrackets(QLatin1Char('{'), QLatin1Char(','), inner, QLatin1Char('{'), QLatin1Char('}')));
     return r;
 }
 
 void NormalViMode::updateYankHighlightAttrib()
 {
     if (!m_highlightYankAttribute) {
         m_highlightYankAttribute = new KTextEditor::Attribute;
     }
     const QColor &yankedColor = m_view->renderer()->config()->savedLineColor();
     m_highlightYankAttribute->setBackground(yankedColor);
     KTextEditor::Attribute::Ptr mouseInAttribute(new KTextEditor::Attribute());
     mouseInAttribute->setFontBold(true);
     m_highlightYankAttribute->setDynamicAttribute(KTextEditor::Attribute::ActivateMouseIn, mouseInAttribute);
     m_highlightYankAttribute->dynamicAttribute(KTextEditor::Attribute::ActivateMouseIn)->setBackground(yankedColor);
 }
 
 void NormalViMode::highlightYank(const Range &range, const OperationMode mode)
 {
     clearYankHighlight();
 
     // current MovingRange doesn't support block mode selection so split the
     // block range into per-line ranges
     if (mode == Block) {
         for (int i = range.startLine; i <= range.endLine; i++) {
             addHighlightYank(KTextEditor::Range(i, range.startColumn, i, range.endColumn));
         }
     } else {
         addHighlightYank(KTextEditor::Range(range.startLine, range.startColumn, range.endLine, range.endColumn));
     }
 }
 
 void NormalViMode::addHighlightYank(const KTextEditor::Range &yankRange)
 {
     KTextEditor::MovingRange *highlightedYank = m_view->doc()->newMovingRange(yankRange, Kate::TextRange::DoNotExpand);
     highlightedYank->setView(m_view); // show only in this view
     highlightedYank->setAttributeOnlyForViews(true);
     // use z depth defined in moving ranges interface
     highlightedYank->setZDepth(-10000.0);
     highlightedYank->setAttribute(m_highlightYankAttribute);
 
     highlightedYankForDocument().insert(highlightedYank);
 }
 
 void NormalViMode::clearYankHighlight()
 {
     QSet<KTextEditor::MovingRange *> &pHighlightedYanks = highlightedYankForDocument();
     qDeleteAll(pHighlightedYanks);
     pHighlightedYanks.clear();
 }
 
 void NormalViMode::aboutToDeleteMovingInterfaceContent()
 {
     QSet<KTextEditor::MovingRange *> &pHighlightedYanks = highlightedYankForDocument();
     // Prevent double-deletion in case this NormalMode is deleted.
     pHighlightedYanks.clear();
 }
 
 QSet<KTextEditor::MovingRange *> &NormalViMode::highlightedYankForDocument()
 {
     // Work around the fact that both Normal and Visual mode will have their own m_highlightedYank -
     // make Normal's the canonical one.
     return m_viInputModeManager->getViNormalMode()->m_highlightedYanks;
 }
 
 bool NormalViMode::waitingForRegisterOrCharToSearch()
 {
     // r, q, @ are never preceded by operators. There will always be a keys size of 1 for them.
     // f, t, F, T can be preceded by a delete/replace/yank/indent operator. size = 2 in that case.
     // f, t, F, T can be preceded by 'g' case/formatting operators. size = 3 in that case.
     const int keysSize = m_keys.size();
     if (keysSize < 1) {
         // Just being defensive there.
         return false;
     }
     if (keysSize > 1) {
         // Multi-letter operation.
         QChar cPrefix = m_keys[0];
         if (keysSize == 2) {
             // delete/replace/yank/indent operator?
             if (cPrefix != QLatin1Char('c') &&
                 cPrefix != QLatin1Char('d') &&
                 cPrefix != QLatin1Char('y') &&
                 cPrefix != QLatin1Char('=') &&
                 cPrefix != QLatin1Char('>') &&
                 cPrefix != QLatin1Char('<')) {
                 return false;
             }
         } else if (keysSize == 3) {
             // We need to look deeper. Is it a g motion?
             QChar cNextfix = m_keys[1];
             if (cPrefix != QLatin1Char('g') || (
                 cNextfix != QLatin1Char('U') &&
                 cNextfix != QLatin1Char('u') &&
                 cNextfix != QLatin1Char('~') &&
                 cNextfix != QLatin1Char('q') &&
                 cNextfix != QLatin1Char('w') &&
                 cNextfix != QLatin1Char('@'))) {
                 return false;
             }
         } else {
             return false;
         }
     }
 
     QChar ch = m_keys[keysSize - 1];
     return (ch == QLatin1Char('f') || ch == QLatin1Char('t')
             || ch == QLatin1Char('F') || ch == QLatin1Char('T')
             // c/d prefix unapplicable for the following cases.
             || (keysSize == 1 && (ch == QLatin1Char('r')
             || ch == QLatin1Char('q') || ch == QLatin1Char('@'))));
 }
 
 void NormalViMode::textInserted(KTextEditor::Document *document, KTextEditor::Range range)
 {
     Q_UNUSED(document);
     const bool isInsertReplaceMode = (m_viInputModeManager->getCurrentViMode() == ViMode::InsertMode || m_viInputModeManager->getCurrentViMode() == ViMode::ReplaceMode);
     const bool continuesInsertion = range.start().line() == m_currentChangeEndMarker.line() && range.start().column() == m_currentChangeEndMarker.column();
     const bool beginsWithNewline = doc()->text(range).at(0) == QLatin1Char('\n');
     if (!continuesInsertion) {
         KTextEditor::Cursor newBeginMarkerPos = range.start();
         if (beginsWithNewline && !isInsertReplaceMode) {
             // Presumably a linewise paste, in which case we ignore the leading '\n'
             newBeginMarkerPos = KTextEditor::Cursor(newBeginMarkerPos.line() + 1, 0);
         }
         m_viInputModeManager->marks()->setStartEditYanked(newBeginMarkerPos);
     }
     m_viInputModeManager->marks()->setLastChange(range.start());
     KTextEditor::Cursor editEndMarker = range.end();
     if (!isInsertReplaceMode) {
         editEndMarker.setColumn(editEndMarker.column() - 1);
     }
     m_viInputModeManager->marks()->setFinishEditYanked(editEndMarker);
     m_currentChangeEndMarker = range.end();
     if (m_isUndo) {
         const bool addsMultipleLines = range.start().line() != range.end().line();
         m_viInputModeManager->marks()->setStartEditYanked(KTextEditor::Cursor(m_viInputModeManager->marks()->getStartEditYanked().line(), 0));
         if (addsMultipleLines) {
             m_viInputModeManager->marks()->setFinishEditYanked(KTextEditor::Cursor(m_viInputModeManager->marks()->getFinishEditYanked().line() + 1, 0));
             m_viInputModeManager->marks()->setLastChange(KTextEditor::Cursor(m_viInputModeManager->marks()->getLastChange().line() + 1, 0));
         } else {
             m_viInputModeManager->marks()->setFinishEditYanked(KTextEditor::Cursor(m_viInputModeManager->marks()->getFinishEditYanked().line(), 0));
             m_viInputModeManager->marks()->setLastChange(KTextEditor::Cursor(m_viInputModeManager->marks()->getLastChange().line(), 0));
         }
     }
 }
 
 void NormalViMode::textRemoved(KTextEditor::Document *document, KTextEditor::Range range)
 {
     Q_UNUSED(document);
     const bool isInsertReplaceMode = (m_viInputModeManager->getCurrentViMode() == ViMode::InsertMode || m_viInputModeManager->getCurrentViMode() == ViMode::ReplaceMode);
     m_viInputModeManager->marks()->setLastChange(range.start());
     if (!isInsertReplaceMode) {
         // Don't go resetting [ just because we did a Ctrl-h!
         m_viInputModeManager->marks()->setStartEditYanked(range.start());
     } else {
         // Don't go disrupting our continued insertion just because we did a Ctrl-h!
         m_currentChangeEndMarker = range.start();
     }
     m_viInputModeManager->marks()->setFinishEditYanked(range.start());
     if (m_isUndo) {
         // Slavishly follow Vim's weird rules: if an undo removes several lines, then all markers should
         // be at the beginning of the line after the last line removed, else they should at the beginning
         // of the line above that.
         const int markerLineAdjustment = (range.start().line() != range.end().line()) ? 1 : 0;
         m_viInputModeManager->marks()->setStartEditYanked(KTextEditor::Cursor(m_viInputModeManager->marks()->getStartEditYanked().line() + markerLineAdjustment, 0));
         m_viInputModeManager->marks()->setFinishEditYanked(KTextEditor::Cursor(m_viInputModeManager->marks()->getFinishEditYanked().line() + markerLineAdjustment, 0));
         m_viInputModeManager->marks()->setLastChange(KTextEditor::Cursor(m_viInputModeManager->marks()->getLastChange().line() + markerLineAdjustment, 0));
     }
 }
 
 void NormalViMode::undoBeginning()
 {
     m_isUndo = true;
 }
 
 void NormalViMode::undoEnded()
 {
     m_isUndo = false;
 }
 
 bool NormalViMode::executeKateCommand(const QString &command)
 {
     KTextEditor::Command *p = KateCmd::self()->queryCommand(command);
 
     if (!p) {
         return false;
     }
 
     QString msg;
     return p->exec(m_view, command, msg);
 }