aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-07-26 11:04:33 -04:00
Code

patch 8.2.4770: cannot easily mix expression and heredoc

Browse Source 
Problem:    Cannot easily mix expression and heredoc.
Solution:   Support  in heredoc. (Yegappan Lakshmanan, closes #10138)
This commit is contained in:
Yegappan Lakshmanan 2022-04-17 12:47:40 +01:00 committed by Bram Moolenaar
parent 68aaff4697
commit efbfa867a1
6 changed files with 315 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
runtime/doc/eval.txt
View File

@ -3224,14 +3224,32 @@ declarations and assignments do not use a command. |vim9-declaration|
*:let=<<* *:let-heredoc*
*E990* *E991* *E172* *E221* *E1145*
:let {var-name} =<< [trim] {endmarker}
:let {var-name} =<< [trim] [eval] {endmarker}
text...
text...
{endmarker}
Set internal variable {var-name} to a |List|
containing the lines of text bounded by the string
{endmarker}. The lines of text is used as a
|literal-string|.
{endmarker}.
If "eval" is not specified, then each line of text is
used as a |literal-string|. If "eval" is specified,
then any Vim expression in the form ``={expr}`` is
evaluated and the result replaces the expression.
Example where $HOME is expanded: >
let lines =<< trim eval END
some text
See the file `=$HOME`/.vimrc
more text
END
< There can be multiple Vim expressions in a single line
but an expression cannot span multiple lines. If any
expression evaluation fails, then the assignment fails.
once the "`=" has been found {expr} and a backtick
must follow. {expr} cannot be empty.
Currenty, in a compiled function {expr} is evaluated
when compiling the function, THIS WILL CHANGE.
{endmarker} must not contain white space.
{endmarker} cannot start with a lower case character.
The last line should end only with the {endmarker}
@ -3281,6 +3299,13 @@ text...
1 2 3 4
5 6 7 8
DATA
let code =<< trim eval CODE
let v = `=10 + 20`
let h = "`=$HOME`"
let s = "`=Str1()` abc `=Str2()`"
let n = `=MyFunc(3, 4)`
CODE
<
*E121*
:let {var-name} .. List the value of variable {var-name}. Multiple

135
src/evalvars.c
View File

@ -602,6 +602,66 @@ list_script_vars(int *first)
"s:", FALSE, first);
}
/*
* Evaluate all the Vim expressions (`=expr`) in string "str" and return the
* resulting string. The caller must free the returned string.
*/
static char_u *
eval_all_expr_in_str(char_u *str)
{
garray_T ga;
char_u *s;
char_u *p;
char_u save_c;
char_u *exprval;
int status;
ga_init2(&ga, 1, 80);
p = str;
// Look for `=expr`, evaluate the expression and replace `=expr` with the
// result.
while (*p != NUL)
{
s = p;
while (*p != NUL && (*p != '`' || p[1] != '='))
p++;
ga_concat_len(&ga, s, p - s);
if (*p == NUL)
break; // no backtick expression found
s = p;
p += 2; // skip `=
status = *p == NUL ? OK : skip_expr(&p, NULL);
if (status == FAIL || *p != '`')
{
// invalid expression or missing ending backtick
if (status != FAIL)
emsg(_(e_missing_backtick));
vim_free(ga.ga_data);
return NULL;
}
s += 2; // skip `=
save_c = *p;
*p = NUL;
exprval = eval_to_string(s, TRUE);
*p = save_c;
p++;
if (exprval == NULL)
{
// expression evaluation failed
vim_free(ga.ga_data);
return NULL;
}
ga_concat(&ga, exprval);
vim_free(exprval);
}
ga_append(&ga, NUL);
return ga.ga_data;
}
/*
* Get a list of lines from a HERE document. The here document is a list of
* lines surrounded by a marker.
@ -619,7 +679,7 @@ list_script_vars(int *first)
* tcl, mzscheme), script_get is set to TRUE. In this case, if the marker is
* missing, then '.' is accepted as a marker.
*
* Returns a List with {lines} or NULL.
* Returns a List with {lines} or NULL on failure.
*/
list_T *
heredoc_get(exarg_T *eap, char_u *cmd, int script_get)
@ -628,11 +688,14 @@ heredoc_get(exarg_T *eap, char_u *cmd, int script_get)
char_u *marker;
list_T *l;
char_u *p;
char_u *str;
int marker_indent_len = 0;
int text_indent_len = 0;
char_u *text_indent = NULL;
char_u dot[] = ".";
int comment_char = in_vim9script() ? '#' : '"';
int evalstr = FALSE;
int eval_failed = FALSE;
if (eap->getline == NULL)
{
@ -642,21 +705,36 @@ heredoc_get(exarg_T *eap, char_u *cmd, int script_get)
// Check for the optional 'trim' word before the marker
cmd = skipwhite(cmd);
if (STRNCMP(cmd, "trim", 4) == 0 && (cmd[4] == NUL || VIM_ISWHITE(cmd[4])))
{
cmd = skipwhite(cmd + 4);
// Trim the indentation from all the lines in the here document.
// The amount of indentation trimmed is the same as the indentation of
// the first line after the :let command line. To find the end marker
// the indent of the :let command line is trimmed.
p = *eap->cmdlinep;
while (VIM_ISWHITE(*p))
while (TRUE)
{
if (STRNCMP(cmd, "trim", 4) == 0
&& (cmd[4] == NUL || VIM_ISWHITE(cmd[4])))
{
p++;
marker_indent_len++;
cmd = skipwhite(cmd + 4);
// Trim the indentation from all the lines in the here document.
// The amount of indentation trimmed is the same as the indentation
// of the first line after the :let command line. To find the end
// marker the indent of the :let command line is trimmed.
p = *eap->cmdlinep;
while (VIM_ISWHITE(*p))
{
p++;
marker_indent_len++;
}
text_indent_len = -1;
continue;
}
text_indent_len = -1;
if (STRNCMP(cmd, "eval", 4) == 0
&& (cmd[4] == NUL || VIM_ISWHITE(cmd[4])))
{
cmd = skipwhite(cmd + 4);
evalstr = TRUE;
continue;
}
break;
}
// The marker is the next word.
@ -716,6 +794,14 @@ heredoc_get(exarg_T *eap, char_u *cmd, int script_get)
break;
}
// If expression evaluation failed in the heredoc, then skip till the
// end marker.
if (eval_failed)
{
vim_free(theline);
continue;
}
if (text_indent_len == -1 && *theline != NUL)
{
// set the text indent from the first line.
@ -734,12 +820,33 @@ heredoc_get(exarg_T *eap, char_u *cmd, int script_get)
if (theline[ti] != text_indent[ti])
break;
if (list_append_string(l, theline + ti, -1) == FAIL)
str = theline + ti;
if (evalstr)
{
str = eval_all_expr_in_str(str);
if (str == NULL)
{
// expression evaluation failed
vim_free(theline);
eval_failed = TRUE;
continue;
}
vim_free(theline);
theline = str;
}
if (list_append_string(l, str, -1) == FAIL)
break;
vim_free(theline);
}
vim_free(text_indent);
if (eval_failed)
{
// expression evaluation in the heredoc failed
list_free(l);
return NULL;
}
return l;
}

97
src/testdir/test_let.vim
View File

@ -1,5 +1,7 @@
" Tests for the :let command.
import './vim9.vim' as v9
func Test_let()
" Test to not autoload when assigning. It causes internal error.
set runtimepath+=./sautest
@ -379,7 +381,8 @@ END
call assert_equal(['Text', 'with', 'indent'], text)
endfunc
" Test for the setting a variable using the heredoc syntax
" Test for the setting a variable using the heredoc syntax.
" Keep near the end, this messes up highlighting.
func Test_let_heredoc()
let var1 =<< END
Some sample text
@ -495,4 +498,96 @@ END
call assert_equal([' x', ' \y', ' z'], [a, b, c])
endfunc
" Test for evaluating Vim expressions in a heredoc using `=expr`
" Keep near the end, this messes up highlighting.
func Test_let_heredoc_eval()
let str = ''
let code =<< trim eval END
let a = `=5 + 10`
let b = `=min([10, 6])` + `=max([4, 6])`
`=str`
let c = "abc`=str`d"
END
call assert_equal(['let a = 15', 'let b = 6 + 6', '', 'let c = "abcd"'], code)
let $TESTVAR = "Hello"
let code =<< eval trim END
let s = "`=$TESTVAR`"
END
call assert_equal(['let s = "Hello"'], code)
let code =<< eval END
let s = "`=$TESTVAR`"
END
call assert_equal([' let s = "Hello"'], code)
let a = 10
let data =<< eval END
`=a`
END
call assert_equal(['10'], data)
let x = 'X'
let code =<< eval trim END
let a = `abc`
let b = `=x`
let c = `
END
call assert_equal(['let a = `abc`', 'let b = X', 'let c = `'], code)
let code = 'xxx'
let code =<< eval trim END
let n = `=5 +
6`
END
call assert_equal('xxx', code)
let code =<< eval trim END
let n = `=min([1, 2]` + `=max([3, 4])`
END
call assert_equal('xxx', code)
let lines =<< trim LINES
let text =<< eval trim END
let b = `=
END
LINES
call v9.CheckScriptFailure(lines, 'E1083:')
let lines =<< trim LINES
let text =<< eval trim END
let b = `=abc
END
LINES
call v9.CheckScriptFailure(lines, 'E1083:')
let lines =<< trim LINES
let text =<< eval trim END
let b = `=`
END
LINES
call v9.CheckScriptFailure(lines, 'E15:')
" Test for sourcing a script containing a heredoc with invalid expression.
" Variable assignment should fail, if expression evaluation fails
new
let g:Xvar = 'test'
let g:b = 10
let lines =<< trim END
let Xvar =<< eval CODE
let a = 1
let b = `=5+`
let c = 2
CODE
let g:Count += 1
END
call setline(1, lines)
let g:Count = 0
call assert_fails('source', 'E15:')
call assert_equal(1, g:Count)
call setline(3, 'let b = `=abc`')
call assert_fails('source', 'E121:')
call assert_equal(2, g:Count)
call setline(3, 'let b = `=abc` + `=min([9, 4])` + 2')
call assert_fails('source', 'E121:')
call assert_equal(3, g:Count)
call assert_equal('test', g:Xvar)
call assert_equal(10, g:b)
bw!
endfunc
" vim: shiftwidth=2 sts=2 expandtab

54
src/testdir/test_vim9_assign.vim
View File

@ -740,7 +740,7 @@ def Test_init_in_for_loop()
enddef
def Test_extend_list()
# using uninitilaized list assigns empty list
# using uninitialized list assigns empty list
var lines =<< trim END
var l1: list<number>
var l2 = l1
@ -758,7 +758,7 @@ def Test_extend_list()
END
v9.CheckDefAndScriptSuccess(lines)
# appending to uninitialzed list from a function works
# appending to uninitialized list from a function works
lines =<< trim END
vim9script
var list: list<string>
@ -2637,6 +2637,56 @@ def Test_using_s_var_in_function()
v9.CheckScriptSuccess(lines)
enddef
let g:someVar = 'X'
" Test for heredoc with Vim expressions.
" This messes up highlighting, keep it near the end.
def Test_heredoc_expr()
var code =<< trim eval END
var a = `=5 + 10`
var b = `=min([10, 6])` + `=max([4, 6])`
END
assert_equal(['var a = 15', 'var b = 6 + 6'], code)
code =<< eval trim END
var s = "`=$SOME_ENV_VAR`"
END
assert_equal(['var s = "somemore"'], code)
code =<< eval END
var s = "`=$SOME_ENV_VAR`"
END
assert_equal([' var s = "somemore"'], code)
code =<< eval trim END
let a = `abc`
let b = `=g:someVar`
let c = `
END
assert_equal(['let a = `abc`', 'let b = X', 'let c = `'], code)
var lines =<< trim LINES
var text =<< eval trim END
let b = `=
END
LINES
v9.CheckDefAndScriptFailure(lines, 'E1083:')
lines =<< trim LINES
var text =<< eval trim END
let b = `=abc
END
LINES
v9.CheckDefAndScriptFailure(lines, 'E1083:')
lines =<< trim LINES
var text =<< eval trim END
let b = `=`
END
LINES
v9.CheckDefAndScriptFailure(lines, 'E15:')
enddef
" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker

21
src/userfunc.c
View File

@ -1077,12 +1077,23 @@ get_function_body(
|| checkforcmd(&p, "const", 5))))
{
p = skipwhite(arg + 3);
if (STRNCMP(p, "trim", 4) == 0)
while (TRUE)
{
// Ignore leading white space.
p = skipwhite(p + 4);
heredoc_trimmed = vim_strnsave(theline,
skipwhite(theline) - theline);
if (STRNCMP(p, "trim", 4) == 0)
{
// Ignore leading white space.
p = skipwhite(p + 4);
heredoc_trimmed = vim_strnsave(theline,
skipwhite(theline) - theline);
continue;
}
if (STRNCMP(p, "eval", 4) == 0)
{
// Ignore leading white space.
p = skipwhite(p + 4);
continue;
}
break;
}
skip_until = vim_strnsave(p, skiptowhite(p) - p);
getline_options = GETLINE_NONE;

2
src/version.c
View File

@ -746,6 +746,8 @@ static char *(features[]) =
static int included_patches[] =
{ /* Add new patch number below this line */
/**/
4770,
/**/
4769,
/**/