Submission #1136407

#	Time	Username	Problem	Language	Result	Execution time	Memory
1136407		horiseun	Fish 3 (JOI24_fish3)	C++20	Compilation error	0 ms	0 KiB

Main

" Insert or delete brackets, parens, quotes in pairs.
" Maintainer:	JiangMiao <[email protected]>
" Contributor: camthompson
" Last Change:  2019-02-02
" Version: 2.0.0
" Homepage: http://www.vim.org/scripts/script.php?script_id=3599
" Repository: https://github.com/jiangmiao/auto-pairs
" License: MIT

if exists('g:AutoPairsLoaded') || &cp
  finish
end
let g:AutoPairsLoaded = 1

if !exists('g:AutoPairs')
  let g:AutoPairs = {'(':')', '[':']', '{':'}',"'":"'",'"':'"', '```':'```', '"""':'"""', "'''":"'''", "`":"`"}
end

" default pairs base on filetype
func! AutoPairsDefaultPairs()
  if exists('b:autopairs_defaultpairs')
    return b:autopairs_defaultpairs
  end
  let r = copy(g:AutoPairs)
  let allPairs = {
        \ 'vim': {'\v^\s*\zs"': ''},
        \ 'rust': {'\w\zs<': '>', '&\zs''': ''},
        \ 'php': {'<?': '?>//k]', '<?php': '?>//k]'}
        \ }
  for [filetype, pairs] in items(allPairs)
    if &filetype == filetype
      for [open, close] in items(pairs)
        let r[open] = close
      endfor
    end
  endfor
  let b:autopairs_defaultpairs = r
  return r
endf

if !exists('g:AutoPairsMapBS')
  let g:AutoPairsMapBS = 1
end

" Map <C-h> as the same BS
if !exists('g:AutoPairsMapCh')
  let g:AutoPairsMapCh = 1
end

if !exists('g:AutoPairsMapCR')
  let g:AutoPairsMapCR = 1
end

if !exists('g:AutoPairsWildClosedPair')
  let g:AutoPairsWildClosedPair = ''
end

if !exists('g:AutoPairsMapSpace')
  let g:AutoPairsMapSpace = 1
end

if !exists('g:AutoPairsCenterLine')
  let g:AutoPairsCenterLine = 1
end

if !exists('g:AutoPairsShortcutToggle')
  let g:AutoPairsShortcutToggle = '<M-p>'
end

if !exists('g:AutoPairsShortcutFastWrap')
  let g:AutoPairsShortcutFastWrap = '<M-e>'
end

if !exists('g:AutoPairsMoveCharacter')
  let g:AutoPairsMoveCharacter = "()[]{}\"'"
end

if !exists('g:AutoPairsShortcutJump')
  let g:AutoPairsShortcutJump = '<M-n>'
endif

" Fly mode will for closed pair to jump to closed pair instead of insert.
" also support AutoPairsBackInsert to insert pairs where jumped.
if !exists('g:AutoPairsFlyMode')
  let g:AutoPairsFlyMode = 0
endif

" When skipping the closed pair, look at the current and
" next line as well.
if !exists('g:AutoPairsMultilineClose')
  let g:AutoPairsMultilineClose = 1
endif

" Work with Fly Mode, insert pair where jumped
if !exists('g:AutoPairsShortcutBackInsert')
  let g:AutoPairsShortcutBackInsert = '<M-b>'
endif

if !exists('g:AutoPairsSmartQuotes')
  let g:AutoPairsSmartQuotes = 1
endif

" 7.4.849 support <C-G>U to avoid breaking '.'
" Issue talk: https://github.com/jiangmiao/auto-pairs/issues/3
" Vim note: https://github.com/vim/vim/releases/tag/v7.4.849
if v:version > 704 || v:version == 704 && has("patch849")
  let s:Go = "\<C-G>U"
else
  let s:Go = ""
endif

let s:Left = s:Go."\<LEFT>"
let s:Right = s:Go."\<RIGHT>"




" unicode len
func! s:ulen(s)
  return len(split(a:s, '\zs'))
endf

func! s:left(s)
  return repeat(s:Left, s:ulen(a:s))
endf

func! s:right(s)
  return repeat(s:Right, s:ulen(a:s))
endf

func! s:delete(s)
  return repeat("\<DEL>", s:ulen(a:s))
endf

func! s:backspace(s)
  return repeat("\<BS>", s:ulen(a:s))
endf

func! s:getline()
  let line = getline('.')
  let pos = col('.') - 1
  let before = strpart(line, 0, pos)
  let after = strpart(line, pos)
  let afterline = after
  if g:AutoPairsMultilineClose
    let n = line('$')
    let i = line('.')+1
    while i <= n
      let line = getline(i)
      let after = after.' '.line
      if !(line =~ '\v^\s*$')
        break
      end
      let i = i+1
    endwhile
  end
  return [before, after, afterline]
endf

" split text to two part
" returns [orig, text_before_open, open]
func! s:matchend(text, open)
    let m = matchstr(a:text, '\V'.a:open.'\v$')
    if m == ""
      return []
    end
    return [a:text, strpart(a:text, 0, len(a:text)-len(m)), m]
endf

" returns [orig, close, text_after_close]
func! s:matchbegin(text, close)
    let m = matchstr(a:text, '^\V'.a:close)
    if m == ""
      return []
    end
    return [a:text, m, strpart(a:text, len(m), len(a:text)-len(m))]
endf

" add or delete pairs base on g:AutoPairs
" AutoPairsDefine(addPairs:dict[, removeOpenPairList:list])
"
" eg:
"   au FileType html let b:AutoPairs = AutoPairsDefine({'<!--' : '-->'}, ['{'])
"   add <!-- --> pair and remove '{' for html file
func! AutoPairsDefine(pairs, ...)
  let r = AutoPairsDefaultPairs()
  if a:0 > 0
    for open in a:1
      unlet r[open]
    endfor
  end
  for [open, close] in items(a:pairs)
    let r[open] = close
  endfor
  return r
endf

func! AutoPairsInsert(key)
  if !b:autopairs_enabled
    return a:key
  end

  let b:autopairs_saved_pair = [a:key, getpos('.')]

  let [before, after, afterline] = s:getline()

  " Ignore auto close if prev character is \
  if before[-1:-1] == '\'
    return a:key
  end

  " check open pairs
  for [open, close, opt] in b:AutoPairsList
    let ms = s:matchend(before.a:key, open)
    let m = matchstr(afterline, '^\v\s*\zs\V'.close)
    if len(ms) > 0
      " process the open pair
      
      " remove inserted pair
      " eg: if the pairs include < > and  <!-- --> 
      " when <!-- is detected the inserted pair < > should be clean up 
      let target = ms[1]
      let openPair = ms[2]
      if len(openPair) == 1 && m == openPair
        break
      end
      let bs = ''
      let del = ''
      while len(before) > len(target)
        let found = 0
        " delete pair
        for [o, c, opt] in b:AutoPairsList
          let os = s:matchend(before, o)
          if len(os) && len(os[1]) < len(target)
            " any text before openPair should not be deleted
            continue
          end
          let cs = s:matchbegin(afterline, c)
          if len(os) && len(cs)
            let found = 1
            let before = os[1]
            let afterline = cs[2]
            let bs = bs.s:backspace(os[2])
            let del = del.s:delete(cs[1])
            break
          end
        endfor
        if !found
          " delete charactor
          let ms = s:matchend(before, '\v.')
          if len(ms)
            let before = ms[1]
            let bs = bs.s:backspace(ms[2])
          end
        end
      endwhile
      return bs.del.openPair.close.s:left(close)
    end
  endfor

  " check close pairs
  for [open, close, opt] in b:AutoPairsList
    if close == ''
      continue
    end
    if a:key == g:AutoPairsWildClosedPair || opt['mapclose'] && opt['key'] == a:key
      " the close pair is in the same line
      let m = matchstr(afterline, '^\v\s*\V'.close)
      if m != ''
        if before =~ '\V'.open.'\v\s*$' && m[0] =~ '\v\s'
          " remove the space we inserted if the text in pairs is blank
          return "\<DEL>".s:right(m[1:])
        else
          return s:right(m)
        end
      end
      let m = matchstr(after, '^\v\s*\zs\V'.close)
      if m != ''
        if a:key == g:AutoPairsWildClosedPair || opt['multiline']
          if b:autopairs_return_pos == line('.') && getline('.') =~ '\v^\s*$'
            normal! ddk$
          end
          call search(m, 'We')
          return "\<Right>"
        else
          break
        end
      end
    end
  endfor


  " Fly Mode, and the key is closed-pairs, search closed-pair and jump
  if g:AutoPairsFlyMode &&  a:key =~ '\v[\}\]\)]'
    if search(a:key, 'We')
      return "\<Right>"
    endif
  endif

  return a:key
endf

func! AutoPairsDelete()
  if !b:autopairs_enabled
    return "\<BS>"
  end

  let [before, after, ig] = s:getline()
  for [open, close, opt] in b:AutoPairsList
    let b = matchstr(before, '\V'.open.'\v\s?$')
    let a = matchstr(after, '^\v\s*\V'.close)
    if b != '' && a != ''
      if b[-1:-1] == ' '
        if a[0] == ' '
          return "\<BS>\<DELETE>"
        else
          return "\<BS>"
        end
      end
      return s:backspace(b).s:delete(a)
    end
  endfor

  return "\<BS>"
  " delete the pair foo[]| <BS> to foo
  for [open, close, opt] in b:AutoPairsList
    let m = s:matchend(before, '\V'.open.'\v\s*'.'\V'.close.'\v$')
    if len(m) > 0
      return s:backspace(m[2])
    end
  endfor
  return "\<BS>"
endf


" Fast wrap the word in brackets
func! AutoPairsFastWrap()
  let c = @"
  normal! x
  let [before, after, ig] = s:getline()
  if after[0] =~ '\v[\{\[\(\<]'
    normal! %
    normal! p
  else
    for [open, close, opt] in b:AutoPairsList
      if close == ''
        continue
      end
      if after =~ '^\s*\V'.open
        call search(close, 'We')
        normal! p
        let @" = c
        return ""
      end
    endfor
    if after[1:1] =~ '\v\w'
      normal! e
      normal! p
    else
      normal! p
    end
  end
  let @" = c
  return ""
endf

func! AutoPairsJump()
  call search('["\]'')}]','W')
endf

func! AutoPairsMoveCharacter(key)
  let c = getline(".")[col(".")-1]
  let escaped_key = substitute(a:key, "'", "''", 'g')
  return "\<DEL>\<ESC>:call search("."'".escaped_key."'".")\<CR>a".c."\<LEFT>"
endf

func! AutoPairsBackInsert()
  let pair = b:autopairs_saved_pair[0]
  let pos  = b:autopairs_saved_pair[1]
  call setpos('.', pos)
  return pair
endf

func! AutoPairsReturn()
  if b:autopairs_enabled == 0
    return ''
  end
  let b:autopairs_return_pos = 0
  let before = getline(line('.')-1)
  let [ig, ig, afterline] = s:getline()
  let cmd = ''
  for [open, close, opt] in b:AutoPairsList
    if close == ''
      continue
    end

    if before =~ '\V'.open.'\v\s*$' && afterline =~ '^\s*\V'.close
      let b:autopairs_return_pos = line('.')
      if g:AutoPairsCenterLine && winline() * 3 >= winheight(0) * 2
        " Recenter before adding new line to avoid replacing line content
        let cmd = "zz"
      end

      " If equalprg has been set, then avoid call =
      " https://github.com/jiangmiao/auto-pairs/issues/24
      if &equalprg != ''
        return "\<ESC>".cmd."O"
      endif

      " conflict with javascript and coffee
      " javascript   need   indent new line
      " coffeescript forbid indent new line
      if &filetype == 'coffeescript' || &filetype == 'coffee'
        return "\<ESC>".cmd."k==o"
      else
        return "\<ESC>".cmd."=ko"
      endif
    end
  endfor
  return ''
endf

func! AutoPairsSpace()
  if !b:autopairs_enabled
    return "\<SPACE>"
  end

  let [before, after, ig] = s:getline()

  for [open, close, opt] in b:AutoPairsList
    if close == ''
      continue
    end
    if before =~ '\V'.open.'\v$' && after =~ '^\V'.close
      if close =~ '\v^[''"`]$'
        return "\<SPACE>"
      else
        return "\<SPACE>\<SPACE>".s:Left
      end
    end
  endfor
  return "\<SPACE>"
endf

func! AutoPairsMap(key)
  " | is special key which separate map command from text
  let key = a:key
  if key == '|'
    let key = '<BAR>'
  end
  let escaped_key = substitute(key, "'", "''", 'g')
  " use expr will cause search() doesn't work
  execute 'inoremap <buffer> <silent> '.key." <C-R>=AutoPairsInsert('".escaped_key."')<CR>"
endf

func! AutoPairsToggle()
  if b:autopairs_enabled
    let b:autopairs_enabled = 0
    echo 'AutoPairs Disabled.'
  else
    let b:autopairs_enabled = 1
    echo 'AutoPairs Enabled.'
  end
  return ''
endf

func! s:sortByLength(i1, i2)
  return len(a:i2[0])-len(a:i1[0])
endf

func! AutoPairsInit()
  let b:autopairs_loaded  = 1
  if !exists('b:autopairs_enabled')
    let b:autopairs_enabled = 1
  end

  if !exists('b:AutoPairs')
    let b:AutoPairs = AutoPairsDefaultPairs()
  end

  if !exists('b:AutoPairsMoveCharacter')
    let b:AutoPairsMoveCharacter = g:AutoPairsMoveCharacter
  end

  let b:autopairs_return_pos = 0
  let b:autopairs_saved_pair = [0, 0]
  let b:AutoPairsList = []

  " buffer level map pairs keys
  " n - do not map the first charactor of closed pair to close key
  " m - close key jumps through multi line
  " s - close key jumps only in the same line
  for [open, close] in items(b:AutoPairs)
    let o = open[-1:-1]
    let c = close[0]
    let opt = {'mapclose': 1, 'multiline':1}
    let opt['key'] = c
    if o == c
      let opt['multiline'] = 0
    end
    let m = matchlist(close, '\v(.*)//(.*)$')
    if len(m) > 0 
      if m[2] =~ 'n'
        let opt['mapclose'] = 0
      end
      if m[2] =~ 'm'
        let opt['multiline'] = 1
      end
      if m[2] =~ 's'
        let opt['multiline'] = 0
      end
      let ks = matchlist(m[2], '\vk(.)')
      if len(ks) > 0
        let opt['key'] = ks[1]
        let c = opt['key']
      end
      let close = m[1]
    end
    call AutoPairsMap(o)
    if o != c && c != '' && opt['mapclose']
      call AutoPairsMap(c)
    end
    let b:AutoPairsList += [[open, close, opt]]
  endfor

  " sort pairs by length, longer pair should have higher priority
  let b:AutoPairsList = sort(b:AutoPairsList, "s:sortByLength")

  for item in b:AutoPairsList
    let [open, close, opt] = item
    if open == "'" && open == close
      let item[0] = '\v(^|\W)\zs'''
    end
  endfor


  for key in split(b:AutoPairsMoveCharacter, '\s*')
    let escaped_key = substitute(key, "'", "''", 'g')
    execute 'inoremap <silent> <buffer> <M-'.key."> <C-R>=AutoPairsMoveCharacter('".escaped_key."')<CR>"
  endfor

  " Still use <buffer> level mapping for <BS> <SPACE>
  if g:AutoPairsMapBS
    " Use <C-R> instead of <expr> for issue #14 sometimes press BS output strange words
    execute 'inoremap <buffer> <silent> <BS> <C-R>=AutoPairsDelete()<CR>'
  end

  if g:AutoPairsMapCh
    execute 'inoremap <buffer> <silent> <C-h> <C-R>=AutoPairsDelete()<CR>'
  endif

  if g:AutoPairsMapSpace
    " Try to respect abbreviations on a <SPACE>
    let do_abbrev = ""
    if v:version == 703 && has("patch489") || v:version > 703
      let do_abbrev = "<C-]>"
    endif
    execute 'inoremap <buffer> <silent> <SPACE> '.do_abbrev.'<C-R>=AutoPairsSpace()<CR>'
  end

  if g:AutoPairsShortcutFastWrap != ''
    execute 'inoremap <buffer> <silent> '.g:AutoPairsShortcutFastWrap.' <C-R>=AutoPairsFastWrap()<CR>'
  end

  if g:AutoPairsShortcutBackInsert != ''
    execute 'inoremap <buffer> <silent> '.g:AutoPairsShortcutBackInsert.' <C-R>=AutoPairsBackInsert()<CR>'
  end

  if g:AutoPairsShortcutToggle != ''
    " use <expr> to ensure showing the status when toggle
    execute 'inoremap <buffer> <silent> <expr> '.g:AutoPairsShortcutToggle.' AutoPairsToggle()'
    execute 'noremap <buffer> <silent> '.g:AutoPairsShortcutToggle.' :call AutoPairsToggle()<CR>'
  end

  if g:AutoPairsShortcutJump != ''
    execute 'inoremap <buffer> <silent> ' . g:AutoPairsShortcutJump. ' <ESC>:call AutoPairsJump()<CR>a'
    execute 'noremap <buffer> <silent> ' . g:AutoPairsShortcutJump. ' :call AutoPairsJump()<CR>'
  end

  if &keymap != ''
    let l:imsearch = &imsearch
    let l:iminsert = &iminsert
    let l:imdisable = &imdisable
    execute 'setlocal keymap=' . &keymap
    execute 'setlocal imsearch=' . l:imsearch
    execute 'setlocal iminsert=' . l:iminsert
    if l:imdisable
      execute 'setlocal imdisable'
    else
      execute 'setlocal noimdisable'
    end
  end

endf

func! s:ExpandMap(map)
  let map = a:map
  let map = substitute(map, '\(<Plug>\w\+\)', '\=maparg(submatch(1), "i")', 'g')
  let map = substitute(map, '\(<Plug>([^)]*)\)', '\=maparg(submatch(1), "i")', 'g')
  return map
endf

func! AutoPairsTryInit()
  if exists('b:autopairs_loaded')
    return
  end

  " for auto-pairs starts with 'a', so the priority is higher than supertab and vim-endwise
  "
  " vim-endwise doesn't support <Plug>AutoPairsReturn
  " when use <Plug>AutoPairsReturn will cause <Plug> isn't expanded
  "
  " supertab doesn't support <SID>AutoPairsReturn
  " when use <SID>AutoPairsReturn  will cause Duplicated <CR>
  "
  " and when load after vim-endwise will cause unexpected endwise inserted.
  " so always load AutoPairs at last

  " Buffer level keys mapping
  " comptible with other plugin
  if g:AutoPairsMapCR
    if v:version == 703 && has('patch32') || v:version > 703
      " VIM 7.3 supports advancer maparg which could get <expr> info
      " then auto-pairs could remap <CR> in any case.
      let info = maparg('<CR>', 'i', 0, 1)
      if empty(info)
        let old_cr = '<CR>'
        let is_expr = 0
      else
        let old_cr = info['rhs']
        let old_cr = s:ExpandMap(old_cr)
        let old_cr = substitute(old_cr, '<SID>', '<SNR>' . info['sid'] . '_', 'g')
        let is_expr = info['expr']
        let wrapper_name = '<SID>AutoPairsOldCRWrapper73'
      endif
    else
      " VIM version less than 7.3
      " the mapping's <expr> info is lost, so guess it is expr or not, it's
      " not accurate.
      let old_cr = maparg('<CR>', 'i')
      if old_cr == ''
        let old_cr = '<CR>'
        let is_expr = 0
      else
        let old_cr = s:ExpandMap(old_cr)
        " old_cr contain (, I guess the old cr is in expr mode
        let is_expr = old_cr =~ '\V(' && toupper(old_cr) !~ '\V<C-R>'

        " The old_cr start with " it must be in expr mode
        let is_expr = is_expr || old_cr =~ '\v^"'
        let wrapper_name = '<SID>AutoPairsOldCRWrapper'
      end
    end

    if old_cr !~ 'AutoPairsReturn'
      if is_expr
        " remap <expr> to `name` to avoid mix expr and non-expr mode
        execute 'inoremap <buffer> <expr> <script> '. wrapper_name . ' ' . old_cr
        let old_cr = wrapper_name
      end
      " Always silent mapping
      execute 'inoremap <script> <buffer> <silent> <CR> '.old_cr.'<SID>AutoPairsReturn'
    end
  endif
  call AutoPairsInit()
endf

" Always silent the command
inoremap <silent> <SID>AutoPairsReturn <C-R>=AutoPairsReturn()<CR>
imap <script> <Plug>AutoPairsReturn <SID>AutoPairsReturn


au BufEnter * :call AutoPairsTryInit()

Compilation message (stderr)

Main.cpp:1:1: warning: missing terminating " character
    1 | " Insert or delete brackets, parens, quotes in pairs.
      | ^
Main.cpp:1:1: error: missing terminating " character
    1 | " Insert or delete brackets, parens, quotes in pairs.
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:2:1: warning: missing terminating " character
    2 | " Maintainer:   JiangMiao <[email protected]>
      | ^
Main.cpp:2:1: error: missing terminating " character
    2 | " Maintainer:   JiangMiao <[email protected]>
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:3:1: warning: missing terminating " character
    3 | " Contributor: camthompson
      | ^
Main.cpp:3:1: error: missing terminating " character
    3 | " Contributor: camthompson
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:4:1: warning: missing terminating " character
    4 | " Last Change:  2019-02-02
      | ^
Main.cpp:4:1: error: missing terminating " character
    4 | " Last Change:  2019-02-02
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:5:1: warning: missing terminating " character
    5 | " Version: 2.0.0
      | ^
Main.cpp:5:1: error: missing terminating " character
    5 | " Version: 2.0.0
      | ^~~~~~~~~~~~~~~~
Main.cpp:6:1: warning: missing terminating " character
    6 | " Homepage: http://www.vim.org/scripts/script.php?script_id=3599
      | ^
Main.cpp:6:1: error: missing terminating " character
    6 | " Homepage: http://www.vim.org/scripts/script.php?script_id=3599
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:7:1: warning: missing terminating " character
    7 | " Repository: https://github.com/jiangmiao/auto-pairs
      | ^
Main.cpp:7:1: error: missing terminating " character
    7 | " Repository: https://github.com/jiangmiao/auto-pairs
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:8:1: warning: missing terminating " character
    8 | " License: MIT
      | ^
Main.cpp:8:1: error: missing terminating " character
    8 | " License: MIT
      | ^~~~~~~~~~~~~~
Main.cpp:10:11: warning: character constant too long for its type
   10 | if exists('g:AutoPairsLoaded') || &cp
      |           ^~~~~~~~~~~~~~~~~~~
Main.cpp:15:12: warning: character constant too long for its type
   15 | if !exists('g:AutoPairs')
      |            ^~~~~~~~~~~~~
Main.cpp:16:65: warning: multi-character character constant [-Wmultichar]
   16 |   let g:AutoPairs = {'(':')', '[':']', '{':'}',"'":"'",'"':'"', '```':'```', '"""':'"""', "'''":"'''", "`":"`"}
      |                                                                 ^~~~~
Main.cpp:16:71: warning: multi-character character constant [-Wmultichar]
   16 |   let g:AutoPairs = {'(':')', '[':']', '{':'}',"'":"'",'"':'"', '```':'```', '"""':'"""', "'''":"'''", "`":"`"}
      |                                                                       ^~~~~
Main.cpp:16:78: warning: multi-character character constant [-Wmultichar]
   16 |   let g:AutoPairs = {'(':')', '[':']', '{':'}',"'":"'",'"':'"', '```':'```', '"""':'"""', "'''":"'''", "`":"`"}
      |                                                                              ^~~~~
Main.cpp:16:84: warning: multi-character character constant [-Wmultichar]
   16 |   let g:AutoPairs = {'(':')', '[':']', '{':'}',"'":"'",'"':'"', '```':'```', '"""':'"""', "'''":"'''", "`":"`"}
      |                                                                                    ^~~~~
Main.cpp:19:1: warning: missing terminating " character
   19 | " default pairs base on filetype
      | ^
Main.cpp:19:1: error: missing terminating " character
   19 | " default pairs base on filetype
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:21:13: warning: character constant too long for its type
   21 |   if exists('b:autopairs_defaultpairs')
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:26:9: error: stray '\' in program
   26 |         \ 'vim': {'\v^\s*\zs"': ''},
      |         ^
Main.cpp:26:11: warning: multi-character character constant [-Wmultichar]
   26 |         \ 'vim': {'\v^\s*\zs"': ''},
      |           ^~~~~
Main.cpp:26:19: warning: unknown escape sequence: '\s'
   26 |         \ 'vim': {'\v^\s*\zs"': ''},
      |                   ^~~~~~~~~~~~
Main.cpp:26:19: warning: unknown escape sequence: '\z'
Main.cpp:26:19: warning: character constant too long for its type
Main.cpp:26:33: error: empty character constant
   26 |         \ 'vim': {'\v^\s*\zs"': ''},
      |                                 ^~
Main.cpp:27:9: error: stray '\' in program
   27 |         \ 'rust': {'\w\zs<': '>', '&\zs''': ''},
      |         ^
Main.cpp:27:11: warning: multi-character character constant [-Wmultichar]
   27 |         \ 'rust': {'\w\zs<': '>', '&\zs''': ''},
      |           ^~~~~~
Main.cpp:27:20: warning: unknown escape sequence: '\w'
   27 |         \ 'rust': {'\w\zs<': '>', '&\zs''': ''},
      |                    ^~~~~~~~
Main.cpp:27:20: warning: unknown escape sequence: '\z'
Main.cpp:27:20: warning: multi-character character constant [-Wmultichar]
Main.cpp:27:35: warning: unknown escape sequence: '\z'
   27 |         \ 'rust': {'\w\zs<': '>', '&\zs''': ''},
      |                                   ^~~~~~
Main.cpp:27:35: warning: multi-character character constant [-Wmultichar]
Main.cpp:27:41: error: empty character constant
   27 |         \ 'rust': {'\w\zs<': '>', '&\zs''': ''},
      |                                         ^~
Main.cpp:27:45: error: empty character constant
   27 |         \ 'rust': {'\w\zs<': '>', '&\zs''': ''},
      |                                             ^~
Main.cpp:28:9: error: stray '\' in program
   28 |         \ 'php': {'<?': '?>//k]', '<?php': '?>//k]'}
      |         ^
Main.cpp:28:11: warning: multi-character character constant [-Wmultichar]
   28 |         \ 'php': {'<?': '?>//k]', '<?php': '?>//k]'}
      |           ^~~~~
Main.cpp:28:19: warning: multi-character character constant [-Wmultichar]
   28 |         \ 'php': {'<?': '?>//k]', '<?php': '?>//k]'}
      |                   ^~~~
Main.cpp:28:25: warning: character constant too long for its type
   28 |         \ 'php': {'<?': '?>//k]', '<?php': '?>//k]'}
      |                         ^~~~~~~~
Main.cpp:28:35: warning: character constant too long for its type
   28 |         \ 'php': {'<?': '?>//k]', '<?php': '?>//k]'}
      |                                   ^~~~~~~
Main.cpp:28:44: warning: character constant too long for its type
   28 |         \ 'php': {'<?': '?>//k]', '<?php': '?>//k]'}
      |                                            ^~~~~~~~
Main.cpp:29:9: error: stray '\' in program
   29 |         \ }
      |         ^
Main.cpp:41:12: warning: character constant too long for its type
   41 | if !exists('g:AutoPairsMapBS')
      |            ^~~~~~~~~~~~~~~~~~
Main.cpp:45:1: warning: missing terminating " character
   45 | " Map <C-h> as the same BS
      | ^
Main.cpp:45:1: error: missing terminating " character
   45 | " Map <C-h> as the same BS
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:46:12: warning: character constant too long for its type
   46 | if !exists('g:AutoPairsMapCh')
      |            ^~~~~~~~~~~~~~~~~~
Main.cpp:50:12: warning: character constant too long for its type
   50 | if !exists('g:AutoPairsMapCR')
      |            ^~~~~~~~~~~~~~~~~~
Main.cpp:54:12: warning: character constant too long for its type
   54 | if !exists('g:AutoPairsWildClosedPair')
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:55:35: error: empty character constant
   55 |   let g:AutoPairsWildClosedPair = ''
      |                                   ^~
Main.cpp:58:12: warning: character constant too long for its type
   58 | if !exists('g:AutoPairsMapSpace')
      |            ^~~~~~~~~~~~~~~~~~~~~
Main.cpp:62:12: warning: character constant too long for its type
   62 | if !exists('g:AutoPairsCenterLine')
      |            ^~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:66:12: warning: character constant too long for its type
   66 | if !exists('g:AutoPairsShortcutToggle')
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:67:35: warning: character constant too long for its type
   67 |   let g:AutoPairsShortcutToggle = '<M-p>'
      |                                   ^~~~~~~
Main.cpp:70:12: warning: character constant too long for its type
   70 | if !exists('g:AutoPairsShortcutFastWrap')
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:71:37: warning: character constant too long for its type
   71 |   let g:AutoPairsShortcutFastWrap = '<M-e>'
      |                                     ^~~~~~~
Main.cpp:74:12: warning: character constant too long for its type
   74 | if !exists('g:AutoPairsMoveCharacter')
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:78:12: warning: character constant too long for its type
   78 | if !exists('g:AutoPairsShortcutJump')
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:79:33: warning: character constant too long for its type
   79 |   let g:AutoPairsShortcutJump = '<M-n>'
      |                                 ^~~~~~~
Main.cpp:82:1: warning: missing terminating " character
   82 | " Fly mode will for closed pair to jump to closed pair instead of insert.
      | ^
Main.cpp:82:1: error: missing terminating " character
   82 | " Fly mode will for closed pair to jump to closed pair instead of insert.
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:83:1: warning: missing terminating " character
   83 | " also support AutoPairsBackInsert to insert pairs where jumped.
      | ^
Main.cpp:83:1: error: missing terminating " character
   83 | " also support AutoPairsBackInsert to insert pairs where jumped.
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:84:12: warning: character constant too long for its type
   84 | if !exists('g:AutoPairsFlyMode')
      |            ^~~~~~~~~~~~~~~~~~~~
Main.cpp:88:1: warning: missing terminating " character
   88 | " When skipping the closed pair, look at the current and
      | ^
Main.cpp:88:1: error: missing terminating " character
   88 | " When skipping the closed pair, look at the current and
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:89:1: warning: missing terminating " character
   89 | " next line as well.
      | ^
Main.cpp:89:1: error: missing terminating " character
   89 | " next line as well.
      | ^~~~~~~~~~~~~~~~~~~~
Main.cpp:90:12: warning: character constant too long for its type
   90 | if !exists('g:AutoPairsMultilineClose')
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:94:1: warning: missing terminating " character
   94 | " Work with Fly Mode, insert pair where jumped
      | ^
Main.cpp:94:1: error: missing terminating " character
   94 | " Work with Fly Mode, insert pair where jumped
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:95:12: warning: character constant too long for its type
   95 | if !exists('g:AutoPairsShortcutBackInsert')
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:96:39: warning: character constant too long for its type
   96 |   let g:AutoPairsShortcutBackInsert = '<M-b>'
      |                                       ^~~~~~~
Main.cpp:99:12: warning: character constant too long for its type
   99 | if !exists('g:AutoPairsSmartQuotes')
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:103:1: warning: missing terminating " character
  103 | " 7.4.849 support <C-G>U to avoid breaking '.'
      | ^
Main.cpp:103:1: error: missing terminating " character
  103 | " 7.4.849 support <C-G>U to avoid breaking '.'
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:104:1: warning: missing terminating " character
  104 | " Issue talk: https://github.com/jiangmiao/auto-pairs/issues/3
      | ^
Main.cpp:104:1: error: missing terminating " character
  104 | " Issue talk: https://github.com/jiangmiao/auto-pairs/issues/3
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:105:1: warning: missing terminating " character
  105 | " Vim note: https://github.com/vim/vim/releases/tag/v7.4.849
      | ^
Main.cpp:105:1: error: missing terminating " character
  105 | " Vim note: https://github.com/vim/vim/releases/tag/v7.4.849
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:118:1: warning: missing terminating " character
  118 | " unicode len
      | ^
Main.cpp:118:1: error: missing terminating " character
  118 | " unicode len
      | ^~~~~~~~~~~~~
Main.cpp:120:25: warning: unknown escape sequence: '\z'
  120 |   return len(split(a:s, '\zs'))
      |                         ^~~~~
Main.cpp:120:25: warning: multi-character character constant [-Wmultichar]
Main.cpp:151:20: warning: unknown escape sequence: '\s'
  151 |       if !(line =~ '\v^\s*$')
      |                    ^~~~~~~~~
Main.cpp:151:20: warning: character constant too long for its type
Main.cpp:160:1: warning: missing terminating " character
  160 | " split text to two part
      | ^
Main.cpp:160:1: error: missing terminating " character
  160 | " split text to two part
      | ^~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:161:1: warning: missing terminating " character
  161 | " returns [orig, text_before_open, open]
      | ^
Main.cpp:161:1: error: missing terminating " character
  161 | " returns [orig, text_before_open, open]
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:163:30: warning: unknown escape sequence: '\V'
  163 |     let m = matchstr(a:text, '\V'.a:open.'\v$')
      |                              ^~~~
Main.cpp:163:42: warning: multi-character character constant [-Wmultichar]
  163 |     let m = matchstr(a:text, '\V'.a:open.'\v$')
      |                                          ^~~~~
Main.cpp:170:1: warning: missing terminating " character
  170 | " returns [orig, close, text_after_close]
      | ^
Main.cpp:170:1: error: missing terminating " character
  170 | " returns [orig, close, text_after_close]
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:172:30: warning: unknown escape sequence: '\V'
  172 |     let m = matchstr(a:text, '^\V'.a:close)
      |                              ^~~~~
Main.cpp:172:30: warning: multi-character character constant [-Wmultichar]
Main.cpp:179:1: warning: missing terminating " character
  179 | " add or delete pairs base on g:AutoPairs
      | ^
Main.cpp:179:1: error: missing terminating " character
  179 | " add or delete pairs base on g:AutoPairs
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:180:1: warning: missing terminating " character
  180 | " AutoPairsDefine(addPairs:dict[, removeOpenPairList:list])
      | ^
Main.cpp:180:1: error: missing terminating " character
  180 | " AutoPairsDefine(addPairs:dict[, removeOpenPairList:list])
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:181:1: warning: missing terminating " character
  181 | "
      | ^
Main.cpp:181:1: error: missing terminating " character
Main.cpp:182:1: warning: missing terminating " character
  182 | " eg:
      | ^
Main.cpp:182:1: error: missing terminating " character
  182 | " eg:
      | ^~~~~
Main.cpp:183:1: warning: missing terminating " character
  183 | "   au FileType html let b:AutoPairs = AutoPairsDefine({'<!--' : '-->'}, ['{'])
      | ^
Main.cpp:183:1: error: missing terminating " character
  183 | "   au FileType html let b:AutoPairs = AutoPairsDefine({'<!--' : '-->'}, ['{'])
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:184:1: warning: missing terminating " character
  184 | "   add <!-- --> pair and remove '{' for html file
      | ^
Main.cpp:184:1: error: missing terminating " character
  184 | "   add <!-- --> pair and remove '{' for html file
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:207:3: warning: missing terminating " character
  207 |   " Ignore auto close if prev character is \
      |   ^
Main.cpp:207:3: error: missing terminating " character
  207 |   " Ignore auto close if prev character is \
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  208 |   if before[-1:-1] == '\'
      |   ~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:212:3: warning: missing terminating " character
  212 |   " check open pairs
      |   ^
Main.cpp:212:3: error: missing terminating " character
  212 |   " check open pairs
      |   ^~~~~~~~~~~~~~~~~~
Main.cpp:215:33: warning: unknown escape sequence: '\s'
  215 |     let m = matchstr(afterline, '^\v\s*\zs\V'.close)
      |                                 ^~~~~~~~~~~~~
Main.cpp:215:33: warning: unknown escape sequence: '\z'
Main.cpp:215:33: warning: unknown escape sequence: '\V'
Main.cpp:215:33: warning: character constant too long for its type
Main.cpp:217:7: warning: missing terminating " character
  217 |       " process the open pair
      |       ^
Main.cpp:217:7: error: missing terminating " character
  217 |       " process the open pair
      |       ^~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:219:7: warning: missing terminating " character
  219 |       " remove inserted pair
      |       ^
Main.cpp:219:7: error: missing terminating " character
  219 |       " remove inserted pair
      |       ^~~~~~~~~~~~~~~~~~~~~~
Main.cpp:220:7: warning: missing terminating " character
  220 |       " eg: if the pairs include < > and  <!-- -->
      |       ^
Main.cpp:220:7: error: missing terminating " character
  220 |       " eg: if the pairs include < > and  <!-- -->
      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
Main.cpp:221:7: warning: missing terminating " character
  221 |       " when <!-- is detected the inserted pair < > should be clean up
      |       ^
Main.cpp:221:7: error: missing terminating " character
  221 |       " when <!-- is detected the inserted pair < > should be clean up
      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
Main.cpp:227:16: error: empty character constant
  227 |       let bs = ''
      |                ^~
Main.cpp:228:17: error: empty character constant
  228 |       let del = ''
      |                 ^~
Main.cpp:231:9: warning: missing terminating " character
  231 |         " delete pair
      |         ^
Main.cpp:231:9: error: missing terminating " character
  231 |         " delete pair
      |         ^~~~~~~~~~~~~
Main.cpp:235:13: warning: missing terminating " character
  235 |             " any text before openPair should not be deleted
      |             ^
Main.cpp:235:13: error: missing terminating " character
  235 |             " any text before openPair should not be deleted
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:249:11: warning: missing terminating " character
  249 |           " delete charactor
      |           ^
Main.cpp:249:11: error: missing terminating " character
  249 |           " delete charactor
      |           ^~~~~~~~~~~~~~~~~~
Main.cpp:250:39: warning: multi-character character constant [-Wmultichar]
  250 |           let ms = s:matchend(before, '\v.')
      |                                       ^~~~~
Main.cpp:261:3: warning: missing terminating " character
  261 |   " check close pairs
      |   ^
Main.cpp:261:3: error: missing terminating " character
  261 |   " check close pairs
      |   ^~~~~~~~~~~~~~~~~~~
Main.cpp:263:17: error: empty character constant
  263 |     if close == ''
      |                 ^~
Main.cpp:266:50: warning: character constant too long for its type
  266 |     if a:key == g:AutoPairsWildClosedPair || opt['mapclose'] && opt['key'] == a:key
      |                                                  ^~~~~~~~~~
Main.cpp:266:69: warning: multi-character character constant [-Wmultichar]
  266 |     if a:key == g:AutoPairsWildClosedPair || opt['mapclose'] && opt['key'] == a:key
      |                                                                     ^~~~~
Main.cpp:267:7: warning: missing terminating " character
  267 |       " the close pair is in the same line
      |       ^
Main.cpp:267:7: error: missing terminating " character
  267 |       " the close pair is in the same line
      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:268:35: warning: unknown escape sequence: '\s'
  268 |       let m = matchstr(afterline, '^\v\s*\V'.close)
      |                                   ^~~~~~~~~~
Main.cpp:268:35: warning: unknown escape sequence: '\V'
Main.cpp:268:35: warning: character constant too long for its type
Main.cpp:269:15: error: empty character constant
  269 |       if m != ''
      |               ^~
Main.cpp:270:22: warning: unknown escape sequence: '\V'
  270 |         if before =~ '\V'.open.'\v\s*$' && m[0] =~ '\v\s'
      |                      ^~~~
Main.cpp:270:32: warning: unknown escape sequence: '\s'
  270 |         if before =~ '\V'.open.'\v\s*$' && m[0] =~ '\v\s'
      |                                ^~~~~~~~
Main.cpp:270:32: warning: multi-character character constant [-Wmultichar]
Main.cpp:270:52: warning: unknown escape sequence: '\s'
  270 |         if before =~ '\V'.open.'\v\s*$' && m[0] =~ '\v\s'
      |                                                    ^~~~~~
Main.cpp:270:52: warning: multi-character character constant [-Wmultichar]
Main.cpp:271:11: warning: missing terminating " character
  271 |           " remove the space we inserted if the text in pairs is blank
      |           ^
Main.cpp:271:11: error: missing terminating " character
  271 |           " remove the space we inserted if the text in pairs is blank
      |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:277:31: warning: unknown escape sequence: '\s'
  277 |       let m = matchstr(after, '^\v\s*\zs\V'.close)
      |                               ^~~~~~~~~~~~~
Main.cpp:277:31: warning: unknown escape sequence: '\z'
Main.cpp:277:31: warning: unknown escape sequence: '\V'
Main.cpp:277:31: warning: character constant too long for its type
Main.cpp:278:15: error: empty character constant
  278 |       if m != ''
      |               ^~
Main.cpp:279:54: warning: character constant too long for its type
  279 |         if a:key == g:AutoPairsWildClosedPair || opt['multiline']
      |                                                      ^~~~~~~~~~~
Main.cpp:280:69: warning: unknown escape sequence: '\s'
  280 |           if b:autopairs_return_pos == line('.') && getline('.') =~ '\v^\s*$'
      |                                                                     ^~~~~~~~~
Main.cpp:280:69: warning: character constant too long for its type
Main.cpp:283:26: warning: multi-character character constant [-Wmultichar]
  283 |           call search(m, 'We')
      |                          ^~~~
Main.cpp:293:3: warning: missing terminating " character
  293 |   " Fly Mode, and the key is closed-pairs, search closed-pair and jump
      |   ^
Main.cpp:293:3: error: missing terminating " character
  293 |   " Fly Mode, and the key is closed-pairs, search closed-pair and jump
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:294:38: warning: unknown escape sequence: '\}'
  294 |   if g:AutoPairsFlyMode &&  a:key =~ '\v[\}\]\)]'
      |                                      ^~~~~~~~~~~~
Main.cpp:294:38: warning: unknown escape sequence: '\]'
Main.cpp:294:38: warning: unknown escape sequence: '\)'
Main.cpp:294:38: warning: character constant too long for its type
Main.cpp:295:22: warning: multi-character character constant [-Wmultichar]
  295 |     if search(a:key, 'We')
      |                      ^~~~
Main.cpp:310:30: warning: unknown escape sequence: '\V'
  310 |     let b = matchstr(before, '\V'.open.'\v\s?$')
      |                              ^~~~
Main.cpp:310:40: warning: unknown escape sequence: '\s'
  310 |     let b = matchstr(before, '\V'.open.'\v\s?$')
      |                                        ^~~~~~~~
Main.cpp:310:40: warning: multi-character character constant [-Wmultichar]
Main.cpp:311:29: warning: unknown escape sequence: '\s'
  311 |     let a = matchstr(after, '^\v\s*\V'.close)
      |                             ^~~~~~~~~~
Main.cpp:311:29: warning: unknown escape sequence: '\V'
Main.cpp:311:29: warning: character constant too long for its type
Main.cpp:312:13: error: empty character constant
  312 |     if b != '' && a != ''
      |             ^~
Main.cpp:312:24: error: empty character constant
  312 |     if b != '' && a != ''
      |                        ^~
Main.cpp:325:3: warning: missing terminating " character
  325 |   " delete the pair foo[]| <BS> to foo
      |   ^
Main.cpp:325:3: error: missing terminating " character
  325 |   " delete the pair foo[]| <BS> to foo
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:327:32: warning: unknown escape sequence: '\V'
  327 |     let m = s:matchend(before, '\V'.open.'\v\s*'.'\V'.close.'\v$')
      |                                ^~~~
Main.cpp:327:42: warning: unknown escape sequence: '\s'
  327 |     let m = s:matchend(before, '\V'.open.'\v\s*'.'\V'.close.'\v$')
      |                                          ^~~~~~~
Main.cpp:327:42: warning: multi-character character constant [-Wmultichar]
Main.cpp:327:50: warning: unknown escape sequence: '\V'
  327 |     let m = s:matchend(before, '\V'.open.'\v\s*'.'\V'.close.'\v$')
      |                                                  ^~~~
Main.cpp:327:61: warning: multi-character character constant [-Wmultichar]
  327 |     let m = s:matchend(before, '\V'.open.'\v\s*'.'\V'.close.'\v$')
      |                                                             ^~~~~
Main.cpp:336:1: warning: missing terminating " character
  336 | " Fast wrap the word in brackets
      | ^
Main.cpp:336:1: error: missing terminating " character
  336 | " Fast wrap the word in brackets
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:338:11: error: stray '@' in program
  338 |   let c = @"
      |           ^
Main.cpp:338:12: warning: missing terminating " character
  338 |   let c = @"
      |            ^
Main.cpp:338:12: error: missing terminating " character
Main.cpp:341:18: warning: unknown escape sequence: '\<'
  341 |   if after[0] =~ '\v[\{\[\(\<]'
      |                  ^~~~~~~~~~~~~~
Main.cpp:341:18: warning: character constant too long for its type
Main.cpp:346:19: error: empty character constant
  346 |       if close == ''
      |                   ^~
Main.cpp:349:19: warning: unknown escape sequence: '\s'
  349 |       if after =~ '^\s*\V'.open
      |                   ^~~~~~~~
Main.cpp:349:19: warning: unknown escape sequence: '\V'
Main.cpp:349:19: warning: multi-character character constant [-Wmultichar]
Main.cpp:350:28: warning: multi-character character constant [-Wmultichar]
  350 |         call search(close, 'We')
      |                            ^~~~
Main.cpp:352:13: error: stray '@' in program
  352 |         let @" = c
      |             ^
Main.cpp:352:14: warning: missing terminating " character
  352 |         let @" = c
      |              ^
Main.cpp:352:14: error: missing terminating " character
  352 |         let @" = c
      |              ^~~~~
Main.cpp:356:22: warning: unknown escape sequence: '\w'
  356 |     if after[1:1] =~ '\v\w'
      |                      ^~~~~~
Main.cpp:356:22: warning: multi-character character constant [-Wmultichar]
Main.cpp:363:7: error: stray '@' in program
  363 |   let @" = c
      |       ^
Main.cpp:363:8: warning: missing terminating " character
  363 |   let @" = c
      |        ^
Main.cpp:363:8: error: missing terminating " character
  363 |   let @" = c
      |        ^~~~~
Main.cpp:368:15: warning: unknown escape sequence: '\]'
  368 |   call search('["\]'')}]','W')
      |               ^~~~~~
Main.cpp:368:15: warning: multi-character character constant [-Wmultichar]
Main.cpp:368:21: warning: multi-character character constant [-Wmultichar]
  368 |   call search('["\]'')}]','W')
      |                     ^~~~~
Main.cpp:386:12: error: empty character constant
  386 |     return ''
      |            ^~
Main.cpp:391:13: error: empty character constant
  391 |   let cmd = ''
      |             ^~
Main.cpp:393:17: error: empty character constant
  393 |     if close == ''
      |                 ^~
Main.cpp:397:18: warning: unknown escape sequence: '\V'
  397 |     if before =~ '\V'.open.'\v\s*$' && afterline =~ '^\s*\V'.close
      |                  ^~~~
Main.cpp:397:28: warning: unknown escape sequence: '\s'
  397 |     if before =~ '\V'.open.'\v\s*$' && afterline =~ '^\s*\V'.close
      |                            ^~~~~~~~
Main.cpp:397:28: warning: multi-character character constant [-Wmultichar]
Main.cpp:397:53: warning: unknown escape sequence: '\s'
  397 |     if before =~ '\V'.open.'\v\s*$' && afterline =~ '^\s*\V'.close
      |                                                     ^~~~~~~~
Main.cpp:397:53: warning: unknown escape sequence: '\V'
Main.cpp:397:53: warning: multi-character character constant [-Wmultichar]
Main.cpp:400:9: warning: missing terminating " character
  400 |         " Recenter before adding new line to avoid replacing line content
      |         ^
Main.cpp:400:9: error: missing terminating " character
  400 |         " Recenter before adding new line to avoid replacing line content
      |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:404:7: warning: missing terminating " character
  404 |       " If equalprg has been set, then avoid call =
      |       ^
Main.cpp:404:7: error: missing terminating " character
  404 |       " If equalprg has been set, then avoid call =
      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:405:7: warning: missing terminating " character
  405 |       " https://github.com/jiangmiao/auto-pairs/issues/24
      |       ^
Main.cpp:405:7: error: missing terminating " character
  405 |       " https://github.com/jiangmiao/auto-pairs/issues/24
      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:406:23: error: empty character constant
  406 |       if &equalprg != ''
      |                       ^~
Main.cpp:410:7: warning: missing terminating " character
  410 |       " conflict with javascript and coffee
      |       ^
Main.cpp:410:7: error: missing terminating " character
  410 |       " conflict with javascript and coffee
      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:411:7: warning: missing terminating " character
  411 |       " javascript   need   indent new line
      |       ^
Main.cpp:411:7: error: missing terminating " character
  411 |       " javascript   need   indent new line
      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:412:7: warning: missing terminating " character
  412 |       " coffeescript forbid indent new line
      |       ^
Main.cpp:412:7: error: missing terminating " character
  412 |       " coffeescript forbid indent new line
      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:413:23: warning: character constant too long for its type
  413 |       if &filetype == 'coffeescript' || &filetype == 'coffee'
      |                       ^~~~~~~~~~~~~~
Main.cpp:413:54: warning: character constant too long for its type
  413 |       if &filetype == 'coffeescript' || &filetype == 'coffee'
      |                                                      ^~~~~~~~
Main.cpp:420:10: error: empty character constant
  420 |   return ''
      |          ^~
Main.cpp:431:17: error: empty character constant
  431 |     if close == ''
      |                 ^~
Main.cpp:434:18: warning: unknown escape sequence: '\V'
  434 |     if before =~ '\V'.open.'\v$' && after =~ '^\V'.close
      |                  ^~~~
Main.cpp:434:28: warning: multi-character character constant [-Wmultichar]
  434 |     if before =~ '\V'.open.'\v$' && after =~ '^\V'.close
      |                            ^~~~~
Main.cpp:434:46: warning: unknown escape sequence: '\V'
  434 |     if before =~ '\V'.open.'\v$' && after =~ '^\V'.close
      |                                              ^~~~~
Main.cpp:434:46: warning: multi-character character constant [-Wmultichar]
Main.cpp:435:19: warning: multi-character character constant [-Wmultichar]
  435 |       if close =~ '\v^[''"`]$'
      |                   ^~~~~~
Main.cpp:435:25: warning: multi-character character constant [-Wmultichar]
  435 |       if close =~ '\v^[''"`]$'
      |                         ^~~~~~
Main.cpp:446:3: warning: missing terminating " character
  446 |   " | is special key which separate map command from text
      |   ^
Main.cpp:446:3: error: missing terminating " character
  446 |   " | is special key which separate map command from text
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:449:15: warning: character constant too long for its type
  449 |     let key = '<BAR>'
      |               ^~~~~~~
Main.cpp:452:3: warning: missing terminating " character
  452 |   " use expr will cause search() doesn't work
      |   ^
Main.cpp:452:3: error: missing terminating " character
  452 |   " use expr will cause search() doesn't work
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:453:11: warning: character constant too long for its type
  453 |   execute 'inoremap <buffer> <silent> '.key." <C-R>=AutoPairsInsert('".escaped_key."')<CR>"
      |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:459:10: warning: character constant too long for its type
  459 |     echo 'AutoPairs Disabled.'
      |          ^~~~~~~~~~~~~~~~~~~~~
Main.cpp:462:10: warning: character constant too long for its type
  462 |     echo 'AutoPairs Enabled.'
      |          ^~~~~~~~~~~~~~~~~~~~
Main.cpp:464:10: error: empty character constant
  464 |   return ''
      |          ^~
Main.cpp:473:14: warning: character constant too long for its type
  473 |   if !exists('b:autopairs_enabled')
      |              ^~~~~~~~~~~~~~~~~~~~~
Main.cpp:477:14: warning: character constant too long for its type
  477 |   if !exists('b:AutoPairs')
      |              ^~~~~~~~~~~~~
Main.cpp:481:14: warning: character constant too long for its type
  481 |   if !exists('b:AutoPairsMoveCharacter')
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:489:3: warning: missing terminating " character
  489 |   " buffer level map pairs keys
      |   ^
Main.cpp:489:3: error: missing terminating " character
  489 |   " buffer level map pairs keys
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:490:3: warning: missing terminating " character
  490 |   " n - do not map the first charactor of closed pair to close key
      |   ^
Main.cpp:490:3: error: missing terminating " character
  490 |   " n - do not map the first charactor of closed pair to close key
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:491:3: warning: missing terminating " character
  491 |   " m - close key jumps through multi line
      |   ^
Main.cpp:491:3: error: missing terminating " character
  491 |   " m - close key jumps through multi line
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:492:3: warning: missing terminating " character
  492 |   " s - close key jumps only in the same line
      |   ^
Main.cpp:492:3: error: missing terminating " character
  492 |   " s - close key jumps only in the same line
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:496:16: warning: character constant too long for its type
  496 |     let opt = {'mapclose': 1, 'multiline':1}
      |                ^~~~~~~~~~
Main.cpp:496:31: warning: character constant too long for its type
  496 |     let opt = {'mapclose': 1, 'multiline':1}
      |                               ^~~~~~~~~~~
Main.cpp:497:13: warning: multi-character character constant [-Wmultichar]
  497 |     let opt['key'] = c
      |             ^~~~~
Main.cpp:499:15: warning: character constant too long for its type
  499 |       let opt['multiline'] = 0
      |               ^~~~~~~~~~~
Main.cpp:501:30: warning: character constant too long for its type
  501 |     let m = matchlist(close, '\v(.*)//(.*)$')
      |                              ^~~~~~~~~~~~~~~
Main.cpp:504:17: warning: character constant too long for its type
  504 |         let opt['mapclose'] = 0
      |                 ^~~~~~~~~~
Main.cpp:507:17: warning: character constant too long for its type
  507 |         let opt['multiline'] = 1
      |                 ^~~~~~~~~~~
Main.cpp:510:17: warning: character constant too long for its type
  510 |         let opt['multiline'] = 0
      |                 ^~~~~~~~~~~
Main.cpp:512:32: warning: character constant too long for its type
  512 |       let ks = matchlist(m[2], '\vk(.)')
      |                                ^~~~~~~~
Main.cpp:514:17: warning: multi-character character constant [-Wmultichar]
  514 |         let opt['key'] = ks[1]
      |                 ^~~~~
Main.cpp:515:21: warning: multi-character character constant [-Wmultichar]
  515 |         let c = opt['key']
      |                     ^~~~~
Main.cpp:520:23: error: empty character constant
  520 |     if o != c && c != '' && opt['mapclose']
      |                       ^~
Main.cpp:520:33: warning: character constant too long for its type
  520 |     if o != c && c != '' && opt['mapclose']
      |                                 ^~~~~~~~~~
Main.cpp:526:3: warning: missing terminating " character
  526 |   " sort pairs by length, longer pair should have higher priority
      |   ^
Main.cpp:526:3: error: missing terminating " character
  526 |   " sort pairs by length, longer pair should have higher priority
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:532:21: warning: unknown escape sequence: '\W'
  532 |       let item[0] = '\v(^|\W)\zs'''
      |                     ^~~~~~~~~~~~~
Main.cpp:532:21: warning: unknown escape sequence: '\z'
Main.cpp:532:21: warning: character constant too long for its type
Main.cpp:532:34: error: empty character constant
  532 |       let item[0] = '\v(^|\W)\zs'''
      |                                  ^~
Main.cpp:537:46: warning: unknown escape sequence: '\s'
  537 |   for key in split(b:AutoPairsMoveCharacter, '\s*')
      |                                              ^~~~~
Main.cpp:537:46: warning: multi-character character constant [-Wmultichar]
Main.cpp:539:13: warning: character constant too long for its type
  539 |     execute 'inoremap <silent> <buffer> <M-'.key."> <C-R>=AutoPairsMoveCharacter('".escaped_key."')<CR>"
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:542:3: warning: missing terminating " character
  542 |   " Still use <buffer> level mapping for <BS> <SPACE>
      |   ^
Main.cpp:542:3: error: missing terminating " character
  542 |   " Still use <buffer> level mapping for <BS> <SPACE>
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:544:5: warning: missing terminating " character
  544 |     " Use <C-R> instead of <expr> for issue #14 sometimes press BS output strange words
      |     ^
Main.cpp:544:5: error: missing terminating " character
  544 |     " Use <C-R> instead of <expr> for issue #14 sometimes press BS output strange words
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:545:13: warning: character constant too long for its type
  545 |     execute 'inoremap <buffer> <silent> <BS> <C-R>=AutoPairsDelete()<CR>'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:549:13: warning: character constant too long for its type
  549 |     execute 'inoremap <buffer> <silent> <C-h> <C-R>=AutoPairsDelete()<CR>'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:553:5: warning: missing terminating " character
  553 |     " Try to respect abbreviations on a <SPACE>
      |     ^
Main.cpp:553:5: error: missing terminating " character
  553 |     " Try to respect abbreviations on a <SPACE>
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:558:13: warning: character constant too long for its type
  558 |     execute 'inoremap <buffer> <silent> <SPACE> '.do_abbrev.'<C-R>=AutoPairsSpace()<CR>'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:558:61: warning: character constant too long for its type
  558 |     execute 'inoremap <buffer> <silent> <SPACE> '.do_abbrev.'<C-R>=AutoPairsSpace()<CR>'
      |                                                             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:561:37: error: empty character constant
  561 |   if g:AutoPairsShortcutFastWrap != ''
      |                                     ^~
Main.cpp:562:13: warning: character constant too long for its type
  562 |     execute 'inoremap <buffer> <silent> '.g:AutoPairsShortcutFastWrap.' <C-R>=AutoPairsFastWrap()<CR>'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:562:71: warning: character constant too long for its type
  562 |     execute 'inoremap <buffer> <silent> '.g:AutoPairsShortcutFastWrap.' <C-R>=AutoPairsFastWrap()<CR>'
      |                                                                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:565:39: error: empty character constant
  565 |   if g:AutoPairsShortcutBackInsert != ''
      |                                       ^~
Main.cpp:566:13: warning: character constant too long for its type
  566 |     execute 'inoremap <buffer> <silent> '.g:AutoPairsShortcutBackInsert.' <C-R>=AutoPairsBackInsert()<CR>'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:566:73: warning: character constant too long for its type
  566 |     execute 'inoremap <buffer> <silent> '.g:AutoPairsShortcutBackInsert.' <C-R>=AutoPairsBackInsert()<CR>'
      |                                                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:569:35: error: empty character constant
  569 |   if g:AutoPairsShortcutToggle != ''
      |                                   ^~
Main.cpp:570:5: warning: missing terminating " character
  570 |     " use <expr> to ensure showing the status when toggle
      |     ^
Main.cpp:570:5: error: missing terminating " character
  570 |     " use <expr> to ensure showing the status when toggle
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:571:13: warning: character constant too long for its type
  571 |     execute 'inoremap <buffer> <silent> <expr> '.g:AutoPairsShortcutToggle.' AutoPairsToggle()'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:571:76: warning: character constant too long for its type
  571 |     execute 'inoremap <buffer> <silent> <expr> '.g:AutoPairsShortcutToggle.' AutoPairsToggle()'
      |                                                                            ^~~~~~~~~~~~~~~~~~~~
Main.cpp:572:13: warning: character constant too long for its type
  572 |     execute 'noremap <buffer> <silent> '.g:AutoPairsShortcutToggle.' :call AutoPairsToggle()<CR>'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:572:68: warning: character constant too long for its type
  572 |     execute 'noremap <buffer> <silent> '.g:AutoPairsShortcutToggle.' :call AutoPairsToggle()<CR>'
      |                                                                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:575:33: error: empty character constant
  575 |   if g:AutoPairsShortcutJump != ''
      |                                 ^~
Main.cpp:576:13: warning: character constant too long for its type
  576 |     execute 'inoremap <buffer> <silent> ' . g:AutoPairsShortcutJump. ' <ESC>:call AutoPairsJump()<CR>a'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:576:70: warning: character constant too long for its type
  576 |     execute 'inoremap <buffer> <silent> ' . g:AutoPairsShortcutJump. ' <ESC>:call AutoPairsJump()<CR>a'
      |                                                                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:577:13: warning: character constant too long for its type
  577 |     execute 'noremap <buffer> <silent> ' . g:AutoPairsShortcutJump. ' :call AutoPairsJump()<CR>'
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:577:69: warning: character constant too long for its type
  577 |     execute 'noremap <buffer> <silent> ' . g:AutoPairsShortcutJump. ' :call AutoPairsJump()<CR>'
      |                                                                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:580:17: error: empty character constant
  580 |   if &keymap != ''
      |                 ^~
Main.cpp:584:13: warning: character constant too long for its type
  584 |     execute 'setlocal keymap=' . &keymap
      |             ^~~~~~~~~~~~~~~~~~
Main.cpp:585:13: warning: character constant too long for its type
  585 |     execute 'setlocal imsearch=' . l:imsearch
      |             ^~~~~~~~~~~~~~~~~~~~
Main.cpp:586:13: warning: character constant too long for its type
  586 |     execute 'setlocal iminsert=' . l:iminsert
      |             ^~~~~~~~~~~~~~~~~~~~
Main.cpp:588:15: warning: character constant too long for its type
  588 |       execute 'setlocal imdisable'
      |               ^~~~~~~~~~~~~~~~~~~~
Main.cpp:590:15: warning: character constant too long for its type
  590 |       execute 'setlocal noimdisable'
      |               ^~~~~~~~~~~~~~~~~~~~~~
Main.cpp:598:29: warning: unknown escape sequence: '\w'
  598 |   let map = substitute(map, '\(<Plug>\w\+\)', '\=maparg(submatch(1), "i")', 'g')
      |                             ^~~~~~~~~~~~~~~~
Main.cpp:598:29: warning: unknown escape sequence: '\+'
Main.cpp:598:29: warning: unknown escape sequence: '\)'
Main.cpp:598:29: warning: character constant too long for its type
Main.cpp:598:47: warning: unknown escape sequence: '\='
  598 |   let map = substitute(map, '\(<Plug>\w\+\)', '\=maparg(submatch(1), "i")', 'g')
      |                                               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:598:47: warning: character constant too long for its type
Main.cpp:599:29: warning: unknown escape sequence: '\)'
  599 |   let map = substitute(map, '\(<Plug>([^)]*)\)', '\=maparg(submatch(1), "i")', 'g')
      |                             ^~~~~~~~~~~~~~~~~~~
Main.cpp:599:29: warning: character constant too long for its type
Main.cpp:599:50: warning: unknown escape sequence: '\='
  599 |   let map = substitute(map, '\(<Plug>([^)]*)\)', '\=maparg(submatch(1), "i")', 'g')
      |                                                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:599:50: warning: character constant too long for its type
Main.cpp:604:13: warning: character constant too long for its type
  604 |   if exists('b:autopairs_loaded')
      |             ^~~~~~~~~~~~~~~~~~~~
Main.cpp:608:3: warning: missing terminating " character
  608 |   " for auto-pairs starts with 'a', so the priority is higher than supertab and vim-endwise
      |   ^
Main.cpp:608:3: error: missing terminating " character
  608 |   " for auto-pairs starts with 'a', so the priority is higher than supertab and vim-endwise
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:609:3: warning: missing terminating " character
  609 |   "
      |   ^
Main.cpp:609:3: error: missing terminating " character
Main.cpp:610:3: warning: missing terminating " character
  610 |   " vim-endwise doesn't support <Plug>AutoPairsReturn
      |   ^
Main.cpp:610:3: error: missing terminating " character
  610 |   " vim-endwise doesn't support <Plug>AutoPairsReturn
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:611:3: warning: missing terminating " character
  611 |   " when use <Plug>AutoPairsReturn will cause <Plug> isn't expanded
      |   ^
Main.cpp:611:3: error: missing terminating " character
  611 |   " when use <Plug>AutoPairsReturn will cause <Plug> isn't expanded
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:612:3: warning: missing terminating " character
  612 |   "
      |   ^
Main.cpp:612:3: error: missing terminating " character
Main.cpp:613:3: warning: missing terminating " character
  613 |   " supertab doesn't support <SID>AutoPairsReturn
      |   ^
Main.cpp:613:3: error: missing terminating " character
  613 |   " supertab doesn't support <SID>AutoPairsReturn
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:614:3: warning: missing terminating " character
  614 |   " when use <SID>AutoPairsReturn  will cause Duplicated <CR>
      |   ^
Main.cpp:614:3: error: missing terminating " character
  614 |   " when use <SID>AutoPairsReturn  will cause Duplicated <CR>
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:615:3: warning: missing terminating " character
  615 |   "
      |   ^
Main.cpp:615:3: error: missing terminating " character
Main.cpp:616:3: warning: missing terminating " character
  616 |   " and when load after vim-endwise will cause unexpected endwise inserted.
      |   ^
Main.cpp:616:3: error: missing terminating " character
  616 |   " and when load after vim-endwise will cause unexpected endwise inserted.
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:617:3: warning: missing terminating " character
  617 |   " so always load AutoPairs at last
      |   ^
Main.cpp:617:3: error: missing terminating " character
  617 |   " so always load AutoPairs at last
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:619:3: warning: missing terminating " character
  619 |   " Buffer level keys mapping
      |   ^
Main.cpp:619:3: error: missing terminating " character
  619 |   " Buffer level keys mapping
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:620:3: warning: missing terminating " character
  620 |   " comptible with other plugin
      |   ^
Main.cpp:620:3: error: missing terminating " character
  620 |   " comptible with other plugin
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.c