vim: src/vim9cmds.c comparison

comparison src/vim9cmds.c @ 30333:fc0830246f49 v9.0.0502

patch 9.0.0502: a closure in a nested loop in a :def function does not work Commit: https://github.com/vim/vim/commit/cc34181f9994d64f8c8fa2f5845eaf0cc963067f Author: Bram Moolenaar <Bram@vim.org> Date: Mon Sep 19 15:54:34 2022 +0100 patch 9.0.0502: a closure in a nested loop in a :def function does not work Problem: A closure in a nested loop in a :def function does not work. Solution: Use an array of loopvars, one per loop level.

author	Bram Moolenaar <Bram@vim.org>
date	Mon, 19 Sep 2022 17:00:07 +0200
parents	bee38b1d323c
children	ee039a6049ff

comparison

equal deleted inserted replaced

-:462d122636b3
+:fc0830246f49
 	return NULL;
 scope->se_outer = cctx->ctx_scope;
 cctx->ctx_scope = scope;
 scope->se_type = type;
 scope->se_local_count = cctx->ctx_locals.ga_len;
+if (scope->se_outer != NULL)
+	scope->se_loop_depth = scope->se_outer->se_loop_depth;
 return scope;
 }
 /*
 * Free the current scope and go back to the outer scope.
 size_t	varlen;
 garray_T	*instr = &cctx->ctx_instr;
 scope_T	*scope;
 forscope_T	*forscope;
 lvar_T	*loop_lvar;	// loop iteration variable
+int		loop_lvar_idx;
 lvar_T	*funcref_lvar;
+int		funcref_lvar_idx;
 lvar_T	*var_lvar;	// variable for "var"
 type_T	*vartype;
 type_T	*item_type = &t_any;
 int		idx;
 int		prev_lnum = cctx->ctx_prev_lnum;
 }
 scope = new_scope(cctx, FOR_SCOPE);
 if (scope == NULL)
 	return NULL;
+if (scope->se_loop_depth == MAX_LOOP_DEPTH)
+{
+	emsg(_(e_loop_nesting_too_deep));
+	return NULL;
+}
+++scope->se_loop_depth;
 forscope = &scope->se_u.se_for;
 // Reserve a variable to store the loop iteration counter and initialize it
 // to -1.
 loop_lvar = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number);
 if (loop_lvar == NULL)
 {
 	drop_scope(cctx);
 	return NULL;  // out of memory
 }
-generate_STORENR(cctx, loop_lvar->lv_idx, -1);
+// get the index before a following reserve_local() makes the lval invalid
+loop_lvar_idx = loop_lvar->lv_idx;
+generate_STORENR(cctx, loop_lvar_idx, -1);
 // Reserve a variable to store ec_funcrefs.ga_len, used in ISN_ENDLOOP.
 // The variable index is always the loop var index plus one.
 // It is not used when no closures are encountered, we don't know yet.
 funcref_lvar = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number);
 if (funcref_lvar == NULL)
 {
 	drop_scope(cctx);
 	return NULL;  // out of memory
 }
+// get the index before a following reserve_local() makes the lval invalid
+funcref_lvar_idx = funcref_lvar->lv_idx;
 // compile "expr", it remains on the stack until "endfor"
 arg = p;
 if (compile_expr0(&arg, cctx) == FAIL)
 {
 	    isn = generate_instr_debug(cctx);
 	    ++isn->isn_arg.debug.dbg_var_names_len;
 	    cctx->ctx_prev_lnum = save_prev_lnum;
 	}
-	generate_FOR(cctx, loop_lvar->lv_idx);
+	generate_FOR(cctx, loop_lvar_idx);
 	arg = arg_start;
 	if (var_list)
 	{
 	    generate_UNPACK(cctx, var_count, semicolon);
 	    arg = skipwhite(p);
 	    vim_free(name);
 	}
 	// remember the number of variables and closures, used for ENDLOOP
-	compile_fill_loop_info(&forscope->fs_loop_info,
+	compile_fill_loop_info(&forscope->fs_loop_info, funcref_lvar_idx, cctx);
-						   funcref_lvar->lv_idx, cctx);
+	forscope->fs_loop_info.li_depth = scope->se_loop_depth - 1;
 }
 return arg_end;
 failed:
 static int
 compile_loop_end(loop_info_T *loop_info, cctx_T *cctx)
 {
 if (cctx->ctx_locals.ga_len > loop_info->li_local_count
 	    && cctx->ctx_closure_count > loop_info->li_closure_count)
-	return generate_ENDLOOP(cctx, loop_info->li_funcref_idx,
+	return generate_ENDLOOP(cctx, loop_info);
-						    loop_info->li_local_count);
 return OK;
 }
 /*
 * compile "endfor"
 {
 char_u	    *p = arg;
 scope_T	    *scope;
 whilescope_T    *whilescope;
 lvar_T	    *funcref_lvar;
+int		    funcref_lvar_idx;
 scope = new_scope(cctx, WHILE_SCOPE);
 if (scope == NULL)
 	return NULL;
+if (scope->se_loop_depth == MAX_LOOP_DEPTH)
+{
+	emsg(_(e_loop_nesting_too_deep));
+	return NULL;
+}
+++scope->se_loop_depth;
 whilescope = &scope->se_u.se_while;
 // "endwhile" jumps back here, one before when profiling or using cmdmods
 whilescope->ws_top_label = current_instr_idx(cctx);
 if (funcref_lvar == NULL)
 {
 	drop_scope(cctx);
 	return NULL;  // out of memory
 }
+// get the index before a following reserve_local() makes the lval invalid
+funcref_lvar_idx = funcref_lvar->lv_idx;
 // remember the number of variables and closures, used for ENDLOOP
-compile_fill_loop_info(&whilescope->ws_loop_info,
+compile_fill_loop_info(&whilescope->ws_loop_info, funcref_lvar_idx, cctx);
-						   funcref_lvar->lv_idx, cctx);
+whilescope->ws_loop_info.li_depth = scope->se_loop_depth - 1;
 // compile "expr"
 if (compile_expr0(&p, cctx) == FAIL)
 	return NULL;
 	// CMDMOD_REV must come before the jump
 	generate_undo_cmdmods(cctx);
 	// "while_end" is set when ":endwhile" is found
 	if (compile_jump_to_end(&whilescope->ws_end_label,
-			 JUMP_WHILE_FALSE, funcref_lvar->lv_idx, cctx) == FAIL)
+			     JUMP_WHILE_FALSE, funcref_lvar_idx, cctx) == FAIL)
 	    return FAIL;
 }
 return p;
 }
 return arg;
 }
 /*
 * Get the current information about variables declared inside a loop.
-* Returns zero if there are none, otherwise the count.
+* Returns TRUE if there are any and fills "lvi".
-* "loop_var_idx" is then set to the index of the first variable.
+*/
-*/
+int
-short
+get_loop_var_info(cctx_T *cctx, loopvarinfo_T *lvi)
-get_loop_var_info(cctx_T *cctx, short *loop_var_idx)
 {
 scope_T	*scope = cctx->ctx_scope;
-int		start_local_count;
+int		prev_local_count = 0;
-while (scope != NULL && scope->se_type != WHILE_SCOPE
+CLEAR_POINTER(lvi);
+for (;;)
+{
+	loop_info_T	*loopinfo;
+	int		cur_local_last;
+	int		start_local_count;
+	while (scope != NULL && scope->se_type != WHILE_SCOPE
 						&& scope->se_type != FOR_SCOPE)
+	    scope = scope->se_outer;
+	if (scope == NULL)
+	    break;
+	if (scope->se_type == WHILE_SCOPE)
+	{
+	    loopinfo = &scope->se_u.se_while.ws_loop_info;
+	    // :while reserves one variable for funcref count
+	    cur_local_last = loopinfo->li_local_count - 1;
+	}
+	else
+	{
+	    loopinfo = &scope->se_u.se_for.fs_loop_info;
+	    // :for reserves three variable: loop count, funcref count and loop
+	    // var
+	    cur_local_last = loopinfo->li_local_count - 3;
+	}
+	start_local_count = loopinfo->li_local_count;
+	if (cctx->ctx_locals.ga_len > start_local_count)
+	{
+	    lvi->lvi_loop[loopinfo->li_depth].var_idx =
+						      (short)start_local_count;
+	    lvi->lvi_loop[loopinfo->li_depth].var_count =
+			  (short)(cctx->ctx_locals.ga_len - start_local_count
+							   - prev_local_count);
+	    if (lvi->lvi_depth == 0)
+		lvi->lvi_depth = loopinfo->li_depth + 1;
+	}
 	scope = scope->se_outer;
-if (scope == NULL)
+	prev_local_count = cctx->ctx_locals.ga_len - cur_local_last;
-	return 0;
+}
+return lvi->lvi_depth > 0;
-if (scope->se_type == WHILE_SCOPE)
+}
-	start_local_count = scope->se_u.se_while.ws_loop_info.li_local_count;
-else
+/*
-	start_local_count = scope->se_u.se_for.fs_loop_info.li_local_count;
+* Get the index of the variable "idx" in a loop, if any.
-if (cctx->ctx_locals.ga_len > start_local_count)
+*/
-{
+void
-	*loop_var_idx = (short)start_local_count;
+get_loop_var_idx(cctx_T *cctx, int idx, lvar_T *lvar)
-	return (short)(cctx->ctx_locals.ga_len - start_local_count);
+{
-}
+loopvarinfo_T lvi;
-return 0;
-}
+lvar->lv_loop_depth = -1;
+lvar->lv_loop_idx = -1;
-/*
+if (get_loop_var_info(cctx, &lvi))
-* Get the index of the first variable in a loop, if any.
+{
-* Returns -1 if none.
+	int depth;
-*/
-int
+	for (depth = lvi.lvi_depth - 1; depth >= 0; --depth)
-get_loop_var_idx(cctx_T *cctx)
+	    if (idx >= lvi.lvi_loop[depth].var_idx
-{
+		    && idx < lvi.lvi_loop[depth].var_idx
-short loop_var_idx;
+					       + lvi.lvi_loop[depth].var_count)
+	    {
-if (get_loop_var_info(cctx, &loop_var_idx) > 0)
+		lvar->lv_loop_depth = depth;
-	return loop_var_idx;
+		lvar->lv_loop_idx = lvi.lvi_loop[depth].var_idx;
-return -1;
+		return;
+	    }
+}
 }
 /*
 * Common for :break, :continue and :return
 */

Mercurial > vim

comparison src/vim9cmds.c @ 30333:fc0830246f49 v9.0.0502