mirror of https://github.com/vim/vim.git
5597 lines
123 KiB
C
5597 lines
123 KiB
C
/* 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"
|
|
|
|
/*
|
|
* 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_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
|
|
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_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
|
|
garray_T ctx_instr; // generated instructions
|
|
|
|
garray_T ctx_locals; // currently visible local variables
|
|
int ctx_max_local; // maximum number of locals at one time
|
|
|
|
garray_T ctx_imports; // imported items
|
|
|
|
int ctx_skip; // when TRUE skip commands, when FALSE skip
|
|
// commands after "else"
|
|
scope_T *ctx_scope; // current scope, NULL at toplevel
|
|
|
|
garray_T ctx_type_stack; // type of each item on the stack
|
|
garray_T *ctx_type_list; // space for adding types
|
|
};
|
|
|
|
static char e_var_notfound[] = N_("E1001: variable not found: %s");
|
|
static char e_syntax_at[] = N_("E1002: Syntax error at %s");
|
|
|
|
static int compile_expr1(char_u **arg, cctx_T *cctx);
|
|
static int compile_expr2(char_u **arg, cctx_T *cctx);
|
|
static int compile_expr3(char_u **arg, cctx_T *cctx);
|
|
static void delete_def_function_contents(dfunc_T *dfunc);
|
|
|
|
/*
|
|
* Lookup variable "name" in the local scope and return the index.
|
|
*/
|
|
static int
|
|
lookup_local(char_u *name, size_t len, cctx_T *cctx)
|
|
{
|
|
int idx;
|
|
|
|
if (len == 0)
|
|
return -1;
|
|
for (idx = 0; idx < cctx->ctx_locals.ga_len; ++idx)
|
|
{
|
|
lvar_T *lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
|
|
|
|
if (STRNCMP(name, lvar->lv_name, len) == 0
|
|
&& STRLEN(lvar->lv_name) == len)
|
|
return idx;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Lookup an argument in the current function.
|
|
* Returns the argument index or -1 if not found.
|
|
*/
|
|
static int
|
|
lookup_arg(char_u *name, size_t len, cctx_T *cctx)
|
|
{
|
|
int idx;
|
|
|
|
if (len == 0)
|
|
return -1;
|
|
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 && STRLEN(arg) == len)
|
|
return idx;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Lookup a vararg argument in the current function.
|
|
* Returns TRUE if there is a match.
|
|
*/
|
|
static int
|
|
lookup_vararg(char_u *name, size_t len, cctx_T *cctx)
|
|
{
|
|
char_u *va_name = cctx->ctx_ufunc->uf_va_name;
|
|
|
|
return len > 0 && va_name != NULL
|
|
&& STRNCMP(name, va_name, len) == 0 && STRLEN(va_name) == len;
|
|
}
|
|
|
|
/*
|
|
* 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, int len, cctx_T *cctx)
|
|
{
|
|
if (lookup_script(p, len) == OK
|
|
|| (cctx != NULL
|
|
&& (lookup_local(p, len, cctx) >= 0
|
|
|| find_imported(p, len, cctx) != NULL)))
|
|
{
|
|
semsg("E1073: imported name already defined: %s", p);
|
|
return FAIL;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
static type_T *
|
|
get_list_type(type_T *member_type, garray_T *type_list)
|
|
{
|
|
type_T *type;
|
|
|
|
// recognize commonly used types
|
|
if (member_type->tt_type == VAR_UNKNOWN)
|
|
return &t_list_any;
|
|
if (member_type->tt_type == VAR_VOID)
|
|
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.
|
|
if (ga_grow(type_list, 1) == FAIL)
|
|
return &t_any;
|
|
type = ((type_T *)type_list->ga_data) + type_list->ga_len;
|
|
++type_list->ga_len;
|
|
type->tt_type = VAR_LIST;
|
|
type->tt_member = member_type;
|
|
return type;
|
|
}
|
|
|
|
static type_T *
|
|
get_dict_type(type_T *member_type, garray_T *type_list)
|
|
{
|
|
type_T *type;
|
|
|
|
// recognize commonly used types
|
|
if (member_type->tt_type == VAR_UNKNOWN)
|
|
return &t_dict_any;
|
|
if (member_type->tt_type == VAR_VOID)
|
|
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.
|
|
if (ga_grow(type_list, 1) == FAIL)
|
|
return &t_any;
|
|
type = ((type_T *)type_list->ga_data) + type_list->ga_len;
|
|
++type_list->ga_len;
|
|
type->tt_type = VAR_DICT;
|
|
type->tt_member = member_type;
|
|
return type;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// Following generate_ functions expect the caller to call ga_grow().
|
|
|
|
#define RETURN_NULL_IF_SKIP(cctx) if (cctx->ctx_skip == TRUE) return NULL
|
|
#define RETURN_OK_IF_SKIP(cctx) if (cctx->ctx_skip == TRUE) 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;
|
|
++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_UNKNOWN)
|
|
&& (type2 == VAR_NUMBER || type2 == VAR_FLOAT
|
|
|| type2 == VAR_UNKNOWN)))
|
|
{
|
|
if (*op == '+')
|
|
emsg(_("E1035: 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_UNKNOWN;
|
|
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_UNKNOWN
|
|
&& type2->tt_type != VAR_UNKNOWN
|
|
&& 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_UNKNOWN
|
|
&& type1->tt_type != VAR_NUMBER)
|
|
|| (type2->tt_type != VAR_UNKNOWN
|
|
&& 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_UNKNOWN)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* 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_DROP;
|
|
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;
|
|
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;
|
|
case VAR_PARTIAL: isntype = ISN_COMPAREPARTIAL; break;
|
|
default: isntype = ISN_COMPAREANY; break;
|
|
}
|
|
}
|
|
else if (type1 == VAR_UNKNOWN || type2 == VAR_UNKNOWN
|
|
|| ((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 FAIL;
|
|
}
|
|
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 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;
|
|
isn->isn_arg.type.ct_type = vartype->tt_type; // TODO: whole type
|
|
isn->isn_arg.type.ct_off = offset;
|
|
|
|
// type becomes vartype
|
|
((type_T **)stack->ga_data)[stack->ga_len - 1] = vartype;
|
|
|
|
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)
|
|
{
|
|
isn_T *isn;
|
|
|
|
RETURN_OK_IF_SKIP(cctx);
|
|
if ((isn = generate_instr_type(cctx, ISN_PUSHFUNC, &t_func_void)) == NULL)
|
|
return FAIL;
|
|
isn->isn_arg.string = name;
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Generate an ISN_PUSHPARTIAL instruction with partial "part".
|
|
* Consumes "name".
|
|
*/
|
|
static int
|
|
generate_PUSHPARTIAL(cctx_T *cctx, partial_T *part)
|
|
{
|
|
isn_T *isn;
|
|
|
|
RETURN_OK_IF_SKIP(cctx);
|
|
if ((isn = generate_instr_type(cctx, ISN_PUSHPARTIAL,
|
|
&t_partial_any)) == NULL)
|
|
return FAIL;
|
|
isn->isn_arg.partial = part;
|
|
|
|
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.
|
|
*/
|
|
static int
|
|
generate_LOADV(
|
|
cctx_T *cctx,
|
|
char_u *name,
|
|
int error)
|
|
{
|
|
// load v:var
|
|
int vidx = find_vim_var(name);
|
|
|
|
RETURN_OK_IF_SKIP(cctx);
|
|
if (vidx < 0)
|
|
{
|
|
if (error)
|
|
semsg(_(e_var_notfound), name);
|
|
return FAIL;
|
|
}
|
|
|
|
// TODO: get actual type
|
|
return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, &t_any);
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
garray_T *type_list = cctx->ctx_type_list;
|
|
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 "void" 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, 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;
|
|
garray_T *type_list = cctx->ctx_type_list;
|
|
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, 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.number = dfunc_idx;
|
|
|
|
if (ga_grow(stack, 1) == FAIL)
|
|
return FAIL;
|
|
((type_T **)stack->ga_data)[stack->ga_len] = &t_partial_any;
|
|
// TODO: argument and return types
|
|
++stack->ga_len;
|
|
|
|
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.
|
|
* Return FAIL if the number of arguments is wrong.
|
|
*/
|
|
static int
|
|
generate_BCALL(cctx_T *cctx, int func_idx, int argcount)
|
|
{
|
|
isn_T *isn;
|
|
garray_T *stack = &cctx->ctx_type_stack;
|
|
type_T *argtypes[MAX_FUNC_ARGS];
|
|
int i;
|
|
|
|
RETURN_OK_IF_SKIP(cctx);
|
|
if (check_internal_func(func_idx, argcount) == FAIL)
|
|
return FAIL;
|
|
|
|
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;
|
|
}
|
|
|
|
// Turn varargs into a list.
|
|
if (ufunc->uf_va_name != NULL)
|
|
{
|
|
int count = argcount - regular_args;
|
|
|
|
// If count is negative an empty list will be added after evaluating
|
|
// default values for missing optional arguments.
|
|
if (count >= 0)
|
|
{
|
|
generate_NEWLIST(cctx, count);
|
|
argcount = regular_args + 1;
|
|
}
|
|
}
|
|
|
|
if ((isn = generate_instr(cctx,
|
|
ufunc->uf_dfunc_idx >= 0 ? ISN_DCALL : ISN_UCALL)) == NULL)
|
|
return FAIL;
|
|
if (ufunc->uf_dfunc_idx >= 0)
|
|
{
|
|
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.
|
|
*/
|
|
static int
|
|
generate_PCALL(cctx_T *cctx, int argcount, int at_top)
|
|
{
|
|
isn_T *isn;
|
|
garray_T *stack = &cctx->ctx_type_stack;
|
|
|
|
RETURN_OK_IF_SKIP(cctx);
|
|
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] = &t_any;
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Generate an ISN_MEMBER instruction.
|
|
*/
|
|
static int
|
|
generate_MEMBER(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_MEMBER)) == NULL)
|
|
return FAIL;
|
|
isn->isn_arg.string = vim_strnsave(name, (int)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 instruction.
|
|
*/
|
|
static int
|
|
generate_EXECUTE(cctx_T *cctx, int count)
|
|
{
|
|
isn_T *isn;
|
|
|
|
if ((isn = generate_instr_drop(cctx, ISN_EXECUTE, 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 char e_white_both[] =
|
|
N_("E1004: white space required before and after '%s'");
|
|
|
|
/*
|
|
* Reserve space for a local variable.
|
|
* Return the index or -1 if it failed.
|
|
*/
|
|
static int
|
|
reserve_local(cctx_T *cctx, char_u *name, size_t len, int isConst, type_T *type)
|
|
{
|
|
int idx;
|
|
lvar_T *lvar;
|
|
|
|
if (lookup_arg(name, len, cctx) >= 0 || lookup_vararg(name, len, cctx))
|
|
{
|
|
emsg_namelen(_("E1006: %s is used as an argument"), name, (int)len);
|
|
return -1;
|
|
}
|
|
|
|
if (ga_grow(&cctx->ctx_locals, 1) == FAIL)
|
|
return -1;
|
|
idx = cctx->ctx_locals.ga_len;
|
|
if (cctx->ctx_max_local < idx + 1)
|
|
cctx->ctx_max_local = idx + 1;
|
|
++cctx->ctx_locals.ga_len;
|
|
|
|
lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
|
|
lvar->lv_name = vim_strnsave(name, (int)(len == 0 ? STRLEN(name) : len));
|
|
lvar->lv_const = isConst;
|
|
lvar->lv_type = type;
|
|
|
|
return idx;
|
|
}
|
|
|
|
/*
|
|
* 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_local(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.
|
|
*/
|
|
char_u *
|
|
skip_type(char_u *start)
|
|
{
|
|
char_u *p = start;
|
|
|
|
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));
|
|
p = skipwhite(p);
|
|
if (*p == '>')
|
|
++p;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/*
|
|
* Parse the member type: "<type>" and return "type" with the member set.
|
|
* Use "type_list" 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_list)
|
|
{
|
|
type_T *member_type;
|
|
int prev_called_emsg = called_emsg;
|
|
|
|
if (**arg != '<')
|
|
{
|
|
if (*skipwhite(*arg) == '<')
|
|
emsg(_("E1007: No white space allowed before <"));
|
|
else
|
|
emsg(_("E1008: Missing <type>"));
|
|
return type;
|
|
}
|
|
*arg = skipwhite(*arg + 1);
|
|
|
|
member_type = parse_type(arg, type_list);
|
|
|
|
*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_list);
|
|
return get_dict_type(member_type, type_list);
|
|
}
|
|
|
|
/*
|
|
* Parse a type at "arg" and advance over it.
|
|
* Return NULL for failure.
|
|
*/
|
|
type_T *
|
|
parse_type(char_u **arg, garray_T *type_list)
|
|
{
|
|
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_list);
|
|
}
|
|
break;
|
|
case 'f':
|
|
if (len == 5 && STRNCMP(*arg, "float", len) == 0)
|
|
{
|
|
#ifdef FEAT_FLOAT
|
|
*arg += len;
|
|
return &t_float;
|
|
#else
|
|
emsg(_("E1055: This Vim is not compiled with float support"));
|
|
return &t_any;
|
|
#endif
|
|
}
|
|
if (len == 4 && STRNCMP(*arg, "func", len) == 0)
|
|
{
|
|
*arg += len;
|
|
// TODO: arguments and return type
|
|
return &t_func_any;
|
|
}
|
|
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_list);
|
|
}
|
|
break;
|
|
case 'n':
|
|
if (len == 6 && STRNCMP(*arg, "number", len) == 0)
|
|
{
|
|
*arg += len;
|
|
return &t_number;
|
|
}
|
|
break;
|
|
case 'p':
|
|
if (len == 7 && STRNCMP(*arg, "partial", len) == 0)
|
|
{
|
|
*arg += len;
|
|
// TODO: arguments and return type
|
|
return &t_partial_any;
|
|
}
|
|
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)
|
|
{
|
|
if (type1->tt_type != type2->tt_type)
|
|
return FALSE;
|
|
switch (type1->tt_type)
|
|
{
|
|
case VAR_VOID:
|
|
case VAR_UNKNOWN:
|
|
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:
|
|
// TODO; check argument types.
|
|
return equal_type(type1->tt_member, type2->tt_member)
|
|
&& type1->tt_argcount == type2->tt_argcount;
|
|
}
|
|
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_list)
|
|
{
|
|
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_list);
|
|
if (type1->tt_type == VAR_LIST)
|
|
*dest = get_list_type(common, type_list);
|
|
else
|
|
*dest = get_dict_type(common, type_list);
|
|
return;
|
|
}
|
|
// TODO: VAR_FUNC and VAR_PARTIAL
|
|
*dest = type1;
|
|
}
|
|
|
|
*dest = &t_any;
|
|
}
|
|
|
|
char *
|
|
vartype_name(vartype_T type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case VAR_UNKNOWN: break;
|
|
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: return "func";
|
|
case VAR_PARTIAL: return "partial";
|
|
}
|
|
return "any";
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
}
|
|
// TODO: function and partial argument types
|
|
|
|
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/
|
|
*/
|
|
imported_T *
|
|
find_imported(char_u *name, size_t len, cctx_T *cctx)
|
|
{
|
|
scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
|
|
int idx;
|
|
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Generate an instruction to load script-local variable "name".
|
|
*/
|
|
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);
|
|
int name_len;
|
|
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;
|
|
}
|
|
|
|
idx = find_exported(import->imp_sid, &p, &name_len, &ufunc, &type);
|
|
// 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
|
|
{
|
|
// TODO: check this is a variable, not a function
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
char_u *end = end_arg;
|
|
int res = FAIL;
|
|
int prev_called_emsg = called_emsg;
|
|
|
|
if (*(*arg + 1) == ':')
|
|
{
|
|
// load namespaced variable
|
|
if (end <= *arg + 2)
|
|
name = vim_strsave((char_u *)"[empty]");
|
|
else
|
|
name = vim_strnsave(*arg + 2, end - (*arg + 2));
|
|
if (name == NULL)
|
|
return FAIL;
|
|
|
|
if (**arg == 'v')
|
|
{
|
|
res = generate_LOADV(cctx, name, error);
|
|
}
|
|
else if (**arg == 'g')
|
|
{
|
|
// Global variables can be defined later, thus we don't check if it
|
|
// exists, give error at runtime.
|
|
res = generate_LOAD(cctx, ISN_LOADG, 0, name, &t_any);
|
|
}
|
|
else if (**arg == 's')
|
|
{
|
|
res = compile_load_scriptvar(cctx, name, NULL, NULL, error);
|
|
}
|
|
else if (**arg == 'b')
|
|
{
|
|
semsg("Namespace b: not supported yet: %s", *arg);
|
|
goto theend;
|
|
}
|
|
else if (**arg == 'w')
|
|
{
|
|
semsg("Namespace w: not supported yet: %s", *arg);
|
|
goto theend;
|
|
}
|
|
else if (**arg == 't')
|
|
{
|
|
semsg("Namespace t: not supported yet: %s", *arg);
|
|
goto theend;
|
|
}
|
|
else
|
|
{
|
|
semsg("E1075: Namespace not supported: %s", *arg);
|
|
goto theend;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
size_t len = end - *arg;
|
|
int idx;
|
|
int gen_load = FALSE;
|
|
|
|
name = vim_strnsave(*arg, end - *arg);
|
|
if (name == NULL)
|
|
return FAIL;
|
|
|
|
idx = lookup_arg(*arg, len, cctx);
|
|
if (idx >= 0)
|
|
{
|
|
if (cctx->ctx_ufunc->uf_arg_types != NULL)
|
|
type = cctx->ctx_ufunc->uf_arg_types[idx];
|
|
else
|
|
type = &t_any;
|
|
|
|
// Arguments are located above the frame pointer.
|
|
idx -= cctx->ctx_ufunc->uf_args.ga_len + STACK_FRAME_SIZE;
|
|
if (cctx->ctx_ufunc->uf_va_name != NULL)
|
|
--idx;
|
|
gen_load = TRUE;
|
|
}
|
|
else if (lookup_vararg(*arg, len, cctx))
|
|
{
|
|
// varargs is always the last argument
|
|
idx = -STACK_FRAME_SIZE - 1;
|
|
type = cctx->ctx_ufunc->uf_va_type;
|
|
gen_load = TRUE;
|
|
}
|
|
else
|
|
{
|
|
idx = lookup_local(*arg, len, cctx);
|
|
if (idx >= 0)
|
|
{
|
|
type = (((lvar_T *)cctx->ctx_locals.ga_data) + idx)->lv_type;
|
|
gen_load = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if ((len == 4 && STRNCMP("true", *arg, 4) == 0)
|
|
|| (len == 5 && STRNCMP("false", *arg, 5) == 0))
|
|
res = generate_PUSHBOOL(cctx, **arg == 't'
|
|
? VVAL_TRUE : VVAL_FALSE);
|
|
else if (SCRIPT_ITEM(current_sctx.sc_sid)->sn_version
|
|
== SCRIPT_VERSION_VIM9)
|
|
// in Vim9 script "var" can be script-local.
|
|
res = compile_load_scriptvar(cctx, name, *arg, &end, error);
|
|
}
|
|
}
|
|
if (gen_load)
|
|
res = generate_LOAD(cctx, ISN_LOAD, 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;
|
|
|
|
while (*p != NUL && *p != ')')
|
|
{
|
|
if (compile_expr1(&p, cctx) == FAIL)
|
|
return FAIL;
|
|
++*argcount;
|
|
|
|
if (*p != ',' && *skipwhite(p) == ',')
|
|
{
|
|
emsg(_("E1068: No white space allowed before ,"));
|
|
p = skipwhite(p);
|
|
}
|
|
if (*p == ',')
|
|
{
|
|
++p;
|
|
if (!VIM_ISWHITE(*p))
|
|
emsg(_("E1069: white space required after ,"));
|
|
}
|
|
p = skipwhite(p);
|
|
}
|
|
p = skipwhite(p);
|
|
if (*p != ')')
|
|
{
|
|
emsg(_(e_missing_close));
|
|
return FAIL;
|
|
}
|
|
*arg = p + 1;
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* 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, 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;
|
|
|
|
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);
|
|
goto theend;
|
|
}
|
|
semsg(_(e_unknownfunc), namebuf);
|
|
}
|
|
|
|
// If we can find the function by name generate the right call.
|
|
ufunc = find_func(name, cctx);
|
|
if (ufunc != NULL)
|
|
{
|
|
res = generate_CALL(cctx, ufunc, argcount);
|
|
goto theend;
|
|
}
|
|
|
|
// If the name is a variable, load it and use PCALL.
|
|
p = namebuf;
|
|
if (compile_load(&p, namebuf + varlen, cctx, FALSE) == OK)
|
|
{
|
|
res = generate_PCALL(cctx, argcount, FALSE);
|
|
goto theend;
|
|
}
|
|
|
|
// The function may be defined only later. Need to figure out at runtime.
|
|
res = generate_UCALL(cctx, name, argcount);
|
|
|
|
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.
|
|
*/
|
|
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 (get_list_tv(&p, &rettv, FALSE, FALSE) == FAIL)
|
|
p = arg;
|
|
}
|
|
else if (p == arg && *arg == '#' && arg[1] == '{')
|
|
{
|
|
// Can be "#{a: 1}->Func()".
|
|
++p;
|
|
if (eval_dict(&p, &rettv, FALSE, TRUE) == FAIL)
|
|
p = arg;
|
|
}
|
|
else if (p == arg && *arg == '{')
|
|
{
|
|
int ret = get_lambda_tv(&p, &rettv, FALSE);
|
|
|
|
// Can be "{x -> ret}()".
|
|
// Can be "{'a': 1}->Func()".
|
|
if (ret == NOTDONE)
|
|
ret = eval_dict(&p, &rettv, FALSE, FALSE);
|
|
if (ret != OK)
|
|
p = arg;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Check if the expected and actual types match.
|
|
*/
|
|
static int
|
|
check_type(type_T *expected, type_T *actual, int give_msg)
|
|
{
|
|
if (expected->tt_type != VAR_UNKNOWN)
|
|
{
|
|
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)
|
|
{
|
|
int ret;
|
|
|
|
// void is used for an empty list or dict
|
|
if (actual->tt_member == &t_void)
|
|
ret = OK;
|
|
else
|
|
ret = check_type(expected->tt_member, actual->tt_member, FALSE);
|
|
if (ret == FAIL && give_msg)
|
|
type_mismatch(expected, actual);
|
|
return ret;
|
|
}
|
|
}
|
|
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)
|
|
{
|
|
if (check_type(expected, actual, FALSE))
|
|
return OK;
|
|
if (actual->tt_type != VAR_UNKNOWN)
|
|
{
|
|
type_mismatch(expected, actual);
|
|
return FAIL;
|
|
}
|
|
generate_TYPECHECK(cctx, expected, offset);
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* 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);
|
|
int count = 0;
|
|
|
|
while (*p != ']')
|
|
{
|
|
if (*p == NUL)
|
|
{
|
|
semsg(_(e_list_end), *arg);
|
|
return FAIL;
|
|
}
|
|
if (compile_expr1(&p, cctx) == FAIL)
|
|
break;
|
|
++count;
|
|
if (*p == ',')
|
|
++p;
|
|
p = skipwhite(p);
|
|
}
|
|
*arg = p + 1;
|
|
|
|
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)
|
|
{
|
|
garray_T *instr = &cctx->ctx_instr;
|
|
typval_T rettv;
|
|
ufunc_T *ufunc;
|
|
|
|
// Get the funcref in "rettv".
|
|
if (get_lambda_tv(arg, &rettv, TRUE) != OK)
|
|
return FAIL;
|
|
|
|
ufunc = rettv.vval.v_partial->pt_func;
|
|
++ufunc->uf_refcount;
|
|
clear_tv(&rettv);
|
|
|
|
// The function will have one line: "return {expr}".
|
|
// Compile it into instructions.
|
|
compile_def_function(ufunc, TRUE);
|
|
|
|
if (ufunc->uf_dfunc_idx >= 0)
|
|
{
|
|
if (ga_grow(instr, 1) == FAIL)
|
|
return FAIL;
|
|
generate_FUNCREF(cctx, ufunc->uf_dfunc_idx);
|
|
return OK;
|
|
}
|
|
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, TRUE) == 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);
|
|
|
|
// The function will have one line: "return {expr}".
|
|
// Compile it into instructions.
|
|
compile_def_function(ufunc, TRUE);
|
|
|
|
// compile the arguments
|
|
*arg = skipwhite(*arg + 1);
|
|
if (compile_arguments(arg, cctx, &argcount) == OK)
|
|
// call the compiled function
|
|
ret = generate_CALL(cctx, ufunc, argcount);
|
|
|
|
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;
|
|
int count = 0;
|
|
dict_T *d = dict_alloc();
|
|
dictitem_T *item;
|
|
|
|
if (d == NULL)
|
|
return FAIL;
|
|
*arg = skipwhite(*arg + 1);
|
|
while (**arg != '}' && **arg != NUL)
|
|
{
|
|
char_u *key = NULL;
|
|
|
|
if (literal)
|
|
{
|
|
char_u *p = to_name_end(*arg, !literal);
|
|
|
|
if (p == *arg)
|
|
{
|
|
semsg(_("E1014: Invalid key: %s"), *arg);
|
|
return FAIL;
|
|
}
|
|
key = vim_strnsave(*arg, p - *arg);
|
|
if (generate_PUSHS(cctx, key) == FAIL)
|
|
return FAIL;
|
|
*arg = p;
|
|
}
|
|
else
|
|
{
|
|
isn_T *isn;
|
|
|
|
if (compile_expr1(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
// TODO: check type is string
|
|
isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
|
|
if (isn->isn_type == ISN_PUSHS)
|
|
key = isn->isn_arg.string;
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
*arg = skipwhite(*arg + 1);
|
|
if (compile_expr1(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
++count;
|
|
|
|
if (**arg == '}')
|
|
break;
|
|
if (**arg != ',')
|
|
{
|
|
semsg(_(e_missing_dict_comma), *arg);
|
|
goto failret;
|
|
}
|
|
*arg = skipwhite(*arg + 1);
|
|
}
|
|
|
|
if (**arg != '}')
|
|
{
|
|
semsg(_(e_missing_dict_end), *arg);
|
|
goto failret;
|
|
}
|
|
*arg = *arg + 1;
|
|
|
|
dict_unref(d);
|
|
return generate_NEWDICT(cctx, count);
|
|
|
|
failret:
|
|
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 = get_option_tv(arg, &rettv, TRUE);
|
|
if (ret == OK)
|
|
{
|
|
// include the '&' in the name, get_option_tv() 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, get_env_tv() 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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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()".
|
|
*/
|
|
static int
|
|
compile_subscript(
|
|
char_u **arg,
|
|
cctx_T *cctx,
|
|
char_u **start_leader,
|
|
char_u *end_leader)
|
|
{
|
|
for (;;)
|
|
{
|
|
if (**arg == '(')
|
|
{
|
|
int argcount = 0;
|
|
|
|
// funcref(arg)
|
|
*arg = skipwhite(*arg + 1);
|
|
if (compile_arguments(arg, cctx, &argcount) == FAIL)
|
|
return FAIL;
|
|
if (generate_PCALL(cctx, argcount, TRUE) == FAIL)
|
|
return FAIL;
|
|
}
|
|
else if (**arg == '-' && (*arg)[1] == '>')
|
|
{
|
|
char_u *p;
|
|
|
|
// 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
|
|
|
|
*arg = skipwhite(*arg + 2);
|
|
if (**arg == '{')
|
|
{
|
|
// lambda call: list->{lambda}
|
|
if (compile_lambda_call(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
}
|
|
else
|
|
{
|
|
// method call: list->method()
|
|
p = *arg;
|
|
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, 1) == FAIL)
|
|
return FAIL;
|
|
}
|
|
}
|
|
else if (**arg == '[')
|
|
{
|
|
garray_T *stack;
|
|
type_T **typep;
|
|
|
|
// list index: list[123]
|
|
// TODO: more arguments
|
|
// TODO: dict member dict['name']
|
|
*arg = skipwhite(*arg + 1);
|
|
if (compile_expr1(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
if (**arg != ']')
|
|
{
|
|
emsg(_(e_missbrac));
|
|
return FAIL;
|
|
}
|
|
*arg = *arg + 1;
|
|
|
|
if (generate_instr_drop(cctx, ISN_INDEX, 1) == FAIL)
|
|
return FAIL;
|
|
stack = &cctx->ctx_type_stack;
|
|
typep = ((type_T **)stack->ga_data) + stack->ga_len - 1;
|
|
if ((*typep)->tt_type != VAR_LIST && *typep != &t_any)
|
|
{
|
|
emsg(_(e_listreq));
|
|
return FAIL;
|
|
}
|
|
if ((*typep)->tt_type == VAR_LIST)
|
|
*typep = (*typep)->tt_member;
|
|
}
|
|
else if (**arg == '.' && (*arg)[1] != '.')
|
|
{
|
|
char_u *p;
|
|
|
|
++*arg;
|
|
p = *arg;
|
|
// dictionary member: dict.name
|
|
if (eval_isnamec1(*p))
|
|
while (eval_isnamec(*p))
|
|
MB_PTR_ADV(p);
|
|
if (p == *arg)
|
|
{
|
|
semsg(_(e_syntax_at), *arg);
|
|
return FAIL;
|
|
}
|
|
if (generate_MEMBER(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 "*p" and add instructions to "instr".
|
|
* "p" is advanced until after the expression, skipping white space.
|
|
*
|
|
* This is the 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)
|
|
{
|
|
typval_T rettv;
|
|
char_u *start_leader, *end_leader;
|
|
int ret = OK;
|
|
|
|
/*
|
|
* 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 (get_number_tv(arg, &rettv, TRUE, FALSE) == FAIL)
|
|
return FAIL;
|
|
break;
|
|
|
|
/*
|
|
* String constant: "string".
|
|
*/
|
|
case '"': if (get_string_tv(arg, &rettv, TRUE) == FAIL)
|
|
return FAIL;
|
|
break;
|
|
|
|
/*
|
|
* Literal string constant: 'str''ing'.
|
|
*/
|
|
case '\'': if (get_lit_string_tv(arg, &rettv, TRUE) == FAIL)
|
|
return FAIL;
|
|
break;
|
|
|
|
/*
|
|
* Constant Vim variable.
|
|
*/
|
|
case 'v': get_vim_constant(arg, &rettv);
|
|
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);
|
|
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);
|
|
ret = compile_expr1(arg, cctx); // recursive!
|
|
*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)
|
|
{
|
|
// 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
|
|
|
|
// push constant
|
|
switch (rettv.v_type)
|
|
{
|
|
case VAR_BOOL:
|
|
generate_PUSHBOOL(cctx, rettv.vval.v_number);
|
|
break;
|
|
case VAR_SPECIAL:
|
|
generate_PUSHSPEC(cctx, rettv.vval.v_number);
|
|
break;
|
|
case VAR_NUMBER:
|
|
generate_PUSHNR(cctx, rettv.vval.v_number);
|
|
break;
|
|
#ifdef FEAT_FLOAT
|
|
case VAR_FLOAT:
|
|
generate_PUSHF(cctx, rettv.vval.v_float);
|
|
break;
|
|
#endif
|
|
case VAR_BLOB:
|
|
generate_PUSHBLOB(cctx, rettv.vval.v_blob);
|
|
rettv.vval.v_blob = NULL;
|
|
break;
|
|
case VAR_STRING:
|
|
generate_PUSHS(cctx, rettv.vval.v_string);
|
|
rettv.vval.v_string = NULL;
|
|
break;
|
|
default:
|
|
iemsg("constant type missing");
|
|
return FAIL;
|
|
}
|
|
}
|
|
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, 0);
|
|
else
|
|
r = compile_load(arg, p, cctx, TRUE);
|
|
if (r == FAIL)
|
|
return FAIL;
|
|
}
|
|
|
|
if (compile_subscript(arg, cctx, &start_leader, end_leader) == FAIL)
|
|
return FAIL;
|
|
|
|
// Now deal with prefixed '-', '+' and '!', if not done already.
|
|
return compile_leader(cctx, start_leader, end_leader);
|
|
}
|
|
|
|
/*
|
|
* * number multiplication
|
|
* / number division
|
|
* % number modulo
|
|
*/
|
|
static int
|
|
compile_expr6(char_u **arg, cctx_T *cctx)
|
|
{
|
|
char_u *op;
|
|
|
|
// get the first variable
|
|
if (compile_expr7(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
/*
|
|
* Repeat computing, until no "*", "/" or "%" is following.
|
|
*/
|
|
for (;;)
|
|
{
|
|
op = skipwhite(*arg);
|
|
if (*op != '*' && *op != '/' && *op != '%')
|
|
break;
|
|
if (!VIM_ISWHITE(**arg) || !VIM_ISWHITE(op[1]))
|
|
{
|
|
char_u buf[3];
|
|
|
|
vim_strncpy(buf, op, 1);
|
|
semsg(_(e_white_both), buf);
|
|
}
|
|
*arg = skipwhite(op + 1);
|
|
|
|
// get the second variable
|
|
if (compile_expr7(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
generate_two_op(cctx, op);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* + number addition
|
|
* - number subtraction
|
|
* .. string concatenation
|
|
*/
|
|
static int
|
|
compile_expr5(char_u **arg, cctx_T *cctx)
|
|
{
|
|
char_u *op;
|
|
int oplen;
|
|
|
|
// get the first variable
|
|
if (compile_expr6(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
/*
|
|
* Repeat computing, until no "+", "-" or ".." is following.
|
|
*/
|
|
for (;;)
|
|
{
|
|
op = skipwhite(*arg);
|
|
if (*op != '+' && *op != '-' && !(*op == '.' && (*(*arg + 1) == '.')))
|
|
break;
|
|
oplen = (*op == '.' ? 2 : 1);
|
|
|
|
if (!VIM_ISWHITE(**arg) || !VIM_ISWHITE(op[oplen]))
|
|
{
|
|
char_u buf[3];
|
|
|
|
vim_strncpy(buf, op, oplen);
|
|
semsg(_(e_white_both), buf);
|
|
}
|
|
|
|
*arg = skipwhite(op + oplen);
|
|
|
|
// get the second variable
|
|
if (compile_expr6(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
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;
|
|
}
|
|
|
|
static 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;
|
|
}
|
|
|
|
/*
|
|
* 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)
|
|
{
|
|
exptype_T type = EXPR_UNKNOWN;
|
|
char_u *p;
|
|
int len = 2;
|
|
int type_is = FALSE;
|
|
|
|
// get the first variable
|
|
if (compile_expr5(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
p = skipwhite(*arg);
|
|
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 (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 (!VIM_ISWHITE(**arg) || !VIM_ISWHITE(p[len]))
|
|
{
|
|
char_u buf[7];
|
|
|
|
vim_strncpy(buf, p, len);
|
|
semsg(_(e_white_both), buf);
|
|
}
|
|
|
|
// get the second variable
|
|
*arg = skipwhite(p + len);
|
|
if (compile_expr5(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
generate_COMPARE(cctx, type, ic);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Compile || or &&.
|
|
*/
|
|
static int
|
|
compile_and_or(char_u **arg, cctx_T *cctx, char *op)
|
|
{
|
|
char_u *p = skipwhite(*arg);
|
|
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 (!VIM_ISWHITE(**arg) || !VIM_ISWHITE(p[2]))
|
|
semsg(_(e_white_both), op);
|
|
|
|
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 ((opchar == '|' ? compile_expr3(arg, cctx)
|
|
: compile_expr4(arg, cctx)) == FAIL)
|
|
{
|
|
ga_clear(&end_ga);
|
|
return FAIL;
|
|
}
|
|
p = skipwhite(*arg);
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
// get the first variable
|
|
if (compile_expr4(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
// || and && work almost the same
|
|
return compile_and_or(arg, cctx, "&&");
|
|
}
|
|
|
|
/*
|
|
* 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)
|
|
{
|
|
// eval the first expression
|
|
if (compile_expr3(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
// || and && work almost the same
|
|
return compile_and_or(arg, cctx, "||");
|
|
}
|
|
|
|
/*
|
|
* 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)
|
|
{
|
|
char_u *p;
|
|
|
|
// evaluate the first expression
|
|
if (compile_expr2(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
p = skipwhite(*arg);
|
|
if (*p == '?')
|
|
{
|
|
garray_T *instr = &cctx->ctx_instr;
|
|
garray_T *stack = &cctx->ctx_type_stack;
|
|
int alt_idx = instr->ga_len;
|
|
int end_idx;
|
|
isn_T *isn;
|
|
type_T *type1;
|
|
type_T *type2;
|
|
|
|
if (!VIM_ISWHITE(**arg) || !VIM_ISWHITE(p[1]))
|
|
semsg(_(e_white_both), "?");
|
|
|
|
generate_JUMP(cctx, JUMP_IF_FALSE, 0);
|
|
|
|
// evaluate the second expression; any type is accepted
|
|
*arg = skipwhite(p + 1);
|
|
if (compile_expr1(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
// 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 = skipwhite(*arg);
|
|
if (*p != ':')
|
|
{
|
|
emsg(_(e_missing_colon));
|
|
return FAIL;
|
|
}
|
|
if (!VIM_ISWHITE(**arg) || !VIM_ISWHITE(p[1]))
|
|
semsg(_(e_white_both), ":");
|
|
|
|
// evaluate the third expression
|
|
*arg = skipwhite(p + 1);
|
|
if (compile_expr1(arg, cctx) == FAIL)
|
|
return FAIL;
|
|
|
|
// 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;
|
|
}
|
|
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_expr1(&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 (need_type(stack_type, cctx->ctx_ufunc->uf_ret_type, -1, cctx)
|
|
== FAIL)
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
if (set_return_type)
|
|
cctx->ctx_ufunc->uf_ret_type = &t_void;
|
|
else if (cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_VOID)
|
|
{
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* 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
|
|
};
|
|
|
|
/*
|
|
* Get a line for "=<<".
|
|
* Return a pointer to the line in allocated memory.
|
|
* Return NULL for end-of-file or some error.
|
|
*/
|
|
static char_u *
|
|
heredoc_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)
|
|
NULL;
|
|
++cctx->ctx_lnum;
|
|
return vim_strsave(((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)
|
|
[cctx->ctx_lnum]);
|
|
}
|
|
|
|
typedef enum {
|
|
dest_local,
|
|
dest_option,
|
|
dest_env,
|
|
dest_global,
|
|
dest_vimvar,
|
|
dest_script,
|
|
dest_reg,
|
|
} assign_dest_T;
|
|
|
|
/*
|
|
* compile "let var [= expr]", "const var = expr" and "var = expr"
|
|
* "arg" points to "var".
|
|
*/
|
|
static char_u *
|
|
compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
|
|
{
|
|
char_u *p;
|
|
char_u *ret = NULL;
|
|
int var_count = 0;
|
|
int semicolon = 0;
|
|
size_t varlen;
|
|
garray_T *instr = &cctx->ctx_instr;
|
|
int idx = -1;
|
|
char_u *op;
|
|
int opt_type;
|
|
assign_dest_T dest = dest_local;
|
|
int opt_flags = 0;
|
|
int vimvaridx = -1;
|
|
int oplen = 0;
|
|
int heredoc = FALSE;
|
|
type_T *type;
|
|
lvar_T *lvar;
|
|
char_u *name;
|
|
char_u *sp;
|
|
int has_type = FALSE;
|
|
int is_decl = cmdidx == CMD_let || cmdidx == CMD_const;
|
|
int instr_count = -1;
|
|
|
|
p = skip_var_list(arg, FALSE, &var_count, &semicolon);
|
|
if (p == NULL)
|
|
return NULL;
|
|
if (var_count > 0)
|
|
{
|
|
// TODO: let [var, var] = list
|
|
emsg("Cannot handle a list yet");
|
|
return NULL;
|
|
}
|
|
|
|
varlen = p - arg;
|
|
name = vim_strnsave(arg, (int)varlen);
|
|
if (name == NULL)
|
|
return NULL;
|
|
|
|
if (cctx->ctx_skip != TRUE)
|
|
{
|
|
if (*arg == '&')
|
|
{
|
|
int cc;
|
|
long numval;
|
|
|
|
dest = dest_option;
|
|
if (cmdidx == CMD_const)
|
|
{
|
|
emsg(_(e_const_option));
|
|
return NULL;
|
|
}
|
|
if (is_decl)
|
|
{
|
|
semsg(_("E1052: Cannot declare an option: %s"), arg);
|
|
goto theend;
|
|
}
|
|
p = arg;
|
|
p = find_option_end(&p, &opt_flags);
|
|
if (p == NULL)
|
|
{
|
|
emsg(_(e_letunexp));
|
|
return NULL;
|
|
}
|
|
cc = *p;
|
|
*p = NUL;
|
|
opt_type = get_option_value(arg + 1, &numval, NULL, opt_flags);
|
|
*p = cc;
|
|
if (opt_type == -3)
|
|
{
|
|
semsg(_(e_unknown_option), *arg);
|
|
return NULL;
|
|
}
|
|
if (opt_type == -2 || opt_type == 0)
|
|
type = &t_string;
|
|
else
|
|
type = &t_number; // both number and boolean option
|
|
}
|
|
else if (*arg == '$')
|
|
{
|
|
dest = dest_env;
|
|
if (is_decl)
|
|
{
|
|
semsg(_("E1065: Cannot declare an environment variable: %s"), name);
|
|
goto theend;
|
|
}
|
|
}
|
|
else if (*arg == '@')
|
|
{
|
|
if (!valid_yank_reg(arg[1], TRUE))
|
|
{
|
|
emsg_invreg(arg[1]);
|
|
return FAIL;
|
|
}
|
|
dest = dest_reg;
|
|
if (is_decl)
|
|
{
|
|
semsg(_("E1066: Cannot declare a register: %s"), name);
|
|
goto theend;
|
|
}
|
|
}
|
|
else if (STRNCMP(arg, "g:", 2) == 0)
|
|
{
|
|
dest = dest_global;
|
|
if (is_decl)
|
|
{
|
|
semsg(_("E1016: Cannot declare a global variable: %s"), name);
|
|
goto theend;
|
|
}
|
|
}
|
|
else if (STRNCMP(arg, "v:", 2) == 0)
|
|
{
|
|
vimvaridx = find_vim_var(name + 2);
|
|
if (vimvaridx < 0)
|
|
{
|
|
semsg(_(e_var_notfound), arg);
|
|
goto theend;
|
|
}
|
|
dest = dest_vimvar;
|
|
if (is_decl)
|
|
{
|
|
semsg(_("E1064: Cannot declare a v: variable: %s"), name);
|
|
goto theend;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (idx = 0; reserved[idx] != NULL; ++idx)
|
|
if (STRCMP(reserved[idx], name) == 0)
|
|
{
|
|
semsg(_("E1034: Cannot use reserved name %s"), name);
|
|
goto theend;
|
|
}
|
|
|
|
idx = lookup_local(arg, varlen, cctx);
|
|
if (idx >= 0)
|
|
{
|
|
if (is_decl)
|
|
{
|
|
semsg(_("E1017: Variable already declared: %s"), name);
|
|
goto theend;
|
|
}
|
|
else
|
|
{
|
|
lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
|
|
if (lvar->lv_const)
|
|
{
|
|
semsg(_("E1018: Cannot assign to a constant: %s"), name);
|
|
goto theend;
|
|
}
|
|
}
|
|
}
|
|
else if (STRNCMP(arg, "s:", 2) == 0
|
|
|| lookup_script(arg, varlen) == OK
|
|
|| find_imported(arg, varlen, cctx) != NULL)
|
|
{
|
|
dest = dest_script;
|
|
if (is_decl)
|
|
{
|
|
semsg(_("E1054: Variable already declared in the script: %s"),
|
|
name);
|
|
goto theend;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dest != dest_option)
|
|
{
|
|
if (is_decl && *p == ':')
|
|
{
|
|
// parse optional type: "let var: type = expr"
|
|
p = skipwhite(p + 1);
|
|
type = parse_type(&p, cctx->ctx_type_list);
|
|
if (type == NULL)
|
|
goto theend;
|
|
has_type = TRUE;
|
|
}
|
|
else if (idx < 0)
|
|
{
|
|
// global and new local default to "any" type
|
|
type = &t_any;
|
|
}
|
|
else
|
|
{
|
|
lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
|
|
type = lvar->lv_type;
|
|
}
|
|
}
|
|
|
|
sp = p;
|
|
p = skipwhite(p);
|
|
op = p;
|
|
oplen = assignment_len(p, &heredoc);
|
|
if (oplen > 0 && (!VIM_ISWHITE(*sp) || !VIM_ISWHITE(op[oplen])))
|
|
{
|
|
char_u buf[4];
|
|
|
|
vim_strncpy(buf, op, oplen);
|
|
semsg(_(e_white_both), buf);
|
|
}
|
|
|
|
if (oplen == 3 && !heredoc && dest != dest_global
|
|
&& type->tt_type != VAR_STRING && type->tt_type != VAR_UNKNOWN)
|
|
{
|
|
emsg(_("E1019: Can only concatenate to string"));
|
|
goto theend;
|
|
}
|
|
|
|
// +=, /=, etc. require an existing variable
|
|
if (idx < 0 && dest == dest_local && cctx->ctx_skip != TRUE)
|
|
{
|
|
if (oplen > 1 && !heredoc)
|
|
{
|
|
semsg(_("E1020: cannot use an operator on a new variable: %s"),
|
|
name);
|
|
goto theend;
|
|
}
|
|
|
|
// new local variable
|
|
idx = reserve_local(cctx, arg, varlen, cmdidx == CMD_const, type);
|
|
if (idx < 0)
|
|
goto theend;
|
|
}
|
|
|
|
if (heredoc)
|
|
{
|
|
list_T *l;
|
|
listitem_T *li;
|
|
|
|
// [let] varname =<< [trim] {end}
|
|
eap->getline = heredoc_getline;
|
|
eap->cookie = cctx;
|
|
l = heredoc_get(eap, op + 3);
|
|
|
|
// Push each line and the create the list.
|
|
for (li = l->lv_first; li != NULL; li = li->li_next)
|
|
{
|
|
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;
|
|
list_free(l);
|
|
p += STRLEN(p);
|
|
}
|
|
else if (oplen > 0)
|
|
{
|
|
// for "+=", "*=", "..=" etc. first load the current value
|
|
if (*op != '=')
|
|
{
|
|
switch (dest)
|
|
{
|
|
case dest_option:
|
|
// TODO: check the option exists
|
|
generate_LOAD(cctx, ISN_LOADOPT, 0, name + 1, type);
|
|
break;
|
|
case dest_global:
|
|
generate_LOAD(cctx, ISN_LOADG, 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, arg[1], NULL, &t_string);
|
|
break;
|
|
case dest_vimvar:
|
|
generate_LOADV(cctx, name + 2, TRUE);
|
|
break;
|
|
case dest_local:
|
|
generate_LOAD(cctx, ISN_LOAD, idx, NULL, type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// compile the expression
|
|
instr_count = instr->ga_len;
|
|
p = skipwhite(p + oplen);
|
|
if (compile_expr1(&p, cctx) == FAIL)
|
|
goto theend;
|
|
|
|
if (idx >= 0 && (is_decl || !has_type))
|
|
{
|
|
garray_T *stack = &cctx->ctx_type_stack;
|
|
type_T *stacktype =
|
|
((type_T **)stack->ga_data)[stack->ga_len - 1];
|
|
|
|
lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx;
|
|
if (!has_type)
|
|
{
|
|
if (stacktype->tt_type == VAR_VOID)
|
|
{
|
|
emsg(_("E1031: Cannot use void value"));
|
|
goto theend;
|
|
}
|
|
else
|
|
lvar->lv_type = stacktype;
|
|
}
|
|
else
|
|
if (check_type(lvar->lv_type, stacktype, TRUE) == FAIL)
|
|
goto theend;
|
|
}
|
|
}
|
|
else if (cmdidx == CMD_const)
|
|
{
|
|
emsg(_("E1021: const requires a value"));
|
|
goto theend;
|
|
}
|
|
else if (!has_type || dest == dest_option)
|
|
{
|
|
emsg(_("E1022: type or initialization required"));
|
|
goto theend;
|
|
}
|
|
else
|
|
{
|
|
// variables are always initialized
|
|
if (ga_grow(instr, 1) == FAIL)
|
|
goto theend;
|
|
switch (type->tt_type)
|
|
{
|
|
case VAR_BOOL:
|
|
generate_PUSHBOOL(cctx, VVAL_FALSE);
|
|
break;
|
|
case VAR_SPECIAL:
|
|
generate_PUSHSPEC(cctx, VVAL_NONE);
|
|
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);
|
|
break;
|
|
case VAR_PARTIAL:
|
|
generate_PUSHPARTIAL(cctx, NULL);
|
|
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_VOID:
|
|
generate_PUSHNR(cctx, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (oplen > 0 && *op != '=')
|
|
{
|
|
type_T *expected = &t_number;
|
|
garray_T *stack = &cctx->ctx_type_stack;
|
|
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) == 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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_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:
|
|
{
|
|
char_u *rawname = name + (name[1] == ':' ? 2 : 0);
|
|
imported_T *import = NULL;
|
|
int sid = current_sctx.sc_sid;
|
|
|
|
if (name[1] != ':')
|
|
{
|
|
import = find_imported(name, 0, cctx);
|
|
if (import != NULL)
|
|
sid = import->imp_sid;
|
|
}
|
|
|
|
idx = get_script_item_idx(sid, rawname, TRUE);
|
|
// TODO: specific type
|
|
if (idx < 0)
|
|
generate_OLDSCRIPT(cctx, ISN_STORES, name, sid, &t_any);
|
|
else
|
|
generate_VIM9SCRIPT(cctx, ISN_STORESCRIPT,
|
|
sid, idx, &t_any);
|
|
}
|
|
break;
|
|
case dest_local:
|
|
{
|
|
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 (instr->ga_len == instr_count + 1
|
|
&& isn->isn_type == ISN_PUSHNR)
|
|
{
|
|
varnumber_T val = isn->isn_arg.number;
|
|
garray_T *stack = &cctx->ctx_type_stack;
|
|
|
|
isn->isn_type = ISN_STORENR;
|
|
isn->isn_arg.storenr.stnr_idx = idx;
|
|
isn->isn_arg.storenr.stnr_val = val;
|
|
if (stack->ga_len > 0)
|
|
--stack->ga_len;
|
|
}
|
|
else
|
|
generate_STORE(cctx, ISN_STORE, idx, NULL);
|
|
}
|
|
break;
|
|
}
|
|
ret = p;
|
|
|
|
theend:
|
|
vim_free(name);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Compile an :import command.
|
|
*/
|
|
static char_u *
|
|
compile_import(char_u *arg, cctx_T *cctx)
|
|
{
|
|
return handle_import(arg, &cctx->ctx_imports, 0, 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);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
|
|
/*
|
|
* Evaluate an expression that is a constant:
|
|
* has(arg)
|
|
*
|
|
* Also handle:
|
|
* ! in front logical NOT
|
|
*
|
|
* Return FAIL if the expression is not a constant.
|
|
*/
|
|
static int
|
|
evaluate_const_expr7(char_u **arg, cctx_T *cctx UNUSED, typval_T *tv)
|
|
{
|
|
typval_T argvars[2];
|
|
char_u *start_leader, *end_leader;
|
|
|
|
/*
|
|
* Skip '!' characters. They are handled later.
|
|
*/
|
|
start_leader = *arg;
|
|
while (**arg == '!')
|
|
*arg = skipwhite(*arg + 1);
|
|
end_leader = *arg;
|
|
|
|
/*
|
|
* Recognize only a few types of constants for now.
|
|
*/
|
|
if (STRNCMP("true", *arg, 4) == 0 && !ASCII_ISALNUM((*arg)[4]))
|
|
{
|
|
tv->v_type = VAR_SPECIAL;
|
|
tv->vval.v_number = VVAL_TRUE;
|
|
*arg += 4;
|
|
return OK;
|
|
}
|
|
if (STRNCMP("false", *arg, 5) == 0 && !ASCII_ISALNUM((*arg)[5]))
|
|
{
|
|
tv->v_type = VAR_SPECIAL;
|
|
tv->vval.v_number = VVAL_FALSE;
|
|
*arg += 5;
|
|
return OK;
|
|
}
|
|
|
|
if (STRNCMP("has(", *arg, 4) != 0)
|
|
return FAIL;
|
|
*arg = skipwhite(*arg + 4);
|
|
|
|
if (**arg == '"')
|
|
{
|
|
if (get_string_tv(arg, tv, TRUE) == FAIL)
|
|
return FAIL;
|
|
}
|
|
else if (**arg == '\'')
|
|
{
|
|
if (get_lit_string_tv(arg, tv, TRUE) == FAIL)
|
|
return FAIL;
|
|
}
|
|
else
|
|
return FAIL;
|
|
|
|
*arg = skipwhite(*arg);
|
|
if (**arg != ')')
|
|
return FAIL;
|
|
*arg = skipwhite(*arg + 1);
|
|
|
|
argvars[0] = *tv;
|
|
argvars[1].v_type = VAR_UNKNOWN;
|
|
tv->v_type = VAR_NUMBER;
|
|
tv->vval.v_number = 0;
|
|
f_has(argvars, tv);
|
|
clear_tv(&argvars[0]);
|
|
|
|
while (start_leader < end_leader)
|
|
{
|
|
if (*start_leader == '!')
|
|
tv->vval.v_number = !tv->vval.v_number;
|
|
++start_leader;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int
|
|
evaluate_const_expr4(char_u **arg, cctx_T *cctx UNUSED, typval_T *tv)
|
|
{
|
|
exptype_T type = EXPR_UNKNOWN;
|
|
char_u *p;
|
|
int len = 2;
|
|
int type_is = FALSE;
|
|
|
|
// get the first variable
|
|
if (evaluate_const_expr7(arg, cctx, tv) == FAIL)
|
|
return FAIL;
|
|
|
|
p = skipwhite(*arg);
|
|
type = get_compare_type(p, &len, &type_is);
|
|
|
|
/*
|
|
* If there is a comparative operator, use it.
|
|
*/
|
|
if (type != EXPR_UNKNOWN)
|
|
{
|
|
// TODO
|
|
return FAIL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int evaluate_const_expr3(char_u **arg, cctx_T *cctx, typval_T *tv);
|
|
|
|
/*
|
|
* Compile constant || or &&.
|
|
*/
|
|
static int
|
|
evaluate_const_and_or(char_u **arg, cctx_T *cctx, char *op, typval_T *tv)
|
|
{
|
|
char_u *p = skipwhite(*arg);
|
|
int opchar = *op;
|
|
|
|
if (p[0] == opchar && p[1] == opchar)
|
|
{
|
|
int val = tv2bool(tv);
|
|
|
|
/*
|
|
* Repeat until there is no following "||" or "&&"
|
|
*/
|
|
while (p[0] == opchar && p[1] == opchar)
|
|
{
|
|
typval_T tv2;
|
|
|
|
if (!VIM_ISWHITE(**arg) || !VIM_ISWHITE(p[2]))
|
|
return FAIL;
|
|
|
|
// eval the next expression
|
|
*arg = skipwhite(p + 2);
|
|
tv2.v_type = VAR_UNKNOWN;
|
|
tv2.v_lock = 0;
|
|
if ((opchar == '|' ? evaluate_const_expr3(arg, cctx, &tv2)
|
|
: evaluate_const_expr4(arg, cctx, &tv2)) == FAIL)
|
|
{
|
|
clear_tv(&tv2);
|
|
return FAIL;
|
|
}
|
|
if ((opchar == '&') == val)
|
|
{
|
|
// false || tv2 or true && tv2: use tv2
|
|
clear_tv(tv);
|
|
*tv = tv2;
|
|
val = tv2bool(tv);
|
|
}
|
|
else
|
|
clear_tv(&tv2);
|
|
p = skipwhite(*arg);
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Evaluate an expression that is a constant: expr4 && expr4 && expr4
|
|
* Return FAIL if the expression is not a constant.
|
|
*/
|
|
static int
|
|
evaluate_const_expr3(char_u **arg, cctx_T *cctx, typval_T *tv)
|
|
{
|
|
// evaluate the first expression
|
|
if (evaluate_const_expr4(arg, cctx, tv) == FAIL)
|
|
return FAIL;
|
|
|
|
// || and && work almost the same
|
|
return evaluate_const_and_or(arg, cctx, "&&", tv);
|
|
}
|
|
|
|
/*
|
|
* Evaluate an expression that is a constant: expr3 || expr3 || expr3
|
|
* Return FAIL if the expression is not a constant.
|
|
*/
|
|
static int
|
|
evaluate_const_expr2(char_u **arg, cctx_T *cctx, typval_T *tv)
|
|
{
|
|
// evaluate the first expression
|
|
if (evaluate_const_expr3(arg, cctx, tv) == FAIL)
|
|
return FAIL;
|
|
|
|
// || and && work almost the same
|
|
return evaluate_const_and_or(arg, cctx, "||", tv);
|
|
}
|
|
|
|
/*
|
|
* Evaluate an expression that is a constant: expr2 ? expr1 : expr1
|
|
* E.g. for "has('feature')".
|
|
* This does not produce error messages. "tv" should be cleared afterwards.
|
|
* Return FAIL if the expression is not a constant.
|
|
*/
|
|
static int
|
|
evaluate_const_expr1(char_u **arg, cctx_T *cctx, typval_T *tv)
|
|
{
|
|
char_u *p;
|
|
|
|
// evaluate the first expression
|
|
if (evaluate_const_expr2(arg, cctx, tv) == FAIL)
|
|
return FAIL;
|
|
|
|
p = skipwhite(*arg);
|
|
if (*p == '?')
|
|
{
|
|
int val = tv2bool(tv);
|
|
typval_T tv2;
|
|
|
|
if (!VIM_ISWHITE(**arg) || !VIM_ISWHITE(p[1]))
|
|
return FAIL;
|
|
|
|
// evaluate the second expression; any type is accepted
|
|
clear_tv(tv);
|
|
*arg = skipwhite(p + 1);
|
|
if (evaluate_const_expr1(arg, cctx, tv) == FAIL)
|
|
return FAIL;
|
|
|
|
// Check for the ":".
|
|
p = skipwhite(*arg);
|
|
if (*p != ':' || !VIM_ISWHITE(**arg) || !VIM_ISWHITE(p[1]))
|
|
return FAIL;
|
|
|
|
// evaluate the third expression
|
|
*arg = skipwhite(p + 1);
|
|
tv2.v_type = VAR_UNKNOWN;
|
|
if (evaluate_const_expr1(arg, cctx, &tv2) == FAIL)
|
|
{
|
|
clear_tv(&tv2);
|
|
return FAIL;
|
|
}
|
|
if (val)
|
|
{
|
|
// use the expr after "?"
|
|
clear_tv(&tv2);
|
|
}
|
|
else
|
|
{
|
|
// use the expr after ":"
|
|
clear_tv(tv);
|
|
*tv = tv2;
|
|
}
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
scope_T *scope;
|
|
typval_T tv;
|
|
|
|
// compile "expr"; if we know it evaluates to FALSE skip the block
|
|
tv.v_type = VAR_UNKNOWN;
|
|
if (evaluate_const_expr1(&p, cctx, &tv) == OK)
|
|
cctx->ctx_skip = tv2bool(&tv) ? FALSE : TRUE;
|
|
else
|
|
cctx->ctx_skip = MAYBE;
|
|
clear_tv(&tv);
|
|
if (cctx->ctx_skip == MAYBE)
|
|
{
|
|
p = arg;
|
|
if (compile_expr1(&p, cctx) == FAIL)
|
|
return NULL;
|
|
}
|
|
|
|
scope = new_scope(cctx, IF_SCOPE);
|
|
if (scope == NULL)
|
|
return NULL;
|
|
|
|
if (cctx->ctx_skip == MAYBE)
|
|
{
|
|
// "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;
|
|
isn_T *isn;
|
|
scope_T *scope = cctx->ctx_scope;
|
|
typval_T tv;
|
|
|
|
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_skip == MAYBE)
|
|
{
|
|
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
|
|
tv.v_type = VAR_UNKNOWN;
|
|
if (evaluate_const_expr1(&p, cctx, &tv) == OK)
|
|
cctx->ctx_skip = tv2bool(&tv) ? FALSE : TRUE;
|
|
else
|
|
cctx->ctx_skip = MAYBE;
|
|
clear_tv(&tv);
|
|
if (cctx->ctx_skip == MAYBE)
|
|
{
|
|
p = arg;
|
|
if (compile_expr1(&p, cctx) == 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);
|
|
}
|
|
else
|
|
scope->se_u.se_if.is_if_label = -1;
|
|
|
|
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);
|
|
|
|
// jump from previous block to the end, unless the else block is empty
|
|
if (cctx->ctx_skip == MAYBE)
|
|
{
|
|
if (compile_jump_to_end(&scope->se_u.se_if.is_end_label,
|
|
JUMP_ALWAYS, cctx) == FAIL)
|
|
return NULL;
|
|
}
|
|
|
|
if (cctx->ctx_skip == MAYBE)
|
|
{
|
|
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 != MAYBE)
|
|
cctx->ctx_skip = !cctx->ctx_skip;
|
|
|
|
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;
|
|
cctx->ctx_scope = scope->se_outer;
|
|
unwind_locals(cctx, scope->se_local_count);
|
|
|
|
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 = FALSE;
|
|
|
|
vim_free(scope);
|
|
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;
|
|
int loop_idx; // index of loop iteration variable
|
|
int var_idx; // index of "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_idx = lookup_local(arg, varlen, cctx);
|
|
if (var_idx >= 0)
|
|
{
|
|
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_idx = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number);
|
|
if (loop_idx < 0)
|
|
return NULL;
|
|
|
|
// Reserve a variable to store "var"
|
|
var_idx = reserve_local(cctx, arg, varlen, FALSE, &t_any);
|
|
if (var_idx < 0)
|
|
return NULL;
|
|
|
|
generate_STORENR(cctx, loop_idx, -1);
|
|
|
|
// compile "expr", it remains on the stack until "endfor"
|
|
arg = p;
|
|
if (compile_expr1(&arg, cctx) == FAIL)
|
|
return NULL;
|
|
|
|
// now we know the type of "var"
|
|
vartype = ((type_T **)stack->ga_data)[stack->ga_len - 1];
|
|
if (vartype->tt_type != VAR_LIST)
|
|
{
|
|
emsg(_("E1024: need a List to iterate over"));
|
|
return NULL;
|
|
}
|
|
if (vartype->tt_member->tt_type != VAR_UNKNOWN)
|
|
{
|
|
lvar_T *lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + var_idx;
|
|
|
|
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_idx);
|
|
generate_STORE(cctx, ISN_STORE, var_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_expr1(&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_excmd(*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 len;
|
|
|
|
// Push v:exception, push {expr} and MATCH
|
|
generate_instr_type(cctx, ISN_PUSHEXC, &t_string);
|
|
|
|
end = skip_regexp(p + 1, *p, TRUE, &tofree);
|
|
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 + 1));
|
|
pat = vim_strnsave(p + 1, len);
|
|
vim_free(tofree);
|
|
p += len + 2;
|
|
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);
|
|
|
|
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;
|
|
}
|
|
|
|
isn->isn_arg.try.try_finally = instr->ga_len;
|
|
// 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_finally == 0)
|
|
isn->isn_arg.try.try_finally = 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 (ends_excmd(*p))
|
|
{
|
|
emsg(_(e_argreq));
|
|
return NULL;
|
|
}
|
|
if (compile_expr1(&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"
|
|
*/
|
|
static char_u *
|
|
compile_echo(char_u *arg, int with_white, cctx_T *cctx)
|
|
{
|
|
char_u *p = arg;
|
|
int count = 0;
|
|
|
|
for (;;)
|
|
{
|
|
if (compile_expr1(&p, cctx) == FAIL)
|
|
return NULL;
|
|
++count;
|
|
p = skipwhite(p);
|
|
if (ends_excmd(*p))
|
|
break;
|
|
}
|
|
|
|
generate_ECHO(cctx, with_white, count);
|
|
return p;
|
|
}
|
|
|
|
/*
|
|
* compile "execute expr"
|
|
*/
|
|
static char_u *
|
|
compile_execute(char_u *arg, cctx_T *cctx)
|
|
{
|
|
char_u *p = arg;
|
|
int count = 0;
|
|
|
|
for (;;)
|
|
{
|
|
if (compile_expr1(&p, cctx) == FAIL)
|
|
return NULL;
|
|
++count;
|
|
p = skipwhite(p);
|
|
if (ends_excmd(*p))
|
|
break;
|
|
}
|
|
|
|
generate_EXECUTE(cctx, count);
|
|
|
|
return p;
|
|
}
|
|
|
|
/*
|
|
* 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).
|
|
*/
|
|
void
|
|
compile_def_function(ufunc_T *ufunc, int set_return_type)
|
|
{
|
|
dfunc_T *dfunc;
|
|
char_u *line = NULL;
|
|
char_u *p;
|
|
exarg_T ea;
|
|
char *errormsg = NULL; // error message
|
|
int had_return = FALSE;
|
|
cctx_T cctx;
|
|
garray_T *instr;
|
|
int called_emsg_before = called_emsg;
|
|
int ret = FAIL;
|
|
sctx_T save_current_sctx = current_sctx;
|
|
int emsg_before = called_emsg;
|
|
|
|
if (ufunc->uf_dfunc_idx >= 0)
|
|
{
|
|
// Redefining a function that was compiled before.
|
|
dfunc = ((dfunc_T *)def_functions.ga_data) + ufunc->uf_dfunc_idx;
|
|
|
|
// Free old instructions.
|
|
delete_def_function_contents(dfunc);
|
|
}
|
|
else
|
|
{
|
|
// Add the function to "def_functions".
|
|
if (ga_grow(&def_functions, 1) == FAIL)
|
|
return;
|
|
dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len;
|
|
vim_memset(dfunc, 0, sizeof(dfunc_T));
|
|
dfunc->df_idx = def_functions.ga_len;
|
|
ufunc->uf_dfunc_idx = dfunc->df_idx;
|
|
dfunc->df_ufunc = ufunc;
|
|
++def_functions.ga_len;
|
|
}
|
|
|
|
vim_memset(&cctx, 0, sizeof(cctx));
|
|
cctx.ctx_ufunc = ufunc;
|
|
cctx.ctx_lnum = -1;
|
|
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;
|
|
|
|
// Most modern script version.
|
|
current_sctx.sc_version = SCRIPT_VERSION_VIM9;
|
|
|
|
if (ufunc->uf_def_args.ga_len > 0)
|
|
{
|
|
int count = ufunc->uf_def_args.ga_len;
|
|
int i;
|
|
char_u *arg;
|
|
int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0);
|
|
|
|
// 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)
|
|
{
|
|
ufunc->uf_def_arg_idx[i] = instr->ga_len;
|
|
arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i];
|
|
if (compile_expr1(&arg, &cctx) == FAIL
|
|
|| generate_STORE(&cctx, ISN_STORE,
|
|
i - count - off, NULL) == FAIL)
|
|
goto erret;
|
|
}
|
|
|
|
// If a varargs is following, push an empty list.
|
|
if (ufunc->uf_va_name != NULL)
|
|
{
|
|
if (generate_NEWLIST(&cctx, 0) == FAIL
|
|
|| generate_STORE(&cctx, ISN_STORE, -off, NULL) == FAIL)
|
|
goto erret;
|
|
}
|
|
|
|
ufunc->uf_def_arg_idx[count] = instr->ga_len;
|
|
}
|
|
|
|
/*
|
|
* Loop over all the lines of the function and generate instructions.
|
|
*/
|
|
for (;;)
|
|
{
|
|
int is_ex_command;
|
|
|
|
if (line != NULL && *line == '|')
|
|
// the line continues after a '|'
|
|
++line;
|
|
else if (line != NULL && *line != NUL)
|
|
{
|
|
if (emsg_before == called_emsg)
|
|
semsg(_("E488: Trailing characters: %s"), line);
|
|
goto erret;
|
|
}
|
|
else
|
|
{
|
|
do
|
|
{
|
|
++cctx.ctx_lnum;
|
|
if (cctx.ctx_lnum == ufunc->uf_lines.ga_len)
|
|
break;
|
|
line = ((char_u **)ufunc->uf_lines.ga_data)[cctx.ctx_lnum];
|
|
} while (line == NULL);
|
|
if (cctx.ctx_lnum == ufunc->uf_lines.ga_len)
|
|
break;
|
|
SOURCING_LNUM = ufunc->uf_script_ctx.sc_lnum + cctx.ctx_lnum + 1;
|
|
}
|
|
emsg_before = called_emsg;
|
|
|
|
had_return = FALSE;
|
|
vim_memset(&ea, 0, sizeof(ea));
|
|
ea.cmdlinep = &line;
|
|
ea.cmd = skipwhite(line);
|
|
|
|
// "}" ends a block scope
|
|
if (*ea.cmd == '}')
|
|
{
|
|
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;
|
|
}
|
|
|
|
// "{" starts a block scope
|
|
// "{'a': 1}->func() is something else
|
|
if (*ea.cmd == '{' && ends_excmd(*skipwhite(ea.cmd + 1)))
|
|
{
|
|
line = compile_block(ea.cmd, &cctx);
|
|
continue;
|
|
}
|
|
is_ex_command = *ea.cmd == ':';
|
|
|
|
/*
|
|
* COMMAND MODIFIERS
|
|
*/
|
|
if (parse_command_modifiers(&ea, &errormsg, FALSE) == FAIL)
|
|
{
|
|
if (errormsg != NULL)
|
|
goto erret;
|
|
// empty line or comment
|
|
line = (char_u *)"";
|
|
continue;
|
|
}
|
|
|
|
// Skip ":call" to get to the function name.
|
|
if (checkforcmd(&ea.cmd, "call", 3))
|
|
ea.cmd = skipwhite(ea.cmd);
|
|
|
|
if (!is_ex_command)
|
|
{
|
|
// Assuming the command starts with a variable or function name,
|
|
// find what follows. Also "&opt = val", "$ENV = val" and "@r =
|
|
// val".
|
|
p = (*ea.cmd == '&' || *ea.cmd == '$' || *ea.cmd == '@')
|
|
? ea.cmd + 1 : ea.cmd;
|
|
p = to_name_end(p, TRUE);
|
|
if ((p > ea.cmd && *p != NUL) || *p == '(')
|
|
{
|
|
int oplen;
|
|
int heredoc;
|
|
|
|
oplen = assignment_len(skipwhite(p), &heredoc);
|
|
if (oplen > 0)
|
|
{
|
|
// 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 == '@'
|
|
|| ((p - ea.cmd) > 2 && ea.cmd[1] == ':')
|
|
|| lookup_local(ea.cmd, p - ea.cmd, &cctx) >= 0
|
|
|| lookup_script(ea.cmd, p - ea.cmd) == OK
|
|
|| find_imported(ea.cmd, p - ea.cmd, &cctx) != NULL)
|
|
{
|
|
line = compile_assignment(ea.cmd, &ea, CMD_SIZE, &cctx);
|
|
if (line == NULL)
|
|
goto erret;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* COMMAND after range
|
|
*/
|
|
ea.cmd = skip_range(ea.cmd, NULL);
|
|
p = find_ex_command(&ea, NULL, is_ex_command ? NULL : lookup_local,
|
|
&cctx);
|
|
|
|
if (p == ea.cmd && ea.cmdidx != CMD_SIZE)
|
|
{
|
|
if (cctx.ctx_skip == TRUE)
|
|
{
|
|
line += STRLEN(line);
|
|
continue;
|
|
}
|
|
|
|
// Expression or function call.
|
|
if (ea.cmdidx == CMD_eval)
|
|
{
|
|
p = ea.cmd;
|
|
if (compile_expr1(&p, &cctx) == FAIL)
|
|
goto erret;
|
|
|
|
// drop the return value
|
|
generate_instr_drop(&cctx, ISN_DROP, 1);
|
|
line = p;
|
|
continue;
|
|
}
|
|
if (ea.cmdidx == CMD_let)
|
|
{
|
|
line = compile_assignment(ea.cmd, &ea, CMD_SIZE, &cctx);
|
|
if (line == NULL)
|
|
goto erret;
|
|
continue;
|
|
}
|
|
iemsg("Command from find_ex_command() not handled");
|
|
goto erret;
|
|
}
|
|
|
|
p = skipwhite(p);
|
|
|
|
if (cctx.ctx_skip == TRUE
|
|
&& ea.cmdidx != CMD_elseif
|
|
&& ea.cmdidx != CMD_else
|
|
&& ea.cmdidx != CMD_endif)
|
|
{
|
|
line += STRLEN(line);
|
|
continue;
|
|
}
|
|
|
|
switch (ea.cmdidx)
|
|
{
|
|
case CMD_def:
|
|
case CMD_function:
|
|
// TODO: Nested function
|
|
emsg("Nested function not implemented yet");
|
|
goto erret;
|
|
|
|
case CMD_return:
|
|
line = compile_return(p, set_return_type, &cctx);
|
|
had_return = TRUE;
|
|
break;
|
|
|
|
case CMD_let:
|
|
case CMD_const:
|
|
line = compile_assignment(p, &ea, ea.cmdidx, &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);
|
|
break;
|
|
case CMD_else:
|
|
line = compile_else(p, &cctx);
|
|
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);
|
|
break;
|
|
|
|
case CMD_for:
|
|
line = compile_for(p, &cctx);
|
|
break;
|
|
case CMD_endfor:
|
|
line = compile_endfor(p, &cctx);
|
|
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);
|
|
break;
|
|
case CMD_finally:
|
|
line = compile_finally(p, &cctx);
|
|
break;
|
|
case CMD_endtry:
|
|
line = compile_endtry(p, &cctx);
|
|
break;
|
|
case CMD_throw:
|
|
line = compile_throw(p, &cctx);
|
|
break;
|
|
|
|
case CMD_echo:
|
|
line = compile_echo(p, TRUE, &cctx);
|
|
break;
|
|
case CMD_echon:
|
|
line = compile_echo(p, FALSE, &cctx);
|
|
break;
|
|
case CMD_execute:
|
|
line = compile_execute(p, &cctx);
|
|
break;
|
|
|
|
default:
|
|
// Not recognized, execute with do_cmdline_cmd().
|
|
// TODO:
|
|
// CMD_echomsg
|
|
// etc.
|
|
generate_EXEC(&cctx, line);
|
|
line = (char_u *)"";
|
|
break;
|
|
}
|
|
if (line == NULL)
|
|
goto erret;
|
|
|
|
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 (!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->df_deleted = FALSE;
|
|
dfunc->df_instr = instr->ga_data;
|
|
dfunc->df_instr_count = instr->ga_len;
|
|
dfunc->df_varcount = cctx.ctx_max_local;
|
|
|
|
ret = OK;
|
|
|
|
erret:
|
|
if (ret == FAIL)
|
|
{
|
|
int idx;
|
|
|
|
for (idx = 0; idx < instr->ga_len; ++idx)
|
|
delete_instr(((isn_T *)instr->ga_data) + idx);
|
|
ga_clear(instr);
|
|
|
|
ufunc->uf_dfunc_idx = -1;
|
|
if (!dfunc->df_deleted)
|
|
--def_functions.ga_len;
|
|
|
|
// 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;
|
|
free_imported(&cctx);
|
|
free_local(&cctx);
|
|
ga_clear(&cctx.ctx_type_stack);
|
|
}
|
|
|
|
/*
|
|
* 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_LOADOPT:
|
|
case ISN_MEMBER:
|
|
case ISN_PUSHEXC:
|
|
case ISN_PUSHS:
|
|
case ISN_STOREENV:
|
|
case ISN_STOREG:
|
|
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_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_PUSHPARTIAL:
|
|
partial_unref(isn->isn_arg.partial);
|
|
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_2BOOL:
|
|
case ISN_2STRING:
|
|
case ISN_ADDBLOB:
|
|
case ISN_ADDLIST:
|
|
case ISN_BCALL:
|
|
case ISN_CATCH:
|
|
case ISN_CHECKNR:
|
|
case ISN_CHECKTYPE:
|
|
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_COMPAREPARTIAL:
|
|
case ISN_COMPARESPECIAL:
|
|
case ISN_COMPARESTRING:
|
|
case ISN_CONCAT:
|
|
case ISN_DCALL:
|
|
case ISN_DROP:
|
|
case ISN_ECHO:
|
|
case ISN_EXECUTE:
|
|
case ISN_ENDTRY:
|
|
case ISN_FOR:
|
|
case ISN_FUNCREF:
|
|
case ISN_INDEX:
|
|
case ISN_JUMP:
|
|
case ISN_LOAD:
|
|
case ISN_LOADSCRIPT:
|
|
case ISN_LOADREG:
|
|
case ISN_LOADV:
|
|
case ISN_NEGATENR:
|
|
case ISN_NEWDICT:
|
|
case ISN_NEWLIST:
|
|
case ISN_OPNR:
|
|
case ISN_OPFLOAT:
|
|
case ISN_OPANY:
|
|
case ISN_PCALL:
|
|
case ISN_PUSHF:
|
|
case ISN_PUSHNR:
|
|
case ISN_PUSHBOOL:
|
|
case ISN_PUSHSPEC:
|
|
case ISN_RETURN:
|
|
case ISN_STORE:
|
|
case ISN_STOREV:
|
|
case ISN_STORENR:
|
|
case ISN_STOREREG:
|
|
case ISN_STORESCRIPT:
|
|
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, delete any associated def function.
|
|
*/
|
|
void
|
|
delete_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);
|
|
}
|
|
}
|
|
|
|
#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
|