diff --git a/src/testdir/test49.ok b/src/testdir/test49.ok
index 50696fd..8ca8a56 100644
--- a/src/testdir/test49.ok
+++ b/src/testdir/test49.ok
@@ -1,18 +1,9 @@
 Results of test49.vim:
-*** Test  52: OK (1247112011)
-*** Test  53: OK (131071)
-*** Test  54: OK (2047)
-*** Test  55: OK (1023)
-*** Test  56: OK (511)
-*** Test  57: OK (2147450880)
-*** Test  58: OK (624945)
 *** Test  59: OK (2038431743)
 *** Test  60: OK (311511339)
-*** Test  61: OK (374889517)
 *** Test  62: OK (286331153)
 *** Test  63: OK (236978127)
 *** Test  64: OK (1499645335)
-*** Test  65: OK (70187)
 *** Test  66: OK (5464)
 *** Test  67: OK (212514423)
 *** Test  68: OK (212514423)
diff --git a/src/testdir/test49.vim b/src/testdir/test49.vim
index b3215df..9ef91df 100644
--- a/src/testdir/test49.vim
+++ b/src/testdir/test49.vim
@@ -607,23 +607,6 @@
 
 " END_OF_TEST_ENVIRONMENT - do not change or remove this line.
 
-" Tests 1 to 50, 87 were moved to test_vimscript.vim
-" Tests 25, 26, 32, 33, 41-48, 51, 69-75 were moved to test_trycatch.vim
-let Xtest = 52
-
-"-------------------------------------------------------------------------------
-" Test 52:  Uncaught exceptions						    {{{1
-"
-"	    When an exception is thrown but not caught, an error message is
-"	    displayed when the script is terminated.  In case of an interrupt
-"	    or error exception, the normal interrupt or error message(s) are
-"	    displayed.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-let msgfile = tempname()
-
 function! MESSAGES(...)
     try
 	exec "edit" g:msgfile
@@ -665,940 +648,11 @@
     return match
 endfunction
 
-if ExtraVim(msgfile)
-    Xpath 1					" X: 1
-    throw "arrgh"
-endif
-
-Xpath 2						" X: 2
-if !MESSAGES('E605', "Exception not caught")
-    Xpath 4					" X: 0
-endif
-
-if ExtraVim(msgfile)
-    try
-	Xpath 8					" X: 8
-	throw "oops"
-    catch /arrgh/
-	Xpath 16				" X: 0
-    endtry
-    Xpath 32					" X: 0
-endif
-
-Xpath 64					" X: 64
-if !MESSAGES('E605', "Exception not caught")
-    Xpath 128					" X: 0
-endif
-
-if ExtraVim(msgfile)
-    function! T()
-	throw "brrr"
-    endfunction
-
-    try
-	Xpath 256				" X: 256
-	throw "arrgh"
-    catch /.*/
-	Xpath 512				" X: 512
-	call T()
-    endtry
-    Xpath 1024					" X: 0
-endif
-
-Xpath 2048					" X: 2048
-if !MESSAGES('E605', "Exception not caught")
-    Xpath 4096					" X: 0
-endif
-
-if ExtraVim(msgfile)
-    try
-	Xpath 8192				" X: 8192
-	throw "arrgh"
-    finally
-	Xpath 16384				" X: 16384
-	throw "brrr"
-    endtry
-    Xpath 32768					" X: 0
-endif
-
-Xpath 65536					" X: 65536
-if !MESSAGES('E605', "Exception not caught")
-    Xpath 131072				" X: 0
-endif
-
-if ExtraVim(msgfile)
-    try
-	Xpath 262144				" X: 262144
-	"INTERRUPT
-    endtry
-    Xpath 524288				" X: 0
-endif
-
-Xpath 1048576					" X: 1048576
-if !MESSAGES('INT', "Interrupted")
-    Xpath 2097152				" X: 0
-endif
-
-if ExtraVim(msgfile)
-    try
-	Xpath 4194304				" X: 4194304
-	let x = novar	" error E121; exception: E121
-    catch /E15:/	" should not catch
-	Xpath 8388608				" X: 0
-    endtry
-    Xpath 16777216				" X: 0
-endif
-
-Xpath 33554432					" X: 33554432
-if !MESSAGES('E121', "Undefined variable")
-    Xpath 67108864				" X: 0
-endif
-
-if ExtraVim(msgfile)
-    try
-	Xpath 134217728				" X: 134217728
-"	unlet novar #	" error E108/E488; exception: E488
-    catch /E108:/	" should not catch
-	Xpath 268435456				" X: 0
-    endtry
-    Xpath 536870912				" X: 0
-endif
-
-Xpath 1073741824				" X: 1073741824
-if !MESSAGES('E108', "No such variable", 'E488', "Trailing characters")
-    " The Xpath command does not accept 2^31 (negative); add explicitly:
-    let Xpath = Xpath + 2147483648		" X: 0
-endif
-
-call delete(msgfile)
-unlet msgfile
-
-Xcheck 1247112011
-
 " Leave MESSAGES() for the next tests.
 
-
-"-------------------------------------------------------------------------------
-" Test 53:  Nesting errors: :endif/:else/:elseif			    {{{1
-"
-"	    For nesting errors of :if conditionals the correct error messages
-"	    should be given.
-"
-"	    This test reuses the function MESSAGES() from the previous test.
-"	    This functions checks the messages in g:msgfile.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-let msgfile = tempname()
-
-if ExtraVim(msgfile)
-"   endif
-endif
-if MESSAGES('E580', ":endif without :if")
-    Xpath 1					" X: 1
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       endif
-"   endwhile
-endif
-if MESSAGES('E580', ":endif without :if")
-    Xpath 2					" X: 2
-endif
-
-if ExtraVim(msgfile)
-"   try
-"   finally
-"       endif
-"   endtry
-endif
-if MESSAGES('E580', ":endif without :if")
-    Xpath 4					" X: 4
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       endif
-"   endtry
-endif
-if MESSAGES('E580', ":endif without :if")
-    Xpath 8					" X: 8
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       throw "a"
-"   catch /a/
-"       endif
-"   endtry
-endif
-if MESSAGES('E580', ":endif without :if")
-    Xpath 16					" X: 16
-endif
-
-if ExtraVim(msgfile)
-"   else
-endif
-if MESSAGES('E581', ":else without :if")
-    Xpath 32					" X: 32
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       else
-"   endwhile
-endif
-if MESSAGES('E581', ":else without :if")
-    Xpath 64					" X: 64
-endif
-
-if ExtraVim(msgfile)
-"   try
-"   finally
-"       else
-"   endtry
-endif
-if MESSAGES('E581', ":else without :if")
-    Xpath 128					" X: 128
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       else
-"   endtry
-endif
-if MESSAGES('E581', ":else without :if")
-    Xpath 256					" X: 256
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       throw "a"
-"   catch /a/
-"       else
-"   endtry
-endif
-if MESSAGES('E581', ":else without :if")
-    Xpath 512					" X: 512
-endif
-
-if ExtraVim(msgfile)
-"   elseif
-endif
-if MESSAGES('E582', ":elseif without :if")
-    Xpath 1024					" X: 1024
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       elseif
-"   endwhile
-endif
-if MESSAGES('E582', ":elseif without :if")
-    Xpath 2048					" X: 2048
-endif
-
-if ExtraVim(msgfile)
-"   try
-"   finally
-"       elseif
-"   endtry
-endif
-if MESSAGES('E582', ":elseif without :if")
-    Xpath 4096					" X: 4096
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       elseif
-"   endtry
-endif
-if MESSAGES('E582', ":elseif without :if")
-    Xpath 8192					" X: 8192
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       throw "a"
-"   catch /a/
-"       elseif
-"   endtry
-endif
-if MESSAGES('E582', ":elseif without :if")
-    Xpath 16384					" X: 16384
-endif
-
-if ExtraVim(msgfile)
-"   if 1
-"   else
-"   else
-"   endif
-endif
-if MESSAGES('E583', "multiple :else")
-    Xpath 32768					" X: 32768
-endif
-
-if ExtraVim(msgfile)
-"   if 1
-"   else
-"   elseif 1
-"   endif
-endif
-if MESSAGES('E584', ":elseif after :else")
-    Xpath 65536					" X: 65536
-endif
-
-call delete(msgfile)
-unlet msgfile
-
-Xcheck 131071
-
-" Leave MESSAGES() for the next test.
-
-
-"-------------------------------------------------------------------------------
-" Test 54:  Nesting errors: :while/:endwhile				    {{{1
-"
-"	    For nesting errors of :while conditionals the correct error messages
-"	    should be given.
-"
-"	    This test reuses the function MESSAGES() from the previous test.
-"	    This functions checks the messages in g:msgfile.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-let msgfile = tempname()
-
-if ExtraVim(msgfile)
-"   endwhile
-endif
-if MESSAGES('E588', ":endwhile without :while")
-    Xpath 1					" X: 1
-endif
-
-if ExtraVim(msgfile)
-"   if 1
-"       endwhile
-"   endif
-endif
-if MESSAGES('E588', ":endwhile without :while")
-    Xpath 2					" X: 2
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       if 1
-"   endwhile
-endif
-if MESSAGES('E171', "Missing :endif")
-    Xpath 4					" X: 4
-endif
-
-if ExtraVim(msgfile)
-"   try
-"   finally
-"       endwhile
-"   endtry
-endif
-if MESSAGES('E588', ":endwhile without :while")
-    Xpath 8					" X: 8
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       try
-"       finally
-"   endwhile
-endif
-if MESSAGES('E600', "Missing :endtry")
-    Xpath 16					" X: 16
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       if 1
-"	    try
-"	    finally
-"   endwhile
-endif
-if MESSAGES('E600', "Missing :endtry")
-    Xpath 32					" X: 32
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       try
-"       finally
-"	    if 1
-"   endwhile
-endif
-if MESSAGES('E171', "Missing :endif")
-    Xpath 64					" X: 64
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       endwhile
-"   endtry
-endif
-if MESSAGES('E588', ":endwhile without :while")
-    Xpath 128					" X: 128
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       try
-"	    endwhile
-"       endtry
-"   endwhile
-endif
-if MESSAGES('E588', ":endwhile without :while")
-    Xpath 256					" X: 256
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       throw "a"
-"   catch /a/
-"       endwhile
-"   endtry
-endif
-if MESSAGES('E588', ":endwhile without :while")
-    Xpath 512					" X: 512
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       try
-"	    throw "a"
-"	catch /a/
-"	    endwhile
-"       endtry
-"   endwhile
-endif
-if MESSAGES('E588', ":endwhile without :while")
-    Xpath 1024					" X: 1024
-endif
-
-
-call delete(msgfile)
-unlet msgfile
-
-Xcheck 2047
-
-" Leave MESSAGES() for the next test.
-
-
-"-------------------------------------------------------------------------------
-" Test 55:  Nesting errors: :continue/:break				    {{{1
-"
-"	    For nesting errors of :continue and :break commands the correct
-"	    error messages should be given.
-"
-"	    This test reuses the function MESSAGES() from the previous test.
-"	    This functions checks the messages in g:msgfile.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-let msgfile = tempname()
-
-if ExtraVim(msgfile)
-"   continue
-endif
-if MESSAGES('E586', ":continue without :while")
-    Xpath 1					" X: 1
-endif
-
-if ExtraVim(msgfile)
-"   if 1
-"       continue
-"   endif
-endif
-if MESSAGES('E586', ":continue without :while")
-    Xpath 2					" X: 2
-endif
-
-if ExtraVim(msgfile)
-"   try
-"   finally
-"       continue
-"   endtry
-endif
-if MESSAGES('E586', ":continue without :while")
-    Xpath 4					" X: 4
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       continue
-"   endtry
-endif
-if MESSAGES('E586', ":continue without :while")
-    Xpath 8					" X: 8
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       throw "a"
-"   catch /a/
-"       continue
-"   endtry
-endif
-if MESSAGES('E586', ":continue without :while")
-    Xpath 16					" X: 16
-endif
-
-if ExtraVim(msgfile)
-"   break
-endif
-if MESSAGES('E587', ":break without :while")
-    Xpath 32					" X: 32
-endif
-
-if ExtraVim(msgfile)
-"   if 1
-"       break
-"   endif
-endif
-if MESSAGES('E587', ":break without :while")
-    Xpath 64					" X: 64
-endif
-
-if ExtraVim(msgfile)
-"   try
-"   finally
-"       break
-"   endtry
-endif
-if MESSAGES('E587', ":break without :while")
-    Xpath 128					" X: 128
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       break
-"   endtry
-endif
-if MESSAGES('E587', ":break without :while")
-    Xpath 256					" X: 256
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       throw "a"
-"   catch /a/
-"       break
-"   endtry
-endif
-if MESSAGES('E587', ":break without :while")
-    Xpath 512					" X: 512
-endif
-
-call delete(msgfile)
-unlet msgfile
-
-Xcheck 1023
-
-" Leave MESSAGES() for the next test.
-
-
-"-------------------------------------------------------------------------------
-" Test 56:  Nesting errors: :endtry					    {{{1
-"
-"	    For nesting errors of :try conditionals the correct error messages
-"	    should be given.
-"
-"	    This test reuses the function MESSAGES() from the previous test.
-"	    This functions checks the messages in g:msgfile.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-let msgfile = tempname()
-
-if ExtraVim(msgfile)
-"   endtry
-endif
-if MESSAGES('E602', ":endtry without :try")
-    Xpath 1					" X: 1
-endif
-
-if ExtraVim(msgfile)
-"   if 1
-"       endtry
-"   endif
-endif
-if MESSAGES('E602', ":endtry without :try")
-    Xpath 2					" X: 2
-endif
-
-if ExtraVim(msgfile)
-"   while 1
-"       endtry
-"   endwhile
-endif
-if MESSAGES('E602', ":endtry without :try")
-    Xpath 4					" X: 4
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       if 1
-"   endtry
-endif
-if MESSAGES('E171', "Missing :endif")
-    Xpath 8					" X: 8
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       while 1
-"   endtry
-endif
-if MESSAGES('E170', "Missing :endwhile")
-    Xpath 16					" X: 16
-endif
-
-if ExtraVim(msgfile)
-"   try
-"   finally
-"       if 1
-"   endtry
-endif
-if MESSAGES('E171', "Missing :endif")
-    Xpath 32					" X: 32
-endif
-
-if ExtraVim(msgfile)
-"   try
-"   finally
-"       while 1
-"   endtry
-endif
-if MESSAGES('E170', "Missing :endwhile")
-    Xpath 64					" X: 64
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       throw "a"
-"   catch /a/
-"       if 1
-"   endtry
-endif
-if MESSAGES('E171', "Missing :endif")
-    Xpath 128					" X: 128
-endif
-
-if ExtraVim(msgfile)
-"   try
-"       throw "a"
-"   catch /a/
-"       while 1
-"   endtry
-endif
-if MESSAGES('E170', "Missing :endwhile")
-    Xpath 256					" X: 256
-endif
-
-call delete(msgfile)
-unlet msgfile
-
-delfunction MESSAGES
-
-Xcheck 511
-
-
-"-------------------------------------------------------------------------------
-" Test 57:  v:exception and v:throwpoint for user exceptions		    {{{1
-"
-"	    v:exception evaluates to the value of the exception that was caught
-"	    most recently and is not finished.  (A caught exception is finished
-"	    when the next ":catch", ":finally", or ":endtry" is reached.)
-"	    v:throwpoint evaluates to the script/function name and line number
-"	    where that exception has been thrown.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-function! FuncException()
-    let g:exception = v:exception
-endfunction
-
-function! FuncThrowpoint()
-    let g:throwpoint = v:throwpoint
-endfunction
-
-let scriptException  = MakeScript("FuncException")
-let scriptThrowPoint = MakeScript("FuncThrowpoint")
-
-command! CmdException  let g:exception  = v:exception
-command! CmdThrowpoint let g:throwpoint = v:throwpoint
-
-XloopINIT! 1 2
-
-function! CHECK(n, exception, throwname, throwline)
-    XloopNEXT
-    let error = 0
-    if v:exception != a:exception
-	Xout a:n.": v:exception is" v:exception "instead of" a:exception
-	let error = 1
-    endif
-    if v:throwpoint !~ a:throwname
-	let name = escape(a:throwname, '\')
-	Xout a:n.": v:throwpoint (".v:throwpoint.") does not match" name
-	let error = 1
-    endif
-    if v:throwpoint !~ a:throwline
-	let line = escape(a:throwline, '\')
-	Xout a:n.": v:throwpoint (".v:throwpoint.") does not match" line
-	let error = 1
-    endif
-    if error
-	Xloop 1					" X: 0
-    endif
-endfunction
-
-function! T(arg, line)
-    if a:line == 2
-	throw a:arg		" in line 2
-    elseif a:line == 4
-	throw a:arg		" in line 4
-    elseif a:line == 6
-	throw a:arg		" in line 6
-    elseif a:line == 8
-	throw a:arg		" in line 8
-    endif
-endfunction
-
-function! G(arg, line)
-    call T(a:arg, a:line)
-endfunction
-
-function! F(arg, line)
-    call G(a:arg, a:line)
-endfunction
-
-let scriptT = MakeScript("T")
-let scriptG = MakeScript("G", scriptT)
-let scriptF = MakeScript("F", scriptG)
-
-try
-    Xpath 32768					" X: 32768
-    call F("oops", 2)
-catch /.*/
-    Xpath 65536					" X: 65536
-    let exception  = v:exception
-    let throwpoint = v:throwpoint
-    call CHECK(1, "oops", '\<F\[1]\.\.G\[1]\.\.T\>', '\<2\>')
-    exec "let exception  = v:exception"
-    exec "let throwpoint = v:throwpoint"
-    call CHECK(2, "oops", '\<F\[1]\.\.G\[1]\.\.T\>', '\<2\>')
-    CmdException
-    CmdThrowpoint
-    call CHECK(3, "oops", '\<F\[1]\.\.G\[1]\.\.T\>', '\<2\>')
-    call FuncException()
-    call FuncThrowpoint()
-    call CHECK(4, "oops", '\<F\[1]\.\.G\[1]\.\.T\>', '\<2\>')
-    exec "source" scriptException
-    exec "source" scriptThrowPoint
-    call CHECK(5, "oops", '\<F\[1]\.\.G\[1]\.\.T\>', '\<2\>')
-    try
-	Xpath 131072				" X: 131072
-	call G("arrgh", 4)
-    catch /.*/
-	Xpath 262144				" X: 262144
-	let exception  = v:exception
-	let throwpoint = v:throwpoint
-	call CHECK(6, "arrgh", '\<G\[1]\.\.T\>', '\<4\>')
-	try
-	    Xpath 524288			" X: 524288
-	    let g:arg = "autsch"
-	    let g:line = 6
-	    exec "source" scriptF
-	catch /.*/
-	    Xpath 1048576			" X: 1048576
-	    let exception  = v:exception
-	    let throwpoint = v:throwpoint
-	    " Symbolic links in tempname()s are not resolved, whereas resolving
-	    " is done for v:throwpoint.  Resolve the temporary file name for
-	    " scriptT, so that it can be matched against v:throwpoint.
-	    call CHECK(7, "autsch", resolve(scriptT), '\<6\>')
-	finally
-	    Xpath 2097152			" X: 2097152
-	    let exception  = v:exception
-	    let throwpoint = v:throwpoint
-	    call CHECK(8, "arrgh", '\<G\[1]\.\.T\>', '\<4\>')
-	    try
-		Xpath 4194304			" X: 4194304
-		let g:arg = "brrrr"
-		let g:line = 8
-		exec "source" scriptG
-	    catch /.*/
-		Xpath 8388608			" X: 8388608
-		let exception  = v:exception
-		let throwpoint = v:throwpoint
-		" Resolve scriptT for matching it against v:throwpoint.
-		call CHECK(9, "brrrr", resolve(scriptT), '\<8\>')
-	    finally
-		Xpath 16777216			" X: 16777216
-		let exception  = v:exception
-		let throwpoint = v:throwpoint
-		call CHECK(10, "arrgh", '\<G\[1]\.\.T\>', '\<4\>')
-	    endtry
-	    Xpath 33554432			" X: 33554432
-	    let exception  = v:exception
-	    let throwpoint = v:throwpoint
-	    call CHECK(11, "arrgh", '\<G\[1]\.\.T\>', '\<4\>')
-	endtry
-	Xpath 67108864				" X: 67108864
-	let exception  = v:exception
-	let throwpoint = v:throwpoint
-	call CHECK(12, "arrgh", '\<G\[1]\.\.T\>', '\<4\>')
-    finally
-	Xpath 134217728				" X: 134217728
-	let exception  = v:exception
-	let throwpoint = v:throwpoint
-	call CHECK(13, "oops", '\<F\[1]\.\.G\[1]\.\.T\>', '\<2\>')
-    endtry
-    Xpath 268435456				" X: 268435456
-    let exception  = v:exception
-    let throwpoint = v:throwpoint
-    call CHECK(14, "oops", '\<F\[1]\.\.G\[1]\.\.T\>', '\<2\>')
-finally
-    Xpath 536870912				" X: 536870912
-    let exception  = v:exception
-    let throwpoint = v:throwpoint
-    call CHECK(15, "", '^$', '^$')
-endtry
-
-Xpath 1073741824				" X: 1073741824
-
-unlet exception throwpoint
-delfunction FuncException
-delfunction FuncThrowpoint
-call delete(scriptException)
-call delete(scriptThrowPoint)
-unlet scriptException scriptThrowPoint
-delcommand CmdException
-delcommand CmdThrowpoint
-delfunction T
-delfunction G
-delfunction F
-call delete(scriptT)
-call delete(scriptG)
-call delete(scriptF)
-unlet scriptT scriptG scriptF
-
-Xcheck 2147450880
-
-
-"-------------------------------------------------------------------------------
-"
-" Test 58:  v:exception and v:throwpoint for error/interrupt exceptions	    {{{1
-"
-"	    v:exception and v:throwpoint work also for error and interrupt
-"	    exceptions.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-if ExtraVim()
-
-    function! T(line)
-	if a:line == 2
-	    delfunction T		" error (function in use) in line 2
-	elseif a:line == 4
-	    let dummy = 0		" INTERRUPT1 - interrupt in line 4
-	endif
-    endfunction
-
-    while 1
-	try
-	    Xpath 1				" X: 1
-	    let caught = 0
-	    call T(2)
-	catch /.*/
-	    let caught = 1
-	    if v:exception !~ 'Vim(delfunction):'
-		Xpath 2				" X: 0
-	    endif
-	    if v:throwpoint !~ '\<T\>'
-		Xpath 4				" X: 0
-	    endif
-	    if v:throwpoint !~ '\<2\>'
-		Xpath 8				" X: 0
-	    endif
-	finally
-	    Xpath 16				" X: 16
-	    if caught || $VIMNOERRTHROW
-		Xpath 32			" X: 32
-	    endif
-	    if v:exception != ""
-		Xpath 64			" X: 0
-	    endif
-	    if v:throwpoint != ""
-		Xpath 128			" X: 0
-	    endif
-	    break		" discard error for $VIMNOERRTHROW
-	endtry
-    endwhile
-
-    Xpath 256					" X: 256
-    if v:exception != ""
-	Xpath 512				" X: 0
-    endif
-    if v:throwpoint != ""
-	Xpath 1024				" X: 0
-    endif
-
-    while 1
-	try
-	    Xpath 2048				" X: 2048
-	    let caught = 0
-	    call T(4)
-	catch /.*/
-	    let caught = 1
-	    if v:exception != 'Vim:Interrupt'
-		Xpath 4096			" X: 0
-	    endif
-	    if v:throwpoint !~ '\<T\>'
-		Xpath 8192			" X: 0
-	    endif
-	    if v:throwpoint !~ '\<4\>'
-		Xpath 16384			" X: 0
-	    endif
-	finally
-	    Xpath 32768				" X: 32768
-	    if caught || $VIMNOINTTHROW
-		Xpath 65536			" X: 65536
-	    endif
-	    if v:exception != ""
-		Xpath 131072			" X: 0
-	    endif
-	    if v:throwpoint != ""
-		Xpath 262144			" X: 0
-	    endif
-	    break		" discard error for $VIMNOERRTHROW
-	endtry
-    endwhile
-
-    Xpath 524288				" X: 524288
-    if v:exception != ""
-	Xpath 1048576				" X: 0
-    endif
-    if v:throwpoint != ""
-	Xpath 2097152				" X: 0
-    endif
-
-endif
-
-Xcheck 624945
-
+" Tests 1 to 50, 52 to 57, 87 were moved to test_vimscript.vim
+" Tests 25, 26, 32, 33, 41-48, 51, 69-75 were moved to test_trycatch.vim
+let Xtest = 59
 
 "-------------------------------------------------------------------------------
 "
@@ -2067,142 +1121,8 @@
 
 Xcheck 311511339
 
-
-"-------------------------------------------------------------------------------
-" Test 61:  Catching interrupt exceptions				    {{{1
-"
-"	    When an interrupt occurs inside a :try/:endtry region, an
-"	    interrupt exception is thrown and can be caught.  Its value is
-"	    "Vim:Interrupt".  If the interrupt occurs after an error or a :throw
-"	    but before a matching :catch is reached, all following :catches of
-"	    that try block are ignored, but the interrupt exception can be
-"	    caught by the next surrounding try conditional.  An interrupt is
-"	    ignored when there is a previous interrupt that has not been caught
-"	    or causes a :finally clause to be executed.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-if ExtraVim()
-
-    while 1
-	try
-	    try
-		Xpath 1				" X: 1
-		let caught = 0
-		"INTERRUPT
-		Xpath 2				" X: 0
-	    catch /^Vim:Interrupt$/
-		let caught = 1
-	    finally
-		Xpath 4				" X: 4
-		if caught || $VIMNOINTTHROW
-		    Xpath 8			" X: 8
-		endif
-	    endtry
-	catch /.*/
-	    Xpath 16				" X: 0
-	    Xout v:exception "in" v:throwpoint
-	finally
-	    break		" discard interrupt for $VIMNOINTTHROW
-	endtry
-    endwhile
-
-    while 1
-	try
-	    try
-		let caught = 0
-		try
-		    Xpath 32			" X: 32
-		    asdf
-		    Xpath 64			" X: 0
-		catch /do_not_catch/
-		    Xpath 128			" X: 0
-		catch /.*/	"INTERRUPT - throw interrupt if !$VIMNOERRTHROW
-		    Xpath 256			" X: 0
-		catch /.*/
-		    Xpath 512			" X: 0
-		finally		"INTERRUPT - throw interrupt if $VIMNOERRTHROW
-		    Xpath 1024			" X: 1024
-		endtry
-	    catch /^Vim:Interrupt$/
-		let caught = 1
-	    finally
-		Xpath 2048			" X: 2048
-		if caught || $VIMNOINTTHROW
-		    Xpath 4096			" X: 4096
-		endif
-	    endtry
-	catch /.*/
-	    Xpath 8192				" X: 0
-	    Xout v:exception "in" v:throwpoint
-	finally
-	    break		" discard interrupt for $VIMNOINTTHROW
-	endtry
-    endwhile
-
-    while 1
-	try
-	    try
-		let caught = 0
-		try
-		    Xpath 16384			" X: 16384
-		    throw "x"
-		    Xpath 32768			" X: 0
-		catch /do_not_catch/
-		    Xpath 65536			" X: 0
-		catch /x/	"INTERRUPT
-		    Xpath 131072		" X: 0
-		catch /.*/
-		    Xpath 262144		" X: 0
-		endtry
-	    catch /^Vim:Interrupt$/
-		let caught = 1
-	    finally
-		Xpath 524288			" X: 524288
-		if caught || $VIMNOINTTHROW
-		    Xpath 1048576		" X: 1048576
-		endif
-	    endtry
-	catch /.*/
-	    Xpath 2097152			" X: 0
-	    Xout v:exception "in" v:throwpoint
-	finally
-	    break		" discard interrupt for $VIMNOINTTHROW
-	endtry
-    endwhile
-
-    while 1
-	try
-	    let caught = 0
-	    try
-		Xpath 4194304			" X: 4194304
-		"INTERRUPT
-		Xpath 8388608			" X: 0
-	    catch /do_not_catch/ "INTERRUPT
-		Xpath 16777216			" X: 0
-	    catch /^Vim:Interrupt$/
-		let caught = 1
-	    finally
-		Xpath 33554432			" X: 33554432
-		if caught || $VIMNOINTTHROW
-		    Xpath 67108864		" X: 67108864
-		endif
-	    endtry
-	catch /.*/
-	    Xpath 134217728			" X: 0
-	    Xout v:exception "in" v:throwpoint
-	finally
-	    break		" discard interrupt for $VIMNOINTTHROW
-	endtry
-    endwhile
-
-    Xpath 268435456				" X: 268435456
-
-endif
-
-Xcheck 374889517
-
+" Test 61 was moved to test_vimscript.vim
+let Xtest = 62
 
 "-------------------------------------------------------------------------------
 " Test 62:  Catching error exceptions					    {{{1
@@ -2725,100 +1645,8 @@
 
 Xcheck 1499645335
 
-
-"-------------------------------------------------------------------------------
-" Test 65:  Errors in the /pattern/ argument of a :catch		    {{{1
-"
-"	    On an error in the /pattern/ argument of a :catch, the :catch does
-"	    not match.  Any following :catches of the same :try/:endtry don't
-"	    match either.  Finally clauses are executed.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-function! MSG(enr, emsg)
-    let english = v:lang == "C" || v:lang =~ '^[Ee]n'
-    if a:enr == ""
-	Xout "TODO: Add message number for:" a:emsg
-	let v:errmsg = ":" . v:errmsg
-    endif
-    let match = 1
-    if v:errmsg !~ '^'.a:enr.':' || (english && v:errmsg !~ a:emsg)
-	let match = 0
-	if v:errmsg == ""
-	    Xout "Message missing."
-	else
-	    let v:errmsg = escape(v:errmsg, '"')
-	    Xout "Unexpected message:" v:errmsg
-	endif
-    endif
-    return match
-endfunction
-
-try
-    try
-	Xpath 1					" X: 1
-	throw "oops"
-    catch /^oops$/
-	Xpath 2					" X: 2
-    catch /\)/		" not checked; exception has already been caught
-	Xpath 4					" X: 0
-    endtry
-    Xpath 8					" X: 8
-catch /.*/
-    Xpath 16					" X: 0
-    Xout v:exception "in" v:throwpoint
-endtry
-
-function! F()
-    try
-	let caught = 0
-	try
-	    try
-		Xpath 32			" X: 32
-		throw "ab"
-	    catch /abc/	" does not catch
-		Xpath 64			" X: 0
-	    catch /\)/	" error; discards exception
-		Xpath 128			" X: 0
-	    catch /.*/	" not checked
-		Xpath 256			" X: 0
-	    finally
-		Xpath 512			" X: 512
-	    endtry
-	    Xpath 1024				" X: 0
-	catch /^ab$/	" checked, but original exception is discarded
-	    Xpath 2048				" X: 0
-	catch /^Vim(catch):/
-	    let caught = 1
-	    let v:errmsg = substitute(v:exception, '^Vim(catch):', '', "")
-	finally
-	    Xpath 4096				" X: 4096
-	    if !caught && !$VIMNOERRTHROW
-		Xpath 8192			" X: 0
-	    endif
-	    if !MSG('E475', "Invalid argument")
-		Xpath 16384			" X: 0
-	    endif
-	    if !caught
-		return	| " discard error
-	    endif
-	endtry
-    catch /.*/
-	Xpath 32768				" X: 0
-	Xout v:exception "in" v:throwpoint
-    endtry
-endfunction
-
-call F()
-Xpath 65536					" X: 65536
-
-delfunction MSG
-delfunction F
-unlet! caught
-
-Xcheck 70187
-
+" Test 65 was moved to test_vimscript.vim
+let Xtest = 66
 
 "-------------------------------------------------------------------------------
 " Test 66:  Stop range :call on error, interrupt, or :throw		    {{{1
diff --git a/src/testdir/test_vimscript.vim b/src/testdir/test_vimscript.vim
index b752bc8..02cf2d1 100644
--- a/src/testdir/test_vimscript.vim
+++ b/src/testdir/test_vimscript.vim
@@ -2764,6 +2764,1153 @@
 endfunc
 
 "-------------------------------------------------------------------------------
+" Test 52:  Uncaught exceptions						    {{{1
+"
+"	    When an exception is thrown but not caught, an error message is
+"	    displayed when the script is terminated.  In case of an interrupt
+"	    or error exception, the normal interrupt or error message(s) are
+"	    displayed.
+"-------------------------------------------------------------------------------
+
+func Test_uncaught_exception_1()
+  CheckEnglish
+
+  let test =<< trim [CODE]
+    Xpath 'a'
+    throw "arrgh"
+    call assert_report('should not get here')`
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('E605: Exception not caught: arrgh', v:errmsg)
+    call assert_equal('a', g:Xpath)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+func Test_uncaught_exception_2()
+  CheckEnglish
+
+  let test =<< trim [CODE]
+    try
+      Xpath 'a'
+      throw "oops"
+      call assert_report('should not get here')`
+    catch /arrgh/
+      call assert_report('should not get here')`
+    endtry
+    call assert_report('should not get here')`
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('E605: Exception not caught: oops', v:errmsg)
+    call assert_equal('a', g:Xpath)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+func Test_uncaught_exception_3()
+  CheckEnglish
+
+  let test =<< trim [CODE]
+    func T()
+      Xpath 'c'
+      throw "brrr"
+      call assert_report('should not get here')`
+    endfunc
+
+    try
+      Xpath 'a'
+      throw "arrgh"
+      call assert_report('should not get here')`
+    catch /.*/
+      Xpath 'b'
+      call T()
+      call assert_report('should not get here')`
+    endtry
+    call assert_report('should not get here')`
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('E605: Exception not caught: brrr', v:errmsg)
+    call assert_equal('abc', g:Xpath)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+func Test_uncaught_exception_4()
+  CheckEnglish
+
+  let test =<< trim [CODE]
+    try
+      Xpath 'a'
+      throw "arrgh"
+      call assert_report('should not get here')`
+    finally
+      Xpath 'b'
+      throw "brrr"
+      call assert_report('should not get here')`
+    endtry
+    call assert_report('should not get here')`
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('E605: Exception not caught: brrr', v:errmsg)
+    call assert_equal('ab', g:Xpath)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+func Test_uncaught_exception_5()
+  CheckEnglish
+
+  " Need to catch and handle interrupt, otherwise the test will wait for the
+  " user to press <Enter> to continue
+  let test =<< trim [CODE]
+    try
+      try
+        Xpath 'a'
+        call interrupt()
+        call assert_report('should not get here')
+      endtry
+      call assert_report('should not get here')
+    catch /^Vim:Interrupt$/
+      Xpath 'b'
+    endtry
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('ab', g:Xpath)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+func Test_uncaught_exception_6()
+  CheckEnglish
+
+  let test =<< trim [CODE]
+    try
+      Xpath 'a'
+      let x = novar	" error E121; exception: E121
+    catch /E15:/	" should not catch
+      call assert_report('should not get here')
+    endtry
+    call assert_report('should not get here')
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('a', g:Xpath)
+    call assert_equal('E121: Undefined variable: novar', v:errmsg)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+func Test_uncaught_exception_7()
+  CheckEnglish
+
+  let test =<< trim [CODE]
+    try
+      Xpath 'a'
+      " error E108/E488; exception: E488
+      unlet novar #
+    catch /E108:/       " should not catch
+      call assert_report('should not get here')
+    endtry
+    call assert_report('should not get here')
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('a', g:Xpath)
+    call assert_equal('E488: Trailing characters: #', v:errmsg)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+"-------------------------------------------------------------------------------
+" Test 53:  Nesting errors: :endif/:else/:elseif			    {{{1
+"
+"	    For nesting errors of :if conditionals the correct error messages
+"	    should be given.
+"-------------------------------------------------------------------------------
+
+func Test_nested_if_else_errors()
+  CheckEnglish
+
+  " :endif without :if
+  let code =<< trim END
+    endif
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
+
+  " :endif without :if
+  let code =<< trim END
+    while 1
+      endif
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
+
+  " :endif without :if
+  let code =<< trim END
+    try
+    finally
+      endif
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
+
+  " :endif without :if
+  let code =<< trim END
+    try
+      endif
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
+
+  " :endif without :if
+  let code =<< trim END
+    try
+      throw "a"
+    catch /a/
+      endif
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
+
+  " :else without :if
+  let code =<< trim END
+    else
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
+
+  " :else without :if
+  let code =<< trim END
+    while 1
+      else
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
+
+  " :else without :if
+  let code =<< trim END
+    try
+    finally
+      else
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
+
+  " :else without :if
+  let code =<< trim END
+    try
+      else
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
+
+  " :else without :if
+  let code =<< trim END
+    try
+      throw "a"
+    catch /a/
+      else
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
+
+  " :elseif without :if
+  let code =<< trim END
+    elseif
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
+
+  " :elseif without :if
+  let code =<< trim END
+    while 1
+      elseif
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
+
+  " :elseif without :if
+  let code =<< trim END
+    try
+    finally
+      elseif
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
+
+  " :elseif without :if
+  let code =<< trim END
+    try
+      elseif
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
+
+  " :elseif without :if
+  let code =<< trim END
+    try
+      throw "a"
+    catch /a/
+      elseif
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
+
+  " multiple :else
+  let code =<< trim END
+    if 1
+    else
+    else
+    endif
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(else):E583: multiple :else')
+
+  " :elseif after :else
+  let code =<< trim END
+    if 1
+    else
+    elseif 1
+    endif
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(elseif):E584: :elseif after :else')
+
+  call delete('Xtest')
+endfunc
+
+"-------------------------------------------------------------------------------
+" Test 54:  Nesting errors: :while/:endwhile				    {{{1
+"
+"	    For nesting errors of :while conditionals the correct error messages
+"	    should be given.
+"
+"	    This test reuses the function MESSAGES() from the previous test.
+"	    This functions checks the messages in g:msgfile.
+"-------------------------------------------------------------------------------
+
+func Test_nested_while_error()
+  CheckEnglish
+
+  " :endwhile without :while
+  let code =<< trim END
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
+
+  " :endwhile without :while
+  let code =<< trim END
+    if 1
+      endwhile
+    endif
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
+
+  " Missing :endif
+  let code =<< trim END
+    while 1
+      if 1
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E171: Missing :endif')
+
+  " :endwhile without :while
+  let code =<< trim END
+    try
+    finally
+      endwhile
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
+
+  " Missing :endtry
+  let code =<< trim END
+    while 1
+      try
+      finally
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E600: Missing :endtry')
+
+  " Missing :endtry
+  let code =<< trim END
+    while 1
+      if 1
+        try
+        finally
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E600: Missing :endtry')
+
+  " Missing :endif
+  let code =<< trim END
+    while 1
+      try
+      finally
+        if 1
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E171: Missing :endif')
+
+  " :endwhile without :while
+  let code =<< trim END
+    try
+      endwhile
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
+
+  " :endwhile without :while
+  let code =<< trim END
+    while 1
+      try
+        endwhile
+      endtry
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
+
+  " :endwhile without :while
+  let code =<< trim END
+    try
+      throw "a"
+    catch /a/
+      endwhile
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
+
+  " :endwhile without :while
+  let code =<< trim END
+    while 1
+      try
+        throw "a"
+      catch /a/
+        endwhile
+      endtry
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
+
+  call delete('Xtest')
+endfunc
+
+"-------------------------------------------------------------------------------
+" Test 55:  Nesting errors: :continue/:break				    {{{1
+"
+"	    For nesting errors of :continue and :break commands the correct
+"	    error messages should be given.
+"
+"	    This test reuses the function MESSAGES() from the previous test.
+"	    This functions checks the messages in g:msgfile.
+"-------------------------------------------------------------------------------
+
+func Test_nested_cont_break_error()
+  CheckEnglish
+
+  " :continue without :while
+  let code =<< trim END
+    continue
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
+
+  " :continue without :while
+  let code =<< trim END
+    if 1
+      continue
+    endif
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
+
+  " :continue without :while
+  let code =<< trim END
+    try
+    finally
+      continue
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
+
+  " :continue without :while
+  let code =<< trim END
+    try
+      continue
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
+
+  " :continue without :while
+  let code =<< trim END
+    try
+      throw "a"
+    catch /a/
+      continue
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
+
+  " :break without :while
+  let code =<< trim END
+    break
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
+
+  " :break without :while
+  let code =<< trim END
+    if 1
+      break
+    endif
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
+
+  " :break without :while
+  let code =<< trim END
+    try
+    finally
+      break
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
+
+  " :break without :while
+  let code =<< trim END
+    try
+      break
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
+
+  " :break without :while
+  let code =<< trim END
+    try
+      throw "a"
+    catch /a/
+      break
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
+
+  call delete('Xtest')
+endfunc
+
+"-------------------------------------------------------------------------------
+" Test 56:  Nesting errors: :endtry					    {{{1
+"
+"	    For nesting errors of :try conditionals the correct error messages
+"	    should be given.
+"
+"	    This test reuses the function MESSAGES() from the previous test.
+"	    This functions checks the messages in g:msgfile.
+"-------------------------------------------------------------------------------
+
+func Test_nested_endtry_error()
+  CheckEnglish
+
+  " :endtry without :try
+  let code =<< trim END
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E602: :endtry without :try')
+
+  " :endtry without :try
+  let code =<< trim END
+    if 1
+      endtry
+    endif
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E602: :endtry without :try')
+
+  " :endtry without :try
+  let code =<< trim END
+    while 1
+      endtry
+    endwhile
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E602: :endtry without :try')
+
+  " Missing :endif
+  let code =<< trim END
+    try
+        if 1
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E171: Missing :endif')
+
+  " Missing :endwhile
+  let code =<< trim END
+    try
+      while 1
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E170: Missing :endwhile')
+
+  " Missing :endif
+  let code =<< trim END
+    try
+    finally
+      if 1
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E171: Missing :endif')
+
+  " Missing :endwhile
+  let code =<< trim END
+    try
+    finally
+      while 1
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E170: Missing :endwhile')
+
+  " Missing :endif
+  let code =<< trim END
+    try
+      throw "a"
+    catch /a/
+      if 1
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E171: Missing :endif')
+
+  " Missing :endwhile
+  let code =<< trim END
+    try
+      throw "a"
+    catch /a/
+      while 1
+    endtry
+  END
+  call writefile(code, 'Xtest')
+  call AssertException(['source Xtest'], 'Vim(endtry):E170: Missing :endwhile')
+
+  call delete('Xtest')
+endfunc
+
+"-------------------------------------------------------------------------------
+" Test 57:  v:exception and v:throwpoint for user exceptions		    {{{1
+"
+"	    v:exception evaluates to the value of the exception that was caught
+"	    most recently and is not finished.  (A caught exception is finished
+"	    when the next ":catch", ":finally", or ":endtry" is reached.)
+"	    v:throwpoint evaluates to the script/function name and line number
+"	    where that exception has been thrown.
+"-------------------------------------------------------------------------------
+
+func Test_user_exception_info()
+  CheckEnglish
+
+  XpathINIT
+  XloopINIT
+
+  func FuncException()
+    let g:exception = v:exception
+  endfunc
+
+  func FuncThrowpoint()
+    let g:throwpoint = v:throwpoint
+  endfunc
+
+  let scriptException  = MakeScript("FuncException")
+  let scriptThrowPoint = MakeScript("FuncThrowpoint")
+
+  command! CmdException  let g:exception  = v:exception
+  command! CmdThrowpoint let g:throwpoint = v:throwpoint
+
+  func T(arg, line)
+    if a:line == 2
+      throw a:arg		" in line 2
+    elseif a:line == 4
+      throw a:arg		" in line 4
+    elseif a:line == 6
+      throw a:arg		" in line 6
+    elseif a:line == 8
+      throw a:arg		" in line 8
+    endif
+  endfunc
+
+  func G(arg, line)
+    call T(a:arg, a:line)
+  endfunc
+
+  func F(arg, line)
+    call G(a:arg, a:line)
+  endfunc
+
+  let scriptT = MakeScript("T")
+  let scriptG = MakeScript("G", scriptT)
+  let scriptF = MakeScript("F", scriptG)
+
+  try
+    Xpath 'a'
+    call F("oops", 2)
+  catch /.*/
+    Xpath 'b'
+    let exception  = v:exception
+    let throwpoint = v:throwpoint
+    call assert_equal("oops", v:exception)
+    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
+    call assert_match('\<2\>', v:throwpoint)
+
+    exec "let exception  = v:exception"
+    exec "let throwpoint = v:throwpoint"
+    call assert_equal("oops", v:exception)
+    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
+    call assert_match('\<2\>', v:throwpoint)
+
+    CmdException
+    CmdThrowpoint
+    call assert_equal("oops", v:exception)
+    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
+    call assert_match('\<2\>', v:throwpoint)
+
+    call FuncException()
+    call FuncThrowpoint()
+    call assert_equal("oops", v:exception)
+    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
+    call assert_match('\<2\>', v:throwpoint)
+
+    exec "source" scriptException
+    exec "source" scriptThrowPoint
+    call assert_equal("oops", v:exception)
+    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
+    call assert_match('\<2\>', v:throwpoint)
+
+    try
+      Xpath 'c'
+      call G("arrgh", 4)
+    catch /.*/
+      Xpath 'd'
+      let exception  = v:exception
+      let throwpoint = v:throwpoint
+      call assert_equal("arrgh", v:exception)
+      call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
+      call assert_match('\<4\>', v:throwpoint)
+
+      try
+        Xpath 'e'
+        let g:arg = "autsch"
+        let g:line = 6
+        exec "source" scriptF
+      catch /.*/
+        Xpath 'f'
+        let exception  = v:exception
+        let throwpoint = v:throwpoint
+        call assert_equal("autsch", v:exception)
+        call assert_match(fnamemodify(scriptT, ':t'), v:throwpoint)
+        call assert_match('\<6\>', v:throwpoint)
+      finally
+        Xpath 'g'
+        let exception  = v:exception
+        let throwpoint = v:throwpoint
+        call assert_equal("arrgh", v:exception)
+        call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
+        call assert_match('\<4\>', v:throwpoint)
+        try
+          Xpath 'h'
+          let g:arg = "brrrr"
+          let g:line = 8
+          exec "source" scriptG
+        catch /.*/
+          Xpath 'i'
+          let exception  = v:exception
+          let throwpoint = v:throwpoint
+          " Resolve scriptT for matching it against v:throwpoint.
+          call assert_equal("brrrr", v:exception)
+          call assert_match(fnamemodify(scriptT, ':t'), v:throwpoint)
+          call assert_match('\<8\>', v:throwpoint)
+        finally
+          Xpath 'j'
+          let exception  = v:exception
+          let throwpoint = v:throwpoint
+          call assert_equal("arrgh", v:exception)
+          call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
+          call assert_match('\<4\>', v:throwpoint)
+        endtry
+        Xpath 'k'
+        let exception  = v:exception
+        let throwpoint = v:throwpoint
+        call assert_equal("arrgh", v:exception)
+        call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
+        call assert_match('\<4\>', v:throwpoint)
+      endtry
+      Xpath 'l'
+      let exception  = v:exception
+      let throwpoint = v:throwpoint
+      call assert_equal("arrgh", v:exception)
+      call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
+      call assert_match('\<4\>', v:throwpoint)
+    finally
+      Xpath 'm'
+      let exception  = v:exception
+      let throwpoint = v:throwpoint
+      call assert_equal("oops", v:exception)
+      call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
+      call assert_match('\<2\>', v:throwpoint)
+    endtry
+    Xpath 'n'
+    let exception  = v:exception
+    let throwpoint = v:throwpoint
+    call assert_equal("oops", v:exception)
+    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
+    call assert_match('\<2\>', v:throwpoint)
+  finally
+    Xpath 'o'
+    let exception  = v:exception
+    let throwpoint = v:throwpoint
+    call assert_equal("", v:exception)
+    call assert_match('^$', v:throwpoint)
+    call assert_match('^$', v:throwpoint)
+  endtry
+
+  call assert_equal('abcdefghijklmno', g:Xpath)
+
+  unlet exception throwpoint
+  delfunction FuncException
+  delfunction FuncThrowpoint
+  call delete(scriptException)
+  call delete(scriptThrowPoint)
+  unlet scriptException scriptThrowPoint
+  delcommand CmdException
+  delcommand CmdThrowpoint
+  delfunction T
+  delfunction G
+  delfunction F
+  call delete(scriptT)
+  call delete(scriptG)
+  call delete(scriptF)
+  unlet scriptT scriptG scriptF
+endfunc
+
+"-------------------------------------------------------------------------------
+"
+" Test 58:  v:exception and v:throwpoint for error/interrupt exceptions	    {{{1
+"
+"	    v:exception and v:throwpoint work also for error and interrupt
+"	    exceptions.
+"-------------------------------------------------------------------------------
+
+func Test_execption_info_for_error()
+  CheckEnglish
+
+  let test =<< trim [CODE]
+    func T(line)
+      if a:line == 2
+        delfunction T		" error (function in use) in line 2
+      elseif a:line == 4
+        call interrupt()
+      endif
+    endfunc
+
+    while 1
+      try
+        Xpath 'a'
+        call T(2)
+        call assert_report('should not get here')
+      catch /.*/
+        Xpath 'b'
+        if v:exception !~ 'Vim(delfunction):'
+          call assert_report('should not get here')
+        endif
+        if v:throwpoint !~ '\<T\>'
+          call assert_report('should not get here')
+        endif
+        if v:throwpoint !~ '\<2\>'
+          call assert_report('should not get here')
+        endif
+      finally
+        Xpath 'c'
+        if v:exception != ""
+          call assert_report('should not get here')
+        endif
+        if v:throwpoint != ""
+          call assert_report('should not get here')
+        endif
+        break
+      endtry
+    endwhile
+
+    Xpath 'd'
+    if v:exception != ""
+      call assert_report('should not get here')
+    endif
+    if v:throwpoint != ""
+      call assert_report('should not get here')
+    endif
+
+    while 1
+      try
+        Xpath 'e'
+        call T(4)
+        call assert_report('should not get here')
+      catch /.*/
+        Xpath 'f'
+        if v:exception != 'Vim:Interrupt'
+          call assert_report('should not get here')
+        endif
+        if v:throwpoint !~ 'function T'
+          call assert_report('should not get here')
+        endif
+        if v:throwpoint !~ '\<4\>'
+          call assert_report('should not get here')
+        endif
+      finally
+        Xpath 'g'
+        if v:exception != ""
+          call assert_report('should not get here')
+        endif
+        if v:throwpoint != ""
+          call assert_report('should not get here')
+        endif
+        break
+      endtry
+    endwhile
+
+    Xpath 'h'
+    if v:exception != ""
+      call assert_report('should not get here')
+    endif
+    if v:throwpoint != ""
+      call assert_report('should not get here')
+    endif
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('abcdefgh', g:Xpath)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+"-------------------------------------------------------------------------------
+" Test 61:  Catching interrupt exceptions				    {{{1
+"
+"	    When an interrupt occurs inside a :try/:endtry region, an
+"	    interrupt exception is thrown and can be caught.  Its value is
+"	    "Vim:Interrupt".  If the interrupt occurs after an error or a :throw
+"	    but before a matching :catch is reached, all following :catches of
+"	    that try block are ignored, but the interrupt exception can be
+"	    caught by the next surrounding try conditional.  An interrupt is
+"	    ignored when there is a previous interrupt that has not been caught
+"	    or causes a :finally clause to be executed.
+"-------------------------------------------------------------------------------
+
+func Test_catch_intr_exception()
+  let test =<< trim [CODE]
+    while 1
+      try
+        try
+          Xpath 'a'
+          call interrupt()
+          call assert_report('should not get here')
+        catch /^Vim:Interrupt$/
+          Xpath 'b'
+        finally
+          Xpath 'c'
+        endtry
+      catch /.*/
+        call assert_report('should not get here')
+      finally
+        Xpath 'd'
+        break
+      endtry
+    endwhile
+
+    while 1
+      try
+        try
+          try
+            Xpath 'e'
+            asdf
+            call assert_report('should not get here')
+          catch /do_not_catch/
+            call assert_report('should not get here')
+          catch /.*/
+            Xpath 'f'
+            call interrupt()
+            call assert_report('should not get here')
+          catch /.*/
+            call assert_report('should not get here')
+          finally
+            Xpath 'g'
+            call interrupt()
+            call assert_report('should not get here')
+          endtry
+        catch /^Vim:Interrupt$/
+          Xpath 'h'
+        finally
+          Xpath 'i'
+        endtry
+      catch /.*/
+        call assert_report('should not get here')
+      finally
+        Xpath 'j'
+        break
+      endtry
+    endwhile
+
+    while 1
+      try
+        try
+          try
+            Xpath 'k'
+            throw "x"
+            call assert_report('should not get here')
+          catch /do_not_catch/
+            call assert_report('should not get here')
+          catch /x/
+            Xpath 'l'
+            call interrupt()
+            call assert_report('should not get here')
+          catch /.*/
+            call assert_report('should not get here')
+          endtry
+        catch /^Vim:Interrupt$/
+          Xpath 'm'
+        finally
+          Xpath 'n'
+        endtry
+      catch /.*/
+        call assert_report('should not get here')
+      finally
+        Xpath 'o'
+        break
+      endtry
+    endwhile
+
+    while 1
+      try
+        try
+          Xpath 'p'
+          call interrupt()
+          call assert_report('should not get here')
+        catch /do_not_catch/
+          call interrupt()
+          call assert_report('should not get here')
+        catch /^Vim:Interrupt$/
+          Xpath 'q'
+        finally
+          Xpath 'r'
+        endtry
+      catch /.*/
+        call assert_report('should not get here')
+      finally
+        Xpath 's'
+        break
+      endtry
+    endwhile
+
+    Xpath 't'
+  [CODE]
+  let verify =<< trim [CODE]
+    call assert_equal('abcdefghijklmnopqrst', g:Xpath)
+  [CODE]
+  call RunInNewVim(test, verify)
+endfunc
+
+"-------------------------------------------------------------------------------
+" Test 65:  Errors in the /pattern/ argument of a :catch		    {{{1
+"
+"	    On an error in the /pattern/ argument of a :catch, the :catch does
+"	    not match.  Any following :catches of the same :try/:endtry don't
+"	    match either.  Finally clauses are executed.
+"-------------------------------------------------------------------------------
+
+func Test_catch_pattern_error()
+  CheckEnglish
+  XpathINIT
+
+  try
+    try
+      Xpath 'a'
+      throw "oops"
+    catch /^oops$/
+      Xpath 'b'
+    catch /\)/		" not checked; exception has already been caught
+      call assert_report('should not get here')
+    endtry
+    Xpath 'c'
+  catch /.*/
+    call assert_report('should not get here')
+  endtry
+  call assert_equal('abc', g:Xpath)
+
+  XpathINIT
+  func F()
+    try
+      try
+        try
+          Xpath 'a'
+          throw "ab"
+        catch /abc/	" does not catch
+          call assert_report('should not get here')
+        catch /\)/	" error; discards exception
+          call assert_report('should not get here')
+        catch /.*/	" not checked
+          call assert_report('should not get here')
+        finally
+          Xpath 'b'
+        endtry
+        call assert_report('should not get here')
+      catch /^ab$/	" checked, but original exception is discarded
+        call assert_report('should not get here')
+      catch /^Vim(catch):/
+        Xpath 'c'
+        call assert_match('Vim(catch):E475: Invalid argument:', v:exception)
+      finally
+        Xpath 'd'
+      endtry
+      Xpath 'e'
+    catch /.*/
+      call assert_report('should not get here')
+    endtry
+    Xpath 'f'
+  endfunc
+
+  call F()
+  call assert_equal('abcdef', g:Xpath)
+
+  delfunc F
+endfunc
+
+"-------------------------------------------------------------------------------
 " Test 87   using (expr) ? funcref : funcref				    {{{1
 "
 "	    Vim needs to correctly parse the funcref and even when it does
diff --git a/src/version.c b/src/version.c
index 5c745df..e6b8a89 100644
--- a/src/version.c
+++ b/src/version.c
@@ -755,6 +755,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    1383,
+/**/
     1382,
 /**/
     1381,