20 files changed, 1600 insertions, 390 deletions
diff --git a/runtime/indent/cdl.vim b/runtime/indent/cdl.vim
index db2b9052b2..5ec2a7b21a 100644
--- a/runtime/indent/cdl.vim
+++ b/runtime/indent/cdl.vim
@@ -16,7 +16,7 @@ if exists("*CdlGetIndent")
     "finish
 endif
 
-" find out if an "...=..." expresion its an asignment (or a conditional)
+" 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
diff --git a/runtime/indent/context.vim b/runtime/indent/context.vim
new file mode 100644
index 0000000000..652479f7e2
--- /dev/null
+++ b/runtime/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
diff --git a/runtime/indent/cucumber.vim b/runtime/indent/cucumber.vim
index 965c7786ed..999b8d6a76 100644
--- a/runtime/indent/cucumber.vim
+++ b/runtime/indent/cucumber.vim
@@ -1,7 +1,7 @@
 " Vim indent file
 " Language:	Cucumber
 " Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2013 May 30
+" Last Change:	2016 Aug 29
 
 if exists("b:did_indent")
   finish
@@ -27,6 +27,7 @@ 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() : &sw
   let syn = s:syn(prevnonblank(v:lnum-1))
   let csyn = s:syn(v:lnum)
   let nsyn = s:syn(nextnonblank(v:lnum+1))
@@ -35,38 +36,38 @@ function! GetCucumberIndent()
     return 0
   elseif csyn ==# 'cucumberExamples' || cline =~# '^\s*\%(Examples\|Scenarios\):'
     " examples heading
-    return 2 * &sw
+    return 2 * sw
   elseif csyn =~# '^cucumber\%(Background\|Scenario\|ScenarioOutline\)$' || cline =~# '^\s*\%(Background\|Scenario\|Scenario Outline\):'
     " background, scenario or outline heading
-    return &sw
+    return sw
   elseif syn ==# 'cucumberFeature' || line =~# '^\s*Feature:'
     " line after feature heading
-    return &sw
+    return sw
   elseif syn ==# 'cucumberExamples' || line =~# '^\s*\%(Examples\|Scenarios\):'
     " line after examples heading
-    return 3 * &sw
+    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
+    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
+    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
+    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
+    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
+    return sw
   endif
   return indent(prevnonblank(v:lnum-1))
 endfunction
diff --git a/runtime/indent/eruby.vim b/runtime/indent/eruby.vim
index 80cab7000e..afabd4fe5b 100644
--- a/runtime/indent/eruby.vim
+++ b/runtime/indent/eruby.vim
@@ -19,6 +19,9 @@ else
 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)'
@@ -38,7 +41,18 @@ 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'
@@ -52,31 +66,44 @@ function! GetErubyIndent(...)
     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
+    let ind = ind - sw
   endif
   if line =~# '\S\s*<%[-=]\=\s*\%(}\|end\).\{-\}\s*\%([-=]\=%>\|$\)'
-    let ind = ind - &sw
+    let ind = ind - sw
   endif
   if line =~# '\%({\|\<do\)\%(\s*|[^|]*|\)\=\s*[-=]\=%>'
-    let ind = ind + &sw
+    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
+    let ind = ind + sw
   endif
   if line =~# '^\s*<%[=#-]\=\s*$' && cline !~# '^\s*end\>'
-    let ind = ind + &sw
+    let ind = ind + sw
   endif
-  if line !~# '^\s*<%' && line =~# '%>\s*$'
-    let ind = ind - &sw
+  if line !~# '^\s*<%' && line =~# '%>\s*$' && line !~# '^\s*end\>'
+    let ind = ind - sw
   endif
   if cline =~# '^\s*[-=]\=%>\s*$'
-    let ind = ind - &sw
+    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:
diff --git a/runtime/indent/fortran.vim b/runtime/indent/fortran.vim
index e19a19fb1f..2ba69e86df 100644
--- a/runtime/indent/fortran.vim
+++ b/runtime/indent/fortran.vim
@@ -1,11 +1,12 @@
 " Vim indent file
 " Language:	Fortran 2008 (and older: Fortran 2003, 95, 90, and 77)
-" Version:	0.44
-" Last Change:	2016 Jan. 26
+" 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 by: Albert Oliver Serra and Takuya Fujiwara.
+"  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")
@@ -99,9 +100,9 @@ function FortranGetIndent(lnum)
     endif
   endif
 
-  "Add a shiftwidth to statements following if, else, else if, case,
+  "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\|else\|else\s*if\|else\s*where\)\>'
+  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\>'
@@ -121,7 +122,8 @@ function FortranGetIndent(lnum)
     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*\(module\|contains\|program\)\>'
+    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\>'
@@ -129,16 +131,16 @@ function FortranGetIndent(lnum)
     endif
     if getline(v:lnum) =~? '^\s*contains\>'
           \ ||getline(v:lnum)=~? '^\s*end\s*'
-          \ .'\(function\|subroutine\|module\|program\)\>'
+          \ .'\(function\|subroutine\|module\|submodule\|program\)\>'
       let ind = ind - shiftwidth()
     endif
   endif
 
-  "Subtract a shiftwidth from else, else if, elsewhere, case, end if,
+  "Subtract a shiftwidth from else, else if, elsewhere, case, class, end if,
   " end where, end select, end forall, end interface, end associate,
-  " end enum, and end type statements
+  " 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\|'
+        \. '\(else\|else\s*if\|else\s*where\|case\|class\|'
         \. 'end\s*\(if\|where\|select\|interface\|'
         \. 'type\|forall\|associate\|enum\|block\)\)\>'
     let ind = ind - shiftwidth()
@@ -152,9 +154,6 @@ function FortranGetIndent(lnum)
   if prevstat =~ '&\s*$' && prev2stat !~ '&\s*$'
     let ind = ind + shiftwidth()
   endif
-  if prevstat =~ '&\s*$' && prevstat =~ '\<else\s*if\>'
-    let ind = ind - shiftwidth()
-  endif
   "Line after last continuation line
   if prevstat !~ '&\s*$' && prev2stat =~ '&\s*$' && prevstat !~? '\<then\>'
     let ind = ind - shiftwidth()
diff --git a/runtime/indent/gitconfig.vim b/runtime/indent/gitconfig.vim
index 7d5d44b779..480c96d1b9 100644
--- a/runtime/indent/gitconfig.vim
+++ b/runtime/indent/gitconfig.vim
@@ -1,7 +1,7 @@
 " Vim indent file
 " Language:	git config file
 " Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2013 May 30
+" Last Change:	2016 Aug 29
 
 if exists("b:did_indent")
   finish
@@ -20,17 +20,18 @@ if exists("*GetGitconfigIndent")
 endif
 
 function! GetGitconfigIndent()
+  let sw    = exists('*shiftwidth') ? shiftwidth() : &sw
   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
+    return 2 * sw
   elseif cline =~ '^\s*\['
     return 0
   elseif cline =~ '^\s*\a'
-    return &sw
+    return sw
   elseif cline == ''       && line =~ '^\['
-    return &sw
+    return sw
   else
     return -1
   endif
diff --git a/runtime/indent/haml.vim b/runtime/indent/haml.vim
index c47a8a59c7..c3935af9e9 100644
--- a/runtime/indent/haml.vim
+++ b/runtime/indent/haml.vim
@@ -1,7 +1,7 @@
 " Vim indent file
 " Language:	Haml
 " Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2013 May 30
+" Last Change:	2016 Aug 29
 
 if exists("b:did_indent")
   finish
@@ -37,10 +37,11 @@ function! GetHamlIndent()
   let line = substitute(line,'^\s\+','','')
   let indent = indent(lnum)
   let cindent = indent(v:lnum)
+  let sw = exists('*shiftwidth') ? shiftwidth() : &sw
   if cline =~# '\v^-\s*%(elsif|else|when)>'
-    let indent = cindent < indent ? cindent : indent - &sw
+    let indent = cindent < indent ? cindent : indent - sw
   endif
-  let increase = indent + &sw
+  let increase = indent + sw
   if indent == indent(lnum)
     let indent = cindent <= indent ? -1 : increase
   endif
diff --git a/runtime/indent/html.vim b/runtime/indent/html.vim
index 828bc3120b..57ba53ecd4 100644
--- a/runtime/indent/html.vim
+++ b/runtime/indent/html.vim
@@ -2,7 +2,7 @@
 " Header: "{{{
 " Maintainer:	Bram Moolenaar
 " Original Author: Andy Wokula <anwoku@yahoo.de>
-" Last Change:	2016 Mar 30
+" Last Change:	2017 Jan 17
 " Version:	1.0
 " Description:	HTML indent script with cached state for faster indenting on a
 "		range of lines.
@@ -25,27 +25,22 @@
 if exists("b:did_indent") "{{{
   finish
 endif
+
+" Load the Javascript indent script first, it defines GetJavascriptIndent().
+" Undo the rest.
+" Load base python indent.
+if !exists('*GetJavascriptIndent')
+  runtime! indent/javascript.vim
+endif
 let b:did_indent = 1
 
 setlocal indentexpr=HtmlIndent()
 setlocal indentkeys=o,O,<Return>,<>>,{,},!^F
 
-" "j1" is included to make cindent() work better with Javascript.
-setlocal cino=j1
-" "J1" should be included, but it doen't work properly before 7.4.355.
-if has("patch-7.4.355")
-  setlocal cino+=J1
-endif
-" Before patch 7.4.355 indenting after "(function() {" does not work well, add
-" )2 to limit paren search.
-if !has("patch-7.4.355")
-  setlocal cino+=)2
-endif
-
 " Needed for % to work when finding start/end of a tag.
 setlocal matchpairs+=<:>
 
-let b:undo_indent = "setlocal inde< indk< cino<"
+let b:undo_indent = "setlocal inde< indk<"
 
 " b:hi_indent keeps state to speed up indenting consecutive lines.
 let b:hi_indent = {"lnum": -1}
@@ -596,7 +591,7 @@ func! s:Alien3()
     return eval(b:hi_js1indent)
   endif
   if b:hi_indent.scripttype == "javascript"
-    return cindent(v:lnum)
+    return GetJavascriptIndent()
   else
     return -1
   endif
@@ -749,7 +744,7 @@ func! s:CssPrevNonComment(lnum, stopline)
   while 1
     let ccol = match(getline(lnum), '\*/')
     if ccol < 0
-      " No comment end thus its something else.
+      " No comment end thus it's something else.
       return lnum
     endif
     call cursor(lnum, ccol + 1)
diff --git a/runtime/indent/javascript.vim b/runtime/indent/javascript.vim
index 3507e305ed..a6f1e1a8f8 100644
--- a/runtime/indent/javascript.vim
+++ b/runtime/indent/javascript.vim
@@ -1,8 +1,8 @@
 " Vim indent file
 " Language: Javascript
-" Maintainer: vim-javascript community
+" Maintainer: Chris Paul ( https://github.com/bounceme )
 " URL: https://github.com/pangloss/vim-javascript
-" Last Change: August 12, 2016
+" Last Change: December 31, 2016
 
 " Only load this indent file when no other was loaded.
 if exists('b:did_indent')
@@ -12,11 +12,10 @@ let b:did_indent = 1
 
 " Now, set up our indentation expression and keys that trigger it.
 setlocal indentexpr=GetJavascriptIndent()
-setlocal nolisp
-setlocal indentkeys=0{,0},0),0],:,!^F,o,O,e
-setlocal cinoptions+=j1,J1
+setlocal autoindent nolisp nosmartindent
+setlocal indentkeys+=0],0)
 
-let b:undo_indent = 'setlocal indentexpr< indentkeys< cinoptions<'
+let b:undo_indent = 'setlocal indentexpr< smartindent< autoindent< indentkeys<'
 
 " Only define the function once.
 if exists('*GetJavascriptIndent')
@@ -37,156 +36,329 @@ else
   endfunction
 endif
 
-let s:line_pre = '^\s*\%(\/\*.\{-}\*\/\s*\)*'
-let s:expr_case = s:line_pre . '\%(\%(case\>.\+\)\|default\)\s*:'
+" searchpair() wrapper
+if has('reltime')
+  function s:GetPair(start,end,flags,skip,time,...)
+    return searchpair('\m'.a:start,'','\m'.a:end,a:flags,a:skip,max([prevnonblank(v:lnum) - 2000,0] + a:000),a:time)
+  endfunction
+else
+  function s:GetPair(start,end,flags,skip,...)
+    return searchpair('\m'.a:start,'','\m'.a:end,a:flags,a:skip,max([prevnonblank(v:lnum) - 1000,get(a:000,1)]))
+  endfunction
+endif
+
 " Regex of syntax group names that are or delimit string or are comments.
-let s:syng_strcom = '\%(s\%(tring\|pecial\)\|comment\|regex\|doc\|template\)'
+let s:syng_strcom = 'string\|comment\|regex\|special\|doc\|template'
+let s:syng_str = 'string\|template'
+let s:syng_com = 'comment\|doc'
+" Expression used to check whether we should skip a match with searchpair().
+let s:skip_expr = "synIDattr(synID(line('.'),col('.'),0),'name') =~? '".s:syng_strcom."'"
 
-" Regex of syntax group names that are strings or documentation.
-let s:syng_comment = '\%(comment\|doc\)'
+function s:skip_func()
+  if !s:free || search('\m`\|\*\/','nW',s:looksyn)
+    let s:free = !eval(s:skip_expr)
+    let s:looksyn = s:free ? line('.') : s:looksyn
+    return !s:free
+  endif
+  let s:looksyn = line('.')
+  return (search('\m\/','nbW',s:looksyn) || search('\m[''"]\|\\$','nW',s:looksyn)) && eval(s:skip_expr)
+endfunction
 
-" Expression used to check whether we should skip a match with searchpair().
-let s:skip_expr = "line('.') < (prevnonblank(v:lnum) - 2000) ? dummy : synIDattr(synID(line('.'),col('.'),0),'name') =~? '".s:syng_strcom."'"
+function s:alternatePair(stop)
+  let pos = getpos('.')[1:2]
+  while search('\m[][(){}]','bW',a:stop)
+    if !s:skip_func()
+      let idx = stridx('])}',s:looking_at())
+      if idx + 1
+        if !s:GetPair(['\[','(','{'][idx], '])}'[idx],'bW','s:skip_func()',2000,a:stop)
+          break
+        endif
+      else
+        return
+      endif
+    endif
+  endwhile
+  call call('cursor',pos)
+endfunction
 
-function s:lookForParens(start,end,flags,time)
-  if has('reltime')
-    return searchpair(a:start,'',a:end,a:flags,s:skip_expr,0,a:time)
-  else
-    return searchpair(a:start,'',a:end,a:flags,0,0)
+function s:save_pos(f,...)
+  let l:pos = getpos('.')[1:2]
+  let ret = call(a:f,a:000)
+  call call('cursor',l:pos)
+  return ret
+endfunction
+
+function s:syn_at(l,c)
+  return synIDattr(synID(a:l,a:c,0),'name')
+endfunction
+
+function s:looking_at()
+  return getline('.')[col('.')-1]
+endfunction
+
+function s:token()
+  return s:looking_at() =~ '\k' ? expand('<cword>') : s:looking_at()
+endfunction
+
+function s:b_token()
+  if s:looking_at() =~ '\k'
+    call search('\m\<','cbW')
   endif
+  return search('\m\S','bW')
 endfunction
 
-let s:line_term = '\%(\s*\%(\/\*.\{-}\*\/\s*\)\=\)\@>$'
+function s:previous_token()
+  let l:n = line('.')
+  while s:b_token()
+    if (s:looking_at() == '/' || line('.') != l:n && search('\m\/\/','nbW',
+          \ line('.'))) && s:syn_at(line('.'),col('.')) =~? s:syng_com
+      call search('\m\_[^/]\zs\/[/*]','bW')
+    else
+      return s:token()
+    endif
+  endwhile
+  return ''
+endfunction
 
-" configurable regexes that define continuation lines, not including (, {, or [.
-if !exists('g:javascript_opfirst')
-  let g:javascript_opfirst = '\%([<>,:?^%]\|\([-/.+]\)\%(\1\|\*\|\/\)\@!\|\*\/\@!\|=>\@!\||\|&\|in\%(stanceof\)\=\>\)'
-endif
-let g:javascript_opfirst = s:line_pre . g:javascript_opfirst
+function s:others(p)
+  return "((line2byte(line('.')) + col('.')) <= ".(line2byte(a:p[0]) + a:p[1]).") || ".s:skip_expr
+endfunction
 
-if !exists('g:javascript_continuation')
-  let g:javascript_continuation = '\%([<*,.?:^%]\|+\@<!+\|-\@<!-\|=\@<!>\|\*\@<!\/\|=\||\|&\|\<in\%(stanceof\)\=\)'
-endif
-let g:javascript_continuation .= s:line_term
+function s:tern_skip(p)
+  return s:GetPair('{','}','nbW',s:others(a:p),200,a:p[0]) > 0
+endfunction
 
-function s:Onescope(lnum,text,add)
-  return a:text =~# '\%(\<else\|\<do\|=>' . (a:add ? '\|\<try\|\<finally' : '' ) . '\)' . s:line_term ||
-        \ ((a:add && a:text =~ s:line_pre . '$' && search('\%' . s:PrevCodeLine(a:lnum - 1) . 'l.)' . s:line_term)) ||
-        \ cursor(a:lnum, match(a:text, ')' . s:line_term)) > -1) &&
-        \ s:lookForParens('(', ')', 'cbW', 100) > 0 && search((a:add ?
-        \ '\%(function\*\|[[:lower:][:upper:]_$][[:digit:][:lower:][:upper:]_$]*\)' :
-        \ '\<\%(for\%(\s\+each\)\=\|if\|let\|w\%(hile\|ith\)\)') . '\_s*\%#\C','bW') &&
-        \ (a:add || (expand('<cword>') ==# 'while' ? !s:lookForParens('\<do\>\C', '\<while\>\C','bW',100) : 1))
+function s:tern_col(p)
+  return s:GetPair('?',':\@<!::\@!','nbW',s:others(a:p)
+        \ .' || s:tern_skip('.string(a:p).')',200,a:p[0]) > 0
 endfunction
 
-" Auxiliary Functions {{{2
+function s:label_col()
+  let pos = getpos('.')[1:2]
+  let [s:looksyn,s:free] = pos
+  call s:alternatePair(0)
+  if s:save_pos('s:IsBlock')
+    let poss = getpos('.')[1:2]
+    return call('cursor',pos) || !s:tern_col(poss)
+  elseif s:looking_at() == ':'
+    return !s:tern_col([0,0])
+  endif
+endfunction
+
+" configurable regexes that define continuation lines, not including (, {, or [.
+let s:opfirst = '^' . get(g:,'javascript_opfirst',
+      \ '\%([<>=,?^%|*/&]\|\([-.:+]\)\1\@!\|!=\|in\%(stanceof\)\=\>\)')
+let s:continuation = get(g:,'javascript_continuation',
+      \ '\%([<=,.~!?/*^%|&:]\|+\@<!+\|-\@<!-\|=\@<!>\|\<\%(typeof\|delete\|void\|in\|instanceof\)\)') . '$'
 
-" strip line of comment
-function s:StripLine(c)
-  return a:c !~# s:expr_case ? substitute(a:c, '\%(:\@<!\/\/.*\)$', '','') : a:c
+function s:continues(ln,con)
+  return !cursor(a:ln, match(' '.a:con,s:continuation)) &&
+        \ eval((['s:syn_at(line("."),col(".")) !~? "regex"'] +
+        \ repeat(['s:previous_token() != "."'],5) + [1])[
+        \ index(split('/ typeof in instanceof void delete'),s:token())])
 endfunction
 
-" Find line above 'lnum' that isn't empty, in a comment, or in a string.
+" get the line of code stripped of comments and move cursor to the last
+" non-comment char.
+function s:Trim(ln)
+  let pline = substitute(getline(a:ln),'\s*$','','')
+  let l:max = max([match(pline,'.*[^/]\zs\/[/*]'),0])
+  while l:max && s:syn_at(a:ln, strlen(pline)) =~? s:syng_com
+    let pline = substitute(strpart(pline, 0, l:max),'\s*$','','')
+    let l:max = max([match(pline,'.*[^/]\zs\/[/*]'),0])
+  endwhile
+  return cursor(a:ln,strlen(pline)) ? pline : pline
+endfunction
+
+" Find line above 'lnum' that isn't empty or in a comment
 function s:PrevCodeLine(lnum)
-  let l:lnum = prevnonblank(a:lnum)
-  while l:lnum > 0
-    if synIDattr(synID(l:lnum,matchend(getline(l:lnum), '^\s*[^''"]'),0),'name') !~? s:syng_strcom
-      break
+  let l:n = prevnonblank(a:lnum)
+  while l:n
+    if getline(l:n) =~ '^\s*\/[/*]'
+      if (stridx(getline(l:n),'`') > 0 || getline(l:n-1)[-1:] == '\') &&
+            \ s:syn_at(l:n,1) =~? s:syng_str
+        return l:n
+      endif
+      let l:n = prevnonblank(l:n-1)
+    elseif s:syn_at(l:n,1) =~? s:syng_com
+      let l:n = s:save_pos('eval',
+            \ 'cursor('.l:n.',1) + search(''\m\/\*'',"bW")')
+    else
+      return l:n
     endif
-    let l:lnum = prevnonblank(l:lnum - 1)
   endwhile
-  return l:lnum
 endfunction
 
 " Check if line 'lnum' has a balanced amount of parentheses.
 function s:Balanced(lnum)
-  let open_0 = 0
-  let open_2 = 0
-  let open_4 = 0
+  let l:open = 0
   let l:line = getline(a:lnum)
   let pos = match(l:line, '[][(){}]', 0)
   while pos != -1
-    if synIDattr(synID(a:lnum,pos + 1,0),'name') !~? s:syng_strcom
-      let idx = stridx('(){}[]', l:line[pos])
-      if idx % 2 == 0
-        let open_{idx} = open_{idx} + 1
-      else
-        let open_{idx - 1} = open_{idx - 1} - 1
+    if s:syn_at(a:lnum,pos + 1) !~? s:syng_strcom
+      let l:open += match(' ' . l:line[pos],'[[({]')
+      if l:open < 0
+        return
       endif
     endif
     let pos = match(l:line, '[][(){}]', pos + 1)
   endwhile
-  return (!open_4 + !open_2 + !open_0) - 2
+  return !l:open
 endfunction
-" }}}
 
-function GetJavascriptIndent()
-  if !exists('b:js_cache')
-    let b:js_cache = [0,0,0]
+function s:OneScope(lnum)
+  let pline = s:Trim(a:lnum)
+  let kw = 'else do'
+  if pline[-1:] == ')' && s:GetPair('(', ')', 'bW', s:skip_expr, 100) > 0
+    call s:previous_token()
+    let kw = 'for if let while with'
+    if index(split('await each'),s:token()) + 1
+      call s:previous_token()
+      let kw = 'for'
+    endif
+  endif
+  return pline[-2:] == '=>' || index(split(kw),s:token()) + 1 &&
+        \ s:save_pos('s:previous_token') != '.'
+endfunction
+
+" returns braceless levels started by 'i' and above lines * &sw. 'num' is the
+" lineNr which encloses the entire context, 'cont' if whether line 'i' + 1 is
+" a continued expression, which could have started in a braceless context
+function s:iscontOne(i,num,cont)
+  let [l:i, l:num, bL] = [a:i, a:num + !a:num, 0]
+  let pind = a:num ? indent(l:num) + s:W : 0
+  let ind = indent(l:i) + (a:cont ? 0 : s:W)
+  while l:i >= l:num && (ind > pind || l:i == l:num)
+    if indent(l:i) < ind && s:OneScope(l:i)
+      let bL += s:W
+      let l:i = line('.')
+    elseif !a:cont || bL || ind < indent(a:i)
+      break
+    endif
+    let ind = min([ind, indent(l:i)])
+    let l:i = s:PrevCodeLine(l:i - 1)
+  endwhile
+  return bL
+endfunction
+
+" https://github.com/sweet-js/sweet.js/wiki/design#give-lookbehind-to-the-reader
+function s:IsBlock()
+  if s:looking_at() == '{'
+    let l:n = line('.')
+    let char = s:previous_token()
+    let syn = char =~ '[{>/]' ? s:syn_at(line('.'),col('.')-(char == '{')) : ''
+    if syn =~? 'xml\|jsx'
+      return char != '{'
+    elseif char =~ '\k'
+      return index(split('return const let import export yield default delete var await void typeof throw case new in instanceof')
+            \ ,char) < (line('.') != l:n) || s:previous_token() == '.'
+    elseif char == '>'
+      return getline('.')[col('.')-2] == '=' || syn =~? '^jsflow'
+    elseif char == ':'
+      return getline('.')[col('.')-2] != ':' && s:label_col()
+    endif
+    return syn =~? 'regex' || char !~ '[-=~!<*+,/?^%|&([]'
   endif
+endfunction
+
+function GetJavascriptIndent()
+  let b:js_cache = get(b:,'js_cache',[0,0,0])
   " Get the current line.
-  let l:line = getline(v:lnum)
-  let syns = synIDattr(synID(v:lnum, 1, 0), 'name')
+  call cursor(v:lnum,1)
+  let l:line = getline('.')
+  let syns = s:syn_at(v:lnum, 1)
 
-  " start with strings,comments,etc.{{{2
-  if (l:line !~ '^[''"`]' && syns =~? 'string\|template') ||
-        \ (l:line !~ '^\s*[/*]' && syns =~? s:syng_comment)
+  " start with strings,comments,etc.
+  if syns =~? s:syng_com
+    if l:line =~ '^\s*\*'
+      return cindent(v:lnum)
+    elseif l:line !~ '^\s*\/[/*]'
+      return -1
+    endif
+  elseif syns =~? s:syng_str && l:line !~ '^[''"]'
+    if b:js_cache[0] == v:lnum - 1 && s:Balanced(v:lnum-1)
+      let b:js_cache[0] = v:lnum
+    endif
     return -1
   endif
-  if l:line !~ '^\%(\/\*\|\s*\/\/\)' && syns =~? s:syng_comment
-    return cindent(v:lnum)
-  endif
   let l:lnum = s:PrevCodeLine(v:lnum - 1)
-  if l:lnum == 0
-    return 0
+  if !l:lnum
+    return
   endif
 
-  if (l:line =~# s:expr_case)
-    let cpo_switch = &cpo
-    set cpo+=%
-    let ind = cindent(v:lnum)
-    let &cpo = cpo_switch
-    return ind
+  let l:line = substitute(l:line,'^\s*','','')
+  if l:line[:1] == '/*'
+    let l:line = substitute(l:line,'^\%(\/\*.\{-}\*\/\s*\)*','','')
+  endif
+  if l:line =~ '^\/[/*]'
+    let l:line = ''
   endif
-  "}}}
 
-  " the containing paren, bracket, curly. Memoize, last lineNr either has the
-  " same scope or starts a new one, unless if it closed a scope.
-  call cursor(v:lnum,1)
-  if b:js_cache[0] >= l:lnum  && b:js_cache[0] <= v:lnum && b:js_cache[0] &&
-        \ (b:js_cache[0] > l:lnum || s:Balanced(l:lnum) > 0)
-    let num = b:js_cache[1]
-  elseif syns != '' && l:line[0] =~ '\s'
-    let pattern = syns =~? 'block' ? ['{','}'] : syns =~? 'jsparen' ? ['(',')'] :
-          \ syns =~? 'jsbracket'? ['\[','\]'] : ['[({[]','[])}]']
-    let num = s:lookForParens(pattern[0],pattern[1],'bW',2000)
+  " the containing paren, bracket, or curly. Many hacks for performance
+  let idx = strlen(l:line) ? stridx('])}',l:line[0]) : -1
+  if b:js_cache[0] >= l:lnum && b:js_cache[0] < v:lnum &&
+        \ (b:js_cache[0] > l:lnum || s:Balanced(l:lnum))
+    call call('cursor',b:js_cache[1:])
   else
-    let num = s:lookForParens('[({[]','[])}]','bW',2000)
+    let [s:looksyn, s:free, top] = [v:lnum - 1, 1, (!indent(l:lnum) &&
+          \ s:syn_at(l:lnum,1) !~? s:syng_str) * l:lnum]
+    if idx + 1
+      call s:GetPair(['\[','(','{'][idx], '])}'[idx],'bW','s:skip_func()',2000,top)
+    elseif indent(v:lnum) && syns =~? 'block'
+      call s:GetPair('{','}','bW','s:skip_func()',2000,top)
+    else
+      call s:alternatePair(top)
+    endif
   endif
-  let b:js_cache = [v:lnum,num,line('.') == v:lnum ? b:js_cache[2] : col('.')]
 
-  if l:line =~ s:line_pre . '[])}]'
-    return indent(num)
+  if idx + 1 || l:line[:1] == '|}'
+    if idx == 2 && search('\m\S','bW',line('.')) && s:looking_at() == ')'
+      call s:GetPair('(',')','bW',s:skip_expr,200)
+    endif
+    return indent('.')
   endif
 
-  let pline = s:StripLine(getline(l:lnum))
-  let inb = num == 0 ? 1 : (s:Onescope(num, s:StripLine(strpart(getline(num),0,b:js_cache[2] - 1)),1) ||
-        \ (l:line !~ s:line_pre . ',' && pline !~ ',' . s:line_term)) && num < l:lnum
-  let switch_offset = (!inb || num == 0) || expand("<cword>") !=# 'switch' ? 0 : &cino !~ ':' || !has('float') ?  s:sw() :
-        \ float2nr(str2float(matchstr(&cino,'.*:\zs[-0-9.]*')) * (&cino =~# '.*:[^,]*s' ? s:sw() : 1))
-
-  " most significant, find the indent amount
-  if (inb && (l:line =~# g:javascript_opfirst ||
-        \ (pline =~# g:javascript_continuation && pline !~# s:expr_case && (pline !~ ':' . s:line_term || l:line !~#
-        \ s:line_pre . '\%(d\%(o\|ebugger\)\|else\|f\%(or\|inally\)\|if\|let\|switch\|t\%(hrow\|ry\)\|w\%(hile\|ith\)\)\>')))) ||
-        \ (num < l:lnum && s:Onescope(l:lnum,pline,0) && l:line !~ s:line_pre . '{')
-    return (num > 0 ? indent(num) : -s:sw()) + (s:sw() * 2) + switch_offset
-  elseif num > 0
-    return indent(num) + s:sw() + switch_offset
+  let b:js_cache = [v:lnum] + (line('.') == v:lnum ? [0,0] : getpos('.')[1:2])
+  let num = b:js_cache[1]
+
+  let [s:W, isOp, bL, switch_offset] = [s:sw(),0,0,0]
+  if !num || s:IsBlock()
+    let pline = s:save_pos('s:Trim',l:lnum)
+    if num && s:looking_at() == ')' && s:GetPair('(', ')', 'bW', s:skip_expr, 100) > 0
+      let num = line('.')
+      if s:previous_token() ==# 'switch' && s:previous_token() != '.'
+        if &cino !~ ':' || !has('float')
+          let switch_offset = s:W
+        else
+          let cinc = matchlist(&cino,'.*:\(-\)\=\([0-9.]*\)\(s\)\=\C')
+          let switch_offset = float2nr(str2float(cinc[1].(strlen(cinc[2]) ? cinc[2] : strlen(cinc[3])))
+                \ * (strlen(cinc[3]) ? s:W : 1))
+        endif
+        if pline[-1:] != '.' && l:line =~# '^\%(default\|case\)\>'
+          return indent(num) + switch_offset
+        endif
+      endif
+    endif
+    if pline[-1:] !~ '[{;]'
+      if pline =~# ':\@<!:$'
+        call cursor(l:lnum,strlen(pline))
+        let isOp = s:tern_col(b:js_cache[1:2])
+      else
+        let isOp = l:line =~# s:opfirst || s:continues(l:lnum,pline)
+      endif
+      let bL = s:iscontOne(l:lnum,num,isOp)
+      let bL -= (bL && l:line[0] == '{') * s:W
+    endif
   endif
 
+  " main return
+  if isOp
+    return (num ? indent(num) : -s:W) + (s:W * 2) + switch_offset + bL
+  elseif num
+    return indent(num) + s:W + switch_offset + bL
+  endif
+  return bL
 endfunction
 
-
 let &cpo = s:cpo_save
 unlet s:cpo_save
diff --git a/runtime/indent/liquid.vim b/runtime/indent/liquid.vim
index 01e7223696..f8e1c83079 100644
--- a/runtime/indent/liquid.vim
+++ b/runtime/indent/liquid.vim
@@ -1,7 +1,7 @@
 " Vim indent file
 " Language:     Liquid
 " Maintainer:   Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2013 May 30
+" Last Change:	2016 Aug 29
 
 if exists('b:did_indent')
   finish
@@ -54,9 +54,10 @@ function! GetLiquidIndent(...)
   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 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*$')
+  let sw = exists('*shiftwidth') ? shiftwidth() : &sw
+  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
diff --git a/runtime/indent/mf.vim b/runtime/indent/mf.vim
new file mode 100644
index 0000000000..88737f4e9f
--- /dev/null
+++ b/runtime/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
diff --git a/runtime/indent/mp.vim b/runtime/indent/mp.vim
index a118eb8b60..86fa2539c1 100644
--- a/runtime/indent/mp.vim
+++ b/runtime/indent/mp.vim
@@ -1,56 +1,19 @@
 " MetaPost indent file
-" Language:	MetaPost
-" Maintainer:	Eugene Minkovskii <emin@mccme.ru>
-" Last Change:	2012 May 18
-" Version: 0.1
-" ==========================================================================
-
-" Identation Rules: {{{1
-" First of all, MetaPost language don't expect any identation rules.
-" This screept need for you only if you (not MetaPost) need to do
-" exactly code. If you don't need to use indentation, see
-" :help filetype-indent-off
-"
-" Note: Every rules of identation in MetaPost or TeX languages (and in some
-" other of course) is very subjective. I can release only my vision of this
-" promlem.
-"
-" ..........................................................................
-" Example of correct (by me) identation {{{2
-" shiftwidth=4
-" ==========================================================================
-" for i=0 upto 99:
-"     z[i] = (0,1u) rotated (i*360/100);
-" endfor
-" draw z0 -- z10 -- z20
-"         withpen ...     % <- 2sw because breaked line
-"         withcolor ...;  % <- same as previous
-" draw z0 for i=1 upto 99:
-"             -- z[i]             % <- 1sw from left end of 'for' satement
-"         endfor withpen ...      % <- 0sw from left end of 'for' satement
-"                 withcolor ...;  % <- 2sw because breaked line
-" draw if One:     % <- This is internal if (like 'for' above)
-"          one
-"      elsif Other:
-"          other
-"      fi withpen ...;
-" if one:          % <- This is external if
-"     draw one;
-" elseif other:
-"     draw other;
-" fi
-" draw z0; draw z1;
-" }}}
-" }}}
+" 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
 
-" Only load this indent file when no other was loaded.
 if exists("b:did_indent")
   finish
 endif
 let b:did_indent = 1
 
 setlocal indentexpr=GetMetaPostIndent()
-setlocal indentkeys+=;,<:>,=if,=for,=def,=end,=else,=fi
+setlocal indentkeys+==end,=else,=fi,=fill,0),0]
+
+let b:undo_indent = "setl indentkeys< indentexpr<"
 
 " Only define the function once.
 if exists("*GetMetaPostIndent")
@@ -59,151 +22,337 @@ endif
 let s:keepcpo= &cpo
 set cpo&vim
 
-" Auxiliary Definitions: {{{1
-function! MetaNextNonblankNoncomment(pos)
-  " Like nextnonblank() but ignore comment lines
-  let tmp = nextnonblank(a:pos)
-  while tmp && getline(tmp) =~ '^\s*%'
-    let tmp = nextnonblank(tmp+1)
+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 tmp
+  return in_string || (c >= 0 && c <= a:pos)
 endfunction
 
-function! MetaPrevNonblankNoncomment(pos)
-  " Like prevnonblank() but ignore comment lines
-  let tmp = prevnonblank(a:pos)
-  while tmp && getline(tmp) =~ '^\s*%'
-    let tmp = prevnonblank(tmp-1)
+" 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 tmp
+  return l:lnum
 endfunction
 
-function! MetaSearchNoncomment(pattern, ...)
-  " Like search() but ignore commented areas
-  if a:0
-    let flags = a:1
-  elseif &wrapscan
-    let flags = "w"
-  else
-    let flags = "W"
-  endif
-  let cl  = line(".")
-  let cc  = col(".")
-  let tmp = search(a:pattern, flags)
-  while tmp && synIDattr(synID(line("."), col("."), 1), "name") =~
-        \ 'm[fp]\(Comment\|TeXinsert\|String\)'
-    let tmp = search(a:pattern, flags)
+" 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
-  if !tmp
-    call cursor(cl,cc)
+  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 tmp
+  return a:curr_indent
 endfunction
 " }}}
 
-function! GetMetaPostIndent()
-  " not indent in comment ???
-  if synIDattr(synID(line("."), col("."), 1), "name") =~
-        \ 'm[fp]\(Comment\|TeXinsert\|String\)'
+" 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
-  " Some RegExps: {{{1
-  " end_of_item: all of end by ';'
-  "            + all of end by :endfor, :enddef, :endfig, :endgroup, :fi
-  "            + all of start by :beginfig(num), :begingroup
-  "            + all of start by :for, :if, :else, :elseif and end by ':'
-  "            + all of start by :def, :vardef             and end by '='
-  let end_of_item = '\('                              .
-        \ ';\|'                                       .
-        \ '\<\(end\(for\|def\|fig\|group\)\|fi\)\>\|' .
-        \ '\<begin\(group\>\|fig\s*(\s*\d\+\s*)\)\|'  .
-        \ '\<\(for\|if\|else\(if\)\=\)\>.\+:\|'       .
-        \ '\<\(var\)\=def\>.\+='                      . '\)'
-  " }}}
-  " Save: current position {{{1
-  let cl = line   (".")
-  let cc = col    (".")
-  let cs = getline(".")
-  " if it is :beginfig or :endfig use zero indent
-  if  cs =~ '^\s*\(begin\|end\)fig\>'
-    return 0
-  endif
-  " }}}
-  " Initialise: ind variable {{{1
-  " search previous item not in current line
-  let p_semicol_l = MetaSearchNoncomment(end_of_item,"bW")
-  while p_semicol_l == cl
-    let p_semicol_l = MetaSearchNoncomment(end_of_item,"bW")
-  endwhile
-  " if this is first item in program use zero indent
-  if !p_semicol_l
+
+  " 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
-  " if this is multiline item, remember first indent
-  if MetaNextNonblankNoncomment(p_semicol_l+1) < cl
-    let ind = indent(MetaNextNonblankNoncomment(p_semicol_l+1))
-  " else --- search pre-previous item for search first line in previous item
-  else
-    " search pre-previous item not in current line
-    let pp_semicol_l = MetaSearchNoncomment(end_of_item,"bW")
-    while pp_semicol_l == p_semicol_l
-      let pp_semicol_l = MetaSearchNoncomment(end_of_item,"bW")
-    endwhile
-    " if we find pre-previous item, remember indent of previous item
-    " else --- remember zero
-    if pp_semicol_l
-      let ind = indent(MetaNextNonblankNoncomment(line(".")+1))
-    else
-      let ind = 0
+
+  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
-  " }}}
-  " Increase Indent: {{{1
-  " if it is an internal/external :for or :if statements {{{2
-  let pnn_s = getline(MetaPrevNonblankNoncomment(cl-1))
-  if  pnn_s =~ '\<\(for\|if\)\>.\+:\s*\($\|%\)'
-    let ind = match(pnn_s, '\<\(for\|if\)\>.\+:\s*\($\|%\)') + &sw
-  " }}}
-  " if it is a :def, :vardef, :beginfig, :begingroup, :else, :elseif {{{2
-  elseif pnn_s =~ '^\s*\('                       .
-        \ '\(var\)\=def\|'                       .
-        \ 'begin\(group\|fig\s*(\s*\d\+\s*)\)\|' .
-        \ 'else\(if\)\='                         . '\)\>'
-    let ind = ind + &sw
-  " }}}
-  " if it is a broken line {{{2
-  elseif pnn_s !~ end_of_item.'\s*\($\|%\)'
-    let ind = ind + (2 * &sw)
+
+  " 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
-  " }}}
-  " }}}
-  " Decrease Indent: {{{1
-  " if this is :endfor or :enddef statements {{{2
-  " this is correct because :def cannot be inside :for
-  if  cs  =~ '\<end\(for\|def\)\=\>'
-    call MetaSearchNoncomment('\<for\>.\+:\s*\($\|%\)' . '\|' .
-                            \ '^\s*\(var\)\=def\>',"bW")
-    if col(".") > 1
-      let ind = col(".") - 1
+
+  " 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
-      let ind = indent(".")
+      return s:DecreaseIndentOnClosingTag(indent(lnum))
     endif
-  " }}}
-  " if this is :fi, :else, :elseif statements {{{2
-  elseif cs =~ '\<\(else\(if\)\=\|fi\)\>'
-    call MetaSearchNoncomment('\<if\>.\+:\s*\($\|%\)',"bW")
-    let ind = col(".") - 1
-  " }}}
-  " if this is :endgroup statement {{{2
-  elseif cs =~ '^\s*endgroup\>'
-    let ind = ind - &sw
   endif
-  " }}}
-  " }}}
 
-  return ind
+  " 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
diff --git a/runtime/indent/rnoweb.vim b/runtime/indent/rnoweb.vim
index 29fa5bc78f..8c11e85cb3 100644
--- a/runtime/indent/rnoweb.vim
+++ b/runtime/indent/rnoweb.vim
@@ -2,7 +2,7 @@
 " Language:	Rnoweb
 " Author:	Jakson Alves de Aquino <jalvesaq@gmail.com>
 " Homepage:     https://github.com/jalvesaq/R-Vim-runtime
-" Last Change:	Tue Apr 07, 2015  04:38PM
+" Last Change:	Fri Apr 15, 2016  10:58PM
 
 
 " Only load this indent file when no other was loaded.
@@ -10,7 +10,17 @@ if exists("b:did_indent")
   finish
 endif
 runtime indent/tex.vim
-let s:TeXIndent = function(substitute(&indentexpr, "()", "", ""))
+
+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, "()", "", ""))
diff --git a/runtime/indent/ruby.vim b/runtime/indent/ruby.vim
index 095b3a43c6..a97f4828d6 100644
--- a/runtime/indent/ruby.vim
+++ b/runtime/indent/ruby.vim
@@ -13,12 +13,23 @@ if exists("b:did_indent")
 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_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=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")
@@ -34,7 +45,7 @@ set cpo&vim
 " Regex of syntax group names that are or delimit strings/symbols or are comments.
 let s:syng_strcom = '\<ruby\%(Regexp\|RegexpDelimiter\|RegexpEscape' .
       \ '\|Symbol\|String\|StringDelimiter\|StringEscape\|ASCIICode' .
-      \ '\|Interpolation\|NoInterpolation\|Comment\|Documentation\)\>'
+      \ '\|Interpolation\|InterpolationDelimiter\|NoInterpolation\|Comment\|Documentation\)\>'
 
 " Regex of syntax group names that are strings.
 let s:syng_string =
@@ -49,9 +60,10 @@ let s:skip_expr =
       \ "synIDattr(synID(line('.'),col('.'),1),'name') =~ '".s:syng_strcom."'"
 
 " 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\|def\|if\|for' .
-      \ '\|while\|until\|else\|elsif\|case\|when\|unless\|begin\|ensure' .
-      \ '\|rescue\):\@!\>' .
+let s:ruby_indent_keywords =
+      \ '^\s*\zs\<\%(module\|class\|if\|for' .
+      \   '\|while\|until\|else\|elsif\|case\|when\|unless\|begin\|ensure\|rescue' .
+      \   '\|\%(public\|protected\|private\)\=\s*def\):\@!\>' .
       \ '\|\%([=,*/%+-]\|<<\|>>\|:\s\)\s*\zs' .
       \    '\<\%(if\|for\|while\|until\|case\|unless\|begin\):\@!\>'
 
@@ -64,7 +76,8 @@ let s:ruby_deindent_keywords =
 " 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\|def\|if\|for\|while\|until\|case\|unless\|begin\):\@!\>' .
+      \ '\<\%(module\|class\|if\|for\|while\|until\|case\|unless\|begin' .
+      \   '\|\%(public\|protected\|private\)\=\s*def\):\@!\>' .
       \ '\|\%(^\|[^.:@$]\)\@<=\<do:\@!\>'
 
 " Regex that defines the middle-match for the 'end' keyword.
@@ -79,19 +92,39 @@ let s:end_skip_expr = s:skip_expr .
       \ ' && getline(".") =~ "^\\s*\\<\\(while\\|until\\|for\\):\\@!\\>")'
 
 " Regex that defines continuation lines, not including (, {, or [.
-let s:non_bracket_continuation_regex = '\%([\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\)\s*\%(#.*\)\=$'
+let s:non_bracket_continuation_regex =
+      \ '\%([\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|:\@<![^[:alnum:]:][|&?]\|||\|&&\)\s*\%(#.*\)\=$'
 
 " Regex that defines continuation lines.
-" TODO: this needs to deal with if ...: and so on
 let s:continuation_regex =
-      \ '\%(%\@<![({[\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\)\s*\%(#.*\)\=$'
+      \ '\%(%\@<![({[\\.,:*/%+]\|\<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.
@@ -102,10 +135,13 @@ let s:splat_regex = '[[,(]\s*\*\s*\%(#.*\)\=$'
 " 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*\%(#.*\)\=$'
+      \ '\%(\<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. Auxiliary Functions {{{1
 " ======================
 
@@ -165,7 +201,21 @@ function s:GetMSL(lnum)
     " Otherwise, terminate search as we have found our MSL already.
     let line = getline(lnum)
 
-    if s:Match(lnum, s:splat_regex)
+    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.
       "
@@ -175,7 +225,7 @@ function s:GetMSL(lnum)
       "       something
       "
       return msl
-    elseif s:Match(line, s:non_bracket_continuation_regex) &&
+    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.
@@ -186,6 +236,18 @@ function s:GetMSL(lnum)
       "     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
@@ -299,18 +361,39 @@ function s:ExtraBrackets(lnum)
 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
+  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
 
-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)
+" Locates the containing class/module's definition line, ignoring nested classes
+" along the way.
+"
+function! s:FindContainingClass()
+  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
-  return col + 1
+
+  call setpos('.', saved_position)
+  return 0
 endfunction
 
 " 3. GetRubyIndent Function {{{1
@@ -320,6 +403,13 @@ function GetRubyIndent(...)
   " 3.1. Setup {{{2
   " ----------
 
+  " The value of a single shift-width
+  if exists('*shiftwidth')
+    let sw = shiftwidth()
+  else
+    let sw = &sw
+  endif
+
   " For the current line, use the first argument if given, else v:lnum
   let clnum = a:0 ? a:1 : v:lnum
 
@@ -333,6 +423,24 @@ function GetRubyIndent(...)
   let line = getline(clnum)
   let ind = -1
 
+  " 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(clnum, s:access_modifier_regex)
+      let class_line = s:FindContainingClass()
+      if class_line > 0
+        return indent(class_line) + sw
+      endif
+    endif
+  elseif g:ruby_indent_access_modifier_style == 'outdent'
+    if s:Match(clnum, s:access_modifier_regex)
+      let class_line = s:FindContainingClass()
+      if class_line > 0
+        return indent(class_line)
+      endif
+    endif
+  endif
+
   " 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.
@@ -343,7 +451,9 @@ function GetRubyIndent(...)
     if searchpair(escape(bs[0], '\['), '', bs[1], 'bW', s:skip_expr) > 0
       if line[col-1]==')' && col('.') != col('$') - 1
         let ind = virtcol('.') - 1
-      else
+      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
@@ -366,10 +476,17 @@ function GetRubyIndent(...)
 
       if strpart(line, 0, col('.') - 1) =~ '=\s*$' &&
             \ strpart(line, col('.') - 1, 2) !~ 'do'
+        " assignment to case/begin/etc, on the same line, hanging indent
         let ind = virtcol('.') - 1
+      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
@@ -389,6 +506,11 @@ function GetRubyIndent(...)
     return 0
   endif
 
+  " If the current line starts with a leading operator, add a level of indent.
+  if s:Match(clnum, s:leading_operator_regex)
+    return indent(s:GetMSL(clnum)) + sw
+  endif
+
   " 3.3. Work on the previous line. {{{2
   " -------------------------------
 
@@ -409,14 +531,50 @@ function GetRubyIndent(...)
   let line = getline(lnum)
   let ind = indent(lnum)
 
+  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(lnum, s:indent_access_modifier_regex)
+      return indent(lnum) + 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(lnum, s:access_modifier_regex)
+      return indent(lnum) + sw
+    endif
+  endif
+
+  if s:Match(lnum, s:continuable_regex) && s:Match(lnum, s:continuation_regex)
+    return indent(s:GetMSL(lnum)) + sw + sw
+  endif
+
   " 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)) + &sw
+    let msl = s:GetMSL(lnum)
+
+    if g:ruby_indent_block_style == 'do'
+      " don't align to the msl, align to the "do"
+      let ind = indent(lnum) + sw
+    elseif getline(msl) =~ '=\s*\(#.*\)\=$'
+      " in the case of assignment to the msl, align to the starting line,
+      " not to the msl
+      let ind = indent(lnum) + sw
+    else
+      let ind = indent(msl) + sw
+    endif
+    return ind
+  endif
+
+  " If the previous line started with a leading operator, use its MSL's level
+  " of indent
+  if s:Match(lnum, s:leading_operator_regex)
+    return indent(s:GetMSL(lnum))
   endif
 
   " If the previous line ended with the "*" of a splat, add a level of indent
   if line =~ s:splat_regex
-    return indent(lnum) + &sw
+    return indent(lnum) + sw
   endif
 
   " If the previous line contained unclosed opening brackets and we are still
@@ -431,22 +589,22 @@ function GetRubyIndent(...)
     if opening.pos != -1
       if opening.type == '(' && searchpair('(', '', ')', 'bW', s:skip_expr) > 0
         if col('.') + 1 == col('$')
-          return ind + &sw
+          return ind + sw
         else
           return virtcol('.')
         endif
       else
         let nonspace = matchend(line, '\S', opening.pos + 1) - 1
-        return nonspace > 0 ? nonspace : ind + &sw
+        return nonspace > 0 ? nonspace : ind + sw
       endif
     elseif closing.pos != -1
       call cursor(lnum, closing.pos + 1)
       normal! %
 
       if s:Match(line('.'), s:ruby_indent_keywords)
-        return indent('.') + &sw
+        return indent('.') + sw
       else
-        return indent('.')
+        return indent(s:GetMSL(line('.')))
       endif
     else
       call cursor(clnum, vcol)
@@ -473,7 +631,7 @@ function GetRubyIndent(...)
   let col = s:Match(lnum, s:ruby_indent_keywords)
   if col > 0
     call cursor(lnum, col)
-    let ind = virtcol('.') - 1 + &sw
+    let ind = virtcol('.') - 1 + 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
@@ -490,10 +648,14 @@ function GetRubyIndent(...)
   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 the previous line wasn't a MSL.
   if p_lnum != lnum
-    if s:Match(p_lnum, s:non_bracket_continuation_regex) || s:IsInString(p_lnum,strlen(line))
+    " If previous line ends bracket and begins non-bracket continuation decrease indent by 1.
+    if s:Match(p_lnum, s:bracket_switch_continuation_regex)
+      return ind - 1
+    " If previous line is a continuation return its indent.
+    " TODO: the || s:IsInString() thing worries me a bit.
+    elseif s:Match(p_lnum, s:non_bracket_continuation_regex) || s:IsInString(p_lnum,strlen(line))
       return ind
     endif
   endif
@@ -506,9 +668,9 @@ function GetRubyIndent(...)
   " TODO: this does not take into account contrived things such as
   " module Foo; class Bar; end
   if s:Match(lnum, s:ruby_indent_keywords)
-    let ind = msl_ind + &sw
+    let ind = msl_ind + sw
     if s:Match(lnum, s:end_end_regex)
-      let ind = ind - &sw
+      let ind = ind - sw
     endif
     return ind
   endif
@@ -517,7 +679,7 @@ function GetRubyIndent(...)
   " 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 + &sw
+      let ind = msl_ind + sw
     else
       let ind = msl_ind
     endif
diff --git a/runtime/indent/sass.vim b/runtime/indent/sass.vim
index b6e2e66e8a..d87b371fdd 100644
--- a/runtime/indent/sass.vim
+++ b/runtime/indent/sass.vim
@@ -1,7 +1,7 @@
 " Vim indent file
 " Language:	Sass
 " Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2013 May 30
+" Last Change:	2016 Aug 29
 
 if exists("b:did_indent")
   finish
@@ -29,9 +29,7 @@ function! GetSassIndent()
   let indent = indent(lnum)
   let cindent = indent(v:lnum)
   if line !~ s:property && line !~ s:extend && cline =~ s:property
-    return indent + &sw
-  "elseif line =~ s:property && cline !~ s:property
-    "return indent - &sw
+    return indent + (exists('*shiftwidth') ? shiftwidth() : &sw)
   else
     return -1
   endif
diff --git a/runtime/indent/scala.vim b/runtime/indent/scala.vim
new file mode 100644
index 0000000000..f97c79bbab
--- /dev/null
+++ b/runtime/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:
diff --git a/runtime/indent/sh.vim b/runtime/indent/sh.vim
index d05bb3770f..aca110f504 100644
--- a/runtime/indent/sh.vim
+++ b/runtime/indent/sh.vim
@@ -3,9 +3,15 @@
 " Maintainer:          Christian Brabandt <cb@256bit.org>
 " Previous Maintainer: Peter Aronoff <telemachus@arpinum.org>
 " Original Author:     Nikolai Weibull <now@bitwi.se>
-" Latest Revision:     2016-02-15
+" Latest Revision:     2016-06-27
 " License:             Vim (see :h license)
 " Repository:          https://github.com/chrisbra/vim-sh-indent
+" Changelog:
+"          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
@@ -102,6 +108,8 @@ function! GetShIndent()
     endif
   elseif s:is_case_break(line)
     let ind -= s:indent_value('case-breaks')
+  elseif s:is_here_doc(line)
+    let ind = 0
   endif
 
   return ind
@@ -160,6 +168,14 @@ 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
@@ -172,5 +188,9 @@ function! s:is_case_empty(line)
   endif
 endfunction
 
+function! s:escape(pattern)
+    return '\V'. escape(a:pattern, '\\')
+endfunction
+
 let &cpo = s:cpo_save
 unlet s:cpo_save
diff --git a/runtime/indent/teraterm.vim b/runtime/indent/teraterm.vim
index ba24257b02..8467cefcc0 100644
--- a/runtime/indent/teraterm.vim
+++ b/runtime/indent/teraterm.vim
@@ -1,9 +1,9 @@
 " Vim indent file
 " Language:	Tera Term Language (TTL)
-"		Based on Tera Term Version 4.86
+"		Based on Tera Term Version 4.92
 " Maintainer:	Ken Takata
 " URL:		https://github.com/k-takata/vim-teraterm
-" Last Change:	2015 Jun 4
+" Last Change:	2016 Aug 17
 " Filenames:	*.ttl
 " License:	VIM License
 
@@ -25,9 +25,7 @@ endif
 " The shiftwidth() function is relatively new.
 " Don't require it to exist.
 if exists('*shiftwidth')
-  function s:sw() abort
-    return shiftwidth()
-  endfunction
+  let s:sw = function('shiftwidth')
 else
   function s:sw() abort
     return &shiftwidth
@@ -48,7 +46,7 @@ function! GetTeraTermIndent(lnum)
 
   let l:ind = l:previ
 
-  if l:prevl =~ '^\s*if\>.*\<then\s*$'
+  if l:prevl =~ '^\s*if\>.*\<then\>'
     " previous line opened a block
     let l:ind += s:sw()
   endif
diff --git a/runtime/indent/vim.vim b/runtime/indent/vim.vim
index 7ec7df849e..8ebfa12caf 100644
--- a/runtime/indent/vim.vim
+++ b/runtime/indent/vim.vim
@@ -1,7 +1,7 @@
 " Vim indent file
 " Language:	Vim script
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2016 Apr 19
+" Last Change:	2016 Jun 27
 
 " Only load this indent file when no other was loaded.
 if exists("b:did_indent")
@@ -60,7 +60,7 @@ function GetVimIndentIntern()
     else
       let ind = ind + shiftwidth() * 3
     endif
-  elseif prev_text =~ '^\s*aug\%[roup]' && prev_text !~ '^\s*aug\%[roup]\s*!\=\s\+[eE][nN][dD]'
+  elseif prev_text =~ '^\s*aug\%[roup]\s\+' && prev_text !~ '^\s*aug\%[roup]\s\+[eE][nN][dD]\>'
     let ind = ind + shiftwidth()
   else
     " A line starting with :au does not increment/decrement indent.
@@ -89,7 +89,7 @@ function GetVimIndentIntern()
 
   " Subtract a 'shiftwidth' on a :endif, :endwhile, :catch, :finally, :endtry,
   " :endfun, :else and :augroup END.
-  if cur_text =~ '^\s*\(ene\@!\|cat\|fina\|el\|aug\%[roup]\s*!\=\s\+[eE][nN][dD]\)'
+  if cur_text =~ '^\s*\(ene\@!\|cat\|fina\|el\|aug\%[roup]\s\+[eE][nN][dD]\)'
     let ind = ind - shiftwidth()
   endif
 
diff --git a/runtime/indent/yaml.vim b/runtime/indent/yaml.vim
index aa4906ce0a..3201462fbc 100644
--- a/runtime/indent/yaml.vim
+++ b/runtime/indent/yaml.vim
@@ -37,7 +37,7 @@ function s:FindPrevLessIndentedLine(lnum, ...)
     let curindent = a:0 ? a:1 : indent(a:lnum)
     while           prevlnum
                 \&&  indent(prevlnum) >=  curindent
-                \&& getline(prevlnum) !~# '^\s*#'
+                \&& getline(prevlnum) =~# '^\s*#'
         let prevlnum = prevnonblank(prevlnum-1)
     endwhile
     return prevlnum
@@ -51,11 +51,33 @@ function s:FindPrevLEIndentedLineMatchingRegex(lnum, regex)
     return plilnum
 endfunction
 
-let s:mapkeyregex='\v^\s*%(\''%([^'']|'''')*\'''.
-                \        '|\"%([^"\\]|\\.)*\"'.
-                \        '|%(%(\:\ )@!.)*)\:%(\ |$)'
+let s:mapkeyregex='\v^\s*\#@!\S@=%(\''%([^'']|\''\'')*\'''.
+                \                 '|\"%([^"\\]|\\.)*\"'.
+                \                 '|%(%(\:\ )@!.)*)\:%(\ |$)'
 let s:liststartregex='\v^\s*%(\-%(\ |$))'
 
+let s:c_ns_anchor_char = '\v%([\n\r\uFEFF \t,[\]{}]@!\p)'
+let s:c_ns_anchor_name = s:c_ns_anchor_char.'+'
+let s:c_ns_anchor_property =  '\v\&'.s:c_ns_anchor_name
+
+let s:ns_word_char = '\v[[:alnum:]_\-]'
+let s:ns_tag_char  = '\v%(%\x\x|'.s:ns_word_char.'|[#/;?:@&=+$.~*''()])'
+let s:c_named_tag_handle     = '\v\!'.s:ns_word_char.'+\!'
+let s:c_secondary_tag_handle = '\v\!\!'
+let s:c_primary_tag_handle   = '\v\!'
+let s:c_tag_handle = '\v%('.s:c_named_tag_handle.
+            \            '|'.s:c_secondary_tag_handle.
+            \            '|'.s:c_primary_tag_handle.')'
+let s:c_ns_shorthand_tag = '\v'.s:c_tag_handle . s:ns_tag_char.'+'
+let s:c_non_specific_tag = '\v\!'
+let s:ns_uri_char  = '\v%(%\x\x|'.s:ns_word_char.'\v|[#/;?:@&=+$,.!~*''()[\]])'
+let s:c_verbatim_tag = '\v\!\<'.s:ns_uri_char.'+\>'
+let s:c_ns_tag_property = '\v'.s:c_verbatim_tag.
+            \               '\v|'.s:c_ns_shorthand_tag.
+            \               '\v|'.s:c_non_specific_tag
+
+let s:block_scalar_header = '\v[|>]%([+-]?[1-9]|[1-9]?[+-])?'
+
 function GetYAMLIndent(lnum)
     if a:lnum == 1 || !prevnonblank(a:lnum-1)
         return 0
@@ -127,7 +149,10 @@ function GetYAMLIndent(lnum)
         " - List with
         "   multiline scalar
         return previndent+2
-    elseif prevline =~# s:mapkeyregex
+    elseif prevline =~# s:mapkeyregex . '\v\s*%(%('.s:c_ns_tag_property.
+                \                              '\v|'.s:c_ns_anchor_property.
+                \                              '\v|'.s:block_scalar_header.
+                \                             '\v)%(\s+|\s*%(\#.*)?$))*'
         " Mapping with: value
         "     that is multiline scalar
         return previndent+s:shiftwidth()