thac0/vim
1
0
Fork 0
forked from aniani/vim
Code
vim/src/vim9compile.c
Bram Moolenaar 2caa1594e7 patch 8.2.1339: Vim9: assigning to global dict variable doesn't work 
Problem:    Vim9: assigning to global dict variable doesn't work.
Solution:   Guess variable type based in index type. (issue #6591)
2020-08-01 15:53:19 +02:00

7845 lines
179 KiB
C
Raw Blame History

/* 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.
*/
/*
* vim9compile.c: :def and dealing with instructions
*/
#define USING_FLOAT_STUFF
#include "vim.h"
#if defined(FEAT_EVAL) || defined(PROTO)
#ifdef VMS
# include <float.h>
#endif
#define DEFINE_VIM9_GLOBALS
#include "vim9.h"
// 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_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 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
} 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
} 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
} 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
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_from_outer; // when TRUE using ctx_outer scope
int lv_const; // when TRUE cannot be assigned to
int lv_arg; // when TRUE this is an argument
} lvar_T;
/*
* Context for compiling lines of Vim script.
* 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
garray_T ctx_locals; // currently visible local variables
int ctx_locals_count; // total number of local variables
int ctx_closure_count; // number of closures created in the
// function
garray_T ctx_imports; // imported items
skip_T ctx_skip;
scope_T *ctx_scope; // current scope, NULL at toplevel
int ctx_had_return; // last seen statement was "return"
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
};
static char e_var_notfound[] = N_("E1001: variable not found: %s");
static char e_syntax_at[] = N_("E1002: Syntax error at %s");
static char e_used_as_arg[] = N_("E1006: %s is used as an argument");
static char e_cannot_use_void[] = N_("E1031: Cannot use void value");
static char e_namespace[] = N_("E1075: Namespace not supported: %s");
static void delete_def_function_contents(dfunc_T *dfunc);
static void arg_type_mismatch(type_T *expected, type_T *actual, int argidx);
/*
* Lookup variable "name" in the local scope and return it.
* Return NULL if not found.
*/
static lvar_T *
lookup_local(char_u *name, size_t len, cctx_T *cctx)
{
int idx;
lvar_T *lvar;
if (len == 0)
return NULL;
// Find local in current function scope.
for (idx = 0; idx < cctx->ctx_locals.ga_len; ++idx)
{
lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
if (STRNCMP(name, lvar->lv_name, len) == 0
&& STRLEN(lvar->lv_name) == len)
{
lvar->lv_from_outer = FALSE;
return lvar;
}
}
// Find local in outer function scope.
if (cctx->ctx_outer != NULL)
{
lvar = lookup_local(name, len, cctx->ctx_outer);
if (lvar != NULL)
{
// TODO: are there situations we should not mark the outer scope as
// used?
cctx->ctx_outer_used = TRUE;
lvar->lv_from_outer = TRUE;
return lvar;
}
}
return NULL;
}
/*
* Lookup an argument in the current function and an enclosing function.
* Returns the argument index in "idxp"
* Returns the argument type in "type"
* Sets "gen_load_outer" to TRUE if found in outer scope.
* Returns OK when found, FAIL otherwise.
*/
static int
lookup_arg(
char_u *name,
size_t len,
int *idxp,
type_T **type,
int *gen_load_outer,
cctx_T *cctx)
{
int idx;
char_u *va_name;
if (len == 0)
return FAIL;
for (idx = 0; idx < cctx->ctx_ufunc->uf_args.ga_len; ++idx)
{
char_u *arg = FUNCARG(cctx->ctx_ufunc, idx);
if (STRNCMP(name, arg, len) == 0 && arg[len] == NUL)
{
if (idxp != NULL)
{
// Arguments are located above the frame pointer. One further
// if there is a vararg argument
*idxp = idx - (cctx->ctx_ufunc->uf_args.ga_len
+ STACK_FRAME_SIZE)
+ (cctx->ctx_ufunc->uf_va_name != NULL ? -1 : 0);
if (cctx->ctx_ufunc->uf_arg_types != NULL)
*type = cctx->ctx_ufunc->uf_arg_types[idx];
else
*type = &t_any;
}
return OK;
}
}
va_name = cctx->ctx_ufunc->uf_va_name;
if (va_name != NULL
&& STRNCMP(name, va_name, len) == 0 && va_name[len] == NUL)
{
if (idxp != NULL)
{
// varargs is always the last argument
*idxp = -STACK_FRAME_SIZE - 1;
*type = cctx->ctx_ufunc->uf_va_type;
}
return OK;
}
if (cctx->ctx_outer != NULL)
{
// Lookup the name for an argument of the outer function.
if (lookup_arg(name, len, idxp, type, gen_load_outer, cctx->ctx_outer)
== OK)
{
*gen_load_outer = TRUE;
return OK;
}
}
return FAIL;
}
/*
* Lookup a variable in the current script.
* Returns OK or FAIL.
*/
static int
lookup_script(char_u *name, size_t len)
{
int cc;
hashtab_T *ht = &SCRIPT_VARS(current_sctx.sc_sid);
dictitem_T *di;
cc = name[len];
name[len] = NUL;
di = find_var_in_ht(ht, 0, name, TRUE);
name[len] = cc;
return di == NULL ? FAIL: OK;
}
/*
* Check if "p[len]" is already defined, either in script "import_sid" or in
* compilation context "cctx".
* Return FAIL and give an error if it defined.
*/
int
check_defined(char_u *p, size_t len, cctx_T *cctx)
{
if (lookup_script(p, len) == OK
|| (cctx != NULL
&& (lookup_local(p, len, cctx) != NULL
|| find_imported(p, len, cctx) != NULL)))
{
semsg("E1073: imported name already defined: %s", p);
return FAIL;
}
return OK;
}
/*
* Allocate memory for a type_T and add the pointer to type_gap, so that it can
* be freed later.
*/
static type_T *
alloc_type(garray_T *type_gap)
{
type_T *type;
if (ga_grow(type_gap, 1) == FAIL)
return NULL;
type = ALLOC_CLEAR_ONE(type_T);
if (type != NULL)
{
((type_T **)type_gap->ga_data)[type_gap->ga_len] = type;
++type_gap->ga_len;
}
return type;
}
void
clear_type_list(garray_T *gap)
{
while (gap->ga_len > 0)
vim_free(((type_T **)gap->ga_data)[--gap->ga_len]);
ga_clear(gap);
}
static type_T *
get_list_type(type_T *member_type, garray_T *type_gap)
{
type_T *type;
// recognize commonly used types
if (member_type->tt_type == VAR_ANY)
return &t_list_any;
if (member_type->tt_type == VAR_VOID
|| member_type->tt_type == VAR_UNKNOWN)
return &t_list_empty;
if (member_type->tt_type == VAR_BOOL)
return &t_list_bool;
if (member_type->tt_type == VAR_NUMBER)
return &t_list_number;
if (member_type->tt_type == VAR_STRING)
return &t_list_string;
// Not a common type, create a new entry.
type = alloc_type(type_gap);
if (type == NULL)
return &t_any;
type->tt_type = VAR_LIST;
type->tt_member = member_type;
type->tt_argcount = 0;
type->tt_args = NULL;
return type;
}
static type_T *
get_dict_type(type_T *member_type, garray_T *type_gap)
{
type_T *type;
// recognize commonly used types
if (member_type->tt_type == VAR_ANY)
return &t_dict_any;
if (member_type->tt_type == VAR_VOID
|| member_type->tt_type == VAR_UNKNOWN)
return &t_dict_empty;
if (member_type->tt_type == VAR_BOOL)
return &t_dict_bool;
if (member_type->tt_type == VAR_NUMBER)
return &t_dict_number;
if (member_type->tt_type == VAR_STRING)
return &t_dict_string;
// Not a common type, create a new entry.
type = alloc_type(type_gap);
if (type == NULL)
return &t_any;
type->tt_type = VAR_DICT;
type->tt_member = member_type;
type->tt_argcount = 0;
type->tt_args = NULL;
return type;
}
/*
* Allocate a new type for a function.
*/
static type_T *
alloc_func_type(type_T *ret_type, int argcount, garray_T *type_gap)
{
type_T *type = alloc_type(type_gap);
if (type == NULL)
return &t_any;
type->tt_type = VAR_FUNC;
type->tt_member = ret_type;
type->tt_argcount = argcount;
type->tt_args = NULL;
return type;
}
/*
* Get a function type, based on the return type "ret_type".
* If "argcount" is -1 or 0 a predefined type can be used.
* If "argcount" > 0 always create a new type, so that arguments can be added.
*/
static type_T *
get_func_type(type_T *ret_type, int argcount, garray_T *type_gap)
{
// recognize commonly used types
if (argcount <= 0)
{
if (ret_type == &t_unknown)
{
// (argcount == 0) is not possible
return &t_func_unknown;
}
if (ret_type == &t_void)
{
if (argcount == 0)
return &t_func_0_void;
else
return &t_func_void;
}
if (ret_type == &t_any)
{
if (argcount == 0)
return &t_func_0_any;
else
return &t_func_any;
}
if (ret_type == &t_number)
{
if (argcount == 0)
return &t_func_0_number;
else
return &t_func_number;
}
if (ret_type == &t_string)
{
if (argcount == 0)
return &t_func_0_string;
else
return &t_func_string;
}
}
return alloc_func_type(ret_type, argcount, type_gap);
}
/*
* For a function type, reserve space for "argcount" argument types (including
* vararg).
*/
static int
func_type_add_arg_types(
type_T *functype,
int argcount,
garray_T *type_gap)
{
// To make it easy to free the space needed for the argument types, add the
// pointer to type_gap.
if (ga_grow(type_gap, 1) == FAIL)
return FAIL;
functype->tt_args = ALLOC_CLEAR_MULT(type_T *, argcount);
if (functype->tt_args == NULL)
return FAIL;
((type_T **)type_gap->ga_data)[type_gap->ga_len] =
(void *)functype->tt_args;
++type_gap->ga_len;
return OK;
}
/*
* Get a type_T for a typval_T.
* "type_list" is used to temporarily create types in.
*/
type_T *
typval2type(typval_T *tv, garray_T *type_gap)
{
type_T *actual;
type_T *member_type;
if (tv->v_type == VAR_NUMBER)
return &t_number;
if (tv->v_type == VAR_BOOL)
return &t_bool; // not used
if (tv->v_type == VAR_STRING)
return &t_string;
if (tv->v_type == VAR_LIST
&& tv->vval.v_list != NULL
&& tv->vval.v_list->lv_first != NULL)
{
// Use the type of the first member, it is the most specific.
member_type = typval2type(&tv->vval.v_list->lv_first->li_tv, type_gap);
return get_list_type(member_type, type_gap);
}
if (tv->v_type == VAR_DICT
&& tv->vval.v_dict != NULL
&& tv->vval.v_dict->dv_hashtab.ht_used > 0)
{
dict_iterator_T iter;
typval_T *value;
// Use the type of the first value, it is the most specific.
dict_iterate_start(tv, &iter);
dict_iterate_next(&iter, &value);
member_type = typval2type(value, type_gap);
return get_dict_type(member_type, type_gap);
}
if (tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL)
{
char_u *name = NULL;
ufunc_T *ufunc = NULL;
if (tv->v_type == VAR_PARTIAL)
{
if (tv->vval.v_partial->pt_func != NULL)
ufunc = tv->vval.v_partial->pt_func;
else
name = tv->vval.v_partial->pt_name;
}
else
name = tv->vval.v_string;
if (name != NULL)
// TODO: how about a builtin function?
ufunc = find_func(name, FALSE, NULL);
if (ufunc != NULL)
{
// May need to get the argument types from default values by
// compiling the function.
if (ufunc->uf_def_status == UF_TO_BE_COMPILED
&& compile_def_function(ufunc, TRUE, NULL) == FAIL)
return NULL;
if (ufunc->uf_func_type != NULL)
return ufunc->uf_func_type;
}
}
actual = alloc_type(type_gap);
if (actual == NULL)
return NULL;
actual->tt_type = tv->v_type;
actual->tt_member = &t_any;
return actual;
}
/*
* Get a type_T for a typval_T, used for v: variables.
* "type_list" is used to temporarily create types in.
*/
type_T *
typval2type_vimvar(typval_T *tv, garray_T *type_gap)
{
if (tv->v_type == VAR_LIST) // e.g. for v:oldfiles
return &t_list_string;
if (tv->v_type == VAR_DICT) // e.g. for v:completed_item
return &t_dict_any;
return typval2type(tv, type_gap);
}
/*
* Return FAIL if "expected" and "actual" don't match.
*/
int
check_typval_type(type_T *expected, typval_T *actual_tv)
{
garray_T type_list;
type_T *actual_type;
int res = FAIL;
ga_init2(&type_list, sizeof(type_T *), 10);
actual_type = typval2type(actual_tv, &type_list);
if (actual_type != NULL)
res = check_type(expected, actual_type, TRUE);
clear_type_list(&type_list);
return res;
}
static void
type_mismatch(type_T *expected, type_T *actual)
{
char *tofree1, *tofree2;
semsg(_("E1013: type mismatch, expected %s but got %s"),
type_name(expected, &tofree1), type_name(actual, &tofree2));
vim_free(tofree1);
vim_free(tofree2);
}
static void
arg_type_mismatch(type_T *expected, type_T *actual, int argidx)
{
char *tofree1, *tofree2;
semsg(_("E1013: argument %d: type mismatch, expected %s but got %s"),
argidx,
type_name(expected, &tofree1), type_name(actual, &tofree2));
vim_free(tofree1);
vim_free(tofree2);
}
/*
* Check if the expected and actual types match.
* Does not allow for assigning "any" to a specific type.
*/
int
check_type(type_T *expected, type_T *actual, int give_msg)
{
int ret = OK;
// When expected is "unknown" we accept any actual type.
// When expected is "any" we accept any actual type except "void".
if (expected->tt_type != VAR_UNKNOWN
&& !(expected->tt_type == VAR_ANY && actual->tt_type != VAR_VOID))
{
if (expected->tt_type != actual->tt_type)
{
if (give_msg)
type_mismatch(expected, actual);
return FAIL;
}
if (expected->tt_type == VAR_DICT || expected->tt_type == VAR_LIST)
{
// "unknown" is used for an empty list or dict
if (actual->tt_member != &t_unknown)
ret = check_type(expected->tt_member, actual->tt_member, FALSE);
}
else if (expected->tt_type == VAR_FUNC)
{
if (expected->tt_member != &t_unknown)
ret = check_type(expected->tt_member, actual->tt_member, FALSE);
if (ret == OK && expected->tt_argcount != -1
&& (actual->tt_argcount < expected->tt_min_argcount
|| actual->tt_argcount > expected->tt_argcount))
ret = FAIL;
if (expected->tt_args != NULL && actual->tt_args != NULL)
{
int i;
for (i = 0; i < expected->tt_argcount; ++i)
if (check_type(expected->tt_args[i], actual->tt_args[i],
FALSE) == FAIL)
{
ret = FAIL;
break;
}
}
}
if (ret == FAIL && give_msg)
type_mismatch(expected, actual);
}
return ret;
}
/////////////////////////////////////////////////////////////////////
// Following generate_ functions expect the caller to call ga_grow().
#define RETURN_NULL_IF_SKIP(cctx) if (cctx->ctx_skip == SKIP_YES) return NULL
#define RETURN_OK_IF_SKIP(cctx) if (cctx->ctx_skip == SKIP_YES) return OK
/*
* Generate an instruction without arguments.
* Returns a pointer to the new instruction, NULL if failed.
*/
static isn_T *
generate_instr(cctx_T *cctx, isntype_T isn_type)
{
garray_T *instr = &cctx->ctx_instr;
isn_T *isn;
RETURN_NULL_IF_SKIP(cctx);
if (ga_grow(instr, 1) == FAIL)
return NULL;
isn = ((isn_T *)instr->ga_data) + instr->ga_len;
isn->isn_type = isn_type;
isn->isn_lnum = cctx->ctx_lnum + 1;
++instr->ga_len;
return isn;
}
/*
* Generate an instruction without arguments.
* "drop" will be removed from the stack.
* Returns a pointer to the new instruction, NULL if failed.
*/
static isn_T *
generate_instr_drop(cctx_T *cctx, isntype_T isn_type, int drop)
{
garray_T *stack = &cctx->ctx_type_stack;
RETURN_NULL_IF_SKIP(cctx);
stack->ga_len -= drop;
return generate_instr(cctx, isn_type);
}
/*
* Generate instruction "isn_type" and put "type" on the type stack.
*/
static isn_T *
generate_instr_type(cctx_T *cctx, isntype_T isn_type, type_T *type)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
if ((isn = generate_instr(cctx, isn_type)) == NULL)
return NULL;
if (ga_grow(stack, 1) == FAIL)
return NULL;
((type_T **)stack->ga_data)[stack->ga_len] = type == NULL ? &t_any : type;
++stack->ga_len;
return isn;
}
/*
* If type at "offset" isn't already VAR_STRING then generate ISN_2STRING.
*/
static int
may_generate_2STRING(int offset, cctx_T *cctx)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
type_T **type = ((type_T **)stack->ga_data) + stack->ga_len + offset;
if ((*type)->tt_type == VAR_STRING)
return OK;
*type = &t_string;
if ((isn = generate_instr(cctx, ISN_2STRING)) == NULL)
return FAIL;
isn->isn_arg.number = offset;
return OK;
}
static int
check_number_or_float(vartype_T type1, vartype_T type2, char_u *op)
{
if (!((type1 == VAR_NUMBER || type1 == VAR_FLOAT || type1 == VAR_ANY)
&& (type2 == VAR_NUMBER || type2 == VAR_FLOAT
|| type2 == VAR_ANY)))
{
if (*op == '+')
emsg(_("E1051: wrong argument type for +"));
else
semsg(_("E1036: %c requires number or float arguments"), *op);
return FAIL;
}
return OK;
}
/*
* Generate an instruction with two arguments. The instruction depends on the
* type of the arguments.
*/
static int
generate_two_op(cctx_T *cctx, char_u *op)
{
garray_T *stack = &cctx->ctx_type_stack;
type_T *type1;
type_T *type2;
vartype_T vartype;
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
// Get the known type of the two items on the stack. If they are matching
// use a type-specific instruction. Otherwise fall back to runtime type
// checking.
type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2];
type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1];
vartype = VAR_ANY;
if (type1->tt_type == type2->tt_type
&& (type1->tt_type == VAR_NUMBER
|| type1->tt_type == VAR_LIST
#ifdef FEAT_FLOAT
|| type1->tt_type == VAR_FLOAT
#endif
|| type1->tt_type == VAR_BLOB))
vartype = type1->tt_type;
switch (*op)
{
case '+': if (vartype != VAR_LIST && vartype != VAR_BLOB
&& type1->tt_type != VAR_ANY
&& type2->tt_type != VAR_ANY
&& check_number_or_float(
type1->tt_type, type2->tt_type, op) == FAIL)
return FAIL;
isn = generate_instr_drop(cctx,
vartype == VAR_NUMBER ? ISN_OPNR
: vartype == VAR_LIST ? ISN_ADDLIST
: vartype == VAR_BLOB ? ISN_ADDBLOB
#ifdef FEAT_FLOAT
: vartype == VAR_FLOAT ? ISN_OPFLOAT
#endif
: ISN_OPANY, 1);
if (isn != NULL)
isn->isn_arg.op.op_type = EXPR_ADD;
break;
case '-':
case '*':
case '/': if (check_number_or_float(type1->tt_type, type2->tt_type,
op) == FAIL)
return FAIL;
if (vartype == VAR_NUMBER)
isn = generate_instr_drop(cctx, ISN_OPNR, 1);
#ifdef FEAT_FLOAT
else if (vartype == VAR_FLOAT)
isn = generate_instr_drop(cctx, ISN_OPFLOAT, 1);
#endif
else
isn = generate_instr_drop(cctx, ISN_OPANY, 1);
if (isn != NULL)
isn->isn_arg.op.op_type = *op == '*'
? EXPR_MULT : *op == '/'? EXPR_DIV : EXPR_SUB;
break;
case '%': if ((type1->tt_type != VAR_ANY
&& type1->tt_type != VAR_NUMBER)
|| (type2->tt_type != VAR_ANY
&& type2->tt_type != VAR_NUMBER))
{
emsg(_("E1035: % requires number arguments"));
return FAIL;
}
isn = generate_instr_drop(cctx,
vartype == VAR_NUMBER ? ISN_OPNR : ISN_OPANY, 1);
if (isn != NULL)
isn->isn_arg.op.op_type = EXPR_REM;
break;
}
// correct type of result
if (vartype == VAR_ANY)
{
type_T *type = &t_any;
#ifdef FEAT_FLOAT
// float+number and number+float results in float
if ((type1->tt_type == VAR_NUMBER || type1->tt_type == VAR_FLOAT)
&& (type2->tt_type == VAR_NUMBER || type2->tt_type == VAR_FLOAT))
type = &t_float;
#endif
((type_T **)stack->ga_data)[stack->ga_len - 1] = type;
}
return OK;
}
/*
* Get the instruction to use for comparing "type1" with "type2"
* Return ISN_DROP when failed.
*/
static isntype_T
get_compare_isn(exptype_T exptype, vartype_T type1, vartype_T type2)
{
isntype_T isntype = ISN_DROP;
if (type1 == VAR_UNKNOWN)
type1 = VAR_ANY;
if (type2 == VAR_UNKNOWN)
type2 = VAR_ANY;
if (type1 == type2)
{
switch (type1)
{
case VAR_BOOL: isntype = ISN_COMPAREBOOL; break;
case VAR_SPECIAL: isntype = ISN_COMPARESPECIAL; break;
case VAR_NUMBER: isntype = ISN_COMPARENR; break;
case VAR_FLOAT: isntype = ISN_COMPAREFLOAT; break;
case VAR_STRING: isntype = ISN_COMPARESTRING; break;
case VAR_BLOB: isntype = ISN_COMPAREBLOB; break;
case VAR_LIST: isntype = ISN_COMPARELIST; break;
case VAR_DICT: isntype = ISN_COMPAREDICT; break;
case VAR_FUNC: isntype = ISN_COMPAREFUNC; break;
default: isntype = ISN_COMPAREANY; break;
}
}
else if (type1 == VAR_ANY || type2 == VAR_ANY
|| ((type1 == VAR_NUMBER || type1 == VAR_FLOAT)
&& (type2 == VAR_NUMBER || type2 ==VAR_FLOAT)))
isntype = ISN_COMPAREANY;
if ((exptype == EXPR_IS || exptype == EXPR_ISNOT)
&& (isntype == ISN_COMPAREBOOL
|| isntype == ISN_COMPARESPECIAL
|| isntype == ISN_COMPARENR
|| isntype == ISN_COMPAREFLOAT))
{
semsg(_("E1037: Cannot use \"%s\" with %s"),
exptype == EXPR_IS ? "is" : "isnot" , vartype_name(type1));
return ISN_DROP;
}
if (isntype == ISN_DROP
|| ((exptype != EXPR_EQUAL && exptype != EXPR_NEQUAL
&& (type1 == VAR_BOOL || type1 == VAR_SPECIAL
|| type2 == VAR_BOOL || type2 == VAR_SPECIAL)))
|| ((exptype != EXPR_EQUAL && exptype != EXPR_NEQUAL
&& exptype != EXPR_IS && exptype != EXPR_ISNOT
&& (type1 == VAR_BLOB || type2 == VAR_BLOB
|| type1 == VAR_LIST || type2 == VAR_LIST))))
{
semsg(_("E1072: Cannot compare %s with %s"),
vartype_name(type1), vartype_name(type2));
return ISN_DROP;
}
return isntype;
}
int
check_compare_types(exptype_T type, typval_T *tv1, typval_T *tv2)
{
if (get_compare_isn(type, tv1->v_type, tv2->v_type) == ISN_DROP)
return FAIL;
return OK;
}
/*
* Generate an ISN_COMPARE* instruction with a boolean result.
*/
static int
generate_COMPARE(cctx_T *cctx, exptype_T exptype, int ic)
{
isntype_T isntype;
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
vartype_T type1;
vartype_T type2;
RETURN_OK_IF_SKIP(cctx);
// Get the known type of the two items on the stack. If they are matching
// use a type-specific instruction. Otherwise fall back to runtime type
// checking.
type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2]->tt_type;
type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type;
isntype = get_compare_isn(exptype, type1, type2);
if (isntype == ISN_DROP)
return FAIL;
if ((isn = generate_instr(cctx, isntype)) == NULL)
return FAIL;
isn->isn_arg.op.op_type = exptype;
isn->isn_arg.op.op_ic = ic;
// takes two arguments, puts one bool back
if (stack->ga_len >= 2)
{
--stack->ga_len;
((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
}
return OK;
}
/*
* Generate an ISN_2BOOL instruction.
*/
static int
generate_2BOOL(cctx_T *cctx, int invert)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_2BOOL)) == NULL)
return FAIL;
isn->isn_arg.number = invert;
// type becomes bool
((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool;
return OK;
}
static int
generate_TYPECHECK(cctx_T *cctx, type_T *vartype, int offset)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_CHECKTYPE)) == NULL)
return FAIL;
// TODO: whole type, e.g. for a function also arg and return types
isn->isn_arg.type.ct_type = vartype->tt_type;
isn->isn_arg.type.ct_off = offset;
// type becomes vartype
((type_T **)stack->ga_data)[stack->ga_len + offset] = vartype;
return OK;
}
/*
* Check that
* - "actual" is "expected" type or
* - "actual" is a type that can be "expected" type: add a runtime check; or
* - return FAIL.
*/
static int
need_type(
type_T *actual,
type_T *expected,
int offset,
cctx_T *cctx,
int silent)
{
if (check_type(expected, actual, FALSE) == OK)
return OK;
if (actual->tt_type != VAR_ANY
&& actual->tt_type != VAR_UNKNOWN
&& !(actual->tt_type == VAR_FUNC
&& (actual->tt_member == &t_any || actual->tt_argcount < 0)))
{
if (!silent)
type_mismatch(expected, actual);
return FAIL;
}
generate_TYPECHECK(cctx, expected, offset);
return OK;
}
/*
* Generate an ISN_PUSHNR instruction.
*/
static int
generate_PUSHNR(cctx_T *cctx, varnumber_T number)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHNR, &t_number)) == NULL)
return FAIL;
isn->isn_arg.number = number;
return OK;
}
/*
* Generate an ISN_PUSHBOOL instruction.
*/
static int
generate_PUSHBOOL(cctx_T *cctx, varnumber_T number)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHBOOL, &t_bool)) == NULL)
return FAIL;
isn->isn_arg.number = number;
return OK;
}
/*
* Generate an ISN_PUSHSPEC instruction.
*/
static int
generate_PUSHSPEC(cctx_T *cctx, varnumber_T number)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHSPEC, &t_special)) == NULL)
return FAIL;
isn->isn_arg.number = number;
return OK;
}
#ifdef FEAT_FLOAT
/*
* Generate an ISN_PUSHF instruction.
*/
static int
generate_PUSHF(cctx_T *cctx, float_T fnumber)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHF, &t_float)) == NULL)
return FAIL;
isn->isn_arg.fnumber = fnumber;
return OK;
}
#endif
/*
* Generate an ISN_PUSHS instruction.
* Consumes "str".
*/
static int
generate_PUSHS(cctx_T *cctx, char_u *str)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHS, &t_string)) == NULL)
return FAIL;
isn->isn_arg.string = str;
return OK;
}
/*
* Generate an ISN_PUSHCHANNEL instruction.
* Consumes "channel".
*/
static int
generate_PUSHCHANNEL(cctx_T *cctx, channel_T *channel)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHCHANNEL, &t_channel)) == NULL)
return FAIL;
isn->isn_arg.channel = channel;
return OK;
}
/*
* Generate an ISN_PUSHJOB instruction.
* Consumes "job".
*/
static int
generate_PUSHJOB(cctx_T *cctx, job_T *job)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHJOB, &t_channel)) == NULL)
return FAIL;
isn->isn_arg.job = job;
return OK;
}
/*
* Generate an ISN_PUSHBLOB instruction.
* Consumes "blob".
*/
static int
generate_PUSHBLOB(cctx_T *cctx, blob_T *blob)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHBLOB, &t_blob)) == NULL)
return FAIL;
isn->isn_arg.blob = blob;
return OK;
}
/*
* Generate an ISN_PUSHFUNC instruction with name "name".
* Consumes "name".
*/
static int
generate_PUSHFUNC(cctx_T *cctx, char_u *name, type_T *type)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, ISN_PUSHFUNC, type)) == NULL)
return FAIL;
isn->isn_arg.string = name == NULL ? NULL : vim_strsave(name);
return OK;
}
/*
* Generate an ISN_GETITEM instruction with "index".
*/
static int
generate_GETITEM(cctx_T *cctx, int index)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
type_T *type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
type_T *item_type = &t_any;
RETURN_OK_IF_SKIP(cctx);
if (type->tt_type != VAR_LIST)
{
// cannot happen, caller has checked the type
emsg(_(e_listreq));
return FAIL;
}
item_type = type->tt_member;
if ((isn = generate_instr(cctx, ISN_GETITEM)) == NULL)
return FAIL;
isn->isn_arg.number = index;
// add the item type to the type stack
if (ga_grow(stack, 1) == FAIL)
return FAIL;
((type_T **)stack->ga_data)[stack->ga_len] = item_type;
++stack->ga_len;
return OK;
}
/*
* Generate an ISN_SLICE instruction with "count".
*/
static int
generate_SLICE(cctx_T *cctx, int count)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_SLICE)) == NULL)
return FAIL;
isn->isn_arg.number = count;
return OK;
}
/*
* Generate an ISN_CHECKLEN instruction with "min_len".
*/
static int
generate_CHECKLEN(cctx_T *cctx, int min_len, int more_OK)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_CHECKLEN)) == NULL)
return FAIL;
isn->isn_arg.checklen.cl_min_len = min_len;
isn->isn_arg.checklen.cl_more_OK = more_OK;
return OK;
}
/*
* Generate an ISN_STORE instruction.
*/
static int
generate_STORE(cctx_T *cctx, isntype_T isn_type, int idx, char_u *name)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_drop(cctx, isn_type, 1)) == NULL)
return FAIL;
if (name != NULL)
isn->isn_arg.string = vim_strsave(name);
else
isn->isn_arg.number = idx;
return OK;
}
/*
* Generate an ISN_STORENR instruction (short for ISN_PUSHNR + ISN_STORE)
*/
static int
generate_STORENR(cctx_T *cctx, int idx, varnumber_T value)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_STORENR)) == NULL)
return FAIL;
isn->isn_arg.storenr.stnr_idx = idx;
isn->isn_arg.storenr.stnr_val = value;
return OK;
}
/*
* Generate an ISN_STOREOPT instruction
*/
static int
generate_STOREOPT(cctx_T *cctx, char_u *name, int opt_flags)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_STOREOPT)) == NULL)
return FAIL;
isn->isn_arg.storeopt.so_name = vim_strsave(name);
isn->isn_arg.storeopt.so_flags = opt_flags;
return OK;
}
/*
* Generate an ISN_LOAD or similar instruction.
*/
static int
generate_LOAD(
cctx_T *cctx,
isntype_T isn_type,
int idx,
char_u *name,
type_T *type)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_type(cctx, isn_type, type)) == NULL)
return FAIL;
if (name != NULL)
isn->isn_arg.string = vim_strsave(name);
else
isn->isn_arg.number = idx;
return OK;
}
/*
* Generate an ISN_LOADV instruction for v:var.
*/
static int
generate_LOADV(
cctx_T *cctx,
char_u *name,
int error)
{
int di_flags;
int vidx = find_vim_var(name, &di_flags);
type_T *type;
RETURN_OK_IF_SKIP(cctx);
if (vidx < 0)
{
if (error)
semsg(_(e_var_notfound), name);
return FAIL;
}
type = typval2type_vimvar(get_vim_var_tv(vidx), cctx->ctx_type_list);
return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, type);
}
/*
* Generate an ISN_UNLET instruction.
*/
static int
generate_UNLET(cctx_T *cctx, isntype_T isn_type, char_u *name, int forceit)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, isn_type)) == NULL)
return FAIL;
isn->isn_arg.unlet.ul_name = vim_strsave(name);
isn->isn_arg.unlet.ul_forceit = forceit;
return OK;
}
/*
* Generate an ISN_LOADS instruction.
*/
static int
generate_OLDSCRIPT(
cctx_T *cctx,
isntype_T isn_type,
char_u *name,
int sid,
type_T *type)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if (isn_type == ISN_LOADS)
isn = generate_instr_type(cctx, isn_type, type);
else
isn = generate_instr_drop(cctx, isn_type, 1);
if (isn == NULL)
return FAIL;
isn->isn_arg.loadstore.ls_name = vim_strsave(name);
isn->isn_arg.loadstore.ls_sid = sid;
return OK;
}
/*
* Generate an ISN_LOADSCRIPT or ISN_STORESCRIPT instruction.
*/
static int
generate_VIM9SCRIPT(
cctx_T *cctx,
isntype_T isn_type,
int sid,
int idx,
type_T *type)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if (isn_type == ISN_LOADSCRIPT)
isn = generate_instr_type(cctx, isn_type, type);
else
isn = generate_instr_drop(cctx, isn_type, 1);
if (isn == NULL)
return FAIL;
isn->isn_arg.script.script_sid = sid;
isn->isn_arg.script.script_idx = idx;
return OK;
}
/*
* Generate an ISN_NEWLIST instruction.
*/
static int
generate_NEWLIST(cctx_T *cctx, int count)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
type_T *type;
type_T *member;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_NEWLIST)) == NULL)
return FAIL;
isn->isn_arg.number = count;
// drop the value types
stack->ga_len -= count;
// Use the first value type for the list member type. Use "any" for an
// empty list.
if (count > 0)
member = ((type_T **)stack->ga_data)[stack->ga_len];
else
member = &t_void;
type = get_list_type(member, cctx->ctx_type_list);
// add the list type to the type stack
if (ga_grow(stack, 1) == FAIL)
return FAIL;
((type_T **)stack->ga_data)[stack->ga_len] = type;
++stack->ga_len;
return OK;
}
/*
* Generate an ISN_NEWDICT instruction.
*/
static int
generate_NEWDICT(cctx_T *cctx, int count)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
type_T *type;
type_T *member;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_NEWDICT)) == NULL)
return FAIL;
isn->isn_arg.number = count;
// drop the key and value types
stack->ga_len -= 2 * count;
// Use the first value type for the list member type. Use "void" for an
// empty dict.
if (count > 0)
member = ((type_T **)stack->ga_data)[stack->ga_len + 1];
else
member = &t_void;
type = get_dict_type(member, cctx->ctx_type_list);
// add the dict type to the type stack
if (ga_grow(stack, 1) == FAIL)
return FAIL;
((type_T **)stack->ga_data)[stack->ga_len] = type;
++stack->ga_len;
return OK;
}
/*
* Generate an ISN_FUNCREF instruction.
*/
static int
generate_FUNCREF(cctx_T *cctx, int dfunc_idx)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_FUNCREF)) == NULL)
return FAIL;
isn->isn_arg.funcref.fr_func = dfunc_idx;
isn->isn_arg.funcref.fr_var_idx = cctx->ctx_closure_count++;
if (ga_grow(stack, 1) == FAIL)
return FAIL;
((type_T **)stack->ga_data)[stack->ga_len] = &t_func_any;
// TODO: argument and return types
++stack->ga_len;
return OK;
}
/*
* Generate an ISN_NEWFUNC instruction.
*/
static int
generate_NEWFUNC(cctx_T *cctx, char_u *lambda_name, char_u *func_name)
{
isn_T *isn;
char_u *name;
RETURN_OK_IF_SKIP(cctx);
name = vim_strsave(lambda_name);
if (name == NULL)
return FAIL;
if ((isn = generate_instr(cctx, ISN_NEWFUNC)) == NULL)
return FAIL;
isn->isn_arg.newfunc.nf_lambda = name;
isn->isn_arg.newfunc.nf_global = func_name;
return OK;
}
/*
* Generate an ISN_JUMP instruction.
*/
static int
generate_JUMP(cctx_T *cctx, jumpwhen_T when, int where)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_JUMP)) == NULL)
return FAIL;
isn->isn_arg.jump.jump_when = when;
isn->isn_arg.jump.jump_where = where;
if (when != JUMP_ALWAYS && stack->ga_len > 0)
--stack->ga_len;
return OK;
}
static int
generate_FOR(cctx_T *cctx, int loop_idx)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_FOR)) == NULL)
return FAIL;
isn->isn_arg.forloop.for_idx = loop_idx;
if (ga_grow(stack, 1) == FAIL)
return FAIL;
// type doesn't matter, will be stored next
((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
++stack->ga_len;
return OK;
}
/*
* Generate an ISN_BCALL instruction.
* "method_call" is TRUE for "value->method()"
* Return FAIL if the number of arguments is wrong.
*/
static int
generate_BCALL(cctx_T *cctx, int func_idx, int argcount, int method_call)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
int argoff;
type_T *argtypes[MAX_FUNC_ARGS];
int i;
RETURN_OK_IF_SKIP(cctx);
argoff = check_internal_func(func_idx, argcount);
if (argoff < 0)
return FAIL;
if (method_call && argoff > 1)
{
if ((isn = generate_instr(cctx, ISN_SHUFFLE)) == NULL)
return FAIL;
isn->isn_arg.shuffle.shfl_item = argcount;
isn->isn_arg.shuffle.shfl_up = argoff - 1;
}
if ((isn = generate_instr(cctx, ISN_BCALL)) == NULL)
return FAIL;
isn->isn_arg.bfunc.cbf_idx = func_idx;
isn->isn_arg.bfunc.cbf_argcount = argcount;
for (i = 0; i < argcount; ++i)
argtypes[i] = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i];
stack->ga_len -= argcount; // drop the arguments
if (ga_grow(stack, 1) == FAIL)
return FAIL;
((type_T **)stack->ga_data)[stack->ga_len] =
internal_func_ret_type(func_idx, argcount, argtypes);
++stack->ga_len; // add return value
return OK;
}
/*
* Generate an ISN_DCALL or ISN_UCALL instruction.
* Return FAIL if the number of arguments is wrong.
*/
static int
generate_CALL(cctx_T *cctx, ufunc_T *ufunc, int pushed_argcount)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
int regular_args = ufunc->uf_args.ga_len;
int argcount = pushed_argcount;
RETURN_OK_IF_SKIP(cctx);
if (argcount > regular_args && !has_varargs(ufunc))
{
semsg(_(e_toomanyarg), ufunc->uf_name);
return FAIL;
}
if (argcount < regular_args - ufunc->uf_def_args.ga_len)
{
semsg(_(e_toofewarg), ufunc->uf_name);
return FAIL;
}
if (ufunc->uf_def_status != UF_NOT_COMPILED)
{
int i;
for (i = 0; i < argcount; ++i)
{
type_T *expected;
type_T *actual;
if (i < regular_args)
{
if (ufunc->uf_arg_types == NULL)
continue;
expected = ufunc->uf_arg_types[i];
}
else
expected = ufunc->uf_va_type->tt_member;
actual = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i];
if (need_type(actual, expected, -argcount + i, cctx, TRUE) == FAIL)
{
arg_type_mismatch(expected, actual, i + 1);
return FAIL;
}
}
if (ufunc->uf_def_status == UF_TO_BE_COMPILED)
if (compile_def_function(ufunc, TRUE, NULL) == FAIL)
return FAIL;
}
if ((isn = generate_instr(cctx,
ufunc->uf_def_status != UF_NOT_COMPILED ? ISN_DCALL
: ISN_UCALL)) == NULL)
return FAIL;
if (ufunc->uf_def_status != UF_NOT_COMPILED)
{
isn->isn_arg.dfunc.cdf_idx = ufunc->uf_dfunc_idx;
isn->isn_arg.dfunc.cdf_argcount = argcount;
}
else
{
// A user function may be deleted and redefined later, can't use the
// ufunc pointer, need to look it up again at runtime.
isn->isn_arg.ufunc.cuf_name = vim_strsave(ufunc->uf_name);
isn->isn_arg.ufunc.cuf_argcount = argcount;
}
stack->ga_len -= argcount; // drop the arguments
if (ga_grow(stack, 1) == FAIL)
return FAIL;
// add return value
((type_T **)stack->ga_data)[stack->ga_len] = ufunc->uf_ret_type;
++stack->ga_len;
return OK;
}
/*
* Generate an ISN_UCALL instruction when the function isn't defined yet.
*/
static int
generate_UCALL(cctx_T *cctx, char_u *name, int argcount)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_UCALL)) == NULL)
return FAIL;
isn->isn_arg.ufunc.cuf_name = vim_strsave(name);
isn->isn_arg.ufunc.cuf_argcount = argcount;
stack->ga_len -= argcount; // drop the arguments
if (ga_grow(stack, 1) == FAIL)
return FAIL;
// add return value
((type_T **)stack->ga_data)[stack->ga_len] = &t_any;
++stack->ga_len;
return OK;
}
/*
* Generate an ISN_PCALL instruction.
* "type" is the type of the FuncRef.
*/
static int
generate_PCALL(
cctx_T *cctx,
int argcount,
char_u *name,
type_T *type,
int at_top)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
type_T *ret_type;
RETURN_OK_IF_SKIP(cctx);
if (type->tt_type == VAR_ANY)
ret_type = &t_any;
else if (type->tt_type == VAR_FUNC || type->tt_type == VAR_PARTIAL)
{
if (type->tt_argcount != -1)
{
int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0;
if (argcount < type->tt_min_argcount - varargs)
{
semsg(_(e_toofewarg), "[reference]");
return FAIL;
}
if (!varargs && argcount > type->tt_argcount)
{
semsg(_(e_toomanyarg), "[reference]");
return FAIL;
}
}
ret_type = type->tt_member;
}
else
{
semsg(_("E1085: Not a callable type: %s"), name);
return FAIL;
}
if ((isn = generate_instr(cctx, ISN_PCALL)) == NULL)
return FAIL;
isn->isn_arg.pfunc.cpf_top = at_top;
isn->isn_arg.pfunc.cpf_argcount = argcount;
stack->ga_len -= argcount; // drop the arguments
// drop the funcref/partial, get back the return value
((type_T **)stack->ga_data)[stack->ga_len - 1] = ret_type;
// If partial is above the arguments it must be cleared and replaced with
// the return value.
if (at_top && generate_instr(cctx, ISN_PCALL_END) == NULL)
return FAIL;
return OK;
}
/*
* Generate an ISN_STRINGMEMBER instruction.
*/
static int
generate_STRINGMEMBER(cctx_T *cctx, char_u *name, size_t len)
{
isn_T *isn;
garray_T *stack = &cctx->ctx_type_stack;
type_T *type;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_STRINGMEMBER)) == NULL)
return FAIL;
isn->isn_arg.string = vim_strnsave(name, len);
// check for dict type
type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
if (type->tt_type != VAR_DICT && type != &t_any)
{
emsg(_(e_dictreq));
return FAIL;
}
// change dict type to dict member type
if (type->tt_type == VAR_DICT)
((type_T **)stack->ga_data)[stack->ga_len - 1] = type->tt_member;
return OK;
}
/*
* Generate an ISN_ECHO instruction.
*/
static int
generate_ECHO(cctx_T *cctx, int with_white, int count)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr_drop(cctx, ISN_ECHO, count)) == NULL)
return FAIL;
isn->isn_arg.echo.echo_with_white = with_white;
isn->isn_arg.echo.echo_count = count;
return OK;
}
/*
* Generate an ISN_EXECUTE/ISN_ECHOMSG/ISN_ECHOERR instruction.
*/
static int
generate_MULT_EXPR(cctx_T *cctx, isntype_T isn_type, int count)
{
isn_T *isn;
if ((isn = generate_instr_drop(cctx, isn_type, count)) == NULL)
return FAIL;
isn->isn_arg.number = count;
return OK;
}
static int
generate_EXEC(cctx_T *cctx, char_u *line)
{
isn_T *isn;
RETURN_OK_IF_SKIP(cctx);
if ((isn = generate_instr(cctx, ISN_EXEC)) == NULL)
return FAIL;
isn->isn_arg.string = vim_strsave(line);
return OK;
}
static int
generate_EXECCONCAT(cctx_T *cctx, int count)
{
isn_T *isn;
if ((isn = generate_instr_drop(cctx, ISN_EXECCONCAT, count)) == NULL)
return FAIL;
isn->isn_arg.number = count;
return OK;
}
/*
* Reserve space for a local variable.
* Return the variable or NULL if it failed.
*/
static lvar_T *
reserve_local(cctx_T *cctx, char_u *name, size_t len, int isConst, type_T *type)
{
lvar_T *lvar;
if (lookup_arg(name, len, NULL, NULL, NULL, cctx) == OK)
{
emsg_namelen(_(e_used_as_arg), name, (int)len);
return NULL;
}
if (ga_grow(&cctx->ctx_locals, 1) == FAIL)
return NULL;
lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + cctx->ctx_locals.ga_len++;
// Every local variable uses the next entry on the stack. We could re-use
// the last ones when leaving a scope, but then variables used in a closure
// might get overwritten. To keep things simple do not re-use stack
// entries. This is less efficient, but memory is cheap these days.
lvar->lv_idx = cctx->ctx_locals_count++;
lvar->lv_name = vim_strnsave(name, len == 0 ? STRLEN(name) : len);
lvar->lv_const = isConst;
lvar->lv_type = type;
return lvar;
}
/*
* Remove local variables above "new_top".
*/
static void
unwind_locals(cctx_T *cctx, int new_top)
{
if (cctx->ctx_locals.ga_len > new_top)
{
int idx;
lvar_T *lvar;
for (idx = new_top; idx < cctx->ctx_locals.ga_len; ++idx)
{
lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
vim_free(lvar->lv_name);
}
}
cctx->ctx_locals.ga_len = new_top;
}
/*
* Free all local variables.
*/
static void
free_locals(cctx_T *cctx)
{
unwind_locals(cctx, 0);
ga_clear(&cctx->ctx_locals);
}
/*
* Skip over a type definition and return a pointer to just after it.
* When "optional" is TRUE then a leading "?" is accepted.
*/
char_u *
skip_type(char_u *start, int optional)
{
char_u *p = start;
if (optional && *p == '?')
++p;
while (ASCII_ISALNUM(*p) || *p == '_')
++p;
// Skip over "<type>"; this is permissive about white space.
if (*skipwhite(p) == '<')
{
p = skipwhite(p);
p = skip_type(skipwhite(p + 1), FALSE);
p = skipwhite(p);
if (*p == '>')
++p;
}
else if ((*p == '(' || (*p == ':' && VIM_ISWHITE(p[1])))
&& STRNCMP("func", start, 4) == 0)
{
if (*p == '(')
{
// handle func(args): type
++p;
while (*p != ')' && *p != NUL)
{
char_u *sp = p;
if (STRNCMP(p, "...", 3) == 0)
p += 3;
p = skip_type(p, TRUE);
if (p == sp)
return p; // syntax error
if (*p == ',')
p = skipwhite(p + 1);
}
if (*p == ')')
{
if (p[1] == ':')
p = skip_type(skipwhite(p + 2), FALSE);
else
++p;
}
}
else
{
// handle func: return_type
p = skip_type(skipwhite(p + 1), FALSE);
}
}
return p;
}
/*
* Parse the member type: "<type>" and return "type" with the member set.
* Use "type_gap" if a new type needs to be added.
* Returns NULL in case of failure.
*/
static type_T *
parse_type_member(char_u **arg, type_T *type, garray_T *type_gap)
{
type_T *member_type;
int prev_called_emsg = called_emsg;
if (**arg != '<')
{
if (*skipwhite(*arg) == '<')
semsg(_(e_no_white_before), "<");
else
emsg(_("E1008: Missing <type>"));
return type;
}
*arg = skipwhite(*arg + 1);
member_type = parse_type(arg, type_gap);
*arg = skipwhite(*arg);
if (**arg != '>' && called_emsg == prev_called_emsg)
{
emsg(_("E1009: Missing > after type"));
return type;
}
++*arg;
if (type->tt_type == VAR_LIST)
return get_list_type(member_type, type_gap);
return get_dict_type(member_type, type_gap);
}
/*
* Parse a type at "arg" and advance over it.
* Return &t_any for failure.
*/
type_T *
parse_type(char_u **arg, garray_T *type_gap)
{
char_u *p = *arg;
size_t len;
// skip over the first word
while (ASCII_ISALNUM(*p) || *p == '_')
++p;
len = p - *arg;
switch (**arg)
{
case 'a':
if (len == 3 && STRNCMP(*arg, "any", len) == 0)
{
*arg += len;
return &t_any;
}
break;
case 'b':
if (len == 4 && STRNCMP(*arg, "bool", len) == 0)
{
*arg += len;
return &t_bool;
}
if (len == 4 && STRNCMP(*arg, "blob", len) == 0)
{
*arg += len;
return &t_blob;
}
break;
case 'c':
if (len == 7 && STRNCMP(*arg, "channel", len) == 0)
{
*arg += len;
return &t_channel;
}
break;
case 'd':
if (len == 4 && STRNCMP(*arg, "dict", len) == 0)
{
*arg += len;
return parse_type_member(arg, &t_dict_any, type_gap);
}
break;
case 'f':
if (len == 5 && STRNCMP(*arg, "float", len) == 0)
{
#ifdef FEAT_FLOAT
*arg += len;
return &t_float;
#else
emsg(_("E1076: This Vim is not compiled with float support"));
return &t_any;
#endif
}
if (len == 4 && STRNCMP(*arg, "func", len) == 0)
{
type_T *type;
type_T *ret_type = &t_unknown;
int argcount = -1;
int flags = 0;
int first_optional = -1;
type_T *arg_type[MAX_FUNC_ARGS + 1];
// func({type}, ...{type}): {type}
*arg += len;
if (**arg == '(')
{
// "func" may or may not return a value, "func()" does
// not return a value.
ret_type = &t_void;
p = ++*arg;
argcount = 0;
while (*p != NUL && *p != ')')
{
if (*p == '?')
{
if (first_optional == -1)
first_optional = argcount;
++p;
}
else if (STRNCMP(p, "...", 3) == 0)
{
flags |= TTFLAG_VARARGS;
p += 3;
}
else if (first_optional != -1)
{
emsg(_("E1007: mandatory argument after optional argument"));
return &t_any;
}
arg_type[argcount++] = parse_type(&p, type_gap);
// Nothing comes after "...{type}".
if (flags & TTFLAG_VARARGS)
break;
if (*p != ',' && *skipwhite(p) == ',')
{
semsg(_(e_no_white_before), ",");
return &t_any;
}
if (*p == ',')
{
++p;
if (!VIM_ISWHITE(*p))
{
semsg(_(e_white_after), ",");
return &t_any;
}
}
p = skipwhite(p);
if (argcount == MAX_FUNC_ARGS)
{
emsg(_("E740: Too many argument types"));
return &t_any;
}
}
p = skipwhite(p);
if (*p != ')')
{
emsg(_(e_missing_close));
return &t_any;
}
*arg = p + 1;
}
if (**arg == ':')
{
// parse return type
++*arg;
if (!VIM_ISWHITE(**arg))
semsg(_(e_white_after), ":");
*arg = skipwhite(*arg);
ret_type = parse_type(arg, type_gap);
}
if (flags == 0 && first_optional == -1 && argcount <= 0)
type = get_func_type(ret_type, argcount, type_gap);
else
{
type = alloc_func_type(ret_type, argcount, type_gap);
type->tt_flags = flags;
if (argcount > 0)
{
type->tt_argcount = argcount;
type->tt_min_argcount = first_optional == -1
? argcount : first_optional;
if (func_type_add_arg_types(type, argcount,
type_gap) == FAIL)
return &t_any;
mch_memmove(type->tt_args, arg_type,
sizeof(type_T *) * argcount);
}
}
return type;
}
break;
case 'j':
if (len == 3 && STRNCMP(*arg, "job", len) == 0)
{
*arg += len;
return &t_job;
}
break;
case 'l':
if (len == 4 && STRNCMP(*arg, "list", len) == 0)
{
*arg += len;
return parse_type_member(arg, &t_list_any, type_gap);
}
break;
case 'n':
if (len == 6 && STRNCMP(*arg, "number", len) == 0)
{
*arg += len;
return &t_number;
}
break;
case 's':
if (len == 6 && STRNCMP(*arg, "string", len) == 0)
{
*arg += len;
return &t_string;
}
break;
case 'v':
if (len == 4 && STRNCMP(*arg, "void", len) == 0)
{
*arg += len;
return &t_void;
}
break;
}
semsg(_("E1010: Type not recognized: %s"), *arg);
return &t_any;
}
/*
* Check if "type1" and "type2" are exactly the same.
*/
static int
equal_type(type_T *type1, type_T *type2)
{
int i;
if (type1->tt_type != type2->tt_type)
return FALSE;
switch (type1->tt_type)
{
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_VOID:
case VAR_SPECIAL:
case VAR_BOOL:
case VAR_NUMBER:
case VAR_FLOAT:
case VAR_STRING:
case VAR_BLOB:
case VAR_JOB:
case VAR_CHANNEL:
break; // not composite is always OK
case VAR_LIST:
case VAR_DICT:
return equal_type(type1->tt_member, type2->tt_member);
case VAR_FUNC:
case VAR_PARTIAL:
if (!equal_type(type1->tt_member, type2->tt_member)
|| type1->tt_argcount != type2->tt_argcount)
return FALSE;
if (type1->tt_argcount < 0
|| type1->tt_args == NULL || type2->tt_args == NULL)
return TRUE;
for (i = 0; i < type1->tt_argcount; ++i)
if (!equal_type(type1->tt_args[i], type2->tt_args[i]))
return FALSE;
return TRUE;
}
return TRUE;
}
/*
* Find the common type of "type1" and "type2" and put it in "dest".
* "type2" and "dest" may be the same.
*/
static void
common_type(type_T *type1, type_T *type2, type_T **dest, garray_T *type_gap)
{
if (equal_type(type1, type2))
{
*dest = type1;
return;
}
if (type1->tt_type == type2->tt_type)
{
if (type1->tt_type == VAR_LIST || type2->tt_type == VAR_DICT)
{
type_T *common;
common_type(type1->tt_member, type2->tt_member, &common, type_gap);
if (type1->tt_type == VAR_LIST)
*dest = get_list_type(common, type_gap);
else
*dest = get_dict_type(common, type_gap);
return;
}
if (type1->tt_type == VAR_FUNC)
{
type_T *common;
common_type(type1->tt_member, type2->tt_member, &common, type_gap);
if (type1->tt_argcount == type2->tt_argcount
&& type1->tt_argcount >= 0)
{
int argcount = type1->tt_argcount;
int i;
*dest = alloc_func_type(common, argcount, type_gap);
if (type1->tt_args != NULL && type2->tt_args != NULL)
{
if (func_type_add_arg_types(*dest, argcount,
type_gap) == OK)
for (i = 0; i < argcount; ++i)
common_type(type1->tt_args[i], type2->tt_args[i],
&(*dest)->tt_args[i], type_gap);
}
}
else
*dest = alloc_func_type(common, -1, type_gap);
return;
}
}
*dest = &t_any;
}
char *
vartype_name(vartype_T type)
{
switch (type)
{
case VAR_UNKNOWN: break;
case VAR_ANY: return "any";
case VAR_VOID: return "void";
case VAR_SPECIAL: return "special";
case VAR_BOOL: return "bool";
case VAR_NUMBER: return "number";
case VAR_FLOAT: return "float";
case VAR_STRING: return "string";
case VAR_BLOB: return "blob";
case VAR_JOB: return "job";
case VAR_CHANNEL: return "channel";
case VAR_LIST: return "list";
case VAR_DICT: return "dict";
case VAR_FUNC:
case VAR_PARTIAL: return "func";
}
return "unknown";
}
/*
* Return the name of a type.
* The result may be in allocated memory, in which case "tofree" is set.
*/
char *
type_name(type_T *type, char **tofree)
{
char *name = vartype_name(type->tt_type);
*tofree = NULL;
if (type->tt_type == VAR_LIST || type->tt_type == VAR_DICT)
{
char *member_free;
char *member_name = type_name(type->tt_member, &member_free);
size_t len;
len = STRLEN(name) + STRLEN(member_name) + 3;
*tofree = alloc(len);
if (*tofree != NULL)
{
vim_snprintf(*tofree, len, "%s<%s>", name, member_name);
vim_free(member_free);
return *tofree;
}
}
if (type->tt_type == VAR_FUNC)
{
garray_T ga;
int i;
int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0;
ga_init2(&ga, 1, 100);
if (ga_grow(&ga, 20) == FAIL)
return "[unknown]";
*tofree = ga.ga_data;
STRCPY(ga.ga_data, "func(");
ga.ga_len += 5;
for (i = 0; i < type->tt_argcount; ++i)
{
char *arg_free;
char *arg_type;
int len;
if (type->tt_args == NULL)
arg_type = "[unknown]";
else
arg_type = type_name(type->tt_args[i], &arg_free);
if (i > 0)
{
STRCPY((char *)ga.ga_data + ga.ga_len, ", ");
ga.ga_len += 2;
}
len = (int)STRLEN(arg_type);
if (ga_grow(&ga, len + 8) == FAIL)
{
vim_free(arg_free);
return "[unknown]";
}
*tofree = ga.ga_data;
if (varargs && i == type->tt_argcount - 1)
{
STRCPY((char *)ga.ga_data + ga.ga_len, "...");
ga.ga_len += 3;
}
else if (i >= type->tt_min_argcount)
*((char *)ga.ga_data + ga.ga_len++) = '?';
STRCPY((char *)ga.ga_data + ga.ga_len, arg_type);
ga.ga_len += len;
vim_free(arg_free);
}
if (type->tt_member == &t_void)
STRCPY((char *)ga.ga_data + ga.ga_len, ")");
else
{
char *ret_free;
char *ret_name = type_name(type->tt_member, &ret_free);
int len;
len = (int)STRLEN(ret_name) + 4;
if (ga_grow(&ga, len) == FAIL)
{
vim_free(ret_free);
return "[unknown]";
}
*tofree = ga.ga_data;
STRCPY((char *)ga.ga_data + ga.ga_len, "): ");
STRCPY((char *)ga.ga_data + ga.ga_len + 3, ret_name);
vim_free(ret_free);
}
return ga.ga_data;
}
return name;
}
/*
* Find "name" in script-local items of script "sid".
* Returns the index in "sn_var_vals" if found.
* If found but not in "sn_var_vals" returns -1.
* If not found returns -2.
*/
int
get_script_item_idx(int sid, char_u *name, int check_writable)
{
hashtab_T *ht;
dictitem_T *di;
scriptitem_T *si = SCRIPT_ITEM(sid);
int idx;
// First look the name up in the hashtable.
if (sid <= 0 || sid > script_items.ga_len)
return -1;
ht = &SCRIPT_VARS(sid);
di = find_var_in_ht(ht, 0, name, TRUE);
if (di == NULL)
return -2;
// Now find the svar_T index in sn_var_vals.
for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx)
{
svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
if (sv->sv_tv == &di->di_tv)
{
if (check_writable && sv->sv_const)
semsg(_(e_readonlyvar), name);
return idx;
}
}
return -1;
}
/*
* Find "name" in imported items of the current script or in "cctx" if not
* NULL.
*/
imported_T *
find_imported(char_u *name, size_t len, cctx_T *cctx)
{
scriptitem_T *si;
int idx;
if (current_sctx.sc_sid <= 0)
return NULL;
si = SCRIPT_ITEM(current_sctx.sc_sid);
if (cctx != NULL)
for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx)
{
imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data)
+ idx;
if (len == 0 ? STRCMP(name, import->imp_name) == 0
: STRLEN(import->imp_name) == len
&& STRNCMP(name, import->imp_name, len) == 0)
return import;
}
for (idx = 0; idx < si->sn_imports.ga_len; ++idx)
{
imported_T *import = ((imported_T *)si->sn_imports.ga_data) + idx;
if (len == 0 ? STRCMP(name, import->imp_name) == 0
: STRLEN(import->imp_name) == len
&& STRNCMP(name, import->imp_name, len) == 0)
return import;
}
return NULL;
}
/*
* Free all imported variables.
*/
static void
free_imported(cctx_T *cctx)
{
int idx;
for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx)
{
imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data) + idx;
vim_free(import->imp_name);
}
ga_clear(&cctx->ctx_imports);
}
/*
* Return TRUE if "p" points at a "#" but not at "#{".
*/
int
vim9_comment_start(char_u *p)
{
return p[0] == '#' && p[1] != '{';
}
/*
* Return a pointer to the next line that isn't empty or only contains a
* comment. Skips over white space.
* Returns NULL if there is none.
*/
char_u *
peek_next_line_from_context(cctx_T *cctx)
{
int lnum = cctx->ctx_lnum;
while (++lnum < cctx->ctx_ufunc->uf_lines.ga_len)
{
char_u *line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[lnum];
char_u *p;
if (line == NULL)
break;
p = skipwhite(line);
if (*p != NUL && !vim9_comment_start(p))
return p;
}
return NULL;
}
/*
* Called when checking for a following operator at "arg". When the rest of
* the line is empty or only a comment, peek the next line. If there is a next
* line return a pointer to it and set "nextp".
* Otherwise skip over white space.
*/
static char_u *
may_peek_next_line(cctx_T *cctx, char_u *arg, char_u **nextp)
{
char_u *p = skipwhite(arg);
*nextp = NULL;
if (*p == NUL || (VIM_ISWHITE(*arg) && vim9_comment_start(p)))
{
*nextp = peek_next_line_from_context(cctx);
if (*nextp != NULL)
return *nextp;
}
return p;
}
/*
* Get the next line of the function from "cctx".
* Skips over empty lines. Skips over comment lines if "skip_comment" is TRUE.
* Returns NULL when at the end.
*/
char_u *
next_line_from_context(cctx_T *cctx, int skip_comment)
{
char_u *line;
do
{
++cctx->ctx_lnum;
if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len)
{
line = NULL;
break;
}
line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum];
cctx->ctx_line_start = line;
SOURCING_LNUM = cctx->ctx_lnum + 1;
} while (line == NULL || *skipwhite(line) == NUL
|| (skip_comment && vim9_comment_start(skipwhite(line))));
return line;
}
/*
* If "*arg" is at the end of the line, advance to the next line.
* Also when "whitep" points to white space and "*arg" is on a "#".
* Return FAIL if beyond the last line, "*arg" is unmodified then.
*/
static int
may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx)
{
if (**arg == NUL || (VIM_ISWHITE(*whitep) && vim9_comment_start(*arg)))
{
char_u *next = next_line_from_context(cctx, TRUE);
if (next == NULL)
return FAIL;
*arg = skipwhite(next);
}
return OK;
}
/*
* Idem, and give an error when failed.
*/
static int
may_get_next_line_error(char_u *whitep, char_u **arg, cctx_T *cctx)
{
if (may_get_next_line(whitep, arg, cctx) == FAIL)
{
emsg(_("E1097: line incomplete"));
return FAIL;
}
return OK;
}
// 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[]
} ppconst_T;
static int compile_expr0(char_u **arg, cctx_T *cctx);
static int compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst);
/*
* Generate a PUSH instruction for "tv".
* "tv" will be consumed or cleared.
* Nothing happens if "tv" is NULL or of type VAR_UNKNOWN;
*/
static int
generate_tv_PUSH(cctx_T *cctx, typval_T *tv)
{
if (tv != NULL)
{
switch (tv->v_type)
{
case VAR_UNKNOWN:
break;
case VAR_BOOL:
generate_PUSHBOOL(cctx, tv->vval.v_number);
break;
case VAR_SPECIAL:
generate_PUSHSPEC(cctx, tv->vval.v_number);
break;
case VAR_NUMBER:
generate_PUSHNR(cctx, tv->vval.v_number);
break;
#ifdef FEAT_FLOAT
case VAR_FLOAT:
generate_PUSHF(cctx, tv->vval.v_float);
break;
#endif
case VAR_BLOB:
generate_PUSHBLOB(cctx, tv->vval.v_blob);
tv->vval.v_blob = NULL;
break;
case VAR_STRING:
generate_PUSHS(cctx, tv->vval.v_string);
tv->vval.v_string = NULL;
break;
default:
iemsg("constant type not supported");
clear_tv(tv);
return FAIL;
}
tv->v_type = VAR_UNKNOWN;
}
return OK;
}
/*
* Generate code for any ppconst entries.
*/
static int
generate_ppconst(cctx_T *cctx, ppconst_T *ppconst)
{
int i;
int ret = OK;
int save_skip = cctx->ctx_skip;
cctx->ctx_skip = SKIP_NOT;
for (i = 0; i < ppconst->pp_used; ++i)
if (generate_tv_PUSH(cctx, &ppconst->pp_tv[i]) == FAIL)
ret = FAIL;
ppconst->pp_used = 0;
cctx->ctx_skip = save_skip;
return ret;
}
/*
* Clear ppconst constants. Used when failing.
*/
static void
clear_ppconst(ppconst_T *ppconst)
{
int i;
for (i = 0; i < ppconst->pp_used; ++i)
clear_tv(&ppconst->pp_tv[i]);
ppconst->pp_used = 0;
}
/*
* Generate an instruction to load script-local variable "name", without the
* leading "s:".
* Also finds imported variables.
*/
static int
compile_load_scriptvar(
cctx_T *cctx,
char_u *name, // variable NUL terminated
char_u *start, // start of variable
char_u **end, // end of variable
int error) // when TRUE may give error
{
scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
int idx = get_script_item_idx(current_sctx.sc_sid, name, FALSE);
imported_T *import;
if (idx == -1 || si->sn_version != SCRIPT_VERSION_VIM9)
{
// variable is not in sn_var_vals: old style script.
return generate_OLDSCRIPT(cctx, ISN_LOADS, name, current_sctx.sc_sid,
&t_any);
}
if (idx >= 0)
{
svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
current_sctx.sc_sid, idx, sv->sv_type);
return OK;
}
import = find_imported(name, 0, cctx);
if (import != NULL)
{
if (import->imp_all)
{
char_u *p = skipwhite(*end);
char_u *exp_name;
int cc;
ufunc_T *ufunc;
type_T *type;
// Used "import * as Name", need to lookup the member.
if (*p != '.')
{
semsg(_("E1060: expected dot after name: %s"), start);
return FAIL;
}
++p;
if (VIM_ISWHITE(*p))
{
emsg(_("E1074: no white space allowed after dot"));
return FAIL;
}
// isolate one name
exp_name = p;
while (eval_isnamec(*p))
++p;
cc = *p;
*p = NUL;
idx = find_exported(import->imp_sid, exp_name, &ufunc, &type);
*p = cc;
p = skipwhite(p);
// TODO: what if it is a function?
if (idx < 0)
return FAIL;
*end = p;
generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
import->imp_sid,
idx,
type);
}
else if (import->imp_funcname != NULL)
generate_PUSHFUNC(cctx, import->imp_funcname, import->imp_type);
else
generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
import->imp_sid,
import->imp_var_vals_idx,
import->imp_type);
return OK;
}
if (error)
semsg(_("E1050: Item not found: %s"), name);
return FAIL;
}
static int
generate_funcref(cctx_T *cctx, char_u *name)
{
ufunc_T *ufunc = find_func(name, FALSE, cctx);
if (ufunc == NULL)
return FAIL;
// Need to compile any default values to get the argument types.
if (ufunc->uf_def_status == UF_TO_BE_COMPILED)
if (compile_def_function(ufunc, TRUE, NULL) == FAIL)
return FAIL;
return generate_PUSHFUNC(cctx, ufunc->uf_name, ufunc->uf_func_type);
}
/*
* Compile a variable name into a load instruction.
* "end" points to just after the name.
* When "error" is FALSE do not give an error when not found.
*/
static int
compile_load(char_u **arg, char_u *end_arg, cctx_T *cctx, int error)
{
type_T *type;
char_u *name = NULL;
char_u *end = end_arg;
int res = FAIL;
int prev_called_emsg = called_emsg;
if (*(*arg + 1) == ':')
{
// load namespaced variable
if (end <= *arg + 2)
{
isntype_T isn_type;
switch (**arg)
{
case 'g': isn_type = ISN_LOADGDICT; break;
case 'w': isn_type = ISN_LOADWDICT; break;
case 't': isn_type = ISN_LOADTDICT; break;
case 'b': isn_type = ISN_LOADBDICT; break;
default:
semsg(_(e_namespace), *arg);
goto theend;
}
if (generate_instr_type(cctx, isn_type, &t_dict_any) == NULL)
goto theend;
res = OK;
}
else
{
isntype_T isn_type = ISN_DROP;
name = vim_strnsave(*arg + 2, end - (*arg + 2));
if (name == NULL)
return FAIL;
switch (**arg)
{
case 'v': res = generate_LOADV(cctx, name, error);
break;
case 's': res = compile_load_scriptvar(cctx, name,
NULL, NULL, error);
break;
case 'g': isn_type = ISN_LOADG; break;
case 'w': isn_type = ISN_LOADW; break;
case 't': isn_type = ISN_LOADT; break;
case 'b': isn_type = ISN_LOADB; break;
default: semsg(_(e_namespace), *arg);
goto theend;
}
if (isn_type != ISN_DROP)
{
// Global, Buffer-local, Window-local and Tabpage-local
// variables can be defined later, thus we don't check if it
// exists, give error at runtime.
res = generate_LOAD(cctx, isn_type, 0, name, &t_any);
}
}
}
else
{
size_t len = end - *arg;
int idx;
int gen_load = FALSE;
int gen_load_outer = FALSE;
name = vim_strnsave(*arg, end - *arg);
if (name == NULL)
return FAIL;
if (lookup_arg(*arg, len, &idx, &type, &gen_load_outer, cctx) == OK)
{
if (!gen_load_outer)
gen_load = TRUE;
}
else
{
lvar_T *lvar = lookup_local(*arg, len, cctx);
if (lvar != NULL)
{
type = lvar->lv_type;
idx = lvar->lv_idx;
if (lvar->lv_from_outer)
gen_load_outer = TRUE;
else
gen_load = TRUE;
}
else
{
// "var" can be script-local even without using "s:" if it
// already exists.
if (SCRIPT_ITEM(current_sctx.sc_sid)->sn_version
== SCRIPT_VERSION_VIM9
|| lookup_script(*arg, len) == OK)
res = compile_load_scriptvar(cctx, name, *arg, &end,
FALSE);
// When the name starts with an uppercase letter or "x:" it
// can be a user defined function.
if (res == FAIL && (ASCII_ISUPPER(*name) || name[1] == ':'))
res = generate_funcref(cctx, name);
}
}
if (gen_load)
res = generate_LOAD(cctx, ISN_LOAD, idx, NULL, type);
if (gen_load_outer)
res = generate_LOAD(cctx, ISN_LOADOUTER, idx, NULL, type);
}
*arg = end;
theend:
if (res == FAIL && error && called_emsg == prev_called_emsg)
semsg(_(e_var_notfound), name);
vim_free(name);
return res;
}
/*
* Compile the argument expressions.
* "arg" points to just after the "(" and is advanced to after the ")"
*/
static int
compile_arguments(char_u **arg, cctx_T *cctx, int *argcount)
{
char_u *p = *arg;
char_u *whitep = *arg;
for (;;)
{
if (may_get_next_line(whitep, &p, cctx) == FAIL)
goto failret;
if (*p == ')')
{
*arg = p + 1;
return OK;
}
if (compile_expr0(&p, cctx) == FAIL)
return FAIL;
++*argcount;
if (*p != ',' && *skipwhite(p) == ',')
{
semsg(_(e_no_white_before), ",");
p = skipwhite(p);
}
if (*p == ',')
{
++p;
if (*p != NUL && !VIM_ISWHITE(*p))
semsg(_(e_white_after), ",");
}
whitep = p;
p = skipwhite(p);
}
failret:
emsg(_(e_missing_close));
return FAIL;
}
/*
* Compile a function call: name(arg1, arg2)
* "arg" points to "name", "arg + varlen" to the "(".
* "argcount_init" is 1 for "value->method()"
* Instructions:
* EVAL arg1
* EVAL arg2
* BCALL / DCALL / UCALL
*/
static int
compile_call(
char_u **arg,
size_t varlen,
cctx_T *cctx,
ppconst_T *ppconst,
int argcount_init)
{
char_u *name = *arg;
char_u *p;
int argcount = argcount_init;
char_u namebuf[100];
char_u fname_buf[FLEN_FIXED + 1];
char_u *tofree = NULL;
int error = FCERR_NONE;
ufunc_T *ufunc;
int res = FAIL;
// we can evaluate "has('name')" at compile time
if (varlen == 3 && STRNCMP(*arg, "has", 3) == 0)
{
char_u *s = skipwhite(*arg + varlen + 1);
typval_T argvars[2];
argvars[0].v_type = VAR_UNKNOWN;
if (*s == '"')
(void)eval_string(&s, &argvars[0], TRUE);
else if (*s == '\'')
(void)eval_lit_string(&s, &argvars[0], TRUE);
s = skipwhite(s);
if (*s == ')' && argvars[0].v_type == VAR_STRING)
{
typval_T *tv = &ppconst->pp_tv[ppconst->pp_used];
*arg = s + 1;
argvars[1].v_type = VAR_UNKNOWN;
tv->v_type = VAR_NUMBER;
tv->vval.v_number = 0;
f_has(argvars, tv);
clear_tv(&argvars[0]);
++ppconst->pp_used;
return OK;
}
clear_tv(&argvars[0]);
}
if (generate_ppconst(cctx, ppconst) == FAIL)
return FAIL;
if (varlen >= sizeof(namebuf))
{
semsg(_("E1011: name too long: %s"), name);
return FAIL;
}
vim_strncpy(namebuf, *arg, varlen);
name = fname_trans_sid(namebuf, fname_buf, &tofree, &error);
*arg = skipwhite(*arg + varlen + 1);
if (compile_arguments(arg, cctx, &argcount) == FAIL)
goto theend;
if (ASCII_ISLOWER(*name) && name[1] != ':')
{
int idx;
// builtin function
idx = find_internal_func(name);
if (idx >= 0)
res = generate_BCALL(cctx, idx, argcount, argcount_init == 1);
else
semsg(_(e_unknownfunc), namebuf);
goto theend;
}
// If we can find the function by name generate the right call.
ufunc = find_func(name, FALSE, cctx);
if (ufunc != NULL)
{
res = generate_CALL(cctx, ufunc, argcount);
goto theend;
}
// If the name is a variable, load it and use PCALL.
// Not for g:Func(), we don't know if it is a variable or not.
p = namebuf;
if (STRNCMP(namebuf, "g:", 2) != 0
&& compile_load(&p, namebuf + varlen, cctx, FALSE) == OK)
{
garray_T *stack = &cctx->ctx_type_stack;
type_T *type;
type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
res = generate_PCALL(cctx, argcount, namebuf, type, FALSE);
goto theend;
}
// A global function may be defined only later. Need to figure out at
// runtime. Also handles a FuncRef at runtime.
if (STRNCMP(namebuf, "g:", 2) == 0)
res = generate_UCALL(cctx, name, argcount);
else
semsg(_(e_unknownfunc), namebuf);
theend:
vim_free(tofree);
return res;
}
// like NAMESPACE_CHAR but with 'a' and 'l'.
#define VIM9_NAMESPACE_CHAR (char_u *)"bgstvw"
/*
* Find the end of a variable or function name. Unlike find_name_end() this
* does not recognize magic braces.
* When "namespace" is TRUE recognize "b:", "s:", etc.
* Return a pointer to just after the name. Equal to "arg" if there is no
* valid name.
*/
static char_u *
to_name_end(char_u *arg, int namespace)
{
char_u *p;
// Quick check for valid starting character.
if (!eval_isnamec1(*arg))
return arg;
for (p = arg + 1; *p != NUL && eval_isnamec(*p); MB_PTR_ADV(p))
// Include a namespace such as "s:var" and "v:var". But "n:" is not
// and can be used in slice "[n:]".
if (*p == ':' && (p != arg + 1
|| !namespace
|| vim_strchr(VIM9_NAMESPACE_CHAR, *arg) == NULL))
break;
return p;
}
/*
* Like to_name_end() but also skip over a list or dict constant.
* This intentionally does not handle line continuation.
*/
char_u *
to_name_const_end(char_u *arg)
{
char_u *p = to_name_end(arg, TRUE);
typval_T rettv;
if (p == arg && *arg == '[')
{
// Can be "[1, 2, 3]->Func()".
if (eval_list(&p, &rettv, NULL, FALSE) == FAIL)
p = arg;
}
else if (p == arg && *arg == '#' && arg[1] == '{')
{
// Can be "#{a: 1}->Func()".
++p;
if (eval_dict(&p, &rettv, NULL, TRUE) == FAIL)
p = arg;
}
else if (p == arg && *arg == '{')
{
int ret = get_lambda_tv(&p, &rettv, NULL);
// Can be "{x -> ret}()".
// Can be "{'a': 1}->Func()".
if (ret == NOTDONE)
ret = eval_dict(&p, &rettv, NULL, FALSE);
if (ret != OK)
p = arg;
}
return p;
}
/*
* parse a list: [expr, expr]
* "*arg" points to the '['.
*/
static int
compile_list(char_u **arg, cctx_T *cctx)
{
char_u *p = skipwhite(*arg + 1);
char_u *whitep = *arg + 1;
int count = 0;
for (;;)
{
if (may_get_next_line(whitep, &p, cctx) == FAIL)
{
semsg(_(e_list_end), *arg);
return FAIL;
}
if (*p == ']')
{
++p;
// Allow for following comment, after at least one space.
if (VIM_ISWHITE(*p) && *skipwhite(p) == '#')
p += STRLEN(p);
break;
}
if (compile_expr0(&p, cctx) == FAIL)
break;
++count;
if (*p == ',')
{
++p;
if (*p != ']' && !IS_WHITE_OR_NUL(*p))
{
semsg(_(e_white_after), ",");
return FAIL;
}
}
whitep = p;
p = skipwhite(p);
}
*arg = p;
generate_NEWLIST(cctx, count);
return OK;
}
/*
* parse a lambda: {arg, arg -> expr}
* "*arg" points to the '{'.
*/
static int
compile_lambda(char_u **arg, cctx_T *cctx)
{
typval_T rettv;
ufunc_T *ufunc;
evalarg_T evalarg;
CLEAR_FIELD(evalarg);
evalarg.eval_flags = EVAL_EVALUATE;
evalarg.eval_cctx = cctx;
// Get the funcref in "rettv".
if (get_lambda_tv(arg, &rettv, &evalarg) != OK)
return FAIL;
ufunc = rettv.vval.v_partial->pt_func;
++ufunc->uf_refcount;
clear_tv(&rettv);
ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10);
// The function will have one line: "return {expr}".
// Compile it into instructions.
compile_def_function(ufunc, TRUE, cctx);
clear_evalarg(&evalarg, NULL);
if (ufunc->uf_def_status == UF_COMPILED)
return generate_FUNCREF(cctx, ufunc->uf_dfunc_idx);
func_ptr_unref(ufunc);
return FAIL;
}
/*
* Compile a lamda call: expr->{lambda}(args)
* "arg" points to the "{".
*/
static int
compile_lambda_call(char_u **arg, cctx_T *cctx)
{
ufunc_T *ufunc;
typval_T rettv;
int argcount = 1;
int ret = FAIL;
// Get the funcref in "rettv".
if (get_lambda_tv(arg, &rettv, &EVALARG_EVALUATE) == FAIL)
return FAIL;
if (**arg != '(')
{
if (*skipwhite(*arg) == '(')
emsg(_(e_nowhitespace));
else
semsg(_(e_missing_paren), "lambda");
clear_tv(&rettv);
return FAIL;
}
ufunc = rettv.vval.v_partial->pt_func;
++ufunc->uf_refcount;
clear_tv(&rettv);
ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10);
// The function will have one line: "return {expr}".
// Compile it into instructions.
compile_def_function(ufunc, TRUE, cctx);
// compile the arguments
*arg = skipwhite(*arg + 1);
if (compile_arguments(arg, cctx, &argcount) == OK)
// call the compiled function
ret = generate_CALL(cctx, ufunc, argcount);
if (ret == FAIL)
func_ptr_unref(ufunc);
return ret;
}
/*
* parse a dict: {'key': val} or #{key: val}
* "*arg" points to the '{'.
*/
static int
compile_dict(char_u **arg, cctx_T *cctx, int literal)
{
garray_T *instr = &cctx->ctx_instr;
garray_T *stack = &cctx->ctx_type_stack;
int count = 0;
dict_T *d = dict_alloc();
dictitem_T *item;
char_u *whitep = *arg;
char_u *p;
if (d == NULL)
return FAIL;
*arg = skipwhite(*arg + 1);
for (;;)
{
char_u *key = NULL;
if (may_get_next_line(whitep, arg, cctx) == FAIL)
{
*arg = NULL;
goto failret;
}
if (**arg == '}')
break;
if (literal)
{
char_u *end = to_name_end(*arg, !literal);
if (end == *arg)
{
semsg(_("E1014: Invalid key: %s"), *arg);
return FAIL;
}
key = vim_strnsave(*arg, end - *arg);
if (generate_PUSHS(cctx, key) == FAIL)
return FAIL;
*arg = end;
}
else
{
isn_T *isn;
if (compile_expr0(arg, cctx) == FAIL)
return FAIL;
isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
if (isn->isn_type == ISN_PUSHS)
key = isn->isn_arg.string;
else
{
type_T *keytype = ((type_T **)stack->ga_data)
[stack->ga_len - 1];
if (need_type(keytype, &t_string, -1, cctx, FALSE) == FAIL)
return FAIL;
}
}
// Check for duplicate keys, if using string keys.
if (key != NULL)
{
item = dict_find(d, key, -1);
if (item != NULL)
{
semsg(_(e_duplicate_key), key);
goto failret;
}
item = dictitem_alloc(key);
if (item != NULL)
{
item->di_tv.v_type = VAR_UNKNOWN;
item->di_tv.v_lock = 0;
if (dict_add(d, item) == FAIL)
dictitem_free(item);
}
}
*arg = skipwhite(*arg);
if (**arg != ':')
{
semsg(_(e_missing_dict_colon), *arg);
return FAIL;
}
whitep = *arg + 1;
*arg = skipwhite(*arg + 1);
if (may_get_next_line(whitep, arg, cctx) == FAIL)
{
*arg = NULL;
goto failret;
}
if (compile_expr0(arg, cctx) == FAIL)
return FAIL;
++count;
whitep = *arg;
*arg = skipwhite(*arg);
if (may_get_next_line(whitep, arg, cctx) == FAIL)
{
*arg = NULL;
goto failret;
}
if (**arg == '}')
break;
if (**arg != ',')
{
semsg(_(e_missing_dict_comma), *arg);
goto failret;
}
whitep = *arg + 1;
*arg = skipwhite(*arg + 1);
}
*arg = *arg + 1;
// Allow for following comment, after at least one space.
p = skipwhite(*arg);
if (VIM_ISWHITE(**arg) && vim9_comment_start(p))
*arg += STRLEN(*arg);
dict_unref(d);
return generate_NEWDICT(cctx, count);
failret:
if (*arg == NULL)
semsg(_(e_missing_dict_end), _("[end of lines]"));
dict_unref(d);
return FAIL;
}
/*
* Compile "&option".
*/
static int
compile_get_option(char_u **arg, cctx_T *cctx)
{
typval_T rettv;
char_u *start = *arg;
int ret;
// parse the option and get the current value to get the type.
rettv.v_type = VAR_UNKNOWN;
ret = eval_option(arg, &rettv, TRUE);
if (ret == OK)
{
// include the '&' in the name, eval_option() expects it.
char_u *name = vim_strnsave(start, *arg - start);
type_T *type = rettv.v_type == VAR_NUMBER ? &t_number : &t_string;
ret = generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
vim_free(name);
}
clear_tv(&rettv);
return ret;
}
/*
* Compile "$VAR".
*/
static int
compile_get_env(char_u **arg, cctx_T *cctx)
{
char_u *start = *arg;
int len;
int ret;
char_u *name;
++*arg;
len = get_env_len(arg);
if (len == 0)
{
semsg(_(e_syntax_at), start - 1);
return FAIL;
}
// include the '$' in the name, eval_env_var() expects it.
name = vim_strnsave(start, len + 1);
ret = generate_LOAD(cctx, ISN_LOADENV, 0, name, &t_string);
vim_free(name);
return ret;
}
/*
* Compile "@r".
*/
static int
compile_get_register(char_u **arg, cctx_T *cctx)
{
int ret;
++*arg;
if (**arg == NUL)
{
semsg(_(e_syntax_at), *arg - 1);
return FAIL;
}
if (!valid_yank_reg(**arg, TRUE))
{
emsg_invreg(**arg);
return FAIL;
}
ret = generate_LOAD(cctx, ISN_LOADREG, **arg, NULL, &t_string);
++*arg;
return ret;
}
/*
* Apply leading '!', '-' and '+' to constant "rettv".
*/
static int
apply_leader(typval_T *rettv, char_u *start, char_u *end)
{
char_u *p = end;
// this works from end to start
while (p > start)
{
--p;
if (*p == '-' || *p == '+')
{
// only '-' has an effect, for '+' we only check the type
#ifdef FEAT_FLOAT
if (rettv->v_type == VAR_FLOAT)
{
if (*p == '-')
rettv->vval.v_float = -rettv->vval.v_float;
}
else
#endif
{
varnumber_T val;
int error = FALSE;
// tv_get_number_chk() accepts a string, but we don't want that
// here
if (check_not_string(rettv) == FAIL)
return FAIL;
val = tv_get_number_chk(rettv, &error);
clear_tv(rettv);
if (error)
return FAIL;
if (*p == '-')
val = -val;
rettv->v_type = VAR_NUMBER;
rettv->vval.v_number = val;
}
}
else
{
int v = tv2bool(rettv);
// '!' is permissive in the type.
clear_tv(rettv);
rettv->v_type = VAR_BOOL;
rettv->vval.v_number = v ? VVAL_FALSE : VVAL_TRUE;
}
}
return OK;
}
/*
* Recognize v: variables that are constants and set "rettv".
*/
static void
get_vim_constant(char_u **arg, typval_T *rettv)
{
if (STRNCMP(*arg, "v:true", 6) == 0)
{
rettv->v_type = VAR_BOOL;
rettv->vval.v_number = VVAL_TRUE;
*arg += 6;
}
else if (STRNCMP(*arg, "v:false", 7) == 0)
{
rettv->v_type = VAR_BOOL;
rettv->vval.v_number = VVAL_FALSE;
*arg += 7;
}
else if (STRNCMP(*arg, "v:null", 6) == 0)
{
rettv->v_type = VAR_SPECIAL;
rettv->vval.v_number = VVAL_NULL;
*arg += 6;
}
else if (STRNCMP(*arg, "v:none", 6) == 0)
{
rettv->v_type = VAR_SPECIAL;
rettv->vval.v_number = VVAL_NONE;
*arg += 6;
}
}
exptype_T
get_compare_type(char_u *p, int *len, int *type_is)
{
exptype_T type = EXPR_UNKNOWN;
int i;
switch (p[0])
{
case '=': if (p[1] == '=')
type = EXPR_EQUAL;
else if (p[1] == '~')
type = EXPR_MATCH;
break;
case '!': if (p[1] == '=')
type = EXPR_NEQUAL;
else if (p[1] == '~')
type = EXPR_NOMATCH;
break;
case '>': if (p[1] != '=')
{
type = EXPR_GREATER;
*len = 1;
}
else
type = EXPR_GEQUAL;
break;
case '<': if (p[1] != '=')
{
type = EXPR_SMALLER;
*len = 1;
}
else
type = EXPR_SEQUAL;
break;
case 'i': if (p[1] == 's')
{
// "is" and "isnot"; but not a prefix of a name
if (p[2] == 'n' && p[3] == 'o' && p[4] == 't')
*len = 5;
i = p[*len];
if (!isalnum(i) && i != '_')
{
type = *len == 2 ? EXPR_IS : EXPR_ISNOT;
*type_is = TRUE;
}
}
break;
}
return type;
}
/*
* Compile code to apply '-', '+' and '!'.
*/
static int
compile_leader(cctx_T *cctx, char_u *start, char_u *end)
{
char_u *p = end;
// this works from end to start
while (p > start)
{
--p;
if (*p == '-' || *p == '+')
{
int negate = *p == '-';
isn_T *isn;
// TODO: check type
while (p > start && (p[-1] == '-' || p[-1] == '+'))
{
--p;
if (*p == '-')
negate = !negate;
}
// only '-' has an effect, for '+' we only check the type
if (negate)
isn = generate_instr(cctx, ISN_NEGATENR);
else
isn = generate_instr(cctx, ISN_CHECKNR);
if (isn == NULL)
return FAIL;
}
else
{
int invert = TRUE;
while (p > start && p[-1] == '!')
{
--p;
invert = !invert;
}
if (generate_2BOOL(cctx, invert) == FAIL)
return FAIL;
}
}
return OK;
}
/*
* Compile whatever comes after "name" or "name()".
* Advances "*arg" only when something was recognized.
*/
static int
compile_subscript(
char_u **arg,
cctx_T *cctx,
char_u **start_leader,
char_u *end_leader,
ppconst_T *ppconst)
{
for (;;)
{
char_u *p = skipwhite(*arg);
if (*p == NUL || (VIM_ISWHITE(**arg) && vim9_comment_start(p)))
{
char_u *next = peek_next_line_from_context(cctx);
// If a following line starts with "->{" or "->X" advance to that
// line, so that a line break before "->" is allowed.
// Also if a following line starts with ".x".
if (next != NULL &&
((next[0] == '-' && next[1] == '>'
&& (next[2] == '{' || ASCII_ISALPHA(next[2])))
|| (next[0] == '.' && eval_isdictc(next[1]))))
{
next = next_line_from_context(cctx, TRUE);
if (next == NULL)
return FAIL;
*arg = next;
p = skipwhite(*arg);
}
}
// Do not skip over white space to find the "(", "exeucte 'x' ()" is
// not a function call.
if (**arg == '(')
{
garray_T *stack = &cctx->ctx_type_stack;
type_T *type;
int argcount = 0;
if (generate_ppconst(cctx, ppconst) == FAIL)
return FAIL;
// funcref(arg)
type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
*arg = skipwhite(p + 1);
if (compile_arguments(arg, cctx, &argcount) == FAIL)
return FAIL;
if (generate_PCALL(cctx, argcount, end_leader, type, TRUE) == FAIL)
return FAIL;
}
else if (*p == '-' && p[1] == '>')
{
char_u *pstart = p;
if (generate_ppconst(cctx, ppconst) == FAIL)
return FAIL;
// something->method()
// Apply the '!', '-' and '+' first:
// -1.0->func() works like (-1.0)->func()
if (compile_leader(cctx, *start_leader, end_leader) == FAIL)
return FAIL;
*start_leader = end_leader; // don't apply again later
p += 2;
*arg = skipwhite(p);
// No line break supported right after "->".
if (**arg == '{')
{
// lambda call: list->{lambda}
if (compile_lambda_call(arg, cctx) == FAIL)
return FAIL;
}
else
{
// method call: list->method()
p = *arg;
if (!eval_isnamec1(*p))
{
semsg(_(e_trailing_arg), pstart);
return FAIL;
}
if (ASCII_ISALPHA(*p) && p[1] == ':')
p += 2;
for ( ; eval_isnamec1(*p); ++p)
;
if (*p != '(')
{
semsg(_(e_missing_paren), *arg);
return FAIL;
}
// TODO: base value may not be the first argument
if (compile_call(arg, p - *arg, cctx, ppconst, 1) == FAIL)
return FAIL;
}
}
else if (**arg == '[')
{
garray_T *stack = &cctx->ctx_type_stack;
type_T **typep;
vartype_T vtype;
// list index: list[123]
// dict member: dict[key]
// string index: text[123]
// TODO: blob index
// TODO: more arguments
// TODO: recognize list or dict at runtime
if (generate_ppconst(cctx, ppconst) == FAIL)
return FAIL;
++p;
*arg = skipwhite(p);
if (may_get_next_line_error(p, arg, cctx) == FAIL)
return FAIL;
if (compile_expr0(arg, cctx) == FAIL)
return FAIL;
if (may_get_next_line_error(p, arg, cctx) == FAIL)
return FAIL;
if (**arg != ']')
{
emsg(_(e_missbrac));
return FAIL;
}
*arg = *arg + 1;
// We can index a list and a dict. If we don't know the type
// we can use the index value type.
// TODO: If we don't know use an instruction to figure it out at
// runtime.
typep = ((type_T **)stack->ga_data) + stack->ga_len - 2;
vtype = (*typep)->tt_type;
if (*typep == &t_any)
{
type_T *valtype = ((type_T **)stack->ga_data)
[stack->ga_len - 1];
if (valtype == &t_string)
vtype = VAR_DICT;
}
if (vtype == VAR_DICT)
{
if ((*typep)->tt_type == VAR_DICT)
*typep = (*typep)->tt_member;
else
{
if (need_type(*typep, &t_dict_any, -2, cctx, FALSE) == FAIL)
return FAIL;
*typep = &t_any;
}
if (may_generate_2STRING(-1, cctx) == FAIL)
return FAIL;
if (generate_instr_drop(cctx, ISN_MEMBER, 1) == FAIL)
return FAIL;
}
else if (vtype == VAR_STRING)
{
*typep = &t_number;
if (generate_instr_drop(cctx, ISN_STRINDEX, 1) == FAIL)
return FAIL;
}
else if (vtype == VAR_LIST || *typep == &t_any)
{
if ((*typep)->tt_type == VAR_LIST)
*typep = (*typep)->tt_member;
if (generate_instr_drop(cctx, ISN_LISTINDEX, 1) == FAIL)
return FAIL;
}
else
{
emsg(_(e_listdictblobreq));
return FAIL;
}
}
else if (*p == '.' && p[1] != '.')
{
if (generate_ppconst(cctx, ppconst) == FAIL)
return FAIL;
*arg = p + 1;
if (may_get_next_line(*arg, arg, cctx) == FAIL)
return FAIL;
// dictionary member: dict.name
p = *arg;
if (eval_isdictc(*p))
while (eval_isnamec(*p))
MB_PTR_ADV(p);
if (p == *arg)
{
semsg(_(e_syntax_at), *arg);
return FAIL;
}
if (generate_STRINGMEMBER(cctx, *arg, p - *arg) == FAIL)
return FAIL;
*arg = p;
}
else
break;
}
// TODO - see handle_subscript():
// Turn "dict.Func" into a partial for "Func" bound to "dict".
// Don't do this when "Func" is already a partial that was bound
// explicitly (pt_auto is FALSE).
return OK;
}
/*
* Compile an expression at "*arg" and add instructions to "cctx->ctx_instr".
* "arg" is advanced until after the expression, skipping white space.
*
* If the value is a constant "ppconst->pp_ret" will be set.
* Before instructions are generated, any values in "ppconst" will generated.
*
* This is the compiling equivalent of eval1(), eval2(), etc.
*/
/*
* number number constant
* 0zFFFFFFFF Blob constant
* "string" string constant
* 'string' literal string constant
* &option-name option value
* @r register contents
* identifier variable value
* function() function call
* $VAR environment variable
* (expression) nested expression
* [expr, expr] List
* {key: val, key: val} Dictionary
* #{key: val, key: val} Dictionary with literal keys
*
* Also handle:
* ! in front logical NOT
* - in front unary minus
* + in front unary plus (ignored)
* trailing (arg) funcref/partial call
* trailing [] subscript in String or List
* trailing .name entry in Dictionary
* trailing ->name() method call
*/
static int
compile_expr7(
char_u **arg,
cctx_T *cctx,
ppconst_T *ppconst)
{
char_u *start_leader, *end_leader;
int ret = OK;
typval_T *rettv = &ppconst->pp_tv[ppconst->pp_used];
int used_before = ppconst->pp_used;
/*
* Skip '!', '-' and '+' characters. They are handled later.
*/
start_leader = *arg;
while (**arg == '!' || **arg == '-' || **arg == '+')
*arg = skipwhite(*arg + 1);
end_leader = *arg;
rettv->v_type = VAR_UNKNOWN;
switch (**arg)
{
/*
* Number constant.
*/
case '0': // also for blob starting with 0z
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '.': if (eval_number(arg, rettv, TRUE, FALSE) == FAIL)
return FAIL;
break;
/*
* String constant: "string".
*/
case '"': if (eval_string(arg, rettv, TRUE) == FAIL)
return FAIL;
break;
/*
* Literal string constant: 'str''ing'.
*/
case '\'': if (eval_lit_string(arg, rettv, TRUE) == FAIL)
return FAIL;
break;
/*
* Constant Vim variable.
*/
case 'v': get_vim_constant(arg, rettv);
ret = NOTDONE;
break;
/*
* "true" constant
*/
case 't': if (STRNCMP(*arg, "true", 4) == 0
&& !eval_isnamec((*arg)[4]))
{
*arg += 4;
rettv->v_type = VAR_BOOL;
rettv->vval.v_number = VVAL_TRUE;
}
else
ret = NOTDONE;
break;
/*
* "false" constant
*/
case 'f': if (STRNCMP(*arg, "false", 5) == 0
&& !eval_isnamec((*arg)[5]))
{
*arg += 5;
rettv->v_type = VAR_BOOL;
rettv->vval.v_number = VVAL_FALSE;
}
else
ret = NOTDONE;
break;
/*
* List: [expr, expr]
*/
case '[': ret = compile_list(arg, cctx);
break;
/*
* Dictionary: #{key: val, key: val}
*/
case '#': if ((*arg)[1] == '{')
{
++*arg;
ret = compile_dict(arg, cctx, TRUE);
}
else
ret = NOTDONE;
break;
/*
* Lambda: {arg, arg -> expr}
* Dictionary: {'key': val, 'key': val}
*/
case '{': {
char_u *start = skipwhite(*arg + 1);
// Find out what comes after the arguments.
ret = get_function_args(&start, '-', NULL,
NULL, NULL, NULL, TRUE, NULL, NULL);
if (ret != FAIL && *start == '>')
ret = compile_lambda(arg, cctx);
else
ret = compile_dict(arg, cctx, FALSE);
}
break;
/*
* Option value: &name
*/
case '&': ret = compile_get_option(arg, cctx);
break;
/*
* Environment variable: $VAR.
*/
case '$': ret = compile_get_env(arg, cctx);
break;
/*
* Register contents: @r.
*/
case '@': ret = compile_get_register(arg, cctx);
break;
/*
* nested expression: (expression).
*/
case '(': *arg = skipwhite(*arg + 1);
// recursive!
if (ppconst->pp_used <= PPSIZE - 10)
{
ret = compile_expr1(arg, cctx, ppconst);
}
else
{
// Not enough space in ppconst, flush constants.
if (generate_ppconst(cctx, ppconst) == FAIL)
return FAIL;
ret = compile_expr0(arg, cctx);
}
*arg = skipwhite(*arg);
if (**arg == ')')
++*arg;
else if (ret == OK)
{
emsg(_(e_missing_close));
ret = FAIL;
}
break;
default: ret = NOTDONE;
break;
}
if (ret == FAIL)
return FAIL;
if (rettv->v_type != VAR_UNKNOWN && used_before == ppconst->pp_used)
{
// apply the '!', '-' and '+' before the constant
if (apply_leader(rettv, start_leader, end_leader) == FAIL)
{
clear_tv(rettv);
return FAIL;
}
start_leader = end_leader; // don't apply again below
if (cctx->ctx_skip == SKIP_YES)
clear_tv(rettv);
else
// A constant expression can possibly be handled compile time,
// return the value instead of generating code.
++ppconst->pp_used;
}
else if (ret == NOTDONE)
{
char_u *p;
int r;
if (!eval_isnamec1(**arg))
{
semsg(_("E1015: Name expected: %s"), *arg);
return FAIL;
}
// "name" or "name()"
p = to_name_end(*arg, TRUE);
if (*p == '(')
{
r = compile_call(arg, p - *arg, cctx, ppconst, 0);
}
else
{
if (generate_ppconst(cctx, ppconst) == FAIL)
return FAIL;
r = compile_load(arg, p, cctx, TRUE);
}
if (r == FAIL)
return FAIL;
}
// Handle following "[]", ".member", etc.
// Then deal with prefixed '-', '+' and '!', if not done already.
if (compile_subscript(arg, cctx, &start_leader, end_leader,
ppconst) == FAIL)
return FAIL;
if (ppconst->pp_used > 0)
{
// apply the '!', '-' and '+' before the constant
rettv = &ppconst->pp_tv[ppconst->pp_used - 1];
if (apply_leader(rettv, start_leader, end_leader) == FAIL)
return FAIL;
return OK;
}
if (compile_leader(cctx, start_leader, end_leader) == FAIL)
return FAIL;
return OK;
}
/*
* * number multiplication
* / number division
* % number modulo
*/
static int
compile_expr6(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
{
char_u *op;
char_u *next;
int ppconst_used = ppconst->pp_used;
// get the first expression
if (compile_expr7(arg, cctx, ppconst) == FAIL)
return FAIL;
/*
* Repeat computing, until no "*", "/" or "%" is following.
*/
for (;;)
{
op = may_peek_next_line(cctx, *arg, &next);
if (*op != '*' && *op != '/' && *op != '%')
break;
if (next != NULL)
{
*arg = next_line_from_context(cctx, TRUE);
op = skipwhite(*arg);
}
if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[1]))
{
char_u buf[3];
vim_strncpy(buf, op, 1);
semsg(_(e_white_both), buf);
return FAIL;
}
*arg = skipwhite(op + 1);
if (may_get_next_line(op + 1, arg, cctx) == FAIL)
return FAIL;
// get the second expression
if (compile_expr7(arg, cctx, ppconst) == FAIL)
return FAIL;
if (ppconst->pp_used == ppconst_used + 2
&& ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER
&& ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER)
{
typval_T *tv1 = &ppconst->pp_tv[ppconst_used];
typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1];
varnumber_T res = 0;
// both are numbers: compute the result
switch (*op)
{
case '*': res = tv1->vval.v_number * tv2->vval.v_number;
break;
case '/': res = tv1->vval.v_number / tv2->vval.v_number;
break;
case '%': res = tv1->vval.v_number % tv2->vval.v_number;
break;
}
tv1->vval.v_number = res;
--ppconst->pp_used;
}
else
{
generate_ppconst(cctx, ppconst);
generate_two_op(cctx, op);
}
}
return OK;
}
/*
* + number addition
* - number subtraction
* .. string concatenation
*/
static int
compile_expr5(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
{
char_u *op;
char_u *next;
int oplen;
int ppconst_used = ppconst->pp_used;
// get the first variable
if (compile_expr6(arg, cctx, ppconst) == FAIL)
return FAIL;
/*
* Repeat computing, until no "+", "-" or ".." is following.
*/
for (;;)
{
op = may_peek_next_line(cctx, *arg, &next);
if (*op != '+' && *op != '-' && !(*op == '.' && *(op + 1) == '.'))
break;
oplen = (*op == '.' ? 2 : 1);
if (next != NULL)
{
*arg = next_line_from_context(cctx, TRUE);
op = skipwhite(*arg);
}
if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[oplen]))
{
char_u buf[3];
vim_strncpy(buf, op, oplen);
semsg(_(e_white_both), buf);
return FAIL;
}
*arg = skipwhite(op + oplen);
if (may_get_next_line(op + oplen, arg, cctx) == FAIL)
return FAIL;
// get the second expression
if (compile_expr6(arg, cctx, ppconst) == FAIL)
return FAIL;
if (ppconst->pp_used == ppconst_used + 2
&& (*op == '.'
? (ppconst->pp_tv[ppconst_used].v_type == VAR_STRING
&& ppconst->pp_tv[ppconst_used + 1].v_type == VAR_STRING)
: (ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER
&& ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER)))
{
typval_T *tv1 = &ppconst->pp_tv[ppconst_used];
typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1];
// concat/subtract/add constant numbers
if (*op == '+')
tv1->vval.v_number = tv1->vval.v_number + tv2->vval.v_number;
else if (*op == '-')
tv1->vval.v_number = tv1->vval.v_number - tv2->vval.v_number;
else
{
// concatenate constant strings
char_u *s1 = tv1->vval.v_string;
char_u *s2 = tv2->vval.v_string;
size_t len1 = STRLEN(s1);
tv1->vval.v_string = alloc((int)(len1 + STRLEN(s2) + 1));
if (tv1->vval.v_string == NULL)
{
clear_ppconst(ppconst);
return FAIL;
}
mch_memmove(tv1->vval.v_string, s1, len1);
STRCPY(tv1->vval.v_string + len1, s2);
vim_free(s1);
vim_free(s2);
}
--ppconst->pp_used;
}
else
{
generate_ppconst(cctx, ppconst);
if (*op == '.')
{
if (may_generate_2STRING(-2, cctx) == FAIL
|| may_generate_2STRING(-1, cctx) == FAIL)
return FAIL;
generate_instr_drop(cctx, ISN_CONCAT, 1);
}
else
generate_two_op(cctx, op);
}
}
return OK;
}
/*
* expr5a == expr5b
* expr5a =~ expr5b
* expr5a != expr5b
* expr5a !~ expr5b
* expr5a > expr5b
* expr5a >= expr5b
* expr5a < expr5b
* expr5a <= expr5b
* expr5a is expr5b
* expr5a isnot expr5b
*
* Produces instructions:
* EVAL expr5a Push result of "expr5a"
* EVAL expr5b Push result of "expr5b"
* COMPARE one of the compare instructions
*/
static int
compile_expr4(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
{
exptype_T type = EXPR_UNKNOWN;
char_u *p;
char_u *next;
int len = 2;
int type_is = FALSE;
int ppconst_used = ppconst->pp_used;
// get the first variable
if (compile_expr5(arg, cctx, ppconst) == FAIL)
return FAIL;
p = may_peek_next_line(cctx, *arg, &next);
type = get_compare_type(p, &len, &type_is);
/*
* If there is a comparative operator, use it.
*/
if (type != EXPR_UNKNOWN)
{
int ic = FALSE; // Default: do not ignore case
if (next != NULL)
{
*arg = next_line_from_context(cctx, TRUE);
p = skipwhite(*arg);
}
if (type_is && (p[len] == '?' || p[len] == '#'))
{
semsg(_(e_invexpr2), *arg);
return FAIL;
}
// extra question mark appended: ignore case
if (p[len] == '?')
{
ic = TRUE;
++len;
}
// extra '#' appended: match case (ignored)
else if (p[len] == '#')
++len;
// nothing appended: match case
if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[len]))
{
char_u buf[7];
vim_strncpy(buf, p, len);
semsg(_(e_white_both), buf);
return FAIL;
}
// get the second variable
*arg = skipwhite(p + len);
if (may_get_next_line(p + len, arg, cctx) == FAIL)
return FAIL;
if (compile_expr5(arg, cctx, ppconst) == FAIL)
return FAIL;
if (ppconst->pp_used == ppconst_used + 2)
{
typval_T * tv1 = &ppconst->pp_tv[ppconst->pp_used - 2];
typval_T *tv2 = &ppconst->pp_tv[ppconst->pp_used - 1];
int ret;
// Both sides are a constant, compute the result now.
// First check for a valid combination of types, this is more
// strict than typval_compare().
if (check_compare_types(type, tv1, tv2) == FAIL)
ret = FAIL;
else
{
ret = typval_compare(tv1, tv2, type, ic);
tv1->v_type = VAR_BOOL;
tv1->vval.v_number = tv1->vval.v_number
? VVAL_TRUE : VVAL_FALSE;
clear_tv(tv2);
--ppconst->pp_used;
}
return ret;
}
generate_ppconst(cctx, ppconst);
return generate_COMPARE(cctx, type, ic);
}
return OK;
}
static int compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst);
/*
* Compile || or &&.
*/
static int
compile_and_or(
char_u **arg,
cctx_T *cctx,
char *op,
ppconst_T *ppconst,
int ppconst_used UNUSED)
{
char_u *next;
char_u *p = may_peek_next_line(cctx, *arg, &next);
int opchar = *op;
if (p[0] == opchar && p[1] == opchar)
{
garray_T *instr = &cctx->ctx_instr;
garray_T end_ga;
/*
* Repeat until there is no following "||" or "&&"
*/
ga_init2(&end_ga, sizeof(int), 10);
while (p[0] == opchar && p[1] == opchar)
{
if (next != NULL)
{
*arg = next_line_from_context(cctx, TRUE);
p = skipwhite(*arg);
}
if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[2]))
{
semsg(_(e_white_both), op);
return FAIL;
}
// TODO: use ppconst if the value is a constant
generate_ppconst(cctx, ppconst);
if (ga_grow(&end_ga, 1) == FAIL)
{
ga_clear(&end_ga);
return FAIL;
}
*(((int *)end_ga.ga_data) + end_ga.ga_len) = instr->ga_len;
++end_ga.ga_len;
generate_JUMP(cctx, opchar == '|'
? JUMP_AND_KEEP_IF_TRUE : JUMP_AND_KEEP_IF_FALSE, 0);
// eval the next expression
*arg = skipwhite(p + 2);
if (may_get_next_line(p + 2, arg, cctx) == FAIL)
return FAIL;
if ((opchar == '|' ? compile_expr3(arg, cctx, ppconst)
: compile_expr4(arg, cctx, ppconst)) == FAIL)
{
ga_clear(&end_ga);
return FAIL;
}
p = may_peek_next_line(cctx, *arg, &next);
}
generate_ppconst(cctx, ppconst);
// Fill in the end label in all jumps.
while (end_ga.ga_len > 0)
{
isn_T *isn;
--end_ga.ga_len;
isn = ((isn_T *)instr->ga_data)
+ *(((int *)end_ga.ga_data) + end_ga.ga_len);
isn->isn_arg.jump.jump_where = instr->ga_len;
}
ga_clear(&end_ga);
}
return OK;
}
/*
* expr4a && expr4a && expr4a logical AND
*
* Produces instructions:
* EVAL expr4a Push result of "expr4a"
* JUMP_AND_KEEP_IF_FALSE end
* EVAL expr4b Push result of "expr4b"
* JUMP_AND_KEEP_IF_FALSE end
* EVAL expr4c Push result of "expr4c"
* end:
*/
static int
compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
{
int ppconst_used = ppconst->pp_used;
// get the first variable
if (compile_expr4(arg, cctx, ppconst) == FAIL)
return FAIL;
// || and && work almost the same
return compile_and_or(arg, cctx, "&&", ppconst, ppconst_used);
}
/*
* expr3a || expr3b || expr3c logical OR
*
* Produces instructions:
* EVAL expr3a Push result of "expr3a"
* JUMP_AND_KEEP_IF_TRUE end
* EVAL expr3b Push result of "expr3b"
* JUMP_AND_KEEP_IF_TRUE end
* EVAL expr3c Push result of "expr3c"
* end:
*/
static int
compile_expr2(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
{
int ppconst_used = ppconst->pp_used;
// eval the first expression
if (compile_expr3(arg, cctx, ppconst) == FAIL)
return FAIL;
// || and && work almost the same
return compile_and_or(arg, cctx, "||", ppconst, ppconst_used);
}
/*
* Toplevel expression: expr2 ? expr1a : expr1b
*
* Produces instructions:
* EVAL expr2 Push result of "expr"
* JUMP_IF_FALSE alt jump if false
* EVAL expr1a
* JUMP_ALWAYS end
* alt: EVAL expr1b
* end:
*/
static int
compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
{
char_u *p;
int ppconst_used = ppconst->pp_used;
char_u *next;
// Evaluate the first expression.
if (compile_expr2(arg, cctx, ppconst) == FAIL)
return FAIL;
p = may_peek_next_line(cctx, *arg, &next);
if (*p == '?')
{
garray_T *instr = &cctx->ctx_instr;
garray_T *stack = &cctx->ctx_type_stack;
int alt_idx = instr->ga_len;
int end_idx = 0;
isn_T *isn;
type_T *type1 = NULL;
type_T *type2;
int has_const_expr = FALSE;
int const_value = FALSE;
int save_skip = cctx->ctx_skip;
if (next != NULL)
{
*arg = next_line_from_context(cctx, TRUE);
p = skipwhite(*arg);
}
if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1]))
{
semsg(_(e_white_both), "?");
return FAIL;
}
if (ppconst->pp_used == ppconst_used + 1)
{
// the condition is a constant, we know whether the ? or the :
// expression is to be evaluated.
has_const_expr = TRUE;
const_value = tv2bool(&ppconst->pp_tv[ppconst_used]);
clear_tv(&ppconst->pp_tv[ppconst_used]);
--ppconst->pp_used;
cctx->ctx_skip = save_skip == SKIP_YES || !const_value
? SKIP_YES : SKIP_NOT;
}
else
{
generate_ppconst(cctx, ppconst);
generate_JUMP(cctx, JUMP_IF_FALSE, 0);
}
// evaluate the second expression; any type is accepted
*arg = skipwhite(p + 1);
if (may_get_next_line(p + 1, arg, cctx) == FAIL)
return FAIL;
if (compile_expr1(arg, cctx, ppconst) == FAIL)
return FAIL;
if (!has_const_expr)
{
generate_ppconst(cctx, ppconst);
// remember the type and drop it
--stack->ga_len;
type1 = ((type_T **)stack->ga_data)[stack->ga_len];
end_idx = instr->ga_len;
generate_JUMP(cctx, JUMP_ALWAYS, 0);
// jump here from JUMP_IF_FALSE
isn = ((isn_T *)instr->ga_data) + alt_idx;
isn->isn_arg.jump.jump_where = instr->ga_len;
}
// Check for the ":".
p = may_peek_next_line(cctx, *arg, &next);
if (*p != ':')
{
emsg(_(e_missing_colon));
return FAIL;
}
if (next != NULL)
{
*arg = next_line_from_context(cctx, TRUE);
p = skipwhite(*arg);
}
if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1]))
{
semsg(_(e_white_both), ":");
return FAIL;
}
// evaluate the third expression
if (has_const_expr)
cctx->ctx_skip = save_skip == SKIP_YES || const_value
? SKIP_YES : SKIP_NOT;
*arg = skipwhite(p + 1);
if (may_get_next_line(p + 1, arg, cctx) == FAIL)
return FAIL;
if (compile_expr1(arg, cctx, ppconst) == FAIL)
return FAIL;
if (!has_const_expr)
{
generate_ppconst(cctx, ppconst);
// If the types differ, the result has a more generic type.
type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1];
common_type(type1, type2, &type2, cctx->ctx_type_list);
// jump here from JUMP_ALWAYS
isn = ((isn_T *)instr->ga_data) + end_idx;
isn->isn_arg.jump.jump_where = instr->ga_len;
}
cctx->ctx_skip = save_skip;
}
return OK;
}
/*
* Toplevel expression.
*/
static int
compile_expr0(char_u **arg, cctx_T *cctx)
{
ppconst_T ppconst;
CLEAR_FIELD(ppconst);
if (compile_expr1(arg, cctx, &ppconst) == FAIL)
{
clear_ppconst(&ppconst);
return FAIL;
}
if (generate_ppconst(cctx, &ppconst) == FAIL)
return FAIL;
return OK;
}
/*
* compile "return [expr]"
*/
static char_u *
compile_return(char_u *arg, int set_return_type, cctx_T *cctx)
{
char_u *p = arg;
garray_T *stack = &cctx->ctx_type_stack;
type_T *stack_type;
if (*p != NUL && *p != '|' && *p != '\n')
{
// compile return argument into instructions
if (compile_expr0(&p, cctx) == FAIL)
return NULL;
stack_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
if (set_return_type)
cctx->ctx_ufunc->uf_ret_type = stack_type;
else
{
if (cctx->ctx_ufunc->uf_ret_type->tt_type == VAR_VOID
&& stack_type->tt_type != VAR_VOID
&& stack_type->tt_type != VAR_UNKNOWN)
{
emsg(_("E1096: Returning a value in a function without a return type"));
return NULL;
}
if (need_type(stack_type, cctx->ctx_ufunc->uf_ret_type, -1,
cctx, FALSE) == FAIL)
return NULL;
}
}
else
{
// "set_return_type" cannot be TRUE, only used for a lambda which
// always has an argument.
if (cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_VOID
&& cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_UNKNOWN)
{
emsg(_("E1003: Missing return value"));
return NULL;
}
// No argument, return zero.
generate_PUSHNR(cctx, 0);
}
if (generate_instr(cctx, ISN_RETURN) == NULL)
return NULL;
// "return val | endif" is possible
return skipwhite(p);
}
/*
* Get a line from the compilation context, compatible with exarg_T getline().
* Return a pointer to the line in allocated memory.
* Return NULL for end-of-file or some error.
*/
static char_u *
exarg_getline(
int c UNUSED,
void *cookie,
int indent UNUSED,
int do_concat UNUSED)
{
cctx_T *cctx = (cctx_T *)cookie;
if (cctx->ctx_lnum == cctx->ctx_ufunc->uf_lines.ga_len)
{
iemsg("Heredoc got to end");
return NULL;
}
++cctx->ctx_lnum;
return vim_strsave(((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)
[cctx->ctx_lnum]);
}
/*
* Compile a nested :def command.
*/
static char_u *
compile_nested_function(exarg_T *eap, cctx_T *cctx)
{
int is_global = *eap->arg == 'g' && eap->arg[1] == ':';
char_u *name_start = eap->arg;
char_u *name_end = to_name_end(eap->arg, is_global);
char_u *name = get_lambda_name();
lvar_T *lvar;
ufunc_T *ufunc;
int r;
eap->arg = name_end;
eap->getline = exarg_getline;
eap->cookie = cctx;
eap->skip = cctx->ctx_skip == SKIP_YES;
eap->forceit = FALSE;
ufunc = def_function(eap, name);
if (ufunc == NULL)
return NULL;
if (ufunc->uf_def_status == UF_TO_BE_COMPILED
&& compile_def_function(ufunc, TRUE, cctx) == FAIL)
return NULL;
if (is_global)
{
char_u *func_name = vim_strnsave(name_start + 2,
name_end - name_start - 2);
if (func_name == NULL)
r = FAIL;
else
r = generate_NEWFUNC(cctx, name, func_name);
}
else
{
// Define a local variable for the function reference.
lvar = reserve_local(cctx, name_start, name_end - name_start,
TRUE, ufunc->uf_func_type);
if (generate_FUNCREF(cctx, ufunc->uf_dfunc_idx) == FAIL)
return NULL;
r = generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL);
}
// TODO: warning for trailing text?
return r == FAIL ? NULL : (char_u *)"";
}
/*
* Return the length of an assignment operator, or zero if there isn't one.
*/
int
assignment_len(char_u *p, int *heredoc)
{
if (*p == '=')
{
if (p[1] == '<' && p[2] == '<')
{
*heredoc = TRUE;
return 3;
}
return 1;
}
if (vim_strchr((char_u *)"+-*/%", *p) != NULL && p[1] == '=')
return 2;
if (STRNCMP(p, "..=", 3) == 0)
return 3;
return 0;
}
// words that cannot be used as a variable
static char *reserved[] = {
"true",
"false",
NULL
};
typedef enum {
dest_local,
dest_option,
dest_env,
dest_global,
dest_buffer,
dest_window,
dest_tab,
dest_vimvar,
dest_script,
dest_reg,
} assign_dest_T;
/*
* Generate the load instruction for "name".
*/
static void
generate_loadvar(
cctx_T *cctx,
assign_dest_T dest,
char_u *name,
lvar_T *lvar,
type_T *type)
{
switch (dest)
{
case dest_option:
// TODO: check the option exists
generate_LOAD(cctx, ISN_LOADOPT, 0, name, type);
break;
case dest_global:
generate_LOAD(cctx, ISN_LOADG, 0, name + 2, type);
break;
case dest_buffer:
generate_LOAD(cctx, ISN_LOADB, 0, name + 2, type);
break;
case dest_window:
generate_LOAD(cctx, ISN_LOADW, 0, name + 2, type);
break;
case dest_tab:
generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type);
break;
case dest_script:
compile_load_scriptvar(cctx,
name + (name[1] == ':' ? 2 : 0), NULL, NULL, TRUE);
break;
case dest_env:
// Include $ in the name here
generate_LOAD(cctx, ISN_LOADENV, 0, name, type);
break;
case dest_reg:
generate_LOAD(cctx, ISN_LOADREG, name[1], NULL, &t_string);
break;
case dest_vimvar:
generate_LOADV(cctx, name + 2, TRUE);
break;
case dest_local:
if (lvar->lv_from_outer)
generate_LOAD(cctx, ISN_LOADOUTER, lvar->lv_idx,
NULL, type);
else
generate_LOAD(cctx, ISN_LOAD, lvar->lv_idx, NULL, type);
break;
}
}
void
vim9_declare_error(char_u *name)
{
char *scope = "";
switch (*name)
{
case 'g': scope = _("global"); break;
case 'b': scope = _("buffer"); break;
case 'w': scope = _("window"); break;
case 't': scope = _("tab"); break;
case 'v': scope = "v:"; break;
case '$': semsg(_(e_declare_env_var), name); return;
default: return;
}
semsg(_(e_declare_var), scope, name);
}
/*
* Compile declaration and assignment:
* "let var", "let var = expr", "const var = expr" and "var = expr"
* "arg" points to "var".
* Return NULL for an error.
* Return "arg" if it does not look like a variable list.
*/
static char_u *
compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
{
char_u *var_start;
char_u *p;
char_u *end = arg;
char_u *ret = NULL;
int var_count = 0;
int var_idx;
int scriptvar_sid = 0;
int scriptvar_idx = -1;
int semicolon = 0;
garray_T *instr = &cctx->ctx_instr;
garray_T *stack = &cctx->ctx_type_stack;
char_u *op;
int oplen = 0;
int heredoc = FALSE;
type_T *type = &t_any;
type_T *member_type = &t_any;
char_u *name = NULL;
char_u *sp;
int is_decl = cmdidx == CMD_let || cmdidx == CMD_const;
// Skip over the "var" or "[var, var]" to get to any "=".
p = skip_var_list(arg, TRUE, &var_count, &semicolon, TRUE);
if (p == NULL)
return *arg == '[' ? arg : NULL;
if (var_count > 0 && is_decl)
{
// TODO: should we allow this, and figure out type inference from list
// members?
emsg(_("E1092: Cannot use a list for a declaration"));
return NULL;
}
sp = p;
p = skipwhite(p);
op = p;
oplen = assignment_len(p, &heredoc);
if (var_count > 0 && oplen == 0)
// can be something like "[1, 2]->func()"
return arg;
if (oplen > 0 && (!VIM_ISWHITE(*sp) || !VIM_ISWHITE(op[oplen])))
{
char_u buf[4];
vim_strncpy(buf, op, oplen);
semsg(_(e_white_both), buf);
return NULL;
}
if (heredoc)
{
list_T *l;
listitem_T *li;
// [let] varname =<< [trim] {end}
eap->getline = exarg_getline;
eap->cookie = cctx;
l = heredoc_get(eap, op + 3, FALSE);
// Push each line and the create the list.
FOR_ALL_LIST_ITEMS(l, li)
{
generate_PUSHS(cctx, li->li_tv.vval.v_string);
li->li_tv.vval.v_string = NULL;
}
generate_NEWLIST(cctx, l->lv_len);
type = &t_list_string;
member_type = &t_list_string;
list_free(l);
p += STRLEN(p);
end = p;
}
else if (var_count > 0)
{
// for "[var, var] = expr" evaluate the expression here, loop over the
// list of variables below.
p = skipwhite(op + oplen);
if (compile_expr0(&p, cctx) == FAIL)
return NULL;
end = p;
if (cctx->ctx_skip != SKIP_YES)
{
type_T *stacktype;
stacktype = stack->ga_len == 0 ? &t_void
: ((type_T **)stack->ga_data)[stack->ga_len - 1];
if (stacktype->tt_type == VAR_VOID)
{
emsg(_(e_cannot_use_void));
goto theend;
}
if (need_type(stacktype, &t_list_any, -1, cctx, FALSE) == FAIL)
goto theend;
// TODO: check the length of a constant list here
generate_CHECKLEN(cctx, semicolon ? var_count - 1 : var_count,
semicolon);
}
}
/*
* Loop over variables in "[var, var] = expr".
* For "var = expr" and "let var: type" this is done only once.
*/
if (var_count > 0)
var_start = skipwhite(arg + 1); // skip over the "["
else
var_start = arg;
for (var_idx = 0; var_idx == 0 || var_idx < var_count; var_idx++)
{
char_u *var_end = skip_var_one(var_start, FALSE);
size_t varlen;
int new_local = FALSE;
int opt_type;
int opt_flags = 0;
assign_dest_T dest = dest_local;
int vimvaridx = -1;
lvar_T *lvar = NULL;
lvar_T arg_lvar;
int has_type = FALSE;
int has_index = FALSE;
int instr_count = -1;
p = (*var_start == '&' || *var_start == '$'
|| *var_start == '@') ? var_start + 1 : var_start;
p = to_name_end(p, TRUE);
// "a: type" is declaring variable "a" with a type, not "a:".
if (is_decl && var_end == var_start + 2 && var_end[-1] == ':')
--var_end;
if (is_decl && p == var_start + 2 && p[-1] == ':')
--p;
varlen = p - var_start;
vim_free(name);
name = vim_strnsave(var_start, varlen);
if (name == NULL)
return NULL;
if (!heredoc)
type = &t_any;
if (cctx->ctx_skip != SKIP_YES)
{
if (*var_start == '&')
{
int cc;
long numval;
dest = dest_option;
if (cmdidx == CMD_const)
{
emsg(_(e_const_option));
goto theend;
}
if (is_decl)
{
semsg(_("E1052: Cannot declare an option: %s"), var_start);
goto theend;
}
p = var_start;
p = find_option_end(&p, &opt_flags);
if (p == NULL)
{
// cannot happen?
emsg(_(e_letunexp));
goto theend;
}
cc = *p;
*p = NUL;
opt_type = get_option_value(var_start + 1, &numval,
NULL, opt_flags);
*p = cc;
if (opt_type == -3)
{
semsg(_(e_unknown_option), var_start);
goto theend;
}
if (opt_type == -2 || opt_type == 0)
type = &t_string;
else
type = &t_number; // both number and boolean option
}
else if (*var_start == '$')
{
dest = dest_env;
type = &t_string;
if (is_decl)
{
vim9_declare_error(name);
goto theend;
}
}
else if (*var_start == '@')
{
if (!valid_yank_reg(var_start[1], TRUE))
{
emsg_invreg(var_start[1]);
goto theend;
}
dest = dest_reg;
type = &t_string;
if (is_decl)
{
semsg(_("E1066: Cannot declare a register: %s"), name);
goto theend;
}
}
else if (varlen > 1 && STRNCMP(var_start, "g:", 2) == 0)
{
dest = dest_global;
if (is_decl)
{
vim9_declare_error(name);
goto theend;
}
}
else if (varlen > 1 && STRNCMP(var_start, "b:", 2) == 0)
{
dest = dest_buffer;
if (is_decl)
{
vim9_declare_error(name);
goto theend;
}
}
else if (varlen > 1 && STRNCMP(var_start, "w:", 2) == 0)
{
dest = dest_window;
if (is_decl)
{
vim9_declare_error(name);
goto theend;
}
}
else if (varlen > 1 && STRNCMP(var_start, "t:", 2) == 0)
{
dest = dest_tab;
if (is_decl)
{
vim9_declare_error(name);
goto theend;
}
}
else if (varlen > 1 && STRNCMP(var_start, "v:", 2) == 0)
{
typval_T *vtv;
int di_flags;
vimvaridx = find_vim_var(name + 2, &di_flags);
if (vimvaridx < 0)
{
semsg(_(e_var_notfound), var_start);
goto theend;
}
// We use the current value of "sandbox" here, is that OK?
if (var_check_ro(di_flags, name, FALSE))
goto theend;
dest = dest_vimvar;
vtv = get_vim_var_tv(vimvaridx);
type = typval2type_vimvar(vtv, cctx->ctx_type_list);
if (is_decl)
{
vim9_declare_error(name);
goto theend;
}
}
else
{
int idx;
imported_T *import = NULL;
for (idx = 0; reserved[idx] != NULL; ++idx)
if (STRCMP(reserved[idx], name) == 0)
{
semsg(_("E1034: Cannot use reserved name %s"), name);
goto theend;
}
lvar = lookup_local(var_start, varlen, cctx);
if (lvar == NULL)
{
CLEAR_FIELD(arg_lvar);
if (lookup_arg(var_start, varlen,
&arg_lvar.lv_idx, &arg_lvar.lv_type,
&arg_lvar.lv_from_outer, cctx) == OK)
{
if (is_decl)
{
semsg(_(e_used_as_arg), name);
goto theend;
}
lvar = &arg_lvar;
}
}
if (lvar != NULL)
{
if (is_decl)
{
semsg(_("E1017: Variable already declared: %s"), name);
goto theend;
}
else if (lvar->lv_const)
{
semsg(_("E1018: Cannot assign to a constant: %s"),
name);
goto theend;
}
}
else if ((varlen > 1 && STRNCMP(var_start, "s:", 2) == 0)
|| lookup_script(var_start, varlen) == OK
|| (import = find_imported(var_start, varlen, cctx))
!= NULL)
{
char_u *rawname = name + (name[1] == ':' ? 2 : 0);
if (is_decl)
{
if ((varlen > 1 && STRNCMP(var_start, "s:", 2) == 0))
semsg(_("E1101: Cannot declare a script variable in a function: %s"),
name);
else
semsg(_("E1054: Variable already declared in the script: %s"),
name);
goto theend;
}
dest = dest_script;
// existing script-local variables should have a type
scriptvar_sid = current_sctx.sc_sid;
if (import != NULL)
scriptvar_sid = import->imp_sid;
scriptvar_idx = get_script_item_idx(scriptvar_sid,
rawname, TRUE);
if (scriptvar_idx >= 0)
{
scriptitem_T *si = SCRIPT_ITEM(scriptvar_sid);
svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data)
+ scriptvar_idx;
type = sv->sv_type;
}
}
else if (name[1] == ':' && name[2] != NUL)
{
semsg(_("E1082: Cannot use a namespaced variable: %s"),
name);
goto theend;
}
else if (!is_decl)
{
semsg(_("E1089: unknown variable: %s"), name);
goto theend;
}
}
}
// handle "a:name" as a name, not index "name" on "a"
if (varlen > 1 || var_start[varlen] != ':')
p = var_end;
if (dest != dest_option)
{
if (is_decl && *p == ':')
{
// parse optional type: "let var: type = expr"
if (!VIM_ISWHITE(p[1]))
{
semsg(_(e_white_after), ":");
goto theend;
}
p = skipwhite(p + 1);
type = parse_type(&p, cctx->ctx_type_list);
has_type = TRUE;
}
else if (lvar != NULL)
type = lvar->lv_type;
}
if (oplen == 3 && !heredoc && dest != dest_global
&& type->tt_type != VAR_STRING
&& type->tt_type != VAR_ANY)
{
emsg(_("E1019: Can only concatenate to string"));
goto theend;
}
if (lvar == NULL && dest == dest_local && cctx->ctx_skip != SKIP_YES)
{
if (oplen > 1 && !heredoc)
{
// +=, /=, etc. require an existing variable
semsg(_("E1020: cannot use an operator on a new variable: %s"),
name);
goto theend;
}
// new local variable
if (type->tt_type == VAR_FUNC && var_check_func_name(name, TRUE))
goto theend;
lvar = reserve_local(cctx, var_start, varlen,
cmdidx == CMD_const, type);
if (lvar == NULL)
goto theend;
new_local = TRUE;
}
member_type = type;
if (var_end > var_start + varlen)
{
// Something follows after the variable: "var[idx]".
if (is_decl)
{
emsg(_("E1087: cannot use an index when declaring a variable"));
goto theend;
}
if (var_start[varlen] == '[')
{
has_index = TRUE;
if (type->tt_member == NULL)
member_type = &t_any;
else
member_type = type->tt_member;
}
else
{
semsg("Not supported yet: %s", var_start);
goto theend;
}
}
else if (lvar == &arg_lvar)
{
semsg(_("E1090: Cannot assign to argument %s"), name);
goto theend;
}
if (!heredoc)
{
if (cctx->ctx_skip == SKIP_YES)
{
if (oplen > 0 && var_count == 0)
{
// skip over the "=" and the expression
p = skipwhite(op + oplen);
compile_expr0(&p, cctx);
}
}
else if (oplen > 0)
{
type_T *stacktype;
// For "var = expr" evaluate the expression.
if (var_count == 0)
{
int r;
// for "+=", "*=", "..=" etc. first load the current value
if (*op != '=')
{
generate_loadvar(cctx, dest, name, lvar, type);
if (has_index)
{
// TODO: get member from list or dict
emsg("Index with operation not supported yet");
goto theend;
}
}
// Compile the expression. Temporarily hide the new local
// variable here, it is not available to this expression.
if (new_local)
--cctx->ctx_locals.ga_len;
instr_count = instr->ga_len;
p = skipwhite(op + oplen);
r = compile_expr0(&p, cctx);
if (new_local)
++cctx->ctx_locals.ga_len;
if (r == FAIL)
goto theend;
}
else if (semicolon && var_idx == var_count - 1)
{
// For "[var; var] = expr" get the rest of the list
if (generate_SLICE(cctx, var_count - 1) == FAIL)
goto theend;
}
else
{
// For "[var, var] = expr" get the "var_idx" item from the
// list.
if (generate_GETITEM(cctx, var_idx) == FAIL)
return FAIL;
}
stacktype = stack->ga_len == 0 ? &t_void
: ((type_T **)stack->ga_data)[stack->ga_len - 1];
if (lvar != NULL && (is_decl || !has_type))
{
if (new_local && !has_type)
{
if (stacktype->tt_type == VAR_VOID)
{
emsg(_(e_cannot_use_void));
goto theend;
}
else
{
// An empty list or dict has a &t_void member,
// for a variable that implies &t_any.
if (stacktype == &t_list_empty)
lvar->lv_type = &t_list_any;
else if (stacktype == &t_dict_empty)
lvar->lv_type = &t_dict_any;
else
lvar->lv_type = stacktype;
}
}
else
{
type_T *use_type = lvar->lv_type;
if (has_index)
{
use_type = use_type->tt_member;
if (use_type == NULL)
use_type = &t_void;
}
if (need_type(stacktype, use_type, -1, cctx, FALSE)
== FAIL)
goto theend;
}
}
else if (*p != '=' && need_type(stacktype, member_type, -1,
cctx, FALSE) == FAIL)
goto theend;
}
else if (cmdidx == CMD_const)
{
emsg(_(e_const_req_value));
goto theend;
}
else if (!has_type || dest == dest_option)
{
emsg(_(e_type_req));
goto theend;
}
else
{
// variables are always initialized
if (ga_grow(instr, 1) == FAIL)
goto theend;
switch (member_type->tt_type)
{
case VAR_BOOL:
generate_PUSHBOOL(cctx, VVAL_FALSE);
break;
case VAR_FLOAT:
#ifdef FEAT_FLOAT
generate_PUSHF(cctx, 0.0);
#endif
break;
case VAR_STRING:
generate_PUSHS(cctx, NULL);
break;
case VAR_BLOB:
generate_PUSHBLOB(cctx, NULL);
break;
case VAR_FUNC:
generate_PUSHFUNC(cctx, NULL, &t_func_void);
break;
case VAR_LIST:
generate_NEWLIST(cctx, 0);
break;
case VAR_DICT:
generate_NEWDICT(cctx, 0);
break;
case VAR_JOB:
generate_PUSHJOB(cctx, NULL);
break;
case VAR_CHANNEL:
generate_PUSHCHANNEL(cctx, NULL);
break;
case VAR_NUMBER:
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_PARTIAL:
case VAR_VOID:
case VAR_SPECIAL: // cannot happen
generate_PUSHNR(cctx, 0);
break;
}
}
if (var_count == 0)
end = p;
}
// no need to parse more when skipping
if (cctx->ctx_skip == SKIP_YES)
break;
if (oplen > 0 && *op != '=')
{
type_T *expected = &t_number;
type_T *stacktype;
// TODO: if type is known use float or any operation
if (*op == '.')
expected = &t_string;
stacktype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
if (need_type(stacktype, expected, -1, cctx, FALSE) == FAIL)
goto theend;
if (*op == '.')
generate_instr_drop(cctx, ISN_CONCAT, 1);
else
{
isn_T *isn = generate_instr_drop(cctx, ISN_OPNR, 1);
if (isn == NULL)
goto theend;
switch (*op)
{
case '+': isn->isn_arg.op.op_type = EXPR_ADD; break;
case '-': isn->isn_arg.op.op_type = EXPR_SUB; break;
case '*': isn->isn_arg.op.op_type = EXPR_MULT; break;
case '/': isn->isn_arg.op.op_type = EXPR_DIV; break;
case '%': isn->isn_arg.op.op_type = EXPR_REM; break;
}
}
}
if (has_index)
{
int r;
// Compile the "idx" in "var[idx]".
if (new_local)
--cctx->ctx_locals.ga_len;
p = skipwhite(var_start + varlen + 1);
r = compile_expr0(&p, cctx);
if (new_local)
++cctx->ctx_locals.ga_len;
if (r == FAIL)
goto theend;
if (*skipwhite(p) != ']')
{
emsg(_(e_missbrac));
goto theend;
}
if (type == &t_any)
{
type_T *idx_type = ((type_T **)stack->ga_data)[
stack->ga_len - 1];
// Index on variable of unknown type: guess the type from the
// index type: number is dict, otherwise dict.
// TODO: should do the assignment at runtime
if (idx_type->tt_type == VAR_NUMBER)
type = &t_list_any;
else
type = &t_dict_any;
}
if (type->tt_type == VAR_DICT
&& may_generate_2STRING(-1, cctx) == FAIL)
goto theend;
if (type->tt_type == VAR_LIST
&& ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type
!= VAR_NUMBER)
{
emsg(_(e_number_exp));
goto theend;
}
// Load the dict or list. On the stack we then have:
// - value
// - index
// - variable
generate_loadvar(cctx, dest, name, lvar, type);
if (type->tt_type == VAR_LIST)
{
if (generate_instr_drop(cctx, ISN_STORELIST, 3) == FAIL)
return FAIL;
}
else if (type->tt_type == VAR_DICT)
{
if (generate_instr_drop(cctx, ISN_STOREDICT, 3) == FAIL)
return FAIL;
}
else
{
emsg(_(e_listreq));
goto theend;
}
}
else
{
switch (dest)
{
case dest_option:
generate_STOREOPT(cctx, name + 1, opt_flags);
break;
case dest_global:
// include g: with the name, easier to execute that way
generate_STORE(cctx, ISN_STOREG, 0, name);
break;
case dest_buffer:
// include b: with the name, easier to execute that way
generate_STORE(cctx, ISN_STOREB, 0, name);
break;
case dest_window:
// include w: with the name, easier to execute that way
generate_STORE(cctx, ISN_STOREW, 0, name);
break;
case dest_tab:
// include t: with the name, easier to execute that way
generate_STORE(cctx, ISN_STORET, 0, name);
break;
case dest_env:
generate_STORE(cctx, ISN_STOREENV, 0, name + 1);
break;
case dest_reg:
generate_STORE(cctx, ISN_STOREREG, name[1], NULL);
break;
case dest_vimvar:
generate_STORE(cctx, ISN_STOREV, vimvaridx, NULL);
break;
case dest_script:
{
if (scriptvar_idx < 0)
{
char_u *name_s = name;
// Include s: in the name for store_var()
if (name[1] != ':')
{
int len = (int)STRLEN(name) + 3;
name_s = alloc(len);
if (name_s == NULL)
name_s = name;
else
vim_snprintf((char *)name_s, len,
"s:%s", name);
}
generate_OLDSCRIPT(cctx, ISN_STORES, name_s,
scriptvar_sid, type);
if (name_s != name)
vim_free(name_s);
}
else
generate_VIM9SCRIPT(cctx, ISN_STORESCRIPT,
scriptvar_sid, scriptvar_idx, type);
}
break;
case dest_local:
if (lvar != NULL)
{
isn_T *isn = ((isn_T *)instr->ga_data)
+ instr->ga_len - 1;
// optimization: turn "var = 123" from ISN_PUSHNR +
// ISN_STORE into ISN_STORENR
if (!lvar->lv_from_outer
&& instr->ga_len == instr_count + 1
&& isn->isn_type == ISN_PUSHNR)
{
varnumber_T val = isn->isn_arg.number;
isn->isn_type = ISN_STORENR;
isn->isn_arg.storenr.stnr_idx = lvar->lv_idx;
isn->isn_arg.storenr.stnr_val = val;
if (stack->ga_len > 0)
--stack->ga_len;
}
else if (lvar->lv_from_outer)
generate_STORE(cctx, ISN_STOREOUTER, lvar->lv_idx,
NULL);
else
generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL);
}
break;
}
}
if (var_idx + 1 < var_count)
var_start = skipwhite(var_end + 1);
}
// for "[var, var] = expr" drop the "expr" value
if (var_count > 0 && !semicolon)
{
if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
goto theend;
}
ret = skipwhite(end);
theend:
vim_free(name);
return ret;
}
/*
* Check if "name" can be "unlet".
*/
int
check_vim9_unlet(char_u *name)
{
if (name[1] != ':' || vim_strchr((char_u *)"gwtb", *name) == NULL)
{
semsg(_("E1081: Cannot unlet %s"), name);
return FAIL;
}
return OK;
}
/*
* Callback passed to ex_unletlock().
*/
static int
compile_unlet(
lval_T *lvp,
char_u *name_end,
exarg_T *eap,
int deep UNUSED,
void *coookie)
{
cctx_T *cctx = coookie;
if (lvp->ll_tv == NULL)
{
char_u *p = lvp->ll_name;
int cc = *name_end;
int ret = OK;
// Normal name. Only supports g:, w:, t: and b: namespaces.
*name_end = NUL;
if (*p == '$')
ret = generate_UNLET(cctx, ISN_UNLETENV, p + 1, eap->forceit);
else if (check_vim9_unlet(p) == FAIL)
ret = FAIL;
else
ret = generate_UNLET(cctx, ISN_UNLET, p, eap->forceit);
*name_end = cc;
return ret;
}
// TODO: unlet {list}[idx]
// TODO: unlet {dict}[key]
emsg("Sorry, :unlet not fully implemented yet");
return FAIL;
}
/*
* compile "unlet var", "lock var" and "unlock var"
* "arg" points to "var".
*/
static char_u *
compile_unletlock(char_u *arg, exarg_T *eap, cctx_T *cctx)
{
char_u *p = arg;
if (eap->cmdidx != CMD_unlet)
{
emsg("Sorry, :lock and unlock not implemented yet");
return NULL;
}
if (*p == '!')
{
p = skipwhite(p + 1);
eap->forceit = TRUE;
}
ex_unletlock(eap, p, 0, GLV_NO_AUTOLOAD, compile_unlet, cctx);
return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd;
}
/*
* Compile an :import command.
*/
static char_u *
compile_import(char_u *arg, cctx_T *cctx)
{
return handle_import(arg, &cctx->ctx_imports, 0, NULL, cctx);
}
/*
* generate a jump to the ":endif"/":endfor"/":endwhile"/":finally"/":endtry".
*/
static int
compile_jump_to_end(endlabel_T **el, jumpwhen_T when, cctx_T *cctx)
{
garray_T *instr = &cctx->ctx_instr;
endlabel_T *endlabel = ALLOC_CLEAR_ONE(endlabel_T);
if (endlabel == NULL)
return FAIL;
endlabel->el_next = *el;
*el = endlabel;
endlabel->el_end_label = instr->ga_len;
generate_JUMP(cctx, when, 0);
return OK;
}
static void
compile_fill_jump_to_end(endlabel_T **el, cctx_T *cctx)
{
garray_T *instr = &cctx->ctx_instr;
while (*el != NULL)
{
endlabel_T *cur = (*el);
isn_T *isn;
isn = ((isn_T *)instr->ga_data) + cur->el_end_label;
isn->isn_arg.jump.jump_where = instr->ga_len;
*el = cur->el_next;
vim_free(cur);
}
}
static void
compile_free_jump_to_end(endlabel_T **el)
{
while (*el != NULL)
{
endlabel_T *cur = (*el);
*el = cur->el_next;
vim_free(cur);
}
}
/*
* Create a new scope and set up the generic items.
*/
static scope_T *
new_scope(cctx_T *cctx, scopetype_T type)
{
scope_T *scope = ALLOC_CLEAR_ONE(scope_T);
if (scope == NULL)
return NULL;
scope->se_outer = cctx->ctx_scope;
cctx->ctx_scope = scope;
scope->se_type = type;
scope->se_local_count = cctx->ctx_locals.ga_len;
return scope;
}
/*
* Free the current scope and go back to the outer scope.
*/
static void
drop_scope(cctx_T *cctx)
{
scope_T *scope = cctx->ctx_scope;
if (scope == NULL)
{
iemsg("calling drop_scope() without a scope");
return;
}
cctx->ctx_scope = scope->se_outer;
switch (scope->se_type)
{
case IF_SCOPE:
compile_free_jump_to_end(&scope->se_u.se_if.is_end_label); break;
case FOR_SCOPE:
compile_free_jump_to_end(&scope->se_u.se_for.fs_end_label); break;
case WHILE_SCOPE:
compile_free_jump_to_end(&scope->se_u.se_while.ws_end_label); break;
case TRY_SCOPE:
compile_free_jump_to_end(&scope->se_u.se_try.ts_end_label); break;
case NO_SCOPE:
case BLOCK_SCOPE:
break;
}
vim_free(scope);
}
/*
* compile "if expr"
*
* "if expr" Produces instructions:
* EVAL expr Push result of "expr"
* JUMP_IF_FALSE end
* ... body ...
* end:
*
* "if expr | else" Produces instructions:
* EVAL expr Push result of "expr"
* JUMP_IF_FALSE else
* ... body ...
* JUMP_ALWAYS end
* else:
* ... body ...
* end:
*
* "if expr1 | elseif expr2 | else" Produces instructions:
* EVAL expr Push result of "expr"
* JUMP_IF_FALSE elseif
* ... body ...
* JUMP_ALWAYS end
* elseif:
* EVAL expr Push result of "expr"
* JUMP_IF_FALSE else
* ... body ...
* JUMP_ALWAYS end
* else:
* ... body ...
* end:
*/
static char_u *
compile_if(char_u *arg, cctx_T *cctx)
{
char_u *p = arg;
garray_T *instr = &cctx->ctx_instr;
int instr_count = instr->ga_len;
scope_T *scope;
skip_T skip_save = cctx->ctx_skip;
ppconst_T ppconst;
CLEAR_FIELD(ppconst);
if (compile_expr1(&p, cctx, &ppconst) == FAIL)
{
clear_ppconst(&ppconst);
return NULL;
}
if (cctx->ctx_skip == SKIP_YES)
clear_ppconst(&ppconst);
else if (instr->ga_len == instr_count && ppconst.pp_used == 1)
{
// The expression results in a constant.
cctx->ctx_skip = tv2bool(&ppconst.pp_tv[0]) ? SKIP_NOT : SKIP_YES;
clear_ppconst(&ppconst);
}
else
{
// Not a constant, generate instructions for the expression.
cctx->ctx_skip = SKIP_UNKNOWN;
if (generate_ppconst(cctx, &ppconst) == FAIL)
return NULL;
}
scope = new_scope(cctx, IF_SCOPE);
if (scope == NULL)
return NULL;
scope->se_skip_save = skip_save;
// "is_had_return" will be reset if any block does not end in :return
scope->se_u.se_if.is_had_return = TRUE;
if (cctx->ctx_skip == SKIP_UNKNOWN)
{
// "where" is set when ":elseif", "else" or ":endif" is found
scope->se_u.se_if.is_if_label = instr->ga_len;
generate_JUMP(cctx, JUMP_IF_FALSE, 0);
}
else
scope->se_u.se_if.is_if_label = -1;
return p;
}
static char_u *
compile_elseif(char_u *arg, cctx_T *cctx)
{
char_u *p = arg;
garray_T *instr = &cctx->ctx_instr;
int instr_count = instr->ga_len;
isn_T *isn;
scope_T *scope = cctx->ctx_scope;
ppconst_T ppconst;
if (scope == NULL || scope->se_type != IF_SCOPE)
{
emsg(_(e_elseif_without_if));
return NULL;
}
unwind_locals(cctx, scope->se_local_count);
if (!cctx->ctx_had_return)
scope->se_u.se_if.is_had_return = FALSE;
if (cctx->ctx_skip == SKIP_UNKNOWN)
{
if (compile_jump_to_end(&scope->se_u.se_if.is_end_label,
JUMP_ALWAYS, cctx) == FAIL)
return NULL;
// previous "if" or "elseif" jumps here
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
isn->isn_arg.jump.jump_where = instr->ga_len;
}
// compile "expr"; if we know it evaluates to FALSE skip the block
CLEAR_FIELD(ppconst);
if (compile_expr1(&p, cctx, &ppconst) == FAIL)
{
clear_ppconst(&ppconst);
return NULL;
}
if (scope->se_skip_save == SKIP_YES)
clear_ppconst(&ppconst);
else if (instr->ga_len == instr_count && ppconst.pp_used == 1)
{
// The expression results in a constant.
// TODO: how about nesting?
cctx->ctx_skip = tv2bool(&ppconst.pp_tv[0]) ? SKIP_NOT : SKIP_YES;
clear_ppconst(&ppconst);
scope->se_u.se_if.is_if_label = -1;
}
else
{
// Not a constant, generate instructions for the expression.
cctx->ctx_skip = SKIP_UNKNOWN;
if (generate_ppconst(cctx, &ppconst) == FAIL)
return NULL;
// "where" is set when ":elseif", "else" or ":endif" is found
scope->se_u.se_if.is_if_label = instr->ga_len;
generate_JUMP(cctx, JUMP_IF_FALSE, 0);
}
return p;
}
static char_u *
compile_else(char_u *arg, cctx_T *cctx)
{
char_u *p = arg;
garray_T *instr = &cctx->ctx_instr;
isn_T *isn;
scope_T *scope = cctx->ctx_scope;
if (scope == NULL || scope->se_type != IF_SCOPE)
{
emsg(_(e_else_without_if));
return NULL;
}
unwind_locals(cctx, scope->se_local_count);
if (!cctx->ctx_had_return)
scope->se_u.se_if.is_had_return = FALSE;
scope->se_u.se_if.is_seen_else = TRUE;
if (scope->se_skip_save != SKIP_YES)
{
// jump from previous block to the end, unless the else block is empty
if (cctx->ctx_skip == SKIP_UNKNOWN)
{
if (!cctx->ctx_had_return
&& compile_jump_to_end(&scope->se_u.se_if.is_end_label,
JUMP_ALWAYS, cctx) == FAIL)
return NULL;
}
if (cctx->ctx_skip == SKIP_UNKNOWN)
{
if (scope->se_u.se_if.is_if_label >= 0)
{
// previous "if" or "elseif" jumps here
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
isn->isn_arg.jump.jump_where = instr->ga_len;
scope->se_u.se_if.is_if_label = -1;
}
}
if (cctx->ctx_skip != SKIP_UNKNOWN)
cctx->ctx_skip = cctx->ctx_skip == SKIP_YES ? SKIP_NOT : SKIP_YES;
}
return p;
}
static char_u *
compile_endif(char_u *arg, cctx_T *cctx)
{
scope_T *scope = cctx->ctx_scope;
ifscope_T *ifscope;
garray_T *instr = &cctx->ctx_instr;
isn_T *isn;
if (scope == NULL || scope->se_type != IF_SCOPE)
{
emsg(_(e_endif_without_if));
return NULL;
}
ifscope = &scope->se_u.se_if;
unwind_locals(cctx, scope->se_local_count);
if (!cctx->ctx_had_return)
ifscope->is_had_return = FALSE;
if (scope->se_u.se_if.is_if_label >= 0)
{
// previous "if" or "elseif" jumps here
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label;
isn->isn_arg.jump.jump_where = instr->ga_len;
}
// Fill in the "end" label in jumps at the end of the blocks.
compile_fill_jump_to_end(&ifscope->is_end_label, cctx);
cctx->ctx_skip = scope->se_skip_save;
// If all the blocks end in :return and there is an :else then the
// had_return flag is set.
cctx->ctx_had_return = ifscope->is_had_return && ifscope->is_seen_else;
drop_scope(cctx);
return arg;
}
/*
* compile "for var in expr"
*
* Produces instructions:
* PUSHNR -1
* STORE loop-idx Set index to -1
* EVAL expr Push result of "expr"
* top: FOR loop-idx, end Increment index, use list on bottom of stack
* - if beyond end, jump to "end"
* - otherwise get item from list and push it
* STORE var Store item in "var"
* ... body ...
* JUMP top Jump back to repeat
* end: DROP Drop the result of "expr"
*
*/
static char_u *
compile_for(char_u *arg, cctx_T *cctx)
{
char_u *p;
size_t varlen;
garray_T *instr = &cctx->ctx_instr;
garray_T *stack = &cctx->ctx_type_stack;
scope_T *scope;
lvar_T *loop_lvar; // loop iteration variable
lvar_T *var_lvar; // variable for "var"
type_T *vartype;
// TODO: list of variables: "for [key, value] in dict"
// parse "var"
for (p = arg; eval_isnamec1(*p); ++p)
;
varlen = p - arg;
var_lvar = lookup_local(arg, varlen, cctx);
if (var_lvar != NULL)
{
semsg(_("E1023: variable already defined: %s"), arg);
return NULL;
}
// consume "in"
p = skipwhite(p);
if (STRNCMP(p, "in", 2) != 0 || !VIM_ISWHITE(p[2]))
{
emsg(_(e_missing_in));
return NULL;
}
p = skipwhite(p + 2);
scope = new_scope(cctx, FOR_SCOPE);
if (scope == NULL)
return NULL;
// Reserve a variable to store the loop iteration counter.
loop_lvar = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number);
if (loop_lvar == NULL)
{
// out of memory
drop_scope(cctx);
return NULL;
}
// Reserve a variable to store "var"
var_lvar = reserve_local(cctx, arg, varlen, FALSE, &t_any);
if (var_lvar == NULL)
{
// out of memory or used as an argument
drop_scope(cctx);
return NULL;
}
generate_STORENR(cctx, loop_lvar->lv_idx, -1);
// compile "expr", it remains on the stack until "endfor"
arg = p;
if (compile_expr0(&arg, cctx) == FAIL)
{
drop_scope(cctx);
return NULL;
}
// Now that we know the type of "var", check that it is a list, now or at
// runtime.
vartype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
if (need_type(vartype, &t_list_any, -1, cctx, FALSE) == FAIL)
{
drop_scope(cctx);
return NULL;
}
if (vartype->tt_type == VAR_LIST && vartype->tt_member->tt_type != VAR_ANY)
var_lvar->lv_type = vartype->tt_member;
// "for_end" is set when ":endfor" is found
scope->se_u.se_for.fs_top_label = instr->ga_len;
generate_FOR(cctx, loop_lvar->lv_idx);
generate_STORE(cctx, ISN_STORE, var_lvar->lv_idx, NULL);
return arg;
}
/*
* compile "endfor"
*/
static char_u *
compile_endfor(char_u *arg, cctx_T *cctx)
{
garray_T *instr = &cctx->ctx_instr;
scope_T *scope = cctx->ctx_scope;
forscope_T *forscope;
isn_T *isn;
if (scope == NULL || scope->se_type != FOR_SCOPE)
{
emsg(_(e_for));
return NULL;
}
forscope = &scope->se_u.se_for;
cctx->ctx_scope = scope->se_outer;
unwind_locals(cctx, scope->se_local_count);
// At end of ":for" scope jump back to the FOR instruction.
generate_JUMP(cctx, JUMP_ALWAYS, forscope->fs_top_label);
// Fill in the "end" label in the FOR statement so it can jump here
isn = ((isn_T *)instr->ga_data) + forscope->fs_top_label;
isn->isn_arg.forloop.for_end = instr->ga_len;
// Fill in the "end" label any BREAK statements
compile_fill_jump_to_end(&forscope->fs_end_label, cctx);
// Below the ":for" scope drop the "expr" list from the stack.
if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL)
return NULL;
vim_free(scope);
return arg;
}
/*
* compile "while expr"
*
* Produces instructions:
* top: EVAL expr Push result of "expr"
* JUMP_IF_FALSE end jump if false
* ... body ...
* JUMP top Jump back to repeat
* end:
*
*/
static char_u *
compile_while(char_u *arg, cctx_T *cctx)
{
char_u *p = arg;
garray_T *instr = &cctx->ctx_instr;
scope_T *scope;
scope = new_scope(cctx, WHILE_SCOPE);
if (scope == NULL)
return NULL;
scope->se_u.se_while.ws_top_label = instr->ga_len;
// compile "expr"
if (compile_expr0(&p, cctx) == FAIL)
return NULL;
// "while_end" is set when ":endwhile" is found
if (compile_jump_to_end(&scope->se_u.se_while.ws_end_label,
JUMP_IF_FALSE, cctx) == FAIL)
return FAIL;
return p;
}
/*
* compile "endwhile"
*/
static char_u *
compile_endwhile(char_u *arg, cctx_T *cctx)
{
scope_T *scope = cctx->ctx_scope;
if (scope == NULL || scope->se_type != WHILE_SCOPE)
{
emsg(_(e_while));
return NULL;
}
cctx->ctx_scope = scope->se_outer;
unwind_locals(cctx, scope->se_local_count);
// At end of ":for" scope jump back to the FOR instruction.
generate_JUMP(cctx, JUMP_ALWAYS, scope->se_u.se_while.ws_top_label);
// Fill in the "end" label in the WHILE statement so it can jump here.
// And in any jumps for ":break"
compile_fill_jump_to_end(&scope->se_u.se_while.ws_end_label, cctx);
vim_free(scope);
return arg;
}
/*
* compile "continue"
*/
static char_u *
compile_continue(char_u *arg, cctx_T *cctx)
{
scope_T *scope = cctx->ctx_scope;
for (;;)
{
if (scope == NULL)
{
emsg(_(e_continue));
return NULL;
}
if (scope->se_type == FOR_SCOPE || scope->se_type == WHILE_SCOPE)
break;
scope = scope->se_outer;
}
// Jump back to the FOR or WHILE instruction.
generate_JUMP(cctx, JUMP_ALWAYS,
scope->se_type == FOR_SCOPE ? scope->se_u.se_for.fs_top_label
: scope->se_u.se_while.ws_top_label);
return arg;
}
/*
* compile "break"
*/
static char_u *
compile_break(char_u *arg, cctx_T *cctx)
{
scope_T *scope = cctx->ctx_scope;
endlabel_T **el;
for (;;)
{
if (scope == NULL)
{
emsg(_(e_break));
return NULL;
}
if (scope->se_type == FOR_SCOPE || scope->se_type == WHILE_SCOPE)
break;
scope = scope->se_outer;
}
// Jump to the end of the FOR or WHILE loop.
if (scope->se_type == FOR_SCOPE)
el = &scope->se_u.se_for.fs_end_label;
else
el = &scope->se_u.se_while.ws_end_label;
if (compile_jump_to_end(el, JUMP_ALWAYS, cctx) == FAIL)
return FAIL;
return arg;
}
/*
* compile "{" start of block
*/
static char_u *
compile_block(char_u *arg, cctx_T *cctx)
{
if (new_scope(cctx, BLOCK_SCOPE) == NULL)
return NULL;
return skipwhite(arg + 1);
}
/*
* compile end of block: drop one scope
*/
static void
compile_endblock(cctx_T *cctx)
{
scope_T *scope = cctx->ctx_scope;
cctx->ctx_scope = scope->se_outer;
unwind_locals(cctx, scope->se_local_count);
vim_free(scope);
}
/*
* compile "try"
* Creates a new scope for the try-endtry, pointing to the first catch and
* finally.
* Creates another scope for the "try" block itself.
* TRY instruction sets up exception handling at runtime.
*
* "try"
* TRY -> catch1, -> finally push trystack entry
* ... try block
* "throw {exception}"
* EVAL {exception}
* THROW create exception
* ... try block
* " catch {expr}"
* JUMP -> finally
* catch1: PUSH exeception
* EVAL {expr}
* MATCH
* JUMP nomatch -> catch2
* CATCH remove exception
* ... catch block
* " catch"
* JUMP -> finally
* catch2: CATCH remove exception
* ... catch block
* " finally"
* finally:
* ... finally block
* " endtry"
* ENDTRY pop trystack entry, may rethrow
*/
static char_u *
compile_try(char_u *arg, cctx_T *cctx)
{
garray_T *instr = &cctx->ctx_instr;
scope_T *try_scope;
scope_T *scope;
// scope that holds the jumps that go to catch/finally/endtry
try_scope = new_scope(cctx, TRY_SCOPE);
if (try_scope == NULL)
return NULL;
// "catch" is set when the first ":catch" is found.
// "finally" is set when ":finally" or ":endtry" is found
try_scope->se_u.se_try.ts_try_label = instr->ga_len;
if (generate_instr(cctx, ISN_TRY) == NULL)
return NULL;
// scope for the try block itself
scope = new_scope(cctx, BLOCK_SCOPE);
if (scope == NULL)
return NULL;
return arg;
}
/*
* compile "catch {expr}"
*/
static char_u *
compile_catch(char_u *arg, cctx_T *cctx UNUSED)
{
scope_T *scope = cctx->ctx_scope;
garray_T *instr = &cctx->ctx_instr;
char_u *p;
isn_T *isn;
// end block scope from :try or :catch
if (scope != NULL && scope->se_type == BLOCK_SCOPE)
compile_endblock(cctx);
scope = cctx->ctx_scope;
// Error if not in a :try scope
if (scope == NULL || scope->se_type != TRY_SCOPE)
{
emsg(_(e_catch));
return NULL;
}
if (scope->se_u.se_try.ts_caught_all)
{
emsg(_("E1033: catch unreachable after catch-all"));
return NULL;
}
// Jump from end of previous block to :finally or :endtry
if (compile_jump_to_end(&scope->se_u.se_try.ts_end_label,
JUMP_ALWAYS, cctx) == FAIL)
return NULL;
// End :try or :catch scope: set value in ISN_TRY instruction
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
if (isn->isn_arg.try.try_catch == 0)
isn->isn_arg.try.try_catch = instr->ga_len;
if (scope->se_u.se_try.ts_catch_label != 0)
{
// Previous catch without match jumps here
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
isn->isn_arg.jump.jump_where = instr->ga_len;
}
p = skipwhite(arg);
if (ends_excmd2(arg, p))
{
scope->se_u.se_try.ts_caught_all = TRUE;
scope->se_u.se_try.ts_catch_label = 0;
}
else
{
char_u *end;
char_u *pat;
char_u *tofree = NULL;
int dropped = 0;
int len;
// Push v:exception, push {expr} and MATCH
generate_instr_type(cctx, ISN_PUSHEXC, &t_string);
end = skip_regexp_ex(p + 1, *p, TRUE, &tofree, &dropped);
if (*end != *p)
{
semsg(_("E1067: Separator mismatch: %s"), p);
vim_free(tofree);
return FAIL;
}
if (tofree == NULL)
len = (int)(end - (p + 1));
else
len = (int)(end - tofree);
pat = vim_strnsave(tofree == NULL ? p + 1 : tofree, len);
vim_free(tofree);
p += len + 2 + dropped;
if (pat == NULL)
return FAIL;
if (generate_PUSHS(cctx, pat) == FAIL)
return FAIL;
if (generate_COMPARE(cctx, EXPR_MATCH, FALSE) == FAIL)
return NULL;
scope->se_u.se_try.ts_catch_label = instr->ga_len;
if (generate_JUMP(cctx, JUMP_IF_FALSE, 0) == FAIL)
return NULL;
}
if (generate_instr(cctx, ISN_CATCH) == NULL)
return NULL;
if (new_scope(cctx, BLOCK_SCOPE) == NULL)
return NULL;
return p;
}
static char_u *
compile_finally(char_u *arg, cctx_T *cctx)
{
scope_T *scope = cctx->ctx_scope;
garray_T *instr = &cctx->ctx_instr;
isn_T *isn;
// end block scope from :try or :catch
if (scope != NULL && scope->se_type == BLOCK_SCOPE)
compile_endblock(cctx);
scope = cctx->ctx_scope;
// Error if not in a :try scope
if (scope == NULL || scope->se_type != TRY_SCOPE)
{
emsg(_(e_finally));
return NULL;
}
// End :catch or :finally scope: set value in ISN_TRY instruction
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
if (isn->isn_arg.try.try_finally != 0)
{
emsg(_(e_finally_dup));
return NULL;
}
// Fill in the "end" label in jumps at the end of the blocks.
compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, cctx);
isn->isn_arg.try.try_finally = instr->ga_len;
if (scope->se_u.se_try.ts_catch_label != 0)
{
// Previous catch without match jumps here
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
isn->isn_arg.jump.jump_where = instr->ga_len;
scope->se_u.se_try.ts_catch_label = 0;
}
// TODO: set index in ts_finally_label jumps
return arg;
}
static char_u *
compile_endtry(char_u *arg, cctx_T *cctx)
{
scope_T *scope = cctx->ctx_scope;
garray_T *instr = &cctx->ctx_instr;
isn_T *isn;
// end block scope from :catch or :finally
if (scope != NULL && scope->se_type == BLOCK_SCOPE)
compile_endblock(cctx);
scope = cctx->ctx_scope;
// Error if not in a :try scope
if (scope == NULL || scope->se_type != TRY_SCOPE)
{
if (scope == NULL)
emsg(_(e_no_endtry));
else if (scope->se_type == WHILE_SCOPE)
emsg(_(e_endwhile));
else if (scope->se_type == FOR_SCOPE)
emsg(_(e_endfor));
else
emsg(_(e_endif));
return NULL;
}
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
if (isn->isn_arg.try.try_catch == 0 && isn->isn_arg.try.try_finally == 0)
{
emsg(_("E1032: missing :catch or :finally"));
return NULL;
}
// Fill in the "end" label in jumps at the end of the blocks, if not done
// by ":finally".
compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, cctx);
// End :catch or :finally scope: set value in ISN_TRY instruction
if (isn->isn_arg.try.try_catch == 0)
isn->isn_arg.try.try_catch = instr->ga_len;
if (isn->isn_arg.try.try_finally == 0)
isn->isn_arg.try.try_finally = instr->ga_len;
if (scope->se_u.se_try.ts_catch_label != 0)
{
// Last catch without match jumps here
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label;
isn->isn_arg.jump.jump_where = instr->ga_len;
}
compile_endblock(cctx);
if (generate_instr(cctx, ISN_ENDTRY) == NULL)
return NULL;
return arg;
}
/*
* compile "throw {expr}"
*/
static char_u *
compile_throw(char_u *arg, cctx_T *cctx UNUSED)
{
char_u *p = skipwhite(arg);
if (compile_expr0(&p, cctx) == FAIL)
return NULL;
if (may_generate_2STRING(-1, cctx) == FAIL)
return NULL;
if (generate_instr_drop(cctx, ISN_THROW, 1) == NULL)
return NULL;
return p;
}
/*
* compile "echo expr"
* compile "echomsg expr"
* compile "echoerr expr"
* compile "execute expr"
*/
static char_u *
compile_mult_expr(char_u *arg, int cmdidx, cctx_T *cctx)
{
char_u *p = arg;
int count = 0;
for (;;)
{
if (compile_expr0(&p, cctx) == FAIL)
return NULL;
++count;
p = skipwhite(p);
if (ends_excmd(*p))
break;
}
if (cmdidx == CMD_echo || cmdidx == CMD_echon)
generate_ECHO(cctx, cmdidx == CMD_echo, count);
else if (cmdidx == CMD_execute)
generate_MULT_EXPR(cctx, ISN_EXECUTE, count);
else if (cmdidx == CMD_echomsg)
generate_MULT_EXPR(cctx, ISN_ECHOMSG, count);
else
generate_MULT_EXPR(cctx, ISN_ECHOERR, count);
return p;
}
/*
* A command that is not compiled, execute with legacy code.
*/
static char_u *
compile_exec(char_u *line, exarg_T *eap, cctx_T *cctx)
{
char_u *p;
int has_expr = FALSE;
char_u *nextcmd = (char_u *)"";
if (cctx->ctx_skip == SKIP_YES)
goto theend;
if (eap->cmdidx >= 0 && eap->cmdidx < CMD_SIZE)
{
long argt = excmd_get_argt(eap->cmdidx);
int usefilter = FALSE;
has_expr = argt & (EX_XFILE | EX_EXPAND);
// If the command can be followed by a bar, find the bar and truncate
// it, so that the following command can be compiled.
// The '|' is overwritten with a NUL, it is put back below.
if ((eap->cmdidx == CMD_write || eap->cmdidx == CMD_read)
&& *eap->arg == '!')
// :w !filter or :r !filter or :r! filter
usefilter = TRUE;
if ((argt & EX_TRLBAR) && !usefilter)
{
separate_nextcmd(eap);
if (eap->nextcmd != NULL)
nextcmd = eap->nextcmd;
}
}
if (eap->cmdidx == CMD_syntax && STRNCMP(eap->arg, "include ", 8) == 0)
{
// expand filename in "syntax include [@group] filename"
has_expr = TRUE;
eap->arg = skipwhite(eap->arg + 7);
if (*eap->arg == '@')
eap->arg = skiptowhite(eap->arg);
}
if (has_expr && (p = (char_u *)strstr((char *)eap->arg, "`=")) != NULL)
{
int count = 0;
char_u *start = skipwhite(line);
// :cmd xxx`=expr1`yyy`=expr2`zzz
// PUSHS ":cmd xxx"
// eval expr1
// PUSHS "yyy"
// eval expr2
// PUSHS "zzz"
// EXECCONCAT 5
for (;;)
{
if (p > start)
{
generate_PUSHS(cctx, vim_strnsave(start, p - start));
++count;
}
p += 2;
if (compile_expr0(&p, cctx) == FAIL)
return NULL;
may_generate_2STRING(-1, cctx);
++count;
p = skipwhite(p);
if (*p != '`')
{
emsg(_("E1083: missing backtick"));
return NULL;
}
start = p + 1;
p = (char_u *)strstr((char *)start, "`=");
if (p == NULL)
{
if (*skipwhite(start) != NUL)
{
generate_PUSHS(cctx, vim_strsave(start));
++count;
}
break;
}
}
generate_EXECCONCAT(cctx, count);
}
else
generate_EXEC(cctx, line);
theend:
if (*nextcmd != NUL)
{
// the parser expects a pointer to the bar, put it back
--nextcmd;
*nextcmd = '|';
}
return nextcmd;
}
/*
* Add a function to the list of :def functions.
* This sets "ufunc->uf_dfunc_idx" but the function isn't compiled yet.
*/
static int
add_def_function(ufunc_T *ufunc)
{
dfunc_T *dfunc;
if (def_functions.ga_len == 0)
{
// The first position is not used, so that a zero uf_dfunc_idx means it
// wasn't set.
if (ga_grow(&def_functions, 1) == FAIL)
return FAIL;
++def_functions.ga_len;
}
// Add the function to "def_functions".
if (ga_grow(&def_functions, 1) == FAIL)
return FAIL;
dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len;
CLEAR_POINTER(dfunc);
dfunc->df_idx = def_functions.ga_len;
ufunc->uf_dfunc_idx = dfunc->df_idx;
dfunc->df_ufunc = ufunc;
++def_functions.ga_len;
return OK;
}
/*
* After ex_function() has collected all the function lines: parse and compile
* the lines into instructions.
* Adds the function to "def_functions".
* When "set_return_type" is set then set ufunc->uf_ret_type to the type of the
* return statement (used for lambda).
* "outer_cctx" is set for a nested function.
* This can be used recursively through compile_lambda(), which may reallocate
* "def_functions".
* Returns OK or FAIL.
*/
int
compile_def_function(ufunc_T *ufunc, int set_return_type, cctx_T *outer_cctx)
{
char_u *line = NULL;
char_u *p;
char *errormsg = NULL; // error message
cctx_T cctx;
garray_T *instr;
int called_emsg_before = called_emsg;
int ret = FAIL;
sctx_T save_current_sctx = current_sctx;
int do_estack_push;
int emsg_before = called_emsg;
int new_def_function = FALSE;
// When using a function that was compiled before: Free old instructions.
// Otherwise add a new entry in "def_functions".
if (ufunc->uf_dfunc_idx > 0)
{
dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
+ ufunc->uf_dfunc_idx;
delete_def_function_contents(dfunc);
}
else
{
if (add_def_function(ufunc) == FAIL)
return FAIL;
new_def_function = TRUE;
}
ufunc->uf_def_status = UF_COMPILING;
CLEAR_FIELD(cctx);
cctx.ctx_ufunc = ufunc;
cctx.ctx_lnum = -1;
cctx.ctx_outer = outer_cctx;
ga_init2(&cctx.ctx_locals, sizeof(lvar_T), 10);
ga_init2(&cctx.ctx_type_stack, sizeof(type_T *), 50);
ga_init2(&cctx.ctx_imports, sizeof(imported_T), 10);
cctx.ctx_type_list = &ufunc->uf_type_list;
ga_init2(&cctx.ctx_instr, sizeof(isn_T), 50);
instr = &cctx.ctx_instr;
// Set the context to the function, it may be compiled when called from
// another script. Set the script version to the most modern one.
// The line number will be set in next_line_from_context().
current_sctx = ufunc->uf_script_ctx;
current_sctx.sc_version = SCRIPT_VERSION_VIM9;
// Make sure error messages are OK.
do_estack_push = !estack_top_is_ufunc(ufunc, 1);
if (do_estack_push)
estack_push_ufunc(ufunc, 1);
if (ufunc->uf_def_args.ga_len > 0)
{
int count = ufunc->uf_def_args.ga_len;
int first_def_arg = ufunc->uf_args.ga_len - count;
int i;
char_u *arg;
int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0);
int did_set_arg_type = FALSE;
// Produce instructions for the default values of optional arguments.
// Store the instruction index in uf_def_arg_idx[] so that we know
// where to start when the function is called, depending on the number
// of arguments.
ufunc->uf_def_arg_idx = ALLOC_CLEAR_MULT(int, count + 1);
if (ufunc->uf_def_arg_idx == NULL)
goto erret;
for (i = 0; i < count; ++i)
{
garray_T *stack = &cctx.ctx_type_stack;
type_T *val_type;
int arg_idx = first_def_arg + i;
ufunc->uf_def_arg_idx[i] = instr->ga_len;
arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i];
if (compile_expr0(&arg, &cctx) == FAIL)
goto erret;
// If no type specified use the type of the default value.
// Otherwise check that the default value type matches the
// specified type.
val_type = ((type_T **)stack->ga_data)[stack->ga_len - 1];
if (ufunc->uf_arg_types[arg_idx] == &t_unknown)
{
did_set_arg_type = TRUE;
ufunc->uf_arg_types[arg_idx] = val_type;
}
else if (check_type(ufunc->uf_arg_types[arg_idx], val_type, FALSE)
== FAIL)
{
arg_type_mismatch(ufunc->uf_arg_types[arg_idx], val_type,
arg_idx + 1);
goto erret;
}
if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL)
goto erret;
}
ufunc->uf_def_arg_idx[count] = instr->ga_len;
if (did_set_arg_type)
set_function_type(ufunc);
}
/*
* Loop over all the lines of the function and generate instructions.
*/
for (;;)
{
exarg_T ea;
int starts_with_colon = FALSE;
char_u *cmd;
int save_msg_scroll = msg_scroll;
// Bail out on the first error to avoid a flood of errors and report
// the right line number when inside try/catch.
if (emsg_before != called_emsg)
goto erret;
if (line != NULL && *line == '|')
// the line continues after a '|'
++line;
else if (line != NULL && *skipwhite(line) != NUL
&& !(*line == '#' && (line == cctx.ctx_line_start
|| VIM_ISWHITE(line[-1]))))
{
semsg(_(e_trailing_arg), line);
goto erret;
}
else
{
line = next_line_from_context(&cctx, FALSE);
if (cctx.ctx_lnum >= ufunc->uf_lines.ga_len)
// beyond the last line
break;
}
emsg_before = called_emsg;
CLEAR_FIELD(ea);
ea.cmdlinep = &line;
ea.cmd = skipwhite(line);
// Some things can be recognized by the first character.
switch (*ea.cmd)
{
case '#':
// "#" starts a comment, but "#{" does not.
if (ea.cmd[1] != '{')
{
line = (char_u *)"";
continue;
}
break;
case '}':
{
// "}" ends a block scope
scopetype_T stype = cctx.ctx_scope == NULL
? NO_SCOPE : cctx.ctx_scope->se_type;
if (stype == BLOCK_SCOPE)
{
compile_endblock(&cctx);
line = ea.cmd;
}
else
{
emsg(_("E1025: using } outside of a block scope"));
goto erret;
}
if (line != NULL)
line = skipwhite(ea.cmd + 1);
continue;
}
case '{':
// "{" starts a block scope
// "{'a': 1}->func() is something else
if (ends_excmd(*skipwhite(ea.cmd + 1)))
{
line = compile_block(ea.cmd, &cctx);
continue;
}
break;
case ':':
starts_with_colon = TRUE;
break;
}
/*
* COMMAND MODIFIERS
*/
if (parse_command_modifiers(&ea, &errormsg, FALSE) == FAIL)
{
if (errormsg != NULL)
goto erret;
// empty line or comment
line = (char_u *)"";
continue;
}
// TODO: use modifiers in the command
undo_cmdmod(&ea, save_msg_scroll);
CLEAR_FIELD(cmdmod);
// Skip ":call" to get to the function name.
if (checkforcmd(&ea.cmd, "call", 3))
ea.cmd = skipwhite(ea.cmd);
if (!starts_with_colon)
{
char_u *pskip;
// Assuming the command starts with a variable or function name,
// find what follows.
// Skip over "var.member", "var[idx]" and the like.
// Also "&opt = val", "$ENV = val" and "@r = val".
pskip = (*ea.cmd == '&' || *ea.cmd == '$' || *ea.cmd == '@')
? ea.cmd + 1 : ea.cmd;
p = to_name_end(pskip, TRUE);
if (p > ea.cmd && *p != NUL)
{
char_u *var_end;
int oplen;
int heredoc;
var_end = find_name_end(pskip, NULL, NULL,
FNE_CHECK_START | FNE_INCL_BR);
oplen = assignment_len(skipwhite(var_end), &heredoc);
if (oplen > 0)
{
size_t len = p - ea.cmd;
// Recognize an assignment if we recognize the variable
// name:
// "g:var = expr"
// "local = expr" where "local" is a local var.
// "script = expr" where "script" is a script-local var.
// "import = expr" where "import" is an imported var
// "&opt = expr"
// "$ENV = expr"
// "@r = expr"
if (*ea.cmd == '&'
|| *ea.cmd == '$'
|| *ea.cmd == '@'
|| ((len) > 2 && ea.cmd[1] == ':')
|| lookup_local(ea.cmd, len, &cctx) != NULL
|| lookup_arg(ea.cmd, len, NULL, NULL,
NULL, &cctx) == OK
|| lookup_script(ea.cmd, len) == OK
|| find_imported(ea.cmd, len, &cctx) != NULL)
{
line = compile_assignment(ea.cmd, &ea, CMD_SIZE, &cctx);
if (line == NULL || line == ea.cmd)
goto erret;
continue;
}
}
}
if (*ea.cmd == '[')
{
// [var, var] = expr
line = compile_assignment(ea.cmd, &ea, CMD_SIZE, &cctx);
if (line == NULL)
goto erret;
if (line != ea.cmd)
continue;
}
}
/*
* COMMAND after range
* 'text'->func() should not be confused with 'a mark
*/
cmd = ea.cmd;
if (*cmd != '\'')
{
ea.cmd = skip_range(ea.cmd, NULL);
if (ea.cmd > cmd && !starts_with_colon)
{
emsg(_(e_colon_required));
goto erret;
}
}
p = find_ex_command(&ea, NULL, starts_with_colon ? NULL
: (void *(*)(char_u *, size_t, cctx_T *))lookup_local,
&cctx);
if (p == ea.cmd && ea.cmdidx != CMD_SIZE)
{
if (cctx.ctx_skip == SKIP_YES)
{
line += STRLEN(line);
continue;
}
// Expression or function call.
if (ea.cmdidx != CMD_eval)
{
// CMD_let cannot happen, compile_assignment() above is used
iemsg("Command from find_ex_command() not handled");
goto erret;
}
}
p = skipwhite(p);
if (cctx.ctx_skip == SKIP_YES
&& ea.cmdidx != CMD_if
&& ea.cmdidx != CMD_elseif
&& ea.cmdidx != CMD_else
&& ea.cmdidx != CMD_endif)
{
line = (char_u *)"";
continue;
}
if (ea.cmdidx != CMD_elseif
&& ea.cmdidx != CMD_else
&& ea.cmdidx != CMD_endif
&& ea.cmdidx != CMD_endfor
&& ea.cmdidx != CMD_endwhile
&& ea.cmdidx != CMD_catch
&& ea.cmdidx != CMD_finally
&& ea.cmdidx != CMD_endtry)
{
if (cctx.ctx_had_return)
{
emsg(_("E1095: Unreachable code after :return"));
goto erret;
}
}
switch (ea.cmdidx)
{
case CMD_def:
ea.arg = p;
line = compile_nested_function(&ea, &cctx);
break;
case CMD_function:
emsg(_("E1086: Cannot use :function inside :def"));
goto erret;
case CMD_return:
line = compile_return(p, set_return_type, &cctx);
cctx.ctx_had_return = TRUE;
break;
case CMD_let:
case CMD_const:
line = compile_assignment(p, &ea, ea.cmdidx, &cctx);
if (line == p)
line = NULL;
break;
case CMD_unlet:
case CMD_unlockvar:
case CMD_lockvar:
line = compile_unletlock(p, &ea, &cctx);
break;
case CMD_import:
line = compile_import(p, &cctx);
break;
case CMD_if:
line = compile_if(p, &cctx);
break;
case CMD_elseif:
line = compile_elseif(p, &cctx);
cctx.ctx_had_return = FALSE;
break;
case CMD_else:
line = compile_else(p, &cctx);
cctx.ctx_had_return = FALSE;
break;
case CMD_endif:
line = compile_endif(p, &cctx);
break;
case CMD_while:
line = compile_while(p, &cctx);
break;
case CMD_endwhile:
line = compile_endwhile(p, &cctx);
cctx.ctx_had_return = FALSE;
break;
case CMD_for:
line = compile_for(p, &cctx);
break;
case CMD_endfor:
line = compile_endfor(p, &cctx);
cctx.ctx_had_return = FALSE;
break;
case CMD_continue:
line = compile_continue(p, &cctx);
break;
case CMD_break:
line = compile_break(p, &cctx);
break;
case CMD_try:
line = compile_try(p, &cctx);
break;
case CMD_catch:
line = compile_catch(p, &cctx);
cctx.ctx_had_return = FALSE;
break;
case CMD_finally:
line = compile_finally(p, &cctx);
cctx.ctx_had_return = FALSE;
break;
case CMD_endtry:
line = compile_endtry(p, &cctx);
cctx.ctx_had_return = FALSE;
break;
case CMD_throw:
line = compile_throw(p, &cctx);
break;
case CMD_eval:
if (compile_expr0(&p, &cctx) == FAIL)
goto erret;
// drop the return value
generate_instr_drop(&cctx, ISN_DROP, 1);
line = skipwhite(p);
break;
case CMD_echo:
case CMD_echon:
case CMD_execute:
case CMD_echomsg:
case CMD_echoerr:
line = compile_mult_expr(p, ea.cmdidx, &cctx);
break;
// TODO: other commands with an expression argument
case CMD_append:
case CMD_change:
case CMD_insert:
case CMD_xit:
not_in_vim9(&ea);
goto erret;
case CMD_SIZE:
semsg(_("E476: Invalid command: %s"), ea.cmd);
goto erret;
default:
// Not recognized, execute with do_cmdline_cmd().
ea.arg = p;
line = compile_exec(line, &ea, &cctx);
break;
}
if (line == NULL)
goto erret;
line = skipwhite(line);
if (cctx.ctx_type_stack.ga_len < 0)
{
iemsg("Type stack underflow");
goto erret;
}
}
if (cctx.ctx_scope != NULL)
{
if (cctx.ctx_scope->se_type == IF_SCOPE)
emsg(_(e_endif));
else if (cctx.ctx_scope->se_type == WHILE_SCOPE)
emsg(_(e_endwhile));
else if (cctx.ctx_scope->se_type == FOR_SCOPE)
emsg(_(e_endfor));
else
emsg(_("E1026: Missing }"));
goto erret;
}
if (!cctx.ctx_had_return)
{
if (ufunc->uf_ret_type->tt_type != VAR_VOID)
{
emsg(_("E1027: Missing return statement"));
goto erret;
}
// Return zero if there is no return at the end.
generate_PUSHNR(&cctx, 0);
generate_instr(&cctx, ISN_RETURN);
}
{
dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
+ ufunc->uf_dfunc_idx;
dfunc->df_deleted = FALSE;
dfunc->df_instr = instr->ga_data;
dfunc->df_instr_count = instr->ga_len;
dfunc->df_varcount = cctx.ctx_locals_count;
dfunc->df_closure_count = cctx.ctx_closure_count;
if (cctx.ctx_outer_used)
ufunc->uf_flags |= FC_CLOSURE;
ufunc->uf_def_status = UF_COMPILED;
}
ret = OK;
erret:
if (ret == FAIL)
{
int idx;
dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
+ ufunc->uf_dfunc_idx;
for (idx = 0; idx < instr->ga_len; ++idx)
delete_instr(((isn_T *)instr->ga_data) + idx);
ga_clear(instr);
// If using the last entry in the table and it was added above, we
// might as well remove it.
if (!dfunc->df_deleted && new_def_function
&& ufunc->uf_dfunc_idx == def_functions.ga_len - 1)
{
--def_functions.ga_len;
ufunc->uf_dfunc_idx = 0;
}
ufunc->uf_def_status = UF_NOT_COMPILED;
while (cctx.ctx_scope != NULL)
drop_scope(&cctx);
// Don't execute this function body.
ga_clear_strings(&ufunc->uf_lines);
if (errormsg != NULL)
emsg(errormsg);
else if (called_emsg == called_emsg_before)
emsg(_("E1028: compile_def_function failed"));
}
current_sctx = save_current_sctx;
if (do_estack_push)
estack_pop();
free_imported(&cctx);
free_locals(&cctx);
ga_clear(&cctx.ctx_type_stack);
return ret;
}
void
set_function_type(ufunc_T *ufunc)
{
int varargs = ufunc->uf_va_name != NULL;
int argcount = ufunc->uf_args.ga_len;
// Create a type for the function, with the return type and any
// argument types.
// A vararg is included in uf_args.ga_len but not in uf_arg_types.
// The type is included in "tt_args".
if (argcount > 0 || varargs)
{
ufunc->uf_func_type = alloc_func_type(ufunc->uf_ret_type,
argcount, &ufunc->uf_type_list);
// Add argument types to the function type.
if (func_type_add_arg_types(ufunc->uf_func_type,
argcount + varargs,
&ufunc->uf_type_list) == FAIL)
return;
ufunc->uf_func_type->tt_argcount = argcount + varargs;
ufunc->uf_func_type->tt_min_argcount =
argcount - ufunc->uf_def_args.ga_len;
if (ufunc->uf_arg_types == NULL)
{
int i;
// lambda does not have argument types.
for (i = 0; i < argcount; ++i)
ufunc->uf_func_type->tt_args[i] = &t_any;
}
else
mch_memmove(ufunc->uf_func_type->tt_args,
ufunc->uf_arg_types, sizeof(type_T *) * argcount);
if (varargs)
{
ufunc->uf_func_type->tt_args[argcount] =
ufunc->uf_va_type == NULL ? &t_any : ufunc->uf_va_type;
ufunc->uf_func_type->tt_flags = TTFLAG_VARARGS;
}
}
else
// No arguments, can use a predefined type.
ufunc->uf_func_type = get_func_type(ufunc->uf_ret_type,
argcount, &ufunc->uf_type_list);
}
/*
* Delete an instruction, free what it contains.
*/
void
delete_instr(isn_T *isn)
{
switch (isn->isn_type)
{
case ISN_EXEC:
case ISN_LOADENV:
case ISN_LOADG:
case ISN_LOADB:
case ISN_LOADW:
case ISN_LOADT:
case ISN_LOADOPT:
case ISN_STRINGMEMBER:
case ISN_PUSHEXC:
case ISN_PUSHS:
case ISN_STOREENV:
case ISN_STOREG:
case ISN_STOREB:
case ISN_STOREW:
case ISN_STORET:
case ISN_PUSHFUNC:
vim_free(isn->isn_arg.string);
break;
case ISN_LOADS:
case ISN_STORES:
vim_free(isn->isn_arg.loadstore.ls_name);
break;
case ISN_UNLET:
case ISN_UNLETENV:
vim_free(isn->isn_arg.unlet.ul_name);
break;
case ISN_STOREOPT:
vim_free(isn->isn_arg.storeopt.so_name);
break;
case ISN_PUSHBLOB: // push blob isn_arg.blob
blob_unref(isn->isn_arg.blob);
break;
case ISN_PUSHJOB:
#ifdef FEAT_JOB_CHANNEL
job_unref(isn->isn_arg.job);
#endif
break;
case ISN_PUSHCHANNEL:
#ifdef FEAT_JOB_CHANNEL
channel_unref(isn->isn_arg.channel);
#endif
break;
case ISN_UCALL:
vim_free(isn->isn_arg.ufunc.cuf_name);
break;
case ISN_FUNCREF:
{
dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
+ isn->isn_arg.funcref.fr_func;
func_ptr_unref(dfunc->df_ufunc);
}
break;
case ISN_NEWFUNC:
{
char_u *lambda = isn->isn_arg.newfunc.nf_lambda;
ufunc_T *ufunc = find_func_even_dead(lambda, TRUE, NULL);
if (ufunc != NULL)
{
// Clear uf_dfunc_idx so that the function is deleted.
clear_def_function(ufunc);
ufunc->uf_dfunc_idx = 0;
func_ptr_unref(ufunc);
}
vim_free(lambda);
vim_free(isn->isn_arg.newfunc.nf_global);
}
break;
case ISN_2BOOL:
case ISN_2STRING:
case ISN_ADDBLOB:
case ISN_ADDLIST:
case ISN_BCALL:
case ISN_CATCH:
case ISN_CHECKNR:
case ISN_CHECKTYPE:
case ISN_CHECKLEN:
case ISN_COMPAREANY:
case ISN_COMPAREBLOB:
case ISN_COMPAREBOOL:
case ISN_COMPAREDICT:
case ISN_COMPAREFLOAT:
case ISN_COMPAREFUNC:
case ISN_COMPARELIST:
case ISN_COMPARENR:
case ISN_COMPARESPECIAL:
case ISN_COMPARESTRING:
case ISN_CONCAT:
case ISN_DCALL:
case ISN_SHUFFLE:
case ISN_DROP:
case ISN_ECHO:
case ISN_ECHOERR:
case ISN_ECHOMSG:
case ISN_ENDTRY:
case ISN_EXECCONCAT:
case ISN_EXECUTE:
case ISN_FOR:
case ISN_LISTINDEX:
case ISN_STRINDEX:
case ISN_GETITEM:
case ISN_SLICE:
case ISN_MEMBER:
case ISN_JUMP:
case ISN_LOAD:
case ISN_LOADBDICT:
case ISN_LOADGDICT:
case ISN_LOADOUTER:
case ISN_LOADREG:
case ISN_LOADSCRIPT:
case ISN_LOADTDICT:
case ISN_LOADV:
case ISN_LOADWDICT:
case ISN_NEGATENR:
case ISN_NEWDICT:
case ISN_NEWLIST:
case ISN_OPNR:
case ISN_OPFLOAT:
case ISN_OPANY:
case ISN_PCALL:
case ISN_PCALL_END:
case ISN_PUSHF:
case ISN_PUSHNR:
case ISN_PUSHBOOL:
case ISN_PUSHSPEC:
case ISN_RETURN:
case ISN_STORE:
case ISN_STOREOUTER:
case ISN_STOREV:
case ISN_STORENR:
case ISN_STOREREG:
case ISN_STORESCRIPT:
case ISN_STOREDICT:
case ISN_STORELIST:
case ISN_THROW:
case ISN_TRY:
// nothing allocated
break;
}
}
/*
* Free all instructions for "dfunc".
*/
static void
delete_def_function_contents(dfunc_T *dfunc)
{
int idx;
ga_clear(&dfunc->df_def_args_isn);
if (dfunc->df_instr != NULL)
{
for (idx = 0; idx < dfunc->df_instr_count; ++idx)
delete_instr(dfunc->df_instr + idx);
VIM_CLEAR(dfunc->df_instr);
}
dfunc->df_deleted = TRUE;
}
/*
* When a user function is deleted, clear the contents of any associated def
* function. The position in def_functions can be re-used.
*/
void
clear_def_function(ufunc_T *ufunc)
{
if (ufunc->uf_dfunc_idx > 0)
{
dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
+ ufunc->uf_dfunc_idx;
delete_def_function_contents(dfunc);
ufunc->uf_def_status = UF_NOT_COMPILED;
}
}
#if defined(EXITFREE) || defined(PROTO)
/*
* Free all functions defined with ":def".
*/
void
free_def_functions(void)
{
int idx;
for (idx = 0; idx < def_functions.ga_len; ++idx)
{
dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) + idx;
delete_def_function_contents(dfunc);
}
ga_clear(&def_functions);
}
#endif
#endif // FEAT_EVAL
View Git Blame Copy Permalink