Initial class construction

Git/usr/share/vim/vim81/indent/README.txt

@@ -0,0 +1,47 @@
+This directory contains files to automatically compute the indent for a
+type of file.
+
+If you want to add your own indent file for your personal use, read the docs
+at ":help indent-expression".  Looking at the existing files should give you
+inspiration.
+
+If you make a new indent file which would be useful for others, please send it
+to Bram@vim.org.  Include instructions for detecting the file type for this
+language, by file name extension or by checking a few lines in the file.
+And please stick to the rules below.
+
+If you have remarks about an existing file, send them to the maintainer of
+that file.  Only when you get no response send a message to Bram@vim.org.
+
+If you are the maintainer of an indent file and make improvements, e-mail the
+new version to Bram@vim.org.
+
+
+Rules for making an indent file:
+
+You should use this check for "b:did_indent":
+
+	" Only load this indent file when no other was loaded yet.
+	if exists("b:did_indent")
+	  finish
+	endif
+	let b:did_indent = 1
+
+Always use ":setlocal" to set 'indentexpr'.  This avoids it being carried over
+to other buffers.
+
+To trigger the indenting after typing a word like "endif", add the word to the
+'cinkeys' option with "+=".
+
+You normally set 'indentexpr' to evaluate a function and then define that
+function.  That function only needs to be defined once for as long as Vim is
+running.  Add a test if the function exists and use ":finish", like this:
+	if exists("*GetMyIndent")
+	  finish
+	endif
+
+The user may have several options set unlike you, try to write the file such
+that it works with any option settings.  Also be aware of certain features not
+being compiled in.
+
+To test the indent file, see testdir/README.txt.

Git/usr/share/vim/vim81/indent/aap.vim

@@ -0,0 +1,12 @@
+" Vim indent file
+" Language:	Aap recipe
+" Maintainer:	Bram Moolenaar <Bram@vim.org>
+" Last Change:	2005 Jun 24
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+
+" Works mostly like Python.
+runtime! indent/python.vim

Git/usr/share/vim/vim81/indent/ada.vim

@@ -0,0 +1,308 @@
+"------------------------------------------------------------------------------
+"  Description: Vim Ada indent file
+"     Language: Ada (2005)
+"	   $Id: ada.vim 887 2008-07-08 14:29:01Z krischik $
+"    Copyright: Copyright (C) 2006 Martin Krischik
+"   Maintainer: Martin Krischik <krischik@users.sourceforge.net>
+"		Neil Bird <neil@fnxweb.com>
+"		Ned Okie <nokie@radford.edu>
+"      $Author: krischik $
+"	 $Date: 2008-07-08 16:29:01 +0200 (Di, 08 Jul 2008) $
+"      Version: 4.6
+"    $Revision: 887 $
+"     $HeadURL: https://gnuada.svn.sourceforge.net/svnroot/gnuada/trunk/tools/vim/indent/ada.vim $
+"      History: 24.05.2006 MK Unified Headers
+"		16.07.2006 MK Ada-Mode as vim-ball
+"		15.10.2006 MK Bram's suggestion for runtime integration
+"		05.11.2006 MK Bram suggested to save on spaces
+"		19.09.2007 NO g: missing before ada#Comment
+"    Help Page: ft-vim-indent
+"------------------------------------------------------------------------------
+" ToDo:
+"  Verify handling of multi-line exprs. and recovery upon the final ';'.
+"  Correctly find comments given '"' and "" ==> " syntax.
+"  Combine the two large block-indent functions into one?
+"------------------------------------------------------------------------------
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent") || version < 700
+   finish
+endif
+
+let b:did_indent = 45
+
+setlocal indentexpr=GetAdaIndent()
+setlocal indentkeys-=0{,0}
+setlocal indentkeys+=0=~then,0=~end,0=~elsif,0=~when,0=~exception,0=~begin,0=~is,0=~record
+
+" Only define the functions once.
+if exists("*GetAdaIndent")
+   finish
+endif
+let s:keepcpo= &cpo
+set cpo&vim
+
+if exists("g:ada_with_gnat_project_files")
+   let s:AdaBlockStart = '^\s*\(if\>\|while\>\|else\>\|elsif\>\|loop\>\|for\>.*\<\(loop\|use\)\>\|declare\>\|begin\>\|type\>.*\<is\>[^;]*$\|\(type\>.*\)\=\<record\>\|procedure\>\|function\>\|accept\>\|do\>\|task\>\|package\>\|project\>\|then\>\|when\>\|is\>\)'
+else
+   let s:AdaBlockStart = '^\s*\(if\>\|while\>\|else\>\|elsif\>\|loop\>\|for\>.*\<\(loop\|use\)\>\|declare\>\|begin\>\|type\>.*\<is\>[^;]*$\|\(type\>.*\)\=\<record\>\|procedure\>\|function\>\|accept\>\|do\>\|task\>\|package\>\|then\>\|when\>\|is\>\)'
+endif
+
+" Section: s:MainBlockIndent {{{1
+"
+" Try to find indent of the block we're in
+" prev_indent = the previous line's indent
+" prev_lnum   = previous line (to start looking on)
+" blockstart  = expr. that indicates a possible start of this block
+" stop_at     = if non-null, if a matching line is found, gives up!
+" No recursive previous block analysis: simply look for a valid line
+" with a lesser or equal indent than we currently (on prev_lnum) have.
+" This shouldn't work as well as it appears to with lines that are currently
+" nowhere near the correct indent (e.g., start of line)!
+" Seems to work OK as it 'starts' with the indent of the /previous/ line.
+function s:MainBlockIndent (prev_indent, prev_lnum, blockstart, stop_at)
+   let lnum = a:prev_lnum
+   let line = substitute( getline(lnum), g:ada#Comment, '', '' )
+   while lnum > 1
+      if a:stop_at != ''  &&  line =~ '^\s*' . a:stop_at  &&  indent(lnum) < a:prev_indent
+	 return a:prev_indent
+      elseif line =~ '^\s*' . a:blockstart
+	 let ind = indent(lnum)
+	 if ind < a:prev_indent
+	    return ind
+	 endif
+      endif
+
+      let lnum = prevnonblank(lnum - 1)
+      " Get previous non-blank/non-comment-only line
+      while 1
+	 let line = substitute( getline(lnum), g:ada#Comment, '', '' )
+	 if line !~ '^\s*$' && line !~ '^\s*#'
+	    break
+	 endif
+	 let lnum = prevnonblank(lnum - 1)
+	 if lnum <= 0
+	    return a:prev_indent
+	 endif
+      endwhile
+   endwhile
+   " Fallback - just move back one
+   return a:prev_indent - shiftwidth()
+endfunction MainBlockIndent
+
+" Section: s:EndBlockIndent {{{1
+"
+" Try to find indent of the block we're in (and about to complete),
+" including handling of nested blocks. Works on the 'end' of a block.
+" prev_indent = the previous line's indent
+" prev_lnum   = previous line (to start looking on)
+" blockstart  = expr. that indicates a possible start of this block
+" blockend    = expr. that indicates a possible end of this block
+function s:EndBlockIndent( prev_indent, prev_lnum, blockstart, blockend )
+   let lnum = a:prev_lnum
+   let line = getline(lnum)
+   let ends = 0
+   while lnum > 1
+      if getline(lnum) =~ '^\s*' . a:blockstart
+	 let ind = indent(lnum)
+	 if ends <= 0
+	    if ind < a:prev_indent
+	       return ind
+	    endif
+	 else
+	    let ends = ends - 1
+	 endif
+      elseif getline(lnum) =~ '^\s*' . a:blockend
+	 let ends = ends + 1
+      endif
+
+      let lnum = prevnonblank(lnum - 1)
+      " Get previous non-blank/non-comment-only line
+      while 1
+	 let line = getline(lnum)
+	 let line = substitute( line, g:ada#Comment, '', '' )
+	 if line !~ '^\s*$'
+	    break
+	 endif
+	 let lnum = prevnonblank(lnum - 1)
+	 if lnum <= 0
+	    return a:prev_indent
+	 endif
+      endwhile
+   endwhile
+   " Fallback - just move back one
+   return a:prev_indent - shiftwidth()
+endfunction EndBlockIndent
+
+" Section: s:StatementIndent {{{1
+"
+" Return indent of previous statement-start
+" (after we've indented due to multi-line statements).
+" This time, we start searching on the line *before* the one given (which is
+" the end of a statement - we want the previous beginning).
+function s:StatementIndent( current_indent, prev_lnum )
+   let lnum  = a:prev_lnum
+   while lnum > 0
+      let prev_lnum = lnum
+      let lnum = prevnonblank(lnum - 1)
+      " Get previous non-blank/non-comment-only line
+      while 1
+	 let line = substitute( getline(lnum), g:ada#Comment, '', '' )
+
+	 if line !~ '^\s*$' && line !~ '^\s*#'
+	    break
+	 endif
+	 let lnum = prevnonblank(lnum - 1)
+	 if lnum <= 0
+	    return a:current_indent
+	 endif
+      endwhile
+      " Leave indent alone if our ';' line is part of a ';'-delineated
+      " aggregate (e.g., procedure args.) or first line after a block start.
+      if line =~ s:AdaBlockStart || line =~ '(\s*$'
+	 return a:current_indent
+      endif
+      if line !~ '[.=(]\s*$'
+	 let ind = indent(prev_lnum)
+	 if ind < a:current_indent
+	    return ind
+	 endif
+      endif
+   endwhile
+   " Fallback - just use current one
+   return a:current_indent
+endfunction StatementIndent
+
+
+" Section: GetAdaIndent {{{1
+"
+" Find correct indent of a new line based upon what went before
+"
+function GetAdaIndent()
+   " Find a non-blank line above the current line.
+   let lnum = prevnonblank(v:lnum - 1)
+   let ind = indent(lnum)
+   let package_line = 0
+
+   " Get previous non-blank/non-comment-only/non-cpp line
+   while 1
+      let line = substitute( getline(lnum), g:ada#Comment, '', '' )
+      if line !~ '^\s*$' && line !~ '^\s*#'
+	 break
+      endif
+      let lnum = prevnonblank(lnum - 1)
+      if lnum <= 0
+	 return ind
+      endif
+   endwhile
+
+   " Get default indent (from prev. line)
+   let ind = indent(lnum)
+   let initind = ind
+
+   " Now check what's on the previous line
+   if line =~ s:AdaBlockStart  ||  line =~ '(\s*$'
+      " Check for false matches to AdaBlockStart
+      let false_match = 0
+      if line =~ '^\s*\(procedure\|function\|package\)\>.*\<is\s*new\>'
+	 " Generic instantiation
+	 let false_match = 1
+      elseif line =~ ')\s*;\s*$'  ||  line =~ '^\([^(]*([^)]*)\)*[^(]*;\s*$'
+	 " forward declaration
+	 let false_match = 1
+      endif
+      " Move indent in
+      if ! false_match
+	 let ind = ind + shiftwidth()
+      endif
+   elseif line =~ '^\s*\(case\|exception\)\>'
+      " Move indent in twice (next 'when' will move back)
+      let ind = ind + 2 * shiftwidth()
+   elseif line =~ '^\s*end\s*record\>'
+      " Move indent back to tallying 'type' preceeding the 'record'.
+      " Allow indent to be equal to 'end record's.
+      let ind = s:MainBlockIndent( ind+shiftwidth(), lnum, 'type\>', '' )
+   elseif line =~ '\(^\s*new\>.*\)\@<!)\s*[;,]\s*$'
+      " Revert to indent of line that started this parenthesis pair
+      exe lnum
+      exe 'normal! $F)%'
+      if getline('.') =~ '^\s*('
+	 " Dire layout - use previous indent (could check for g:ada#Comment here)
+	 let ind = indent( prevnonblank( line('.')-1 ) )
+      else
+	 let ind = indent('.')
+      endif
+      exe v:lnum
+   elseif line =~ '[.=(]\s*$'
+      " A statement continuation - move in one
+      let ind = ind + shiftwidth()
+   elseif line =~ '^\s*new\>'
+      " Multiple line generic instantiation ('package blah is\nnew thingy')
+      let ind = s:StatementIndent( ind - shiftwidth(), lnum )
+   elseif line =~ ';\s*$'
+      " Statement end (but not 'end' ) - try to find current statement-start indent
+      let ind = s:StatementIndent( ind, lnum )
+   endif
+
+   " Check for potential argument list on next line
+   let continuation = (line =~ '[A-Za-z0-9_]\s*$')
+
+
+   " Check current line; search for simplistic matching start-of-block
+   let line = getline(v:lnum)
+   if line =~ '^\s*#'
+      " Start of line for ada-pp
+      let ind = 0
+   elseif continuation && line =~ '^\s*('
+      " Don't do this if we've already indented due to the previous line
+      if ind == initind
+	 let ind = ind + shiftwidth()
+      endif
+   elseif line =~ '^\s*\(begin\|is\)\>'
+      let ind = s:MainBlockIndent( ind, lnum, '\(procedure\|function\|declare\|package\|task\)\>', 'begin\>' )
+   elseif line =~ '^\s*record\>'
+      let ind = s:MainBlockIndent( ind, lnum, 'type\>\|for\>.*\<use\>', '' ) + shiftwidth()
+   elseif line =~ '^\s*\(else\|elsif\)\>'
+      let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
+   elseif line =~ '^\s*when\>'
+      " Align 'when' one /in/ from matching block start
+      let ind = s:MainBlockIndent( ind, lnum, '\(case\|exception\)\>', '' ) + shiftwidth()
+   elseif line =~ '^\s*end\>\s*\<if\>'
+      " End of if statements
+      let ind = s:EndBlockIndent( ind, lnum, 'if\>', 'end\>\s*\<if\>' )
+   elseif line =~ '^\s*end\>\s*\<loop\>'
+      " End of loops
+      let ind = s:EndBlockIndent( ind, lnum, '\(\(while\|for\)\>.*\)\?\<loop\>', 'end\>\s*\<loop\>' )
+   elseif line =~ '^\s*end\>\s*\<record\>'
+      " End of records
+      let ind = s:EndBlockIndent( ind, lnum, '\(type\>.*\)\=\<record\>', 'end\>\s*\<record\>' )
+   elseif line =~ '^\s*end\>\s*\<procedure\>'
+      " End of procedures
+      let ind = s:EndBlockIndent( ind, lnum, 'procedure\>.*\<is\>', 'end\>\s*\<procedure\>' )
+   elseif line =~ '^\s*end\>\s*\<case\>'
+      " End of case statement
+      let ind = s:EndBlockIndent( ind, lnum, 'case\>.*\<is\>', 'end\>\s*\<case\>' )
+   elseif line =~ '^\s*end\>'
+      " General case for end
+      let ind = s:MainBlockIndent( ind, lnum, '\(if\|while\|for\|loop\|accept\|begin\|record\|case\|exception\|package\)\>', '' )
+   elseif line =~ '^\s*exception\>'
+      let ind = s:MainBlockIndent( ind, lnum, 'begin\>', '' )
+   elseif line =~ '^\s*then\>'
+      let ind = s:MainBlockIndent( ind, lnum, 'if\>', '' )
+   endif
+
+   return ind
+endfunction GetAdaIndent
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+finish " 1}}}
+
+"------------------------------------------------------------------------------
+"   Copyright (C) 2006	Martin Krischik
+"
+"   Vim is Charityware - see ":help license" or uganda.txt for licence details.
+"------------------------------------------------------------------------------
+" vim: textwidth=78 wrap tabstop=8 shiftwidth=3 softtabstop=3 noexpandtab
+" vim: foldmethod=marker

Git/usr/share/vim/vim81/indent/ant.vim

@@ -0,0 +1,12 @@
+" Vim indent file
+" Language:    ANT files
+" Maintainer:  David Fishburn <fishburn@ianywhere.com>
+" Last Change: Thu May 15 2003 10:02:54 PM
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+
+" Use XML formatting rules
+runtime! indent/xml.vim

Git/usr/share/vim/vim81/indent/automake.vim

@@ -0,0 +1,11 @@
+" Vim indent file
+" Language:    	    automake
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2006-04-19
+
+if exists("b:did_indent")
+  finish
+endif
+
+" same as makefile indenting for now.
+runtime! indent/make.vim

Git/usr/share/vim/vim81/indent/awk.vim

@@ -0,0 +1,232 @@
+"  vim: set sw=3 sts=3:
+
+" Awk indent script. It can handle multi-line statements and expressions.
+" It works up to the point where the distinction between correct/incorrect
+" and personal taste gets fuzzy. Drop me an e-mail for bug reports and
+" reasonable style suggestions.
+"
+" Bugs:
+" =====
+" - Some syntax errors may cause erratic indentation.
+" - Same for very unusual but syntacticly correct use of { }
+" - In some cases it's confused by the use of ( and { in strings constants
+" - This version likes the closing brace of a multiline pattern-action be on
+"   character position 1 before the following pattern-action combination is
+"   formatted
+
+" Author:
+" =======
+" Erik Janssen, ejanssen@itmatters.nl
+"
+" History:
+" ========
+" 26-04-2002 Got initial version working reasonably well
+" 29-04-2002 Fixed problems in function headers and max line width
+"	     Added support for two-line if's without curly braces
+" Fixed hang: 2011 Aug 31
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+
+let b:did_indent = 1
+
+setlocal indentexpr=GetAwkIndent()
+" Mmm, copied from the tcl indent program. Is this okay?
+setlocal indentkeys-=:,0#
+
+" Only define the function once.
+if exists("*GetAwkIndent")
+    finish
+endif
+
+" This function contains a lot of exit points. It checks for simple cases
+" first to get out of the function as soon as possible, thereby reducing the
+" number of possibilities later on in the difficult parts
+
+function! GetAwkIndent()
+
+   " Find previous line and get it's indentation
+   let prev_lineno = s:Get_prev_line( v:lnum )
+   if prev_lineno == 0
+      return 0
+   endif
+   let prev_data = getline( prev_lineno )
+   let ind = indent( prev_lineno )
+
+   " Increase indent if the previous line contains an opening brace. Search
+   " for this brace the hard way to prevent errors if the previous line is a
+   " 'pattern { action }' (simple check match on /{/ increases the indent then)
+
+   if s:Get_brace_balance( prev_data, '{', '}' ) > 0
+      return ind + shiftwidth()
+   endif
+
+   let brace_balance = s:Get_brace_balance( prev_data, '(', ')' )
+
+   " If prev line has positive brace_balance and starts with a word (keyword
+   " or function name), align the current line on the first '(' of the prev
+   " line
+
+   if brace_balance > 0 && s:Starts_with_word( prev_data )
+      return s:Safe_indent( ind, s:First_word_len(prev_data), getline(v:lnum))
+   endif
+
+   " If this line starts with an open brace bail out now before the line
+   " continuation checks.
+
+   if getline( v:lnum ) =~ '^\s*{'
+      return ind
+   endif
+
+   " If prev line seems to be part of multiline statement:
+   " 1. Prev line is first line of a multiline statement
+   "    -> attempt to indent on first ' ' or '(' of prev line, just like we
+   "       indented the positive brace balance case above
+   " 2. Prev line is not first line of a multiline statement
+   "    -> copy indent of prev line
+
+   let continue_mode = s:Seems_continuing( prev_data )
+   if continue_mode > 0
+     if s:Seems_continuing( getline(s:Get_prev_line( prev_lineno )) )
+       " Case 2
+       return ind
+     else
+       " Case 1
+       if continue_mode == 1
+	  " Need continuation due to comma, backslash, etc
+	  return s:Safe_indent( ind, s:First_word_len(prev_data), getline(v:lnum))
+       else
+	 " if/for/while without '{'
+	 return ind + shiftwidth()
+       endif
+     endif
+   endif
+
+   " If the previous line doesn't need continuation on the current line we are
+   " on the start of a new statement.  We have to make sure we align with the
+   " previous statement instead of just the previous line. This is a bit
+   " complicated because the previous statement might be multi-line.
+   "
+   " The start of a multiline statement can be found by:
+   "
+   " 1 If the previous line contains closing braces and has negative brace
+   "   balance, search backwards until cumulative brace balance becomes zero,
+   "   take indent of that line
+   " 2 If the line before the previous needs continuation search backward
+   "   until that's not the case anymore. Take indent of one line down.
+
+   " Case 1
+   if prev_data =~ ')' && brace_balance < 0
+      while brace_balance != 0 && prev_lineno > 0
+	 let prev_lineno = s:Get_prev_line( prev_lineno )
+	 let prev_data = getline( prev_lineno )
+	 let brace_balance=brace_balance+s:Get_brace_balance(prev_data,'(',')' )
+      endwhile
+      let ind = indent( prev_lineno )
+   else
+      " Case 2
+      if s:Seems_continuing( getline( prev_lineno - 1 ) )
+	 let prev_lineno = prev_lineno - 2
+	 let prev_data = getline( prev_lineno )
+	 while prev_lineno > 0 && (s:Seems_continuing( prev_data ) > 0)
+	    let prev_lineno = s:Get_prev_line( prev_lineno )
+	    let prev_data = getline( prev_lineno )
+	 endwhile
+	 let ind = indent( prev_lineno + 1 )
+      endif
+   endif
+
+   " Decrease indent if this line contains a '}'.
+   if getline(v:lnum) =~ '^\s*}'
+      let ind = ind - shiftwidth()
+   endif
+
+   return ind
+endfunction
+
+" Find the open and close braces in this line and return how many more open-
+" than close braces there are. It's also used to determine cumulative balance
+" across multiple lines.
+
+function! s:Get_brace_balance( line, b_open, b_close )
+   let line2 = substitute( a:line, a:b_open, "", "g" )
+   let openb = strlen( a:line ) - strlen( line2 )
+   let line3 = substitute( line2, a:b_close, "", "g" )
+   let closeb = strlen( line2 ) - strlen( line3 )
+   return openb - closeb
+endfunction
+
+" Find out whether the line starts with a word (i.e. keyword or function
+" call). Might need enhancements here.
+
+function! s:Starts_with_word( line )
+  if a:line =~ '^\s*[a-zA-Z_0-9]\+\s*('
+     return 1
+  endif
+  return 0
+endfunction
+
+" Find the length of the first word in a line. This is used to be able to
+" align a line relative to the 'print ' or 'if (' on the previous line in case
+" such a statement spans multiple lines.
+" Precondition: only to be used on lines where 'Starts_with_word' returns 1.
+
+function! s:First_word_len( line )
+   let white_end = matchend( a:line, '^\s*' )
+   if match( a:line, '^\s*func' ) != -1
+     let word_end = matchend( a:line, '[a-z]\+\s\+[a-zA-Z_0-9]\+[ (]*' )
+   else
+     let word_end = matchend( a:line, '[a-zA-Z_0-9]\+[ (]*' )
+   endif
+   return word_end - white_end
+endfunction
+
+" Determine if 'line' completes a statement or is continued on the next line.
+" This one is far from complete and accepts illegal code. Not important for
+" indenting, however.
+
+function! s:Seems_continuing( line )
+  " Unfinished lines
+  if a:line =~ '\(--\|++\)\s*$'
+    return 0
+  endif
+  if a:line =~ '[\\,\|\&\+\-\*\%\^]\s*$'
+    return 1
+  endif
+  " if/for/while (cond) eol
+  if a:line =~ '^\s*\(if\|while\|for\)\s*(.*)\s*$' || a:line =~ '^\s*else\s*'
+      return 2
+   endif
+  return 0
+endfunction
+
+" Get previous relevant line. Search back until a line is that is no
+" comment or blank and return the line number
+
+function! s:Get_prev_line( lineno )
+   let lnum = a:lineno - 1
+   let data = getline( lnum )
+   while lnum > 0 && (data =~ '^\s*#' || data =~ '^\s*$')
+      let lnum = lnum - 1
+      let data = getline( lnum )
+   endwhile
+   return lnum
+endfunction
+
+" This function checks whether an indented line exceeds a maximum linewidth
+" (hardcoded 80). If so and it is possible to stay within 80 positions (or
+" limit num of characters beyond linewidth) by decreasing the indent (keeping
+" it > base_indent), do so.
+
+function! s:Safe_indent( base, wordlen, this_line )
+   let line_base = matchend( a:this_line, '^\s*' )
+   let line_len = strlen( a:this_line ) - line_base
+   let indent = a:base
+   if (indent + a:wordlen + line_len) > 80
+     " Simple implementation good enough for the time being
+     let indent = indent + 3
+   endif
+   return indent + a:wordlen
+endfunction

Git/usr/share/vim/vim81/indent/bib.vim

@@ -0,0 +1,15 @@
+" Vim indent file
+" Language:      BibTeX
+" Maintainer:    Dorai Sitaram <ds26@gte.com>
+" URL:		 http://www.ccs.neu.edu/~dorai/vimplugins/vimplugins.html
+" Last Change:   2005 Mar 28
+
+" Only do this when not done yet for this buffer
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal cindent
+
+let b:undo_indent = "setl cin<"

Git/usr/share/vim/vim81/indent/bst.vim

@@ -0,0 +1,75 @@
+" Vim indent file
+" Language:	bst
+" Author:	Tim Pope <vimNOSPAM@tpope.info>
+" $Id: bst.vim,v 1.1 2007/05/05 18:11:12 vimboss Exp $
+
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+setlocal expandtab
+setlocal indentexpr=GetBstIndent(v:lnum)
+"setlocal smartindent
+setlocal cinkeys&
+setlocal cinkeys-=0#
+setlocal indentkeys&
+"setlocal indentkeys+=0%
+
+" Only define the function once.
+if exists("*GetBstIndent")
+    finish
+endif
+
+function! s:prevgood(lnum)
+    " Find a non-blank line above the current line.
+    " Skip over comments.
+    let lnum = a:lnum
+    while lnum > 0
+        let lnum = prevnonblank(lnum - 1)
+        if getline(lnum) !~ '^\s*%.*$'
+            break
+        endif
+    endwhile
+    return lnum
+endfunction
+
+function! s:strip(lnum)
+    let line = getline(a:lnum)
+    let line = substitute(line,'"[^"]*"','""','g')
+    let line = substitute(line,'%.*','','')
+    let line = substitute(line,'^\s\+','','')
+    return line
+endfunction
+
+function! s:count(string,char)
+    let str = substitute(a:string,'[^'.a:char.']','','g')
+    return strlen(str)
+endfunction
+
+function! GetBstIndent(lnum) abort
+    if a:lnum == 1
+        return 0
+    endif
+    let lnum = s:prevgood(a:lnum)
+    if lnum <= 0
+        return indent(a:lnum - 1)
+    endif
+    let line = s:strip(lnum)
+    let cline = s:strip(a:lnum)
+    if cline =~ '^}' && exists("b:current_syntax")
+        call cursor(a:lnum,indent(a:lnum))
+        if searchpair('{','','}','bW',"synIDattr(synID(line('.'),col('.'),1),'name') =~? 'comment\\|string'")
+            if col('.')+1 == col('$')
+                return indent('.')
+            else
+                return virtcol('.')-1
+            endif
+        endif
+    endif
+    let fakeline = substitute(line,'^}','','').matchstr(cline,'^}')
+    let ind = indent(lnum)
+    let ind = ind + shiftwidth() * s:count(line,'{')
+    let ind = ind - shiftwidth() * s:count(fakeline,'}')
+    return ind
+endfunction

Git/usr/share/vim/vim81/indent/bzl.vim

@@ -0,0 +1,94 @@
+" Vim indent file
+" Language:	Bazel (http://bazel.io)
+" Maintainer:	David Barnett (https://github.com/google/vim-ft-bzl)
+" Last Change:	2017 Jun 13
+
+if exists('b:did_indent')
+  finish
+endif
+
+" Load base python indent.
+if !exists('*GetPythonIndent')
+  runtime! indent/python.vim
+endif
+
+let b:did_indent = 1
+
+" Only enable bzl google indent if python google indent is enabled.
+if !get(g:, 'no_google_python_indent')
+  setlocal indentexpr=GetBzlIndent(v:lnum)
+endif
+
+if exists('*GetBzlIndent')
+  finish
+endif
+
+let s:save_cpo = &cpo
+set cpo-=C
+
+" Maximum number of lines to look backwards.
+let s:maxoff = 50
+
+""
+" Determine the correct indent level given an {lnum} in the current buffer.
+function GetBzlIndent(lnum) abort
+  let l:use_recursive_indent = !get(g:, 'no_google_python_recursive_indent')
+  if l:use_recursive_indent
+    " Backup and override indent setting variables.
+    if exists('g:pyindent_nested_paren')
+      let l:pyindent_nested_paren = g:pyindent_nested_paren
+    endif
+    if exists('g:pyindent_open_paren')
+      let l:pyindent_open_paren = g:pyindent_open_paren
+    endif
+    let g:pyindent_nested_paren = 'shiftwidth() * 2'
+    let g:pyindent_open_paren = 'shiftwidth() * 2'
+  endif
+
+  let l:indent = -1
+
+  " Indent inside parens.
+  " Align with the open paren unless it is at the end of the line.
+  " E.g.
+  "   open_paren_not_at_EOL(100,
+  "                         (200,
+  "                          300),
+  "                         400)
+  "   open_paren_at_EOL(
+  "       100, 200, 300, 400)
+  call cursor(a:lnum, 1)
+  let [l:par_line, l:par_col] = searchpairpos('(\|{\|\[', '', ')\|}\|\]', 'bW',
+      \ "line('.') < " . (a:lnum - s:maxoff) . " ? dummy :" .
+      \ " synIDattr(synID(line('.'), col('.'), 1), 'name')" .
+      \ " =~ '\\(Comment\\|String\\)$'")
+  if l:par_line > 0
+    call cursor(l:par_line, 1)
+    if l:par_col != col('$') - 1
+      let l:indent = l:par_col
+    endif
+  endif
+
+  " Delegate the rest to the original function.
+  if l:indent == -1
+    let l:indent = GetPythonIndent(a:lnum)
+  endif
+
+  if l:use_recursive_indent
+    " Restore global variables.
+    if exists('l:pyindent_nested_paren')
+      let g:pyindent_nested_paren = l:pyindent_nested_paren
+    else
+      unlet g:pyindent_nested_paren
+    endif
+    if exists('l:pyindent_open_paren')
+      let g:pyindent_open_paren = l:pyindent_open_paren
+    else
+      unlet g:pyindent_open_paren
+    endif
+  endif
+
+  return l:indent
+endfunction
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

Git/usr/share/vim/vim81/indent/c.vim

@@ -0,0 +1,15 @@
+" Vim indent file
+" Language:	C
+" Maintainer:	Bram Moolenaar <Bram@vim.org>
+" Last Change:	2005 Mar 27
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+   finish
+endif
+let b:did_indent = 1
+
+" C indenting is built-in, thus this is very simple
+setlocal cindent
+
+let b:undo_indent = "setl cin<"

Git/usr/share/vim/vim81/indent/cdl.vim

@@ -0,0 +1,129 @@
+" Description:	Comshare Dimension Definition Language (CDL)
+" Author:	Raul Segura Acevedo <raulseguraaceved@netscape.net>
+" Last Change:	Fri Nov 30 13:35:48  2001 CST
+
+if exists("b:did_indent")
+    "finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=CdlGetIndent(v:lnum)
+setlocal indentkeys&
+setlocal indentkeys+==~else,=~endif,=~then,;,),=
+
+" Only define the function once.
+if exists("*CdlGetIndent")
+    "finish
+endif
+
+" find out if an "...=..." expresion is an assignment (or a conditional)
+" it scans 'line' first, and then the previos lines
+fun! CdlAsignment(lnum, line)
+  let f = -1
+  let lnum = a:lnum
+  let line = a:line
+  while lnum > 0 && f == -1
+    " line without members [a] of [b]:[c]...
+    let inicio = 0
+    while 1
+      " keywords that help to decide
+      let inicio = matchend(line, '\c\<\(expr\|\a*if\|and\|or\|not\|else\|then\|memberis\|\k\+of\)\>\|[<>;]', inicio)
+      if inicio < 0
+	break
+      endif
+      " it's formula if there's a ';', 'elsE', 'theN', 'enDif' or 'expr'
+      " conditional if there's a '<', '>', 'elseif', 'if', 'and', 'or', 'not',
+      " 'memberis', 'childrenof' and other \k\+of funcions
+      let f = line[inicio-1] =~? '[en;]' || strpart(line, inicio-4, 4) =~? 'ndif\|expr'
+    endw
+    let lnum = prevnonblank(lnum-1)
+    let line = substitute(getline(lnum), '\c\(\[[^]]*]\(\s*of\s*\|:\)*\)\+', ' ', 'g')
+  endw
+  " if we hit the start of the file then f = -1, return 1 (formula)
+  return f != 0
+endf
+
+fun! CdlGetIndent(lnum)
+  let thisline = getline(a:lnum)
+  if match(thisline, '^\s*\(\k\+\|\[[^]]*]\)\s*\(,\|;\s*$\)') >= 0
+    " it's an attributes line
+    return shiftwidth()
+  elseif match(thisline, '^\c\s*\([{}]\|\/[*/]\|dimension\|schedule\|group\|hierarchy\|class\)') >= 0
+    " it's a header or '{' or '}' or a comment
+    return 0
+  end
+
+  let lnum = prevnonblank(a:lnum-1)
+  " Hit the start of the file, use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  " PREVIOUS LINE
+  let ind = indent(lnum)
+  let line = getline(lnum)
+  let f = -1 " wether a '=' is a conditional or a asignment, -1 means we don't know yet
+  " one 'closing' element at the beginning of the line has already reduced the
+  "   indent, but 'else', 'elseif' & 'then' increment it for the next line
+  " '=' at the beginning has already de right indent (increased for asignments)
+  let inicio = matchend(line, '^\c\s*\(else\a*\|then\|endif\|/[*/]\|[);={]\)')
+  if inicio > 0
+    let c = line[inicio-1]
+    " ')' and '=' don't change indent and are useless to set 'f'
+    if c == '{'
+      return shiftwidth()
+    elseif c != ')' && c != '='
+      let f = 1 " all but 'elseif' are followed by a formula
+      if c ==? 'n' || c ==? 'e' " 'then', 'else'
+	let ind = ind + shiftwidth()
+      elseif strpart(line, inicio-6, 6) ==? 'elseif' " elseif, set f to conditional
+	let ind = ind + shiftwidth()
+	let f = 0
+      end
+    end
+  end
+
+  " remove members [a] of [b]:[c]... (inicio remainds valid)
+  let line = substitute(line, '\c\(\[[^]]*]\(\s*of\s*\|:\)*\)\+', ' ', 'g')
+  while 1
+    " search for the next interesting element
+    let inicio=matchend(line, '\c\<if\|endif\|[()=;]', inicio)
+    if inicio < 0
+      break
+    end
+
+    let c = line[inicio-1]
+    " 'expr(...)' containing the formula
+    if strpart(line, inicio-5, 5) ==? 'expr('
+      let ind = 0
+      let f = 1
+    elseif c == ')' || c== ';' || strpart(line, inicio-5, 5) ==? 'endif'
+      let ind = ind - shiftwidth()
+    elseif c == '(' || c ==? 'f' " '(' or 'if'
+      let ind = ind + shiftwidth()
+    else " c == '='
+      " if it is an asignment increase indent
+      if f == -1 " we don't know yet, find out
+	let f = CdlAsignment(lnum, strpart(line, 0, inicio))
+      end
+      if f == 1 " formula increase it
+	let ind = ind + shiftwidth()
+      end
+    end
+  endw
+
+  " CURRENT LINE, if it starts with a closing element, decrease indent
+  " or if it starts with '=' (asignment), increase indent
+  if match(thisline, '^\c\s*\(else\|then\|endif\|[);]\)') >= 0
+    let ind = ind - shiftwidth()
+  elseif match(thisline, '^\s*=') >= 0
+    if f == -1 " we don't know yet if is an asignment, find out
+      let f = CdlAsignment(lnum, "")
+    end
+    if f == 1 " formula increase it
+      let ind = ind + shiftwidth()
+    end
+  end
+
+  return ind
+endfun

Git/usr/share/vim/vim81/indent/ch.vim

@@ -0,0 +1,18 @@
+" Vim indent file
+" Language:	Ch
+" Maintainer:	SoftIntegration, Inc. <info@softintegration.com>
+" URL:		http://www.softintegration.com/download/vim/indent/ch.vim
+" Last change:	2006 Apr 30
+"		Created based on cpp.vim
+"
+" Ch is a C/C++ interpreter with many high level extensions
+
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+   finish
+endif
+let b:did_indent = 1
+
+" Ch indenting is built-in, thus this is very simple
+setlocal cindent

Git/usr/share/vim/vim81/indent/chaiscript.vim

@@ -0,0 +1,50 @@
+" Vim indent file
+" Language:     ChaiScript
+" Maintainer:	Jason Turner <lefticus 'at' gmail com>
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetChaiScriptIndent()
+setlocal autoindent
+
+" Only define the function once.
+if exists("*GetChaiScriptIndent")
+  finish
+endif
+
+function! GetChaiScriptIndent()
+  " Find a non-blank line above the current line.
+  let lnum = prevnonblank(v:lnum - 1)
+
+  " Hit the start of the file, use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  " Add a 'shiftwidth' after lines that start a block:
+  " lines containing a {
+  let ind = indent(lnum)
+  let flag = 0
+  let prevline = getline(lnum)
+  if prevline =~ '^.*{.*'
+    let ind = ind + shiftwidth()
+    let flag = 1
+  endif
+
+  " Subtract a 'shiftwidth' after lines containing a { followed by a }
+  " to keep it balanced
+  if flag == 1 && prevline =~ '.*{.*}.*'
+    let ind = ind - shiftwidth()
+  endif
+
+  " Subtract a 'shiftwidth' on lines ending with }
+  if getline(v:lnum) =~ '^\s*\%(}\)'
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/changelog.vim

@@ -0,0 +1,14 @@
+" Vim indent file
+" Language:	generic Changelog file
+" Maintainer:	noone
+" Last Change:	2005 Mar 29
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+   finish
+endif
+let b:did_indent = 1
+
+setlocal ai
+
+let b:undo_indent = "setl ai<"

Git/usr/share/vim/vim81/indent/clojure.vim

@@ -0,0 +1,394 @@
+" Vim indent file
+" Language:     Clojure
+" Author:       Meikel Brandmeyer <mb@kotka.de>
+" URL:          http://kotka.de/projects/clojure/vimclojure.html
+"
+" Maintainer:   Sung Pae <self@sungpae.com>
+" URL:          https://github.com/guns/vim-clojure-static
+" License:      Same as Vim
+" Last Change:  18 July 2016
+
+if exists("b:did_indent")
+	finish
+endif
+let b:did_indent = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+let b:undo_indent = 'setlocal autoindent< smartindent< expandtab< softtabstop< shiftwidth< indentexpr< indentkeys<'
+
+setlocal noautoindent nosmartindent
+setlocal softtabstop=2 shiftwidth=2 expandtab
+setlocal indentkeys=!,o,O
+
+if exists("*searchpairpos")
+
+	if !exists('g:clojure_maxlines')
+		let g:clojure_maxlines = 100
+	endif
+
+	if !exists('g:clojure_fuzzy_indent')
+		let g:clojure_fuzzy_indent = 1
+	endif
+
+	if !exists('g:clojure_fuzzy_indent_patterns')
+		let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let']
+	endif
+
+	if !exists('g:clojure_fuzzy_indent_blacklist')
+		let g:clojure_fuzzy_indent_blacklist = ['-fn$', '\v^with-%(meta|out-str|loading-context)$']
+	endif
+
+	if !exists('g:clojure_special_indent_words')
+		let g:clojure_special_indent_words = 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn'
+	endif
+
+	if !exists('g:clojure_align_multiline_strings')
+		let g:clojure_align_multiline_strings = 0
+	endif
+
+	if !exists('g:clojure_align_subforms')
+		let g:clojure_align_subforms = 0
+	endif
+
+	function! s:syn_id_name()
+		return synIDattr(synID(line("."), col("."), 0), "name")
+	endfunction
+
+	function! s:ignored_region()
+		return s:syn_id_name() =~? '\vstring|regex|comment|character'
+	endfunction
+
+	function! s:current_char()
+		return getline('.')[col('.')-1]
+	endfunction
+
+	function! s:current_word()
+		return getline('.')[col('.')-1 : searchpos('\v>', 'n', line('.'))[1]-2]
+	endfunction
+
+	function! s:is_paren()
+		return s:current_char() =~# '\v[\(\)\[\]\{\}]' && !s:ignored_region()
+	endfunction
+
+	" Returns 1 if string matches a pattern in 'patterns', which may be a
+	" list of patterns, or a comma-delimited string of implicitly anchored
+	" patterns.
+	function! s:match_one(patterns, string)
+		let list = type(a:patterns) == type([])
+		           \ ? a:patterns
+		           \ : map(split(a:patterns, ','), '"^" . v:val . "$"')
+		for pat in list
+			if a:string =~# pat | return 1 | endif
+		endfor
+	endfunction
+
+	function! s:match_pairs(open, close, stopat)
+		" Stop only on vector and map [ resp. {. Ignore the ones in strings and
+		" comments.
+		if a:stopat == 0
+			let stopat = max([line(".") - g:clojure_maxlines, 0])
+		else
+			let stopat = a:stopat
+		endif
+
+		let pos = searchpairpos(a:open, '', a:close, 'bWn', "!s:is_paren()", stopat)
+		return [pos[0], col(pos)]
+	endfunction
+
+	function! s:clojure_check_for_string_worker()
+		" Check whether there is the last character of the previous line is
+		" highlighted as a string. If so, we check whether it's a ". In this
+		" case we have to check also the previous character. The " might be the
+		" closing one. In case the we are still in the string, we search for the
+		" opening ". If this is not found we take the indent of the line.
+		let nb = prevnonblank(v:lnum - 1)
+
+		if nb == 0
+			return -1
+		endif
+
+		call cursor(nb, 0)
+		call cursor(0, col("$") - 1)
+		if s:syn_id_name() !~? "string"
+			return -1
+		endif
+
+		" This will not work for a " in the first column...
+		if s:current_char() == '"'
+			call cursor(0, col("$") - 2)
+			if s:syn_id_name() !~? "string"
+				return -1
+			endif
+			if s:current_char() != '\\'
+				return -1
+			endif
+			call cursor(0, col("$") - 1)
+		endif
+
+		let p = searchpos('\(^\|[^\\]\)\zs"', 'bW')
+
+		if p != [0, 0]
+			return p[1] - 1
+		endif
+
+		return indent(".")
+	endfunction
+
+	function! s:check_for_string()
+		let pos = getpos('.')
+		try
+			let val = s:clojure_check_for_string_worker()
+		finally
+			call setpos('.', pos)
+		endtry
+		return val
+	endfunction
+
+	function! s:strip_namespace_and_macro_chars(word)
+		return substitute(a:word, "\\v%(.*/|[#'`~@^,]*)(.*)", '\1', '')
+	endfunction
+
+	function! s:clojure_is_method_special_case_worker(position)
+		" Find the next enclosing form.
+		call search('\S', 'Wb')
+
+		" Special case: we are at a '(('.
+		if s:current_char() == '('
+			return 0
+		endif
+		call cursor(a:position)
+
+		let next_paren = s:match_pairs('(', ')', 0)
+
+		" Special case: we are now at toplevel.
+		if next_paren == [0, 0]
+			return 0
+		endif
+		call cursor(next_paren)
+
+		call search('\S', 'W')
+		let w = s:strip_namespace_and_macro_chars(s:current_word())
+		if g:clojure_special_indent_words =~# '\V\<' . w . '\>'
+			return 1
+		endif
+
+		return 0
+	endfunction
+
+	function! s:is_method_special_case(position)
+		let pos = getpos('.')
+		try
+			let val = s:clojure_is_method_special_case_worker(a:position)
+		finally
+			call setpos('.', pos)
+		endtry
+		return val
+	endfunction
+
+	" Check if form is a reader conditional, that is, it is prefixed by #?
+	" or @#?
+	function! s:is_reader_conditional_special_case(position)
+		if getline(a:position[0])[a:position[1] - 3 : a:position[1] - 2] == "#?"
+			return 1
+		endif
+
+		return 0
+	endfunction
+
+	" Returns 1 for opening brackets, -1 for _anything else_.
+	function! s:bracket_type(char)
+		return stridx('([{', a:char) > -1 ? 1 : -1
+	endfunction
+
+	" Returns: [opening-bracket-lnum, indent]
+	function! s:clojure_indent_pos()
+		" Get rid of special case.
+		if line(".") == 1
+			return [0, 0]
+		endif
+
+		" We have to apply some heuristics here to figure out, whether to use
+		" normal lisp indenting or not.
+		let i = s:check_for_string()
+		if i > -1
+			return [0, i + !!g:clojure_align_multiline_strings]
+		endif
+
+		call cursor(0, 1)
+
+		" Find the next enclosing [ or {. We can limit the second search
+		" to the line, where the [ was found. If no [ was there this is
+		" zero and we search for an enclosing {.
+		let paren = s:match_pairs('(', ')', 0)
+		let bracket = s:match_pairs('\[', '\]', paren[0])
+		let curly = s:match_pairs('{', '}', bracket[0])
+
+		" In case the curly brace is on a line later then the [ or - in
+		" case they are on the same line - in a higher column, we take the
+		" curly indent.
+		if curly[0] > bracket[0] || curly[1] > bracket[1]
+			if curly[0] > paren[0] || curly[1] > paren[1]
+				return curly
+			endif
+		endif
+
+		" If the curly was not chosen, we take the bracket indent - if
+		" there was one.
+		if bracket[0] > paren[0] || bracket[1] > paren[1]
+			return bracket
+		endif
+
+		" There are neither { nor [ nor (, ie. we are at the toplevel.
+		if paren == [0, 0]
+			return paren
+		endif
+
+		" Now we have to reimplement lispindent. This is surprisingly easy, as
+		" soon as one has access to syntax items.
+		"
+		" - Check whether we are in a special position after a word in
+		"   g:clojure_special_indent_words. These are special cases.
+		" - Get the next keyword after the (.
+		" - If its first character is also a (, we have another sexp and align
+		"   one column to the right of the unmatched (.
+		" - In case it is in lispwords, we indent the next line to the column of
+		"   the ( + sw.
+		" - If not, we check whether it is last word in the line. In that case
+		"   we again use ( + sw for indent.
+		" - In any other case we use the column of the end of the word + 2.
+		call cursor(paren)
+
+		if s:is_method_special_case(paren)
+			return [paren[0], paren[1] + shiftwidth() - 1]
+		endif
+
+		if s:is_reader_conditional_special_case(paren)
+			return paren
+		endif
+
+		" In case we are at the last character, we use the paren position.
+		if col("$") - 1 == paren[1]
+			return paren
+		endif
+
+		" In case after the paren is a whitespace, we search for the next word.
+		call cursor(0, col('.') + 1)
+		if s:current_char() == ' '
+			call search('\v\S', 'W')
+		endif
+
+		" If we moved to another line, there is no word after the (. We
+		" use the ( position for indent.
+		if line(".") > paren[0]
+			return paren
+		endif
+
+		" We still have to check, whether the keyword starts with a (, [ or {.
+		" In that case we use the ( position for indent.
+		let w = s:current_word()
+		if s:bracket_type(w[0]) == 1
+			return paren
+		endif
+
+		" Test words without namespace qualifiers and leading reader macro
+		" metacharacters.
+		"
+		" e.g. clojure.core/defn and #'defn should both indent like defn.
+		let ww = s:strip_namespace_and_macro_chars(w)
+
+		if &lispwords =~# '\V\<' . ww . '\>'
+			return [paren[0], paren[1] + shiftwidth() - 1]
+		endif
+
+		if g:clojure_fuzzy_indent
+			\ && !s:match_one(g:clojure_fuzzy_indent_blacklist, ww)
+			\ && s:match_one(g:clojure_fuzzy_indent_patterns, ww)
+			return [paren[0], paren[1] + shiftwidth() - 1]
+		endif
+
+		call search('\v\_s', 'cW')
+		call search('\v\S', 'W')
+		if paren[0] < line(".")
+			return [paren[0], paren[1] + (g:clojure_align_subforms ? 0 : shiftwidth() - 1)]
+		endif
+
+		call search('\v\S', 'bW')
+		return [line('.'), col('.') + 1]
+	endfunction
+
+	function! GetClojureIndent()
+		let lnum = line('.')
+		let orig_lnum = lnum
+		let orig_col = col('.')
+		let [opening_lnum, indent] = s:clojure_indent_pos()
+
+		" Account for multibyte characters
+		if opening_lnum > 0
+			let indent -= indent - virtcol([opening_lnum, indent])
+		endif
+
+		" Return if there are no previous lines to inherit from
+		if opening_lnum < 1 || opening_lnum >= lnum - 1
+			call cursor(orig_lnum, orig_col)
+			return indent
+		endif
+
+		let bracket_count = 0
+
+		" Take the indent of the first previous non-white line that is
+		" at the same sexp level. cf. src/misc1.c:get_lisp_indent()
+		while 1
+			let lnum = prevnonblank(lnum - 1)
+			let col = 1
+
+			if lnum <= opening_lnum
+				break
+			endif
+
+			call cursor(lnum, col)
+
+			" Handle bracket counting edge case
+			if s:is_paren()
+				let bracket_count += s:bracket_type(s:current_char())
+			endif
+
+			while 1
+				if search('\v[(\[{}\])]', '', lnum) < 1
+					break
+				elseif !s:ignored_region()
+					let bracket_count += s:bracket_type(s:current_char())
+				endif
+			endwhile
+
+			if bracket_count == 0
+				" Check if this is part of a multiline string
+				call cursor(lnum, 1)
+				if s:syn_id_name() !~? '\vstring|regex'
+					call cursor(orig_lnum, orig_col)
+					return indent(lnum)
+				endif
+			endif
+		endwhile
+
+		call cursor(orig_lnum, orig_col)
+		return indent
+	endfunction
+
+	setlocal indentexpr=GetClojureIndent()
+
+else
+
+	" In case we have searchpairpos not available we fall back to
+	" normal lisp indenting.
+	setlocal indentexpr=
+	setlocal lisp
+	let b:undo_indent .= '| setlocal lisp<'
+
+endif
+
+let &cpo = s:save_cpo
+unlet! s:save_cpo
+
+" vim:sts=8:sw=8:ts=8:noet

Git/usr/share/vim/vim81/indent/cmake.vim

@@ -0,0 +1,88 @@
+" Vim indent file
+" Language:     CMake (ft=cmake)
+" Author:       Andy Cedilnik <andy.cedilnik@kitware.com>
+" Maintainer:   Dimitri Merejkowsky <d.merej@gmail.com>
+" Former Maintainer: Karthik Krishnan <karthik.krishnan@kitware.com>
+" Last Change:  2017 Sep 24
+"
+" Licence:      The CMake license applies to this file. See
+"               https://cmake.org/licensing
+"               This implies that distribution with Vim is allowed
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=CMakeGetIndent(v:lnum)
+setlocal indentkeys+==ENDIF(,ENDFOREACH(,ENDMACRO(,ELSE(,ELSEIF(,ENDWHILE(
+
+" Only define the function once.
+if exists("*CMakeGetIndent")
+  finish
+endif
+let s:keepcpo= &cpo
+set cpo&vim
+
+fun! CMakeGetIndent(lnum)
+  let this_line = getline(a:lnum)
+
+  " Find a non-blank line above the current line.
+  let lnum = a:lnum
+  let lnum = prevnonblank(lnum - 1)
+  let previous_line = getline(lnum)
+
+  " Hit the start of the file, use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  let ind = indent(lnum)
+
+  let or = '\|'
+  " Regular expressions used by line indentation function.
+  let cmake_regex_comment = '#.*'
+  let cmake_regex_identifier = '[A-Za-z][A-Za-z0-9_]*'
+  let cmake_regex_quoted = '"\([^"\\]\|\\.\)*"'
+  let cmake_regex_arguments = '\(' . cmake_regex_quoted .
+                    \       or . '\$(' . cmake_regex_identifier . ')' .
+                    \       or . '[^()\\#"]' . or . '\\.' . '\)*'
+
+  let cmake_indent_comment_line = '^\s*' . cmake_regex_comment
+  let cmake_indent_blank_regex = '^\s*$'
+  let cmake_indent_open_regex = '^\s*' . cmake_regex_identifier .
+                    \           '\s*(' . cmake_regex_arguments .
+                    \           '\(' . cmake_regex_comment . '\)\?$'
+
+  let cmake_indent_close_regex = '^' . cmake_regex_arguments .
+                    \            ')\s*' .
+                    \            '\(' . cmake_regex_comment . '\)\?$'
+
+  let cmake_indent_begin_regex = '^\s*\(IF\|MACRO\|FOREACH\|ELSE\|ELSEIF\|WHILE\|FUNCTION\)\s*('
+  let cmake_indent_end_regex = '^\s*\(ENDIF\|ENDFOREACH\|ENDMACRO\|ELSE\|ELSEIF\|ENDWHILE\|ENDFUNCTION\)\s*('
+
+  " Add
+  if previous_line =~? cmake_indent_comment_line " Handle comments
+    let ind = ind
+  else
+    if previous_line =~? cmake_indent_begin_regex
+      let ind = ind + shiftwidth()
+    endif
+    if previous_line =~? cmake_indent_open_regex
+      let ind = ind + shiftwidth()
+    endif
+  endif
+
+  " Subtract
+  if this_line =~? cmake_indent_end_regex
+    let ind = ind - shiftwidth()
+  endif
+  if previous_line =~? cmake_indent_close_regex
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfun
+
+let &cpo = s:keepcpo
+unlet s:keepcpo

Git/usr/share/vim/vim81/indent/cobol.vim

@@ -0,0 +1,216 @@
+" Vim indent file
+" Language:	cobol
+" Author:	Tim Pope <vimNOSPAM@tpope.info>
+" $Id: cobol.vim,v 1.1 2007/05/05 18:08:19 vimboss Exp $
+
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+setlocal expandtab
+setlocal indentexpr=GetCobolIndent(v:lnum)
+setlocal indentkeys&
+setlocal indentkeys+=0<*>,0/,0$,0=01,=~division,=~section,0=~end,0=~then,0=~else,0=~when,*<Return>,.
+
+" Only define the function once.
+if exists("*GetCobolIndent")
+    finish
+endif
+
+let s:skip = 'getline(".") =~ "^.\\{6\\}[*/$-]\\|\"[^\"]*\""'
+
+function! s:prevgood(lnum)
+    " Find a non-blank line above the current line.
+    " Skip over comments.
+    let lnum = a:lnum
+    while lnum > 0
+        let lnum = prevnonblank(lnum - 1)
+        let line = getline(lnum)
+        if line !~? '^\s*[*/$-]' && line !~? '^.\{6\}[*/$CD-]'
+            break
+        endif
+    endwhile
+    return lnum
+endfunction
+
+function! s:stripped(lnum)
+    return substitute(strpart(getline(a:lnum),0,72),'^\s*','','')
+endfunction
+
+function! s:optionalblock(lnum,ind,blocks,clauses)
+    let ind = a:ind
+    let clauses = '\c\<\%(\<NOT\s\+\)\@<!\%(NOT\s\+\)\=\%('.a:clauses.'\)'
+    let begin = '\c-\@<!\<\%('.a:blocks.'\)\>'
+    let beginfull = begin.'\ze.*\%(\n\%(\s*\%([*/$-].*\)\=\n\)*\)\=\s*\%('.clauses.'\)'
+    let end   = '\c\<end-\%('.a:blocks.'\)\>\|\%(\.\%( \|$\)\)\@='
+    let cline = s:stripped(a:lnum)
+    let line  = s:stripped(s:prevgood(a:lnum))
+    if cline =~? clauses "&& line !~? '^search\>'
+        call cursor(a:lnum,1)
+        let lastclause = searchpair(beginfull,clauses,end,'bWr',s:skip)
+        if getline(lastclause) =~? clauses && s:stripped(lastclause) !~? '^'.begin
+            let ind = indent(lastclause)
+        elseif lastclause > 0
+            let ind = indent(lastclause) + shiftwidth()
+            "let ind = ind + shiftwidth()
+        endif
+    elseif line =~? clauses && cline !~? end
+        let ind = ind + shiftwidth()
+    endif
+    return ind
+endfunction
+
+function! GetCobolIndent(lnum) abort
+    let minshft = 6
+    let ashft = minshft + 1
+    let bshft = ashft + 4
+    " (Obsolete) numbered lines
+    if getline(a:lnum) =~? '^\s*\d\{6\}\%($\|[ */$CD-]\)'
+        return 0
+    endif
+    let cline = s:stripped(a:lnum)
+    " Comments, etc. must start in the 7th column
+    if cline =~? '^[*/$-]'
+        return minshft
+    elseif cline =~# '^[CD]' && indent(a:lnum) == minshft
+        return minshft
+    endif
+    " Divisions, sections, and file descriptions start in area A
+    if cline =~? '\<\(DIVISION\|SECTION\)\%($\|\.\)' || cline =~? '^[FS]D\>'
+        return ashft
+    endif
+    " Fields
+    if cline =~? '^0*\(1\|77\)\>'
+        return ashft
+    endif
+    if cline =~? '^\d\+\>'
+        let cnum = matchstr(cline,'^\d\+\>')
+        let default = 0
+        let step = -1
+        while step < 2
+        let lnum = a:lnum
+        while lnum > 0 && lnum < line('$') && lnum > a:lnum - 500 && lnum < a:lnum + 500
+            let lnum = step > 0 ? nextnonblank(lnum + step) : prevnonblank(lnum + step)
+            let line = getline(lnum)
+            let lindent = indent(lnum)
+            if line =~? '^\s*\d\+\>'
+                let num = matchstr(line,'^\s*\zs\d\+\>')
+                if 0+cnum == num
+                    return lindent
+                elseif 0+cnum > num && default < lindent + shiftwidth()
+                    let default = lindent + shiftwidth()
+                endif
+            elseif lindent < bshft && lindent >= ashft
+                break
+            endif
+        endwhile
+        let step = step + 2
+        endwhile
+        return default ? default : bshft
+    endif
+    let lnum = s:prevgood(a:lnum)
+    " Hit the start of the file, use "zero" indent.
+    if lnum == 0
+        return ashft
+    endif
+    " Initial spaces are ignored
+    let line = s:stripped(lnum)
+    let ind = indent(lnum)
+    " Paragraphs.  There may be some false positives.
+    if cline =~? '^\(\a[A-Z0-9-]*[A-Z0-9]\|\d[A-Z0-9-]*\a\)\.' "\s*$'
+        if cline !~? '^EXIT\s*\.' && line =~? '\.\s*$'
+            return ashft
+        endif
+    endif
+    " Paragraphs in the identification division.
+    "if cline =~? '^\(PROGRAM-ID\|AUTHOR\|INSTALLATION\|' .
+                "\ 'DATE-WRITTEN\|DATE-COMPILED\|SECURITY\)\>'
+        "return ashft
+    "endif
+    if line =~? '\.$'
+        " XXX
+        return bshft
+    endif
+    if line =~? '^PERFORM\>'
+        let perfline = substitute(line, '\c^PERFORM\s*', "", "")
+        if perfline =~? '^\%(\k\+\s\+TIMES\)\=\s*$'
+            let ind = ind + shiftwidth()
+        elseif perfline =~? '^\%(WITH\s\+TEST\|VARYING\|UNTIL\)\>.*[^.]$'
+            let ind = ind + shiftwidth()
+        endif
+    endif
+    if line =~? '^\%(IF\|THEN\|ELSE\|READ\|EVALUATE\|SEARCH\|SELECT\)\>'
+        let ind = ind + shiftwidth()
+    endif
+    let ind = s:optionalblock(a:lnum,ind,'ADD\|COMPUTE\|DIVIDE\|MULTIPLY\|SUBTRACT','ON\s\+SIZE\s\+ERROR')
+    let ind = s:optionalblock(a:lnum,ind,'STRING\|UNSTRING\|ACCEPT\|DISPLAY\|CALL','ON\s\+OVERFLOW\|ON\s\+EXCEPTION')
+    if cline !~? '^AT\s\+END\>' || line !~? '^SEARCH\>'
+        let ind = s:optionalblock(a:lnum,ind,'DELETE\|REWRITE\|START\|WRITE\|READ','INVALID\s\+KEY\|AT\s\+END\|NO\s\+DATA\|AT\s\+END-OF-PAGE')
+    endif
+    if cline =~? '^WHEN\>'
+        call cursor(a:lnum,1)
+        " We also search for READ so that contained AT ENDs are skipped
+        let lastclause = searchpair('\c-\@<!\<\%(SEARCH\|EVALUATE\|READ\)\>','\c\<\%(WHEN\|AT\s\+END\)\>','\c\<END-\%(SEARCH\|EVALUATE\|READ\)\>','bW',s:skip)
+        let g:foo = s:stripped(lastclause)
+        if s:stripped(lastclause) =~? '\c\<\%(WHEN\|AT\s\+END\)\>'
+            "&& s:stripped(lastclause) !~? '^\%(SEARCH\|EVALUATE\|READ\)\>'
+            let ind = indent(lastclause)
+        elseif lastclause > 0
+            let ind = indent(lastclause) + shiftwidth()
+        endif
+    elseif line =~? '^WHEN\>'
+        let ind = ind + shiftwidth()
+    endif
+    "I'm not sure why I had this
+    "if line =~? '^ELSE\>-\@!' && line !~? '\.$'
+        "let ind = indent(s:prevgood(lnum))
+    "endif
+    if cline =~? '^\(END\)\>-\@!'
+        " On lines with just END, 'guess' a simple shift left
+        let ind = ind - shiftwidth()
+    elseif cline =~? '^\(END-IF\|THEN\|ELSE\)\>-\@!'
+        call cursor(a:lnum,indent(a:lnum))
+        let match = searchpair('\c-\@<!\<IF\>','\c-\@<!\%(THEN\|ELSE\)\>','\c-\@<!\<END-IF\>\zs','bnW',s:skip)
+        if match > 0
+            let ind = indent(match)
+        endif
+    elseif cline =~? '^END-[A-Z]'
+        let beginword = matchstr(cline,'\c\<END-\zs[A-Z0-9-]\+')
+        let endword = 'END-'.beginword
+        let first = 0
+        let suffix = '.*\%(\n\%(\%(\s*\|.\{6\}\)[*/].*\n\)*\)\=\s*'
+        if beginword =~? '^\%(ADD\|COMPUTE\|DIVIDE\|MULTIPLY\|SUBTRACT\)$'
+            let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=ON\s\+SIZE\s\+ERROR'
+            let g:beginword = beginword
+            let first = 1
+        elseif beginword =~? '^\%(STRING\|UNSTRING\)$'
+            let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=ON\s\+OVERFLOW'
+            let first = 1
+        elseif beginword =~? '^\%(ACCEPT\|DISPLAY\)$'
+            let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=ON\s\+EXCEPTION'
+            let first = 1
+        elseif beginword ==? 'CALL'
+            let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=ON\s\+\%(EXCEPTION\|OVERFLOW\)'
+            let first = 1
+        elseif beginword =~? '^\%(DELETE\|REWRITE\|START\|READ\|WRITE\)$'
+            let first = 1
+            let beginword = beginword . suffix . '\<\%(NOT\s\+\)\=\(INVALID\s\+KEY'
+            if beginword =~? '^READ'
+                let first = 0
+                let beginword = beginword . '\|AT\s\+END\|NO\s\+DATA'
+            elseif beginword =~? '^WRITE'
+                let beginword = beginword . '\|AT\s\+END-OF-PAGE'
+            endif
+            let beginword = beginword . '\)'
+        endif
+        call cursor(a:lnum,indent(a:lnum))
+        let match = searchpair('\c-\@<!\<'.beginword.'\>','','\c\<'.endword.'\>\zs','bnW'.(first? 'r' : ''),s:skip)
+        if match > 0
+            let ind = indent(match)
+        elseif cline =~? '^\(END-\(READ\|EVALUATE\|SEARCH\|PERFORM\)\)\>'
+            let ind = ind - shiftwidth()
+        endif
+    endif
+    return ind < bshft ? bshft : ind
+endfunction

Git/usr/share/vim/vim81/indent/config.vim

@@ -0,0 +1,82 @@
+" Vim indent file
+" Language:             Autoconf configure.{ac,in} file
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2006-12-20
+" TODO:                 how about nested [()]'s in one line
+"                   what's wrong with '\\\@!'?
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+
+runtime! indent/sh.vim          " will set b:did_indent
+
+setlocal indentexpr=GetConfigIndent()
+setlocal indentkeys=!^F,o,O,=then,=do,=else,=elif,=esac,=fi,=fin,=fil,=done
+setlocal nosmartindent
+
+" Only define the function once.
+if exists("*GetConfigIndent")
+  finish
+endif
+
+" get the offset (indent) of the end of the match of 'regexp' in 'line'
+function s:GetOffsetOf(line, regexp)
+  let end = matchend(a:line, a:regexp)
+  let width = 0
+  let i = 0
+  while i < end
+    if a:line[i] != "\t"
+      let width = width + 1
+    else
+      let width = width + &ts - (width % &ts)
+    endif
+    let i = i + 1
+  endwhile
+  return width
+endfunction
+
+function GetConfigIndent()
+  " Find a non-blank line above the current line.
+  let lnum = prevnonblank(v:lnum - 1)
+
+  " Hit the start of the file, use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  " where to put this
+  let ind = GetShIndent()
+  let line = getline(lnum)
+
+  " if previous line has unmatched, unescaped opening parentheses,
+  " indent to its position. TODO: not failsafe if multiple ('s
+  if line =~ '\\\@<!([^)]*$'
+    let ind = s:GetOffsetOf(line, '\\\@!(')
+  endif
+
+  " if previous line has unmatched opening bracket,
+  " indent to its position. TODO: same as above
+  if line =~ '\[[^]]*$'
+    let ind = s:GetOffsetOf(line, '\[')
+  endif
+
+  " if previous line had an unmatched closing parantheses,
+  " indent to the matching opening parantheses
+  if line =~ '[^(]\+\\\@<!)$'
+    call search(')', 'bW')
+    let lnum = searchpair('\\\@<!(', '', ')', 'bWn')
+    let ind = indent(lnum)
+  endif
+
+  " if previous line had an unmatched closing bracket,
+  " indent to the matching opening bracket
+  if line =~ '[^[]\+]$'
+    call search(']', 'bW')
+    let lnum = searchpair('\[', '', ']', 'bWn')
+    let ind = indent(lnum)
+  endif
+
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/context.vim

@@ -0,0 +1,36 @@
+" ConTeXt indent file
+" Language: ConTeXt typesetting engine
+" Maintainer: Nicola Vitacolonna <nvitacolonna@gmail.com>
+" Last Change:  2016 Oct 15
+
+if exists("b:did_indent")
+  finish
+endif
+
+if !get(b:, 'context_metapost', get(g:, 'context_metapost', 1))
+  finish
+endif
+
+" Load MetaPost indentation script
+runtime! indent/mp.vim
+
+let s:keepcpo= &cpo
+set cpo&vim
+
+setlocal indentexpr=GetConTeXtIndent()
+
+let b:undo_indent = "setl indentexpr<"
+
+function! GetConTeXtIndent()
+  " Use MetaPost rules inside MetaPost graphic environments
+  if len(synstack(v:lnum, 1)) > 0 &&
+        \ synIDattr(synstack(v:lnum, 1)[0], "name") ==# 'contextMPGraphic'
+    return GetMetaPostIndent()
+  endif
+  return -1
+endfunc
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+" vim:sw=2

Git/usr/share/vim/vim81/indent/cpp.vim

@@ -0,0 +1,15 @@
+" Vim indent file
+" Language:	C++
+" Maintainer:	Bram Moolenaar <Bram@vim.org>
+" Last Change:	2008 Nov 29
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+   finish
+endif
+let b:did_indent = 1
+
+" C++ indenting is built-in, thus this is very simple
+setlocal cindent
+
+let b:undo_indent = "setl cin<"

Git/usr/share/vim/vim81/indent/cs.vim

@@ -0,0 +1,73 @@
+" Vim indent file
+" Language:            C#
+" Maintainer:          Nick Jensen <nickspoon@gmail.com>
+" Former Maintainers:  Aquila Deus
+"                      Johannes Zellner <johannes@zellner.org>
+" Last Change:         2018-11-21
+" Filenames:           *.cs
+" License:             Vim (see :h license)
+" Repository:          https://github.com/nickspoons/vim-cs
+"
+
+" Only load this indent file when no other was loaded.
+if exists('b:did_indent')
+  finish
+endif
+let b:did_indent = 1
+
+let s:save_cpo = &cpoptions
+set cpoptions&vim
+
+
+setlocal indentexpr=GetCSIndent(v:lnum)
+
+function! s:IsCompilerDirective(line)
+  return a:line =~? '^\s*#'
+endf
+
+function! s:IsAttributeLine(line)
+  return a:line =~? '^\s*\[[A-Za-z]' && a:line =~? '\]$'
+endf
+
+function! s:FindPreviousNonCompilerDirectiveLine(start_lnum)
+  for delta in range(0, a:start_lnum)
+    let lnum = a:start_lnum - delta
+    let line = getline(lnum)
+    let is_directive = s:IsCompilerDirective(line)
+    if !is_directive
+      return lnum
+    endif
+  endfor
+  return 0
+endf
+
+function! GetCSIndent(lnum) abort
+  " Hit the start of the file, use zero indent.
+  if a:lnum == 0
+    return 0
+  endif
+
+  let this_line = getline(a:lnum)
+
+  " Compiler directives use zero indent if so configured.
+  let is_first_col_macro = s:IsCompilerDirective(this_line) && stridx(&l:cinkeys, '0#') >= 0
+  if is_first_col_macro
+    return cindent(a:lnum)
+  endif
+
+  let lnum = s:FindPreviousNonCompilerDirectiveLine(a:lnum - 1)
+  let previous_code_line = getline(lnum)
+  if s:IsAttributeLine(previous_code_line)
+    let ind = indent(lnum)
+    return ind
+  else
+    return cindent(a:lnum)
+  endif
+endfunction
+
+let b:undo_indent = 'setlocal indentexpr<'
+
+let &cpoptions = s:save_cpo
+unlet s:save_cpo
+
+" vim:et:sw=2:sts=2

Git/usr/share/vim/vim81/indent/css.vim

@@ -0,0 +1,84 @@
+" Vim indent file
+" Language:	    CSS
+" Maintainer:	    Nikolai Weibull <now@bitwi.se>
+" Latest Revision:  2012-05-30
+"		    Use of shiftwidth() added by Oleg Zubchenko.	
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetCSSIndent()
+setlocal indentkeys=0{,0},!^F,o,O
+setlocal nosmartindent
+
+let b:undo_indent = "setl smartindent< indentkeys< indentexpr<"
+
+if exists("*GetCSSIndent")
+  finish
+endif
+let s:keepcpo= &cpo
+set cpo&vim
+
+function s:prevnonblanknoncomment(lnum)
+  let lnum = a:lnum
+  while lnum > 1
+    let lnum = prevnonblank(lnum)
+    let line = getline(lnum)
+    if line =~ '\*/'
+      while lnum > 1 && line !~ '/\*'
+        let lnum -= 1
+      endwhile
+      if line =~ '^\s*/\*'
+        let lnum -= 1
+      else
+        break
+      endif
+    else
+      break
+    endif
+  endwhile
+  return lnum
+endfunction
+
+function s:count_braces(lnum, count_open)
+  let n_open = 0
+  let n_close = 0
+  let line = getline(a:lnum)
+  let pattern = '[{}]'
+  let i = match(line, pattern)
+  while i != -1
+    if synIDattr(synID(a:lnum, i + 1, 0), 'name') !~ 'css\%(Comment\|StringQ\{1,2}\)'
+      if line[i] == '{'
+        let n_open += 1
+      elseif line[i] == '}'
+        if n_open > 0
+          let n_open -= 1
+        else
+          let n_close += 1
+        endif
+      endif
+    endif
+    let i = match(line, pattern, i + 1)
+  endwhile
+  return a:count_open ? n_open : n_close
+endfunction
+
+function GetCSSIndent()
+  let line = getline(v:lnum)
+  if line =~ '^\s*\*'
+    return cindent(v:lnum)
+  endif
+
+  let pnum = s:prevnonblanknoncomment(v:lnum - 1)
+  if pnum == 0
+    return 0
+  endif
+
+  return indent(pnum) + s:count_braces(pnum, 1) * shiftwidth()
+        \ - s:count_braces(v:lnum, 0) * shiftwidth()
+endfunction
+
+let &cpo = s:keepcpo
+unlet s:keepcpo

Git/usr/share/vim/vim81/indent/cucumber.vim

@@ -0,0 +1,75 @@
+" Vim indent file
+" Language:	Cucumber
+" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
+" Last Change:	2017 Jun 13
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentexpr=GetCucumberIndent()
+setlocal indentkeys=o,O,*<Return>,<:>,0<Bar>,0#,=,!^F
+
+let b:undo_indent = 'setl ai< inde< indk<'
+
+" Only define the function once.
+if exists("*GetCucumberIndent")
+  finish
+endif
+
+function! s:syn(lnum)
+  return synIDattr(synID(a:lnum,1+indent(a:lnum),1),'name')
+endfunction
+
+function! GetCucumberIndent()
+  let line  = getline(prevnonblank(v:lnum-1))
+  let cline = getline(v:lnum)
+  let nline = getline(nextnonblank(v:lnum+1))
+  let sw = exists('*shiftwidth') ? shiftwidth() : shiftwidth()
+  let syn = s:syn(prevnonblank(v:lnum-1))
+  let csyn = s:syn(v:lnum)
+  let nsyn = s:syn(nextnonblank(v:lnum+1))
+  if csyn ==# 'cucumberFeature' || cline =~# '^\s*Feature:'
+    " feature heading
+    return 0
+  elseif csyn ==# 'cucumberExamples' || cline =~# '^\s*\%(Examples\|Scenarios\):'
+    " examples heading
+    return 2 * sw
+  elseif csyn =~# '^cucumber\%(Background\|Scenario\|ScenarioOutline\)$' || cline =~# '^\s*\%(Background\|Scenario\|Scenario Outline\):'
+    " background, scenario or outline heading
+    return sw
+  elseif syn ==# 'cucumberFeature' || line =~# '^\s*Feature:'
+    " line after feature heading
+    return sw
+  elseif syn ==# 'cucumberExamples' || line =~# '^\s*\%(Examples\|Scenarios\):'
+    " line after examples heading
+    return 3 * sw
+  elseif syn =~# '^cucumber\%(Background\|Scenario\|ScenarioOutline\)$' || line =~# '^\s*\%(Background\|Scenario\|Scenario Outline\):'
+    " line after background, scenario or outline heading
+    return 2 * sw
+  elseif cline =~# '^\s*[@#]' && (nsyn == 'cucumberFeature' || nline =~# '^\s*Feature:' || indent(prevnonblank(v:lnum-1)) <= 0)
+    " tag or comment before a feature heading
+    return 0
+  elseif cline =~# '^\s*@'
+    " other tags
+    return sw
+  elseif cline =~# '^\s*[#|]' && line =~# '^\s*|'
+    " mid-table
+    " preserve indent
+    return indent(prevnonblank(v:lnum-1))
+  elseif cline =~# '^\s*|' && line =~# '^\s*[^|]'
+    " first line of a table, relative indent
+    return indent(prevnonblank(v:lnum-1)) + sw
+  elseif cline =~# '^\s*[^|]' && line =~# '^\s*|'
+    " line after a table, relative unindent
+    return indent(prevnonblank(v:lnum-1)) - sw
+  elseif cline =~# '^\s*#' && getline(v:lnum-1) =~ '^\s*$' && (nsyn =~# '^cucumber\%(Background\|Scenario\|ScenarioOutline\)$' || nline =~# '^\s*\%(Background\|Scenario\|Scenario Outline\):')
+    " comments on scenarios
+    return sw
+  endif
+  return indent(prevnonblank(v:lnum-1))
+endfunction
+
+" vim:set sts=2 sw=2:

Git/usr/share/vim/vim81/indent/cuda.vim

@@ -0,0 +1,15 @@
+" Vim indent file
+" Language:	CUDA
+" Maintainer:	Bram Moolenaar <Bram@vim.org>
+" Last Change:	2008 Nov 29
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+   finish
+endif
+let b:did_indent = 1
+
+" It's just like C indenting
+setlocal cindent
+
+let b:undo_indent = "setl cin<"

Git/usr/share/vim/vim81/indent/d.vim

@@ -0,0 +1,22 @@
+" Vim indent file for the D programming language (version 0.137).
+"
+" Language:	D
+" Maintainer:	Jason Mills<jmills@cs.mun.ca>
+" Last Change:	2005 Nov 22
+" Version:	0.1
+"
+" Please email me with bugs, comments, and suggestion. Put vim in the subject
+" to ensure the email will not be marked has spam.
+"
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+
+let b:did_indent = 1
+
+" D indenting is a lot like the built-in C indenting.
+setlocal cindent
+
+" vim: ts=8 noet

Git/usr/share/vim/vim81/indent/dictconf.vim

@@ -0,0 +1,13 @@
+" Vim indent file
+" Language:             dict(1) configuration file
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2006-12-20
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentkeys=0{,0},!^F,o,O cinwords= autoindent smartindent
+setlocal nosmartindent
+inoremap <buffer> # X#

Git/usr/share/vim/vim81/indent/dictdconf.vim

@@ -0,0 +1,13 @@
+" Vim indent file
+" Language:             dictd(8) configuration file
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2006-12-20
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentkeys=0{,0},!^F,o,O cinwords= autoindent smartindent
+setlocal nosmartindent
+inoremap <buffer> # X#

Git/usr/share/vim/vim81/indent/docbk.vim

@@ -0,0 +1,15 @@
+" Vim indent file
+" Language:    	    DocBook Documentation Format
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2006-04-19
+
+if exists("b:did_indent")
+  finish
+endif
+
+" Same as XML indenting for now.
+runtime! indent/xml.vim
+
+if exists('*XmlIndentGet')
+  setlocal indentexpr=XmlIndentGet(v:lnum,0)
+endif

Git/usr/share/vim/vim81/indent/dosbatch.vim

@@ -0,0 +1,59 @@
+" Vim indent file
+" Language:	MSDOS batch file (with NT command extensions)
+" Maintainer:	Ken Takata
+" URL:		https://github.com/k-takata/vim-dosbatch-indent
+" Last Change:	2017 May 10
+" Filenames:	*.bat
+" License:	VIM License
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal nosmartindent
+setlocal noautoindent
+setlocal indentexpr=GetDosBatchIndent(v:lnum)
+setlocal indentkeys=!^F,o,O
+setlocal indentkeys+=0=)
+
+if exists("*GetDosBatchIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+function! GetDosBatchIndent(lnum)
+  let l:prevlnum = prevnonblank(a:lnum-1)
+  if l:prevlnum == 0
+    " top of file
+    return 0
+  endif
+
+  " grab the previous and current line, stripping comments.
+  let l:prevl = substitute(getline(l:prevlnum), '\c^\s*\%(@\s*\)\?rem\>.*$', '', '')
+  let l:thisl = getline(a:lnum)
+  let l:previ = indent(l:prevlnum)
+
+  let l:ind = l:previ
+
+  if l:prevl =~? '^\s*@\=if\>.*(\s*$' ||
+        \ l:prevl =~? '\<do\>\s*(\s*$' ||
+        \ l:prevl =~? '\<else\>\s*\%(if\>.*\)\?(\s*$' ||
+        \ l:prevl =~? '^.*\(&&\|||\)\s*(\s*$'
+    " previous line opened a block
+    let l:ind += shiftwidth()
+  endif
+  if l:thisl =~ '^\s*)'
+    " this line closed a block
+    let l:ind -= shiftwidth()
+  endif
+
+  return l:ind
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim: ts=8 sw=2 sts=2

Git/usr/share/vim/vim81/indent/dtd.vim

@@ -0,0 +1,325 @@
+" Vim indent file
+" Language:    	    DTD (Document Type Definition for XML)
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2011-07-08
+
+setlocal indentexpr=GetDTDIndent()
+setlocal indentkeys=!^F,o,O,>
+setlocal nosmartindent
+
+if exists("*GetDTDIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+" TODO: Needs to be adjusted to stop at [, <, and ].
+let s:token_pattern = '^[^[:space:]]\+'
+
+function s:lex1(input, start, ...)
+  let pattern = a:0 > 0 ? a:1 : s:token_pattern
+  let start = matchend(a:input, '^\_s*', a:start)
+  if start == -1
+    return ["", a:start]
+  endif
+  let end = matchend(a:input, pattern, start)
+  if end == -1
+    return ["", a:start]
+  endif
+  let token = strpart(a:input, start, end - start)
+  return [token, end]
+endfunction
+
+function s:lex(input, start, ...)
+  let pattern = a:0 > 0 ? a:1 : s:token_pattern
+  let info = s:lex1(a:input, a:start, pattern)
+  while info[0] == '--'
+    let info = s:lex1(a:input, info[1], pattern)
+    while info[0] != "" && info[0] != '--'
+      let info = s:lex1(a:input, info[1], pattern)
+    endwhile
+    if info[0] == ""
+      return info
+    endif
+    let info = s:lex1(a:input, info[1], pattern)
+  endwhile
+  return info
+endfunction
+
+function s:indent_to_innermost_parentheses(line, end)
+  let token = '('
+  let end = a:end
+  let parentheses = [end - 1]
+  while token != ""
+    let [token, end] = s:lex(a:line, end, '^\%([(),|]\|[A-Za-z0-9_-]\+\|#P\=CDATA\|%[A-Za-z0-9_-]\+;\)[?*+]\=')
+    if token[0] == '('
+      call add(parentheses, end - 1)
+    elseif token[0] == ')'
+      if len(parentheses) == 1
+        return [-1, end]
+      endif
+      call remove(parentheses, -1)
+    endif
+  endwhile
+  return [parentheses[-1] - strridx(a:line, "\n", parentheses[-1]), end]
+endfunction
+
+" TODO: Line and end could be script global (think OO members).
+function GetDTDIndent()
+  if v:lnum == 1
+    return 0
+  endif
+  
+  " Begin by searching back for a <! that isn’t inside a comment.
+  " From here, depending on what follows immediately after, parse to
+  " where we’re at to determine what to do.
+  if search('<!', 'bceW') == 0
+    return indent(v:lnum - 1)
+  endif
+  let lnum = line('.')
+  let col = col('.')
+  let indent = indent('.')
+  let line = lnum == v:lnum ? getline(lnum) : join(getline(lnum, v:lnum - 1), "\n")
+
+  let [declaration, end] = s:lex1(line, col)
+  if declaration == ""
+    return indent + shiftwidth()
+  elseif declaration == '--'
+    " We’re looking at a comment.  Now, simply determine if the comment is
+    " terminated or not.  If it isn’t, let Vim take care of that using
+    " 'comments' and 'autoindent'. Otherwise, indent to the first lines level.
+    while declaration != ""
+      let [declaration, end] = s:lex(line, end)
+      if declaration == "-->"
+        return indent
+      endif
+    endwhile
+    return -1
+  elseif declaration == 'ELEMENT'
+    " Check for element name.  If none exists, indent one level.
+    let [name, end] = s:lex(line, end)
+    if name == ""
+      return indent + shiftwidth()
+    endif
+
+    " Check for token following element name.  This can be a specification of
+    " whether the start or end tag may be omitted.  If nothing is found, indent
+    " one level.
+    let [token, end] = s:lex(line, end, '^\%([-O(]\|ANY\|EMPTY\)')
+    let n = 0
+    while token =~ '[-O]' && n < 2
+      let [token, end] = s:lex(line, end, '^\%([-O(]\|ANY\|EMPTY\)')
+      let n += 1
+    endwhile
+    if token == ""
+      return indent + shiftwidth()
+    endif
+
+    " Next comes the content model.  If the token we’ve found isn’t a
+    " parenthesis it must be either ANY, EMPTY or some random junk.  Either
+    " way, we’re done indenting this element, so set it to that of the first
+    " line so that the terminating “>” winds up having the same indention.
+    if token != '('
+      return indent
+    endif
+
+    " Now go through the content model.  We need to keep track of the nesting
+    " of parentheses.  As soon as we hit 0 we’re done.  If that happens we must
+    " have a complete content model.  Thus set indention to be the same as that
+    " of the first line so that the terminating “>” winds up having the same
+    " indention.  Otherwise, we’ll indent to the innermost parentheses not yet
+    " matched.
+    let [indent_of_innermost, end] = s:indent_to_innermost_parentheses(line, end)
+    if indent_of_innermost != -1
+      return indent_of_innermost
+    endif
+
+    " Finally, look for any additions and/or exceptions to the content model.
+    " This is defined by a “+” or “-” followed by another content model
+    " declaration.
+    " TODO: Can the “-” be separated by whitespace from the “(”?
+    let seen = { '+(': 0, '-(': 0 }
+    while 1
+      let [additions_exceptions, end] = s:lex(line, end, '^[+-](')
+      if additions_exceptions != '+(' && additions_exceptions != '-('
+        let [token, end] = s:lex(line, end)
+        if token == '>'
+          return indent
+        endif
+        " TODO: Should use s:lex here on getline(v:lnum) and check for >.
+        return getline(v:lnum) =~ '^\s*>' || count(values(seen), 0) == 0 ? indent : (indent + shiftwidth())
+      endif
+
+      " If we’ve seen an addition or exception already and this is of the same
+      " kind, the user is writing a broken DTD.  Time to bail.
+      if seen[additions_exceptions]
+        return indent
+      endif
+      let seen[additions_exceptions] = 1
+
+      let [indent_of_innermost, end] = s:indent_to_innermost_parentheses(line, end)
+      if indent_of_innermost != -1
+        return indent_of_innermost
+      endif
+    endwhile
+  elseif declaration == 'ATTLIST'
+    " Check for element name.  If none exists, indent one level.
+    let [name, end] = s:lex(line, end)
+    if name == ""
+      return indent + shiftwidth()
+    endif
+
+    " Check for any number of attributes.
+    while 1
+      " Check for attribute name.  If none exists, indent one level, unless the
+      " current line is a lone “>”, in which case we indent to the same level
+      " as the first line.  Otherwise, if the attribute name is “>”, we have
+      " actually hit the end of the attribute list, in which case we indent to
+      " the same level as the first line.
+      let [name, end] = s:lex(line, end)
+      if name == ""
+        " TODO: Should use s:lex here on getline(v:lnum) and check for >.
+        return getline(v:lnum) =~ '^\s*>' ? indent : (indent + shiftwidth())
+      elseif name == ">"
+        return indent
+      endif
+
+      " Check for attribute value declaration.  If none exists, indent two
+      " levels.  Otherwise, if it’s an enumerated value, check for nested
+      " parentheses and indent to the innermost one if we don’t reach the end
+      " of the listc.  Otherwise, just continue with looking for the default
+      " attribute value.
+      " TODO: Do validation of keywords
+      " (CDATA|NMTOKEN|NMTOKENS|ID|IDREF|IDREFS|ENTITY|ENTITIES)?
+      let [value, end] = s:lex(line, end, '^\%((\|[^[:space:]]\+\)')
+      if value == ""
+        return indent + shiftwidth() * 2
+      elseif value == 'NOTATION'
+        " If this is a enumerated value based on notations, read another token
+        " for the actual value.  If it doesn’t exist, indent three levels.
+        " TODO: If validating according to above, value must be equal to '('.
+        let [value, end] = s:lex(line, end, '^\%((\|[^[:space:]]\+\)')
+        if value == ""
+          return indent + shiftwidth() * 3
+        endif
+      endif
+
+      if value == '('
+        let [indent_of_innermost, end] = s:indent_to_innermost_parentheses(line, end)
+        if indent_of_innermost != -1
+          return indent_of_innermost
+        endif
+      endif
+
+      " Finally look for the attribute’s default value.  If non exists, indent
+      " two levels.
+      let [default, end] = s:lex(line, end, '^\%("\_[^"]*"\|#\(REQUIRED\|IMPLIED\|FIXED\)\)')
+      if default == ""
+        return indent + shiftwidth() * 2
+      elseif default == '#FIXED'
+        " We need to look for the fixed value.  If non exists, indent three
+        " levels.
+        let [default, end] = s:lex(line, end, '^"\_[^"]*"')
+        if default == ""
+          return indent + shiftwidth() * 3
+        endif
+      endif
+    endwhile
+  elseif declaration == 'ENTITY'
+    " Check for entity name.  If none exists, indent one level.  Otherwise, if
+    " the name actually turns out to be a percent sign, “%”, this is a
+    " parameter entity.  Read another token to determine the entity name and,
+    " again, if none exists, indent one level.
+    let [name, end] = s:lex(line, end)
+    if name == ""
+      return indent + shiftwidth()
+    elseif name == '%'
+      let [name, end] = s:lex(line, end)
+      if name == ""
+        return indent + shiftwidth()
+      endif
+    endif
+
+    " Now check for the entity value.  If none exists, indent one level.  If it
+    " does exist, indent to same level as first line, as we’re now done with
+    " this entity.
+    "
+    " The entity value can be a string in single or double quotes (no escapes
+    " to worry about, as entities are used instead).  However, it can also be
+    " that this is an external unparsed entity.  In that case we have to look
+    " further for (possibly) a public ID and an URI followed by the NDATA
+    " keyword and the actual notation name.  For the public ID and URI, indent
+    " two levels, if they don’t exist.  If the NDATA keyword doesn’t exist,
+    " indent one level.  Otherwise, if the actual notation name doesn’t exist,
+    " indent two level.  If it does, indent to same level as first line, as
+    " we’re now done with this entity.
+    let [value, end] = s:lex(line, end)
+    if value == ""
+      return indent + shiftwidth()
+    elseif value == 'SYSTEM' || value == 'PUBLIC'
+      let [quoted_string, end] = s:lex(line, end, '\%("[^"]\+"\|''[^'']\+''\)')
+      if quoted_string == ""
+        return indent + shiftwidth() * 2
+      endif
+
+      if value == 'PUBLIC'
+        let [quoted_string, end] = s:lex(line, end, '\%("[^"]\+"\|''[^'']\+''\)')
+        if quoted_string == ""
+          return indent + shiftwidth() * 2
+        endif
+      endif
+
+      let [ndata, end] = s:lex(line, end)
+      if ndata == ""
+        return indent + shiftwidth()
+      endif
+
+      let [name, end] = s:lex(line, end)
+      return name == "" ? (indent + shiftwidth() * 2) : indent
+    else
+      return indent
+    endif
+  elseif declaration == 'NOTATION'
+    " Check for notation name.  If none exists, indent one level.
+    let [name, end] = s:lex(line, end)
+    if name == ""
+      return indent + shiftwidth()
+    endif
+
+    " Now check for the external ID.  If none exists, indent one level.
+    let [id, end] = s:lex(line, end)
+    if id == ""
+      return indent + shiftwidth()
+    elseif id == 'SYSTEM' || id == 'PUBLIC'
+      let [quoted_string, end] = s:lex(line, end, '\%("[^"]\+"\|''[^'']\+''\)')
+      if quoted_string == ""
+        return indent + shiftwidth() * 2
+      endif
+
+      if id == 'PUBLIC'
+        let [quoted_string, end] = s:lex(line, end, '\%("[^"]\+"\|''[^'']\+''\|>\)')
+        if quoted_string == ""
+          " TODO: Should use s:lex here on getline(v:lnum) and check for >.
+          return getline(v:lnum) =~ '^\s*>' ? indent : (indent + shiftwidth() * 2)
+        elseif quoted_string == '>'
+          return indent
+        endif
+      endif
+    endif
+
+    return indent
+  endif
+
+  " TODO: Processing directives could be indented I suppose.  But perhaps it’s
+  " just as well to let the user decide how to indent them (perhaps extending
+  " this function to include proper support for whatever processing directive
+  " language they want to use).
+
+  " Conditional sections are simply passed along to let Vim decide what to do
+  " (and hence the user).
+  return -1
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

Git/usr/share/vim/vim81/indent/dtrace.vim

@@ -0,0 +1,17 @@
+" Vim indent file
+" Language: D script as described in "Solaris Dynamic Tracing Guide",
+"           http://docs.sun.com/app/docs/doc/817-6223
+" Last Change: 2008/03/20
+" Version: 1.2
+" Maintainer: Nicolas Weber <nicolasweber@gmx.de>
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+   finish
+endif
+let b:did_indent = 1
+
+" Built-in C indenting works nicely for dtrace.
+setlocal cindent
+
+let b:undo_indent = "setl cin<"

Git/usr/share/vim/vim81/indent/dylan.vim

@@ -0,0 +1,90 @@
+" Vim indent file
+" Language:	Dylan
+" Version:	0.01
+" Last Change:	2017 Jun 13
+" Maintainer:	Brent A. Fulgham <bfulgham@debian.org>
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentkeys+==~begin,=~block,=~case,=~cleanup,=~define,=~end,=~else,=~elseif,=~exception,=~for,=~finally,=~if,=~otherwise,=~select,=~unless,=~while
+
+" Define the appropriate indent function but only once
+setlocal indentexpr=DylanGetIndent()
+if exists("*DylanGetIndent")
+  finish
+endif
+
+function DylanGetIndent()
+  " Get the line to be indented
+  let cline = getline(v:lnum)
+
+  " Don't reindent comments on first column
+  if cline =~ '^/\[/\*]'
+    return 0
+  endif
+
+  "Find the previous non-blank line
+  let lnum = prevnonblank(v:lnum - 1)
+  "Use zero indent at the top of the file
+  if lnum == 0
+    return 0
+  endif
+
+  let prevline=getline(lnum)
+  let ind = indent(lnum)
+  let chg = 0
+
+  " If previous line was a comment, use its indent
+  if prevline =~ '^\s*//'
+    return ind
+  endif
+
+  " If previous line was a 'define', indent
+  if prevline =~? '\(^\s*\(begin\|block\|case\|define\|else\|elseif\|for\|finally\|if\|select\|unless\|while\)\|\s*\S*\s*=>$\)'
+    let chg = shiftwidth()
+  " local methods indent the shift-width, plus 6 for the 'local'
+  elseif prevline =~? '^\s*local'
+    let chg = shiftwidth() + 6
+  " If previous line was a let with no closing semicolon, indent
+  elseif prevline =~? '^\s*let.*[^;]\s*$'
+    let chg = shiftwidth()
+  " If previous line opened a parenthesis, and did not close it, indent
+  elseif prevline =~ '^.*(\s*[^)]*\((.*)\)*[^)]*$'
+    return = match( prevline, '(.*\((.*)\|[^)]\)*.*$') + 1
+  "elseif prevline =~ '^.*(\s*[^)]*\((.*)\)*[^)]*$'
+  elseif prevline =~ '^[^(]*)\s*$'
+    " This line closes a parenthesis.  Find opening
+    let curr_line = prevnonblank(lnum - 1)
+    while curr_line >= 0
+      let str = getline(curr_line)
+      if str !~ '^.*(\s*[^)]*\((.*)\)*[^)]*$'
+	let curr_line = prevnonblank(curr_line - 1)
+      else
+	break
+      endif
+    endwhile
+    if curr_line < 0
+      return -1
+    endif
+    let ind = indent(curr_line)
+    " Although we found the closing parenthesis, make sure this
+    " line doesn't start with an indentable command:
+    let curr_str = getline(curr_line)
+    if curr_str =~? '^\s*\(begin\|block\|case\|define\|else\|elseif\|for\|finally\|if\|select\|unless\|while\)'
+      let chg = shiftwidth()
+    endif
+  endif
+
+  " If a line starts with end, un-indent (even if we just indented!)
+  if cline =~? '^\s*\(cleanup\|end\|else\|elseif\|exception\|finally\|otherwise\)'
+    let chg = chg - shiftwidth()
+  endif
+
+  return ind + chg
+endfunction
+
+" vim:sw=2 tw=130

Git/usr/share/vim/vim81/indent/eiffel.vim

@@ -0,0 +1,115 @@
+" Vim indent file
+" Language:	Eiffel
+" Maintainer:	Jocelyn Fiat <jfiat@eiffel.com>
+" Previous-Maintainer:	David Clarke <gadicath@dishevelled.net>
+" Contributions from: Takuya Fujiwara
+" Contributions from: Thilo Six
+" $Date: 2017/03/08 06:00:00 $
+" $Revision: 1.4 $
+" URL: https://github.com/eiffelhub/vim-eiffel
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetEiffelIndent()
+setlocal nolisp
+setlocal nosmartindent
+setlocal nocindent
+setlocal autoindent
+setlocal comments=:--
+setlocal indentkeys+==end,=else,=ensure,=require,=check,=loop,=until
+setlocal indentkeys+==creation,=feature,=inherit,=class,=is,=redefine,=rename,=variant
+setlocal indentkeys+==invariant,=do,=local,=export
+
+let b:undo_indent = "setl smartindent< indentkeys< indentexpr< autoindent< comments< "
+
+" Define some stuff
+" keywords grouped by indenting
+let s:trust_user_indent = '\(+\)\(\s*\(--\).*\)\=$'
+let s:relative_indent = '^\s*\(deferred\|class\|feature\|creation\|inherit\|loop\|from\|across\|until\|if\|else\|elseif\|ensure\|require\|check\|do\|local\|invariant\|variant\|rename\|redefine\|do\|export\)\>'
+let s:outdent = '^\s*\(else\|invariant\|variant\|do\|require\|until\|loop\|local\)\>'
+let s:no_indent = '^\s*\(class\|feature\|creation\|inherit\)\>'
+let s:single_dent = '^[^-]\+[[:alnum:]]\+ is\(\s*\(--\).*\)\=$'
+let s:inheritance_dent = '\s*\(redefine\|rename\|export\)\>'
+
+
+" Only define the function once.
+if exists("*GetEiffelIndent")
+  finish
+endif
+
+let s:keepcpo= &cpo
+set cpo&vim
+
+function GetEiffelIndent()
+
+  " Eiffel Class indenting
+  "
+  " Find a non-blank line above the current line.
+  let lnum = prevnonblank(v:lnum - 1)
+
+  " At the start of the file use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  " trust the user's indenting
+  if getline(lnum) =~ s:trust_user_indent
+    return -1
+  endif
+
+  " Add a 'shiftwidth' after lines that start with an indent word
+  let ind = indent(lnum)
+  if getline(lnum) =~ s:relative_indent
+    let ind = ind + shiftwidth()
+  endif
+
+  " Indent to single indent
+  if getline(v:lnum) =~ s:single_dent && getline(v:lnum) !~ s:relative_indent
+	   \ && getline(v:lnum) !~ '\s*\<\(and\|or\|implies\)\>'
+     let ind = shiftwidth()
+  endif
+
+  " Indent to double indent
+  if getline(v:lnum) =~ s:inheritance_dent
+     let ind = 2 * shiftwidth()
+  endif
+
+  " Indent line after the first line of the function definition
+  if getline(lnum) =~ s:single_dent
+     let ind = ind + shiftwidth()
+  endif
+
+  " The following should always be at the start of a line, no indenting
+  if getline(v:lnum) =~ s:no_indent
+     let ind = 0
+  endif
+
+  " Subtract a 'shiftwidth', if this isn't the first thing after the 'is'
+  " or first thing after the 'do'
+  if getline(v:lnum) =~ s:outdent && getline(v:lnum - 1) !~ s:single_dent
+	\ && getline(v:lnum - 1) !~ '^\s*do\>'
+    let ind = ind - shiftwidth()
+  endif
+
+  " Subtract a shiftwidth for end statements
+  if getline(v:lnum) =~ '^\s*end\>'
+    let ind = ind - shiftwidth()
+  endif
+
+  " set indent of zero end statements that are at an indent of 3, this should
+  " only ever be the class's end.
+  if getline(v:lnum) =~ '^\s*end\>' && ind == shiftwidth()
+    let ind = 0
+  endif
+
+  return ind
+endfunction
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+" vim:sw=2

Git/usr/share/vim/vim81/indent/eruby.vim

@@ -0,0 +1,111 @@
+" Vim indent file
+" Language:		eRuby
+" Maintainer:		Tim Pope <vimNOSPAM@tpope.org>
+" URL:			https://github.com/vim-ruby/vim-ruby
+" Release Coordinator:	Doug Kearns <dougkearns@gmail.com>
+" Last Change:		2019 Jan 06
+
+if exists("b:did_indent")
+  finish
+endif
+
+runtime! indent/ruby.vim
+unlet! b:did_indent
+setlocal indentexpr=
+
+if exists("b:eruby_subtype") && b:eruby_subtype != '' && b:eruby_subtype !=# 'eruby'
+  exe "runtime! indent/".b:eruby_subtype.".vim"
+else
+  runtime! indent/html.vim
+endif
+unlet! b:did_indent
+
+" Force HTML indent to not keep state.
+let b:html_indent_usestate = 0
+
+if &l:indentexpr == ''
+  if &l:cindent
+    let &l:indentexpr = 'cindent(v:lnum)'
+  else
+    let &l:indentexpr = 'indent(prevnonblank(v:lnum-1))'
+  endif
+endif
+let b:eruby_subtype_indentexpr = &l:indentexpr
+
+let b:did_indent = 1
+
+setlocal indentexpr=GetErubyIndent()
+setlocal indentkeys=o,O,*<Return>,<>>,{,},0),0],o,O,!^F,=end,=else,=elsif,=rescue,=ensure,=when
+
+" Only define the function once.
+if exists("*GetErubyIndent")
+  finish
+endif
+
+" this file uses line continuations
+let s:cpo_sav = &cpo
+set cpo&vim
+
+function! GetErubyIndent(...)
+  " The value of a single shift-width
+  if exists('*shiftwidth')
+    let sw = shiftwidth()
+  else
+    let sw = &sw
+  endif
+
+  if a:0 && a:1 == '.'
+    let v:lnum = line('.')
+  elseif a:0 && a:1 =~ '^\d'
+    let v:lnum = a:1
+  endif
+  let vcol = col('.')
+  call cursor(v:lnum,1)
+  let inruby = searchpair('<%','','%>','W')
+  call cursor(v:lnum,vcol)
+  if inruby && getline(v:lnum) !~ '^<%\|^\s*[-=]\=%>'
+    let ind = GetRubyIndent(v:lnum)
+  else
+    exe "let ind = ".b:eruby_subtype_indentexpr
+
+    " Workaround for Andy Wokula's HTML indent. This should be removed after
+    " some time, since the newest version is fixed in a different way.
+    if b:eruby_subtype_indentexpr =~# '^HtmlIndent('
+	  \ && exists('b:indent')
+	  \ && type(b:indent) == type({})
+	  \ && has_key(b:indent, 'lnum')
+      " Force HTML indent to not keep state
+      let b:indent.lnum = -1
+    endif
+  endif
+  let lnum = prevnonblank(v:lnum-1)
+  let line = getline(lnum)
+  let cline = getline(v:lnum)
+  if cline =~# '^\s*<%[-=]\=\s*\%(}\|end\|else\|\%(ensure\|rescue\|elsif\|when\).\{-\}\)\s*\%([-=]\=%>\|$\)'
+    let ind = ind - sw
+  endif
+  if line =~# '\S\s*<%[-=]\=\s*\%(}\|end\).\{-\}\s*\%([-=]\=%>\|$\)'
+    let ind = ind - sw
+  endif
+  if line =~# '\%({\|\<do\)\%(\s*|[^|]*|\)\=\s*[-=]\=%>'
+    let ind = ind + sw
+  elseif line =~# '<%[-=]\=\s*\%(module\|class\|def\|if\|for\|while\|until\|else\|elsif\|case\|when\|unless\|begin\|ensure\|rescue\)\>.*%>'
+    let ind = ind + sw
+  endif
+  if line =~# '^\s*<%[=#-]\=\s*$' && cline !~# '^\s*end\>'
+    let ind = ind + sw
+  endif
+  if line !~# '^\s*<%' && line =~# '%>\s*$' && line !~# '^\s*end\>'
+	\ && synID(v:lnum, match(cline, '\S') + 1, 1) != hlID('htmlEndTag')
+    let ind = ind - sw
+  endif
+  if cline =~# '^\s*[-=]\=%>\s*$'
+    let ind = ind - sw
+  endif
+  return ind
+endfunction
+
+let &cpo = s:cpo_sav
+unlet! s:cpo_sav
+
+" vim:set sw=2 sts=2 ts=8 noet:

Git/usr/share/vim/vim81/indent/eterm.vim

@@ -0,0 +1,36 @@
+" Vim indent file
+" Language:             Eterm configuration file
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2006-12-20
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetEtermIndent()
+setlocal indentkeys=!^F,o,O,=end
+setlocal nosmartindent
+
+if exists("*GetEtermIndent")
+  finish
+endif
+
+function GetEtermIndent()
+  let lnum = prevnonblank(v:lnum - 1)
+  if lnum == 0
+    return 0
+  endif
+
+  let ind = indent(lnum)
+
+  if getline(lnum) =~ '^\s*begin\>'
+    let ind = ind + shiftwidth()
+  endif
+
+  if getline(v:lnum) =~ '^\s*end\>'
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/falcon.vim

@@ -0,0 +1,451 @@
+" Vim indent file
+" Language: Falcon
+" Maintainer: Steven Oliver <oliver.steven@gmail.com>
+" Website: https://steveno@github.com/steveno/falconpl-vim.git
+" Credits: This is, to a great extent, a copy n' paste of ruby.vim.
+
+" 1. Setup {{{1
+" ============
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+setlocal nosmartindent
+
+" Setup indent function and when to use it
+setlocal indentexpr=FalconGetIndent(v:lnum)
+setlocal indentkeys=0{,0},0),0],!^F,o,O,e
+setlocal indentkeys+==~case,=~catch,=~default,=~elif,=~else,=~end,=~\"
+
+" Define the appropriate indent function but only once
+if exists("*FalconGetIndent")
+    finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+" 2. Variables {{{1
+" ============
+
+" Regex of syntax group names that are strings AND comments
+let s:syng_strcom = '\<falcon\%(String\|StringEscape\|Comment\)\>'
+
+" Regex of syntax group names that are strings
+let s:syng_string = '\<falcon\%(String\|StringEscape\)\>'
+
+" Regex that defines blocks.
+"
+" Note that there's a slight problem with this regex and s:continuation_regex.
+" Code like this will be matched by both:
+"
+"   method_call do |(a, b)|
+"
+" The reason is that the pipe matches a hanging "|" operator.
+"
+let s:block_regex =
+      \ '\%(\<do:\@!\>\|%\@<!{\)\s*\%(|\s*(*\s*\%([*@&]\=\h\w*,\=\s*\)\%(,\s*(*\s*[*@&]\=\h\w*\s*)*\s*\)*|\)\=\s*\%(#.*\)\=$'
+
+let s:block_continuation_regex = '^\s*[^])}\t ].*'.s:block_regex
+
+" Regex that defines continuation lines.
+" TODO: this needs to deal with if ...: and so on
+let s:continuation_regex =
+      \ '\%(%\@<![({[\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\)\s*\%(#.*\)\=$'
+
+" Regex that defines bracket continuations
+let s:bracket_continuation_regex = '%\@<!\%([({[]\)\s*\%(#.*\)\=$'
+
+" Regex that defines continuation lines, not including (, {, or [.
+let s:non_bracket_continuation_regex = '\%([\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\)\s*\%(#.*\)\=$'
+
+" Keywords to indent on
+let s:falcon_indent_keywords = '^\s*\(case\|catch\|class\|enum\|default\|elif\|else' .
+    \ '\|for\|function\|if.*"[^"]*:.*"\|if \(\(:\)\@!.\)*$\|loop\|object\|select' .
+    \ '\|switch\|try\|while\|\w*\s*=\s*\w*([$\)'
+
+" Keywords to deindent on
+let s:falcon_deindent_keywords = '^\s*\(case\|catch\|default\|elif\|else\|end\)'
+
+" 3. Functions {{{1
+" ============
+
+" Check if the character at lnum:col is inside a string, comment, or is ascii.
+function s:IsInStringOrComment(lnum, col)
+    return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_strcom
+endfunction
+
+" Check if the character at lnum:col is inside a string.
+function s:IsInString(lnum, col)
+    return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_string
+endfunction
+
+" Check if the character at lnum:col is inside a string delimiter
+function s:IsInStringDelimiter(lnum, col)
+    return synIDattr(synID(a:lnum, a:col, 1), 'name') == 'falconStringDelimiter'
+endfunction
+
+" Find line above 'lnum' that isn't empty, in a comment, or in a string.
+function s:PrevNonBlankNonString(lnum)
+    let in_block = 0
+    let lnum = prevnonblank(a:lnum)
+    while lnum > 0
+	" Go in and out of blocks comments as necessary.
+	" If the line isn't empty (with opt. comment) or in a string, end search.
+	let line = getline(lnum)
+	if line =~ '^=begin'
+	    if in_block
+		let in_block = 0
+	    else
+		break
+	    endif
+	elseif !in_block && line =~ '^=end'
+	    let in_block = 1
+	elseif !in_block && line !~ '^\s*#.*$' && !(s:IsInStringOrComment(lnum, 1)
+		    \ && s:IsInStringOrComment(lnum, strlen(line)))
+	    break
+	endif
+	let lnum = prevnonblank(lnum - 1)
+    endwhile
+    return lnum
+endfunction
+
+" Find line above 'lnum' that started the continuation 'lnum' may be part of.
+function s:GetMSL(lnum)
+    " Start on the line we're at and use its indent.
+    let msl = a:lnum
+    let msl_body = getline(msl)
+    let lnum = s:PrevNonBlankNonString(a:lnum - 1)
+    while lnum > 0
+	" If we have a continuation line, or we're in a string, use line as MSL.
+	" Otherwise, terminate search as we have found our MSL already.
+	let line = getline(lnum)
+	
+	if s:Match(line, s:non_bracket_continuation_regex) &&
+          	\ s:Match(msl, s:non_bracket_continuation_regex)
+	    " If the current line is a non-bracket continuation and so is the
+	    " previous one, keep its indent and continue looking for an MSL.
+	    "    
+	    " Example:
+	    "   method_call one,
+	    "       two,
+	    "           three
+	    "           
+	    let msl = lnum
+	elseif s:Match(lnum, s:non_bracket_continuation_regex) &&
+		    \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
+	    " If the current line is a bracket continuation or a block-starter, but
+	    " the previous is a non-bracket one, respect the previous' indentation,
+	    " and stop here.
+	    " 
+	    " Example:
+	    "   method_call one,
+	    "       two {
+	    "           three
+	    "
+	    return lnum
+	elseif s:Match(lnum, s:bracket_continuation_regex) &&
+		    \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
+	    " If both lines are bracket continuations (the current may also be a
+	    " block-starter), use the current one's and stop here
+	    "
+	    " Example:
+	    "   method_call(
+	    "       other_method_call(
+	    "             foo
+	    return msl
+	elseif s:Match(lnum, s:block_regex) &&
+		    \ !s:Match(msl, s:continuation_regex) &&
+		    \ !s:Match(msl, s:block_continuation_regex)
+	    " If the previous line is a block-starter and the current one is
+	    " mostly ordinary, use the current one as the MSL.
+	    " 
+	    " Example:
+	    "   method_call do
+	    "       something
+	    "           something_else
+	    return msl
+	else
+	    let col = match(line, s:continuation_regex) + 1
+	    if (col > 0 && !s:IsInStringOrComment(lnum, col))
+			\ || s:IsInString(lnum, strlen(line))
+		let msl = lnum
+	    else
+		break
+	    endif
+	endif
+	
+	let msl_body = getline(msl)
+	let lnum = s:PrevNonBlankNonString(lnum - 1)
+    endwhile
+    return msl
+endfunction
+
+" Check if line 'lnum' has more opening brackets than closing ones.
+function s:ExtraBrackets(lnum)
+    let opening = {'parentheses': [], 'braces': [], 'brackets': []}
+    let closing = {'parentheses': [], 'braces': [], 'brackets': []}
+
+    let line = getline(a:lnum)
+    let pos  = match(line, '[][(){}]', 0)
+
+    " Save any encountered opening brackets, and remove them once a matching
+    " closing one has been found. If a closing bracket shows up that doesn't
+    " close anything, save it for later.
+    while pos != -1
+	if !s:IsInStringOrComment(a:lnum, pos + 1)
+	    if line[pos] == '('
+		call add(opening.parentheses, {'type': '(', 'pos': pos})
+	    elseif line[pos] == ')'
+		if empty(opening.parentheses)
+		    call add(closing.parentheses, {'type': ')', 'pos': pos})
+		else
+		    let opening.parentheses = opening.parentheses[0:-2]
+		endif
+	    elseif line[pos] == '{'
+		call add(opening.braces, {'type': '{', 'pos': pos})
+	    elseif line[pos] == '}'
+		if empty(opening.braces)
+		    call add(closing.braces, {'type': '}', 'pos': pos})
+		else
+		    let opening.braces = opening.braces[0:-2]
+		endif
+	    elseif line[pos] == '['
+		call add(opening.brackets, {'type': '[', 'pos': pos})
+	    elseif line[pos] == ']'
+		if empty(opening.brackets)
+		    call add(closing.brackets, {'type': ']', 'pos': pos})
+		else
+		    let opening.brackets = opening.brackets[0:-2]
+		endif
+	    endif
+	endif
+	
+	let pos = match(line, '[][(){}]', pos + 1)
+    endwhile
+
+    " Find the rightmost brackets, since they're the ones that are important in
+    " both opening and closing cases
+    let rightmost_opening = {'type': '(', 'pos': -1}
+    let rightmost_closing = {'type': ')', 'pos': -1}
+
+    for opening in opening.parentheses + opening.braces + opening.brackets
+	if opening.pos > rightmost_opening.pos
+	    let rightmost_opening = opening
+	endif
+    endfor
+
+    for closing in closing.parentheses + closing.braces + closing.brackets
+	if closing.pos > rightmost_closing.pos
+	    let rightmost_closing = closing
+	endif
+    endfor
+
+    return [rightmost_opening, rightmost_closing]
+endfunction
+
+function s:Match(lnum, regex)
+    let col = match(getline(a:lnum), '\C'.a:regex) + 1
+    return col > 0 && !s:IsInStringOrComment(a:lnum, col) ? col : 0
+endfunction
+
+function s:MatchLast(lnum, regex)
+    let line = getline(a:lnum)
+    let col = match(line, '.*\zs' . a:regex)
+    while col != -1 && s:IsInStringOrComment(a:lnum, col)
+	let line = strpart(line, 0, col)
+	let col = match(line, '.*' . a:regex)
+    endwhile
+    return col + 1
+endfunction
+
+" 4. FalconGetIndent Routine {{{1
+" ============
+
+function FalconGetIndent(...)
+    " For the current line, use the first argument if given, else v:lnum
+    let clnum = a:0 ? a:1 : v:lnum
+
+    " Use zero indent at the top of the file
+    if clnum == 0
+        return 0
+    endif
+
+    let line = getline(clnum)
+    let ind = -1
+
+    " If we got a closing bracket on an empty line, find its match and indent
+    " according to it.  For parentheses we indent to its column - 1, for the
+    " others we indent to the containing line's MSL's level.  Return -1 if fail.
+    let col = matchend(line, '^\s*[]})]')
+    if col > 0 && !s:IsInStringOrComment(clnum, col)
+	call cursor(clnum, col)
+	let bs = strpart('(){}[]', stridx(')}]', line[col - 1]) * 2, 2)
+	if searchpair(escape(bs[0], '\['), '', bs[1], 'bW', s:skip_expr) > 0
+	    if line[col-1]==')' && col('.') != col('$') - 1
+		let ind = virtcol('.') - 1
+	    else
+		let ind = indent(s:GetMSL(line('.')))
+	    endif
+	endif
+	return ind
+    endif
+
+    " If we have a deindenting keyword, find its match and indent to its level.
+    " TODO: this is messy
+    if s:Match(clnum, s:falcon_deindent_keywords)
+	call cursor(clnum, 1)
+	if searchpair(s:end_start_regex, s:end_middle_regex, s:end_end_regex, 'bW',
+		    \ s:end_skip_expr) > 0
+	    let msl  = s:GetMSL(line('.'))
+	    let line = getline(line('.'))
+
+	    if strpart(line, 0, col('.') - 1) =~ '=\s*$' &&
+			\ strpart(line, col('.') - 1, 2) !~ 'do'
+		let ind = virtcol('.') - 1
+	    elseif getline(msl) =~ '=\s*\(#.*\)\=$'
+		let ind = indent(line('.'))
+	    else
+		let ind = indent(msl)
+	    endif
+	endif
+	return ind
+    endif
+
+    " If we are in a multi-line string or line-comment, don't do anything to it.
+    if s:IsInString(clnum, matchend(line, '^\s*') + 1)
+	return indent('.')
+    endif
+
+    " Find a non-blank, non-multi-line string line above the current line.
+    let lnum = s:PrevNonBlankNonString(clnum - 1)
+
+    " If the line is empty and inside a string, use the previous line.
+    if line =~ '^\s*$' && lnum != prevnonblank(clnum - 1)
+	return indent(prevnonblank(clnum))
+    endif
+
+    " At the start of the file use zero indent.
+    if lnum == 0
+	return 0
+    endif
+
+    " Set up variables for the previous line.
+    let line = getline(lnum)
+    let ind = indent(lnum)
+
+    " If the previous line ended with a block opening, add a level of indent.
+    if s:Match(lnum, s:block_regex)
+	return indent(s:GetMSL(lnum)) + shiftwidth()
+    endif
+
+    " If it contained hanging closing brackets, find the rightmost one, find its
+    " match and indent according to that.
+    if line =~ '[[({]' || line =~ '[])}]\s*\%(#.*\)\=$'
+	let [opening, closing] = s:ExtraBrackets(lnum)
+
+	if opening.pos != -1
+	    if opening.type == '(' && searchpair('(', '', ')', 'bW', s:skip_expr) > 0
+		if col('.') + 1 == col('$')
+		    return ind + shiftwidth()
+		else
+		    return virtcol('.')
+		endif
+	    else
+		let nonspace = matchend(line, '\S', opening.pos + 1) - 1
+		return nonspace > 0 ? nonspace : ind + shiftwidth()
+	    endif
+	elseif closing.pos != -1
+	    call cursor(lnum, closing.pos + 1)
+	    normal! %
+
+	    if s:Match(line('.'), s:falcon_indent_keywords)
+		return indent('.') + shiftwidth()
+	    else
+		return indent('.')
+	    endif
+	else
+	    call cursor(clnum, 0)  " FIXME: column was vcol
+	end
+    endif
+
+    " If the previous line ended with an "end", match that "end"s beginning's
+    " indent.
+    let col = s:Match(lnum, '\%(^\|[^.:@$]\)\<end\>\s*\%(#.*\)\=$')
+    if col > 0
+	call cursor(lnum, col)
+	if searchpair(s:end_start_regex, '', s:end_end_regex, 'bW',
+		    \ s:end_skip_expr) > 0
+	    let n = line('.')
+	    let ind = indent('.')
+	    let msl = s:GetMSL(n)
+	    if msl != n
+		let ind = indent(msl)
+	    end
+	    return ind
+	endif
+    end
+
+    let col = s:Match(lnum, s:falcon_indent_keywords)
+    if col > 0
+	call cursor(lnum, col)
+	let ind = virtcol('.') - 1 + shiftwidth()
+	" TODO: make this better (we need to count them) (or, if a searchpair
+	" fails, we know that something is lacking an end and thus we indent a
+	" level
+	if s:Match(lnum, s:end_end_regex)
+	    let ind = indent('.')
+	endif
+	return ind
+    endif
+
+    " Set up variables to use and search for MSL to the previous line.
+    let p_lnum = lnum
+    let lnum = s:GetMSL(lnum)
+
+    " If the previous line wasn't a MSL and is continuation return its indent.
+    " TODO: the || s:IsInString() thing worries me a bit.
+    if p_lnum != lnum
+	if s:Match(p_lnum, s:non_bracket_continuation_regex) || s:IsInString(p_lnum,strlen(line))
+	    return ind
+	endif
+    endif
+
+    " Set up more variables, now that we know we wasn't continuation bound.
+    let line = getline(lnum)
+    let msl_ind = indent(lnum)
+
+    " If the MSL line had an indenting keyword in it, add a level of indent.
+    " TODO: this does not take into account contrived things such as
+    " module Foo; class Bar; end
+    if s:Match(lnum, s:falcon_indent_keywords)
+	let ind = msl_ind + shiftwidth()
+	if s:Match(lnum, s:end_end_regex)
+	    let ind = ind - shiftwidth()
+	endif
+	return ind
+    endif
+
+    " If the previous line ended with [*+/.,-=], but wasn't a block ending or a
+    " closing bracket, indent one extra level.
+    if s:Match(lnum, s:non_bracket_continuation_regex) && !s:Match(lnum, '^\s*\([\])}]\|end\)')
+	if lnum == p_lnum
+	    let ind = msl_ind + shiftwidth()
+	else
+	    let ind = msl_ind
+	endif
+	return ind
+    endif
+
+  return ind
+endfunction
+
+" }}}1
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim: set sw=4 sts=4 et tw=80 :

Git/usr/share/vim/vim81/indent/fortran.vim

@@ -0,0 +1,218 @@
+" Vim indent file
+" Language:	Fortran 2008 (and older: Fortran 2003, 95, 90, and 77)
+" Version:	47
+" Last Change:	2016 Oct. 29
+" Maintainer:	Ajit J. Thakkar <ajit@unb.ca>; <http://www2.unb.ca/~ajit/>
+" Usage:	For instructions, do :help fortran-indent from Vim
+" Credits:
+"  Useful suggestions were made, in chronological order, by:
+"  Albert Oliver Serra, Takuya Fujiwara and Philipp Edelmann.
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+let s:cposet=&cpoptions
+set cpoptions&vim
+
+setlocal indentkeys+==~end,=~case,=~if,=~else,=~do,=~where,=~elsewhere,=~select
+setlocal indentkeys+==~endif,=~enddo,=~endwhere,=~endselect,=~elseif
+setlocal indentkeys+==~type,=~interface,=~forall,=~associate,=~block,=~enum
+setlocal indentkeys+==~endforall,=~endassociate,=~endblock,=~endenum
+if exists("b:fortran_indent_more") || exists("g:fortran_indent_more")
+  setlocal indentkeys+==~function,=~subroutine,=~module,=~contains,=~program
+  setlocal indentkeys+==~endfunction,=~endsubroutine,=~endmodule
+  setlocal indentkeys+==~endprogram
+endif
+
+" Determine whether this is a fixed or free format source file
+" if this hasn't been done yet using the priority:
+" buffer-local value
+" > global value
+" > file extension as in Intel ifort, gcc (gfortran), NAG, Pathscale, and Cray compilers
+if !exists("b:fortran_fixed_source")
+  if exists("fortran_free_source")
+    " User guarantees free source form
+    let b:fortran_fixed_source = 0
+  elseif exists("fortran_fixed_source")
+    " User guarantees fixed source form
+    let b:fortran_fixed_source = 1
+  elseif expand("%:e") ==? "f\<90\|95\|03\|08\>"
+    " Free-form file extension defaults as in Intel ifort, gcc(gfortran), NAG, Pathscale, and Cray compilers
+    let b:fortran_fixed_source = 0
+  elseif expand("%:e") ==? "f\|f77\|for"
+    " Fixed-form file extension defaults
+    let b:fortran_fixed_source = 1
+  else
+    " Modern fortran still allows both fixed and free source form
+    " Assume fixed source form unless signs of free source form
+    " are detected in the first five columns of the first s:lmax lines.
+    " Detection becomes more accurate and time-consuming if more lines
+    " are checked. Increase the limit below if you keep lots of comments at
+    " the very top of each file and you have a fast computer.
+    let s:lmax = 500
+    if ( s:lmax > line("$") )
+      let s:lmax = line("$")
+    endif
+    let b:fortran_fixed_source = 1
+    let s:ln=1
+    while s:ln <= s:lmax
+      let s:test = strpart(getline(s:ln),0,5)
+      if s:test !~ '^[Cc*]' && s:test !~ '^ *[!#]' && s:test =~ '[^ 0-9\t]' && s:test !~ '^[ 0-9]*\t'
+	let b:fortran_fixed_source = 0
+	break
+      endif
+      let s:ln = s:ln + 1
+    endwhile
+  endif
+endif
+
+" Define the appropriate indent function but only once
+if (b:fortran_fixed_source == 1)
+  setlocal indentexpr=FortranGetFixedIndent()
+  if exists("*FortranGetFixedIndent")
+    finish
+  endif
+else
+  setlocal indentexpr=FortranGetFreeIndent()
+  if exists("*FortranGetFreeIndent")
+    finish
+  endif
+endif
+
+function FortranGetIndent(lnum)
+  let ind = indent(a:lnum)
+  let prevline=getline(a:lnum)
+  " Strip tail comment
+  let prevstat=substitute(prevline, '!.*$', '', '')
+  let prev2line=getline(a:lnum-1)
+  let prev2stat=substitute(prev2line, '!.*$', '', '')
+
+  "Indent do loops only if they are all guaranteed to be of do/end do type
+  if exists("b:fortran_do_enddo") || exists("g:fortran_do_enddo")
+    if prevstat =~? '^\s*\(\d\+\s\)\=\s*\(\a\w*\s*:\)\=\s*do\>'
+      let ind = ind + shiftwidth()
+    endif
+    if getline(v:lnum) =~? '^\s*\(\d\+\s\)\=\s*end\s*do\>'
+      let ind = ind - shiftwidth()
+    endif
+  endif
+
+  "Add a shiftwidth to statements following if, else, else if, case, class,
+  "where, else where, forall, type, interface and associate statements
+  if prevstat =~? '^\s*\(case\|class\|else\|else\s*if\|else\s*where\)\>'
+	\ ||prevstat=~? '^\s*\(type\|interface\|associate\|enum\)\>'
+	\ ||prevstat=~?'^\s*\(\d\+\s\)\=\s*\(\a\w*\s*:\)\=\s*\(forall\|where\|block\)\>'
+	\ ||prevstat=~? '^\s*\(\d\+\s\)\=\s*\(\a\w*\s*:\)\=\s*if\>'
+     let ind = ind + shiftwidth()
+    " Remove unwanted indent after logical and arithmetic ifs
+    if prevstat =~? '\<if\>' && prevstat !~? '\<then\>'
+      let ind = ind - shiftwidth()
+    endif
+    " Remove unwanted indent after type( statements
+    if prevstat =~? '^\s*type\s*('
+      let ind = ind - shiftwidth()
+    endif
+  endif
+
+  "Indent program units unless instructed otherwise
+  if !exists("b:fortran_indent_less") && !exists("g:fortran_indent_less")
+    let prefix='\(\(pure\|impure\|elemental\|recursive\)\s\+\)\{,2}'
+    let type='\(\(integer\|real\|double\s\+precision\|complex\|logical'
+          \.'\|character\|type\|class\)\s*\S*\s\+\)\='
+    if prevstat =~? '^\s*\(contains\|submodule\|program\)\>'
+            \ ||prevstat =~? '^\s*'.'module\>\(\s*\procedure\)\@!'
+            \ ||prevstat =~? '^\s*'.prefix.'subroutine\>'
+            \ ||prevstat =~? '^\s*'.prefix.type.'function\>'
+            \ ||prevstat =~? '^\s*'.type.prefix.'function\>'
+      let ind = ind + shiftwidth()
+    endif
+    if getline(v:lnum) =~? '^\s*contains\>'
+          \ ||getline(v:lnum)=~? '^\s*end\s*'
+          \ .'\(function\|subroutine\|module\|submodule\|program\)\>'
+      let ind = ind - shiftwidth()
+    endif
+  endif
+
+  "Subtract a shiftwidth from else, else if, elsewhere, case, class, end if,
+  " end where, end select, end forall, end interface, end associate,
+  " end enum, end type, end block and end type statements
+  if getline(v:lnum) =~? '^\s*\(\d\+\s\)\=\s*'
+        \. '\(else\|else\s*if\|else\s*where\|case\|class\|'
+        \. 'end\s*\(if\|where\|select\|interface\|'
+        \. 'type\|forall\|associate\|enum\|block\)\)\>'
+    let ind = ind - shiftwidth()
+    " Fix indent for case statement immediately after select
+    if prevstat =~? '\<select\s\+\(case\|type\)\>'
+      let ind = ind + shiftwidth()
+    endif
+  endif
+
+  "First continuation line
+  if prevstat =~ '&\s*$' && prev2stat !~ '&\s*$'
+    let ind = ind + shiftwidth()
+  endif
+  "Line after last continuation line
+  if prevstat !~ '&\s*$' && prev2stat =~ '&\s*$' && prevstat !~? '\<then\>'
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfunction
+
+function FortranGetFreeIndent()
+  "Find the previous non-blank line
+  let lnum = prevnonblank(v:lnum - 1)
+
+  "Use zero indent at the top of the file
+  if lnum == 0
+    return 0
+  endif
+
+  let ind=FortranGetIndent(lnum)
+  return ind
+endfunction
+
+function FortranGetFixedIndent()
+  let currline=getline(v:lnum)
+  "Don't indent comments, continuation lines and labelled lines
+  if strpart(currline,0,6) =~ '[^ \t]'
+    let ind = indent(v:lnum)
+    return ind
+  endif
+
+  "Find the previous line which is not blank, not a comment,
+  "not a continuation line, and does not have a label
+  let lnum = v:lnum - 1
+  while lnum > 0
+    let prevline=getline(lnum)
+    if (prevline =~ "^[C*!]") || (prevline =~ "^\s*$")
+	\ || (strpart(prevline,5,1) !~ "[ 0]")
+      " Skip comments, blank lines and continuation lines
+      let lnum = lnum - 1
+    else
+      let test=strpart(prevline,0,5)
+      if test =~ "[0-9]"
+	" Skip lines with statement numbers
+	let lnum = lnum - 1
+      else
+	break
+      endif
+    endif
+  endwhile
+
+  "First line must begin at column 7
+  if lnum == 0
+    return 6
+  endif
+
+  let ind=FortranGetIndent(lnum)
+  return ind
+endfunction
+
+let &cpoptions=s:cposet
+unlet s:cposet
+
+" vim:sw=2 tw=130

Git/usr/share/vim/vim81/indent/framescript.vim

@@ -0,0 +1,41 @@
+" Vim indent file
+" Language:             FrameScript
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2008-07-19
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetFrameScriptIndent()
+setlocal indentkeys=!^F,o,O,0=~Else,0=~EndIf,0=~EndLoop,0=~EndSub
+setlocal nosmartindent
+
+if exists("*GetFrameScriptIndent")
+  finish
+endif
+
+function GetFrameScriptIndent()
+  let lnum = prevnonblank(v:lnum - 1)
+
+  if lnum == 0
+    return 0
+  endif
+
+  if getline(v:lnum) =~ '^\s*\*'
+    return cindent(v:lnum)
+  endif
+
+  let ind = indent(lnum)
+
+  if getline(lnum) =~? '^\s*\%(If\|Loop\|Sub\)'
+    let ind = ind + shiftwidth()
+  endif
+
+  if getline(v:lnum) =~? '^\s*\%(Else\|End\%(If\|Loop\|Sub\)\)'
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/gitconfig.vim

@@ -0,0 +1,38 @@
+" Vim indent file
+" Language:	git config file
+" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
+" Last Change:	2017 Jun 13
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentexpr=GetGitconfigIndent()
+setlocal indentkeys=o,O,*<Return>,0[,],0;,0#,=,!^F
+
+let b:undo_indent = 'setl ai< inde< indk<'
+
+" Only define the function once.
+if exists("*GetGitconfigIndent")
+  finish
+endif
+
+function! GetGitconfigIndent()
+  let sw    = shiftwidth()
+  let line  = getline(prevnonblank(v:lnum-1))
+  let cline = getline(v:lnum)
+  if line =~  '\\\@<!\%(\\\\\)*\\$'
+    " odd number of slashes, in a line continuation
+    return 2 * sw
+  elseif cline =~ '^\s*\['
+    return 0
+  elseif cline =~ '^\s*\a'
+    return sw
+  elseif cline == ''       && line =~ '^\['
+    return sw
+  else
+    return -1
+  endif
+endfunction

Git/usr/share/vim/vim81/indent/gitolite.vim

@@ -0,0 +1,49 @@
+" Vim indent file
+" Language:	gitolite configuration
+" URL:		https://github.com/sitaramc/gitolite/blob/master/contrib/vim/indent/gitolite.vim
+"	(https://raw.githubusercontent.com/sitaramc/gitolite/master/contrib/vim/indent/gitolite.vim)
+" Maintainer:	Sitaram Chamarty <sitaramc@gmail.com>
+" (former Maintainer:	Teemu Matilainen <teemu.matilainen@iki.fi>)
+" Last Change:	2017 Oct 05
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentexpr=GetGitoliteIndent()
+setlocal indentkeys=o,O,*<Return>,!^F,=repo,\",=
+
+" Only define the function once.
+if exists("*GetGitoliteIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+function! GetGitoliteIndent()
+  let prevln = prevnonblank(v:lnum-1)
+  let pline = getline(prevln)
+  let cline = getline(v:lnum)
+
+  if cline =~ '^\s*\(C\|R\|RW\|RW+\|RWC\|RW+C\|RWD\|RW+D\|RWCD\|RW+CD\|-\)[ \t=]'
+    return shiftwidth()
+  elseif cline =~ '^\s*config\s'
+    return shiftwidth()
+  elseif cline =~ '^\s*option\s'
+    return shiftwidth()
+  elseif pline =~ '^\s*repo\s' && cline =~ '^\s*\(#.*\)\?$'
+    return shiftwidth()
+  elseif cline =~ '^\s*#'
+    return indent(prevln)
+  elseif cline =~ '^\s*$'
+    return -1
+  else
+    return 0
+  endif
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

Git/usr/share/vim/vim81/indent/go.vim

@@ -0,0 +1,66 @@
+" Vim indent file
+" Language:	Go
+" Maintainer:	David Barnett (https://github.com/google/vim-ft-go)
+" Last Change:	2017 Jun 13
+"
+" TODO:
+" - function invocations split across lines
+" - general line splits (line ends in an operator)
+
+if exists('b:did_indent')
+  finish
+endif
+let b:did_indent = 1
+
+" C indentation is too far off useful, mainly due to Go's := operator.
+" Let's just define our own.
+setlocal nolisp
+setlocal autoindent
+setlocal indentexpr=GoIndent(v:lnum)
+setlocal indentkeys+=<:>,0=},0=)
+
+if exists('*GoIndent')
+  finish
+endif
+
+function! GoIndent(lnum)
+  let l:prevlnum = prevnonblank(a:lnum-1)
+  if l:prevlnum == 0
+    " top of file
+    return 0
+  endif
+
+  " grab the previous and current line, stripping comments.
+  let l:prevl = substitute(getline(l:prevlnum), '//.*$', '', '')
+  let l:thisl = substitute(getline(a:lnum), '//.*$', '', '')
+  let l:previ = indent(l:prevlnum)
+
+  let l:ind = l:previ
+
+  if l:prevl =~ '[({]\s*$'
+    " previous line opened a block
+    let l:ind += shiftwidth()
+  endif
+  if l:prevl =~# '^\s*\(case .*\|default\):$'
+    " previous line is part of a switch statement
+    let l:ind += shiftwidth()
+  endif
+  " TODO: handle if the previous line is a label.
+
+  if l:thisl =~ '^\s*[)}]'
+    " this line closed a block
+    let l:ind -= shiftwidth()
+  endif
+
+  " Colons are tricky.
+  " We want to outdent if it's part of a switch ("case foo:" or "default:").
+  " We ignore trying to deal with jump labels because (a) they're rare, and
+  " (b) they're hard to disambiguate from a composite literal key.
+  if l:thisl =~# '^\s*\(case .*\|default\):$'
+    let l:ind -= shiftwidth()
+  endif
+
+  return l:ind
+endfunction
+
+" vim: sw=2 sts=2 et

Git/usr/share/vim/vim81/indent/haml.vim

@@ -0,0 +1,74 @@
+" Vim indent file
+" Language:	Haml
+" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
+" Last Change:	2017 Jun 13
+
+if exists("b:did_indent")
+  finish
+endif
+runtime! indent/ruby.vim
+unlet! b:did_indent
+let b:did_indent = 1
+
+setlocal autoindent sw=2 et
+setlocal indentexpr=GetHamlIndent()
+setlocal indentkeys=o,O,*<Return>,},],0),!^F,=end,=else,=elsif,=rescue,=ensure,=when
+
+" Only define the function once.
+if exists("*GetHamlIndent")
+  finish
+endif
+
+let s:attributes = '\%({.\{-\}}\|\[.\{-\}\]\)'
+let s:tag = '\%([%.#][[:alnum:]_-]\+\|'.s:attributes.'\)*[<>]*'
+
+if !exists('g:haml_self_closing_tags')
+  let g:haml_self_closing_tags = 'base|link|meta|br|hr|img|input'
+endif
+
+function! GetHamlIndent()
+  let lnum = prevnonblank(v:lnum-1)
+  if lnum == 0
+    return 0
+  endif
+  let line = substitute(getline(lnum),'\s\+$','','')
+  let cline = substitute(substitute(getline(v:lnum),'\s\+$','',''),'^\s\+','','')
+  let lastcol = strlen(line)
+  let line = substitute(line,'^\s\+','','')
+  let indent = indent(lnum)
+  let cindent = indent(v:lnum)
+  let sw = shiftwidth()
+  if cline =~# '\v^-\s*%(elsif|else|when)>'
+    let indent = cindent < indent ? cindent : indent - sw
+  endif
+  let increase = indent + sw
+  if indent == indent(lnum)
+    let indent = cindent <= indent ? -1 : increase
+  endif
+
+  let group = synIDattr(synID(lnum,lastcol,1),'name')
+
+  if line =~ '^!!!'
+    return indent
+  elseif line =~ '^/\%(\[[^]]*\]\)\=$'
+    return increase
+  elseif group == 'hamlFilter'
+    return increase
+  elseif line =~ '^'.s:tag.'[&!]\=[=~-]\s*\%(\%(if\|else\|elsif\|unless\|case\|when\|while\|until\|for\|begin\|module\|class\|def\)\>\%(.*\<end\>\)\@!\|.*do\%(\s*|[^|]*|\)\=\s*$\)'
+    return increase
+  elseif line =~ '^'.s:tag.'[&!]\=[=~-].*,\s*$'
+    return increase
+  elseif line == '-#'
+    return increase
+  elseif group =~? '\v^(hamlSelfCloser)$' || line =~? '^%\v%('.g:haml_self_closing_tags.')>'
+    return indent
+  elseif group =~? '\v^%(hamlTag|hamlAttributesDelimiter|hamlObjectDelimiter|hamlClass|hamlId|htmlTagName|htmlSpecialTagName)$'
+    return increase
+  elseif synIDattr(synID(v:lnum,1,1),'name') ==? 'hamlRubyFilter'
+    return GetRubyIndent()
+  else
+    return indent
+  endif
+endfunction
+
+" vim:set sw=2:

Git/usr/share/vim/vim81/indent/hamster.vim

@@ -0,0 +1,55 @@
+" Vim indent file
+" Language:    Hamster Script 
+" Version:     2.0.6.0
+" Last Change: Wed Nov 08 2006 12:02:42 PM
+" Maintainer:  David Fishburn <fishburn@ianywhere.com>
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentkeys+==~if,=~else,=~endif,=~endfor,=~endwhile
+setlocal indentkeys+==~do,=~until,=~while,=~repeat,=~for,=~loop
+setlocal indentkeys+==~sub,=~endsub
+
+" Define the appropriate indent function but only once
+setlocal indentexpr=HamGetFreeIndent()
+if exists("*HamGetFreeIndent")
+  finish
+endif
+
+function HamGetIndent(lnum)
+  let ind = indent(a:lnum)
+  let prevline=getline(a:lnum)
+
+  " Add a shiftwidth to statements following if,  else, elseif,
+  " case, select, default, do, until, while, for, start
+  if prevline =~? '^\s*\<\(if\|else\%(if\)\?\|for\|repeat\|do\|while\|sub\)\>' 
+    let ind = ind + shiftwidth()
+  endif
+
+  " Subtract a shiftwidth from else, elseif, end(if|while|for), until
+  let line = getline(v:lnum)
+  if line =~? '^\s*\(else\|elseif\|loop\|until\|end\%(if\|while\|for\|sub\)\)\>'
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfunction
+
+function HamGetFreeIndent()
+  " Find the previous non-blank line
+  let lnum = prevnonblank(v:lnum - 1)
+
+  " Use zero indent at the top of the file
+  if lnum == 0
+    return 0
+  endif
+
+  let ind=HamGetIndent(lnum)
+  return ind
+endfunction
+
+" vim:sw=2 tw=80

Git/usr/share/vim/vim81/indent/hog.vim

@@ -0,0 +1,77 @@
+" Vim indent file
+" Language:     hog (Snort.conf)
+" Maintainer:   Victor Roemer, <vroemer@badsec.org>
+" Last Change:  Mar 7, 2013
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+let b:undo_indent = 'setlocal smartindent< indentexpr< indentkeys<'
+
+setlocal nosmartindent
+setlocal indentexpr=GetHogIndent()
+setlocal indentkeys+=!^F,o,O,0#
+
+" Only define the function once.
+if exists("*GetHogIndent")
+    finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+let s:syn_blocks = '\<SnortRuleTypeBody\>'
+
+function s:IsInBlock(lnum)
+    return synIDattr(synID(a:lnum, 1, 1), 'name') =~ s:syn_blocks 
+endfunction
+
+function GetHogIndent()
+    let prevlnum = prevnonblank(v:lnum-1)
+
+    " Comment blocks have identical indent
+    if getline(v:lnum) =~ '^\s*#' && getline(prevlnum) =~ '^\s*#'
+            return indent(prevlnum)
+    endif
+
+    " Ignore comment lines when calculating indent
+    while getline(prevlnum) =~ '^\s*#'
+        let prevlnum = prevnonblank(prevlnum-1)
+        if !prevlnum
+            return previndent
+        endif
+    endwhile
+
+    " Continuation of a line that wasn't indented
+    let prevline = getline(prevlnum)
+    if prevline =~ '^\k\+.*\\\s*$'
+        return shiftwidth() 
+    endif
+
+    " Continuation of a line that was indented
+    if prevline =~ '\k\+.*\\\s*$'
+        return indent(prevlnum)
+    endif
+
+    " Indent the next line if previous line contained a start of a block
+    " definition ('{' or '(').
+    if prevline =~ '^\k\+[^#]*{}\@!\s*$' " TODO || prevline =~ '^\k\+[^#]*()\@!\s*$'
+        return shiftwidth()
+    endif
+
+    " Match inside of a block
+    if s:IsInBlock(v:lnum)
+        if prevline =~ "^\k\+.*$"
+            return shiftwidth()
+        else
+            return indent(prevlnum)
+        endif
+    endif
+
+    return 0 
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

Git/usr/share/vim/vim81/indent/htmldjango.vim

@@ -0,0 +1,12 @@
+" Vim indent file
+" Language:	Django HTML template
+" Maintainer:	Dave Hodder <dmh@dmh.org.uk>
+" Last Change:	2007 Jan 25
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+
+" Use HTML formatting rules.
+runtime! indent/html.vim

Git/usr/share/vim/vim81/indent/idlang.vim

@@ -0,0 +1,62 @@
+" IDL (Interactive Data Language) indent file.
+" Language: IDL (ft=idlang)
+" Last change:	2017 Jun 13
+" Maintainer: Aleksandar Jelenak <ajelenak AT yahoo.com>
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+   finish
+endif
+let b:did_indent = 1
+
+setlocal indentkeys=o,O,0=endif,0=ENDIF,0=endelse,0=ENDELSE,0=endwhile,0=ENDWHILE,0=endfor,0=ENDFOR,0=endrep,0=ENDREP
+
+setlocal indentexpr=GetIdlangIndent(v:lnum)
+
+" Only define the function once.
+if exists("*GetIdlangIndent")
+   finish
+endif
+
+function GetIdlangIndent(lnum)
+   " First non-empty line above the current line.
+   let pnum = prevnonblank(v:lnum-1)
+   " v:lnum is the first non-empty line -- zero indent.
+   if pnum == 0
+      return 0
+   endif
+   " Second non-empty line above the current line.
+   let pnum2 = prevnonblank(pnum-1)
+
+   " Current indent.
+   let curind = indent(pnum)
+
+   " Indenting of continued lines.
+   if getline(pnum) =~ '\$\s*\(;.*\)\=$'
+      if getline(pnum2) !~ '\$\s*\(;.*\)\=$'
+	 let curind = curind+shiftwidth()
+      endif
+   else
+      if getline(pnum2) =~ '\$\s*\(;.*\)\=$'
+	 let curind = curind-shiftwidth()
+      endif
+   endif
+
+   " Indenting blocks of statements.
+   if getline(v:lnum) =~? '^\s*\(endif\|endelse\|endwhile\|endfor\|endrep\)\>'
+      if getline(pnum) =~? 'begin\>'
+      elseif indent(v:lnum) > curind-shiftwidth()
+	 let curind = curind-shiftwidth()
+      else
+	 return -1
+      endif
+   elseif getline(pnum) =~? 'begin\>'
+      if indent(v:lnum) < curind+shiftwidth()
+	 let curind = curind+shiftwidth()
+      else
+	 return -1
+      endif
+   endif
+   return curind
+endfunction
+

Git/usr/share/vim/vim81/indent/ishd.vim

@@ -0,0 +1,68 @@
+" Description:	InstallShield indenter
+" Author:	Johannes Zellner <johannes@zellner.org>
+" Last Change:	Tue, 27 Apr 2004 14:54:59 CEST
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentexpr=GetIshdIndent(v:lnum)
+setlocal indentkeys&
+setlocal indentkeys+==else,=elseif,=endif,=end,=begin,<:>
+" setlocal indentkeys-=0#
+
+let b:undo_indent = "setl ai< indentexpr< indentkeys<"
+
+" Only define the function once.
+if exists("*GetIshdIndent")
+    finish
+endif
+
+fun! GetIshdIndent(lnum)
+    " labels and preprocessor get zero indent immediately
+    let this_line = getline(a:lnum)
+    let LABELS_OR_PREPROC = '^\s*\(\<\k\+\>:\s*$\|#.*\)'
+    let LABELS_OR_PREPROC_EXCEPT = '^\s*\<default\+\>:'
+    if this_line =~ LABELS_OR_PREPROC && this_line !~ LABELS_OR_PREPROC_EXCEPT
+	return 0
+    endif
+
+    " Find a non-blank line above the current line.
+    " Skip over labels and preprocessor directives.
+    let lnum = a:lnum
+    while lnum > 0
+	let lnum = prevnonblank(lnum - 1)
+	let previous_line = getline(lnum)
+	if previous_line !~ LABELS_OR_PREPROC || previous_line =~ LABELS_OR_PREPROC_EXCEPT
+	    break
+	endif
+    endwhile
+
+    " Hit the start of the file, use zero indent.
+    if lnum == 0
+	return 0
+    endif
+
+    let ind = indent(lnum)
+
+    " Add
+    if previous_line =~ '^\s*\<\(function\|begin\|switch\|case\|default\|if.\{-}then\|else\|elseif\|while\|repeat\)\>'
+	let ind = ind + shiftwidth()
+    endif
+
+    " Subtract
+    if this_line =~ '^\s*\<endswitch\>'
+	let ind = ind - 2 * shiftwidth()
+    elseif this_line =~ '^\s*\<\(begin\|end\|endif\|endwhile\|else\|elseif\|until\)\>'
+	let ind = ind - shiftwidth()
+    elseif this_line =~ '^\s*\<\(case\|default\)\>'
+	if previous_line !~ '^\s*\<switch\>'
+	    let ind = ind - shiftwidth()
+	endif
+    endif
+
+    return ind
+endfun

Git/usr/share/vim/vim81/indent/j.vim

@@ -0,0 +1,50 @@
+" Vim indent file
+" Language:	J
+" Maintainer:	David Bürgin <676c7473@gmail.com>
+" URL:		https://github.com/glts/vim-j
+" Last Change:	2015-01-11
+
+if exists('b:did_indent')
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetJIndent()
+setlocal indentkeys-=0{,0},:,0#
+setlocal indentkeys+=0),0<:>,=case.,=catch.,=catchd.,=catcht.,=do.,=else.,=elseif.,=end.,=fcase.
+
+let b:undo_indent = 'setlocal indentkeys< indentexpr<'
+
+if exists('*GetJIndent')
+  finish
+endif
+
+" If g:j_indent_definitions is true, the bodies of explicit definitions of
+" adverbs, conjunctions, and verbs will be indented. Default is false (0).
+if !exists('g:j_indent_definitions')
+  let g:j_indent_definitions = 0
+endif
+
+function GetJIndent() abort
+  let l:prevlnum = prevnonblank(v:lnum - 1)
+  if l:prevlnum == 0
+    return 0
+  endif
+  let l:indent = indent(l:prevlnum)
+  let l:prevline = getline(l:prevlnum)
+  if l:prevline =~# '^\s*\%(case\|catch[dt]\=\|do\|else\%(if\)\=\|fcase\|for\%(_\a\k*\)\=\|if\|select\|try\|whil\%(e\|st\)\)\.\%(\%(\<end\.\)\@!.\)*$'
+    " Increase indentation after an initial control word that starts or
+    " continues a block and is not terminated by "end."
+    let l:indent += shiftwidth()
+  elseif g:j_indent_definitions && (l:prevline =~# '\<\%([1-4]\|13\|adverb\|conjunction\|verb\|monad\|dyad\)\s\+\%(:\s*0\|def\s\+0\|define\)\>' || l:prevline =~# '^\s*:\s*$')
+    " Increase indentation in explicit definitions of adverbs, conjunctions,
+    " and verbs
+    let l:indent += shiftwidth()
+  endif
+  " Decrease indentation in lines that start with either control words that
+  " continue or end a block, or the special items ")" and ":"
+  if getline(v:lnum) =~# '^\s*\%()\|:\|\%(case\|catch[dt]\=\|do\|else\%(if\)\=\|end\|fcase\)\.\)'
+    let l:indent -= shiftwidth()
+  endif
+  return l:indent
+endfunction

Git/usr/share/vim/vim81/indent/java.vim

@@ -0,0 +1,150 @@
+" Vim indent file
+" Language:	Java
+" Previous Maintainer: Toby Allsopp <toby.allsopp@peace.com>
+" Current Maintainer: Hong Xu <hong@topbug.net>
+" Homepage: http://www.vim.org/scripts/script.php?script_id=3899
+"           https://github.com/xuhdev/indent-java.vim
+" Last Change:	2016 Mar 7
+" Version: 1.1
+" License: Same as Vim.
+" Copyright (c) 2012-2016 Hong Xu
+" Before 2012, this file was maintained by Toby Allsopp.
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+" Indent Java anonymous classes correctly.
+setlocal cindent cinoptions& cinoptions+=j1
+
+" The "extends" and "implements" lines start off with the wrong indent.
+setlocal indentkeys& indentkeys+=0=extends indentkeys+=0=implements
+
+" Set the function to do the work.
+setlocal indentexpr=GetJavaIndent()
+
+let b:undo_indent = "set cin< cino< indentkeys< indentexpr<"
+
+" Only define the function once.
+if exists("*GetJavaIndent")
+  finish
+endif
+
+let s:keepcpo= &cpo
+set cpo&vim
+
+function! SkipJavaBlanksAndComments(startline)
+  let lnum = a:startline
+  while lnum > 1
+    let lnum = prevnonblank(lnum)
+    if getline(lnum) =~ '\*/\s*$'
+      while getline(lnum) !~ '/\*' && lnum > 1
+        let lnum = lnum - 1
+      endwhile
+      if getline(lnum) =~ '^\s*/\*'
+        let lnum = lnum - 1
+      else
+        break
+      endif
+    elseif getline(lnum) =~ '^\s*//'
+      let lnum = lnum - 1
+    else
+      break
+    endif
+  endwhile
+  return lnum
+endfunction
+
+function GetJavaIndent()
+
+  " Java is just like C; use the built-in C indenting and then correct a few
+  " specific cases.
+  let theIndent = cindent(v:lnum)
+
+  " If we're in the middle of a comment then just trust cindent
+  if getline(v:lnum) =~ '^\s*\*'
+    return theIndent
+  endif
+
+  " find start of previous line, in case it was a continuation line
+  let lnum = SkipJavaBlanksAndComments(v:lnum - 1)
+
+  " If the previous line starts with '@', we should have the same indent as
+  " the previous one
+  if getline(lnum) =~ '^\s*@.*$'
+    return indent(lnum)
+  endif
+
+  let prev = lnum
+  while prev > 1
+    let next_prev = SkipJavaBlanksAndComments(prev - 1)
+    if getline(next_prev) !~ ',\s*$'
+      break
+    endif
+    let prev = next_prev
+  endwhile
+
+  " Try to align "throws" lines for methods and "extends" and "implements" for
+  " classes.
+  if getline(v:lnum) =~ '^\s*\(throws\|extends\|implements\)\>'
+        \ && getline(lnum) !~ '^\s*\(throws\|extends\|implements\)\>'
+    let theIndent = theIndent + shiftwidth()
+  endif
+
+  " correct for continuation lines of "throws", "implements" and "extends"
+  let cont_kw = matchstr(getline(prev),
+        \ '^\s*\zs\(throws\|implements\|extends\)\>\ze.*,\s*$')
+  if strlen(cont_kw) > 0
+    let amount = strlen(cont_kw) + 1
+    if getline(lnum) !~ ',\s*$'
+      let theIndent = theIndent - (amount + shiftwidth())
+      if theIndent < 0
+        let theIndent = 0
+      endif
+    elseif prev == lnum
+      let theIndent = theIndent + amount
+      if cont_kw ==# 'throws'
+        let theIndent = theIndent + shiftwidth()
+      endif
+    endif
+  elseif getline(prev) =~ '^\s*\(throws\|implements\|extends\)\>'
+        \ && (getline(prev) =~ '{\s*$'
+        \  || getline(v:lnum) =~ '^\s*{\s*$')
+    let theIndent = theIndent - shiftwidth()
+  endif
+
+  " When the line starts with a }, try aligning it with the matching {,
+  " skipping over "throws", "extends" and "implements" clauses.
+  if getline(v:lnum) =~ '^\s*}\s*\(//.*\|/\*.*\)\=$'
+    call cursor(v:lnum, 1)
+    silent normal! %
+    let lnum = line('.')
+    if lnum < v:lnum
+      while lnum > 1
+        let next_lnum = SkipJavaBlanksAndComments(lnum - 1)
+        if getline(lnum) !~ '^\s*\(throws\|extends\|implements\)\>'
+              \ && getline(next_lnum) !~ ',\s*$'
+          break
+        endif
+        let lnum = prevnonblank(next_lnum)
+      endwhile
+      return indent(lnum)
+    endif
+  endif
+
+  " Below a line starting with "}" never indent more.  Needed for a method
+  " below a method with an indented "throws" clause.
+  let lnum = SkipJavaBlanksAndComments(v:lnum - 1)
+  if getline(lnum) =~ '^\s*}\s*\(//.*\|/\*.*\)\=$' && indent(lnum) < theIndent
+    let theIndent = indent(lnum)
+  endif
+
+  return theIndent
+endfunction
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+" vi: sw=2 et

Git/usr/share/vim/vim81/indent/javascript.vim

@@ -0,0 +1,480 @@
+" Vim indent file
+" Language: Javascript
+" Maintainer: Chris Paul ( https://github.com/bounceme )
+" URL: https://github.com/pangloss/vim-javascript
+" Last Change: December 4, 2017
+
+" Only load this indent file when no other was loaded.
+if exists('b:did_indent')
+  finish
+endif
+let b:did_indent = 1
+
+" Now, set up our indentation expression and keys that trigger it.
+setlocal indentexpr=GetJavascriptIndent()
+setlocal autoindent nolisp nosmartindent
+setlocal indentkeys+=0],0)
+" Testable with something like:
+" vim  -eNs "+filetype plugin indent on" "+syntax on" "+set ft=javascript" \
+"       "+norm! gg=G" '+%print' '+:q!' testfile.js \
+"       | diff -uBZ testfile.js -
+
+let b:undo_indent = 'setlocal indentexpr< smartindent< autoindent< indentkeys<'
+
+" Only define the function once.
+if exists('*GetJavascriptIndent')
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+" indent correctly if inside <script>
+" vim/vim@690afe1 for the switch from cindent
+" overridden with b:html_indent_script1
+call extend(g:,{'html_indent_script1': 'inc'},'keep')
+
+" Regex of syntax group names that are or delimit string or are comments.
+let s:bvars = {
+      \ 'syng_strcom': 'string\|comment\|regex\|special\|doc\|template\%(braces\)\@!',
+      \ 'syng_str': 'string\|template\|special' }
+" template strings may want to be excluded when editing graphql:
+" au! Filetype javascript let b:syng_str = '^\%(.*template\)\@!.*string\|special'
+" au! Filetype javascript let b:syng_strcom = '^\%(.*template\)\@!.*string\|comment\|regex\|special\|doc'
+
+function s:GetVars()
+  call extend(b:,extend(s:bvars,{'js_cache': [0,0,0]}),'keep')
+endfunction
+
+" Get shiftwidth value
+if exists('*shiftwidth')
+  function s:sw()
+    return shiftwidth()
+  endfunction
+else
+  function s:sw()
+    return &l:shiftwidth ? &l:shiftwidth : &l:tabstop
+  endfunction
+endif
+
+" Performance for forwards search(): start search at pos rather than masking
+" matches before pos.
+let s:z = has('patch-7.4.984') ? 'z' : ''
+
+" Expression used to check whether we should skip a match with searchpair().
+let s:skip_expr = "s:SynAt(line('.'),col('.')) =~? b:syng_strcom"
+let s:in_comm = s:skip_expr[:-14] . "'comment\\|doc'"
+
+let s:rel = has('reltime')
+" searchpair() wrapper
+if s:rel
+  function s:GetPair(start,end,flags,skip)
+    return searchpair('\m'.a:start,'','\m'.a:end,a:flags,a:skip,s:l1,a:skip ==# 's:SkipFunc()' ? 2000 : 200)
+  endfunction
+else
+  function s:GetPair(start,end,flags,skip)
+    return searchpair('\m'.a:start,'','\m'.a:end,a:flags,a:skip,s:l1)
+  endfunction
+endif
+
+function s:SynAt(l,c)
+  let byte = line2byte(a:l) + a:c - 1
+  let pos = index(s:synid_cache[0], byte)
+  if pos == -1
+    let s:synid_cache[:] += [[byte], [synIDattr(synID(a:l, a:c, 0), 'name')]]
+  endif
+  return s:synid_cache[1][pos]
+endfunction
+
+function s:ParseCino(f)
+  let [divider, n, cstr] = [0] + matchlist(&cino,
+        \ '\%(.*,\)\=\%(\%d'.char2nr(a:f).'\(-\)\=\([.s0-9]*\)\)\=')[1:2]
+  for c in split(cstr,'\zs')
+    if c == '.' && !divider
+      let divider = 1
+    elseif c ==# 's'
+      if n !~ '\d'
+        return n . s:sw() + 0
+      endif
+      let n = str2nr(n) * s:sw()
+      break
+    else
+      let [n, divider] .= [c, 0]
+    endif
+  endfor
+  return str2nr(n) / max([str2nr(divider),1])
+endfunction
+
+" Optimized {skip} expr, only callable from the search loop which
+" GetJavascriptIndent does to find the containing [[{(] (side-effects)
+function s:SkipFunc()
+  if s:top_col == 1
+    throw 'out of bounds'
+  elseif s:check_in
+    if eval(s:skip_expr)
+      return 1
+    endif
+    let s:check_in = 0
+  elseif getline('.') =~ '\%<'.col('.').'c\/.\{-}\/\|\%>'.col('.').'c[''"]\|\\$'
+    if eval(s:skip_expr)
+      return 1
+    endif
+  elseif search('\m`\|\${\|\*\/','nW'.s:z,s:looksyn)
+    if eval(s:skip_expr)
+      let s:check_in = 1
+      return 1
+    endif
+  else
+    let s:synid_cache[:] += [[line2byte('.') + col('.') - 1], ['']]
+  endif
+  let [s:looksyn, s:top_col] = getpos('.')[1:2]
+endfunction
+
+function s:AlternatePair()
+  let [pat, l:for] = ['[][(){};]', 2]
+  while s:SearchLoop(pat,'bW','s:SkipFunc()')
+    if s:LookingAt() == ';'
+      if !l:for
+        if s:GetPair('{','}','bW','s:SkipFunc()')
+          return
+        endif
+        break
+      else
+        let [pat, l:for] = ['[{}();]', l:for - 1]
+      endif
+    else
+      let idx = stridx('])}',s:LookingAt())
+      if idx == -1
+        return
+      elseif !s:GetPair(['\[','(','{'][idx],'])}'[idx],'bW','s:SkipFunc()')
+        break
+      endif
+    endif
+  endwhile
+  throw 'out of bounds'
+endfunction
+
+function s:Nat(int)
+  return a:int * (a:int > 0)
+endfunction
+
+function s:LookingAt()
+  return getline('.')[col('.')-1]
+endfunction
+
+function s:Token()
+  return s:LookingAt() =~ '\k' ? expand('<cword>') : s:LookingAt()
+endfunction
+
+function s:PreviousToken(...)
+  let [l:pos, tok] = [getpos('.'), '']
+  if search('\m\k\{1,}\|\S','ebW')
+    if getline('.')[col('.')-2:col('.')-1] == '*/'
+      if eval(s:in_comm) && !s:SearchLoop('\S\ze\_s*\/[/*]','bW',s:in_comm)
+        call setpos('.',l:pos)
+      else
+        let tok = s:Token()
+      endif
+    else
+      let two = a:0 || line('.') != l:pos[1] ? strridx(getline('.')[:col('.')],'//') + 1 : 0
+      if two && eval(s:in_comm)
+        call cursor(0,two)
+        let tok = s:PreviousToken(1)
+        if tok is ''
+          call setpos('.',l:pos)
+        endif
+      else
+        let tok = s:Token()
+      endif
+    endif
+  endif
+  return tok
+endfunction
+
+function s:Pure(f,...)
+  return eval("[call(a:f,a:000),cursor(a:firstline,".col('.').")][0]")
+endfunction
+
+function s:SearchLoop(pat,flags,expr)
+  return s:GetPair(a:pat,'\_$.',a:flags,a:expr)
+endfunction
+
+function s:ExprCol()
+  if getline('.')[col('.')-2] == ':'
+    return 1
+  endif
+  let bal = 0
+  while s:SearchLoop('[{}?:]','bW',s:skip_expr)
+    if s:LookingAt() == ':'
+      if getline('.')[col('.')-2] == ':'
+        call cursor(0,col('.')-1)
+        continue
+      endif
+      let bal -= 1
+    elseif s:LookingAt() == '?'
+      if getline('.')[col('.'):col('.')+1] =~ '^\.\d\@!'
+        continue
+      elseif !bal
+        return 1
+      endif
+      let bal += 1
+    elseif s:LookingAt() == '{'
+      return !s:IsBlock()
+    elseif !s:GetPair('{','}','bW',s:skip_expr)
+      break
+    endif
+  endwhile
+endfunction
+
+" configurable regexes that define continuation lines, not including (, {, or [.
+let s:opfirst = '^' . get(g:,'javascript_opfirst',
+      \ '\C\%([<>=,.?^%|/&]\|\([-:+]\)\1\@!\|\*\+\|!=\|in\%(stanceof\)\=\>\)')
+let s:continuation = get(g:,'javascript_continuation',
+      \ '\C\%([<=,.~!?/*^%|&:]\|+\@<!+\|-\@<!-\|=\@<!>\|\<\%(typeof\|new\|delete\|void\|in\|instanceof\|await\)\)') . '$'
+
+function s:Continues()
+  let tok = matchstr(strpart(getline('.'),col('.')-15,15),s:continuation)
+  if tok =~ '[a-z:]'
+    return tok == ':' ? s:ExprCol() : s:PreviousToken() != '.'
+  elseif tok !~ '[/>]'
+    return tok isnot ''
+  endif
+  return s:SynAt(line('.'),col('.')) !~? (tok == '>' ? 'jsflow\|^html' : 'regex')
+endfunction
+
+" Check if line 'lnum' has a balanced amount of parentheses.
+function s:Balanced(lnum,line)
+  let l:open = 0
+  let pos = match(a:line, '[][(){}]')
+  while pos != -1
+    if s:SynAt(a:lnum,pos + 1) !~? b:syng_strcom
+      let l:open += match(' ' . a:line[pos],'[[({]')
+      if l:open < 0
+        return
+      endif
+    endif
+    let pos = match(a:line, !l:open ? '[][(){}]' : '()' =~ a:line[pos] ?
+          \ '[()]' : '{}' =~ a:line[pos] ? '[{}]' : '[][]', pos + 1)
+  endwhile
+  return !l:open
+endfunction
+
+function s:OneScope()
+  if s:LookingAt() == ')' && s:GetPair('(', ')', 'bW', s:skip_expr)
+    let tok = s:PreviousToken()
+    return (count(split('for if let while with'),tok) ||
+          \ tok =~# '^await$\|^each$' && s:PreviousToken() ==# 'for') &&
+          \ s:Pure('s:PreviousToken') != '.' && !(tok == 'while' && s:DoWhile())
+  elseif s:Token() =~# '^else$\|^do$'
+    return s:Pure('s:PreviousToken') != '.'
+  elseif strpart(getline('.'),col('.')-2,2) == '=>'
+    call cursor(0,col('.')-1)
+    if s:PreviousToken() == ')'
+      return s:GetPair('(', ')', 'bW', s:skip_expr)
+    endif
+    return 1
+  endif
+endfunction
+
+function s:DoWhile()
+  let cpos = searchpos('\m\<','cbW')
+  while s:SearchLoop('\C[{}]\|\<\%(do\|while\)\>','bW',s:skip_expr)
+    if s:LookingAt() =~ '\a'
+      if s:Pure('s:IsBlock')
+        if s:LookingAt() ==# 'd'
+          return 1
+        endif
+        break
+      endif
+    elseif s:LookingAt() != '}' || !s:GetPair('{','}','bW',s:skip_expr)
+      break
+    endif
+  endwhile
+  call call('cursor',cpos)
+endfunction
+
+" returns total offset from braceless contexts. 'num' is the lineNr which
+" encloses the entire context, 'cont' if whether a:firstline is a continued
+" expression, which could have started in a braceless context
+function s:IsContOne(cont)
+  let [l:num, b_l] = [b:js_cache[1] + !b:js_cache[1], 0]
+  let pind = b:js_cache[1] ? indent(b:js_cache[1]) + s:sw() : 0
+  let ind = indent('.') + !a:cont
+  while line('.') > l:num && ind > pind || line('.') == l:num
+    if indent('.') < ind && s:OneScope()
+      let b_l += 1
+    elseif !a:cont || b_l || ind < indent(a:firstline)
+      break
+    else
+      call cursor(0,1)
+    endif
+    let ind = min([ind, indent('.')])
+    if s:PreviousToken() is ''
+      break
+    endif
+  endwhile
+  return b_l
+endfunction
+
+function s:IsSwitch()
+  call call('cursor',b:js_cache[1:])
+  return search('\m\C\%#.\_s*\%(\%(\/\/.*\_$\|\/\*\_.\{-}\*\/\)\@>\_s*\)*\%(case\|default\)\>','nWc'.s:z)
+endfunction
+
+" https://github.com/sweet-js/sweet.js/wiki/design#give-lookbehind-to-the-reader
+function s:IsBlock()
+  let tok = s:PreviousToken()
+  if join(s:stack) =~? 'xml\|jsx' && s:SynAt(line('.'),col('.')-1) =~? 'xml\|jsx'
+    let s:in_jsx = 1
+    return tok != '{'
+  elseif tok =~ '\k'
+    if tok ==# 'type'
+      return s:Pure('eval',"s:PreviousToken() !~# '^\\%(im\\|ex\\)port$' || s:PreviousToken() == '.'")
+    elseif tok ==# 'of'
+      return s:Pure('eval',"!s:GetPair('[[({]','[])}]','bW',s:skip_expr) || s:LookingAt() != '(' ||"
+            \ ."s:{s:PreviousToken() ==# 'await' ? 'Previous' : ''}Token() !=# 'for' || s:PreviousToken() == '.'")
+    endif
+    return index(split('return const let import export extends yield default delete var await void typeof throw case new in instanceof')
+          \ ,tok) < (line('.') != a:firstline) || s:Pure('s:PreviousToken') == '.'
+  elseif tok == '>'
+    return getline('.')[col('.')-2] == '=' || s:SynAt(line('.'),col('.')) =~? 'jsflow\|^html'
+  elseif tok == '*'
+    return s:Pure('s:PreviousToken') == ':'
+  elseif tok == ':'
+    return s:Pure('eval',"s:PreviousToken() =~ '^\\K\\k*$' && !s:ExprCol()")
+  elseif tok == '/'
+    return s:SynAt(line('.'),col('.')) =~? 'regex'
+  elseif tok !~ '[=~!<,.?^%|&([]'
+    return tok !~ '[-+]' || line('.') != a:firstline && getline('.')[col('.')-2] == tok
+  endif
+endfunction
+
+function GetJavascriptIndent()
+  call s:GetVars()
+  let s:synid_cache = [[],[]]
+  let l:line = getline(v:lnum)
+  " use synstack as it validates syn state and works in an empty line
+  let s:stack = [''] + map(synstack(v:lnum,1),"synIDattr(v:val,'name')")
+
+  " start with strings,comments,etc.
+  if s:stack[-1] =~? 'comment\|doc'
+    if l:line =~ '^\s*\*'
+      return cindent(v:lnum)
+    elseif l:line !~ '^\s*\/[/*]'
+      return -1
+    endif
+  elseif s:stack[-1] =~? b:syng_str
+    if b:js_cache[0] == v:lnum - 1 && s:Balanced(v:lnum-1,getline(v:lnum-1))
+      let b:js_cache[0] = v:lnum
+    endif
+    return -1
+  endif
+
+  let s:l1 = max([0,prevnonblank(v:lnum) - (s:rel ? 2000 : 1000),
+        \ get(get(b:,'hi_indent',{}),'blocklnr')])
+  call cursor(v:lnum,1)
+  if s:PreviousToken() is ''
+    return
+  endif
+  let [l:lnum, pline] = [line('.'), getline('.')[:col('.')-1]]
+
+  let l:line = substitute(l:line,'^\s*','','')
+  let l:line_raw = l:line
+  if l:line[:1] == '/*'
+    let l:line = substitute(l:line,'^\%(\/\*.\{-}\*\/\s*\)*','','')
+  endif
+  if l:line =~ '^\/[/*]'
+    let l:line = ''
+  endif
+
+  " the containing paren, bracket, or curly. Many hacks for performance
+  call cursor(v:lnum,1)
+  let idx = index([']',')','}'],l:line[0])
+  if b:js_cache[0] > l:lnum && b:js_cache[0] < v:lnum ||
+        \ b:js_cache[0] == l:lnum && s:Balanced(l:lnum,pline)
+    call call('cursor',b:js_cache[1:])
+  else
+    let [s:looksyn, s:top_col, s:check_in, s:l1] = [v:lnum - 1,0,0,
+          \ max([s:l1, &smc ? search('\m^.\{'.&smc.',}','nbW',s:l1 + 1) + 1 : 0])]
+    try
+      if idx != -1
+        call s:GetPair(['\[','(','{'][idx],'])}'[idx],'bW','s:SkipFunc()')
+      elseif getline(v:lnum) !~ '^\S' && s:stack[-1] =~? 'block\|^jsobject$'
+        call s:GetPair('{','}','bW','s:SkipFunc()')
+      else
+        call s:AlternatePair()
+      endif
+    catch /^\Cout of bounds$/
+      call cursor(v:lnum,1)
+    endtry
+    let b:js_cache[1:] = line('.') == v:lnum ? [0,0] : getpos('.')[1:2]
+  endif
+
+  let [b:js_cache[0], num] = [v:lnum, b:js_cache[1]]
+
+  let [num_ind, is_op, b_l, l:switch_offset, s:in_jsx] = [s:Nat(indent(num)),0,0,0,0]
+  if !num || s:LookingAt() == '{' && s:IsBlock()
+    let ilnum = line('.')
+    if num && !s:in_jsx && s:LookingAt() == ')' && s:GetPair('(',')','bW',s:skip_expr)
+      if ilnum == num
+        let [num, num_ind] = [line('.'), indent('.')]
+      endif
+      if idx == -1 && s:PreviousToken() ==# 'switch' && s:IsSwitch()
+        let l:switch_offset = &cino !~ ':' ? s:sw() : s:ParseCino(':')
+        if pline[-1:] != '.' && l:line =~# '^\%(default\|case\)\>'
+          return s:Nat(num_ind + l:switch_offset)
+        elseif &cino =~ '='
+          let l:case_offset = s:ParseCino('=')
+        endif
+      endif
+    endif
+    if idx == -1 && pline[-1:] !~ '[{;]'
+      call cursor(l:lnum, len(pline))
+      let sol = matchstr(l:line,s:opfirst)
+      if sol is '' || sol == '/' && s:SynAt(v:lnum,
+            \ 1 + len(getline(v:lnum)) - len(l:line)) =~? 'regex'
+        if s:Continues()
+          let is_op = s:sw()
+        endif
+      elseif num && sol =~# '^\%(in\%(stanceof\)\=\|\*\)$' &&
+            \ s:LookingAt() == '}' && s:GetPair('{','}','bW',s:skip_expr) &&
+            \ s:PreviousToken() == ')' && s:GetPair('(',')','bW',s:skip_expr) &&
+            \ (s:PreviousToken() == ']' || s:LookingAt() =~ '\k' &&
+            \ s:{s:PreviousToken() == '*' ? 'Previous' : ''}Token() !=# 'function')
+        return num_ind + s:sw()
+      else
+        let is_op = s:sw()
+      endif
+      call cursor(l:lnum, len(pline))
+      let b_l = s:Nat(s:IsContOne(is_op) - (!is_op && l:line =~ '^{')) * s:sw()
+    endif
+  elseif idx.s:LookingAt().&cino =~ '^-1(.*(' && (search('\m\S','nbW',num) || s:ParseCino('U'))
+    let pval = s:ParseCino('(')
+    if !pval
+      let [Wval, vcol] = [s:ParseCino('W'), virtcol('.')]
+      if search('\m\S','W',num)
+        return s:ParseCino('w') ? vcol : virtcol('.')-1
+      endif
+      return Wval ? s:Nat(num_ind + Wval) : vcol
+    endif
+    return s:Nat(num_ind + pval + searchpair('\m(','','\m)','nbrmW',s:skip_expr,num) * s:sw())
+  endif
+
+  " main return
+  if l:line =~ '^[])}]\|^|}'
+    if l:line_raw[0] == ')'
+      if s:ParseCino('M')
+        return indent(l:lnum)
+      elseif num && &cino =~# 'm' && !s:ParseCino('m')
+        return virtcol('.') - 1
+      endif
+    endif
+    return num_ind
+  elseif num
+    return s:Nat(num_ind + get(l:,'case_offset',s:sw()) + l:switch_offset + b_l + is_op)
+  endif
+  return b_l + is_op
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

Git/usr/share/vim/vim81/indent/json.vim

@@ -0,0 +1,168 @@
+" Vim indent file
+" Language:		JSON
+" Mantainer:		Eli Parra <eli@elzr.com> https://github.com/elzr/vim-json
+" Last Change:          2017 Jun 13
+"   https://github.com/jakar/vim-json/commit/20b650e22aa750c4ab6a66aa646bdd95d7cd548a#diff-e81fc111b2052e306d126bd9989f7b7c
+" Original Author:	Rogerz Zhang <rogerz.zhang at gmail.com> http://github.com/rogerz/vim-json
+" Acknowledgement:      Based off of vim-javascript maintained by Darrick Wiebe 
+"                       http://www.vim.org/scripts/script.php?script_id=2765
+
+" 0. Initialization {{{1
+" =================
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal nosmartindent
+
+" Now, set up our indentation expression and keys that trigger it.
+setlocal indentexpr=GetJSONIndent()
+setlocal indentkeys=0{,0},0),0[,0],!^F,o,O,e
+
+" Only define the function once.
+if exists("*GetJSONIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+" 1. Variables {{{1
+" ============
+
+let s:line_term = '\s*\%(\%(\/\/\).*\)\=$'
+" Regex that defines blocks.
+let s:block_regex = '\%({\)\s*\%(|\%([*@]\=\h\w*,\=\s*\)\%(,\s*[*@]\=\h\w*\)*|\)\=' . s:line_term
+
+" 2. Auxiliary Functions {{{1
+" ======================
+
+" Check if the character at lnum:col is inside a string.
+function s:IsInString(lnum, col)
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') == 'jsonString'
+endfunction
+
+" Find line above 'lnum' that isn't empty, or in a string.
+function s:PrevNonBlankNonString(lnum)
+  let lnum = prevnonblank(a:lnum)
+  while lnum > 0
+    " If the line isn't empty or in a string, end search.
+    let line = getline(lnum)
+    if !(s:IsInString(lnum, 1) && s:IsInString(lnum, strlen(line)))
+      break
+    endif
+    let lnum = prevnonblank(lnum - 1)
+  endwhile
+  return lnum
+endfunction
+
+" Check if line 'lnum' has more opening brackets than closing ones.
+function s:LineHasOpeningBrackets(lnum)
+  let open_0 = 0
+  let open_2 = 0
+  let open_4 = 0
+  let line = getline(a:lnum)
+  let pos = match(line, '[][(){}]', 0)
+  while pos != -1
+    let idx = stridx('(){}[]', line[pos])
+    if idx % 2 == 0
+      let open_{idx} = open_{idx} + 1
+    else
+      let open_{idx - 1} = open_{idx - 1} - 1
+    endif
+    let pos = match(line, '[][(){}]', pos + 1)
+  endwhile
+  return (open_0 > 0) . (open_2 > 0) . (open_4 > 0)
+endfunction
+
+function s:Match(lnum, regex)
+  let col = match(getline(a:lnum), a:regex) + 1
+  return col > 0 && !s:IsInString(a:lnum, col) ? col : 0
+endfunction
+
+" 3. GetJSONIndent Function {{{1
+" =========================
+
+function GetJSONIndent()
+  " 3.1. Setup {{{2
+  " ----------
+
+  " Set up variables for restoring position in file.  Could use v:lnum here.
+  let vcol = col('.')
+
+  " 3.2. Work on the current line {{{2
+  " -----------------------------
+
+  " Get the current line.
+  let line = getline(v:lnum)
+  let ind = -1
+
+  " If we got a closing bracket on an empty line, find its match and indent
+  " according to it.
+  let col = matchend(line, '^\s*[]}]')
+
+  if col > 0 && !s:IsInString(v:lnum, col)
+    call cursor(v:lnum, col)
+    let bs = strpart('{}[]', stridx('}]', line[col - 1]) * 2, 2)
+
+    let pairstart = escape(bs[0], '[')
+    let pairend = escape(bs[1], ']')
+    let pairline = searchpair(pairstart, '', pairend, 'bW')
+
+    if pairline > 0 
+      let ind = indent(pairline)
+    else
+      let ind = virtcol('.') - 1
+    endif
+
+    return ind
+  endif
+
+  " If we are in a multi-line string, don't do anything to it.
+  if s:IsInString(v:lnum, matchend(line, '^\s*') + 1)
+    return indent('.')
+  endif
+
+  " 3.3. Work on the previous line. {{{2
+  " -------------------------------
+
+  let lnum = prevnonblank(v:lnum - 1)
+
+  if lnum == 0
+    return 0
+  endif
+
+  " Set up variables for current line.
+  let line = getline(lnum)
+  let ind = indent(lnum)
+
+  " If the previous line ended with a block opening, add a level of indent.
+  " if s:Match(lnum, s:block_regex)
+    " return indent(lnum) + shiftwidth()
+  " endif
+
+  " If the previous line contained an opening bracket, and we are still in it,
+  " add indent depending on the bracket type.
+  if line =~ '[[({]'
+    let counts = s:LineHasOpeningBrackets(lnum)
+    if counts[0] == '1' || counts[1] == '1' || counts[2] == '1'
+      return ind + shiftwidth()
+    else
+      call cursor(v:lnum, vcol)
+    end
+  endif
+
+  " }}}2
+
+  return ind
+endfunction
+
+" }}}1
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim:set sw=2 sts=2 ts=8 noet:

Git/usr/share/vim/vim81/indent/jsp.vim

@@ -0,0 +1,17 @@
+" Vim filetype indent file
+" Language:    JSP files
+" Maintainer:  David Fishburn <fishburn@ianywhere.com>
+" Version:     1.0
+" Last Change: Wed Nov 08 2006 11:08:05 AM
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+
+" If there has been no specific JSP indent script created, 
+" use the default html indent script which will handle
+" html, javascript and most of the JSP constructs.
+runtime! indent/html.vim
+
+

Git/usr/share/vim/vim81/indent/ld.vim

@@ -0,0 +1,84 @@
+" Vim indent file
+" Language:             ld(1) script
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2006-12-20
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetLDIndent()
+setlocal indentkeys=0{,0},!^F,o,O
+setlocal nosmartindent
+
+if exists("*GetLDIndent")
+  finish
+endif
+
+function s:prevnonblanknoncomment(lnum)
+  let lnum = a:lnum
+  while lnum > 1
+    let lnum = prevnonblank(lnum)
+    let line = getline(lnum)
+    if line =~ '\*/'
+      while lnum > 1 && line !~ '/\*'
+        let lnum -= 1
+      endwhile
+      if line =~ '^\s*/\*'
+        let lnum -= 1
+      else
+        break
+      endif
+    else
+      break
+    endif
+  endwhile
+  return lnum
+endfunction
+
+function s:count_braces(lnum, count_open)
+  let n_open = 0
+  let n_close = 0
+  let line = getline(a:lnum)
+  let pattern = '[{}]'
+  let i = match(line, pattern)
+  while i != -1
+    if synIDattr(synID(a:lnum, i + 1, 0), 'name') !~ 'ld\%(Comment\|String\)'
+      if line[i] == '{'
+        let n_open += 1
+      elseif line[i] == '}'
+        if n_open > 0
+          let n_open -= 1
+        else
+          let n_close += 1
+        endif
+      endif
+    endif
+    let i = match(line, pattern, i + 1)
+  endwhile
+  return a:count_open ? n_open : n_close
+endfunction
+
+function GetLDIndent()
+  let line = getline(v:lnum)
+  if line =~ '^\s*\*'
+    return cindent(v:lnum)
+  elseif line =~ '^\s*}'
+    return indent(v:lnum) - shiftwidth()
+  endif
+
+  let pnum = s:prevnonblanknoncomment(v:lnum - 1)
+  if pnum == 0
+    return 0
+  endif
+
+  let ind = indent(pnum) + s:count_braces(pnum, 1) * shiftwidth()
+
+  let pline = getline(pnum)
+  if pline =~ '}\s*$'
+    let ind -= (s:count_braces(pnum, 0) - (pline =~ '^\s*}' ? 1 : 0)) * shiftwidth()
+  endif
+
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/less.vim

@@ -0,0 +1,13 @@
+" Vim indent file
+" Language:	less
+" Maintainer:	Alessandro Vioni <jenoma@gmail.com>
+" URL: https://github.com/genoma/vim-less
+" Last Change:	2014 November 24
+
+if exists("b:did_indent")
+  finish
+endif
+
+runtime! indent/css.vim
+
+" vim:set sw=2:

Git/usr/share/vim/vim81/indent/lifelines.vim

@@ -0,0 +1,24 @@
+" Vim indent file
+" Language:	LifeLines
+" Maintainer:	Patrick Texier <p.texier@orsennes.com>
+" Location:	<http://patrick.texier.free.fr/vim/indent/lifelines.vim>
+" Last Change:	2010 May 7
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+" LifeLines uses cindent without ; line terminator, C functions
+" declarations, C keywords, C++ formating
+setlocal cindent
+setlocal cinwords=""
+setlocal cinoptions+=+0
+setlocal cinoptions+=p0
+setlocal cinoptions+=i0
+setlocal cinoptions+=t0
+setlocal cinoptions+=*500
+
+let b:undo_indent = "setl cin< cino< cinw<"
+" vim: ts=8 sw=4

Git/usr/share/vim/vim81/indent/liquid.vim

@@ -0,0 +1,63 @@
+" Vim indent file
+" Language:     Liquid
+" Maintainer:   Tim Pope <vimNOSPAM@tpope.org>
+" Last Change:	2017 Jun 13
+
+if exists('b:did_indent')
+  finish
+endif
+
+set indentexpr=
+if exists('b:liquid_subtype')
+  exe 'runtime! indent/'.b:liquid_subtype.'.vim'
+else
+  runtime! indent/html.vim
+endif
+unlet! b:did_indent
+
+if &l:indentexpr == ''
+  if &l:cindent
+    let &l:indentexpr = 'cindent(v:lnum)'
+  else
+    let &l:indentexpr = 'indent(prevnonblank(v:lnum-1))'
+  endif
+endif
+let b:liquid_subtype_indentexpr = &l:indentexpr
+
+let b:did_indent = 1
+
+setlocal indentexpr=GetLiquidIndent()
+setlocal indentkeys=o,O,*<Return>,<>>,{,},0),0],o,O,!^F,=end,=endif,=endunless,=endifchanged,=endcase,=endfor,=endtablerow,=endcapture,=else,=elsif,=when,=empty
+
+" Only define the function once.
+if exists('*GetLiquidIndent')
+  finish
+endif
+
+function! s:count(string,pattern)
+  let string = substitute(a:string,'\C'.a:pattern,"\n",'g')
+  return strlen(substitute(string,"[^\n]",'','g'))
+endfunction
+
+function! GetLiquidIndent(...)
+  if a:0 && a:1 == '.'
+    let v:lnum = line('.')
+  elseif a:0 && a:1 =~ '^\d'
+    let v:lnum = a:1
+  endif
+  let vcol = col('.')
+  call cursor(v:lnum,1)
+  exe "let ind = ".b:liquid_subtype_indentexpr
+  let lnum = prevnonblank(v:lnum-1)
+  let line = getline(lnum)
+  let cline = getline(v:lnum)
+  let line  = substitute(line,'\C^\%(\s*{%\s*end\w*\s*%}\)\+','','')
+  let line .= matchstr(cline,'\C^\%(\s*{%\s*end\w*\s*%}\)\+')
+  let cline = substitute(cline,'\C^\%(\s*{%\s*end\w*\s*%}\)\+','','')
+  let sw = shiftwidth()
+  let ind += sw * s:count(line,'{%\s*\%(if\|elsif\|else\|unless\|ifchanged\|case\|when\|for\|empty\|tablerow\|capture\)\>')
+  let ind -= sw * s:count(line,'{%\s*end\%(if\|unless\|ifchanged\|case\|for\|tablerow\|capture\)\>')
+  let ind -= sw * s:count(cline,'{%\s*\%(elsif\|else\|when\|empty\)\>')
+  let ind -= sw * s:count(cline,'{%\s*end\w*$')
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/lisp.vim

@@ -0,0 +1,15 @@
+" Vim indent file
+" Language:	Lisp
+" Maintainer:    Sergey Khorev <sergey.khorev@gmail.com>
+" URL:		 http://sites.google.com/site/khorser/opensource/vim
+" Last Change:	2012 Jan 10
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+   finish
+endif
+let b:did_indent = 1
+
+setlocal ai nosi
+
+let b:undo_indent = "setl ai< si<"

Git/usr/share/vim/vim81/indent/logtalk.vim

@@ -0,0 +1,64 @@
+"  Maintainer:	Paulo Moura <pmoura@logtalk.org>
+"  Revised on:	2018.08.04
+"  Language:	Logtalk
+
+" This Logtalk indent file is a modified version of the Prolog
+" indent file written by Gergely Kontra
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+	finish
+endif
+
+let b:did_indent = 1
+
+setlocal indentexpr=GetLogtalkIndent()
+setlocal indentkeys-=:,0#
+setlocal indentkeys+=0%,-,0;,>,0)
+
+" Only define the function once.
+if exists("*GetLogtalkIndent")
+	finish
+endif
+
+function! GetLogtalkIndent()
+	" Find a non-blank line above the current line.
+	let pnum = prevnonblank(v:lnum - 1)
+	" Hit the start of the file, use zero indent.
+	if pnum == 0
+		return 0
+	endif
+	let line = getline(v:lnum)
+	let pline = getline(pnum)
+
+	let ind = indent(pnum)
+	" Previous line was comment -> use previous line's indent
+	if pline =~ '^\s*%'
+		retu ind
+	endif
+	" Check for entity opening directive on previous line
+	if pline =~ '^\s*:-\s\(object\|protocol\|category\)\ze(.*,$'
+		let ind = ind + shiftwidth()
+	" Check for clause head on previous line
+	elseif pline =~ ':-\s*\(%.*\)\?$'
+		let ind = ind + shiftwidth()
+	" Check for grammar rule head on previous line
+	elseif pline =~ '-->\s*\(%.*\)\?$'
+		let ind = ind + shiftwidth()
+	" Check for entity closing directive on previous line
+	elseif pline =~ '^\s*:-\send_\(object\|protocol\|category\)\.\(%.*\)\?$'
+		let ind = ind - shiftwidth()
+	" Check for end of clause on previous line
+	elseif pline =~ '\.\s*\(%.*\)\?$'
+		let ind = ind - shiftwidth()
+	endif
+	" Check for opening conditional on previous line
+	if pline =~ '^\s*\([(;]\|->\)' && pline !~ '\.\s*\(%.*\)\?$' && pline !~ '^.*\([)][,]\s*\(%.*\)\?$\)'
+		let ind = ind + shiftwidth()
+	endif
+	" Check for closing an unclosed paren, or middle ; or ->
+	if line =~ '^\s*\([);]\|->\)'
+		let ind = ind - shiftwidth()
+	endif
+	return ind
+endfunction

Git/usr/share/vim/vim81/indent/lua.vim

@@ -0,0 +1,63 @@
+" Vim indent file
+" Language:	Lua script
+" Maintainer:	Marcus Aurelius Farias <marcus.cf 'at' bol.com.br>
+" First Author:	Max Ischenko <mfi 'at' ukr.net>
+" Last Change:	2017 Jun 13
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetLuaIndent()
+
+" To make Vim call GetLuaIndent() when it finds '\s*end' or '\s*until'
+" on the current line ('else' is default and includes 'elseif').
+setlocal indentkeys+=0=end,0=until
+
+setlocal autoindent
+
+" Only define the function once.
+if exists("*GetLuaIndent")
+  finish
+endif
+
+function! GetLuaIndent()
+  " Find a non-blank line above the current line.
+  let prevlnum = prevnonblank(v:lnum - 1)
+
+  " Hit the start of the file, use zero indent.
+  if prevlnum == 0
+    return 0
+  endif
+
+  " Add a 'shiftwidth' after lines that start a block:
+  " 'function', 'if', 'for', 'while', 'repeat', 'else', 'elseif', '{'
+  let ind = indent(prevlnum)
+  let prevline = getline(prevlnum)
+  let midx = match(prevline, '^\s*\%(if\>\|for\>\|while\>\|repeat\>\|else\>\|elseif\>\|do\>\|then\>\)')
+  if midx == -1
+    let midx = match(prevline, '{\s*$')
+    if midx == -1
+      let midx = match(prevline, '\<function\>\s*\%(\k\|[.:]\)\{-}\s*(')
+    endif
+  endif
+
+  if midx != -1
+    " Add 'shiftwidth' if what we found previously is not in a comment and
+    " an "end" or "until" is not present on the same line.
+    if synIDattr(synID(prevlnum, midx + 1, 1), "name") != "luaComment" && prevline !~ '\<end\>\|\<until\>'
+      let ind = ind + shiftwidth()
+    endif
+  endif
+
+  " Subtract a 'shiftwidth' on end, else, elseif, until and '}'
+  " This is the part that requires 'indentkeys'.
+  let midx = match(getline(v:lnum), '^\s*\%(end\>\|else\>\|elseif\>\|until\>\|}\)')
+  if midx != -1 && synIDattr(synID(v:lnum, midx + 1, 1), "name") != "luaComment"
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/mail.vim

@@ -0,0 +1,13 @@
+" Vim indent file
+" Language:	Mail
+" Maintainer:	Bram Moolenaar
+" Last Change:	2009 Jun 03
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+" What works best is auto-indenting, disable other indenting.
+" For formatting see the ftplugin.
+setlocal autoindent nosmartindent nocindent indentexpr=

Git/usr/share/vim/vim81/indent/make.vim

@@ -0,0 +1,116 @@
+" Vim indent file
+" Language:             Makefile
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2007-05-07
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetMakeIndent()
+setlocal indentkeys=!^F,o,O,<:>,=else,=endif
+setlocal nosmartindent
+
+if exists("*GetMakeIndent")
+  finish
+endif
+
+let s:comment_rx = '^\s*#'
+let s:rule_rx = '^[^ \t#:][^#:]*:\{1,2}\%([^=:]\|$\)'
+let s:continued_rule_rx = '^[^#:]*:\{1,2}\%([^=:]\|$\)'
+let s:continuation_rx = '\\$'
+let s:assignment_rx = '^\s*\h\w*\s*[+?]\==\s*\zs.*\\$'
+let s:folded_assignment_rx = '^\s*\h\w*\s*[+?]\=='
+" TODO: This needs to be a lot more restrictive in what it matches.
+let s:just_inserted_rule_rx = '^\s*[^#:]\+:\{1,2}$'
+let s:conditional_directive_rx = '^ *\%(ifn\=\%(eq\|def\)\|else\)\>'
+let s:end_conditional_directive_rx = '^\s*\%(else\|endif\)\>'
+
+function s:remove_continuation(line)
+  return substitute(a:line, s:continuation_rx, "", "")
+endfunction
+
+function GetMakeIndent()
+  " TODO: Should this perhaps be v:lnum -1?
+"  let prev_lnum = prevnonblank(v:lnum - 1)
+  let prev_lnum = v:lnum - 1
+  if prev_lnum == 0
+    return 0
+  endif
+  let prev_line = getline(prev_lnum)
+
+  let prev_prev_lnum = prev_lnum - 1
+  let prev_prev_line = prev_prev_lnum != 0 ? getline(prev_prev_lnum) : ""
+
+  " TODO: Deal with comments.  In comments, continuations aren't interesting.
+  if prev_line =~ s:continuation_rx
+    if prev_prev_line =~ s:continuation_rx
+      return indent(prev_lnum)
+    elseif prev_line =~ s:rule_rx
+      return shiftwidth()
+    elseif prev_line =~ s:assignment_rx
+      call cursor(prev_lnum, 1)
+      if search(s:assignment_rx, 'W') != 0
+        return virtcol('.') - 1
+      else
+        " TODO: ?
+        return shiftwidth()
+      endif
+    else
+      " TODO: OK, this might be a continued shell command, so perhaps indent
+      " properly here?  Leave this out for now, but in the next release this
+      " should be using indent/sh.vim somehow.
+      "if prev_line =~ '^\t' " s:rule_command_rx
+      "  if prev_line =~ '^\s\+[@-]\%(if\)\>'
+      "    return indent(prev_lnum) + 2
+      "  endif
+      "endif
+      return indent(prev_lnum) + shiftwidth()
+    endif
+  elseif prev_prev_line =~ s:continuation_rx
+    let folded_line = s:remove_continuation(prev_prev_line) . ' ' . s:remove_continuation(prev_line)
+    let lnum = prev_prev_lnum - 1
+    let line = getline(lnum)
+    while line =~ s:continuation_rx
+      let folded_line = s:remove_continuation(line) . ' ' . folded_line
+      let lnum -= 1
+      let line = getline(lnum)
+    endwhile
+    let folded_lnum = lnum + 1
+    if folded_line =~ s:rule_rx
+      if getline(v:lnum) =~ s:rule_rx
+        return 0
+      else
+        return &ts
+      endif
+    else
+"    elseif folded_line =~ s:folded_assignment_rx
+      if getline(v:lnum) =~ s:rule_rx
+        return 0
+      else
+        return indent(folded_lnum)
+      endif
+"    else
+"      " TODO: ?
+"      return indent(prev_lnum)
+    endif
+  elseif prev_line =~ s:rule_rx
+    if getline(v:lnum) =~ s:rule_rx
+      return 0
+    else
+      return &ts
+    endif
+  elseif prev_line =~ s:conditional_directive_rx
+    return shiftwidth()
+  else
+    let line = getline(v:lnum)
+    if line =~ s:just_inserted_rule_rx
+      return 0
+    elseif line =~ s:end_conditional_directive_rx
+      return v:lnum - 1 == 0 ? 0 : indent(v:lnum - 1) - shiftwidth()
+    else
+      return v:lnum - 1 == 0 ? 0 : indent(v:lnum - 1)
+    endif
+  endif
+endfunction

Git/usr/share/vim/vim81/indent/matlab.vim

@@ -0,0 +1,121 @@
+" Vim indent file
+" Language: MATLAB
+" Maintainer: Axel Forsman <axelsfor@gmail.com>
+" Previous maintainer: Christophe Poucet <christophe.poucet@pandora.be>
+
+" Only load if no other indent file is loaded
+if exists('b:did_indent') | finish | endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetMatlabIndent()
+setlocal indentkeys=!,o,O,e,0=end,0=elseif,0=case,0=otherwise,0=catch,0=function,0=elsei
+
+" The value of the Function indenting format in
+" MATLAB Editor/Debugger Language Preferences.
+" The possible values are 0 for Classic, 1 for Indent nested functions
+" and 2 for Indent all functions (default).
+let b:MATLAB_function_indent = get(g:, 'MATLAB_function_indent', 2)
+" The previous value of b:changedtick
+let b:MATLAB_lasttick = -1
+" The previously indented line
+let b:MATLAB_lastline = -1
+" Whether the line above was a line continuation
+let b:MATLAB_waslc = 0
+let b:MATLAB_bracketlevel = 0
+
+" Only define the function once
+if exists("*GetMatlabIndent") | finish | endif
+
+let s:keepcpo = &cpo
+set cpo&vim
+
+let s:end = '\<end\>\%([^(]*)\)\@!' " Array indexing heuristic
+let s:open_pat = 'for\|if\|parfor\|spmd\|switch\|try\|while\|classdef\|properties\|methods\|events\|enumeration'
+let s:dedent_pat = '\C^\s*\zs\<\%(end\|else\|elseif\|catch\|\(case\|otherwise\|function\)\)\>'
+let s:start_pat = '\C\<\%(function\|' . s:open_pat . '\)\>'
+let s:bracket_pair_pat = '\(\[\|{\)\|\(\]\|}\)'
+let s:zflag = has('patch-7.4.984') ? 'z' : ''
+
+" Returns whether a comment or string envelops the specified column.
+function! s:IsCommentOrString(lnum, col)
+	return synIDattr(synID(a:lnum, a:col, 1), "name") =~# 'matlabComment\|matlabMultilineComment\|matlabString'
+endfunction
+
+" Returns whether the specified line continues on the next line.
+function! s:IsLineContinuation(lnum)
+	let l = getline(a:lnum) | let c = -3
+	while 1
+		let c = match(l, '\.\{3}', c + 3)
+		if c == -1 | return 0
+		elseif !s:IsCommentOrString(a:lnum, c) | return 1 | endif
+	endwhile
+endfunction
+
+function! s:SubmatchCount(lnum, pattern, ...)
+	let endcol = a:0 >= 1 ? a:1 : 1 / 0 | let x = [0, 0, 0, 0]
+	call cursor(a:lnum, 1)
+	while 1
+		let [lnum, c, submatch] = searchpos(a:pattern, 'cpe' . s:zflag, a:lnum)
+		if !submatch || c >= endcol | break | endif
+		if !s:IsCommentOrString(lnum, c) | let x[submatch - 2] += 1 | endif
+		if cursor(0, c + 1) == -1 || col('.') == c | break | endif
+	endwhile
+	return x
+endfunction
+
+function! s:GetOpenCloseCount(lnum, pattern, ...)
+	let counts = call('s:SubmatchCount', [a:lnum, a:pattern] + a:000)
+	return counts[0] - counts[1]
+endfunction
+
+function! GetMatlabIndent()
+	let prevlnum = prevnonblank(v:lnum - 1)
+
+	if b:MATLAB_lasttick != b:changedtick || b:MATLAB_lastline != prevlnum
+		" Recalculate bracket count (only have to check same block and line above)
+		let b:MATLAB_bracketlevel = 0
+		let previndent = indent(prevlnum) | let l = prevlnum
+		while 1
+			let l = prevnonblank(l - 1) | let indent = indent(l)
+			if l <= 0 || previndent < indent | break | endif
+			let b:MATLAB_bracketlevel += s:GetOpenCloseCount(l, s:bracket_pair_pat)
+			if previndent != indent | break | endif
+		endwhile
+
+		let b:MATLAB_waslc = s:IsLineContinuation(prevlnum - 1)
+	endif
+	" If line above was blank it can impossibly have been a LC
+	let above_lc = b:MATLAB_lasttick == b:changedtick && prevlnum != v:lnum - 1 && b:MATLAB_lastline == prevlnum ? 0 : s:IsLineContinuation(v:lnum - 1)
+
+	let pair_pat = '\C\<\(' . s:open_pat . '\|'
+				\ . (b:MATLAB_function_indent == 1 ? '^\@<!' : '')
+				\ . (b:MATLAB_function_indent >= 1 ? 'function\|' : '')
+				\ . '\|\%(^\s*\)\@<=\%(else\|elseif\|case\|otherwise\|catch\)\)\>'
+				\ . '\|\S\s*\zs\(' . s:end . '\)'
+	let [open, close, b_open, b_close] = prevlnum ? s:SubmatchCount(prevlnum,
+				\ pair_pat . '\|' . s:bracket_pair_pat) : [0, 0, 0, 0]
+	let curbracketlevel = b:MATLAB_bracketlevel + b_open - b_close
+
+	call cursor(v:lnum, 1)
+	let submatch = search(s:dedent_pat, 'cp' . s:zflag, v:lnum)
+	if submatch && !s:IsCommentOrString(v:lnum, col('.'))
+		" Align end, et cetera with start of block
+		let [lnum, col] = searchpairpos(s:start_pat, '',  '\C' . s:end, 'bW', 's:IsCommentOrString(line("."), col("."))')
+		let result = lnum ? indent(lnum) + shiftwidth() * (s:GetOpenCloseCount(lnum, pair_pat, col) + submatch == 2) : 0
+	else
+		" Count how many blocks the previous line opens/closes
+		" Line continuations/brackets indent once per statement
+		let result = indent(prevlnum) + shiftwidth() * (open - close
+					\ + (b:MATLAB_bracketlevel ? -!curbracketlevel : !!curbracketlevel)
+					\ + (curbracketlevel <= 0) * (above_lc - b:MATLAB_waslc))
+	endif
+
+	let b:MATLAB_waslc = above_lc
+	let b:MATLAB_bracketlevel = curbracketlevel
+	let b:MATLAB_lasttick = b:changedtick
+	let b:MATLAB_lastline = v:lnum
+	return result
+endfunction
+
+let &cpo = s:keepcpo
+unlet s:keepcpo

Git/usr/share/vim/vim81/indent/mf.vim

@@ -0,0 +1,6 @@
+" METAFONT indent file
+" Language:    METAFONT
+" Maintainer:  Nicola Vitacolonna <nvitacolonna@gmail.com>
+" Last Change: 2016 Oct 1
+
+runtime! indent/mp.vim

Git/usr/share/vim/vim81/indent/mma.vim

@@ -0,0 +1,75 @@
+" Vim indent file
+" Language:     Mathematica
+" Author:       steve layland <layland@wolfram.com>
+" Last Change:  Sat May  10 18:56:22 CDT 2005
+" Source:       http://vim.sourceforge.net/scripts/script.php?script_id=1274
+"               http://members.wolfram.com/layland/vim/indent/mma.vim
+"
+" NOTE:
+" Empty .m files will automatically be presumed to be Matlab files
+" unless you have the following in your .vimrc:
+"
+"       let filetype_m="mma"
+"
+" Credits:
+" o steve hacked this out of a random indent file in the Vim 6.1
+"   distribution that he no longer remembers...sh.vim?  Thanks!
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetMmaIndent()
+setlocal indentkeys+=0[,0],0(,0)
+setlocal nosi "turn off smart indent so we don't over analyze } blocks
+
+if exists("*GetMmaIndent")
+    finish
+endif
+
+function GetMmaIndent()
+
+    " Hit the start of the file, use zero indent.
+    if v:lnum == 0
+        return 0
+    endif
+
+     " Find a non-blank line above the current line.
+    let lnum = prevnonblank(v:lnum - 1)
+
+    " use indenting as a base
+    let ind = indent(v:lnum)
+    let lnum = v:lnum
+
+    " if previous line has an unmatched bracket, or ( indent.
+    " doesn't do multiple parens/blocks/etc...
+
+    " also, indent only if this line if this line isn't starting a new
+    " block... TODO - fix this with indentkeys?
+    if getline(v:lnum-1) =~ '\\\@<!\%(\[[^\]]*\|([^)]*\|{[^}]*\)$' && getline(v:lnum) !~ '\s\+[\[({]'
+        let ind = ind+shiftwidth()
+    endif
+
+    " if this line had unmatched closing block,
+    " indent to the matching opening block
+    if getline(v:lnum) =~ '[^[]*]\s*$'
+        " move to the closing bracket
+        call search(']','bW')
+        " and find it's partner's indent
+        let ind = indent(searchpair('\[','',']','bWn'))
+    " same for ( blocks
+    elseif getline(v:lnum) =~ '[^(]*)$'
+        call search(')','bW')
+        let ind = indent(searchpair('(','',')','bWn'))
+
+    " and finally, close { blocks if si ain't already set
+    elseif getline(v:lnum) =~ '[^{]*}'
+        call search('}','bW')
+        let ind = indent(searchpair('{','','}','bWn'))
+    endif
+
+    return ind
+endfunction
+

Git/usr/share/vim/vim81/indent/mp.vim

@@ -0,0 +1,360 @@
+" MetaPost indent file
+" Language:           MetaPost
+" Maintainer:         Nicola Vitacolonna <nvitacolonna@gmail.com>
+" Former Maintainers: Eugene Minkovskii <emin@mccme.ru>
+" Last Change:        2016 Oct 2, 4:13pm
+" Version: 0.2
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetMetaPostIndent()
+setlocal indentkeys+==end,=else,=fi,=fill,0),0]
+
+let b:undo_indent = "setl indentkeys< indentexpr<"
+
+" Only define the function once.
+if exists("*GetMetaPostIndent")
+  finish
+endif
+let s:keepcpo= &cpo
+set cpo&vim
+
+function GetMetaPostIndent()
+  let ignorecase_save = &ignorecase
+  try
+    let &ignorecase = 0
+    return GetMetaPostIndentIntern()
+  finally
+    let &ignorecase = ignorecase_save
+  endtry
+endfunc
+
+" Regexps {{{
+" Note: the next three variables are made global so that a user may add
+" further keywords.
+"
+" Example:
+"
+"    Put these in ~/.vim/after/indent/mp.vim
+"
+"    let g:mp_open_tag .= '\|\<begintest\>'
+"    let g:mp_close_tag .= '\|\<endtest\>'
+
+" Expressions starting indented blocks
+let g:mp_open_tag = ''
+      \ . '\<if\>'
+      \ . '\|\<else\%[if]\>'
+      \ . '\|\<for\%(\|ever\|suffixes\)\>'
+      \ . '\|\<begingroup\>'
+      \ . '\|\<\%(\|var\|primary\|secondary\|tertiary\)def\>'
+      \ . '\|^\s*\<begin\%(fig\|graph\|glyph\|char\|logochar\)\>'
+      \ . '\|[([{]'
+
+" Expressions ending indented blocks
+let g:mp_close_tag = ''
+      \ . '\<fi\>'
+      \ . '\|\<else\%[if]\>'
+      \ . '\|\<end\%(\|for\|group\|def\|fig\|char\|glyph\|graph\)\>'
+      \ . '\|[)\]}]'
+
+" Statements that may span multiple lines and are ended by a semicolon. To
+" keep this list short, statements that are unlikely to be very long or are
+" not very common (e.g., keywords like `interim` or `showtoken`) are not
+" included.
+"
+" The regex for assignments and equations (the last branch) is tricky, because
+" it must not match things like `for i :=`, `if a=b`, `def...=`, etc... It is
+" not perfect, but it works reasonably well.
+let g:mp_statement = ''
+      \ . '\<\%(\|un\|cut\)draw\>'
+      \ . '\|\<\%(\|un\)fill\%[draw]\>'
+      \ . '\|\<draw\%(dbl\)\=arrow\>'
+      \ . '\|\<clip\>'
+      \ . '\|\<addto\>'
+      \ . '\|\<save\>'
+      \ . '\|\<setbounds\>'
+      \ . '\|\<message\>'
+      \ . '\|\<errmessage\>'
+      \ . '\|\<errhelp\>'
+      \ . '\|\<fontmapline\>'
+      \ . '\|\<pickup\>'
+      \ . '\|\<show\>'
+      \ . '\|\<special\>'
+      \ . '\|\<write\>'
+      \ . '\|\%(^\|;\)\%([^;=]*\%('.g:mp_open_tag.'\)\)\@!.\{-}:\=='
+
+" A line ends with zero or more spaces, possibly followed by a comment.
+let s:eol = '\s*\%($\|%\)'
+" }}}
+
+" Auxiliary functions {{{
+" Returns 1 if (0-based) position immediately preceding `pos` in `line` is
+" inside a string or a comment; returns 0 otherwise.
+
+" This is the function that is called more often when indenting, so it is
+" critical that it is efficient. The method we use is significantly faster
+" than using syntax attributes, and more general (it does not require
+" syntax_items). It is also faster than using a single regex matching an even
+" number of quotes. It helps that MetaPost strings cannot span more than one
+" line and cannot contain escaped quotes.
+function! s:CommentOrString(line, pos)
+  let in_string = 0
+  let q = stridx(a:line, '"')
+  let c = stridx(a:line, '%')
+  while q >= 0 && q < a:pos
+    if c >= 0 && c < q
+      if in_string " Find next percent symbol
+        let c = stridx(a:line, '%', q + 1)
+      else " Inside comment
+        return 1
+      endif
+    endif
+    let in_string = 1 - in_string
+    let q = stridx(a:line, '"', q + 1) " Find next quote
+  endwhile
+  return in_string || (c >= 0 && c <= a:pos)
+endfunction
+
+" Find the first non-comment non-blank line before the current line.
+function! s:PrevNonBlankNonComment(lnum)
+  let l:lnum = prevnonblank(a:lnum - 1)
+  while getline(l:lnum) =~# '^\s*%'
+    let l:lnum = prevnonblank(l:lnum - 1)
+  endwhile
+  return l:lnum
+endfunction
+
+" Returns true if the last tag appearing in the line is an open tag; returns
+" false otherwise.
+function! s:LastTagIsOpen(line)
+  let o = s:LastValidMatchEnd(a:line, g:mp_open_tag, 0)
+  if o == - 1 | return v:false | endif
+  return s:LastValidMatchEnd(a:line, g:mp_close_tag, o) < 0
+endfunction
+
+" A simple, efficient and quite effective heuristics is used to test whether
+" a line should cause the next line to be indented: count the "opening tags"
+" (if, for, def, ...) in the line, count the "closing tags" (endif, endfor,
+" ...) in the line, and compute the difference. We call the result the
+" "weight" of the line. If the weight is positive, then the next line should
+" most likely be indented. Note that `else` and `elseif` are both opening and
+" closing tags, so they "cancel out" in almost all cases, the only exception
+" being a leading `else[if]`, which is counted as an opening tag, but not as
+" a closing tag (so that, for instance, a line containing a single `else:`
+" will have weight equal to one, not zero). We do not treat a trailing
+" `else[if]` in any special way, because lines ending with an open tag are
+" dealt with separately before this function is called (see
+" GetMetaPostIndentIntern()).
+"
+" Example:
+"
+"     forsuffixes $=a,b: if x.$ = y.$ : draw else: fill fi
+"       % This line will be indented because |{forsuffixes,if,else}| > |{else,fi}| (3 > 2)
+"     endfor
+
+function! s:Weight(line)
+  let [o, i] = [0, s:ValidMatchEnd(a:line, g:mp_open_tag, 0)]
+  while i > 0
+    let o += 1
+    let i = s:ValidMatchEnd(a:line, g:mp_open_tag, i)
+  endwhile
+  let [c, i] = [0, matchend(a:line, '^\s*\<else\%[if]\>')] " Skip a leading else[if]
+  let i = s:ValidMatchEnd(a:line, g:mp_close_tag, i)
+  while i > 0
+    let c += 1
+    let i = s:ValidMatchEnd(a:line, g:mp_close_tag, i)
+  endwhile
+  return o - c
+endfunction
+
+" Similar to matchend(), but skips strings and comments.
+" line: a String
+function! s:ValidMatchEnd(line, pat, start)
+  let i = matchend(a:line, a:pat, a:start)
+  while i > 0 && s:CommentOrString(a:line, i)
+    let i = matchend(a:line, a:pat, i)
+  endwhile
+  return i
+endfunction
+
+" Like s:ValidMatchEnd(), but returns the end position of the last (i.e.,
+" rightmost) match.
+function! s:LastValidMatchEnd(line, pat, start)
+  let last_found = -1
+  let i = matchend(a:line, a:pat, a:start)
+  while i > 0
+    if !s:CommentOrString(a:line, i)
+      let last_found = i
+    endif
+    let i = matchend(a:line, a:pat, i)
+  endwhile
+  return last_found
+endfunction
+
+function! s:DecreaseIndentOnClosingTag(curr_indent)
+  let cur_text = getline(v:lnum)
+  if cur_text =~# '^\s*\%('.g:mp_close_tag.'\)'
+    return max([a:curr_indent - shiftwidth(), 0])
+  endif
+  return a:curr_indent
+endfunction
+" }}}
+
+" Main function {{{
+"
+" Note: Every rule of indentation in MetaPost is very subjective. We might get
+" creative, but things get murky very soon (there are too many corner cases).
+" So, we provide a means for the user to decide what to do when this script
+" doesn't get it. We use a simple idea: use '%>', '%<' and '%=' to explicitly
+" control indentation. The '<' and '>' symbols may be repeated many times
+" (e.g., '%>>' will cause the next line to be indented twice).
+"
+" By using '%>...', '%<...' and '%=', the indentation the user wants is
+" preserved by commands like gg=G, even if it does not follow the rules of
+" this script.
+"
+" Example:
+"
+"    def foo =
+"        makepen(
+"            subpath(T-n,t) of r  %>
+"                shifted .5down   %>
+"                    --subpath(t,T) of r shifted .5up -- cycle   %<<<
+"        )
+"        withcolor black
+"    enddef
+"
+" The default indentation of the previous example would be:
+"
+"    def foo =
+"        makepen(
+"            subpath(T-n,t) of r
+"            shifted .5down
+"            --subpath(t,T) of r shifted .5up -- cycle
+"        )
+"        withcolor black
+"    enddef
+"
+" Personally, I prefer the latter, but anyway...
+function! GetMetaPostIndentIntern()
+  " Do not touch indentation inside verbatimtex/btex.. etex blocks.
+  if synIDattr(synID(v:lnum, 1, 1), "name") =~# '^mpTeXinsert$\|^tex\|^Delimiter'
+    return -1
+  endif
+
+  " This is the reference line relative to which the current line is indented
+  " (but see below).
+  let lnum = s:PrevNonBlankNonComment(v:lnum)
+
+  " At the start of the file use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  let prev_text = getline(lnum)
+
+  " User-defined overrides take precedence over anything else.
+  " See above for an example.
+  let j = match(prev_text, '%[<>=]')
+  if j > 0
+    let i = strlen(matchstr(prev_text, '%>\+', j)) - 1
+    if i > 0
+      return indent(lnum) + i * shiftwidth()
+    endif
+
+    let i = strlen(matchstr(prev_text, '%<\+', j)) - 1
+    if i > 0
+      return max([indent(lnum) - i * shiftwidth(), 0])
+    endif
+
+    if match(prev_text, '%=', j)
+      return indent(lnum)
+    endif
+  endif
+
+  " If the reference line ends with an open tag, indent.
+  "
+  " Example:
+  "
+  " if c:
+  "     0
+  " else:
+  "     1
+  " fi if c2: % Note that this line has weight equal to zero.
+  "     ...   % This line will be indented
+  if s:LastTagIsOpen(prev_text)
+    return s:DecreaseIndentOnClosingTag(indent(lnum) + shiftwidth())
+  endif
+
+  " Lines with a positive weight are unbalanced and should likely be indented.
+  "
+  " Example:
+  "
+  " def f = enddef for i = 1 upto 5: if x[i] > 0: 1 else: 2 fi
+  "     ... % This line will be indented (because of the unterminated `for`)
+  if s:Weight(prev_text) > 0
+    return s:DecreaseIndentOnClosingTag(indent(lnum) + shiftwidth())
+  endif
+
+  " Unterminated statements cause indentation to kick in.
+  "
+  " Example:
+  "
+  " draw unitsquare
+  "     withcolor black; % This line is indented because of `draw`.
+  " x := a + b + c
+  "     + d + e;         % This line is indented because of `:=`.
+  "
+  let i = s:LastValidMatchEnd(prev_text, g:mp_statement, 0)
+  if i >= 0 " Does the line contain a statement?
+    if s:ValidMatchEnd(prev_text, ';', i) < 0 " Is the statement unterminated?
+      return indent(lnum) + shiftwidth()
+    else
+      return s:DecreaseIndentOnClosingTag(indent(lnum))
+    endif
+  endif
+
+  " Deal with the special case of a statement spanning multiple lines. If the
+  " current reference line L ends with a semicolon, search backwards for
+  " another semicolon or a statement keyword. If the latter is found first,
+  " its line is used as the reference line for indenting the current line
+  " instead of L.
+  "
+  "  Example:
+  "
+  "  if cond:
+  "    draw if a: z0 else: z1 fi
+  "        shifted S
+  "        scaled T;      % L
+  "
+  "    for i = 1 upto 3:  % <-- Current line: this gets the same indent as `draw ...`
+  "
+  " NOTE: we get here only if L does not contain a statement (among those
+  " listed in g:mp_statement).
+  if s:ValidMatchEnd(prev_text, ';'.s:eol, 0) >= 0 " L ends with a semicolon
+    let stm_lnum = s:PrevNonBlankNonComment(lnum)
+    while stm_lnum > 0
+      let prev_text = getline(stm_lnum)
+      let sc_pos = s:LastValidMatchEnd(prev_text, ';', 0)
+      let stm_pos = s:ValidMatchEnd(prev_text, g:mp_statement, sc_pos)
+      if stm_pos > sc_pos
+        let lnum = stm_lnum
+        break
+      elseif sc_pos > stm_pos
+        break
+      endif
+      let stm_lnum = s:PrevNonBlankNonComment(stm_lnum)
+    endwhile
+  endif
+
+  return s:DecreaseIndentOnClosingTag(indent(lnum))
+endfunction
+" }}}
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+" vim:sw=2:fdm=marker

Git/usr/share/vim/vim81/indent/nsis.vim

@@ -0,0 +1,91 @@
+" Vim indent file
+" Language:		NSIS script
+" Maintainer:		Ken Takata
+" URL:			https://github.com/k-takata/vim-nsis
+" Last Change:		2018-01-21
+" Filenames:		*.nsi
+" License:		VIM License
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal nosmartindent
+setlocal noautoindent
+setlocal indentexpr=GetNsisIndent(v:lnum)
+setlocal indentkeys=!^F,o,O
+setlocal indentkeys+==~${Else,=~${EndIf,=~${EndUnless,=~${AndIf,=~${AndUnless,=~${OrIf,=~${OrUnless,=~${Case,=~${Default,=~${EndSelect,=~${EndSwith,=~${Loop,=~${Next,=~${MementoSectionEnd,=~FunctionEnd,=~SectionEnd,=~SectionGroupEnd,=~PageExEnd,0=~!macroend,0=~!if,0=~!else,0=~!endif
+
+if exists("*GetNsisIndent")
+  finish
+endif
+
+function! GetNsisIndent(lnum)
+  " If this line is explicitly joined: If the previous line was also joined,
+  " line it up with that one, otherwise add two 'shiftwidth'
+  if getline(a:lnum - 1) =~ '\\$'
+    if a:lnum > 1 && getline(a:lnum - 2) =~ '\\$'
+      return indent(a:lnum - 1)
+    endif
+    return indent(a:lnum - 1) + shiftwidth() * 2
+  endif
+
+  " Grab the current line, stripping comments.
+  let l:thisl = substitute(getline(a:lnum), '[;#].*$', '', '')
+  " Check if this line is a conditional preprocessor line.
+  let l:preproc = l:thisl =~? '^\s*!\%(if\|else\|endif\)'
+
+  " Grab the previous line, stripping comments.
+  " Skip preprocessor lines and continued lines.
+  let l:prevlnum = a:lnum
+  while 1
+    let l:prevlnum = prevnonblank(l:prevlnum - 1)
+    if l:prevlnum == 0
+      " top of file
+      return 0
+    endif
+    let l:prevl = substitute(getline(l:prevlnum), '[;#].*$', '', '')
+    let l:prevpreproc = l:prevl =~? '^\s*!\%(if\|else\|endif\)'
+    if l:preproc == l:prevpreproc && getline(l:prevlnum - 1) !~? '\\$'
+      break
+    endif
+  endwhile
+  let l:previ = indent(l:prevlnum)
+  let l:ind = l:previ
+
+  if l:preproc
+    " conditional preprocessor
+    if l:prevl =~? '^\s*!\%(if\%(\%(macro\)\?n\?def\)\?\|else\)\>'
+      let l:ind += shiftwidth()
+    endif
+    if l:thisl =~? '^\s*!\%(else\|endif\)\?\>'
+      let l:ind -= shiftwidth()
+    endif
+    return l:ind
+  endif
+
+  if l:prevl =~? '^\s*\%(\${\%(If\|IfNot\|Unless\|ElseIf\|ElseIfNot\|ElseUnless\|Else\|AndIf\|AndIfNot\|AndUnless\|OrIf\|OrIfNot\|OrUnless\|Select\|Case\|Case[2-5]\|CaseElse\|Default\|Switch\|Do\|DoWhile\|DoUntil\|For\|ForEach\|MementoSection\)}\|Function\>\|Section\>\|SectionGroup\|PageEx\>\|!macro\>\)'
+    " previous line opened a block
+    let l:ind += shiftwidth()
+  endif
+  if l:thisl =~? '^\s*\%(\${\%(ElseIf\|ElseIfNot\|ElseUnless\|Else\|EndIf\|EndUnless\|AndIf\|AndIfNot\|AndUnless\|OrIf\|OrIfNot\|OrUnless\|Loop\|LoopWhile\|LoopUntil\|Next\|MementoSectionEnd\)\>}\?\|FunctionEnd\>\|SectionEnd\>\|SectionGroupEnd\|PageExEnd\>\|!macroend\>\)'
+    " this line closed a block
+    let l:ind -= shiftwidth()
+  elseif l:thisl =~? '^\s*\${\%(Case\|Case[2-5]\|CaseElse\|Default\)\>}\?'
+    if l:prevl !~? '^\s*\${\%(Select\|Switch\)}'
+      let l:ind -= shiftwidth()
+    endif
+  elseif l:thisl =~? '^\s*\${\%(EndSelect\|EndSwitch\)\>}\?'
+    " this line closed a block
+    if l:prevl =~? '^\s*\${\%(Select\|Switch\)}'
+      let l:ind -= shiftwidth()
+    else
+      let l:ind -= shiftwidth() * 2
+    endif
+  endif
+
+  return l:ind
+endfunction
+
+" vim: ts=8 sw=2 sts=2

Git/usr/share/vim/vim81/indent/objc.vim

@@ -0,0 +1,79 @@
+"   Vim indent file
+"   Language:	    Objective-C
+"   Maintainer:	    Kazunobu Kuriyama <kazunobu.kuriyama@nifty.com>
+"   Last Change:    2004 May 16
+"
+
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+setlocal cindent
+
+" Set the function to do the work.
+setlocal indentexpr=GetObjCIndent()
+
+" To make a colon (:) suggest an indentation other than a goto/swich label,
+setlocal indentkeys-=:
+setlocal indentkeys+=<:>
+
+" Only define the function once.
+if exists("*GetObjCIndent")
+    finish
+endif
+
+function s:GetWidth(line, regexp)
+    let end = matchend(a:line, a:regexp)
+    let width = 0
+    let i = 0
+    while i < end
+	if a:line[i] != "\t"
+	    let width = width + 1
+	else
+	    let width = width + &ts - (width % &ts)
+	endif
+	let i = i + 1
+    endwhile
+    return width
+endfunction
+
+function s:LeadingWhiteSpace(line)
+    let end = strlen(a:line)
+    let width = 0
+    let i = 0
+    while i < end
+	let char = a:line[i]
+	if char != " " && char != "\t"
+	    break
+	endif
+	if char != "\t"
+	    let width = width + 1
+	else
+	    let width = width + &ts - (width % &ts)
+	endif
+	let i = i + 1
+    endwhile
+    return width
+endfunction
+
+
+function GetObjCIndent()
+    let theIndent = cindent(v:lnum)
+
+    let prev_line = getline(v:lnum - 1)
+    let cur_line = getline(v:lnum)
+
+    if prev_line !~# ":" || cur_line !~# ":"
+	return theIndent
+    endif
+
+    if prev_line !~# ";"
+	let prev_colon_pos = s:GetWidth(prev_line, ":")
+	let delta = s:GetWidth(cur_line, ":") - s:LeadingWhiteSpace(cur_line)
+	let theIndent = prev_colon_pos - delta
+    endif
+
+    return theIndent
+endfunction

Git/usr/share/vim/vim81/indent/ocaml.vim

@@ -0,0 +1,273 @@
+" Vim indent file
+" Language:     OCaml
+" Maintainers:  Jean-Francois Yuen   <jfyuen@happycoders.org>
+"               Mike Leary           <leary@nwlink.com>
+"               Markus Mottl         <markus.mottl@gmail.com>
+" URL:          http://www.ocaml.info/vim/indent/ocaml.vim
+" Last Change:  2017 Jun 13
+"               2005 Jun 25 - Fixed multiple bugs due to 'else\nreturn ind' working
+"               2005 May 09 - Added an option to not indent OCaml-indents specially (MM)
+"               2013 June   - commented textwidth (Marc Weber)
+"
+" Marc Weber's comment: This file may contain a lot of (very custom) stuff
+" which eventually should be moved somewhere else ..
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+ finish
+endif
+let b:did_indent = 1
+
+setlocal expandtab
+setlocal indentexpr=GetOCamlIndent()
+setlocal indentkeys+=0=and,0=class,0=constraint,0=done,0=else,0=end,0=exception,0=external,0=if,0=in,0=include,0=inherit,0=initializer,0=let,0=method,0=open,0=then,0=type,0=val,0=with,0;;,0>\],0\|\],0>},0\|,0},0\],0)
+setlocal nolisp
+setlocal nosmartindent
+
+" At least Marc Weber and Markus Mottl do not like this:
+" setlocal textwidth=80
+
+" Comment formatting
+if !exists("no_ocaml_comments")
+ if (has("comments"))
+   setlocal comments=sr:(*,mb:*,ex:*)
+   setlocal fo=cqort
+ endif
+endif
+
+" Only define the function once.
+if exists("*GetOCamlIndent")
+ finish
+endif
+
+" Define some patterns:
+let s:beflet = '^\s*\(initializer\|method\|try\)\|\(\<\(begin\|do\|else\|in\|then\|try\)\|->\|<-\|=\|;\|(\)\s*$'
+let s:letpat = '^\s*\(let\|type\|module\|class\|open\|exception\|val\|include\|external\)\>'
+let s:letlim = '\(\<\(sig\|struct\)\|;;\)\s*$'
+let s:lim = '^\s*\(exception\|external\|include\|let\|module\|open\|type\|val\)\>'
+let s:module = '\<\%(begin\|sig\|struct\|object\)\>'
+let s:obj = '^\s*\(constraint\|inherit\|initializer\|method\|val\)\>\|\<\(object\|object\s*(.*)\)\s*$'
+let s:type = '^\s*\%(class\|let\|type\)\>.*='
+
+" Skipping pattern, for comments
+function! s:GetLineWithoutFullComment(lnum)
+ let lnum = prevnonblank(a:lnum - 1)
+ let lline = substitute(getline(lnum), '(\*.*\*)\s*$', '', '')
+ while lline =~ '^\s*$' && lnum > 0
+   let lnum = prevnonblank(lnum - 1)
+   let lline = substitute(getline(lnum), '(\*.*\*)\s*$', '', '')
+ endwhile
+ return lnum
+endfunction
+
+" Indent for ';;' to match multiple 'let'
+function! s:GetInd(lnum, pat, lim)
+ let llet = search(a:pat, 'bW')
+ let old = indent(a:lnum)
+ while llet > 0
+   let old = indent(llet)
+   let nb = s:GetLineWithoutFullComment(llet)
+   if getline(nb) =~ a:lim
+     return old
+   endif
+   let llet = search(a:pat, 'bW')
+ endwhile
+ return old
+endfunction
+
+" Indent pairs
+function! s:FindPair(pstart, pmid, pend)
+ call search(a:pend, 'bW')
+ return indent(searchpair(a:pstart, a:pmid, a:pend, 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"'))
+endfunction
+
+" Indent 'let'
+function! s:FindLet(pstart, pmid, pend)
+ call search(a:pend, 'bW')
+ return indent(searchpair(a:pstart, a:pmid, a:pend, 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment" || getline(".") =~ "^\\s*let\\>.*=.*\\<in\\s*$" || getline(prevnonblank(".") - 1) =~ s:beflet'))
+endfunction
+
+function! GetOCamlIndent()
+ " Find a non-commented line above the current line.
+ let lnum = s:GetLineWithoutFullComment(v:lnum)
+
+ " At the start of the file use zero indent.
+ if lnum == 0
+   return 0
+ endif
+
+ let ind = indent(lnum)
+ let lline = substitute(getline(lnum), '(\*.*\*)\s*$', '', '')
+
+ " Return double 'shiftwidth' after lines matching:
+ if lline =~ '^\s*|.*->\s*$'
+   return ind + 2 * shiftwidth()
+ endif
+
+ let line = getline(v:lnum)
+
+ " Indent if current line begins with 'end':
+ if line =~ '^\s*end\>'
+   return s:FindPair(s:module, '','\<end\>')
+
+ " Indent if current line begins with 'done' for 'do':
+ elseif line =~ '^\s*done\>'
+   return s:FindPair('\<do\>', '','\<done\>')
+
+ " Indent if current line begins with '}' or '>}':
+ elseif line =~ '^\s*\(\|>\)}'
+   return s:FindPair('{', '','}')
+
+ " Indent if current line begins with ']', '|]' or '>]':
+ elseif line =~ '^\s*\(\||\|>\)\]'
+   return s:FindPair('\[', '','\]')
+
+ " Indent if current line begins with ')':
+ elseif line =~ '^\s*)'
+   return s:FindPair('(', '',')')
+
+ " Indent if current line begins with 'let':
+ elseif line =~ '^\s*let\>'
+   if lline !~ s:lim . '\|' . s:letlim . '\|' . s:beflet
+     return s:FindLet(s:type, '','\<let\s*$')
+   endif
+
+ " Indent if current line begins with 'class' or 'type':
+ elseif line =~ '^\s*\(class\|type\)\>'
+   if lline !~ s:lim . '\|\<and\s*$\|' . s:letlim
+     return s:FindLet(s:type, '','\<\(class\|type\)\s*$')
+   endif
+
+ " Indent for pattern matching:
+ elseif line =~ '^\s*|'
+   if lline !~ '^\s*\(|[^\]]\|\(match\|type\|with\)\>\)\|\<\(function\|parser\|private\|with\)\s*$'
+     call search('|', 'bW')
+     return indent(searchpair('^\s*\(match\|type\)\>\|\<\(function\|parser\|private\|with\)\s*$', '', '^\s*|', 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment" || getline(".") !~ "^\\s*|.*->"'))
+   endif
+
+ " Indent if current line begins with ';;':
+ elseif line =~ '^\s*;;'
+   if lline !~ ';;\s*$'
+     return s:GetInd(v:lnum, s:letpat, s:letlim)
+   endif
+
+ " Indent if current line begins with 'in':
+ elseif line =~ '^\s*in\>'
+   if lline !~ '^\s*\(let\|and\)\>'
+     return s:FindPair('\<let\>', '', '\<in\>')
+   endif
+
+ " Indent if current line begins with 'else':
+ elseif line =~ '^\s*else\>'
+   if lline !~ '^\s*\(if\|then\)\>'
+     return s:FindPair('\<if\>', '', '\<else\>')
+   endif
+
+ " Indent if current line begins with 'then':
+ elseif line =~ '^\s*then\>'
+   if lline !~ '^\s*\(if\|else\)\>'
+     return s:FindPair('\<if\>', '', '\<then\>')
+   endif
+
+ " Indent if current line begins with 'and':
+ elseif line =~ '^\s*and\>'
+   if lline !~ '^\s*\(and\|let\|type\)\>\|\<end\s*$'
+     return ind - shiftwidth()
+   endif
+
+ " Indent if current line begins with 'with':
+ elseif line =~ '^\s*with\>'
+   if lline !~ '^\s*\(match\|try\)\>'
+     return s:FindPair('\<\%(match\|try\)\>', '','\<with\>')
+   endif
+
+ " Indent if current line begins with 'exception', 'external', 'include' or
+ " 'open':
+ elseif line =~ '^\s*\(exception\|external\|include\|open\)\>'
+   if lline !~ s:lim . '\|' . s:letlim
+     call search(line)
+     return indent(search('^\s*\(\(exception\|external\|include\|open\|type\)\>\|val\>.*:\)', 'bW'))
+   endif
+
+ " Indent if current line begins with 'val':
+ elseif line =~ '^\s*val\>'
+   if lline !~ '^\s*\(exception\|external\|include\|open\)\>\|' . s:obj . '\|' . s:letlim
+     return indent(search('^\s*\(\(exception\|include\|initializer\|method\|open\|type\|val\)\>\|external\>.*:\)', 'bW'))
+   endif
+
+ " Indent if current line begins with 'constraint', 'inherit', 'initializer'
+ " or 'method':
+ elseif line =~ '^\s*\(constraint\|inherit\|initializer\|method\)\>'
+   if lline !~ s:obj
+     return indent(search('\<\(object\|object\s*(.*)\)\s*$', 'bW')) + shiftwidth()
+   endif
+
+ endif
+
+ " Add a 'shiftwidth' after lines ending with:
+ if lline =~ '\(:\|=\|->\|<-\|(\|\[\|{\|{<\|\[|\|\[<\|\<\(begin\|do\|else\|fun\|function\|functor\|if\|initializer\|object\|parser\|private\|sig\|struct\|then\|try\)\|\<object\s*(.*)\)\s*$'
+   let ind = ind + shiftwidth()
+
+ " Back to normal indent after lines ending with ';;':
+ elseif lline =~ ';;\s*$' && lline !~ '^\s*;;'
+   let ind = s:GetInd(v:lnum, s:letpat, s:letlim)
+
+ " Back to normal indent after lines ending with 'end':
+ elseif lline =~ '\<end\s*$'
+   let ind = s:FindPair(s:module, '','\<end\>')
+
+ " Back to normal indent after lines ending with 'in':
+ elseif lline =~ '\<in\s*$' && lline !~ '^\s*in\>'
+   let ind = s:FindPair('\<let\>', '', '\<in\>')
+
+ " Back to normal indent after lines ending with 'done':
+ elseif lline =~ '\<done\s*$'
+   let ind = s:FindPair('\<do\>', '','\<done\>')
+
+ " Back to normal indent after lines ending with '}' or '>}':
+ elseif lline =~ '\(\|>\)}\s*$'
+   let ind = s:FindPair('{', '','}')
+
+ " Back to normal indent after lines ending with ']', '|]' or '>]':
+ elseif lline =~ '\(\||\|>\)\]\s*$'
+   let ind = s:FindPair('\[', '','\]')
+
+ " Back to normal indent after comments:
+ elseif lline =~ '\*)\s*$'
+   call search('\*)', 'bW')
+   let ind = indent(searchpair('(\*', '', '\*)', 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"'))
+
+ " Back to normal indent after lines ending with ')':
+ elseif lline =~ ')\s*$'
+   let ind = s:FindPair('(', '',')')
+
+ " If this is a multiline comment then align '*':
+ elseif lline =~ '^\s*(\*' && line =~ '^\s*\*'
+   let ind = ind + 1
+
+ else
+ " Don't change indentation of this line
+ " for new lines (indent==0) use indentation of previous line
+
+ " This is for preventing removing indentation of these args:
+ "   let f x =
+ "     let y = x + 1 in
+ "     Printf.printf
+ "       "o"           << here
+ "       "oeuth"       << don't touch indentation
+
+   let i = indent(v:lnum)
+   return i == 0 ? ind : i
+
+ endif
+
+ " Subtract a 'shiftwidth' after lines matching 'match ... with parser':
+ if lline =~ '\<match\>.*\<with\>\s*\<parser\s*$'
+   let ind = ind - shiftwidth()
+ endif
+
+ return ind
+
+endfunction
+
+" vim:sw=2

Git/usr/share/vim/vim81/indent/occam.vim

@@ -0,0 +1,187 @@
+" Vim indent file
+" Language:	occam
+" Maintainer:	Mario Schweigler <ms44@kent.ac.uk>
+" Last Change:	23 April 2003
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+"{{{  Settings
+" Set the occam indent function
+setlocal indentexpr=GetOccamIndent()
+" Indent after new line and after initial colon
+setlocal indentkeys=o,O,0=:
+"}}}
+
+" Only define the function once
+if exists("*GetOccamIndent")
+  finish
+endif
+let s:keepcpo= &cpo
+set cpo&vim
+
+"{{{  Indent definitions
+" Define carriage return indent
+let s:FirstLevelIndent = '^\C\s*\(IF\|ALT\|PRI\s\+ALT\|PAR\|SEQ\|PRI\s\+PAR\|WHILE\|VALOF\|CLAIM\|FORKING\)\>\|\(--.*\)\@<!\(\<PROC\>\|??\|\<CASE\>\s*\(--.*\)\=\_$\)'
+let s:FirstLevelNonColonEndIndent = '^\C\s*PROTOCOL\>\|\(--.*\)\@<!\<\(\(CHAN\|DATA\)\s\+TYPE\|FUNCTION\)\>'
+let s:SecondLevelIndent = '^\C\s*\(IF\|ALT\|PRI\s\+ALT\)\>\|\(--.*\)\@<!?\s*\<CASE\>\s*\(--.*\)\=\_$'
+let s:SecondLevelNonColonEndIndent = '\(--.*\)\@<!\<\(CHAN\|DATA\)\s\+TYPE\>'
+
+" Define colon indent
+let s:ColonIndent = '\(--.*\)\@<!\<PROC\>'
+let s:ColonNonColonEndIndent = '^\C\s*PROTOCOL\>\|\(--.*\)\@<!\<\(\(CHAN\|DATA\)\s\+TYPE\|FUNCTION\)\>'
+
+let s:ColonEnd = '\(--.*\)\@<!:\s*\(--.*\)\=$'
+let s:ColonStart = '^\s*:\s*\(--.*\)\=$'
+
+" Define comment
+let s:CommentLine = '^\s*--'
+"}}}
+
+"{{{  function GetOccamIndent()
+" Auxiliary function to get the correct indent for a line of occam code
+function GetOccamIndent()
+
+  " Ensure magic is on
+  let save_magic = &magic
+  setlocal magic
+
+  " Get reference line number
+  let linenum = prevnonblank(v:lnum - 1)
+  while linenum > 0 && getline(linenum) =~ s:CommentLine
+    let linenum = prevnonblank(linenum - 1)
+  endwhile
+
+  " Get current indent
+  let curindent = indent(linenum)
+
+  " Get current line
+  let line = getline(linenum)
+
+  " Get previous line number
+  let prevlinenum = prevnonblank(linenum - 1)
+  while prevlinenum > 0 && getline(prevlinenum) =~ s:CommentLine
+    let prevlinenum = prevnonblank(prevlinenum - 1)
+  endwhile
+
+  " Get previous line
+  let prevline = getline(prevlinenum)
+
+  " Colon indent
+  if getline(v:lnum) =~ s:ColonStart
+
+    let found = 0
+
+    while found < 1
+
+      if line =~ s:ColonStart
+	let found = found - 1
+      elseif line =~ s:ColonIndent || (line =~ s:ColonNonColonEndIndent && line !~ s:ColonEnd)
+	let found = found + 1
+      endif
+
+      if found < 1
+	let linenum = prevnonblank(linenum - 1)
+	if linenum > 0
+	  let line = getline(linenum)
+	else
+	  let found = 1
+	endif
+      endif
+
+    endwhile
+
+    if linenum > 0
+      let curindent = indent(linenum)
+    else
+      let colonline = getline(v:lnum)
+      let tabstr = ''
+      while strlen(tabstr) < &tabstop
+	let tabstr = ' ' . tabstr
+      endwhile
+      let colonline = substitute(colonline, '\t', tabstr, 'g')
+      let curindent = match(colonline, ':')
+    endif
+
+    " Restore magic
+    if !save_magic|setlocal nomagic|endif
+
+    return curindent
+  endif
+
+  if getline(v:lnum) =~ '^\s*:'
+    let colonline = getline(v:lnum)
+    let tabstr = ''
+    while strlen(tabstr) < &tabstop
+      let tabstr = ' ' . tabstr
+    endwhile
+    let colonline = substitute(colonline, '\t', tabstr, 'g')
+    let curindent = match(colonline, ':')
+
+    " Restore magic
+    if !save_magic|setlocal nomagic|endif
+
+    return curindent
+  endif
+
+  " Carriage return indenat
+  if line =~ s:FirstLevelIndent || (line =~ s:FirstLevelNonColonEndIndent && line !~ s:ColonEnd)
+	\ || (line !~ s:ColonStart && (prevline =~ s:SecondLevelIndent
+	\ || (prevline =~ s:SecondLevelNonColonEndIndent && prevline !~ s:ColonEnd)))
+    let curindent = curindent + shiftwidth()
+
+    " Restore magic
+    if !save_magic|setlocal nomagic|endif
+
+    return curindent
+  endif
+
+  " Commented line
+  if getline(prevnonblank(v:lnum - 1)) =~ s:CommentLine
+
+    " Restore magic
+    if !save_magic|setlocal nomagic|endif
+
+    return indent(prevnonblank(v:lnum - 1))
+  endif
+
+  " Look for previous second level IF / ALT / PRI ALT
+  let found = 0
+
+  while !found
+
+    if indent(prevlinenum) == curindent - shiftwidth()
+      let found = 1
+    endif
+
+    if !found
+      let prevlinenum = prevnonblank(prevlinenum - 1)
+      while prevlinenum > 0 && getline(prevlinenum) =~ s:CommentLine
+	let prevlinenum = prevnonblank(prevlinenum - 1)
+      endwhile
+      if prevlinenum == 0
+	let found = 1
+      endif
+    endif
+
+  endwhile
+
+  if prevlinenum > 0
+    if getline(prevlinenum) =~ s:SecondLevelIndent
+      let curindent = curindent + shiftwidth()
+    endif
+  endif
+
+  " Restore magic
+  if !save_magic|setlocal nomagic|endif
+
+  return curindent
+
+endfunction
+"}}}
+
+let &cpo = s:keepcpo
+unlet s:keepcpo

Git/usr/share/vim/vim81/indent/pascal.vim

@@ -0,0 +1,228 @@
+" Vim indent file
+" Language:    Pascal
+" Maintainer:  Neil Carter <n.carter@swansea.ac.uk>
+" Created:     2004 Jul 13
+" Last Change: 2017 Jun 13
+"
+" This is version 2.0, a complete rewrite.
+"
+" For further documentation, see http://psy.swansea.ac.uk/staff/carter/vim/
+
+
+if exists("b:did_indent")
+	finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetPascalIndent(v:lnum)
+setlocal indentkeys&
+setlocal indentkeys+==end;,==const,==type,==var,==begin,==repeat,==until,==for
+setlocal indentkeys+==program,==function,==procedure,==object,==private
+setlocal indentkeys+==record,==if,==else,==case
+
+if exists("*GetPascalIndent")
+	finish
+endif
+
+
+function! s:GetPrevNonCommentLineNum( line_num )
+
+	" Skip lines starting with a comment
+	let SKIP_LINES = '^\s*\(\((\*\)\|\(\*\ \)\|\(\*)\)\|{\|}\)'
+
+	let nline = a:line_num
+	while nline > 0
+		let nline = prevnonblank(nline-1)
+		if getline(nline) !~? SKIP_LINES
+			break
+		endif
+	endwhile
+
+	return nline
+endfunction
+
+
+function! s:PurifyCode( line_num )
+	" Strip any trailing comments and whitespace
+	let pureline = 'TODO'
+	return pureline
+endfunction
+
+
+function! GetPascalIndent( line_num )
+
+	" Line 0 always goes at column 0
+	if a:line_num == 0
+		return 0
+	endif
+
+	let this_codeline = getline( a:line_num )
+
+
+	" SAME INDENT
+
+	" Middle of a three-part comment
+	if this_codeline =~ '^\s*\*'
+		return indent( a:line_num - 1)
+	endif
+
+
+	" COLUMN 1 ALWAYS
+
+	" Last line of the program
+	if this_codeline =~ '^\s*end\.'
+		return 0
+	endif
+
+	" Compiler directives, allowing "(*" and "{"
+	"if this_codeline =~ '^\s*\({\|(\*\)$\(IFDEF\|IFNDEF\|ELSE\|ENDIF\)'
+	if this_codeline =~ '^\s*\({\|(\*\)\$'
+		return 0
+	endif
+
+	" section headers
+	if this_codeline =~ '^\s*\(program\|procedure\|function\|type\)\>'
+		return 0
+	endif
+
+	" Subroutine separators, lines ending with "const" or "var"
+	if this_codeline =~ '^\s*\((\*\ _\+\ \*)\|\(const\|var\)\)$'
+		return 0
+	endif
+
+
+	" OTHERWISE, WE NEED TO LOOK FURTHER BACK...
+
+	let prev_codeline_num = s:GetPrevNonCommentLineNum( a:line_num )
+	let prev_codeline = getline( prev_codeline_num )
+	let indnt = indent( prev_codeline_num )
+
+
+	" INCREASE INDENT
+
+	" If the PREVIOUS LINE ended in these items, always indent
+	if prev_codeline =~ '\<\(type\|const\|var\)$'
+		return indnt + shiftwidth()
+	endif
+
+	if prev_codeline =~ '\<repeat$'
+		if this_codeline !~ '^\s*until\>'
+			return indnt + shiftwidth()
+		else
+			return indnt
+		endif
+	endif
+
+	if prev_codeline =~ '\<\(begin\|record\)$'
+		if this_codeline !~ '^\s*end\>'
+			return indnt + shiftwidth()
+		else
+			return indnt
+		endif
+	endif
+
+	" If the PREVIOUS LINE ended with these items, indent if not
+	" followed by "begin"
+	if prev_codeline =~ '\<\(\|else\|then\|do\)$' || prev_codeline =~ ':$'
+		if this_codeline !~ '^\s*begin\>'
+			return indnt + shiftwidth()
+		else
+			" If it does start with "begin" then keep the same indent
+			"return indnt + shiftwidth()
+			return indnt
+		endif
+	endif
+
+	" Inside a parameter list (i.e. a "(" without a ")"). ???? Considers
+	" only the line before the current one. TODO: Get it working for
+	" parameter lists longer than two lines.
+	if prev_codeline =~ '([^)]\+$'
+		return indnt + shiftwidth()
+	endif
+
+
+	" DECREASE INDENT
+
+	" Lines starting with "else", but not following line ending with
+	" "end".
+	if this_codeline =~ '^\s*else\>' && prev_codeline !~ '\<end$'
+		return indnt - shiftwidth()
+	endif
+
+	" Lines after a single-statement branch/loop.
+	" Two lines before ended in "then", "else", or "do"
+	" Previous line didn't end in "begin"
+	let prev2_codeline_num = s:GetPrevNonCommentLineNum( prev_codeline_num )
+	let prev2_codeline = getline( prev2_codeline_num )
+	if prev2_codeline =~ '\<\(then\|else\|do\)$' && prev_codeline !~ '\<begin$'
+		" If the next code line after a single statement branch/loop
+		" starts with "end", "except" or "finally", we need an
+		" additional unindentation.
+		if this_codeline =~ '^\s*\(end;\|except\|finally\|\)$'
+			" Note that we don't return from here.
+			return indnt - 2 * shiftwidth()
+		endif
+		return indnt - shiftwidth()
+	endif
+
+	" Lines starting with "until" or "end". This rule must be overridden
+	" by the one for "end" after a single-statement branch/loop. In
+	" other words that rule should come before this one.
+	if this_codeline =~ '^\s*\(end\|until\)\>'
+		return indnt - shiftwidth()
+	endif
+
+
+	" MISCELLANEOUS THINGS TO CATCH
+
+	" Most "begin"s will have been handled by now. Any remaining
+	" "begin"s on their own line should go in column 1.
+	if this_codeline =~ '^\s*begin$'
+		return 0
+	endif
+
+
+" ____________________________________________________________________
+" Object/Borland Pascal/Delphi Extensions
+"
+" Note that extended-pascal is handled here, unless it is simpler to
+" handle them in the standard-pascal section above.
+
+
+	" COLUMN 1 ALWAYS
+
+	" section headers at start of line.
+	if this_codeline =~ '^\s*\(interface\|implementation\|uses\|unit\)\>'
+		return 0
+	endif
+
+
+	" INDENT ONCE
+
+	" If the PREVIOUS LINE ended in these items, always indent.
+	if prev_codeline =~ '^\s*\(unit\|uses\|try\|except\|finally\|private\|protected\|public\|published\)$'
+		return indnt + shiftwidth()
+	endif
+
+	" ???? Indent "procedure" and "functions" if they appear within an
+	" class/object definition. But that means overriding standard-pascal
+	" rule where these words always go in column 1.
+
+
+	" UNINDENT ONCE
+
+	if this_codeline =~ '^\s*\(except\|finally\)$'
+		return indnt - shiftwidth()
+	endif
+
+	if this_codeline =~ '^\s*\(private\|protected\|public\|published\)$'
+		return indnt - shiftwidth()
+	endif
+
+
+" ____________________________________________________________________
+
+	" If nothing changed, return same indent.
+	return indnt
+endfunction
+

Git/usr/share/vim/vim81/indent/perl.vim

@@ -0,0 +1,180 @@
+" Vim indent file
+" Language:      Perl 5
+" Maintainer:    vim-perl <vim-perl@googlegroups.com>
+" Homepage:      http://github.com/vim-perl/vim-perl
+" Bugs/requests: http://github.com/vim-perl/vim-perl/issues
+" Last Change:   2017-01-04
+
+" Suggestions and improvements by :
+"   Aaron J. Sherman (use syntax for hints)
+"   Artem Chuprina (play nice with folding)
+
+" TODO things that are not or not properly indented (yet) :
+" - Continued statements
+"     print "foo",
+"       "bar";
+"     print "foo"
+"       if bar();
+" - Multiline regular expressions (m//x)
+" (The following probably needs modifying the perl syntax file)
+" - qw() lists
+" - Heredocs with terminators that don't match \I\i*
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+" Is syntax highlighting active ?
+let b:indent_use_syntax = has("syntax")
+
+setlocal indentexpr=GetPerlIndent()
+setlocal indentkeys+=0=,0),0],0=or,0=and
+if !b:indent_use_syntax
+    setlocal indentkeys+=0=EO
+endif
+
+let s:cpo_save = &cpo
+set cpo-=C
+
+function! GetPerlIndent()
+
+    " Get the line to be indented
+    let cline = getline(v:lnum)
+
+    " Indent POD markers to column 0
+    if cline =~ '^\s*=\L\@!'
+        return 0
+    endif
+
+    " Get current syntax item at the line's first char
+    let csynid = ''
+    if b:indent_use_syntax
+        let csynid = synIDattr(synID(v:lnum,1,0),"name")
+    endif
+
+    " Don't reindent POD and heredocs
+    if csynid == "perlPOD" || csynid == "perlHereDoc" || csynid =~ "^pod"
+        return indent(v:lnum)
+    endif
+
+    " Indent end-of-heredocs markers to column 0
+    if b:indent_use_syntax
+        " Assumes that an end-of-heredoc marker matches \I\i* to avoid
+        " confusion with other types of strings
+        if csynid == "perlStringStartEnd" && cline =~ '^\I\i*$'
+            return 0
+        endif
+    else
+        " Without syntax hints, assume that end-of-heredocs markers begin with EO
+        if cline =~ '^\s*EO'
+            return 0
+        endif
+    endif
+
+    " Now get the indent of the previous perl line.
+
+    " Find a non-blank line above the current line.
+    let lnum = prevnonblank(v:lnum - 1)
+    " Hit the start of the file, use zero indent.
+    if lnum == 0
+        return 0
+    endif
+    let line = getline(lnum)
+    let ind = indent(lnum)
+    " Skip heredocs, POD, and comments on 1st column
+    if b:indent_use_syntax
+        let skippin = 2
+        while skippin
+            let synid = synIDattr(synID(lnum,1,0),"name")
+            if (synid == "perlStringStartEnd" && line =~ '^\I\i*$')
+                        \ || (skippin != 2 && synid == "perlPOD")
+                        \ || (skippin != 2 && synid == "perlHereDoc")
+                        \ || synid == "perlComment"
+                        \ || synid =~ "^pod"
+                let lnum = prevnonblank(lnum - 1)
+                if lnum == 0
+                    return 0
+                endif
+                let line = getline(lnum)
+                let ind = indent(lnum)
+                let skippin = 1
+            else
+                let skippin = 0
+            endif
+        endwhile
+    else
+        if line =~ "^EO"
+            let lnum = search("<<[\"']\\=EO", "bW")
+            let line = getline(lnum)
+            let ind = indent(lnum)
+        endif
+    endif
+
+    " Indent blocks enclosed by {}, (), or []
+    if b:indent_use_syntax
+        " Find a real opening brace
+        " NOTE: Unlike Perl character classes, we do NOT need to escape the
+        " closing brackets with a backslash.  Doing so just puts a backslash
+        " in the character class and causes sorrow.  Instead, put the closing
+        " bracket as the first character in the class.
+        let braceclass = '[][(){}]'
+        let bracepos = match(line, braceclass, matchend(line, '^\s*[])}]'))
+        while bracepos != -1
+            let synid = synIDattr(synID(lnum, bracepos + 1, 0), "name")
+            " If the brace is highlighted in one of those groups, indent it.
+            " 'perlHereDoc' is here only to handle the case '&foo(<<EOF)'.
+            if synid == ""
+                        \ || synid == "perlMatchStartEnd"
+                        \ || synid == "perlHereDoc"
+                        \ || synid == "perlBraces"
+                        \ || synid == "perlStatementIndirObj"
+                        \ || synid =~ "^perlFiledescStatement"
+                        \ || synid =~ '^perl\(Sub\|Block\|Package\)Fold'
+                let brace = strpart(line, bracepos, 1)
+                if brace == '(' || brace == '{' || brace == '['
+                    let ind = ind + shiftwidth()
+                else
+                    let ind = ind - shiftwidth()
+                endif
+            endif
+            let bracepos = match(line, braceclass, bracepos + 1)
+        endwhile
+        let bracepos = matchend(cline, '^\s*[])}]')
+        if bracepos != -1
+            let synid = synIDattr(synID(v:lnum, bracepos, 0), "name")
+            if synid == ""
+                        \ || synid == "perlMatchStartEnd"
+                        \ || synid == "perlBraces"
+                        \ || synid == "perlStatementIndirObj"
+                        \ || synid =~ '^perl\(Sub\|Block\|Package\)Fold'
+                let ind = ind - shiftwidth()
+            endif
+        endif
+    else
+        if line =~ '[{[(]\s*\(#[^])}]*\)\=$'
+            let ind = ind + shiftwidth()
+        endif
+        if cline =~ '^\s*[])}]'
+            let ind = ind - shiftwidth()
+        endif
+    endif
+
+    " Indent lines that begin with 'or' or 'and'
+    if cline =~ '^\s*\(or\|and\)\>'
+        if line !~ '^\s*\(or\|and\)\>'
+            let ind = ind + shiftwidth()
+        endif
+    elseif line =~ '^\s*\(or\|and\)\>'
+        let ind = ind - shiftwidth()
+    endif
+
+    return ind
+
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim:ts=8:sts=4:sw=4:expandtab:ft=vim

Git/usr/share/vim/vim81/indent/perl6.vim

@@ -0,0 +1,132 @@
+" Vim indent file
+" Language:      Perl 6
+" Maintainer:    vim-perl <vim-perl@googlegroups.com>
+" Homepage:      http://github.com/vim-perl/vim-perl
+" Bugs/requests: http://github.com/vim-perl/vim-perl/issues
+" Last Change:   2017 Jun 13
+" Contributors:  Andy Lester <andy@petdance.com>
+"                Hinrik Örn Sigurðsson <hinrik.sig@gmail.com>
+"
+" Adapted from indent/perl.vim by Rafael Garcia-Suarez <rgarciasuarez@free.fr>
+
+" Suggestions and improvements by :
+"   Aaron J. Sherman (use syntax for hints)
+"   Artem Chuprina (play nice with folding)
+" TODO:
+" This file still relies on stuff from the Perl 5 syntax file, which Perl 6
+" does not use.
+"
+" Things that are not or not properly indented (yet) :
+" - Continued statements
+"     print "foo",
+"       "bar";
+"     print "foo"
+"       if bar();
+" - Multiline regular expressions (m//x)
+" (The following probably needs modifying the perl syntax file)
+" - qw() lists
+" - Heredocs with terminators that don't match \I\i*
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+" Is syntax highlighting active ?
+let b:indent_use_syntax = has("syntax")
+
+setlocal indentexpr=GetPerl6Indent()
+
+" we reset it first because the Perl 5 indent file might have been loaded due
+" to a .pl/pm file extension, and indent files don't clean up afterwards
+setlocal indentkeys&
+
+setlocal indentkeys+=0=,0),0],0>,0»,0=or,0=and
+if !b:indent_use_syntax
+    setlocal indentkeys+=0=EO
+endif
+
+let s:cpo_save = &cpo
+set cpo-=C
+
+function! GetPerl6Indent()
+
+    " Get the line to be indented
+    let cline = getline(v:lnum)
+
+    " Indent POD markers to column 0
+    if cline =~ '^\s*=\L\@!'
+        return 0
+    endif
+
+    " Don't reindent coments on first column
+    if cline =~ '^#'
+        return 0
+    endif
+
+    " Get current syntax item at the line's first char
+    let csynid = ''
+    if b:indent_use_syntax
+        let csynid = synIDattr(synID(v:lnum,1,0),"name")
+    endif
+
+    " Don't reindent POD and heredocs
+    if csynid =~ "^p6Pod"
+        return indent(v:lnum)
+    endif
+
+
+    " Now get the indent of the previous perl line.
+
+    " Find a non-blank line above the current line.
+    let lnum = prevnonblank(v:lnum - 1)
+    " Hit the start of the file, use zero indent.
+    if lnum == 0
+        return 0
+    endif
+    let line = getline(lnum)
+    let ind = indent(lnum)
+    " Skip heredocs, POD, and comments on 1st column
+    if b:indent_use_syntax
+        let skippin = 2
+        while skippin
+            let synid = synIDattr(synID(lnum,1,0),"name")
+            if (synid =~ "^p6Pod" || synid =~ "p6Comment")
+                let lnum = prevnonblank(lnum - 1)
+                if lnum == 0
+                    return 0
+                endif
+                let line = getline(lnum)
+                let ind = indent(lnum)
+                let skippin = 1
+            else
+                let skippin = 0
+            endif
+        endwhile
+    endif
+
+        if line =~ '[<«\[{(]\s*\(#[^)}\]»>]*\)\=$'
+            let ind = ind + shiftwidth()
+        endif
+        if cline =~ '^\s*[)}\]»>]'
+            let ind = ind - shiftwidth()
+        endif
+
+    " Indent lines that begin with 'or' or 'and'
+    if cline =~ '^\s*\(or\|and\)\>'
+        if line !~ '^\s*\(or\|and\)\>'
+            let ind = ind + shiftwidth()
+        endif
+    elseif line =~ '^\s*\(or\|and\)\>'
+        let ind = ind - shiftwidth()
+    endif
+
+    return ind
+
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim:ts=8:sts=4:sw=4:expandtab:ft=vim

Git/usr/share/vim/vim81/indent/php.vim

@@ -0,0 +1,909 @@
+" Vim indent file
+" Language:	PHP
+" Author:	John Wellesz <John.wellesz (AT) teaser (DOT) fr>
+" URL:		http://www.2072productions.com/vim/indent/php.vim
+" Home:		https://github.com/2072/PHP-Indenting-for-VIm
+" Last Change:	2018 May 18th
+" Version:	1.66
+"
+"
+"	Type :help php-indent for available options
+"
+"	A fully commented version of this file is available on github
+"
+"
+"  If you find a bug, please open a ticket on github.com
+"  ( https://github.com/2072/PHP-Indenting-for-VIm/issues ) with an example of
+"  code that breaks the algorithm.
+"
+
+" NOTE: This script must be used with PHP syntax ON and with the php syntax
+"	script by Lutz Eymers (http://www.isp.de/data/php.vim ) or with the
+"	script by Peter Hodge (http://www.vim.org/scripts/script.php?script_id=1571 )
+"	the later is bunbdled by default with Vim 7.
+"
+"
+"	In the case you have syntax errors in your script such as HereDoc end
+"	identifiers not at col 1 you'll have to indent your file 2 times (This
+"	script will automatically put HereDoc end identifiers at col 1 if
+"	they are followed by a ';').
+"
+
+" NOTE: If you are editing files in Unix file format and that (by accident)
+"	there are '\r' before new lines, this script won't be able to proceed
+"	correctly and will make many mistakes because it won't be able to match
+"	'\s*$' correctly.
+"	So you have to remove those useless characters first with a command like:
+"
+"	:%s /\r$//g
+"
+"	or simply 'let' the option PHP_removeCRwhenUnix to 1 and the script will
+"	silently remove them when VIM load this script (at each bufread).
+
+
+
+if exists("b:did_indent")
+    finish
+endif
+let b:did_indent = 1
+
+
+let g:php_sync_method = 0
+
+
+if exists("PHP_default_indenting")
+    let b:PHP_default_indenting = PHP_default_indenting * shiftwidth()
+else
+    let b:PHP_default_indenting = 0
+endif
+
+if exists("PHP_outdentSLComments")
+    let b:PHP_outdentSLComments = PHP_outdentSLComments * shiftwidth()
+else
+    let b:PHP_outdentSLComments = 0
+endif
+
+if exists("PHP_BracesAtCodeLevel")
+    let b:PHP_BracesAtCodeLevel = PHP_BracesAtCodeLevel
+else
+    let b:PHP_BracesAtCodeLevel = 0
+endif
+
+
+if exists("PHP_autoformatcomment")
+    let b:PHP_autoformatcomment = PHP_autoformatcomment
+else
+    let b:PHP_autoformatcomment = 1
+endif
+
+if exists("PHP_outdentphpescape")
+    let b:PHP_outdentphpescape = PHP_outdentphpescape
+else
+    let b:PHP_outdentphpescape = 1
+endif
+
+if exists("PHP_noArrowMatching")
+    let b:PHP_noArrowMatching = PHP_noArrowMatching
+else
+    let b:PHP_noArrowMatching = 0
+endif
+
+
+if exists("PHP_vintage_case_default_indent") && PHP_vintage_case_default_indent
+    let b:PHP_vintage_case_default_indent = 1
+else
+    let b:PHP_vintage_case_default_indent = 0
+endif
+
+
+
+let b:PHP_lastindented = 0
+let b:PHP_indentbeforelast = 0
+let b:PHP_indentinghuge = 0
+let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
+let b:PHP_LastIndentedWasComment = 0
+let b:PHP_InsideMultilineComment = 0
+let b:InPHPcode = 0
+let b:InPHPcode_checked = 0
+let b:InPHPcode_and_script = 0
+let b:InPHPcode_tofind = ""
+let b:PHP_oldchangetick = b:changedtick
+let b:UserIsTypingComment = 0
+let b:optionsset = 0
+
+setlocal nosmartindent
+setlocal noautoindent
+setlocal nocindent
+setlocal nolisp
+
+setlocal indentexpr=GetPhpIndent()
+setlocal indentkeys=0{,0},0),0],:,!^F,o,O,e,*<Return>,=?>,=<?,=*/
+
+
+
+let s:searchpairflags = 'bWr'
+
+if &fileformat == "unix" && exists("PHP_removeCRwhenUnix") && PHP_removeCRwhenUnix
+    silent! %s/\r$//g
+endif
+
+if exists("*GetPhpIndent")
+    call ResetPhpOptions()
+    finish
+endif
+
+
+let s:PHP_validVariable = '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
+let s:notPhpHereDoc = '\%(break\|return\|continue\|exit\|die\|else\)'
+let s:blockstart = '\%(\%(\%(}\s*\)\=else\%(\s\+\)\=\)\=if\>\|\%(}\s*\)\?else\>\|do\>\|while\>\|switch\>\|case\>\|default\>\|for\%(each\)\=\>\|declare\>\|class\>\|trait\>\|use\>\|interface\>\|abstract\>\|final\>\|try\>\|\%(}\s*\)\=catch\>\|\%(}\s*\)\=finally\>\)'
+let s:functionDecl = '\<function\>\%(\s\+&\='.s:PHP_validVariable.'\)\=\s*(.*'
+let s:endline = '\s*\%(//.*\|#.*\|/\*.*\*/\s*\)\=$'
+let s:unstated = '\%(^\s*'.s:blockstart.'.*)\|\%(//.*\)\@<!\<e'.'lse\>\)'.s:endline
+
+
+let s:terminated = '\%(\%(;\%(\s*\%(?>\|}\)\)\=\|<<<\s*[''"]\=\a\w*[''"]\=$\|^\s*}\|^\s*'.s:PHP_validVariable.':\)'.s:endline.'\)'
+let s:PHP_startindenttag = '<?\%(.*?>\)\@!\|<script[^>]*>\%(.*<\/script>\)\@!'
+let s:structureHead = '^\s*\%(' . s:blockstart . '\)\|'. s:functionDecl . s:endline . '\|\<new\s\+class\>'
+
+
+let s:escapeDebugStops = 0
+function! DebugPrintReturn(scriptLine)
+
+    if ! s:escapeDebugStops
+	echo "debug:" . a:scriptLine
+	let c = getchar()
+	if c == "\<Del>"
+	    let s:escapeDebugStops = 1
+	end
+    endif
+
+endfunction
+
+function! GetLastRealCodeLNum(startline) " {{{
+
+    let lnum = a:startline
+
+    if b:GetLastRealCodeLNum_ADD && b:GetLastRealCodeLNum_ADD == lnum + 1
+	let lnum = b:GetLastRealCodeLNum_ADD
+    endif
+
+    while lnum > 1
+	let lnum = prevnonblank(lnum)
+	let lastline = getline(lnum)
+
+	if b:InPHPcode_and_script && lastline =~ '?>\s*$'
+	    let lnum = lnum - 1
+	elseif lastline =~ '^\s*?>.*<?\%(php\)\=\s*$'
+	    let lnum = lnum - 1
+	elseif lastline =~ '^\s*\%(//\|#\|/\*.*\*/\s*$\)'
+	    let lnum = lnum - 1
+	elseif lastline =~ '\*/\s*$'
+	    call cursor(lnum, 1)
+	    if lastline !~ '^\*/'
+		call search('\*/', 'W')
+	    endif
+	    let lnum = searchpair('/\*', '', '\*/', s:searchpairflags, 'Skippmatch2()')
+
+	    let lastline = getline(lnum)
+	    if lastline =~ '^\s*/\*'
+		let lnum = lnum - 1
+	    else
+		break
+	    endif
+
+
+	elseif lastline =~? '\%(//\s*\|?>.*\)\@<!<?\%(php\)\=\s*$\|^\s*<script\>'
+
+	    while lastline !~ '\(<?.*\)\@<!?>' && lnum > 1
+		let lnum = lnum - 1
+		let lastline = getline(lnum)
+	    endwhile
+	    if lastline =~ '^\s*?>'
+		let lnum = lnum - 1
+	    else
+		break
+	    endif
+
+
+	elseif lastline =~? '^\a\w*;\=$' && lastline !~? s:notPhpHereDoc
+	    let tofind=substitute( lastline, '\(\a\w*\);\=', '<<<\\s*[''"]\\=\1[''"]\\=$', '')
+	    while getline(lnum) !~? tofind && lnum > 1
+		let lnum = lnum - 1
+	    endwhile
+	elseif lastline =~ '^[^''"`]*[''"`][;,]'.s:endline
+
+	    let tofind=substitute( lastline, '^.*\([''"`]\)[;,].*$', '^[^\1]\\+[\1]$\\|^[^\1]\\+[=([]\\s*[\1]', '')
+	    let trylnum = lnum
+	    while getline(trylnum) !~? tofind && trylnum > 1
+		let trylnum = trylnum - 1
+	    endwhile
+
+	    if trylnum == 1
+		break
+	    else
+		if lastline =~ ';'.s:endline
+		    while getline(trylnum) !~? s:terminated && getline(trylnum) !~? '{'.s:endline && trylnum > 1
+			let trylnum = prevnonblank(trylnum - 1)
+		    endwhile
+
+
+		    if trylnum == 1
+			break
+		    end
+		end
+		let lnum = trylnum
+	    end
+	else
+	    break
+	endif
+    endwhile
+
+    if lnum==1 && getline(lnum) !~ '<?'
+	let lnum=0
+    endif
+
+    if b:InPHPcode_and_script && 1 > b:InPHPcode
+	let b:InPHPcode_and_script = 0
+    endif
+
+    return lnum
+endfunction " }}}
+
+function! Skippmatch2()
+
+    let line = getline(".")
+
+    if line =~ "\\([\"']\\).*/\\*.*\\1" || line =~ '\%(//\|#\).*/\*'
+	return 1
+    else
+	return 0
+    endif
+endfun
+
+function! Skippmatch()	" {{{
+    let synname = synIDattr(synID(line("."), col("."), 0), "name")
+    if synname ==? "Delimiter" || synname ==? "phpRegionDelimiter" || synname =~? "^phpParent" || synname ==? "phpArrayParens" || synname =~? '^php\%(Block\|Brace\)' || synname ==? "javaScriptBraces" || synname =~? '^php\%(Doc\)\?Comment' && b:UserIsTypingComment
+	return 0
+    else
+	return 1
+    endif
+endfun " }}}
+
+function! FindOpenBracket(lnum, blockStarter) " {{{
+    call cursor(a:lnum, 1)
+    let line = searchpair('{', '', '}', 'bW', 'Skippmatch()')
+
+    if a:blockStarter == 1
+	while line > 1
+	    let linec = getline(line)
+
+	    if linec =~ s:terminated || linec =~ s:structureHead
+		break
+	    endif
+
+	    let line = GetLastRealCodeLNum(line - 1)
+	endwhile
+    endif
+
+    return line
+endfun " }}}
+
+let s:blockChars = {'{':1, '[': 1, '(': 1, ')':-1, ']':-1, '}':-1}
+function! BalanceDirection (str)
+
+    let balance = 0
+
+    for c in split(a:str, '\zs')
+	if has_key(s:blockChars, c)
+	    let balance += s:blockChars[c]
+	endif
+    endfor
+
+    return balance
+endfun
+
+function! StripEndlineComments (line)
+    return substitute(a:line,"\\(//\\|#\\)\\(\\(\\([^\"']*\\([\"']\\)[^\"']*\\5\\)\\+[^\"']*$\\)\\|\\([^\"']*$\\)\\)",'','')
+endfun
+
+function! FindArrowIndent (lnum)  " {{{
+
+    let parrentArrowPos = 0
+    let lnum = a:lnum
+    while lnum > 1
+	let last_line = getline(lnum)
+	if last_line =~ '^\s*->'
+	    let parrentArrowPos = indent(a:lnum)
+	    break
+	else
+	    call cursor(lnum, 1)
+	    let cleanedLnum = StripEndlineComments(last_line)
+	    if cleanedLnum =~ '->'
+		if ! b:PHP_noArrowMatching
+		    let parrentArrowPos = searchpos('->', 'W', lnum)[1] - 1
+		else
+		    let parrentArrowPos = indent(lnum) + shiftwidth()
+		endif
+		break
+	    elseif cleanedLnum =~ ')'.s:endline && BalanceDirection(last_line) < 0
+		call searchpos(')'.s:endline, 'cW', lnum)
+		let openedparent = searchpair('(', '', ')', 'bW', 'Skippmatch()')
+		if openedparent != lnum
+		    let lnum = openedparent
+		else
+		    let openedparent = -1
+		endif
+
+	    else
+		let parrentArrowPos = indent(lnum) + shiftwidth()
+		break
+	    endif
+	endif
+    endwhile
+
+    return parrentArrowPos
+endfun "}}}
+
+function! FindTheIfOfAnElse (lnum, StopAfterFirstPrevElse) " {{{
+
+    if getline(a:lnum) =~# '^\s*}\s*else\%(if\)\=\>'
+	let beforeelse = a:lnum
+    else
+	let beforeelse = GetLastRealCodeLNum(a:lnum - 1)
+    endif
+
+    if !s:level
+	let s:iftoskip = 0
+    endif
+
+    if getline(beforeelse) =~# '^\s*\%(}\s*\)\=else\%(\s*if\)\@!\>'
+	let s:iftoskip = s:iftoskip + 1
+    endif
+
+    if getline(beforeelse) =~ '^\s*}'
+	let beforeelse = FindOpenBracket(beforeelse, 0)
+
+	if getline(beforeelse) =~ '^\s*{'
+	    let beforeelse = GetLastRealCodeLNum(beforeelse - 1)
+	endif
+    endif
+
+
+    if !s:iftoskip && a:StopAfterFirstPrevElse && getline(beforeelse) =~# '^\s*\%([}]\s*\)\=else\%(if\)\=\>'
+	return beforeelse
+    endif
+
+    if getline(beforeelse) !~# '^\s*if\>' && beforeelse>1 || s:iftoskip && beforeelse>1
+
+	if s:iftoskip && getline(beforeelse) =~# '^\s*if\>'
+	    let s:iftoskip = s:iftoskip - 1
+	endif
+
+	let s:level =  s:level + 1
+	let beforeelse = FindTheIfOfAnElse(beforeelse, a:StopAfterFirstPrevElse)
+    endif
+
+    return beforeelse
+
+endfunction " }}}
+
+let s:defaultORcase = '^\s*\%(default\|case\).*:'
+
+function! FindTheSwitchIndent (lnum) " {{{
+
+    let test = GetLastRealCodeLNum(a:lnum - 1)
+
+    if test <= 1
+	return indent(1) - shiftwidth() * b:PHP_vintage_case_default_indent
+    end
+
+    while getline(test) =~ '^\s*}' && test > 1
+	let test = GetLastRealCodeLNum(FindOpenBracket(test, 0) - 1)
+
+	if getline(test) =~ '^\s*switch\>'
+	    let test = GetLastRealCodeLNum(test - 1)
+	endif
+    endwhile
+
+    if getline(test) =~# '^\s*switch\>'
+	return indent(test)
+    elseif getline(test) =~# s:defaultORcase
+	return indent(test) - shiftwidth() * b:PHP_vintage_case_default_indent
+    else
+	return FindTheSwitchIndent(test)
+    endif
+
+endfunction "}}}
+
+let s:SynPHPMatchGroups = {'phpparent':1, 'delimiter':1, 'define':1, 'storageclass':1, 'structure':1, 'exception':1}
+function! IslinePHP (lnum, tofind) " {{{
+    let cline = getline(a:lnum)
+
+    if a:tofind==""
+	let tofind = "^\\s*[\"'`]*\\s*\\zs\\S"
+    else
+	let tofind = a:tofind
+    endif
+
+    let tofind = tofind . '\c'
+
+    let coltotest = match (cline, tofind) + 1
+
+    let synname = synIDattr(synID(a:lnum, coltotest, 0), "name")
+
+    if synname ==? 'phpStringSingle' || synname ==? 'phpStringDouble' || synname ==? 'phpBacktick'
+	if cline !~ '^\s*[''"`]'
+	    return "SpecStringEntrails"
+	else
+	    return synname
+	end
+    end
+
+    if get(s:SynPHPMatchGroups, tolower(synname)) || synname =~ '^php' ||  synname =~? '^javaScript'
+	return synname
+    else
+	return ""
+    endif
+endfunction " }}}
+
+let s:autoresetoptions = 0
+if ! s:autoresetoptions
+    let s:autoresetoptions = 1
+endif
+
+function! ResetPhpOptions()
+    if ! b:optionsset && &filetype =~ "php"
+	if b:PHP_autoformatcomment
+
+	    setlocal comments=s1:/*,mb:*,ex:*/,://,:#
+
+	    setlocal formatoptions-=t
+	    setlocal formatoptions+=q
+	    setlocal formatoptions+=r
+	    setlocal formatoptions+=o
+	    setlocal formatoptions+=c
+	    setlocal formatoptions+=b
+	endif
+	let b:optionsset = 1
+    endif
+endfunc
+
+call ResetPhpOptions()
+
+function! GetPhpIndentVersion()
+    return "1.66-bundle"
+endfun
+
+function! GetPhpIndent()
+
+    let b:GetLastRealCodeLNum_ADD = 0
+
+    let UserIsEditing=0
+    if	b:PHP_oldchangetick != b:changedtick
+	let b:PHP_oldchangetick = b:changedtick
+	let UserIsEditing=1
+    endif
+
+    if b:PHP_default_indenting
+	let b:PHP_default_indenting = g:PHP_default_indenting * shiftwidth()
+    endif
+
+    let cline = getline(v:lnum)
+
+    if !b:PHP_indentinghuge && b:PHP_lastindented > b:PHP_indentbeforelast
+	if b:PHP_indentbeforelast
+	    let b:PHP_indentinghuge = 1
+	endif
+	let b:PHP_indentbeforelast = b:PHP_lastindented
+    endif
+
+    if b:InPHPcode_checked && prevnonblank(v:lnum - 1) != b:PHP_lastindented
+	if b:PHP_indentinghuge
+	    let b:PHP_indentinghuge = 0
+	    let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
+	endif
+	let real_PHP_lastindented = v:lnum
+	let b:PHP_LastIndentedWasComment=0
+	let b:PHP_InsideMultilineComment=0
+	let b:PHP_indentbeforelast = 0
+
+	let b:InPHPcode = 0
+	let b:InPHPcode_checked = 0
+	let b:InPHPcode_and_script = 0
+	let b:InPHPcode_tofind = ""
+
+    elseif v:lnum > b:PHP_lastindented
+	let real_PHP_lastindented = b:PHP_lastindented
+    else
+	let real_PHP_lastindented = v:lnum
+    endif
+
+    let b:PHP_lastindented = v:lnum
+
+
+    if !b:InPHPcode_checked " {{{ One time check
+	let b:InPHPcode_checked = 1
+	let b:UserIsTypingComment = 0
+
+	let synname = ""
+	if cline !~ '<?.*?>'
+	    let synname = IslinePHP (prevnonblank(v:lnum), "")
+	endif
+
+	if synname!=""
+	    if synname ==? "SpecStringEntrails"
+		let b:InPHPcode = -1 " thumb down
+		let b:InPHPcode_tofind = ""
+	    elseif synname !=? "phpHereDoc" && synname !=? "phpHereDocDelimiter"
+		let b:InPHPcode = 1
+		let b:InPHPcode_tofind = ""
+
+		if synname =~? '^php\%(Doc\)\?Comment'
+		    let b:UserIsTypingComment = 1
+		    let b:InPHPcode_checked = 0
+		endif
+
+		if synname =~? '^javaScript'
+		    let b:InPHPcode_and_script = 1
+		endif
+
+	    else
+		let b:InPHPcode = 0
+
+		let lnum = v:lnum - 1
+		while getline(lnum) !~? '<<<\s*[''"]\=\a\w*[''"]\=$' && lnum > 1
+		    let lnum = lnum - 1
+		endwhile
+
+		let b:InPHPcode_tofind = substitute( getline(lnum), '^.*<<<\s*[''"]\=\(\a\w*\)[''"]\=$', '^\\s*\1;\\=$', '')
+	    endif
+	else
+	    let b:InPHPcode = 0
+	    let b:InPHPcode_tofind = s:PHP_startindenttag
+	endif
+    endif "!b:InPHPcode_checked }}}
+
+
+    " Test if we are indenting PHP code {{{
+    let lnum = prevnonblank(v:lnum - 1)
+    let last_line = getline(lnum)
+    let endline= s:endline
+
+    if b:InPHPcode_tofind!=""
+	if cline =~? b:InPHPcode_tofind
+	    let b:InPHPcode_tofind = ""
+	    let b:UserIsTypingComment = 0
+
+	    if b:InPHPcode == -1
+		let b:InPHPcode = 1
+		return -1
+	    end
+
+	    let b:InPHPcode = 1
+
+	    if cline =~ '\*/'
+		call cursor(v:lnum, 1)
+		if cline !~ '^\*/'
+		    call search('\*/', 'W')
+		endif
+		let lnum = searchpair('/\*', '', '\*/', s:searchpairflags, 'Skippmatch2()')
+
+		let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
+
+		let b:PHP_LastIndentedWasComment = 0
+
+		if cline =~ '^\s*\*/'
+		    return indent(lnum) + 1
+		else
+		    return indent(lnum)
+		endif
+
+	    elseif cline =~? '<script\>'
+		let b:InPHPcode_and_script = 1
+		let b:GetLastRealCodeLNum_ADD = v:lnum
+	    endif
+	endif
+    endif
+
+    if 1 == b:InPHPcode
+
+	if !b:InPHPcode_and_script && last_line =~ '\%(<?.*\)\@<!?>\%(.*<?\)\@!' && IslinePHP(lnum, '?>')=~?"Delimiter"
+	    if cline !~? s:PHP_startindenttag
+		let b:InPHPcode = 0
+		let b:InPHPcode_tofind = s:PHP_startindenttag
+	    elseif cline =~? '<script\>'
+		let b:InPHPcode_and_script = 1
+	    endif
+
+	elseif last_line =~ '^[^''"`]\+[''"`]$' " a string identifier with nothing after it and no other string identifier before
+	    let b:InPHPcode = -1
+	    let b:InPHPcode_tofind = substitute( last_line, '^.*\([''"`]\).*$', '^[^\1]*\1[;,]$', '')
+	elseif last_line =~? '<<<\s*[''"]\=\a\w*[''"]\=$'
+	    let b:InPHPcode = 0
+	    let b:InPHPcode_tofind = substitute( last_line, '^.*<<<\s*[''"]\=\(\a\w*\)[''"]\=$', '^\\s*\1;\\=$', '')
+
+	elseif !UserIsEditing && cline =~ '^\s*/\*\%(.*\*/\)\@!' && getline(v:lnum + 1) !~ '^\s*\*'
+	    let b:InPHPcode = 0
+	    let b:InPHPcode_tofind = '\*/'
+
+	elseif cline =~? '^\s*</script>'
+	    let b:InPHPcode = 0
+	    let b:InPHPcode_tofind = s:PHP_startindenttag
+	endif
+    endif " }}}
+
+
+    if 1 > b:InPHPcode && !b:InPHPcode_and_script
+	return -1
+    endif
+
+    " Indent successive // or # comment the same way the first is {{{
+    let addSpecial = 0
+    if cline =~ '^\s*\%(//\|#\|/\*.*\*/\s*$\)'
+	let addSpecial = b:PHP_outdentSLComments
+	if b:PHP_LastIndentedWasComment == 1
+	    return indent(real_PHP_lastindented)
+	endif
+	let b:PHP_LastIndentedWasComment = 1
+    else
+	let b:PHP_LastIndentedWasComment = 0
+    endif " }}}
+
+    " Indent multiline /* comments correctly {{{
+
+    if b:PHP_InsideMultilineComment || b:UserIsTypingComment
+	if cline =~ '^\s*\*\%(\/\)\@!'
+	    if last_line =~ '^\s*/\*'
+		return indent(lnum) + 1
+	    else
+		return indent(lnum)
+	    endif
+	else
+	    let b:PHP_InsideMultilineComment = 0
+	endif
+    endif
+
+    if !b:PHP_InsideMultilineComment && cline =~ '^\s*/\*\%(.*\*/\)\@!'
+	if getline(v:lnum + 1) !~ '^\s*\*'
+	    return -1
+	endif
+	let b:PHP_InsideMultilineComment = 1
+    endif " }}}
+
+
+    " Things always indented at col 1 (PHP delimiter: <?, ?>, Heredoc end) {{{
+    if cline =~# '^\s*<?' && cline !~ '?>' && b:PHP_outdentphpescape
+	return 0
+    endif
+
+    if	cline =~ '^\s*?>' && cline !~# '<?' && b:PHP_outdentphpescape
+	return 0
+    endif
+
+    if cline =~? '^\s*\a\w*;$\|^\a\w*$\|^\s*[''"`][;,]' && cline !~? s:notPhpHereDoc
+	return 0
+    endif " }}}
+
+    let s:level = 0
+
+    let lnum = GetLastRealCodeLNum(v:lnum - 1)
+
+    let last_line = getline(lnum)
+    let ind = indent(lnum)
+
+    if ind==0 && b:PHP_default_indenting
+	let ind = b:PHP_default_indenting
+    endif
+
+    if lnum == 0
+	return b:PHP_default_indenting + addSpecial
+    endif
+
+
+    if cline =~ '^\s*}\%(}}\)\@!'
+	let ind = indent(FindOpenBracket(v:lnum, 1))
+	let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
+	return ind
+    endif
+
+    if cline =~ '^\s*\*/'
+	call cursor(v:lnum, 1)
+	if cline !~ '^\*/'
+	    call search('\*/', 'W')
+	endif
+	let lnum = searchpair('/\*', '', '\*/', s:searchpairflags, 'Skippmatch2()')
+
+	let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
+
+	if cline =~ '^\s*\*/'
+	    return indent(lnum) + 1
+	else
+	    return indent(lnum)
+	endif
+    endif
+
+
+    if last_line =~ '[;}]'.endline && last_line !~ '^[)\]]' && last_line !~# s:defaultORcase
+	if ind==b:PHP_default_indenting
+	    return b:PHP_default_indenting + addSpecial
+	elseif b:PHP_indentinghuge && ind==b:PHP_CurrentIndentLevel && cline !~# '^\s*\%(else\|\%(case\|default\).*:\|[})];\=\)' && last_line !~# '^\s*\%(\%(}\s*\)\=else\)' && getline(GetLastRealCodeLNum(lnum - 1))=~';'.endline
+	    return b:PHP_CurrentIndentLevel + addSpecial
+	endif
+    endif
+
+    let LastLineClosed = 0
+
+    let terminated = s:terminated
+
+    let unstated  = s:unstated
+
+
+    if ind != b:PHP_default_indenting && cline =~# '^\s*else\%(if\)\=\>'
+	let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
+	return indent(FindTheIfOfAnElse(v:lnum, 1))
+    elseif cline =~# s:defaultORcase
+	return FindTheSwitchIndent(v:lnum) + shiftwidth() * b:PHP_vintage_case_default_indent
+    elseif cline =~ '^\s*)\=\s*{'
+	let previous_line = last_line
+	let last_line_num = lnum
+
+	while last_line_num > 1
+
+	    if previous_line =~ terminated || previous_line =~ s:structureHead
+
+		let ind = indent(last_line_num)
+
+		if  b:PHP_BracesAtCodeLevel
+		    let ind = ind + shiftwidth()
+		endif
+
+		return ind
+	    endif
+
+	    let last_line_num = GetLastRealCodeLNum(last_line_num - 1)
+	    let previous_line = getline(last_line_num)
+	endwhile
+    elseif cline =~ '^\s*->'
+	return FindArrowIndent(lnum)
+    elseif last_line =~# unstated && cline !~ '^\s*);\='.endline
+	let ind = ind + shiftwidth() " we indent one level further when the preceding line is not stated
+	return ind + addSpecial
+
+    elseif (ind != b:PHP_default_indenting || last_line =~ '^[)\]]' ) && last_line =~ terminated
+	let previous_line = last_line
+	let last_line_num = lnum
+	let LastLineClosed = 1
+
+	let isSingleLineBlock = 0
+	while 1
+	    if ! isSingleLineBlock && previous_line =~ '^\s*}\|;\s*}'.endline
+
+		call cursor(last_line_num, 1)
+		if previous_line !~ '^}'
+		    call search('}\|;\s*}'.endline, 'W')
+		end
+		let oldLastLine = last_line_num
+		let last_line_num = searchpair('{', '', '}', 'bW', 'Skippmatch()')
+
+		if getline(last_line_num) =~ '^\s*{'
+		    let last_line_num = GetLastRealCodeLNum(last_line_num - 1)
+		elseif oldLastLine == last_line_num
+		    let isSingleLineBlock = 1
+		    continue
+		endif
+
+		let previous_line = getline(last_line_num)
+
+		continue
+	    else
+		let isSingleLineBlock = 0
+
+		if getline(last_line_num) =~# '^\s*else\%(if\)\=\>'
+		    let last_line_num = FindTheIfOfAnElse(last_line_num, 0)
+		    continue
+		endif
+
+
+		let last_match = last_line_num
+
+		let one_ahead_indent = indent(last_line_num)
+		let last_line_num = GetLastRealCodeLNum(last_line_num - 1)
+		let two_ahead_indent = indent(last_line_num)
+		let after_previous_line = previous_line
+		let previous_line = getline(last_line_num)
+
+
+		if previous_line =~# s:defaultORcase.'\|{'.endline
+		    break
+		endif
+
+		if after_previous_line=~# '^\s*'.s:blockstart.'.*)'.endline && previous_line =~# '[;}]'.endline
+		    break
+		endif
+
+		if one_ahead_indent == two_ahead_indent || last_line_num < 1
+		    if previous_line =~# '\%(;\|^\s*}\)'.endline || last_line_num < 1
+			break
+		    endif
+		endif
+	    endif
+	endwhile
+
+	if indent(last_match) != ind
+	    let ind = indent(last_match)
+	    let b:PHP_CurrentIndentLevel = b:PHP_default_indenting
+
+	    return ind + addSpecial
+	endif
+    endif
+
+    if (last_line !~ '^\s*}\%(}}\)\@!')
+	let plinnum = GetLastRealCodeLNum(lnum - 1)
+    else
+	let plinnum = GetLastRealCodeLNum(FindOpenBracket(lnum, 1) - 1)
+    endif
+
+    let AntepenultimateLine = getline(plinnum)
+
+    let last_line = StripEndlineComments(last_line)
+
+    if ind == b:PHP_default_indenting
+	if last_line =~ terminated && last_line !~# s:defaultORcase
+	    let LastLineClosed = 1
+	endif
+    endif
+
+    if !LastLineClosed
+
+	let openedparent = -1
+
+
+	if last_line =~# '[{(\[]'.endline || last_line =~? '\h\w*\s*(.*,$' && AntepenultimateLine !~ '[,(\[]'.endline && BalanceDirection(last_line) > 0
+
+	    let dontIndent = 0
+	    if last_line =~ '\S\+\s*{'.endline && last_line !~ '^\s*[)\]]\+\(\s*:\s*'.s:PHP_validVariable.'\)\=\s*{'.endline && last_line !~ s:structureHead
+		let dontIndent = 1
+	    endif
+
+	    if !dontIndent && (!b:PHP_BracesAtCodeLevel || last_line !~# '^\s*{')
+		let ind = ind + shiftwidth()
+	    endif
+
+	    if b:PHP_BracesAtCodeLevel || b:PHP_vintage_case_default_indent == 1
+		let b:PHP_CurrentIndentLevel = ind
+
+	    endif
+
+	elseif last_line =~ '),'.endline && BalanceDirection(last_line) < 0
+	    call cursor(lnum, 1)
+	    call searchpos('),'.endline, 'cW')
+	    let openedparent = searchpair('(', '', ')', 'bW', 'Skippmatch()')
+	    if openedparent != lnum
+		let ind = indent(openedparent)
+	    endif
+
+	elseif last_line =~ s:structureHead
+	    let ind = ind + shiftwidth()
+
+
+	elseif AntepenultimateLine =~ '{'.endline && AntepenultimateLine !~? '^\s*use\>' || AntepenultimateLine =~ terminated || AntepenultimateLine =~# s:defaultORcase
+	    let ind = ind + shiftwidth()
+	endif
+
+
+	if openedparent >= 0
+	    let last_line = StripEndlineComments(getline(openedparent))
+	endif
+    endif
+
+    if cline =~ '^\s*[)\]];\='
+	let ind = ind - shiftwidth()
+    endif
+
+    if last_line =~ '^\s*->' && last_line !~? s:structureHead && BalanceDirection(last_line) <= 0
+	let ind = ind - shiftwidth()
+    endif
+
+    let b:PHP_CurrentIndentLevel = ind
+    return ind + addSpecial
+endfunction

Git/usr/share/vim/vim81/indent/postscr.vim

@@ -0,0 +1,68 @@
+" PostScript indent file
+" Language:    PostScript
+" Maintainer:  Mike Williams <mrw@netcomuk.co.uk>
+" Last Change: 2nd July 2001
+"
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=PostscrIndentGet(v:lnum)
+setlocal indentkeys+=0],0=>>,0=%%,0=end,0=restore,0=grestore indentkeys-=:,0#,e
+
+" Catch multiple instantiations
+if exists("*PostscrIndentGet")
+  finish
+endif
+
+function! PostscrIndentGet(lnum)
+  " Find a non-empty non-comment line above the current line.
+  " Note: ignores DSC comments as well!
+  let lnum = a:lnum - 1
+  while lnum != 0
+    let lnum = prevnonblank(lnum)
+    if getline(lnum) !~ '^\s*%.*$'
+      break
+    endif
+    let lnum = lnum - 1
+  endwhile
+
+  " Hit the start of the file, use user indent.
+  if lnum == 0
+    return -1
+  endif
+
+  " Start with the indent of the previous line
+  let ind = indent(lnum)
+  let pline = getline(lnum)
+
+  " Indent for dicts, arrays, and saves with possible trailing comment
+  if pline =~ '\(begin\|<<\|g\=save\|{\|[\)\s*\(%.*\)\=$'
+    let ind = ind + shiftwidth()
+  endif
+
+  " Remove indent for popped dicts, and restores.
+  if pline =~ '\(end\|g\=restore\)\s*$'
+    let ind = ind - shiftwidth()
+
+  " Else handle immediate dedents of dicts, restores, and arrays.
+  elseif getline(a:lnum) =~ '\(end\|>>\|g\=restore\|}\|]\)'
+    let ind = ind - shiftwidth()
+
+  " Else handle DSC comments - always start of line.
+  elseif getline(a:lnum) =~ '^\s*%%'
+    let ind = 0
+  endif
+
+  " For now catch excessive left indents if they occur.
+  if ind < 0
+    let ind = -1
+  endif
+
+  return ind
+endfunction
+
+" vim:sw=2

Git/usr/share/vim/vim81/indent/pov.vim

@@ -0,0 +1,84 @@
+" Vim indent file
+" Language: PoV-Ray Scene Description Language
+" Maintainer: David Necas (Yeti) <yeti@physics.muni.cz>
+" Last Change: 2017 Jun 13
+" URI: http://trific.ath.cx/Ftp/vim/indent/pov.vim
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+" Some preliminary settings.
+setlocal nolisp " Make sure lisp indenting doesn't supersede us.
+
+setlocal indentexpr=GetPoVRayIndent()
+setlocal indentkeys+==else,=end,0]
+
+" Only define the function once.
+if exists("*GetPoVRayIndent")
+  finish
+endif
+
+" Counts matches of a regexp <rexp> in line number <line>.
+" Doesn't count matches inside strings and comments (as defined by current
+" syntax).
+function! s:MatchCount(line, rexp)
+  let str = getline(a:line)
+  let i = 0
+  let n = 0
+  while i >= 0
+    let i = matchend(str, a:rexp, i)
+    if i >= 0 && synIDattr(synID(a:line, i, 0), "name") !~? "string\|comment"
+      let n = n + 1
+    endif
+  endwhile
+  return n
+endfunction
+
+" The main function.  Returns indent amount.
+function GetPoVRayIndent()
+  " If we are inside a comment (may be nested in obscure ways), give up
+  if synIDattr(synID(v:lnum, indent(v:lnum)+1, 0), "name") =~? "string\|comment"
+    return -1
+  endif
+
+  " Search backwards for the frist non-empty, non-comment line.
+  let plnum = prevnonblank(v:lnum - 1)
+  let plind = indent(plnum)
+  while plnum > 0 && synIDattr(synID(plnum, plind+1, 0), "name") =~? "comment"
+    let plnum = prevnonblank(plnum - 1)
+    let plind = indent(plnum)
+  endwhile
+
+  " Start indenting from zero
+  if plnum == 0
+    return 0
+  endif
+
+  " Analyse previous nonempty line.
+  let chg = 0
+  let chg = chg + s:MatchCount(plnum, '[[{(]')
+  let chg = chg + s:MatchCount(plnum, '#\s*\%(if\|ifdef\|ifndef\|switch\|while\|macro\|else\)\>')
+  let chg = chg - s:MatchCount(plnum, '#\s*end\>')
+  let chg = chg - s:MatchCount(plnum, '[]})]')
+  " Dirty hack for people writing #if and #else on the same line.
+  let chg = chg - s:MatchCount(plnum, '#\s*\%(if\|ifdef\|ifndef\|switch\)\>.*#\s*else\>')
+  " When chg > 0, then we opened groups and we should indent more, but when
+  " chg < 0, we closed groups and this already affected the previous line,
+  " so we should not dedent.  And when everything else fails, scream.
+  let chg = chg > 0 ? chg : 0
+
+  " Analyse current line
+  " FIXME: If we have to dedent, we should try to find the indentation of the
+  " opening line.
+  let cur = s:MatchCount(v:lnum, '^\s*\%(#\s*\%(end\|else\)\>\|[]})]\)')
+  if cur > 0
+    let final = plind + (chg - cur) * shiftwidth()
+  else
+    let final = plind + chg * shiftwidth()
+  endif
+
+  return final < 0 ? 0 : final
+endfunction

Git/usr/share/vim/vim81/indent/prolog.vim

@@ -0,0 +1,67 @@
+"  vim: set sw=4 sts=4:
+"  Maintainer	: Gergely Kontra <kgergely@mcl.hu>
+"  Revised on	: 2002.02.18. 23:34:05
+"  Language	: Prolog
+"  Last change by: Takuya Fujiwara, 2018 Sep 23
+
+" TODO:
+"   checking with respect to syntax highlighting
+"   ignoring multiline comments
+"   detecting multiline strings
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+
+let b:did_indent = 1
+
+setlocal indentexpr=GetPrologIndent()
+setlocal indentkeys-=:,0#
+setlocal indentkeys+=0%,-,0;,>,0)
+
+" Only define the function once.
+"if exists("*GetPrologIndent")
+"    finish
+"endif
+
+function! GetPrologIndent()
+    " Find a non-blank line above the current line.
+    let pnum = prevnonblank(v:lnum - 1)
+    " Hit the start of the file, use zero indent.
+    if pnum == 0
+       return 0
+    endif
+    let line = getline(v:lnum)
+    let pline = getline(pnum)
+
+    let ind = indent(pnum)
+    " Previous line was comment -> use previous line's indent
+    if pline =~ '^\s*%'
+	return ind
+    endif
+    " Previous line was the start of block comment -> +1 after '/*' comment
+    if pline =~ '^\s*/\*'
+	return ind + 1
+    endif
+    " Previous line was the end of block comment -> -1 after '*/' comment
+    if pline =~ '^\s*\*/'
+	return ind - 1
+    endif
+    " Check for clause head on previous line
+    if pline =~ '\%(:-\|-->\)\s*\(%.*\)\?$'
+	let ind = ind + shiftwidth()
+    " Check for end of clause on previous line
+    elseif pline =~ '\.\s*\(%.*\)\?$'
+	let ind = ind - shiftwidth()
+    endif
+    " Check for opening conditional on previous line
+    if pline =~ '^\s*\([(;]\|->\)'
+	let ind = ind + shiftwidth()
+    endif
+    " Check for closing an unclosed paren, or middle ; or ->
+    if line =~ '^\s*\([);]\|->\)'
+	let ind = ind - shiftwidth()
+    endif
+    return ind
+endfunction

Git/usr/share/vim/vim81/indent/pyrex.vim

@@ -0,0 +1,13 @@
+" Vim indent file
+" Language:	Pyrex
+" Maintainer:	Marco Barisione <marco.bari@people.it>
+" URL:		http://marcobari.altervista.org/pyrex_vim.html
+" Last Change:	2005 Jun 24
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+
+" Use Python formatting rules
+runtime! indent/python.vim

Git/usr/share/vim/vim81/indent/python.vim

@@ -0,0 +1,206 @@
+" Vim indent file
+" Language:		Python
+" Maintainer:		Bram Moolenaar <Bram@vim.org>
+" Original Author:	David Bustos <bustos@caltech.edu>
+" Last Change:		2013 Jul 9
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+" Some preliminary settings
+setlocal nolisp		" Make sure lisp indenting doesn't supersede us
+setlocal autoindent	" indentexpr isn't much help otherwise
+
+setlocal indentexpr=GetPythonIndent(v:lnum)
+setlocal indentkeys+=<:>,=elif,=except
+
+" Only define the function once.
+if exists("*GetPythonIndent")
+  finish
+endif
+let s:keepcpo= &cpo
+set cpo&vim
+
+" Come here when loading the script the first time.
+
+let s:maxoff = 50	" maximum number of lines to look backwards for ()
+
+function GetPythonIndent(lnum)
+
+  " If this line is explicitly joined: If the previous line was also joined,
+  " line it up with that one, otherwise add two 'shiftwidth'
+  if getline(a:lnum - 1) =~ '\\$'
+    if a:lnum > 1 && getline(a:lnum - 2) =~ '\\$'
+      return indent(a:lnum - 1)
+    endif
+    return indent(a:lnum - 1) + (exists("g:pyindent_continue") ? eval(g:pyindent_continue) : (shiftwidth() * 2))
+  endif
+
+  " If the start of the line is in a string don't change the indent.
+  if has('syntax_items')
+	\ && synIDattr(synID(a:lnum, 1, 1), "name") =~ "String$"
+    return -1
+  endif
+
+  " Search backwards for the previous non-empty line.
+  let plnum = prevnonblank(v:lnum - 1)
+
+  if plnum == 0
+    " This is the first non-empty line, use zero indent.
+    return 0
+  endif
+
+  " searchpair() can be slow sometimes, limit the time to 100 msec or what is
+  " put in g:pyindent_searchpair_timeout
+  let searchpair_stopline = 0
+  let searchpair_timeout = get(g:, 'pyindent_searchpair_timeout', 150)
+
+  " If the previous line is inside parenthesis, use the indent of the starting
+  " line.
+  " Trick: use the non-existing "dummy" variable to break out of the loop when
+  " going too far back.
+  call cursor(plnum, 1)
+  let parlnum = searchpair('(\|{\|\[', '', ')\|}\|\]', 'nbW',
+	  \ "line('.') < " . (plnum - s:maxoff) . " ? dummy :"
+	  \ . " synIDattr(synID(line('.'), col('.'), 1), 'name')"
+	  \ . " =~ '\\(Comment\\|Todo\\|String\\)$'",
+	  \ searchpair_stopline, searchpair_timeout)
+  if parlnum > 0
+    let plindent = indent(parlnum)
+    let plnumstart = parlnum
+  else
+    let plindent = indent(plnum)
+    let plnumstart = plnum
+  endif
+
+
+  " When inside parenthesis: If at the first line below the parenthesis add
+  " two 'shiftwidth', otherwise same as previous line.
+  " i = (a
+  "       + b
+  "       + c)
+  call cursor(a:lnum, 1)
+  let p = searchpair('(\|{\|\[', '', ')\|}\|\]', 'bW',
+	  \ "line('.') < " . (a:lnum - s:maxoff) . " ? dummy :"
+	  \ . " synIDattr(synID(line('.'), col('.'), 1), 'name')"
+	  \ . " =~ '\\(Comment\\|Todo\\|String\\)$'",
+	  \ searchpair_stopline, searchpair_timeout)
+  if p > 0
+    if p == plnum
+      " When the start is inside parenthesis, only indent one 'shiftwidth'.
+      let pp = searchpair('(\|{\|\[', '', ')\|}\|\]', 'bW',
+	  \ "line('.') < " . (a:lnum - s:maxoff) . " ? dummy :"
+	  \ . " synIDattr(synID(line('.'), col('.'), 1), 'name')"
+	  \ . " =~ '\\(Comment\\|Todo\\|String\\)$'",
+	  \ searchpair_stopline, searchpair_timeout)
+      if pp > 0
+	return indent(plnum) + (exists("g:pyindent_nested_paren") ? eval(g:pyindent_nested_paren) : shiftwidth())
+      endif
+      return indent(plnum) + (exists("g:pyindent_open_paren") ? eval(g:pyindent_open_paren) : (shiftwidth() * 2))
+    endif
+    if plnumstart == p
+      return indent(plnum)
+    endif
+    return plindent
+  endif
+
+
+  " Get the line and remove a trailing comment.
+  " Use syntax highlighting attributes when possible.
+  let pline = getline(plnum)
+  let pline_len = strlen(pline)
+  if has('syntax_items')
+    " If the last character in the line is a comment, do a binary search for
+    " the start of the comment.  synID() is slow, a linear search would take
+    " too long on a long line.
+    if synIDattr(synID(plnum, pline_len, 1), "name") =~ "\\(Comment\\|Todo\\)$"
+      let min = 1
+      let max = pline_len
+      while min < max
+	let col = (min + max) / 2
+	if synIDattr(synID(plnum, col, 1), "name") =~ "\\(Comment\\|Todo\\)$"
+	  let max = col
+	else
+	  let min = col + 1
+	endif
+      endwhile
+      let pline = strpart(pline, 0, min - 1)
+    endif
+  else
+    let col = 0
+    while col < pline_len
+      if pline[col] == '#'
+	let pline = strpart(pline, 0, col)
+	break
+      endif
+      let col = col + 1
+    endwhile
+  endif
+
+  " If the previous line ended with a colon, indent this line
+  if pline =~ ':\s*$'
+    return plindent + shiftwidth()
+  endif
+
+  " If the previous line was a stop-execution statement...
+  if getline(plnum) =~ '^\s*\(break\|continue\|raise\|return\|pass\)\>'
+    " See if the user has already dedented
+    if indent(a:lnum) > indent(plnum) - shiftwidth()
+      " If not, recommend one dedent
+      return indent(plnum) - shiftwidth()
+    endif
+    " Otherwise, trust the user
+    return -1
+  endif
+
+  " If the current line begins with a keyword that lines up with "try"
+  if getline(a:lnum) =~ '^\s*\(except\|finally\)\>'
+    let lnum = a:lnum - 1
+    while lnum >= 1
+      if getline(lnum) =~ '^\s*\(try\|except\)\>'
+	let ind = indent(lnum)
+	if ind >= indent(a:lnum)
+	  return -1	" indent is already less than this
+	endif
+	return ind	" line up with previous try or except
+      endif
+      let lnum = lnum - 1
+    endwhile
+    return -1		" no matching "try"!
+  endif
+
+  " If the current line begins with a header keyword, dedent
+  if getline(a:lnum) =~ '^\s*\(elif\|else\)\>'
+
+    " Unless the previous line was a one-liner
+    if getline(plnumstart) =~ '^\s*\(for\|if\|try\)\>'
+      return plindent
+    endif
+
+    " Or the user has already dedented
+    if indent(a:lnum) <= plindent - shiftwidth()
+      return -1
+    endif
+
+    return plindent - shiftwidth()
+  endif
+
+  " When after a () construct we probably want to go back to the start line.
+  " a = (b
+  "       + c)
+  " here
+  if parlnum > 0
+    return plindent
+  endif
+
+  return -1
+
+endfunction
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+" vim:sw=2

Git/usr/share/vim/vim81/indent/r.vim

@@ -0,0 +1,522 @@
+" Vim indent file
+" Language:	R
+" Author:	Jakson Alves de Aquino <jalvesaq@gmail.com>
+" Homepage:     https://github.com/jalvesaq/R-Vim-runtime
+" Last Change:	Sun Aug 19, 2018  09:13PM
+
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentkeys=0{,0},:,!^F,o,O,e
+setlocal indentexpr=GetRIndent()
+
+" Only define the function once.
+if exists("*GetRIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+" Options to make the indentation more similar to Emacs/ESS:
+let g:r_indent_align_args     = get(g:, 'r_indent_align_args',      1)
+let g:r_indent_ess_comments   = get(g:, 'r_indent_ess_comments',    0)
+let g:r_indent_comment_column = get(g:, 'r_indent_comment_column', 40)
+let g:r_indent_ess_compatible = get(g:, 'r_indent_ess_compatible',  0)
+let g:r_indent_op_pattern     = get(g:, 'r_indent_op_pattern',
+      \ '\(&\||\|+\|-\|\*\|/\|=\|\~\|%\|->\)\s*$')
+
+function s:RDelete_quotes(line)
+  let i = 0
+  let j = 0
+  let line1 = ""
+  let llen = strlen(a:line)
+  while i < llen
+    if a:line[i] == '"'
+      let i += 1
+      let line1 = line1 . 's'
+      while !(a:line[i] == '"' && ((i > 1 && a:line[i-1] == '\' && a:line[i-2] == '\') || a:line[i-1] != '\')) && i < llen
+        let i += 1
+      endwhile
+      if a:line[i] == '"'
+        let i += 1
+      endif
+    else
+      if a:line[i] == "'"
+        let i += 1
+        let line1 = line1 . 's'
+        while !(a:line[i] == "'" && ((i > 1 && a:line[i-1] == '\' && a:line[i-2] == '\') || a:line[i-1] != '\')) && i < llen
+          let i += 1
+        endwhile
+        if a:line[i] == "'"
+          let i += 1
+        endif
+      else
+        if a:line[i] == "`"
+          let i += 1
+          let line1 = line1 . 's'
+          while a:line[i] != "`" && i < llen
+            let i += 1
+          endwhile
+          if a:line[i] == "`"
+            let i += 1
+          endif
+        endif
+      endif
+    endif
+    if i == llen
+      break
+    endif
+    let line1 = line1 . a:line[i]
+    let j += 1
+    let i += 1
+  endwhile
+  return line1
+endfunction
+
+" Convert foo(bar()) int foo()
+function s:RDelete_parens(line)
+  if s:Get_paren_balance(a:line, "(", ")") != 0
+    return a:line
+  endif
+  let i = 0
+  let j = 0
+  let line1 = ""
+  let llen = strlen(a:line)
+  while i < llen
+    let line1 = line1 . a:line[i]
+    if a:line[i] == '('
+      let nop = 1
+      while nop > 0 && i < llen
+        let i += 1
+        if a:line[i] == ')'
+          let nop -= 1
+        else
+          if a:line[i] == '('
+            let nop += 1
+          endif
+        endif
+      endwhile
+      let line1 = line1 . a:line[i]
+    endif
+    let i += 1
+  endwhile
+  return line1
+endfunction
+
+function! s:Get_paren_balance(line, o, c)
+  let line2 = substitute(a:line, a:o, "", "g")
+  let openp = strlen(a:line) - strlen(line2)
+  let line3 = substitute(line2, a:c, "", "g")
+  let closep = strlen(line2) - strlen(line3)
+  return openp - closep
+endfunction
+
+function! s:Get_matching_brace(linenr, o, c, delbrace)
+  let line = SanitizeRLine(getline(a:linenr))
+  if a:delbrace == 1
+    let line = substitute(line, '{$', "", "")
+  endif
+  let pb = s:Get_paren_balance(line, a:o, a:c)
+  let i = a:linenr
+  while pb != 0 && i > 1
+    let i -= 1
+    let pb += s:Get_paren_balance(SanitizeRLine(getline(i)), a:o, a:c)
+  endwhile
+  return i
+endfunction
+
+" This function is buggy because there 'if's without 'else'
+" It must be rewritten relying more on indentation
+function! s:Get_matching_if(linenr, delif)
+  let line = SanitizeRLine(getline(a:linenr))
+  if a:delif
+    let line = substitute(line, "if", "", "g")
+  endif
+  let elsenr = 0
+  let i = a:linenr
+  let ifhere = 0
+  while i > 0
+    let line2 = substitute(line, '\<else\>', "xxx", "g")
+    let elsenr += strlen(line) - strlen(line2)
+    if line =~ '.*\s*if\s*()' || line =~ '.*\s*if\s*()'
+      let elsenr -= 1
+      if elsenr == 0
+        let ifhere = i
+        break
+      endif
+    endif
+    let i -= 1
+    let line = SanitizeRLine(getline(i))
+  endwhile
+  if ifhere
+    return ifhere
+  else
+    return a:linenr
+  endif
+endfunction
+
+function! s:Get_last_paren_idx(line, o, c, pb)
+  let blc = a:pb
+  let line = substitute(a:line, '\t', s:curtabstop, "g")
+  let theidx = -1
+  let llen = strlen(line)
+  let idx = 0
+  while idx < llen
+    if line[idx] == a:o
+      let blc -= 1
+      if blc == 0
+        let theidx = idx
+      endif
+    else
+      if line[idx] == a:c
+        let blc += 1
+      endif
+    endif
+    let idx += 1
+  endwhile
+  return theidx + 1
+endfunction
+
+" Get previous relevant line. Search back until getting a line that isn't
+" comment or blank
+function s:Get_prev_line(lineno)
+  let lnum = a:lineno - 1
+  let data = getline( lnum )
+  while lnum > 0 && (data =~ '^\s*#' || data =~ '^\s*$')
+    let lnum = lnum - 1
+    let data = getline( lnum )
+  endwhile
+  return lnum
+endfunction
+
+" This function is also used by r-plugin/common_global.vim
+" Delete from '#' to the end of the line, unless the '#' is inside a string.
+function SanitizeRLine(line)
+  let newline = s:RDelete_quotes(a:line)
+  let newline = s:RDelete_parens(newline)
+  let newline = substitute(newline, '#.*', "", "")
+  let newline = substitute(newline, '\s*$', "", "")
+  if &filetype == "rhelp" && newline =~ '^\\method{.*}{.*}(.*'
+    let newline = substitute(newline, '^\\method{\(.*\)}{.*}', '\1', "")
+  endif
+  return newline
+endfunction
+
+function GetRIndent()
+
+  let clnum = line(".")    " current line
+
+  let cline = getline(clnum)
+  if cline =~ '^\s*#'
+    if g:r_indent_ess_comments == 1
+      if cline =~ '^\s*###'
+        return 0
+      endif
+      if cline !~ '^\s*##'
+        return g:r_indent_comment_column
+      endif
+    endif
+  endif
+
+  let cline = SanitizeRLine(cline)
+
+  if cline =~ '^\s*}'
+    let indline = s:Get_matching_brace(clnum, '{', '}', 1)
+    if indline > 0 && indline != clnum
+      let iline = SanitizeRLine(getline(indline))
+      if s:Get_paren_balance(iline, "(", ")") == 0 || iline =~ '(\s*{$'
+        return indent(indline)
+      else
+        let indline = s:Get_matching_brace(indline, '(', ')', 1)
+        return indent(indline)
+      endif
+    endif
+  endif
+
+  if cline =~ '^\s*)$'
+    let indline = s:Get_matching_brace(clnum, '(', ')', 1)
+    return indent(indline)
+  endif
+
+  " Find the first non blank line above the current line
+  let lnum = s:Get_prev_line(clnum)
+  " Hit the start of the file, use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  let line = SanitizeRLine(getline(lnum))
+
+  if &filetype == "rhelp"
+    if cline =~ '^\\dontshow{' || cline =~ '^\\dontrun{' || cline =~ '^\\donttest{' || cline =~ '^\\testonly{'
+      return 0
+    endif
+    if line =~ '^\\examples{' || line =~ '^\\usage{' || line =~ '^\\dontshow{' || line =~ '^\\dontrun{' || line =~ '^\\donttest{' || line =~ '^\\testonly{'
+      return 0
+    endif
+  endif
+
+  if &filetype == "rnoweb" && line =~ "^<<.*>>="
+    return 0
+  endif
+
+  if cline =~ '^\s*{' && s:Get_paren_balance(cline, '{', '}') > 0
+    if g:r_indent_ess_compatible && line =~ ')$'
+      let nlnum = lnum
+      let nline = line
+      while s:Get_paren_balance(nline, '(', ')') < 0
+        let nlnum = s:Get_prev_line(nlnum)
+        let nline = SanitizeRLine(getline(nlnum)) . nline
+      endwhile
+      if nline =~ '^\s*function\s*(' && indent(nlnum) == shiftwidth()
+        return 0
+      endif
+    endif
+    if s:Get_paren_balance(line, "(", ")") == 0
+      return indent(lnum)
+    endif
+  endif
+
+  " line is an incomplete command:
+  if line =~ '\<\(if\|while\|for\|function\)\s*()$' || line =~ '\<else$' || line =~ '<-$' || line =~ '->$'
+    return indent(lnum) + shiftwidth()
+  endif
+
+  " Deal with () and []
+
+  let pb = s:Get_paren_balance(line, '(', ')')
+
+  if line =~ '^\s*{$' || line =~ '(\s*{' || (pb == 0 && (line =~ '{$' || line =~ '(\s*{$'))
+    return indent(lnum) + shiftwidth()
+  endif
+
+  let s:curtabstop = repeat(' ', &tabstop)
+
+  if g:r_indent_align_args == 1
+    if pb > 0 && line =~ '{$'
+      return s:Get_last_paren_idx(line, '(', ')', pb) + shiftwidth()
+    endif
+
+    let bb = s:Get_paren_balance(line, '[', ']')
+
+    if pb > 0
+      if &filetype == "rhelp"
+        let ind = s:Get_last_paren_idx(line, '(', ')', pb)
+      else
+        let ind = s:Get_last_paren_idx(getline(lnum), '(', ')', pb)
+      endif
+      return ind
+    endif
+
+    if pb < 0 && line =~ '.*[,&|\-\*+<>]$'
+      let lnum = s:Get_prev_line(lnum)
+      while pb < 1 && lnum > 0
+        let line = SanitizeRLine(getline(lnum))
+        let line = substitute(line, '\t', s:curtabstop, "g")
+        let ind = strlen(line)
+        while ind > 0
+          if line[ind] == ')'
+            let pb -= 1
+          else
+            if line[ind] == '('
+              let pb += 1
+            endif
+          endif
+          if pb == 1
+            return ind + 1
+          endif
+          let ind -= 1
+        endwhile
+        let lnum -= 1
+      endwhile
+      return 0
+    endif
+
+    if bb > 0
+      let ind = s:Get_last_paren_idx(getline(lnum), '[', ']', bb)
+      return ind
+    endif
+  endif
+
+  let post_block = 0
+  if line =~ '}$' && s:Get_paren_balance(line, '{', '}') < 0
+    let lnum = s:Get_matching_brace(lnum, '{', '}', 0)
+    let line = SanitizeRLine(getline(lnum))
+    if lnum > 0 && line =~ '^\s*{'
+      let lnum = s:Get_prev_line(lnum)
+      let line = SanitizeRLine(getline(lnum))
+    endif
+    let pb = s:Get_paren_balance(line, '(', ')')
+    let post_block = 1
+  endif
+
+  " Indent after operator pattern
+  let olnum = s:Get_prev_line(lnum)
+  let oline = getline(olnum)
+  if olnum > 0
+    if line =~ g:r_indent_op_pattern && s:Get_paren_balance(line, "(", ")") == 0
+      if oline =~ g:r_indent_op_pattern && s:Get_paren_balance(line, "(", ")") == 0
+        return indent(lnum)
+      else
+        return indent(lnum) + shiftwidth()
+      endif
+    else
+      if oline =~ g:r_indent_op_pattern && s:Get_paren_balance(line, "(", ")") == 0
+        return indent(lnum) - shiftwidth()
+      endif
+    endif
+  endif
+
+  let post_fun = 0
+  if pb < 0 && line !~ ')\s*[,&|\-\*+<>]$'
+    let post_fun = 1
+    while pb < 0 && lnum > 0
+      let lnum -= 1
+      let linepiece = SanitizeRLine(getline(lnum))
+      let pb += s:Get_paren_balance(linepiece, "(", ")")
+      let line = linepiece . line
+    endwhile
+    if line =~ '{$' && post_block == 0
+      return indent(lnum) + shiftwidth()
+    endif
+
+    " Now we can do some tests again
+    if cline =~ '^\s*{'
+      return indent(lnum)
+    endif
+    if post_block == 0
+      let newl = SanitizeRLine(line)
+      if newl =~ '\<\(if\|while\|for\|function\)\s*()$' || newl =~ '\<else$' || newl =~ '<-$'
+        return indent(lnum) + shiftwidth()
+      endif
+    endif
+  endif
+
+  if cline =~ '^\s*else'
+    if line =~ '<-\s*if\s*()'
+      return indent(lnum) + shiftwidth()
+    else
+      if line =~ '\<if\s*()'
+        return indent(lnum)
+      else
+        return indent(lnum) - shiftwidth()
+      endif
+    endif
+  endif
+
+  let bb = s:Get_paren_balance(line, '[', ']')
+  if bb < 0 && line =~ '.*]'
+    while bb < 0 && lnum > 0
+      let lnum -= 1
+      let linepiece = SanitizeRLine(getline(lnum))
+      let bb += s:Get_paren_balance(linepiece, "[", "]")
+      let line = linepiece . line
+    endwhile
+    let line = s:RDelete_parens(line)
+  endif
+
+  let plnum = s:Get_prev_line(lnum)
+  let ppost_else = 0
+  if plnum > 0
+    let pline = SanitizeRLine(getline(plnum))
+    let ppost_block = 0
+    if pline =~ '}$'
+      let ppost_block = 1
+      let plnum = s:Get_matching_brace(plnum, '{', '}', 0)
+      let pline = SanitizeRLine(getline(plnum))
+      if pline =~ '^\s*{$' && plnum > 0
+        let plnum = s:Get_prev_line(plnum)
+        let pline = SanitizeRLine(getline(plnum))
+      endif
+    endif
+
+    if pline =~ 'else$'
+      let ppost_else = 1
+      let plnum = s:Get_matching_if(plnum, 0)
+      let pline = SanitizeRLine(getline(plnum))
+    endif
+
+    if pline =~ '^\s*else\s*if\s*('
+      let pplnum = s:Get_prev_line(plnum)
+      let ppline = SanitizeRLine(getline(pplnum))
+      while ppline =~ '^\s*else\s*if\s*(' || ppline =~ '^\s*if\s*()\s*\S$'
+        let plnum = pplnum
+        let pline = ppline
+        let pplnum = s:Get_prev_line(plnum)
+        let ppline = SanitizeRLine(getline(pplnum))
+      endwhile
+      while ppline =~ '\<\(if\|while\|for\|function\)\s*()$' || ppline =~ '\<else$' || ppline =~ '<-$'
+        let plnum = pplnum
+        let pline = ppline
+        let pplnum = s:Get_prev_line(plnum)
+        let ppline = SanitizeRLine(getline(pplnum))
+      endwhile
+    endif
+
+    let ppb = s:Get_paren_balance(pline, '(', ')')
+    if ppb < 0 && (pline =~ ')\s*{$' || pline =~ ')$')
+      while ppb < 0 && plnum > 0
+        let plnum -= 1
+        let linepiece = SanitizeRLine(getline(plnum))
+        let ppb += s:Get_paren_balance(linepiece, "(", ")")
+        let pline = linepiece . pline
+      endwhile
+      let pline = s:RDelete_parens(pline)
+    endif
+  endif
+
+  let ind = indent(lnum)
+
+  if g:r_indent_align_args == 0 && pb != 0
+    let ind += pb * shiftwidth()
+    return ind
+  endif
+
+  if g:r_indent_align_args == 0 && bb != 0
+    let ind += bb * shiftwidth()
+    return ind
+  endif
+
+  if plnum > 0
+    let pind = indent(plnum)
+  else
+    let pind = 0
+  endif
+
+  if ind == pind || (ind == (pind  + shiftwidth()) && pline =~ '{$' && ppost_else == 0)
+    return ind
+  endif
+
+  let pline = getline(plnum)
+  let pbb = s:Get_paren_balance(pline, '[', ']')
+
+  while pind < ind && plnum > 0 && ppb == 0 && pbb == 0
+    let ind = pind
+    let plnum = s:Get_prev_line(plnum)
+    let pline = getline(plnum)
+    let ppb = s:Get_paren_balance(pline, '(', ')')
+    let pbb = s:Get_paren_balance(pline, '[', ']')
+    while pline =~ '^\s*else'
+      let plnum = s:Get_matching_if(plnum, 1)
+      let pline = getline(plnum)
+      let ppb = s:Get_paren_balance(pline, '(', ')')
+      let pbb = s:Get_paren_balance(pline, '[', ']')
+    endwhile
+    let pind = indent(plnum)
+    if ind == (pind  + shiftwidth()) && pline =~ '{$'
+      return ind
+    endif
+  endwhile
+
+  return ind
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim: sw=2

Git/usr/share/vim/vim81/indent/raml.vim

@@ -0,0 +1,12 @@
+" Vim indent file
+" Language:         RAML (RESTful API Modeling Language)
+" Maintainer:       mucheng <leisurelicht@gmail.com>
+" License:          VIM LICENSE
+" Latest Revision:  2018-11-03
+
+if exists("b:did_indent")
+  finish
+endif
+
+" Same as yaml indenting.
+runtime! indent/yaml.vim

Git/usr/share/vim/vim81/indent/readline.vim

@@ -0,0 +1,36 @@
+" Vim indent file
+" Language:             readline configuration file
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2006-12-20
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetReadlineIndent()
+setlocal indentkeys=!^F,o,O,=$else,=$endif
+setlocal nosmartindent
+
+if exists("*GetReadlineIndent")
+  finish
+endif
+
+function GetReadlineIndent()
+  let lnum = prevnonblank(v:lnum - 1)
+  if lnum == 0
+    return 0
+  endif
+
+  let ind = indent(lnum)
+
+  if getline(lnum) =~ '^\s*$\(if\|else\)\>'
+    let ind = ind + shiftwidth()
+  endif
+
+  if getline(v:lnum) =~ '^\s*$\(else\|endif\)\>'
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/rhelp.vim

@@ -0,0 +1,108 @@
+" Vim indent file
+" Language:	R Documentation (Help), *.Rd
+" Author:	Jakson Alves de Aquino <jalvesaq@gmail.com>
+" Homepage:     https://github.com/jalvesaq/R-Vim-runtime
+" Last Change:	Tue Apr 07, 2015  04:38PM
+
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+runtime indent/r.vim
+let s:RIndent = function(substitute(&indentexpr, "()", "", ""))
+let b:did_indent = 1
+
+setlocal noautoindent
+setlocal nocindent
+setlocal nosmartindent
+setlocal nolisp
+setlocal indentkeys=0{,0},:,!^F,o,O,e
+setlocal indentexpr=GetCorrectRHelpIndent()
+
+" Only define the functions once.
+if exists("*GetRHelpIndent")
+  finish
+endif
+
+function s:SanitizeRHelpLine(line)
+  let newline = substitute(a:line, '\\\\', "x", "g")
+  let newline = substitute(newline, '\\{', "x", "g")
+  let newline = substitute(newline, '\\}', "x", "g")
+  let newline = substitute(newline, '\\%', "x", "g")
+  let newline = substitute(newline, '%.*', "", "")
+  let newline = substitute(newline, '\s*$', "", "")
+  return newline
+endfunction
+
+function GetRHelpIndent()
+
+  let clnum = line(".")    " current line
+  if clnum == 1
+    return 0
+  endif
+  let cline = getline(clnum)
+
+  if cline =~ '^\s*}\s*$'
+    let i = clnum
+    let bb = -1
+    while bb != 0 && i > 1
+      let i -= 1
+      let line = s:SanitizeRHelpLine(getline(i))
+      let line2 = substitute(line, "{", "", "g")
+      let openb = strlen(line) - strlen(line2)
+      let line3 = substitute(line2, "}", "", "g")
+      let closeb = strlen(line2) - strlen(line3)
+      let bb += openb - closeb
+    endwhile
+    return indent(i)
+  endif
+
+  if cline =~ '^\s*#ifdef\>' || cline =~ '^\s*#endif\>'
+    return 0
+  endif
+
+  let lnum = clnum - 1
+  let line = getline(lnum)
+  if line =~ '^\s*#ifdef\>' || line =~ '^\s*#endif\>'
+    let lnum -= 1
+    let line = getline(lnum)
+  endif
+  while lnum > 1 && (line =~ '^\s*$' || line =~ '^#ifdef' || line =~ '^#endif')
+    let lnum -= 1
+    let line = getline(lnum)
+  endwhile
+  if lnum == 1
+    return 0
+  endif
+  let line = s:SanitizeRHelpLine(line)
+  let line2 = substitute(line, "{", "", "g")
+  let openb = strlen(line) - strlen(line2)
+  let line3 = substitute(line2, "}", "", "g")
+  let closeb = strlen(line2) - strlen(line3)
+  let bb = openb - closeb
+
+  let ind = indent(lnum) + (bb * shiftwidth())
+
+  if line =~ '^\s*}\s*$'
+    let ind = indent(lnum)
+  endif
+
+  if ind < 0
+    return 0
+  endif
+
+  return ind
+endfunction
+
+function GetCorrectRHelpIndent()
+  let lastsection = search('^\\[a-z]*{', "bncW")
+  let secname = getline(lastsection)
+  if secname =~ '^\\usage{' || secname =~ '^\\examples{' || secname =~ '^\\dontshow{' || secname =~ '^\\dontrun{' || secname =~ '^\\donttest{' || secname =~ '^\\testonly{' || secname =~ '^\\method{.*}{.*}('
+    return s:RIndent()
+  else
+    return GetRHelpIndent()
+  endif
+endfunction
+
+" vim: sw=2

Git/usr/share/vim/vim81/indent/rmd.vim

@@ -0,0 +1,66 @@
+" Vim indent file
+" Language:	Rmd
+" Author:	Jakson Alves de Aquino <jalvesaq@gmail.com>
+" Homepage:     https://github.com/jalvesaq/R-Vim-runtime
+" Last Change:	Sun Aug 19, 2018  09:14PM
+
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+runtime indent/r.vim
+let s:RIndent = function(substitute(&indentexpr, "()", "", ""))
+let b:did_indent = 1
+
+setlocal indentkeys=0{,0},:,!^F,o,O,e
+setlocal indentexpr=GetRmdIndent()
+
+if exists("*GetRmdIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+function s:GetMdIndent()
+  let pline = getline(v:lnum - 1)
+  let cline = getline(v:lnum)
+  if prevnonblank(v:lnum - 1) < v:lnum - 1 || cline =~ '^\s*[-\+\*]\s' || cline =~ '^\s*\d\+\.\s\+'
+    return indent(v:lnum)
+  elseif pline =~ '^\s*[-\+\*]\s'
+    return indent(v:lnum - 1) + 2
+  elseif pline =~ '^\s*\d\+\.\s\+'
+    return indent(v:lnum - 1) + 3
+  endif
+  return indent(prevnonblank(v:lnum - 1))
+endfunction
+
+function s:GetYamlIndent()
+  let pline = getline(v:lnum - 1)
+  if pline =~ ':\s*$'
+    return indent(v:lnum) + &sw
+  elseif pline =~ '^\s*- '
+    return indent(v:lnum) + 2
+  endif
+  return indent(prevnonblank(v:lnum - 1))
+endfunction
+
+function GetRmdIndent()
+  if getline(".") =~ '^[ \t]*```{r .*}$' || getline(".") =~ '^[ \t]*```$'
+    return 0
+  endif
+  if search('^[ \t]*```{r', "bncW") > search('^[ \t]*```$', "bncW")
+    return s:RIndent()
+  elseif v:lnum > 1 && search('^---$', "bnW") == 1 &&
+        \ (search('^---$', "nW") > v:lnum || search('^...$', "nW") > v:lnum)
+    return s:GetYamlIndent()
+  else
+    return s:GetMdIndent()
+  endif
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim: sw=2

Git/usr/share/vim/vim81/indent/rnoweb.vim

@@ -0,0 +1,47 @@
+" Vim indent file
+" Language:	Rnoweb
+" Author:	Jakson Alves de Aquino <jalvesaq@gmail.com>
+" Homepage:     https://github.com/jalvesaq/R-Vim-runtime
+" Last Change:	Fri Apr 15, 2016  10:58PM
+
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+runtime indent/tex.vim
+
+function! s:NoTeXIndent()
+  return indent(line("."))
+endfunction
+
+if &indentexpr == "" || &indentexpr == "GetRnowebIndent()"
+  let s:TeXIndent = function("s:NoTeXIndent")
+else
+  let s:TeXIndent = function(substitute(&indentexpr, "()", "", ""))
+endif
+
+unlet! b:did_indent
+runtime indent/r.vim
+let s:RIndent = function(substitute(&indentexpr, "()", "", ""))
+let b:did_indent = 1
+
+setlocal indentkeys=0{,0},!^F,o,O,e,},=\bibitem,=\item
+setlocal indentexpr=GetRnowebIndent()
+
+if exists("*GetRnowebIndent")
+  finish
+endif
+
+function GetRnowebIndent()
+  let curline = getline(".")
+  if curline =~ '^<<.*>>=$' || curline =~ '^\s*@$'
+    return 0
+  endif
+  if search("^<<", "bncW") > search("^@", "bncW")
+    return s:RIndent()
+  endif
+  return s:TeXIndent()
+endfunction
+
+" vim: sw=2

Git/usr/share/vim/vim81/indent/rpl.vim

@@ -0,0 +1,63 @@
+" Vim indent file
+" Language:	RPL/2
+" Version:	0.2
+" Last Change:	2017 Jun 13
+" Maintainer:	BERTRAND Jo<4A>l <rpl2@free.fr>
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentkeys+==~end,=~case,=~if,=~then,=~else,=~do,=~until,=~while,=~repeat,=~select,=~default,=~for,=~start,=~next,=~step,<<>,<>>
+
+" Define the appropriate indent function but only once
+setlocal indentexpr=RplGetFreeIndent()
+if exists("*RplGetFreeIndent")
+  finish
+endif
+
+let b:undo_indent = "set ai< indentkeys< indentexpr<"
+
+function RplGetIndent(lnum)
+  let ind = indent(a:lnum)
+  let prevline=getline(a:lnum)
+  " Strip tail comment
+  let prevstat=substitute(prevline, '!.*$', '', '')
+
+  " Add a shiftwidth to statements following if, iferr, then, else, elseif,
+  " case, select, default, do, until, while, repeat, for, start
+  if prevstat =~? '\<\(if\|iferr\|do\|while\)\>' && prevstat =~? '\<end\>'
+  elseif prevstat =~? '\(^\|\s\+\)<<\($\|\s\+\)' && prevstat =~? '\s\+>>\($\|\s\+\)'
+  elseif prevstat =~? '\<\(if\|iferr\|then\|else\|elseif\|select\|case\|do\|until\|while\|repeat\|for\|start\|default\)\>' || prevstat =~? '\(^\|\s\+\)<<\($\|\s\+\)'
+    let ind = ind + shiftwidth()
+  endif
+
+  " Subtract a shiftwidth from then, else, elseif, end, until, repeat, next,
+  " step
+  let line = getline(v:lnum)
+  if line =~? '^\s*\(then\|else\|elseif\|until\|repeat\|next\|step\|default\|end\)\>'
+    let ind = ind - shiftwidth()
+  elseif line =~? '^\s*>>\($\|\s\+\)'
+    let ind = ind - shiftwidth()
+  endif
+
+  return ind
+endfunction
+
+function RplGetFreeIndent()
+  " Find the previous non-blank line
+  let lnum = prevnonblank(v:lnum - 1)
+
+  " Use zero indent at the top of the file
+  if lnum == 0
+    return 0
+  endif
+
+  let ind=RplGetIndent(lnum)
+  return ind
+endfunction
+
+" vim:sw=2 tw=130

Git/usr/share/vim/vim81/indent/rrst.vim

@@ -0,0 +1,47 @@
+" Vim indent file
+" Language:	Rrst
+" Author:	Jakson Alves de Aquino <jalvesaq@gmail.com>
+" Homepage:     https://github.com/jalvesaq/R-Vim-runtime
+" Last Change:	Tue Apr 07, 2015  04:38PM
+
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+runtime indent/r.vim
+let s:RIndent = function(substitute(&indentexpr, "()", "", ""))
+let b:did_indent = 1
+
+setlocal indentkeys=0{,0},:,!^F,o,O,e
+setlocal indentexpr=GetRrstIndent()
+
+if exists("*GetRrstIndent")
+  finish
+endif
+
+function GetRstIndent()
+  let pline = getline(v:lnum - 1)
+  let cline = getline(v:lnum)
+  if prevnonblank(v:lnum - 1) < v:lnum - 1 || cline =~ '^\s*[-\+\*]\s' || cline =~ '^\s*\d\+\.\s\+'
+    return indent(v:lnum)
+  elseif pline =~ '^\s*[-\+\*]\s'
+    return indent(v:lnum - 1) + 2
+  elseif pline =~ '^\s*\d\+\.\s\+'
+    return indent(v:lnum - 1) + 3
+  endif
+  return indent(prevnonblank(v:lnum - 1))
+endfunction
+
+function GetRrstIndent()
+  if getline(".") =~ '^\.\. {r .*}$' || getline(".") =~ '^\.\. \.\.$'
+    return 0
+  endif
+  if search('^\.\. {r', "bncW") > search('^\.\. \.\.$', "bncW")
+    return s:RIndent()
+  else
+    return GetRstIndent()
+  endif
+endfunction
+
+" vim: sw=2

Git/usr/share/vim/vim81/indent/rst.vim

@@ -0,0 +1,59 @@
+" Vim indent file
+" Language:             reStructuredText Documentation Format
+" Previous Maintainer:  Nikolai Weibull <now@bitwi.se>
+" Latest Revision:      2011-08-03
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetRSTIndent()
+setlocal indentkeys=!^F,o,O
+setlocal nosmartindent
+
+if exists("*GetRSTIndent")
+  finish
+endif
+
+let s:itemization_pattern = '^\s*[-*+]\s'
+let s:enumeration_pattern = '^\s*\%(\d\+\|#\)\.\s\+'
+
+function GetRSTIndent()
+  let lnum = prevnonblank(v:lnum - 1)
+  if lnum == 0
+    return 0
+  endif
+
+  let ind = indent(lnum)
+  let line = getline(lnum)
+
+  if line =~ s:itemization_pattern
+    let ind += 2
+  elseif line =~ s:enumeration_pattern
+    let ind += matchend(line, s:enumeration_pattern)
+  endif
+
+  let line = getline(v:lnum - 1)
+
+  " Indent :FIELD: lines.  Don’t match if there is no text after the field or
+  " if the text ends with a sent-ender.
+   if line =~ '^:.\+:\s\{-1,\}\S.\+[^.!?:]$'
+     return matchend(line, '^:.\{-1,}:\s\+')
+   endif
+
+  if line =~ '^\s*$'
+    execute lnum
+    call search('^\s*\%([-*+]\s\|\%(\d\+\|#\)\.\s\|\.\.\|$\)', 'bW')
+    let line = getline('.')
+    if line =~ s:itemization_pattern
+      let ind -= 2
+    elseif line =~ s:enumeration_pattern
+      let ind -= matchend(line, s:enumeration_pattern)
+    elseif line =~ '^\s*\.\.'
+      let ind -= 3
+    endif
+  endif
+
+  return ind
+endfunction

Git/usr/share/vim/vim81/indent/ruby.vim

@@ -0,0 +1,939 @@
+" Vim indent file
+" Language:		Ruby
+" Maintainer:		Andrew Radev <andrey.radev@gmail.com>
+" Previous Maintainer:	Nikolai Weibull <now at bitwi.se>
+" URL:			https://github.com/vim-ruby/vim-ruby
+" Release Coordinator:	Doug Kearns <dougkearns@gmail.com>
+" Last Change:		2019 Jan 06
+
+" 0. Initialization {{{1
+" =================
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+if !exists('g:ruby_indent_access_modifier_style')
+  " Possible values: "normal", "indent", "outdent"
+  let g:ruby_indent_access_modifier_style = 'normal'
+endif
+
+if !exists('g:ruby_indent_assignment_style')
+  " Possible values: "variable", "hanging"
+  let g:ruby_indent_assignment_style = 'hanging'
+endif
+
+if !exists('g:ruby_indent_block_style')
+  " Possible values: "expression", "do"
+  let g:ruby_indent_block_style = 'expression'
+endif
+
+setlocal nosmartindent
+
+" Now, set up our indentation expression and keys that trigger it.
+setlocal indentexpr=GetRubyIndent(v:lnum)
+setlocal indentkeys=0{,0},0),0],!^F,o,O,e,:,.
+setlocal indentkeys+==end,=else,=elsif,=when,=ensure,=rescue,==begin,==end
+setlocal indentkeys+==private,=protected,=public
+
+" Only define the function once.
+if exists("*GetRubyIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+" 1. Variables {{{1
+" ============
+
+" Syntax group names that are strings.
+let s:syng_string =
+      \ ['String', 'Interpolation', 'InterpolationDelimiter', 'NoInterpolation', 'StringEscape']
+
+" Syntax group names that are strings or documentation.
+let s:syng_stringdoc = s:syng_string + ['Documentation']
+
+" Syntax group names that are or delimit strings/symbols/regexes or are comments.
+let s:syng_strcom = s:syng_stringdoc +
+      \ ['Regexp', 'RegexpDelimiter', 'RegexpEscape',
+      \ 'Symbol', 'StringDelimiter', 'ASCIICode', 'Comment']
+
+" Expression used to check whether we should skip a match with searchpair().
+let s:skip_expr =
+      \ 'index(map('.string(s:syng_strcom).',"hlID(''ruby''.v:val)"), synID(line("."),col("."),1)) >= 0'
+
+" Regex used for words that, at the start of a line, add a level of indent.
+let s:ruby_indent_keywords =
+      \ '^\s*\zs\<\%(module\|class\|if\|for' .
+      \   '\|while\|until\|else\|elsif\|case\|when\|unless\|begin\|ensure\|rescue' .
+      \   '\|\%(\K\k*[!?]\?\)\=\s*def\):\@!\>' .
+      \ '\|\%([=,*/%+-]\|<<\|>>\|:\s\)\s*\zs' .
+      \    '\<\%(if\|for\|while\|until\|case\|unless\|begin\):\@!\>'
+
+" Regex used for words that, at the start of a line, remove a level of indent.
+let s:ruby_deindent_keywords =
+      \ '^\s*\zs\<\%(ensure\|else\|rescue\|elsif\|when\|end\):\@!\>'
+
+" Regex that defines the start-match for the 'end' keyword.
+"let s:end_start_regex = '\%(^\|[^.]\)\<\%(module\|class\|def\|if\|for\|while\|until\|case\|unless\|begin\|do\)\>'
+" TODO: the do here should be restricted somewhat (only at end of line)?
+let s:end_start_regex =
+      \ '\C\%(^\s*\|[=,*/%+\-|;{]\|<<\|>>\|:\s\)\s*\zs' .
+      \ '\<\%(module\|class\|if\|for\|while\|until\|case\|unless\|begin' .
+      \   '\|\%(\K\k*[!?]\?\)\=\s*def\):\@!\>' .
+      \ '\|\%(^\|[^.:@$]\)\@<=\<do:\@!\>'
+
+" Regex that defines the middle-match for the 'end' keyword.
+let s:end_middle_regex = '\<\%(ensure\|else\|\%(\%(^\|;\)\s*\)\@<=\<rescue:\@!\>\|when\|elsif\):\@!\>'
+
+" Regex that defines the end-match for the 'end' keyword.
+let s:end_end_regex = '\%(^\|[^.:@$]\)\@<=\<end:\@!\>'
+
+" Expression used for searchpair() call for finding match for 'end' keyword.
+let s:end_skip_expr = s:skip_expr .
+      \ ' || (expand("<cword>") == "do"' .
+      \ ' && getline(".") =~ "^\\s*\\<\\(while\\|until\\|for\\):\\@!\\>")'
+
+" Regex that defines continuation lines, not including (, {, or [.
+let s:non_bracket_continuation_regex =
+      \ '\%([\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|:\@<![^[:alnum:]:][|&?]\|||\|&&\)\s*\%(#.*\)\=$'
+
+" Regex that defines continuation lines.
+let s:continuation_regex =
+      \ '\%(%\@<![({[\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|:\@<![^[:alnum:]:][|&?]\|||\|&&\)\s*\%(#.*\)\=$'
+
+" Regex that defines continuable keywords
+let s:continuable_regex =
+      \ '\C\%(^\s*\|[=,*/%+\-|;{]\|<<\|>>\|:\s\)\s*\zs' .
+      \ '\<\%(if\|for\|while\|until\|unless\):\@!\>'
+
+" Regex that defines bracket continuations
+let s:bracket_continuation_regex = '%\@<!\%([({[]\)\s*\%(#.*\)\=$'
+
+" Regex that defines dot continuations
+let s:dot_continuation_regex = '%\@<!\.\s*\%(#.*\)\=$'
+
+" Regex that defines backslash continuations
+let s:backslash_continuation_regex = '%\@<!\\\s*$'
+
+" Regex that defines end of bracket continuation followed by another continuation
+let s:bracket_switch_continuation_regex = '^\([^(]\+\zs).\+\)\+'.s:continuation_regex
+
+" Regex that defines the first part of a splat pattern
+let s:splat_regex = '[[,(]\s*\*\s*\%(#.*\)\=$'
+
+" Regex that describes all indent access modifiers
+let s:access_modifier_regex = '\C^\s*\%(public\|protected\|private\)\s*\%(#.*\)\=$'
+
+" Regex that describes the indent access modifiers (excludes public)
+let s:indent_access_modifier_regex = '\C^\s*\%(protected\|private\)\s*\%(#.*\)\=$'
+
+" Regex that defines blocks.
+"
+" Note that there's a slight problem with this regex and s:continuation_regex.
+" Code like this will be matched by both:
+"
+"   method_call do |(a, b)|
+"
+" The reason is that the pipe matches a hanging "|" operator.
+"
+let s:block_regex =
+      \ '\%(\<do:\@!\>\|%\@<!{\)\s*\%(|[^|]*|\)\=\s*\%(#.*\)\=$'
+
+let s:block_continuation_regex = '^\s*[^])}\t ].*'.s:block_regex
+
+" Regex that describes a leading operator (only a method call's dot for now)
+let s:leading_operator_regex = '^\s*[.]'
+
+" 2. GetRubyIndent Function {{{1
+" =========================
+
+function! GetRubyIndent(...) abort
+  " 2.1. Setup {{{2
+  " ----------
+
+  let indent_info = {}
+
+  " The value of a single shift-width
+  if exists('*shiftwidth')
+    let indent_info.sw = shiftwidth()
+  else
+    let indent_info.sw = &sw
+  endif
+
+  " For the current line, use the first argument if given, else v:lnum
+  let indent_info.clnum = a:0 ? a:1 : v:lnum
+  let indent_info.cline = getline(indent_info.clnum)
+
+  " Set up variables for restoring position in file.  Could use clnum here.
+  let indent_info.col = col('.')
+
+  " 2.2. Work on the current line {{{2
+  " -----------------------------
+  let indent_callback_names = [
+        \ 's:AccessModifier',
+        \ 's:ClosingBracketOnEmptyLine',
+        \ 's:BlockComment',
+        \ 's:DeindentingKeyword',
+        \ 's:MultilineStringOrLineComment',
+        \ 's:ClosingHeredocDelimiter',
+        \ 's:LeadingOperator',
+        \ ]
+
+  for callback_name in indent_callback_names
+"    Decho "Running: ".callback_name
+    let indent = call(function(callback_name), [indent_info])
+
+    if indent >= 0
+"      Decho "Match: ".callback_name." indent=".indent." info=".string(indent_info)
+      return indent
+    endif
+  endfor
+
+  " 2.3. Work on the previous line. {{{2
+  " -------------------------------
+
+  " Special case: we don't need the real s:PrevNonBlankNonString for an empty
+  " line inside a string. And that call can be quite expensive in that
+  " particular situation.
+  let indent_callback_names = [
+        \ 's:EmptyInsideString',
+        \ ]
+
+  for callback_name in indent_callback_names
+"    Decho "Running: ".callback_name
+    let indent = call(function(callback_name), [indent_info])
+
+    if indent >= 0
+"      Decho "Match: ".callback_name." indent=".indent." info=".string(indent_info)
+      return indent
+    endif
+  endfor
+
+  " Previous line number
+  let indent_info.plnum = s:PrevNonBlankNonString(indent_info.clnum - 1)
+  let indent_info.pline = getline(indent_info.plnum)
+
+  let indent_callback_names = [
+        \ 's:StartOfFile',
+        \ 's:AfterAccessModifier',
+        \ 's:ContinuedLine',
+        \ 's:AfterBlockOpening',
+        \ 's:AfterHangingSplat',
+        \ 's:AfterUnbalancedBracket',
+        \ 's:AfterLeadingOperator',
+        \ 's:AfterEndKeyword',
+        \ 's:AfterIndentKeyword',
+        \ ]
+
+  for callback_name in indent_callback_names
+"    Decho "Running: ".callback_name
+    let indent = call(function(callback_name), [indent_info])
+
+    if indent >= 0
+"      Decho "Match: ".callback_name." indent=".indent." info=".string(indent_info)
+      return indent
+    endif
+  endfor
+
+  " 2.4. Work on the MSL line. {{{2
+  " --------------------------
+  let indent_callback_names = [
+        \ 's:PreviousNotMSL',
+        \ 's:IndentingKeywordInMSL',
+        \ 's:ContinuedHangingOperator',
+        \ ]
+
+  " Most Significant line based on the previous one -- in case it's a
+  " contination of something above
+  let indent_info.plnum_msl = s:GetMSL(indent_info.plnum)
+
+  for callback_name in indent_callback_names
+"    Decho "Running: ".callback_name
+    let indent = call(function(callback_name), [indent_info])
+
+    if indent >= 0
+"      Decho "Match: ".callback_name." indent=".indent." info=".string(indent_info)
+      return indent
+    endif
+  endfor
+
+  " }}}2
+
+  " By default, just return the previous line's indent
+"  Decho "Default case matched"
+  return indent(indent_info.plnum)
+endfunction
+
+" 3. Indenting Logic Callbacks {{{1
+" ============================
+
+function! s:AccessModifier(cline_info) abort
+  let info = a:cline_info
+
+  " If this line is an access modifier keyword, align according to the closest
+  " class declaration.
+  if g:ruby_indent_access_modifier_style == 'indent'
+    if s:Match(info.clnum, s:access_modifier_regex)
+      let class_lnum = s:FindContainingClass()
+      if class_lnum > 0
+        return indent(class_lnum) + info.sw
+      endif
+    endif
+  elseif g:ruby_indent_access_modifier_style == 'outdent'
+    if s:Match(info.clnum, s:access_modifier_regex)
+      let class_lnum = s:FindContainingClass()
+      if class_lnum > 0
+        return indent(class_lnum)
+      endif
+    endif
+  endif
+
+  return -1
+endfunction
+
+function! s:ClosingBracketOnEmptyLine(cline_info) abort
+  let info = a:cline_info
+
+  " If we got a closing bracket on an empty line, find its match and indent
+  " according to it.  For parentheses we indent to its column - 1, for the
+  " others we indent to the containing line's MSL's level.  Return -1 if fail.
+  let col = matchend(info.cline, '^\s*[]})]')
+
+  if col > 0 && !s:IsInStringOrComment(info.clnum, col)
+    call cursor(info.clnum, col)
+    let closing_bracket = info.cline[col - 1]
+    let bracket_pair = strpart('(){}[]', stridx(')}]', closing_bracket) * 2, 2)
+
+    if searchpair(escape(bracket_pair[0], '\['), '', bracket_pair[1], 'bW', s:skip_expr) > 0
+      if closing_bracket == ')' && col('.') != col('$') - 1
+        let ind = virtcol('.') - 1
+      elseif g:ruby_indent_block_style == 'do'
+        let ind = indent(line('.'))
+      else " g:ruby_indent_block_style == 'expression'
+        let ind = indent(s:GetMSL(line('.')))
+      endif
+    endif
+
+    return ind
+  endif
+
+  return -1
+endfunction
+
+function! s:BlockComment(cline_info) abort
+  " If we have a =begin or =end set indent to first column.
+  if match(a:cline_info.cline, '^\s*\%(=begin\|=end\)$') != -1
+    return 0
+  endif
+  return -1
+endfunction
+
+function! s:DeindentingKeyword(cline_info) abort
+  let info = a:cline_info
+
+  " If we have a deindenting keyword, find its match and indent to its level.
+  " TODO: this is messy
+  if s:Match(info.clnum, s:ruby_deindent_keywords)
+    call cursor(info.clnum, 1)
+
+    if searchpair(s:end_start_regex, s:end_middle_regex, s:end_end_regex, 'bW',
+          \ s:end_skip_expr) > 0
+      let msl  = s:GetMSL(line('.'))
+      let line = getline(line('.'))
+
+      if s:IsAssignment(line, col('.')) &&
+            \ strpart(line, col('.') - 1, 2) !~ 'do'
+        " assignment to case/begin/etc, on the same line
+        if g:ruby_indent_assignment_style == 'hanging'
+          " hanging indent
+          let ind = virtcol('.') - 1
+        else
+          " align with variable
+          let ind = indent(line('.'))
+        endif
+      elseif g:ruby_indent_block_style == 'do'
+        " align to line of the "do", not to the MSL
+        let ind = indent(line('.'))
+      elseif getline(msl) =~ '=\s*\(#.*\)\=$'
+        " in the case of assignment to the MSL, align to the starting line,
+        " not to the MSL
+        let ind = indent(line('.'))
+      else
+        " align to the MSL
+        let ind = indent(msl)
+      endif
+    endif
+    return ind
+  endif
+
+  return -1
+endfunction
+
+function! s:MultilineStringOrLineComment(cline_info) abort
+  let info = a:cline_info
+
+  " If we are in a multi-line string or line-comment, don't do anything to it.
+  if s:IsInStringOrDocumentation(info.clnum, matchend(info.cline, '^\s*') + 1)
+    return indent(info.clnum)
+  endif
+  return -1
+endfunction
+
+function! s:ClosingHeredocDelimiter(cline_info) abort
+  let info = a:cline_info
+
+  " If we are at the closing delimiter of a "<<" heredoc-style string, set the
+  " indent to 0.
+  if info.cline =~ '^\k\+\s*$'
+        \ && s:IsInStringDelimiter(info.clnum, 1)
+        \ && search('\V<<'.info.cline, 'nbW') > 0
+    return 0
+  endif
+
+  return -1
+endfunction
+
+function! s:LeadingOperator(cline_info) abort
+  " If the current line starts with a leading operator, add a level of indent.
+  if s:Match(a:cline_info.clnum, s:leading_operator_regex)
+    return indent(s:GetMSL(a:cline_info.clnum)) + a:cline_info.sw
+  endif
+  return -1
+endfunction
+
+function! s:EmptyInsideString(pline_info) abort
+  " If the line is empty and inside a string (the previous line is a string,
+  " too), use the previous line's indent
+  let info = a:pline_info
+
+  let plnum = prevnonblank(info.clnum - 1)
+  let pline = getline(plnum)
+
+  if info.cline =~ '^\s*$'
+        \ && s:IsInStringOrComment(plnum, 1)
+        \ && s:IsInStringOrComment(plnum, strlen(pline))
+    return indent(plnum)
+  endif
+  return -1
+endfunction
+
+function! s:StartOfFile(pline_info) abort
+  " At the start of the file use zero indent.
+  if a:pline_info.plnum == 0
+    return 0
+  endif
+  return -1
+endfunction
+
+function! s:AfterAccessModifier(pline_info) abort
+  let info = a:pline_info
+
+  if g:ruby_indent_access_modifier_style == 'indent'
+    " If the previous line was a private/protected keyword, add a
+    " level of indent.
+    if s:Match(info.plnum, s:indent_access_modifier_regex)
+      return indent(info.plnum) + info.sw
+    endif
+  elseif g:ruby_indent_access_modifier_style == 'outdent'
+    " If the previous line was a private/protected/public keyword, add
+    " a level of indent, since the keyword has been out-dented.
+    if s:Match(info.plnum, s:access_modifier_regex)
+      return indent(info.plnum) + info.sw
+    endif
+  endif
+  return -1
+endfunction
+
+" Example:
+"
+"   if foo || bar ||
+"       baz || bing
+"     puts "foo"
+"   end
+"
+function! s:ContinuedLine(pline_info) abort
+  let info = a:pline_info
+
+  let col = s:Match(info.plnum, s:ruby_indent_keywords)
+  if s:Match(info.plnum, s:continuable_regex) &&
+        \ s:Match(info.plnum, s:continuation_regex)
+    if col > 0 && s:IsAssignment(info.pline, col)
+      if g:ruby_indent_assignment_style == 'hanging'
+        " hanging indent
+        let ind = col - 1
+      else
+        " align with variable
+        let ind = indent(info.plnum)
+      endif
+    else
+      let ind = indent(s:GetMSL(info.plnum))
+    endif
+    return ind + info.sw + info.sw
+  endif
+  return -1
+endfunction
+
+function! s:AfterBlockOpening(pline_info) abort
+  let info = a:pline_info
+
+  " If the previous line ended with a block opening, add a level of indent.
+  if s:Match(info.plnum, s:block_regex)
+    if g:ruby_indent_block_style == 'do'
+      " don't align to the msl, align to the "do"
+      let ind = indent(info.plnum) + info.sw
+    else
+      let plnum_msl = s:GetMSL(info.plnum)
+
+      if getline(plnum_msl) =~ '=\s*\(#.*\)\=$'
+        " in the case of assignment to the msl, align to the starting line,
+        " not to the msl
+        let ind = indent(info.plnum) + info.sw
+      else
+        let ind = indent(plnum_msl) + info.sw
+      endif
+    endif
+
+    return ind
+  endif
+
+  return -1
+endfunction
+
+function! s:AfterLeadingOperator(pline_info) abort
+  " If the previous line started with a leading operator, use its MSL's level
+  " of indent
+  if s:Match(a:pline_info.plnum, s:leading_operator_regex)
+    return indent(s:GetMSL(a:pline_info.plnum))
+  endif
+  return -1
+endfunction
+
+function! s:AfterHangingSplat(pline_info) abort
+  let info = a:pline_info
+
+  " If the previous line ended with the "*" of a splat, add a level of indent
+  if info.pline =~ s:splat_regex
+    return indent(info.plnum) + info.sw
+  endif
+  return -1
+endfunction
+
+function! s:AfterUnbalancedBracket(pline_info) abort
+  let info = a:pline_info
+
+  " If the previous line contained unclosed opening brackets and we are still
+  " in them, find the rightmost one and add indent depending on the bracket
+  " type.
+  "
+  " If it contained hanging closing brackets, find the rightmost one, find its
+  " match and indent according to that.
+  if info.pline =~ '[[({]' || info.pline =~ '[])}]\s*\%(#.*\)\=$'
+    let [opening, closing] = s:ExtraBrackets(info.plnum)
+
+    if opening.pos != -1
+      if opening.type == '(' && searchpair('(', '', ')', 'bW', s:skip_expr) > 0
+        if col('.') + 1 == col('$')
+          return indent(info.plnum) + info.sw
+        else
+          return virtcol('.')
+        endif
+      else
+        let nonspace = matchend(info.pline, '\S', opening.pos + 1) - 1
+        return nonspace > 0 ? nonspace : indent(info.plnum) + info.sw
+      endif
+    elseif closing.pos != -1
+      call cursor(info.plnum, closing.pos + 1)
+      normal! %
+
+      if s:Match(line('.'), s:ruby_indent_keywords)
+        return indent('.') + info.sw
+      else
+        return indent(s:GetMSL(line('.')))
+      endif
+    else
+      call cursor(info.clnum, info.col)
+    end
+  endif
+
+  return -1
+endfunction
+
+function! s:AfterEndKeyword(pline_info) abort
+  let info = a:pline_info
+  " If the previous line ended with an "end", match that "end"s beginning's
+  " indent.
+  let col = s:Match(info.plnum, '\%(^\|[^.:@$]\)\<end\>\s*\%(#.*\)\=$')
+  if col > 0
+    call cursor(info.plnum, col)
+    if searchpair(s:end_start_regex, '', s:end_end_regex, 'bW',
+          \ s:end_skip_expr) > 0
+      let n = line('.')
+      let ind = indent('.')
+      let msl = s:GetMSL(n)
+      if msl != n
+        let ind = indent(msl)
+      end
+      return ind
+    endif
+  end
+  return -1
+endfunction
+
+function! s:AfterIndentKeyword(pline_info) abort
+  let info = a:pline_info
+  let col = s:Match(info.plnum, s:ruby_indent_keywords)
+
+  if col > 0
+    call cursor(info.plnum, col)
+    let ind = virtcol('.') - 1 + info.sw
+    " TODO: make this better (we need to count them) (or, if a searchpair
+    " fails, we know that something is lacking an end and thus we indent a
+    " level
+    if s:Match(info.plnum, s:end_end_regex)
+      let ind = indent('.')
+    elseif s:IsAssignment(info.pline, col)
+      if g:ruby_indent_assignment_style == 'hanging'
+        " hanging indent
+        let ind = col + info.sw - 1
+      else
+        " align with variable
+        let ind = indent(info.plnum) + info.sw
+      endif
+    endif
+    return ind
+  endif
+
+  return -1
+endfunction
+
+function! s:PreviousNotMSL(msl_info) abort
+  let info = a:msl_info
+
+  " If the previous line wasn't a MSL
+  if info.plnum != info.plnum_msl
+    " If previous line ends bracket and begins non-bracket continuation decrease indent by 1.
+    if s:Match(info.plnum, s:bracket_switch_continuation_regex)
+      " TODO (2016-10-07) Wrong/unused? How could it be "1"?
+      return indent(info.plnum) - 1
+      " If previous line is a continuation return its indent.
+      " TODO: the || s:IsInString() thing worries me a bit.
+    elseif s:Match(info.plnum, s:non_bracket_continuation_regex) || s:IsInString(info.plnum, strlen(line))
+      return indent(info.plnum)
+    endif
+  endif
+
+  return -1
+endfunction
+
+function! s:IndentingKeywordInMSL(msl_info) abort
+  let info = a:msl_info
+  " If the MSL line had an indenting keyword in it, add a level of indent.
+  " TODO: this does not take into account contrived things such as
+  " module Foo; class Bar; end
+  let col = s:Match(info.plnum_msl, s:ruby_indent_keywords)
+  if col > 0
+    let ind = indent(info.plnum_msl) + info.sw
+    if s:Match(info.plnum_msl, s:end_end_regex)
+      let ind = ind - info.sw
+    elseif s:IsAssignment(getline(info.plnum_msl), col)
+      if g:ruby_indent_assignment_style == 'hanging'
+        " hanging indent
+        let ind = col + info.sw - 1
+      else
+        " align with variable
+        let ind = indent(info.plnum_msl) + info.sw
+      endif
+    endif
+    return ind
+  endif
+  return -1
+endfunction
+
+function! s:ContinuedHangingOperator(msl_info) abort
+  let info = a:msl_info
+
+  " If the previous line ended with [*+/.,-=], but wasn't a block ending or a
+  " closing bracket, indent one extra level.
+  if s:Match(info.plnum_msl, s:non_bracket_continuation_regex) && !s:Match(info.plnum_msl, '^\s*\([\])}]\|end\)')
+    if info.plnum_msl == info.plnum
+      let ind = indent(info.plnum_msl) + info.sw
+    else
+      let ind = indent(info.plnum_msl)
+    endif
+    return ind
+  endif
+
+  return -1
+endfunction
+
+" 4. Auxiliary Functions {{{1
+" ======================
+
+function! s:IsInRubyGroup(groups, lnum, col) abort
+  let ids = map(copy(a:groups), 'hlID("ruby".v:val)')
+  return index(ids, synID(a:lnum, a:col, 1)) >= 0
+endfunction
+
+" Check if the character at lnum:col is inside a string, comment, or is ascii.
+function! s:IsInStringOrComment(lnum, col) abort
+  return s:IsInRubyGroup(s:syng_strcom, a:lnum, a:col)
+endfunction
+
+" Check if the character at lnum:col is inside a string.
+function! s:IsInString(lnum, col) abort
+  return s:IsInRubyGroup(s:syng_string, a:lnum, a:col)
+endfunction
+
+" Check if the character at lnum:col is inside a string or documentation.
+function! s:IsInStringOrDocumentation(lnum, col) abort
+  return s:IsInRubyGroup(s:syng_stringdoc, a:lnum, a:col)
+endfunction
+
+" Check if the character at lnum:col is inside a string delimiter
+function! s:IsInStringDelimiter(lnum, col) abort
+  return s:IsInRubyGroup(['StringDelimiter'], a:lnum, a:col)
+endfunction
+
+function! s:IsAssignment(str, pos) abort
+  return strpart(a:str, 0, a:pos - 1) =~ '=\s*$'
+endfunction
+
+" Find line above 'lnum' that isn't empty, in a comment, or in a string.
+function! s:PrevNonBlankNonString(lnum) abort
+  let in_block = 0
+  let lnum = prevnonblank(a:lnum)
+  while lnum > 0
+    " Go in and out of blocks comments as necessary.
+    " If the line isn't empty (with opt. comment) or in a string, end search.
+    let line = getline(lnum)
+    if line =~ '^=begin'
+      if in_block
+        let in_block = 0
+      else
+        break
+      endif
+    elseif !in_block && line =~ '^=end'
+      let in_block = 1
+    elseif !in_block && line !~ '^\s*#.*$' && !(s:IsInStringOrComment(lnum, 1)
+          \ && s:IsInStringOrComment(lnum, strlen(line)))
+      break
+    endif
+    let lnum = prevnonblank(lnum - 1)
+  endwhile
+  return lnum
+endfunction
+
+" Find line above 'lnum' that started the continuation 'lnum' may be part of.
+function! s:GetMSL(lnum) abort
+  " Start on the line we're at and use its indent.
+  let msl = a:lnum
+  let lnum = s:PrevNonBlankNonString(a:lnum - 1)
+  while lnum > 0
+    " If we have a continuation line, or we're in a string, use line as MSL.
+    " Otherwise, terminate search as we have found our MSL already.
+    let line = getline(lnum)
+
+    if !s:Match(msl, s:backslash_continuation_regex) &&
+          \ s:Match(lnum, s:backslash_continuation_regex)
+      " If the current line doesn't end in a backslash, but the previous one
+      " does, look for that line's msl
+      "
+      " Example:
+      "   foo = "bar" \
+      "     "baz"
+      "
+      let msl = lnum
+    elseif s:Match(msl, s:leading_operator_regex)
+      " If the current line starts with a leading operator, keep its indent
+      " and keep looking for an MSL.
+      let msl = lnum
+    elseif s:Match(lnum, s:splat_regex)
+      " If the above line looks like the "*" of a splat, use the current one's
+      " indentation.
+      "
+      " Example:
+      "   Hash[*
+      "     method_call do
+      "       something
+      "
+      return msl
+    elseif s:Match(lnum, s:non_bracket_continuation_regex) &&
+          \ s:Match(msl, s:non_bracket_continuation_regex)
+      " If the current line is a non-bracket continuation and so is the
+      " previous one, keep its indent and continue looking for an MSL.
+      "
+      " Example:
+      "   method_call one,
+      "     two,
+      "     three
+      "
+      let msl = lnum
+    elseif s:Match(lnum, s:dot_continuation_regex) &&
+          \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
+      " If the current line is a bracket continuation or a block-starter, but
+      " the previous is a dot, keep going to see if the previous line is the
+      " start of another continuation.
+      "
+      " Example:
+      "   parent.
+      "     method_call {
+      "     three
+      "
+      let msl = lnum
+    elseif s:Match(lnum, s:non_bracket_continuation_regex) &&
+          \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
+      " If the current line is a bracket continuation or a block-starter, but
+      " the previous is a non-bracket one, respect the previous' indentation,
+      " and stop here.
+      "
+      " Example:
+      "   method_call one,
+      "     two {
+      "     three
+      "
+      return lnum
+    elseif s:Match(lnum, s:bracket_continuation_regex) &&
+          \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
+      " If both lines are bracket continuations (the current may also be a
+      " block-starter), use the current one's and stop here
+      "
+      " Example:
+      "   method_call(
+      "     other_method_call(
+      "       foo
+      return msl
+    elseif s:Match(lnum, s:block_regex) &&
+          \ !s:Match(msl, s:continuation_regex) &&
+          \ !s:Match(msl, s:block_continuation_regex)
+      " If the previous line is a block-starter and the current one is
+      " mostly ordinary, use the current one as the MSL.
+      "
+      " Example:
+      "   method_call do
+      "     something
+      "     something_else
+      return msl
+    else
+      let col = match(line, s:continuation_regex) + 1
+      if (col > 0 && !s:IsInStringOrComment(lnum, col))
+            \ || s:IsInString(lnum, strlen(line))
+        let msl = lnum
+      else
+        break
+      endif
+    endif
+
+    let lnum = s:PrevNonBlankNonString(lnum - 1)
+  endwhile
+  return msl
+endfunction
+
+" Check if line 'lnum' has more opening brackets than closing ones.
+function! s:ExtraBrackets(lnum) abort
+  let opening = {'parentheses': [], 'braces': [], 'brackets': []}
+  let closing = {'parentheses': [], 'braces': [], 'brackets': []}
+
+  let line = getline(a:lnum)
+  let pos  = match(line, '[][(){}]', 0)
+
+  " Save any encountered opening brackets, and remove them once a matching
+  " closing one has been found. If a closing bracket shows up that doesn't
+  " close anything, save it for later.
+  while pos != -1
+    if !s:IsInStringOrComment(a:lnum, pos + 1)
+      if line[pos] == '('
+        call add(opening.parentheses, {'type': '(', 'pos': pos})
+      elseif line[pos] == ')'
+        if empty(opening.parentheses)
+          call add(closing.parentheses, {'type': ')', 'pos': pos})
+        else
+          let opening.parentheses = opening.parentheses[0:-2]
+        endif
+      elseif line[pos] == '{'
+        call add(opening.braces, {'type': '{', 'pos': pos})
+      elseif line[pos] == '}'
+        if empty(opening.braces)
+          call add(closing.braces, {'type': '}', 'pos': pos})
+        else
+          let opening.braces = opening.braces[0:-2]
+        endif
+      elseif line[pos] == '['
+        call add(opening.brackets, {'type': '[', 'pos': pos})
+      elseif line[pos] == ']'
+        if empty(opening.brackets)
+          call add(closing.brackets, {'type': ']', 'pos': pos})
+        else
+          let opening.brackets = opening.brackets[0:-2]
+        endif
+      endif
+    endif
+
+    let pos = match(line, '[][(){}]', pos + 1)
+  endwhile
+
+  " Find the rightmost brackets, since they're the ones that are important in
+  " both opening and closing cases
+  let rightmost_opening = {'type': '(', 'pos': -1}
+  let rightmost_closing = {'type': ')', 'pos': -1}
+
+  for opening in opening.parentheses + opening.braces + opening.brackets
+    if opening.pos > rightmost_opening.pos
+      let rightmost_opening = opening
+    endif
+  endfor
+
+  for closing in closing.parentheses + closing.braces + closing.brackets
+    if closing.pos > rightmost_closing.pos
+      let rightmost_closing = closing
+    endif
+  endfor
+
+  return [rightmost_opening, rightmost_closing]
+endfunction
+
+function! s:Match(lnum, regex) abort
+  let line   = getline(a:lnum)
+  let offset = match(line, '\C'.a:regex)
+  let col    = offset + 1
+
+  while offset > -1 && s:IsInStringOrComment(a:lnum, col)
+    let offset = match(line, '\C'.a:regex, offset + 1)
+    let col = offset + 1
+  endwhile
+
+  if offset > -1
+    return col
+  else
+    return 0
+  endif
+endfunction
+
+" Locates the containing class/module's definition line, ignoring nested classes
+" along the way.
+"
+function! s:FindContainingClass() abort
+  let saved_position = getpos('.')
+
+  while searchpair(s:end_start_regex, s:end_middle_regex, s:end_end_regex, 'bW',
+        \ s:end_skip_expr) > 0
+    if expand('<cword>') =~# '\<class\|module\>'
+      let found_lnum = line('.')
+      call setpos('.', saved_position)
+      return found_lnum
+    endif
+  endwhile
+
+  call setpos('.', saved_position)
+  return 0
+endfunction
+
+" }}}1
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim:set sw=2 sts=2 ts=8 et:

Git/usr/share/vim/vim81/indent/rust.vim

@@ -0,0 +1,213 @@
+" Vim indent file
+" Language:         Rust
+" Author:           Chris Morgan <me@chrismorgan.info>
+" Last Change:      2017 Jun 13
+" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+	finish
+endif
+let b:did_indent = 1
+
+setlocal cindent
+setlocal cinoptions=L0,(0,Ws,J1,j1
+setlocal cinkeys=0{,0},!^F,o,O,0[,0]
+" Don't think cinwords will actually do anything at all... never mind
+setlocal cinwords=for,if,else,while,loop,impl,mod,unsafe,trait,struct,enum,fn,extern
+
+" Some preliminary settings
+setlocal nolisp		" Make sure lisp indenting doesn't supersede us
+setlocal autoindent	" indentexpr isn't much help otherwise
+" Also do indentkeys, otherwise # gets shoved to column 0 :-/
+setlocal indentkeys=0{,0},!^F,o,O,0[,0]
+
+setlocal indentexpr=GetRustIndent(v:lnum)
+
+" Only define the function once.
+if exists("*GetRustIndent")
+	finish
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Come here when loading the script the first time.
+
+function! s:get_line_trimmed(lnum)
+	" Get the line and remove a trailing comment.
+	" Use syntax highlighting attributes when possible.
+	" NOTE: this is not accurate; /* */ or a line continuation could trick it
+	let line = getline(a:lnum)
+	let line_len = strlen(line)
+	if has('syntax_items')
+		" If the last character in the line is a comment, do a binary search for
+		" the start of the comment.  synID() is slow, a linear search would take
+		" too long on a long line.
+		if synIDattr(synID(a:lnum, line_len, 1), "name") =~ 'Comment\|Todo'
+			let min = 1
+			let max = line_len
+			while min < max
+				let col = (min + max) / 2
+				if synIDattr(synID(a:lnum, col, 1), "name") =~ 'Comment\|Todo'
+					let max = col
+				else
+					let min = col + 1
+				endif
+			endwhile
+			let line = strpart(line, 0, min - 1)
+		endif
+		return substitute(line, "\s*$", "", "")
+	else
+		" Sorry, this is not complete, nor fully correct (e.g. string "//").
+		" Such is life.
+		return substitute(line, "\s*//.*$", "", "")
+	endif
+endfunction
+
+function! s:is_string_comment(lnum, col)
+	if has('syntax_items')
+		for id in synstack(a:lnum, a:col)
+			let synname = synIDattr(id, "name")
+			if synname == "rustString" || synname =~ "^rustComment"
+				return 1
+			endif
+		endfor
+	else
+		" without syntax, let's not even try
+		return 0
+	endif
+endfunction
+
+function GetRustIndent(lnum)
+
+	" Starting assumption: cindent (called at the end) will do it right
+	" normally. We just want to fix up a few cases.
+
+	let line = getline(a:lnum)
+
+	if has('syntax_items')
+		let synname = synIDattr(synID(a:lnum, 1, 1), "name")
+		if synname == "rustString"
+			" If the start of the line is in a string, don't change the indent
+			return -1
+		elseif synname =~ '\(Comment\|Todo\)'
+					\ && line !~ '^\s*/\*'  " not /* opening line
+			if synname =~ "CommentML" " multi-line
+				if line !~ '^\s*\*' && getline(a:lnum - 1) =~ '^\s*/\*'
+					" This is (hopefully) the line after a /*, and it has no
+					" leader, so the correct indentation is that of the
+					" previous line.
+					return GetRustIndent(a:lnum - 1)
+				endif
+			endif
+			" If it's in a comment, let cindent take care of it now. This is
+			" for cases like "/*" where the next line should start " * ", not
+			" "* " as the code below would otherwise cause for module scope
+			" Fun fact: "  /*\n*\n*/" takes two calls to get right!
+			return cindent(a:lnum)
+		endif
+	endif
+
+	" cindent gets second and subsequent match patterns/struct members wrong,
+	" as it treats the comma as indicating an unfinished statement::
+	"
+	" match a {
+	"     b => c,
+	"         d => e,
+	"         f => g,
+	" };
+
+	" Search backwards for the previous non-empty line.
+	let prevlinenum = prevnonblank(a:lnum - 1)
+	let prevline = s:get_line_trimmed(prevlinenum)
+	while prevlinenum > 1 && prevline !~ '[^[:blank:]]'
+		let prevlinenum = prevnonblank(prevlinenum - 1)
+		let prevline = s:get_line_trimmed(prevlinenum)
+	endwhile
+
+	" Handle where clauses nicely: subsequent values should line up nicely.
+	if prevline[len(prevline) - 1] == ","
+				\ && prevline =~# '^\s*where\s'
+		return indent(prevlinenum) + 6
+	endif
+
+	if prevline[len(prevline) - 1] == ","
+				\ && s:get_line_trimmed(a:lnum) !~ '^\s*[\[\]{}]'
+				\ && prevline !~ '^\s*fn\s'
+				\ && prevline !~ '([^()]\+,$'
+				\ && s:get_line_trimmed(a:lnum) !~ '^\s*\S\+\s*=>'
+		" Oh ho! The previous line ended in a comma! I bet cindent will try to
+		" take this too far... For now, let's normally use the previous line's
+		" indent.
+
+		" One case where this doesn't work out is where *this* line contains
+		" square or curly brackets; then we normally *do* want to be indenting
+		" further.
+		"
+		" Another case where we don't want to is one like a function
+		" definition with arguments spread over multiple lines:
+		"
+		" fn foo(baz: Baz,
+		"        baz: Baz) // <-- cindent gets this right by itself
+		"
+		" Another case is similar to the previous, except calling a function
+		" instead of defining it, or any conditional expression that leaves
+		" an open paren:
+		"
+		" foo(baz,
+		"     baz);
+		"
+		" if baz && (foo ||
+		"            bar) {
+		"
+		" Another case is when the current line is a new match arm.
+		"
+		" There are probably other cases where we don't want to do this as
+		" well. Add them as needed.
+		return indent(prevlinenum)
+	endif
+
+	if !has("patch-7.4.355")
+		" cindent before 7.4.355 doesn't do the module scope well at all; e.g.::
+		"
+		" static FOO : &'static [bool] = [
+		" true,
+		"	 false,
+		"	 false,
+		"	 true,
+		"	 ];
+		"
+		"	 uh oh, next statement is indented further!
+
+		" Note that this does *not* apply the line continuation pattern properly;
+		" that's too hard to do correctly for my liking at present, so I'll just
+		" start with these two main cases (square brackets and not returning to
+		" column zero)
+
+		call cursor(a:lnum, 1)
+		if searchpair('{\|(', '', '}\|)', 'nbW',
+					\ 's:is_string_comment(line("."), col("."))') == 0
+			if searchpair('\[', '', '\]', 'nbW',
+						\ 's:is_string_comment(line("."), col("."))') == 0
+				" Global scope, should be zero
+				return 0
+			else
+				" At the module scope, inside square brackets only
+				"if getline(a:lnum)[0] == ']' || search('\[', '', '\]', 'nW') == a:lnum
+				if line =~ "^\\s*]"
+					" It's the closing line, dedent it
+					return 0
+				else
+					return shiftwidth()
+				endif
+			endif
+		endif
+	endif
+
+	" Fall back on cindent, which does it mostly right
+	return cindent(a:lnum)
+endfunction
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

Git/usr/share/vim/vim81/indent/sas.vim

@@ -0,0 +1,138 @@
+" Vim indent file
+" Language:     SAS
+" Maintainer:   Zhen-Huan Hu <wildkeny@gmail.com>
+" Version:      3.0.3
+" Last Change:  Jun 26, 2018
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetSASIndent()
+setlocal indentkeys+=;,=~data,=~proc,=~macro
+
+if exists("*GetSASIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+" Regex that captures the start of a data/proc section
+let s:section_str = '\v%(^|;)\s*%(data|proc)>'
+" Regex that captures the end of a run-processing section
+let s:section_run = '\v%(^|;)\s*run\s*;'
+" Regex that captures the end of a data/proc section
+let s:section_end = '\v%(^|;)\s*%(quit|enddata)\s*;'
+
+" Regex that captures the start of a control block (anything inside a section)
+let s:block_str = '\v<%(do>%([^;]+<%(to|over|while)>[^;]+)=|%(compute|define\s+%(column|footer|header|style|table|tagset|crosstabs|statgraph)|edit|layout|method|select)>[^;]+|begingraph)\s*;'
+" Regex that captures the end of a control block (anything inside a section)
+let s:block_end = '\v<%(end|endcomp|endlayout|endgraph)\s*;'
+
+" Regex that captures the start of a macro
+let s:macro_str = '\v%(^|;)\s*\%macro>'
+" Regex that captures the end of a macro
+let s:macro_end = '\v%(^|;)\s*\%mend\s*;'
+
+" Regex that defines the end of the program
+let s:program_end = '\v%(^|;)\s*endsas\s*;'
+
+" List of procs supporting run-processing
+let s:run_processing_procs = [
+      \ 'catalog', 'chart', 'datasets', 'document', 'ds2', 'plot', 'sql',
+      \ 'gareabar', 'gbarline', 'gchart', 'gkpi', 'gmap', 'gplot', 'gradar', 'greplay', 'gslide', 'gtile',
+      \ 'anova', 'arima', 'catmod', 'factex', 'glm', 'model', 'optex', 'plan', 'reg',
+      \ 'iml',
+      \ ]
+
+" Find the line number of previous keyword defined by the regex
+function! s:PrevMatch(lnum, regex)
+  let prev_lnum = prevnonblank(a:lnum - 1)
+  while prev_lnum > 0
+    let prev_line = getline(prev_lnum)
+    if prev_line =~? a:regex
+      break
+    else
+      let prev_lnum = prevnonblank(prev_lnum - 1)
+    endif
+  endwhile
+  return prev_lnum
+endfunction
+
+" Main function
+function! GetSASIndent()
+  let prev_lnum = prevnonblank(v:lnum - 1)
+  if prev_lnum ==# 0
+    " Leave the indentation of the first line unchanged
+    return indent(1)
+  else
+    let prev_line = getline(prev_lnum)
+    " Previous non-blank line contains the start of a macro/section/block
+    " while not the end of a macro/section/block (at the same line)
+    if (prev_line =~? s:section_str && prev_line !~? s:section_run && prev_line !~? s:section_end) ||
+          \ (prev_line =~? s:block_str && prev_line !~? s:block_end) ||
+          \ (prev_line =~? s:macro_str && prev_line !~? s:macro_end)
+      let ind = indent(prev_lnum) + shiftwidth()
+    elseif prev_line =~? s:section_run && prev_line !~? s:section_end
+      let prev_section_str_lnum = s:PrevMatch(v:lnum, s:section_str)
+      let prev_section_end_lnum = max([
+            \ s:PrevMatch(v:lnum, s:section_end),
+            \ s:PrevMatch(v:lnum, s:macro_end  ),
+            \ s:PrevMatch(v:lnum, s:program_end)])
+      " Check if the section supports run-processing
+      if prev_section_end_lnum < prev_section_str_lnum &&
+            \ getline(prev_section_str_lnum) =~? '\v%(^|;)\s*proc\s+%(' .
+            \ join(s:run_processing_procs, '|') . ')>'
+        let ind = indent(prev_lnum) + shiftwidth()
+      else
+        let ind = indent(prev_lnum)
+      endif
+    else
+      let ind = indent(prev_lnum)
+    endif
+  endif
+  " Re-adjustments based on the inputs of the current line
+  let curr_line = getline(v:lnum)
+  if curr_line =~? s:program_end
+    " End of the program
+    " Same indentation as the first non-blank line
+    return indent(nextnonblank(1))
+  elseif curr_line =~? s:macro_end
+    " Current line is the end of a macro
+    " Match the indentation of the start of the macro
+    return indent(s:PrevMatch(v:lnum, s:macro_str))
+  elseif curr_line =~? s:block_end && curr_line !~? s:block_str
+    " Re-adjust if current line is the end of a block
+    " while not the beginning of a block (at the same line)
+    " Returning the indent of previous block start directly
+    " would not work due to nesting
+    let ind = ind - shiftwidth()
+  elseif curr_line =~? s:section_str || curr_line =~? s:section_run || curr_line =~? s:section_end
+    " Re-adjust if current line is the start/end of a section
+    " since the end of a section could be inexplicit
+    let prev_section_str_lnum = s:PrevMatch(v:lnum, s:section_str)
+    " Check if the previous section supports run-processing
+    if getline(prev_section_str_lnum) =~? '\v%(^|;)\s*proc\s+%(' .
+          \ join(s:run_processing_procs, '|') . ')>'
+      let prev_section_end_lnum = max([
+            \ s:PrevMatch(v:lnum, s:section_end),
+            \ s:PrevMatch(v:lnum, s:macro_end  ),
+            \ s:PrevMatch(v:lnum, s:program_end)])
+    else
+      let prev_section_end_lnum = max([
+            \ s:PrevMatch(v:lnum, s:section_end),
+            \ s:PrevMatch(v:lnum, s:section_run),
+            \ s:PrevMatch(v:lnum, s:macro_end  ),
+            \ s:PrevMatch(v:lnum, s:program_end)])
+    endif
+    if prev_section_end_lnum < prev_section_str_lnum
+      let ind = ind - shiftwidth()
+    endif
+  endif
+  return ind
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

Git/usr/share/vim/vim81/indent/sass.vim

@@ -0,0 +1,38 @@
+" Vim indent file
+" Language:	Sass
+" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
+" Last Change:	2017 Jun 13
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent sw=2 et
+setlocal indentexpr=GetSassIndent()
+setlocal indentkeys=o,O,*<Return>,<:>,!^F
+
+" Only define the function once.
+if exists("*GetSassIndent")
+  finish
+endif
+
+let s:property = '^\s*:\|^\s*[[:alnum:]#{}-]\+\%(:\|\s*=\)'
+let s:extend = '^\s*\%(@extend\|@include\|+\)'
+
+function! GetSassIndent()
+  let lnum = prevnonblank(v:lnum-1)
+  let line = substitute(getline(lnum),'\s\+$','','')
+  let cline = substitute(substitute(getline(v:lnum),'\s\+$','',''),'^\s\+','','')
+  let lastcol = strlen(line)
+  let line = substitute(line,'^\s\+','','')
+  let indent = indent(lnum)
+  let cindent = indent(v:lnum)
+  if line !~ s:property && line !~ s:extend && cline =~ s:property
+    return indent + shiftwidth()
+  else
+    return -1
+  endif
+endfunction
+
+" vim:set sw=2:

Git/usr/share/vim/vim81/indent/scala.vim

@@ -0,0 +1,609 @@
+" Vim indent file
+" Language:             Scala (http://scala-lang.org/)
+" Original Author:      Stefan Matthias Aust
+" Modifications By:     Derek Wyatt
+" URL:                  https://github.com/derekwyatt/vim-scala
+" Last Change:          2016 Aug 26
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentexpr=GetScalaIndent()
+setlocal indentkeys=0{,0},0),!^F,<>>,o,O,e,=case,<CR>
+
+if exists("*GetScalaIndent")
+  finish
+endif
+let s:keepcpo= &cpo
+set cpo&vim
+
+let s:defMatcher = '\%(\%(private\|protected\)\%(\[[^\]]*\]\)\?\s\+\|abstract\s\+\|override\s\+\)*\<def\>'
+let s:funcNameMatcher = '\w\+'
+let s:typeSpecMatcher = '\%(\s*\[\_[^\]]*\]\)'
+let s:defArgMatcher = '\%((\_.\{-})\)'
+let s:returnTypeMatcher = '\%(:\s*\w\+' . s:typeSpecMatcher . '\?\)'
+let g:fullDefMatcher = '^\s*' . s:defMatcher . '\s\+' . s:funcNameMatcher . '\s*' . s:typeSpecMatcher . '\?\s*' . s:defArgMatcher . '\?\s*' . s:returnTypeMatcher . '\?\s*[={]'
+
+function! scala#ConditionalConfirm(msg)
+  if 0
+    call confirm(a:msg)
+  endif
+endfunction
+
+function! scala#GetLine(lnum)
+  let line = substitute(getline(a:lnum), '//.*$', '', '')
+  let line = substitute(line, '"\(.\|\\"\)\{-}"', '""', 'g')
+  return line
+endfunction
+
+function! scala#CountBrackets(line, openBracket, closedBracket)
+  let line = substitute(a:line, '"\(.\|\\"\)\{-}"', '', 'g')
+  let open = substitute(line, '[^' . a:openBracket . ']', '', 'g')
+  let close = substitute(line, '[^' . a:closedBracket . ']', '', 'g')
+  return strlen(open) - strlen(close)
+endfunction
+
+function! scala#CountParens(line)
+  return scala#CountBrackets(a:line, '(', ')')
+endfunction
+
+function! scala#CountCurlies(line)
+  return scala#CountBrackets(a:line, '{', '}')
+endfunction
+
+function! scala#LineEndsInIncomplete(line)
+  if a:line =~ '[.,]\s*$'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#LineIsAClosingXML(line)
+  if a:line =~ '^\s*</\w'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#LineCompletesXML(lnum, line)
+  let savedpos = getpos('.')
+  call setpos('.', [savedpos[0], a:lnum, 0, savedpos[3]])
+  let tag = substitute(a:line, '^.*</\([^>]*\)>.*$', '\1', '')
+  let [lineNum, colnum] = searchpairpos('<' . tag . '>', '', '</' . tag . '>', 'Wbn')
+  call setpos('.', savedpos)
+  let pline = scala#GetLine(prevnonblank(lineNum - 1))
+  if pline =~ '=\s*$'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#IsParentCase()
+  let savedpos = getpos('.')
+  call setpos('.', [savedpos[0], savedpos[1], 0, savedpos[3]])
+  let [l, c] = searchpos('^\s*\%(' . s:defMatcher . '\|\%(\<case\>\)\)', 'bnW')
+  let retvalue = -1
+  if l != 0 && search('\%' . l . 'l\s*\<case\>', 'bnW')
+    let retvalue = l
+  endif
+  call setpos('.', savedpos)
+  return retvalue
+endfunction
+
+function! scala#CurlyMatcher()
+  let matchline = scala#GetLineThatMatchesBracket('{', '}')
+  if scala#CountParens(scala#GetLine(matchline)) < 0
+    let savedpos = getpos('.')
+    call setpos('.', [savedpos[0], matchline, 9999, savedpos[3]])
+    call searchpos('{', 'Wbc')
+    call searchpos(')', 'Wb')
+    let [lnum, colnum] = searchpairpos('(', '', ')', 'Wbn')
+    call setpos('.', savedpos)
+    let line = scala#GetLine(lnum)
+    if line =~ '^\s*' . s:defMatcher
+      return lnum
+    else
+      return matchline
+    endif
+  else
+    return matchline
+  endif
+endfunction
+
+function! scala#GetLineAndColumnThatMatchesCurly()
+  return scala#GetLineAndColumnThatMatchesBracket('{', '}')
+endfunction
+
+function! scala#GetLineAndColumnThatMatchesParen()
+  return scala#GetLineAndColumnThatMatchesBracket('(', ')')
+endfunction
+
+function! scala#GetLineAndColumnThatMatchesBracket(openBracket, closedBracket)
+  let savedpos = getpos('.')
+  let curline = scala#GetLine(line('.'))
+  if curline =~ a:closedBracket . '.*' . a:openBracket . '.*' . a:closedBracket
+    call setpos('.', [savedpos[0], savedpos[1], 0, savedpos[3]])
+    call searchpos(a:closedBracket . '\ze[^' . a:closedBracket . a:openBracket . ']*' . a:openBracket, 'W')
+  else
+    call setpos('.', [savedpos[0], savedpos[1], 9999, savedpos[3]])
+    call searchpos(a:closedBracket, 'Wbc')
+  endif
+  let [lnum, colnum] = searchpairpos(a:openBracket, '', a:closedBracket, 'Wbn')
+  call setpos('.', savedpos)
+  return [lnum, colnum]
+endfunction
+
+function! scala#GetLineThatMatchesCurly()
+  return scala#GetLineThatMatchesBracket('{', '}')
+endfunction
+
+function! scala#GetLineThatMatchesParen()
+  return scala#GetLineThatMatchesBracket('(', ')')
+endfunction
+
+function! scala#GetLineThatMatchesBracket(openBracket, closedBracket)
+  let [lnum, colnum] = scala#GetLineAndColumnThatMatchesBracket(a:openBracket, a:closedBracket)
+  return lnum
+endfunction
+
+function! scala#NumberOfBraceGroups(line)
+  let line = substitute(a:line, '[^()]', '', 'g')
+  if strlen(line) == 0
+    return 0
+  endif
+  let line = substitute(line, '^)*', '', 'g')
+  if strlen(line) == 0
+    return 0
+  endif
+  let line = substitute(line, '^(', '', 'g')
+  if strlen(line) == 0
+    return 0
+  endif
+  let c = 1
+  let counter = 0
+  let groupCount = 0
+  while counter < strlen(line)
+    let char = strpart(line, counter, 1)
+    if char == '('
+      let c = c + 1
+    elseif char == ')'
+      let c = c - 1
+    endif
+    if c == 0
+      let groupCount = groupCount + 1
+    endif
+    let counter = counter + 1
+  endwhile
+  return groupCount
+endfunction
+
+function! scala#MatchesIncompleteDefValr(line)
+  if a:line =~ '^\s*\%(' . s:defMatcher . '\|\<va[lr]\>\).*[=({]\s*$'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#LineIsCompleteIf(line)
+  if scala#CountBrackets(a:line, '{', '}') == 0 &&
+   \ scala#CountBrackets(a:line, '(', ')') == 0 &&
+   \ a:line =~ '^\s*\<if\>\s*([^)]*)\s*\S.*$'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#LineCompletesIfElse(lnum, line)
+  if a:line =~ '^\s*\%(\<if\>\|\%(}\s*\)\?\<else\>\)'
+    return 0
+  endif
+  let result = search('^\%(\s*\<if\>\s*(.*).*\n\|\s*\<if\>\s*(.*)\s*\n.*\n\)\%(\s*\<else\>\s*\<if\>\s*(.*)\s*\n.*\n\)*\%(\s*\<else\>\s*\n\|\s*\<else\>[^{]*\n\)\?\%' . a:lnum . 'l', 'Wbn')
+  if result != 0 && scala#GetLine(prevnonblank(a:lnum - 1)) !~ '{\s*$'
+    return result
+  endif
+  return 0
+endfunction
+
+function! scala#GetPrevCodeLine(lnum)
+  " This needs to skip comment lines
+  return prevnonblank(a:lnum - 1)
+endfunction
+
+function! scala#InvertBracketType(openBracket, closedBracket)
+  if a:openBracket == '('
+    return [ '{', '}' ]
+  else
+    return [ '(', ')' ]
+  endif
+endfunction
+
+function! scala#Testhelper(lnum, line, openBracket, closedBracket, iteration)
+  let bracketCount = scala#CountBrackets(a:line, a:openBracket, a:closedBracket)
+  " There are more '}' braces than '{' on this line so it may be completing the function definition
+  if bracketCount < 0
+    let [matchedLNum, matchedColNum] = scala#GetLineAndColumnThatMatchesBracket(a:openBracket, a:closedBracket)
+    if matchedLNum == a:lnum
+      return -1
+    endif
+    let matchedLine = scala#GetLine(matchedLNum)
+    if ! scala#MatchesIncompleteDefValr(matchedLine)
+      let bracketLine = substitute(substitute(matchedLine, '\%' . matchedColNum . 'c.*$', '', ''), '[^{}()]', '', 'g')
+      if bracketLine =~ '}$'
+        return scala#Testhelper(matchedLNum, matchedLine, '{', '}', a:iteration + 1)
+      elseif bracketLine =~ ')$'
+        return scala#Testhelper(matchedLNum, matchedLine, '(', ')', a:iteration + 1)
+      else
+        let prevCodeLNum = scala#GetPrevCodeLine(matchedLNum)
+        if scala#MatchesIncompleteDefValr(scala#GetLine(prevCodeLNum))
+          return prevCodeLNum
+        else
+          return -1
+        endif
+      endif
+    else
+      " return indent value instead
+      return matchedLNum
+    endif
+  " There's an equal number of '{' and '}' on this line so it may be a single line function definition
+  elseif bracketCount == 0
+    if a:iteration == 0
+      let otherBracketType = scala#InvertBracketType(a:openBracket, a:closedBracket)
+      return scala#Testhelper(a:lnum, a:line, otherBracketType[0], otherBracketType[1], a:iteration + 1)
+    else
+      let prevCodeLNum = scala#GetPrevCodeLine(a:lnum)
+      let prevCodeLine = scala#GetLine(prevCodeLNum)
+      if scala#MatchesIncompleteDefValr(prevCodeLine) && prevCodeLine !~ '{\s*$'
+        return prevCodeLNum
+      else
+        let possibleIfElse = scala#LineCompletesIfElse(a:lnum, a:line)
+        if possibleIfElse != 0
+          let defValrLine = prevnonblank(possibleIfElse - 1)
+          let possibleDefValr = scala#GetLine(defValrLine)
+          if scala#MatchesIncompleteDefValr(possibleDefValr) && possibleDefValr =~ '^.*=\s*$'
+            return possibleDefValr
+          else
+            return -1
+          endif
+        else
+          return -1
+        endif
+      endif
+    endif
+  else
+    return -1
+  endif
+endfunction
+
+function! scala#Test(lnum, line, openBracket, closedBracket)
+  return scala#Testhelper(a:lnum, a:line, a:openBracket, a:closedBracket, 0)
+endfunction
+
+function! scala#LineCompletesDefValr(lnum, line)
+  let bracketCount = scala#CountBrackets(a:line, '{', '}')
+  if bracketCount < 0
+    let matchedBracket = scala#GetLineThatMatchesBracket('{', '}')
+    if ! scala#MatchesIncompleteDefValr(scala#GetLine(matchedBracket))
+      let possibleDefValr = scala#GetLine(prevnonblank(matchedBracket - 1))
+      if matchedBracket != -1 && scala#MatchesIncompleteDefValr(possibleDefValr)
+        return 1
+      else
+        return 0
+      endif
+    else
+      return 0
+    endif
+  elseif bracketCount == 0
+    let bracketCount = scala#CountBrackets(a:line, '(', ')')
+    if bracketCount < 0
+      let matchedBracket = scala#GetLineThatMatchesBracket('(', ')')
+      if ! scala#MatchesIncompleteDefValr(scala#GetLine(matchedBracket))
+        let possibleDefValr = scala#GetLine(prevnonblank(matchedBracket - 1))
+        if matchedBracket != -1 && scala#MatchesIncompleteDefValr(possibleDefValr)
+          return 1
+        else
+          return 0
+        endif
+      else
+        return 0
+      endif
+    elseif bracketCount == 0
+      let possibleDefValr = scala#GetLine(prevnonblank(a:lnum - 1))
+      if scala#MatchesIncompleteDefValr(possibleDefValr) && possibleDefValr =~ '^.*=\s*$'
+        return 1
+      else
+        let possibleIfElse = scala#LineCompletesIfElse(a:lnum, a:line)
+        if possibleIfElse != 0
+          let possibleDefValr = scala#GetLine(prevnonblank(possibleIfElse - 1))
+          if scala#MatchesIncompleteDefValr(possibleDefValr) && possibleDefValr =~ '^.*=\s*$'
+            return 2
+          else
+            return 0
+          endif
+        else
+          return 0
+        endif
+      endif
+    else
+      return 0
+    endif
+  endif
+endfunction
+
+function! scala#SpecificLineCompletesBrackets(lnum, openBracket, closedBracket)
+  let savedpos = getpos('.')
+  call setpos('.', [savedpos[0], a:lnum, 9999, savedpos[3]])
+  let retv = scala#LineCompletesBrackets(a:openBracket, a:closedBracket)
+  call setpos('.', savedpos)
+
+  return retv
+endfunction
+
+function! scala#LineCompletesBrackets(openBracket, closedBracket)
+  let savedpos = getpos('.')
+  let offline = 0
+  while offline == 0
+    let [lnum, colnum] = searchpos(a:closedBracket, 'Wb')
+    let [lnumA, colnumA] = searchpairpos(a:openBracket, '', a:closedBracket, 'Wbn')
+    if lnum != lnumA
+      let [lnumB, colnumB] = searchpairpos(a:openBracket, '', a:closedBracket, 'Wbnr')
+      let offline = 1
+    endif
+  endwhile
+  call setpos('.', savedpos)
+  if lnumA == lnumB && colnumA == colnumB
+    return lnumA
+  else
+    return -1
+  endif
+endfunction
+
+function! GetScalaIndent()
+  " Find a non-blank line above the current line.
+  let prevlnum = prevnonblank(v:lnum - 1)
+
+  " Hit the start of the file, use zero indent.
+  if prevlnum == 0
+    return 0
+  endif
+
+  let ind = indent(prevlnum)
+  let originalIndentValue = ind
+  let prevline = scala#GetLine(prevlnum)
+  let curlnum = v:lnum
+  let curline = scala#GetLine(curlnum)
+  if get(g:, 'scala_scaladoc_indent', 0)
+    let star_indent = 2
+  else
+    let star_indent = 1
+  end
+
+  if prevline =~ '^\s*/\*\*'
+    if prevline =~ '\*/\s*$'
+      return ind
+    else
+      return ind + star_indent
+    endif
+  endif
+
+  if curline =~ '^\s*\*'
+    return cindent(curlnum)
+  endif
+
+  " If this line starts with a { then make it indent the same as the previous line
+  if curline =~ '^\s*{'
+    call scala#ConditionalConfirm("1")
+    " Unless, of course, the previous one is a { as well
+    if prevline !~ '^\s*{'
+      call scala#ConditionalConfirm("2")
+      return indent(prevlnum)
+    endif
+  endif
+
+  " '.' continuations
+  if curline =~ '^\s*\.'
+    if prevline =~ '^\s*\.'
+      return ind
+    else
+      return ind + shiftwidth()
+    endif
+  endif
+
+  " Indent html literals
+  if prevline !~ '/>\s*$' && prevline =~ '^\s*<[a-zA-Z][^>]*>\s*$'
+    call scala#ConditionalConfirm("3")
+    return ind + shiftwidth()
+  endif
+
+  " assumes curly braces around try-block
+  if curline =~ '^\s*}\s*\<catch\>'
+    return ind - shiftwidth()
+  elseif curline =~ '^\s*\<catch\>'
+    return ind
+  endif
+
+  " Add a shiftwidth()' after lines that start a block
+  " If 'if', 'for' or 'while' end with ), this is a one-line block
+  " If 'val', 'var', 'def' end with =, this is a one-line block
+  if (prevline =~ '^\s*\<\%(\%(}\?\s*else\s\+\)\?if\|for\|while\)\>.*[)=]\s*$' && scala#NumberOfBraceGroups(prevline) <= 1)
+        \ || prevline =~ '^\s*' . s:defMatcher . '.*=\s*$'
+        \ || prevline =~ '^\s*\<va[lr]\>.*[=]\s*$'
+        \ || prevline =~ '^\s*\%(}\s*\)\?\<else\>\s*$'
+        \ || prevline =~ '=\s*$'
+    call scala#ConditionalConfirm("4")
+    let ind = ind + shiftwidth()
+  elseif prevline =~ '^\s*\<\%(}\?\s*else\s\+\)\?if\>' && curline =~ '^\s*}\?\s*\<else\>'
+    return ind
+  endif
+
+  let lineCompletedBrackets = 0
+  let bracketCount = scala#CountBrackets(prevline, '{', '}')
+  if bracketCount > 0 || prevline =~ '.*{\s*$'
+    call scala#ConditionalConfirm("5b")
+    let ind = ind + shiftwidth()
+  elseif bracketCount < 0
+    call scala#ConditionalConfirm("6b")
+    " if the closing brace actually completes the braces entirely, then we
+    " have to indent to line that started the whole thing
+    let completeLine = scala#LineCompletesBrackets('{', '}')
+    if completeLine != -1
+      call scala#ConditionalConfirm("8b")
+      let prevCompleteLine = scala#GetLine(prevnonblank(completeLine - 1))
+      " However, what actually started this part looks like it was a function
+      " definition, so we need to indent to that line instead.  This is
+      " actually pretty weak at the moment.
+      if prevCompleteLine =~ '=\s*$'
+        call scala#ConditionalConfirm("9b")
+        let ind = indent(prevnonblank(completeLine - 1))
+      else
+        call scala#ConditionalConfirm("10b")
+        let ind = indent(completeLine)
+      endif
+    else
+      let lineCompletedBrackets = 1
+    endif
+  endif
+
+  if ind == originalIndentValue
+    let bracketCount = scala#CountBrackets(prevline, '(', ')')
+    if bracketCount > 0 || prevline =~ '.*(\s*$'
+      call scala#ConditionalConfirm("5a")
+      let ind = ind + shiftwidth()
+    elseif bracketCount < 0
+      call scala#ConditionalConfirm("6a")
+      " if the closing brace actually completes the braces entirely, then we
+      " have to indent to line that started the whole thing
+      let completeLine = scala#LineCompletesBrackets('(', ')')
+      if completeLine != -1 && prevline !~ '^.*{\s*$'
+        call scala#ConditionalConfirm("8a")
+        let prevCompleteLine = scala#GetLine(prevnonblank(completeLine - 1))
+        " However, what actually started this part looks like it was a function
+        " definition, so we need to indent to that line instead.  This is
+        " actually pretty weak at the moment.
+        if prevCompleteLine =~ '=\s*$'
+          call scala#ConditionalConfirm("9a")
+          let ind = indent(prevnonblank(completeLine - 1))
+        else
+          call scala#ConditionalConfirm("10a")
+          let ind = indent(completeLine)
+        endif
+      else
+        " This is the only part that's different from from the '{', '}' one below
+        " Yup... some refactoring is necessary at some point.
+        let ind = ind + (bracketCount * shiftwidth())
+        let lineCompletedBrackets = 1
+      endif
+    endif
+  endif
+
+  if curline =~ '^\s*}\?\s*\<else\>\%(\s\+\<if\>\s*(.*)\)\?\s*{\?\s*$' &&
+   \ ! scala#LineIsCompleteIf(prevline) &&
+   \ prevline !~ '^.*}\s*$'
+    let ind = ind - shiftwidth()
+  endif
+
+  " Subtract a shiftwidth()' on '}' or html
+  let curCurlyCount = scala#CountCurlies(curline)
+  if curCurlyCount < 0
+    call scala#ConditionalConfirm("14a")
+    let matchline = scala#CurlyMatcher()
+    return indent(matchline)
+  elseif curline =~ '^\s*</[a-zA-Z][^>]*>'
+    call scala#ConditionalConfirm("14c")
+    return ind - shiftwidth()
+  endif
+
+  let prevParenCount = scala#CountParens(prevline)
+  if prevline =~ '^\s*\<for\>.*$' && prevParenCount > 0
+    call scala#ConditionalConfirm("15")
+    let ind = indent(prevlnum) + 5
+  endif
+
+  let prevCurlyCount = scala#CountCurlies(prevline)
+  if prevCurlyCount == 0 && prevline =~ '^.*\%(=>\|⇒\)\s*$' && prevline !~ '^\s*this\s*:.*\%(=>\|⇒\)\s*$' && curline !~ '^\s*\<case\>'
+    call scala#ConditionalConfirm("16")
+    let ind = ind + shiftwidth()
+  endif
+
+  if ind == originalIndentValue && curline =~ '^\s*\<case\>'
+    call scala#ConditionalConfirm("17")
+    let parentCase = scala#IsParentCase()
+    if parentCase != -1
+      call scala#ConditionalConfirm("17a")
+      return indent(parentCase)
+    endif
+  endif
+
+  if prevline =~ '^\s*\*/'
+   \ || prevline =~ '*/\s*$'
+    call scala#ConditionalConfirm("18")
+    let ind = ind - star_indent
+  endif
+
+  if scala#LineEndsInIncomplete(prevline)
+    call scala#ConditionalConfirm("19")
+    return ind
+  endif
+
+  if scala#LineIsAClosingXML(prevline)
+    if scala#LineCompletesXML(prevlnum, prevline)
+      call scala#ConditionalConfirm("20a")
+      return ind - shiftwidth()
+    else
+      call scala#ConditionalConfirm("20b")
+      return ind
+    endif
+  endif
+
+  if ind == originalIndentValue
+    "let indentMultiplier = scala#LineCompletesDefValr(prevlnum, prevline)
+    "if indentMultiplier != 0
+    "  call scala#ConditionalConfirm("19a")
+    "  let ind = ind - (indentMultiplier * shiftwidth())
+    let defValrLine = scala#Test(prevlnum, prevline, '{', '}')
+    if defValrLine != -1
+      call scala#ConditionalConfirm("21a")
+      let ind = indent(defValrLine)
+    elseif lineCompletedBrackets == 0
+      call scala#ConditionalConfirm("21b")
+      if scala#GetLine(prevnonblank(prevlnum - 1)) =~ '^.*\<else\>\s*\%(//.*\)\?$'
+        call scala#ConditionalConfirm("21c")
+        let ind = ind - shiftwidth()
+      elseif scala#LineCompletesIfElse(prevlnum, prevline)
+        call scala#ConditionalConfirm("21d")
+        let ind = ind - shiftwidth()
+      elseif scala#CountParens(curline) < 0 && curline =~ '^\s*)' && scala#GetLine(scala#GetLineThatMatchesBracket('(', ')')) =~ '.*(\s*$'
+        " Handles situations that look like this:
+        "
+        "   val a = func(
+        "     10
+        "   )
+        "
+        " or
+        "
+        "   val a = func(
+        "     10
+        "   ).somethingHere()
+        call scala#ConditionalConfirm("21e")
+        let ind = ind - shiftwidth()
+      endif
+    endif
+  endif
+
+  call scala#ConditionalConfirm("returning " . ind)
+
+  return ind
+endfunction
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+" vim:set sw=2 sts=2 ts=8 et:
+" vim600:fdm=marker fdl=1 fdc=0:

Git/usr/share/vim/vim81/indent/scheme.vim

@@ -0,0 +1,14 @@
+" Vim indent file
+" Language: Scheme
+" Last Change: 2018 Jan 31
+" Maintainer: Evan Hanson <evhan@foldling.org>
+" Previous Maintainer: Sergey Khorev <sergey.khorev@gmail.com>
+" URL: https://foldling.org/vim/indent/scheme.vim
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+
+" Use the Lisp indenting
+runtime! indent/lisp.vim

Git/usr/share/vim/vim81/indent/scss.vim

@@ -0,0 +1,12 @@
+" Vim indent file
+" Language:	SCSS
+" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
+" Last Change:	2010 Jul 26
+
+if exists("b:did_indent")
+  finish
+endif
+
+runtime! indent/css.vim
+
+" vim:set sw=2:

Git/usr/share/vim/vim81/indent/sdl.vim

@@ -0,0 +1,93 @@
+" Vim indent file
+" Language:	SDL
+" Maintainer:	Michael Piefel <entwurf@piefel.de>
+" Last Change:	10 December 2011
+
+" Shamelessly stolen from the Vim-Script indent file
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetSDLIndent()
+setlocal indentkeys+==~end,=~state,*<Return>
+
+" Only define the function once.
+if exists("*GetSDLIndent")
+"  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+function! GetSDLIndent()
+  " Find a non-blank line above the current line.
+  let lnum = prevnonblank(v:lnum - 1)
+
+  " At the start of the file use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  let ind = indent(lnum)
+  let virtuality = '^\s*\(\(virtual\|redefined\|finalized\)\s\+\)\=\s*'
+
+  " Add a single space to comments which use asterisks
+  if getline(lnum) =~ '^\s*\*'
+    let ind = ind - 1
+  endif
+  if getline(v:lnum) =~ '^\s*\*'
+    let ind = ind + 1
+  endif
+
+  " Add a 'shiftwidth' after states, different blocks, decision (and alternatives), inputs
+  if (getline(lnum) =~? '^\s*\(start\|state\|system\|package\|connection\|channel\|alternative\|macro\|operator\|newtype\|select\|substructure\|decision\|generator\|refinement\|service\|method\|exceptionhandler\|asntype\|syntype\|value\|(.*):\|\(priority\s\+\)\=input\|provided\)'
+    \ || getline(lnum) =~? virtuality . '\(process\|procedure\|block\|object\)')
+    \ && getline(lnum) !~? 'end[[:alpha:]]\+;$'
+    let ind = ind + shiftwidth()
+  endif
+
+  " Subtract a 'shiftwidth' after states
+  if getline(lnum) =~? '^\s*\(stop\|return\>\|nextstate\)'
+    let ind = ind - shiftwidth()
+  endif
+
+  " Subtract a 'shiftwidth' on on end (uncompleted line)
+  if getline(v:lnum) =~? '^\s*end\>'
+    let ind = ind - shiftwidth()
+  endif
+
+  " Put each alternatives where the corresponding decision was
+  if getline(v:lnum) =~? '^\s*\((.*)\|else\):'
+    normal k
+    let ind = indent(searchpair('^\s*decision', '', '^\s*enddecision', 'bW',
+      \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "sdlString"'))
+  endif
+
+  " Put each state where the preceding state was
+  if getline(v:lnum) =~? '^\s*state\>'
+    let ind = indent(search('^\s*start', 'bW'))
+  endif
+
+  " Systems and packages are always in column 0
+  if getline(v:lnum) =~? '^\s*\(\(end\)\=system\|\(end\)\=package\)'
+    return 0
+  endif
+
+  " Put each end* where the corresponding begin was
+  if getline(v:lnum) =~? '^\s*end[[:alpha:]]'
+    normal k
+    let partner=matchstr(getline(v:lnum), '\(' . virtuality . 'end\)\@<=[[:alpha:]]\+')
+    let ind = indent(searchpair(virtuality . partner, '', '^\s*end' . partner, 'bW',
+      \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "sdlString"'))
+  endif
+
+  return ind
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim:sw=2

Git/usr/share/vim/vim81/indent/sh.vim

@@ -0,0 +1,276 @@
+" Vim indent file
+" Language:            Shell Script
+" Maintainer:          Christian Brabandt <cb@256bit.org>
+" Original Author:     Nikolai Weibull <now@bitwi.se>
+" Previous Maintainer: Peter Aronoff <telemachus@arpinum.org>
+" Latest Revision:     2019-02-02
+" License:             Vim (see :h license)
+" Repository:          https://github.com/chrisbra/vim-sh-indent
+" Changelog:
+"          20190201  - Better check for closing if sections
+"          20180724  - make check for zsh syntax more rigid (needs word-boundaries)
+"          20180326  - better support for line continuation
+"          20180325  - better detection of function definitions
+"          20180127  - better support for zsh complex commands
+"          20170808: - better indent of line continuation
+"          20170502: - get rid of buffer-shiftwidth function
+"          20160912: - preserve indentation of here-doc blocks
+"          20160627: - detect heredocs correctly
+"          20160213: - detect function definition correctly
+"          20160202: - use shiftwidth() function
+"          20151215: - set b:undo_indent variable
+"          20150728: - add foreach detection for zsh
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetShIndent()
+setlocal indentkeys+=0=then,0=do,0=else,0=elif,0=fi,0=esac,0=done,0=end,),0=;;,0=;&
+setlocal indentkeys+=0=fin,0=fil,0=fip,0=fir,0=fix
+setlocal indentkeys-=:,0#
+setlocal nosmartindent
+
+let b:undo_indent = 'setlocal indentexpr< indentkeys< smartindent<'
+
+if exists("*GetShIndent")
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+let s:sh_indent_defaults = {
+      \ 'default': function('shiftwidth'),
+      \ 'continuation-line': function('shiftwidth'),
+      \ 'case-labels': function('shiftwidth'),
+      \ 'case-statements': function('shiftwidth'),
+      \ 'case-breaks': 0 }
+
+function! s:indent_value(option)
+  let Value = exists('b:sh_indent_options')
+            \ && has_key(b:sh_indent_options, a:option) ?
+            \ b:sh_indent_options[a:option] :
+            \ s:sh_indent_defaults[a:option]
+  if type(Value) == type(function('type'))
+    return Value()
+  endif
+  return Value
+endfunction
+
+function! GetShIndent()
+  let curline = getline(v:lnum)
+  let lnum = prevnonblank(v:lnum - 1)
+  if lnum == 0
+    return 0
+  endif
+  let line = getline(lnum)
+
+  let pnum = prevnonblank(lnum - 1)
+  let pline = getline(pnum)
+  let ind = indent(lnum)
+
+  " Check contents of previous lines
+  if line =~ '^\s*\%(if\|then\|do\|else\|elif\|case\|while\|until\|for\|select\|foreach\)\>' ||
+        \  (&ft is# 'zsh' && line =~ '\<\%(if\|then\|do\|else\|elif\|case\|while\|until\|for\|select\|foreach\)\>')
+    if !s:is_end_expression(line)
+      let ind += s:indent_value('default')
+    endif
+  elseif s:is_case_label(line, pnum)
+    if !s:is_case_ended(line)
+      let ind += s:indent_value('case-statements')
+    endif
+  " function definition
+  elseif s:is_function_definition(line)
+    if line !~ '}\s*\%(#.*\)\=$'
+      let ind += s:indent_value('default')
+    endif
+  elseif s:is_continuation_line(line)
+    if pnum == 0 || !s:is_continuation_line(pline)
+      let ind += s:indent_value('continuation-line')
+    endif
+  elseif s:end_block(line) && !s:start_block(line)
+    let ind -= s:indent_value('default')
+  elseif pnum != 0 &&
+        \ s:is_continuation_line(pline) &&
+        \ !s:end_block(curline) &&
+        \ !s:is_end_expression(curline)
+    " only add indent, if line and pline is in the same block
+    let i = v:lnum
+    let ind2 = indent(s:find_continued_lnum(pnum))
+    while !s:is_empty(getline(i)) && i > pnum
+      let i -= 1
+    endw
+    if i == pnum
+      let ind += ind2
+    else
+      let ind = ind2
+    endif
+  endif
+
+  let pine = line
+  " Check content of current line
+  let line = curline
+  " Current line is a endif line, so get indent from start of "if condition" line
+  " TODO: should we do the same for other "end" lines?
+  if curline =~ '^\s*\%(fi\)\s*\%(#.*\)\=$'
+    let previous_line = search('if.\{-\};\s*then\s*\%(#.*\)\=$', 'bnW')
+    if previous_line > 0
+      let ind = indent(previous_line)
+    endif
+  elseif line =~ '^\s*\%(then\|do\|else\|elif\|done\|end\)\>' || s:end_block(line)
+    let ind -= s:indent_value('default')
+  elseif line =~ '^\s*esac\>' && s:is_case_empty(getline(v:lnum - 1))
+    let ind -= s:indent_value('default')
+  elseif line =~ '^\s*esac\>'
+    let ind -= (s:is_case_label(pine, lnum) && s:is_case_ended(pine) ?
+             \ 0 : s:indent_value('case-statements')) +
+             \ s:indent_value('case-labels')
+    if s:is_case_break(pine)
+      let ind += s:indent_value('case-breaks')
+    endif
+  elseif s:is_case_label(line, lnum)
+    if s:is_case(pine)
+      let ind = indent(lnum) + s:indent_value('case-labels')
+    else
+      let ind -= (s:is_case_label(pine, lnum) && s:is_case_ended(pine) ?
+                  \ 0 : s:indent_value('case-statements')) -
+                  \ s:indent_value('case-breaks')
+    endif
+  elseif s:is_case_break(line)
+    let ind -= s:indent_value('case-breaks')
+  elseif s:is_here_doc(line)
+    let ind = 0
+  " statements, executed within a here document. Keep the current indent
+  elseif match(map(synstack(v:lnum, 1), 'synIDattr(v:val, "name")'), '\c\mheredoc') > -1
+    return indent(v:lnum)
+  elseif s:is_comment(line) && s:is_empty(getline(v:lnum-1))
+    return indent(v:lnum)
+  endif
+
+  return ind > 0 ? ind : 0
+endfunction
+
+function! s:is_continuation_line(line)
+  " Comment, cannot be a line continuation
+  if a:line =~ '^\s*#'
+    return 0
+  else
+    " start-of-line
+    " \\ or && or || or |
+    " followed optionally by { or #
+    return a:line =~ '\%(\%(^\|[^\\]\)\\\|&&\|||\||\)' .
+                 \ '\s*\({\s*\)\=\(#.*\)\=$'
+  endif
+endfunction
+
+function! s:find_continued_lnum(lnum)
+  let i = a:lnum
+  while i > 1 && s:is_continuation_line(getline(i - 1))
+    let i -= 1
+  endwhile
+  return i
+endfunction
+
+function! s:is_function_definition(line)
+  return a:line =~ '^\s*\<\k\+\>\s*()\s*{' ||
+       \ a:line =~ '^\s*{' ||
+       \ a:line =~ '^\s*function\s*\w\S\+\s*\%(()\)\?\s*{'
+endfunction
+
+function! s:is_case_label(line, pnum)
+  if a:line !~ '^\s*(\=.*)'
+    return 0
+  endif
+
+  if a:pnum > 0
+    let pine = getline(a:pnum)
+    if !(s:is_case(pine) || s:is_case_ended(pine))
+      return 0
+    endif
+  endif
+
+  let suffix = substitute(a:line, '^\s*(\=', "", "")
+  let nesting = 0
+  let i = 0
+  let n = strlen(suffix)
+  while i < n
+    let c = suffix[i]
+    let i += 1
+    if c == '\\'
+      let i += 1
+    elseif c == '('
+      let nesting += 1
+    elseif c == ')'
+      if nesting == 0
+        return 1
+      endif
+      let nesting -= 1
+    endif
+  endwhile
+  return 0
+endfunction
+
+function! s:is_case(line)
+  return a:line =~ '^\s*case\>'
+endfunction
+
+function! s:is_case_break(line)
+  return a:line =~ '^\s*;[;&]'
+endfunction
+
+function! s:is_here_doc(line)
+    if a:line =~ '^\w\+$'
+      let here_pat = '<<-\?'. s:escape(a:line). '\$'
+      return search(here_pat, 'bnW') > 0
+    endif
+    return 0
+endfunction
+
+function! s:is_case_ended(line)
+  return s:is_case_break(a:line) || a:line =~ ';[;&]\s*\%(#.*\)\=$'
+endfunction
+
+function! s:is_case_empty(line)
+  if a:line =~ '^\s*$' || a:line =~ '^\s*#'
+    return s:is_case_empty(getline(v:lnum - 1))
+  else
+    return a:line =~ '^\s*case\>'
+  endif
+endfunction
+
+function! s:escape(pattern)
+    return '\V'. escape(a:pattern, '\\')
+endfunction
+
+function! s:is_empty(line)
+  return a:line =~ '^\s*$'
+endfunction
+
+function! s:end_block(line)
+  return a:line =~ '^\s*}'
+endfunction
+
+function! s:start_block(line)
+  return a:line =~ '{\s*\(#.*\)\?$'
+endfunction
+
+function! s:find_start_block(lnum)
+  let i = a:lnum
+  while i > 1 && !s:start_block(getline(i))
+    let i -= 1
+  endwhile
+  return i
+endfunction
+
+function! s:is_comment(line)
+  return a:line =~ '^\s*#'
+endfunction
+
+function! s:is_end_expression(line)
+  return a:line =~ '\<\%(fi\|esac\|done\|end\)\>\s*\%(#.*\)\=$'
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

Git/usr/share/vim/vim81/indent/sml.vim

@@ -0,0 +1,217 @@
+" Vim indent file
+" Language:     SML
+" Maintainer:	Saikat Guha <sg266@cornell.edu>
+" 				Hubert Chao <hc85@cornell.edu>
+" Original OCaml Version:
+" 				Jean-Francois Yuen  <jfyuen@ifrance.com>
+"               Mike Leary          <leary@nwlink.com>
+"               Markus Mottl        <markus@oefai.at>
+" OCaml URL:    http://www.oefai.at/~markus/vim/indent/ocaml.vim
+" Last Change:  2003 Jan 04	- Adapted to SML
+" 				2002 Nov 06 - Some fixes (JY)
+"               2002 Oct 28 - Fixed bug with indentation of ']' (MM)
+"               2002 Oct 22 - Major rewrite (JY)
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal expandtab
+setlocal indentexpr=GetSMLIndent()
+setlocal indentkeys+=0=and,0=else,0=end,0=handle,0=if,0=in,0=let,0=then,0=val,0=fun,0=\|,0=*),0)
+setlocal nolisp
+setlocal nosmartindent
+setlocal textwidth=80
+setlocal shiftwidth=2
+
+" Comment formatting
+if (has("comments"))
+  set comments=sr:(*,mb:*,ex:*)
+  set fo=cqort
+endif
+
+" Only define the function once.
+"if exists("*GetSMLIndent")
+"finish
+"endif
+
+" Define some patterns:
+let s:beflet = '^\s*\(initializer\|method\|try\)\|\(\<\(begin\|do\|else\|in\|then\|try\)\|->\|;\)\s*$'
+let s:letpat = '^\s*\(let\|type\|module\|class\|open\|exception\|val\|include\|external\)\>'
+let s:letlim = '\(\<\(sig\|struct\)\|;;\)\s*$'
+let s:lim = '^\s*\(exception\|external\|include\|let\|module\|open\|type\|val\)\>'
+let s:module = '\<\%(let\|sig\|struct\)\>'
+let s:obj = '^\s*\(constraint\|inherit\|initializer\|method\|val\)\>\|\<\(object\|object\s*(.*)\)\s*$'
+let s:type = '^\s*\%(let\|type\)\>.*='
+let s:val = '^\s*\(val\|external\)\>.*:'
+
+" Skipping pattern, for comments
+function! s:SkipPattern(lnum, pat)
+  let def = prevnonblank(a:lnum - 1)
+  while def > 0 && getline(def) =~ a:pat
+    let def = prevnonblank(def - 1)
+  endwhile
+  return def
+endfunction
+
+" Indent for ';;' to match multiple 'let'
+function! s:GetInd(lnum, pat, lim)
+  let llet = search(a:pat, 'bW')
+  let old = indent(a:lnum)
+  while llet > 0
+    let old = indent(llet)
+    let nb = s:SkipPattern(llet, '^\s*(\*.*\*)\s*$')
+    if getline(nb) =~ a:lim
+      return old
+    endif
+    let llet = search(a:pat, 'bW')
+  endwhile
+  return old
+endfunction
+
+" Indent pairs
+function! s:FindPair(pstart, pmid, pend)
+  call search(a:pend, 'bW')
+"  return indent(searchpair(a:pstart, a:pmid, a:pend, 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"'))
+  let lno = searchpair(a:pstart, a:pmid, a:pend, 'bW', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"')
+  if lno == -1
+	return indent(lno)
+  else
+	return col(".") - 1
+  endif
+endfunction
+
+function! s:FindLet(pstart, pmid, pend)
+  call search(a:pend, 'bW')
+"  return indent(searchpair(a:pstart, a:pmid, a:pend, 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"'))
+  let lno = searchpair(a:pstart, a:pmid, a:pend, 'bW', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"')
+  let moduleLine = getline(lno)
+  if lno == -1 || moduleLine =~ '^\s*\(fun\|structure\|signature\)\>'
+	return indent(lno)
+  else
+	return col(".") - 1
+  endif
+endfunction
+
+" Indent 'let'
+"function! s:FindLet(pstart, pmid, pend)
+"  call search(a:pend, 'bW')
+"  return indent(searchpair(a:pstart, a:pmid, a:pend, 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment" || getline(".") =~ "^\\s*let\\>.*=.*\\<in\\s*$" || getline(prevnonblank(".") - 1) =~ "^\\s*let\\>.*=\\s*$\\|" . s:beflet'))
+"endfunction
+
+function! GetSMLIndent()
+  " Find a non-blank line above the current line.
+  let lnum = prevnonblank(v:lnum - 1)
+
+  " At the start of the file use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  let ind = indent(lnum)
+  let lline = getline(lnum)
+
+	" Return double 'shiftwidth' after lines matching:
+	if lline =~ '^\s*|.*=>\s*$'
+		return ind + 2 *shiftwidth()
+	elseif lline =~ '^\s*val\>.*=\s*$'
+		return ind + shiftwidth()
+	endif
+
+  let line = getline(v:lnum)
+
+	" Indent lines starting with 'end' to matching module
+	if line =~ '^\s*end\>'
+		return s:FindLet(s:module, '', '\<end\>')
+
+	" Match 'else' with 'if'
+	elseif line =~ '^\s*else\>'
+	  	if lline !~ '^\s*\(if\|else\|then\)\>'
+				return s:FindPair('\<if\>', '', '\<then\>')
+	  	else
+		  return ind
+		endif
+
+	" Match 'then' with 'if'
+	elseif line =~ '^\s*then\>'
+  	if lline !~ '^\s*\(if\|else\|then\)\>'
+		  return s:FindPair('\<if\>', '', '\<then\>')
+	else
+	  return ind
+	endif
+
+	" Indent if current line begins with ']'
+	elseif line =~ '^\s*\]'
+		return s:FindPair('\[','','\]')
+
+  " Indent current line starting with 'in' to last matching 'let'
+	elseif line =~ '^\s*in\>'
+		let ind = s:FindLet('\<let\>','','\<in\>')
+
+	" Indent from last matching module if line matches:
+	elseif line =~ '^\s*\(fun\|val\|open\|structure\|and\|datatype\|type\|exception\)\>'
+		cursor(lnum,1)
+  		let lastModule = indent(searchpair(s:module, '', '\<end\>', 'bWn', 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string\\|comment"'))
+		if lastModule == -1
+			return 0
+		else
+			return lastModule + shiftwidth()
+		endif
+
+	" Indent lines starting with '|' from matching 'case', 'handle'
+	elseif line =~ '^\s*|'
+		" cursor(lnum,1)
+		let lastSwitch = search('\<\(case\|handle\|fun\|datatype\)\>','bW')
+		let switchLine = getline(lastSwitch)
+		let switchLineIndent = indent(lastSwitch)
+		if lline =~ '^\s*|'
+		  return ind
+		endif
+		if switchLine =~ '\<case\>'
+			return col(".") + 2
+		elseif switchLine =~ '\<handle\>'
+			return switchLineIndent + shiftwidth()
+		elseif switchLine =~ '\<datatype\>'
+			call search('=')
+			return col(".") - 1
+		else
+			return switchLineIndent + 2
+		endif
+
+
+  " Indent if last line ends with 'sig', 'struct', 'let', 'then', 'else',
+  " 'in'
+  elseif lline =~ '\<\(sig\|struct\|let\|in\|then\|else\)\s*$'
+		let ind = ind + shiftwidth()
+
+  " Indent if last line ends with 'of', align from 'case'
+  elseif lline =~ '\<\(of\)\s*$'
+		call search('\<case\>',"bW")
+		let ind = col(".")+4
+
+	" Indent if current line starts with 'of'
+  elseif line =~ '^\s*of\>'
+		call search('\<case\>',"bW")
+		let ind = col(".")+1
+
+
+	" Indent if last line starts with 'fun', 'case', 'fn'
+	elseif lline =~ '^\s*\(fun\|fn\|case\)\>'
+		let ind = ind + shiftwidth()
+
+	endif
+
+	" Don't indent 'let' if last line started with 'fun', 'fn'
+	if line =~ '^\s*let\>'
+		if lline =~ '^\s*\(fun\|fn\)'
+			let ind = ind - shiftwidth()
+		endif
+  endif
+
+  return ind
+
+endfunction
+
+" vim:sw=2

Git/usr/share/vim/vim81/indent/sql.vim

@@ -0,0 +1,39 @@
+" Vim indent file loader
+" Language:    SQL
+" Maintainer:  David Fishburn <fishburn at ianywhere dot com>
+" Last Change: Thu Sep 15 2005 10:27:51 AM
+" Version:     1.0
+" Download:    http://vim.sourceforge.net/script.php?script_id=495
+
+" Description: Checks for a:
+"                  buffer local variable,
+"                  global variable,
+"              If the above exist, it will source the type specified.
+"              If none exist, it will source the default sqlanywhere.vim file.
+
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+    finish
+endif
+
+" Default to the standard Vim distribution file
+let filename = 'sqlanywhere'
+
+" Check for overrides.  Buffer variables have the highest priority.
+if exists("b:sql_type_override")
+    " Check the runtimepath to see if the file exists
+    if globpath(&runtimepath, 'indent/'.b:sql_type_override.'.vim') != ''
+        let filename = b:sql_type_override
+    endif
+elseif exists("g:sql_type_default")
+    if globpath(&runtimepath, 'indent/'.g:sql_type_default.'.vim') != ''
+        let filename = g:sql_type_default
+    endif
+endif
+
+" Source the appropriate file
+exec 'runtime indent/'.filename.'.vim'
+
+
+" vim:sw=4: