/* 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) || defined(PROTO)

#ifdef AMIGA

# include <time.h> /* for strftime() */

#endif

#ifdef VMS

# include <float.h>

#endif

#ifdef MACOS_X

# include <time.h> /* for time_t */

#endif

static char *e_listarg = N_("E686: Argument of %s must be a List");

static char *e_listblobarg = N_("E899: Argument of %s must be a List or Blob");

static char *e_stringreq = N_("E928: String required");

#ifdef FEAT_FLOAT

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

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

#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef FEAT_FLOAT

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

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

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

#endif

#ifdef FEAT_BEVAL

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_browse(typval_T *argvars, typval_T *rettv);

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

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

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

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

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

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

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

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

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

static void byteidx(typval_T *argvars, typval_T *rettv, int comp);

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

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

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

#ifdef FEAT_FLOAT

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

#endif

#ifdef FEAT_JOB_CHANNEL

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#endif

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

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

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

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

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

#if defined(FEAT_INS_EXPAND)

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

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

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

#endif

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

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

#ifdef FEAT_FLOAT

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

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

#endif

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

static void f_cscope_connection(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_delete(typval_T *argvars, typval_T *rettv);

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

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

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

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

static void f_empty(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_executable(typval_T *argvars, typval_T *rettv);

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

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

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

#ifdef FEAT_FLOAT

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

#endif

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

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

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

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

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

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

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

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

#ifdef FEAT_FLOAT

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

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

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

#endif

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

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

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

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

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

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

static void f_foldtextresult(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_getbufinfo(typval_T *argvars, typval_T *rettv);

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

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

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

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

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

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

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

#if defined(FEAT_CMDL_COMPL)

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

#endif

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

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

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

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

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

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

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

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

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

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

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

static void f_getloclist(typval_T *argvars UNUSED, typval_T *rettv UNUSED);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static void f_histnr(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_iconv(typval_T *argvars, typval_T *rettv);

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

static void f_index(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_insert(typval_T *argvars, typval_T *rettv);

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

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

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

#if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)

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

#endif

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

#ifdef FEAT_JOB_CHANNEL

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

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

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

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

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

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

#endif

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

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

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

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

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

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

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

static void f_len(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);

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

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

#ifdef FEAT_FLOAT

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

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

#endif

#ifdef FEAT_LUA

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

#endif

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

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

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

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

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

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

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

static void f_matchdelete(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_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 vim_mkdir

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

#endif

static void f_mode(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_nr2char(typval_T *argvars, typval_T *rettv);

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

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

#ifdef FEAT_PERL

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

#endif

#ifdef FEAT_FLOAT

static void f_pow(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);

#ifdef FEAT_JOB_CHANNEL

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

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

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

#endif

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_range(typval_T *argvars, typval_T *rettv);

static void f_readfile(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_reltime(typval_T *argvars, typval_T *rettv);

#ifdef FEAT_FLOAT

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

#endif

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

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

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

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

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

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

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

static void f_remove(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);

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

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

#ifdef FEAT_FLOAT

static void f_round(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_screencol(typval_T *argvars, typval_T *rettv);

static void f_screenrow(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_server2client(typval_T *argvars, typval_T *rettv);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef FEAT_CRYPT

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

#endif /* FEAT_CRYPT */

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

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

#ifdef FEAT_SIGNS

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

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

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

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

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

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

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

#endif

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

#ifdef FEAT_FLOAT

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

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

#endif

static void f_sort(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);

#ifdef FEAT_FLOAT

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

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

#endif

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

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

#ifdef HAVE_STRFTIME

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

#endif

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

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

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

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

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

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

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

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

static void f_strwidth(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_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_system(typval_T *argvars, typval_T *rettv);

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

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

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

static void f_tabpagewinnr(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_tempname(typval_T *argvars, typval_T *rettv);

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

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

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

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

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

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

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

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

#ifdef FEAT_JOB_CHANNEL

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

#endif

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

#ifdef FEAT_JOB_CHANNEL

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

#endif

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

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

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

#ifdef FEAT_GUI

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

#endif

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

#ifdef FEAT_FLOAT

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

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

#endif

#ifdef FEAT_TIMERS

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

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

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

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

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

#endif

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

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

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

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

#ifdef FEAT_FLOAT

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

#endif

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

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

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

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

static void f_values(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_win_findbuf(typval_T *argvars, typval_T *rettv);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static void f_writefile(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);

/*

* Array with names and number of arguments of all internal functions

* MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!

*/

static struct fst

{

char *f_name; /* function name */

char f_min_argc; /* minimal number of arguments */

char f_max_argc; /* maximal number of arguments */

void (*f_func)(typval_T *args, typval_T *rvar);

/* implementation of function */

} functions[] =

{

#ifdef FEAT_FLOAT

{"abs", 1, 1, f_abs},

{"acos", 1, 1, f_acos}, /* WJMc */

#endif

{"add", 2, 2, f_add},

{"and", 2, 2, f_and},

{"append", 2, 2, f_append},

{"appendbufline", 3, 3, f_appendbufline},

{"argc", 0, 1, f_argc},

{"argidx", 0, 0, f_argidx},

{"arglistid", 0, 2, f_arglistid},

{"argv", 0, 2, f_argv},

#ifdef FEAT_FLOAT

{"asin", 1, 1, f_asin}, /* WJMc */

#endif

{"assert_beeps", 1, 2, f_assert_beeps},

{"assert_equal", 2, 3, f_assert_equal},

{"assert_equalfile", 2, 2, f_assert_equalfile},

{"assert_exception", 1, 2, f_assert_exception},

{"assert_fails", 1, 3, f_assert_fails},

{"assert_false", 1, 2, f_assert_false},

{"assert_inrange", 3, 4, f_assert_inrange},

{"assert_match", 2, 3, f_assert_match},

{"assert_notequal", 2, 3, f_assert_notequal},

{"assert_notmatch", 2, 3, f_assert_notmatch},

{"assert_report", 1, 1, f_assert_report},

{"assert_true", 1, 2, f_assert_true},

#ifdef FEAT_FLOAT

{"atan", 1, 1, f_atan},

{"atan2", 2, 2, f_atan2},

#endif

#ifdef FEAT_BEVAL

{"balloon_show", 1, 1, f_balloon_show},

# if defined(FEAT_BEVAL_TERM)

{"balloon_split", 1, 1, f_balloon_split},

# endif

#endif

{"browse", 4, 4, f_browse},

{"browsedir", 2, 2, f_browsedir},

{"bufexists", 1, 1, f_bufexists},

{"buffer_exists", 1, 1, f_bufexists}, /* obsolete */

{"buffer_name", 1, 1, f_bufname}, /* obsolete */

{"buffer_number", 1, 1, f_bufnr}, /* obsolete */

{"buflisted", 1, 1, f_buflisted},

{"bufloaded", 1, 1, f_bufloaded},

{"bufname", 1, 1, f_bufname},

{"bufnr", 1, 2, f_bufnr},

{"bufwinid", 1, 1, f_bufwinid},

{"bufwinnr", 1, 1, f_bufwinnr},

{"byte2line", 1, 1, f_byte2line},

{"byteidx", 2, 2, f_byteidx},

{"byteidxcomp", 2, 2, f_byteidxcomp},

{"call", 2, 3, f_call},

#ifdef FEAT_FLOAT

{"ceil", 1, 1, f_ceil},

#endif

#ifdef FEAT_JOB_CHANNEL

{"ch_canread", 1, 1, f_ch_canread},

{"ch_close", 1, 1, f_ch_close},

{"ch_close_in", 1, 1, f_ch_close_in},

{"ch_evalexpr", 2, 3, f_ch_evalexpr},

{"ch_evalraw", 2, 3, f_ch_evalraw},

{"ch_getbufnr", 2, 2, f_ch_getbufnr},

{"ch_getjob", 1, 1, f_ch_getjob},

{"ch_info", 1, 1, f_ch_info},

{"ch_log", 1, 2, f_ch_log},

{"ch_logfile", 1, 2, f_ch_logfile},

{"ch_open", 1, 2, f_ch_open},

{"ch_read", 1, 2, f_ch_read},

{"ch_readblob", 1, 2, f_ch_readblob},

{"ch_readraw", 1, 2, f_ch_readraw},

{"ch_sendexpr", 2, 3, f_ch_sendexpr},

{"ch_sendraw", 2, 3, f_ch_sendraw},

{"ch_setoptions", 2, 2, f_ch_setoptions},

{"ch_status", 1, 2, f_ch_status},

#endif

{"changenr", 0, 0, f_changenr},

{"char2nr", 1, 2, f_char2nr},

{"cindent", 1, 1, f_cindent},

{"clearmatches", 0, 0, f_clearmatches},

{"col", 1, 1, f_col},

#if defined(FEAT_INS_EXPAND)

{"complete", 2, 2, f_complete},

{"complete_add", 1, 1, f_complete_add},

{"complete_check", 0, 0, f_complete_check},

#endif

{"confirm", 1, 4, f_confirm},

{"copy", 1, 1, f_copy},

#ifdef FEAT_FLOAT

{"cos", 1, 1, f_cos},

{"cosh", 1, 1, f_cosh},

#endif

{"count", 2, 4, f_count},

{"cscope_connection",0,3, f_cscope_connection},

{"cursor", 1, 3, f_cursor},

#ifdef MSWIN

{"debugbreak", 1, 1, f_debugbreak},

#endif

{"deepcopy", 1, 2, f_deepcopy},

{"delete", 1, 2, f_delete},

{"deletebufline", 2, 3, f_deletebufline},

{"did_filetype", 0, 0, f_did_filetype},

{"diff_filler", 1, 1, f_diff_filler},

{"diff_hlID", 2, 2, f_diff_hlID},

{"empty", 1, 1, f_empty},

{"escape", 2, 2, f_escape},

{"eval", 1, 1, f_eval},

{"eventhandler", 0, 0, f_eventhandler},

{"executable", 1, 1, f_executable},

{"execute", 1, 2, f_execute},

{"exepath", 1, 1, f_exepath},

{"exists", 1, 1, f_exists},

#ifdef FEAT_FLOAT

{"exp", 1, 1, f_exp},

#endif

{"expand", 1, 3, f_expand},

{"extend", 2, 3, f_extend},

{"feedkeys", 1, 2, f_feedkeys},

{"file_readable", 1, 1, f_filereadable}, /* obsolete */

{"filereadable", 1, 1, f_filereadable},

{"filewritable", 1, 1, f_filewritable},

{"filter", 2, 2, f_filter},

{"finddir", 1, 3, f_finddir},

{"findfile", 1, 3, f_findfile},

#ifdef FEAT_FLOAT

{"float2nr", 1, 1, f_float2nr},

{"floor", 1, 1, f_floor},

{"fmod", 2, 2, f_fmod},

#endif

{"fnameescape", 1, 1, f_fnameescape},

{"fnamemodify", 2, 2, f_fnamemodify},

{"foldclosed", 1, 1, f_foldclosed},

{"foldclosedend", 1, 1, f_foldclosedend},

{"foldlevel", 1, 1, f_foldlevel},

{"foldtext", 0, 0, f_foldtext},

{"foldtextresult", 1, 1, f_foldtextresult},

{"foreground", 0, 0, f_foreground},

{"funcref", 1, 3, f_funcref},

{"function", 1, 3, f_function},

{"garbagecollect", 0, 1, f_garbagecollect},

{"get", 2, 3, f_get},

{"getbufinfo", 0, 1, f_getbufinfo},

{"getbufline", 2, 3, f_getbufline},

{"getbufvar", 2, 3, f_getbufvar},

{"getchangelist", 1, 1, f_getchangelist},

{"getchar", 0, 1, f_getchar},

{"getcharmod", 0, 0, f_getcharmod},

{"getcharsearch", 0, 0, f_getcharsearch},

{"getcmdline", 0, 0, f_getcmdline},

{"getcmdpos", 0, 0, f_getcmdpos},

{"getcmdtype", 0, 0, f_getcmdtype},

{"getcmdwintype", 0, 0, f_getcmdwintype},

#if defined(FEAT_CMDL_COMPL)

{"getcompletion", 2, 3, f_getcompletion},

#endif

{"getcurpos", 0, 0, f_getcurpos},

{"getcwd", 0, 2, f_getcwd},

{"getfontname", 0, 1, f_getfontname},

{"getfperm", 1, 1, f_getfperm},

{"getfsize", 1, 1, f_getfsize},

{"getftime", 1, 1, f_getftime},

{"getftype", 1, 1, f_getftype},

{"getjumplist", 0, 2, f_getjumplist},

{"getline", 1, 2, f_getline},

{"getloclist", 1, 2, f_getloclist},

{"getmatches", 0, 0, f_getmatches},

{"getpid", 0, 0, f_getpid},

{"getpos", 1, 1, f_getpos},

{"getqflist", 0, 1, f_getqflist},

{"getreg", 0, 3, f_getreg},

{"getregtype", 0, 1, f_getregtype},

{"gettabinfo", 0, 1, f_gettabinfo},

{"gettabvar", 2, 3, f_gettabvar},

{"gettabwinvar", 3, 4, f_gettabwinvar},

{"gettagstack", 0, 1, f_gettagstack},

{"getwininfo", 0, 1, f_getwininfo},

{"getwinpos", 0, 1, f_getwinpos},

{"getwinposx", 0, 0, f_getwinposx},

{"getwinposy", 0, 0, f_getwinposy},

{"getwinvar", 2, 3, f_getwinvar},

{"glob", 1, 4, f_glob},

{"glob2regpat", 1, 1, f_glob2regpat},

{"globpath", 2, 5, f_globpath},

{"has", 1, 1, f_has},

{"has_key", 2, 2, f_has_key},

{"haslocaldir", 0, 2, f_haslocaldir},

{"hasmapto", 1, 3, f_hasmapto},

{"highlightID", 1, 1, f_hlID}, /* obsolete */

{"highlight_exists",1, 1, f_hlexists}, /* obsolete */

{"histadd", 2, 2, f_histadd},

{"histdel", 1, 2, f_histdel},

{"histget", 1, 2, f_histget},

{"histnr", 1, 1, f_histnr},

{"hlID", 1, 1, f_hlID},

{"hlexists", 1, 1, f_hlexists},

{"hostname", 0, 0, f_hostname},

{"iconv", 3, 3, f_iconv},

{"indent", 1, 1, f_indent},

{"index", 2, 4, f_index},

{"input", 1, 3, f_input},

{"inputdialog", 1, 3, f_inputdialog},

{"inputlist", 1, 1, f_inputlist},

{"inputrestore", 0, 0, f_inputrestore},

{"inputsave", 0, 0, f_inputsave},

{"inputsecret", 1, 2, f_inputsecret},

{"insert", 2, 3, f_insert},

{"invert", 1, 1, f_invert},

{"isdirectory", 1, 1, f_isdirectory},

{"islocked", 1, 1, f_islocked},

#if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)

{"isnan", 1, 1, f_isnan},

#endif

{"items", 1, 1, f_items},

#ifdef FEAT_JOB_CHANNEL

{"job_getchannel", 1, 1, f_job_getchannel},

{"job_info", 0, 1, f_job_info},

{"job_setoptions", 2, 2, f_job_setoptions},

{"job_start", 1, 2, f_job_start},

{"job_status", 1, 1, f_job_status},

{"job_stop", 1, 2, f_job_stop},

#endif

{"join", 1, 2, f_join},

{"js_decode", 1, 1, f_js_decode},

{"js_encode", 1, 1, f_js_encode},

{"json_decode", 1, 1, f_json_decode},

{"json_encode", 1, 1, f_json_encode},

{"keys", 1, 1, f_keys},

{"last_buffer_nr", 0, 0, f_last_buffer_nr},/* obsolete */

{"len", 1, 1, f_len},

{"libcall", 3, 3, f_libcall},

{"libcallnr", 3, 3, f_libcallnr},

{"line", 1, 1, f_line},

{"line2byte", 1, 1, f_line2byte},

{"lispindent", 1, 1, f_lispindent},

{"localtime", 0, 0, f_localtime},

#ifdef FEAT_FLOAT

{"log", 1, 1, f_log},

{"log10", 1, 1, f_log10},

#endif

#ifdef FEAT_LUA

{"luaeval", 1, 2, f_luaeval},

#endif

{"map", 2, 2, f_map},

{"maparg", 1, 4, f_maparg},

{"mapcheck", 1, 3, f_mapcheck},

{"match", 2, 4, f_match},

{"matchadd", 2, 5, f_matchadd},

{"matchaddpos", 2, 5, f_matchaddpos},

{"matcharg", 1, 1, f_matcharg},

{"matchdelete", 1, 1, f_matchdelete},

{"matchend", 2, 4, f_matchend},

{"matchlist", 2, 4, f_matchlist},

{"matchstr", 2, 4, f_matchstr},

{"matchstrpos", 2, 4, f_matchstrpos},

{"max", 1, 1, f_max},

{"min", 1, 1, f_min},

#ifdef vim_mkdir

{"mkdir", 1, 3, f_mkdir},

#endif

{"mode", 0, 1, f_mode},

#ifdef FEAT_MZSCHEME

{"mzeval", 1, 1, f_mzeval},

#endif

{"nextnonblank", 1, 1, f_nextnonblank},

{"nr2char", 1, 2, f_nr2char},

{"or", 2, 2, f_or},

{"pathshorten", 1, 1, f_pathshorten},

#ifdef FEAT_PERL

{"perleval", 1, 1, f_perleval},

#endif

#ifdef FEAT_FLOAT

{"pow", 2, 2, f_pow},

#endif

{"prevnonblank", 1, 1, f_prevnonblank},

{"printf", 1, 19, f_printf},

#ifdef FEAT_JOB_CHANNEL

{"prompt_setcallback", 2, 2, f_prompt_setcallback},

{"prompt_setinterrupt", 2, 2, f_prompt_setinterrupt},

{"prompt_setprompt", 2, 2, f_prompt_setprompt},

#endif

#ifdef FEAT_TEXT_PROP

{"prop_add", 3, 3, f_prop_add},

{"prop_clear", 1, 3, f_prop_clear},

{"prop_list", 1, 2, f_prop_list},

{"prop_remove", 2, 3, f_prop_remove},

{"prop_type_add", 2, 2, f_prop_type_add},

{"prop_type_change", 2, 2, f_prop_type_change},

{"prop_type_delete", 1, 2, f_prop_type_delete},

{"prop_type_get", 1, 2, f_prop_type_get},

{"prop_type_list", 0, 1, f_prop_type_list},

#endif

{"pumvisible", 0, 0, f_pumvisible},

#ifdef FEAT_PYTHON3

{"py3eval", 1, 1, f_py3eval},

#endif

#ifdef FEAT_PYTHON

{"pyeval", 1, 1, f_pyeval},

#endif

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

{"pyxeval", 1, 1, f_pyxeval},

#endif

{"range", 1, 3, f_range},

{"readfile", 1, 3, f_readfile},

{"reg_executing", 0, 0, f_reg_executing},

{"reg_recording", 0, 0, f_reg_recording},

{"reltime", 0, 2, f_reltime},

#ifdef FEAT_FLOAT

{"reltimefloat", 1, 1, f_reltimefloat},

#endif

{"reltimestr", 1, 1, f_reltimestr},

{"remote_expr", 2, 4, f_remote_expr},

{"remote_foreground", 1, 1, f_remote_foreground},

{"remote_peek", 1, 2, f_remote_peek},

{"remote_read", 1, 2, f_remote_read},

{"remote_send", 2, 3, f_remote_send},

{"remote_startserver", 1, 1, f_remote_startserver},

{"remove", 2, 3, f_remove},

{"rename", 2, 2, f_rename},

{"repeat", 2, 2, f_repeat},

{"resolve", 1, 1, f_resolve},

{"reverse", 1, 1, f_reverse},

#ifdef FEAT_FLOAT

{"round", 1, 1, f_round},

#endif

{"screenattr", 2, 2, f_screenattr},

{"screenchar", 2, 2, f_screenchar},

{"screencol", 0, 0, f_screencol},

{"screenrow", 0, 0, f_screenrow},

{"search", 1, 4, f_search},

{"searchdecl", 1, 3, f_searchdecl},

{"searchpair", 3, 7, f_searchpair},

{"searchpairpos", 3, 7, f_searchpairpos},

{"searchpos", 1, 4, f_searchpos},

{"server2client", 2, 2, f_server2client},

{"serverlist", 0, 0, f_serverlist},

{"setbufline", 3, 3, f_setbufline},

{"setbufvar", 3, 3, f_setbufvar},

{"setcharsearch", 1, 1, f_setcharsearch},

{"setcmdpos", 1, 1, f_setcmdpos},

{"setfperm", 2, 2, f_setfperm},

{"setline", 2, 2, f_setline},

{"setloclist", 2, 4, f_setloclist},

{"setmatches", 1, 1, f_setmatches},

{"setpos", 2, 2, f_setpos},

{"setqflist", 1, 3, f_setqflist},

{"setreg", 2, 3, f_setreg},

{"settabvar", 3, 3, f_settabvar},

{"settabwinvar", 4, 4, f_settabwinvar},

{"settagstack", 2, 3, f_settagstack},

{"setwinvar", 3, 3, f_setwinvar},

#ifdef FEAT_CRYPT

{"sha256", 1, 1, f_sha256},

#endif

{"shellescape", 1, 2, f_shellescape},

{"shiftwidth", 0, 1, f_shiftwidth},

#ifdef FEAT_SIGNS

{"sign_define", 1, 2, f_sign_define},

{"sign_getdefined", 0, 1, f_sign_getdefined},

{"sign_getplaced", 0, 2, f_sign_getplaced},

{"sign_jump", 3, 3, f_sign_jump},

{"sign_place", 4, 5, f_sign_place},

{"sign_undefine", 0, 1, f_sign_undefine},

{"sign_unplace", 1, 2, f_sign_unplace},

#endif

{"simplify", 1, 1, f_simplify},

#ifdef FEAT_FLOAT

{"sin", 1, 1, f_sin},

{"sinh", 1, 1, f_sinh},

#endif

{"sort", 1, 3, f_sort},

{"soundfold", 1, 1, f_soundfold},

{"spellbadword", 0, 1, f_spellbadword},

{"spellsuggest", 1, 3, f_spellsuggest},

{"split", 1, 3, f_split},

#ifdef FEAT_FLOAT

{"sqrt", 1, 1, f_sqrt},

{"str2float", 1, 1, f_str2float},

#endif

{"str2nr", 1, 2, f_str2nr},

{"strcharpart", 2, 3, f_strcharpart},

{"strchars", 1, 2, f_strchars},

{"strdisplaywidth", 1, 2, f_strdisplaywidth},

#ifdef HAVE_STRFTIME

{"strftime", 1, 2, f_strftime},

#endif

{"strgetchar", 2, 2, f_strgetchar},

{"stridx", 2, 3, f_stridx},

{"string", 1, 1, f_string},

{"strlen", 1, 1, f_strlen},

{"strpart", 2, 3, f_strpart},

{"strridx", 2, 3, f_strridx},

{"strtrans", 1, 1, f_strtrans},

{"strwidth", 1, 1, f_strwidth},

{"submatch", 1, 2, f_submatch},

{"substitute", 4, 4, f_substitute},

{"swapinfo", 1, 1, f_swapinfo},

{"swapname", 1, 1, f_swapname},

{"synID", 3, 3, f_synID},

{"synIDattr", 2, 3, f_synIDattr},

{"synIDtrans", 1, 1, f_synIDtrans},

{"synconcealed", 2, 2, f_synconcealed},

{"synstack", 2, 2, f_synstack},

{"system", 1, 2, f_system},

{"systemlist", 1, 2, f_systemlist},

{"tabpagebuflist", 0, 1, f_tabpagebuflist},

{"tabpagenr", 0, 1, f_tabpagenr},

{"tabpagewinnr", 1, 2, f_tabpagewinnr},

{"tagfiles", 0, 0, f_tagfiles},

{"taglist", 1, 2, f_taglist},

#ifdef FEAT_FLOAT

{"tan", 1, 1, f_tan},

{"tanh", 1, 1, f_tanh},

#endif

{"tempname", 0, 0, f_tempname},

#ifdef FEAT_TERMINAL

{"term_dumpdiff", 2, 3, f_term_dumpdiff},

{"term_dumpload", 1, 2, f_term_dumpload},

{"term_dumpwrite", 2, 3, f_term_dumpwrite},

{"term_getaltscreen", 1, 1, f_term_getaltscreen},

# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)

{"term_getansicolors", 1, 1, f_term_getansicolors},

# endif

{"term_getattr", 2, 2, f_term_getattr},

{"term_getcursor", 1, 1, f_term_getcursor},

{"term_getjob", 1, 1, f_term_getjob},

{"term_getline", 2, 2, f_term_getline},

{"term_getscrolled", 1, 1, f_term_getscrolled},

{"term_getsize", 1, 1, f_term_getsize},

{"term_getstatus", 1, 1, f_term_getstatus},

{"term_gettitle", 1, 1, f_term_gettitle},

{"term_gettty", 1, 2, f_term_gettty},

{"term_list", 0, 0, f_term_list},

{"term_scrape", 2, 2, f_term_scrape},

{"term_sendkeys", 2, 2, f_term_sendkeys},

# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)

{"term_setansicolors", 2, 2, f_term_setansicolors},

# endif

{"term_setkill", 2, 2, f_term_setkill},

{"term_setrestore", 2, 2, f_term_setrestore},

{"term_setsize", 3, 3, f_term_setsize},

{"term_start", 1, 2, f_term_start},

{"term_wait", 1, 2, f_term_wait},

#endif

{"test_alloc_fail", 3, 3, f_test_alloc_fail},

{"test_autochdir", 0, 0, f_test_autochdir},

{"test_feedinput", 1, 1, f_test_feedinput},

{"test_garbagecollect_now", 0, 0, f_test_garbagecollect_now},

{"test_ignore_error", 1, 1, f_test_ignore_error},

{"test_null_blob", 0, 0, f_test_null_blob},

#ifdef FEAT_JOB_CHANNEL

{"test_null_channel", 0, 0, f_test_null_channel},

#endif

{"test_null_dict", 0, 0, f_test_null_dict},

#ifdef FEAT_JOB_CHANNEL

{"test_null_job", 0, 0, f_test_null_job},

#endif

{"test_null_list", 0, 0, f_test_null_list},

{"test_null_partial", 0, 0, f_test_null_partial},

{"test_null_string", 0, 0, f_test_null_string},

{"test_option_not_set", 1, 1, f_test_option_not_set},

{"test_override", 2, 2, f_test_override},

#ifdef FEAT_GUI

{"test_scrollbar", 3, 3, f_test_scrollbar},

#endif

{"test_settime", 1, 1, f_test_settime},

#ifdef FEAT_TIMERS

{"timer_info", 0, 1, f_timer_info},

{"timer_pause", 2, 2, f_timer_pause},

{"timer_start", 2, 3, f_timer_start},

{"timer_stop", 1, 1, f_timer_stop},

{"timer_stopall", 0, 0, f_timer_stopall},

#endif

{"tolower", 1, 1, f_tolower},

{"toupper", 1, 1, f_toupper},

{"tr", 3, 3, f_tr},

{"trim", 1, 2, f_trim},

#ifdef FEAT_FLOAT

{"trunc", 1, 1, f_trunc},

#endif

{"type", 1, 1, f_type},

{"undofile", 1, 1, f_undofile},

{"undotree", 0, 0, f_undotree},

{"uniq", 1, 3, f_uniq},

{"values", 1, 1, f_values},

{"virtcol", 1, 1, f_virtcol},

{"visualmode", 0, 1, f_visualmode},

{"wildmenumode", 0, 0, f_wildmenumode},

{"win_findbuf", 1, 1, f_win_findbuf},

{"win_getid", 0, 2, f_win_getid},

{"win_gotoid", 1, 1, f_win_gotoid},

{"win_id2tabwin", 1, 1, f_win_id2tabwin},

{"win_id2win", 1, 1, f_win_id2win},

{"win_screenpos", 1, 1, f_win_screenpos},

{"winbufnr", 1, 1, f_winbufnr},