在 vim 中粘贴时转义字符

Question

I copy stuff from output buffers into C++ code I'm working on in vim. Often this output gets stuck into strings. And it'd be nice to be able to escape all the control characters automatically rather than going back and hand editing the pasted fragment.

As an example I might copy something like this:

error in file "foo.dat"

And need to put it into something like this

std::string expected_error = "error in file \"foo.dat\""

I'm thinking it might be possible to apply a replace function to the body of the last paste using the start and end marks of the last paste, but I'm not sure how to make it fly.

UPDATE:

Joey Mazzarelli sugested using

`[v`]h:%s/\%V"/\\"/g

after a paste.

Since no explaination was given for what that was going and I initially found it a bit terse, but hard to explain in the comments I thought I'd put an explaination of what I think that does here:

`[  : Move to start of last paste
v   : Start visual mode
`]  : Move to end of last paste
h   : adjust cursor one position left
:%  : apply on the lines of the selection
s/  : replace
\%V : within the visual area
"   : "
/   : with
\\" : \"
/g  : all occurrences

This seems like a good approach, but only handles the one character, ", I'd like it to handle newlines, tabs, and other things that might be expected to fall in text. (Probably not general unicode though) I understand that may not have been clear in the problem definition.

Answer 1

Here are a couple of vimscript functions that should do what you want.

• EscapeText() transforms arbitrary text to the C-escaped equivalent. It converts newline to \\n , tab to \\t , Control+G to \\a , etc., and generates octal escapes (like \\o032 ) for special characters that don't have a friendly name.

• PasteEscapedRegister() escapes the contents of the register named by v:register , then inserts it into the current buffer. (The register is restored when the function returns, so the function can be called repeatedly without escaping the register contents multiple times.)

There are also a couple of key mappings included to make PasteEscapedRegister() easy to use interactively. <Leader>P pastes escaped register contents before the cursor position, and <Leader>p pastes after. Both can be prefixed with a register specification, like "a\\P to paste the escaped contents of register a.

Here's the code:

function! EscapeText(text)

    let l:escaped_text = a:text

    " Map characters to named C backslash escapes. Normally, single-quoted
    " strings don't require double-backslashing, but these are necessary
    " to make the substitute() call below work properly.
    "
    let l:charmap = {
    \   '"'     : '\\"',
    \   "'"     : '\\''',
    \   "\n"    : '\\n',
    \   "\r"    : '\\r',
    \   "\b"    : '\\b',
    \   "\t"    : '\\t',
    \   "\x07"  : '\\a',
    \   "\x0B"  : '\\v',
    \   "\f"    : '\\f',
    \   }

    " Escape any existing backslashes in the text first, before
    " generating new ones. (Vim dictionaries iterate in arbitrary order,
    " so this step can't be combined with the items() loop below.)
    "
    let l:escaped_text = substitute(l:escaped_text, "\\", '\\\', 'g')

    " Replace actual returns, newlines, tabs, etc., with their escaped
    " representations.
    "
    for [original, escaped] in items(charmap)
        let l:escaped_text = substitute(l:escaped_text, original, escaped, 'g')
    endfor

    " Replace any other character that isn't a letter, number,
    " punctuation, or space with a 3-digit octal escape sequence. (Octal
    " is used instead of hex, since octal escapes terminate after 3
    " digits. C allows hex escapes of any length, so it's possible for
    " them to run up against subsequent characters that might be valid
    " hex digits.)
    "
    let l:escaped_text = substitute(l:escaped_text,
    \   '\([^[:alnum:][:punct:] ]\)',
    \   '\="\\o" . printf("%03o",char2nr(submatch(1)))',
    \   'g')

    return l:escaped_text

endfunction


function! PasteEscapedRegister(where)

    " Remember current register name, contents, and type,
    " so they can be restored once we're done.
    "
    let l:save_reg_name     = v:register
    let l:save_reg_contents = getreg(l:save_reg_name, 1)
    let l:save_reg_type     = getregtype(l:save_reg_name)

    echo "register: [" . l:save_reg_name . "] type: [" . l:save_reg_type . "]"

    " Replace the contents of the register with the escaped text, and set the
    " type to characterwise (so pasting into an existing double-quoted string,
    " for example, will work as expected).
    " 
    call setreg(l:save_reg_name, EscapeText(getreg(l:save_reg_name)), "c")

    " Build the appropriate normal-mode paste command.
    " 
    let l:cmd = 'normal "' . l:save_reg_name . (a:where == "before" ? "P" : "p")

    " Insert the escaped register contents.
    "
    exec l:cmd

    " Restore the register to its original value and type.
    " 
    call setreg(l:save_reg_name, l:save_reg_contents, l:save_reg_type)

endfunction

" Define keymaps to paste escaped text before or after the cursor.
"
nmap <Leader>P :call PasteEscapedRegister("before")<cr>
nmap <Leader>p :call PasteEscapedRegister("after")<cr>

Answer 2

This might at least get you started...

After pasting it in:

`[v`]h:%s/\%V"/\\"/g

You can obviously map that to something easier to type.

Answer 3

While Joeys solution looks like it might be extensible to cover all the cases that I need, I thought I'd share my partial solution using vims python integration (Since I'm more familiar at python than vim script)

# FILE : tocstring.py
import vim
def setRegister(reg, value):
  vim.command( "let @%s='%s'" % (reg, value.replace("'","''") ) )

def getRegister(reg):
  return vim.eval("@%s" % reg )

def transformChar( map, c):
  if c in map:
    return map[c]
  return c

def transformText( map, text ):
  return ''.join( [ transformChar(map,c) for c in text ] )

cmap={}
cmap["\\"]="\\\\"
cmap["\n"]="\\n" 
cmap["\t"]=r"\\t"
cmap['"']="\\\""

def convertToCString( inregister, outregister ):
  setRegister(outregister, transformText( cmap, getRegister(inregister) ) )

Then in my .vimrc or other conf file I can put

# FILE cpp.vim
python import tocstring
# C-Escape and paste the currently yanked content
nmap <Leader>P :python tocstring.convertToCString("@","z")<CR>"zP
# C-Escape and paste the current visual selection
vmap <Leader>P "zd:python tocstring.convertToCString("z","z")<CR>"zP

It would be nice if I could the first function to work so that "a\\P pasted the transformed contents of the "a" register, and I assume this is doable using v:register somehow, but it escapes me.

A version of this that works in the same way as Joeys solution could be crafted as

nmap <Leader>P `[v`]"zd:python tocstring.convertToCString("z","z")<CR>"zP

Acknowledgement : This uses code from Can you access registers from python functions in vim for interacting with registers from vims python

Answer 4

for Java/JavaScript type of escaping one can use json_encode

nmap <leader>jp :call setreg('e', json_encode(@+))\| normal "ep<CR>

json_encode(@+) - json encode content of register + (mapped to clipboard)

setreg('e',...) - write it to register e

normal "ep - paste content of register e