Updated plugins

sources_non_forked/vim-snipmate/autoload/snipmate/jumping.vim

@@ -0,0 +1,205 @@
+function! s:sfile()
+	return expand('<sfile>')
+endfunction
+
+let s:state_proto = {}
+
+function! snipmate#jumping#state()
+	return copy(s:state_proto)
+endfunction
+
+function! s:listize_mirror(mirrors)
+	return map(copy(a:mirrors), '[v:val.line, v:val.col]')
+endfunction
+
+" Removes snippet state info
+function! s:state_remove() dict
+	" Remove all autocmds in group snipmate_changes in the current buffer
+	unlet! b:snip_state
+	silent! au! snipmate_changes * <buffer>
+endfunction
+
+function! s:state_find_next_stop(backwards) dict
+	let self.stop_no += a:backwards? -1 : 1
+	while !has_key(self.stops, self.stop_no)
+		if self.stop_no == self.stop_count
+			let self.stop_no = 0
+		endif
+		if self.stop_no <= 0 && a:backwards
+			let self.stop_no = self.stop_count - 1
+		endif
+		let self.stop_no += a:backwards? -1 : 1
+	endwhile
+endfunction
+
+" Update state information to correspond to the given tab stop
+function! s:state_set_stop(backwards) dict
+	call self.find_next_stop(a:backwards)
+	let self.cur_stop    = self.stops[self.stop_no]
+	let self.stop_len = (type(self.cur_stop.placeholder) == type(0))
+				\ ? self.cur_stop.placeholder
+				\ : len(snipMate#placeholder_str(self.stop_no, self.stops))
+	let self.start_col   = self.cur_stop.col
+	let self.end_col     = self.start_col + self.stop_len
+	let self.mirrors     = get(self.cur_stop, 'mirrors', [])
+	let self.old_mirrors = deepcopy(self.mirrors)
+	call cursor(self.cur_stop.line, self.cur_stop.col)
+	let self.prev_len    = col('$')
+	let self.changed = 0
+	let ret = self.select_word()
+	if (self.stop_no == 0 || self.stop_no == self.stop_count - 1) && !a:backwards
+		call self.remove()
+	endif
+	return ret
+endfunction
+
+" Jump to the next/previous tab stop
+function! s:state_jump_stop(backwards) dict
+	" Update changes just in case
+	" This seems to be only needed because insert completion does not trigger
+	" the CursorMovedI event
+	call self.update_changes()
+
+	" Store placeholder/location changes
+	let self.cur_stop.col = self.start_col
+	if self.changed
+		call self.remove_nested()
+		unlet! self.cur_stop.placeholder " avoid type error for old parsing version
+		let self.cur_stop.placeholder = [strpart(getline('.'),
+					\ self.start_col - 1, self.end_col - self.start_col)]
+	endif
+
+	return self.set_stop(a:backwards)
+endfunction
+
+function! s:state_remove_nested(...) dict
+	let id = a:0 ? a:1 : self.stop_no
+	if type(self.stops[id].placeholder) == type([])
+		for i in self.stops[id].placeholder
+			if type(i) == type([])
+				if type(i[1]) != type({})
+					call self.remove_nested(i[0])
+					call remove(self.stops, i[0])
+				else
+					call filter(self.stops[i[0]].mirrors, 'v:val isnot i[1]')
+				endif
+			endif
+			unlet i " Avoid E706
+		endfor
+	endif
+endfunction
+
+" Select the placeholder for the current tab stop
+function! s:state_select_word() dict
+	let len = self.stop_len
+	if !len | return '' | endif
+	let l = col('.') != 1 ? 'l' : ''
+	if &sel == 'exclusive'
+		return "\<esc>".l.'v'.len."l\<c-g>"
+	endif
+	return len == 1 ? "\<esc>".l.'gh' : "\<esc>".l.'v'.(len - 1)."l\<c-g>"
+endfunction
+
+" Update the snippet as text is typed. The self.update_mirrors() function does
+" the actual work.
+" If the cursor moves outside of a placeholder, call self.remove()
+function! s:state_update_changes() dict
+	let change_len = col('$') - self.prev_len
+	let self.changed = self.changed || change_len != 0
+	let self.end_col += change_len
+	let col = col('.')
+
+	if line('.') != self.cur_stop.line || col < self.start_col || col > self.end_col
+		return self.remove()
+	endif
+
+	call self.update(self.cur_stop, change_len)
+	if !empty(self.mirrors)
+		call self.update_mirrors(change_len)
+	endif
+
+	let self.prev_len = col('$')
+endfunction
+
+" Actually update the mirrors for any changed text
+function! s:state_update_mirrors(change) dict
+	let newWordLen = self.end_col - self.start_col
+	let newWord = strpart(getline('.'), self.start_col - 1, newWordLen)
+	let changeLen = a:change
+	let curLine = line('.')
+	let curCol = col('.')
+	let oldStartSnip = self.start_col
+	let i = 0
+
+	for mirror in self.mirrors
+		for stop in values(filter(copy(self.stops), 'v:key != 0'))
+			if type(stop.placeholder) == type(0)
+				if mirror.line == stop.line && mirror.col > stop.col
+							\ && mirror.col < stop.col + stop.placeholder
+					let stop.placeholder += changeLen
+				endif
+			endif
+		endfor
+
+		call self.update(mirror, changeLen)
+		" Split the line into three parts: the mirror, what's before it, and
+		" what's after it. Then combine them using the new mirror string.
+		" Subtract one to go from column index to byte index
+		let theline = getline(mirror.line)
+		let update  = strpart(theline, 0, mirror.col - 1)
+		let update .= substitute(newWord, get(mirror, 'pat', ''), get(mirror, 'sub', ''), get(mirror, 'flags', ''))
+		let update .= strpart(theline, mirror.col + self.end_col - self.start_col - a:change - 1)
+		call setline(mirror.line, update)
+	endfor
+
+	" Reposition the cursor in case a var updates on the same line but before
+	" the current tabstop
+	if oldStartSnip != self.start_col || mode() == 'i'
+		call cursor(0, curCol + self.start_col - oldStartSnip)
+	endif
+endfunction
+
+function! s:state_find_update_objects(item) dict
+	let item = a:item
+	let item.update_objects = []
+
+	" Filter the zeroth stop because it's duplicated as the last
+	for stop in values(filter(copy(self.stops), 'v:key != 0'))
+		if stop.line == item.line && stop.col > item.col
+			call add(item.update_objects, stop)
+		endif
+
+		for mirror in get(stop, 'mirrors', [])
+			if mirror.line == item.line && mirror.col > item.col
+				call add(item.update_objects, mirror)
+			endif
+		endfor
+	endfor
+
+	return item.update_objects
+endfunction
+
+function! s:state_update(item, change_len) dict
+	let item = a:item
+	if exists('item.update_objects')
+		let to_update = item.update_objects
+	else
+		let to_update = self.find_update_objects(a:item)
+		let item.update_objects = to_update
+	endif
+
+	for obj in to_update
+		let obj.col += a:change_len
+		if obj is self.cur_stop
+			let self.start_col += a:change_len
+			let self.end_col += a:change_len
+		endif
+	endfor
+endfunction
+
+call extend(s:state_proto, snipmate#util#add_methods(s:sfile(), 'state',
+			\ [ 'remove', 'set_stop', 'jump_stop', 'remove_nested',
+			\ 'select_word', 'update_changes', 'update_mirrors',
+			\ 'find_next_stop', 'find_update_objects', 'update' ]), 'error')
+
+" vim:noet:sw=4:ts=4:ft=vim

sources_non_forked/vim-snipmate/autoload/snipmate/legacy.vim

@@ -0,0 +1,129 @@
+let s:sigil = nr2char(31)
+let snipmate#legacy#sigil = s:sigil
+
+" Prepare snippet to be processed by s:BuildTabStops
+function! snipmate#legacy#process_snippet(snip)
+	let snippet = a:snip
+	let esc_bslash = '\%(\\\@<!\%(\\\\\)*\)\@<='
+
+	if exists('b:snipmate_visual')
+		let visual = substitute(b:snipmate_visual, "\n$", '', '')
+		unlet b:snipmate_visual
+	else
+		let visual = ''
+	endif
+	let snippet = substitute(snippet, '\n\(\t\+\).\{-\}\zs{VISUAL}',
+				\ substitute(escape(visual, '%\'), "\n", "\n\\\\1", 'g'), 'g')
+
+	" Evaluate eval (`...`) expressions.
+	" Backquotes prefixed with a backslash "\" are ignored.
+	" And backslash can be escaped by doubling it.
+	" Using a loop here instead of a regex fixes a bug with nested "\=".
+	if stridx(snippet, '`') != -1
+		let new = []
+		let snip = split(snippet, esc_bslash . '`', 1)
+		let isexp = 0
+		for i in snip
+			if isexp
+				call add(new, substitute(eval(i), "\n\\%$", '', ''))
+			else
+				call add(new, i)
+			endif
+			let isexp = !isexp
+		endfor
+		let snippet = join(new, '')
+		let snippet = substitute(snippet, "\r", "\n", 'g')
+		let snippet = substitute(snippet, '\\`', "`", 'g')
+	endif
+
+	" Place all text after a colon in a tab stop after the tab stop
+	" (e.g. "${#:foo}" becomes "${:foo}foo").
+	" This helps tell the position of the tab stops later.
+	let snippet = substitute(snippet, esc_bslash . '\$\({\d\+:\(.\{-}\)}\|{\d\+}\)', s:sigil . '\1\2', 'g')
+	let snippet = substitute(snippet, esc_bslash . '\$\(\d\+\)', s:sigil . '\1', 'g')
+	let snippet = substitute(snippet, esc_bslash . '\\\$', '$', 'g')
+	let snippet = substitute(snippet, '\\\\', "\\", 'g')
+
+	" Update the a:snip so that all the $# become the text after
+	" the colon in their associated ${#}.
+	" (e.g. "${1:foo}" turns all "$1"'s into "foo")
+	let i = 0
+	if snippet !~ s:sigil . '{0'
+		let snippet .= s:sigil . '{0}'
+	endif
+	while snippet =~ s:sigil.'{'.i
+		let s = matchstr(snippet, s:sigil . '{' . i . ':\zs.\{-}\ze}')
+		if s != ''
+			let snippet = substitute(snippet, s:sigil . i, s.'&', 'g')
+		endif
+		let i += 1
+	endw
+
+	if &et " Expand tabs to spaces if 'expandtab' is set.
+		return substitute(snippet, '\t', repeat(' ', (&sts > 0) ? &sts : &sw), 'g')
+	endif
+	return snippet
+endfunction
+
+" Builds a list of a list of each tab stop in the snippet containing:
+" 1.) The tab stop's line number.
+" 2.) The tab stop's column number
+"     (by getting the length of the string between the last "\n" and the
+"     tab stop).
+" 3.) The length of the text after the colon for the current tab stop
+"     (e.g. "${1:foo}" would return 3).
+" 4.) If the "${#:}" construct is given, another list containing all
+"     the matches of "$#", to be replaced with the placeholder. This list is
+"     composed the same way as the parent; the first item is the line number,
+"     and the second is the column.
+function! snipmate#legacy#build_stops(snip, lnum, col, indent)
+	let stops = {}
+	let i = 0
+	let withoutVars = substitute(a:snip, s:sigil . '\d\+', '', 'g')
+	while a:snip =~ s:sigil . '{' . i
+		let beforeTabStop = matchstr(withoutVars, '^.*\ze'.s:sigil .'{'.i.'\D')
+		let withoutOthers = substitute(withoutVars, ''.s:sigil .'{\('.i.'\D\)\@!\d\+.\{-}}', '', 'g')
+
+		let stops[i] = {}
+		let stops[i].line = a:lnum + s:count(beforeTabStop, "\n")
+		let stops[i].col = a:indent + len(matchstr(withoutOthers, '.*\(\n\|^\)\zs.*\ze'.s:sigil .'{'.i.'\D'))
+                let stops[i].placeholder = 0
+                let stops[i].mirrors = []
+		if stops[i].line == a:lnum
+			let stops[i].col += a:col
+		endif
+
+		" Get all $# matches in another list, if ${#:name} is given
+		if withoutVars =~ printf('%s{%d:', s:sigil, i)
+			let stops[i].placeholder = len(matchstr(withoutVars, ''.s:sigil .'{'.i.':\zs.\{-}\ze}'))
+			let withoutOthers = substitute(a:snip, ''.s:sigil .'{\d\+.\{-}}\|'.s:sigil .''.i.'\@!\d\+', '', 'g')
+
+			while match(withoutOthers, ''.s:sigil .''.i.'\(\D\|$\)') != -1
+				let stops[i].mirrors = get(stops[i], 'mirrors', [])
+				let beforeMark = matchstr(withoutOthers,
+							\ printf('^.\{-}\ze%s%s%d\(\D\|$\)',
+							\ repeat('.', stops[i].placeholder), s:sigil, i))
+				let line = a:lnum + s:count(beforeMark, "\n")
+				let col = a:indent + (line > a:lnum
+				                           \ ? len(matchstr(beforeMark, '.*\n\zs.*'))
+				                           \ : a:col + len(beforeMark))
+				call add(stops[i].mirrors, { 'line' : line, 'col' : col })
+				let withoutOthers = substitute(withoutOthers, ''.s:sigil .''.i.'\ze\(\D\|$\)', '', '')
+			endw
+		endif
+		let i += 1
+	endw
+	let stops[i] = stops[0]
+	return [stops, i + 1]
+endfunction
+
+" Counts occurences of haystack in needle
+function! s:count(haystack, needle)
+	let counter = 0
+	let index = stridx(a:haystack, a:needle)
+	while index != -1
+		let index = stridx(a:haystack, a:needle, index+1)
+		let counter += 1
+	endw
+	return counter
+endfunction

sources_non_forked/vim-snipmate/autoload/snipmate/parse.vim

@@ -0,0 +1,220 @@
+" Snippet definition parsing code
+
+function! s:sfile()
+    return expand('<sfile>')
+endfunction
+
+let s:parser_proto = {}
+
+function! s:new_parser(text)
+    let ret = copy(s:parser_proto)
+    let ret.input = a:text
+    let ret.len = strlen(ret.input)
+    let ret.pos = -1
+    let ret.indent = 0
+    let ret.value = []
+    let ret.vars = {}
+    call ret.advance()
+    return ret
+endfunction
+
+function! s:parser_advance(...) dict
+    let self.pos += a:0 ? a:1 : 1
+    let self.next = self.input[self.pos]
+endfunction
+
+function! s:parser_same(tok) dict
+    if self.next == a:tok
+        call self.advance()
+        return 1
+    else
+        return 0
+    endif
+endfunction
+
+function! s:parser_id() dict
+    if self.input[(self.pos):(self.pos+5)] == 'VISUAL'
+        call self.advance(6)
+        return 'VISUAL'
+    elseif self.next =~ '\d'
+        let end = matchend(self.input, '\d\+', self.pos)
+        let res = strpart(self.input, self.pos, end - self.pos)
+        call self.advance(end - self.pos)
+        return +res " force conversion to Number
+    endif
+    return -1
+endfunction
+
+function! s:parser_add_var(var) dict
+    let id = a:var[0]
+    if !has_key(self.vars, id)
+        let self.vars[id] = { 'instances' : [] }
+    endif
+    call add(self.vars[id].instances, a:var)
+endfunction
+
+function! s:parser_var() dict
+    let ret = []
+    if self.same('{')
+        let id = self.id()
+        if id >= 0
+            call add(ret, id)
+            call extend(ret, self.varend())
+        endif
+    else
+        let id = self.id()
+        if id >= 0
+            call add(ret, id)
+        endif
+    endif
+    return ret
+endfunction
+
+function! s:parser_varend() dict
+    let ret = []
+    if self.same(':')
+        call extend(ret, self.placeholder())
+    elseif self.same('/')
+        call add(ret, self.subst())
+    endif
+    call self.same('}')
+    return ret
+endfunction
+
+function! s:parser_placeholder() dict
+    return self.parse('}')
+endfunction
+
+function! s:parser_subst() dict
+    let ret = {}
+    let ret.pat = join(self.text('/', 1))
+    if self.same('/')
+        let ret.sub = join(self.text('/}'))
+    endif
+    if self.same('/')
+        let ret.flags = join(self.text('}', 1))
+    endif
+    return ret
+endfunction
+
+function! s:parser_expr() dict
+    let str = join(self.text('`', 1))
+    let ret = eval(str)
+    call self.same('`')
+    return type(ret) == type('') ? ret : string(ret)
+endfunction
+
+function! s:parser_text(...) dict
+    let res = []
+    let val = ''
+    if a:0 == 2 && a:2
+        let till = '\V' . escape(a:1, '\')
+    else
+        let till = '[`$' . (a:0 ? a:1 : '') . ']'
+    endif
+
+    while self.pos < self.len
+        if self.same('\')
+            if self.next != "\n"
+                let val .= self.next
+            endif
+            call self.advance()
+        elseif self.next =~# till
+            break
+        elseif self.next == "\n"
+            call add(res, val)
+            let val = ''
+            let self.indent = 0
+            call self.advance()
+        elseif self.next == "\t"
+            let self.indent += 1
+            let val .= s:indent(1)
+            call self.advance()
+        else
+            let val .= self.next
+            call self.advance()
+        endif
+    endwhile
+
+    call add(res, val)
+    return res
+endfunction
+
+function! s:parser_parse(...) dict
+    let ret = a:0 ? [] : self.value
+    while self.pos < self.len
+        if self.same('$')
+            let var = self.var()
+            if !empty(var)
+                if var[0] is# 'VISUAL'
+                    let add_to = s:visual_placeholder(var, self.indent)
+                    if !empty(ret) && type(ret[-1]) == type('')
+                        let ret[-1] .= add_to[0]
+                    else
+                        call add(ret, add_to[0])
+                    endif
+                    call extend(ret, add_to[1:-1])
+                elseif var[0] >= 0
+                    call add(ret, var)
+                    call self.add_var(var)
+                endif
+            endif
+        elseif self.same('`')
+            let add_to = self.expr()
+            if !empty(ret) && type(ret[-1]) == type('')
+                let ret[-1] .= add_to
+            else
+                call add(ret, add_to)
+            endif
+        else
+            let text = a:0 ? self.text(a:1) : self.text()
+            if exists('add_to')
+                let ret[-1] .= text[0]
+                call remove(text, 0)
+                unlet add_to
+            endif
+            call extend(ret, text)
+        endif
+        if a:0 && self.next == a:1
+            break
+        endif
+    endwhile
+    return ret
+endfunction
+
+call extend(s:parser_proto, snipmate#util#add_methods(s:sfile(), 'parser',
+            \ [ 'advance', 'same', 'id', 'add_var', 'var', 'varend',
+            \ 'placeholder', 'subst', 'expr', 'text', 'parse' ]), 'error')
+
+function! s:indent(count)
+    if &expandtab
+        let shift = repeat(' ', (&sts > 0) ? &sts : &sw)
+    else
+        let shift = "\t"
+    endif
+    return repeat(shift, a:count)
+endfunction
+
+function! s:visual_placeholder(var, indent)
+    let arg = get(a:var, 1, {})
+    if type(arg) == type({})
+        let pat = get(arg, 'pat', '')
+        let sub = get(arg, 'sub', '')
+        let flags = get(arg, 'flags', '')
+        let content = split(substitute(get(b:, 'snipmate_visual', ''), pat, sub, flags), "\n", 1)
+    else
+        let content = split(get(b:, 'snipmate_visual', arg), "\n", 1)
+    endif
+
+    let indent = s:indent(a:indent)
+    call map(content, '(v:key != 0) ? indent . v:val : v:val')
+
+    return content
+endfunction
+
+function! snipmate#parse#snippet(text)
+    let parser = s:new_parser(a:text)
+    call parser.parse()
+    unlet! b:snipmate_visual
+    return [parser.value, parser.vars]
+endfunction

sources_non_forked/vim-snipmate/autoload/snipmate/util.vim

@@ -0,0 +1,10 @@
+" The next function was based on s:function and s:add_methods in fugitive
+" <https://github.com/tpope/vim-fugitive/blob/master/plugin/fugitive.vim>
+function! snipmate#util#add_methods(sfile, namespace, methods)
+	let dict = {}
+	for name in a:methods
+		let dict[name] = function(join([matchstr(a:sfile, '<SNR>\d\+'),
+                    \ a:namespace, name], '_'))
+	endfor
+	return dict
+endfunction