/* 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.

*/

/*

* evalfunc.c: Builtin functions

*/

#define USING_FLOAT_STUFF

#include "vim.h"

#if defined(FEAT_EVAL)

#ifdef VMS

# include <float.h>

#endif

static void f_and(typval_T *argvars, typval_T *rettv);

#ifdef FEAT_BEVAL

static void f_balloon_gettext(typval_T *argvars, typval_T *rettv);

static void f_balloon_show(typval_T *argvars, typval_T *rettv);

# if defined(FEAT_BEVAL_TERM)

static void f_balloon_split(typval_T *argvars, typval_T *rettv);

# endif

#endif

static void f_base64_encode(typval_T *argvars, typval_T *rettv);

static void f_base64_decode(typval_T *argvars, typval_T *rettv);

static void f_bindtextdomain(typval_T *argvars, typval_T *rettv);

static void f_byte2line(typval_T *argvars, typval_T *rettv);

static void f_call(typval_T *argvars, typval_T *rettv);

static void f_changenr(typval_T *argvars, typval_T *rettv);

static void f_char2nr(typval_T *argvars, typval_T *rettv);

static void f_charcol(typval_T *argvars, typval_T *rettv);

static void f_col(typval_T *argvars, typval_T *rettv);

static void f_confirm(typval_T *argvars, typval_T *rettv);

static void f_copy(typval_T *argvars, typval_T *rettv);

static void f_cursor(typval_T *argsvars, typval_T *rettv);

#ifdef MSWIN

static void f_debugbreak(typval_T *argvars, typval_T *rettv);

#endif

static void f_deepcopy(typval_T *argvars, typval_T *rettv);

static void f_did_filetype(typval_T *argvars, typval_T *rettv);

static void f_echoraw(typval_T *argvars, typval_T *rettv);

static void f_empty(typval_T *argvars, typval_T *rettv);

static void f_environ(typval_T *argvars, typval_T *rettv);

static void f_err_teapot(typval_T *argvars, typval_T *rettv);

static void f_escape(typval_T *argvars, typval_T *rettv);

static void f_eval(typval_T *argvars, typval_T *rettv);

static void f_eventhandler(typval_T *argvars, typval_T *rettv);

static void f_execute(typval_T *argvars, typval_T *rettv);

static void f_exists_compiled(typval_T *argvars, typval_T *rettv);

static void f_expand(typval_T *argvars, typval_T *rettv);

static void f_expandcmd(typval_T *argvars, typval_T *rettv);

static void f_feedkeys(typval_T *argvars, typval_T *rettv);

static void f_fnameescape(typval_T *argvars, typval_T *rettv);

static void f_foreground(typval_T *argvars, typval_T *rettv);

static void f_funcref(typval_T *argvars, typval_T *rettv);

static void f_function(typval_T *argvars, typval_T *rettv);

static void f_garbagecollect(typval_T *argvars, typval_T *rettv);

static void f_get(typval_T *argvars, typval_T *rettv);

static void f_getcellpixels(typval_T *argvars, typval_T *rettv);

static void f_getchangelist(typval_T *argvars, typval_T *rettv);

static void f_getcharpos(typval_T *argvars, typval_T *rettv);

static void f_getcharsearch(typval_T *argvars, typval_T *rettv);

static void f_getcurpos(typval_T *argvars, typval_T *rettv);

static void f_getcursorcharpos(typval_T *argvars, typval_T *rettv);

static void f_getenv(typval_T *argvars, typval_T *rettv);

static void f_getfontname(typval_T *argvars, typval_T *rettv);

static void f_getjumplist(typval_T *argvars, typval_T *rettv);

static void f_getpid(typval_T *argvars, typval_T *rettv);

static void f_getpos(typval_T *argvars, typval_T *rettv);

static void f_getreg(typval_T *argvars, typval_T *rettv);

static void f_getreginfo(typval_T *argvars, typval_T *rettv);

static void f_getregion(typval_T *argvars, typval_T *rettv);

static void f_getregionpos(typval_T *argvars, typval_T *rettv);

static void f_getregtype(typval_T *argvars, typval_T *rettv);

static void f_gettagstack(typval_T *argvars, typval_T *rettv);

static void f_gettext(typval_T *argvars, typval_T *rettv);

static void f_haslocaldir(typval_T *argvars, typval_T *rettv);

static void f_hlID(typval_T *argvars, typval_T *rettv);

static void f_hlexists(typval_T *argvars, typval_T *rettv);

static void f_hostname(typval_T *argvars, typval_T *rettv);

static void f_id(typval_T *argvars, typval_T *rettv);

static void f_index(typval_T *argvars, typval_T *rettv);

static void f_indexof(typval_T *argvars, typval_T *rettv);

static void f_input(typval_T *argvars, typval_T *rettv);

static void f_inputdialog(typval_T *argvars, typval_T *rettv);

static void f_inputlist(typval_T *argvars, typval_T *rettv);

static void f_inputrestore(typval_T *argvars, typval_T *rettv);

static void f_inputsave(typval_T *argvars, typval_T *rettv);

static void f_inputsecret(typval_T *argvars, typval_T *rettv);

static void f_interrupt(typval_T *argvars, typval_T *rettv);

static void f_invert(typval_T *argvars, typval_T *rettv);

static void f_islocked(typval_T *argvars, typval_T *rettv);

static void f_items(typval_T *argvars, typval_T *rettv);

static void f_keytrans(typval_T *argvars, typval_T *rettv);

static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv);

static void f_libcall(typval_T *argvars, typval_T *rettv);

static void f_libcallnr(typval_T *argvars, typval_T *rettv);

static void f_line(typval_T *argvars, typval_T *rettv);

static void f_line2byte(typval_T *argvars, typval_T *rettv);

#ifdef FEAT_LUA

static void f_luaeval(typval_T *argvars, typval_T *rettv);

#endif

static void f_match(typval_T *argvars, typval_T *rettv);

static void f_matchbufline(typval_T *argvars, typval_T *rettv);

static void f_matchend(typval_T *argvars, typval_T *rettv);

static void f_matchlist(typval_T *argvars, typval_T *rettv);

static void f_matchstr(typval_T *argvars, typval_T *rettv);

static void f_matchstrlist(typval_T *argvars, typval_T *rettv);

static void f_matchstrpos(typval_T *argvars, typval_T *rettv);

static void f_max(typval_T *argvars, typval_T *rettv);

static void f_min(typval_T *argvars, typval_T *rettv);

#ifdef FEAT_MZSCHEME

static void f_mzeval(typval_T *argvars, typval_T *rettv);

#endif

static void f_nextnonblank(typval_T *argvars, typval_T *rettv);

static void f_ngettext(typval_T *argvars, typval_T *rettv);

static void f_nr2char(typval_T *argvars, typval_T *rettv);

static void f_or(typval_T *argvars, typval_T *rettv);

#ifdef FEAT_PERL

static void f_perleval(typval_T *argvars, typval_T *rettv);

#endif

static void f_prevnonblank(typval_T *argvars, typval_T *rettv);

static void f_printf(typval_T *argvars, typval_T *rettv);

static void f_pum_getpos(typval_T *argvars, typval_T *rettv);

static void f_pumvisible(typval_T *argvars, typval_T *rettv);

#ifdef FEAT_PYTHON3

static void f_py3eval(typval_T *argvars, typval_T *rettv);

#endif

#ifdef FEAT_PYTHON

static void f_pyeval(typval_T *argvars, typval_T *rettv);

#endif

#if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3)

static void f_pyxeval(typval_T *argvars, typval_T *rettv);

#endif

static void f_test_srand_seed(typval_T *argvars, typval_T *rettv);

static void f_rand(typval_T *argvars, typval_T *rettv);

static void f_range(typval_T *argvars, typval_T *rettv);

static void f_reg_executing(typval_T *argvars, typval_T *rettv);

static void f_reg_recording(typval_T *argvars, typval_T *rettv);

static void f_rename(typval_T *argvars, typval_T *rettv);

static void f_repeat(typval_T *argvars, typval_T *rettv);

#ifdef FEAT_RUBY

static void f_rubyeval(typval_T *argvars, typval_T *rettv);

#endif

static void f_screenattr(typval_T *argvars, typval_T *rettv);

static void f_screenchar(typval_T *argvars, typval_T *rettv);

static void f_screenchars(typval_T *argvars, typval_T *rettv);

static void f_screencol(typval_T *argvars, typval_T *rettv);

static void f_screenrow(typval_T *argvars, typval_T *rettv);

static void f_screenstring(typval_T *argvars, typval_T *rettv);

static void f_search(typval_T *argvars, typval_T *rettv);

static void f_searchdecl(typval_T *argvars, typval_T *rettv);

static void f_searchpair(typval_T *argvars, typval_T *rettv);

static void f_searchpairpos(typval_T *argvars, typval_T *rettv);

static void f_searchpos(typval_T *argvars, typval_T *rettv);

static void f_setcharpos(typval_T *argvars, typval_T *rettv);

static void f_setcharsearch(typval_T *argvars, typval_T *rettv);

static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv);

static void f_setenv(typval_T *argvars, typval_T *rettv);

static void f_setfperm(typval_T *argvars, typval_T *rettv);

static void f_setpos(typval_T *argvars, typval_T *rettv);

static void f_setreg(typval_T *argvars, typval_T *rettv);

static void f_settagstack(typval_T *argvars, typval_T *rettv);

#ifdef FEAT_CRYPT

static void f_sha256(typval_T *argvars, typval_T *rettv);

#endif

static void f_shellescape(typval_T *argvars, typval_T *rettv);

static void f_shiftwidth(typval_T *argvars, typval_T *rettv);

static void f_soundfold(typval_T *argvars, typval_T *rettv);

static void f_spellbadword(typval_T *argvars, typval_T *rettv);

static void f_spellsuggest(typval_T *argvars, typval_T *rettv);

static void f_split(typval_T *argvars, typval_T *rettv);

static void f_srand(typval_T *argvars, typval_T *rettv);

static void f_submatch(typval_T *argvars, typval_T *rettv);

static void f_substitute(typval_T *argvars, typval_T *rettv);

static void f_swapfilelist(typval_T *argvars, typval_T *rettv);

static void f_swapinfo(typval_T *argvars, typval_T *rettv);

static void f_swapname(typval_T *argvars, typval_T *rettv);

static void f_synID(typval_T *argvars, typval_T *rettv);

static void f_synIDattr(typval_T *argvars, typval_T *rettv);

static void f_synIDtrans(typval_T *argvars, typval_T *rettv);

static void f_synstack(typval_T *argvars, typval_T *rettv);

static void f_synconcealed(typval_T *argvars, typval_T *rettv);

static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv);

static void f_taglist(typval_T *argvars, typval_T *rettv);

static void f_tagfiles(typval_T *argvars, typval_T *rettv);

static void f_type(typval_T *argvars, typval_T *rettv);

static void f_virtcol(typval_T *argvars, typval_T *rettv);

static void f_visualmode(typval_T *argvars, typval_T *rettv);

static void f_wildmenumode(typval_T *argvars, typval_T *rettv);

static void f_windowsversion(typval_T *argvars, typval_T *rettv);

static void f_wordcount(typval_T *argvars, typval_T *rettv);

static void f_xor(typval_T *argvars, typval_T *rettv);

/*

* Functions that check the argument type of a builtin function.

* Each function returns FAIL and gives an error message if the type is wrong.

*/

// Context passed to an arg_ function.

typedef struct {

int arg_count; // actual argument count

type2_T *arg_types; // list of argument types

int arg_idx; // current argument index (first arg is zero)

cctx_T *arg_cctx;

} argcontext_T;

// A function to check one argument type. The first argument is the type to

// check. If needed, other argument types can be obtained with the context.

// E.g. if "arg_idx" is 1, then (type - 1) is the first argument type.

// NOTE: Use "arg_any", not NULL, in funcentry_T.f_argcheck array

// to accept an argument of any type.

typedef int (*argcheck_T)(type_T *, type_T *, argcontext_T *);

/*

* Call need_type() to check an argument type.

*/

static int

check_arg_type(

type_T *expected,

type_T *actual,

argcontext_T *context)

{

return need_type(actual, expected, 0,

context->arg_idx - context->arg_count, context->arg_idx + 1,

context->arg_cctx, FALSE, FALSE);

}

/*

* Call need_type() to check an argument type and that it is modifiable

*/

static int

check_arg_type_mod(

type_T *expected,

type_T *actual,

argcontext_T *context)

{

if (need_type(actual, expected, 0,

context->arg_idx - context->arg_count, context->arg_idx + 1,

context->arg_cctx, FALSE, FALSE) == FAIL)

return FAIL;

return arg_type_modifiable(actual, context->arg_idx + 1);

}

/*

* Give an error if "type" is a constant.

*/

int

arg_type_modifiable(type_T *type, int arg_idx)

{

char *tofree;

if ((type->tt_flags & TTFLAG_CONST) == 0)

return OK;

semsg(_(e_argument_nr_trying_to_modify_const_str),

arg_idx, type_name(type, &tofree));

vim_free(tofree);

return FAIL;

}

/*

* Return OK for any type unconditionally.

*/

static int

arg_any(type_T *type UNUSED,

type_T *decl_type UNUSED,

argcontext_T *context UNUSED)

{

return OK;

}

/*

* Check "type" is a float or a number.

*/

static int

arg_float_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_FLOAT

|| type->tt_type == VAR_NUMBER

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_number, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a number.

*/

static int

arg_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_number, type, context);

}

/*

* Check "type" is an object.

*/

static int

arg_object(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_OBJECT

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_object_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a dict of 'any'.

*/

static int

arg_dict_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_dict_any, type, context);

}

/*

* Check "type" is a list of 'any'.

*/

static int

arg_list_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_list_any, type, context);

}

/*

* Check "type" is a list of 'any' and modifiable

*/

static int

arg_list_any_mod(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

return check_arg_type_mod(&t_list_any, type, context);

}

/*

* Check "type" is a list of numbers.

*/

static int

arg_list_number(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_list_number, type, context);

}

/*

* Check "type" is a list of strings.

*/

static int

arg_list_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_list_string, type, context);

}

/*

* Check "type" is a tuple of 'any'.

*/

static int

arg_tuple_any(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_tuple_any, type, context);

}

/*

* Check "type" is a string.

*/

static int

arg_string(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_string, type, context);

}

/*

* Check "type" is a blob

*/

static int

arg_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_blob, type, context);

}

/*

* Check "type" is a bool or number 0 or 1.

*/

static int

arg_bool(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_bool, type, context);

}

/*

* Check "type" is a bool or a number.

*/

static int

arg_bool_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_BOOL

|| type->tt_type == VAR_NUMBER

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_number, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a list of 'any' or a blob.

*/

static int

arg_list_or_blob(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_BLOB

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a modifiable list of 'any' or a blob.

*/

static int

arg_list_or_blob_mod(

type_T *type,

type_T *decl_type,

argcontext_T *context)

{

if (arg_list_or_blob(type, decl_type, context) == FAIL)

return FAIL;

return arg_type_modifiable(type, context->arg_idx + 1);

}

/*

* Check "type" is a list of 'any' or a tuple.

*/

static int

arg_list_or_tuple(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_TUPLE

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a list of 'any', a tuple or a blob.

*/

static int

arg_list_or_tuple_or_blob(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_TUPLE

|| type->tt_type == VAR_BLOB

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a string or a number

*/

static int

arg_string_or_nr(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_NUMBER

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_string, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a buffer (string or a number)

*/

static int

arg_buffer(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_NUMBER

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_string, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a buffer or a dict of any

*/

static int

arg_buffer_or_dict_any(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_NUMBER

|| type->tt_type == VAR_DICT

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_string, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a line (string or a number)

*/

static int

arg_lnum(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_NUMBER

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_string, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a string or a list of strings.

*/

static int

arg_string_or_list_string(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type_any_or_unknown(type))

return OK;

if (type->tt_type != VAR_LIST)

{

arg_type_mismatch(&t_string, type, context->arg_idx + 1);

return FAIL;

}

if (type->tt_member->tt_type == VAR_ANY

|| type->tt_member->tt_type == VAR_STRING)

return OK;

arg_type_mismatch(&t_list_string, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a string or a list of 'any'

*/

static int

arg_string_or_list_any(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_LIST

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_string, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a string or a dict of 'any'

*/

static int

arg_string_or_dict_any(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_DICT

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_string, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a string or a blob

*/

static int

arg_string_or_blob(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_BLOB

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_string, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a list of 'any' or a dict of 'any'.

*/

static int

arg_list_or_dict(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_DICT

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a list of 'any' or a dict of 'any'. And modifiable.

*/

static int

arg_list_or_dict_mod(

type_T *type,

type_T *decl_type,

argcontext_T *context)

{

if (arg_list_or_dict(type, decl_type, context) == FAIL)

return FAIL;

return arg_type_modifiable(type, context->arg_idx + 1);

}

/*

* Check "type" is a list of 'any', a tuple of 'any' or dict of 'any'.

*/

static int

arg_list_or_tuple_or_dict(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_TUPLE

|| type->tt_type == VAR_DICT

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a list of 'any', a dict of 'any' or a blob.

* Also check if "type" is modifiable.

*/

static int

arg_list_or_dict_or_blob_mod(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_DICT

|| type->tt_type == VAR_BLOB

|| type_any_or_unknown(type))

return arg_type_modifiable(type, context->arg_idx + 1);

arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a list of 'any' or a dict of 'any' or a blob or a string.

*/

static int

arg_list_or_dict_or_blob_or_string(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_DICT

|| type->tt_type == VAR_BLOB

|| type->tt_type == VAR_STRING

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a list of 'any' or a dict of 'any' or a blob or a string.

* Also check the value is modifiable.

*/

static int

arg_list_or_dict_or_blob_or_string_mod(

type_T *type,

type_T *decl_type,

argcontext_T *context)

{

if (arg_list_or_dict_or_blob_or_string(type, decl_type, context) == FAIL)

return FAIL;

return arg_type_modifiable(type, context->arg_idx + 1);

}

/*

* Check "type" is a list of 'any', a tuple of 'any', a dict of 'any', a blob

* or a string.

*/

static int

arg_list_tuple_dict_blob_or_string(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_TUPLE

|| type->tt_type == VAR_DICT

|| type->tt_type == VAR_BLOB

|| type->tt_type == VAR_STRING

|| type_any_or_unknown(type))

return OK;

semsg(_(e_list_tuple_dict_blob_or_string_required_for_argument_nr),

context->arg_idx + 1);

return FAIL;

}

/*

* Check second argument of map(), filter(), foreach().

*/

static int

check_map_filter_arg2(

type_T *type,

argcontext_T *context,

filtermap_T filtermap)

{

type_T *expected_member = NULL;

type_T *(args[2]);

type_T t_func_exp = {VAR_FUNC, 2, 0, 0, NULL, NULL, args};

if (context->arg_types[0].type_curr->tt_type == VAR_LIST

|| context->arg_types[0].type_curr->tt_type == VAR_DICT)

{

// Use the declared type if possible, so that an error is given if

// a declared list changes type, but not if a constant list changes

// type.

if (context->arg_types[0].type_decl->tt_type == VAR_LIST

|| context->arg_types[0].type_decl->tt_type == VAR_DICT)

expected_member = context->arg_types[0].type_decl->tt_member;

else

expected_member = context->arg_types[0].type_curr->tt_member;

}

else if (context->arg_types[0].type_curr->tt_type == VAR_STRING)

expected_member = &t_string;

else if (context->arg_types[0].type_curr->tt_type == VAR_BLOB)

expected_member = &t_number;

args[0] = NULL;

args[1] = &t_unknown;

if (type->tt_argcount != -1)

{

if (!(type->tt_argcount == 2 || (type->tt_argcount == 1

&& (type->tt_flags & TTFLAG_VARARGS))))

{

emsg(_(e_invalid_number_of_arguments));

return FAIL;

}

if (type->tt_flags & TTFLAG_VARARGS)

// check the argument types at runtime

t_func_exp.tt_argcount = -1;

else

{

if (context->arg_types[0].type_curr->tt_type == VAR_STRING

|| context->arg_types[0].type_curr->tt_type == VAR_BLOB

|| context->arg_types[0].type_curr->tt_type == VAR_LIST)

args[0] = &t_number;

else if (context->arg_types[0].type_decl->tt_type == VAR_DICT)

args[0] = &t_string;

if (args[0] != NULL)

args[1] = expected_member;

}

}

if (!type_any_or_unknown(type->tt_member) || args[0] != NULL)

{

where_T where = WHERE_INIT;

if (filtermap == FILTERMAP_MAP)

t_func_exp.tt_member = expected_member == NULL

|| type_any_or_unknown(type->tt_member)

? &t_any : expected_member;

else if (filtermap == FILTERMAP_FILTER)

t_func_exp.tt_member = &t_bool;

else // filtermap == FILTERMAP_FOREACH

t_func_exp.tt_member = &t_unknown;

if (args[0] == NULL)

args[0] = &t_unknown;

if (type->tt_argcount == -1)

t_func_exp.tt_argcount = -1;

where.wt_index = 2;

where.wt_kind = WT_ARGUMENT;

return check_type(&t_func_exp, type, TRUE, where);

}

return OK;

}

/*

* Check second argument of filter(): func must return a bool.

*/

static int

arg_filter_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_PARTIAL

|| type_any_or_unknown(type))

return OK;

if (type->tt_type == VAR_FUNC)

return check_map_filter_arg2(type, context, FILTERMAP_FILTER);

semsg(_(e_string_or_function_required_for_argument_nr), 2);

return FAIL;

}

/*

* Check second argument of map(), the function.

*/

static int

arg_map_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_PARTIAL

|| type_any_or_unknown(type))

return OK;

if (type->tt_type == VAR_FUNC)

return check_map_filter_arg2(type, context, FILTERMAP_MAP);

semsg(_(e_string_or_function_required_for_argument_nr), 2);

return FAIL;

}

/*

* Check second argument of foreach(), the function.

*/

static int

arg_foreach_func(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_PARTIAL

|| type_any_or_unknown(type))

return OK;

if (type->tt_type == VAR_FUNC)

return check_map_filter_arg2(type, context, FILTERMAP_FOREACH);

semsg(_(e_string_or_function_required_for_argument_nr), 2);

return FAIL;

}

/*

* Check second argument of sort() and uniq(), the "how" argument.

*/

static int

arg_sort_how(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_PARTIAL

|| type_any_or_unknown(type))

return OK;

if (type->tt_type == VAR_FUNC)

{

type_T *(args[2]);

type_T t_func_exp = {VAR_FUNC, 2, 0, 0, &t_number, NULL, args};

if (context->arg_types[0].type_curr->tt_type == VAR_LIST)

args[0] = context->arg_types[0].type_curr->tt_member;

else

args[0] = &t_unknown;

if (!type_any_or_unknown(type->tt_member) || args[0] != &t_unknown)

{

where_T where = WHERE_INIT;

args[1] = args[0];

if (type->tt_argcount == -1)

t_func_exp.tt_argcount = -1;

where.wt_index = 2;

where.wt_kind = WT_ARGUMENT;

return check_type(&t_func_exp, type, TRUE, where);

}

return OK;

}

semsg(_(e_string_or_function_required_for_argument_nr), 2);

return FAIL;

}

/*

* Check an expression argument, can be a string, funcref or partial.

* Also accept a bool, a constant resulting from compiling a string argument.

* Also accept a number, one and zero are accepted.

*/

static int

arg_string_or_func(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_STRING

|| type->tt_type == VAR_PARTIAL

|| type->tt_type == VAR_FUNC

|| type->tt_type == VAR_BOOL

|| type->tt_type == VAR_NUMBER

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_func_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check varargs' "type" are class.

*/

static int

varargs_class(type_T *type UNUSED,

type_T *decl_type UNUSED,

argcontext_T *context)

{

for (int i = context->arg_idx; i < context->arg_count; ++i)

{

type2_T *types = &context->arg_types[i];

if (types->type_curr->tt_type != VAR_CLASS)

{

semsg(_(e_class_or_typealias_required_for_argument_nr), i + 1);

return FAIL;

}

}

return OK;

}

/*

* Check "type" is a list of 'any', a tuple, a blob or a string.

*/

static int

arg_string_list_tuple_or_blob(

type_T *type,

type_T *decl_type UNUSED,

argcontext_T *context)

{

if (type->tt_type == VAR_LIST

|| type->tt_type == VAR_TUPLE

|| type->tt_type == VAR_BLOB

|| type->tt_type == VAR_STRING

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_list_any, type, context->arg_idx + 1);

return FAIL;

}

/*

* Check "type" is a tuple or a modifiable list of 'any' or a blob or a string.

*/

static int

arg_reverse(type_T *type, type_T *decl_type, argcontext_T *context)

{

if (arg_string_list_tuple_or_blob(type, decl_type, context) == FAIL)

return FAIL;

return arg_type_modifiable(type, context->arg_idx + 1);

}

/*

* Check "type" is a job.

*/

static int

arg_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

return check_arg_type(&t_job, type, context);

}

/*

* Check "type" is a channel or a job.

*/

static int

arg_chan_or_job(type_T *type, type_T *decl_type UNUSED, argcontext_T *context)

{

if (type->tt_type == VAR_CHANNEL

|| type->tt_type == VAR_JOB

|| type_any_or_unknown(type))

return OK;

arg_type_mismatch(&t_channel, type, context->arg_idx + 1);

return FAIL;

}

/*