Adding upstream version 2:9.1.0016.upstream/2%9.1.0016

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 882 insertions, 0 deletions

diff --git a/src/vim9.h b/src/vim9.h
new file mode 100644
index 0000000..dd5ad73
--- /dev/null
+++ b/src/vim9.h
@@ -0,0 +1,882 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved	by Bram Moolenaar
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * vim9.h: types and globals used for Vim9 script.
+ */
+
+#ifdef VMS
+# include <float.h>
+#endif
+
+typedef enum {
+    ISN_EXEC,	    // execute Ex command line isn_arg.string
+    ISN_EXECCONCAT, // execute Ex command from isn_arg.number items on stack
+    ISN_EXEC_SPLIT, // execute Ex command from isn_arg.string split at NL
+    ISN_EXECRANGE,  // execute EX command that is only a range
+    ISN_LEGACY_EVAL, // evaluate expression isn_arg.string with legacy syntax.
+    ISN_ECHO,	    // :echo with isn_arg.echo.echo_count items on top of stack
+    ISN_EXECUTE,    // :execute with isn_arg.number items on top of stack
+    ISN_ECHOMSG,    // :echomsg with isn_arg.number items on top of stack
+    ISN_ECHOCONSOLE, // :echoconsole with isn_arg.number items on top of stack
+    ISN_ECHOWINDOW, // :echowindow with isn_arg.number items on top of stack
+    ISN_ECHOERR,    // :echoerr with isn_arg.number items on top of stack
+    ISN_RANGE,	    // compute range from isn_arg.string, push to stack
+    ISN_SUBSTITUTE, // :s command with expression
+
+    ISN_SOURCE,	    // source autoload script, isn_arg.number is the script ID
+    ISN_INSTR,	    // instructions compiled from expression
+    ISN_CONSTRUCT,  // construct an object, using construct_T
+    ISN_GET_OBJ_MEMBER, // object member, index is isn_arg.number
+    ISN_GET_ITF_MEMBER, // interface member, index is isn_arg.classmember
+    ISN_STORE_THIS, // store value in "this" object member, index is
+		    // isn_arg.number
+    ISN_LOAD_CLASSMEMBER,  // load class member, using isn_arg.classmember
+    ISN_STORE_CLASSMEMBER,  // store in class member, using isn_arg.classmember
+
+    // get and set variables
+    ISN_LOAD,	    // push local variable isn_arg.number
+    ISN_LOADV,	    // push v: variable isn_arg.number
+    ISN_LOADG,	    // push g: variable isn_arg.string
+    ISN_LOADAUTO,   // push g: autoload variable isn_arg.string
+    ISN_LOADB,	    // push b: variable isn_arg.string
+    ISN_LOADW,	    // push w: variable isn_arg.string
+    ISN_LOADT,	    // push t: variable isn_arg.string
+    ISN_LOADGDICT,  // push g: dict
+    ISN_LOADBDICT,  // push b: dict
+    ISN_LOADWDICT,  // push w: dict
+    ISN_LOADTDICT,  // push t: dict
+    ISN_LOADS,	    // push s: variable isn_arg.loadstore
+    ISN_LOADEXPORT, // push exported variable isn_arg.loadstore
+    ISN_LOADOUTER,  // push variable from outer scope isn_arg.outer
+    ISN_LOADSCRIPT, // push script-local variable isn_arg.script.
+    ISN_LOADOPT,    // push option isn_arg.string
+    ISN_LOADENV,    // push environment variable isn_arg.string
+    ISN_LOADREG,    // push register isn_arg.number
+
+    ISN_STORE,	    // pop into local variable isn_arg.number
+    ISN_STOREV,	    // pop into v: variable isn_arg.number
+    ISN_STOREG,	    // pop into global variable isn_arg.string
+    ISN_STOREAUTO,  // pop into global autoload variable isn_arg.string
+    ISN_STOREB,	    // pop into buffer-local variable isn_arg.string
+    ISN_STOREW,	    // pop into window-local variable isn_arg.string
+    ISN_STORET,	    // pop into tab-local variable isn_arg.string
+    ISN_STORES,	    // pop into script variable isn_arg.loadstore
+    ISN_STOREEXPORT, // pop into exported script variable isn_arg.loadstore
+    ISN_STOREOUTER,  // pop variable into outer scope isn_arg.outer
+    ISN_STORESCRIPT, // pop into script variable isn_arg.script
+    ISN_STOREOPT,    // pop into option isn_arg.storeopt
+    ISN_STOREFUNCOPT, // pop into option isn_arg.storeopt
+    ISN_STOREENV,    // pop into environment variable isn_arg.string
+    ISN_STOREREG,    // pop into register isn_arg.number
+    // ISN_STOREOTHER, // pop into other script variable isn_arg.other.
+
+    ISN_STORENR,    // store number into local variable isn_arg.storenr.stnr_idx
+    ISN_STOREINDEX,	// store into list or dictionary, using
+			// isn_arg.storeindex; value/index/variable on stack
+    ISN_STORERANGE,	// store into blob,
+			// value/index 1/index 2/variable on stack
+
+    ISN_UNLET,		// unlet variable isn_arg.unlet.ul_name
+    ISN_UNLETENV,	// unlet environment variable isn_arg.unlet.ul_name
+    ISN_UNLETINDEX,	// unlet item of list or dict
+    ISN_UNLETRANGE,	// unlet items of list
+
+    ISN_LOCKUNLOCK,	// :lock and :unlock for local variable member
+    ISN_LOCKCONST,	// lock constant value
+
+    // constants
+    ISN_PUSHNR,		// push number isn_arg.number
+    ISN_PUSHBOOL,	// push bool value isn_arg.number
+    ISN_PUSHSPEC,	// push special value isn_arg.number
+    ISN_PUSHF,		// push float isn_arg.fnumber
+    ISN_PUSHS,		// push string isn_arg.string
+    ISN_PUSHBLOB,	// push blob isn_arg.blob
+    ISN_PUSHFUNC,	// push func isn_arg.string
+    ISN_PUSHCHANNEL,	// push NULL channel
+    ISN_PUSHJOB,	// push NULL job
+    ISN_PUSHOBJ,	// push NULL object
+    ISN_PUSHCLASS,	// push class, uses isn_arg.classarg
+    ISN_NEWLIST,	// push list from stack items, size is isn_arg.number
+			// -1 for null_list
+    ISN_NEWDICT,	// push dict from stack items, size is isn_arg.number
+			// -1 for null_dict
+    ISN_NEWPARTIAL,	// push NULL partial
+
+    ISN_AUTOLOAD,	// get item from autoload import, function or variable
+
+    // function call
+    ISN_BCALL,	    // call builtin function isn_arg.bfunc
+    ISN_DCALL,	    // call def function isn_arg.dfunc
+    ISN_METHODCALL, // call method on interface, uses isn_arg.mfunc
+    ISN_UCALL,	    // call user function or funcref/partial isn_arg.ufunc
+    ISN_PCALL,	    // call partial, use isn_arg.pfunc
+    ISN_PCALL_END,  // cleanup after ISN_PCALL with cpf_top set
+    ISN_RETURN,	    // return, result is on top of stack
+    ISN_RETURN_VOID, // Push void, then return
+    ISN_RETURN_OBJECT, // Push constructed object, then return
+    ISN_FUNCREF,    // push a function ref to dfunc isn_arg.funcref
+    ISN_NEWFUNC,    // create a global function from a lambda function
+    ISN_DEF,	    // list functions
+    ISN_DEFER,	    // :defer  argument count is isn_arg.number
+
+    // expression operations
+    ISN_JUMP,	    // jump if condition is matched isn_arg.jump
+    ISN_JUMP_IF_ARG_SET, // jump if argument is already set, uses
+			 // isn_arg.jumparg
+    ISN_JUMP_IF_ARG_NOT_SET, // jump if argument is not set, uses
+			 // isn_arg.jumparg
+
+    // loop
+    ISN_FOR,	    // get next item from a list, uses isn_arg.forloop
+    ISN_WHILE,	    // jump if condition false, store funcref count, uses
+		    // isn_arg.whileloop
+    ISN_ENDLOOP,    // handle variables for closures, uses isn_arg.endloop
+
+    ISN_TRY,	    // add entry to ec_trystack, uses isn_arg.tryref
+    ISN_THROW,	    // pop value of stack, store in v:exception
+    ISN_PUSHEXC,    // push v:exception
+    ISN_CATCH,	    // drop v:exception
+    ISN_FINALLY,    // start of :finally block
+    ISN_ENDTRY,	    // take entry off from ec_trystack
+    ISN_TRYCONT,    // handle :continue or :break inside a :try statement
+
+    // more expression operations
+    ISN_ADDLIST,    // add two lists
+    ISN_ADDBLOB,    // add two blobs
+
+    // operation with two arguments; isn_arg.op.op_type is exprtype_T
+    ISN_OPNR,
+    ISN_OPFLOAT,
+    ISN_OPANY,
+
+    // comparative operations; isn_arg.op.op_type is exprtype_T, op_ic used
+    ISN_COMPAREBOOL,
+    ISN_COMPARESPECIAL,
+    ISN_COMPARENULL,
+    ISN_COMPARENR,
+    ISN_COMPAREFLOAT,
+    ISN_COMPARESTRING,
+    ISN_COMPAREBLOB,
+    ISN_COMPARELIST,
+    ISN_COMPAREDICT,
+    ISN_COMPAREFUNC,
+    ISN_COMPAREANY,
+    ISN_COMPAREOBJECT,
+
+    // expression operations
+    ISN_CONCAT,     // concatenate isn_arg.number strings
+    ISN_STRINDEX,   // [expr] string index
+    ISN_STRSLICE,   // [expr:expr] string slice
+    ISN_LISTAPPEND, // append to a list, like add()
+    ISN_LISTINDEX,  // [expr] list index
+    ISN_LISTSLICE,  // [expr:expr] list slice
+    ISN_BLOBINDEX,  // [expr] blob index
+    ISN_BLOBSLICE,  // [expr:expr] blob slice
+    ISN_ANYINDEX,   // [expr] runtime index
+    ISN_ANYSLICE,   // [expr:expr] runtime slice
+    ISN_SLICE,	    // drop isn_arg.number items from start of list
+    ISN_BLOBAPPEND, // append to a blob, like add()
+    ISN_GETITEM,    // push list item, isn_arg.number is the index
+    ISN_MEMBER,	    // dict[member]
+    ISN_STRINGMEMBER, // dict.member using isn_arg.string
+    ISN_2BOOL,	    // falsy/truthy to bool, uses isn_arg.tobool
+    ISN_COND2BOOL,  // convert value to bool
+    ISN_2STRING,    // convert value to string at isn_arg.tostring on stack
+    ISN_2STRING_ANY, // like ISN_2STRING but check type
+    ISN_NEGATENR,   // apply "-" to number
+
+    ISN_CHECKTYPE,  // check value type is isn_arg.type.ct_type
+    ISN_CHECKLEN,   // check list length is isn_arg.checklen.cl_min_len
+    ISN_SETTYPE,    // set dict type to isn_arg.type.ct_type
+
+    ISN_CLEARDICT,  // clear dict saved by ISN_MEMBER/ISN_STRINGMEMBER
+    ISN_USEDICT,    // use or clear dict saved by ISN_MEMBER/ISN_STRINGMEMBER
+
+    ISN_PUT,	    // ":put", uses isn_arg.put
+
+    ISN_CMDMOD,	    // set cmdmod
+    ISN_CMDMOD_REV, // undo ISN_CMDMOD
+
+    ISN_PROF_START, // start a line for profiling
+    ISN_PROF_END,   // end a line for profiling
+
+    ISN_DEBUG,	    // check for debug breakpoint, uses isn_arg.debug
+
+    ISN_UNPACK,	    // unpack list into items, uses isn_arg.unpack
+    ISN_SHUFFLE,    // move item on stack up or down
+    ISN_DROP,	    // pop stack and discard value
+
+    ISN_REDIRSTART, // :redir =>
+    ISN_REDIREND,   // :redir END, isn_arg.number == 1 for append
+
+    ISN_CEXPR_AUCMD, // first part of :cexpr  isn_arg.number is cmdidx
+    ISN_CEXPR_CORE,  // second part of :cexpr, uses isn_arg.cexpr
+
+    ISN_FINISH	    // end marker in list of instructions
+} isntype_T;
+
+
+// arguments to ISN_BCALL
+typedef struct {
+    int	    cbf_idx;	    // index in "global_functions"
+    int	    cbf_argcount;   // number of arguments on top of stack
+} cbfunc_T;
+
+// arguments to ISN_DCALL
+typedef struct {
+    int	    cdf_idx;	    // index in "def_functions" for ISN_DCALL
+    int	    cdf_argcount;   // number of arguments on top of stack
+} cdfunc_T;
+
+// arguments to ISN_METHODCALL
+typedef struct {
+    class_T *cmf_itf;	    // interface used
+    int	    cmf_idx;	    // index in "def_functions" for ISN_DCALL
+    int	    cmf_argcount;   // number of arguments on top of stack
+} cmfunc_T;
+
+// arguments to ISN_PCALL
+typedef struct {
+    int	    cpf_top;	    // when TRUE partial is above the arguments
+    int	    cpf_argcount;   // number of arguments on top of stack
+} cpfunc_T;
+
+// arguments to ISN_UCALL and ISN_XCALL
+typedef struct {
+    char_u  *cuf_name;
+    int	    cuf_argcount;   // number of arguments on top of stack
+} cufunc_T;
+
+// arguments to ISN_GETITEM
+typedef struct {
+    varnumber_T	gi_index;
+    int		gi_with_op;
+} getitem_T;
+
+typedef enum {
+    JUMP_ALWAYS,
+    JUMP_NEVER,
+    JUMP_IF_FALSE,		// pop and jump if false
+    JUMP_WHILE_FALSE,		// pop and jump if false for :while
+    JUMP_AND_KEEP_IF_TRUE,	// jump if top of stack is truthy, drop if not
+    JUMP_IF_COND_TRUE,		// jump if top of stack is true, drop if not
+    JUMP_IF_COND_FALSE,		// jump if top of stack is false, drop if not
+} jumpwhen_T;
+
+// arguments to ISN_JUMP
+typedef struct {
+    jumpwhen_T	jump_when;
+    int		jump_where;	// position to jump to
+} jump_T;
+
+// arguments to ISN_JUMP_IF_ARG_SET and ISN_JUMP_IF_ARG_NOT_SET
+typedef struct {
+    int		jump_arg_off;	// argument index, negative
+    int		jump_where;	// position to jump to
+} jumparg_T;
+
+// arguments to ISN_FOR
+typedef struct {
+    short	for_loop_idx;	// loop variable index
+    int		for_end;	// position to jump to after done
+} forloop_T;
+
+// arguments to ISN_WHILE
+typedef struct {
+    short	while_funcref_idx;  // variable index for funcref count
+    int		while_end;	    // position to jump to after done
+} whileloop_T;
+
+// arguments to ISN_ENDLOOP
+typedef struct {
+    short    end_funcref_idx;	// variable index of funcrefs.ga_len
+    short    end_depth;		// nested loop depth
+    short    end_var_idx;	// first variable declared in the loop
+    short    end_var_count;	// number of variables declared in the loop
+} endloop_T;
+
+// indirect arguments to ISN_TRY
+typedef struct {
+    int	    try_catch;	    // position to jump to on throw
+    int	    try_finally;    // :finally or :endtry position to jump to
+    int	    try_endtry;	    // :endtry position to jump to
+} tryref_T;
+
+// arguments to ISN_TRY
+typedef struct {
+    tryref_T *try_ref;
+} try_T;
+
+// arguments to ISN_TRYCONT
+typedef struct {
+    int	    tct_levels;	    // number of nested try statements
+    int	    tct_where;	    // position to jump to, WHILE or FOR
+} trycont_T;
+
+// arguments to ISN_ECHO
+typedef struct {
+    int	    echo_with_white;    // :echo instead of :echon
+    int	    echo_count;		// number of expressions
+} echo_T;
+
+// arguments to ISN_OPNR, ISN_OPFLOAT, etc.
+typedef struct {
+    exprtype_T	op_type;
+    int		op_ic;	    // TRUE with '#', FALSE with '?', else MAYBE
+} opexpr_T;
+
+// arguments to ISN_CHECKTYPE
+typedef struct {
+    type_T	*ct_type;
+    int8_T	ct_off;		// offset in stack, -1 is bottom
+    int8_T	ct_arg_idx;	// argument index or zero
+    int8_T	ct_is_var;	// when TRUE checking variable instead of arg
+} checktype_T;
+
+// arguments to ISN_STORENR
+typedef struct {
+    int		stnr_idx;
+    varnumber_T	stnr_val;
+} storenr_T;
+
+// arguments to ISN_STOREOPT and ISN_STOREFUNCOPT
+typedef struct {
+    char_u	*so_name;
+    int		so_flags;
+} storeopt_T;
+
+// arguments to ISN_LOADS and ISN_STORES
+typedef struct {
+    char_u	*ls_name;	// variable name (with s: for ISN_STORES)
+    int		ls_sid;		// script ID
+} loadstore_T;
+
+// arguments to ISN_LOADSCRIPT and ISN_STORESCRIPT
+typedef struct {
+    int		sref_sid;	// script ID
+    int		sref_idx;	// index in sn_var_vals
+    int		sref_seq;	// sn_script_seq when compiled
+    type_T	*sref_type;	// type of the variable when compiled
+} scriptref_T;
+
+typedef struct {
+    scriptref_T	*scriptref;
+} script_T;
+
+// arguments to ISN_UNLET
+typedef struct {
+    char_u	*ul_name;	// variable name with g:, w:, etc.
+    int		ul_forceit;	// forceit flag
+} unlet_T;
+
+// extra arguments for funcref_T
+typedef struct {
+    char_u	  *fre_func_name;	// function name for legacy function
+    loopvarinfo_T fre_loopvar_info;	// info about variables inside loops
+    class_T	  *fre_class;		// class for a method
+    int		  fre_object_method;	// class or object method
+    int		  fre_method_idx;	// method index on "fre_class"
+} funcref_extra_T;
+
+// arguments to ISN_FUNCREF
+typedef struct {
+    int		    fr_dfunc_idx;   // function index for :def function
+    funcref_extra_T *fr_extra;	    // optional extra information
+} funcref_T;
+
+// arguments to ISN_NEWFUNC
+typedef struct {
+    char_u	  *nfa_lambda;	    // name of the lambda already defined
+    char_u	  *nfa_global;	    // name of the global function to be created
+    loopvarinfo_T nfa_loopvar_info; // ifno about variables inside loops
+} newfuncarg_T;
+
+typedef struct {
+    newfuncarg_T *nf_arg;
+} newfunc_T;
+
+// arguments to ISN_CHECKLEN
+typedef struct {
+    int		cl_min_len;	// minimum length
+    int		cl_more_OK;	// longer is allowed
+} checklen_T;
+
+// arguments to ISN_SHUFFLE
+typedef struct {
+    int		shfl_item;	// item to move (relative to top of stack)
+    int		shfl_up;	// places to move upwards
+} shuffle_T;
+
+// arguments to ISN_PUT
+typedef struct {
+    int		put_regname;	// register, can be NUL
+    linenr_T	put_lnum;	// line number to put below
+} put_T;
+
+// arguments to ISN_CMDMOD
+typedef struct {
+    cmdmod_T	*cf_cmdmod;	// allocated
+} cmod_T;
+
+// arguments to ISN_UNPACK
+typedef struct {
+    int		unp_count;	// number of items to produce
+    int		unp_semicolon;	// last item gets list of remainder
+} unpack_T;
+
+// arguments to ISN_LOADOUTER and ISN_STOREOUTER
+typedef struct {
+    int		outer_idx;	// index
+    int		outer_depth;	// nesting level, stack frames to go up
+} isn_outer_T;
+
+#define OUTER_LOOP_DEPTH -9	// used for outer_depth for loop variables
+
+// arguments to ISN_SUBSTITUTE
+typedef struct {
+    char_u	*subs_cmd;	// :s command
+    isn_T	*subs_instr;	// sequence of instructions
+} subs_T;
+
+// indirect arguments to ISN_TRY
+typedef struct {
+    int		cer_cmdidx;
+    char_u	*cer_cmdline;
+    int		cer_forceit;
+} cexprref_T;
+
+// arguments to ISN_CEXPR_CORE
+typedef struct {
+    cexprref_T *cexpr_ref;
+} cexpr_T;
+
+// arguments to ISN_2STRING and ISN_2STRING_ANY
+typedef struct {
+    int		offset;
+    int		tolerant;
+} tostring_T;
+
+// arguments to ISN_2BOOL
+typedef struct {
+    int		offset;
+    int		invert;
+} tobool_T;
+
+// arguments to ISN_DEBUG
+typedef struct {
+    varnumber_T	dbg_var_names_len;  // current number of local variables
+    int		dbg_break_lnum;	    // first line to break after
+} debug_T;
+
+// arguments to ISN_DEFER
+typedef struct {
+    int		defer_var_idx;	    // local variable index for defer list
+    int		defer_argcount;	    // number of arguments
+} deferins_T;
+
+// arguments to ISN_ECHOWINDOW
+typedef struct {
+    int		ewin_count;	    // number of arguments
+    long	ewin_time;	    // time argument (msec)
+} echowin_T;
+
+// arguments to ISN_CONSTRUCT
+typedef struct {
+    int		construct_size;	    // size of object in bytes
+    class_T	*construct_class;   // class the object is created from
+} construct_T;
+
+// arguments to ISN_STORE_CLASSMEMBER, ISN_LOAD_CLASSMEMBER, ISN_GET_ITF_MEMBER
+typedef struct {
+    class_T	*cm_class;
+    int		cm_idx;
+} classmember_T;
+
+// arguments to ISN_STOREINDEX
+typedef struct {
+    vartype_T	si_vartype;
+    class_T	*si_class;
+} storeindex_T;
+
+// arguments to ISN_LOCKUNLOCK
+typedef struct {
+    char_u	*lu_string;	// for exec_command
+    class_T	*lu_cl_exec;	// executing, null if not class/obj method
+    int		lu_is_arg;	// is lval_root a function arg
+} lockunlock_T;
+
+/*
+ * Instruction
+ */
+struct isn_S {
+    isntype_T	isn_type;
+    int		isn_lnum;
+    union {
+	char_u		    *string;
+	varnumber_T	    number;
+	blob_T		    *blob;
+	vartype_T	    vartype;
+	float_T		    fnumber;
+	channel_T	    *channel;
+	job_T		    *job;
+	partial_T	    *partial;
+	class_T		    *classarg;
+	jump_T		    jump;
+	jumparg_T	    jumparg;
+	forloop_T	    forloop;
+	whileloop_T	    whileloop;
+	endloop_T	    endloop;
+	try_T		    tryref;
+	trycont_T	    trycont;
+	cbfunc_T	    bfunc;
+	cdfunc_T	    dfunc;
+	cmfunc_T	    *mfunc;
+	cpfunc_T	    pfunc;
+	cufunc_T	    ufunc;
+	echo_T		    echo;
+	opexpr_T	    op;
+	checktype_T	    type;
+	storenr_T	    storenr;
+	storeopt_T	    storeopt;
+	loadstore_T	    loadstore;
+	script_T	    script;
+	unlet_T		    unlet;
+	funcref_T	    funcref;
+	newfunc_T	    newfunc;
+	checklen_T	    checklen;
+	shuffle_T	    shuffle;
+	put_T		    put;
+	cmod_T		    cmdmod;
+	unpack_T	    unpack;
+	isn_outer_T	    outer;
+	subs_T		    subs;
+	cexpr_T		    cexpr;
+	isn_T		    *instr;
+	tostring_T	    tostring;
+	tobool_T	    tobool;
+	getitem_T	    getitem;
+	debug_T		    debug;
+	deferins_T	    defer;
+	echowin_T	    echowin;
+	construct_T	    construct;
+	classmember_T	    classmember;
+	storeindex_T	    storeindex;
+	lockunlock_T	    lockunlock;
+    } isn_arg;
+};
+
+/*
+ * Info about a function defined with :def.  Used in "def_functions".
+ */
+struct dfunc_S {
+    ufunc_T	*df_ufunc;	    // struct containing most stuff
+    int		df_refcount;	    // how many ufunc_T point to this dfunc_T
+    int		df_idx;		    // index in def_functions
+    char	df_deleted;	    // if TRUE function was deleted
+    char	df_delete_busy;	    // TRUE when in
+				    // delete_def_function_contents()
+    int		df_script_seq;	    // Value of sctx_T sc_seq when the function
+				    // was compiled.
+    char_u	*df_name;	    // name used for error messages
+
+    garray_T	df_def_args_isn;    // default argument instructions
+    garray_T	df_var_names;	    // names of local vars
+
+    // After compiling "df_instr" and/or "df_instr_prof" is not NULL.
+    isn_T	*df_instr;	    // function body to be executed
+    int		df_instr_count;	    // size of "df_instr"
+    int		df_instr_debug_count; // size of "df_instr_debug"
+    isn_T	*df_instr_debug;      // like "df_instr" with debugging
+#ifdef FEAT_PROFILE
+    isn_T	*df_instr_prof;	     // like "df_instr" with profiling
+    int		df_instr_prof_count; // size of "df_instr_prof"
+#endif
+
+    int		df_varcount;	    // number of local variables
+    int		df_has_closure;	    // one if a closure was created
+    int		df_defer_var_idx;   // index of local variable that has a list
+				    // of deferred function calls; zero if not
+				    // set
+};
+
+// Number of entries used by stack frame for a function call.
+// - ec_dfunc_idx:   function index
+// - ec_iidx:	     instruction index
+// - ec_instr:       instruction list pointer
+// - ec_outer:	     stack used for closures
+// - funclocal:	     function-local data
+// - ec_frame_idx:   previous frame index
+#define STACK_FRAME_FUNC_OFF 0
+#define STACK_FRAME_IIDX_OFF 1
+#define STACK_FRAME_INSTR_OFF 2
+#define STACK_FRAME_OUTER_OFF 3
+#define STACK_FRAME_FUNCLOCAL_OFF 4
+#define STACK_FRAME_IDX_OFF 5
+#define STACK_FRAME_SIZE 6
+
+
+extern garray_T def_functions;
+
+// Used for "lnum" when a range is to be taken from the stack.
+#define LNUM_VARIABLE_RANGE (-999)
+
+// Used for "lnum" when a range is to be taken from the stack and "!" is used.
+#define LNUM_VARIABLE_RANGE_ABOVE (-888)
+
+// Keep in sync with get_compile_type()
+#ifdef FEAT_PROFILE
+# define INSTRUCTIONS(dfunc) \
+	(debug_break_level > 0 || may_break_in_function(dfunc->df_ufunc) \
+	    ? (dfunc)->df_instr_debug \
+	    : ((do_profiling == PROF_YES && (dfunc->df_ufunc)->uf_profiling) \
+		? (dfunc)->df_instr_prof \
+		: (dfunc)->df_instr))
+#else
+# define INSTRUCTIONS(dfunc) \
+	(debug_break_level > 0 || may_break_in_function((dfunc)->df_ufunc) \
+		? (dfunc)->df_instr_debug \
+		: (dfunc)->df_instr)
+#endif
+
+// Structure passed between the compile_expr* functions to keep track of
+// constants that have been parsed but for which no code was produced yet.  If
+// possible expressions on these constants are applied at compile time.  If
+// that is not possible, the code to push the constants needs to be generated
+// before other instructions.
+// Using 50 should be more than enough of 5 levels of ().
+#define PPSIZE 50
+typedef struct {
+    typval_T	pp_tv[PPSIZE];	// stack of ppconst constants
+    int		pp_used;	// active entries in pp_tv[]
+    int		pp_is_const;	// all generated code was constants, used for a
+				// list or dict with constant members
+} ppconst_T;
+
+// values for ctx_skip
+typedef enum {
+    SKIP_NOT,		// condition is a constant, produce code
+    SKIP_YES,		// condition is a constant, do NOT produce code
+    SKIP_UNKNOWN	// condition is not a constant, produce code
+} skip_T;
+
+/*
+ * Chain of jump instructions where the end label needs to be set.
+ */
+typedef struct endlabel_S endlabel_T;
+struct endlabel_S {
+    endlabel_T	*el_next;	    // chain end_label locations
+    int		el_end_label;	    // instruction idx where to set end
+};
+
+/*
+ * info specific for the scope of :if / elseif / else
+ */
+typedef struct {
+    int		is_seen_else;
+    int		is_seen_skip_not;   // a block was unconditionally executed
+    int		is_had_return;	    // every block ends in :return
+    int		is_if_label;	    // instruction idx at IF or ELSEIF
+    endlabel_T	*is_end_label;	    // instructions to set end label
+} ifscope_T;
+
+// info used by :for and :while needed for ENDLOOP
+typedef struct {
+    int	    li_local_count;	    // ctx_locals.ga_len at loop start
+    int	    li_closure_count;	    // ctx_closure_count at loop start
+    int	    li_funcref_idx;	    // index of var that holds funcref count
+    int	    li_depth;		    // nested loop depth
+} loop_info_T;
+
+/*
+ * info specific for the scope of :while
+ */
+typedef struct {
+    int		ws_top_label;	    // instruction idx at WHILE
+    endlabel_T	*ws_end_label;	    // instructions to set end
+    loop_info_T ws_loop_info;	    // info for LOOPEND
+} whilescope_T;
+
+/*
+ * info specific for the scope of :for
+ */
+typedef struct {
+    int		fs_top_label;	    // instruction idx at FOR
+    endlabel_T	*fs_end_label;	    // break instructions
+    loop_info_T	fs_loop_info;	    // info for LOOPEND
+} forscope_T;
+
+/*
+ * info specific for the scope of :try
+ */
+typedef struct {
+    int		ts_try_label;	    // instruction idx at TRY
+    endlabel_T	*ts_end_label;	    // jump to :finally or :endtry
+    int		ts_catch_label;	    // instruction idx of last CATCH
+    int		ts_caught_all;	    // "catch" without argument encountered
+    int		ts_has_finally;	    // "finally" encountered
+    int		ts_no_return;	    // one of the blocks did not end in return
+} tryscope_T;
+
+typedef enum {
+    NO_SCOPE,
+    IF_SCOPE,
+    WHILE_SCOPE,
+    FOR_SCOPE,
+    TRY_SCOPE,
+    BLOCK_SCOPE
+} scopetype_T;
+
+/*
+ * Info for one scope, pointed to by "ctx_scope".
+ */
+typedef struct scope_S scope_T;
+struct scope_S {
+    scope_T	*se_outer;	    // scope containing this one
+    scopetype_T se_type;
+    int		se_local_count;	    // ctx_locals.ga_len before scope
+    skip_T	se_skip_save;	    // ctx_skip before the block
+    int		se_loop_depth;	    // number of loop scopes, including this
+    union {
+	ifscope_T	se_if;
+	whilescope_T	se_while;
+	forscope_T	se_for;
+	tryscope_T	se_try;
+    } se_u;
+};
+
+/*
+ * Entry for "ctx_locals".  Used for arguments and local variables.
+ */
+typedef struct {
+    char_u	*lv_name;
+    type_T	*lv_type;
+    int		lv_idx;		// index of the variable on the stack
+    int		lv_loop_depth;	// depth for variable inside a loop or -1
+    int		lv_loop_idx;	// index of first variable inside a loop or -1
+    int		lv_from_outer;	// nesting level, using ctx_outer scope
+    int		lv_const;	// ASSIGN_VAR (can be assigned to),
+				// ASSIGN_FINAL (no assignment) or ASSIGN_CONST
+				// (value cannot be changed)
+    int		lv_arg;		// when TRUE this is an argument
+} lvar_T;
+
+// Destination for an assignment or ":unlet" with an index.
+typedef enum {
+    dest_local,
+    dest_option,
+    dest_func_option,
+    dest_env,
+    dest_global,
+    dest_buffer,
+    dest_window,
+    dest_tab,
+    dest_vimvar,
+    dest_class_member,
+    dest_script,
+    dest_reg,
+    dest_expr,
+} assign_dest_T;
+
+// Used by compile_lhs() to store information about the LHS of an assignment
+// and one argument of ":unlet" with an index.
+typedef struct {
+    assign_dest_T   lhs_dest;	    // type of destination
+
+    char_u	    *lhs_name;	    // allocated name excluding the last
+				    // "[expr]" or ".name".
+    size_t	    lhs_varlen;	    // length of the variable without
+				    // "[expr]" or ".name"
+    char_u	    *lhs_whole;	    // allocated name including the last
+				    // "[expr]" or ".name" for :redir
+    size_t	    lhs_varlen_total; // length of the variable including
+				      // any "[expr]" or ".name"
+    char_u	    *lhs_dest_end;  // end of the destination, including
+				    // "[expr]" or ".name".
+    char_u	    *lhs_end;	    // end including any type
+
+    int		    lhs_has_index;  // has "[expr]" or ".name"
+
+    int		    lhs_new_local;  // create new local variable
+    int		    lhs_opt_flags;  // for when destination is an option
+    int		    lhs_vimvaridx;  // for when destination is a v:var
+
+    lvar_T	    lhs_local_lvar; // used for existing local destination
+    lvar_T	    lhs_arg_lvar;   // used for argument destination
+    lvar_T	    *lhs_lvar;	    // points to destination lvar
+
+    class_T	    *lhs_class;		    // for dest_class_member
+    int		    lhs_classmember_idx;    // for dest_class_member
+
+    int		    lhs_scriptvar_sid;
+    int		    lhs_scriptvar_idx;
+
+    int		    lhs_has_type;   // type was specified
+    type_T	    *lhs_type;
+    int		    lhs_member_idx;    // object member index
+    type_T	    *lhs_member_type;  // list/dict/object member type
+
+    int		    lhs_append;	    // used by ISN_REDIREND
+} lhs_T;
+
+/*
+ * Context for compiling lines of a :def function.
+ * Stores info about the local variables and condition stack.
+ */
+struct cctx_S {
+    ufunc_T	*ctx_ufunc;	    // current function
+    int		ctx_lnum;	    // line number in current function
+    char_u	*ctx_line_start;    // start of current line or NULL
+    garray_T	ctx_instr;	    // generated instructions
+
+    int		ctx_prev_lnum;	    // line number below previous command, for
+				    // debugging
+
+    compiletype_T ctx_compile_type;
+
+    garray_T	ctx_locals;	    // currently visible local variables
+
+    int		ctx_has_closure;    // set to one if a FUNCREF was used in the
+				    // function
+    int		ctx_closure_count;  // incremented for each closure created in
+				    // the function.
+
+    skip_T	ctx_skip;
+    scope_T	*ctx_scope;	    // current scope, NULL at toplevel
+    int		ctx_had_return;	    // last seen statement was "return"
+    int		ctx_had_throw;	    // last seen statement was "throw"
+
+    cctx_T	*ctx_outer;	    // outer scope for lambda or nested
+				    // function
+    int		ctx_outer_used;	    // var in ctx_outer was used
+
+    garray_T	ctx_type_stack;	    // type of each item on the stack
+    garray_T	*ctx_type_list;	    // list of pointers to allocated types
+
+    int		ctx_has_cmdmod;	    // ISN_CMDMOD was generated
+
+    lhs_T	ctx_redir_lhs;	    // LHS for ":redir => var", valid when
+				    // lhs_name is not NULL
+};
+
+/*
+ * List of special functions for "compile_arguments()".
+ */
+typedef enum {
+    CA_NOT_SPECIAL,
+    CA_SEARCHPAIR,	    // {skip} in searchpair() and searchpairpos()
+    CA_SUBSTITUTE,	    // {sub} in substitute(), when prefixed with \=
+} ca_special_T;
+
+// flags for typval2type()
+#define TVTT_DO_MEMBER	    1
+#define TVTT_MORE_SPECIFIC  2	// get most specific type for member
+
+// flags for call_def_function()
+#define DEF_USE_PT_ARGV	    1	// use the partial arguments