Problem: Vim9: list unpack in for statement not compiled yet.
Solution: Compile list unpack. (closes #7345)
#ifdef FEAT_EVAL
EXTERN char e_invalid_command_str[]
INIT(= N_("E476: Invalid command: %s"));
+EXTERN char e_list_value_has_more_items_than_targets[]
+ INIT(= N_("E710: List value has more items than targets"));
+EXTERN char e_list_value_does_not_have_enough_items[]
+ INIT(= N_("E711: List value does not have enough items"));
EXTERN char e_cannot_slice_dictionary[]
INIT(= N_("E719: Cannot slice a Dictionary"));
EXTERN char e_assert_fails_second_arg[]
INIT(= N_("E1138: Using a Bool as a Number"));
EXTERN char e_missing_matching_bracket_after_dict_key[]
INIT(= N_("E1139: Missing matching bracket after dict key"));
+EXTERN char e_for_argument_must_be_sequence_of_lists[]
+ INIT(= N_("E1140: For argument must be a sequence of lists"));
++lp->ll_n1;
}
if (ri != NULL)
- emsg(_("E710: List value has more items than target"));
+ emsg(_(e_list_value_has_more_items_than_targets));
else if (lp->ll_empty2
? (lp->ll_li != NULL && lp->ll_li->li_next != NULL)
: lp->ll_n1 != lp->ll_n2)
- emsg(_("E711: List value has not enough items"));
+ emsg(_(e_list_value_does_not_have_enough_items));
}
else
{
instr)
enddef
+def ForLoopUnpack()
+ for [x1, x2] in [[1, 2], [3, 4]]
+ echo x1 x2
+ endfor
+enddef
+
+def Test_disassemble_for_loop_unpack()
+ var instr = execute('disassemble ForLoopUnpack')
+ assert_match('ForLoopUnpack\_s*' ..
+ 'for \[x1, x2\] in \[\[1, 2\], \[3, 4\]\]\_s*' ..
+ '\d\+ STORE -1 in $0\_s*' ..
+ '\d\+ PUSHNR 1\_s*' ..
+ '\d\+ PUSHNR 2\_s*' ..
+ '\d\+ NEWLIST size 2\_s*' ..
+ '\d\+ PUSHNR 3\_s*' ..
+ '\d\+ PUSHNR 4\_s*' ..
+ '\d\+ NEWLIST size 2\_s*' ..
+ '\d\+ NEWLIST size 2\_s*' ..
+ '\d\+ FOR $0 -> 16\_s*' ..
+ '\d\+ UNPACK 2\_s*' ..
+ '\d\+ STORE $1\_s*' ..
+ '\d\+ STORE $2\_s*' ..
+ 'echo x1 x2\_s*' ..
+ '\d\+ LOAD $1\_s*' ..
+ '\d\+ LOAD $2\_s*' ..
+ '\d\+ ECHO 2\_s*' ..
+ 'endfor\_s*' ..
+ '\d\+ JUMP -> 8\_s*' ..
+ '\d\+ DROP\_s*' ..
+ '\d\+ PUSHNR 0\_s*' ..
+ '\d\+ RETURN',
+ instr)
+enddef
+
let g:number = 42
def TypeCast()
CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
enddef
+def Test_for_loop_unpack()
+ var result = []
+ for [v1, v2] in [[1, 2], [3, 4]]
+ result->add(v1)
+ result->add(v2)
+ endfor
+ assert_equal([1, 2, 3, 4], result)
+
+ result = []
+ for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]]
+ result->add(v1)
+ result->add(v2)
+ result->add(v3)
+ endfor
+ assert_equal([1, 2, [], 3, 4, [5, 6]], result)
+
+ var lines =<< trim END
+ for [v1, v2] in [[1, 2, 3], [3, 4]]
+ echo v1 v2
+ endfor
+ END
+ CheckDefExecFailure(lines, 'E710:', 1)
+
+ lines =<< trim END
+ for [v1, v2] in [[1], [3, 4]]
+ echo v1 v2
+ endfor
+ END
+ CheckDefExecFailure(lines, 'E711:', 1)
+
+ lines =<< trim END
+ for [v1, v1] in [[1, 2], [3, 4]]
+ echo v1
+ endfor
+ END
+ CheckDefExecFailure(lines, 'E1017:', 1)
+enddef
+
def Test_while_loop()
var result = ''
var cnt = 0
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 2034,
/**/
2033,
/**/
ISN_CMDMOD, // set cmdmod
ISN_CMDMOD_REV, // undo ISN_CMDMOD
+ ISN_UNPACK, // unpack list into items, uses isn_arg.unpack
ISN_SHUFFLE, // move item on stack up or down
ISN_DROP // pop stack and discard value
} isntype_T;
cmdmod_T *cf_cmdmod; // allocated
} cmod_T;
+// arguments to ISN_UNPACK
+typedef struct {
+ int unp_count; // number of items to produce
+ int unp_semicolon; // last item gets list of remainder
+} unpack_T;
+
/*
* Instruction
*/
shuffle_T shuffle;
put_T put;
cmod_T cmdmod;
+ unpack_T unpack;
} isn_arg;
};
return OK;
}
+ static int
+generate_UNPACK(cctx_T *cctx, int var_count, int semicolon)
+{
+ isn_T *isn;
+
+ RETURN_OK_IF_SKIP(cctx);
+ if ((isn = generate_instr(cctx, ISN_UNPACK)) == NULL)
+ return FAIL;
+ isn->isn_arg.unpack.unp_count = var_count;
+ isn->isn_arg.unpack.unp_semicolon = semicolon;
+ return OK;
+}
+
/*
* Generate an instruction for any command modifiers.
*/
}
/*
- * compile "for var in expr"
+ * Compile "for var in expr":
*
* Produces instructions:
* PUSHNR -1
* STORE loop-idx Set index to -1
- * EVAL expr Push result of "expr"
+ * EVAL expr result of "expr" on top of stack
* top: FOR loop-idx, end Increment index, use list on bottom of stack
* - if beyond end, jump to "end"
* - otherwise get item from list and push it
* JUMP top Jump back to repeat
* end: DROP Drop the result of "expr"
*
+ * Compile "for [var1, var2] in expr" - as above, but instead of "STORE var":
+ * UNPACK 2 Split item in 2
+ * STORE var1 Store item in "var1"
+ * STORE var2 Store item in "var2"
*/
static char_u *
-compile_for(char_u *arg, cctx_T *cctx)
+compile_for(char_u *arg_start, cctx_T *cctx)
{
+ char_u *arg;
+ char_u *arg_end;
char_u *p;
+ int var_count = 0;
+ int semicolon = FALSE;
size_t varlen;
garray_T *instr = &cctx->ctx_instr;
garray_T *stack = &cctx->ctx_type_stack;
lvar_T *loop_lvar; // loop iteration variable
lvar_T *var_lvar; // variable for "var"
type_T *vartype;
+ type_T *item_type = &t_any;
+ int idx;
- // TODO: list of variables: "for [key, value] in dict"
- // parse "var"
- for (p = arg; eval_isnamec1(*p); ++p)
- ;
- varlen = p - arg;
- var_lvar = lookup_local(arg, varlen, cctx);
- if (var_lvar != NULL)
- {
- semsg(_(e_variable_already_declared), arg);
- return NULL;
- }
+ p = skip_var_list(arg_start, TRUE, &var_count, &semicolon, FALSE);
+ if (var_count == 0)
+ var_count = 1;
// consume "in"
p = skipwhite(p);
}
p = skipwhite(p + 2);
-
scope = new_scope(cctx, FOR_SCOPE);
if (scope == NULL)
return NULL;
- // Reserve a variable to store the loop iteration counter.
+ // 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;
}
-
- // Reserve a variable to store "var"
- var_lvar = reserve_local(cctx, arg, varlen, FALSE, &t_any);
- if (var_lvar == NULL)
- {
- // out of memory or used as an argument
- drop_scope(cctx);
- return NULL;
- }
-
generate_STORENR(cctx, loop_lvar->lv_idx, -1);
// compile "expr", it remains on the stack until "endfor"
drop_scope(cctx);
return NULL;
}
+ arg_end = arg;
// Now that we know the type of "var", check that it is a list, now or at
// runtime.
drop_scope(cctx);
return NULL;
}
+
if (vartype->tt_type == VAR_LIST && vartype->tt_member->tt_type != VAR_ANY)
- var_lvar->lv_type = vartype->tt_member;
+ {
+ if (var_count == 1)
+ item_type = vartype->tt_member;
+ else if (vartype->tt_member->tt_type == VAR_LIST
+ && vartype->tt_member->tt_member->tt_type != VAR_ANY)
+ item_type = vartype->tt_member->tt_member;
+ }
// "for_end" is set when ":endfor" is found
scope->se_u.se_for.fs_top_label = instr->ga_len;
-
generate_FOR(cctx, loop_lvar->lv_idx);
- generate_STORE(cctx, ISN_STORE, var_lvar->lv_idx, NULL);
- return arg;
+ arg = arg_start;
+ if (var_count > 1)
+ {
+ generate_UNPACK(cctx, var_count, semicolon);
+ arg = skipwhite(arg + 1); // skip white after '['
+
+ // the list item is replaced by a number of items
+ if (ga_grow(stack, var_count - 1) == FAIL)
+ {
+ drop_scope(cctx);
+ return NULL;
+ }
+ --stack->ga_len;
+ for (idx = 0; idx < var_count; ++idx)
+ {
+ ((type_T **)stack->ga_data)[stack->ga_len] =
+ (semicolon && idx == 0) ? vartype : item_type;
+ ++stack->ga_len;
+ }
+ }
+
+ for (idx = 0; idx < var_count; ++idx)
+ {
+ // TODO: use skip_var_one, also assign to @r, $VAR, etc.
+ p = arg;
+ while (eval_isnamec(*p))
+ ++p;
+ varlen = p - arg;
+ var_lvar = lookup_local(arg, varlen, cctx);
+ if (var_lvar != NULL)
+ {
+ semsg(_(e_variable_already_declared), arg);
+ drop_scope(cctx);
+ return NULL;
+ }
+
+ // Reserve a variable to store "var".
+ // TODO: check for type
+ var_lvar = reserve_local(cctx, arg, varlen, FALSE, &t_any);
+ if (var_lvar == NULL)
+ {
+ // out of memory or used as an argument
+ drop_scope(cctx);
+ return NULL;
+ }
+
+ if (semicolon && idx == var_count - 1)
+ var_lvar->lv_type = vartype;
+ else
+ var_lvar->lv_type = item_type;
+ generate_STORE(cctx, ISN_STORE, var_lvar->lv_idx, NULL);
+
+ if (*p == ',' || *p == ';')
+ ++p;
+ arg = skipwhite(p);
+ }
+
+ return arg_end;
}
/*
case ISN_STRSLICE:
case ISN_THROW:
case ISN_TRY:
+ case ISN_UNPACK:
// nothing allocated
break;
}
restore_cmdmod = FALSE;
break;
+ case ISN_UNPACK:
+ {
+ int count = iptr->isn_arg.unpack.unp_count;
+ int semicolon = iptr->isn_arg.unpack.unp_semicolon;
+ list_T *l;
+ listitem_T *li;
+ int i;
+
+ // Check there is a valid list to unpack.
+ tv = STACK_TV_BOT(-1);
+ if (tv->v_type != VAR_LIST)
+ {
+ SOURCING_LNUM = iptr->isn_lnum;
+ emsg(_(e_for_argument_must_be_sequence_of_lists));
+ goto on_error;
+ }
+ l = tv->vval.v_list;
+ if (l == NULL
+ || l->lv_len < (semicolon ? count - 1 : count))
+ {
+ SOURCING_LNUM = iptr->isn_lnum;
+ emsg(_(e_list_value_does_not_have_enough_items));
+ goto on_error;
+ }
+ else if (!semicolon && l->lv_len > count)
+ {
+ SOURCING_LNUM = iptr->isn_lnum;
+ emsg(_(e_list_value_has_more_items_than_targets));
+ goto on_error;
+ }
+
+ CHECK_LIST_MATERIALIZE(l);
+ if (GA_GROW(&ectx.ec_stack, count - 1) == FAIL)
+ goto failed;
+ ectx.ec_stack.ga_len += count - 1;
+
+ // Variable after semicolon gets a list with the remaining
+ // items.
+ if (semicolon)
+ {
+ list_T *rem_list =
+ list_alloc_with_items(l->lv_len - count + 1);
+
+ if (rem_list == NULL)
+ goto failed;
+ tv = STACK_TV_BOT(-count);
+ tv->vval.v_list = rem_list;
+ ++rem_list->lv_refcount;
+ tv->v_lock = 0;
+ li = l->lv_first;
+ for (i = 0; i < count - 1; ++i)
+ li = li->li_next;
+ for (i = 0; li != NULL; ++i)
+ {
+ list_set_item(rem_list, i, &li->li_tv);
+ li = li->li_next;
+ }
+ --count;
+ }
+
+ // Produce the values in reverse order, first item last.
+ li = l->lv_first;
+ for (i = 0; i < count; ++i)
+ {
+ tv = STACK_TV_BOT(-i - 1);
+ copy_tv(&li->li_tv, tv);
+ li = li->li_next;
+ }
+
+ list_unref(l);
+ }
+ break;
+
case ISN_SHUFFLE:
{
- typval_T tmp_tv;
- int item = iptr->isn_arg.shuffle.shfl_item;
- int up = iptr->isn_arg.shuffle.shfl_up;
+ typval_T tmp_tv;
+ int item = iptr->isn_arg.shuffle.shfl_item;
+ int up = iptr->isn_arg.shuffle.shfl_up;
tmp_tv = *STACK_TV_BOT(-item);
for ( ; up > 0 && item > 1; --up)
}
case ISN_CMDMOD_REV: smsg("%4d CMDMOD_REV", current); break;
+ case ISN_UNPACK: smsg("%4d UNPACK %d%s", current,
+ iptr->isn_arg.unpack.unp_count,
+ iptr->isn_arg.unpack.unp_semicolon ? " semicolon" : "");
+ break;
case ISN_SHUFFLE: smsg("%4d SHUFFLE %d up %d", current,
iptr->isn_arg.shuffle.shfl_item,
iptr->isn_arg.shuffle.shfl_up);
projects / vim / commitdiff