How do I change the word boundaries of forward-word and backward-word?

[whitesnakeftw]

How do I change the behavior of forward-word and backward-word so that it behaves like regular cmd? In other words, when I press Ctrl + Right I want the cursor to move right up until a space is found, not up to the end of the word (\b).

[chrisant996]

There isn't a way at this time.

You could write custom commands in Lua, though.

Or you could modify the Clink source code and add new commands written in C.

[chrisant996]

@whitesnakeftw I went to add commands, but then I realized commands already exist for this! I never use vi mode, so it hadn't occurred to me to look at the vi mode commands.

Adding the following key bindings to your .inputrc file will make Ctrl- Left and Right move the same way as they do in plain CMD.exe.

"\e[1;5D":    vi-backward-bigword
"\e[1;5C":    vi-forward-bigword

None of the vi commands in Readline are documented, so it wouldn't have been easy to find them.

I'll look into either documenting some of them (but that's kind of weird), or adding new documented command names that aren't vi-specific.

[whitesnakeftw]

Not sure about this, for me this whole block:

"\e[1;5D":    vi-backward-bigword
"\e[1;5C":    vi-forward-bigword
Rubout:       "\e[1;5C\C-w"

behaves perfectly. If the cursor is pointing at the space between the two words, it will only delete the word on the left. It will delete the word on the right if it's pointing at the first letter of the word on the right, like this:

foo bar

which is intended behavior (at least for me).

If I change vi-forward-bigword with vi-end-bigword it behaves like you described: when the cursor is in the space between two words, it will delete the word on the right, which is not intended behavior (also, it seems like it never deletes the last character of a word for some reason), so I'm definitely going to stick with the above bindings. :)

[whitesnakeftw]

@chrisant996

It sounds like your intent is for this key to only be pressed in/after the last word in the input line, and not used earlier than that in the input line.

Your concern was justified, I've only now realized that there is a problem with my bindings. In particular, if I find myself in the middle of a command like this:

foo bar baz

Ctrl + Backspace correctly deletes all of "bar", but places the cursor at the start of the word on the right, like this:

foo baz

so if I were to press Ctrl + Backspace again, I would now delete "baz" instead of "foo". So to fix it and make it more robust I simply inserted a Left after the deletion:

"\e[1;5D":    vi-backward-bigword
"\e[1;5C":    vi-forward-bigword
Rubout:      "\e[1;5C\C-w\e[D"

Maybe not the best implementation, but these basic commands should now behave exactly like vanilla cmd.

[chrisant996]

So to fix it and make it more robust I simply inserted a Left after the deletion:

"\e[1;5D":    vi-backward-bigword
"\e[1;5C":    vi-forward-bigword
Rubout:      "\e[1;5C\C-w\e[D"

Maybe not the best implementation, but these basic commands should now behave exactly like vanilla cmd.

FWIW, that's not how Ctrl-Backspace works in vanilla cmd. The unix-word-rubout command by itself is what vanilla cmd does in response to Ctrl-Backspace. Except that unix-word-rubout also puts the deleted word into the kill ring for retrieval again later (e.g. by Ctrl-y for yank).

But I think you mean that you explicitly do not want CMD behavior for Ctrl-Backspace.

And with the new approach, you have to explicitly press Right or Space to continue typing after deleting a word, otherwise the new word ends up concatenated with the old word.

I don't think that a macro combining keystrokes will achieve quite what you want.

You would need to write a Lua function.

Pseudo code:

• If not at beginning of word and cursor is not in whitespace, then vi-forward-bigword (or clink-forward-bigword in v1.6.1 and higher).
• unix-word-rubout.

Lua example:

function my_kill_word(rl_buffer)
    -- Do nothing at beginning of line (otherwise it deletes the first word).
    local pos = rl_buffer:getcursor()
    if pos <= 1 then
        return
    end

    -- If in a word but not at the beginning of a word, go to end of word.
    -- Going to the end of the current word is so behavior is consistent
    -- with respect to whether it deletes spaces after the word (i.e. don't).
    local line = rl_buffer:getbuffer()
    local before = line:sub(pos - 1, pos - 1)
    local current = line:sub(pos, pos)
    if before ~= "" and before ~= " " then          -- "" at beginning of line.
        if current ~= "" and current ~= " " then    -- "" at end of line.
            -- Go forward to beginning of next bigword.
            rl.invokecommand('vi-forward-bigword')
            -- Go back to the beginning of the word before.
            rl.invokecommand('backward-word')
            -- Go forward to the end of the word.
            -- Thus the cursor is right after the end of the word
            -- that was under the cursor.
            rl.invokecommand('forward-word')
        end
    end

    -- Now kill the preceding word, using spaces as the word delimiter.
    rl.invokecommand('unix-word-rubout')
end

rl.setbinding([["\C-?"]], '"luafunc:my_kill_word"')
rl.describemacro('luafunc:my_kill_word', 'Delete the current word or word behind the cursor point, using white space as a word boundary. The killed text is saved on the kill-ring.')

[whitesnakeftw]

FWIW, that's not how Ctrl-Backspace works in vanilla cmd. The unix-word-rubout command by itself is what vanilla cmd does in response to Ctrl-Backspace. Except that unix-word-rubout also puts the deleted word into the kill ring for retrieval again later (e.g. by Ctrl-y for yank).

I definitely got confused there. For a moment I thought vanilla cmd also deleted the portion of a word right of the cursor, which it doesn't. I had also not thought about the implications for Ctrl + Y.

But I think you mean that you explicitly do not want CMD behavior for Ctrl-Backspace.

Yes, I realize now that I don't want the vanilla cmd behavior for Ctrl + Backspace.

And with the new approach, you have to explicitly press Right or Space to continue typing after deleting a word, otherwise the new word ends up concatenated with the old word.

I don't think that a macro combining keystrokes will achieve quite what you want.

Yeah, I've just tried this:

Rubout:       "\e[1;5C\C-w\e[D  \e[D"

which works nicely for the deletion itself, but if you want to retrieve the deleted word with Ctrl + Y, it also brings back the extra spaces that I put there, which is not pretty (I might try to redefine yank as well but that sounds like a slippery slope).

You would need to write a Lua function.

Just put your lua script inside %localappdata%\clink and it seems to work flawlessly. Thanks for all your help. :)

[chrisant996]

which works nicely for the deletion itself, but if you want to retrieve the deleted word with Ctrl + Y, it also brings back the extra spaces that I put there, which is not pretty (I might try to redefine yank as well but that sounds like a slippery slope).

Yes, very much a slippery slope (yank isn't the only thing that uses the kill ring). It would be much simpler and much less work to instead make a deletion command that only puts into the kill ring the parts that are intended to go in the kill ring, and if anything else needs to be deleted, then delete the other things using mechanisms that don't put text into the kill ring.