diff options
| -rw-r--r-- | src/alloc.c | 14 | ||||
| -rw-r--r-- | src/dict.c | 4 | ||||
| -rw-r--r-- | src/eval.c | 4 | ||||
| -rw-r--r-- | src/evalvars.c | 74 | ||||
| -rw-r--r-- | src/proto/alloc.pro | 4 | ||||
| -rw-r--r-- | src/proto/evalvars.pro | 4 | ||||
| -rw-r--r-- | src/proto/typval.pro | 6 | ||||
| -rw-r--r-- | src/proto/vim9compile.pro | 1 | ||||
| -rw-r--r-- | src/testdir/test_expr.vim | 8 | ||||
| -rw-r--r-- | src/testdir/test_let.vim | 5 | ||||
| -rw-r--r-- | src/typval.c | 156 | ||||
| -rw-r--r-- | src/version.c | 2 | ||||
| -rw-r--r-- | src/vim9compile.c | 52 | ||||
| -rw-r--r-- | src/vim9expr.c | 71 | ||||
| -rw-r--r-- | src/vim9instr.c | 2 |
15 files changed, 286 insertions, 121 deletions
diff --git a/src/alloc.c b/src/alloc.c index 5218d0046..6d4db629e 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -832,7 +832,7 @@ ga_add_string(garray_T *gap, char_u *p) /* * Concatenate a string to a growarray which contains bytes. - * When "s" is NULL does not do anything. + * When "s" is NULL memory allocation fails does not do anything. * Note: Does NOT copy the NUL at the end! */ void @@ -869,14 +869,14 @@ ga_concat_len(garray_T *gap, char_u *s, size_t len) /* * Append one byte to a growarray which contains bytes. */ - void + int ga_append(garray_T *gap, int c) { - if (ga_grow(gap, 1) == OK) - { - *((char *)gap->ga_data + gap->ga_len) = c; - ++gap->ga_len; - } + if (ga_grow(gap, 1) == FAIL) + return FAIL; + *((char *)gap->ga_data + gap->ga_len) = c; + ++gap->ga_len; + return OK; } #if (defined(UNIX) && !defined(USE_SYSTEM)) || defined(MSWIN) \ diff --git a/src/dict.c b/src/dict.c index 88cc4b3fc..538dd8ba2 100644 --- a/src/dict.c +++ b/src/dict.c @@ -866,13 +866,13 @@ get_literal_key(char_u **arg) if (**arg == '\'') { - if (eval_lit_string(arg, &rettv, TRUE) == FAIL) + if (eval_lit_string(arg, &rettv, TRUE, FALSE) == FAIL) return NULL; key = rettv.vval.v_string; } else if (**arg == '"') { - if (eval_string(arg, &rettv, TRUE) == FAIL) + if (eval_string(arg, &rettv, TRUE, FALSE) == FAIL) return NULL; key = rettv.vval.v_string; } diff --git a/src/eval.c b/src/eval.c index 4906fa614..ac3c998a5 100644 --- a/src/eval.c +++ b/src/eval.c @@ -3726,13 +3726,13 @@ eval7( /* * String constant: "string". */ - case '"': ret = eval_string(arg, rettv, evaluate); + case '"': ret = eval_string(arg, rettv, evaluate, FALSE); break; /* * Literal string constant: 'str''ing'. */ - case '\'': ret = eval_lit_string(arg, rettv, evaluate); + case '\'': ret = eval_lit_string(arg, rettv, evaluate, FALSE); break; /* diff --git a/src/evalvars.c b/src/evalvars.c index 2f285189b..d8ee21608 100644 --- a/src/evalvars.c +++ b/src/evalvars.c @@ -603,16 +603,52 @@ list_script_vars(int *first) } /* - * Evaluate all the Vim expressions ({expr}) in string "str" and return the - * resulting string. The caller must free the returned string. + * Evaluate one Vim expression {expr} in string "p" and append the + * resulting string to "gap". "p" points to the opening "{". + * Return a pointer to the character after "}", NULL for an error. + */ + char_u * +eval_one_expr_in_str(char_u *p, garray_T *gap) +{ + char_u *block_start = skipwhite(p + 1); // skip the opening { + char_u *block_end = block_start; + char_u *expr_val; + + if (*block_start == NUL) + { + semsg(_(e_missing_close_curly_str), p); + return NULL; + } + if (skip_expr(&block_end, NULL) == FAIL) + return NULL; + block_end = skipwhite(block_end); + if (*block_end != '}') + { + semsg(_(e_missing_close_curly_str), p); + return NULL; + } + *block_end = NUL; + expr_val = eval_to_string(block_start, TRUE); + *block_end = '}'; + if (expr_val == NULL) + return NULL; + ga_concat(gap, expr_val); + vim_free(expr_val); + + return block_end + 1; +} + +/* + * Evaluate all the Vim expressions {expr} in "str" and return the resulting + * string in allocated memory. "{{" is reduced to "{" and "}}" to "}". + * Used for a heredoc assignment. + * Returns NULL for an error. */ char_u * eval_all_expr_in_str(char_u *str) { garray_T ga; char_u *p; - char_u save_c; - char_u *expr_val; ga_init2(&ga, 1, 80); p = str; @@ -620,8 +656,6 @@ eval_all_expr_in_str(char_u *str) while (*p != NUL) { char_u *lit_start; - char_u *block_start; - char_u *block_end; int escaped_brace = FALSE; // Look for a block start. @@ -656,35 +690,13 @@ eval_all_expr_in_str(char_u *str) continue; } - // Skip the opening {. - block_start = ++p; - block_end = block_start; - if (*block_start != NUL && skip_expr(&block_end, NULL) == FAIL) - { - ga_clear(&ga); - return NULL; - } - block_end = skipwhite(block_end); - // The block must be closed by a }. - if (*block_end != '}') - { - semsg(_(e_missing_close_curly_str), str); - ga_clear(&ga); - return NULL; - } - save_c = *block_end; - *block_end = NUL; - expr_val = eval_to_string(block_start, TRUE); - *block_end = save_c; - if (expr_val == NULL) + // Evaluate the expression and append the result. + p = eval_one_expr_in_str(p, &ga); + if (p == NULL) { ga_clear(&ga); return NULL; } - ga_concat(&ga, expr_val); - vim_free(expr_val); - - p = block_end + 1; } ga_append(&ga, NUL); diff --git a/src/proto/alloc.pro b/src/proto/alloc.pro index b605f28a5..fe20810c1 100644 --- a/src/proto/alloc.pro +++ b/src/proto/alloc.pro @@ -19,13 +19,13 @@ int ga_copy_strings(garray_T *from, garray_T *to); void ga_init(garray_T *gap); void ga_init2(garray_T *gap, size_t itemsize, int growsize); int ga_grow(garray_T *gap, int n); -int ga_grow_id(garray_T *gap, int n, alloc_id_T id UNUSED); +int ga_grow_id(garray_T *gap, int n, alloc_id_T id); int ga_grow_inner(garray_T *gap, int n); char_u *ga_concat_strings(garray_T *gap, char *sep); int ga_copy_string(garray_T *gap, char_u *p); int ga_add_string(garray_T *gap, char_u *p); void ga_concat(garray_T *gap, char_u *s); void ga_concat_len(garray_T *gap, char_u *s, size_t len); -void ga_append(garray_T *gap, int c); +int ga_append(garray_T *gap, int c); void append_ga_line(garray_T *gap); /* vim: set ft=c : */ diff --git a/src/proto/evalvars.pro b/src/proto/evalvars.pro index 97bec7df3..ce794351d 100644 --- a/src/proto/evalvars.pro +++ b/src/proto/evalvars.pro @@ -13,6 +13,8 @@ list_T *eval_spell_expr(char_u *badword, char_u *expr); int get_spellword(list_T *list, char_u **pp); void prepare_vimvar(int idx, typval_T *save_tv); void restore_vimvar(int idx, typval_T *save_tv); +char_u *eval_one_expr_in_str(char_u *p, garray_T *gap); +char_u *eval_all_expr_in_str(char_u *str); list_T *heredoc_get(exarg_T *eap, char_u *cmd, int script_get, int vim9compile); void ex_var(exarg_T *eap); void ex_let(exarg_T *eap); @@ -105,6 +107,4 @@ void set_callback(callback_T *dest, callback_T *src); void copy_callback(callback_T *dest, callback_T *src); void expand_autload_callback(callback_T *cb); void free_callback(callback_T *callback); -char_u *eval_all_expr_in_str(char_u *str); - /* vim: set ft=c : */ diff --git a/src/proto/typval.pro b/src/proto/typval.pro index 5b1f97431..6a8d0acf4 100644 --- a/src/proto/typval.pro +++ b/src/proto/typval.pro @@ -68,11 +68,11 @@ int tv_islocked(typval_T *tv); int tv_equal(typval_T *tv1, typval_T *tv2, int ic, int recursive); int eval_option(char_u **arg, typval_T *rettv, int evaluate); int eval_number(char_u **arg, typval_T *rettv, int evaluate, int want_string); -int eval_string(char_u **arg, typval_T *rettv, int evaluate); -int eval_lit_string(char_u **arg, typval_T *rettv, int evaluate); +int eval_string(char_u **arg, typval_T *rettv, int evaluate, int interpolate); +int eval_lit_string(char_u **arg, typval_T *rettv, int evaluate, int interpolate); +int eval_interp_string(char_u **arg, typval_T *rettv, int evaluate); char_u *tv2string(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID); int eval_env_var(char_u **arg, typval_T *rettv, int evaluate); -int eval_interp_string(char_u **arg, typval_T *rettv, int evaluate); linenr_T tv_get_lnum(typval_T *argvars); linenr_T tv_get_lnum_buf(typval_T *argvars, buf_T *buf); buf_T *tv_get_buf(typval_T *tv, int curtab_only); diff --git a/src/proto/vim9compile.pro b/src/proto/vim9compile.pro index 03f7df1a6..e6c6f3eff 100644 --- a/src/proto/vim9compile.pro +++ b/src/proto/vim9compile.pro @@ -16,6 +16,7 @@ int may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx); int may_get_next_line_error(char_u *whitep, char_u **arg, cctx_T *cctx); void fill_exarg_from_cctx(exarg_T *eap, cctx_T *cctx); int func_needs_compiling(ufunc_T *ufunc, compiletype_T compile_type); +char_u *compile_one_expr_in_str(char_u *p, cctx_T *cctx); int compile_all_expr_in_str(char_u *str, int evalstr, cctx_T *cctx); int assignment_len(char_u *p, int *heredoc); void vim9_declare_error(char_u *name); diff --git a/src/testdir/test_expr.vim b/src/testdir/test_expr.vim index 3ea59eb26..0b6b57e4a 100644 --- a/src/testdir/test_expr.vim +++ b/src/testdir/test_expr.vim @@ -897,7 +897,7 @@ func Test_string_interp() #" Escaping rules. call assert_equal('"foo"{bar}', $"\"foo\"{{bar}}") call assert_equal('"foo"{bar}', $'"foo"{{bar}}') - call assert_equal('foobar', $"{\"foo\"}" .. $'{''bar''}') + call assert_equal('foobar', $"{"foo"}" .. $'{'bar'}') #" Whitespace before/after the expression. call assert_equal('3', $"{ 1 + 2 }") #" String conversion. @@ -907,8 +907,8 @@ func Test_string_interp() call assert_equal(string(v:true), $"{v:true}") call assert_equal('(1+1=2)', $"(1+1={1 + 1})") #" Hex-escaped opening brace: char2nr('{') == 0x7b - call assert_equal('esc123ape', $"esc\x7b123}ape") - call assert_equal('me{}me', $"me{\x7b}\x7dme") + call assert_equal('esc123ape', $"esc{123}ape") + call assert_equal('me{}me', $"me{"\x7b"}\x7dme") VAR var1 = "sun" VAR var2 = "shine" call assert_equal('sunshine', $"{var1}{var2}") @@ -916,7 +916,7 @@ func Test_string_interp() #" Multibyte strings. call assert_equal('say ハロー・ワールド', $"say {'ハロー・ワールド'}") #" Nested. - call assert_equal('foobarbaz', $"foo{$\"{'bar'}\"}baz") + call assert_equal('foobarbaz', $"foo{$"{'bar'}"}baz") #" Do not evaluate blocks when the expr is skipped. VAR tmp = 0 if v:false diff --git a/src/testdir/test_let.vim b/src/testdir/test_let.vim index 7e1a9232e..fb315e89e 100644 --- a/src/testdir/test_let.vim +++ b/src/testdir/test_let.vim @@ -387,9 +387,8 @@ func Test_let_interpolated() let text = 'text' call assert_equal('text{{', $'{text .. "{{"}') call assert_equal('text{{', $"{text .. '{{'}") - " FIXME: should not need to escape quotes in the expression - call assert_equal('text{{', $'{text .. ''{{''}') - call assert_equal('text{{', $"{text .. \"{{\"}") + call assert_equal('text{{', $'{text .. '{{'}') + call assert_equal('text{{', $"{text .. "{{"}") endfunc " Test for the setting a variable using the heredoc syntax. diff --git a/src/typval.c b/src/typval.c index ba98f1e84..09dc47493 100644 --- a/src/typval.c +++ b/src/typval.c @@ -2065,19 +2065,23 @@ eval_number( } /* - * Allocate a variable for a string constant. + * Evaluate a string constant and put the result in "rettv". + * "*arg" points to the double quote or to after it when "interpolate" is TRUE. + * When "interpolate" is TRUE reduce "{{" to "{", reduce "}}" to "}" and stop + * at a single "{". * Return OK or FAIL. */ int -eval_string(char_u **arg, typval_T *rettv, int evaluate) +eval_string(char_u **arg, typval_T *rettv, int evaluate, int interpolate) { char_u *p; char_u *end; - int extra = 0; + int extra = interpolate ? 1 : 0; + int off = interpolate ? 0 : 1; int len; // Find the end of the string, skipping backslashed characters. - for (p = *arg + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p)) + for (p = *arg + off; *p != NUL && *p != '"'; MB_PTR_ADV(p)) { if (*p == '\\' && p[1] != NUL) { @@ -2088,9 +2092,21 @@ eval_string(char_u **arg, typval_T *rettv, int evaluate) if (*p == '<') extra += 5; } + else if (interpolate && (*p == '{' || *p == '}')) + { + if (*p == '{' && p[1] != '{') // start of expression + break; + ++p; + if (p[-1] == '}' && *p != '}') // single '}' is an error + { + semsg(_(e_stray_closing_curly_str), *arg); + return FAIL; + } + --extra; // "{{" becomes "{", "}}" becomes "}" + } } - if (*p != '"') + if (*p != '"' && !(interpolate && *p == '{')) { semsg(_(e_missing_double_quote_str), *arg); return FAIL; @@ -2099,7 +2115,7 @@ eval_string(char_u **arg, typval_T *rettv, int evaluate) // If only parsing, set *arg and return here if (!evaluate) { - *arg = p + 1; + *arg = p + off; return OK; } @@ -2112,7 +2128,7 @@ eval_string(char_u **arg, typval_T *rettv, int evaluate) return FAIL; end = rettv->vval.v_string; - for (p = *arg + 1; *p != NUL && *p != '"'; ) + for (p = *arg + off; *p != NUL && *p != '"'; ) { if (*p == '\\') { @@ -2192,15 +2208,23 @@ eval_string(char_u **arg, typval_T *rettv, int evaluate) } // FALLTHROUGH - default: MB_COPY_CHAR(p, end); + default: MB_COPY_CHAR(p, end); break; } } else + { + if (interpolate && (*p == '{' || *p == '}')) + { + if (*p == '{' && p[1] != '{') // start of expression + break; + ++p; // reduce "{{" to "{" and "}}" to "}" + } MB_COPY_CHAR(p, end); + } } *end = NUL; - if (*p != NUL) // just in case + if (*p == '"' && !interpolate) ++p; *arg = p; @@ -2209,17 +2233,20 @@ eval_string(char_u **arg, typval_T *rettv, int evaluate) /* * Allocate a variable for a 'str''ing' constant. - * Return OK or FAIL. + * When "interpolate" is TRUE reduce "{{" to "{" and stop at a single "{". + * Return OK when a "rettv" was set to the string. + * Return FAIL on error, "rettv" is not set. */ int -eval_lit_string(char_u **arg, typval_T *rettv, int evaluate) +eval_lit_string(char_u **arg, typval_T *rettv, int evaluate, int interpolate) { char_u *p; char_u *str; - int reduce = 0; + int reduce = interpolate ? -1 : 0; + int off = interpolate ? 0 : 1; // Find the end of the string, skipping ''. - for (p = *arg + 1; *p != NUL; MB_PTR_ADV(p)) + for (p = *arg + off; *p != NUL; MB_PTR_ADV(p)) { if (*p == '\'') { @@ -2228,9 +2255,29 @@ eval_lit_string(char_u **arg, typval_T *rettv, int evaluate) ++reduce; ++p; } + else if (interpolate) + { + if (*p == '{') + { + if (p[1] != '{') + break; + ++p; + ++reduce; + } + else if (*p == '}') + { + ++p; + if (*p != '}') + { + semsg(_(e_stray_closing_curly_str), *arg); + return FAIL; + } + ++reduce; + } + } } - if (*p != '\'') + if (*p != '\'' && !(interpolate && *p == '{')) { semsg(_(e_missing_single_quote_str), *arg); return FAIL; @@ -2239,18 +2286,19 @@ eval_lit_string(char_u **arg, typval_T *rettv, int evaluate) // If only parsing return after setting "*arg" if (!evaluate) { - *arg = p + 1; + *arg = p + off; return OK; } - // Copy the string into allocated memory, handling '' to ' reduction. + // Copy the string into allocated memory, handling '' to ' reduction and + // any expressions. str = alloc((p - *arg) - reduce); if (str == NULL) return FAIL; rettv->v_type = VAR_STRING; rettv->vval.v_string = str; - for (p = *arg + 1; *p != NUL; ) + for (p = *arg + off; *p != NUL; ) { if (*p == '\'') { @@ -2258,38 +2306,82 @@ eval_lit_string(char_u **arg, typval_T *rettv, int evaluate) break; ++p; } + else if (interpolate && (*p == '{' || *p == '}')) + { + if (*p == '{' && p[1] != '{') + break; + ++p; + } MB_COPY_CHAR(p, str); } *str = NUL; - *arg = p + 1; + *arg = p + off; return OK; } +/* + * Evaluate a single or double quoted string possibly containing expressions. + * "arg" points to the '$'. The result is put in "rettv". + * Returns OK or FAIL. + */ int eval_interp_string(char_u **arg, typval_T *rettv, int evaluate) { typval_T tv; - int ret; - - // *arg is on the '$' character. - (*arg)++; + int ret = OK; + int quote; + garray_T ga; + char_u *p; - rettv->v_type = VAR_STRING; + ga_init2(&ga, 1, 80); - if (**arg == '"') - ret = eval_string(arg, &tv, evaluate); - else - ret = eval_lit_string(arg, &tv, evaluate); + // *arg is on the '$' character, move it to the first string character. + ++*arg; + quote = **arg; + ++*arg; - if (ret == FAIL || !evaluate) - return ret; + for (;;) + { + // Get the string up to the matching quote or to a single '{'. + // "arg" is advanced to either the quote or the '{'. + if (quote == '"') + ret = eval_string(arg, &tv, evaluate, TRUE); + else + ret = eval_lit_string(arg, &tv, evaluate, TRUE); + if (ret == FAIL) + break; + if (evaluate) + { + ga_concat(&ga, tv.vval.v_string); + clear_tv(&tv); + } - rettv->vval.v_string = eval_all_expr_in_str(tv.vval.v_string); + if (**arg != '{') + { + // found terminating quote + ++*arg; + break; + } + p = eval_one_expr_in_str(*arg, &ga); + if (p == NULL) + { + ret = FAIL; + break; + } + *arg = p; + } - clear_tv(&tv); + rettv->v_type = VAR_STRING; + if (ret == FAIL || !evaluate || ga_append(&ga, NUL) == FAIL) + { + ga_clear(&ga); + rettv->vval.v_string = NULL; + return ret; + } - return rettv->vval.v_string != NULL ? OK : FAIL; + rettv->vval.v_string = ga.ga_data; + return OK; } /* diff --git a/src/version.c b/src/version.c index 6fbc3bec0..0a08909cb 100644 --- a/src/version.c +++ b/src/version.c @@ -747,6 +747,8 @@ static char *(features[]) = static int included_patches[] = { /* Add new patch number below this line */ /**/ + 4930, +/**/ 4929, /**/ 4928, diff --git a/src/vim9compile.c b/src/vim9compile.c index bdaf1eddc..8ab4e2957 100644 --- a/src/vim9compile.c +++ b/src/vim9compile.c @@ -969,6 +969,36 @@ theend: } /* + * Compile one Vim expression {expr} in string "p". + * "p" points to the opening "{". + * Return a pointer to the character after "}", NULL for an error. + */ + char_u * +compile_one_expr_in_str(char_u *p, cctx_T *cctx) +{ + char_u *block_start; + char_u *block_end; + + // Skip the opening {. + block_start = skipwhite(p + 1); + block_end = block_start; + if (*block_start != NUL && skip_expr(&block_end, NULL) == FAIL) + return NULL; + block_end = skipwhite(block_end); + // The block must be closed by a }. + if (*block_end != '}') + { + semsg(_(e_missing_close_curly_str), p); + return NULL; + } + if (compile_expr0(&block_start, cctx) == FAIL) + return NULL; + may_generate_2STRING(-1, TRUE, cctx); + + return block_end + 1; +} + +/* * Compile a string "str" (either containing a literal string or a mix of * literal strings and Vim expressions of the form `{expr}`). This is used * when compiling a heredoc assignment to a variable or an interpolated string @@ -997,8 +1027,6 @@ compile_all_expr_in_str(char_u *str, int evalstr, cctx_T *cctx) while (*p != NUL) { char_u *lit_start; - char_u *block_start; - char_u *block_end; int escaped_brace = FALSE; // Look for a block start. @@ -1038,28 +1066,14 @@ compile_all_expr_in_str(char_u *str, int evalstr, cctx_T *cctx) continue; } - // Skip the opening {. - block_start = skipwhite(p + 1); - block_end = block_start; - if (*block_start != NUL && skip_expr(&block_end, NULL) == FAIL) - return FAIL; - block_end = skipwhite(block_end); - // The block must be closed by a }. - if (*block_end != '}') - { - semsg(_(e_missing_close_curly_str), str); - return FAIL; - } - if (compile_expr0(&block_start, cctx) == FAIL) + p = compile_one_expr_in_str(p, cctx); + if (p == NULL) return FAIL; - may_generate_2STRING(-1, TRUE, cctx); ++count; - - p = block_end + 1; } // Small optimization, if there's only a single piece skip the ISN_CONCAT. - if (count != 1) + if (count > 1) return generate_CONCAT(cctx, count); return OK; diff --git a/src/vim9expr.c b/src/vim9expr.c index 8bda461de..36a3695e9 100644 --- a/src/vim9expr.c +++ b/src/vim9expr.c @@ -762,9 +762,9 @@ compile_call( argvars[0].v_type = VAR_UNKNOWN; if (*s == '"') - (void)eval_string(&s, &argvars[0], TRUE); + (void)eval_string(&s, &argvars[0], TRUE, FALSE); else if (*s == '\'') - (void)eval_lit_string(&s, &argvars[0], TRUE); + (void)eval_lit_string(&s, &argvars[0], TRUE, FALSE); s = skipwhite(s); if (*s == ')' && argvars[0].v_type == VAR_STRING && ((is_has && !dynamic_feature(argvars[0].vval.v_string)) @@ -1375,30 +1375,73 @@ compile_get_env(char_u **arg, cctx_T *cctx) } /* - * Compile "$"string"" or "$'string'". + * Compile $"string" or $'string'. */ static int compile_interp_string(char_u **arg, cctx_T *cctx) { typval_T tv; int ret; + int quote; int evaluate = cctx->ctx_skip != SKIP_YES; + int count = 0; + char_u *p; - // *arg is on the '$' character. - (*arg)++; + // *arg is on the '$' character, move it to the first string character. + ++*arg; + quote = **arg; + ++*arg; - if (**arg == '"') - ret = eval_string(arg, &tv, evaluate); - else - ret = eval_lit_string(arg, &tv, evaluate); + for (;;) + { + // Get the string up to the matching quote or to a single '{'. + // "arg" is advanced to either the quote or the '{'. + if (quote == '"') + ret = eval_string(arg, &tv, evaluate, TRUE); + else + ret = eval_lit_string(arg, &tv, evaluate, TRUE); + if (ret == FAIL) + break; + if (evaluate) + { + if ((tv.vval.v_string != NULL && *tv.vval.v_string != NUL) + || (**arg != '{' && count == 0)) + { + // generate non-empty string or empty string if it's the only + // one + if (generate_PUSHS(cctx, &tv.vval.v_string) == FAIL) + return FAIL; + tv.vval.v_string = NULL; // don't free it now + ++count; + } + clear_tv(&tv); + } + + if (**arg != '{') + { + // found terminating quote + ++*arg; + break; + } + + p = compile_one_expr_in_str(*arg, cctx); + if (p == NULL) + { + ret = FAIL; + break; + } + ++count; + *arg = p; + } if (ret == FAIL || !evaluate) return ret; - ret = compile_all_expr_in_str(tv.vval.v_string, TRUE, cctx); - clear_tv(&tv); + // Small optimization, if there's only a single piece skip the ISN_CONCAT. + if (count > 1) + return generate_CONCAT(cctx, count); - return ret; + return OK; } /* @@ -2161,14 +2204,14 @@ compile_expr8( /* * String constant: "string". */ - case '"': if (eval_string(arg, rettv, TRUE) == FAIL) + case '"': if (eval_string(arg, rettv, TRUE, FALSE) == FAIL) return FAIL; break; /* * Literal string constant: 'str''ing'. */ - case '\'': if (eval_lit_string(arg, rettv, TRUE) == FAIL) + case '\'': if (eval_lit_string(arg, rettv, TRUE, FALSE) == FAIL) return FAIL; break; diff --git a/src/vim9instr.c b/src/vim9instr.c index 93ac062a3..edc5db045 100644 --- a/src/vim9instr.c +++ b/src/vim9instr.c @@ -726,6 +726,8 @@ generate_PUSHF(cctx_T *cctx, float_T fnumber) /* * Generate an ISN_PUSHS instruction. * Consumes "*str". When freed *str is set to NULL, unless "str" is NULL. + * Note that if "str" is used in the instruction OK is returned and "*str" is + * not set to NULL. */ int generate_PUSHS(cctx_T *cctx, char_u **str) |