vim: src/vim9compile.c annotate

annotate src/vim9compile.c @ 20334:b774655968b4 v8.2.0722

patch 8.2.0722: Vim9: not handling constant expression for elseif Commit: https://github.com/vim/vim/commit/7f14155f422ffcc997fc5a0b635a20a4bafd2093 Author: Bram Moolenaar <Bram@vim.org> Date: Sat May 9 17:35:53 2020 +0200 patch 8.2.0722: Vim9: not handling constant expression for elseif Problem: Vim9: not handling constant expression for elseif. Solution: Use postponed constants. Delete the code for evaluating a constant expression.

author	Bram Moolenaar <Bram@vim.org>
date	Sat, 09 May 2020 17:45:03 +0200
parents	a407e243c55c
children	2fd980fb9ab3

rev	line source
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1 /* vi:set ts=8 sts=4 sw=4 noet:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3 * VIM - Vi IMproved by Bram Moolenaar
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5 * Do ":help uganda" in Vim to read copying and usage conditions.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6 * Do ":help credits" in Vim to see a list of people who contributed.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	7 * See README.txt for an overview of the Vim source code.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	8 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	9
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	10 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	11 * vim9compile.c: :def and dealing with instructions
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	12 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	13
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	14 #define USING_FLOAT_STUFF
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	15 #include "vim.h"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	16
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	17 #if defined(FEAT_EVAL) \|\| defined(PROTO)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	18
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	19 #ifdef VMS
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	20 # include <float.h>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	21 #endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	22
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	23 #define DEFINE_VIM9_GLOBALS
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	24 #include "vim9.h"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	25
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	26 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	27 * Chain of jump instructions where the end label needs to be set.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	28 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	29 typedef struct endlabel_S endlabel_T;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	30 struct endlabel_S {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	31 endlabel_T *el_next; // chain end_label locations
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	32 int el_end_label; // instruction idx where to set end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	33 };
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	34
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	35 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	36 * info specific for the scope of :if / elseif / else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	37 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	38 typedef struct {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	39 int is_if_label; // instruction idx at IF or ELSEIF
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	40 endlabel_T *is_end_label; // instructions to set end label
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	41 } ifscope_T;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	42
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	43 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	44 * info specific for the scope of :while
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	45 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	46 typedef struct {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	47 int ws_top_label; // instruction idx at WHILE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	48 endlabel_T *ws_end_label; // instructions to set end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	49 } whilescope_T;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	50
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	51 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	52 * info specific for the scope of :for
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	53 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	54 typedef struct {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	55 int fs_top_label; // instruction idx at FOR
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	56 endlabel_T *fs_end_label; // break instructions
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	57 } forscope_T;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	58
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	59 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	60 * info specific for the scope of :try
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	61 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	62 typedef struct {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	63 int ts_try_label; // instruction idx at TRY
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	64 endlabel_T *ts_end_label; // jump to :finally or :endtry
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	65 int ts_catch_label; // instruction idx of last CATCH
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	66 int ts_caught_all; // "catch" without argument encountered
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	67 } tryscope_T;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	68
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	69 typedef enum {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	70 NO_SCOPE,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	71 IF_SCOPE,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	72 WHILE_SCOPE,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	73 FOR_SCOPE,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	74 TRY_SCOPE,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	75 BLOCK_SCOPE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	76 } scopetype_T;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	77
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	78 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	79 * Info for one scope, pointed to by "ctx_scope".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	80 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	81 typedef struct scope_S scope_T;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	82 struct scope_S {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	83 scope_T *se_outer; // scope containing this one
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	84 scopetype_T se_type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	85 int se_local_count; // ctx_locals.ga_len before scope
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	86 union {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	87 ifscope_T se_if;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	88 whilescope_T se_while;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	89 forscope_T se_for;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	90 tryscope_T se_try;
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	91 } se_u;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	92 };
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	93
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	94 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	95 * Entry for "ctx_locals". Used for arguments and local variables.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	96 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	97 typedef struct {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	98 char_u *lv_name;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	99 type_T *lv_type;
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	100 int lv_idx; // index of the variable on the stack
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	101 int lv_from_outer; // when TRUE using ctx_outer scope
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	102 int lv_const; // when TRUE cannot be assigned to
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	103 int lv_arg; // when TRUE this is an argument
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	104 } lvar_T;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	105
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	106 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	107 * Context for compiling lines of Vim script.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	108 * Stores info about the local variables and condition stack.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	109 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	110 struct cctx_S {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	111 ufunc_T *ctx_ufunc; // current function
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	112 int ctx_lnum; // line number in current function
20059 de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	113 char_u *ctx_line_start; // start of current line or NULL
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	114 garray_T ctx_instr; // generated instructions
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	115
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	116 garray_T ctx_locals; // currently visible local variables
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	117 int ctx_locals_count; // total number of local variables
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	118
20247 e46e72aaff74 patch 8.2.0679: Vim9: incomplete support for closures Bram Moolenaar <Bram@vim.org> parents: 20244 diff changeset	119 int ctx_closure_count; // number of closures created in the
e46e72aaff74 patch 8.2.0679: Vim9: incomplete support for closures Bram Moolenaar <Bram@vim.org> parents: 20244 diff changeset	120 // function
e46e72aaff74 patch 8.2.0679: Vim9: incomplete support for closures Bram Moolenaar <Bram@vim.org> parents: 20244 diff changeset	121
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	122 garray_T ctx_imports; // imported items
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	123
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	124 int ctx_skip; // when TRUE skip commands, when FALSE skip
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	125 // commands after "else"
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	126 scope_T *ctx_scope; // current scope, NULL at toplevel
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	127
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	128 cctx_T *ctx_outer; // outer scope for lambda or nested
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	129 // function
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	130 int ctx_outer_used; // var in ctx_outer was used
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	131
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	132 garray_T ctx_type_stack; // type of each item on the stack
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	133 garray_T *ctx_type_list; // list of pointers to allocated types
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	134 };
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	135
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	136 static char e_var_notfound[] = N_("E1001: variable not found: %s");
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	137 static char e_syntax_at[] = N_("E1002: Syntax error at %s");
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	138
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	139 static int compile_expr0(char_u *arg, cctx_T cctx);
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	140 static void delete_def_function_contents(dfunc_T *dfunc);
19944 3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	141 static void arg_type_mismatch(type_T expected, type_T actual, int argidx);
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	142 static int check_type(type_T expected, type_T actual, int give_msg);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	143
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	144 /*
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	145 * Lookup variable "name" in the local scope and return it.
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	146 * Return NULL if not found.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	147 */
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	148 static lvar_T *
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	149 lookup_local(char_u name, size_t len, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	150 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	151 int idx;
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	152 lvar_T *lvar;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	153
19392 5b6f420e7352 patch 8.2.0254: compiler warning for checking size_t to be negative Bram Moolenaar <Bram@vim.org> parents: 19388 diff changeset	154 if (len == 0)
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	155 return NULL;
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	156
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	157 // Find local in current function scope.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	158 for (idx = 0; idx < cctx->ctx_locals.ga_len; ++idx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	159 {
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	160 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	161 if (STRNCMP(name, lvar->lv_name, len) == 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	162 && STRLEN(lvar->lv_name) == len)
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	163 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	164 lvar->lv_from_outer = FALSE;
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	165 return lvar;
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	166 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	167 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	168
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	169 // Find local in outer function scope.
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	170 if (cctx->ctx_outer != NULL)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	171 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	172 lvar = lookup_local(name, len, cctx->ctx_outer);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	173 if (lvar != NULL)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	174 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	175 // TODO: are there situations we should not mark the outer scope as
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	176 // used?
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	177 cctx->ctx_outer_used = TRUE;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	178 lvar->lv_from_outer = TRUE;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	179 return lvar;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	180 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	181 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	182
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	183 return NULL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	184 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	185
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	186 /*
20275 350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	187 * Lookup an argument in the current function and an enclosing function.
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	188 * Returns the argument index in "idxp"
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	189 * Returns the argument type in "type"
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	190 * Sets "gen_load_outer" to TRUE if found in outer scope.
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	191 * Returns OK when found, FAIL otherwise.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	192 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	193 static int
20275 350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	194 lookup_arg(
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	195 char_u *name,
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	196 size_t len,
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	197 int *idxp,
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	198 type_T **type,
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	199 int *gen_load_outer,
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	200 cctx_T *cctx)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	201 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	202 int idx;
20275 350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	203 char_u *va_name;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	204
19392 5b6f420e7352 patch 8.2.0254: compiler warning for checking size_t to be negative Bram Moolenaar <Bram@vim.org> parents: 19388 diff changeset	205 if (len == 0)
20275 350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	206 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	207 for (idx = 0; idx < cctx->ctx_ufunc->uf_args.ga_len; ++idx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	208 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	209 char_u *arg = FUNCARG(cctx->ctx_ufunc, idx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	210
20275 350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	211 if (STRNCMP(name, arg, len) == 0 && arg[len] == NUL)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	212 {
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	213 if (idxp != NULL)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	214 {
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	215 // Arguments are located above the frame pointer. One further
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	216 // if there is a vararg argument
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	217 *idxp = idx - (cctx->ctx_ufunc->uf_args.ga_len
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	218 + STACK_FRAME_SIZE)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	219 + (cctx->ctx_ufunc->uf_va_name != NULL ? -1 : 0);
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	220
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	221 if (cctx->ctx_ufunc->uf_arg_types != NULL)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	222 *type = cctx->ctx_ufunc->uf_arg_types[idx];
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	223 else
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	224 *type = &t_any;
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	225 }
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	226 return OK;
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	227 }
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	228 }
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	229
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	230 va_name = cctx->ctx_ufunc->uf_va_name;
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	231 if (va_name != NULL
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	232 && STRNCMP(name, va_name, len) == 0 && va_name[len] == NUL)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	233 {
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	234 if (idxp != NULL)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	235 {
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	236 // varargs is always the last argument
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	237 *idxp = -STACK_FRAME_SIZE - 1;
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	238 *type = cctx->ctx_ufunc->uf_va_type;
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	239 }
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	240 return OK;
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	241 }
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	242
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	243 if (cctx->ctx_outer != NULL)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	244 {
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	245 // Lookup the name for an argument of the outer function.
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	246 if (lookup_arg(name, len, idxp, type, gen_load_outer, cctx->ctx_outer)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	247 == OK)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	248 {
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	249 *gen_load_outer = TRUE;
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	250 return OK;
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	251 }
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	252 }
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	253
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	254 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	255 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	256
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	257 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	258 * Lookup a variable in the current script.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	259 * Returns OK or FAIL.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	260 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	261 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	262 lookup_script(char_u *name, size_t len)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	263 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	264 int cc;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	265 hashtab_T *ht = &SCRIPT_VARS(current_sctx.sc_sid);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	266 dictitem_T *di;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	267
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	268 cc = name[len];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	269 name[len] = NUL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	270 di = find_var_in_ht(ht, 0, name, TRUE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	271 name[len] = cc;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	272 return di == NULL ? FAIL: OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	273 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	274
19623 2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	275 /*
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	276 * Check if "p[len]" is already defined, either in script "import_sid" or in
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	277 * compilation context "cctx".
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	278 * Return FAIL and give an error if it defined.
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	279 */
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	280 int
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	281 check_defined(char_u p, int len, cctx_T cctx)
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	282 {
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	283 if (lookup_script(p, len) == OK
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	284 \|\| (cctx != NULL
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	285 && (lookup_local(p, len, cctx) != NULL
19623 2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	286 \|\| find_imported(p, len, cctx) != NULL)))
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	287 {
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	288 semsg("E1073: imported name already defined: %s", p);
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	289 return FAIL;
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	290 }
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	291 return OK;
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	292 }
2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	293
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	294 /*
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	295 * Allocate memory for a type_T and add the pointer to type_gap, so that it can
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	296 * be freed later.
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	297 */
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	298 static type_T *
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	299 alloc_type(garray_T *type_gap)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	300 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	301 type_T *type;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	302
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	303 if (ga_grow(type_gap, 1) == FAIL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	304 return NULL;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	305 type = ALLOC_CLEAR_ONE(type_T);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	306 if (type != NULL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	307 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	308 ((type_T **)type_gap->ga_data)[type_gap->ga_len] = type;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	309 ++type_gap->ga_len;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	310 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	311 return type;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	312 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	313
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	314 static type_T *
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	315 get_list_type(type_T member_type, garray_T type_gap)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	316 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	317 type_T *type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	318
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	319 // recognize commonly used types
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	320 if (member_type->tt_type == VAR_ANY)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	321 return &t_list_any;
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	322 if (member_type->tt_type == VAR_VOID
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	323 \|\| member_type->tt_type == VAR_UNKNOWN)
19467 f41e46f02c8c patch 8.2.0291: Vim9: assigning [] to list<string> doesn't work Bram Moolenaar <Bram@vim.org> parents: 19461 diff changeset	324 return &t_list_empty;
19521 860b39ed0e0b patch 8.2.0318: Vim9: types not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19509 diff changeset	325 if (member_type->tt_type == VAR_BOOL)
860b39ed0e0b patch 8.2.0318: Vim9: types not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19509 diff changeset	326 return &t_list_bool;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	327 if (member_type->tt_type == VAR_NUMBER)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	328 return &t_list_number;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	329 if (member_type->tt_type == VAR_STRING)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	330 return &t_list_string;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	331
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	332 // Not a common type, create a new entry.
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	333 type = alloc_type(type_gap);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	334 if (type == NULL)
19818 c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	335 return &t_any;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	336 type->tt_type = VAR_LIST;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	337 type->tt_member = member_type;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	338 type->tt_argcount = 0;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	339 type->tt_args = NULL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	340 return type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	341 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	342
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	343 static type_T *
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	344 get_dict_type(type_T member_type, garray_T type_gap)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	345 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	346 type_T *type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	347
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	348 // recognize commonly used types
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	349 if (member_type->tt_type == VAR_ANY)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	350 return &t_dict_any;
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	351 if (member_type->tt_type == VAR_VOID
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	352 \|\| member_type->tt_type == VAR_UNKNOWN)
19467 f41e46f02c8c patch 8.2.0291: Vim9: assigning [] to list<string> doesn't work Bram Moolenaar <Bram@vim.org> parents: 19461 diff changeset	353 return &t_dict_empty;
19521 860b39ed0e0b patch 8.2.0318: Vim9: types not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19509 diff changeset	354 if (member_type->tt_type == VAR_BOOL)
860b39ed0e0b patch 8.2.0318: Vim9: types not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19509 diff changeset	355 return &t_dict_bool;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	356 if (member_type->tt_type == VAR_NUMBER)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	357 return &t_dict_number;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	358 if (member_type->tt_type == VAR_STRING)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	359 return &t_dict_string;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	360
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	361 // Not a common type, create a new entry.
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	362 type = alloc_type(type_gap);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	363 if (type == NULL)
19818 c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	364 return &t_any;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	365 type->tt_type = VAR_DICT;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	366 type->tt_member = member_type;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	367 type->tt_argcount = 0;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	368 type->tt_args = NULL;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	369 return type;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	370 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	371
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	372 /*
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	373 * Allocate a new type for a function.
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	374 */
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	375 static type_T *
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	376 alloc_func_type(type_T ret_type, int argcount, garray_T type_gap)
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	377 {
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	378 type_T *type = alloc_type(type_gap);
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	379
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	380 if (type == NULL)
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	381 return &t_any;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	382 type->tt_type = VAR_FUNC;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	383 type->tt_member = ret_type;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	384 type->tt_argcount = argcount;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	385 type->tt_args = NULL;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	386 return type;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	387 }
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	388
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	389 /*
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	390 * Get a function type, based on the return type "ret_type".
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	391 * If "argcount" is -1 or 0 a predefined type can be used.
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	392 * If "argcount" > 0 always create a new type, so that arguments can be added.
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	393 */
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	394 static type_T *
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	395 get_func_type(type_T ret_type, int argcount, garray_T type_gap)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	396 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	397 // recognize commonly used types
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	398 if (argcount <= 0)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	399 {
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	400 if (ret_type == &t_unknown)
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	401 {
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	402 // (argcount == 0) is not possible
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	403 return &t_func_unknown;
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	404 }
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	405 if (ret_type == &t_void)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	406 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	407 if (argcount == 0)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	408 return &t_func_0_void;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	409 else
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	410 return &t_func_void;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	411 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	412 if (ret_type == &t_any)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	413 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	414 if (argcount == 0)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	415 return &t_func_0_any;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	416 else
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	417 return &t_func_any;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	418 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	419 if (ret_type == &t_number)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	420 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	421 if (argcount == 0)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	422 return &t_func_0_number;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	423 else
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	424 return &t_func_number;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	425 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	426 if (ret_type == &t_string)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	427 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	428 if (argcount == 0)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	429 return &t_func_0_string;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	430 else
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	431 return &t_func_string;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	432 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	433 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	434
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	435 return alloc_func_type(ret_type, argcount, type_gap);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	436 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	437
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	438 /*
19914 6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	439 * For a function type, reserve space for "argcount" argument types (including
6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	440 * vararg).
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	441 */
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	442 static int
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	443 func_type_add_arg_types(
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	444 type_T *functype,
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	445 int argcount,
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	446 garray_T *type_gap)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	447 {
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	448 // To make it easy to free the space needed for the argument types, add the
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	449 // pointer to type_gap.
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	450 if (ga_grow(type_gap, 1) == FAIL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	451 return FAIL;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	452 functype->tt_args = ALLOC_CLEAR_MULT(type_T *, argcount);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	453 if (functype->tt_args == NULL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	454 return FAIL;
19918 ccfeae6af59e patch 8.2.0515: some compilers cannot add to "void " Bram Moolenaar <Bram@vim.org>* parents: 19914 diff changeset	455 ((type_T **)type_gap->ga_data)[type_gap->ga_len] =
ccfeae6af59e patch 8.2.0515: some compilers cannot add to "void " Bram Moolenaar <Bram@vim.org>* parents: 19914 diff changeset	456 (void *)functype->tt_args;
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	457 ++type_gap->ga_len;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	458 return OK;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	459 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	460
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	461 /*
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	462 * Return the type_T for a typval. Only for primitive types.
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	463 */
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	464 static type_T *
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	465 typval2type(typval_T *tv)
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	466 {
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	467 if (tv->v_type == VAR_NUMBER)
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	468 return &t_number;
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	469 if (tv->v_type == VAR_BOOL)
19964 6765a88e72a5 patch 8.2.0538: Vim9: VAR_PARTIAL is not used during compilation Bram Moolenaar <Bram@vim.org> parents: 19960 diff changeset	470 return &t_bool; // not used
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	471 if (tv->v_type == VAR_STRING)
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	472 return &t_string;
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	473 if (tv->v_type == VAR_LIST) // e.g. for v:oldfiles
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	474 return &t_list_string;
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	475 if (tv->v_type == VAR_DICT) // e.g. for v:completed_item
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	476 return &t_dict_any;
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	477 return &t_any; // not used
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	478 }
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	479
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	480 static void
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	481 type_mismatch(type_T expected, type_T actual)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	482 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	483 char tofree1, tofree2;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	484
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	485 semsg(_("E1013: type mismatch, expected %s but got %s"),
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	486 type_name(expected, &tofree1), type_name(actual, &tofree2));
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	487 vim_free(tofree1);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	488 vim_free(tofree2);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	489 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	490
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	491 static void
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	492 arg_type_mismatch(type_T expected, type_T actual, int argidx)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	493 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	494 char tofree1, tofree2;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	495
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	496 semsg(_("E1013: argument %d: type mismatch, expected %s but got %s"),
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	497 argidx,
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	498 type_name(expected, &tofree1), type_name(actual, &tofree2));
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	499 vim_free(tofree1);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	500 vim_free(tofree2);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	501 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	502
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	503 /*
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	504 * Check if the expected and actual types match.
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	505 * Does not allow for assigning "any" to a specific type.
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	506 */
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	507 static int
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	508 check_type(type_T expected, type_T actual, int give_msg)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	509 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	510 int ret = OK;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	511
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	512 // When expected is "unknown" we accept any actual type.
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	513 // When expected is "any" we accept any actual type except "void".
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	514 if (expected->tt_type != VAR_UNKNOWN
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	515 && !(expected->tt_type == VAR_ANY && actual->tt_type != VAR_VOID))
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	516
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	517 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	518 if (expected->tt_type != actual->tt_type)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	519 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	520 if (give_msg)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	521 type_mismatch(expected, actual);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	522 return FAIL;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	523 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	524 if (expected->tt_type == VAR_DICT \|\| expected->tt_type == VAR_LIST)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	525 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	526 // "unknown" is used for an empty list or dict
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	527 if (actual->tt_member != &t_unknown)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	528 ret = check_type(expected->tt_member, actual->tt_member, FALSE);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	529 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	530 else if (expected->tt_type == VAR_FUNC)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	531 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	532 if (expected->tt_member != &t_unknown)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	533 ret = check_type(expected->tt_member, actual->tt_member, FALSE);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	534 if (ret == OK && expected->tt_argcount != -1
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	535 && (actual->tt_argcount < expected->tt_min_argcount
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	536 \|\| actual->tt_argcount > expected->tt_argcount))
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	537 ret = FAIL;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	538 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	539 if (ret == FAIL && give_msg)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	540 type_mismatch(expected, actual);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	541 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	542 return ret;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	543 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	544
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	545 /////////////////////////////////////////////////////////////////////
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	546 // Following generate_ functions expect the caller to call ga_grow().
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	547
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	548 #define RETURN_NULL_IF_SKIP(cctx) if (cctx->ctx_skip == TRUE) return NULL
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	549 #define RETURN_OK_IF_SKIP(cctx) if (cctx->ctx_skip == TRUE) return OK
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	550
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	551 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	552 * Generate an instruction without arguments.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	553 * Returns a pointer to the new instruction, NULL if failed.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	554 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	555 static isn_T *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	556 generate_instr(cctx_T *cctx, isntype_T isn_type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	557 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	558 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	559 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	560
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	561 RETURN_NULL_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	562 if (ga_grow(instr, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	563 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	564 isn = ((isn_T *)instr->ga_data) + instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	565 isn->isn_type = isn_type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	566 isn->isn_lnum = cctx->ctx_lnum + 1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	567 ++instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	568
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	569 return isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	570 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	571
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	572 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	573 * Generate an instruction without arguments.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	574 * "drop" will be removed from the stack.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	575 * Returns a pointer to the new instruction, NULL if failed.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	576 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	577 static isn_T *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	578 generate_instr_drop(cctx_T *cctx, isntype_T isn_type, int drop)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	579 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	580 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	581
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	582 RETURN_NULL_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	583 stack->ga_len -= drop;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	584 return generate_instr(cctx, isn_type);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	585 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	586
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	587 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	588 * Generate instruction "isn_type" and put "type" on the type stack.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	589 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	590 static isn_T *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	591 generate_instr_type(cctx_T cctx, isntype_T isn_type, type_T type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	592 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	593 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	594 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	595
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	596 if ((isn = generate_instr(cctx, isn_type)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	597 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	598
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	599 if (ga_grow(stack, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	600 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	601 ((type_T **)stack->ga_data)[stack->ga_len] = type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	602 ++stack->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	603
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	604 return isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	605 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	606
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	607 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	608 * If type at "offset" isn't already VAR_STRING then generate ISN_2STRING.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	609 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	610 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	611 may_generate_2STRING(int offset, cctx_T *cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	612 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	613 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	614 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	615 type_T type = ((type_T )stack->ga_data) + stack->ga_len + offset;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	616
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	617 if ((*type)->tt_type == VAR_STRING)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	618 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	619 *type = &t_string;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	620
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	621 if ((isn = generate_instr(cctx, ISN_2STRING)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	622 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	623 isn->isn_arg.number = offset;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	624
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	625 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	626 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	627
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	628 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	629 check_number_or_float(vartype_T type1, vartype_T type2, char_u *op)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	630 {
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	631 if (!((type1 == VAR_NUMBER \|\| type1 == VAR_FLOAT \|\| type1 == VAR_ANY)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	632 && (type2 == VAR_NUMBER \|\| type2 == VAR_FLOAT
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	633 \|\| type2 == VAR_ANY)))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	634 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	635 if (*op == '+')
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	636 emsg(_("E1035: wrong argument type for +"));
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	637 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	638 semsg(_("E1036: %c requires number or float arguments"), *op);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	639 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	640 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	641 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	642 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	643
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	644 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	645 * Generate an instruction with two arguments. The instruction depends on the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	646 * type of the arguments.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	647 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	648 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	649 generate_two_op(cctx_T cctx, char_u op)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	650 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	651 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	652 type_T *type1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	653 type_T *type2;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	654 vartype_T vartype;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	655 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	656
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	657 RETURN_OK_IF_SKIP(cctx);
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	658
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	659 // Get the known type of the two items on the stack. If they are matching
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	660 // use a type-specific instruction. Otherwise fall back to runtime type
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	661 // checking.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	662 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	663 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1];
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	664 vartype = VAR_ANY;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	665 if (type1->tt_type == type2->tt_type
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	666 && (type1->tt_type == VAR_NUMBER
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	667 \|\| type1->tt_type == VAR_LIST
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	668 #ifdef FEAT_FLOAT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	669 \|\| type1->tt_type == VAR_FLOAT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	670 #endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	671 \|\| type1->tt_type == VAR_BLOB))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	672 vartype = type1->tt_type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	673
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	674 switch (*op)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	675 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	676 case '+': if (vartype != VAR_LIST && vartype != VAR_BLOB
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	677 && type1->tt_type != VAR_ANY
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	678 && type2->tt_type != VAR_ANY
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	679 && check_number_or_float(
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	680 type1->tt_type, type2->tt_type, op) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	681 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	682 isn = generate_instr_drop(cctx,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	683 vartype == VAR_NUMBER ? ISN_OPNR
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	684 : vartype == VAR_LIST ? ISN_ADDLIST
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	685 : vartype == VAR_BLOB ? ISN_ADDBLOB
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	686 #ifdef FEAT_FLOAT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	687 : vartype == VAR_FLOAT ? ISN_OPFLOAT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	688 #endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	689 : ISN_OPANY, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	690 if (isn != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	691 isn->isn_arg.op.op_type = EXPR_ADD;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	692 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	693
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	694 case '-':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	695 case '*':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	696 case '/': if (check_number_or_float(type1->tt_type, type2->tt_type,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	697 op) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	698 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	699 if (vartype == VAR_NUMBER)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	700 isn = generate_instr_drop(cctx, ISN_OPNR, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	701 #ifdef FEAT_FLOAT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	702 else if (vartype == VAR_FLOAT)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	703 isn = generate_instr_drop(cctx, ISN_OPFLOAT, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	704 #endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	705 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	706 isn = generate_instr_drop(cctx, ISN_OPANY, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	707 if (isn != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	708 isn->isn_arg.op.op_type = op == ''
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	709 ? EXPR_MULT : *op == '/'? EXPR_DIV : EXPR_SUB;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	710 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	711
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	712 case '%': if ((type1->tt_type != VAR_ANY
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	713 && type1->tt_type != VAR_NUMBER)
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	714 \|\| (type2->tt_type != VAR_ANY
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	715 && type2->tt_type != VAR_NUMBER))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	716 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	717 emsg(_("E1035: % requires number arguments"));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	718 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	719 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	720 isn = generate_instr_drop(cctx,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	721 vartype == VAR_NUMBER ? ISN_OPNR : ISN_OPANY, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	722 if (isn != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	723 isn->isn_arg.op.op_type = EXPR_REM;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	724 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	725 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	726
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	727 // correct type of result
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	728 if (vartype == VAR_ANY)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	729 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	730 type_T *type = &t_any;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	731
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	732 #ifdef FEAT_FLOAT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	733 // float+number and number+float results in float
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	734 if ((type1->tt_type == VAR_NUMBER \|\| type1->tt_type == VAR_FLOAT)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	735 && (type2->tt_type == VAR_NUMBER \|\| type2->tt_type == VAR_FLOAT))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	736 type = &t_float;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	737 #endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	738 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	739 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	740
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	741 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	742 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	743
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	744 /*
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	745 * Get the instruction to use for comparing "type1" with "type2"
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	746 * Return ISN_DROP when failed.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	747 */
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	748 static isntype_T
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	749 get_compare_isn(exptype_T exptype, vartype_T type1, vartype_T type2)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	750 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	751 isntype_T isntype = ISN_DROP;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	752
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	753 if (type1 == VAR_UNKNOWN)
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	754 type1 = VAR_ANY;
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	755 if (type2 == VAR_UNKNOWN)
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	756 type2 = VAR_ANY;
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	757
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	758 if (type1 == type2)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	759 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	760 switch (type1)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	761 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	762 case VAR_BOOL: isntype = ISN_COMPAREBOOL; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	763 case VAR_SPECIAL: isntype = ISN_COMPARESPECIAL; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	764 case VAR_NUMBER: isntype = ISN_COMPARENR; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	765 case VAR_FLOAT: isntype = ISN_COMPAREFLOAT; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	766 case VAR_STRING: isntype = ISN_COMPARESTRING; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	767 case VAR_BLOB: isntype = ISN_COMPAREBLOB; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	768 case VAR_LIST: isntype = ISN_COMPARELIST; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	769 case VAR_DICT: isntype = ISN_COMPAREDICT; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	770 case VAR_FUNC: isntype = ISN_COMPAREFUNC; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	771 default: isntype = ISN_COMPAREANY; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	772 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	773 }
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	774 else if (type1 == VAR_ANY \|\| type2 == VAR_ANY
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	775 \|\| ((type1 == VAR_NUMBER \|\| type1 == VAR_FLOAT)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	776 && (type2 == VAR_NUMBER \|\| type2 ==VAR_FLOAT)))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	777 isntype = ISN_COMPAREANY;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	778
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	779 if ((exptype == EXPR_IS \|\| exptype == EXPR_ISNOT)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	780 && (isntype == ISN_COMPAREBOOL
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	781 \|\| isntype == ISN_COMPARESPECIAL
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	782 \|\| isntype == ISN_COMPARENR
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	783 \|\| isntype == ISN_COMPAREFLOAT))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	784 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	785 semsg(_("E1037: Cannot use \"%s\" with %s"),
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	786 exptype == EXPR_IS ? "is" : "isnot" , vartype_name(type1));
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	787 return ISN_DROP;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	788 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	789 if (isntype == ISN_DROP
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	790 \|\| ((exptype != EXPR_EQUAL && exptype != EXPR_NEQUAL
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	791 && (type1 == VAR_BOOL \|\| type1 == VAR_SPECIAL
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	792 \|\| type2 == VAR_BOOL \|\| type2 == VAR_SPECIAL)))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	793 \|\| ((exptype != EXPR_EQUAL && exptype != EXPR_NEQUAL
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	794 && exptype != EXPR_IS && exptype != EXPR_ISNOT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	795 && (type1 == VAR_BLOB \|\| type2 == VAR_BLOB
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	796 \|\| type1 == VAR_LIST \|\| type2 == VAR_LIST))))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	797 {
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	798 semsg(_("E1072: Cannot compare %s with %s"),
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	799 vartype_name(type1), vartype_name(type2));
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	800 return ISN_DROP;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	801 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	802 return isntype;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	803 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	804
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	805 /*
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	806 * Generate an ISN_COMPARE* instruction with a boolean result.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	807 */
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	808 static int
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	809 generate_COMPARE(cctx_T *cctx, exptype_T exptype, int ic)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	810 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	811 isntype_T isntype;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	812 isn_T *isn;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	813 garray_T *stack = &cctx->ctx_type_stack;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	814 vartype_T type1;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	815 vartype_T type2;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	816
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	817 RETURN_OK_IF_SKIP(cctx);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	818
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	819 // Get the known type of the two items on the stack. If they are matching
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	820 // use a type-specific instruction. Otherwise fall back to runtime type
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	821 // checking.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	822 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2]->tt_type;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	823 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	824 isntype = get_compare_isn(exptype, type1, type2);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	825 if (isntype == ISN_DROP)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	826 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	827
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	828 if ((isn = generate_instr(cctx, isntype)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	829 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	830 isn->isn_arg.op.op_type = exptype;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	831 isn->isn_arg.op.op_ic = ic;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	832
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	833 // takes two arguments, puts one bool back
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	834 if (stack->ga_len >= 2)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	835 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	836 --stack->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	837 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	838 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	839
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	840 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	841 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	842
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	843 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	844 * Generate an ISN_2BOOL instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	845 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	846 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	847 generate_2BOOL(cctx_T *cctx, int invert)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	848 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	849 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	850 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	851
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	852 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	853 if ((isn = generate_instr(cctx, ISN_2BOOL)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	854 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	855 isn->isn_arg.number = invert;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	856
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	857 // type becomes bool
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	858 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	859
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	860 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	861 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	862
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	863 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	864 generate_TYPECHECK(cctx_T cctx, type_T vartype, int offset)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	865 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	866 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	867 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	868
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	869 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	870 if ((isn = generate_instr(cctx, ISN_CHECKTYPE)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	871 return FAIL;
20207 3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	872 // TODO: whole type, e.g. for a function also arg and return types
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	873 isn->isn_arg.type.ct_type = vartype->tt_type;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	874 isn->isn_arg.type.ct_off = offset;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	875
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	876 // type becomes vartype
20255 aac52c32a91f patch 8.2.0683: Vim9: parsing type does not always work Bram Moolenaar <Bram@vim.org> parents: 20253 diff changeset	877 ((type_T **)stack->ga_data)[stack->ga_len + offset] = vartype;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	878
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	879 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	880 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	881
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	882 /*
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	883 * Check that
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	884 * - "actual" is "expected" type or
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	885 * - "actual" is a type that can be "expected" type: add a runtime check; or
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	886 * - return FAIL.
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	887 */
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	888 static int
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	889 need_type(type_T actual, type_T expected, int offset, cctx_T *cctx)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	890 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	891 if (check_type(expected, actual, FALSE) == OK)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	892 return OK;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	893 if (actual->tt_type != VAR_ANY
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	894 && actual->tt_type != VAR_UNKNOWN
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	895 && !(actual->tt_type == VAR_FUNC
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	896 && (actual->tt_member == &t_any \|\| actual->tt_argcount < 0)))
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	897 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	898 type_mismatch(expected, actual);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	899 return FAIL;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	900 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	901 generate_TYPECHECK(cctx, expected, offset);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	902 return OK;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	903 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	904
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	905 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	906 * Generate an ISN_PUSHNR instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	907 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	908 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	909 generate_PUSHNR(cctx_T *cctx, varnumber_T number)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	910 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	911 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	912
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	913 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	914 if ((isn = generate_instr_type(cctx, ISN_PUSHNR, &t_number)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	915 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	916 isn->isn_arg.number = number;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	917
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	918 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	919 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	920
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	921 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	922 * Generate an ISN_PUSHBOOL instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	923 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	924 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	925 generate_PUSHBOOL(cctx_T *cctx, varnumber_T number)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	926 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	927 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	928
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	929 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	930 if ((isn = generate_instr_type(cctx, ISN_PUSHBOOL, &t_bool)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	931 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	932 isn->isn_arg.number = number;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	933
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	934 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	935 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	936
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	937 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	938 * Generate an ISN_PUSHSPEC instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	939 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	940 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	941 generate_PUSHSPEC(cctx_T *cctx, varnumber_T number)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	942 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	943 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	944
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	945 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	946 if ((isn = generate_instr_type(cctx, ISN_PUSHSPEC, &t_special)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	947 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	948 isn->isn_arg.number = number;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	949
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	950 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	951 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	952
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	953 #ifdef FEAT_FLOAT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	954 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	955 * Generate an ISN_PUSHF instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	956 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	957 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	958 generate_PUSHF(cctx_T *cctx, float_T fnumber)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	959 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	960 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	961
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	962 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	963 if ((isn = generate_instr_type(cctx, ISN_PUSHF, &t_float)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	964 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	965 isn->isn_arg.fnumber = fnumber;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	966
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	967 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	968 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	969 #endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	970
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	971 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	972 * Generate an ISN_PUSHS instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	973 * Consumes "str".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	974 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	975 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	976 generate_PUSHS(cctx_T cctx, char_u str)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	977 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	978 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	979
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	980 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	981 if ((isn = generate_instr_type(cctx, ISN_PUSHS, &t_string)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	982 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	983 isn->isn_arg.string = str;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	984
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	985 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	986 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	987
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	988 /*
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	989 * Generate an ISN_PUSHCHANNEL instruction.
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	990 * Consumes "channel".
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	991 */
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	992 static int
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	993 generate_PUSHCHANNEL(cctx_T cctx, channel_T channel)
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	994 {
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	995 isn_T *isn;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	996
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	997 RETURN_OK_IF_SKIP(cctx);
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	998 if ((isn = generate_instr_type(cctx, ISN_PUSHCHANNEL, &t_channel)) == NULL)
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	999 return FAIL;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1000 isn->isn_arg.channel = channel;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1001
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1002 return OK;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1003 }
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1004
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1005 /*
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1006 * Generate an ISN_PUSHJOB instruction.
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1007 * Consumes "job".
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1008 */
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1009 static int
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1010 generate_PUSHJOB(cctx_T cctx, job_T job)
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1011 {
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1012 isn_T *isn;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1013
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1014 RETURN_OK_IF_SKIP(cctx);
19572 6b6e97d0185e patch 8.2.0343: Vim9: using wrong instruction, limited test coverage Bram Moolenaar <Bram@vim.org> parents: 19566 diff changeset	1015 if ((isn = generate_instr_type(cctx, ISN_PUSHJOB, &t_channel)) == NULL)
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1016 return FAIL;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1017 isn->isn_arg.job = job;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1018
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1019 return OK;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1020 }
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1021
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1022 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1023 * Generate an ISN_PUSHBLOB instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1024 * Consumes "blob".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1025 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1026 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1027 generate_PUSHBLOB(cctx_T cctx, blob_T blob)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1028 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1029 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1030
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1031 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1032 if ((isn = generate_instr_type(cctx, ISN_PUSHBLOB, &t_blob)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1033 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1034 isn->isn_arg.blob = blob;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1035
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1036 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1037 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1038
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1039 /*
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1040 * Generate an ISN_PUSHFUNC instruction with name "name".
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1041 * Consumes "name".
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1042 */
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1043 static int
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1044 generate_PUSHFUNC(cctx_T cctx, char_u name, type_T *type)
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1045 {
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1046 isn_T *isn;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1047
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1048 RETURN_OK_IF_SKIP(cctx);
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1049 if ((isn = generate_instr_type(cctx, ISN_PUSHFUNC, type)) == NULL)
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1050 return FAIL;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1051 isn->isn_arg.string = name;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1052
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1053 return OK;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1054 }
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1055
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	1056 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1057 * Generate an ISN_STORE instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1058 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1059 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1060 generate_STORE(cctx_T cctx, isntype_T isn_type, int idx, char_u name)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1061 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1062 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1063
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1064 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1065 if ((isn = generate_instr_drop(cctx, isn_type, 1)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1066 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1067 if (name != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1068 isn->isn_arg.string = vim_strsave(name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1069 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1070 isn->isn_arg.number = idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1071
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1072 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1073 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1074
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1075 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1076 * Generate an ISN_STORENR instruction (short for ISN_PUSHNR + ISN_STORE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1077 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1078 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1079 generate_STORENR(cctx_T *cctx, int idx, varnumber_T value)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1080 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1081 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1082
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1083 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1084 if ((isn = generate_instr(cctx, ISN_STORENR)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1085 return FAIL;
19597 1098989a90ee patch 8.2.0355: Vim9: str_val is confusing, it's a number Bram Moolenaar <Bram@vim.org> parents: 19587 diff changeset	1086 isn->isn_arg.storenr.stnr_idx = idx;
1098989a90ee patch 8.2.0355: Vim9: str_val is confusing, it's a number Bram Moolenaar <Bram@vim.org> parents: 19587 diff changeset	1087 isn->isn_arg.storenr.stnr_val = value;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1088
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1089 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1090 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1091
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1092 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1093 * Generate an ISN_STOREOPT instruction
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1094 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1095 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1096 generate_STOREOPT(cctx_T cctx, char_u name, int opt_flags)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1097 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1098 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1099
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1100 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1101 if ((isn = generate_instr(cctx, ISN_STOREOPT)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1102 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1103 isn->isn_arg.storeopt.so_name = vim_strsave(name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1104 isn->isn_arg.storeopt.so_flags = opt_flags;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1105
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1106 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1107 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1108
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1109 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1110 * Generate an ISN_LOAD or similar instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1111 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1112 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1113 generate_LOAD(
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1114 cctx_T *cctx,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1115 isntype_T isn_type,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1116 int idx,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1117 char_u *name,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1118 type_T *type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1119 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1120 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1121
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1122 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1123 if ((isn = generate_instr_type(cctx, isn_type, type)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1124 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1125 if (name != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1126 isn->isn_arg.string = vim_strsave(name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1127 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1128 isn->isn_arg.number = idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1129
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1130 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1131 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1132
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1133 /*
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	1134 * Generate an ISN_LOADV instruction for v:var.
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1135 */
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1136 static int
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1137 generate_LOADV(
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1138 cctx_T *cctx,
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1139 char_u *name,
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1140 int error)
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1141 {
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	1142 int di_flags;
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	1143 int vidx = find_vim_var(name, &di_flags);
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	1144 type_T *type;
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1145
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1146 RETURN_OK_IF_SKIP(cctx);
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1147 if (vidx < 0)
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1148 {
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1149 if (error)
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1150 semsg(_(e_var_notfound), name);
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1151 return FAIL;
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1152 }
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	1153 type = typval2type(get_vim_var_tv(vidx));
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	1154
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	1155 return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, type);
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1156 }
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1157
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1158 /*
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1159 * Generate an ISN_UNLET instruction.
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1160 */
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1161 static int
20099 058b41f85bcb patch 8.2.0605: Vim9: cannot unlet an environment variable Bram Moolenaar <Bram@vim.org> parents: 20091 diff changeset	1162 generate_UNLET(cctx_T cctx, isntype_T isn_type, char_u name, int forceit)
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1163 {
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1164 isn_T *isn;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1165
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1166 RETURN_OK_IF_SKIP(cctx);
20099 058b41f85bcb patch 8.2.0605: Vim9: cannot unlet an environment variable Bram Moolenaar <Bram@vim.org> parents: 20091 diff changeset	1167 if ((isn = generate_instr(cctx, isn_type)) == NULL)
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1168 return FAIL;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1169 isn->isn_arg.unlet.ul_name = vim_strsave(name);
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1170 isn->isn_arg.unlet.ul_forceit = forceit;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1171
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1172 return OK;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1173 }
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1174
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1175 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1176 * Generate an ISN_LOADS instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1177 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1178 static int
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1179 generate_OLDSCRIPT(
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1180 cctx_T *cctx,
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1181 isntype_T isn_type,
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1182 char_u *name,
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1183 int sid,
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1184 type_T *type)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1185 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1186 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1187
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1188 RETURN_OK_IF_SKIP(cctx);
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1189 if (isn_type == ISN_LOADS)
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1190 isn = generate_instr_type(cctx, isn_type, type);
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1191 else
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1192 isn = generate_instr_drop(cctx, isn_type, 1);
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1193 if (isn == NULL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1194 return FAIL;
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1195 isn->isn_arg.loadstore.ls_name = vim_strsave(name);
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1196 isn->isn_arg.loadstore.ls_sid = sid;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1197
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1198 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1199 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1200
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1201 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1202 * Generate an ISN_LOADSCRIPT or ISN_STORESCRIPT instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1203 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1204 static int
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	1205 generate_VIM9SCRIPT(
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1206 cctx_T *cctx,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1207 isntype_T isn_type,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1208 int sid,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1209 int idx,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1210 type_T *type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1211 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1212 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1213
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1214 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1215 if (isn_type == ISN_LOADSCRIPT)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1216 isn = generate_instr_type(cctx, isn_type, type);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1217 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1218 isn = generate_instr_drop(cctx, isn_type, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1219 if (isn == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1220 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1221 isn->isn_arg.script.script_sid = sid;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1222 isn->isn_arg.script.script_idx = idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1223 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1224 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1225
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1226 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1227 * Generate an ISN_NEWLIST instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1228 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1229 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1230 generate_NEWLIST(cctx_T *cctx, int count)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1231 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1232 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1233 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1234 type_T *type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1235 type_T *member;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1236
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1237 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1238 if ((isn = generate_instr(cctx, ISN_NEWLIST)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1239 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1240 isn->isn_arg.number = count;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1241
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1242 // drop the value types
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1243 stack->ga_len -= count;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1244
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1245 // Use the first value type for the list member type. Use "any" for an
19467 f41e46f02c8c patch 8.2.0291: Vim9: assigning [] to list<string> doesn't work Bram Moolenaar <Bram@vim.org> parents: 19461 diff changeset	1246 // empty list.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1247 if (count > 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1248 member = ((type_T **)stack->ga_data)[stack->ga_len];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1249 else
19467 f41e46f02c8c patch 8.2.0291: Vim9: assigning [] to list<string> doesn't work Bram Moolenaar <Bram@vim.org> parents: 19461 diff changeset	1250 member = &t_void;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1251 type = get_list_type(member, cctx->ctx_type_list);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1252
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1253 // add the list type to the type stack
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1254 if (ga_grow(stack, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1255 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1256 ((type_T **)stack->ga_data)[stack->ga_len] = type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1257 ++stack->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1258
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1259 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1260 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1261
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1262 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1263 * Generate an ISN_NEWDICT instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1264 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1265 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1266 generate_NEWDICT(cctx_T *cctx, int count)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1267 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1268 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1269 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1270 type_T *type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1271 type_T *member;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1272
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1273 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1274 if ((isn = generate_instr(cctx, ISN_NEWDICT)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1275 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1276 isn->isn_arg.number = count;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1277
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1278 // drop the key and value types
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1279 stack->ga_len -= 2 * count;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1280
19467 f41e46f02c8c patch 8.2.0291: Vim9: assigning [] to list<string> doesn't work Bram Moolenaar <Bram@vim.org> parents: 19461 diff changeset	1281 // Use the first value type for the list member type. Use "void" for an
f41e46f02c8c patch 8.2.0291: Vim9: assigning [] to list<string> doesn't work Bram Moolenaar <Bram@vim.org> parents: 19461 diff changeset	1282 // empty dict.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1283 if (count > 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1284 member = ((type_T **)stack->ga_data)[stack->ga_len + 1];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1285 else
19467 f41e46f02c8c patch 8.2.0291: Vim9: assigning [] to list<string> doesn't work Bram Moolenaar <Bram@vim.org> parents: 19461 diff changeset	1286 member = &t_void;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1287 type = get_dict_type(member, cctx->ctx_type_list);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1288
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1289 // add the dict type to the type stack
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1290 if (ga_grow(stack, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1291 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1292 ((type_T **)stack->ga_data)[stack->ga_len] = type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1293 ++stack->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1294
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1295 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1296 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1297
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1298 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1299 * Generate an ISN_FUNCREF instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1300 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1301 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1302 generate_FUNCREF(cctx_T *cctx, int dfunc_idx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1303 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1304 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1305 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1306
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1307 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1308 if ((isn = generate_instr(cctx, ISN_FUNCREF)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1309 return FAIL;
20247 e46e72aaff74 patch 8.2.0679: Vim9: incomplete support for closures Bram Moolenaar <Bram@vim.org> parents: 20244 diff changeset	1310 isn->isn_arg.funcref.fr_func = dfunc_idx;
e46e72aaff74 patch 8.2.0679: Vim9: incomplete support for closures Bram Moolenaar <Bram@vim.org> parents: 20244 diff changeset	1311 isn->isn_arg.funcref.fr_var_idx = cctx->ctx_closure_count++;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1312
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1313 if (ga_grow(stack, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1314 return FAIL;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1315 ((type_T **)stack->ga_data)[stack->ga_len] = &t_func_any;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1316 // TODO: argument and return types
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1317 ++stack->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1318
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1319 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1320 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1321
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1322 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1323 * Generate an ISN_JUMP instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1324 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1325 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1326 generate_JUMP(cctx_T *cctx, jumpwhen_T when, int where)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1327 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1328 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1329 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1330
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1331 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1332 if ((isn = generate_instr(cctx, ISN_JUMP)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1333 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1334 isn->isn_arg.jump.jump_when = when;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1335 isn->isn_arg.jump.jump_where = where;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1336
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1337 if (when != JUMP_ALWAYS && stack->ga_len > 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1338 --stack->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1339
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1340 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1341 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1342
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1343 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1344 generate_FOR(cctx_T *cctx, int loop_idx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1345 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1346 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1347 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1348
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1349 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1350 if ((isn = generate_instr(cctx, ISN_FOR)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1351 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1352 isn->isn_arg.forloop.for_idx = loop_idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1353
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1354 if (ga_grow(stack, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1355 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1356 // type doesn't matter, will be stored next
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1357 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1358 ++stack->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1359
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1360 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1361 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1362
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1363 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1364 * Generate an ISN_BCALL instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1365 * Return FAIL if the number of arguments is wrong.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1366 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1367 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1368 generate_BCALL(cctx_T *cctx, int func_idx, int argcount)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1369 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1370 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1371 garray_T *stack = &cctx->ctx_type_stack;
19564 06f29b6ea04a patch 8.2.0339: Vim9: function return type may depend on arguments Bram Moolenaar <Bram@vim.org> parents: 19562 diff changeset	1372 type_T *argtypes[MAX_FUNC_ARGS];
06f29b6ea04a patch 8.2.0339: Vim9: function return type may depend on arguments Bram Moolenaar <Bram@vim.org> parents: 19562 diff changeset	1373 int i;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1374
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1375 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1376 if (check_internal_func(func_idx, argcount) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1377 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1378
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1379 if ((isn = generate_instr(cctx, ISN_BCALL)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1380 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1381 isn->isn_arg.bfunc.cbf_idx = func_idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1382 isn->isn_arg.bfunc.cbf_argcount = argcount;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1383
19564 06f29b6ea04a patch 8.2.0339: Vim9: function return type may depend on arguments Bram Moolenaar <Bram@vim.org> parents: 19562 diff changeset	1384 for (i = 0; i < argcount; ++i)
06f29b6ea04a patch 8.2.0339: Vim9: function return type may depend on arguments Bram Moolenaar <Bram@vim.org> parents: 19562 diff changeset	1385 argtypes[i] = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i];
06f29b6ea04a patch 8.2.0339: Vim9: function return type may depend on arguments Bram Moolenaar <Bram@vim.org> parents: 19562 diff changeset	1386
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1387 stack->ga_len -= argcount; // drop the arguments
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1388 if (ga_grow(stack, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1389 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1390 ((type_T **)stack->ga_data)[stack->ga_len] =
19564 06f29b6ea04a patch 8.2.0339: Vim9: function return type may depend on arguments Bram Moolenaar <Bram@vim.org> parents: 19562 diff changeset	1391 internal_func_ret_type(func_idx, argcount, argtypes);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1392 ++stack->ga_len; // add return value
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1393
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1394 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1395 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1396
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1397 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1398 * Generate an ISN_DCALL or ISN_UCALL instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1399 * Return FAIL if the number of arguments is wrong.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1400 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1401 static int
19328 e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	1402 generate_CALL(cctx_T cctx, ufunc_T ufunc, int pushed_argcount)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1403 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1404 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1405 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1406 int regular_args = ufunc->uf_args.ga_len;
19328 e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	1407 int argcount = pushed_argcount;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1408
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1409 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1410 if (argcount > regular_args && !has_varargs(ufunc))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1411 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1412 semsg(_(e_toomanyarg), ufunc->uf_name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1413 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1414 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1415 if (argcount < regular_args - ufunc->uf_def_args.ga_len)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1416 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1417 semsg(_(e_toofewarg), ufunc->uf_name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1418 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1419 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1420
19944 3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1421 if (ufunc->uf_dfunc_idx >= 0)
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1422 {
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1423 int i;
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1424
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1425 for (i = 0; i < argcount; ++i)
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1426 {
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1427 type_T *expected;
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1428 type_T *actual;
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1429
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1430 if (i < regular_args)
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1431 {
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1432 if (ufunc->uf_arg_types == NULL)
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1433 continue;
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1434 expected = ufunc->uf_arg_types[i];
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1435 }
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1436 else
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1437 expected = ufunc->uf_va_type->tt_member;
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1438 actual = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i];
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1439 if (need_type(actual, expected, -argcount + i, cctx) == FAIL)
19944 3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1440 {
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1441 arg_type_mismatch(expected, actual, i + 1);
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1442 return FAIL;
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1443 }
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1444 }
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1445 }
3055cd26e139 patch 8.2.0528: Vim9: function arguments insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19942 diff changeset	1446
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1447 if ((isn = generate_instr(cctx,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1448 ufunc->uf_dfunc_idx >= 0 ? ISN_DCALL : ISN_UCALL)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1449 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1450 if (ufunc->uf_dfunc_idx >= 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1451 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1452 isn->isn_arg.dfunc.cdf_idx = ufunc->uf_dfunc_idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1453 isn->isn_arg.dfunc.cdf_argcount = argcount;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1454 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1455 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1456 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1457 // A user function may be deleted and redefined later, can't use the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1458 // ufunc pointer, need to look it up again at runtime.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1459 isn->isn_arg.ufunc.cuf_name = vim_strsave(ufunc->uf_name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1460 isn->isn_arg.ufunc.cuf_argcount = argcount;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1461 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1462
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1463 stack->ga_len -= argcount; // drop the arguments
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1464 if (ga_grow(stack, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1465 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1466 // add return value
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1467 ((type_T **)stack->ga_data)[stack->ga_len] = ufunc->uf_ret_type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1468 ++stack->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1469
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1470 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1471 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1472
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1473 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1474 * Generate an ISN_UCALL instruction when the function isn't defined yet.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1475 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1476 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1477 generate_UCALL(cctx_T cctx, char_u name, int argcount)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1478 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1479 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1480 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1481
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1482 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1483 if ((isn = generate_instr(cctx, ISN_UCALL)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1484 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1485 isn->isn_arg.ufunc.cuf_name = vim_strsave(name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1486 isn->isn_arg.ufunc.cuf_argcount = argcount;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1487
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1488 stack->ga_len -= argcount; // drop the arguments
19295 2a63b7f5802a patch 8.2.0206: calling Vim9 function using default argument fails Bram Moolenaar <Bram@vim.org> parents: 19285 diff changeset	1489 if (ga_grow(stack, 1) == FAIL)
2a63b7f5802a patch 8.2.0206: calling Vim9 function using default argument fails Bram Moolenaar <Bram@vim.org> parents: 19285 diff changeset	1490 return FAIL;
2a63b7f5802a patch 8.2.0206: calling Vim9 function using default argument fails Bram Moolenaar <Bram@vim.org> parents: 19285 diff changeset	1491 // add return value
2a63b7f5802a patch 8.2.0206: calling Vim9 function using default argument fails Bram Moolenaar <Bram@vim.org> parents: 19285 diff changeset	1492 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
2a63b7f5802a patch 8.2.0206: calling Vim9 function using default argument fails Bram Moolenaar <Bram@vim.org> parents: 19285 diff changeset	1493 ++stack->ga_len;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1494
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1495 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1496 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1497
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1498 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1499 * Generate an ISN_PCALL instruction.
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1500 * "type" is the type of the FuncRef.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1501 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1502 static int
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1503 generate_PCALL(
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1504 cctx_T *cctx,
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1505 int argcount,
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1506 char_u *name,
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1507 type_T *type,
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1508 int at_top)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1509 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1510 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1511 garray_T *stack = &cctx->ctx_type_stack;
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1512 type_T *ret_type;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1513
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1514 RETURN_OK_IF_SKIP(cctx);
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1515
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1516 if (type->tt_type == VAR_ANY)
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1517 ret_type = &t_any;
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1518 else if (type->tt_type == VAR_FUNC \|\| type->tt_type == VAR_PARTIAL)
20281 ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1519 {
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1520 if (type->tt_argcount != -1)
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1521 {
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1522 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0;
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1523
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1524 if (argcount < type->tt_min_argcount - varargs)
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1525 {
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1526 semsg(_(e_toofewarg), "[reference]");
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1527 return FAIL;
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1528 }
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1529 if (!varargs && argcount > type->tt_argcount)
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1530 {
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1531 semsg(_(e_toomanyarg), "[reference]");
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1532 return FAIL;
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1533 }
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1534 }
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1535 ret_type = type->tt_member;
20281 ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	1536 }
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1537 else
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1538 {
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1539 semsg(_("E1085: Not a callable type: %s"), name);
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1540 return FAIL;
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1541 }
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1542
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1543 if ((isn = generate_instr(cctx, ISN_PCALL)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1544 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1545 isn->isn_arg.pfunc.cpf_top = at_top;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1546 isn->isn_arg.pfunc.cpf_argcount = argcount;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1547
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1548 stack->ga_len -= argcount; // drop the arguments
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1549
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1550 // drop the funcref/partial, get back the return value
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	1551 ((type_T **)stack->ga_data)[stack->ga_len - 1] = ret_type;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1552
19862 846fbbacce3a patch 8.2.0487: Vim9: compiling not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19860 diff changeset	1553 // If partial is above the arguments it must be cleared and replaced with
846fbbacce3a patch 8.2.0487: Vim9: compiling not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19860 diff changeset	1554 // the return value.
846fbbacce3a patch 8.2.0487: Vim9: compiling not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19860 diff changeset	1555 if (at_top && generate_instr(cctx, ISN_PCALL_END) == NULL)
846fbbacce3a patch 8.2.0487: Vim9: compiling not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19860 diff changeset	1556 return FAIL;
846fbbacce3a patch 8.2.0487: Vim9: compiling not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19860 diff changeset	1557
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1558 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1559 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1560
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1561 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1562 * Generate an ISN_MEMBER instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1563 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1564 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1565 generate_MEMBER(cctx_T cctx, char_u name, size_t len)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1566 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1567 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1568 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1569 type_T *type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1570
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1571 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1572 if ((isn = generate_instr(cctx, ISN_MEMBER)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1573 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1574 isn->isn_arg.string = vim_strnsave(name, (int)len);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1575
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1576 // check for dict type
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1577 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1578 if (type->tt_type != VAR_DICT && type != &t_any)
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1579 {
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1580 emsg(_(e_dictreq));
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1581 return FAIL;
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1582 }
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1583 // change dict type to dict member type
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1584 if (type->tt_type == VAR_DICT)
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	1585 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type->tt_member;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1586
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1587 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1588 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1589
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1590 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1591 * Generate an ISN_ECHO instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1592 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1593 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1594 generate_ECHO(cctx_T *cctx, int with_white, int count)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1595 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1596 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1597
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1598 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1599 if ((isn = generate_instr_drop(cctx, ISN_ECHO, count)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1600 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1601 isn->isn_arg.echo.echo_with_white = with_white;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1602 isn->isn_arg.echo.echo_count = count;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1603
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1604 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1605 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1606
19528 3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1607 /*
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	1608 * Generate an ISN_EXECUTE/ISN_ECHOMSG/ISN_ECHOERR instruction.
19528 3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1609 */
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1610 static int
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	1611 generate_MULT_EXPR(cctx_T *cctx, isntype_T isn_type, int count)
19528 3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1612 {
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1613 isn_T *isn;
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1614
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	1615 if ((isn = generate_instr_drop(cctx, isn_type, count)) == NULL)
19528 3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1616 return FAIL;
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1617 isn->isn_arg.number = count;
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1618
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1619 return OK;
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1620 }
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1621
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1622 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1623 generate_EXEC(cctx_T cctx, char_u line)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1624 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1625 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1626
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1627 RETURN_OK_IF_SKIP(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1628 if ((isn = generate_instr(cctx, ISN_EXEC)) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1629 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1630 isn->isn_arg.string = vim_strsave(line);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1631 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1632 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1633
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1634 static int
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1635 generate_EXECCONCAT(cctx_T *cctx, int count)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1636 {
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1637 isn_T *isn;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1638
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1639 if ((isn = generate_instr_drop(cctx, ISN_EXECCONCAT, count)) == NULL)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1640 return FAIL;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1641 isn->isn_arg.number = count;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1642 return OK;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1643 }
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	1644
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1645 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1646 * Reserve space for a local variable.
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1647 * Return the variable or NULL if it failed.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1648 */
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1649 static lvar_T *
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1650 reserve_local(cctx_T cctx, char_u name, size_t len, int isConst, type_T *type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1651 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1652 lvar_T *lvar;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1653
20275 350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	1654 if (lookup_arg(name, len, NULL, NULL, NULL, cctx) == OK)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1655 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1656 emsg_namelen(_("E1006: %s is used as an argument"), name, (int)len);
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1657 return NULL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1658 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1659
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1660 if (ga_grow(&cctx->ctx_locals, 1) == FAIL)
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1661 return NULL;
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1662 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + cctx->ctx_locals.ga_len++;
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1663
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1664 // Every local variable uses the next entry on the stack. We could re-use
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1665 // the last ones when leaving a scope, but then variables used in a closure
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1666 // might get overwritten. To keep things simple do not re-use stack
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1667 // entries. This is less efficient, but memory is cheap these days.
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1668 lvar->lv_idx = cctx->ctx_locals_count++;
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1669
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1670 lvar->lv_name = vim_strnsave(name, (int)(len == 0 ? STRLEN(name) : len));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1671 lvar->lv_const = isConst;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1672 lvar->lv_type = type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1673
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1674 return lvar;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1675 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1676
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1677 /*
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1678 * Remove local variables above "new_top".
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1679 */
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1680 static void
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1681 unwind_locals(cctx_T *cctx, int new_top)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1682 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1683 if (cctx->ctx_locals.ga_len > new_top)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1684 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1685 int idx;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1686 lvar_T *lvar;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1687
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1688 for (idx = new_top; idx < cctx->ctx_locals.ga_len; ++idx)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1689 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1690 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1691 vim_free(lvar->lv_name);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1692 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1693 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1694 cctx->ctx_locals.ga_len = new_top;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1695 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1696
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1697 /*
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1698 * Free all local variables.
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1699 */
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1700 static void
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1701 free_locals(cctx_T *cctx)
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1702 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1703 unwind_locals(cctx, 0);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1704 ga_clear(&cctx->ctx_locals);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1705 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1706
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	1707 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1708 * Skip over a type definition and return a pointer to just after it.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1709 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1710 char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1711 skip_type(char_u *start)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1712 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1713 char_u *p = start;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1714
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1715 while (ASCII_ISALNUM(p) \|\| p == '_')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1716 ++p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1717
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1718 // Skip over "<type>"; this is permissive about white space.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1719 if (*skipwhite(p) == '<')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1720 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1721 p = skipwhite(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1722 p = skip_type(skipwhite(p + 1));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1723 p = skipwhite(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1724 if (*p == '>')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1725 ++p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1726 }
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1727 else if (*p == '(' && STRNCMP("func", start, 4) == 0)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1728 {
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1729 // handle func(args): type
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1730 ++p;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1731 while (p != ')' && p != NUL)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1732 {
20253 6f9010b6f7f9 patch 8.2.0682: Vim9: parsing function argument type can get stuck Bram Moolenaar <Bram@vim.org> parents: 20247 diff changeset	1733 char_u *sp = p;
6f9010b6f7f9 patch 8.2.0682: Vim9: parsing function argument type can get stuck Bram Moolenaar <Bram@vim.org> parents: 20247 diff changeset	1734
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1735 p = skip_type(p);
20253 6f9010b6f7f9 patch 8.2.0682: Vim9: parsing function argument type can get stuck Bram Moolenaar <Bram@vim.org> parents: 20247 diff changeset	1736 if (p == sp)
6f9010b6f7f9 patch 8.2.0682: Vim9: parsing function argument type can get stuck Bram Moolenaar <Bram@vim.org> parents: 20247 diff changeset	1737 return p; // syntax error
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1738 if (*p == ',')
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1739 p = skipwhite(p + 1);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1740 }
20255 aac52c32a91f patch 8.2.0683: Vim9: parsing type does not always work Bram Moolenaar <Bram@vim.org> parents: 20253 diff changeset	1741 if (*p == ')')
aac52c32a91f patch 8.2.0683: Vim9: parsing type does not always work Bram Moolenaar <Bram@vim.org> parents: 20253 diff changeset	1742 {
aac52c32a91f patch 8.2.0683: Vim9: parsing type does not always work Bram Moolenaar <Bram@vim.org> parents: 20253 diff changeset	1743 if (p[1] == ':')
aac52c32a91f patch 8.2.0683: Vim9: parsing type does not always work Bram Moolenaar <Bram@vim.org> parents: 20253 diff changeset	1744 p = skip_type(skipwhite(p + 2));
aac52c32a91f patch 8.2.0683: Vim9: parsing type does not always work Bram Moolenaar <Bram@vim.org> parents: 20253 diff changeset	1745 else
aac52c32a91f patch 8.2.0683: Vim9: parsing type does not always work Bram Moolenaar <Bram@vim.org> parents: 20253 diff changeset	1746 p = skipwhite(p + 1);
aac52c32a91f patch 8.2.0683: Vim9: parsing type does not always work Bram Moolenaar <Bram@vim.org> parents: 20253 diff changeset	1747 }
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1748 }
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	1749
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1750 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1751 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1752
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1753 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1754 * Parse the member type: "<type>" and return "type" with the member set.
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1755 * Use "type_gap" if a new type needs to be added.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1756 * Returns NULL in case of failure.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1757 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1758 static type_T *
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1759 parse_type_member(char_u *arg, type_T type, garray_T *type_gap)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1760 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1761 type_T *member_type;
19818 c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	1762 int prev_called_emsg = called_emsg;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1763
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1764 if (**arg != '<')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1765 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1766 if (skipwhite(arg) == '<')
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1767 semsg(_(e_no_white_before), "<");
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1768 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1769 emsg(_("E1008: Missing <type>"));
19785 99248f0ff29d patch 8.2.0449: Vim9: crash if return type is invalid Bram Moolenaar <Bram@vim.org> parents: 19760 diff changeset	1770 return type;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1771 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1772 arg = skipwhite(arg + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1773
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1774 member_type = parse_type(arg, type_gap);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1775
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1776 arg = skipwhite(arg);
19818 c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	1777 if (**arg != '>' && called_emsg == prev_called_emsg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1778 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1779 emsg(_("E1009: Missing > after type"));
19785 99248f0ff29d patch 8.2.0449: Vim9: crash if return type is invalid Bram Moolenaar <Bram@vim.org> parents: 19760 diff changeset	1780 return type;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1781 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1782 ++*arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1783
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1784 if (type->tt_type == VAR_LIST)
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1785 return get_list_type(member_type, type_gap);
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1786 return get_dict_type(member_type, type_gap);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1787 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1788
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1789 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1790 * Parse a type at "arg" and advance over it.
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	1791 * Return &t_any for failure.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1792 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1793 type_T *
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1794 parse_type(char_u *arg, garray_T type_gap)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1795 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1796 char_u p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1797 size_t len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1798
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1799 // skip over the first word
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1800 while (ASCII_ISALNUM(p) \|\| p == '_')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1801 ++p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1802 len = p - *arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1803
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1804 switch (**arg)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1805 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1806 case 'a':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1807 if (len == 3 && STRNCMP(*arg, "any", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1808 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1809 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1810 return &t_any;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1811 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1812 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1813 case 'b':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1814 if (len == 4 && STRNCMP(*arg, "bool", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1815 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1816 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1817 return &t_bool;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1818 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1819 if (len == 4 && STRNCMP(*arg, "blob", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1820 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1821 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1822 return &t_blob;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1823 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1824 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1825 case 'c':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1826 if (len == 7 && STRNCMP(*arg, "channel", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1827 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1828 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1829 return &t_channel;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1830 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1831 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1832 case 'd':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1833 if (len == 4 && STRNCMP(*arg, "dict", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1834 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1835 *arg += len;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1836 return parse_type_member(arg, &t_dict_any, type_gap);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1837 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1838 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1839 case 'f':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1840 if (len == 5 && STRNCMP(*arg, "float", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1841 {
19193 9f98957582d6 patch 8.2.0155: warnings from MinGW compiler; tests fail without +float Bram Moolenaar <Bram@vim.org> parents: 19191 diff changeset	1842 #ifdef FEAT_FLOAT
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1843 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1844 return &t_float;
19193 9f98957582d6 patch 8.2.0155: warnings from MinGW compiler; tests fail without +float Bram Moolenaar <Bram@vim.org> parents: 19191 diff changeset	1845 #else
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1846 emsg(_("E1076: This Vim is not compiled with float support"));
19193 9f98957582d6 patch 8.2.0155: warnings from MinGW compiler; tests fail without +float Bram Moolenaar <Bram@vim.org> parents: 19191 diff changeset	1847 return &t_any;
9f98957582d6 patch 8.2.0155: warnings from MinGW compiler; tests fail without +float Bram Moolenaar <Bram@vim.org> parents: 19191 diff changeset	1848 #endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1849 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1850 if (len == 4 && STRNCMP(*arg, "func", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1851 {
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1852 type_T *type;
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	1853 type_T *ret_type = &t_unknown;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1854 int argcount = -1;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1855 int flags = 0;
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1856 int first_optional = -1;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1857 type_T *arg_type[MAX_FUNC_ARGS + 1];
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1858
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1859 // func({type}, ...{type}): {type}
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1860 *arg += len;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1861 if (**arg == '(')
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1862 {
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1863 // "func" may or may not return a value, "func()" does
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1864 // not return a value.
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1865 ret_type = &t_void;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1866
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1867 p = ++*arg;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1868 argcount = 0;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1869 while (p != NUL && p != ')')
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1870 {
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1871 if (*p == '?')
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1872 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1873 if (first_optional == -1)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1874 first_optional = argcount;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1875 ++p;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1876 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1877 else if (first_optional != -1)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1878 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1879 emsg(_("E1007: mandatory argument after optional argument"));
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1880 return &t_any;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1881 }
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1882 else if (STRNCMP(p, "...", 3) == 0)
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1883 {
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1884 flags \|= TTFLAG_VARARGS;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1885 p += 3;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1886 }
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1887
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1888 arg_type[argcount++] = parse_type(&p, type_gap);
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1889
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1890 // Nothing comes after "...{type}".
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1891 if (flags & TTFLAG_VARARGS)
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1892 break;
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1893
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1894 if (p != ',' && skipwhite(p) == ',')
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1895 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1896 semsg(_(e_no_white_before), ",");
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1897 return &t_any;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1898 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1899 if (*p == ',')
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1900 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1901 ++p;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1902 if (!VIM_ISWHITE(*p))
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	1903 {
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1904 semsg(_(e_white_after), ",");
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	1905 return &t_any;
f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	1906 }
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1907 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1908 p = skipwhite(p);
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1909 if (argcount == MAX_FUNC_ARGS)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1910 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1911 emsg(_("E740: Too many argument types"));
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1912 return &t_any;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1913 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1914 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1915
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1916 p = skipwhite(p);
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1917 if (*p != ')')
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1918 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1919 emsg(_(e_missing_close));
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1920 return &t_any;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1921 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1922 *arg = p + 1;
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1923 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1924 if (**arg == ':')
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1925 {
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1926 // parse return type
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1927 ++*arg;
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	1928 if (!VIM_ISWHITE(**arg))
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1929 semsg(_(e_white_after), ":");
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1930 arg = skipwhite(arg);
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1931 ret_type = parse_type(arg, type_gap);
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1932 }
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	1933 if (flags == 0 && first_optional == -1 && argcount <= 0)
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1934 type = get_func_type(ret_type, argcount, type_gap);
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1935 else
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1936 {
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1937 type = alloc_func_type(ret_type, argcount, type_gap);
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1938 type->tt_flags = flags;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1939 if (argcount > 0)
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1940 {
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1941 type->tt_argcount = argcount;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1942 type->tt_min_argcount = first_optional == -1
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1943 ? argcount : first_optional;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1944 if (func_type_add_arg_types(type, argcount,
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	1945 type_gap) == FAIL)
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1946 return &t_any;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1947 mch_memmove(type->tt_args, arg_type,
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1948 sizeof(type_T ) argcount);
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	1949 }
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1950 }
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1951 return type;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1952 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1953 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1954 case 'j':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1955 if (len == 3 && STRNCMP(*arg, "job", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1956 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1957 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1958 return &t_job;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1959 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1960 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1961 case 'l':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1962 if (len == 4 && STRNCMP(*arg, "list", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1963 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1964 *arg += len;
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	1965 return parse_type_member(arg, &t_list_any, type_gap);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1966 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1967 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1968 case 'n':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1969 if (len == 6 && STRNCMP(*arg, "number", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1970 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1971 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1972 return &t_number;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1973 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1974 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1975 case 's':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1976 if (len == 6 && STRNCMP(*arg, "string", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1977 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1978 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1979 return &t_string;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1980 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1981 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1982 case 'v':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1983 if (len == 4 && STRNCMP(*arg, "void", len) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1984 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1985 *arg += len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1986 return &t_void;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1987 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1988 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1989 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1990
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1991 semsg(_("E1010: Type not recognized: %s"), *arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1992 return &t_any;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1993 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1994
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1995 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1996 * Check if "type1" and "type2" are exactly the same.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1997 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1998 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1999 equal_type(type_T type1, type_T type2)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2000 {
19993 efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2001 int i;
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2002
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2003 if (type1->tt_type != type2->tt_type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2004 return FALSE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2005 switch (type1->tt_type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2006 {
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	2007 case VAR_UNKNOWN:
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	2008 case VAR_ANY:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2009 case VAR_VOID:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2010 case VAR_SPECIAL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2011 case VAR_BOOL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2012 case VAR_NUMBER:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2013 case VAR_FLOAT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2014 case VAR_STRING:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2015 case VAR_BLOB:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2016 case VAR_JOB:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2017 case VAR_CHANNEL:
19579 aae19dd172c0 patch 8.2.0346: Vim9: finding common list type not tested Bram Moolenaar <Bram@vim.org> parents: 19572 diff changeset	2018 break; // not composite is always OK
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2019 case VAR_LIST:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2020 case VAR_DICT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2021 return equal_type(type1->tt_member, type2->tt_member);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2022 case VAR_FUNC:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2023 case VAR_PARTIAL:
19993 efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2024 if (!equal_type(type1->tt_member, type2->tt_member)
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2025 \|\| type1->tt_argcount != type2->tt_argcount)
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2026 return FALSE;
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2027 if (type1->tt_argcount < 0
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2028 \|\| type1->tt_args == NULL \|\| type2->tt_args == NULL)
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2029 return TRUE;
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2030 for (i = 0; i < type1->tt_argcount; ++i)
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2031 if (!equal_type(type1->tt_args[i], type2->tt_args[i]))
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2032 return FALSE;
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2033 return TRUE;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2034 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2035 return TRUE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2036 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2037
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2038 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2039 * Find the common type of "type1" and "type2" and put it in "dest".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2040 * "type2" and "dest" may be the same.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2041 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2042 static void
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	2043 common_type(type_T type1, type_T type2, type_T *dest, garray_T type_gap)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2044 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2045 if (equal_type(type1, type2))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2046 {
19579 aae19dd172c0 patch 8.2.0346: Vim9: finding common list type not tested Bram Moolenaar <Bram@vim.org> parents: 19572 diff changeset	2047 *dest = type1;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2048 return;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2049 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2050
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2051 if (type1->tt_type == type2->tt_type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2052 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2053 if (type1->tt_type == VAR_LIST \|\| type2->tt_type == VAR_DICT)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2054 {
19579 aae19dd172c0 patch 8.2.0346: Vim9: finding common list type not tested Bram Moolenaar <Bram@vim.org> parents: 19572 diff changeset	2055 type_T *common;
aae19dd172c0 patch 8.2.0346: Vim9: finding common list type not tested Bram Moolenaar <Bram@vim.org> parents: 19572 diff changeset	2056
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	2057 common_type(type1->tt_member, type2->tt_member, &common, type_gap);
19579 aae19dd172c0 patch 8.2.0346: Vim9: finding common list type not tested Bram Moolenaar <Bram@vim.org> parents: 19572 diff changeset	2058 if (type1->tt_type == VAR_LIST)
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	2059 *dest = get_list_type(common, type_gap);
19579 aae19dd172c0 patch 8.2.0346: Vim9: finding common list type not tested Bram Moolenaar <Bram@vim.org> parents: 19572 diff changeset	2060 else
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	2061 *dest = get_dict_type(common, type_gap);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2062 return;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2063 }
19993 efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2064 if (type1->tt_type == VAR_FUNC)
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2065 {
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2066 type_T *common;
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2067
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2068 common_type(type1->tt_member, type2->tt_member, &common, type_gap);
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2069 if (type1->tt_argcount == type2->tt_argcount
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2070 && type1->tt_argcount >= 0)
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2071 {
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2072 int argcount = type1->tt_argcount;
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2073 int i;
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2074
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2075 *dest = alloc_func_type(common, argcount, type_gap);
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2076 if (type1->tt_args != NULL && type2->tt_args != NULL)
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2077 {
20001 502a6c9b3974 patch 8.2.0556: Vim9: memory leak when finding common type Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	2078 if (func_type_add_arg_types(*dest, argcount,
502a6c9b3974 patch 8.2.0556: Vim9: memory leak when finding common type Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	2079 type_gap) == OK)
19993 efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2080 for (i = 0; i < argcount; ++i)
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2081 common_type(type1->tt_args[i], type2->tt_args[i],
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2082 &(*dest)->tt_args[i], type_gap);
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2083 }
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2084 }
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2085 else
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2086 *dest = alloc_func_type(common, -1, type_gap);
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2087 return;
efe864a7ce4f patch 8.2.0552: Vim9: some errors not covered by tests Bram Moolenaar <Bram@vim.org> parents: 19985 diff changeset	2088 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2089 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2090
19579 aae19dd172c0 patch 8.2.0346: Vim9: finding common list type not tested Bram Moolenaar <Bram@vim.org> parents: 19572 diff changeset	2091 *dest = &t_any;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2092 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2093
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2094 char *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2095 vartype_name(vartype_T type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2096 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2097 switch (type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2098 {
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	2099 case VAR_UNKNOWN: break;
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	2100 case VAR_ANY: return "any";
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2101 case VAR_VOID: return "void";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2102 case VAR_SPECIAL: return "special";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2103 case VAR_BOOL: return "bool";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2104 case VAR_NUMBER: return "number";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2105 case VAR_FLOAT: return "float";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2106 case VAR_STRING: return "string";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2107 case VAR_BLOB: return "blob";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2108 case VAR_JOB: return "job";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2109 case VAR_CHANNEL: return "channel";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2110 case VAR_LIST: return "list";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2111 case VAR_DICT: return "dict";
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2112
f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2113 case VAR_FUNC:
f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2114 case VAR_PARTIAL: return "func";
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2115 }
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	2116 return "unknown";
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2117 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2118
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2119 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2120 * Return the name of a type.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2121 * The result may be in allocated memory, in which case "tofree" is set.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2122 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2123 char *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2124 type_name(type_T type, char *tofree)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2125 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2126 char *name = vartype_name(type->tt_type);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2127
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2128 *tofree = NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2129 if (type->tt_type == VAR_LIST \|\| type->tt_type == VAR_DICT)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2130 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2131 char *member_free;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2132 char *member_name = type_name(type->tt_member, &member_free);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2133 size_t len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2134
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2135 len = STRLEN(name) + STRLEN(member_name) + 3;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2136 *tofree = alloc(len);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2137 if (*tofree != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2138 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2139 vim_snprintf(*tofree, len, "%s<%s>", name, member_name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2140 vim_free(member_free);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2141 return *tofree;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2142 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2143 }
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2144 if (type->tt_type == VAR_FUNC)
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2145 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2146 garray_T ga;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2147 int i;
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	2148 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0;
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2149
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2150 ga_init2(&ga, 1, 100);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2151 if (ga_grow(&ga, 20) == FAIL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2152 return "[unknown]";
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2153 *tofree = ga.ga_data;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2154 STRCPY(ga.ga_data, "func(");
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2155 ga.ga_len += 5;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2156
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2157 for (i = 0; i < type->tt_argcount; ++i)
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2158 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2159 char *arg_free;
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2160 char *arg_type;
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2161 int len;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2162
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2163 if (type->tt_args == NULL)
f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2164 arg_type = "[unknown]";
f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2165 else
f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2166 arg_type = type_name(type->tt_args[i], &arg_free);
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2167 if (i > 0)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2168 {
19918 ccfeae6af59e patch 8.2.0515: some compilers cannot add to "void " Bram Moolenaar <Bram@vim.org>* parents: 19914 diff changeset	2169 STRCPY((char *)ga.ga_data + ga.ga_len, ", ");
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2170 ga.ga_len += 2;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2171 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2172 len = (int)STRLEN(arg_type);
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	2173 if (ga_grow(&ga, len + 8) == FAIL)
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2174 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2175 vim_free(arg_free);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2176 return "[unknown]";
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2177 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2178 *tofree = ga.ga_data;
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	2179 if (varargs && i == type->tt_argcount - 1)
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	2180 {
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	2181 STRCPY((char *)ga.ga_data + ga.ga_len, "...");
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	2182 ga.ga_len += 3;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	2183 }
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	2184 else if (i >= type->tt_min_argcount)
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	2185 ((char )ga.ga_data + ga.ga_len++) = '?';
19918 ccfeae6af59e patch 8.2.0515: some compilers cannot add to "void " Bram Moolenaar <Bram@vim.org>* parents: 19914 diff changeset	2186 STRCPY((char *)ga.ga_data + ga.ga_len, arg_type);
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2187 ga.ga_len += len;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2188 vim_free(arg_free);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2189 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2190
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2191 if (type->tt_member == &t_void)
19918 ccfeae6af59e patch 8.2.0515: some compilers cannot add to "void " Bram Moolenaar <Bram@vim.org>* parents: 19914 diff changeset	2192 STRCPY((char *)ga.ga_data + ga.ga_len, ")");
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2193 else
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2194 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2195 char *ret_free;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2196 char *ret_name = type_name(type->tt_member, &ret_free);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2197 int len;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2198
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2199 len = (int)STRLEN(ret_name) + 4;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2200 if (ga_grow(&ga, len) == FAIL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2201 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2202 vim_free(ret_free);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2203 return "[unknown]";
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2204 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2205 *tofree = ga.ga_data;
19918 ccfeae6af59e patch 8.2.0515: some compilers cannot add to "void " Bram Moolenaar <Bram@vim.org>* parents: 19914 diff changeset	2206 STRCPY((char *)ga.ga_data + ga.ga_len, "): ");
ccfeae6af59e patch 8.2.0515: some compilers cannot add to "void " Bram Moolenaar <Bram@vim.org>* parents: 19914 diff changeset	2207 STRCPY((char *)ga.ga_data + ga.ga_len + 3, ret_name);
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2208 vim_free(ret_free);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2209 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2210 return ga.ga_data;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2211 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2212
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2213 return name;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2214 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2215
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2216 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2217 * Find "name" in script-local items of script "sid".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2218 * Returns the index in "sn_var_vals" if found.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2219 * If found but not in "sn_var_vals" returns -1.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2220 * If not found returns -2.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2221 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2222 int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2223 get_script_item_idx(int sid, char_u *name, int check_writable)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2224 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2225 hashtab_T *ht;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2226 dictitem_T *di;
19191 133ef7ba4e4e patch 8.2.0154: reallocating the list of scripts is inefficient Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	2227 scriptitem_T *si = SCRIPT_ITEM(sid);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2228 int idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2229
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2230 // First look the name up in the hashtable.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2231 if (sid <= 0 \|\| sid > script_items.ga_len)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2232 return -1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2233 ht = &SCRIPT_VARS(sid);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2234 di = find_var_in_ht(ht, 0, name, TRUE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2235 if (di == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2236 return -2;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2237
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2238 // Now find the svar_T index in sn_var_vals.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2239 for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2240 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2241 svar_T sv = ((svar_T )si->sn_var_vals.ga_data) + idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2242
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2243 if (sv->sv_tv == &di->di_tv)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2244 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2245 if (check_writable && sv->sv_const)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2246 semsg(_(e_readonlyvar), name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2247 return idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2248 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2249 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2250 return -1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2251 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2252
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2253 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2254 * Find "name" in imported items of the current script/
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2255 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2256 imported_T *
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	2257 find_imported(char_u name, size_t len, cctx_T cctx)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2258 {
19191 133ef7ba4e4e patch 8.2.0154: reallocating the list of scripts is inefficient Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	2259 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2260 int idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2261
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2262 if (cctx != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2263 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2264 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2265 imported_T import = ((imported_T )cctx->ctx_imports.ga_data)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2266 + idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2267
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	2268 if (len == 0 ? STRCMP(name, import->imp_name) == 0
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	2269 : STRLEN(import->imp_name) == len
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	2270 && STRNCMP(name, import->imp_name, len) == 0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2271 return import;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2272 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2273
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2274 for (idx = 0; idx < si->sn_imports.ga_len; ++idx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2275 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2276 imported_T import = ((imported_T )si->sn_imports.ga_data) + idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2277
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	2278 if (len == 0 ? STRCMP(name, import->imp_name) == 0
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	2279 : STRLEN(import->imp_name) == len
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	2280 && STRNCMP(name, import->imp_name, len) == 0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2281 return import;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2282 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2283 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2284 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2285
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2286 /*
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2287 * Free all imported variables.
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2288 */
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2289 static void
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2290 free_imported(cctx_T *cctx)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2291 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2292 int idx;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2293
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2294 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2295 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2296 imported_T import = ((imported_T )cctx->ctx_imports.ga_data) + idx;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2297
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2298 vim_free(import->imp_name);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2299 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2300 ga_clear(&cctx->ctx_imports);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2301 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2302
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2303 /*
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2304 * Get the next line of the function from "cctx".
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2305 * Returns NULL when at the end.
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2306 */
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2307 static char_u *
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2308 next_line_from_context(cctx_T *cctx)
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2309 {
20059 de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	2310 char_u *line;
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2311
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2312 do
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2313 {
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2314 ++cctx->ctx_lnum;
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2315 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len)
20059 de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	2316 {
de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	2317 line = NULL;
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2318 break;
20059 de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	2319 }
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2320 line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
20059 de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	2321 cctx->ctx_line_start = line;
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2322 SOURCING_LNUM = cctx->ctx_ufunc->uf_script_ctx.sc_lnum
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2323 + cctx->ctx_lnum + 1;
20019 e9af5a09a55b patch 8.2.0565: Vim9: tests contain superfluous line continuation Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	2324 } while (line == NULL \|\| *skipwhite(line) == NUL);
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2325 return line;
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2326 }
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2327
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2328 /*
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2329 * Return TRUE if "p" points at a "#" but not at "#{".
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2330 */
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2331 static int
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2332 comment_start(char_u *p)
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2333 {
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2334 return p[0] == '#' && p[1] != '{';
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2335 }
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2336
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2337 /*
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2338 * If "*arg" is at the end of the line, advance to the next line.
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2339 * Also when "whitep" points to white space and "*arg" is on a "#".
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2340 * Return FAIL if beyond the last line, "*arg" is unmodified then.
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2341 */
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2342 static int
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2343 may_get_next_line(char_u whitep, char_u arg, cctx_T cctx)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2344 {
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2345 if (*arg == NUL \|\| (VIM_ISWHITE(whitep) && comment_start(*arg)))
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2346 {
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2347 char_u *next = next_line_from_context(cctx);
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2348
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2349 if (next == NULL)
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2350 return FAIL;
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2351 *arg = skipwhite(next);
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2352 }
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2353 return OK;
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2354 }
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2355
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2356 // Structure passed between the compile_expr* functions to keep track of
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2357 // constants that have been parsed but for which no code was produced yet. If
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2358 // possible expressions on these constants are applied at compile time. If
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2359 // that is not possible, the code to push the constants needs to be generated
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2360 // before other instructions.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2361 typedef struct {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2362 typval_T pp_tv[10]; // stack of ppconst constants
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2363 int pp_used; // active entries in pp_tv[]
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2364 } ppconst_T;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2365
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2366 /*
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2367 * Generate a PUSH instruction for "tv".
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2368 * "tv" will be consumed or cleared.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2369 * Nothing happens if "tv" is NULL or of type VAR_UNKNOWN;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2370 */
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2371 static int
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2372 generate_tv_PUSH(cctx_T cctx, typval_T tv)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2373 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2374 if (tv != NULL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2375 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2376 switch (tv->v_type)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2377 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2378 case VAR_UNKNOWN:
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2379 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2380 case VAR_BOOL:
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2381 generate_PUSHBOOL(cctx, tv->vval.v_number);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2382 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2383 case VAR_SPECIAL:
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2384 generate_PUSHSPEC(cctx, tv->vval.v_number);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2385 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2386 case VAR_NUMBER:
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2387 generate_PUSHNR(cctx, tv->vval.v_number);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2388 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2389 #ifdef FEAT_FLOAT
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2390 case VAR_FLOAT:
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2391 generate_PUSHF(cctx, tv->vval.v_float);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2392 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2393 #endif
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2394 case VAR_BLOB:
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2395 generate_PUSHBLOB(cctx, tv->vval.v_blob);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2396 tv->vval.v_blob = NULL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2397 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2398 case VAR_STRING:
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2399 generate_PUSHS(cctx, tv->vval.v_string);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2400 tv->vval.v_string = NULL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2401 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2402 default:
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2403 iemsg("constant type not supported");
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2404 clear_tv(tv);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2405 return FAIL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2406 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2407 tv->v_type = VAR_UNKNOWN;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2408 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2409 return OK;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2410 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2411
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2412 /*
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2413 * Generate code for any ppconst entries.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2414 */
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2415 static int
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2416 generate_ppconst(cctx_T cctx, ppconst_T ppconst)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2417 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2418 int i;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2419 int ret = OK;
20332 a407e243c55c patch 8.2.0721: Vim9: leaking memory when skipping Bram Moolenaar <Bram@vim.org> parents: 20328 diff changeset	2420 int save_skip = cctx->ctx_skip;
a407e243c55c patch 8.2.0721: Vim9: leaking memory when skipping Bram Moolenaar <Bram@vim.org> parents: 20328 diff changeset	2421
a407e243c55c patch 8.2.0721: Vim9: leaking memory when skipping Bram Moolenaar <Bram@vim.org> parents: 20328 diff changeset	2422 cctx->ctx_skip = FALSE;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2423 for (i = 0; i < ppconst->pp_used; ++i)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2424 if (generate_tv_PUSH(cctx, &ppconst->pp_tv[i]) == FAIL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2425 ret = FAIL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2426 ppconst->pp_used = 0;
20332 a407e243c55c patch 8.2.0721: Vim9: leaking memory when skipping Bram Moolenaar <Bram@vim.org> parents: 20328 diff changeset	2427 cctx->ctx_skip = save_skip;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2428 return ret;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2429 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2430
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2431 /*
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2432 * Clear ppconst constants. Used when failing.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2433 */
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2434 static void
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2435 clear_ppconst(ppconst_T *ppconst)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2436 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2437 int i;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2438
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2439 for (i = 0; i < ppconst->pp_used; ++i)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2440 clear_tv(&ppconst->pp_tv[i]);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2441 ppconst->pp_used = 0;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2442 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2443
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	2444 /*
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2445 * Generate an instruction to load script-local variable "name", without the
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2446 * leading "s:".
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2447 * Also finds imported variables.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2448 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2449 static int
19509 17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2450 compile_load_scriptvar(
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2451 cctx_T *cctx,
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2452 char_u *name, // variable NUL terminated
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2453 char_u *start, // start of variable
19530 48e71f948360 patch 8.2.0322: Vim9: error checks not tested Bram Moolenaar <Bram@vim.org> parents: 19528 diff changeset	2454 char_u **end, // end of variable
48e71f948360 patch 8.2.0322: Vim9: error checks not tested Bram Moolenaar <Bram@vim.org> parents: 19528 diff changeset	2455 int error) // when TRUE may give error
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2456 {
19191 133ef7ba4e4e patch 8.2.0154: reallocating the list of scripts is inefficient Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	2457 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2458 int idx = get_script_item_idx(current_sctx.sc_sid, name, FALSE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2459 imported_T *import;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2460
19451 b26e96f7c12f patch 8.2.0283: Vim9: failing to load script var not tested Bram Moolenaar <Bram@vim.org> parents: 19437 diff changeset	2461 if (idx == -1 \|\| si->sn_version != SCRIPT_VERSION_VIM9)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2462 {
19451 b26e96f7c12f patch 8.2.0283: Vim9: failing to load script var not tested Bram Moolenaar <Bram@vim.org> parents: 19437 diff changeset	2463 // variable is not in sn_var_vals: old style script.
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	2464 return generate_OLDSCRIPT(cctx, ISN_LOADS, name, current_sctx.sc_sid,
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	2465 &t_any);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2466 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2467 if (idx >= 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2468 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2469 svar_T sv = ((svar_T )si->sn_var_vals.ga_data) + idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2470
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	2471 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2472 current_sctx.sc_sid, idx, sv->sv_type);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2473 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2474 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2475
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	2476 import = find_imported(name, 0, cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2477 if (import != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2478 {
19509 17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2479 if (import->imp_all)
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2480 {
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2481 char_u p = skipwhite(end);
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2482 int name_len;
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2483 ufunc_T *ufunc;
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2484 type_T *type;
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2485
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2486 // Used "import * as Name", need to lookup the member.
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2487 if (*p != '.')
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2488 {
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2489 semsg(_("E1060: expected dot after name: %s"), start);
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2490 return FAIL;
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2491 }
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2492 ++p;
19818 c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	2493 if (VIM_ISWHITE(*p))
c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	2494 {
c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	2495 emsg(_("E1074: no white space allowed after dot"));
c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	2496 return FAIL;
c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	2497 }
19509 17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2498
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2499 idx = find_exported(import->imp_sid, &p, &name_len, &ufunc, &type);
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2500 // TODO: what if it is a function?
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2501 if (idx < 0)
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2502 return FAIL;
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2503 *end = p;
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2504
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2505 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2506 import->imp_sid,
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2507 idx,
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2508 type);
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2509 }
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2510 else
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2511 {
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2512 // TODO: check this is a variable, not a function?
19509 17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2513 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2514 import->imp_sid,
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2515 import->imp_var_vals_idx,
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2516 import->imp_type);
17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2517 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2518 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2519 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2520
19530 48e71f948360 patch 8.2.0322: Vim9: error checks not tested Bram Moolenaar <Bram@vim.org> parents: 19528 diff changeset	2521 if (error)
48e71f948360 patch 8.2.0322: Vim9: error checks not tested Bram Moolenaar <Bram@vim.org> parents: 19528 diff changeset	2522 semsg(_("E1050: Item not found: %s"), name);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2523 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2524 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2525
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2526 static int
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2527 generate_funcref(cctx_T cctx, char_u name)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2528 {
20189 63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20174 diff changeset	2529 ufunc_T *ufunc = find_func(name, FALSE, cctx);
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2530
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2531 if (ufunc == NULL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2532 return FAIL;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2533
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2534 return generate_PUSHFUNC(cctx, vim_strsave(name), ufunc->uf_func_type);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2535 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2536
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2537 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2538 * Compile a variable name into a load instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2539 * "end" points to just after the name.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2540 * When "error" is FALSE do not give an error when not found.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2541 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2542 static int
19509 17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2543 compile_load(char_u *arg, char_u end_arg, cctx_T *cctx, int error)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2544 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2545 type_T *type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2546 char_u *name;
19509 17f0d6dc6a73 patch 8.2.0312: Vim9: insufficient script tests Bram Moolenaar <Bram@vim.org> parents: 19481 diff changeset	2547 char_u *end = end_arg;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2548 int res = FAIL;
19818 c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	2549 int prev_called_emsg = called_emsg;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2550
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2551 if ((arg + 1) == ':')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2552 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2553 // load namespaced variable
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2554 if (end <= *arg + 2)
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2555 name = vim_strsave((char_u *)"[empty]");
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2556 else
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2557 name = vim_strnsave(arg + 2, end - (arg + 2));
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2558 if (name == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2559 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2560
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2561 if (**arg == 'v')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2562 {
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	2563 res = generate_LOADV(cctx, name, error);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2564 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2565 else if (**arg == 'g')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2566 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2567 // Global variables can be defined later, thus we don't check if it
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2568 // exists, give error at runtime.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2569 res = generate_LOAD(cctx, ISN_LOADG, 0, name, &t_any);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2570 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2571 else if (**arg == 's')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2572 {
19530 48e71f948360 patch 8.2.0322: Vim9: error checks not tested Bram Moolenaar <Bram@vim.org> parents: 19528 diff changeset	2573 res = compile_load_scriptvar(cctx, name, NULL, NULL, error);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2574 }
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2575 else if (**arg == 'b')
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2576 {
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2577 // Buffer-local variables can be defined later, thus we don't check
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2578 // if it exists, give error at runtime.
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2579 res = generate_LOAD(cctx, ISN_LOADB, 0, name, &t_any);
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2580 }
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2581 else if (**arg == 'w')
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2582 {
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2583 // Window-local variables can be defined later, thus we don't check
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2584 // if it exists, give error at runtime.
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2585 res = generate_LOAD(cctx, ISN_LOADW, 0, name, &t_any);
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2586 }
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2587 else if (**arg == 't')
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2588 {
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2589 // Tabpage-local variables can be defined later, thus we don't
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2590 // check if it exists, give error at runtime.
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	2591 res = generate_LOAD(cctx, ISN_LOADT, 0, name, &t_any);
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2592 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2593 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2594 {
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2595 semsg("E1075: Namespace not supported: %s", *arg);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2596 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2597 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2598 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2599 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2600 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2601 size_t len = end - *arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2602 int idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2603 int gen_load = FALSE;
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2604 int gen_load_outer = FALSE;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2605
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2606 name = vim_strnsave(arg, end - arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2607 if (name == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2608 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2609
20275 350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	2610 if (lookup_arg(*arg, len, &idx, &type, &gen_load_outer, cctx) == OK)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2611 {
20275 350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	2612 if (!gen_load_outer)
350bb78345ba patch 8.2.0693: closure using argument not tested Bram Moolenaar <Bram@vim.org> parents: 20259 diff changeset	2613 gen_load = TRUE;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2614 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2615 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2616 {
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	2617 lvar_T lvar = lookup_local(arg, len, cctx);
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	2618
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	2619 if (lvar != NULL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2620 {
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	2621 type = lvar->lv_type;
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	2622 idx = lvar->lv_idx;
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2623 if (lvar->lv_from_outer)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2624 gen_load_outer = TRUE;
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2625 else
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2626 gen_load = TRUE;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2627 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2628 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2629 {
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2630 // "var" can be script-local even without using "s:" if it
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2631 // already exists.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2632 if (SCRIPT_ITEM(current_sctx.sc_sid)->sn_version
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2633 == SCRIPT_VERSION_VIM9
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2634 \|\| lookup_script(*arg, len) == OK)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2635 res = compile_load_scriptvar(cctx, name, *arg, &end,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2636 FALSE);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2637
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2638 // When the name starts with an uppercase letter or "x:" it
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2639 // can be a user defined function.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2640 if (res == FAIL && (ASCII_ISUPPER(*name) \|\| name[1] == ':'))
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2641 res = generate_funcref(cctx, name);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2642 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2643 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2644 if (gen_load)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2645 res = generate_LOAD(cctx, ISN_LOAD, idx, NULL, type);
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2646 if (gen_load_outer)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2647 res = generate_LOAD(cctx, ISN_LOADOUTER, idx, NULL, type);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2648 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2649
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2650 *arg = end;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2651
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2652 theend:
19818 c1c88b333481 patch 8.2.0465: Vim9: dead code and wrong return type Bram Moolenaar <Bram@vim.org> parents: 19785 diff changeset	2653 if (res == FAIL && error && called_emsg == prev_called_emsg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2654 semsg(_(e_var_notfound), name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2655 vim_free(name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2656 return res;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2657 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2658
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2659 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2660 * Compile the argument expressions.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2661 * "arg" points to just after the "(" and is advanced to after the ")"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2662 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2663 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2664 compile_arguments(char_u *arg, cctx_T cctx, int *argcount)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2665 {
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2666 char_u p = arg;
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2667 char_u whitep = arg;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2668
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2669 for (;;)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2670 {
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2671 while (p == NUL \|\| (VIM_ISWHITE(whitep) && comment_start(p)))
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2672 {
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2673 p = next_line_from_context(cctx);
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2674 if (p == NULL)
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2675 goto failret;
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2676 whitep = (char_u *)" ";
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2677 p = skipwhite(p);
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2678 }
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2679 if (*p == ')')
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2680 {
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2681 *arg = p + 1;
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2682 return OK;
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2683 }
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2684
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2685 if (compile_expr0(&p, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2686 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2687 ++*argcount;
19437 5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2688
5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2689 if (p != ',' && skipwhite(p) == ',')
5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2690 {
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	2691 semsg(_(e_no_white_before), ",");
19437 5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2692 p = skipwhite(p);
5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2693 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2694 if (*p == ',')
19437 5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2695 {
5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2696 ++p;
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2697 if (p != NUL && !VIM_ISWHITE(p))
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19896 diff changeset	2698 semsg(_(e_white_after), ",");
19437 5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2699 }
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2700 whitep = p;
19437 5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	2701 p = skipwhite(p);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2702 }
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2703 failret:
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2704 emsg(_(e_missing_close));
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 20007 diff changeset	2705 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2706 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2707
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2708 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2709 * Compile a function call: name(arg1, arg2)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2710 * "arg" points to "name", "arg + varlen" to the "(".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2711 * "argcount_init" is 1 for "value->method()"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2712 * Instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2713 * EVAL arg1
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2714 * EVAL arg2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2715 * BCALL / DCALL / UCALL
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2716 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2717 static int
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2718 compile_call(
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2719 char_u **arg,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2720 size_t varlen,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2721 cctx_T *cctx,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2722 ppconst_T *ppconst,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2723 int argcount_init)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2724 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2725 char_u name = arg;
19257 5aab9c306181 patch 8.2.0187: reduntant code Bram Moolenaar <Bram@vim.org> parents: 19253 diff changeset	2726 char_u *p;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2727 int argcount = argcount_init;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2728 char_u namebuf[100];
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2729 char_u fname_buf[FLEN_FIXED + 1];
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2730 char_u *tofree = NULL;
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2731 int error = FCERR_NONE;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2732 ufunc_T *ufunc;
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2733 int res = FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2734
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2735 // we can evaluate "has('name')" at compile time
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2736 if (varlen == 3 && STRNCMP(*arg, "has", 3) == 0)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2737 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2738 char_u s = skipwhite(arg + varlen + 1);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2739 typval_T argvars[2];
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2740
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2741 argvars[0].v_type = VAR_UNKNOWN;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2742 if (*s == '"')
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2743 (void)get_string_tv(&s, &argvars[0], TRUE);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2744 else if (*s == '\'')
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2745 (void)get_lit_string_tv(&s, &argvars[0], TRUE);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2746 s = skipwhite(s);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2747 if (*s == ')' && argvars[0].v_type == VAR_STRING)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2748 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2749 typval_T *tv = &ppconst->pp_tv[ppconst->pp_used];
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2750
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2751 *arg = s + 1;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2752 argvars[1].v_type = VAR_UNKNOWN;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2753 tv->v_type = VAR_NUMBER;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2754 tv->vval.v_number = 0;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2755 f_has(argvars, tv);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2756 clear_tv(&argvars[0]);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2757 ++ppconst->pp_used;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2758 return OK;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2759 }
20332 a407e243c55c patch 8.2.0721: Vim9: leaking memory when skipping Bram Moolenaar <Bram@vim.org> parents: 20328 diff changeset	2760 clear_tv(&argvars[0]);
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2761 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2762
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2763 if (generate_ppconst(cctx, ppconst) == FAIL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2764 return FAIL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2765
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2766 if (varlen >= sizeof(namebuf))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2767 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2768 semsg(_("E1011: name too long: %s"), name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2769 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2770 }
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2771 vim_strncpy(namebuf, *arg, varlen);
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2772 name = fname_trans_sid(namebuf, fname_buf, &tofree, &error);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2773
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2774 arg = skipwhite(arg + varlen + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2775 if (compile_arguments(arg, cctx, &argcount) == FAIL)
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2776 goto theend;
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2777
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2778 if (ASCII_ISLOWER(*name) && name[1] != ':')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2779 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2780 int idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2781
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2782 // builtin function
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2783 idx = find_internal_func(name);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2784 if (idx >= 0)
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2785 res = generate_BCALL(cctx, idx, argcount);
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2786 else
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2787 semsg(_(e_unknownfunc), namebuf);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2788 goto theend;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2789 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2790
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2791 // If we can find the function by name generate the right call.
20189 63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20174 diff changeset	2792 ufunc = find_func(name, FALSE, cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2793 if (ufunc != NULL)
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2794 {
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2795 res = generate_CALL(cctx, ufunc, argcount);
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2796 goto theend;
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2797 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2798
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2799 // If the name is a variable, load it and use PCALL.
20079 336483164ca6 patch 8.2.0595: Vim9: not all commands using ends_excmd() tested Bram Moolenaar <Bram@vim.org> parents: 20059 diff changeset	2800 // Not for g:Func(), we don't know if it is a variable or not.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2801 p = namebuf;
20079 336483164ca6 patch 8.2.0595: Vim9: not all commands using ends_excmd() tested Bram Moolenaar <Bram@vim.org> parents: 20059 diff changeset	2802 if (STRNCMP(namebuf, "g:", 2) != 0
336483164ca6 patch 8.2.0595: Vim9: not all commands using ends_excmd() tested Bram Moolenaar <Bram@vim.org> parents: 20059 diff changeset	2803 && compile_load(&p, namebuf + varlen, cctx, FALSE) == OK)
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2804 {
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	2805 garray_T *stack = &cctx->ctx_type_stack;
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	2806 type_T *type;
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	2807
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	2808 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	2809 res = generate_PCALL(cctx, argcount, namebuf, type, FALSE);
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2810 goto theend;
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2811 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2812
20140 39a18a0df429 patch 8.2.0625: Vim9: confusing error when calling unknown function Bram Moolenaar <Bram@vim.org> parents: 20138 diff changeset	2813 // A global function may be defined only later. Need to figure out at
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	2814 // runtime. Also handles a FuncRef at runtime.
20140 39a18a0df429 patch 8.2.0625: Vim9: confusing error when calling unknown function Bram Moolenaar <Bram@vim.org> parents: 20138 diff changeset	2815 if (STRNCMP(namebuf, "g:", 2) == 0)
39a18a0df429 patch 8.2.0625: Vim9: confusing error when calling unknown function Bram Moolenaar <Bram@vim.org> parents: 20138 diff changeset	2816 res = generate_UCALL(cctx, name, argcount);
39a18a0df429 patch 8.2.0625: Vim9: confusing error when calling unknown function Bram Moolenaar <Bram@vim.org> parents: 20138 diff changeset	2817 else
39a18a0df429 patch 8.2.0625: Vim9: confusing error when calling unknown function Bram Moolenaar <Bram@vim.org> parents: 20138 diff changeset	2818 semsg(_(e_unknownfunc), namebuf);
19330 9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2819
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2820 theend:
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2821 vim_free(tofree);
9c8b803fe598 patch 8.2.0223: some instructions not yet tested Bram Moolenaar <Bram@vim.org> parents: 19328 diff changeset	2822 return res;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2823 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2824
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2825 // like NAMESPACE_CHAR but with 'a' and 'l'.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2826 #define VIM9_NAMESPACE_CHAR (char_u *)"bgstvw"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2827
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2828 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2829 * Find the end of a variable or function name. Unlike find_name_end() this
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2830 * does not recognize magic braces.
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	2831 * When "namespace" is TRUE recognize "b:", "s:", etc.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2832 * Return a pointer to just after the name. Equal to "arg" if there is no
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2833 * valid name.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2834 */
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	2835 static char_u *
ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	2836 to_name_end(char_u *arg, int namespace)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2837 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2838 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2839
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2840 // Quick check for valid starting character.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2841 if (!eval_isnamec1(*arg))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2842 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2843
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2844 for (p = arg + 1; p != NUL && eval_isnamec(p); MB_PTR_ADV(p))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2845 // Include a namespace such as "s:var" and "v:var". But "n:" is not
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2846 // and can be used in slice "[n:]".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2847 if (*p == ':' && (p != arg + 1
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	2848 \|\| !namespace
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2849 \|\| vim_strchr(VIM9_NAMESPACE_CHAR, *arg) == NULL))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2850 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2851 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2852 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2853
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2854 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2855 * Like to_name_end() but also skip over a list or dict constant.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2856 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2857 char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2858 to_name_const_end(char_u *arg)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2859 {
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	2860 char_u *p = to_name_end(arg, TRUE);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2861 typval_T rettv;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2862
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2863 if (p == arg && *arg == '[')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2864 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2865
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2866 // Can be "[1, 2, 3]->Func()".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2867 if (get_list_tv(&p, &rettv, FALSE, FALSE) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2868 p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2869 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2870 else if (p == arg && *arg == '#' && arg[1] == '{')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2871 {
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2872 // Can be "#{a: 1}->Func()".
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2873 ++p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2874 if (eval_dict(&p, &rettv, FALSE, TRUE) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2875 p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2876 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2877 else if (p == arg && *arg == '{')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2878 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2879 int ret = get_lambda_tv(&p, &rettv, FALSE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2880
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2881 // Can be "{x -> ret}()".
fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19818 diff changeset	2882 // Can be "{'a': 1}->Func()".
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2883 if (ret == NOTDONE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2884 ret = eval_dict(&p, &rettv, FALSE, FALSE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2885 if (ret != OK)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2886 p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2887 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2888
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2889 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2890 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2891
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2892 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2893 * parse a list: [expr, expr]
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2894 * "*arg" points to the '['.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2895 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2896 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2897 compile_list(char_u *arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2898 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2899 char_u p = skipwhite(arg + 1);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2900 char_u whitep = arg + 1;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2901 int count = 0;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2902
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2903 for (;;)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2904 {
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2905 while (p == NUL \|\| (VIM_ISWHITE(whitep) && comment_start(p)))
19830 6500dcaf8e1a patch 8.2.0471: missing change to compile_list() Bram Moolenaar <Bram@vim.org> parents: 19822 diff changeset	2906 {
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2907 p = next_line_from_context(cctx);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2908 if (p == NULL)
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2909 {
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2910 semsg(_(e_list_end), *arg);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2911 return FAIL;
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2912 }
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2913 whitep = (char_u *)" ";
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2914 p = skipwhite(p);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2915 }
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2916 if (*p == ']')
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2917 {
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2918 ++p;
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2919 // Allow for following comment, after at least one space.
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2920 if (VIM_ISWHITE(p) && skipwhite(p) == '"')
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2921 p += STRLEN(p);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2922 break;
19830 6500dcaf8e1a patch 8.2.0471: missing change to compile_list() Bram Moolenaar <Bram@vim.org> parents: 19822 diff changeset	2923 }
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	2924 if (compile_expr0(&p, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2925 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2926 ++count;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2927 if (*p == ',')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2928 ++p;
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	2929 whitep = p;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2930 p = skipwhite(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2931 }
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	2932 *arg = p;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2933
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2934 generate_NEWLIST(cctx, count);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2935 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2936 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2937
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2938 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2939 * parse a lambda: {arg, arg -> expr}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2940 * "*arg" points to the '{'.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2941 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2942 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2943 compile_lambda(char_u *arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2944 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2945 typval_T rettv;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2946 ufunc_T *ufunc;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2947
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2948 // Get the funcref in "rettv".
19830 6500dcaf8e1a patch 8.2.0471: missing change to compile_list() Bram Moolenaar <Bram@vim.org> parents: 19822 diff changeset	2949 if (get_lambda_tv(arg, &rettv, TRUE) != OK)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2950 return FAIL;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2951
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2952 ufunc = rettv.vval.v_partial->pt_func;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2953 ++ufunc->uf_refcount;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2954 clear_tv(&rettv);
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2955 ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2956
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2957 // The function will have one line: "return {expr}".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2958 // Compile it into instructions.
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2959 compile_def_function(ufunc, TRUE, cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2960
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2961 if (ufunc->uf_dfunc_idx >= 0)
20281 ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	2962 return generate_FUNCREF(cctx, ufunc->uf_dfunc_idx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2963 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2964 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2965
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2966 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2967 * Compile a lamda call: expr->{lambda}(args)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2968 * "arg" points to the "{".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2969 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2970 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2971 compile_lambda_call(char_u *arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2972 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2973 ufunc_T *ufunc;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2974 typval_T rettv;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2975 int argcount = 1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2976 int ret = FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2977
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2978 // Get the funcref in "rettv".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2979 if (get_lambda_tv(arg, &rettv, TRUE) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2980 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2981
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2982 if (**arg != '(')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2983 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2984 if (skipwhite(arg) == '(')
19760 9daed26b788b patch 8.2.0436: no warnings for incorrect printf arguments Bram Moolenaar <Bram@vim.org> parents: 19726 diff changeset	2985 emsg(_(e_nowhitespace));
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2986 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2987 semsg(_(e_missing_paren), "lambda");
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2988 clear_tv(&rettv);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2989 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2990 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2991
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2992 ufunc = rettv.vval.v_partial->pt_func;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2993 ++ufunc->uf_refcount;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2994 clear_tv(&rettv);
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	2995 ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10);
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	2996
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2997 // The function will have one line: "return {expr}".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2998 // Compile it into instructions.
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	2999 compile_def_function(ufunc, TRUE, cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3000
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3001 // compile the arguments
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3002 arg = skipwhite(arg + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3003 if (compile_arguments(arg, cctx, &argcount) == OK)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3004 // call the compiled function
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3005 ret = generate_CALL(cctx, ufunc, argcount);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3006
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3007 return ret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3008 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3009
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3010 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3011 * parse a dict: {'key': val} or #{key: val}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3012 * "*arg" points to the '{'.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3013 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3014 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3015 compile_dict(char_u *arg, cctx_T cctx, int literal)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3016 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3017 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3018 int count = 0;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3019 dict_T *d = dict_alloc();
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3020 dictitem_T *item;
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3021 char_u whitep = arg;
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3022 char_u *p;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3023
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3024 if (d == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3025 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3026 arg = skipwhite(arg + 1);
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3027 for (;;)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3028 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3029 char_u *key = NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3030
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3031 while (arg == NUL \|\| (literal && arg == '"')
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3032 \|\| (VIM_ISWHITE(whitep) && comment_start(arg)))
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3033 {
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3034 *arg = next_line_from_context(cctx);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3035 if (*arg == NULL)
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3036 goto failret;
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3037 whitep = (char_u *)" ";
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3038 arg = skipwhite(arg);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3039 }
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3040
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3041 if (**arg == '}')
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3042 break;
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3043
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3044 if (literal)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3045 {
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3046 char_u end = to_name_end(arg, !literal);
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3047
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3048 if (end == *arg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3049 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3050 semsg(_("E1014: Invalid key: %s"), *arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3051 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3052 }
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3053 key = vim_strnsave(arg, end - arg);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3054 if (generate_PUSHS(cctx, key) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3055 return FAIL;
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3056 *arg = end;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3057 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3058 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3059 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3060 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3061
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3062 if (compile_expr0(arg, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3063 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3064 // TODO: check type is string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3065 isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3066 if (isn->isn_type == ISN_PUSHS)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3067 key = isn->isn_arg.string;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3068 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3069
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3070 // Check for duplicate keys, if using string keys.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3071 if (key != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3072 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3073 item = dict_find(d, key, -1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3074 if (item != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3075 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3076 semsg(_(e_duplicate_key), key);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3077 goto failret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3078 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3079 item = dictitem_alloc(key);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3080 if (item != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3081 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3082 item->di_tv.v_type = VAR_UNKNOWN;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3083 item->di_tv.v_lock = 0;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3084 if (dict_add(d, item) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3085 dictitem_free(item);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3086 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3087 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3088
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3089 arg = skipwhite(arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3090 if (**arg != ':')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3091 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3092 semsg(_(e_missing_dict_colon), *arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3093 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3094 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3095
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3096 whitep = *arg + 1;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3097 arg = skipwhite(arg + 1);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3098 while (*arg == NUL \|\| (VIM_ISWHITE(whitep) && comment_start(*arg)))
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3099 {
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3100 *arg = next_line_from_context(cctx);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3101 if (*arg == NULL)
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3102 goto failret;
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3103 whitep = (char_u *)" ";
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3104 arg = skipwhite(arg);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3105 }
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3106
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3107 if (compile_expr0(arg, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3108 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3109 ++count;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3110
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3111 whitep = *arg;
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3112 p = skipwhite(*arg);
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3113 while (p == NUL \|\| (VIM_ISWHITE(whitep) && comment_start(p)))
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3114 {
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3115 *arg = next_line_from_context(cctx);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3116 if (*arg == NULL)
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3117 goto failret;
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3118 whitep = (char_u *)" ";
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3119 arg = skipwhite(arg);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3120 p = *arg;
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3121 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3122 if (**arg == '}')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3123 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3124 if (**arg != ',')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3125 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3126 semsg(_(e_missing_dict_comma), *arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3127 goto failret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3128 }
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3129 whitep = *arg + 1;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3130 arg = skipwhite(arg + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3131 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3132
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3133 arg = arg + 1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3134
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3135 // Allow for following comment, after at least one space.
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3136 p = skipwhite(*arg);
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3137 if (VIM_ISWHITE(*arg) && (p == '"' \|\| comment_start(p)))
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3138 arg += STRLEN(arg);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3139
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3140 dict_unref(d);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3141 return generate_NEWDICT(cctx, count);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3142
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3143 failret:
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3144 if (*arg == NULL)
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	3145 semsg(_(e_missing_dict_end), _("[end of lines]"));
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3146 dict_unref(d);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3147 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3148 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3149
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3150 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3151 * Compile "&option".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3152 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3153 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3154 compile_get_option(char_u *arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3155 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3156 typval_T rettv;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3157 char_u start = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3158 int ret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3159
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3160 // parse the option and get the current value to get the type.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3161 rettv.v_type = VAR_UNKNOWN;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3162 ret = get_option_tv(arg, &rettv, TRUE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3163 if (ret == OK)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3164 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3165 // include the '&' in the name, get_option_tv() expects it.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3166 char_u name = vim_strnsave(start, arg - start);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3167 type_T *type = rettv.v_type == VAR_NUMBER ? &t_number : &t_string;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3168
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3169 ret = generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3170 vim_free(name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3171 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3172 clear_tv(&rettv);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3173
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3174 return ret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3175 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3176
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3177 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3178 * Compile "$VAR".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3179 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3180 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3181 compile_get_env(char_u *arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3182 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3183 char_u start = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3184 int len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3185 int ret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3186 char_u *name;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3187
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3188 ++*arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3189 len = get_env_len(arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3190 if (len == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3191 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3192 semsg(_(e_syntax_at), start - 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3193 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3194 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3195
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3196 // include the '$' in the name, get_env_tv() expects it.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3197 name = vim_strnsave(start, len + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3198 ret = generate_LOAD(cctx, ISN_LOADENV, 0, name, &t_string);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3199 vim_free(name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3200 return ret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3201 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3202
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3203 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3204 * Compile "@r".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3205 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3206 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3207 compile_get_register(char_u *arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3208 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3209 int ret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3210
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3211 ++*arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3212 if (**arg == NUL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3213 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3214 semsg(_(e_syntax_at), *arg - 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3215 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3216 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3217 if (!valid_yank_reg(**arg, TRUE))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3218 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3219 emsg_invreg(**arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3220 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3221 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3222 ret = generate_LOAD(cctx, ISN_LOADREG, **arg, NULL, &t_string);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3223 ++*arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3224 return ret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3225 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3226
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3227 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3228 * Apply leading '!', '-' and '+' to constant "rettv".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3229 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3230 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3231 apply_leader(typval_T rettv, char_u start, char_u *end)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3232 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3233 char_u *p = end;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3234
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3235 // this works from end to start
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3236 while (p > start)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3237 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3238 --p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3239 if (p == '-' \|\| p == '+')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3240 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3241 // only '-' has an effect, for '+' we only check the type
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3242 #ifdef FEAT_FLOAT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3243 if (rettv->v_type == VAR_FLOAT)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3244 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3245 if (*p == '-')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3246 rettv->vval.v_float = -rettv->vval.v_float;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3247 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3248 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3249 #endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3250 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3251 varnumber_T val;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3252 int error = FALSE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3253
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3254 // tv_get_number_chk() accepts a string, but we don't want that
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3255 // here
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3256 if (check_not_string(rettv) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3257 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3258 val = tv_get_number_chk(rettv, &error);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3259 clear_tv(rettv);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3260 if (error)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3261 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3262 if (*p == '-')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3263 val = -val;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3264 rettv->v_type = VAR_NUMBER;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3265 rettv->vval.v_number = val;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3266 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3267 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3268 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3269 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3270 int v = tv2bool(rettv);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3271
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3272 // '!' is permissive in the type.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3273 clear_tv(rettv);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3274 rettv->v_type = VAR_BOOL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3275 rettv->vval.v_number = v ? VVAL_FALSE : VVAL_TRUE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3276 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3277 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3278 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3279 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3280
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3281 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3282 * Recognize v: variables that are constants and set "rettv".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3283 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3284 static void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3285 get_vim_constant(char_u *arg, typval_T rettv)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3286 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3287 if (STRNCMP(*arg, "v:true", 6) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3288 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3289 rettv->v_type = VAR_BOOL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3290 rettv->vval.v_number = VVAL_TRUE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3291 *arg += 6;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3292 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3293 else if (STRNCMP(*arg, "v:false", 7) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3294 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3295 rettv->v_type = VAR_BOOL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3296 rettv->vval.v_number = VVAL_FALSE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3297 *arg += 7;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3298 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3299 else if (STRNCMP(*arg, "v:null", 6) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3300 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3301 rettv->v_type = VAR_SPECIAL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3302 rettv->vval.v_number = VVAL_NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3303 *arg += 6;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3304 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3305 else if (STRNCMP(*arg, "v:none", 6) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3306 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3307 rettv->v_type = VAR_SPECIAL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3308 rettv->vval.v_number = VVAL_NONE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3309 *arg += 6;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3310 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3311 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3312
20305 9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3313 static exptype_T
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3314 get_compare_type(char_u p, int len, int *type_is)
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3315 {
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3316 exptype_T type = EXPR_UNKNOWN;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3317 int i;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3318
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3319 switch (p[0])
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3320 {
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3321 case '=': if (p[1] == '=')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3322 type = EXPR_EQUAL;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3323 else if (p[1] == '~')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3324 type = EXPR_MATCH;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3325 break;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3326 case '!': if (p[1] == '=')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3327 type = EXPR_NEQUAL;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3328 else if (p[1] == '~')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3329 type = EXPR_NOMATCH;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3330 break;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3331 case '>': if (p[1] != '=')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3332 {
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3333 type = EXPR_GREATER;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3334 *len = 1;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3335 }
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3336 else
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3337 type = EXPR_GEQUAL;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3338 break;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3339 case '<': if (p[1] != '=')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3340 {
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3341 type = EXPR_SMALLER;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3342 *len = 1;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3343 }
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3344 else
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3345 type = EXPR_SEQUAL;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3346 break;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3347 case 'i': if (p[1] == 's')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3348 {
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3349 // "is" and "isnot"; but not a prefix of a name
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3350 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3351 *len = 5;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3352 i = p[*len];
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3353 if (!isalnum(i) && i != '_')
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3354 {
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3355 type = *len == 2 ? EXPR_IS : EXPR_ISNOT;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3356 *type_is = TRUE;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3357 }
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3358 }
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3359 break;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3360 }
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3361 return type;
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3362 }
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3363
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	3364 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3365 * Compile code to apply '-', '+' and '!'.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3366 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3367 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3368 compile_leader(cctx_T cctx, char_u start, char_u *end)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3369 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3370 char_u *p = end;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3371
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3372 // this works from end to start
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3373 while (p > start)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3374 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3375 --p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3376 if (p == '-' \|\| p == '+')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3377 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3378 int negate = *p == '-';
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3379 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3380
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3381 // TODO: check type
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3382 while (p > start && (p[-1] == '-' \|\| p[-1] == '+'))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3383 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3384 --p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3385 if (*p == '-')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3386 negate = !negate;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3387 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3388 // only '-' has an effect, for '+' we only check the type
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3389 if (negate)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3390 isn = generate_instr(cctx, ISN_NEGATENR);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3391 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3392 isn = generate_instr(cctx, ISN_CHECKNR);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3393 if (isn == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3394 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3395 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3396 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3397 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3398 int invert = TRUE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3399
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3400 while (p > start && p[-1] == '!')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3401 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3402 --p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3403 invert = !invert;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3404 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3405 if (generate_2BOOL(cctx, invert) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3406 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3407 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3408 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3409 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3410 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3411
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3412 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3413 * Compile whatever comes after "name" or "name()".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3414 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3415 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3416 compile_subscript(
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3417 char_u **arg,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3418 cctx_T *cctx,
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3419 char_u **start_leader,
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3420 char_u *end_leader,
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3421 ppconst_T *ppconst)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3422 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3423 for (;;)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3424 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3425 if (**arg == '(')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3426 {
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	3427 garray_T *stack = &cctx->ctx_type_stack;
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	3428 type_T *type;
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	3429 int argcount = 0;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3430
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3431 if (generate_ppconst(cctx, ppconst) == FAIL)
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3432 return FAIL;
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3433
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3434 // funcref(arg)
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	3435 type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	3436
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3437 arg = skipwhite(arg + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3438 if (compile_arguments(arg, cctx, &argcount) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3439 return FAIL;
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	3440 if (generate_PCALL(cctx, argcount, end_leader, type, TRUE) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3441 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3442 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3443 else if (*arg == '-' && (arg)[1] == '>')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3444 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3445 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3446
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3447 if (generate_ppconst(cctx, ppconst) == FAIL)
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3448 return FAIL;
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3449
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3450 // something->method()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3451 // Apply the '!', '-' and '+' first:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3452 // -1.0->func() works like (-1.0)->func()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3453 if (compile_leader(cctx, *start_leader, end_leader) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3454 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3455 *start_leader = end_leader; // don't apply again later
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3456
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3457 arg = skipwhite(arg + 2);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3458 if (**arg == '{')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3459 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3460 // lambda call: list->{lambda}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3461 if (compile_lambda_call(arg, cctx) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3462 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3463 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3464 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3465 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3466 // method call: list->method()
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19830 diff changeset	3467 p = *arg;
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19830 diff changeset	3468 if (ASCII_ISALPHA(*p) && p[1] == ':')
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19830 diff changeset	3469 p += 2;
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19830 diff changeset	3470 for ( ; eval_isnamec1(*p); ++p)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3471 ;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3472 if (*p != '(')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3473 {
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19830 diff changeset	3474 semsg(_(e_missing_paren), *arg);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3475 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3476 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3477 // TODO: base value may not be the first argument
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3478 if (compile_call(arg, p - *arg, cctx, ppconst, 1) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3479 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3480 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3481 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3482 else if (**arg == '[')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3483 {
19423 f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3484 garray_T *stack;
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3485 type_T **typep;
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3486
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3487 if (generate_ppconst(cctx, ppconst) == FAIL)
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3488 return FAIL;
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3489
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3490 // list index: list[123]
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3491 // TODO: more arguments
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3492 // TODO: dict member dict['name']
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3493 arg = skipwhite(arg + 1);
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3494 if (compile_expr0(arg, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3495 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3496
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3497 if (**arg != ']')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3498 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3499 emsg(_(e_missbrac));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3500 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3501 }
19342 8ff84bc1c89b patch 8.2.0229: compare instructions not tested Bram Moolenaar <Bram@vim.org> parents: 19336 diff changeset	3502 arg = arg + 1;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3503
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3504 if (generate_instr_drop(cctx, ISN_INDEX, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3505 return FAIL;
19423 f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3506 stack = &cctx->ctx_type_stack;
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3507 typep = ((type_T **)stack->ga_data) + stack->ga_len - 1;
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3508 if ((typep)->tt_type != VAR_LIST && typep != &t_any)
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3509 {
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3510 emsg(_(e_listreq));
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3511 return FAIL;
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19411 diff changeset	3512 }
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	3513 if ((*typep)->tt_type == VAR_LIST)
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19455 diff changeset	3514 typep = (typep)->tt_member;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3515 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3516 else if (*arg == '.' && (arg)[1] != '.')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3517 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3518 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3519
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3520 if (generate_ppconst(cctx, ppconst) == FAIL)
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3521 return FAIL;
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3522
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3523 ++*arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3524 p = *arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3525 // dictionary member: dict.name
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3526 if (eval_isnamec1(*p))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3527 while (eval_isnamec(*p))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3528 MB_PTR_ADV(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3529 if (p == *arg)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3530 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3531 semsg(_(e_syntax_at), *arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3532 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3533 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3534 if (generate_MEMBER(cctx, arg, p - arg) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3535 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3536 *arg = p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3537 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3538 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3539 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3540 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3541
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3542 // TODO - see handle_subscript():
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3543 // Turn "dict.Func" into a partial for "Func" bound to "dict".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3544 // Don't do this when "Func" is already a partial that was bound
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3545 // explicitly (pt_auto is FALSE).
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3546
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3547 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3548 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3549
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3550 /*
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3551 * Compile an expression at "*arg" and add instructions to "cctx->ctx_instr".
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3552 * "arg" is advanced until after the expression, skipping white space.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3553 *
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3554 * If the value is a constant "ppconst->pp_ret" will be set.
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3555 * Before instructions are generated, any values in "ppconst" will generated.
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3556 *
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3557 * This is the compiling equivalent of eval1(), eval2(), etc.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3558 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3559
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3560 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3561 * number number constant
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3562 * 0zFFFFFFFF Blob constant
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3563 * "string" string constant
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3564 * 'string' literal string constant
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3565 * &option-name option value
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3566 * @r register contents
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3567 * identifier variable value
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3568 * function() function call
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3569 * $VAR environment variable
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3570 * (expression) nested expression
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3571 * [expr, expr] List
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3572 * {key: val, key: val} Dictionary
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3573 * #{key: val, key: val} Dictionary with literal keys
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3574 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3575 * Also handle:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3576 * ! in front logical NOT
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3577 * - in front unary minus
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3578 * + in front unary plus (ignored)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3579 * trailing (arg) funcref/partial call
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3580 * trailing [] subscript in String or List
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3581 * trailing .name entry in Dictionary
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3582 * trailing ->name() method call
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3583 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3584 static int
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3585 compile_expr7(
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3586 char_u **arg,
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3587 cctx_T *cctx,
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3588 ppconst_T *ppconst)
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3589 {
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3590 char_u start_leader, end_leader;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3591 int ret = OK;
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3592 typval_T *rettv = &ppconst->pp_tv[ppconst->pp_used];
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3593
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3594 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3595 * Skip '!', '-' and '+' characters. They are handled later.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3596 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3597 start_leader = *arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3598 while (arg == '!' \|\| arg == '-' \|\| **arg == '+')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3599 arg = skipwhite(arg + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3600 end_leader = *arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3601
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3602 rettv->v_type = VAR_UNKNOWN;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3603 switch (**arg)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3604 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3605 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3606 * Number constant.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3607 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3608 case '0': // also for blob starting with 0z
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3609 case '1':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3610 case '2':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3611 case '3':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3612 case '4':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3613 case '5':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3614 case '6':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3615 case '7':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3616 case '8':
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3617 case '9':
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3618 case '.': if (get_number_tv(arg, rettv, TRUE, FALSE) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3619 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3620 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3621
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3622 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3623 * String constant: "string".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3624 */
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3625 case '"': if (get_string_tv(arg, rettv, TRUE) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3626 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3627 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3628
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3629 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3630 * Literal string constant: 'str''ing'.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3631 */
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3632 case '\'': if (get_lit_string_tv(arg, rettv, TRUE) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3633 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3634 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3635
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3636 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3637 * Constant Vim variable.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3638 */
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3639 case 'v': get_vim_constant(arg, rettv);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3640 ret = NOTDONE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3641 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3642
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3643 /*
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3644 * "true" constant
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3645 */
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3646 case 't': if (STRNCMP(*arg, "true", 4) == 0
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3647 && !eval_isnamec((*arg)[4]))
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3648 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3649 *arg += 4;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3650 rettv->v_type = VAR_BOOL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3651 rettv->vval.v_number = VVAL_TRUE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3652 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3653 else
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3654 ret = NOTDONE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3655 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3656
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3657 /*
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3658 * "false" constant
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3659 */
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3660 case 'f': if (STRNCMP(*arg, "false", 5) == 0
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3661 && !eval_isnamec((*arg)[5]))
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3662 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3663 *arg += 5;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3664 rettv->v_type = VAR_BOOL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3665 rettv->vval.v_number = VVAL_FALSE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3666 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3667 else
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3668 ret = NOTDONE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3669 break;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3670
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3671 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3672 * List: [expr, expr]
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3673 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3674 case '[': ret = compile_list(arg, cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3675 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3676
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3677 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3678 * Dictionary: #{key: val, key: val}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3679 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3680 case '#': if ((*arg)[1] == '{')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3681 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3682 ++*arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3683 ret = compile_dict(arg, cctx, TRUE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3684 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3685 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3686 ret = NOTDONE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3687 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3688
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3689 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3690 * Lambda: {arg, arg -> expr}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3691 * Dictionary: {'key': val, 'key': val}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3692 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3693 case '{': {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3694 char_u start = skipwhite(arg + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3695
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3696 // Find out what comes after the arguments.
20015 c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	3697 // TODO: pass getline function
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3698 ret = get_function_args(&start, '-', NULL,
20015 c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	3699 NULL, NULL, NULL, TRUE, NULL, NULL);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3700 if (ret != FAIL && *start == '>')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3701 ret = compile_lambda(arg, cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3702 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3703 ret = compile_dict(arg, cctx, FALSE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3704 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3705 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3706
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3707 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3708 * Option value: &name
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3709 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3710 case '&': ret = compile_get_option(arg, cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3711 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3712
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3713 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3714 * Environment variable: $VAR.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3715 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3716 case '$': ret = compile_get_env(arg, cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3717 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3718
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3719 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3720 * Register contents: @r.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3721 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3722 case '@': ret = compile_get_register(arg, cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3723 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3724 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3725 * nested expression: (expression).
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3726 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3727 case '(': arg = skipwhite(arg + 1);
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3728 ret = compile_expr0(arg, cctx); // recursive!
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3729 arg = skipwhite(arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3730 if (**arg == ')')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3731 ++*arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3732 else if (ret == OK)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3733 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3734 emsg(_(e_missing_close));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3735 ret = FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3736 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3737 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3738
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3739 default: ret = NOTDONE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3740 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3741 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3742 if (ret == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3743 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3744
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3745 if (rettv->v_type != VAR_UNKNOWN)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3746 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3747 // apply the '!', '-' and '+' before the constant
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3748 if (apply_leader(rettv, start_leader, end_leader) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3749 {
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3750 clear_tv(rettv);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3751 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3752 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3753 start_leader = end_leader; // don't apply again below
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3754
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3755 if (cctx->ctx_skip == TRUE)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3756 clear_tv(rettv);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3757 else
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3758 // A constant expression can possibly be handled compile time,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3759 // return the value instead of generating code.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3760 ++ppconst->pp_used;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3761 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3762 else if (ret == NOTDONE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3763 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3764 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3765 int r;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3766
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3767 if (!eval_isnamec1(**arg))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3768 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3769 semsg(_("E1015: Name expected: %s"), *arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3770 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3771 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3772
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3773 // "name" or "name()"
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	3774 p = to_name_end(*arg, TRUE);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3775 if (*p == '(')
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3776 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3777 r = compile_call(arg, p - *arg, cctx, ppconst, 0);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3778 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3779 else
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3780 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3781 if (generate_ppconst(cctx, ppconst) == FAIL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3782 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3783 r = compile_load(arg, p, cctx, TRUE);
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3784 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3785 if (r == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3786 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3787 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3788
20322 a3e78893a90b patch 8.2.0716: Vim9: another memory leak Bram Moolenaar <Bram@vim.org> parents: 20320 diff changeset	3789 // Handle following "[]", ".member", etc.
a3e78893a90b patch 8.2.0716: Vim9: another memory leak Bram Moolenaar <Bram@vim.org> parents: 20320 diff changeset	3790 // Then deal with prefixed '-', '+' and '!', if not done already.
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3791 if (compile_subscript(arg, cctx, &start_leader, end_leader,
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3792 ppconst) == FAIL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3793 return FAIL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3794 if (ppconst->pp_used > 0)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3795 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3796 // apply the '!', '-' and '+' before the constant
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3797 rettv = &ppconst->pp_tv[ppconst->pp_used - 1];
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3798 if (apply_leader(rettv, start_leader, end_leader) == FAIL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3799 return FAIL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3800 return OK;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3801 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3802 if (compile_leader(cctx, start_leader, end_leader) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3803 return FAIL;
20322 a3e78893a90b patch 8.2.0716: Vim9: another memory leak Bram Moolenaar <Bram@vim.org> parents: 20320 diff changeset	3804 return OK;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3805 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3806
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3807 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3808 * * number multiplication
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3809 * / number division
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3810 * % number modulo
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3811 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3812 static int
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3813 compile_expr6(char_u *arg, cctx_T cctx, ppconst_T *ppconst)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3814 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3815 char_u *op;
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3816 int ppconst_used = ppconst->pp_used;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3817
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3818 // get the first expression
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3819 if (compile_expr7(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3820 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3821
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3822 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3823 * Repeat computing, until no "*", "/" or "%" is following.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3824 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3825 for (;;)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3826 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3827 op = skipwhite(*arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3828 if (op != '' && op != '/' && op != '%')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3829 break;
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3830
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	3831 if (!IS_WHITE_OR_NUL(**arg) \|\| !IS_WHITE_OR_NUL(op[1]))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3832 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3833 char_u buf[3];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3834
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3835 vim_strncpy(buf, op, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3836 semsg(_(e_white_both), buf);
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	3837 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3838 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3839 *arg = skipwhite(op + 1);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3840 if (may_get_next_line(op + 1, arg, cctx) == FAIL)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	3841 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3842
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3843 // get the second expression
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3844 if (compile_expr7(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3845 return FAIL;
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3846
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3847 if (ppconst->pp_used == ppconst_used + 2
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3848 && ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3849 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER)
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3850 {
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3851 typval_T *tv1 = &ppconst->pp_tv[ppconst_used];
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3852 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1];
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3853 varnumber_T res = 0;
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3854
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3855 // both are numbers: compute the result
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3856 switch (*op)
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3857 {
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3858 case '': res = tv1->vval.v_number tv2->vval.v_number;
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3859 break;
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3860 case '/': res = tv1->vval.v_number / tv2->vval.v_number;
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3861 break;
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3862 case '%': res = tv1->vval.v_number % tv2->vval.v_number;
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3863 break;
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3864 }
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3865 tv1->vval.v_number = res;
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3866 --ppconst->pp_used;
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3867 }
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3868 else
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3869 {
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3870 generate_ppconst(cctx, ppconst);
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3871 generate_two_op(cctx, op);
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3872 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3873 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3874
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3875 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3876 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3877
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3878 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3879 * + number addition
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3880 * - number subtraction
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3881 * .. string concatenation
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3882 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3883 static int
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3884 compile_expr5(char_u *arg, cctx_T cctx, ppconst_T *ppconst)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3885 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3886 char_u *op;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3887 int oplen;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3888 int ppconst_used = ppconst->pp_used;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3889
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3890 // get the first variable
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3891 if (compile_expr6(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3892 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3893
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3894 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3895 * Repeat computing, until no "+", "-" or ".." is following.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3896 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3897 for (;;)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3898 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3899 op = skipwhite(*arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3900 if (op != '+' && op != '-' && !(op == '.' && ((*arg + 1) == '.')))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3901 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3902 oplen = (*op == '.' ? 2 : 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3903
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	3904 if (!IS_WHITE_OR_NUL(**arg) \|\| !IS_WHITE_OR_NUL(op[oplen]))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3905 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3906 char_u buf[3];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3907
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3908 vim_strncpy(buf, op, oplen);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3909 semsg(_(e_white_both), buf);
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	3910 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3911 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3912
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3913 *arg = skipwhite(op + oplen);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	3914 if (may_get_next_line(op + oplen, arg, cctx) == FAIL)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	3915 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3916
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3917 // get the second expression
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3918 if (compile_expr6(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3919 return FAIL;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3920
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3921 if (ppconst->pp_used == ppconst_used + 2
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3922 && (*op == '.'
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3923 ? (ppconst->pp_tv[ppconst_used].v_type == VAR_STRING
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3924 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_STRING)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3925 : (ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3926 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER)))
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3927 {
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3928 typval_T *tv1 = &ppconst->pp_tv[ppconst_used];
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3929 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1];
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3930
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3931 // concat/subtract/add constant numbers
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3932 if (*op == '+')
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3933 tv1->vval.v_number = tv1->vval.v_number + tv2->vval.v_number;
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3934 else if (*op == '-')
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3935 tv1->vval.v_number = tv1->vval.v_number - tv2->vval.v_number;
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3936 else
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3937 {
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3938 // concatenate constant strings
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3939 char_u *s1 = tv1->vval.v_string;
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3940 char_u *s2 = tv2->vval.v_string;
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3941 size_t len1 = STRLEN(s1);
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3942
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3943 tv1->vval.v_string = alloc((int)(len1 + STRLEN(s2) + 1));
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3944 if (tv1->vval.v_string == NULL)
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3945 {
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3946 clear_ppconst(ppconst);
20324 23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3947 return FAIL;
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3948 }
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3949 mch_memmove(tv1->vval.v_string, s1, len1);
23188ef99fc2 patch 8.2.0717: Vim9: postponed constant expressions does not scale Bram Moolenaar <Bram@vim.org> parents: 20322 diff changeset	3950 STRCPY(tv1->vval.v_string + len1, s2);
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3951 vim_free(s1);
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3952 vim_free(s2);
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3953 }
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3954 --ppconst->pp_used;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3955 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3956 else
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3957 {
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3958 generate_ppconst(cctx, ppconst);
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3959 if (*op == '.')
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3960 {
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3961 if (may_generate_2STRING(-2, cctx) == FAIL
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3962 \|\| may_generate_2STRING(-1, cctx) == FAIL)
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3963 return FAIL;
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3964 generate_instr_drop(cctx, ISN_CONCAT, 1);
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3965 }
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3966 else
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3967 generate_two_op(cctx, op);
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3968 }
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3969 }
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	3970
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3971 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3972 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3973
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3974 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3975 * expr5a == expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3976 * expr5a =~ expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3977 * expr5a != expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3978 * expr5a !~ expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3979 * expr5a > expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3980 * expr5a >= expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3981 * expr5a < expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3982 * expr5a <= expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3983 * expr5a is expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3984 * expr5a isnot expr5b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3985 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3986 * Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3987 * EVAL expr5a Push result of "expr5a"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3988 * EVAL expr5b Push result of "expr5b"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3989 * COMPARE one of the compare instructions
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3990 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3991 static int
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3992 compile_expr4(char_u *arg, cctx_T cctx, ppconst_T *ppconst)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3993 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3994 exptype_T type = EXPR_UNKNOWN;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3995 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3996 int len = 2;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3997 int type_is = FALSE;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	3998 int ppconst_used = ppconst->pp_used;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3999
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4000 // get the first variable
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4001 if (compile_expr5(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4002 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4003
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4004 p = skipwhite(*arg);
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4005 type = get_compare_type(p, &len, &type_is);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4006
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4007 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4008 * If there is a comparative operator, use it.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4009 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4010 if (type != EXPR_UNKNOWN)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4011 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4012 int ic = FALSE; // Default: do not ignore case
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4013
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4014 if (type_is && (p[len] == '?' \|\| p[len] == '#'))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4015 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4016 semsg(_(e_invexpr2), *arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4017 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4018 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4019 // extra question mark appended: ignore case
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4020 if (p[len] == '?')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4021 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4022 ic = TRUE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4023 ++len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4024 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4025 // extra '#' appended: match case (ignored)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4026 else if (p[len] == '#')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4027 ++len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4028 // nothing appended: match case
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4029
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4030 if (!IS_WHITE_OR_NUL(**arg) \|\| !IS_WHITE_OR_NUL(p[len]))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4031 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4032 char_u buf[7];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4033
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4034 vim_strncpy(buf, p, len);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4035 semsg(_(e_white_both), buf);
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4036 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4037 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4038
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4039 // get the second variable
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4040 *arg = skipwhite(p + len);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	4041 if (may_get_next_line(p + len, arg, cctx) == FAIL)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4042 return FAIL;
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4043
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4044 if (compile_expr5(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4045 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4046
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4047 if (ppconst->pp_used == ppconst_used + 2)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4048 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4049 typval_T * tv1 = &ppconst->pp_tv[ppconst->pp_used - 2];
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4050 typval_T *tv2 = &ppconst->pp_tv[ppconst->pp_used - 1];
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4051 int ret;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4052
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4053 // Both sides are a constant, compute the result now.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4054 // First check for a valid combination of types, this is more
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4055 // strict than typval_compare().
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4056 if (get_compare_isn(type, tv1->v_type, tv2->v_type) == ISN_DROP)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4057 ret = FAIL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4058 else
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4059 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4060 ret = typval_compare(tv1, tv2, type, ic);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4061 tv1->v_type = VAR_BOOL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4062 tv1->vval.v_number = tv1->vval.v_number
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4063 ? VVAL_TRUE : VVAL_FALSE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4064 clear_tv(tv2);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4065 --ppconst->pp_used;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4066 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4067 return ret;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4068 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4069
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4070 generate_ppconst(cctx, ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4071 return generate_COMPARE(cctx, type, ic);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4072 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4073
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4074 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4075 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4076
20334 b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	4077 static int compile_expr3(char_u *arg, cctx_T cctx, ppconst_T *ppconst);
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	4078
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4079 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4080 * Compile \|\| or &&.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4081 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4082 static int
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4083 compile_and_or(
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4084 char_u **arg,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4085 cctx_T *cctx,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4086 char *op,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4087 ppconst_T *ppconst,
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4088 int ppconst_used UNUSED)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4089 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4090 char_u p = skipwhite(arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4091 int opchar = *op;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4092
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4093 if (p[0] == opchar && p[1] == opchar)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4094 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4095 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4096 garray_T end_ga;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4097
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4098 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4099 * Repeat until there is no following "\|\|" or "&&"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4100 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4101 ga_init2(&end_ga, sizeof(int), 10);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4102 while (p[0] == opchar && p[1] == opchar)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4103 {
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4104 if (!IS_WHITE_OR_NUL(**arg) \|\| !IS_WHITE_OR_NUL(p[2]))
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4105 {
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4106 semsg(_(e_white_both), op);
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4107 return FAIL;
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4108 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4109
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4110 // TODO: use ppconst if the value is a constant
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4111 generate_ppconst(cctx, ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4112
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4113 if (ga_grow(&end_ga, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4114 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4115 ga_clear(&end_ga);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4116 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4117 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4118 (((int )end_ga.ga_data) + end_ga.ga_len) = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4119 ++end_ga.ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4120 generate_JUMP(cctx, opchar == '\|'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4121 ? JUMP_AND_KEEP_IF_TRUE : JUMP_AND_KEEP_IF_FALSE, 0);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4122
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4123 // eval the next expression
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4124 *arg = skipwhite(p + 2);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	4125 if (may_get_next_line(p + 2, arg, cctx) == FAIL)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4126 return FAIL;
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4127
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4128 if ((opchar == '\|' ? compile_expr3(arg, cctx, ppconst)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4129 : compile_expr4(arg, cctx, ppconst)) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4130 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4131 ga_clear(&end_ga);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4132 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4133 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4134 p = skipwhite(*arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4135 }
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4136 generate_ppconst(cctx, ppconst);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4137
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4138 // Fill in the end label in all jumps.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4139 while (end_ga.ga_len > 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4140 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4141 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4142
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4143 --end_ga.ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4144 isn = ((isn_T *)instr->ga_data)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4145 + (((int )end_ga.ga_data) + end_ga.ga_len);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4146 isn->isn_arg.jump.jump_where = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4147 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4148 ga_clear(&end_ga);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4149 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4150
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4151 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4152 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4153
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4154 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4155 * expr4a && expr4a && expr4a logical AND
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4156 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4157 * Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4158 * EVAL expr4a Push result of "expr4a"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4159 * JUMP_AND_KEEP_IF_FALSE end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4160 * EVAL expr4b Push result of "expr4b"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4161 * JUMP_AND_KEEP_IF_FALSE end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4162 * EVAL expr4c Push result of "expr4c"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4163 * end:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4164 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4165 static int
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4166 compile_expr3(char_u *arg, cctx_T cctx, ppconst_T *ppconst)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4167 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4168 int ppconst_used = ppconst->pp_used;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4169
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4170 // get the first variable
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4171 if (compile_expr4(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4172 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4173
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4174 // \|\| and && work almost the same
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4175 return compile_and_or(arg, cctx, "&&", ppconst, ppconst_used);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4176 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4177
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4178 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4179 * expr3a \|\| expr3b \|\| expr3c logical OR
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4180 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4181 * Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4182 * EVAL expr3a Push result of "expr3a"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4183 * JUMP_AND_KEEP_IF_TRUE end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4184 * EVAL expr3b Push result of "expr3b"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4185 * JUMP_AND_KEEP_IF_TRUE end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4186 * EVAL expr3c Push result of "expr3c"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4187 * end:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4188 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4189 static int
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4190 compile_expr2(char_u *arg, cctx_T cctx, ppconst_T *ppconst)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4191 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4192 int ppconst_used = ppconst->pp_used;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4193
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4194 // eval the first expression
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4195 if (compile_expr3(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4196 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4197
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4198 // \|\| and && work almost the same
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4199 return compile_and_or(arg, cctx, "\|\|", ppconst, ppconst_used);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4200 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4201
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4202 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4203 * Toplevel expression: expr2 ? expr1a : expr1b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4204 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4205 * Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4206 * EVAL expr2 Push result of "expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4207 * JUMP_IF_FALSE alt jump if false
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4208 * EVAL expr1a
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4209 * JUMP_ALWAYS end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4210 * alt: EVAL expr1b
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4211 * end:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4212 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4213 static int
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4214 compile_expr1(char_u *arg, cctx_T cctx, ppconst_T *ppconst)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4215 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4216 char_u *p;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4217 int ppconst_used = ppconst->pp_used;
20305 9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	4218
9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	4219 // Evaluate the first expression.
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4220 if (compile_expr2(arg, cctx, ppconst) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4221 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4222
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4223 p = skipwhite(*arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4224 if (*p == '?')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4225 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4226 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4227 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4228 int alt_idx = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4229 int end_idx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4230 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4231 type_T *type1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4232 type_T *type2;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4233 int has_const_expr = FALSE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4234 int const_value = FALSE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4235 int save_skip = cctx->ctx_skip;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4236
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4237 if (!IS_WHITE_OR_NUL(**arg) \|\| !IS_WHITE_OR_NUL(p[1]))
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4238 {
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4239 semsg(_(e_white_both), "?");
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4240 return FAIL;
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4241 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4242
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4243 if (ppconst->pp_used == ppconst_used + 1)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4244 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4245 // the condition is a constant, we know whether the ? or the :
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4246 // expression is to be evaluated.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4247 has_const_expr = TRUE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4248 const_value = tv2bool(&ppconst->pp_tv[ppconst_used]);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4249 clear_tv(&ppconst->pp_tv[ppconst_used]);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4250 --ppconst->pp_used;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4251 cctx->ctx_skip = save_skip == TRUE \|\| !const_value;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4252 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4253 else
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4254 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4255 generate_ppconst(cctx, ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4256 generate_JUMP(cctx, JUMP_IF_FALSE, 0);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4257 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4258
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4259 // evaluate the second expression; any type is accepted
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4260 *arg = skipwhite(p + 1);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	4261 if (may_get_next_line(p + 1, arg, cctx) == FAIL)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4262 return FAIL;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4263 if (compile_expr1(arg, cctx, ppconst) == FAIL)
19223 173b99509038 patch 8.2.0170: Coverity warning for ignoring return value Bram Moolenaar <Bram@vim.org> parents: 19213 diff changeset	4264 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4265
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4266 if (!has_const_expr)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4267 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4268 generate_ppconst(cctx, ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4269
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4270 // remember the type and drop it
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4271 --stack->ga_len;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4272 type1 = ((type_T **)stack->ga_data)[stack->ga_len];
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4273
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4274 end_idx = instr->ga_len;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4275 generate_JUMP(cctx, JUMP_ALWAYS, 0);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4276
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4277 // jump here from JUMP_IF_FALSE
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4278 isn = ((isn_T *)instr->ga_data) + alt_idx;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4279 isn->isn_arg.jump.jump_where = instr->ga_len;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4280 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4281
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4282 // Check for the ":".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4283 p = skipwhite(*arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4284 if (*p != ':')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4285 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4286 emsg(_(e_missing_colon));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4287 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4288 }
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4289 if (!IS_WHITE_OR_NUL(**arg) \|\| !IS_WHITE_OR_NUL(p[1]))
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4290 {
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4291 semsg(_(e_white_both), ":");
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4292 return FAIL;
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4293 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4294
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4295 // evaluate the third expression
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4296 if (has_const_expr)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4297 cctx->ctx_skip = save_skip == TRUE \|\| const_value;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4298 *arg = skipwhite(p + 1);
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20019 diff changeset	4299 if (may_get_next_line(p + 1, arg, cctx) == FAIL)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	4300 return FAIL;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4301 if (compile_expr1(arg, cctx, ppconst) == FAIL)
19223 173b99509038 patch 8.2.0170: Coverity warning for ignoring return value Bram Moolenaar <Bram@vim.org> parents: 19213 diff changeset	4302 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4303
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4304 if (!has_const_expr)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4305 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4306 generate_ppconst(cctx, ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4307
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4308 // If the types differ, the result has a more generic type.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4309 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1];
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4310 common_type(type1, type2, &type2, cctx->ctx_type_list);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4311
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4312 // jump here from JUMP_ALWAYS
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4313 isn = ((isn_T *)instr->ga_data) + end_idx;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4314 isn->isn_arg.jump.jump_where = instr->ga_len;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4315 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4316
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4317 cctx->ctx_skip = save_skip;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4318 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4319 return OK;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4320 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4321
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4322 /*
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4323 * Toplevel expression.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4324 */
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4325 static int
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4326 compile_expr0(char_u *arg, cctx_T cctx)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4327 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4328 ppconst_T ppconst;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4329
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4330 CLEAR_FIELD(ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4331 if (compile_expr1(arg, cctx, &ppconst) == FAIL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4332 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4333 clear_ppconst(&ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4334 return FAIL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4335 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4336 if (generate_ppconst(cctx, &ppconst) == FAIL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4337 return FAIL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4338 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4339 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4340
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4341 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4342 * compile "return [expr]"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4343 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4344 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4345 compile_return(char_u arg, int set_return_type, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4346 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4347 char_u *p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4348 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4349 type_T *stack_type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4350
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4351 if (p != NUL && p != '\|' && *p != '\n')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4352 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4353 // compile return argument into instructions
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4354 if (compile_expr0(&p, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4355 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4356
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4357 stack_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4358 if (set_return_type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4359 cctx->ctx_ufunc->uf_ret_type = stack_type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4360 else if (need_type(stack_type, cctx->ctx_ufunc->uf_ret_type, -1, cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4361 == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4362 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4363 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4364 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4365 {
19860 37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19858 diff changeset	4366 // "set_return_type" cannot be TRUE, only used for a lambda which
37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19858 diff changeset	4367 // always has an argument.
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	4368 if (cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_VOID
1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	4369 && cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_UNKNOWN)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4370 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4371 emsg(_("E1003: Missing return value"));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4372 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4373 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4374
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4375 // No argument, return zero.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4376 generate_PUSHNR(cctx, 0);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4377 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4378
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4379 if (generate_instr(cctx, ISN_RETURN) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4380 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4381
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4382 // "return val \| endif" is possible
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4383 return skipwhite(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4384 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4385
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4386 /*
20279 49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4387 * Get a line from the compilation context, compatible with exarg_T getline().
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4388 * Return a pointer to the line in allocated memory.
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4389 * Return NULL for end-of-file or some error.
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4390 */
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4391 static char_u *
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4392 exarg_getline(
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4393 int c UNUSED,
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4394 void *cookie,
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4395 int indent UNUSED,
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4396 int do_concat UNUSED)
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4397 {
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4398 cctx_T cctx = (cctx_T )cookie;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4399
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4400 if (cctx->ctx_lnum == cctx->ctx_ufunc->uf_lines.ga_len)
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4401 {
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4402 iemsg("Heredoc got to end");
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4403 return NULL;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4404 }
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4405 ++cctx->ctx_lnum;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4406 return vim_strsave(((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4407 [cctx->ctx_lnum]);
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4408 }
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4409
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4410 /*
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4411 * Compile a nested :def command.
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4412 */
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4413 static char_u *
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4414 compile_nested_function(exarg_T eap, cctx_T cctx)
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4415 {
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4416 char_u *name_start = eap->arg;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4417 char_u *name_end = to_name_end(eap->arg, FALSE);
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4418 char_u *name = get_lambda_name();
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4419 lvar_T *lvar;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4420 ufunc_T *ufunc;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4421
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4422 eap->arg = name_end;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4423 eap->getline = exarg_getline;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4424 eap->cookie = cctx;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4425 eap->skip = cctx->ctx_skip == TRUE;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4426 eap->forceit = FALSE;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4427 ufunc = def_function(eap, name, cctx);
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4428
20281 ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	4429 if (ufunc == NULL \|\| ufunc->uf_dfunc_idx < 0)
20279 49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4430 return NULL;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4431
20281 ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	4432 // Define a local variable for the function reference.
20279 49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4433 lvar = reserve_local(cctx, name_start, name_end - name_start,
20281 ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	4434 TRUE, ufunc->uf_func_type);
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	4435
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	4436 if (generate_FUNCREF(cctx, ufunc->uf_dfunc_idx) == FAIL
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	4437 \|\| generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL) == FAIL)
ab8c8fd0f868 patch 8.2.0696: Vim9: nested function does not work properly Bram Moolenaar <Bram@vim.org> parents: 20279 diff changeset	4438 return NULL;
20279 49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4439
20305 9a5e2370df0e patch 8.2.0708: Vim9: constant expressions are not simplified Bram Moolenaar <Bram@vim.org> parents: 20295 diff changeset	4440 // TODO: warning for trailing text?
20279 49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4441 return (char_u *)"";
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4442 }
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4443
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4444 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4445 * Return the length of an assignment operator, or zero if there isn't one.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4446 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4447 int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4448 assignment_len(char_u p, int heredoc)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4449 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4450 if (*p == '=')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4451 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4452 if (p[1] == '<' && p[2] == '<')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4453 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4454 *heredoc = TRUE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4455 return 3;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4456 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4457 return 1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4458 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4459 if (vim_strchr((char_u )"+-/%", *p) != NULL && p[1] == '=')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4460 return 2;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4461 if (STRNCMP(p, "..=", 3) == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4462 return 3;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4463 return 0;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4464 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4465
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4466 // words that cannot be used as a variable
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4467 static char *reserved[] = {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4468 "true",
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4469 "false",
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4470 NULL
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4471 };
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4472
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4473 typedef enum {
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4474 dest_local,
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4475 dest_option,
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4476 dest_env,
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4477 dest_global,
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4478 dest_buffer,
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4479 dest_window,
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4480 dest_tab,
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4481 dest_vimvar,
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4482 dest_script,
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4483 dest_reg,
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4484 } assign_dest_T;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4485
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4486 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4487 * compile "let var [= expr]", "const var = expr" and "var = expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4488 * "arg" points to "var".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4489 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4490 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4491 compile_assignment(char_u arg, exarg_T eap, cmdidx_T cmdidx, cctx_T *cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4492 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4493 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4494 char_u *ret = NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4495 int var_count = 0;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4496 int semicolon = 0;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4497 size_t varlen;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4498 garray_T *instr = &cctx->ctx_instr;
19858 cf09c0962608 patch 8.2.0485: Vim9 script test fails Bram Moolenaar <Bram@vim.org> parents: 19854 diff changeset	4499 int new_local = FALSE;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4500 char_u *op;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4501 int opt_type;
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4502 assign_dest_T dest = dest_local;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4503 int opt_flags = 0;
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	4504 int vimvaridx = -1;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4505 int oplen = 0;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4506 int heredoc = FALSE;
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4507 type_T *type = &t_any;
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4508 lvar_T *lvar = NULL;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4509 char_u *name;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4510 char_u *sp;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4511 int has_type = FALSE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4512 int is_decl = cmdidx == CMD_let \|\| cmdidx == CMD_const;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4513 int instr_count = -1;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4514
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4515 p = skip_var_list(arg, FALSE, &var_count, &semicolon);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4516 if (p == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4517 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4518 if (var_count > 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4519 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4520 // TODO: let [var, var] = list
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4521 emsg("Cannot handle a list yet");
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4522 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4523 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4524
19860 37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19858 diff changeset	4525 // "a: type" is declaring variable "a" with a type, not "a:".
37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19858 diff changeset	4526 if (is_decl && p == arg + 2 && p[-1] == ':')
37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19858 diff changeset	4527 --p;
37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19858 diff changeset	4528
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4529 varlen = p - arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4530 name = vim_strnsave(arg, (int)varlen);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4531 if (name == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4532 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4533
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4534 if (cctx->ctx_skip != TRUE)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4535 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4536 if (*arg == '&')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4537 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4538 int cc;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4539 long numval;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4540
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4541 dest = dest_option;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4542 if (cmdidx == CMD_const)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4543 {
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4544 emsg(_(e_const_option));
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	4545 goto theend;
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4546 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4547 if (is_decl)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4548 {
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4549 semsg(_("E1052: Cannot declare an option: %s"), arg);
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4550 goto theend;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4551 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4552 p = arg;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4553 p = find_option_end(&p, &opt_flags);
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4554 if (p == NULL)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4555 {
19860 37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19858 diff changeset	4556 // cannot happen?
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4557 emsg(_(e_letunexp));
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	4558 goto theend;
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4559 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4560 cc = *p;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4561 *p = NUL;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	4562 opt_type = get_option_value(arg + 1, &numval, NULL, opt_flags);
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4563 *p = cc;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4564 if (opt_type == -3)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4565 {
19860 37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19858 diff changeset	4566 semsg(_(e_unknown_option), arg);
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	4567 goto theend;
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4568 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4569 if (opt_type == -2 \|\| opt_type == 0)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4570 type = &t_string;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4571 else
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4572 type = &t_number; // both number and boolean option
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	4573 }
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4574 else if (*arg == '$')
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	4575 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4576 dest = dest_env;
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4577 type = &t_string;
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4578 if (is_decl)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4579 {
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	4580 semsg(_("E1065: Cannot declare an environment variable: %s"),
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	4581 name);
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4582 goto theend;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4583 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4584 }
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4585 else if (*arg == '@')
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	4586 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4587 if (!valid_yank_reg(arg[1], TRUE))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4588 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4589 emsg_invreg(arg[1]);
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	4590 goto theend;
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4591 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4592 dest = dest_reg;
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4593 type = &t_string;
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4594 if (is_decl)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4595 {
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4596 semsg(_("E1066: Cannot declare a register: %s"), name);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4597 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4598 }
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4599 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4600 else if (STRNCMP(arg, "g:", 2) == 0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4601 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4602 dest = dest_global;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4603 if (is_decl)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4604 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4605 semsg(_("E1016: Cannot declare a global variable: %s"), name);
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4606 goto theend;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4607 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4608 }
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4609 else if (STRNCMP(arg, "b:", 2) == 0)
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4610 {
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4611 dest = dest_buffer;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4612 if (is_decl)
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4613 {
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4614 semsg(_("E1078: Cannot declare a buffer variable: %s"), name);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4615 goto theend;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4616 }
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4617 }
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4618 else if (STRNCMP(arg, "w:", 2) == 0)
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4619 {
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4620 dest = dest_window;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4621 if (is_decl)
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4622 {
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4623 semsg(_("E1079: Cannot declare a window variable: %s"), name);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4624 goto theend;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4625 }
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4626 }
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4627 else if (STRNCMP(arg, "t:", 2) == 0)
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4628 {
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4629 dest = dest_tab;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4630 if (is_decl)
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4631 {
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4632 semsg(_("E1080: Cannot declare a tab variable: %s"), name);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4633 goto theend;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4634 }
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4635 }
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4636 else if (STRNCMP(arg, "v:", 2) == 0)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4637 {
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	4638 typval_T *vtv;
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	4639 int di_flags;
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	4640
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	4641 vimvaridx = find_vim_var(name + 2, &di_flags);
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4642 if (vimvaridx < 0)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4643 {
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4644 semsg(_(e_var_notfound), arg);
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4645 goto theend;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4646 }
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	4647 // We use the current value of "sandbox" here, is that OK?
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	4648 if (var_check_ro(di_flags, name, FALSE))
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19946 diff changeset	4649 goto theend;
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4650 dest = dest_vimvar;
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4651 vtv = get_vim_var_tv(vimvaridx);
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4652 type = typval2type(vtv);
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4653 if (is_decl)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4654 {
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4655 semsg(_("E1064: Cannot declare a v: variable: %s"), name);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4656 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4657 }
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4658 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4659 else
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4660 {
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4661 int idx;
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4662
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4663 for (idx = 0; reserved[idx] != NULL; ++idx)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4664 if (STRCMP(reserved[idx], name) == 0)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4665 {
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4666 semsg(_("E1034: Cannot use reserved name %s"), name);
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4667 goto theend;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4668 }
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4669
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4670 lvar = lookup_local(arg, varlen, cctx);
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4671 if (lvar != NULL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4672 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4673 if (is_decl)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4674 {
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4675 semsg(_("E1017: Variable already declared: %s"), name);
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4676 goto theend;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4677 }
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	4678 else if (lvar->lv_const)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4679 {
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	4680 semsg(_("E1018: Cannot assign to a constant: %s"), name);
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	4681 goto theend;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4682 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4683 }
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4684 else if (STRNCMP(arg, "s:", 2) == 0
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4685 \|\| lookup_script(arg, varlen) == OK
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4686 \|\| find_imported(arg, varlen, cctx) != NULL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4687 {
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4688 dest = dest_script;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4689 if (is_decl)
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4690 {
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4691 semsg(_("E1054: Variable already declared in the script: %s"),
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	4692 name);
19587 e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4693 goto theend;
e61dc51ab9b4 patch 8.2.0350: Vim9: expression tests don't use recognized constants Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	4694 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4695 }
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4696 else if (name[1] == ':' && name[2] != NUL)
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4697 {
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4698 semsg(_("E1082: Cannot use a namespaced variable: %s"), name);
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4699 goto theend;
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4700 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4701 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4702 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4703
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4704 if (dest != dest_option)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4705 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4706 if (is_decl && *p == ':')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4707 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4708 // parse optional type: "let var: type = expr"
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4709 if (!VIM_ISWHITE(p[1]))
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4710 {
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4711 semsg(_(e_white_after), ":");
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4712 goto theend;
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	4713 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4714 p = skipwhite(p + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4715 type = parse_type(&p, cctx->ctx_type_list);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4716 has_type = TRUE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4717 }
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4718 else if (lvar != NULL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4719 type = lvar->lv_type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4720 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4721
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4722 sp = p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4723 p = skipwhite(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4724 op = p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4725 oplen = assignment_len(p, &heredoc);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4726 if (oplen > 0 && (!VIM_ISWHITE(*sp) \|\| !VIM_ISWHITE(op[oplen])))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4727 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4728 char_u buf[4];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4729
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4730 vim_strncpy(buf, op, oplen);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4731 semsg(_(e_white_both), buf);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4732 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4733
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4734 if (oplen == 3 && !heredoc && dest != dest_global
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	4735 && type->tt_type != VAR_STRING && type->tt_type != VAR_ANY)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4736 {
19411 bc880a130120 patch 8.2.0263: a few new Vim9 messages are not localized Bram Moolenaar <Bram@vim.org> parents: 19392 diff changeset	4737 emsg(_("E1019: Can only concatenate to string"));
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4738 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4739 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4740
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4741 if (lvar == NULL && dest == dest_local && cctx->ctx_skip != TRUE)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4742 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4743 if (oplen > 1 && !heredoc)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4744 {
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	4745 // +=, /=, etc. require an existing variable
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4746 semsg(_("E1020: cannot use an operator on a new variable: %s"),
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4747 name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4748 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4749 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4750
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4751 // new local variable
19985 f863aa96cae5 patch 8.2.0548: Vim9: not all possible func type errors tested Bram Moolenaar <Bram@vim.org> parents: 19981 diff changeset	4752 if (type->tt_type == VAR_FUNC && var_check_func_name(name, TRUE))
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	4753 goto theend;
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4754 lvar = reserve_local(cctx, arg, varlen, cmdidx == CMD_const, type);
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4755 if (lvar == NULL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4756 goto theend;
19858 cf09c0962608 patch 8.2.0485: Vim9 script test fails Bram Moolenaar <Bram@vim.org> parents: 19854 diff changeset	4757 new_local = TRUE;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4758 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4759
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4760 if (heredoc)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4761 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4762 list_T *l;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4763 listitem_T *li;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4764
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4765 // [let] varname =<< [trim] {end}
20279 49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	4766 eap->getline = exarg_getline;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4767 eap->cookie = cctx;
20045 04ef2ccf2519 patch 8.2.0578: heredoc for interfaces does not support "trim" Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	4768 l = heredoc_get(eap, op + 3, FALSE);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4769
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4770 // Push each line and the create the list.
19934 3ff714d765ba patch 8.2.0523: loops are repeated Bram Moolenaar <Bram@vim.org> parents: 19926 diff changeset	4771 FOR_ALL_LIST_ITEMS(l, li)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4772 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4773 generate_PUSHS(cctx, li->li_tv.vval.v_string);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4774 li->li_tv.vval.v_string = NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4775 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4776 generate_NEWLIST(cctx, l->lv_len);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4777 type = &t_list_string;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4778 list_free(l);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4779 p += STRLEN(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4780 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4781 else if (oplen > 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4782 {
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4783 int r;
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4784 type_T *stacktype;
8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4785 garray_T *stack;
19854 eddc81783052 patch 8.2.0483: Vim9: "let x = x + 1" does not give an error Bram Moolenaar <Bram@vim.org> parents: 19848 diff changeset	4786
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4787 // for "+=", "*=", "..=" etc. first load the current value
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4788 if (*op != '=')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4789 {
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4790 switch (dest)
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4791 {
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4792 case dest_option:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4793 // TODO: check the option exists
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19866 diff changeset	4794 generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4795 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4796 case dest_global:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4797 generate_LOAD(cctx, ISN_LOADG, 0, name + 2, type);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4798 break;
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4799 case dest_buffer:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4800 generate_LOAD(cctx, ISN_LOADB, 0, name + 2, type);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4801 break;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4802 case dest_window:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4803 generate_LOAD(cctx, ISN_LOADW, 0, name + 2, type);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4804 break;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4805 case dest_tab:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4806 generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4807 break;
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4808 case dest_script:
19530 48e71f948360 patch 8.2.0322: Vim9: error checks not tested Bram Moolenaar <Bram@vim.org> parents: 19528 diff changeset	4809 compile_load_scriptvar(cctx,
48e71f948360 patch 8.2.0322: Vim9: error checks not tested Bram Moolenaar <Bram@vim.org> parents: 19528 diff changeset	4810 name + (name[1] == ':' ? 2 : 0), NULL, NULL, TRUE);
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4811 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4812 case dest_env:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4813 // Include $ in the name here
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4814 generate_LOAD(cctx, ISN_LOADENV, 0, name, type);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4815 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4816 case dest_reg:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4817 generate_LOAD(cctx, ISN_LOADREG, arg[1], NULL, &t_string);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4818 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4819 case dest_vimvar:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4820 generate_LOADV(cctx, name + 2, TRUE);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4821 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4822 case dest_local:
20295 bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	4823 if (lvar->lv_from_outer)
bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	4824 generate_LOAD(cctx, ISN_LOADOUTER, lvar->lv_idx,
bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	4825 NULL, type);
bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	4826 else
bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	4827 generate_LOAD(cctx, ISN_LOAD, lvar->lv_idx, NULL, type);
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4828 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4829 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4830 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4831
19854 eddc81783052 patch 8.2.0483: Vim9: "let x = x + 1" does not give an error Bram Moolenaar <Bram@vim.org> parents: 19848 diff changeset	4832 // Compile the expression. Temporarily hide the new local variable
eddc81783052 patch 8.2.0483: Vim9: "let x = x + 1" does not give an error Bram Moolenaar <Bram@vim.org> parents: 19848 diff changeset	4833 // here, it is not available to this expression.
19858 cf09c0962608 patch 8.2.0485: Vim9 script test fails Bram Moolenaar <Bram@vim.org> parents: 19854 diff changeset	4834 if (new_local)
19854 eddc81783052 patch 8.2.0483: Vim9: "let x = x + 1" does not give an error Bram Moolenaar <Bram@vim.org> parents: 19848 diff changeset	4835 --cctx->ctx_locals.ga_len;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4836 instr_count = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4837 p = skipwhite(p + oplen);
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	4838 r = compile_expr0(&p, cctx);
19858 cf09c0962608 patch 8.2.0485: Vim9 script test fails Bram Moolenaar <Bram@vim.org> parents: 19854 diff changeset	4839 if (new_local)
19854 eddc81783052 patch 8.2.0483: Vim9: "let x = x + 1" does not give an error Bram Moolenaar <Bram@vim.org> parents: 19848 diff changeset	4840 ++cctx->ctx_locals.ga_len;
eddc81783052 patch 8.2.0483: Vim9: "let x = x + 1" does not give an error Bram Moolenaar <Bram@vim.org> parents: 19848 diff changeset	4841 if (r == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4842 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4843
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4844 if (cctx->ctx_skip != TRUE)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4845 {
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4846 stack = &cctx->ctx_type_stack;
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4847 stacktype = stack->ga_len == 0 ? &t_void
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4848 : ((type_T **)stack->ga_data)[stack->ga_len - 1];
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	4849 if (lvar != NULL && (is_decl \|\| !has_type))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4850 {
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4851 if (new_local && !has_type)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4852 {
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4853 if (stacktype->tt_type == VAR_VOID)
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4854 {
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4855 emsg(_("E1031: Cannot use void value"));
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4856 goto theend;
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4857 }
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4858 else
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4859 {
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4860 // An empty list or dict has a &t_void member, for a
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4861 // variable that implies &t_any.
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4862 if (stacktype == &t_list_empty)
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4863 lvar->lv_type = &t_list_any;
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4864 else if (stacktype == &t_dict_empty)
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4865 lvar->lv_type = &t_dict_any;
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4866 else
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4867 lvar->lv_type = stacktype;
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4868 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4869 }
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4870 else if (need_type(stacktype, lvar->lv_type, -1, cctx) == FAIL)
b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4871 goto theend;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4872 }
19942 b471038ec3ea patch 8.2.0527: Vim9: function types insufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19934 diff changeset	4873 else if (*p != '=' && check_type(type, stacktype, TRUE) == FAIL)
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	4874 goto theend;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4875 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4876 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4877 else if (cmdidx == CMD_const)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4878 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4879 emsg(_("E1021: const requires a value"));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4880 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4881 }
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4882 else if (!has_type \|\| dest == dest_option)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4883 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4884 emsg(_("E1022: type or initialization required"));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4885 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4886 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4887 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4888 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4889 // variables are always initialized
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4890 if (ga_grow(instr, 1) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4891 goto theend;
19336 1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4892 switch (type->tt_type)
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4893 {
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4894 case VAR_BOOL:
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4895 generate_PUSHBOOL(cctx, VVAL_FALSE);
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4896 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4897 case VAR_FLOAT:
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4898 #ifdef FEAT_FLOAT
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4899 generate_PUSHF(cctx, 0.0);
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4900 #endif
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4901 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4902 case VAR_STRING:
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4903 generate_PUSHS(cctx, NULL);
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4904 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4905 case VAR_BLOB:
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4906 generate_PUSHBLOB(cctx, NULL);
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4907 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4908 case VAR_FUNC:
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	4909 generate_PUSHFUNC(cctx, NULL, &t_func_void);
19336 1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4910 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4911 case VAR_LIST:
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4912 generate_NEWLIST(cctx, 0);
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4913 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4914 case VAR_DICT:
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4915 generate_NEWDICT(cctx, 0);
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4916 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4917 case VAR_JOB:
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	4918 generate_PUSHJOB(cctx, NULL);
19336 1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4919 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4920 case VAR_CHANNEL:
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	4921 generate_PUSHCHANNEL(cctx, NULL);
19336 1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4922 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4923 case VAR_NUMBER:
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4924 case VAR_UNKNOWN:
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	4925 case VAR_ANY:
19964 6765a88e72a5 patch 8.2.0538: Vim9: VAR_PARTIAL is not used during compilation Bram Moolenaar <Bram@vim.org> parents: 19960 diff changeset	4926 case VAR_PARTIAL:
19336 1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4927 case VAR_VOID:
19874 f92435f0f449 patch 8.2.0493: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19872 diff changeset	4928 case VAR_SPECIAL: // cannot happen
19336 1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4929 generate_PUSHNR(cctx, 0);
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4930 break;
1cd6eab65ce0 patch 8.2.0226: compiling for loop not tested Bram Moolenaar <Bram@vim.org> parents: 19332 diff changeset	4931 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4932 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4933
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4934 if (oplen > 0 && *op != '=')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4935 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4936 type_T *expected = &t_number;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4937 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4938 type_T *stacktype;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4939
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4940 // TODO: if type is known use float or any operation
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4941
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4942 if (*op == '.')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4943 expected = &t_string;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4944 stacktype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4945 if (need_type(stacktype, expected, -1, cctx) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4946 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4947
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4948 if (*op == '.')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4949 generate_instr_drop(cctx, ISN_CONCAT, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4950 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4951 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4952 isn_T *isn = generate_instr_drop(cctx, ISN_OPNR, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4953
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4954 if (isn == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4955 goto theend;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4956 switch (*op)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4957 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4958 case '+': isn->isn_arg.op.op_type = EXPR_ADD; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4959 case '-': isn->isn_arg.op.op_type = EXPR_SUB; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4960 case '*': isn->isn_arg.op.op_type = EXPR_MULT; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4961 case '/': isn->isn_arg.op.op_type = EXPR_DIV; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4962 case '%': isn->isn_arg.op.op_type = EXPR_REM; break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4963 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4964 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4965 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4966
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4967 switch (dest)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4968 {
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4969 case dest_option:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4970 generate_STOREOPT(cctx, name + 1, opt_flags);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4971 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4972 case dest_global:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4973 // include g: with the name, easier to execute that way
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4974 generate_STORE(cctx, ISN_STOREG, 0, name);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4975 break;
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4976 case dest_buffer:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4977 // include b: with the name, easier to execute that way
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4978 generate_STORE(cctx, ISN_STOREB, 0, name);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4979 break;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4980 case dest_window:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4981 // include w: with the name, easier to execute that way
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4982 generate_STORE(cctx, ISN_STOREW, 0, name);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4983 break;
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4984 case dest_tab:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4985 // include t: with the name, easier to execute that way
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4986 generate_STORE(cctx, ISN_STORET, 0, name);
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	4987 break;
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4988 case dest_env:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4989 generate_STORE(cctx, ISN_STOREENV, 0, name + 1);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4990 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4991 case dest_reg:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4992 generate_STORE(cctx, ISN_STOREREG, name[1], NULL);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4993 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4994 case dest_vimvar:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4995 generate_STORE(cctx, ISN_STOREV, vimvaridx, NULL);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4996 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4997 case dest_script:
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4998 {
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	4999 char_u *rawname = name + (name[1] == ':' ? 2 : 0);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5000 imported_T *import = NULL;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5001 int sid = current_sctx.sc_sid;
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5002 int idx;
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5003
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5004 if (name[1] != ':')
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5005 {
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5006 import = find_imported(name, 0, cctx);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5007 if (import != NULL)
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5008 sid = import->imp_sid;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5009 }
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5010
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5011 idx = get_script_item_idx(sid, rawname, TRUE);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5012 // TODO: specific type
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5013 if (idx < 0)
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5014 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5015 char_u *name_s = name;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5016
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5017 // Include s: in the name for store_var()
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5018 if (name[1] != ':')
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5019 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5020 int len = (int)STRLEN(name) + 3;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5021
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5022 name_s = alloc(len);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5023 if (name_s == NULL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5024 name_s = name;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5025 else
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5026 vim_snprintf((char *)name_s, len, "s:%s", name);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5027 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5028 generate_OLDSCRIPT(cctx, ISN_STORES, name_s, sid, &t_any);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5029 if (name_s != name)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5030 vim_free(name_s);
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	5031 }
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5032 else
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5033 generate_VIM9SCRIPT(cctx, ISN_STORESCRIPT,
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5034 sid, idx, &t_any);
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5035 }
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5036 break;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5037 case dest_local:
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5038 if (lvar != NULL)
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5039 {
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5040 isn_T isn = ((isn_T )instr->ga_data) + instr->ga_len - 1;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5041
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5042 // optimization: turn "var = 123" from ISN_PUSHNR + ISN_STORE
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5043 // into ISN_STORENR
20295 bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	5044 if (!lvar->lv_from_outer && instr->ga_len == instr_count + 1
bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	5045 && isn->isn_type == ISN_PUSHNR)
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5046 {
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5047 varnumber_T val = isn->isn_arg.number;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5048 garray_T *stack = &cctx->ctx_type_stack;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5049
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5050 isn->isn_type = ISN_STORENR;
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5051 isn->isn_arg.storenr.stnr_idx = lvar->lv_idx;
19597 1098989a90ee patch 8.2.0355: Vim9: str_val is confusing, it's a number Bram Moolenaar <Bram@vim.org> parents: 19587 diff changeset	5052 isn->isn_arg.storenr.stnr_val = val;
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5053 if (stack->ga_len > 0)
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5054 --stack->ga_len;
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5055 }
20295 bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	5056 else if (lvar->lv_from_outer)
bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	5057 generate_STORE(cctx, ISN_STOREOUTER, lvar->lv_idx, NULL);
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5058 else
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5059 generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL);
19285 86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5060 }
86665583dc83 patch 8.2.0201: cannot assign to an imported variable Bram Moolenaar <Bram@vim.org> parents: 19283 diff changeset	5061 break;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5062 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5063 ret = p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5064
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5065 theend:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5066 vim_free(name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5067 return ret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5068 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5069
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5070 /*
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5071 * Check if "name" can be "unlet".
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5072 */
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5073 int
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5074 check_vim9_unlet(char_u *name)
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5075 {
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5076 if (name[1] != ':' \|\| vim_strchr((char_u )"gwtb", name) == NULL)
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5077 {
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5078 semsg(_("E1081: Cannot unlet %s"), name);
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5079 return FAIL;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5080 }
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5081 return OK;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5082 }
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5083
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5084 /*
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5085 * Callback passed to ex_unletlock().
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5086 */
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5087 static int
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5088 compile_unlet(
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5089 lval_T *lvp,
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5090 char_u *name_end,
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5091 exarg_T *eap,
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5092 int deep UNUSED,
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5093 void *coookie)
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5094 {
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5095 cctx_T *cctx = coookie;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5096
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5097 if (lvp->ll_tv == NULL)
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5098 {
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5099 char_u *p = lvp->ll_name;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5100 int cc = *name_end;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5101 int ret = OK;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5102
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5103 // Normal name. Only supports g:, w:, t: and b: namespaces.
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5104 *name_end = NUL;
20099 058b41f85bcb patch 8.2.0605: Vim9: cannot unlet an environment variable Bram Moolenaar <Bram@vim.org> parents: 20091 diff changeset	5105 if (*p == '$')
058b41f85bcb patch 8.2.0605: Vim9: cannot unlet an environment variable Bram Moolenaar <Bram@vim.org> parents: 20091 diff changeset	5106 ret = generate_UNLET(cctx, ISN_UNLETENV, p + 1, eap->forceit);
058b41f85bcb patch 8.2.0605: Vim9: cannot unlet an environment variable Bram Moolenaar <Bram@vim.org> parents: 20091 diff changeset	5107 else if (check_vim9_unlet(p) == FAIL)
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5108 ret = FAIL;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5109 else
20099 058b41f85bcb patch 8.2.0605: Vim9: cannot unlet an environment variable Bram Moolenaar <Bram@vim.org> parents: 20091 diff changeset	5110 ret = generate_UNLET(cctx, ISN_UNLET, p, eap->forceit);
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5111
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5112 *name_end = cc;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5113 return ret;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5114 }
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5115
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5116 // TODO: unlet {list}[idx]
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5117 // TODO: unlet {dict}[key]
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5118 emsg("Sorry, :unlet not fully implemented yet");
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5119 return FAIL;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5120 }
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5121
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5122 /*
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5123 * compile "unlet var", "lock var" and "unlock var"
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5124 * "arg" points to "var".
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5125 */
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5126 static char_u *
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5127 compile_unletlock(char_u arg, exarg_T eap, cctx_T *cctx)
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5128 {
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5129 char_u *p = arg;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5130
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5131 if (eap->cmdidx != CMD_unlet)
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5132 {
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5133 emsg("Sorry, :lock and unlock not implemented yet");
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5134 return NULL;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5135 }
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5136
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5137 if (*p == '!')
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5138 {
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5139 p = skipwhite(p + 1);
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5140 eap->forceit = TRUE;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5141 }
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5142
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5143 ex_unletlock(eap, p, 0, GLV_NO_AUTOLOAD, compile_unlet, cctx);
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5144 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5145 }
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5146
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	5147 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5148 * Compile an :import command.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5149 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5150 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5151 compile_import(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5152 {
19623 2fee087c94cb patch 8.2.0368: Vim9: import that redefines local variable does not fail Bram Moolenaar <Bram@vim.org> parents: 19597 diff changeset	5153 return handle_import(arg, &cctx->ctx_imports, 0, cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5154 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5155
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5156 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5157 * generate a jump to the ":endif"/":endfor"/":endwhile"/":finally"/":endtry".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5158 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5159 static int
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5160 compile_jump_to_end(endlabel_T *el, jumpwhen_T when, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5161 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5162 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5163 endlabel_T *endlabel = ALLOC_CLEAR_ONE(endlabel_T);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5164
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5165 if (endlabel == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5166 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5167 endlabel->el_next = *el;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5168 *el = endlabel;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5169 endlabel->el_end_label = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5170
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5171 generate_JUMP(cctx, when, 0);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5172 return OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5173 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5174
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5175 static void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5176 compile_fill_jump_to_end(endlabel_T *el, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5177 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5178 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5179
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5180 while (*el != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5181 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5182 endlabel_T cur = (el);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5183 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5184
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5185 isn = ((isn_T *)instr->ga_data) + cur->el_end_label;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5186 isn->isn_arg.jump.jump_where = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5187 *el = cur->el_next;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5188 vim_free(cur);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5189 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5190 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5191
19896 92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5192 static void
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5193 compile_free_jump_to_end(endlabel_T **el)
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5194 {
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5195 while (*el != NULL)
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5196 {
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5197 endlabel_T cur = (el);
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5198
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5199 *el = cur->el_next;
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5200 vim_free(cur);
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5201 }
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5202 }
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5203
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5204 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5205 * Create a new scope and set up the generic items.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5206 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5207 static scope_T *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5208 new_scope(cctx_T *cctx, scopetype_T type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5209 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5210 scope_T *scope = ALLOC_CLEAR_ONE(scope_T);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5211
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5212 if (scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5213 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5214 scope->se_outer = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5215 cctx->ctx_scope = scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5216 scope->se_type = type;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5217 scope->se_local_count = cctx->ctx_locals.ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5218 return scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5219 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5220
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5221 /*
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5222 * Free the current scope and go back to the outer scope.
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5223 */
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5224 static void
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5225 drop_scope(cctx_T *cctx)
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5226 {
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5227 scope_T *scope = cctx->ctx_scope;
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5228
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5229 if (scope == NULL)
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5230 {
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5231 iemsg("calling drop_scope() without a scope");
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5232 return;
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5233 }
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5234 cctx->ctx_scope = scope->se_outer;
19896 92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5235 switch (scope->se_type)
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5236 {
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5237 case IF_SCOPE:
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5238 compile_free_jump_to_end(&scope->se_u.se_if.is_end_label); break;
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5239 case FOR_SCOPE:
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5240 compile_free_jump_to_end(&scope->se_u.se_for.fs_end_label); break;
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5241 case WHILE_SCOPE:
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5242 compile_free_jump_to_end(&scope->se_u.se_while.ws_end_label); break;
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5243 case TRY_SCOPE:
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5244 compile_free_jump_to_end(&scope->se_u.se_try.ts_end_label); break;
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5245 case NO_SCOPE:
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5246 case BLOCK_SCOPE:
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5247 break;
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	5248 }
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5249 vim_free(scope);
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5250 }
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5251
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5252 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5253 * compile "if expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5254 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5255 * "if expr" Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5256 * EVAL expr Push result of "expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5257 * JUMP_IF_FALSE end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5258 * ... body ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5259 * end:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5260 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5261 * "if expr \| else" Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5262 * EVAL expr Push result of "expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5263 * JUMP_IF_FALSE else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5264 * ... body ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5265 * JUMP_ALWAYS end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5266 * else:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5267 * ... body ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5268 * end:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5269 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5270 * "if expr1 \| elseif expr2 \| else" Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5271 * EVAL expr Push result of "expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5272 * JUMP_IF_FALSE elseif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5273 * ... body ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5274 * JUMP_ALWAYS end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5275 * elseif:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5276 * EVAL expr Push result of "expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5277 * JUMP_IF_FALSE else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5278 * ... body ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5279 * JUMP_ALWAYS end
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5280 * else:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5281 * ... body ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5282 * end:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5283 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5284 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5285 compile_if(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5286 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5287 char_u *p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5288 garray_T *instr = &cctx->ctx_instr;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5289 int instr_count = instr->ga_len;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5290 scope_T *scope;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5291 ppconst_T ppconst;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5292
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5293 CLEAR_FIELD(ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5294 if (compile_expr1(&p, cctx, &ppconst) == FAIL)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5295 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5296 clear_ppconst(&ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5297 return NULL;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5298 }
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5299 if (instr->ga_len == instr_count && ppconst.pp_used == 1)
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5300 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5301 // The expression results in a constant.
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5302 // TODO: how about nesting?
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5303 cctx->ctx_skip = tv2bool(&ppconst.pp_tv[0]) ? FALSE : TRUE;
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5304 clear_ppconst(&ppconst);
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5305 }
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5306 else
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5307 {
445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5308 // Not a constant, generate instructions for the expression.
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5309 cctx->ctx_skip = MAYBE;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5310 if (generate_ppconst(cctx, &ppconst) == FAIL)
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5311 return NULL;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5312 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5313
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5314 scope = new_scope(cctx, IF_SCOPE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5315 if (scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5316 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5317
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5318 if (cctx->ctx_skip == MAYBE)
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5319 {
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5320 // "where" is set when ":elseif", "else" or ":endif" is found
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5321 scope->se_u.se_if.is_if_label = instr->ga_len;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5322 generate_JUMP(cctx, JUMP_IF_FALSE, 0);
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5323 }
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5324 else
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5325 scope->se_u.se_if.is_if_label = -1;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5326
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5327 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5328 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5329
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5330 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5331 compile_elseif(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5332 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5333 char_u *p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5334 garray_T *instr = &cctx->ctx_instr;
20334 b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5335 int instr_count = instr->ga_len;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5336 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5337 scope_T *scope = cctx->ctx_scope;
20334 b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5338 ppconst_T ppconst;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5339
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5340 if (scope == NULL \|\| scope->se_type != IF_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5341 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5342 emsg(_(e_elseif_without_if));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5343 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5344 }
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	5345 unwind_locals(cctx, scope->se_local_count);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5346
19332 d6e8a9e80be4 patch 8.2.0224: compiling :elseif not tested yet Bram Moolenaar <Bram@vim.org> parents: 19330 diff changeset	5347 if (cctx->ctx_skip == MAYBE)
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5348 {
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5349 if (compile_jump_to_end(&scope->se_u.se_if.is_end_label,
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5350 JUMP_ALWAYS, cctx) == FAIL)
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5351 return NULL;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5352 // previous "if" or "elseif" jumps here
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5353 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5354 isn->isn_arg.jump.jump_where = instr->ga_len;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5355 }
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5356
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5357 // compile "expr"; if we know it evaluates to FALSE skip the block
20334 b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5358 CLEAR_FIELD(ppconst);
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5359 if (compile_expr1(&p, cctx, &ppconst) == FAIL)
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5360 {
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5361 clear_ppconst(&ppconst);
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5362 return NULL;
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5363 }
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5364 if (instr->ga_len == instr_count && ppconst.pp_used == 1)
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5365 {
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5366 // The expression results in a constant.
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5367 // TODO: how about nesting?
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5368 cctx->ctx_skip = tv2bool(&ppconst.pp_tv[0]) ? FALSE : TRUE;
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5369 clear_ppconst(&ppconst);
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5370 scope->se_u.se_if.is_if_label = -1;
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5371 }
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5372 else
20334 b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5373 {
b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5374 // Not a constant, generate instructions for the expression.
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5375 cctx->ctx_skip = MAYBE;
20334 b774655968b4 patch 8.2.0722: Vim9: not handling constant expression for elseif Bram Moolenaar <Bram@vim.org> parents: 20332 diff changeset	5376 if (generate_ppconst(cctx, &ppconst) == FAIL)
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5377 return NULL;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5378
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5379 // "where" is set when ":elseif", "else" or ":endif" is found
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5380 scope->se_u.se_if.is_if_label = instr->ga_len;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5381 generate_JUMP(cctx, JUMP_IF_FALSE, 0);
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5382 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5383
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5384 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5385 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5386
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5387 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5388 compile_else(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5389 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5390 char_u *p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5391 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5392 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5393 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5394
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5395 if (scope == NULL \|\| scope->se_type != IF_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5396 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5397 emsg(_(e_else_without_if));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5398 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5399 }
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	5400 unwind_locals(cctx, scope->se_local_count);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5401
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5402 // jump from previous block to the end, unless the else block is empty
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5403 if (cctx->ctx_skip == MAYBE)
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5404 {
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5405 if (compile_jump_to_end(&scope->se_u.se_if.is_end_label,
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5406 JUMP_ALWAYS, cctx) == FAIL)
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5407 return NULL;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5408 }
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5409
19332 d6e8a9e80be4 patch 8.2.0224: compiling :elseif not tested yet Bram Moolenaar <Bram@vim.org> parents: 19330 diff changeset	5410 if (cctx->ctx_skip == MAYBE)
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5411 {
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5412 if (scope->se_u.se_if.is_if_label >= 0)
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5413 {
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5414 // previous "if" or "elseif" jumps here
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5415 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5416 isn->isn_arg.jump.jump_where = instr->ga_len;
19332 d6e8a9e80be4 patch 8.2.0224: compiling :elseif not tested yet Bram Moolenaar <Bram@vim.org> parents: 19330 diff changeset	5417 scope->se_u.se_if.is_if_label = -1;
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5418 }
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5419 }
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5420
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5421 if (cctx->ctx_skip != MAYBE)
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5422 cctx->ctx_skip = !cctx->ctx_skip;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5423
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5424 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5425 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5426
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5427 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5428 compile_endif(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5429 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5430 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5431 ifscope_T *ifscope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5432 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5433 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5434
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5435 if (scope == NULL \|\| scope->se_type != IF_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5436 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5437 emsg(_(e_endif_without_if));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5438 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5439 }
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5440 ifscope = &scope->se_u.se_if;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	5441 unwind_locals(cctx, scope->se_local_count);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5442
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5443 if (scope->se_u.se_if.is_if_label >= 0)
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5444 {
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5445 // previous "if" or "elseif" jumps here
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5446 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5447 isn->isn_arg.jump.jump_where = instr->ga_len;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5448 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5449 // Fill in the "end" label in jumps at the end of the blocks.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5450 compile_fill_jump_to_end(&ifscope->is_end_label, cctx);
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	5451 cctx->ctx_skip = FALSE;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5452
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5453 drop_scope(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5454 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5455 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5456
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5457 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5458 * compile "for var in expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5459 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5460 * Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5461 * PUSHNR -1
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5462 * STORE loop-idx Set index to -1
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5463 * EVAL expr Push result of "expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5464 * top: FOR loop-idx, end Increment index, use list on bottom of stack
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5465 * - if beyond end, jump to "end"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5466 * - otherwise get item from list and push it
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5467 * STORE var Store item in "var"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5468 * ... body ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5469 * JUMP top Jump back to repeat
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5470 * end: DROP Drop the result of "expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5471 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5472 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5473 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5474 compile_for(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5475 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5476 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5477 size_t varlen;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5478 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5479 garray_T *stack = &cctx->ctx_type_stack;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5480 scope_T *scope;
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5481 lvar_T *loop_lvar; // loop iteration variable
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5482 lvar_T *var_lvar; // variable for "var"
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5483 type_T *vartype;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5484
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5485 // TODO: list of variables: "for [key, value] in dict"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5486 // parse "var"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5487 for (p = arg; eval_isnamec1(*p); ++p)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5488 ;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5489 varlen = p - arg;
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5490 var_lvar = lookup_local(arg, varlen, cctx);
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5491 if (var_lvar != NULL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5492 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5493 semsg(_("E1023: variable already defined: %s"), arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5494 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5495 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5496
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5497 // consume "in"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5498 p = skipwhite(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5499 if (STRNCMP(p, "in", 2) != 0 \|\| !VIM_ISWHITE(p[2]))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5500 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5501 emsg(_(e_missing_in));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5502 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5503 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5504 p = skipwhite(p + 2);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5505
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5506
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5507 scope = new_scope(cctx, FOR_SCOPE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5508 if (scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5509 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5510
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5511 // Reserve a variable to store the loop iteration counter.
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5512 loop_lvar = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number);
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5513 if (loop_lvar == NULL)
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5514 {
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5515 // out of memory
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5516 drop_scope(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5517 return NULL;
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5518 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5519
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5520 // Reserve a variable to store "var"
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5521 var_lvar = reserve_local(cctx, arg, varlen, FALSE, &t_any);
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5522 if (var_lvar == NULL)
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5523 {
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5524 // out of memory or used as an argument
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5525 drop_scope(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5526 return NULL;
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5527 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5528
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5529 generate_STORENR(cctx, loop_lvar->lv_idx, -1);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5530
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5531 // compile "expr", it remains on the stack until "endfor"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5532 arg = p;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5533 if (compile_expr0(&arg, cctx) == FAIL)
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5534 {
1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5535 drop_scope(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5536 return NULL;
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5537 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5538
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5539 // now we know the type of "var"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5540 vartype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5541 if (vartype->tt_type != VAR_LIST)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5542 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5543 emsg(_("E1024: need a List to iterate over"));
19866 1136ec381dd2 patch 8.2.0489: Vim9: memory leaks Bram Moolenaar <Bram@vim.org> parents: 19864 diff changeset	5544 drop_scope(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5545 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5546 }
19922 1f42c49c3d29 patch 8.2.0517: Vim9: cannot separate "func" and "func(): void" Bram Moolenaar <Bram@vim.org> parents: 19918 diff changeset	5547 if (vartype->tt_member->tt_type != VAR_ANY)
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5548 var_lvar->lv_type = vartype->tt_member;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5549
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5550 // "for_end" is set when ":endfor" is found
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5551 scope->se_u.se_for.fs_top_label = instr->ga_len;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5552
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5553 generate_FOR(cctx, loop_lvar->lv_idx);
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	5554 generate_STORE(cctx, ISN_STORE, var_lvar->lv_idx, NULL);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5555
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5556 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5557 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5558
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5559 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5560 * compile "endfor"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5561 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5562 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5563 compile_endfor(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5564 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5565 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5566 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5567 forscope_T *forscope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5568 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5569
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5570 if (scope == NULL \|\| scope->se_type != FOR_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5571 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5572 emsg(_(e_for));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5573 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5574 }
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5575 forscope = &scope->se_u.se_for;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5576 cctx->ctx_scope = scope->se_outer;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	5577 unwind_locals(cctx, scope->se_local_count);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5578
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5579 // At end of ":for" scope jump back to the FOR instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5580 generate_JUMP(cctx, JUMP_ALWAYS, forscope->fs_top_label);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5581
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5582 // Fill in the "end" label in the FOR statement so it can jump here
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5583 isn = ((isn_T *)instr->ga_data) + forscope->fs_top_label;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5584 isn->isn_arg.forloop.for_end = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5585
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5586 // Fill in the "end" label any BREAK statements
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5587 compile_fill_jump_to_end(&forscope->fs_end_label, cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5588
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5589 // Below the ":for" scope drop the "expr" list from the stack.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5590 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5591 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5592
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5593 vim_free(scope);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5594
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5595 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5596 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5597
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5598 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5599 * compile "while expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5600 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5601 * Produces instructions:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5602 * top: EVAL expr Push result of "expr"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5603 * JUMP_IF_FALSE end jump if false
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5604 * ... body ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5605 * JUMP top Jump back to repeat
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5606 * end:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5607 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5608 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5609 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5610 compile_while(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5611 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5612 char_u *p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5613 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5614 scope_T *scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5615
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5616 scope = new_scope(cctx, WHILE_SCOPE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5617 if (scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5618 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5619
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5620 scope->se_u.se_while.ws_top_label = instr->ga_len;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5621
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5622 // compile "expr"
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5623 if (compile_expr0(&p, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5624 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5625
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5626 // "while_end" is set when ":endwhile" is found
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5627 if (compile_jump_to_end(&scope->se_u.se_while.ws_end_label,
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5628 JUMP_IF_FALSE, cctx) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5629 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5630
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5631 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5632 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5633
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5634 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5635 * compile "endwhile"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5636 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5637 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5638 compile_endwhile(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5639 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5640 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5641
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5642 if (scope == NULL \|\| scope->se_type != WHILE_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5643 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5644 emsg(_(e_while));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5645 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5646 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5647 cctx->ctx_scope = scope->se_outer;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	5648 unwind_locals(cctx, scope->se_local_count);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5649
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5650 // At end of ":for" scope jump back to the FOR instruction.
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5651 generate_JUMP(cctx, JUMP_ALWAYS, scope->se_u.se_while.ws_top_label);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5652
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5653 // Fill in the "end" label in the WHILE statement so it can jump here.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5654 // And in any jumps for ":break"
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5655 compile_fill_jump_to_end(&scope->se_u.se_while.ws_end_label, cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5656
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5657 vim_free(scope);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5658
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5659 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5660 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5661
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5662 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5663 * compile "continue"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5664 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5665 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5666 compile_continue(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5667 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5668 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5669
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5670 for (;;)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5671 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5672 if (scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5673 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5674 emsg(_(e_continue));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5675 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5676 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5677 if (scope->se_type == FOR_SCOPE \|\| scope->se_type == WHILE_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5678 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5679 scope = scope->se_outer;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5680 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5681
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5682 // Jump back to the FOR or WHILE instruction.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5683 generate_JUMP(cctx, JUMP_ALWAYS,
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5684 scope->se_type == FOR_SCOPE ? scope->se_u.se_for.fs_top_label
d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5685 : scope->se_u.se_while.ws_top_label);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5686 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5687 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5688
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5689 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5690 * compile "break"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5691 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5692 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5693 compile_break(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5694 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5695 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5696 endlabel_T **el;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5697
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5698 for (;;)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5699 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5700 if (scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5701 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5702 emsg(_(e_break));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5703 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5704 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5705 if (scope->se_type == FOR_SCOPE \|\| scope->se_type == WHILE_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5706 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5707 scope = scope->se_outer;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5708 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5709
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5710 // Jump to the end of the FOR or WHILE loop.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5711 if (scope->se_type == FOR_SCOPE)
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5712 el = &scope->se_u.se_for.fs_end_label;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5713 else
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5714 el = &scope->se_u.se_while.ws_end_label;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5715 if (compile_jump_to_end(el, JUMP_ALWAYS, cctx) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5716 return FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5717
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5718 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5719 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5720
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5721 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5722 * compile "{" start of block
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5723 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5724 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5725 compile_block(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5726 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5727 if (new_scope(cctx, BLOCK_SCOPE) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5728 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5729 return skipwhite(arg + 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5730 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5731
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5732 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5733 * compile end of block: drop one scope
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5734 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5735 static void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5736 compile_endblock(cctx_T *cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5737 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5738 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5739
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5740 cctx->ctx_scope = scope->se_outer;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	5741 unwind_locals(cctx, scope->se_local_count);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5742 vim_free(scope);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5743 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5744
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5745 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5746 * compile "try"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5747 * Creates a new scope for the try-endtry, pointing to the first catch and
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5748 * finally.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5749 * Creates another scope for the "try" block itself.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5750 * TRY instruction sets up exception handling at runtime.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5751 *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5752 * "try"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5753 * TRY -> catch1, -> finally push trystack entry
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5754 * ... try block
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5755 * "throw {exception}"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5756 * EVAL {exception}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5757 * THROW create exception
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5758 * ... try block
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5759 * " catch {expr}"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5760 * JUMP -> finally
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5761 * catch1: PUSH exeception
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5762 * EVAL {expr}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5763 * MATCH
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5764 * JUMP nomatch -> catch2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5765 * CATCH remove exception
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5766 * ... catch block
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5767 * " catch"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5768 * JUMP -> finally
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5769 * catch2: CATCH remove exception
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5770 * ... catch block
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5771 * " finally"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5772 * finally:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5773 * ... finally block
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5774 * " endtry"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5775 * ENDTRY pop trystack entry, may rethrow
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5776 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5777 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5778 compile_try(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5779 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5780 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5781 scope_T *try_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5782 scope_T *scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5783
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5784 // scope that holds the jumps that go to catch/finally/endtry
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5785 try_scope = new_scope(cctx, TRY_SCOPE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5786 if (try_scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5787 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5788
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5789 // "catch" is set when the first ":catch" is found.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5790 // "finally" is set when ":finally" or ":endtry" is found
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5791 try_scope->se_u.se_try.ts_try_label = instr->ga_len;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5792 if (generate_instr(cctx, ISN_TRY) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5793 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5794
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5795 // scope for the try block itself
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5796 scope = new_scope(cctx, BLOCK_SCOPE);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5797 if (scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5798 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5799
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5800 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5801 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5802
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5803 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5804 * compile "catch {expr}"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5805 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5806 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5807 compile_catch(char_u arg, cctx_T cctx UNUSED)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5808 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5809 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5810 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5811 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5812 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5813
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5814 // end block scope from :try or :catch
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5815 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5816 compile_endblock(cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5817 scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5818
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5819 // Error if not in a :try scope
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5820 if (scope == NULL \|\| scope->se_type != TRY_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5821 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5822 emsg(_(e_catch));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5823 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5824 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5825
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5826 if (scope->se_u.se_try.ts_caught_all)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5827 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5828 emsg(_("E1033: catch unreachable after catch-all"));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5829 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5830 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5831
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5832 // Jump from end of previous block to :finally or :endtry
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5833 if (compile_jump_to_end(&scope->se_u.se_try.ts_end_label,
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5834 JUMP_ALWAYS, cctx) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5835 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5836
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5837 // End :try or :catch scope: set value in ISN_TRY instruction
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5838 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5839 if (isn->isn_arg.try.try_catch == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5840 isn->isn_arg.try.try_catch = instr->ga_len;
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5841 if (scope->se_u.se_try.ts_catch_label != 0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5842 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5843 // Previous catch without match jumps here
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5844 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5845 isn->isn_arg.jump.jump_where = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5846 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5847
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5848 p = skipwhite(arg);
20059 de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	5849 if (ends_excmd2(arg, p))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5850 {
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5851 scope->se_u.se_try.ts_caught_all = TRUE;
d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5852 scope->se_u.se_try.ts_catch_label = 0;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5853 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5854 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5855 {
19316 17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5856 char_u *end;
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5857 char_u *pat;
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5858 char_u *tofree = NULL;
19892 5feb426d2ea1 patch 8.2.0502: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19884 diff changeset	5859 int dropped = 0;
19388 3a579cadceb6 patch 8.2.0252: Windows compiler warns for using size_t Bram Moolenaar <Bram@vim.org> parents: 19342 diff changeset	5860 int len;
19316 17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5861
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5862 // Push v:exception, push {expr} and MATCH
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5863 generate_instr_type(cctx, ISN_PUSHEXC, &t_string);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5864
19892 5feb426d2ea1 patch 8.2.0502: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19884 diff changeset	5865 end = skip_regexp_ex(p + 1, *p, TRUE, &tofree, &dropped);
19316 17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5866 if (end != p)
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5867 {
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5868 semsg(_("E1067: Separator mismatch: %s"), p);
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5869 vim_free(tofree);
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5870 return FAIL;
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5871 }
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5872 if (tofree == NULL)
19388 3a579cadceb6 patch 8.2.0252: Windows compiler warns for using size_t Bram Moolenaar <Bram@vim.org> parents: 19342 diff changeset	5873 len = (int)(end - (p + 1));
19316 17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5874 else
19892 5feb426d2ea1 patch 8.2.0502: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19884 diff changeset	5875 len = (int)(end - tofree);
5feb426d2ea1 patch 8.2.0502: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19884 diff changeset	5876 pat = vim_strnsave(tofree == NULL ? p + 1 : tofree, len);
19316 17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5877 vim_free(tofree);
19892 5feb426d2ea1 patch 8.2.0502: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19884 diff changeset	5878 p += len + 2 + dropped;
19316 17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5879 if (pat == NULL)
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5880 return FAIL;
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5881 if (generate_PUSHS(cctx, pat) == FAIL)
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5882 return FAIL;
17dc6282f370 patch 8.2.0216: several Vim9 instructions are not tested Bram Moolenaar <Bram@vim.org> parents: 19304 diff changeset	5883
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5884 if (generate_COMPARE(cctx, EXPR_MATCH, FALSE) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5885 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5886
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5887 scope->se_u.se_try.ts_catch_label = instr->ga_len;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5888 if (generate_JUMP(cctx, JUMP_IF_FALSE, 0) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5889 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5890 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5891
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5892 if (generate_instr(cctx, ISN_CATCH) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5893 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5894
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5895 if (new_scope(cctx, BLOCK_SCOPE) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5896 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5897 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5898 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5899
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5900 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5901 compile_finally(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5902 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5903 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5904 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5905 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5906
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5907 // end block scope from :try or :catch
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5908 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5909 compile_endblock(cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5910 scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5911
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5912 // Error if not in a :try scope
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5913 if (scope == NULL \|\| scope->se_type != TRY_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5914 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5915 emsg(_(e_finally));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5916 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5917 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5918
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5919 // End :catch or :finally scope: set value in ISN_TRY instruction
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5920 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5921 if (isn->isn_arg.try.try_finally != 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5922 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5923 emsg(_(e_finally_dup));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5924 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5925 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5926
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5927 // Fill in the "end" label in jumps at the end of the blocks.
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5928 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, cctx);
d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5929
19894 ea4f8e789627 patch 8.2.0503: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19892 diff changeset	5930 isn->isn_arg.try.try_finally = instr->ga_len;
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5931 if (scope->se_u.se_try.ts_catch_label != 0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5932 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5933 // Previous catch without match jumps here
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5934 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5935 isn->isn_arg.jump.jump_where = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5936 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5937
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5938 // TODO: set index in ts_finally_label jumps
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5939
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5940 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5941 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5942
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5943 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5944 compile_endtry(char_u arg, cctx_T cctx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5945 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5946 scope_T *scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5947 garray_T *instr = &cctx->ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5948 isn_T *isn;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5949
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5950 // end block scope from :catch or :finally
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5951 if (scope != NULL && scope->se_type == BLOCK_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5952 compile_endblock(cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5953 scope = cctx->ctx_scope;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5954
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5955 // Error if not in a :try scope
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5956 if (scope == NULL \|\| scope->se_type != TRY_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5957 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5958 if (scope == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5959 emsg(_(e_no_endtry));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5960 else if (scope->se_type == WHILE_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5961 emsg(_(e_endwhile));
19213 b18437efabac patch 8.2.0165: Coverity warning for using NULL pointer Bram Moolenaar <Bram@vim.org> parents: 19193 diff changeset	5962 else if (scope->se_type == FOR_SCOPE)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5963 emsg(_(e_endfor));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5964 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5965 emsg(_(e_endif));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5966 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5967 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5968
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5969 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5970 if (isn->isn_arg.try.try_catch == 0 && isn->isn_arg.try.try_finally == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5971 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5972 emsg(_("E1032: missing :catch or :finally"));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5973 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5974 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5975
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5976 // Fill in the "end" label in jumps at the end of the blocks, if not done
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5977 // by ":finally".
19229 d776967d0f0d patch 8.2.0173: build fails with old compiler Bram Moolenaar <Bram@vim.org> parents: 19223 diff changeset	5978 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5979
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5980 // End :catch or :finally scope: set value in ISN_TRY instruction
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5981 if (isn->isn_arg.try.try_finally == 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5982 isn->isn_arg.try.try_finally = instr->ga_len;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5983 compile_endblock(cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5984
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5985 if (generate_instr(cctx, ISN_ENDTRY) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5986 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5987 return arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5988 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5989
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5990 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5991 * compile "throw {expr}"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5992 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5993 static char_u *
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5994 compile_throw(char_u arg, cctx_T cctx UNUSED)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5995 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5996 char_u *p = skipwhite(arg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5997
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	5998 if (compile_expr0(&p, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5999 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6000 if (may_generate_2STRING(-1, cctx) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6001 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6002 if (generate_instr_drop(cctx, ISN_THROW, 1) == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6003 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6004
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6005 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6006 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6007
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6008 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6009 * compile "echo expr"
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6010 * compile "echomsg expr"
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6011 * compile "echoerr expr"
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6012 * compile "execute expr"
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6013 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6014 static char_u *
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6015 compile_mult_expr(char_u arg, int cmdidx, cctx_T cctx)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6016 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6017 char_u *p = arg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6018 int count = 0;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6019
19528 3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	6020 for (;;)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6021 {
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	6022 if (compile_expr0(&p, cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6023 return NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6024 ++count;
19528 3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	6025 p = skipwhite(p);
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	6026 if (ends_excmd(*p))
3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	6027 break;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6028 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6029
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6030 if (cmdidx == CMD_echo \|\| cmdidx == CMD_echon)
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6031 generate_ECHO(cctx, cmdidx == CMD_echo, count);
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6032 else if (cmdidx == CMD_execute)
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6033 generate_MULT_EXPR(cctx, ISN_EXECUTE, count);
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6034 else if (cmdidx == CMD_echomsg)
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6035 generate_MULT_EXPR(cctx, ISN_ECHOMSG, count);
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6036 else
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6037 generate_MULT_EXPR(cctx, ISN_ECHOERR, count);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6038 return p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6039 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6040
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6041 /*
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6042 * A command that is not compiled, execute with legacy code.
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6043 */
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6044 static char_u *
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6045 compile_exec(char_u line, exarg_T eap, cctx_T *cctx)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6046 {
20172 1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6047 char_u *p;
20174 72b437855299 patch 8.2.0642: Vim9: using invalid index Bram Moolenaar <Bram@vim.org> parents: 20172 diff changeset	6048 int has_expr = FALSE;
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6049
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6050 if (cctx->ctx_skip == TRUE)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6051 goto theend;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6052
20174 72b437855299 patch 8.2.0642: Vim9: using invalid index Bram Moolenaar <Bram@vim.org> parents: 20172 diff changeset	6053 if (eap->cmdidx >= 0 && eap->cmdidx < CMD_SIZE)
72b437855299 patch 8.2.0642: Vim9: using invalid index Bram Moolenaar <Bram@vim.org> parents: 20172 diff changeset	6054 has_expr = (excmd_get_argt(eap->cmdidx) & (EX_XFILE \| EX_EXPAND));
20172 1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6055 if (eap->cmdidx == CMD_syntax && STRNCMP(eap->arg, "include ", 8) == 0)
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6056 {
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6057 // expand filename in "syntax include [@group] filename"
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6058 has_expr = TRUE;
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6059 eap->arg = skipwhite(eap->arg + 7);
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6060 if (*eap->arg == '@')
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6061 eap->arg = skiptowhite(eap->arg);
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6062 }
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6063
1d84eaed0ec8 patch 8.2.0641: Vim9: not expanded in :hardcopy and syn-include Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	6064 if (has_expr && (p = (char_u )strstr((char )eap->arg, "`=")) != NULL)
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6065 {
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6066 int count = 0;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6067 char_u *start = skipwhite(line);
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6068
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6069 // :cmd xxx`=expr1`yyy`=expr2`zzz
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6070 // PUSHS ":cmd xxx"
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6071 // eval expr1
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6072 // PUSHS "yyy"
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6073 // eval expr2
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6074 // PUSHS "zzz"
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6075 // EXECCONCAT 5
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6076 for (;;)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6077 {
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6078 if (p > start)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6079 {
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6080 generate_PUSHS(cctx, vim_strnsave(start, (int)(p - start)));
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6081 ++count;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6082 }
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6083 p += 2;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	6084 if (compile_expr0(&p, cctx) == FAIL)
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6085 return NULL;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6086 may_generate_2STRING(-1, cctx);
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6087 ++count;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6088 p = skipwhite(p);
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6089 if (*p != '`')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6090 {
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6091 emsg(_("E1083: missing backtick"));
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6092 return NULL;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6093 }
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6094 start = p + 1;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6095
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6096 p = (char_u )strstr((char )start, "`=");
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6097 if (p == NULL)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6098 {
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6099 if (*skipwhite(start) != NUL)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6100 {
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6101 generate_PUSHS(cctx, vim_strsave(start));
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6102 ++count;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6103 }
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6104 break;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6105 }
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6106 }
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6107 generate_EXECCONCAT(cctx, count);
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6108 }
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6109 else
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6110 generate_EXEC(cctx, line);
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6111
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6112 theend:
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6113 return (char_u *)"";
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6114 }
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6115
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6116 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6117 * After ex_function() has collected all the function lines: parse and compile
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6118 * the lines into instructions.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6119 * Adds the function to "def_functions".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6120 * When "set_return_type" is set then set ufunc->uf_ret_type to the type of the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6121 * return statement (used for lambda).
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	6122 * "outer_cctx" is set for a nested function.
19864 8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6123 * This can be used recursively through compile_lambda(), which may reallocate
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6124 * "def_functions".
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6125 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6126 void
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	6127 compile_def_function(ufunc_T ufunc, int set_return_type, cctx_T outer_cctx)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6128 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6129 char_u *line = NULL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6130 char_u *p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6131 char *errormsg = NULL; // error message
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6132 int had_return = FALSE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6133 cctx_T cctx;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6134 garray_T *instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6135 int called_emsg_before = called_emsg;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6136 int ret = FAIL;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6137 sctx_T save_current_sctx = current_sctx;
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6138 int emsg_before = called_emsg;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6139
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6140 {
19864 8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6141 dfunc_T *dfunc; // may be invalidated by compile_lambda()
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6142
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6143 if (ufunc->uf_dfunc_idx >= 0)
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6144 {
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6145 // Redefining a function that was compiled before.
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6146 dfunc = ((dfunc_T *)def_functions.ga_data) + ufunc->uf_dfunc_idx;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6147
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6148 // Free old instructions.
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6149 delete_def_function_contents(dfunc);
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6150 }
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6151 else
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6152 {
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6153 // Add the function to "def_functions".
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6154 if (ga_grow(&def_functions, 1) == FAIL)
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6155 return;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6156 dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len;
20007 aadd1cae2ff5 patch 8.2.0559: clearing a struct is verbose Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	6157 CLEAR_POINTER(dfunc);
19864 8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6158 dfunc->df_idx = def_functions.ga_len;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6159 ufunc->uf_dfunc_idx = dfunc->df_idx;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6160 dfunc->df_ufunc = ufunc;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6161 ++def_functions.ga_len;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6162 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6163 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6164
20007 aadd1cae2ff5 patch 8.2.0559: clearing a struct is verbose Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	6165 CLEAR_FIELD(cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6166 cctx.ctx_ufunc = ufunc;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6167 cctx.ctx_lnum = -1;
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	6168 cctx.ctx_outer = outer_cctx;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6169 ga_init2(&cctx.ctx_locals, sizeof(lvar_T), 10);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6170 ga_init2(&cctx.ctx_type_stack, sizeof(type_T *), 50);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6171 ga_init2(&cctx.ctx_imports, sizeof(imported_T), 10);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6172 cctx.ctx_type_list = &ufunc->uf_type_list;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6173 ga_init2(&cctx.ctx_instr, sizeof(isn_T), 50);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6174 instr = &cctx.ctx_instr;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6175
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6176 // Most modern script version.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6177 current_sctx.sc_version = SCRIPT_VERSION_VIM9;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6178
19328 e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6179 if (ufunc->uf_def_args.ga_len > 0)
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6180 {
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6181 int count = ufunc->uf_def_args.ga_len;
19946 8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6182 int first_def_arg = ufunc->uf_args.ga_len - count;
19328 e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6183 int i;
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6184 char_u *arg;
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6185 int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0);
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6186
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6187 // Produce instructions for the default values of optional arguments.
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6188 // Store the instruction index in uf_def_arg_idx[] so that we know
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6189 // where to start when the function is called, depending on the number
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6190 // of arguments.
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6191 ufunc->uf_def_arg_idx = ALLOC_CLEAR_MULT(int, count + 1);
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6192 if (ufunc->uf_def_arg_idx == NULL)
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6193 goto erret;
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6194 for (i = 0; i < count; ++i)
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6195 {
19946 8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6196 garray_T *stack = &cctx.ctx_type_stack;
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6197 type_T *val_type;
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6198 int arg_idx = first_def_arg + i;
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6199
19328 e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6200 ufunc->uf_def_arg_idx[i] = instr->ga_len;
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6201 arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i];
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	6202 if (compile_expr0(&arg, &cctx) == FAIL)
19946 8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6203 goto erret;
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6204
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6205 // If no type specified use the type of the default value.
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6206 // Otherwise check that the default value type matches the
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6207 // specified type.
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6208 val_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6209 if (ufunc->uf_arg_types[arg_idx] == &t_unknown)
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6210 ufunc->uf_arg_types[arg_idx] = val_type;
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6211 else if (check_type(ufunc->uf_arg_types[i], val_type, FALSE)
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6212 == FAIL)
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6213 {
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6214 arg_type_mismatch(ufunc->uf_arg_types[arg_idx], val_type,
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6215 arg_idx + 1);
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6216 goto erret;
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6217 }
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6218
8466e62a2481 patch 8.2.0529: Vim9: function argument with default not checked Bram Moolenaar <Bram@vim.org> parents: 19944 diff changeset	6219 if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL)
19328 e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6220 goto erret;
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6221 }
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6222 ufunc->uf_def_arg_idx[count] = instr->ga_len;
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6223 }
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6224
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6225 /*
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6226 * Loop over all the lines of the function and generate instructions.
e99e6d794597 patch 8.2.0222: Vim9: optional function arguments don't work yet Bram Moolenaar <Bram@vim.org> parents: 19316 diff changeset	6227 */
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6228 for (;;)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6229 {
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6230 exarg_T ea;
20055 686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6231 int is_ex_command = FALSE;
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6232
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6233 // Bail out on the first error to avoid a flood of errors and report
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6234 // the right line number when inside try/catch.
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6235 if (emsg_before != called_emsg)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6236 goto erret;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6237
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6238 if (line != NULL && *line == '\|')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6239 // the line continues after a '\|'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6240 ++line;
20059 de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	6241 else if (line != NULL && *line != NUL
de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	6242 && !(*line == '#' && (line == cctx.ctx_line_start
de756b3f4dee patch 8.2.0585: Vim9: # comment not recognized after :vim9script Bram Moolenaar <Bram@vim.org> parents: 20055 diff changeset	6243 \|\| VIM_ISWHITE(line[-1]))))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6244 {
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6245 semsg(_("E488: Trailing characters: %s"), line);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6246 goto erret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6247 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6248 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6249 {
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	6250 line = next_line_from_context(&cctx);
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19993 diff changeset	6251 if (cctx.ctx_lnum >= ufunc->uf_lines.ga_len)
20055 686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6252 // beyond the last line
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6253 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6254 }
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6255 emsg_before = called_emsg;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6256
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6257 had_return = FALSE;
20007 aadd1cae2ff5 patch 8.2.0559: clearing a struct is verbose Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	6258 CLEAR_FIELD(ea);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6259 ea.cmdlinep = &line;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6260 ea.cmd = skipwhite(line);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6261
20055 686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6262 // Some things can be recognized by the first character.
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6263 switch (*ea.cmd)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6264 {
20055 686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6265 case '#':
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6266 // "#" starts a comment, but "#{" does not.
20055 686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6267 if (ea.cmd[1] != '{')
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6268 {
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6269 line = (char_u *)"";
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6270 continue;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6271 }
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6272 break;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6273
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6274 case '}':
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6275 {
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6276 // "}" ends a block scope
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6277 scopetype_T stype = cctx.ctx_scope == NULL
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6278 ? NO_SCOPE : cctx.ctx_scope->se_type;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6279
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6280 if (stype == BLOCK_SCOPE)
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6281 {
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6282 compile_endblock(&cctx);
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6283 line = ea.cmd;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6284 }
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6285 else
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6286 {
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6287 emsg(_("E1025: using } outside of a block scope"));
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6288 goto erret;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6289 }
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6290 if (line != NULL)
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6291 line = skipwhite(ea.cmd + 1);
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6292 continue;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6293 }
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6294
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6295 case '{':
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6296 // "{" starts a block scope
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6297 // "{'a': 1}->func() is something else
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6298 if (ends_excmd(*skipwhite(ea.cmd + 1)))
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6299 {
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6300 line = compile_block(ea.cmd, &cctx);
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6301 continue;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6302 }
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6303 break;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6304
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6305 case ':':
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6306 is_ex_command = TRUE;
686deb5959c2 patch 8.2.0583: Vim9: # comment not recognized in :def function Bram Moolenaar <Bram@vim.org> parents: 20045 diff changeset	6307 break;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6308 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6309
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6310 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6311 * COMMAND MODIFIERS
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6312 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6313 if (parse_command_modifiers(&ea, &errormsg, FALSE) == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6314 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6315 if (errormsg != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6316 goto erret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6317 // empty line or comment
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6318 line = (char_u *)"";
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6319 continue;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6320 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6321
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6322 // Skip ":call" to get to the function name.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6323 if (checkforcmd(&ea.cmd, "call", 3))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6324 ea.cmd = skipwhite(ea.cmd);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6325
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6326 if (!is_ex_command)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6327 {
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6328 // Assuming the command starts with a variable or function name,
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6329 // find what follows. Also "&opt = val", "$ENV = val" and "@r =
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6330 // val".
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6331 p = (ea.cmd == '&' \|\| ea.cmd == '$' \|\| *ea.cmd == '@')
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6332 ? ea.cmd + 1 : ea.cmd;
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	6333 p = to_name_end(p, TRUE);
19862 846fbbacce3a patch 8.2.0487: Vim9: compiling not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19860 diff changeset	6334 if (p > ea.cmd && *p != NUL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6335 {
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6336 int oplen;
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6337 int heredoc;
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6338
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6339 oplen = assignment_len(skipwhite(p), &heredoc);
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6340 if (oplen > 0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6341 {
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6342 // Recognize an assignment if we recognize the variable
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6343 // name:
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6344 // "g:var = expr"
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	6345 // "local = expr" where "local" is a local var.
ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	6346 // "script = expr" where "script" is a script-local var.
ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19579 diff changeset	6347 // "import = expr" where "import" is an imported var
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6348 // "&opt = expr"
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6349 // "$ENV = expr"
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6350 // "@r = expr"
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6351 if (*ea.cmd == '&'
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6352 \|\| *ea.cmd == '$'
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6353 \|\| *ea.cmd == '@'
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6354 \|\| ((p - ea.cmd) > 2 && ea.cmd[1] == ':')
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	6355 \|\| lookup_local(ea.cmd, p - ea.cmd, &cctx) != NULL
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6356 \|\| lookup_script(ea.cmd, p - ea.cmd) == OK
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6357 \|\| find_imported(ea.cmd, p - ea.cmd, &cctx) != NULL)
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6358 {
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6359 line = compile_assignment(ea.cmd, &ea, CMD_SIZE, &cctx);
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6360 if (line == NULL)
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6361 goto erret;
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6362 continue;
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6363 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6364 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6365 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6366 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6367
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6368 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6369 * COMMAND after range
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6370 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6371 ea.cmd = skip_range(ea.cmd, NULL);
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	6372 p = find_ex_command(&ea, NULL, is_ex_command ? NULL
2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	6373 : (void ()(char_u , size_t, cctx_T ))lookup_local,
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19467 diff changeset	6374 &cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6375
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6376 if (p == ea.cmd && ea.cmdidx != CMD_SIZE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6377 {
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6378 if (cctx.ctx_skip == TRUE)
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6379 {
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6380 line += STRLEN(line);
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6381 continue;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6382 }
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6383
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6384 // Expression or function call.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6385 if (ea.cmdidx == CMD_eval)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6386 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6387 p = ea.cmd;
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20324 diff changeset	6388 if (compile_expr0(&p, &cctx) == FAIL)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6389 goto erret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6390
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6391 // drop the return value
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6392 generate_instr_drop(&cctx, ISN_DROP, 1);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6393 line = p;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6394 continue;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6395 }
19894 ea4f8e789627 patch 8.2.0503: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19892 diff changeset	6396 // CMD_let cannot happen, compile_assignment() above is used
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6397 iemsg("Command from find_ex_command() not handled");
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6398 goto erret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6399 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6400
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6401 p = skipwhite(p);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6402
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6403 if (cctx.ctx_skip == TRUE
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6404 && ea.cmdidx != CMD_elseif
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6405 && ea.cmdidx != CMD_else
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6406 && ea.cmdidx != CMD_endif)
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6407 {
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6408 line = (char_u *)"";
19253 a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6409 continue;
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6410 }
a8d2d3c8f0b3 patch 8.2.0185: Vim9 script: cannot use "if has()" to skip lines Bram Moolenaar <Bram@vim.org> parents: 19229 diff changeset	6411
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6412 switch (ea.cmdidx)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6413 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6414 case CMD_def:
20279 49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	6415 ea.arg = p;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	6416 line = compile_nested_function(&ea, &cctx);
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	6417 break;
49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	6418
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6419 case CMD_function:
20279 49b50843e725 patch 8.2.0695: Vim9: cannot define a function inside a function Bram Moolenaar <Bram@vim.org> parents: 20275 diff changeset	6420 emsg(_("E1086: Cannot use :function inside :def"));
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6421 goto erret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6422
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6423 case CMD_return:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6424 line = compile_return(p, set_return_type, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6425 had_return = TRUE;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6426 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6427
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6428 case CMD_let:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6429 case CMD_const:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6430 line = compile_assignment(p, &ea, ea.cmdidx, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6431 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6432
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6433 case CMD_unlet:
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6434 case CMD_unlockvar:
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6435 case CMD_lockvar:
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6436 line = compile_unletlock(p, &ea, &cctx);
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6437 break;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6438
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6439 case CMD_import:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6440 line = compile_import(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6441 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6442
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6443 case CMD_if:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6444 line = compile_if(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6445 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6446 case CMD_elseif:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6447 line = compile_elseif(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6448 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6449 case CMD_else:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6450 line = compile_else(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6451 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6452 case CMD_endif:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6453 line = compile_endif(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6454 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6455
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6456 case CMD_while:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6457 line = compile_while(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6458 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6459 case CMD_endwhile:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6460 line = compile_endwhile(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6461 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6462
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6463 case CMD_for:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6464 line = compile_for(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6465 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6466 case CMD_endfor:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6467 line = compile_endfor(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6468 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6469 case CMD_continue:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6470 line = compile_continue(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6471 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6472 case CMD_break:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6473 line = compile_break(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6474 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6475
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6476 case CMD_try:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6477 line = compile_try(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6478 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6479 case CMD_catch:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6480 line = compile_catch(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6481 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6482 case CMD_finally:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6483 line = compile_finally(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6484 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6485 case CMD_endtry:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6486 line = compile_endtry(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6487 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6488 case CMD_throw:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6489 line = compile_throw(p, &cctx);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6490 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6491
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6492 case CMD_echo:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6493 case CMD_echon:
19528 3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	6494 case CMD_execute:
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6495 case CMD_echomsg:
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6496 case CMD_echoerr:
fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6497 line = compile_mult_expr(p, ea.cmdidx, &cctx);
19528 3b026343f398 patch 8.2.0321: Vim9: ":execute" does not work yet Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	6498 break;
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6499
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6500 default:
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6501 // TODO: other commands with an expression argument
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6502 // Not recognized, execute with do_cmdline_cmd().
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6503 ea.arg = p;
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6504 line = compile_exec(line, &ea, &cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6505 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6506 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6507 if (line == NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6508 goto erret;
19894 ea4f8e789627 patch 8.2.0503: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19892 diff changeset	6509 line = skipwhite(line);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6510
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6511 if (cctx.ctx_type_stack.ga_len < 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6512 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6513 iemsg("Type stack underflow");
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6514 goto erret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6515 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6516 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6517
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6518 if (cctx.ctx_scope != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6519 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6520 if (cctx.ctx_scope->se_type == IF_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6521 emsg(_(e_endif));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6522 else if (cctx.ctx_scope->se_type == WHILE_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6523 emsg(_(e_endwhile));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6524 else if (cctx.ctx_scope->se_type == FOR_SCOPE)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6525 emsg(_(e_endfor));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6526 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6527 emsg(_("E1026: Missing }"));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6528 goto erret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6529 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6530
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6531 if (!had_return)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6532 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6533 if (ufunc->uf_ret_type->tt_type != VAR_VOID)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6534 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6535 emsg(_("E1027: Missing return statement"));
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6536 goto erret;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6537 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6538
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6539 // Return zero if there is no return at the end.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6540 generate_PUSHNR(&cctx, 0);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6541 generate_instr(&cctx, ISN_RETURN);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6542 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6543
19864 8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6544 {
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6545 dfunc_T dfunc = ((dfunc_T )def_functions.ga_data)
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6546 + ufunc->uf_dfunc_idx;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6547 dfunc->df_deleted = FALSE;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6548 dfunc->df_instr = instr->ga_data;
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6549 dfunc->df_instr_count = instr->ga_len;
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	6550 dfunc->df_varcount = cctx.ctx_locals_count;
20247 e46e72aaff74 patch 8.2.0679: Vim9: incomplete support for closures Bram Moolenaar <Bram@vim.org> parents: 20244 diff changeset	6551 dfunc->df_closure_count = cctx.ctx_closure_count;
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	6552 if (cctx.ctx_outer_used)
23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	6553 ufunc->uf_flags \|= FC_CLOSURE;
19864 8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6554 }
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6555
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6556 {
19914 6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	6557 int varargs = ufunc->uf_va_name != NULL;
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6558 int argcount = ufunc->uf_args.ga_len;
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6559
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6560 // Create a type for the function, with the return type and any
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6561 // argument types.
19914 6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	6562 // A vararg is included in uf_args.ga_len but not in uf_arg_types.
6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	6563 // The type is included in "tt_args".
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6564 if (argcount > 0 \|\| varargs)
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6565 {
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6566 ufunc->uf_func_type = alloc_func_type(ufunc->uf_ret_type,
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6567 argcount, &ufunc->uf_type_list);
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6568 // Add argument types to the function type.
19914 6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	6569 if (func_type_add_arg_types(ufunc->uf_func_type,
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6570 argcount + varargs,
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6571 &ufunc->uf_type_list) == FAIL)
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6572 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6573 ret = FAIL;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6574 goto erret;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6575 }
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6576 ufunc->uf_func_type->tt_argcount = argcount + varargs;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6577 ufunc->uf_func_type->tt_min_argcount =
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6578 argcount - ufunc->uf_def_args.ga_len;
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6579 if (ufunc->uf_arg_types == NULL)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6580 {
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6581 int i;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6582
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6583 // lambda does not have argument types.
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6584 for (i = 0; i < argcount; ++i)
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6585 ufunc->uf_func_type->tt_args[i] = &t_any;
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6586 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6587 else
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6588 mch_memmove(ufunc->uf_func_type->tt_args,
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6589 ufunc->uf_arg_types, sizeof(type_T ) argcount);
19914 6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	6590 if (varargs)
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6591 {
19914 6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	6592 ufunc->uf_func_type->tt_args[argcount] =
6babfd2d15e9 patch 8.2.0513: reading past allocate memory when using varargs Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	6593 ufunc->uf_va_type == NULL ? &t_any : ufunc->uf_va_type;
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6594 ufunc->uf_func_type->tt_flags = TTFLAG_VARARGS;
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6595 }
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6596 }
19975 4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6597 else
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6598 // No arguments, can use a predefined type.
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6599 ufunc->uf_func_type = get_func_type(ufunc->uf_ret_type,
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6600 argcount, &ufunc->uf_type_list);
4e8e0ce576af patch 8.2.0543: Vim9: function with varargs does not work properly Bram Moolenaar <Bram@vim.org> parents: 19964 diff changeset	6601
19912 d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6602 }
d4fa9db88d16 patch 8.2.0512: Vim9: no optional arguments in func type Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	6603
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6604 ret = OK;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6605
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6606 erret:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6607 if (ret == FAIL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6608 {
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6609 int idx;
19864 8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6610 dfunc_T dfunc = ((dfunc_T )def_functions.ga_data)
8288884fdfe1 patch 8.2.0488: Vim9: compiling can break when using a lambda inside :def Bram Moolenaar <Bram@vim.org> parents: 19862 diff changeset	6611 + ufunc->uf_dfunc_idx;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6612
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6613 for (idx = 0; idx < instr->ga_len; ++idx)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6614 delete_instr(((isn_T *)instr->ga_data) + idx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6615 ga_clear(instr);
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6616
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6617 ufunc->uf_dfunc_idx = -1;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6618 if (!dfunc->df_deleted)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6619 --def_functions.ga_len;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6620
19896 92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	6621 while (cctx.ctx_scope != NULL)
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	6622 drop_scope(&cctx);
92177b596695 patch 8.2.0504: Vim9: leaking scope memory when compilation fails Bram Moolenaar <Bram@vim.org> parents: 19894 diff changeset	6623
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6624 // Don't execute this function body.
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6625 ga_clear_strings(&ufunc->uf_lines);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6626
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6627 if (errormsg != NULL)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6628 emsg(errormsg);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6629 else if (called_emsg == called_emsg_before)
19411 bc880a130120 patch 8.2.0263: a few new Vim9 messages are not localized Bram Moolenaar <Bram@vim.org> parents: 19392 diff changeset	6630 emsg(_("E1028: compile_def_function failed"));
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6631 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6632
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6633 current_sctx = save_current_sctx;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6634 free_imported(&cctx);
20239 2135b4641680 patch 8.2.0675: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	6635 free_locals(&cctx);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6636 ga_clear(&cctx.ctx_type_stack);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6637 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6638
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6639 /*
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6640 * Delete an instruction, free what it contains.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6641 */
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6642 void
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6643 delete_instr(isn_T *isn)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6644 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6645 switch (isn->isn_type)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6646 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6647 case ISN_EXEC:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6648 case ISN_LOADENV:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6649 case ISN_LOADG:
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	6650 case ISN_LOADB:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	6651 case ISN_LOADW:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	6652 case ISN_LOADT:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6653 case ISN_LOADOPT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6654 case ISN_MEMBER:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6655 case ISN_PUSHEXC:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6656 case ISN_PUSHS:
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	6657 case ISN_STOREENV:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6658 case ISN_STOREG:
20089 7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	6659 case ISN_STOREB:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	6660 case ISN_STOREW:
7fc5d62fe2a5 patch 8.2.0600: Vim9: cannot read or write w:, t: and b: variables Bram Moolenaar <Bram@vim.org> parents: 20079 diff changeset	6661 case ISN_STORET:
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6662 case ISN_PUSHFUNC:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6663 vim_free(isn->isn_arg.string);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6664 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6665
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6666 case ISN_LOADS:
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	6667 case ISN_STORES:
9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	6668 vim_free(isn->isn_arg.loadstore.ls_name);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6669 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6670
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6671 case ISN_UNLET:
20099 058b41f85bcb patch 8.2.0605: Vim9: cannot unlet an environment variable Bram Moolenaar <Bram@vim.org> parents: 20091 diff changeset	6672 case ISN_UNLETENV:
20091 a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6673 vim_free(isn->isn_arg.unlet.ul_name);
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6674 break;
a64c16ff98b8 patch 8.2.0601: Vim9: :unlet is not compiled Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	6675
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6676 case ISN_STOREOPT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6677 vim_free(isn->isn_arg.storeopt.so_name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6678 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6679
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6680 case ISN_PUSHBLOB: // push blob isn_arg.blob
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6681 blob_unref(isn->isn_arg.blob);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6682 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6683
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6684 case ISN_PUSHJOB:
19562 6b7719b8f9b9 patch 8.2.0338: build failure without the channel feature Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	6685 #ifdef FEAT_JOB_CHANNEL
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6686 job_unref(isn->isn_arg.job);
19562 6b7719b8f9b9 patch 8.2.0338: build failure without the channel feature Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	6687 #endif
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6688 break;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6689
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6690 case ISN_PUSHCHANNEL:
19562 6b7719b8f9b9 patch 8.2.0338: build failure without the channel feature Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	6691 #ifdef FEAT_JOB_CHANNEL
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6692 channel_unref(isn->isn_arg.channel);
19562 6b7719b8f9b9 patch 8.2.0338: build failure without the channel feature Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	6693 #endif
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6694 break;
8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19530 diff changeset	6695
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6696 case ISN_UCALL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6697 vim_free(isn->isn_arg.ufunc.cuf_name);
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6698 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6699
20283 934657e365e5 patch 8.2.0697: Vim9: memory leak when using nested function Bram Moolenaar <Bram@vim.org> parents: 20281 diff changeset	6700 case ISN_FUNCREF:
934657e365e5 patch 8.2.0697: Vim9: memory leak when using nested function Bram Moolenaar <Bram@vim.org> parents: 20281 diff changeset	6701 {
934657e365e5 patch 8.2.0697: Vim9: memory leak when using nested function Bram Moolenaar <Bram@vim.org> parents: 20281 diff changeset	6702 dfunc_T dfunc = ((dfunc_T )def_functions.ga_data)
934657e365e5 patch 8.2.0697: Vim9: memory leak when using nested function Bram Moolenaar <Bram@vim.org> parents: 20281 diff changeset	6703 + isn->isn_arg.funcref.fr_func;
934657e365e5 patch 8.2.0697: Vim9: memory leak when using nested function Bram Moolenaar <Bram@vim.org> parents: 20281 diff changeset	6704 func_ptr_unref(dfunc->df_ufunc);
934657e365e5 patch 8.2.0697: Vim9: memory leak when using nested function Bram Moolenaar <Bram@vim.org> parents: 20281 diff changeset	6705 }
934657e365e5 patch 8.2.0697: Vim9: memory leak when using nested function Bram Moolenaar <Bram@vim.org> parents: 20281 diff changeset	6706 break;
934657e365e5 patch 8.2.0697: Vim9: memory leak when using nested function Bram Moolenaar <Bram@vim.org> parents: 20281 diff changeset	6707
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6708 case ISN_2BOOL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6709 case ISN_2STRING:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6710 case ISN_ADDBLOB:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6711 case ISN_ADDLIST:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6712 case ISN_BCALL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6713 case ISN_CATCH:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6714 case ISN_CHECKNR:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6715 case ISN_CHECKTYPE:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6716 case ISN_COMPAREANY:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6717 case ISN_COMPAREBLOB:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6718 case ISN_COMPAREBOOL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6719 case ISN_COMPAREDICT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6720 case ISN_COMPAREFLOAT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6721 case ISN_COMPAREFUNC:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6722 case ISN_COMPARELIST:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6723 case ISN_COMPARENR:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6724 case ISN_COMPARESPECIAL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6725 case ISN_COMPARESTRING:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6726 case ISN_CONCAT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6727 case ISN_DCALL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6728 case ISN_DROP:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6729 case ISN_ECHO:
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6730 case ISN_ECHOERR:
20142 fe8d0a4344df patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script Bram Moolenaar <Bram@vim.org> parents: 20140 diff changeset	6731 case ISN_ECHOMSG:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6732 case ISN_ENDTRY:
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6733 case ISN_EXECCONCAT:
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20142 diff changeset	6734 case ISN_EXECUTE:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6735 case ISN_FOR:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6736 case ISN_INDEX:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6737 case ISN_JUMP:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6738 case ISN_LOAD:
20244 23d75968ca5e patch 8.2.0677: Vim9: no support for closures Bram Moolenaar <Bram@vim.org> parents: 20239 diff changeset	6739 case ISN_LOADOUTER:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6740 case ISN_LOADSCRIPT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6741 case ISN_LOADREG:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6742 case ISN_LOADV:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6743 case ISN_NEGATENR:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6744 case ISN_NEWDICT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6745 case ISN_NEWLIST:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6746 case ISN_OPNR:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6747 case ISN_OPFLOAT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6748 case ISN_OPANY:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6749 case ISN_PCALL:
19862 846fbbacce3a patch 8.2.0487: Vim9: compiling not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19860 diff changeset	6750 case ISN_PCALL_END:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6751 case ISN_PUSHF:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6752 case ISN_PUSHNR:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6753 case ISN_PUSHBOOL:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6754 case ISN_PUSHSPEC:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6755 case ISN_RETURN:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6756 case ISN_STORE:
20295 bc2c9ea94ec1 patch 8.2.0703: Vim9: closure cannot store value in outer context Bram Moolenaar <Bram@vim.org> parents: 20283 diff changeset	6757 case ISN_STOREOUTER:
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	6758 case ISN_STOREV:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6759 case ISN_STORENR:
19283 9dc843109c97 patch 8.2.0200: Vim9 script commands not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	6760 case ISN_STOREREG:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6761 case ISN_STORESCRIPT:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6762 case ISN_THROW:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6763 case ISN_TRY:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6764 // nothing allocated
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6765 break;
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6766 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6767 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6768
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6769 /*
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6770 * Free all instructions for "dfunc".
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6771 */
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6772 static void
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6773 delete_def_function_contents(dfunc_T *dfunc)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6774 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6775 int idx;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6776
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6777 ga_clear(&dfunc->df_def_args_isn);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6778
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6779 if (dfunc->df_instr != NULL)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6780 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6781 for (idx = 0; idx < dfunc->df_instr_count; ++idx)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6782 delete_instr(dfunc->df_instr + idx);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6783 VIM_CLEAR(dfunc->df_instr);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6784 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6785
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6786 dfunc->df_deleted = TRUE;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6787 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6788
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6789 /*
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6790 * When a user function is deleted, delete any associated def function.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6791 */
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6792 void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6793 delete_def_function(ufunc_T *ufunc)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6794 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6795 if (ufunc->uf_dfunc_idx >= 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6796 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6797 dfunc_T dfunc = ((dfunc_T )def_functions.ga_data)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6798 + ufunc->uf_dfunc_idx;
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6799
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6800 delete_def_function_contents(dfunc);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6801 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6802 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6803
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6804 #if defined(EXITFREE) \|\| defined(PROTO)
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6805 /*
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6806 * Free all functions defined with ":def".
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6807 */
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6808 void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6809 free_def_functions(void)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6810 {
19726 ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6811 int idx;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6812
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6813 for (idx = 0; idx < def_functions.ga_len; ++idx)
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6814 {
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6815 dfunc_T dfunc = ((dfunc_T )def_functions.ga_data) + idx;
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6816
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6817 delete_def_function_contents(dfunc);
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6818 }
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6819
ad37a198a708 patch 8.2.0419: various memory leaks in Vim9 script code Bram Moolenaar <Bram@vim.org> parents: 19623 diff changeset	6820 ga_clear(&def_functions);
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6821 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6822 #endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6823
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6824
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6825 #endif // FEAT_EVAL

Mercurial > vim

annotate src/vim9compile.c @ 20334:b774655968b4 v8.2.0722