diff options
Diffstat (limited to 'vim/plugin/supertab.vim')
| -rw-r--r-- | vim/plugin/supertab.vim | 737 |
1 files changed, 0 insertions, 737 deletions
diff --git a/vim/plugin/supertab.vim b/vim/plugin/supertab.vim deleted file mode 100644 index 67f8c5c..0000000 --- a/vim/plugin/supertab.vim +++ /dev/null @@ -1,737 +0,0 @@ -" Author: -" Original: Gergely Kontra <kgergely@mcl.hu> -" Current: Eric Van Dewoestine <ervandew@gmail.com> (as of version 0.4) -" Please direct all correspondence to Eric. -" Version: 1.6 -" GetLatestVimScripts: 1643 1 :AutoInstall: supertab.vim -" -" Description: {{{ -" Use your tab key to do all your completion in insert mode! -" You can cycle forward and backward with the <Tab> and <S-Tab> keys -" Note: you must press <Tab> once to be able to cycle back -" -" http://www.vim.org/scripts/script.php?script_id=1643 -" }}} -" -" License: {{{ -" Copyright (c) 2002 - 2011 -" All rights reserved. -" -" Redistribution and use of this software in source and binary forms, with -" or without modification, are permitted provided that the following -" conditions are met: -" -" * Redistributions of source code must retain the above -" copyright notice, this list of conditions and the -" following disclaimer. -" -" * Redistributions in binary form must reproduce the above -" copyright notice, this list of conditions and the -" following disclaimer in the documentation and/or other -" materials provided with the distribution. -" -" * Neither the name of Gergely Kontra or Eric Van Dewoestine nor the names -" of its contributors may be used to endorse or promote products derived -" from this software without specific prior written permission of Gergely -" Kontra or Eric Van Dewoestine. -" -" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -" IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, -" THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -" PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -" CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -" EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -" PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -" NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -" SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -" }}} -" -" Testing Info: {{{ -" Running vim + supertab with the absolute bar minimum settings: -" $ vim -u NONE -U NONE -c "set nocp | runtime plugin/supertab.vim" -" }}} - -if v:version < 700 - finish -endif - -if exists('complType') " Integration with other completion functions. - finish -endif - -let s:save_cpo=&cpo -set cpo&vim - -" Global Variables {{{ - - if !exists("g:SuperTabDefaultCompletionType") - let g:SuperTabDefaultCompletionType = "<c-p>" - endif - - if !exists("g:SuperTabContextDefaultCompletionType") - let g:SuperTabContextDefaultCompletionType = "<c-p>" - endif - - if !exists("g:SuperTabCompletionContexts") - let g:SuperTabCompletionContexts = ['s:ContextText'] - endif - - if !exists("g:SuperTabRetainCompletionDuration") - let g:SuperTabRetainCompletionDuration = 'insert' - endif - - if !exists("g:SuperTabNoCompleteBefore") - " retain backwards compatability - if exists("g:SuperTabMidWordCompletion") && !g:SuperTabMidWordCompletion - let g:SuperTabNoCompleteBefore = ['\k'] - else - let g:SuperTabNoCompleteBefore = [] - endif - endif - - if !exists("g:SuperTabNoCompleteAfter") - " retain backwards compatability - if exists("g:SuperTabLeadingSpaceCompletion") && g:SuperTabLeadingSpaceCompletion - let g:SuperTabNoCompleteAfter = [] - else - let g:SuperTabNoCompleteAfter = ['\s'] - endif - endif - - if !exists("g:SuperTabMappingForward") - let g:SuperTabMappingForward = '<tab>' - endif - if !exists("g:SuperTabMappingBackward") - let g:SuperTabMappingBackward = '<s-tab>' - endif - - if !exists("g:SuperTabMappingTabLiteral") - let g:SuperTabMappingTabLiteral = '<c-tab>' - endif - - if !exists("g:SuperTabLongestEnhanced") - let g:SuperTabLongestEnhanced = 0 - endif - - if !exists("g:SuperTabLongestHighlight") - let g:SuperTabLongestHighlight = 0 - endif - - if !exists("g:SuperTabCrMapping") - let g:SuperTabCrMapping = 1 - endif - -" }}} - -" Script Variables {{{ - - " construct the help text. - let s:tabHelp = - \ "Hit <CR> or CTRL-] on the completion type you wish to switch to.\n" . - \ "Use :help ins-completion for more information.\n" . - \ "\n" . - \ "|<c-n>| - Keywords in 'complete' searching down.\n" . - \ "|<c-p>| - Keywords in 'complete' searching up (SuperTab default).\n" . - \ "|<c-x><c-l>| - Whole lines.\n" . - \ "|<c-x><c-n>| - Keywords in current file.\n" . - \ "|<c-x><c-k>| - Keywords in 'dictionary'.\n" . - \ "|<c-x><c-t>| - Keywords in 'thesaurus', thesaurus-style.\n" . - \ "|<c-x><c-i>| - Keywords in the current and included files.\n" . - \ "|<c-x><c-]>| - Tags.\n" . - \ "|<c-x><c-f>| - File names.\n" . - \ "|<c-x><c-d>| - Definitions or macros.\n" . - \ "|<c-x><c-v>| - Vim command-line.\n" . - \ "|<c-x><c-u>| - User defined completion.\n" . - \ "|<c-x><c-o>| - Omni completion.\n" . - \ "|<c-x>s| - Spelling suggestions." - - " set the available completion types and modes. - let s:types = - \ "\<c-e>\<c-y>\<c-l>\<c-n>\<c-k>\<c-t>\<c-i>\<c-]>" . - \ "\<c-f>\<c-d>\<c-v>\<c-n>\<c-p>\<c-u>\<c-o>\<c-n>\<c-p>s" - let s:modes = '/^E/^Y/^L/^N/^K/^T/^I/^]/^F/^D/^V/^P/^U/^O/s' - let s:types = s:types . "np" - let s:modes = s:modes . '/n/p' - -" }}} - -" SuperTabSetDefaultCompletionType(type) {{{ -" Globally available function that users can use to set the default -" completion type for the current buffer, like in an ftplugin. -function! SuperTabSetDefaultCompletionType(type) - " init hack for <c-x><c-v> workaround. - let b:complCommandLine = 0 - - let b:SuperTabDefaultCompletionType = a:type - - " set the current completion type to the default - call SuperTabSetCompletionType(b:SuperTabDefaultCompletionType) -endfunction " }}} - -" SuperTabSetCompletionType(type) {{{ -" Globally available function that users can use to create mappings to quickly -" switch completion modes. Useful when a user wants to restore the default or -" switch to another mode without having to kick off a completion of that type -" or use SuperTabHelp. Note, this function only changes the current -" completion type, not the default, meaning that the default will still be -" restored once the configured retension duration has been met (see -" g:SuperTabRetainCompletionDuration). To change the default for the current -" buffer, use SuperTabDefaultCompletionType(type) instead. Example mapping to -" restore SuperTab default: -" nmap <F6> :call SetSuperTabCompletionType("<c-p>")<cr> -function! SuperTabSetCompletionType(type) - call s:InitBuffer() - exec "let b:complType = \"" . escape(a:type, '<') . "\"" -endfunction " }}} - -" SuperTabAlternateCompletion(type) {{{ -" Function which can be mapped to a key to kick off an alternate completion -" other than the default. For instance, if you have 'context' as the default -" and want to map ctrl+space to issue keyword completion. -" Note: due to the way vim expands ctrl characters in mappings, you cannot -" create the alternate mapping like so: -" imap <c-space> <c-r>=SuperTabAlternateCompletion("<c-p>")<cr> -" instead, you have to use \<lt> to prevent vim from expanding the key -" when creating the mapping. -" gvim: -" imap <c-space> <c-r>=SuperTabAlternateCompletion("\<lt>c-p>")<cr> -" console: -" imap <nul> <c-r>=SuperTabAlternateCompletion("\<lt>c-p>")<cr> -function! SuperTabAlternateCompletion(type) - call SuperTabSetCompletionType(a:type) - " end any current completion before attempting to start the new one. - " use feedkeys to prevent possible remapping of <c-e> from causing issues. - "call feedkeys("\<c-e>", 'n') - " ^ since we can't detect completion mode vs regular insert mode, we force - " vim into keyword completion mode and end that mode to prevent the regular - " insert behavior of <c-e> from occurring. - call feedkeys("\<c-x>\<c-p>\<c-e>", 'n') - call feedkeys(b:complType, 'n') - return '' -endfunction " }}} - -" SuperTabLongestHighlight(dir) {{{ -" When longest highlight is enabled, this function is used to do the actual -" selection of the completion popup entry. -function! SuperTabLongestHighlight(dir) - if !pumvisible() - return '' - endif - return a:dir == -1 ? "\<up>" : "\<down>" -endfunction " }}} - -" s:Init {{{ -" Global initilization when supertab is loaded. -function! s:Init() - " Setup mechanism to restore original completion type upon leaving insert - " mode if configured to do so - if g:SuperTabRetainCompletionDuration == 'insert' - augroup supertab_retain - autocmd! - autocmd InsertLeave * call s:SetDefaultCompletionType() - augroup END - endif -endfunction " }}} - -" s:InitBuffer {{{ -" Per buffer initilization. -function! s:InitBuffer() - if exists('b:SuperTabNoCompleteBefore') - return - endif - - let b:complReset = 0 - let b:complTypeManual = !exists('b:complTypeManual') ? '' : b:complTypeManual - let b:complTypeContext = '' - - " init hack for <c-x><c-v> workaround. - let b:complCommandLine = 0 - - if !exists('b:SuperTabNoCompleteBefore') - let b:SuperTabNoCompleteBefore = g:SuperTabNoCompleteBefore - endif - if !exists('b:SuperTabNoCompleteAfter') - let b:SuperTabNoCompleteAfter = g:SuperTabNoCompleteAfter - endif - - let b:SuperTabDefaultCompletionType = g:SuperTabDefaultCompletionType - - " set the current completion type to the default - call SuperTabSetCompletionType(b:SuperTabDefaultCompletionType) -endfunction " }}} - -" s:ManualCompletionEnter() {{{ -" Handles manual entrance into completion mode. -function! s:ManualCompletionEnter() - if &smd - echo '' | echohl ModeMsg | echo '-- ^X++ mode (' . s:modes . ')' | echohl None - endif - let complType = nr2char(getchar()) - if stridx(s:types, complType) != -1 - if stridx("\<c-e>\<c-y>", complType) != -1 " no memory, just scroll... - return "\<c-x>" . complType - elseif stridx('np', complType) != -1 - let complType = nr2char(char2nr(complType) - 96) - else - let complType = "\<c-x>" . complType - endif - - let b:complTypeManual = complType - - if index(['insert', 'session'], g:SuperTabRetainCompletionDuration) != -1 - let b:complType = complType - endif - - " Hack to workaround bug when invoking command line completion via <c-r>= - if complType == "\<c-x>\<c-v>" - return s:CommandLineCompletion() - endif - - " optionally enable enhanced longest completion - if g:SuperTabLongestEnhanced && &completeopt =~ 'longest' - call s:EnableLongestEnhancement() - endif - - if g:SuperTabLongestHighlight && - \ &completeopt =~ 'longest' && - \ &completeopt =~ 'menu' && - \ !pumvisible() - let dir = (complType == "\<c-x>\<c-p>") ? -1 : 1 - call feedkeys("\<c-r>=SuperTabLongestHighlight(" . dir . ")\<cr>", 'n') - endif - - return complType - endif - - echohl "Unknown mode" - return complType -endfunction " }}} - -" s:SetCompletionType() {{{ -" Sets the completion type based on what the user has chosen from the help -" buffer. -function! s:SetCompletionType() - let chosen = substitute(getline('.'), '.*|\(.*\)|.*', '\1', '') - if chosen != getline('.') - let winnr = b:winnr - close - exec winnr . 'winc w' - call SuperTabSetCompletionType(chosen) - endif -endfunction " }}} - -" s:SetDefaultCompletionType() {{{ -function! s:SetDefaultCompletionType() - if exists('b:SuperTabDefaultCompletionType') && - \ (!exists('b:complCommandLine') || !b:complCommandLine) - call SuperTabSetCompletionType(b:SuperTabDefaultCompletionType) - endif -endfunction " }}} - -" s:SuperTab(command) {{{ -" Used to perform proper cycle navigation as the user requests the next or -" previous entry in a completion list, and determines whether or not to simply -" retain the normal usage of <tab> based on the cursor position. -function! s:SuperTab(command) - if exists('b:SuperTabDisabled') && b:SuperTabDisabled - return "\<tab>" - endif - - call s:InitBuffer() - - if s:WillComplete() - " optionally enable enhanced longest completion - if g:SuperTabLongestEnhanced && &completeopt =~ 'longest' - call s:EnableLongestEnhancement() - endif - - if !pumvisible() - let b:complTypeManual = '' - endif - - " exception: if in <c-p> mode, then <c-n> should move up the list, and - " <c-p> down the list. - if a:command == 'p' && !b:complReset && - \ (b:complType == "\<c-p>" || - \ (b:complType == 'context' && - \ b:complTypeManual == '' && - \ b:complTypeContext == "\<c-p>")) - return "\<c-n>" - - elseif a:command == 'p' && !b:complReset && - \ (b:complType == "\<c-n>" || - \ (b:complType == 'context' && - \ b:complTypeManual == '' && - \ b:complTypeContext == "\<c-n>")) - return "\<c-p>" - - " already in completion mode and not resetting for longest enhancement, so - " just scroll to next/previous - elseif pumvisible() && !b:complReset - let type = b:complType == 'context' ? b:complTypeContext : b:complType - if a:command == 'n' - return type == "\<c-p>" ? "\<c-p>" : "\<c-n>" - endif - return type == "\<c-p>" ? "\<c-n>" : "\<c-p>" - endif - - " handle 'context' completion. - if b:complType == 'context' - let complType = s:ContextCompletion() - if complType == '' - exec "let complType = \"" . - \ escape(g:SuperTabContextDefaultCompletionType, '<') . "\"" - endif - let b:complTypeContext = complType - - " Hack to workaround bug when invoking command line completion via <c-r>= - elseif b:complType == "\<c-x>\<c-v>" - let complType = s:CommandLineCompletion() - else - let complType = b:complType - endif - - " highlight first result if longest enabled - if g:SuperTabLongestHighlight && - \ &completeopt =~ 'longest' && - \ &completeopt =~ 'menu' && - \ (!pumvisible() || b:complReset) - let dir = (complType == "\<c-p>") ? -1 : 1 - call feedkeys("\<c-r>=SuperTabLongestHighlight(" . dir . ")\<cr>", 'n') - endif - - if b:complReset - let b:complReset = 0 - " not an accurate condition for everyone, but better than sending <c-e> - " at the wrong time. - if pumvisible() - return "\<c-e>" . complType - endif - endif - - return complType - endif - - return "\<tab>" -endfunction " }}} - -" s:SuperTabHelp() {{{ -" Opens a help window where the user can choose a completion type to enter. -function! s:SuperTabHelp() - let winnr = winnr() - if bufwinnr("SuperTabHelp") == -1 - botright split SuperTabHelp - - setlocal noswapfile - setlocal buftype=nowrite - setlocal bufhidden=delete - - let saved = @" - let @" = s:tabHelp - silent put - call cursor(1, 1) - silent 1,delete - call cursor(4, 1) - let @" = saved - exec "resize " . line('$') - - syntax match Special "|.\{-}|" - - setlocal readonly - setlocal nomodifiable - - nmap <silent> <buffer> <cr> :call <SID>SetCompletionType()<cr> - nmap <silent> <buffer> <c-]> :call <SID>SetCompletionType()<cr> - else - exec bufwinnr("SuperTabHelp") . "winc w" - endif - let b:winnr = winnr -endfunction " }}} - -" s:WillComplete() {{{ -" Determines if completion should be kicked off at the current location. -function! s:WillComplete() - if pumvisible() - return 1 - endif - - let line = getline('.') - let cnum = col('.') - - " Start of line. - if line =~ '^\s*\%' . cnum . 'c' - return 0 - endif - - " honor SuperTabNoCompleteAfter - let pre = line[:cnum - 2] - for pattern in b:SuperTabNoCompleteAfter - if pre =~ pattern . '$' - return 0 - endif - endfor - - " honor SuperTabNoCompleteBefore - " Within a word, but user does not have mid word completion enabled. - let post = line[cnum - 1:] - for pattern in b:SuperTabNoCompleteBefore - if post =~ '^' . pattern - return 0 - endif - endfor - - return 1 -endfunction " }}} - -" s:EnableLongestEnhancement() {{{ -function! s:EnableLongestEnhancement() - augroup supertab_reset - autocmd! - autocmd InsertLeave,CursorMovedI <buffer> - \ call s:ReleaseKeyPresses() | autocmd! supertab_reset - augroup END - call s:CaptureKeyPresses() -endfunction " }}} - -" s:CompletionReset(char) {{{ -function! s:CompletionReset(char) - let b:complReset = 1 - return a:char -endfunction " }}} - -" s:CaptureKeyPresses() {{{ -function! s:CaptureKeyPresses() - if !exists('b:capturing') || !b:capturing - let b:capturing = 1 - " save any previous mappings - " TODO: capture additional info provided by vim 7.3.032 and up. - let b:captured = { - \ '<bs>': maparg('<bs>', 'i'), - \ '<c-h>': maparg('<c-h>', 'i'), - \ } - " TODO: use &keyword to get an accurate list of chars to map - for c in split('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_', '.\zs') - exec 'imap <buffer> ' . c . ' <c-r>=<SID>CompletionReset("' . c . '")<cr>' - endfor - imap <buffer> <bs> <c-r>=<SID>CompletionReset("\<lt>bs>")<cr> - imap <buffer> <c-h> <c-r>=<SID>CompletionReset("\<lt>c-h>")<cr> - endif -endfunction " }}} - -" s:ReleaseKeyPresses() {{{ -function! s:ReleaseKeyPresses() - if exists('b:capturing') && b:capturing - let b:capturing = 0 - for c in split('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_', '.\zs') - exec 'iunmap <buffer> ' . c - endfor - - iunmap <buffer> <bs> - iunmap <buffer> <c-h> - - " restore any previous mappings - for [key, rhs] in items(b:captured) - if rhs != '' - let args = substitute(rhs, '.*\(".\{-}"\).*', '\1', '') - if args != rhs - let args = substitute(args, '<', '<lt>', 'g') - let expr = substitute(rhs, '\(.*\)".\{-}"\(.*\)', '\1%s\2', '') - let rhs = printf(expr, args) - endif - exec printf("imap <silent> %s %s", key, rhs) - endif - endfor - unlet b:captured - - if mode() == 'i' && &completeopt =~ 'menu' - " force full exit from completion mode (don't exit insert mode since - " that will break repeating with '.') - call feedkeys("\<space>\<bs>", 'n') - endif - endif -endfunction " }}} - -" s:CommandLineCompletion() {{{ -" Hack needed to account for apparent bug in vim command line mode completion -" when invoked via <c-r>= -function! s:CommandLineCompletion() - " This hack will trigger InsertLeave which will then invoke - " s:SetDefaultCompletionType. To prevent default completion from being - " restored prematurely, set an internal flag for s:SetDefaultCompletionType - " to check for. - let b:complCommandLine = 1 - return "\<c-\>\<c-o>:call feedkeys('\<c-x>\<c-v>\<c-v>', 'n') | " . - \ "let b:complCommandLine = 0\<cr>" -endfunction " }}} - -" s:ContextCompletion() {{{ -function! s:ContextCompletion() - let contexts = exists('b:SuperTabCompletionContexts') ? - \ b:SuperTabCompletionContexts : g:SuperTabCompletionContexts - - for context in contexts - try - let Context = function(context) - let complType = Context() - unlet Context - if type(complType) == 1 && complType != '' - return complType - endif - catch /E700/ - echohl Error - echom 'supertab: no context function "' . context . '" found.' - echohl None - endtry - endfor - return '' -endfunction " }}} - -" s:ContextDiscover() {{{ -function! s:ContextDiscover() - let discovery = exists('g:SuperTabContextDiscoverDiscovery') ? - \ g:SuperTabContextDiscoverDiscovery : [] - - " loop through discovery list to find the default - if !empty(discovery) - for pair in discovery - let var = substitute(pair, '\(.*\):.*', '\1', '') - let type = substitute(pair, '.*:\(.*\)', '\1', '') - exec 'let value = ' . var - if value !~ '^\s*$' && value != '0' - exec "let complType = \"" . escape(type, '<') . "\"" - return complType - endif - endfor - endif -endfunction " }}} - -" s:ContextText() {{{ -function! s:ContextText() - let exclusions = exists('g:SuperTabContextTextFileTypeExclusions') ? - \ g:SuperTabContextTextFileTypeExclusions : [] - - if index(exclusions, &ft) == -1 - let curline = getline('.') - let cnum = col('.') - let synname = synIDattr(synID(line('.'), cnum - 1, 1), 'name') - if curline =~ '.*/\w*\%' . cnum . 'c' || - \ ((has('win32') || has('win64')) && curline =~ '.*\\\w*\%' . cnum . 'c') - return "\<c-x>\<c-f>" - - elseif curline =~ '.*\(\w\|[\])]\)\(\.\|::\|->\)\w*\%' . cnum . 'c' && - \ synname !~ '\(String\|Comment\)' - let omniPrecedence = exists('g:SuperTabContextTextOmniPrecedence') ? - \ g:SuperTabContextTextOmniPrecedence : ['&completefunc', '&omnifunc'] - - for omniFunc in omniPrecedence - if omniFunc !~ '^&' - let omniFunc = '&' . omniFunc - endif - if getbufvar(bufnr('%'), omniFunc) != '' - return omniFunc == '&omnifunc' ? "\<c-x>\<c-o>" : "\<c-x>\<c-u>" - endif - endfor - endif - endif -endfunction " }}} - -" s:ExpandMap(map) {{{ -function! s:ExpandMap(map) - let map = a:map - if map =~ '<Plug>' - let plug = substitute(map, '.\{-}\(<Plug>\w\+\).*', '\1', '') - let plug_map = maparg(plug, 'i') - let map = substitute(map, '.\{-}\(<Plug>\w\+\).*', plug_map, '') - endif - return map -endfunction " }}} - -" Key Mappings {{{ - " map a regular tab to ctrl-tab (note: doesn't work in console vim) - exec 'inoremap ' . g:SuperTabMappingTabLiteral . ' <tab>' - - imap <c-x> <c-r>=<SID>ManualCompletionEnter()<cr> - - imap <script> <Plug>SuperTabForward <c-r>=<SID>SuperTab('n')<cr> - imap <script> <Plug>SuperTabBackward <c-r>=<SID>SuperTab('p')<cr> - - exec 'imap ' . g:SuperTabMappingForward . ' <Plug>SuperTabForward' - exec 'imap ' . g:SuperTabMappingBackward . ' <Plug>SuperTabBackward' - - " After hitting <Tab>, hitting it once more will go to next match - " (because in XIM mode <c-n> and <c-p> mappings are ignored) - " and wont start a brand new completion - " The side effect, that in the beginning of line <c-n> and <c-p> inserts a - " <Tab>, but I hope it may not be a problem... - let ctrl_n = maparg('<c-n>', 'i') - if ctrl_n != '' - let ctrl_n = substitute(ctrl_n, '<', '<lt>', 'g') - exec 'imap <c-n> <c-r>=<SID>ForwardBack("n", "' . ctrl_n . '")<cr>' - else - imap <c-n> <Plug>SuperTabForward - endif - let ctrl_p = maparg('<c-p>', 'i') - if ctrl_p != '' - let ctrl_p = substitute(ctrl_p, '<', '<lt>', 'g') - exec 'imap <c-p> <c-r>=<SID>ForwardBack("p", "' . ctrl_p . '")<cr>' - else - imap <c-p> <Plug>SuperTabBackward - endif - function! s:ForwardBack(command, map) - exec "let map = \"" . escape(a:map, '<') . "\"" - return pumvisible() ? s:SuperTab(a:command) : map - endfunction - - if g:SuperTabCrMapping - if maparg('<CR>','i') =~ '<CR>' - let map = maparg('<cr>', 'i') - let cr = (map =~? '\(^\|[^)]\)<cr>') - let map = s:ExpandMap(map) - exec "inoremap <script> <cr> <c-r>=<SID>SelectCompletion(" . cr . ")<cr>" . map - else - inoremap <cr> <c-r>=<SID>SelectCompletion(1)<cr> - endif - function! s:SelectCompletion(cr) - " selecting a completion - if pumvisible() - " ugly hack to let other <cr> mappings for other plugins cooperate - " with supertab - let b:supertab_pumwasvisible = 1 - return "\<c-y>" - endif - - " only needed when chained with other mappings and one of them will - " issue a <cr>. - if exists('b:supertab_pumwasvisible') && !a:cr - unlet b:supertab_pumwasvisible - return '' - endif - - " not so pleasant hack to keep <cr> working for abbreviations - let word = substitute(getline('.'), '^.*\s\+\(.*\%' . col('.') . 'c\).*', '\1', '') - if maparg(word, 'i', 1) != '' - call feedkeys("\<c-]>", 't') - call feedkeys("\<cr>", 'n') - return '' - endif - - " only return a cr if nothing else is mapped to it since we don't want - " to duplicate a cr returned by another mapping. - return a:cr ? "\<cr>" : "" - endfunction - endif -" }}} - -" Command Mappings {{{ - if !exists(":SuperTabHelp") - command SuperTabHelp :call <SID>SuperTabHelp() - endif -" }}} - -call s:Init() - -let &cpo = s:save_cpo - -" vim:ft=vim:fdm=marker |