IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #4565 from KillTheMule/vim-patch-1282

Browse Source 
vim-patch:7.4.{1000, 1001, 1030, 1282, 1284}
This commit is contained in:
Justin M. Keyes 2016-04-17 19:19:06 -04:00
commit 83c683f5e1
7 changed files with 1020 additions and 881 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/nvim/ex_eval.c
View File

@ -1370,19 +1370,24 @@ void ex_catch(exarg_T *eap)
}
save_cpo = p_cpo;
p_cpo = (char_u *)"";
// Disable error messages, it will make current exception
// invalid
emsg_off++;
regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
regmatch.rm_ic = FALSE;
if (end != NULL)
emsg_off--;
regmatch.rm_ic = false;
if (end != NULL) {
*end = save_char;
}
p_cpo = save_cpo;
if (regmatch.regprog == NULL)
if (regmatch.regprog == NULL) {
EMSG2(_(e_invarg2), pat);
else {
/*
* Save the value of got_int and reset it. We don't want
* a previous interruption cancel matching, only hitting
* CTRL-C while matching should abort it.
*/
} else {
//
// Save the value of got_int and reset it. We don't want
// a previous interruption cancel matching, only hitting
// CTRL-C while matching should abort it.
//
prev_got_int = got_int;
got_int = FALSE;
caught = vim_regexec_nl(&regmatch, current_exception->value,

2
src/nvim/testdir/Makefile
View File

@ -38,7 +38,7 @@ SCRIPTS := \
test_marks.out \
test_match_conceal.out \
NEW_TESTS =
NEW_TESTS = test_viml.res
SCRIPTS_GUI := test16.out

20
src/nvim/testdir/runtest.vim
View File

@ -33,6 +33,15 @@ if &lines < 24 || &columns < 80
cquit
endif
" This also enables use of line continuation.
set viminfo+=nviminfo
" Avoid stopping at the "hit enter" prompt
set nomore
" Output all messages in English.
lang mess C
" Source the test script. First grab the file name, in case the script
" navigates away.
let testname = expand('%')
@ -40,12 +49,17 @@ let done = 0
let fail = 0
let errors = []
let messages = []
try
if expand('%') =~ 'test_viml.vim'
" this test has intentional errors, don't use try/catch.
source %
catch
else
try
source %
catch
let fail += 1
call add(errors, 'Caught exception: ' . v:exception . ' @ ' . v:throwpoint)
endtry
endtry
endif
" Locate Test_ functions and execute them.
redir @q

15
src/nvim/testdir/test49.ok
View File

@ -1,19 +1,4 @@
Results of test49.vim:
*** Test 1: OK (34695)
*** Test 2: OK (34695)
*** Test 3: OK (1384648195)
*** Test 4: OK (32883)
*** Test 5: OK (32883)
*** Test 6: OK (603978947)
*** Test 7: OK (90563)
*** Test 8: OK (562493431)
*** Test 9: OK (363)
*** Test 10: OK (559615)
*** Test 11: OK (2049)
*** Test 12: OK (352256)
*** Test 13: OK (145)
*** Test 14: OK (42413)
*** Test 15: OK (42413)
*** Test 16: OK (8722)
*** Test 17: OK (285127993)
*** Test 18: OK (67224583)

851
src/nvim/testdir/test49.vim
View File

@ -1,6 +1,6 @@
" Vim script language tests
" Author: Servatius Brandt <Servatius.Brandt@fujitsu-siemens.com>
" Last Change: 2015 Sep 25
" Last Change: 2016 Feb 07
"-------------------------------------------------------------------------------
" Test environment {{{1
@ -608,850 +608,8 @@ com! -nargs=1 -bar ExecAsScript call ExecAsScript(<f-args>)
" END_OF_TEST_ENVIRONMENT - do not change or remove this line.
"-------------------------------------------------------------------------------
" Test 1: :endwhile in function {{{1
"
" Detect if a broken loop is (incorrectly) reactivated by the
" :endwhile. Use a :return to prevent an endless loop, and make
" this test first to get a meaningful result on an error before other
" tests will hang.
"-------------------------------------------------------------------------------
XpathINIT
function! F()
Xpath 1 " X: 1
let first = 1
XloopINIT 2 8
while 1
Xloop 1 " X: 2 + 0 * 16
if first
Xloop 2 " X: 4 + 0 * 32
let first = 0
XloopNEXT
break
else
Xloop 4 " X: 0 + 0 * 64
return
endif
endwhile
endfunction
call F()
Xpath 128 " X: 128
function! G()
Xpath 256 " X: 256 + 0 * 2048
let first = 1
XloopINIT 512 8
while 1
Xloop 1 " X: 512 + 0 * 4096
if first
Xloop 2 " X: 1024 + 0 * 8192
let first = 0
XloopNEXT
break
else
Xloop 4 " X: 0 + 0 * 16384
return
endif
if 1 " unmatched :if
endwhile
endfunction
call G()
Xpath 32768 " X: 32768
Xcheck 34695
" Leave F and G for execution as scripts in the next test.
"-------------------------------------------------------------------------------
" Test 2: :endwhile in script {{{1
"
" Detect if a broken loop is (incorrectly) reactivated by the
" :endwhile. Use a :finish to prevent an endless loop, and place
" this test before others that might hang to get a meaningful result
" on an error.
"
" This test executes the bodies of the functions F and G from the
" previous test as script files (:return replaced by :finish).
"-------------------------------------------------------------------------------
XpathINIT
ExecAsScript F " X: 1 + 2 + 4
Xpath 128 " X: 128
ExecAsScript G " X: 256 + 512 + 1024
Xpath 32768 " X: 32768
unlet first
delfunction F
delfunction G
Xcheck 34695
"-------------------------------------------------------------------------------
" Test 3: :if, :elseif, :while, :continue, :break {{{1
"-------------------------------------------------------------------------------
XpathINIT
if 1
Xpath 1 " X: 1
let loops = 3
XloopINIT 2 512
while loops > -1 " main loop: loops == 3, 2, 1 (which breaks)
if loops <= 0
let break_err = 1
let loops = -1
else " 3: 2: 1:
Xloop 1 " X: 2 + 2*512 + 2*512*512
endif
if (loops == 2)
while loops == 2 " dummy loop
Xloop 2 " X: 4*512
let loops = loops - 1
continue " stop dummy loop
Xloop 4 " X: 0
endwhile
XloopNEXT
continue " continue main loop
Xloop 8 " X: 0
elseif (loops == 1)
let p = 1
while p " dummy loop
Xloop 16 " X: 32*512*512
let p = 0
break " break dummy loop
Xloop 32 " X: 0
endwhile
Xloop 64 " X: 128*512*512
unlet p
break " break main loop
Xloop 128 " X: 0
endif
if (loops > 0)
Xloop 256 " X: 512
endif
while loops == 3 " dummy loop
let loops = loops - 1
endwhile " end dummy loop
XloopNEXT
endwhile " end main loop
Xpath 268435456 " X: 1024*512*512
else
Xpath 536870912 " X: 0
endif
Xpath 1073741824 " X: 4096*512*512
if exists("break_err")
" The Xpath command does not accept 2^31 (negative); add explicitly:
let Xpath = Xpath + 2147483648 " X: 0
unlet break_err
endif
unlet loops
Xcheck 1384648195
"-------------------------------------------------------------------------------
" Test 4: :return {{{1
"-------------------------------------------------------------------------------
XpathINIT
function! F()
if 1
Xpath 1 " X: 1
let loops = 3
XloopINIT 2 16
while loops > 0 " 3: 2: 1:
Xloop 1 " X: 2 + 2*16 + 0*16*16
if (loops == 2)
Xloop 2 " X: 4*16
return
Xloop 4 " X: 0
endif
Xloop 8 " X: 16
let loops = loops - 1
XloopNEXT
endwhile
Xpath 8192 " X: 0
else
Xpath 16384 " X: 0
endif
endfunction
call F()
Xpath 32768 " X: 8*16*16*16
Xcheck 32883
" Leave F for execution as a script in the next test.
"-------------------------------------------------------------------------------
" Test 5: :finish {{{1
"
" This test executes the body of the function F from the previous test
" as a script file (:return replaced by :finish).
"-------------------------------------------------------------------------------
XpathINIT
ExecAsScript F " X: 1 + 2 + 2*16 + 4*16 + 16
Xpath 32768 " X: 32768
unlet loops
delfunction F
Xcheck 32883
"-------------------------------------------------------------------------------
" Test 6: Defining functions in :while loops {{{1
"
" Functions can be defined inside other functions. An inner function
" gets defined when the outer function is executed. Functions may
" also be defined inside while loops. Expressions in braces for
" defining the function name are allowed.
"-------------------------------------------------------------------------------
XpathINIT
if ExtraVim()
" The command CALL collects the argument of all its invocations in "calls"
" when used from a function (that is, when the global variable "calls" needs
" the "g:" prefix). This is to check that the function code is skipped when
" the function is defined. For inner functions, do so only if the outer
" function is not being executed.
"
let calls = ""
com! -nargs=1 CALL
\ if !exists("calls") && !exists("outer") |
\ let g:calls = g:calls . <args> |
\ endif
XloopINIT! 1 16
let i = 0
while i < 3
XloopNEXT
let i = i + 1
if i == 1
Xloop 1 " X: 1
function! F1(arg)
CALL a:arg
let outer = 1
XloopINIT! 4096 4
let j = 0
while j < 1
XloopNEXT
Xloop 1 " X: 4096
let j = j + 1
function! G1(arg)
CALL a:arg
endfunction
Xloop 2 " X: 8192
endwhile
endfunction
Xloop 2 " X: 2
continue
endif
Xloop 4 " X: 4 * (16 + 256)
function! F{i}(i, arg)
CALL a:arg
let outer = 1
XloopINIT! 16384 4
if a:i == 3
XloopNEXT
XloopNEXT
XloopNEXT
endif
let k = 0
while k < 3
XloopNEXT
Xloop 1 " X: 16384*(1+4+16+64+256+1024)
let k = k + 1
function! G{a:i}{k}(arg)
CALL a:arg
endfunction
Xloop 2 " X: 32768*(1+4+16+64+256+1024)
endwhile
endfunction
Xloop 8 " X: 8 * (16 + 256)
endwhile
if exists("*G1")
Xpath 67108864 " X: 0
endif
if exists("*F1")
call F1("F1")
if exists("*G1")
call G1("G1")
endif
endif
if exists("G21") || exists("G21") || exists("G21")
Xpath 134217728 " X: 0
endif
if exists("*F2")
call F2(2, "F2")
if exists("*G21")
call G21("G21")
endif
if exists("*G22")
call G22("G22")
endif
if exists("*G23")
call G23("G23")
endif
endif
if exists("G31") || exists("G31") || exists("G31")
Xpath 268435456 " X: 0
endif
if exists("*F3")
call F3(3, "F3")
if exists("*G31")
call G31("G31")
endif
if exists("*G32")
call G32("G32")
endif
if exists("*G33")
call G33("G33")
endif
endif
Xpath 536870912 " X: 536870912
if calls != "F1G1F2G21G22G23F3G31G32G33"
Xpath 1073741824 " X: 0
Xout "calls is" calls
endif
delfunction F1
delfunction G1
delfunction F2
delfunction G21
delfunction G22
delfunction G23
delfunction G31
delfunction G32
delfunction G33
endif
Xcheck 603978947
"-------------------------------------------------------------------------------
" Test 7: Continuing on errors outside functions {{{1
"
" On an error outside a function, the script processing continues
" at the line following the outermost :endif or :endwhile. When not
" inside an :if or :while, the script processing continues at the next
" line.
"-------------------------------------------------------------------------------
XpathINIT
if 1
Xpath 1 " X: 1
while 1
Xpath 2 " X: 2
asdf
Xpath 4 " X: 0
break
endwhile | Xpath 8 " X: 0
Xpath 16 " X: 0
endif | Xpath 32 " X: 0
Xpath 64 " X: 64
while 1
Xpath 128 " X: 128
if 1
Xpath 256 " X: 256
asdf
Xpath 512 " X: 0
endif | Xpath 1024 " X: 0
Xpath 2048 " X: 0
break
endwhile | Xpath 4096 " X: 0
Xpath 8192 " X: 8192
asdf
Xpath 16384 " X: 16384
asdf | Xpath 32768 " X: 0
Xpath 65536 " X: 65536
Xcheck 90563
"-------------------------------------------------------------------------------
" Test 8: Aborting and continuing on errors inside functions {{{1
"
" On an error inside a function without the "abort" attribute, the
" script processing continues at the next line (unless the error was
" in a :return command). On an error inside a function with the
" "abort" attribute, the function is aborted and the script processing
" continues after the function call; the value -1 is returned then.
"-------------------------------------------------------------------------------
XpathINIT
function! F()
if 1
Xpath 1 " X: 1
while 1
Xpath 2 " X: 2
asdf
Xpath 4 " X: 4
asdf | Xpath 8 " X: 0
Xpath 16 " X: 16
break
endwhile
Xpath 32 " X: 32
endif | Xpath 64 " X: 64
Xpath 128 " X: 128
while 1
Xpath 256 " X: 256
if 1
Xpath 512 " X: 512
asdf
Xpath 1024 " X: 1024
asdf | Xpath 2048 " X: 0
Xpath 4096 " X: 4096
endif
Xpath 8192 " X: 8192
break
endwhile | Xpath 16384 " X: 16384
Xpath 32768 " X: 32768
return novar " returns (default return value 0)
Xpath 65536 " X: 0
return 1 " not reached
endfunction
function! G() abort
if 1
Xpath 131072 " X: 131072
while 1
Xpath 262144 " X: 262144
asdf " returns -1
Xpath 524288 " X: 0
break
endwhile
Xpath 1048576 " X: 0
endif | Xpath 2097152 " X: 0
Xpath Xpath 4194304 " X: 0
return -4 " not reached
endfunction
function! H() abort
while 1
Xpath 8388608 " X: 8388608
if 1
Xpath 16777216 " X: 16777216
asdf " returns -1
Xpath 33554432 " X: 0
endif
Xpath 67108864 " X: 0
break
endwhile | Xpath 134217728 " X: 0
Xpath 268435456 " X: 0
return -4 " not reached
endfunction
" Aborted functions (G and H) return -1.
let sum = (F() + 1) - 4*G() - 8*H()
Xpath 536870912 " X: 536870912
if sum != 13
Xpath 1073741824 " X: 0
Xout "sum is" sum
endif
unlet sum
delfunction F
delfunction G
delfunction H
Xcheck 562493431
"-------------------------------------------------------------------------------
" Test 9: Continuing after aborted functions {{{1
"
" When a function with the "abort" attribute is aborted due to an
" error, the next function back in the call hierarchy without an
" "abort" attribute continues; the value -1 is returned then.
"-------------------------------------------------------------------------------
XpathINIT
function! F() abort
Xpath 1 " X: 1
let result = G() " not aborted
Xpath 2 " X: 2
if result != 2
Xpath 4 " X: 0
endif
return 1
endfunction
function! G() " no abort attribute
Xpath 8 " X: 8
if H() != -1 " aborted
Xpath 16 " X: 0
endif
Xpath 32 " X: 32
return 2
endfunction
function! H() abort
Xpath 64 " X: 64
call I() " aborted
Xpath 128 " X: 0
return 4
endfunction
function! I() abort
Xpath 256 " X: 256
asdf " error
Xpath 512 " X: 0
return 8
endfunction
if F() != 1
Xpath 1024 " X: 0
endif
delfunction F
delfunction G
delfunction H
delfunction I
Xcheck 363
"-------------------------------------------------------------------------------
" Test 10: :if, :elseif, :while argument parsing {{{1
"
" A '"' or '|' in an argument expression must not be mixed up with
" a comment or a next command after a bar. Parsing errors should
" be recognized.
"-------------------------------------------------------------------------------
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
if 1 || strlen("\"") | Xpath 1 " X: 1
Xpath 2 " X: 2
endif
Xpath 4 " X: 4
if 0
elseif 1 || strlen("\"") | Xpath 8 " X: 8
Xpath 16 " X: 16
endif
Xpath 32 " X: 32
while 1 || strlen("\"") | Xpath 64 " X: 64
Xpath 128 " X: 128
break
endwhile
Xpath 256 " X: 256
let v:errmsg = ""
if 1 ||| strlen("\"") | Xpath 512 " X: 0
Xpath 1024 " X: 0
endif
Xpath 2048 " X: 2048
if !MSG('E15', "Invalid expression")
Xpath 4096 " X: 0
endif
let v:errmsg = ""
if 0
elseif 1 ||| strlen("\"") | Xpath 8192 " X: 0
Xpath 16384 " X: 0
endif
Xpath 32768 " X: 32768
if !MSG('E15', "Invalid expression")
Xpath 65536 " X: 0
endif
let v:errmsg = ""
while 1 ||| strlen("\"") | Xpath 131072 " X: 0
Xpath 262144 " X: 0
break
endwhile
Xpath 524288 " X: 524288
if !MSG('E15', "Invalid expression")
Xpath 1048576 " X: 0
endif
delfunction MSG
Xcheck 559615
"-------------------------------------------------------------------------------
" Test 11: :if, :elseif, :while argument evaluation after abort {{{1
"
" When code is skipped over due to an error, the boolean argument to
" an :if, :elseif, or :while must not be evaluated.
"-------------------------------------------------------------------------------
XpathINIT
let calls = 0
function! P(num)
let g:calls = g:calls + a:num " side effect on call
return 0
endfunction
if 1
Xpath 1 " X: 1
asdf " error
Xpath 2 " X: 0
if P(1) " should not be called
Xpath 4 " X: 0
elseif !P(2) " should not be called
Xpath 8 " X: 0
else
Xpath 16 " X: 0
endif
Xpath 32 " X: 0
while P(4) " should not be called
Xpath 64 " X: 0
endwhile
Xpath 128 " X: 0
endif
if calls % 2
Xpath 256 " X: 0
endif
if (calls/2) % 2
Xpath 512 " X: 0
endif
if (calls/4) % 2
Xpath 1024 " X: 0
endif
Xpath 2048 " X: 2048
unlet calls
delfunction P
Xcheck 2049
"-------------------------------------------------------------------------------
" Test 12: Expressions in braces in skipped code {{{1
"
" In code skipped over due to an error or inactive conditional,
" an expression in braces as part of a variable or function name
" should not be evaluated.
"-------------------------------------------------------------------------------
XpathINIT
XloopINIT 1 8
function! NULL()
Xloop 1 " X: 0
return 0
endfunction
function! ZERO()
Xloop 2 " X: 0
return 0
endfunction
function! F0()
Xloop 4 " X: 0
endfunction
function! F1(arg)
Xpath 4096 " X: 0
endfunction
let V0 = 1
Xpath 8192 " X: 8192
echo 0 ? F{NULL() + V{ZERO()}}() : 1
XloopNEXT
Xpath 16384 " X: 16384
if 0
Xpath 32768 " X: 0
call F{NULL() + V{ZERO()}}()
endif
XloopNEXT
Xpath 65536 " X: 65536
if 1
asdf " error
Xpath 131072 " X: 0
call F1(F{NULL() + V{ZERO()}}())
endif
XloopNEXT
Xpath 262144 " X: 262144
if 1
asdf " error
Xpath 524288 " X: 0
call F{NULL() + V{ZERO()}}()
endif
Xcheck 352256
"-------------------------------------------------------------------------------
" Test 13: Failure in argument evaluation for :while {{{1
"
" A failure in the expression evaluation for the condition of a :while
" causes the whole :while loop until the matching :endwhile being
" ignored. Continuation is at the next following line.
"-------------------------------------------------------------------------------
XpathINIT
Xpath 1 " X: 1
while asdf
Xpath 2 " X: 0
while 1
Xpath 4 " X: 0
break
endwhile
Xpath 8 " X: 0
break
endwhile
Xpath 16 " X: 16
while asdf | Xpath 32 | endwhile | Xpath 64 " X: 0
Xpath 128 " X: 128
Xcheck 145
"-------------------------------------------------------------------------------
" Test 14: Failure in argument evaluation for :if {{{1
"
" A failure in the expression evaluation for the condition of an :if
" does not cause the corresponding :else or :endif being matched to
" a previous :if/:elseif. Neither of both branches of the failed :if
" are executed.
"-------------------------------------------------------------------------------
XpathINIT
XloopINIT 1 256
function! F()
Xloop 1 " X: 1 + 256 * 1
let x = 0
if x " false
Xloop 2 " X: 0 + 256 * 0
elseif !x " always true
Xloop 4 " X: 4 + 256 * 4
let x = 1
if g:boolvar " possibly undefined
Xloop 8 " X: 8 + 256 * 0
else
Xloop 16 " X: 0 + 256 * 0
endif
Xloop 32 " X: 32 + 256 * 32
elseif x " never executed
Xloop 64 " X: 0 + 256 * 0
endif
Xloop 128 " X: 128 + 256 * 128
endfunction
let boolvar = 1
call F()
XloopNEXT
unlet boolvar
call F()
delfunction F
Xcheck 42413
"-------------------------------------------------------------------------------
" Test 15: Failure in argument evaluation for :if (bar) {{{1
"
" Like previous test, except that the failing :if ... | ... | :endif
" is in a single line.
"-------------------------------------------------------------------------------
XpathINIT
XloopINIT 1 256
function! F()
Xloop 1 " X: 1 + 256 * 1
let x = 0
if x " false
Xloop 2 " X: 0 + 256 * 0
elseif !x " always true
Xloop 4 " X: 4 + 256 * 4
let x = 1
if g:boolvar | Xloop 8 | else | Xloop 16 | endif " X: 8
Xloop 32 " X: 32 + 256 * 32
elseif x " never executed
Xloop 64 " X: 0 + 256 * 0
endif
Xloop 128 " X: 128 + 256 * 128
endfunction
let boolvar = 1
call F()
XloopNEXT
unlet boolvar
call F()
delfunction F
Xcheck 42413
" Tests 1 to 15 were moved to test_viml.vim
let Xtest = 16
"-------------------------------------------------------------------------------
" Test 16: Double :else or :elseif after :else {{{1
@ -6591,8 +5749,7 @@ function! F()
if !caught && !$VIMNOERRTHROW
Xpath 8192 " X: 0
endif
if caught ? !MSG('E55', 'Unmatched \\)')
\ : !MSG('E475', "Invalid argument")
if !MSG('E475', "Invalid argument")
Xpath 16384 " X: 0
endif
if !caught

914
src/nvim/testdir/test_viml.vim Normal file
View File

@ -0,0 +1,914 @@
" Test various aspects of the Vim language.
" This was formerly in test49.
"-------------------------------------------------------------------------------
" Test environment {{{1
"-------------------------------------------------------------------------------
com! XpathINIT let g:Xpath = ''
com! -nargs=1 -bar Xpath let g:Xpath = g:Xpath . <args>
" Append a message to the "messages" file
func! Xout(text)
split messages
$put =a:text
wq
endfunc
com! -nargs=1 Xout call Xout(<args>)
" MakeScript() - Make a script file from a function. {{{2
"
" Create a script that consists of the body of the function a:funcname.
" Replace any ":return" by a ":finish", any argument variable by a global
" variable, and and every ":call" by a ":source" for the next following argument
" in the variable argument list. This function is useful if similar tests are
" to be made for a ":return" from a function call or a ":finish" in a script
" file.
function! MakeScript(funcname, ...)
let script = tempname()
execute "redir! >" . script
execute "function" a:funcname
redir END
execute "edit" script
" Delete the "function" and the "endfunction" lines. Do not include the
" word "function" in the pattern since it might be translated if LANG is
" set. When MakeScript() is being debugged, this deletes also the debugging
" output of its line 3 and 4.
exec '1,/.*' . a:funcname . '(.*)/d'
/^\d*\s*endfunction\>/,$d
%s/^\d*//e
%s/return/finish/e
%s/\<a:\(\h\w*\)/g:\1/ge
normal gg0
let cnt = 0
while search('\<call\s*\%(\u\|s:\)\w*\s*(.*)', 'W') > 0
let cnt = cnt + 1
s/\<call\s*\%(\u\|s:\)\w*\s*(.*)/\='source ' . a:{cnt}/
endwhile
g/^\s*$/d
write
bwipeout
return script
endfunction
" ExecAsScript - Source a temporary script made from a function. {{{2
"
" Make a temporary script file from the function a:funcname, ":source" it, and
" delete it afterwards.
function! ExecAsScript(funcname)
" Make a script from the function passed as argument.
let script = MakeScript(a:funcname)
" Source and delete the script.
exec "source" script
call delete(script)
endfunction
com! -nargs=1 -bar ExecAsScript call ExecAsScript(<f-args>)
"-------------------------------------------------------------------------------
" Test 1: :endwhile in function {{{1
"
" Detect if a broken loop is (incorrectly) reactivated by the
" :endwhile. Use a :return to prevent an endless loop, and make
" this test first to get a meaningful result on an error before other
" tests will hang.
"-------------------------------------------------------------------------------
function! T1_F()
Xpath 'a'
let first = 1
while 1
Xpath 'b'
if first
Xpath 'c'
let first = 0
break
else
Xpath 'd'
return
endif
endwhile
endfunction
function! T1_G()
Xpath 'h'
let first = 1
while 1
Xpath 'i'
if first
Xpath 'j'
let first = 0
break
else
Xpath 'k'
return
endif
if 1 " unmatched :if
endwhile
endfunction
func Test_endwhile_function()
XpathINIT
call T1_F()
Xpath 'F'
try
call T1_G()
catch
" Catch missing :endif
call assert_true(v:exception =~ 'E171')
Xpath 'x'
endtry
Xpath 'G'
call assert_equal('abcFhijxG', g:Xpath)
endfunc
"-------------------------------------------------------------------------------
" Test 2: :endwhile in script {{{1
"
" Detect if a broken loop is (incorrectly) reactivated by the
" :endwhile. Use a :finish to prevent an endless loop, and place
" this test before others that might hang to get a meaningful result
" on an error.
"
" This test executes the bodies of the functions T1_F and T1_G from
" the previous test as script files (:return replaced by :finish).
"-------------------------------------------------------------------------------
func Test_endwhile_script()
XpathINIT
ExecAsScript T1_F
Xpath 'F'
try
ExecAsScript T1_G
catch
" Catch missing :endif
call assert_true(v:exception =~ 'E171')
Xpath 'x'
endtry
Xpath 'G'
call assert_equal('abcFhijxG', g:Xpath)
endfunc
"-------------------------------------------------------------------------------
" Test 3: :if, :elseif, :while, :continue, :break {{{1
"-------------------------------------------------------------------------------
function Test_if_while()
XpathINIT
if 1
Xpath 'a'
let loops = 3
while loops > -1 " main loop: loops == 3, 2, 1 (which breaks)
if loops <= 0
let break_err = 1
let loops = -1
else
Xpath 'b' . loops
endif
if (loops == 2)
while loops == 2 " dummy loop
Xpath 'c' . loops
let loops = loops - 1
continue " stop dummy loop
Xpath 'd' . loops
endwhile
continue " continue main loop
Xpath 'e' . loops
elseif (loops == 1)
let p = 1
while p " dummy loop
Xpath 'f' . loops
let p = 0
break " break dummy loop
Xpath 'g' . loops
endwhile
Xpath 'h' . loops
unlet p
break " break main loop
Xpath 'i' . loops
endif
if (loops > 0)
Xpath 'j' . loops
endif
while loops == 3 " dummy loop
let loops = loops - 1
endwhile " end dummy loop
endwhile " end main loop
Xpath 'k'
else
Xpath 'l'
endif
Xpath 'm'
if exists("break_err")
Xpath 'm'
unlet break_err
endif
unlet loops
call assert_equal('ab3j3b2c2b1f1h1km', g:Xpath)
endfunc
"-------------------------------------------------------------------------------
" Test 4: :return {{{1
"-------------------------------------------------------------------------------
function! T4_F()
if 1
Xpath 'a'
let loops = 3
while loops > 0 " 3: 2: 1:
Xpath 'b' . loops
if (loops == 2)
Xpath 'c' . loops
return
Xpath 'd' . loops
endif
Xpath 'e' . loops
let loops = loops - 1
endwhile
Xpath 'f'
else
Xpath 'g'
endif
endfunction
function Test_return()
XpathINIT
call T4_F()
Xpath '4'
call assert_equal('ab3e3b2c24', g:Xpath)
endfunction
"-------------------------------------------------------------------------------
" Test 5: :finish {{{1
"
" This test executes the body of the function T4_F from the previous
" test as a script file (:return replaced by :finish).
"-------------------------------------------------------------------------------
function Test_finish()
XpathINIT
ExecAsScript T4_F
Xpath '5'
call assert_equal('ab3e3b2c25', g:Xpath)
endfunction
"-------------------------------------------------------------------------------
" Test 6: Defining functions in :while loops {{{1
"
" Functions can be defined inside other functions. An inner function
" gets defined when the outer function is executed. Functions may
" also be defined inside while loops. Expressions in braces for
" defining the function name are allowed.
"
" The functions are defined when sourcing the script, only the
" resulting path is checked in the test function.
"-------------------------------------------------------------------------------
XpathINIT
" The command CALL collects the argument of all its invocations in "calls"
" when used from a function (that is, when the global variable "calls" needs
" the "g:" prefix). This is to check that the function code is skipped when
" the function is defined. For inner functions, do so only if the outer
" function is not being executed.
"
let calls = ""
com! -nargs=1 CALL
\ if !exists("calls") && !exists("outer") |
\ let g:calls = g:calls . <args> |
\ endif
let i = 0
while i < 3
let i = i + 1
if i == 1
Xpath 'a'
function! F1(arg)
CALL a:arg
let outer = 1
let j = 0
while j < 1
Xpath 'b'
let j = j + 1
function! G1(arg)
CALL a:arg
endfunction
Xpath 'c'
endwhile
endfunction
Xpath 'd'
continue
endif
Xpath 'e' . i
function! F{i}(i, arg)
CALL a:arg
let outer = 1
if a:i == 3
Xpath 'f'
endif
let k = 0
while k < 3
Xpath 'g' . k
let k = k + 1
function! G{a:i}{k}(arg)
CALL a:arg
endfunction
Xpath 'h' . k
endwhile
endfunction
Xpath 'i'
endwhile
if exists("*G1")
Xpath 'j'
endif
if exists("*F1")
call F1("F1")
if exists("*G1")
call G1("G1")
endif
endif
if exists("G21") || exists("G22") || exists("G23")
Xpath 'k'
endif
if exists("*F2")
call F2(2, "F2")
if exists("*G21")
call G21("G21")
endif
if exists("*G22")
call G22("G22")
endif
if exists("*G23")
call G23("G23")
endif
endif
if exists("G31") || exists("G32") || exists("G33")
Xpath 'l'
endif
if exists("*F3")
call F3(3, "F3")
if exists("*G31")
call G31("G31")
endif
if exists("*G32")
call G32("G32")
endif
if exists("*G33")
call G33("G33")
endif
endif
Xpath 'm'
let g:test6_result = g:Xpath
let g:test6_calls = calls
unlet calls
delfunction F1
delfunction G1
delfunction F2
delfunction G21
delfunction G22
delfunction G23
delfunction G31
delfunction G32
delfunction G33
function Test_defining_functions()
call assert_equal('ade2ie3ibcg0h1g1h2g2h3fg0h1g1h2g2h3m', g:test6_result)
call assert_equal('F1G1F2G21G22G23F3G31G32G33', g:test6_calls)
endfunc
"-------------------------------------------------------------------------------
" Test 7: Continuing on errors outside functions {{{1
"
" On an error outside a function, the script processing continues
" at the line following the outermost :endif or :endwhile. When not
" inside an :if or :while, the script processing continues at the next
" line.
"-------------------------------------------------------------------------------
XpathINIT
if 1
Xpath 'a'
while 1
Xpath 'b'
asdf
Xpath 'c'
break
endwhile | Xpath 'd'
Xpath 'e'
endif | Xpath 'f'
Xpath 'g'
while 1
Xpath 'h'
if 1
Xpath 'i'
asdf
Xpath 'j'
endif | Xpath 'k'
Xpath 'l'
break
endwhile | Xpath 'm'
Xpath 'n'
asdf
Xpath 'o'
asdf | Xpath 'p'
Xpath 'q'
let g:test7_result = g:Xpath
func Test_error_in_script()
call assert_equal('abghinoq', g:test7_result)
endfunc
"-------------------------------------------------------------------------------
" Test 8: Aborting and continuing on errors inside functions {{{1
"
" On an error inside a function without the "abort" attribute, the
" script processing continues at the next line (unless the error was
" in a :return command). On an error inside a function with the
" "abort" attribute, the function is aborted and the script processing
" continues after the function call; the value -1 is returned then.
"-------------------------------------------------------------------------------
XpathINIT
function! T8_F()
if 1
Xpath 'a'
while 1
Xpath 'b'
asdf
Xpath 'c'
asdf | Xpath 'd'
Xpath 'e'
break
endwhile
Xpath 'f'
endif | Xpath 'g'
Xpath 'h'
while 1
Xpath 'i'
if 1
Xpath 'j'
asdf
Xpath 'k'
asdf | Xpath 'l'
Xpath 'm'
endif
Xpath 'n'
break
endwhile | Xpath 'o'
Xpath 'p'
return novar " returns (default return value 0)
Xpath 'q'
return 1 " not reached
endfunction
function! T8_G() abort
if 1
Xpath 'r'
while 1
Xpath 's'
asdf " returns -1
Xpath 't'
break
endwhile
Xpath 'v'
endif | Xpath 'w'
Xpath 'x'
return -4 " not reached
endfunction
function! T8_H() abort
while 1
Xpath 'A'
if 1
Xpath 'B'
asdf " returns -1
Xpath 'C'
endif
Xpath 'D'
break
endwhile | Xpath 'E'
Xpath 'F'
return -4 " not reached
endfunction
" Aborted functions (T8_G and T8_H) return -1.
let g:test8_sum = (T8_F() + 1) - 4 * T8_G() - 8 * T8_H()
Xpath 'X'
let g:test8_result = g:Xpath
func Test_error_in_function()
call assert_equal(13, g:test8_sum)
call assert_equal('abcefghijkmnoprsABX', g:test8_result)
delfunction T8_F
delfunction T8_G
delfunction T8_H
endfunc
"-------------------------------------------------------------------------------
" Test 9: Continuing after aborted functions {{{1
"
" When a function with the "abort" attribute is aborted due to an
" error, the next function back in the call hierarchy without an
" "abort" attribute continues; the value -1 is returned then.
"-------------------------------------------------------------------------------
XpathINIT
function! F() abort
Xpath 'a'
let result = G() " not aborted
Xpath 'b'
if result != 2
Xpath 'c'
endif
return 1
endfunction
function! G() " no abort attribute
Xpath 'd'
if H() != -1 " aborted
Xpath 'e'
endif
Xpath 'f'
return 2
endfunction
function! H() abort
Xpath 'g'
call I() " aborted
Xpath 'h'
return 4
endfunction
function! I() abort
Xpath 'i'
asdf " error
Xpath 'j'
return 8
endfunction
if F() != 1
Xpath 'k'
endif
let g:test9_result = g:Xpath
delfunction F
delfunction G
delfunction H
delfunction I
func Test_func_abort()
call assert_equal('adgifb', g:test9_result)
endfunc
"-------------------------------------------------------------------------------
" Test 10: :if, :elseif, :while argument parsing {{{1
"
" A '"' or '|' in an argument expression must not be mixed up with
" a comment or a next command after a bar. Parsing errors should
" be recognized.
"-------------------------------------------------------------------------------
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
if 1 || strlen("\"") | Xpath 'a'
Xpath 'b'
endif
Xpath 'c'
if 0
elseif 1 || strlen("\"") | Xpath 'd'
Xpath 'e'
endif
Xpath 'f'
while 1 || strlen("\"") | Xpath 'g'
Xpath 'h'
break
endwhile
Xpath 'i'
let v:errmsg = ""
if 1 ||| strlen("\"") | Xpath 'j'
Xpath 'k'
endif
Xpath 'l'
if !MSG('E15', "Invalid expression")
Xpath 'm'
endif
let v:errmsg = ""
if 0
elseif 1 ||| strlen("\"") | Xpath 'n'
Xpath 'o'
endif
Xpath 'p'
if !MSG('E15', "Invalid expression")
Xpath 'q'
endif
let v:errmsg = ""
while 1 ||| strlen("\"") | Xpath 'r'
Xpath 's'
break
endwhile
Xpath 't'
if !MSG('E15', "Invalid expression")
Xpath 'u'
endif
let g:test10_result = g:Xpath
delfunction MSG
func Test_expr_parsing()
call assert_equal('abcdefghilpt', g:test10_result)
endfunc
"-------------------------------------------------------------------------------
" Test 11: :if, :elseif, :while argument evaluation after abort {{{1
"
" When code is skipped over due to an error, the boolean argument to
" an :if, :elseif, or :while must not be evaluated.
"-------------------------------------------------------------------------------
XpathINIT
let calls = 0
function! P(num)
let g:calls = g:calls + a:num " side effect on call
return 0
endfunction
if 1
Xpath 'a'
asdf " error
Xpath 'b'
if P(1) " should not be called
Xpath 'c'
elseif !P(2) " should not be called
Xpath 'd'
else
Xpath 'e'
endif
Xpath 'f'
while P(4) " should not be called
Xpath 'g'
endwhile
Xpath 'h'
endif
Xpath 'x'
let g:test11_calls = calls
let g:test11_result = g:Xpath
unlet calls
delfunction P
func Test_arg_abort()
call assert_equal(0, g:test11_calls)
call assert_equal('ax', g:test11_result)
endfunc
"-------------------------------------------------------------------------------
" Test 12: Expressions in braces in skipped code {{{1
"
" In code skipped over due to an error or inactive conditional,
" an expression in braces as part of a variable or function name
" should not be evaluated.
"-------------------------------------------------------------------------------
XpathINIT
function! NULL()
Xpath 'a'
return 0
endfunction
function! ZERO()
Xpath 'b'
return 0
endfunction
function! F0()
Xpath 'c'
endfunction
function! F1(arg)
Xpath 'e'
endfunction
let V0 = 1
Xpath 'f'
echo 0 ? F{NULL() + V{ZERO()}}() : 1
Xpath 'g'
if 0
Xpath 'h'
call F{NULL() + V{ZERO()}}()
endif
Xpath 'i'
if 1
asdf " error
Xpath 'j'
call F1(F{NULL() + V{ZERO()}}())
endif
Xpath 'k'
if 1
asdf " error
Xpath 'l'
call F{NULL() + V{ZERO()}}()
endif
let g:test12_result = g:Xpath
func Test_braces_skipped()
call assert_equal('fgik', g:test12_result)
endfunc
"-------------------------------------------------------------------------------
" Test 13: Failure in argument evaluation for :while {{{1
"
" A failure in the expression evaluation for the condition of a :while
" causes the whole :while loop until the matching :endwhile being
" ignored. Continuation is at the next following line.
"-------------------------------------------------------------------------------
XpathINIT
Xpath 'a'
while asdf
Xpath 'b'
while 1
Xpath 'c'
break
endwhile
Xpath 'd'
break
endwhile
Xpath 'e'
while asdf | Xpath 'f' | endwhile | Xpath 'g'
Xpath 'h'
let g:test13_result = g:Xpath
func Test_while_fail()
call assert_equal('aeh', g:test13_result)
endfunc
"-------------------------------------------------------------------------------
" Test 14: Failure in argument evaluation for :if {{{1
"
" A failure in the expression evaluation for the condition of an :if
" does not cause the corresponding :else or :endif being matched to
" a previous :if/:elseif. Neither of both branches of the failed :if
" are executed.
"-------------------------------------------------------------------------------
XpathINIT
function! F()
Xpath 'a'
let x = 0
if x " false
Xpath 'b'
elseif !x " always true
Xpath 'c'
let x = 1
if g:boolvar " possibly undefined
Xpath 'd'
else
Xpath 'e'
endif
Xpath 'f'
elseif x " never executed
Xpath 'g'
endif
Xpath 'h'
endfunction
let boolvar = 1
call F()
Xpath '-'
unlet boolvar
call F()
let g:test14_result = g:Xpath
delfunction F
func Test_if_fail()
call assert_equal('acdfh-acfh', g:test14_result)
endfunc
"-------------------------------------------------------------------------------
" Test 15: Failure in argument evaluation for :if (bar) {{{1
"
" Like previous test, except that the failing :if ... | ... | :endif
" is in a single line.
"-------------------------------------------------------------------------------
XpathINIT
function! F()
Xpath 'a'
let x = 0
if x " false
Xpath 'b'
elseif !x " always true
Xpath 'c'
let x = 1
if g:boolvar | Xpath 'd' | else | Xpath 'e' | endif
Xpath 'f'
elseif x " never executed
Xpath 'g'
endif
Xpath 'h'
endfunction
let boolvar = 1
call F()
Xpath '-'
unlet boolvar
call F()
let g:test15_result = g:Xpath
delfunction F
func Test_if_bar_fail()
call assert_equal('acdfh-acfh', g:test15_result)
endfunc
"-------------------------------------------------------------------------------
" Modelines {{{1
" vim: ts=8 sw=4 tw=80 fdm=marker
" vim: fdt=substitute(substitute(foldtext(),\ '\\%(^+--\\)\\@<=\\(\\s*\\)\\(.\\{-}\\)\:\ \\%(\"\ \\)\\=\\(Test\ \\d*\\)\:\\s*',\ '\\3\ (\\2)\:\ \\1',\ \"\"),\ '\\(Test\\s*\\)\\(\\d\\)\\D\\@=',\ '\\1\ \\2',\ "")
"-------------------------------------------------------------------------------

72
src/nvim/version.c
View File

@ -78,7 +78,71 @@ static int included_patches[] = {
1511,
1425,
1366,
1284,
// 1283
1282,
// 1281
// 1280
// 1279
// 1278
// 1277
// 1276
// 1275
// 1274
// 1273
// 1272
// 1271
// 1270
// 1269
// 1268
// 1267
// 1266
// 1265
// 1264
// 1263
// 1262
// 1261
// 1260
// 1259
// 1258
// 1257
// 1256
// 1255
// 1254
// 1253
// 1252
// 1251
// 1250
// 1249
// 1248
// 1247
// 1246
// 1245
// 1244
// 1243
// 1242
// 1241
// 1240
// 1239
// 1238
// 1237
// 1236
// 1235
// 1234
// 1233
// 1232
// 1231
// 1230
// 1229
// 1228
// 1227
// 1226
// 1225
// 1224
// 1223
// 1223
// 1221
// 1220
// 1219 NA
// 1218 NA
// 1217 NA
@ -268,7 +332,7 @@ static int included_patches[] = {
// 1033 NA,
1032,
// 1031 NA,
// 1030,
1030,
1029,
// 1028 NA,
1027,
@ -297,8 +361,8 @@ static int included_patches[] = {
// 1004 NA,
// 1003 NA,
// 1002 NA,
// 1001,
// 1000,
1001,
1000,
// 999 NA
// 998,
// 997 NA