Bram Moolenaar | edf3f97 | 2016-08-29 22:49:24 +0200 | [diff] [blame] | 1 | /* vi:set ts=8 sts=4 sw=4 noet: |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2 | * |
| 3 | * VIM - Vi IMproved by Bram Moolenaar |
| 4 | * |
| 5 | * Do ":help uganda" in Vim to read copying and usage conditions. |
| 6 | * Do ":help credits" in Vim to see a list of people who contributed. |
| 7 | * See README.txt for an overview of the Vim source code. |
| 8 | */ |
| 9 | |
| 10 | /* |
| 11 | * evalfunc.c: Builtin functions |
| 12 | */ |
| 13 | #define USING_FLOAT_STUFF |
| 14 | |
| 15 | #include "vim.h" |
| 16 | |
| 17 | #if defined(FEAT_EVAL) || defined(PROTO) |
| 18 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 19 | #ifdef VMS |
| 20 | # include <float.h> |
| 21 | #endif |
| 22 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 23 | static void f_and(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 24 | #ifdef FEAT_BEVAL |
Bram Moolenaar | be0a259 | 2019-05-09 13:50:16 +0200 | [diff] [blame] | 25 | static void f_balloon_gettext(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 26 | static void f_balloon_show(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 669a828 | 2017-11-19 20:13:05 +0100 | [diff] [blame] | 27 | # if defined(FEAT_BEVAL_TERM) |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 28 | static void f_balloon_split(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 669a828 | 2017-11-19 20:13:05 +0100 | [diff] [blame] | 29 | # endif |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 30 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 31 | static void f_byte2line(typval_T *argvars, typval_T *rettv); |
| 32 | static void byteidx(typval_T *argvars, typval_T *rettv, int comp); |
| 33 | static void f_byteidx(typval_T *argvars, typval_T *rettv); |
| 34 | static void f_byteidxcomp(typval_T *argvars, typval_T *rettv); |
| 35 | static void f_call(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 36 | static void f_changenr(typval_T *argvars, typval_T *rettv); |
| 37 | static void f_char2nr(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 38 | static void f_charcol(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 17793ef | 2020-12-28 12:56:58 +0100 | [diff] [blame] | 39 | static void f_charidx(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 40 | static void f_col(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 41 | static void f_confirm(typval_T *argvars, typval_T *rettv); |
| 42 | static void f_copy(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 43 | static void f_cursor(typval_T *argsvars, typval_T *rettv); |
Bram Moolenaar | 4f97475 | 2019-02-17 17:44:42 +0100 | [diff] [blame] | 44 | #ifdef MSWIN |
Bram Moolenaar | 4551c0a | 2018-06-20 22:38:21 +0200 | [diff] [blame] | 45 | static void f_debugbreak(typval_T *argvars, typval_T *rettv); |
| 46 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 47 | static void f_deepcopy(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 48 | static void f_did_filetype(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 4132eb5 | 2020-02-14 16:53:00 +0100 | [diff] [blame] | 49 | static void f_echoraw(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 50 | static void f_empty(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 691ddee | 2019-05-09 14:52:41 +0200 | [diff] [blame] | 51 | static void f_environ(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 52 | static void f_escape(typval_T *argvars, typval_T *rettv); |
| 53 | static void f_eval(typval_T *argvars, typval_T *rettv); |
| 54 | static void f_eventhandler(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 55 | static void f_execute(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 56 | static void f_exists(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 57 | static void f_expand(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 80dad48 | 2019-06-09 17:22:31 +0200 | [diff] [blame] | 58 | static void f_expandcmd(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 59 | static void f_feedkeys(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 60 | static void f_fnameescape(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 61 | static void f_foreground(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 62 | static void f_funcref(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 63 | static void f_function(typval_T *argvars, typval_T *rettv); |
| 64 | static void f_garbagecollect(typval_T *argvars, typval_T *rettv); |
| 65 | static void f_get(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 07ad816 | 2018-02-13 13:59:59 +0100 | [diff] [blame] | 66 | static void f_getchangelist(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 67 | static void f_getcharpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 68 | static void f_getcharsearch(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 691ddee | 2019-05-09 14:52:41 +0200 | [diff] [blame] | 69 | static void f_getenv(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 70 | static void f_getfontname(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 4f50588 | 2018-02-10 21:06:32 +0100 | [diff] [blame] | 71 | static void f_getjumplist(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 72 | static void f_getpid(typval_T *argvars, typval_T *rettv); |
| 73 | static void f_getcurpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 74 | static void f_getcursorcharpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 75 | static void f_getpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 76 | static void f_getreg(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 77 | static void f_getreginfo(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 78 | static void f_getregtype(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 79 | static void f_gettagstack(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 0b39c3f | 2020-08-30 15:52:10 +0200 | [diff] [blame] | 80 | static void f_gettext(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 81 | static void f_haslocaldir(typval_T *argvars, typval_T *rettv); |
| 82 | static void f_hasmapto(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 83 | static void f_hlID(typval_T *argvars, typval_T *rettv); |
| 84 | static void f_hlexists(typval_T *argvars, typval_T *rettv); |
| 85 | static void f_hostname(typval_T *argvars, typval_T *rettv); |
| 86 | static void f_iconv(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 87 | static void f_index(typval_T *argvars, typval_T *rettv); |
| 88 | static void f_input(typval_T *argvars, typval_T *rettv); |
| 89 | static void f_inputdialog(typval_T *argvars, typval_T *rettv); |
| 90 | static void f_inputlist(typval_T *argvars, typval_T *rettv); |
| 91 | static void f_inputrestore(typval_T *argvars, typval_T *rettv); |
| 92 | static void f_inputsave(typval_T *argvars, typval_T *rettv); |
| 93 | static void f_inputsecret(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 67a2deb | 2019-11-25 00:05:32 +0100 | [diff] [blame] | 94 | static void f_interrupt(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 95 | static void f_invert(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 96 | static void f_islocked(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 97 | static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv); |
| 98 | static void f_len(typval_T *argvars, typval_T *rettv); |
| 99 | static void f_libcall(typval_T *argvars, typval_T *rettv); |
| 100 | static void f_libcallnr(typval_T *argvars, typval_T *rettv); |
| 101 | static void f_line(typval_T *argvars, typval_T *rettv); |
| 102 | static void f_line2byte(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 103 | #ifdef FEAT_LUA |
| 104 | static void f_luaeval(typval_T *argvars, typval_T *rettv); |
| 105 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 106 | static void f_maparg(typval_T *argvars, typval_T *rettv); |
| 107 | static void f_mapcheck(typval_T *argvars, typval_T *rettv); |
| 108 | static void f_match(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 109 | static void f_matchend(typval_T *argvars, typval_T *rettv); |
| 110 | static void f_matchlist(typval_T *argvars, typval_T *rettv); |
| 111 | static void f_matchstr(typval_T *argvars, typval_T *rettv); |
| 112 | static void f_matchstrpos(typval_T *argvars, typval_T *rettv); |
| 113 | static void f_max(typval_T *argvars, typval_T *rettv); |
| 114 | static void f_min(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 115 | #ifdef FEAT_MZSCHEME |
| 116 | static void f_mzeval(typval_T *argvars, typval_T *rettv); |
| 117 | #endif |
| 118 | static void f_nextnonblank(typval_T *argvars, typval_T *rettv); |
| 119 | static void f_nr2char(typval_T *argvars, typval_T *rettv); |
| 120 | static void f_or(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 121 | #ifdef FEAT_PERL |
| 122 | static void f_perleval(typval_T *argvars, typval_T *rettv); |
| 123 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 124 | static void f_prevnonblank(typval_T *argvars, typval_T *rettv); |
| 125 | static void f_printf(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | e9bd572 | 2019-08-17 19:36:06 +0200 | [diff] [blame] | 126 | static void f_pum_getpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 127 | static void f_pumvisible(typval_T *argvars, typval_T *rettv); |
| 128 | #ifdef FEAT_PYTHON3 |
| 129 | static void f_py3eval(typval_T *argvars, typval_T *rettv); |
| 130 | #endif |
| 131 | #ifdef FEAT_PYTHON |
| 132 | static void f_pyeval(typval_T *argvars, typval_T *rettv); |
| 133 | #endif |
Bram Moolenaar | f42dd3c | 2017-01-28 16:06:38 +0100 | [diff] [blame] | 134 | #if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) |
| 135 | static void f_pyxeval(typval_T *argvars, typval_T *rettv); |
| 136 | #endif |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 137 | static void f_test_srand_seed(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 138 | static void f_rand(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 139 | static void f_range(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 0b6d911 | 2018-05-22 20:35:17 +0200 | [diff] [blame] | 140 | static void f_reg_executing(typval_T *argvars, typval_T *rettv); |
| 141 | static void f_reg_recording(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 142 | static void f_rename(typval_T *argvars, typval_T *rettv); |
| 143 | static void f_repeat(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | e99be0e | 2019-03-26 22:51:09 +0100 | [diff] [blame] | 144 | #ifdef FEAT_RUBY |
| 145 | static void f_rubyeval(typval_T *argvars, typval_T *rettv); |
| 146 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 147 | static void f_screenattr(typval_T *argvars, typval_T *rettv); |
| 148 | static void f_screenchar(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 2912abb | 2019-03-29 14:16:42 +0100 | [diff] [blame] | 149 | static void f_screenchars(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 150 | static void f_screencol(typval_T *argvars, typval_T *rettv); |
| 151 | static void f_screenrow(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 2912abb | 2019-03-29 14:16:42 +0100 | [diff] [blame] | 152 | static void f_screenstring(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 153 | static void f_search(typval_T *argvars, typval_T *rettv); |
| 154 | static void f_searchdecl(typval_T *argvars, typval_T *rettv); |
| 155 | static void f_searchpair(typval_T *argvars, typval_T *rettv); |
| 156 | static void f_searchpairpos(typval_T *argvars, typval_T *rettv); |
| 157 | static void f_searchpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 158 | static void f_setcharpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 159 | static void f_setcharsearch(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 160 | static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 691ddee | 2019-05-09 14:52:41 +0200 | [diff] [blame] | 161 | static void f_setenv(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 162 | static void f_setfperm(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 163 | static void f_setpos(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 164 | static void f_setreg(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 165 | static void f_settagstack(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 166 | #ifdef FEAT_CRYPT |
| 167 | static void f_sha256(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | b005cd8 | 2019-09-04 15:54:55 +0200 | [diff] [blame] | 168 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 169 | static void f_shellescape(typval_T *argvars, typval_T *rettv); |
| 170 | static void f_shiftwidth(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 171 | static void f_soundfold(typval_T *argvars, typval_T *rettv); |
| 172 | static void f_spellbadword(typval_T *argvars, typval_T *rettv); |
| 173 | static void f_spellsuggest(typval_T *argvars, typval_T *rettv); |
| 174 | static void f_split(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 175 | static void f_srand(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 9d40128 | 2019-04-06 13:18:12 +0200 | [diff] [blame] | 176 | static void f_str2list(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 177 | static void f_str2nr(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 70ce8a1 | 2021-03-14 19:02:09 +0100 | [diff] [blame] | 178 | static void f_strcharlen(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 179 | static void f_strchars(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 180 | static void f_strgetchar(typval_T *argvars, typval_T *rettv); |
| 181 | static void f_stridx(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 182 | static void f_strlen(typval_T *argvars, typval_T *rettv); |
| 183 | static void f_strcharpart(typval_T *argvars, typval_T *rettv); |
| 184 | static void f_strpart(typval_T *argvars, typval_T *rettv); |
| 185 | static void f_strridx(typval_T *argvars, typval_T *rettv); |
| 186 | static void f_strtrans(typval_T *argvars, typval_T *rettv); |
| 187 | static void f_strdisplaywidth(typval_T *argvars, typval_T *rettv); |
| 188 | static void f_strwidth(typval_T *argvars, typval_T *rettv); |
| 189 | static void f_submatch(typval_T *argvars, typval_T *rettv); |
| 190 | static void f_substitute(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 00f123a | 2018-08-21 20:28:54 +0200 | [diff] [blame] | 191 | static void f_swapinfo(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 110bd60 | 2018-09-16 18:46:59 +0200 | [diff] [blame] | 192 | static void f_swapname(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 193 | static void f_synID(typval_T *argvars, typval_T *rettv); |
| 194 | static void f_synIDattr(typval_T *argvars, typval_T *rettv); |
| 195 | static void f_synIDtrans(typval_T *argvars, typval_T *rettv); |
| 196 | static void f_synstack(typval_T *argvars, typval_T *rettv); |
| 197 | static void f_synconcealed(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 198 | static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 199 | static void f_taglist(typval_T *argvars, typval_T *rettv); |
| 200 | static void f_tagfiles(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 201 | static void f_tolower(typval_T *argvars, typval_T *rettv); |
| 202 | static void f_toupper(typval_T *argvars, typval_T *rettv); |
| 203 | static void f_tr(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 204 | static void f_trim(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 205 | static void f_type(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 206 | static void f_virtcol(typval_T *argvars, typval_T *rettv); |
| 207 | static void f_visualmode(typval_T *argvars, typval_T *rettv); |
| 208 | static void f_wildmenumode(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 0c1e374 | 2019-12-27 13:49:24 +0100 | [diff] [blame] | 209 | static void f_windowsversion(typval_T *argvars, typval_T *rettv); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 210 | static void f_wordcount(typval_T *argvars, typval_T *rettv); |
| 211 | static void f_xor(typval_T *argvars, typval_T *rettv); |
| 212 | |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 213 | |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 214 | /* |
| 215 | * Functions that check the argument type of a builtin function. |
| 216 | * Each function returns FAIL and gives an error message if the type is wrong. |
| 217 | */ |
| 218 | |
| 219 | // Context passed to an arg_ function. |
| 220 | typedef struct { |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 221 | int arg_count; // actual argument count |
| 222 | type_T **arg_types; // list of argument types |
| 223 | int arg_idx; // current argument index (first arg is zero) |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 224 | cctx_T *arg_cctx; |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 225 | } argcontext_T; |
| 226 | |
| 227 | // A function to check one argument type. The first argument is the type to |
| 228 | // check. If needed, other argument types can be obtained with the context. |
| 229 | // E.g. if "arg_idx" is 1, then (type - 1) is the first argument type. |
| 230 | typedef int (*argcheck_T)(type_T *, argcontext_T *); |
| 231 | |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 232 | /* |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 233 | * Call need_type() to check an argument type. |
| 234 | */ |
| 235 | static int |
| 236 | check_arg_type( |
| 237 | type_T *expected, |
| 238 | type_T *actual, |
| 239 | argcontext_T *context) |
| 240 | { |
| 241 | // TODO: would be useful to know if "actual" is a constant and pass it to |
| 242 | // need_type() to get a compile time error if possible. |
| 243 | return need_type(actual, expected, |
| 244 | context->arg_idx - context->arg_count, context->arg_idx + 1, |
| 245 | context->arg_cctx, FALSE, FALSE); |
| 246 | } |
| 247 | |
| 248 | /* |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 249 | * Check "type" is a float or a number. |
| 250 | */ |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 251 | static int |
| 252 | arg_float_or_nr(type_T *type, argcontext_T *context) |
| 253 | { |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 254 | if (type->tt_type == VAR_ANY |
| 255 | || type->tt_type == VAR_FLOAT || type->tt_type == VAR_NUMBER) |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 256 | return OK; |
| 257 | arg_type_mismatch(&t_number, type, context->arg_idx + 1); |
| 258 | return FAIL; |
| 259 | } |
| 260 | |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 261 | /* |
| 262 | * Check "type" is a number. |
| 263 | */ |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 264 | static int |
| 265 | arg_number(type_T *type, argcontext_T *context) |
| 266 | { |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 267 | return check_arg_type(&t_number, type, context); |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 268 | } |
| 269 | |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 270 | /* |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 271 | * Check "type" is a dict of 'any'. |
| 272 | */ |
| 273 | static int |
| 274 | arg_dict_any(type_T *type, argcontext_T *context) |
| 275 | { |
| 276 | return check_arg_type(&t_dict_any, type, context); |
| 277 | } |
| 278 | |
| 279 | /* |
| 280 | * Check "type" is a list of numbers. |
| 281 | */ |
| 282 | static int |
| 283 | arg_list_number(type_T *type, argcontext_T *context) |
| 284 | { |
| 285 | return check_arg_type(&t_list_number, type, context); |
| 286 | } |
| 287 | |
| 288 | /* |
| 289 | * Check "type" is a list of strings. |
| 290 | */ |
| 291 | static int |
| 292 | arg_list_string(type_T *type, argcontext_T *context) |
| 293 | { |
| 294 | return check_arg_type(&t_list_string, type, context); |
| 295 | } |
| 296 | |
| 297 | /* |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 298 | * Check "type" is a string. |
| 299 | */ |
| 300 | static int |
| 301 | arg_string(type_T *type, argcontext_T *context) |
| 302 | { |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 303 | return check_arg_type(&t_string, type, context); |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | /* |
Bram Moolenaar | f2b26bc | 2021-01-30 23:05:11 +0100 | [diff] [blame] | 307 | * Check "type" is a bool or number 0 or 1. |
| 308 | */ |
| 309 | static int |
| 310 | arg_bool(type_T *type, argcontext_T *context) |
| 311 | { |
| 312 | if (type->tt_type == VAR_ANY |
| 313 | || type->tt_type == VAR_NUMBER || type->tt_type == VAR_BOOL) |
| 314 | return OK; |
| 315 | return check_arg_type(&t_bool, type, context); |
| 316 | } |
| 317 | |
| 318 | /* |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 319 | * Check "type" is a list or a blob. |
| 320 | */ |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 321 | static int |
| 322 | arg_list_or_blob(type_T *type, argcontext_T *context) |
| 323 | { |
| 324 | if (type->tt_type == VAR_ANY |
| 325 | || type->tt_type == VAR_LIST || type->tt_type == VAR_BLOB) |
| 326 | return OK; |
| 327 | arg_type_mismatch(&t_list_any, type, context->arg_idx + 1); |
| 328 | return FAIL; |
| 329 | } |
| 330 | |
| 331 | /* |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 332 | * Check "type" is a string or a number |
| 333 | */ |
| 334 | static int |
| 335 | arg_string_or_nr(type_T *type, argcontext_T *context) |
| 336 | { |
| 337 | if (type->tt_type == VAR_ANY |
| 338 | || type->tt_type == VAR_STRING || type->tt_type == VAR_NUMBER) |
| 339 | return OK; |
| 340 | arg_type_mismatch(&t_string, type, context->arg_idx + 1); |
| 341 | return FAIL; |
| 342 | } |
| 343 | /* |
Bram Moolenaar | ca81f0e | 2021-06-20 14:41:01 +0200 | [diff] [blame] | 344 | * Check "type" is a string or a list of strings. |
| 345 | */ |
| 346 | static int |
| 347 | arg_string_or_list(type_T *type, argcontext_T *context) |
| 348 | { |
| 349 | if (type->tt_type == VAR_ANY || type->tt_type == VAR_STRING) |
| 350 | return OK; |
| 351 | if (type->tt_type != VAR_LIST) |
| 352 | { |
| 353 | arg_type_mismatch(&t_string, type, context->arg_idx + 1); |
| 354 | return FAIL; |
| 355 | } |
| 356 | if (type->tt_member->tt_type == VAR_ANY |
| 357 | || type->tt_member->tt_type == VAR_STRING) |
| 358 | return OK; |
| 359 | |
| 360 | arg_type_mismatch(&t_list_string, type, context->arg_idx + 1); |
| 361 | return FAIL; |
| 362 | } |
| 363 | |
| 364 | /* |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 365 | * Check "type" is a list or a dict. |
| 366 | */ |
| 367 | static int |
| 368 | arg_list_or_dict(type_T *type, argcontext_T *context) |
| 369 | { |
| 370 | if (type->tt_type == VAR_ANY |
| 371 | || type->tt_type == VAR_LIST || type->tt_type == VAR_DICT) |
| 372 | return OK; |
| 373 | arg_type_mismatch(&t_list_any, type, context->arg_idx + 1); |
| 374 | return FAIL; |
| 375 | } |
| 376 | |
| 377 | /* |
Bram Moolenaar | b0e6b51 | 2021-01-12 20:23:40 +0100 | [diff] [blame] | 378 | * Check "type" is the same type as the previous argument. |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 379 | * Must not be used for the first argcheck_T entry. |
| 380 | */ |
| 381 | static int |
| 382 | arg_same_as_prev(type_T *type, argcontext_T *context) |
| 383 | { |
| 384 | type_T *prev_type = context->arg_types[context->arg_idx - 1]; |
| 385 | |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 386 | return check_arg_type(prev_type, type, context); |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 387 | } |
| 388 | |
| 389 | /* |
Bram Moolenaar | b0e6b51 | 2021-01-12 20:23:40 +0100 | [diff] [blame] | 390 | * Check "type" is the same basic type as the previous argument, checks list or |
| 391 | * dict vs other type, but not member type. |
| 392 | * Must not be used for the first argcheck_T entry. |
| 393 | */ |
| 394 | static int |
| 395 | arg_same_struct_as_prev(type_T *type, argcontext_T *context) |
| 396 | { |
| 397 | type_T *prev_type = context->arg_types[context->arg_idx - 1]; |
| 398 | |
| 399 | if (prev_type->tt_type != context->arg_types[context->arg_idx]->tt_type) |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 400 | return check_arg_type(prev_type, type, context); |
Bram Moolenaar | b0e6b51 | 2021-01-12 20:23:40 +0100 | [diff] [blame] | 401 | return OK; |
| 402 | } |
| 403 | |
| 404 | /* |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 405 | * Check "type" is an item of the list or blob of the previous arg. |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 406 | * Must not be used for the first argcheck_T entry. |
| 407 | */ |
| 408 | static int |
| 409 | arg_item_of_prev(type_T *type, argcontext_T *context) |
| 410 | { |
| 411 | type_T *prev_type = context->arg_types[context->arg_idx - 1]; |
| 412 | type_T *expected; |
| 413 | |
| 414 | if (prev_type->tt_type == VAR_LIST) |
| 415 | expected = prev_type->tt_member; |
| 416 | else if (prev_type->tt_type == VAR_BLOB) |
| 417 | expected = &t_number; |
| 418 | else |
| 419 | // probably VAR_ANY, can't check |
| 420 | return OK; |
| 421 | |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 422 | return check_arg_type(expected, type, context); |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 423 | } |
| 424 | |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 425 | /* |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 426 | * Check "type" which is the third argument of extend(). |
| 427 | */ |
| 428 | static int |
| 429 | arg_extend3(type_T *type, argcontext_T *context) |
| 430 | { |
| 431 | type_T *first_type = context->arg_types[context->arg_idx - 2]; |
| 432 | |
| 433 | if (first_type->tt_type == VAR_LIST) |
| 434 | return arg_number(type, context); |
| 435 | if (first_type->tt_type == VAR_DICT) |
| 436 | return arg_string(type, context); |
| 437 | return OK; |
| 438 | } |
| 439 | |
| 440 | |
| 441 | /* |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 442 | * Lists of functions that check the argument types of a builtin function. |
| 443 | */ |
Bram Moolenaar | 80ad3e2 | 2021-01-31 20:48:58 +0100 | [diff] [blame] | 444 | argcheck_T arg1_string[] = {arg_string}; |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 445 | argcheck_T arg1_number[] = {arg_number}; |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 446 | argcheck_T arg1_dict[] = {arg_dict_any}; |
| 447 | argcheck_T arg1_list_number[] = {arg_list_number}; |
| 448 | argcheck_T arg1_string_list[] = {arg_list_string}; |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 449 | argcheck_T arg1_float_or_nr[] = {arg_float_or_nr}; |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 450 | argcheck_T arg1_string_or_nr[] = {arg_string_or_nr}; |
| 451 | argcheck_T arg1_string_or_list[] = {arg_string_or_list}; |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 452 | argcheck_T arg2_float_or_nr[] = {arg_float_or_nr, arg_float_or_nr}; |
| 453 | argcheck_T arg2_number[] = {arg_number, arg_number}; |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 454 | argcheck_T arg2_string[] = {arg_string, arg_string}; |
| 455 | argcheck_T arg2_list_number[] = {arg_list_number, arg_list_number}; |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 456 | argcheck_T arg2_listblob_item[] = {arg_list_or_blob, arg_item_of_prev}; |
Bram Moolenaar | ca81f0e | 2021-06-20 14:41:01 +0200 | [diff] [blame] | 457 | argcheck_T arg2_execute[] = {arg_string_or_list, arg_string}; |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 458 | argcheck_T arg23_extend[] = {arg_list_or_dict, arg_same_as_prev, arg_extend3}; |
Bram Moolenaar | b0e6b51 | 2021-01-12 20:23:40 +0100 | [diff] [blame] | 459 | argcheck_T arg23_extendnew[] = {arg_list_or_dict, arg_same_struct_as_prev, arg_extend3}; |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 460 | argcheck_T arg3_string[] = {arg_string, arg_string, arg_string}; |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 461 | argcheck_T arg3_number[] = {arg_number, arg_number, arg_number}; |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 462 | argcheck_T arg3_string_nr_bool[] = {arg_string, arg_number, arg_bool}; |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 463 | argcheck_T arg3_insert[] = {arg_list_or_blob, arg_item_of_prev, arg_number}; |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 464 | |
| 465 | /* |
| 466 | * Functions that return the return type of a builtin function. |
Bram Moolenaar | a1224cb | 2020-10-22 12:31:49 +0200 | [diff] [blame] | 467 | * Note that "argtypes" is NULL if "argcount" is zero. |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 468 | */ |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 469 | static type_T * |
| 470 | ret_void(int argcount UNUSED, type_T **argtypes UNUSED) |
| 471 | { |
| 472 | return &t_void; |
| 473 | } |
| 474 | static type_T * |
| 475 | ret_any(int argcount UNUSED, type_T **argtypes UNUSED) |
| 476 | { |
| 477 | return &t_any; |
| 478 | } |
| 479 | static type_T * |
Bram Moolenaar | 403dc31 | 2020-10-17 19:29:51 +0200 | [diff] [blame] | 480 | ret_bool(int argcount UNUSED, type_T **argtypes UNUSED) |
| 481 | { |
| 482 | return &t_bool; |
| 483 | } |
| 484 | static type_T * |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 485 | ret_number_bool(int argcount UNUSED, type_T **argtypes UNUSED) |
| 486 | { |
| 487 | return &t_number_bool; |
| 488 | } |
| 489 | static type_T * |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 490 | ret_number(int argcount UNUSED, type_T **argtypes UNUSED) |
| 491 | { |
| 492 | return &t_number; |
| 493 | } |
| 494 | static type_T * |
| 495 | ret_float(int argcount UNUSED, type_T **argtypes UNUSED) |
| 496 | { |
| 497 | return &t_float; |
| 498 | } |
| 499 | static type_T * |
| 500 | ret_string(int argcount UNUSED, type_T **argtypes UNUSED) |
| 501 | { |
| 502 | return &t_string; |
| 503 | } |
Bram Moolenaar | e69f6d0 | 2020-04-01 22:11:01 +0200 | [diff] [blame] | 504 | static type_T * |
| 505 | ret_list_any(int argcount UNUSED, type_T **argtypes UNUSED) |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 506 | { |
| 507 | return &t_list_any; |
| 508 | } |
| 509 | static type_T * |
| 510 | ret_list_number(int argcount UNUSED, type_T **argtypes UNUSED) |
| 511 | { |
| 512 | return &t_list_number; |
| 513 | } |
| 514 | static type_T * |
| 515 | ret_list_string(int argcount UNUSED, type_T **argtypes UNUSED) |
| 516 | { |
| 517 | return &t_list_string; |
| 518 | } |
| 519 | static type_T * |
| 520 | ret_list_dict_any(int argcount UNUSED, type_T **argtypes UNUSED) |
| 521 | { |
| 522 | return &t_list_dict_any; |
| 523 | } |
| 524 | static type_T * |
| 525 | ret_dict_any(int argcount UNUSED, type_T **argtypes UNUSED) |
| 526 | { |
| 527 | return &t_dict_any; |
| 528 | } |
| 529 | static type_T * |
Bram Moolenaar | 64ed4d4 | 2021-01-12 21:22:31 +0100 | [diff] [blame] | 530 | ret_job_info(int argcount, type_T **argtypes UNUSED) |
| 531 | { |
| 532 | if (argcount == 0) |
| 533 | return &t_list_job; |
| 534 | return &t_dict_any; |
| 535 | } |
| 536 | static type_T * |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 537 | ret_dict_number(int argcount UNUSED, type_T **argtypes UNUSED) |
| 538 | { |
| 539 | return &t_dict_number; |
| 540 | } |
| 541 | static type_T * |
| 542 | ret_dict_string(int argcount UNUSED, type_T **argtypes UNUSED) |
| 543 | { |
| 544 | return &t_dict_string; |
| 545 | } |
| 546 | static type_T * |
| 547 | ret_blob(int argcount UNUSED, type_T **argtypes UNUSED) |
| 548 | { |
| 549 | return &t_blob; |
| 550 | } |
| 551 | static type_T * |
Bram Moolenaar | e69f6d0 | 2020-04-01 22:11:01 +0200 | [diff] [blame] | 552 | ret_func_any(int argcount UNUSED, type_T **argtypes UNUSED) |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 553 | { |
Bram Moolenaar | e69f6d0 | 2020-04-01 22:11:01 +0200 | [diff] [blame] | 554 | return &t_func_any; |
| 555 | } |
| 556 | static type_T * |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 557 | ret_channel(int argcount UNUSED, type_T **argtypes UNUSED) |
| 558 | { |
| 559 | return &t_channel; |
| 560 | } |
| 561 | static type_T * |
| 562 | ret_job(int argcount UNUSED, type_T **argtypes UNUSED) |
| 563 | { |
| 564 | return &t_job; |
| 565 | } |
Bram Moolenaar | 865af6b | 2020-06-18 18:45:49 +0200 | [diff] [blame] | 566 | static type_T * |
| 567 | ret_first_arg(int argcount, type_T **argtypes) |
| 568 | { |
| 569 | if (argcount > 0) |
| 570 | return argtypes[0]; |
| 571 | return &t_void; |
| 572 | } |
Bram Moolenaar | ea69685 | 2020-11-09 18:31:39 +0100 | [diff] [blame] | 573 | // for map(): returns first argument but item type may differ |
| 574 | static type_T * |
| 575 | ret_first_cont(int argcount UNUSED, type_T **argtypes) |
| 576 | { |
| 577 | if (argtypes[0]->tt_type == VAR_LIST) |
| 578 | return &t_list_any; |
| 579 | if (argtypes[0]->tt_type == VAR_DICT) |
| 580 | return &t_dict_any; |
| 581 | if (argtypes[0]->tt_type == VAR_BLOB) |
| 582 | return argtypes[0]; |
| 583 | return &t_any; |
| 584 | } |
Bram Moolenaar | 865af6b | 2020-06-18 18:45:49 +0200 | [diff] [blame] | 585 | |
Bram Moolenaar | f151ad1 | 2020-06-30 13:38:01 +0200 | [diff] [blame] | 586 | /* |
| 587 | * Used for getqflist(): returns list if there is no argument, dict if there is |
| 588 | * one. |
| 589 | */ |
| 590 | static type_T * |
| 591 | ret_list_or_dict_0(int argcount, type_T **argtypes UNUSED) |
| 592 | { |
| 593 | if (argcount > 0) |
| 594 | return &t_dict_any; |
| 595 | return &t_list_dict_any; |
| 596 | } |
| 597 | |
| 598 | /* |
| 599 | * Used for getloclist(): returns list if there is one argument, dict if there |
| 600 | * are two. |
| 601 | */ |
| 602 | static type_T * |
| 603 | ret_list_or_dict_1(int argcount, type_T **argtypes UNUSED) |
| 604 | { |
| 605 | if (argcount > 1) |
| 606 | return &t_dict_any; |
| 607 | return &t_list_dict_any; |
| 608 | } |
| 609 | |
Bram Moolenaar | 846178a | 2020-07-05 17:04:13 +0200 | [diff] [blame] | 610 | static type_T * |
| 611 | ret_argv(int argcount, type_T **argtypes UNUSED) |
| 612 | { |
| 613 | // argv() returns list of strings |
| 614 | if (argcount == 0) |
| 615 | return &t_list_string; |
| 616 | |
| 617 | // argv(0) returns a string, but argv(-1] returns a list |
| 618 | return &t_any; |
| 619 | } |
| 620 | |
Bram Moolenaar | ad7c249 | 2020-07-05 20:55:29 +0200 | [diff] [blame] | 621 | static type_T * |
| 622 | ret_remove(int argcount UNUSED, type_T **argtypes) |
| 623 | { |
Bram Moolenaar | 5e65423 | 2020-09-16 15:22:00 +0200 | [diff] [blame] | 624 | if (argtypes != NULL) |
| 625 | { |
| 626 | if (argtypes[0]->tt_type == VAR_LIST |
| 627 | || argtypes[0]->tt_type == VAR_DICT) |
| 628 | return argtypes[0]->tt_member; |
| 629 | if (argtypes[0]->tt_type == VAR_BLOB) |
| 630 | return &t_number; |
| 631 | } |
Bram Moolenaar | ad7c249 | 2020-07-05 20:55:29 +0200 | [diff] [blame] | 632 | return &t_any; |
| 633 | } |
| 634 | |
Bram Moolenaar | 3d945cc | 2020-08-06 21:26:59 +0200 | [diff] [blame] | 635 | static type_T * |
| 636 | ret_getreg(int argcount, type_T **argtypes UNUSED) |
| 637 | { |
| 638 | // Assume that if the third argument is passed it's non-zero |
| 639 | if (argcount == 3) |
| 640 | return &t_list_string; |
| 641 | return &t_string; |
| 642 | } |
| 643 | |
Bram Moolenaar | 4a6d1b6 | 2020-08-08 17:55:49 +0200 | [diff] [blame] | 644 | static type_T * |
| 645 | ret_maparg(int argcount, type_T **argtypes UNUSED) |
| 646 | { |
| 647 | // Assume that if the fourth argument is passed it's non-zero |
| 648 | if (argcount == 4) |
| 649 | return &t_dict_any; |
| 650 | return &t_string; |
| 651 | } |
| 652 | |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 653 | static type_T *ret_f_function(int argcount, type_T **argtypes); |
| 654 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 655 | /* |
| 656 | * Array with names and number of arguments of all internal functions |
| 657 | * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH! |
| 658 | */ |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 659 | typedef struct |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 660 | { |
Bram Moolenaar | 25e4223 | 2019-08-04 15:04:10 +0200 | [diff] [blame] | 661 | char *f_name; // function name |
| 662 | char f_min_argc; // minimal number of arguments |
| 663 | char f_max_argc; // maximal number of arguments |
| 664 | char f_argtype; // for method: FEARG_ values |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 665 | argcheck_T *f_argcheck; // list of functions to check argument types |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 666 | type_T *(*f_retfunc)(int argcount, type_T **argtypes); |
| 667 | // return type function |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 668 | void (*f_func)(typval_T *args, typval_T *rvar); |
Bram Moolenaar | 25e4223 | 2019-08-04 15:04:10 +0200 | [diff] [blame] | 669 | // implementation of function |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 670 | } funcentry_T; |
| 671 | |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 672 | // values for f_argtype; zero means it cannot be used as a method |
| 673 | #define FEARG_1 1 // base is the first argument |
| 674 | #define FEARG_2 2 // base is the second argument |
Bram Moolenaar | 24278d2 | 2019-08-16 21:49:22 +0200 | [diff] [blame] | 675 | #define FEARG_3 3 // base is the third argument |
Bram Moolenaar | aad222c | 2019-09-06 22:46:09 +0200 | [diff] [blame] | 676 | #define FEARG_4 4 // base is the fourth argument |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 677 | #define FEARG_LAST 9 // base is the last argument |
| 678 | |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 679 | #ifdef FEAT_FLOAT |
| 680 | # define FLOAT_FUNC(name) name |
| 681 | #else |
| 682 | # define FLOAT_FUNC(name) NULL |
| 683 | #endif |
| 684 | #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H) |
| 685 | # define MATH_FUNC(name) name |
| 686 | #else |
| 687 | # define MATH_FUNC(name) NULL |
| 688 | #endif |
| 689 | #ifdef FEAT_TIMERS |
| 690 | # define TIMER_FUNC(name) name |
| 691 | #else |
| 692 | # define TIMER_FUNC(name) NULL |
| 693 | #endif |
| 694 | #ifdef FEAT_JOB_CHANNEL |
| 695 | # define JOB_FUNC(name) name |
| 696 | #else |
| 697 | # define JOB_FUNC(name) NULL |
| 698 | #endif |
| 699 | #ifdef FEAT_PROP_POPUP |
| 700 | # define PROP_FUNC(name) name |
| 701 | #else |
| 702 | # define PROP_FUNC(name) NULL |
| 703 | #endif |
| 704 | #ifdef FEAT_SIGNS |
| 705 | # define SIGN_FUNC(name) name |
| 706 | #else |
| 707 | # define SIGN_FUNC(name) NULL |
| 708 | #endif |
| 709 | #ifdef FEAT_SOUND |
| 710 | # define SOUND_FUNC(name) name |
| 711 | #else |
| 712 | # define SOUND_FUNC(name) NULL |
| 713 | #endif |
| 714 | #ifdef FEAT_TERMINAL |
| 715 | # define TERM_FUNC(name) name |
| 716 | #else |
| 717 | # define TERM_FUNC(name) NULL |
| 718 | #endif |
| 719 | |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 720 | static funcentry_T global_functions[] = |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 721 | { |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 722 | {"abs", 1, 1, FEARG_1, arg1_float_or_nr, |
| 723 | ret_any, FLOAT_FUNC(f_abs)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 724 | {"acos", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 725 | ret_float, FLOAT_FUNC(f_acos)}, |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 726 | {"add", 2, 2, FEARG_1, NULL /* arg2_listblob_item */, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 727 | ret_first_arg, f_add}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 728 | {"and", 2, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 729 | ret_number, f_and}, |
| 730 | {"append", 2, 2, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 731 | ret_number_bool, f_append}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 732 | {"appendbufline", 3, 3, FEARG_3, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 733 | ret_number_bool, f_appendbufline}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 734 | {"argc", 0, 1, 0, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 735 | ret_number, f_argc}, |
| 736 | {"argidx", 0, 0, 0, NULL, |
| 737 | ret_number, f_argidx}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 738 | {"arglistid", 0, 2, 0, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 739 | ret_number, f_arglistid}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 740 | {"argv", 0, 2, 0, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 741 | ret_argv, f_argv}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 742 | {"asin", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 743 | ret_float, FLOAT_FUNC(f_asin)}, |
| 744 | {"assert_beeps", 1, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 745 | ret_number_bool, f_assert_beeps}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 746 | {"assert_equal", 2, 3, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 747 | ret_number_bool, f_assert_equal}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 748 | {"assert_equalfile", 2, 3, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 749 | ret_number_bool, f_assert_equalfile}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 750 | {"assert_exception", 1, 2, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 751 | ret_number_bool, f_assert_exception}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 752 | {"assert_fails", 1, 5, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 753 | ret_number_bool, f_assert_fails}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 754 | {"assert_false", 1, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 755 | ret_number_bool, f_assert_false}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 756 | {"assert_inrange", 3, 4, FEARG_3, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 757 | ret_number_bool, f_assert_inrange}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 758 | {"assert_match", 2, 3, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 759 | ret_number_bool, f_assert_match}, |
Bram Moolenaar | 5b8cabf | 2021-04-02 18:55:57 +0200 | [diff] [blame] | 760 | {"assert_nobeep", 1, 2, FEARG_1, NULL, |
| 761 | ret_number_bool, f_assert_nobeep}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 762 | {"assert_notequal", 2, 3, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 763 | ret_number_bool, f_assert_notequal}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 764 | {"assert_notmatch", 2, 3, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 765 | ret_number_bool, f_assert_notmatch}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 766 | {"assert_report", 1, 1, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 767 | ret_number_bool, f_assert_report}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 768 | {"assert_true", 1, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 769 | ret_number_bool, f_assert_true}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 770 | {"atan", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 771 | ret_float, FLOAT_FUNC(f_atan)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 772 | {"atan2", 2, 2, FEARG_1, arg2_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 773 | ret_float, FLOAT_FUNC(f_atan2)}, |
| 774 | {"balloon_gettext", 0, 0, 0, NULL, |
| 775 | ret_string, |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 776 | #ifdef FEAT_BEVAL |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 777 | f_balloon_gettext |
| 778 | #else |
| 779 | NULL |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 780 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 781 | }, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 782 | {"balloon_show", 1, 1, FEARG_1, arg1_string_or_list, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 783 | ret_void, |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 784 | #ifdef FEAT_BEVAL |
| 785 | f_balloon_show |
| 786 | #else |
| 787 | NULL |
| 788 | #endif |
| 789 | }, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 790 | {"balloon_split", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 791 | ret_list_string, |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 792 | #if defined(FEAT_BEVAL_TERM) |
| 793 | f_balloon_split |
| 794 | #else |
| 795 | NULL |
| 796 | #endif |
| 797 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 798 | {"browse", 4, 4, 0, NULL, |
| 799 | ret_string, f_browse}, |
| 800 | {"browsedir", 2, 2, 0, NULL, |
| 801 | ret_string, f_browsedir}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 802 | {"bufadd", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 803 | ret_number, f_bufadd}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 804 | {"bufexists", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 805 | ret_number_bool, f_bufexists}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 806 | {"buffer_exists", 1, 1, FEARG_1, arg1_string_or_nr, // obsolete |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 807 | ret_number_bool, f_bufexists}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 808 | {"buffer_name", 0, 1, FEARG_1, arg1_string_or_nr, // obsolete |
Bram Moolenaar | b8f519e | 2020-10-21 14:49:08 +0200 | [diff] [blame] | 809 | ret_string, f_bufname}, |
| 810 | {"buffer_number", 0, 1, FEARG_1, NULL, // obsolete |
| 811 | ret_number, f_bufnr}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 812 | {"buflisted", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 813 | ret_number_bool, f_buflisted}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 814 | {"bufload", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 815 | ret_void, f_bufload}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 816 | {"bufloaded", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 817 | ret_number_bool, f_bufloaded}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 818 | {"bufname", 0, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 819 | ret_string, f_bufname}, |
| 820 | {"bufnr", 0, 2, FEARG_1, NULL, |
| 821 | ret_number, f_bufnr}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 822 | {"bufwinid", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 823 | ret_number, f_bufwinid}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 824 | {"bufwinnr", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 825 | ret_number, f_bufwinnr}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 826 | {"byte2line", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 827 | ret_number, f_byte2line}, |
| 828 | {"byteidx", 2, 2, FEARG_1, NULL, |
| 829 | ret_number, f_byteidx}, |
| 830 | {"byteidxcomp", 2, 2, FEARG_1, NULL, |
| 831 | ret_number, f_byteidxcomp}, |
| 832 | {"call", 2, 3, FEARG_1, NULL, |
| 833 | ret_any, f_call}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 834 | {"ceil", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 835 | ret_float, FLOAT_FUNC(f_ceil)}, |
| 836 | {"ch_canread", 1, 1, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 837 | ret_number_bool, JOB_FUNC(f_ch_canread)}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 838 | {"ch_close", 1, 1, FEARG_1, NULL, |
| 839 | ret_void, JOB_FUNC(f_ch_close)}, |
| 840 | {"ch_close_in", 1, 1, FEARG_1, NULL, |
| 841 | ret_void, JOB_FUNC(f_ch_close_in)}, |
| 842 | {"ch_evalexpr", 2, 3, FEARG_1, NULL, |
| 843 | ret_any, JOB_FUNC(f_ch_evalexpr)}, |
| 844 | {"ch_evalraw", 2, 3, FEARG_1, NULL, |
| 845 | ret_any, JOB_FUNC(f_ch_evalraw)}, |
| 846 | {"ch_getbufnr", 2, 2, FEARG_1, NULL, |
| 847 | ret_number, JOB_FUNC(f_ch_getbufnr)}, |
| 848 | {"ch_getjob", 1, 1, FEARG_1, NULL, |
| 849 | ret_job, JOB_FUNC(f_ch_getjob)}, |
| 850 | {"ch_info", 1, 1, FEARG_1, NULL, |
| 851 | ret_dict_any, JOB_FUNC(f_ch_info)}, |
| 852 | {"ch_log", 1, 2, FEARG_1, NULL, |
| 853 | ret_void, JOB_FUNC(f_ch_log)}, |
| 854 | {"ch_logfile", 1, 2, FEARG_1, NULL, |
| 855 | ret_void, JOB_FUNC(f_ch_logfile)}, |
| 856 | {"ch_open", 1, 2, FEARG_1, NULL, |
| 857 | ret_channel, JOB_FUNC(f_ch_open)}, |
| 858 | {"ch_read", 1, 2, FEARG_1, NULL, |
| 859 | ret_string, JOB_FUNC(f_ch_read)}, |
| 860 | {"ch_readblob", 1, 2, FEARG_1, NULL, |
| 861 | ret_blob, JOB_FUNC(f_ch_readblob)}, |
| 862 | {"ch_readraw", 1, 2, FEARG_1, NULL, |
| 863 | ret_string, JOB_FUNC(f_ch_readraw)}, |
| 864 | {"ch_sendexpr", 2, 3, FEARG_1, NULL, |
| 865 | ret_void, JOB_FUNC(f_ch_sendexpr)}, |
| 866 | {"ch_sendraw", 2, 3, FEARG_1, NULL, |
| 867 | ret_void, JOB_FUNC(f_ch_sendraw)}, |
| 868 | {"ch_setoptions", 2, 2, FEARG_1, NULL, |
| 869 | ret_void, JOB_FUNC(f_ch_setoptions)}, |
| 870 | {"ch_status", 1, 2, FEARG_1, NULL, |
| 871 | ret_string, JOB_FUNC(f_ch_status)}, |
| 872 | {"changenr", 0, 0, 0, NULL, |
| 873 | ret_number, f_changenr}, |
| 874 | {"char2nr", 1, 2, FEARG_1, NULL, |
| 875 | ret_number, f_char2nr}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 876 | {"charclass", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 877 | ret_number, f_charclass}, |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 878 | {"charcol", 1, 1, FEARG_1, NULL, |
| 879 | ret_number, f_charcol}, |
Bram Moolenaar | 17793ef | 2020-12-28 12:56:58 +0100 | [diff] [blame] | 880 | {"charidx", 2, 3, FEARG_1, NULL, |
| 881 | ret_number, f_charidx}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 882 | {"chdir", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 883 | ret_string, f_chdir}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 884 | {"cindent", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 885 | ret_number, f_cindent}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 886 | {"clearmatches", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 887 | ret_void, f_clearmatches}, |
| 888 | {"col", 1, 1, FEARG_1, NULL, |
| 889 | ret_number, f_col}, |
| 890 | {"complete", 2, 2, FEARG_2, NULL, |
| 891 | ret_void, f_complete}, |
| 892 | {"complete_add", 1, 1, FEARG_1, NULL, |
| 893 | ret_number, f_complete_add}, |
| 894 | {"complete_check", 0, 0, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 895 | ret_number_bool, f_complete_check}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 896 | {"complete_info", 0, 1, FEARG_1, arg1_string_list, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 897 | ret_dict_any, f_complete_info}, |
| 898 | {"confirm", 1, 4, FEARG_1, NULL, |
| 899 | ret_number, f_confirm}, |
| 900 | {"copy", 1, 1, FEARG_1, NULL, |
| 901 | ret_first_arg, f_copy}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 902 | {"cos", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 903 | ret_float, FLOAT_FUNC(f_cos)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 904 | {"cosh", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 905 | ret_float, FLOAT_FUNC(f_cosh)}, |
| 906 | {"count", 2, 4, FEARG_1, NULL, |
| 907 | ret_number, f_count}, |
| 908 | {"cscope_connection",0,3, 0, NULL, |
| 909 | ret_number, f_cscope_connection}, |
| 910 | {"cursor", 1, 3, FEARG_1, NULL, |
| 911 | ret_number, f_cursor}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 912 | {"debugbreak", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 913 | ret_number, |
Bram Moolenaar | 4f97475 | 2019-02-17 17:44:42 +0100 | [diff] [blame] | 914 | #ifdef MSWIN |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 915 | f_debugbreak |
| 916 | #else |
| 917 | NULL |
Bram Moolenaar | 4551c0a | 2018-06-20 22:38:21 +0200 | [diff] [blame] | 918 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 919 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 920 | {"deepcopy", 1, 2, FEARG_1, NULL, |
| 921 | ret_first_arg, f_deepcopy}, |
| 922 | {"delete", 1, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 923 | ret_number_bool, f_delete}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 924 | {"deletebufline", 2, 3, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 925 | ret_number_bool, f_deletebufline}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 926 | {"did_filetype", 0, 0, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 927 | ret_number_bool, f_did_filetype}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 928 | {"diff_filler", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 929 | ret_number, f_diff_filler}, |
| 930 | {"diff_hlID", 2, 2, FEARG_1, NULL, |
| 931 | ret_number, f_diff_hlID}, |
| 932 | {"echoraw", 1, 1, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 933 | ret_void, f_echoraw}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 934 | {"empty", 1, 1, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 935 | ret_number_bool, f_empty}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 936 | {"environ", 0, 0, 0, NULL, |
| 937 | ret_dict_string, f_environ}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 938 | {"escape", 2, 2, FEARG_1, arg2_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 939 | ret_string, f_escape}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 940 | {"eval", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 941 | ret_any, f_eval}, |
| 942 | {"eventhandler", 0, 0, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 943 | ret_number_bool, f_eventhandler}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 944 | {"executable", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 945 | ret_number, f_executable}, |
Bram Moolenaar | ca81f0e | 2021-06-20 14:41:01 +0200 | [diff] [blame] | 946 | {"execute", 1, 2, FEARG_1, arg2_execute, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 947 | ret_string, f_execute}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 948 | {"exepath", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 949 | ret_string, f_exepath}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 950 | {"exists", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 951 | ret_number_bool, f_exists}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 952 | {"exp", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 953 | ret_float, FLOAT_FUNC(f_exp)}, |
| 954 | {"expand", 1, 3, FEARG_1, NULL, |
| 955 | ret_any, f_expand}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 956 | {"expandcmd", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 957 | ret_string, f_expandcmd}, |
Bram Moolenaar | fbcbffe | 2020-10-31 19:33:38 +0100 | [diff] [blame] | 958 | {"extend", 2, 3, FEARG_1, arg23_extend, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 959 | ret_first_arg, f_extend}, |
Bram Moolenaar | b0e6b51 | 2021-01-12 20:23:40 +0100 | [diff] [blame] | 960 | {"extendnew", 2, 3, FEARG_1, arg23_extendnew, |
| 961 | ret_first_cont, f_extendnew}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 962 | {"feedkeys", 1, 2, FEARG_1, arg2_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 963 | ret_void, f_feedkeys}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 964 | {"file_readable", 1, 1, FEARG_1, arg1_string, // obsolete |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 965 | ret_number_bool, f_filereadable}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 966 | {"filereadable", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 967 | ret_number_bool, f_filereadable}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 968 | {"filewritable", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 969 | ret_number, f_filewritable}, |
| 970 | {"filter", 2, 2, FEARG_1, NULL, |
| 971 | ret_first_arg, f_filter}, |
| 972 | {"finddir", 1, 3, FEARG_1, NULL, |
| 973 | ret_string, f_finddir}, |
| 974 | {"findfile", 1, 3, FEARG_1, NULL, |
| 975 | ret_string, f_findfile}, |
| 976 | {"flatten", 1, 2, FEARG_1, NULL, |
| 977 | ret_list_any, f_flatten}, |
Bram Moolenaar | 3b69006 | 2021-02-01 20:14:51 +0100 | [diff] [blame] | 978 | {"flattennew", 1, 2, FEARG_1, NULL, |
| 979 | ret_list_any, f_flattennew}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 980 | {"float2nr", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 981 | ret_number, FLOAT_FUNC(f_float2nr)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 982 | {"floor", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 983 | ret_float, FLOAT_FUNC(f_floor)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 984 | {"fmod", 2, 2, FEARG_1, arg2_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 985 | ret_float, FLOAT_FUNC(f_fmod)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 986 | {"fnameescape", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 987 | ret_string, f_fnameescape}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 988 | {"fnamemodify", 2, 2, FEARG_1, arg2_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 989 | ret_string, f_fnamemodify}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 990 | {"foldclosed", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 991 | ret_number, f_foldclosed}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 992 | {"foldclosedend", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 993 | ret_number, f_foldclosedend}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 994 | {"foldlevel", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 995 | ret_number, f_foldlevel}, |
| 996 | {"foldtext", 0, 0, 0, NULL, |
| 997 | ret_string, f_foldtext}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 998 | {"foldtextresult", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 999 | ret_string, f_foldtextresult}, |
| 1000 | {"foreground", 0, 0, 0, NULL, |
| 1001 | ret_void, f_foreground}, |
Bram Moolenaar | 038e09e | 2021-02-06 12:38:51 +0100 | [diff] [blame] | 1002 | {"fullcommand", 1, 1, FEARG_1, arg1_string, |
| 1003 | ret_string, f_fullcommand}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1004 | {"funcref", 1, 3, FEARG_1, NULL, |
| 1005 | ret_func_any, f_funcref}, |
| 1006 | {"function", 1, 3, FEARG_1, NULL, |
| 1007 | ret_f_function, f_function}, |
| 1008 | {"garbagecollect", 0, 1, 0, NULL, |
| 1009 | ret_void, f_garbagecollect}, |
| 1010 | {"get", 2, 3, FEARG_1, NULL, |
| 1011 | ret_any, f_get}, |
| 1012 | {"getbufinfo", 0, 1, FEARG_1, NULL, |
| 1013 | ret_list_dict_any, f_getbufinfo}, |
| 1014 | {"getbufline", 2, 3, FEARG_1, NULL, |
| 1015 | ret_list_string, f_getbufline}, |
| 1016 | {"getbufvar", 2, 3, FEARG_1, NULL, |
| 1017 | ret_any, f_getbufvar}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1018 | {"getchangelist", 0, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1019 | ret_list_any, f_getchangelist}, |
| 1020 | {"getchar", 0, 1, 0, NULL, |
Bram Moolenaar | 3a7503c | 2021-06-07 18:29:17 +0200 | [diff] [blame] | 1021 | ret_any, f_getchar}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1022 | {"getcharmod", 0, 0, 0, NULL, |
| 1023 | ret_number, f_getcharmod}, |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 1024 | {"getcharpos", 1, 1, FEARG_1, NULL, |
| 1025 | ret_list_number, f_getcharpos}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1026 | {"getcharsearch", 0, 0, 0, NULL, |
| 1027 | ret_dict_any, f_getcharsearch}, |
Bram Moolenaar | 3a7503c | 2021-06-07 18:29:17 +0200 | [diff] [blame] | 1028 | {"getcharstr", 0, 1, 0, NULL, |
| 1029 | ret_string, f_getcharstr}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1030 | {"getcmdline", 0, 0, 0, NULL, |
| 1031 | ret_string, f_getcmdline}, |
| 1032 | {"getcmdpos", 0, 0, 0, NULL, |
| 1033 | ret_number, f_getcmdpos}, |
| 1034 | {"getcmdtype", 0, 0, 0, NULL, |
| 1035 | ret_string, f_getcmdtype}, |
| 1036 | {"getcmdwintype", 0, 0, 0, NULL, |
| 1037 | ret_string, f_getcmdwintype}, |
| 1038 | {"getcompletion", 2, 3, FEARG_1, NULL, |
| 1039 | ret_list_string, f_getcompletion}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1040 | {"getcurpos", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1041 | ret_list_number, f_getcurpos}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1042 | {"getcursorcharpos", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 1043 | ret_list_number, f_getcursorcharpos}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1044 | {"getcwd", 0, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1045 | ret_string, f_getcwd}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1046 | {"getenv", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 7ad67d1 | 2021-03-10 16:08:26 +0100 | [diff] [blame] | 1047 | ret_any, f_getenv}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1048 | {"getfontname", 0, 1, 0, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1049 | ret_string, f_getfontname}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1050 | {"getfperm", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1051 | ret_string, f_getfperm}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1052 | {"getfsize", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1053 | ret_number, f_getfsize}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1054 | {"getftime", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1055 | ret_number, f_getftime}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1056 | {"getftype", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1057 | ret_string, f_getftype}, |
| 1058 | {"getimstatus", 0, 0, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1059 | ret_number_bool, f_getimstatus}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1060 | {"getjumplist", 0, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1061 | ret_list_any, f_getjumplist}, |
| 1062 | {"getline", 1, 2, FEARG_1, NULL, |
| 1063 | ret_f_getline, f_getline}, |
| 1064 | {"getloclist", 1, 2, 0, NULL, |
| 1065 | ret_list_or_dict_1, f_getloclist}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1066 | {"getmarklist", 0, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1067 | ret_list_dict_any, f_getmarklist}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1068 | {"getmatches", 0, 1, 0, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1069 | ret_list_dict_any, f_getmatches}, |
| 1070 | {"getmousepos", 0, 0, 0, NULL, |
| 1071 | ret_dict_number, f_getmousepos}, |
| 1072 | {"getpid", 0, 0, 0, NULL, |
| 1073 | ret_number, f_getpid}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1074 | {"getpos", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1075 | ret_list_number, f_getpos}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1076 | {"getqflist", 0, 1, 0, arg1_dict, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1077 | ret_list_or_dict_0, f_getqflist}, |
| 1078 | {"getreg", 0, 3, FEARG_1, NULL, |
| 1079 | ret_getreg, f_getreg}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1080 | {"getreginfo", 0, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1081 | ret_dict_any, f_getreginfo}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1082 | {"getregtype", 0, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1083 | ret_string, f_getregtype}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1084 | {"gettabinfo", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1085 | ret_list_dict_any, f_gettabinfo}, |
| 1086 | {"gettabvar", 2, 3, FEARG_1, NULL, |
| 1087 | ret_any, f_gettabvar}, |
| 1088 | {"gettabwinvar", 3, 4, FEARG_1, NULL, |
| 1089 | ret_any, f_gettabwinvar}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1090 | {"gettagstack", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1091 | ret_dict_any, f_gettagstack}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1092 | {"gettext", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1093 | ret_string, f_gettext}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1094 | {"getwininfo", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1095 | ret_list_dict_any, f_getwininfo}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1096 | {"getwinpos", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1097 | ret_list_number, f_getwinpos}, |
| 1098 | {"getwinposx", 0, 0, 0, NULL, |
| 1099 | ret_number, f_getwinposx}, |
| 1100 | {"getwinposy", 0, 0, 0, NULL, |
| 1101 | ret_number, f_getwinposy}, |
| 1102 | {"getwinvar", 2, 3, FEARG_1, NULL, |
| 1103 | ret_any, f_getwinvar}, |
| 1104 | {"glob", 1, 4, FEARG_1, NULL, |
| 1105 | ret_any, f_glob}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1106 | {"glob2regpat", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1107 | ret_string, f_glob2regpat}, |
| 1108 | {"globpath", 2, 5, FEARG_2, NULL, |
| 1109 | ret_any, f_globpath}, |
| 1110 | {"has", 1, 2, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1111 | ret_number_bool, f_has}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1112 | {"has_key", 2, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1113 | ret_number_bool, f_has_key}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1114 | {"haslocaldir", 0, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1115 | ret_number, f_haslocaldir}, |
| 1116 | {"hasmapto", 1, 3, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1117 | ret_number_bool, f_hasmapto}, |
Bram Moolenaar | b8f519e | 2020-10-21 14:49:08 +0200 | [diff] [blame] | 1118 | {"highlightID", 1, 1, FEARG_1, NULL, // obsolete |
| 1119 | ret_number, f_hlID}, |
| 1120 | {"highlight_exists",1, 1, FEARG_1, NULL, // obsolete |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1121 | ret_number_bool, f_hlexists}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1122 | {"histadd", 2, 2, FEARG_2, arg2_string, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1123 | ret_number_bool, f_histadd}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1124 | {"histdel", 1, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1125 | ret_number_bool, f_histdel}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1126 | {"histget", 1, 2, FEARG_1, NULL, |
| 1127 | ret_string, f_histget}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1128 | {"histnr", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1129 | ret_number, f_histnr}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1130 | {"hlID", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1131 | ret_number, f_hlID}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1132 | {"hlexists", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1133 | ret_number_bool, f_hlexists}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1134 | {"hostname", 0, 0, 0, NULL, |
| 1135 | ret_string, f_hostname}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1136 | {"iconv", 3, 3, FEARG_1, arg3_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1137 | ret_string, f_iconv}, |
| 1138 | {"indent", 1, 1, FEARG_1, NULL, |
| 1139 | ret_number, f_indent}, |
| 1140 | {"index", 2, 4, FEARG_1, NULL, |
| 1141 | ret_number, f_index}, |
| 1142 | {"input", 1, 3, FEARG_1, NULL, |
| 1143 | ret_string, f_input}, |
| 1144 | {"inputdialog", 1, 3, FEARG_1, NULL, |
| 1145 | ret_string, f_inputdialog}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1146 | {"inputlist", 1, 1, FEARG_1, arg1_string_list, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1147 | ret_number, f_inputlist}, |
| 1148 | {"inputrestore", 0, 0, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1149 | ret_number_bool, f_inputrestore}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1150 | {"inputsave", 0, 0, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1151 | ret_number_bool, f_inputsave}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1152 | {"inputsecret", 1, 2, FEARG_1, arg2_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1153 | ret_string, f_inputsecret}, |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 1154 | {"insert", 2, 3, FEARG_1, arg3_insert, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1155 | ret_first_arg, f_insert}, |
| 1156 | {"interrupt", 0, 0, 0, NULL, |
| 1157 | ret_void, f_interrupt}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1158 | {"invert", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1159 | ret_number, f_invert}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1160 | {"isdirectory", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1161 | ret_number_bool, f_isdirectory}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1162 | {"isinf", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1163 | ret_number, MATH_FUNC(f_isinf)}, |
| 1164 | {"islocked", 1, 1, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1165 | ret_number_bool, f_islocked}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1166 | {"isnan", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1167 | ret_number_bool, MATH_FUNC(f_isnan)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1168 | {"items", 1, 1, FEARG_1, arg1_dict, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1169 | ret_list_any, f_items}, |
| 1170 | {"job_getchannel", 1, 1, FEARG_1, NULL, |
| 1171 | ret_channel, JOB_FUNC(f_job_getchannel)}, |
| 1172 | {"job_info", 0, 1, FEARG_1, NULL, |
Bram Moolenaar | 64ed4d4 | 2021-01-12 21:22:31 +0100 | [diff] [blame] | 1173 | ret_job_info, JOB_FUNC(f_job_info)}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1174 | {"job_setoptions", 2, 2, FEARG_1, NULL, |
| 1175 | ret_void, JOB_FUNC(f_job_setoptions)}, |
| 1176 | {"job_start", 1, 2, FEARG_1, NULL, |
| 1177 | ret_job, JOB_FUNC(f_job_start)}, |
| 1178 | {"job_status", 1, 1, FEARG_1, NULL, |
| 1179 | ret_string, JOB_FUNC(f_job_status)}, |
| 1180 | {"job_stop", 1, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1181 | ret_number_bool, JOB_FUNC(f_job_stop)}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1182 | {"join", 1, 2, FEARG_1, NULL, |
| 1183 | ret_string, f_join}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1184 | {"js_decode", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1185 | ret_any, f_js_decode}, |
| 1186 | {"js_encode", 1, 1, FEARG_1, NULL, |
| 1187 | ret_string, f_js_encode}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1188 | {"json_decode", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1189 | ret_any, f_json_decode}, |
| 1190 | {"json_encode", 1, 1, FEARG_1, NULL, |
| 1191 | ret_string, f_json_encode}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1192 | {"keys", 1, 1, FEARG_1, arg1_dict, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1193 | ret_list_string, f_keys}, |
Bram Moolenaar | b8f519e | 2020-10-21 14:49:08 +0200 | [diff] [blame] | 1194 | {"last_buffer_nr", 0, 0, 0, NULL, // obsolete |
| 1195 | ret_number, f_last_buffer_nr}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1196 | {"len", 1, 1, FEARG_1, NULL, |
| 1197 | ret_number, f_len}, |
| 1198 | {"libcall", 3, 3, FEARG_3, NULL, |
| 1199 | ret_string, f_libcall}, |
| 1200 | {"libcallnr", 3, 3, FEARG_3, NULL, |
| 1201 | ret_number, f_libcallnr}, |
| 1202 | {"line", 1, 2, FEARG_1, NULL, |
| 1203 | ret_number, f_line}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1204 | {"line2byte", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1205 | ret_number, f_line2byte}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1206 | {"lispindent", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1207 | ret_number, f_lispindent}, |
| 1208 | {"list2str", 1, 2, FEARG_1, NULL, |
| 1209 | ret_string, f_list2str}, |
| 1210 | {"listener_add", 1, 2, FEARG_2, NULL, |
| 1211 | ret_number, f_listener_add}, |
| 1212 | {"listener_flush", 0, 1, FEARG_1, NULL, |
| 1213 | ret_void, f_listener_flush}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1214 | {"listener_remove", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1215 | ret_number_bool, f_listener_remove}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1216 | {"localtime", 0, 0, 0, NULL, |
| 1217 | ret_number, f_localtime}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1218 | {"log", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1219 | ret_float, FLOAT_FUNC(f_log)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1220 | {"log10", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1221 | ret_float, FLOAT_FUNC(f_log10)}, |
| 1222 | {"luaeval", 1, 2, FEARG_1, NULL, |
| 1223 | ret_any, |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1224 | #ifdef FEAT_LUA |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1225 | f_luaeval |
| 1226 | #else |
| 1227 | NULL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1228 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1229 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1230 | {"map", 2, 2, FEARG_1, NULL, |
Bram Moolenaar | ea69685 | 2020-11-09 18:31:39 +0100 | [diff] [blame] | 1231 | ret_first_cont, f_map}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1232 | {"maparg", 1, 4, FEARG_1, NULL, |
| 1233 | ret_maparg, f_maparg}, |
| 1234 | {"mapcheck", 1, 3, FEARG_1, NULL, |
| 1235 | ret_string, f_mapcheck}, |
Bram Moolenaar | ea69685 | 2020-11-09 18:31:39 +0100 | [diff] [blame] | 1236 | {"mapnew", 2, 2, FEARG_1, NULL, |
| 1237 | ret_first_cont, f_mapnew}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1238 | {"mapset", 3, 3, FEARG_1, NULL, |
| 1239 | ret_void, f_mapset}, |
| 1240 | {"match", 2, 4, FEARG_1, NULL, |
| 1241 | ret_any, f_match}, |
| 1242 | {"matchadd", 2, 5, FEARG_1, NULL, |
| 1243 | ret_number, f_matchadd}, |
| 1244 | {"matchaddpos", 2, 5, FEARG_1, NULL, |
| 1245 | ret_number, f_matchaddpos}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1246 | {"matcharg", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1247 | ret_list_string, f_matcharg}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1248 | {"matchdelete", 1, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1249 | ret_number_bool, f_matchdelete}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1250 | {"matchend", 2, 4, FEARG_1, NULL, |
| 1251 | ret_number, f_matchend}, |
| 1252 | {"matchfuzzy", 2, 3, FEARG_1, NULL, |
| 1253 | ret_list_string, f_matchfuzzy}, |
| 1254 | {"matchfuzzypos", 2, 3, FEARG_1, NULL, |
| 1255 | ret_list_any, f_matchfuzzypos}, |
| 1256 | {"matchlist", 2, 4, FEARG_1, NULL, |
| 1257 | ret_list_string, f_matchlist}, |
| 1258 | {"matchstr", 2, 4, FEARG_1, NULL, |
| 1259 | ret_string, f_matchstr}, |
| 1260 | {"matchstrpos", 2, 4, FEARG_1, NULL, |
| 1261 | ret_list_any, f_matchstrpos}, |
| 1262 | {"max", 1, 1, FEARG_1, NULL, |
Bram Moolenaar | 9ae3705 | 2021-01-22 22:31:10 +0100 | [diff] [blame] | 1263 | ret_number, f_max}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1264 | {"menu_info", 1, 2, FEARG_1, arg2_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1265 | ret_dict_any, |
Bram Moolenaar | a2cbdea | 2020-03-16 21:08:31 +0100 | [diff] [blame] | 1266 | #ifdef FEAT_MENU |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1267 | f_menu_info |
| 1268 | #else |
| 1269 | NULL |
Bram Moolenaar | a2cbdea | 2020-03-16 21:08:31 +0100 | [diff] [blame] | 1270 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1271 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1272 | {"min", 1, 1, FEARG_1, NULL, |
Bram Moolenaar | 9ae3705 | 2021-01-22 22:31:10 +0100 | [diff] [blame] | 1273 | ret_number, f_min}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1274 | {"mkdir", 1, 3, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1275 | ret_number_bool, f_mkdir}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1276 | {"mode", 0, 1, FEARG_1, NULL, |
| 1277 | ret_string, f_mode}, |
| 1278 | {"mzeval", 1, 1, FEARG_1, NULL, |
| 1279 | ret_any, |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1280 | #ifdef FEAT_MZSCHEME |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1281 | f_mzeval |
| 1282 | #else |
| 1283 | NULL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1284 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1285 | }, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1286 | {"nextnonblank", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1287 | ret_number, f_nextnonblank}, |
| 1288 | {"nr2char", 1, 2, FEARG_1, NULL, |
| 1289 | ret_string, f_nr2char}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1290 | {"or", 2, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1291 | ret_number, f_or}, |
| 1292 | {"pathshorten", 1, 2, FEARG_1, NULL, |
| 1293 | ret_string, f_pathshorten}, |
| 1294 | {"perleval", 1, 1, FEARG_1, NULL, |
| 1295 | ret_any, |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1296 | #ifdef FEAT_PERL |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1297 | f_perleval |
| 1298 | #else |
| 1299 | NULL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1300 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1301 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1302 | {"popup_atcursor", 2, 2, FEARG_1, NULL, |
| 1303 | ret_number, PROP_FUNC(f_popup_atcursor)}, |
| 1304 | {"popup_beval", 2, 2, FEARG_1, NULL, |
| 1305 | ret_number, PROP_FUNC(f_popup_beval)}, |
| 1306 | {"popup_clear", 0, 1, 0, NULL, |
| 1307 | ret_void, PROP_FUNC(f_popup_clear)}, |
| 1308 | {"popup_close", 1, 2, FEARG_1, NULL, |
| 1309 | ret_void, PROP_FUNC(f_popup_close)}, |
| 1310 | {"popup_create", 2, 2, FEARG_1, NULL, |
| 1311 | ret_number, PROP_FUNC(f_popup_create)}, |
| 1312 | {"popup_dialog", 2, 2, FEARG_1, NULL, |
| 1313 | ret_number, PROP_FUNC(f_popup_dialog)}, |
| 1314 | {"popup_filter_menu", 2, 2, 0, NULL, |
| 1315 | ret_bool, PROP_FUNC(f_popup_filter_menu)}, |
| 1316 | {"popup_filter_yesno", 2, 2, 0, NULL, |
| 1317 | ret_bool, PROP_FUNC(f_popup_filter_yesno)}, |
| 1318 | {"popup_findinfo", 0, 0, 0, NULL, |
| 1319 | ret_number, PROP_FUNC(f_popup_findinfo)}, |
| 1320 | {"popup_findpreview", 0, 0, 0, NULL, |
| 1321 | ret_number, PROP_FUNC(f_popup_findpreview)}, |
| 1322 | {"popup_getoptions", 1, 1, FEARG_1, NULL, |
| 1323 | ret_dict_any, PROP_FUNC(f_popup_getoptions)}, |
| 1324 | {"popup_getpos", 1, 1, FEARG_1, NULL, |
| 1325 | ret_dict_any, PROP_FUNC(f_popup_getpos)}, |
| 1326 | {"popup_hide", 1, 1, FEARG_1, NULL, |
| 1327 | ret_void, PROP_FUNC(f_popup_hide)}, |
| 1328 | {"popup_list", 0, 0, 0, NULL, |
| 1329 | ret_list_number, PROP_FUNC(f_popup_list)}, |
| 1330 | {"popup_locate", 2, 2, 0, NULL, |
| 1331 | ret_number, PROP_FUNC(f_popup_locate)}, |
| 1332 | {"popup_menu", 2, 2, FEARG_1, NULL, |
| 1333 | ret_number, PROP_FUNC(f_popup_menu)}, |
| 1334 | {"popup_move", 2, 2, FEARG_1, NULL, |
| 1335 | ret_void, PROP_FUNC(f_popup_move)}, |
| 1336 | {"popup_notification", 2, 2, FEARG_1, NULL, |
| 1337 | ret_number, PROP_FUNC(f_popup_notification)}, |
| 1338 | {"popup_setoptions", 2, 2, FEARG_1, NULL, |
| 1339 | ret_void, PROP_FUNC(f_popup_setoptions)}, |
| 1340 | {"popup_settext", 2, 2, FEARG_1, NULL, |
| 1341 | ret_void, PROP_FUNC(f_popup_settext)}, |
| 1342 | {"popup_show", 1, 1, FEARG_1, NULL, |
| 1343 | ret_void, PROP_FUNC(f_popup_show)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1344 | {"pow", 2, 2, FEARG_1, arg2_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1345 | ret_float, FLOAT_FUNC(f_pow)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1346 | {"prevnonblank", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1347 | ret_number, f_prevnonblank}, |
| 1348 | {"printf", 1, 19, FEARG_2, NULL, |
| 1349 | ret_string, f_printf}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1350 | {"prompt_getprompt", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1351 | ret_string, JOB_FUNC(f_prompt_getprompt)}, |
| 1352 | {"prompt_setcallback", 2, 2, FEARG_1, NULL, |
| 1353 | ret_void, JOB_FUNC(f_prompt_setcallback)}, |
| 1354 | {"prompt_setinterrupt", 2, 2, FEARG_1, NULL, |
| 1355 | ret_void, JOB_FUNC(f_prompt_setinterrupt)}, |
| 1356 | {"prompt_setprompt", 2, 2, FEARG_1, NULL, |
| 1357 | ret_void, JOB_FUNC(f_prompt_setprompt)}, |
| 1358 | {"prop_add", 3, 3, FEARG_1, NULL, |
| 1359 | ret_void, PROP_FUNC(f_prop_add)}, |
| 1360 | {"prop_clear", 1, 3, FEARG_1, NULL, |
| 1361 | ret_void, PROP_FUNC(f_prop_clear)}, |
| 1362 | {"prop_find", 1, 2, FEARG_1, NULL, |
| 1363 | ret_dict_any, PROP_FUNC(f_prop_find)}, |
| 1364 | {"prop_list", 1, 2, FEARG_1, NULL, |
| 1365 | ret_list_dict_any, PROP_FUNC(f_prop_list)}, |
| 1366 | {"prop_remove", 1, 3, FEARG_1, NULL, |
| 1367 | ret_number, PROP_FUNC(f_prop_remove)}, |
| 1368 | {"prop_type_add", 2, 2, FEARG_1, NULL, |
| 1369 | ret_void, PROP_FUNC(f_prop_type_add)}, |
| 1370 | {"prop_type_change", 2, 2, FEARG_1, NULL, |
| 1371 | ret_void, PROP_FUNC(f_prop_type_change)}, |
| 1372 | {"prop_type_delete", 1, 2, FEARG_1, NULL, |
| 1373 | ret_void, PROP_FUNC(f_prop_type_delete)}, |
| 1374 | {"prop_type_get", 1, 2, FEARG_1, NULL, |
| 1375 | ret_dict_any, PROP_FUNC(f_prop_type_get)}, |
| 1376 | {"prop_type_list", 0, 1, FEARG_1, NULL, |
| 1377 | ret_list_string, PROP_FUNC(f_prop_type_list)}, |
| 1378 | {"pum_getpos", 0, 0, 0, NULL, |
| 1379 | ret_dict_number, f_pum_getpos}, |
| 1380 | {"pumvisible", 0, 0, 0, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1381 | ret_number_bool, f_pumvisible}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1382 | {"py3eval", 1, 1, FEARG_1, NULL, |
| 1383 | ret_any, |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1384 | #ifdef FEAT_PYTHON3 |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1385 | f_py3eval |
| 1386 | #else |
| 1387 | NULL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1388 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1389 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1390 | {"pyeval", 1, 1, FEARG_1, NULL, |
| 1391 | ret_any, |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1392 | #ifdef FEAT_PYTHON |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1393 | f_pyeval |
| 1394 | #else |
| 1395 | NULL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1396 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1397 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1398 | {"pyxeval", 1, 1, FEARG_1, NULL, |
| 1399 | ret_any, |
Bram Moolenaar | f42dd3c | 2017-01-28 16:06:38 +0100 | [diff] [blame] | 1400 | #if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1401 | f_pyxeval |
| 1402 | #else |
| 1403 | NULL |
Bram Moolenaar | f42dd3c | 2017-01-28 16:06:38 +0100 | [diff] [blame] | 1404 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1405 | }, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1406 | {"rand", 0, 1, FEARG_1, arg1_list_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1407 | ret_number, f_rand}, |
| 1408 | {"range", 1, 3, FEARG_1, NULL, |
| 1409 | ret_list_number, f_range}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1410 | {"readblob", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | c423ad7 | 2021-01-13 20:38:03 +0100 | [diff] [blame] | 1411 | ret_blob, f_readblob}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1412 | {"readdir", 1, 3, FEARG_1, NULL, |
| 1413 | ret_list_string, f_readdir}, |
| 1414 | {"readdirex", 1, 3, FEARG_1, NULL, |
| 1415 | ret_list_dict_any, f_readdirex}, |
| 1416 | {"readfile", 1, 3, FEARG_1, NULL, |
Bram Moolenaar | c423ad7 | 2021-01-13 20:38:03 +0100 | [diff] [blame] | 1417 | ret_list_string, f_readfile}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1418 | {"reduce", 2, 3, FEARG_1, NULL, |
| 1419 | ret_any, f_reduce}, |
| 1420 | {"reg_executing", 0, 0, 0, NULL, |
| 1421 | ret_string, f_reg_executing}, |
| 1422 | {"reg_recording", 0, 0, 0, NULL, |
| 1423 | ret_string, f_reg_recording}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1424 | {"reltime", 0, 2, FEARG_1, arg2_list_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1425 | ret_list_any, f_reltime}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1426 | {"reltimefloat", 1, 1, FEARG_1, arg1_list_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1427 | ret_float, FLOAT_FUNC(f_reltimefloat)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1428 | {"reltimestr", 1, 1, FEARG_1, arg1_list_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1429 | ret_string, f_reltimestr}, |
| 1430 | {"remote_expr", 2, 4, FEARG_1, NULL, |
| 1431 | ret_string, f_remote_expr}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1432 | {"remote_foreground", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1433 | ret_string, f_remote_foreground}, |
| 1434 | {"remote_peek", 1, 2, FEARG_1, NULL, |
| 1435 | ret_number, f_remote_peek}, |
| 1436 | {"remote_read", 1, 2, FEARG_1, NULL, |
| 1437 | ret_string, f_remote_read}, |
| 1438 | {"remote_send", 2, 3, FEARG_1, NULL, |
| 1439 | ret_string, f_remote_send}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1440 | {"remote_startserver", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1441 | ret_void, f_remote_startserver}, |
| 1442 | {"remove", 2, 3, FEARG_1, NULL, |
| 1443 | ret_remove, f_remove}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1444 | {"rename", 2, 2, FEARG_1, arg2_string, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1445 | ret_number_bool, f_rename}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1446 | {"repeat", 2, 2, FEARG_1, NULL, |
| 1447 | ret_first_arg, f_repeat}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1448 | {"resolve", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1449 | ret_string, f_resolve}, |
| 1450 | {"reverse", 1, 1, FEARG_1, NULL, |
| 1451 | ret_first_arg, f_reverse}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1452 | {"round", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1453 | ret_float, FLOAT_FUNC(f_round)}, |
| 1454 | {"rubyeval", 1, 1, FEARG_1, NULL, |
| 1455 | ret_any, |
Bram Moolenaar | e99be0e | 2019-03-26 22:51:09 +0100 | [diff] [blame] | 1456 | #ifdef FEAT_RUBY |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1457 | f_rubyeval |
| 1458 | #else |
| 1459 | NULL |
Bram Moolenaar | e99be0e | 2019-03-26 22:51:09 +0100 | [diff] [blame] | 1460 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1461 | }, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1462 | {"screenattr", 2, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1463 | ret_number, f_screenattr}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1464 | {"screenchar", 2, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1465 | ret_number, f_screenchar}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1466 | {"screenchars", 2, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1467 | ret_list_number, f_screenchars}, |
| 1468 | {"screencol", 0, 0, 0, NULL, |
| 1469 | ret_number, f_screencol}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1470 | {"screenpos", 3, 3, FEARG_1, arg3_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1471 | ret_dict_number, f_screenpos}, |
| 1472 | {"screenrow", 0, 0, 0, NULL, |
| 1473 | ret_number, f_screenrow}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1474 | {"screenstring", 2, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1475 | ret_string, f_screenstring}, |
| 1476 | {"search", 1, 5, FEARG_1, NULL, |
| 1477 | ret_number, f_search}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1478 | {"searchcount", 0, 1, FEARG_1, arg1_dict, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1479 | ret_dict_any, f_searchcount}, |
| 1480 | {"searchdecl", 1, 3, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1481 | ret_number_bool, f_searchdecl}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1482 | {"searchpair", 3, 7, 0, NULL, |
| 1483 | ret_number, f_searchpair}, |
| 1484 | {"searchpairpos", 3, 7, 0, NULL, |
| 1485 | ret_list_number, f_searchpairpos}, |
| 1486 | {"searchpos", 1, 5, FEARG_1, NULL, |
| 1487 | ret_list_number, f_searchpos}, |
| 1488 | {"server2client", 2, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1489 | ret_number_bool, f_server2client}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1490 | {"serverlist", 0, 0, 0, NULL, |
| 1491 | ret_string, f_serverlist}, |
| 1492 | {"setbufline", 3, 3, FEARG_3, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1493 | ret_number_bool, f_setbufline}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1494 | {"setbufvar", 3, 3, FEARG_3, NULL, |
| 1495 | ret_void, f_setbufvar}, |
| 1496 | {"setcellwidths", 1, 1, FEARG_1, NULL, |
| 1497 | ret_void, f_setcellwidths}, |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 1498 | {"setcharpos", 2, 2, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1499 | ret_number_bool, f_setcharpos}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1500 | {"setcharsearch", 1, 1, FEARG_1, arg1_dict, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1501 | ret_void, f_setcharsearch}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1502 | {"setcmdpos", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1503 | ret_number_bool, f_setcmdpos}, |
| 1504 | {"setcursorcharpos", 1, 3, FEARG_1, NULL, |
| 1505 | ret_number_bool, f_setcursorcharpos}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1506 | {"setenv", 2, 2, FEARG_2, NULL, |
| 1507 | ret_void, f_setenv}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1508 | {"setfperm", 2, 2, FEARG_1, arg2_string, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1509 | ret_number_bool, f_setfperm}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1510 | {"setline", 2, 2, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1511 | ret_number_bool, f_setline}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1512 | {"setloclist", 2, 4, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1513 | ret_number_bool, f_setloclist}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1514 | {"setmatches", 1, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1515 | ret_number_bool, f_setmatches}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1516 | {"setpos", 2, 2, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1517 | ret_number_bool, f_setpos}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1518 | {"setqflist", 1, 3, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1519 | ret_number_bool, f_setqflist}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1520 | {"setreg", 2, 3, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1521 | ret_number_bool, f_setreg}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1522 | {"settabvar", 3, 3, FEARG_3, NULL, |
| 1523 | ret_void, f_settabvar}, |
| 1524 | {"settabwinvar", 4, 4, FEARG_4, NULL, |
| 1525 | ret_void, f_settabwinvar}, |
| 1526 | {"settagstack", 2, 3, FEARG_2, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1527 | ret_number_bool, f_settagstack}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1528 | {"setwinvar", 3, 3, FEARG_3, NULL, |
| 1529 | ret_void, f_setwinvar}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1530 | {"sha256", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1531 | ret_string, |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1532 | #ifdef FEAT_CRYPT |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1533 | f_sha256 |
| 1534 | #else |
| 1535 | NULL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1536 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1537 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1538 | {"shellescape", 1, 2, FEARG_1, NULL, |
| 1539 | ret_string, f_shellescape}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1540 | {"shiftwidth", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1541 | ret_number, f_shiftwidth}, |
| 1542 | {"sign_define", 1, 2, FEARG_1, NULL, |
| 1543 | ret_any, SIGN_FUNC(f_sign_define)}, |
| 1544 | {"sign_getdefined", 0, 1, FEARG_1, NULL, |
| 1545 | ret_list_dict_any, SIGN_FUNC(f_sign_getdefined)}, |
| 1546 | {"sign_getplaced", 0, 2, FEARG_1, NULL, |
| 1547 | ret_list_dict_any, SIGN_FUNC(f_sign_getplaced)}, |
| 1548 | {"sign_jump", 3, 3, FEARG_1, NULL, |
| 1549 | ret_number, SIGN_FUNC(f_sign_jump)}, |
| 1550 | {"sign_place", 4, 5, FEARG_1, NULL, |
| 1551 | ret_number, SIGN_FUNC(f_sign_place)}, |
| 1552 | {"sign_placelist", 1, 1, FEARG_1, NULL, |
| 1553 | ret_list_number, SIGN_FUNC(f_sign_placelist)}, |
| 1554 | {"sign_undefine", 0, 1, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1555 | ret_number_bool, SIGN_FUNC(f_sign_undefine)}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1556 | {"sign_unplace", 1, 2, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1557 | ret_number_bool, SIGN_FUNC(f_sign_unplace)}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1558 | {"sign_unplacelist", 1, 2, FEARG_1, NULL, |
| 1559 | ret_list_number, SIGN_FUNC(f_sign_unplacelist)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1560 | {"simplify", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1561 | ret_string, f_simplify}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1562 | {"sin", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1563 | ret_float, FLOAT_FUNC(f_sin)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1564 | {"sinh", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1565 | ret_float, FLOAT_FUNC(f_sinh)}, |
Bram Moolenaar | 6601b62 | 2021-01-13 21:47:15 +0100 | [diff] [blame] | 1566 | {"slice", 2, 3, FEARG_1, NULL, |
| 1567 | ret_first_arg, f_slice}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1568 | {"sort", 1, 3, FEARG_1, NULL, |
| 1569 | ret_first_arg, f_sort}, |
| 1570 | {"sound_clear", 0, 0, 0, NULL, |
| 1571 | ret_void, SOUND_FUNC(f_sound_clear)}, |
| 1572 | {"sound_playevent", 1, 2, FEARG_1, NULL, |
| 1573 | ret_number, SOUND_FUNC(f_sound_playevent)}, |
| 1574 | {"sound_playfile", 1, 2, FEARG_1, NULL, |
| 1575 | ret_number, SOUND_FUNC(f_sound_playfile)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1576 | {"sound_stop", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1577 | ret_void, SOUND_FUNC(f_sound_stop)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1578 | {"soundfold", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1579 | ret_string, f_soundfold}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1580 | {"spellbadword", 0, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1581 | ret_list_string, f_spellbadword}, |
| 1582 | {"spellsuggest", 1, 3, FEARG_1, NULL, |
| 1583 | ret_list_string, f_spellsuggest}, |
| 1584 | {"split", 1, 3, FEARG_1, NULL, |
| 1585 | ret_list_string, f_split}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1586 | {"sqrt", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1587 | ret_float, FLOAT_FUNC(f_sqrt)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1588 | {"srand", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1589 | ret_list_number, f_srand}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1590 | {"state", 0, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1591 | ret_string, f_state}, |
Bram Moolenaar | 80ad3e2 | 2021-01-31 20:48:58 +0100 | [diff] [blame] | 1592 | {"str2float", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1593 | ret_float, FLOAT_FUNC(f_str2float)}, |
| 1594 | {"str2list", 1, 2, FEARG_1, NULL, |
| 1595 | ret_list_number, f_str2list}, |
Bram Moolenaar | f2b26bc | 2021-01-30 23:05:11 +0100 | [diff] [blame] | 1596 | {"str2nr", 1, 3, FEARG_1, arg3_string_nr_bool, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1597 | ret_number, f_str2nr}, |
Bram Moolenaar | 70ce8a1 | 2021-03-14 19:02:09 +0100 | [diff] [blame] | 1598 | {"strcharlen", 1, 1, FEARG_1, NULL, |
| 1599 | ret_number, f_strcharlen}, |
Bram Moolenaar | 02b4d9b | 2021-03-14 19:46:45 +0100 | [diff] [blame] | 1600 | {"strcharpart", 2, 4, FEARG_1, NULL, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1601 | ret_string, f_strcharpart}, |
| 1602 | {"strchars", 1, 2, FEARG_1, NULL, |
| 1603 | ret_number, f_strchars}, |
| 1604 | {"strdisplaywidth", 1, 2, FEARG_1, NULL, |
| 1605 | ret_number, f_strdisplaywidth}, |
| 1606 | {"strftime", 1, 2, FEARG_1, NULL, |
| 1607 | ret_string, |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1608 | #ifdef HAVE_STRFTIME |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1609 | f_strftime |
| 1610 | #else |
| 1611 | NULL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1612 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1613 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1614 | {"strgetchar", 2, 2, FEARG_1, NULL, |
| 1615 | ret_number, f_strgetchar}, |
| 1616 | {"stridx", 2, 3, FEARG_1, NULL, |
| 1617 | ret_number, f_stridx}, |
| 1618 | {"string", 1, 1, FEARG_1, NULL, |
| 1619 | ret_string, f_string}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1620 | {"strlen", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1621 | ret_number, f_strlen}, |
| 1622 | {"strpart", 2, 4, FEARG_1, NULL, |
| 1623 | ret_string, f_strpart}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1624 | {"strptime", 2, 2, FEARG_1, arg2_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1625 | ret_number, |
Bram Moolenaar | 10455d4 | 2019-11-21 15:36:18 +0100 | [diff] [blame] | 1626 | #ifdef HAVE_STRPTIME |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1627 | f_strptime |
| 1628 | #else |
| 1629 | NULL |
Bram Moolenaar | 10455d4 | 2019-11-21 15:36:18 +0100 | [diff] [blame] | 1630 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1631 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1632 | {"strridx", 2, 3, FEARG_1, NULL, |
| 1633 | ret_number, f_strridx}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1634 | {"strtrans", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1635 | ret_string, f_strtrans}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1636 | {"strwidth", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1637 | ret_number, f_strwidth}, |
| 1638 | {"submatch", 1, 2, FEARG_1, NULL, |
| 1639 | ret_string, f_submatch}, |
| 1640 | {"substitute", 4, 4, FEARG_1, NULL, |
| 1641 | ret_string, f_substitute}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1642 | {"swapinfo", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1643 | ret_dict_any, f_swapinfo}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1644 | {"swapname", 1, 1, FEARG_1, arg1_string_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1645 | ret_string, f_swapname}, |
| 1646 | {"synID", 3, 3, 0, NULL, |
| 1647 | ret_number, f_synID}, |
| 1648 | {"synIDattr", 2, 3, FEARG_1, NULL, |
| 1649 | ret_string, f_synIDattr}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1650 | {"synIDtrans", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1651 | ret_number, f_synIDtrans}, |
| 1652 | {"synconcealed", 2, 2, 0, NULL, |
| 1653 | ret_list_any, f_synconcealed}, |
| 1654 | {"synstack", 2, 2, 0, NULL, |
| 1655 | ret_list_number, f_synstack}, |
| 1656 | {"system", 1, 2, FEARG_1, NULL, |
| 1657 | ret_string, f_system}, |
| 1658 | {"systemlist", 1, 2, FEARG_1, NULL, |
| 1659 | ret_list_string, f_systemlist}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1660 | {"tabpagebuflist", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1661 | ret_list_number, f_tabpagebuflist}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1662 | {"tabpagenr", 0, 1, 0, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1663 | ret_number, f_tabpagenr}, |
| 1664 | {"tabpagewinnr", 1, 2, FEARG_1, NULL, |
| 1665 | ret_number, f_tabpagewinnr}, |
| 1666 | {"tagfiles", 0, 0, 0, NULL, |
| 1667 | ret_list_string, f_tagfiles}, |
| 1668 | {"taglist", 1, 2, FEARG_1, NULL, |
| 1669 | ret_list_dict_any, f_taglist}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1670 | {"tan", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1671 | ret_float, FLOAT_FUNC(f_tan)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1672 | {"tanh", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1673 | ret_float, FLOAT_FUNC(f_tanh)}, |
| 1674 | {"tempname", 0, 0, 0, NULL, |
| 1675 | ret_string, f_tempname}, |
| 1676 | {"term_dumpdiff", 2, 3, FEARG_1, NULL, |
| 1677 | ret_number, TERM_FUNC(f_term_dumpdiff)}, |
| 1678 | {"term_dumpload", 1, 2, FEARG_1, NULL, |
| 1679 | ret_number, TERM_FUNC(f_term_dumpload)}, |
| 1680 | {"term_dumpwrite", 2, 3, FEARG_2, NULL, |
| 1681 | ret_void, TERM_FUNC(f_term_dumpwrite)}, |
| 1682 | {"term_getaltscreen", 1, 1, FEARG_1, NULL, |
| 1683 | ret_number, TERM_FUNC(f_term_getaltscreen)}, |
| 1684 | {"term_getansicolors", 1, 1, FEARG_1, NULL, |
| 1685 | ret_list_string, |
Bram Moolenaar | bd5e622 | 2020-03-26 23:13:34 +0100 | [diff] [blame] | 1686 | #if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)) |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1687 | f_term_getansicolors |
| 1688 | #else |
| 1689 | NULL |
Bram Moolenaar | c6df10e | 2017-07-29 20:15:08 +0200 | [diff] [blame] | 1690 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1691 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1692 | {"term_getattr", 2, 2, FEARG_1, NULL, |
| 1693 | ret_number, TERM_FUNC(f_term_getattr)}, |
| 1694 | {"term_getcursor", 1, 1, FEARG_1, NULL, |
| 1695 | ret_list_any, TERM_FUNC(f_term_getcursor)}, |
| 1696 | {"term_getjob", 1, 1, FEARG_1, NULL, |
| 1697 | ret_job, TERM_FUNC(f_term_getjob)}, |
| 1698 | {"term_getline", 2, 2, FEARG_1, NULL, |
| 1699 | ret_string, TERM_FUNC(f_term_getline)}, |
| 1700 | {"term_getscrolled", 1, 1, FEARG_1, NULL, |
| 1701 | ret_number, TERM_FUNC(f_term_getscrolled)}, |
| 1702 | {"term_getsize", 1, 1, FEARG_1, NULL, |
| 1703 | ret_list_number, TERM_FUNC(f_term_getsize)}, |
| 1704 | {"term_getstatus", 1, 1, FEARG_1, NULL, |
| 1705 | ret_string, TERM_FUNC(f_term_getstatus)}, |
| 1706 | {"term_gettitle", 1, 1, FEARG_1, NULL, |
| 1707 | ret_string, TERM_FUNC(f_term_gettitle)}, |
| 1708 | {"term_gettty", 1, 2, FEARG_1, NULL, |
| 1709 | ret_string, TERM_FUNC(f_term_gettty)}, |
| 1710 | {"term_list", 0, 0, 0, NULL, |
| 1711 | ret_list_number, TERM_FUNC(f_term_list)}, |
| 1712 | {"term_scrape", 2, 2, FEARG_1, NULL, |
| 1713 | ret_list_dict_any, TERM_FUNC(f_term_scrape)}, |
| 1714 | {"term_sendkeys", 2, 2, FEARG_1, NULL, |
| 1715 | ret_void, TERM_FUNC(f_term_sendkeys)}, |
| 1716 | {"term_setansicolors", 2, 2, FEARG_1, NULL, |
| 1717 | ret_void, |
Bram Moolenaar | bd5e622 | 2020-03-26 23:13:34 +0100 | [diff] [blame] | 1718 | #if defined(FEAT_TERMINAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)) |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1719 | f_term_setansicolors |
| 1720 | #else |
| 1721 | NULL |
| 1722 | #endif |
| 1723 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1724 | {"term_setapi", 2, 2, FEARG_1, NULL, |
| 1725 | ret_void, TERM_FUNC(f_term_setapi)}, |
| 1726 | {"term_setkill", 2, 2, FEARG_1, NULL, |
| 1727 | ret_void, TERM_FUNC(f_term_setkill)}, |
| 1728 | {"term_setrestore", 2, 2, FEARG_1, NULL, |
| 1729 | ret_void, TERM_FUNC(f_term_setrestore)}, |
| 1730 | {"term_setsize", 3, 3, FEARG_1, NULL, |
| 1731 | ret_void, TERM_FUNC(f_term_setsize)}, |
| 1732 | {"term_start", 1, 2, FEARG_1, NULL, |
| 1733 | ret_number, TERM_FUNC(f_term_start)}, |
| 1734 | {"term_wait", 1, 2, FEARG_1, NULL, |
| 1735 | ret_void, TERM_FUNC(f_term_wait)}, |
| 1736 | {"terminalprops", 0, 0, 0, NULL, |
| 1737 | ret_dict_string, f_terminalprops}, |
| 1738 | {"test_alloc_fail", 3, 3, FEARG_1, NULL, |
| 1739 | ret_void, f_test_alloc_fail}, |
| 1740 | {"test_autochdir", 0, 0, 0, NULL, |
| 1741 | ret_void, f_test_autochdir}, |
| 1742 | {"test_feedinput", 1, 1, FEARG_1, NULL, |
| 1743 | ret_void, f_test_feedinput}, |
| 1744 | {"test_garbagecollect_now", 0, 0, 0, NULL, |
| 1745 | ret_void, f_test_garbagecollect_now}, |
| 1746 | {"test_garbagecollect_soon", 0, 0, 0, NULL, |
| 1747 | ret_void, f_test_garbagecollect_soon}, |
| 1748 | {"test_getvalue", 1, 1, FEARG_1, NULL, |
| 1749 | ret_number, f_test_getvalue}, |
Yegappan Lakshmanan | 18d4658 | 2021-06-23 20:46:52 +0200 | [diff] [blame] | 1750 | {"test_gui_drop_files", 4, 4, 0, NULL, |
| 1751 | ret_void, f_test_gui_drop_files}, |
Yegappan Lakshmanan | f1e7449 | 2021-06-21 18:44:26 +0200 | [diff] [blame] | 1752 | {"test_gui_mouse_event", 5, 5, 0, NULL, |
| 1753 | ret_void, f_test_gui_mouse_event}, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1754 | {"test_ignore_error", 1, 1, FEARG_1, NULL, |
| 1755 | ret_void, f_test_ignore_error}, |
| 1756 | {"test_null_blob", 0, 0, 0, NULL, |
| 1757 | ret_blob, f_test_null_blob}, |
| 1758 | {"test_null_channel", 0, 0, 0, NULL, |
| 1759 | ret_channel, JOB_FUNC(f_test_null_channel)}, |
| 1760 | {"test_null_dict", 0, 0, 0, NULL, |
| 1761 | ret_dict_any, f_test_null_dict}, |
| 1762 | {"test_null_function", 0, 0, 0, NULL, |
| 1763 | ret_func_any, f_test_null_function}, |
| 1764 | {"test_null_job", 0, 0, 0, NULL, |
| 1765 | ret_job, JOB_FUNC(f_test_null_job)}, |
| 1766 | {"test_null_list", 0, 0, 0, NULL, |
| 1767 | ret_list_any, f_test_null_list}, |
| 1768 | {"test_null_partial", 0, 0, 0, NULL, |
| 1769 | ret_func_any, f_test_null_partial}, |
| 1770 | {"test_null_string", 0, 0, 0, NULL, |
| 1771 | ret_string, f_test_null_string}, |
| 1772 | {"test_option_not_set", 1, 1, FEARG_1, NULL, |
| 1773 | ret_void, f_test_option_not_set}, |
| 1774 | {"test_override", 2, 2, FEARG_2, NULL, |
| 1775 | ret_void, f_test_override}, |
| 1776 | {"test_refcount", 1, 1, FEARG_1, NULL, |
| 1777 | ret_number, f_test_refcount}, |
| 1778 | {"test_scrollbar", 3, 3, FEARG_2, NULL, |
| 1779 | ret_void, |
Bram Moolenaar | ab18673 | 2018-09-14 21:27:06 +0200 | [diff] [blame] | 1780 | #ifdef FEAT_GUI |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1781 | f_test_scrollbar |
| 1782 | #else |
| 1783 | NULL |
Bram Moolenaar | ab18673 | 2018-09-14 21:27:06 +0200 | [diff] [blame] | 1784 | #endif |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1785 | }, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1786 | {"test_setmouse", 2, 2, 0, NULL, |
| 1787 | ret_void, f_test_setmouse}, |
| 1788 | {"test_settime", 1, 1, FEARG_1, NULL, |
| 1789 | ret_void, f_test_settime}, |
| 1790 | {"test_srand_seed", 0, 1, FEARG_1, NULL, |
| 1791 | ret_void, f_test_srand_seed}, |
| 1792 | {"test_unknown", 0, 0, 0, NULL, |
| 1793 | ret_any, f_test_unknown}, |
| 1794 | {"test_void", 0, 0, 0, NULL, |
| 1795 | ret_void, f_test_void}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1796 | {"timer_info", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1797 | ret_list_dict_any, TIMER_FUNC(f_timer_info)}, |
| 1798 | {"timer_pause", 2, 2, FEARG_1, NULL, |
| 1799 | ret_void, TIMER_FUNC(f_timer_pause)}, |
| 1800 | {"timer_start", 2, 3, FEARG_1, NULL, |
| 1801 | ret_number, TIMER_FUNC(f_timer_start)}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1802 | {"timer_stop", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1803 | ret_void, TIMER_FUNC(f_timer_stop)}, |
| 1804 | {"timer_stopall", 0, 0, 0, NULL, |
| 1805 | ret_void, TIMER_FUNC(f_timer_stopall)}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1806 | {"tolower", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1807 | ret_string, f_tolower}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1808 | {"toupper", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1809 | ret_string, f_toupper}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1810 | {"tr", 3, 3, FEARG_1, arg3_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1811 | ret_string, f_tr}, |
| 1812 | {"trim", 1, 3, FEARG_1, NULL, |
| 1813 | ret_string, f_trim}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1814 | {"trunc", 1, 1, FEARG_1, arg1_float_or_nr, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1815 | ret_float, FLOAT_FUNC(f_trunc)}, |
| 1816 | {"type", 1, 1, FEARG_1, NULL, |
| 1817 | ret_number, f_type}, |
Bram Moolenaar | a47e05f | 2021-01-12 21:49:00 +0100 | [diff] [blame] | 1818 | {"typename", 1, 1, FEARG_1, NULL, |
| 1819 | ret_string, f_typename}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1820 | {"undofile", 1, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1821 | ret_string, f_undofile}, |
| 1822 | {"undotree", 0, 0, 0, NULL, |
| 1823 | ret_dict_any, f_undotree}, |
| 1824 | {"uniq", 1, 3, FEARG_1, NULL, |
| 1825 | ret_list_any, f_uniq}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1826 | {"values", 1, 1, FEARG_1, arg1_dict, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1827 | ret_list_any, f_values}, |
| 1828 | {"virtcol", 1, 1, FEARG_1, NULL, |
| 1829 | ret_number, f_virtcol}, |
| 1830 | {"visualmode", 0, 1, 0, NULL, |
| 1831 | ret_string, f_visualmode}, |
| 1832 | {"wildmenumode", 0, 0, 0, NULL, |
| 1833 | ret_number, f_wildmenumode}, |
| 1834 | {"win_execute", 2, 3, FEARG_2, NULL, |
| 1835 | ret_string, f_win_execute}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1836 | {"win_findbuf", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1837 | ret_list_number, f_win_findbuf}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1838 | {"win_getid", 0, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1839 | ret_number, f_win_getid}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1840 | {"win_gettype", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1841 | ret_string, f_win_gettype}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1842 | {"win_gotoid", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1843 | ret_number_bool, f_win_gotoid}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1844 | {"win_id2tabwin", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1845 | ret_list_number, f_win_id2tabwin}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1846 | {"win_id2win", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1847 | ret_number, f_win_id2win}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1848 | {"win_screenpos", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1849 | ret_list_number, f_win_screenpos}, |
| 1850 | {"win_splitmove", 2, 3, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1851 | ret_number_bool, f_win_splitmove}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1852 | {"winbufnr", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1853 | ret_number, f_winbufnr}, |
| 1854 | {"wincol", 0, 0, 0, NULL, |
| 1855 | ret_number, f_wincol}, |
| 1856 | {"windowsversion", 0, 0, 0, NULL, |
| 1857 | ret_string, f_windowsversion}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1858 | {"winheight", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1859 | ret_number, f_winheight}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1860 | {"winlayout", 0, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1861 | ret_list_any, f_winlayout}, |
| 1862 | {"winline", 0, 0, 0, NULL, |
| 1863 | ret_number, f_winline}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1864 | {"winnr", 0, 1, FEARG_1, arg1_string, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1865 | ret_number, f_winnr}, |
| 1866 | {"winrestcmd", 0, 0, 0, NULL, |
| 1867 | ret_string, f_winrestcmd}, |
Yegappan Lakshmanan | a26f56f | 2021-07-03 11:58:12 +0200 | [diff] [blame] | 1868 | {"winrestview", 1, 1, FEARG_1, arg1_dict, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1869 | ret_void, f_winrestview}, |
| 1870 | {"winsaveview", 0, 0, 0, NULL, |
Bram Moolenaar | 43b69b3 | 2021-01-07 20:23:33 +0100 | [diff] [blame] | 1871 | ret_dict_number, f_winsaveview}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1872 | {"winwidth", 1, 1, FEARG_1, arg1_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1873 | ret_number, f_winwidth}, |
| 1874 | {"wordcount", 0, 0, 0, NULL, |
| 1875 | ret_dict_number, f_wordcount}, |
| 1876 | {"writefile", 2, 3, FEARG_1, NULL, |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 1877 | ret_number_bool, f_writefile}, |
Yegappan Lakshmanan | 7237cab | 2021-06-22 19:52:27 +0200 | [diff] [blame] | 1878 | {"xor", 2, 2, FEARG_1, arg2_number, |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 1879 | ret_number, f_xor}, |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 1880 | }; |
| 1881 | |
K.Takata | eecf2b3 | 2021-06-02 14:56:39 +0200 | [diff] [blame] | 1882 | #if defined(EBCDIC) || defined(PROTO) |
| 1883 | /* |
| 1884 | * Compare funcentry_T by function name. |
| 1885 | */ |
| 1886 | static int |
| 1887 | compare_func_name(const void *s1, const void *s2) |
| 1888 | { |
| 1889 | funcentry_T *p1 = (funcentry_T *)s1; |
| 1890 | funcentry_T *p2 = (funcentry_T *)s2; |
| 1891 | |
| 1892 | return STRCMP(p1->f_name, p2->f_name); |
| 1893 | } |
| 1894 | |
| 1895 | /* |
| 1896 | * Sort the function table by function name. |
| 1897 | * The sorting of the table above is ASCII dependent. |
| 1898 | * On machines using EBCDIC we have to sort it. |
| 1899 | */ |
| 1900 | void |
| 1901 | sortFunctions(void) |
| 1902 | { |
| 1903 | size_t funcCnt = ARRAY_LENGTH(global_functions); |
| 1904 | |
| 1905 | qsort(global_functions, funcCnt, sizeof(funcentry_T), compare_func_name); |
| 1906 | } |
| 1907 | #endif |
| 1908 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1909 | /* |
| 1910 | * Function given to ExpandGeneric() to obtain the list of internal |
| 1911 | * or user defined function names. |
| 1912 | */ |
| 1913 | char_u * |
| 1914 | get_function_name(expand_T *xp, int idx) |
| 1915 | { |
| 1916 | static int intidx = -1; |
| 1917 | char_u *name; |
| 1918 | |
| 1919 | if (idx == 0) |
| 1920 | intidx = -1; |
| 1921 | if (intidx < 0) |
| 1922 | { |
| 1923 | name = get_user_func_name(xp, idx); |
| 1924 | if (name != NULL) |
Bram Moolenaar | 1bb4de5 | 2021-01-13 19:48:46 +0100 | [diff] [blame] | 1925 | { |
| 1926 | if (*name != '<' && STRNCMP("g:", xp->xp_pattern, 2) == 0) |
| 1927 | return cat_prefix_varname('g', name); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1928 | return name; |
Bram Moolenaar | 1bb4de5 | 2021-01-13 19:48:46 +0100 | [diff] [blame] | 1929 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1930 | } |
K.Takata | eeec254 | 2021-06-02 13:28:16 +0200 | [diff] [blame] | 1931 | if (++intidx < (int)ARRAY_LENGTH(global_functions)) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1932 | { |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 1933 | STRCPY(IObuff, global_functions[intidx].f_name); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1934 | STRCAT(IObuff, "("); |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 1935 | if (global_functions[intidx].f_max_argc == 0) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1936 | STRCAT(IObuff, ")"); |
| 1937 | return IObuff; |
| 1938 | } |
| 1939 | |
| 1940 | return NULL; |
| 1941 | } |
| 1942 | |
| 1943 | /* |
| 1944 | * Function given to ExpandGeneric() to obtain the list of internal or |
| 1945 | * user defined variable or function names. |
| 1946 | */ |
| 1947 | char_u * |
| 1948 | get_expr_name(expand_T *xp, int idx) |
| 1949 | { |
| 1950 | static int intidx = -1; |
| 1951 | char_u *name; |
| 1952 | |
| 1953 | if (idx == 0) |
| 1954 | intidx = -1; |
| 1955 | if (intidx < 0) |
| 1956 | { |
| 1957 | name = get_function_name(xp, idx); |
| 1958 | if (name != NULL) |
| 1959 | return name; |
| 1960 | } |
| 1961 | return get_user_var_name(xp, ++intidx); |
| 1962 | } |
| 1963 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1964 | /* |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 1965 | * Find internal function "name" in table "global_functions". |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1966 | * Return index, or -1 if not found or "implemented" is TRUE and the function |
| 1967 | * is not implemented. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1968 | */ |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1969 | static int |
| 1970 | find_internal_func_opt(char_u *name, int implemented) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1971 | { |
| 1972 | int first = 0; |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 1973 | int last; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1974 | int cmp; |
| 1975 | int x; |
| 1976 | |
K.Takata | eeec254 | 2021-06-02 13:28:16 +0200 | [diff] [blame] | 1977 | last = (int)ARRAY_LENGTH(global_functions) - 1; |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 1978 | |
| 1979 | // Find the function name in the table. Binary search. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1980 | while (first <= last) |
| 1981 | { |
| 1982 | x = first + ((unsigned)(last - first) >> 1); |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 1983 | cmp = STRCMP(name, global_functions[x].f_name); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1984 | if (cmp < 0) |
| 1985 | last = x - 1; |
| 1986 | else if (cmp > 0) |
| 1987 | first = x + 1; |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1988 | else if (implemented && global_functions[x].f_func == NULL) |
| 1989 | break; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 1990 | else |
| 1991 | return x; |
| 1992 | } |
| 1993 | return -1; |
| 1994 | } |
| 1995 | |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 1996 | /* |
| 1997 | * Find internal function "name" in table "global_functions". |
| 1998 | * Return index, or -1 if not found or the function is not implemented. |
| 1999 | */ |
| 2000 | int |
| 2001 | find_internal_func(char_u *name) |
| 2002 | { |
| 2003 | return find_internal_func_opt(name, TRUE); |
| 2004 | } |
| 2005 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2006 | int |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2007 | has_internal_func(char_u *name) |
| 2008 | { |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 2009 | return find_internal_func_opt(name, TRUE) >= 0; |
| 2010 | } |
| 2011 | |
| 2012 | static int |
| 2013 | has_internal_func_name(char_u *name) |
| 2014 | { |
| 2015 | return find_internal_func_opt(name, FALSE) >= 0; |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2016 | } |
| 2017 | |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2018 | char * |
| 2019 | internal_func_name(int idx) |
| 2020 | { |
| 2021 | return global_functions[idx].f_name; |
| 2022 | } |
| 2023 | |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 2024 | /* |
Dominique Pelle | fe8ebdb | 2021-05-13 14:55:55 +0200 | [diff] [blame] | 2025 | * Check the argument types for builtin function "idx". |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 2026 | * Uses the list of types on the type stack: "types". |
| 2027 | * Return FAIL and gives an error message when a type is wrong. |
| 2028 | */ |
| 2029 | int |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 2030 | internal_func_check_arg_types( |
| 2031 | type_T **types, |
| 2032 | int idx, |
| 2033 | int argcount, |
| 2034 | cctx_T *cctx) |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 2035 | { |
| 2036 | argcheck_T *argchecks = global_functions[idx].f_argcheck; |
| 2037 | int i; |
| 2038 | |
| 2039 | if (argchecks != NULL) |
| 2040 | { |
| 2041 | argcontext_T context; |
| 2042 | |
| 2043 | context.arg_count = argcount; |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 2044 | context.arg_types = types; |
Bram Moolenaar | 351ead0 | 2021-01-16 16:07:01 +0100 | [diff] [blame] | 2045 | context.arg_cctx = cctx; |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 2046 | for (i = 0; i < argcount; ++i) |
| 2047 | if (argchecks[i] != NULL) |
| 2048 | { |
| 2049 | context.arg_idx = i; |
Bram Moolenaar | ca17453 | 2020-10-21 16:42:22 +0200 | [diff] [blame] | 2050 | if (argchecks[i](types[i], &context) == FAIL) |
Bram Moolenaar | 94738d8 | 2020-10-21 14:25:07 +0200 | [diff] [blame] | 2051 | return FAIL; |
| 2052 | } |
| 2053 | } |
| 2054 | return OK; |
| 2055 | } |
| 2056 | |
Bram Moolenaar | a1224cb | 2020-10-22 12:31:49 +0200 | [diff] [blame] | 2057 | /* |
Bram Moolenaar | 7a40ff0 | 2021-07-04 15:54:08 +0200 | [diff] [blame] | 2058 | * Get the argument count for function "idx". |
| 2059 | * "argcount" is the total argument count, "min_argcount" the non-optional |
| 2060 | * argument count. |
| 2061 | */ |
| 2062 | void |
| 2063 | internal_func_get_argcount(int idx, int *argcount, int *min_argcount) |
| 2064 | { |
| 2065 | *argcount = global_functions[idx].f_max_argc; |
| 2066 | *min_argcount = global_functions[idx].f_min_argc; |
| 2067 | } |
| 2068 | |
| 2069 | /* |
Bram Moolenaar | a1224cb | 2020-10-22 12:31:49 +0200 | [diff] [blame] | 2070 | * Call the "f_retfunc" function to obtain the return type of function "idx". |
| 2071 | * "argtypes" is the list of argument types or NULL when there are no |
| 2072 | * arguments. |
| 2073 | */ |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2074 | type_T * |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 2075 | internal_func_ret_type(int idx, int argcount, type_T **argtypes) |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2076 | { |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 2077 | return global_functions[idx].f_retfunc(argcount, argtypes); |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2078 | } |
| 2079 | |
| 2080 | /* |
Bram Moolenaar | 75ab91f | 2021-01-10 22:42:50 +0100 | [diff] [blame] | 2081 | * Return TRUE if "idx" is for the map() function. |
| 2082 | */ |
| 2083 | int |
| 2084 | internal_func_is_map(int idx) |
| 2085 | { |
| 2086 | return global_functions[idx].f_func == f_map; |
| 2087 | } |
| 2088 | |
| 2089 | /* |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2090 | * Check the argument count to use for internal function "idx". |
Bram Moolenaar | 389df25 | 2020-07-09 21:20:47 +0200 | [diff] [blame] | 2091 | * Returns -1 for failure, 0 if no method base accepted, 1 if method base is |
| 2092 | * first argument, 2 if method base is second argument, etc. 9 if method base |
| 2093 | * is last argument. |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2094 | */ |
| 2095 | int |
| 2096 | check_internal_func(int idx, int argcount) |
| 2097 | { |
| 2098 | int res; |
| 2099 | char *name; |
| 2100 | |
| 2101 | if (argcount < global_functions[idx].f_min_argc) |
| 2102 | res = FCERR_TOOFEW; |
| 2103 | else if (argcount > global_functions[idx].f_max_argc) |
| 2104 | res = FCERR_TOOMANY; |
| 2105 | else |
Bram Moolenaar | 389df25 | 2020-07-09 21:20:47 +0200 | [diff] [blame] | 2106 | return global_functions[idx].f_argtype; |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2107 | |
| 2108 | name = internal_func_name(idx); |
| 2109 | if (res == FCERR_TOOMANY) |
| 2110 | semsg(_(e_toomanyarg), name); |
| 2111 | else |
| 2112 | semsg(_(e_toofewarg), name); |
Bram Moolenaar | 389df25 | 2020-07-09 21:20:47 +0200 | [diff] [blame] | 2113 | return -1; |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2114 | } |
| 2115 | |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2116 | int |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2117 | call_internal_func( |
| 2118 | char_u *name, |
| 2119 | int argcount, |
| 2120 | typval_T *argvars, |
| 2121 | typval_T *rettv) |
| 2122 | { |
| 2123 | int i; |
| 2124 | |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 2125 | i = find_internal_func(name); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2126 | if (i < 0) |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2127 | return FCERR_UNKNOWN; |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2128 | if (argcount < global_functions[i].f_min_argc) |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2129 | return FCERR_TOOFEW; |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2130 | if (argcount > global_functions[i].f_max_argc) |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2131 | return FCERR_TOOMANY; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2132 | argvars[argcount].v_type = VAR_UNKNOWN; |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2133 | global_functions[i].f_func(argvars, rettv); |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2134 | return FCERR_NONE; |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2135 | } |
| 2136 | |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2137 | void |
| 2138 | call_internal_func_by_idx( |
| 2139 | int idx, |
| 2140 | typval_T *argvars, |
| 2141 | typval_T *rettv) |
| 2142 | { |
| 2143 | global_functions[idx].f_func(argvars, rettv); |
| 2144 | } |
| 2145 | |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2146 | /* |
| 2147 | * Invoke a method for base->method(). |
| 2148 | */ |
| 2149 | int |
| 2150 | call_internal_method( |
| 2151 | char_u *name, |
| 2152 | int argcount, |
| 2153 | typval_T *argvars, |
| 2154 | typval_T *rettv, |
| 2155 | typval_T *basetv) |
| 2156 | { |
| 2157 | int i; |
| 2158 | int fi; |
| 2159 | typval_T argv[MAX_FUNC_ARGS + 1]; |
| 2160 | |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 2161 | fi = find_internal_func(name); |
Bram Moolenaar | 9174639 | 2019-08-16 22:22:31 +0200 | [diff] [blame] | 2162 | if (fi < 0) |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2163 | return FCERR_UNKNOWN; |
Bram Moolenaar | 9174639 | 2019-08-16 22:22:31 +0200 | [diff] [blame] | 2164 | if (global_functions[fi].f_argtype == 0) |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2165 | return FCERR_NOTMETHOD; |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 2166 | if (argcount + 1 < global_functions[fi].f_min_argc) |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2167 | return FCERR_TOOFEW; |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 2168 | if (argcount + 1 > global_functions[fi].f_max_argc) |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2169 | return FCERR_TOOMANY; |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2170 | |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 2171 | if (global_functions[fi].f_argtype == FEARG_LAST) |
Bram Moolenaar | 25e4223 | 2019-08-04 15:04:10 +0200 | [diff] [blame] | 2172 | { |
| 2173 | // base value goes last |
| 2174 | for (i = 0; i < argcount; ++i) |
| 2175 | argv[i] = argvars[i]; |
| 2176 | argv[argcount] = *basetv; |
| 2177 | } |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 2178 | else if (global_functions[fi].f_argtype == FEARG_2) |
Bram Moolenaar | 25e4223 | 2019-08-04 15:04:10 +0200 | [diff] [blame] | 2179 | { |
| 2180 | // base value goes second |
| 2181 | argv[0] = argvars[0]; |
| 2182 | argv[1] = *basetv; |
| 2183 | for (i = 1; i < argcount; ++i) |
| 2184 | argv[i + 1] = argvars[i]; |
| 2185 | } |
Bram Moolenaar | 24278d2 | 2019-08-16 21:49:22 +0200 | [diff] [blame] | 2186 | else if (global_functions[fi].f_argtype == FEARG_3) |
| 2187 | { |
| 2188 | // base value goes third |
| 2189 | argv[0] = argvars[0]; |
| 2190 | argv[1] = argvars[1]; |
| 2191 | argv[2] = *basetv; |
| 2192 | for (i = 2; i < argcount; ++i) |
| 2193 | argv[i + 1] = argvars[i]; |
| 2194 | } |
Bram Moolenaar | aad222c | 2019-09-06 22:46:09 +0200 | [diff] [blame] | 2195 | else if (global_functions[fi].f_argtype == FEARG_4) |
| 2196 | { |
| 2197 | // base value goes fourth |
| 2198 | argv[0] = argvars[0]; |
| 2199 | argv[1] = argvars[1]; |
| 2200 | argv[2] = argvars[2]; |
| 2201 | argv[3] = *basetv; |
| 2202 | for (i = 3; i < argcount; ++i) |
| 2203 | argv[i + 1] = argvars[i]; |
| 2204 | } |
Bram Moolenaar | 25e4223 | 2019-08-04 15:04:10 +0200 | [diff] [blame] | 2205 | else |
| 2206 | { |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 2207 | // FEARG_1: base value goes first |
Bram Moolenaar | 25e4223 | 2019-08-04 15:04:10 +0200 | [diff] [blame] | 2208 | argv[0] = *basetv; |
| 2209 | for (i = 0; i < argcount; ++i) |
| 2210 | argv[i + 1] = argvars[i]; |
| 2211 | } |
Bram Moolenaar | ac92e25 | 2019-08-03 21:58:38 +0200 | [diff] [blame] | 2212 | argv[argcount + 1].v_type = VAR_UNKNOWN; |
| 2213 | |
Bram Moolenaar | 7a4ea1d | 2019-08-04 21:35:12 +0200 | [diff] [blame] | 2214 | global_functions[fi].f_func(argv, rettv); |
Bram Moolenaar | ef14054 | 2019-12-31 21:27:13 +0100 | [diff] [blame] | 2215 | return FCERR_NONE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2216 | } |
| 2217 | |
| 2218 | /* |
| 2219 | * Return TRUE for a non-zero Number and a non-empty String. |
| 2220 | */ |
Bram Moolenaar | 0e57dd8 | 2019-09-16 22:56:03 +0200 | [diff] [blame] | 2221 | int |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2222 | non_zero_arg(typval_T *argvars) |
| 2223 | { |
| 2224 | return ((argvars[0].v_type == VAR_NUMBER |
| 2225 | && argvars[0].vval.v_number != 0) |
Bram Moolenaar | 9b4a15d | 2020-01-11 16:05:23 +0100 | [diff] [blame] | 2226 | || (argvars[0].v_type == VAR_BOOL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2227 | && argvars[0].vval.v_number == VVAL_TRUE) |
| 2228 | || (argvars[0].v_type == VAR_STRING |
| 2229 | && argvars[0].vval.v_string != NULL |
| 2230 | && *argvars[0].vval.v_string != NUL)); |
| 2231 | } |
| 2232 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2233 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2234 | * "and(expr, expr)" function |
| 2235 | */ |
| 2236 | static void |
| 2237 | f_and(typval_T *argvars, typval_T *rettv) |
| 2238 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2239 | rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL) |
| 2240 | & tv_get_number_chk(&argvars[1], NULL); |
Bram Moolenaar | ca85159 | 2018-06-06 21:04:07 +0200 | [diff] [blame] | 2241 | } |
| 2242 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2243 | /* |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 2244 | * "balloon_show()" function |
| 2245 | */ |
| 2246 | #ifdef FEAT_BEVAL |
| 2247 | static void |
Bram Moolenaar | be0a259 | 2019-05-09 13:50:16 +0200 | [diff] [blame] | 2248 | f_balloon_gettext(typval_T *argvars UNUSED, typval_T *rettv) |
| 2249 | { |
| 2250 | rettv->v_type = VAR_STRING; |
| 2251 | if (balloonEval != NULL) |
| 2252 | { |
| 2253 | if (balloonEval->msg == NULL) |
| 2254 | rettv->vval.v_string = NULL; |
| 2255 | else |
| 2256 | rettv->vval.v_string = vim_strsave(balloonEval->msg); |
| 2257 | } |
| 2258 | } |
| 2259 | |
| 2260 | static void |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 2261 | f_balloon_show(typval_T *argvars, typval_T *rettv UNUSED) |
| 2262 | { |
Bram Moolenaar | caf6434 | 2017-03-02 22:11:33 +0100 | [diff] [blame] | 2263 | if (balloonEval != NULL) |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 2264 | { |
| 2265 | if (argvars[0].v_type == VAR_LIST |
| 2266 | # ifdef FEAT_GUI |
| 2267 | && !gui.in_use |
| 2268 | # endif |
| 2269 | ) |
Bram Moolenaar | be0a259 | 2019-05-09 13:50:16 +0200 | [diff] [blame] | 2270 | { |
| 2271 | list_T *l = argvars[0].vval.v_list; |
| 2272 | |
| 2273 | // empty list removes the balloon |
| 2274 | post_balloon(balloonEval, NULL, |
| 2275 | l == NULL || l->lv_len == 0 ? NULL : l); |
| 2276 | } |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 2277 | else |
Bram Moolenaar | be0a259 | 2019-05-09 13:50:16 +0200 | [diff] [blame] | 2278 | { |
Bram Moolenaar | 32105ae | 2021-03-27 18:59:25 +0100 | [diff] [blame] | 2279 | char_u *mesg; |
Bram Moolenaar | be0a259 | 2019-05-09 13:50:16 +0200 | [diff] [blame] | 2280 | |
Bram Moolenaar | 32105ae | 2021-03-27 18:59:25 +0100 | [diff] [blame] | 2281 | if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
| 2282 | return; |
| 2283 | |
| 2284 | mesg = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | be0a259 | 2019-05-09 13:50:16 +0200 | [diff] [blame] | 2285 | if (mesg != NULL) |
| 2286 | // empty string removes the balloon |
| 2287 | post_balloon(balloonEval, *mesg == NUL ? NULL : mesg, NULL); |
| 2288 | } |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 2289 | } |
| 2290 | } |
| 2291 | |
Bram Moolenaar | 669a828 | 2017-11-19 20:13:05 +0100 | [diff] [blame] | 2292 | # if defined(FEAT_BEVAL_TERM) |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 2293 | static void |
| 2294 | f_balloon_split(typval_T *argvars, typval_T *rettv UNUSED) |
| 2295 | { |
| 2296 | if (rettv_list_alloc(rettv) == OK) |
| 2297 | { |
Bram Moolenaar | 32105ae | 2021-03-27 18:59:25 +0100 | [diff] [blame] | 2298 | char_u *msg; |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 2299 | |
Bram Moolenaar | 32105ae | 2021-03-27 18:59:25 +0100 | [diff] [blame] | 2300 | if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
| 2301 | return; |
| 2302 | msg = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 2303 | if (msg != NULL) |
| 2304 | { |
| 2305 | pumitem_T *array; |
| 2306 | int size = split_message(msg, &array); |
| 2307 | int i; |
| 2308 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 2309 | // Skip the first and last item, they are always empty. |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 2310 | for (i = 1; i < size - 1; ++i) |
| 2311 | list_append_string(rettv->vval.v_list, array[i].pum_text, -1); |
Bram Moolenaar | b301f6b | 2018-02-10 15:38:35 +0100 | [diff] [blame] | 2312 | while (size > 0) |
| 2313 | vim_free(array[--size].pum_text); |
Bram Moolenaar | 246fe03 | 2017-11-19 19:56:27 +0100 | [diff] [blame] | 2314 | vim_free(array); |
| 2315 | } |
| 2316 | } |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 2317 | } |
Bram Moolenaar | 669a828 | 2017-11-19 20:13:05 +0100 | [diff] [blame] | 2318 | # endif |
Bram Moolenaar | 59716a2 | 2017-03-01 20:32:44 +0100 | [diff] [blame] | 2319 | #endif |
| 2320 | |
| 2321 | /* |
Bram Moolenaar | 6b7b719 | 2019-01-11 13:42:41 +0100 | [diff] [blame] | 2322 | * Get the buffer from "arg" and give an error and return NULL if it is not |
| 2323 | * valid. |
| 2324 | */ |
Bram Moolenaar | a334772 | 2019-05-11 21:14:24 +0200 | [diff] [blame] | 2325 | buf_T * |
Bram Moolenaar | 6b7b719 | 2019-01-11 13:42:41 +0100 | [diff] [blame] | 2326 | get_buf_arg(typval_T *arg) |
| 2327 | { |
| 2328 | buf_T *buf; |
| 2329 | |
| 2330 | ++emsg_off; |
| 2331 | buf = tv_get_buf(arg, FALSE); |
| 2332 | --emsg_off; |
| 2333 | if (buf == NULL) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2334 | semsg(_("E158: Invalid buffer name: %s"), tv_get_string(arg)); |
Bram Moolenaar | 6b7b719 | 2019-01-11 13:42:41 +0100 | [diff] [blame] | 2335 | return buf; |
| 2336 | } |
| 2337 | |
| 2338 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2339 | * "byte2line(byte)" function |
| 2340 | */ |
| 2341 | static void |
| 2342 | f_byte2line(typval_T *argvars UNUSED, typval_T *rettv) |
| 2343 | { |
| 2344 | #ifndef FEAT_BYTEOFF |
| 2345 | rettv->vval.v_number = -1; |
| 2346 | #else |
| 2347 | long boff = 0; |
| 2348 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 2349 | boff = tv_get_number(&argvars[0]) - 1; // boff gets -1 on type error |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2350 | if (boff < 0) |
| 2351 | rettv->vval.v_number = -1; |
| 2352 | else |
| 2353 | rettv->vval.v_number = ml_find_line_or_offset(curbuf, |
| 2354 | (linenr_T)0, &boff); |
| 2355 | #endif |
| 2356 | } |
| 2357 | |
| 2358 | static void |
| 2359 | byteidx(typval_T *argvars, typval_T *rettv, int comp UNUSED) |
| 2360 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2361 | char_u *t; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2362 | char_u *str; |
| 2363 | varnumber_T idx; |
| 2364 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2365 | str = tv_get_string_chk(&argvars[0]); |
| 2366 | idx = tv_get_number_chk(&argvars[1], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2367 | rettv->vval.v_number = -1; |
| 2368 | if (str == NULL || idx < 0) |
| 2369 | return; |
| 2370 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2371 | t = str; |
| 2372 | for ( ; idx > 0; idx--) |
| 2373 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 2374 | if (*t == NUL) // EOL reached |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2375 | return; |
| 2376 | if (enc_utf8 && comp) |
| 2377 | t += utf_ptr2len(t); |
| 2378 | else |
| 2379 | t += (*mb_ptr2len)(t); |
| 2380 | } |
| 2381 | rettv->vval.v_number = (varnumber_T)(t - str); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2382 | } |
| 2383 | |
| 2384 | /* |
| 2385 | * "byteidx()" function |
| 2386 | */ |
| 2387 | static void |
| 2388 | f_byteidx(typval_T *argvars, typval_T *rettv) |
| 2389 | { |
| 2390 | byteidx(argvars, rettv, FALSE); |
| 2391 | } |
| 2392 | |
| 2393 | /* |
| 2394 | * "byteidxcomp()" function |
| 2395 | */ |
| 2396 | static void |
| 2397 | f_byteidxcomp(typval_T *argvars, typval_T *rettv) |
| 2398 | { |
| 2399 | byteidx(argvars, rettv, TRUE); |
| 2400 | } |
| 2401 | |
| 2402 | /* |
| 2403 | * "call(func, arglist [, dict])" function |
| 2404 | */ |
| 2405 | static void |
| 2406 | f_call(typval_T *argvars, typval_T *rettv) |
| 2407 | { |
| 2408 | char_u *func; |
| 2409 | partial_T *partial = NULL; |
| 2410 | dict_T *selfdict = NULL; |
| 2411 | |
| 2412 | if (argvars[1].v_type != VAR_LIST) |
| 2413 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2414 | emsg(_(e_listreq)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2415 | return; |
| 2416 | } |
| 2417 | if (argvars[1].vval.v_list == NULL) |
| 2418 | return; |
| 2419 | |
| 2420 | if (argvars[0].v_type == VAR_FUNC) |
| 2421 | func = argvars[0].vval.v_string; |
| 2422 | else if (argvars[0].v_type == VAR_PARTIAL) |
| 2423 | { |
| 2424 | partial = argvars[0].vval.v_partial; |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 2425 | func = partial_name(partial); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2426 | } |
| 2427 | else |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2428 | func = tv_get_string(&argvars[0]); |
Dominique Pelle | fe8ebdb | 2021-05-13 14:55:55 +0200 | [diff] [blame] | 2429 | if (func == NULL || *func == NUL) |
| 2430 | return; // type error, empty name or null function |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2431 | |
| 2432 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 2433 | { |
| 2434 | if (argvars[2].v_type != VAR_DICT) |
| 2435 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2436 | emsg(_(e_dictreq)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2437 | return; |
| 2438 | } |
| 2439 | selfdict = argvars[2].vval.v_dict; |
| 2440 | } |
| 2441 | |
| 2442 | (void)func_call(func, &argvars[1], partial, selfdict, rettv); |
| 2443 | } |
| 2444 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2445 | /* |
| 2446 | * "changenr()" function |
| 2447 | */ |
| 2448 | static void |
| 2449 | f_changenr(typval_T *argvars UNUSED, typval_T *rettv) |
| 2450 | { |
| 2451 | rettv->vval.v_number = curbuf->b_u_seq_cur; |
| 2452 | } |
| 2453 | |
| 2454 | /* |
| 2455 | * "char2nr(string)" function |
| 2456 | */ |
| 2457 | static void |
| 2458 | f_char2nr(typval_T *argvars, typval_T *rettv) |
| 2459 | { |
Bram Moolenaar | c580943 | 2021-03-27 21:23:30 +0100 | [diff] [blame] | 2460 | if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
| 2461 | return; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2462 | if (has_mbyte) |
| 2463 | { |
| 2464 | int utf8 = 0; |
| 2465 | |
| 2466 | if (argvars[1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 24f7750 | 2020-09-04 19:50:57 +0200 | [diff] [blame] | 2467 | utf8 = (int)tv_get_bool_chk(&argvars[1], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2468 | |
| 2469 | if (utf8) |
Bram Moolenaar | bdace83 | 2019-03-02 10:13:42 +0100 | [diff] [blame] | 2470 | rettv->vval.v_number = utf_ptr2char(tv_get_string(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2471 | else |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2472 | rettv->vval.v_number = (*mb_ptr2char)(tv_get_string(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2473 | } |
| 2474 | else |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 2475 | rettv->vval.v_number = tv_get_string(&argvars[0])[0]; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2476 | } |
| 2477 | |
Bram Moolenaar | 17793ef | 2020-12-28 12:56:58 +0100 | [diff] [blame] | 2478 | /* |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2479 | * Get the current cursor column and store it in 'rettv'. If 'charcol' is TRUE, |
| 2480 | * returns the character index of the column. Otherwise, returns the byte index |
| 2481 | * of the column. |
| 2482 | */ |
| 2483 | static void |
| 2484 | get_col(typval_T *argvars, typval_T *rettv, int charcol) |
| 2485 | { |
| 2486 | colnr_T col = 0; |
| 2487 | pos_T *fp; |
| 2488 | int fnum = curbuf->b_fnum; |
| 2489 | |
| 2490 | fp = var2fpos(&argvars[0], FALSE, &fnum, charcol); |
| 2491 | if (fp != NULL && fnum == curbuf->b_fnum) |
| 2492 | { |
| 2493 | if (fp->col == MAXCOL) |
| 2494 | { |
| 2495 | // '> can be MAXCOL, get the length of the line then |
| 2496 | if (fp->lnum <= curbuf->b_ml.ml_line_count) |
| 2497 | col = (colnr_T)STRLEN(ml_get(fp->lnum)) + 1; |
| 2498 | else |
| 2499 | col = MAXCOL; |
| 2500 | } |
| 2501 | else |
| 2502 | { |
| 2503 | col = fp->col + 1; |
| 2504 | // col(".") when the cursor is on the NUL at the end of the line |
| 2505 | // because of "coladd" can be seen as an extra column. |
| 2506 | if (virtual_active() && fp == &curwin->w_cursor) |
| 2507 | { |
| 2508 | char_u *p = ml_get_cursor(); |
| 2509 | |
| 2510 | if (curwin->w_cursor.coladd >= (colnr_T)chartabsize(p, |
| 2511 | curwin->w_virtcol - curwin->w_cursor.coladd)) |
| 2512 | { |
| 2513 | int l; |
| 2514 | |
| 2515 | if (*p != NUL && p[(l = (*mb_ptr2len)(p))] == NUL) |
| 2516 | col += l; |
| 2517 | } |
| 2518 | } |
| 2519 | } |
| 2520 | } |
| 2521 | rettv->vval.v_number = col; |
| 2522 | } |
| 2523 | |
| 2524 | /* |
| 2525 | * "charcol()" function |
| 2526 | */ |
| 2527 | static void |
| 2528 | f_charcol(typval_T *argvars, typval_T *rettv) |
| 2529 | { |
| 2530 | get_col(argvars, rettv, TRUE); |
| 2531 | } |
| 2532 | |
| 2533 | /* |
Bram Moolenaar | 17793ef | 2020-12-28 12:56:58 +0100 | [diff] [blame] | 2534 | * "charidx()" function |
| 2535 | */ |
| 2536 | static void |
| 2537 | f_charidx(typval_T *argvars, typval_T *rettv) |
| 2538 | { |
| 2539 | char_u *str; |
| 2540 | varnumber_T idx; |
Bram Moolenaar | 239f8d9 | 2021-01-17 13:21:20 +0100 | [diff] [blame] | 2541 | varnumber_T countcc = FALSE; |
Bram Moolenaar | 17793ef | 2020-12-28 12:56:58 +0100 | [diff] [blame] | 2542 | char_u *p; |
| 2543 | int len; |
| 2544 | int (*ptr2len)(char_u *); |
| 2545 | |
| 2546 | rettv->vval.v_number = -1; |
| 2547 | |
| 2548 | if (argvars[0].v_type != VAR_STRING || argvars[1].v_type != VAR_NUMBER |
| 2549 | || (argvars[2].v_type != VAR_UNKNOWN |
| 2550 | && argvars[2].v_type != VAR_NUMBER)) |
| 2551 | { |
| 2552 | emsg(_(e_invarg)); |
| 2553 | return; |
| 2554 | } |
| 2555 | |
| 2556 | str = tv_get_string_chk(&argvars[0]); |
| 2557 | idx = tv_get_number_chk(&argvars[1], NULL); |
| 2558 | if (str == NULL || idx < 0) |
| 2559 | return; |
| 2560 | |
| 2561 | if (argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 239f8d9 | 2021-01-17 13:21:20 +0100 | [diff] [blame] | 2562 | countcc = tv_get_bool(&argvars[2]); |
Bram Moolenaar | 17793ef | 2020-12-28 12:56:58 +0100 | [diff] [blame] | 2563 | if (countcc < 0 || countcc > 1) |
| 2564 | { |
| 2565 | semsg(_(e_using_number_as_bool_nr), countcc); |
| 2566 | return; |
| 2567 | } |
| 2568 | |
| 2569 | if (enc_utf8 && countcc) |
| 2570 | ptr2len = utf_ptr2len; |
| 2571 | else |
| 2572 | ptr2len = mb_ptr2len; |
| 2573 | |
| 2574 | for (p = str, len = 0; p <= str + idx; len++) |
| 2575 | { |
| 2576 | if (*p == NUL) |
| 2577 | return; |
| 2578 | p += ptr2len(p); |
| 2579 | } |
| 2580 | |
| 2581 | rettv->vval.v_number = len > 0 ? len - 1 : 0; |
| 2582 | } |
| 2583 | |
Bram Moolenaar | 29b7d7a | 2019-07-22 23:03:57 +0200 | [diff] [blame] | 2584 | win_T * |
Bram Moolenaar | aff7491 | 2019-03-30 18:11:49 +0100 | [diff] [blame] | 2585 | get_optional_window(typval_T *argvars, int idx) |
| 2586 | { |
| 2587 | win_T *win = curwin; |
| 2588 | |
| 2589 | if (argvars[idx].v_type != VAR_UNKNOWN) |
| 2590 | { |
| 2591 | win = find_win_by_nr_or_id(&argvars[idx]); |
| 2592 | if (win == NULL) |
| 2593 | { |
| 2594 | emsg(_(e_invalwindow)); |
| 2595 | return NULL; |
| 2596 | } |
| 2597 | } |
| 2598 | return win; |
| 2599 | } |
| 2600 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2601 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2602 | * "col(string)" function |
| 2603 | */ |
| 2604 | static void |
| 2605 | f_col(typval_T *argvars, typval_T *rettv) |
| 2606 | { |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2607 | get_col(argvars, rettv, FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2608 | } |
| 2609 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2610 | /* |
| 2611 | * "confirm(message, buttons[, default [, type]])" function |
| 2612 | */ |
| 2613 | static void |
| 2614 | f_confirm(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 2615 | { |
| 2616 | #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) |
| 2617 | char_u *message; |
| 2618 | char_u *buttons = NULL; |
| 2619 | char_u buf[NUMBUFLEN]; |
| 2620 | char_u buf2[NUMBUFLEN]; |
| 2621 | int def = 1; |
| 2622 | int type = VIM_GENERIC; |
| 2623 | char_u *typestr; |
| 2624 | int error = FALSE; |
| 2625 | |
Bram Moolenaar | c580943 | 2021-03-27 21:23:30 +0100 | [diff] [blame] | 2626 | if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
| 2627 | return; |
| 2628 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2629 | message = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2630 | if (message == NULL) |
| 2631 | error = TRUE; |
| 2632 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 2633 | { |
Bram Moolenaar | c580943 | 2021-03-27 21:23:30 +0100 | [diff] [blame] | 2634 | if (in_vim9script() && check_for_string_arg(argvars, 1) == FAIL) |
| 2635 | return; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2636 | buttons = tv_get_string_buf_chk(&argvars[1], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2637 | if (buttons == NULL) |
| 2638 | error = TRUE; |
| 2639 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 2640 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2641 | def = (int)tv_get_number_chk(&argvars[2], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2642 | if (argvars[3].v_type != VAR_UNKNOWN) |
| 2643 | { |
Bram Moolenaar | c580943 | 2021-03-27 21:23:30 +0100 | [diff] [blame] | 2644 | if (in_vim9script() && check_for_string_arg(argvars, 3) == FAIL) |
| 2645 | return; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2646 | typestr = tv_get_string_buf_chk(&argvars[3], buf2); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2647 | if (typestr == NULL) |
| 2648 | error = TRUE; |
| 2649 | else |
| 2650 | { |
| 2651 | switch (TOUPPER_ASC(*typestr)) |
| 2652 | { |
| 2653 | case 'E': type = VIM_ERROR; break; |
| 2654 | case 'Q': type = VIM_QUESTION; break; |
| 2655 | case 'I': type = VIM_INFO; break; |
| 2656 | case 'W': type = VIM_WARNING; break; |
| 2657 | case 'G': type = VIM_GENERIC; break; |
| 2658 | } |
| 2659 | } |
| 2660 | } |
| 2661 | } |
| 2662 | } |
| 2663 | |
| 2664 | if (buttons == NULL || *buttons == NUL) |
| 2665 | buttons = (char_u *)_("&Ok"); |
| 2666 | |
| 2667 | if (!error) |
| 2668 | rettv->vval.v_number = do_dialog(type, NULL, message, buttons, |
| 2669 | def, NULL, FALSE); |
| 2670 | #endif |
| 2671 | } |
| 2672 | |
| 2673 | /* |
| 2674 | * "copy()" function |
| 2675 | */ |
| 2676 | static void |
| 2677 | f_copy(typval_T *argvars, typval_T *rettv) |
| 2678 | { |
| 2679 | item_copy(&argvars[0], rettv, FALSE, 0); |
| 2680 | } |
| 2681 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2682 | /* |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2683 | * Set the cursor position. |
Dominique Pelle | fe8ebdb | 2021-05-13 14:55:55 +0200 | [diff] [blame] | 2684 | * If 'charcol' is TRUE, then use the column number as a character offset. |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2685 | * Otherwise use the column number as a byte offset. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2686 | */ |
| 2687 | static void |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2688 | set_cursorpos(typval_T *argvars, typval_T *rettv, int charcol) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2689 | { |
| 2690 | long line, col; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2691 | long coladd = 0; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2692 | int set_curswant = TRUE; |
| 2693 | |
| 2694 | rettv->vval.v_number = -1; |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2695 | if (argvars[0].v_type == VAR_LIST) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2696 | { |
| 2697 | pos_T pos; |
| 2698 | colnr_T curswant = -1; |
| 2699 | |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2700 | if (list2fpos(argvars, &pos, NULL, &curswant, charcol) == FAIL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2701 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2702 | emsg(_(e_invarg)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2703 | return; |
| 2704 | } |
| 2705 | line = pos.lnum; |
| 2706 | col = pos.col; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2707 | coladd = pos.coladd; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2708 | if (curswant >= 0) |
| 2709 | { |
| 2710 | curwin->w_curswant = curswant - 1; |
| 2711 | set_curswant = FALSE; |
| 2712 | } |
| 2713 | } |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2714 | else if ((argvars[0].v_type == VAR_NUMBER || |
| 2715 | argvars[0].v_type == VAR_STRING) |
Bram Moolenaar | 9ebcf23 | 2021-01-16 16:52:49 +0100 | [diff] [blame] | 2716 | && (argvars[1].v_type == VAR_NUMBER || |
| 2717 | argvars[1].v_type == VAR_STRING)) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2718 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2719 | line = tv_get_lnum(argvars); |
Bram Moolenaar | 9a96337 | 2020-12-21 21:58:46 +0100 | [diff] [blame] | 2720 | if (line < 0) |
| 2721 | semsg(_(e_invarg2), tv_get_string(&argvars[0])); |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2722 | col = (long)tv_get_number_chk(&argvars[1], NULL); |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2723 | if (charcol) |
Bram Moolenaar | 9145846 | 2021-01-13 20:08:38 +0100 | [diff] [blame] | 2724 | col = buf_charidx_to_byteidx(curbuf, line, col) + 1; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2725 | if (argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2726 | coladd = (long)tv_get_number_chk(&argvars[2], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2727 | } |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2728 | else |
| 2729 | { |
| 2730 | emsg(_(e_invarg)); |
| 2731 | return; |
| 2732 | } |
Bram Moolenaar | 29ddebe | 2019-01-26 17:28:26 +0100 | [diff] [blame] | 2733 | if (line < 0 || col < 0 || coladd < 0) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 2734 | return; // type error; errmsg already given |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2735 | if (line > 0) |
| 2736 | curwin->w_cursor.lnum = line; |
| 2737 | if (col > 0) |
| 2738 | curwin->w_cursor.col = col - 1; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2739 | curwin->w_cursor.coladd = coladd; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2740 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 2741 | // Make sure the cursor is in a valid position. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2742 | check_cursor(); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 2743 | // Correct cursor for multi-byte character. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2744 | if (has_mbyte) |
| 2745 | mb_adjust_cursor(); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2746 | |
| 2747 | curwin->w_set_curswant = set_curswant; |
| 2748 | rettv->vval.v_number = 0; |
| 2749 | } |
| 2750 | |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 2751 | /* |
| 2752 | * "cursor(lnum, col)" function, or |
| 2753 | * "cursor(list)" |
| 2754 | * |
| 2755 | * Moves the cursor to the specified line and column. |
| 2756 | * Returns 0 when the position could be set, -1 otherwise. |
| 2757 | */ |
| 2758 | static void |
| 2759 | f_cursor(typval_T *argvars, typval_T *rettv) |
| 2760 | { |
| 2761 | set_cursorpos(argvars, rettv, FALSE); |
| 2762 | } |
| 2763 | |
Bram Moolenaar | 4f97475 | 2019-02-17 17:44:42 +0100 | [diff] [blame] | 2764 | #ifdef MSWIN |
Bram Moolenaar | 4551c0a | 2018-06-20 22:38:21 +0200 | [diff] [blame] | 2765 | /* |
| 2766 | * "debugbreak()" function |
| 2767 | */ |
| 2768 | static void |
| 2769 | f_debugbreak(typval_T *argvars, typval_T *rettv) |
| 2770 | { |
| 2771 | int pid; |
| 2772 | |
| 2773 | rettv->vval.v_number = FAIL; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2774 | pid = (int)tv_get_number(&argvars[0]); |
Bram Moolenaar | 4551c0a | 2018-06-20 22:38:21 +0200 | [diff] [blame] | 2775 | if (pid == 0) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2776 | emsg(_(e_invarg)); |
Bram Moolenaar | 4551c0a | 2018-06-20 22:38:21 +0200 | [diff] [blame] | 2777 | else |
| 2778 | { |
| 2779 | HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid); |
| 2780 | |
| 2781 | if (hProcess != NULL) |
| 2782 | { |
| 2783 | DebugBreakProcess(hProcess); |
| 2784 | CloseHandle(hProcess); |
| 2785 | rettv->vval.v_number = OK; |
| 2786 | } |
| 2787 | } |
| 2788 | } |
| 2789 | #endif |
| 2790 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2791 | /* |
| 2792 | * "deepcopy()" function |
| 2793 | */ |
| 2794 | static void |
| 2795 | f_deepcopy(typval_T *argvars, typval_T *rettv) |
| 2796 | { |
Bram Moolenaar | 239f8d9 | 2021-01-17 13:21:20 +0100 | [diff] [blame] | 2797 | varnumber_T noref = 0; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2798 | int copyID; |
| 2799 | |
| 2800 | if (argvars[1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 239f8d9 | 2021-01-17 13:21:20 +0100 | [diff] [blame] | 2801 | noref = tv_get_bool_chk(&argvars[1], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2802 | if (noref < 0 || noref > 1) |
Bram Moolenaar | bade44e | 2020-09-26 22:39:24 +0200 | [diff] [blame] | 2803 | semsg(_(e_using_number_as_bool_nr), noref); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2804 | else |
| 2805 | { |
| 2806 | copyID = get_copyID(); |
| 2807 | item_copy(&argvars[0], rettv, TRUE, noref == 0 ? copyID : 0); |
| 2808 | } |
| 2809 | } |
| 2810 | |
| 2811 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2812 | * "did_filetype()" function |
| 2813 | */ |
| 2814 | static void |
| 2815 | f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 2816 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2817 | rettv->vval.v_number = did_filetype; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2818 | } |
| 2819 | |
| 2820 | /* |
Bram Moolenaar | 4132eb5 | 2020-02-14 16:53:00 +0100 | [diff] [blame] | 2821 | * "echoraw({expr})" function |
| 2822 | */ |
| 2823 | static void |
| 2824 | f_echoraw(typval_T *argvars, typval_T *rettv UNUSED) |
| 2825 | { |
| 2826 | char_u *str = tv_get_string_chk(&argvars[0]); |
| 2827 | |
| 2828 | if (str != NULL && *str != NUL) |
| 2829 | { |
| 2830 | out_str(str); |
| 2831 | out_flush(); |
| 2832 | } |
| 2833 | } |
| 2834 | |
| 2835 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2836 | * "empty({expr})" function |
| 2837 | */ |
| 2838 | static void |
| 2839 | f_empty(typval_T *argvars, typval_T *rettv) |
| 2840 | { |
| 2841 | int n = FALSE; |
| 2842 | |
| 2843 | switch (argvars[0].v_type) |
| 2844 | { |
| 2845 | case VAR_STRING: |
| 2846 | case VAR_FUNC: |
| 2847 | n = argvars[0].vval.v_string == NULL |
| 2848 | || *argvars[0].vval.v_string == NUL; |
| 2849 | break; |
| 2850 | case VAR_PARTIAL: |
| 2851 | n = FALSE; |
| 2852 | break; |
| 2853 | case VAR_NUMBER: |
| 2854 | n = argvars[0].vval.v_number == 0; |
| 2855 | break; |
| 2856 | case VAR_FLOAT: |
| 2857 | #ifdef FEAT_FLOAT |
| 2858 | n = argvars[0].vval.v_float == 0.0; |
| 2859 | break; |
| 2860 | #endif |
| 2861 | case VAR_LIST: |
| 2862 | n = argvars[0].vval.v_list == NULL |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 2863 | || argvars[0].vval.v_list->lv_len == 0; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2864 | break; |
| 2865 | case VAR_DICT: |
| 2866 | n = argvars[0].vval.v_dict == NULL |
| 2867 | || argvars[0].vval.v_dict->dv_hashtab.ht_used == 0; |
| 2868 | break; |
Bram Moolenaar | 9b4a15d | 2020-01-11 16:05:23 +0100 | [diff] [blame] | 2869 | case VAR_BOOL: |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2870 | case VAR_SPECIAL: |
| 2871 | n = argvars[0].vval.v_number != VVAL_TRUE; |
| 2872 | break; |
| 2873 | |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 2874 | case VAR_BLOB: |
| 2875 | n = argvars[0].vval.v_blob == NULL |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 2876 | || argvars[0].vval.v_blob->bv_ga.ga_len == 0; |
| 2877 | break; |
| 2878 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2879 | case VAR_JOB: |
| 2880 | #ifdef FEAT_JOB_CHANNEL |
| 2881 | n = argvars[0].vval.v_job == NULL |
| 2882 | || argvars[0].vval.v_job->jv_status != JOB_STARTED; |
| 2883 | break; |
| 2884 | #endif |
| 2885 | case VAR_CHANNEL: |
| 2886 | #ifdef FEAT_JOB_CHANNEL |
| 2887 | n = argvars[0].vval.v_channel == NULL |
| 2888 | || !channel_is_open(argvars[0].vval.v_channel); |
| 2889 | break; |
| 2890 | #endif |
| 2891 | case VAR_UNKNOWN: |
Bram Moolenaar | 4c68375 | 2020-04-05 21:38:23 +0200 | [diff] [blame] | 2892 | case VAR_ANY: |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 2893 | case VAR_VOID: |
Bram Moolenaar | f18332f | 2021-05-07 17:55:55 +0200 | [diff] [blame] | 2894 | case VAR_INSTR: |
Bram Moolenaar | dd58923 | 2020-02-29 17:38:12 +0100 | [diff] [blame] | 2895 | internal_error_no_abort("f_empty(UNKNOWN)"); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2896 | n = TRUE; |
| 2897 | break; |
| 2898 | } |
| 2899 | |
| 2900 | rettv->vval.v_number = n; |
| 2901 | } |
| 2902 | |
| 2903 | /* |
Bram Moolenaar | 691ddee | 2019-05-09 14:52:41 +0200 | [diff] [blame] | 2904 | * "environ()" function |
| 2905 | */ |
| 2906 | static void |
| 2907 | f_environ(typval_T *argvars UNUSED, typval_T *rettv) |
| 2908 | { |
| 2909 | #if !defined(AMIGA) |
| 2910 | int i = 0; |
| 2911 | char_u *entry, *value; |
| 2912 | # ifdef MSWIN |
| 2913 | extern wchar_t **_wenviron; |
| 2914 | # else |
| 2915 | extern char **environ; |
| 2916 | # endif |
| 2917 | |
| 2918 | if (rettv_dict_alloc(rettv) != OK) |
| 2919 | return; |
| 2920 | |
| 2921 | # ifdef MSWIN |
| 2922 | if (*_wenviron == NULL) |
| 2923 | return; |
| 2924 | # else |
| 2925 | if (*environ == NULL) |
| 2926 | return; |
| 2927 | # endif |
| 2928 | |
| 2929 | for (i = 0; ; ++i) |
| 2930 | { |
| 2931 | # ifdef MSWIN |
| 2932 | short_u *p; |
| 2933 | |
| 2934 | if ((p = (short_u *)_wenviron[i]) == NULL) |
| 2935 | return; |
| 2936 | entry = utf16_to_enc(p, NULL); |
| 2937 | # else |
| 2938 | if ((entry = (char_u *)environ[i]) == NULL) |
| 2939 | return; |
| 2940 | entry = vim_strsave(entry); |
| 2941 | # endif |
| 2942 | if (entry == NULL) // out of memory |
| 2943 | return; |
| 2944 | if ((value = vim_strchr(entry, '=')) == NULL) |
| 2945 | { |
| 2946 | vim_free(entry); |
| 2947 | continue; |
| 2948 | } |
| 2949 | *value++ = NUL; |
| 2950 | dict_add_string(rettv->vval.v_dict, (char *)entry, value); |
| 2951 | vim_free(entry); |
| 2952 | } |
| 2953 | #endif |
| 2954 | } |
| 2955 | |
| 2956 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2957 | * "escape({string}, {chars})" function |
| 2958 | */ |
| 2959 | static void |
| 2960 | f_escape(typval_T *argvars, typval_T *rettv) |
| 2961 | { |
| 2962 | char_u buf[NUMBUFLEN]; |
| 2963 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2964 | rettv->vval.v_string = vim_strsave_escaped(tv_get_string(&argvars[0]), |
| 2965 | tv_get_string_buf(&argvars[1], buf)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2966 | rettv->v_type = VAR_STRING; |
| 2967 | } |
| 2968 | |
| 2969 | /* |
| 2970 | * "eval()" function |
| 2971 | */ |
| 2972 | static void |
| 2973 | f_eval(typval_T *argvars, typval_T *rettv) |
| 2974 | { |
| 2975 | char_u *s, *p; |
| 2976 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 2977 | s = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2978 | if (s != NULL) |
| 2979 | s = skipwhite(s); |
| 2980 | |
| 2981 | p = s; |
Bram Moolenaar | 5409f5d | 2020-06-24 18:37:35 +0200 | [diff] [blame] | 2982 | if (s == NULL || eval1(&s, rettv, &EVALARG_EVALUATE) == FAIL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2983 | { |
| 2984 | if (p != NULL && !aborting()) |
Bram Moolenaar | 108010a | 2021-06-27 22:03:33 +0200 | [diff] [blame] | 2985 | semsg(_(e_invalid_expression_str), p); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2986 | need_clr_eos = FALSE; |
| 2987 | rettv->v_type = VAR_NUMBER; |
| 2988 | rettv->vval.v_number = 0; |
| 2989 | } |
| 2990 | else if (*s != NUL) |
Bram Moolenaar | 2d06bfd | 2020-07-23 17:16:18 +0200 | [diff] [blame] | 2991 | semsg(_(e_trailing_arg), s); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 2992 | } |
| 2993 | |
| 2994 | /* |
| 2995 | * "eventhandler()" function |
| 2996 | */ |
| 2997 | static void |
| 2998 | f_eventhandler(typval_T *argvars UNUSED, typval_T *rettv) |
| 2999 | { |
Bram Moolenaar | dfc33a6 | 2020-04-29 22:30:13 +0200 | [diff] [blame] | 3000 | rettv->vval.v_number = vgetc_busy || input_busy; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3001 | } |
| 3002 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3003 | static garray_T redir_execute_ga; |
| 3004 | |
| 3005 | /* |
| 3006 | * Append "value[value_len]" to the execute() output. |
| 3007 | */ |
| 3008 | void |
| 3009 | execute_redir_str(char_u *value, int value_len) |
| 3010 | { |
| 3011 | int len; |
| 3012 | |
| 3013 | if (value_len == -1) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3014 | len = (int)STRLEN(value); // Append the entire string |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3015 | else |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3016 | len = value_len; // Append only "value_len" characters |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3017 | if (ga_grow(&redir_execute_ga, len) == OK) |
| 3018 | { |
| 3019 | mch_memmove((char *)redir_execute_ga.ga_data |
| 3020 | + redir_execute_ga.ga_len, value, len); |
| 3021 | redir_execute_ga.ga_len += len; |
| 3022 | } |
| 3023 | } |
| 3024 | |
| 3025 | /* |
| 3026 | * Get next line from a list. |
| 3027 | * Called by do_cmdline() to get the next line. |
| 3028 | * Returns allocated string, or NULL for end of function. |
| 3029 | */ |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3030 | static char_u * |
| 3031 | get_list_line( |
| 3032 | int c UNUSED, |
| 3033 | void *cookie, |
Bram Moolenaar | e96a249 | 2019-06-25 04:12:16 +0200 | [diff] [blame] | 3034 | int indent UNUSED, |
Bram Moolenaar | 66250c9 | 2020-08-20 15:02:42 +0200 | [diff] [blame] | 3035 | getline_opt_T options UNUSED) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3036 | { |
| 3037 | listitem_T **p = (listitem_T **)cookie; |
| 3038 | listitem_T *item = *p; |
| 3039 | char_u buf[NUMBUFLEN]; |
| 3040 | char_u *s; |
| 3041 | |
| 3042 | if (item == NULL) |
| 3043 | return NULL; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3044 | s = tv_get_string_buf_chk(&item->li_tv, buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3045 | *p = item->li_next; |
| 3046 | return s == NULL ? NULL : vim_strsave(s); |
| 3047 | } |
| 3048 | |
| 3049 | /* |
| 3050 | * "execute()" function |
| 3051 | */ |
Bram Moolenaar | 261f346 | 2019-09-07 15:45:32 +0200 | [diff] [blame] | 3052 | void |
Bram Moolenaar | 868b7b6 | 2019-05-29 21:44:40 +0200 | [diff] [blame] | 3053 | execute_common(typval_T *argvars, typval_T *rettv, int arg_off) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3054 | { |
| 3055 | char_u *cmd = NULL; |
| 3056 | list_T *list = NULL; |
| 3057 | int save_msg_silent = msg_silent; |
| 3058 | int save_emsg_silent = emsg_silent; |
| 3059 | int save_emsg_noredir = emsg_noredir; |
| 3060 | int save_redir_execute = redir_execute; |
Bram Moolenaar | 2095148 | 2017-12-25 13:44:43 +0100 | [diff] [blame] | 3061 | int save_redir_off = redir_off; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3062 | garray_T save_ga; |
Bram Moolenaar | 10ccaa1 | 2018-12-07 16:38:23 +0100 | [diff] [blame] | 3063 | int save_msg_col = msg_col; |
Bram Moolenaar | 446e7a3 | 2018-12-08 13:57:42 +0100 | [diff] [blame] | 3064 | int echo_output = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3065 | |
| 3066 | rettv->vval.v_string = NULL; |
| 3067 | rettv->v_type = VAR_STRING; |
| 3068 | |
Bram Moolenaar | 868b7b6 | 2019-05-29 21:44:40 +0200 | [diff] [blame] | 3069 | if (argvars[arg_off].v_type == VAR_LIST) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3070 | { |
Bram Moolenaar | 868b7b6 | 2019-05-29 21:44:40 +0200 | [diff] [blame] | 3071 | list = argvars[arg_off].vval.v_list; |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 3072 | if (list == NULL || list->lv_len == 0) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3073 | // empty list, no commands, empty output |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3074 | return; |
| 3075 | ++list->lv_refcount; |
| 3076 | } |
Bram Moolenaar | e2a8f07 | 2020-01-08 19:32:18 +0100 | [diff] [blame] | 3077 | else if (argvars[arg_off].v_type == VAR_JOB |
| 3078 | || argvars[arg_off].v_type == VAR_CHANNEL) |
| 3079 | { |
Bram Moolenaar | 68db996 | 2021-05-09 23:19:22 +0200 | [diff] [blame] | 3080 | semsg(_(e_using_invalid_value_as_string_str), |
| 3081 | vartype_name(argvars[arg_off].v_type)); |
Bram Moolenaar | e2a8f07 | 2020-01-08 19:32:18 +0100 | [diff] [blame] | 3082 | return; |
| 3083 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3084 | else |
| 3085 | { |
Bram Moolenaar | 868b7b6 | 2019-05-29 21:44:40 +0200 | [diff] [blame] | 3086 | cmd = tv_get_string_chk(&argvars[arg_off]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3087 | if (cmd == NULL) |
| 3088 | return; |
| 3089 | } |
| 3090 | |
Bram Moolenaar | 868b7b6 | 2019-05-29 21:44:40 +0200 | [diff] [blame] | 3091 | if (argvars[arg_off + 1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3092 | { |
| 3093 | char_u buf[NUMBUFLEN]; |
Bram Moolenaar | 3cfa5b1 | 2021-06-06 14:14:39 +0200 | [diff] [blame] | 3094 | char_u *s = tv_get_string_buf_chk_strict(&argvars[arg_off + 1], buf, |
| 3095 | in_vim9script()); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3096 | |
| 3097 | if (s == NULL) |
| 3098 | return; |
Bram Moolenaar | 446e7a3 | 2018-12-08 13:57:42 +0100 | [diff] [blame] | 3099 | if (*s == NUL) |
| 3100 | echo_output = TRUE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3101 | if (STRNCMP(s, "silent", 6) == 0) |
| 3102 | ++msg_silent; |
| 3103 | if (STRCMP(s, "silent!") == 0) |
| 3104 | { |
| 3105 | emsg_silent = TRUE; |
| 3106 | emsg_noredir = TRUE; |
| 3107 | } |
| 3108 | } |
| 3109 | else |
| 3110 | ++msg_silent; |
| 3111 | |
| 3112 | if (redir_execute) |
| 3113 | save_ga = redir_execute_ga; |
| 3114 | ga_init2(&redir_execute_ga, (int)sizeof(char), 500); |
| 3115 | redir_execute = TRUE; |
Bram Moolenaar | 2095148 | 2017-12-25 13:44:43 +0100 | [diff] [blame] | 3116 | redir_off = FALSE; |
Bram Moolenaar | 446e7a3 | 2018-12-08 13:57:42 +0100 | [diff] [blame] | 3117 | if (!echo_output) |
| 3118 | msg_col = 0; // prevent leading spaces |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3119 | |
| 3120 | if (cmd != NULL) |
| 3121 | do_cmdline_cmd(cmd); |
| 3122 | else |
| 3123 | { |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 3124 | listitem_T *item; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3125 | |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 3126 | CHECK_LIST_MATERIALIZE(list); |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 3127 | item = list->lv_first; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3128 | do_cmdline(NULL, get_list_line, (void *)&item, |
| 3129 | DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED); |
| 3130 | --list->lv_refcount; |
| 3131 | } |
| 3132 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3133 | // Need to append a NUL to the result. |
Bram Moolenaar | d297f35 | 2017-01-29 20:31:21 +0100 | [diff] [blame] | 3134 | if (ga_grow(&redir_execute_ga, 1) == OK) |
| 3135 | { |
| 3136 | ((char *)redir_execute_ga.ga_data)[redir_execute_ga.ga_len] = NUL; |
| 3137 | rettv->vval.v_string = redir_execute_ga.ga_data; |
| 3138 | } |
| 3139 | else |
| 3140 | { |
| 3141 | ga_clear(&redir_execute_ga); |
| 3142 | rettv->vval.v_string = NULL; |
| 3143 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3144 | msg_silent = save_msg_silent; |
| 3145 | emsg_silent = save_emsg_silent; |
| 3146 | emsg_noredir = save_emsg_noredir; |
| 3147 | |
| 3148 | redir_execute = save_redir_execute; |
| 3149 | if (redir_execute) |
| 3150 | redir_execute_ga = save_ga; |
Bram Moolenaar | 2095148 | 2017-12-25 13:44:43 +0100 | [diff] [blame] | 3151 | redir_off = save_redir_off; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3152 | |
Bram Moolenaar | 10ccaa1 | 2018-12-07 16:38:23 +0100 | [diff] [blame] | 3153 | // "silent reg" or "silent echo x" leaves msg_col somewhere in the line. |
Bram Moolenaar | 446e7a3 | 2018-12-08 13:57:42 +0100 | [diff] [blame] | 3154 | if (echo_output) |
| 3155 | // When not working silently: put it in column zero. A following |
| 3156 | // "echon" will overwrite the message, unavoidably. |
| 3157 | msg_col = 0; |
| 3158 | else |
| 3159 | // When working silently: Put it back where it was, since nothing |
| 3160 | // should have been written. |
| 3161 | msg_col = save_msg_col; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3162 | } |
| 3163 | |
| 3164 | /* |
Bram Moolenaar | 868b7b6 | 2019-05-29 21:44:40 +0200 | [diff] [blame] | 3165 | * "execute()" function |
| 3166 | */ |
| 3167 | static void |
| 3168 | f_execute(typval_T *argvars, typval_T *rettv) |
| 3169 | { |
| 3170 | execute_common(argvars, rettv, 0); |
| 3171 | } |
| 3172 | |
| 3173 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3174 | * "exists()" function |
| 3175 | */ |
| 3176 | static void |
| 3177 | f_exists(typval_T *argvars, typval_T *rettv) |
| 3178 | { |
| 3179 | char_u *p; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3180 | int n = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3181 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3182 | p = tv_get_string(&argvars[0]); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3183 | if (*p == '$') // environment variable |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3184 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3185 | // first try "normal" environment variables (fast) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3186 | if (mch_getenv(p + 1) != NULL) |
| 3187 | n = TRUE; |
| 3188 | else |
| 3189 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3190 | // try expanding things like $VIM and ${HOME} |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3191 | p = expand_env_save(p); |
| 3192 | if (p != NULL && *p != '$') |
| 3193 | n = TRUE; |
| 3194 | vim_free(p); |
| 3195 | } |
| 3196 | } |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3197 | else if (*p == '&' || *p == '+') // option |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3198 | { |
Bram Moolenaar | 9a78e6d | 2020-07-01 18:29:55 +0200 | [diff] [blame] | 3199 | n = (eval_option(&p, NULL, TRUE) == OK); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3200 | if (*skipwhite(p) != NUL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3201 | n = FALSE; // trailing garbage |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3202 | } |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3203 | else if (*p == '*') // internal or user defined function |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3204 | { |
Bram Moolenaar | b54c3ff | 2016-07-31 14:11:58 +0200 | [diff] [blame] | 3205 | n = function_exists(p + 1, FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3206 | } |
Bram Moolenaar | 15c4760 | 2020-03-26 22:16:48 +0100 | [diff] [blame] | 3207 | else if (*p == '?') // internal function only |
| 3208 | { |
| 3209 | n = has_internal_func_name(p + 1); |
| 3210 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3211 | else if (*p == ':') |
| 3212 | { |
| 3213 | n = cmd_exists(p + 1); |
| 3214 | } |
| 3215 | else if (*p == '#') |
| 3216 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3217 | if (p[1] == '#') |
| 3218 | n = autocmd_supported(p + 2); |
| 3219 | else |
| 3220 | n = au_exists(p + 1); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3221 | } |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3222 | else // internal variable |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3223 | { |
Bram Moolenaar | c6f9f73 | 2018-02-11 19:06:26 +0100 | [diff] [blame] | 3224 | n = var_exists(p); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3225 | } |
| 3226 | |
| 3227 | rettv->vval.v_number = n; |
| 3228 | } |
| 3229 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3230 | /* |
| 3231 | * "expand()" function |
| 3232 | */ |
| 3233 | static void |
| 3234 | f_expand(typval_T *argvars, typval_T *rettv) |
| 3235 | { |
| 3236 | char_u *s; |
| 3237 | int len; |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 3238 | char *errormsg; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3239 | int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND; |
| 3240 | expand_T xpc; |
| 3241 | int error = FALSE; |
| 3242 | char_u *result; |
Bram Moolenaar | 8f187fc | 2020-09-26 18:47:11 +0200 | [diff] [blame] | 3243 | #ifdef BACKSLASH_IN_FILENAME |
| 3244 | char_u *p_csl_save = p_csl; |
| 3245 | |
| 3246 | // avoid using 'completeslash' here |
| 3247 | p_csl = empty_option; |
| 3248 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3249 | |
| 3250 | rettv->v_type = VAR_STRING; |
| 3251 | if (argvars[1].v_type != VAR_UNKNOWN |
| 3252 | && argvars[2].v_type != VAR_UNKNOWN |
Bram Moolenaar | 551d25e | 2020-09-02 21:37:56 +0200 | [diff] [blame] | 3253 | && tv_get_bool_chk(&argvars[2], &error) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3254 | && !error) |
Bram Moolenaar | 45cf6e9 | 2017-04-30 20:25:19 +0200 | [diff] [blame] | 3255 | rettv_list_set(rettv, NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3256 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3257 | s = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3258 | if (*s == '%' || *s == '#' || *s == '<') |
| 3259 | { |
| 3260 | ++emsg_off; |
| 3261 | result = eval_vars(s, s, &len, NULL, &errormsg, NULL); |
| 3262 | --emsg_off; |
| 3263 | if (rettv->v_type == VAR_LIST) |
| 3264 | { |
| 3265 | if (rettv_list_alloc(rettv) != FAIL && result != NULL) |
| 3266 | list_append_string(rettv->vval.v_list, result, -1); |
Bram Moolenaar | 8617348 | 2019-10-01 17:02:16 +0200 | [diff] [blame] | 3267 | vim_free(result); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3268 | } |
| 3269 | else |
| 3270 | rettv->vval.v_string = result; |
| 3271 | } |
| 3272 | else |
| 3273 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3274 | // When the optional second argument is non-zero, don't remove matches |
| 3275 | // for 'wildignore' and don't put matches for 'suffixes' at the end. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3276 | if (argvars[1].v_type != VAR_UNKNOWN |
Bram Moolenaar | 551d25e | 2020-09-02 21:37:56 +0200 | [diff] [blame] | 3277 | && tv_get_bool_chk(&argvars[1], &error)) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3278 | options |= WILD_KEEP_ALL; |
| 3279 | if (!error) |
| 3280 | { |
| 3281 | ExpandInit(&xpc); |
| 3282 | xpc.xp_context = EXPAND_FILES; |
| 3283 | if (p_wic) |
| 3284 | options += WILD_ICASE; |
| 3285 | if (rettv->v_type == VAR_STRING) |
| 3286 | rettv->vval.v_string = ExpandOne(&xpc, s, NULL, |
| 3287 | options, WILD_ALL); |
| 3288 | else if (rettv_list_alloc(rettv) != FAIL) |
| 3289 | { |
| 3290 | int i; |
| 3291 | |
| 3292 | ExpandOne(&xpc, s, NULL, options, WILD_ALL_KEEP); |
| 3293 | for (i = 0; i < xpc.xp_numfiles; i++) |
| 3294 | list_append_string(rettv->vval.v_list, xpc.xp_files[i], -1); |
| 3295 | ExpandCleanup(&xpc); |
| 3296 | } |
| 3297 | } |
| 3298 | else |
| 3299 | rettv->vval.v_string = NULL; |
| 3300 | } |
Bram Moolenaar | 8f187fc | 2020-09-26 18:47:11 +0200 | [diff] [blame] | 3301 | #ifdef BACKSLASH_IN_FILENAME |
| 3302 | p_csl = p_csl_save; |
| 3303 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3304 | } |
| 3305 | |
| 3306 | /* |
Bram Moolenaar | 80dad48 | 2019-06-09 17:22:31 +0200 | [diff] [blame] | 3307 | * "expandcmd()" function |
| 3308 | * Expand all the special characters in a command string. |
| 3309 | */ |
| 3310 | static void |
| 3311 | f_expandcmd(typval_T *argvars, typval_T *rettv) |
| 3312 | { |
| 3313 | exarg_T eap; |
| 3314 | char_u *cmdstr; |
| 3315 | char *errormsg = NULL; |
| 3316 | |
| 3317 | rettv->v_type = VAR_STRING; |
| 3318 | cmdstr = vim_strsave(tv_get_string(&argvars[0])); |
| 3319 | |
| 3320 | memset(&eap, 0, sizeof(eap)); |
| 3321 | eap.cmd = cmdstr; |
| 3322 | eap.arg = cmdstr; |
Bram Moolenaar | 8071cb2 | 2019-07-12 17:58:01 +0200 | [diff] [blame] | 3323 | eap.argt |= EX_NOSPC; |
Bram Moolenaar | 80dad48 | 2019-06-09 17:22:31 +0200 | [diff] [blame] | 3324 | eap.usefilter = FALSE; |
| 3325 | eap.nextcmd = NULL; |
| 3326 | eap.cmdidx = CMD_USER; |
| 3327 | |
| 3328 | expand_filename(&eap, &cmdstr, &errormsg); |
| 3329 | if (errormsg != NULL && *errormsg != NUL) |
| 3330 | emsg(errormsg); |
| 3331 | |
| 3332 | rettv->vval.v_string = cmdstr; |
| 3333 | } |
| 3334 | |
| 3335 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3336 | * "feedkeys()" function |
| 3337 | */ |
| 3338 | static void |
| 3339 | f_feedkeys(typval_T *argvars, typval_T *rettv UNUSED) |
| 3340 | { |
| 3341 | int remap = TRUE; |
| 3342 | int insert = FALSE; |
| 3343 | char_u *keys, *flags; |
| 3344 | char_u nbuf[NUMBUFLEN]; |
| 3345 | int typed = FALSE; |
| 3346 | int execute = FALSE; |
| 3347 | int dangerous = FALSE; |
Bram Moolenaar | 5e66b42 | 2019-01-24 21:58:10 +0100 | [diff] [blame] | 3348 | int lowlevel = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3349 | char_u *keys_esc; |
| 3350 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3351 | // This is not allowed in the sandbox. If the commands would still be |
| 3352 | // executed in the sandbox it would be OK, but it probably happens later, |
| 3353 | // when "sandbox" is no longer set. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3354 | if (check_secure()) |
| 3355 | return; |
| 3356 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3357 | keys = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3358 | |
| 3359 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 3360 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3361 | flags = tv_get_string_buf(&argvars[1], nbuf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3362 | for ( ; *flags != NUL; ++flags) |
| 3363 | { |
| 3364 | switch (*flags) |
| 3365 | { |
| 3366 | case 'n': remap = FALSE; break; |
| 3367 | case 'm': remap = TRUE; break; |
| 3368 | case 't': typed = TRUE; break; |
| 3369 | case 'i': insert = TRUE; break; |
| 3370 | case 'x': execute = TRUE; break; |
| 3371 | case '!': dangerous = TRUE; break; |
Bram Moolenaar | 5e66b42 | 2019-01-24 21:58:10 +0100 | [diff] [blame] | 3372 | case 'L': lowlevel = TRUE; break; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3373 | } |
| 3374 | } |
| 3375 | } |
| 3376 | |
| 3377 | if (*keys != NUL || execute) |
| 3378 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3379 | // Need to escape K_SPECIAL and CSI before putting the string in the |
| 3380 | // typeahead buffer. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3381 | keys_esc = vim_strsave_escape_csi(keys); |
| 3382 | if (keys_esc != NULL) |
| 3383 | { |
Bram Moolenaar | 5e66b42 | 2019-01-24 21:58:10 +0100 | [diff] [blame] | 3384 | if (lowlevel) |
| 3385 | { |
| 3386 | #ifdef USE_INPUT_BUF |
Bram Moolenaar | 9645e2d | 2020-03-20 20:48:49 +0100 | [diff] [blame] | 3387 | int idx; |
| 3388 | int len = (int)STRLEN(keys); |
| 3389 | |
| 3390 | for (idx = 0; idx < len; ++idx) |
| 3391 | { |
| 3392 | // if a CTRL-C was typed, set got_int, similar to what |
| 3393 | // happens in fill_input_buf() |
| 3394 | if (keys[idx] == 3 && ctrl_c_interrupts && typed) |
| 3395 | got_int = TRUE; |
| 3396 | add_to_input_buf(keys + idx, 1); |
| 3397 | } |
Bram Moolenaar | 5e66b42 | 2019-01-24 21:58:10 +0100 | [diff] [blame] | 3398 | #else |
| 3399 | emsg(_("E980: lowlevel input not supported")); |
| 3400 | #endif |
| 3401 | } |
| 3402 | else |
Bram Moolenaar | 8d4ce56 | 2019-01-30 22:01:40 +0100 | [diff] [blame] | 3403 | { |
Bram Moolenaar | 5e66b42 | 2019-01-24 21:58:10 +0100 | [diff] [blame] | 3404 | ins_typebuf(keys_esc, (remap ? REMAP_YES : REMAP_NONE), |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3405 | insert ? 0 : typebuf.tb_len, !typed, FALSE); |
Bram Moolenaar | 8d4ce56 | 2019-01-30 22:01:40 +0100 | [diff] [blame] | 3406 | if (vgetc_busy |
Bram Moolenaar | 5d7be4f | 2017-06-25 13:40:17 +0200 | [diff] [blame] | 3407 | #ifdef FEAT_TIMERS |
Bram Moolenaar | 8d4ce56 | 2019-01-30 22:01:40 +0100 | [diff] [blame] | 3408 | || timer_busy |
Bram Moolenaar | 5d7be4f | 2017-06-25 13:40:17 +0200 | [diff] [blame] | 3409 | #endif |
Bram Moolenaar | dfc33a6 | 2020-04-29 22:30:13 +0200 | [diff] [blame] | 3410 | || input_busy) |
Bram Moolenaar | 8d4ce56 | 2019-01-30 22:01:40 +0100 | [diff] [blame] | 3411 | typebuf_was_filled = TRUE; |
| 3412 | } |
| 3413 | vim_free(keys_esc); |
| 3414 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3415 | if (execute) |
| 3416 | { |
| 3417 | int save_msg_scroll = msg_scroll; |
| 3418 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3419 | // Avoid a 1 second delay when the keys start Insert mode. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3420 | msg_scroll = FALSE; |
| 3421 | |
Bram Moolenaar | b2ac14c | 2018-05-01 18:47:59 +0200 | [diff] [blame] | 3422 | if (!dangerous) |
Bram Moolenaar | 4934ad0 | 2020-09-28 22:29:58 +0200 | [diff] [blame] | 3423 | { |
Bram Moolenaar | b2ac14c | 2018-05-01 18:47:59 +0200 | [diff] [blame] | 3424 | ++ex_normal_busy; |
Bram Moolenaar | 4934ad0 | 2020-09-28 22:29:58 +0200 | [diff] [blame] | 3425 | ++in_feedkeys; |
| 3426 | } |
Bram Moolenaar | 905dd90 | 2019-04-07 14:21:47 +0200 | [diff] [blame] | 3427 | exec_normal(TRUE, lowlevel, TRUE); |
Bram Moolenaar | b2ac14c | 2018-05-01 18:47:59 +0200 | [diff] [blame] | 3428 | if (!dangerous) |
Bram Moolenaar | 189832b | 2020-09-23 12:29:11 +0200 | [diff] [blame] | 3429 | { |
Bram Moolenaar | b2ac14c | 2018-05-01 18:47:59 +0200 | [diff] [blame] | 3430 | --ex_normal_busy; |
Bram Moolenaar | 4934ad0 | 2020-09-28 22:29:58 +0200 | [diff] [blame] | 3431 | --in_feedkeys; |
Bram Moolenaar | 189832b | 2020-09-23 12:29:11 +0200 | [diff] [blame] | 3432 | } |
Bram Moolenaar | b2ac14c | 2018-05-01 18:47:59 +0200 | [diff] [blame] | 3433 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3434 | msg_scroll |= save_msg_scroll; |
| 3435 | } |
| 3436 | } |
| 3437 | } |
| 3438 | } |
| 3439 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3440 | /* |
| 3441 | * "fnameescape({string})" function |
| 3442 | */ |
| 3443 | static void |
| 3444 | f_fnameescape(typval_T *argvars, typval_T *rettv) |
| 3445 | { |
| 3446 | rettv->vval.v_string = vim_strsave_fnameescape( |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3447 | tv_get_string(&argvars[0]), FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3448 | rettv->v_type = VAR_STRING; |
| 3449 | } |
| 3450 | |
| 3451 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3452 | * "foreground()" function |
| 3453 | */ |
| 3454 | static void |
| 3455 | f_foreground(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 3456 | { |
| 3457 | #ifdef FEAT_GUI |
| 3458 | if (gui.in_use) |
Bram Moolenaar | afde13b | 2019-04-28 19:46:49 +0200 | [diff] [blame] | 3459 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3460 | gui_mch_set_foreground(); |
Bram Moolenaar | afde13b | 2019-04-28 19:46:49 +0200 | [diff] [blame] | 3461 | return; |
| 3462 | } |
| 3463 | #endif |
| 3464 | #if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL)) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3465 | win32_set_foreground(); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3466 | #endif |
| 3467 | } |
| 3468 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3469 | static void |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3470 | common_function(typval_T *argvars, typval_T *rettv, int is_funcref) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3471 | { |
| 3472 | char_u *s; |
| 3473 | char_u *name; |
| 3474 | int use_string = FALSE; |
| 3475 | partial_T *arg_pt = NULL; |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3476 | char_u *trans_name = NULL; |
Bram Moolenaar | 4c17ad9 | 2020-04-27 22:47:51 +0200 | [diff] [blame] | 3477 | int is_global = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3478 | |
| 3479 | if (argvars[0].v_type == VAR_FUNC) |
| 3480 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3481 | // function(MyFunc, [arg], dict) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3482 | s = argvars[0].vval.v_string; |
| 3483 | } |
| 3484 | else if (argvars[0].v_type == VAR_PARTIAL |
| 3485 | && argvars[0].vval.v_partial != NULL) |
| 3486 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3487 | // function(dict.MyFunc, [arg]) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3488 | arg_pt = argvars[0].vval.v_partial; |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3489 | s = partial_name(arg_pt); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3490 | } |
| 3491 | else |
| 3492 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3493 | // function('MyFunc', [arg], dict) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3494 | s = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3495 | use_string = TRUE; |
| 3496 | } |
| 3497 | |
Bram Moolenaar | 843b884 | 2016-08-21 14:36:15 +0200 | [diff] [blame] | 3498 | if ((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref) |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3499 | { |
| 3500 | name = s; |
Bram Moolenaar | 4c17ad9 | 2020-04-27 22:47:51 +0200 | [diff] [blame] | 3501 | trans_name = trans_function_name(&name, &is_global, FALSE, |
Bram Moolenaar | 32b3f82 | 2021-01-06 21:59:39 +0100 | [diff] [blame] | 3502 | TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD | TFN_NO_DEREF, |
| 3503 | NULL, NULL, NULL); |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3504 | if (*name != NUL) |
| 3505 | s = NULL; |
| 3506 | } |
| 3507 | |
Bram Moolenaar | 843b884 | 2016-08-21 14:36:15 +0200 | [diff] [blame] | 3508 | if (s == NULL || *s == NUL || (use_string && VIM_ISDIGIT(*s)) |
| 3509 | || (is_funcref && trans_name == NULL)) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 3510 | semsg(_(e_invarg2), use_string ? tv_get_string(&argvars[0]) : s); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3511 | // Don't check an autoload name for existence here. |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3512 | else if (trans_name != NULL && (is_funcref |
Bram Moolenaar | 4c17ad9 | 2020-04-27 22:47:51 +0200 | [diff] [blame] | 3513 | ? find_func(trans_name, is_global, NULL) == NULL |
| 3514 | : !translated_function_exists(trans_name, is_global))) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 3515 | semsg(_("E700: Unknown function: %s"), s); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3516 | else |
| 3517 | { |
| 3518 | int dict_idx = 0; |
| 3519 | int arg_idx = 0; |
| 3520 | list_T *list = NULL; |
| 3521 | |
| 3522 | if (STRNCMP(s, "s:", 2) == 0 || STRNCMP(s, "<SID>", 5) == 0) |
| 3523 | { |
| 3524 | char sid_buf[25]; |
| 3525 | int off = *s == 's' ? 2 : 5; |
| 3526 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3527 | // Expand s: and <SID> into <SNR>nr_, so that the function can |
| 3528 | // also be called from another script. Using trans_function_name() |
| 3529 | // would also work, but some plugins depend on the name being |
| 3530 | // printable text. |
Bram Moolenaar | f29c1c6 | 2018-09-10 21:05:02 +0200 | [diff] [blame] | 3531 | sprintf(sid_buf, "<SNR>%ld_", (long)current_sctx.sc_sid); |
Bram Moolenaar | 51e1438 | 2019-05-25 20:21:28 +0200 | [diff] [blame] | 3532 | name = alloc(STRLEN(sid_buf) + STRLEN(s + off) + 1); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3533 | if (name != NULL) |
| 3534 | { |
| 3535 | STRCPY(name, sid_buf); |
| 3536 | STRCAT(name, s + off); |
| 3537 | } |
| 3538 | } |
| 3539 | else |
| 3540 | name = vim_strsave(s); |
| 3541 | |
| 3542 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 3543 | { |
| 3544 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 3545 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3546 | // function(name, [args], dict) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3547 | arg_idx = 1; |
| 3548 | dict_idx = 2; |
| 3549 | } |
| 3550 | else if (argvars[1].v_type == VAR_DICT) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3551 | // function(name, dict) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3552 | dict_idx = 1; |
| 3553 | else |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3554 | // function(name, [args]) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3555 | arg_idx = 1; |
| 3556 | if (dict_idx > 0) |
| 3557 | { |
| 3558 | if (argvars[dict_idx].v_type != VAR_DICT) |
| 3559 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 3560 | emsg(_("E922: expected a dict")); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3561 | vim_free(name); |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3562 | goto theend; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3563 | } |
| 3564 | if (argvars[dict_idx].vval.v_dict == NULL) |
| 3565 | dict_idx = 0; |
| 3566 | } |
| 3567 | if (arg_idx > 0) |
| 3568 | { |
| 3569 | if (argvars[arg_idx].v_type != VAR_LIST) |
| 3570 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 3571 | emsg(_("E923: Second argument of function() must be a list or a dict")); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3572 | vim_free(name); |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3573 | goto theend; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3574 | } |
| 3575 | list = argvars[arg_idx].vval.v_list; |
| 3576 | if (list == NULL || list->lv_len == 0) |
| 3577 | arg_idx = 0; |
Bram Moolenaar | 4c054e9 | 2019-11-10 00:13:50 +0100 | [diff] [blame] | 3578 | else if (list->lv_len > MAX_FUNC_ARGS) |
| 3579 | { |
Bram Moolenaar | 2118a30 | 2019-11-22 19:29:45 +0100 | [diff] [blame] | 3580 | emsg_funcname((char *)e_toomanyarg, s); |
Bram Moolenaar | 4c054e9 | 2019-11-10 00:13:50 +0100 | [diff] [blame] | 3581 | vim_free(name); |
| 3582 | goto theend; |
| 3583 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3584 | } |
| 3585 | } |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3586 | if (dict_idx > 0 || arg_idx > 0 || arg_pt != NULL || is_funcref) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3587 | { |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 3588 | partial_T *pt = ALLOC_CLEAR_ONE(partial_T); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3589 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3590 | // result is a VAR_PARTIAL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3591 | if (pt == NULL) |
| 3592 | vim_free(name); |
| 3593 | else |
| 3594 | { |
| 3595 | if (arg_idx > 0 || (arg_pt != NULL && arg_pt->pt_argc > 0)) |
| 3596 | { |
| 3597 | listitem_T *li; |
| 3598 | int i = 0; |
| 3599 | int arg_len = 0; |
| 3600 | int lv_len = 0; |
| 3601 | |
| 3602 | if (arg_pt != NULL) |
| 3603 | arg_len = arg_pt->pt_argc; |
| 3604 | if (list != NULL) |
| 3605 | lv_len = list->lv_len; |
| 3606 | pt->pt_argc = arg_len + lv_len; |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 3607 | pt->pt_argv = ALLOC_MULT(typval_T, pt->pt_argc); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3608 | if (pt->pt_argv == NULL) |
| 3609 | { |
| 3610 | vim_free(pt); |
| 3611 | vim_free(name); |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3612 | goto theend; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3613 | } |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3614 | for (i = 0; i < arg_len; i++) |
| 3615 | copy_tv(&arg_pt->pt_argv[i], &pt->pt_argv[i]); |
| 3616 | if (lv_len > 0) |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 3617 | { |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 3618 | CHECK_LIST_MATERIALIZE(list); |
Bram Moolenaar | aeea721 | 2020-04-02 18:50:46 +0200 | [diff] [blame] | 3619 | FOR_ALL_LIST_ITEMS(list, li) |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3620 | copy_tv(&li->li_tv, &pt->pt_argv[i++]); |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 3621 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3622 | } |
| 3623 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3624 | // For "function(dict.func, [], dict)" and "func" is a partial |
| 3625 | // use "dict". That is backwards compatible. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3626 | if (dict_idx > 0) |
| 3627 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3628 | // The dict is bound explicitly, pt_auto is FALSE. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3629 | pt->pt_dict = argvars[dict_idx].vval.v_dict; |
| 3630 | ++pt->pt_dict->dv_refcount; |
| 3631 | } |
| 3632 | else if (arg_pt != NULL) |
| 3633 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3634 | // If the dict was bound automatically the result is also |
| 3635 | // bound automatically. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3636 | pt->pt_dict = arg_pt->pt_dict; |
| 3637 | pt->pt_auto = arg_pt->pt_auto; |
| 3638 | if (pt->pt_dict != NULL) |
| 3639 | ++pt->pt_dict->dv_refcount; |
| 3640 | } |
| 3641 | |
| 3642 | pt->pt_refcount = 1; |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3643 | if (arg_pt != NULL && arg_pt->pt_func != NULL) |
| 3644 | { |
| 3645 | pt->pt_func = arg_pt->pt_func; |
| 3646 | func_ptr_ref(pt->pt_func); |
| 3647 | vim_free(name); |
| 3648 | } |
| 3649 | else if (is_funcref) |
| 3650 | { |
Bram Moolenaar | 4c17ad9 | 2020-04-27 22:47:51 +0200 | [diff] [blame] | 3651 | pt->pt_func = find_func(trans_name, is_global, NULL); |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3652 | func_ptr_ref(pt->pt_func); |
| 3653 | vim_free(name); |
| 3654 | } |
| 3655 | else |
| 3656 | { |
| 3657 | pt->pt_name = name; |
| 3658 | func_ref(name); |
| 3659 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3660 | } |
| 3661 | rettv->v_type = VAR_PARTIAL; |
| 3662 | rettv->vval.v_partial = pt; |
| 3663 | } |
| 3664 | else |
| 3665 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3666 | // result is a VAR_FUNC |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3667 | rettv->v_type = VAR_FUNC; |
| 3668 | rettv->vval.v_string = name; |
| 3669 | func_ref(name); |
| 3670 | } |
| 3671 | } |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3672 | theend: |
| 3673 | vim_free(trans_name); |
| 3674 | } |
| 3675 | |
| 3676 | /* |
| 3677 | * "funcref()" function |
| 3678 | */ |
| 3679 | static void |
| 3680 | f_funcref(typval_T *argvars, typval_T *rettv) |
| 3681 | { |
| 3682 | common_function(argvars, rettv, TRUE); |
| 3683 | } |
| 3684 | |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 3685 | static type_T * |
Bram Moolenaar | dfc33a6 | 2020-04-29 22:30:13 +0200 | [diff] [blame] | 3686 | ret_f_function(int argcount, type_T **argtypes) |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 3687 | { |
| 3688 | if (argcount == 1 && argtypes[0]->tt_type == VAR_STRING) |
| 3689 | return &t_func_any; |
Bram Moolenaar | 5e65423 | 2020-09-16 15:22:00 +0200 | [diff] [blame] | 3690 | return &t_func_unknown; |
Bram Moolenaar | fbdd08e | 2020-03-01 14:04:46 +0100 | [diff] [blame] | 3691 | } |
| 3692 | |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3693 | /* |
| 3694 | * "function()" function |
| 3695 | */ |
| 3696 | static void |
| 3697 | f_function(typval_T *argvars, typval_T *rettv) |
| 3698 | { |
| 3699 | common_function(argvars, rettv, FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3700 | } |
| 3701 | |
| 3702 | /* |
| 3703 | * "garbagecollect()" function |
| 3704 | */ |
| 3705 | static void |
| 3706 | f_garbagecollect(typval_T *argvars, typval_T *rettv UNUSED) |
| 3707 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 3708 | // This is postponed until we are back at the toplevel, because we may be |
| 3709 | // using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3710 | want_garbage_collect = TRUE; |
| 3711 | |
Bram Moolenaar | 2df4731 | 2020-09-05 17:30:44 +0200 | [diff] [blame] | 3712 | if (argvars[0].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[0]) == 1) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3713 | garbage_collect_at_exit = TRUE; |
| 3714 | } |
| 3715 | |
| 3716 | /* |
| 3717 | * "get()" function |
| 3718 | */ |
| 3719 | static void |
| 3720 | f_get(typval_T *argvars, typval_T *rettv) |
| 3721 | { |
| 3722 | listitem_T *li; |
| 3723 | list_T *l; |
| 3724 | dictitem_T *di; |
| 3725 | dict_T *d; |
| 3726 | typval_T *tv = NULL; |
Bram Moolenaar | f91aac5 | 2019-07-28 13:21:01 +0200 | [diff] [blame] | 3727 | int what_is_dict = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3728 | |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 3729 | if (argvars[0].v_type == VAR_BLOB) |
| 3730 | { |
| 3731 | int error = FALSE; |
| 3732 | int idx = tv_get_number_chk(&argvars[1], &error); |
| 3733 | |
| 3734 | if (!error) |
| 3735 | { |
| 3736 | rettv->v_type = VAR_NUMBER; |
Bram Moolenaar | 2ea773b | 2019-01-15 22:16:42 +0100 | [diff] [blame] | 3737 | if (idx < 0) |
| 3738 | idx = blob_len(argvars[0].vval.v_blob) + idx; |
| 3739 | if (idx < 0 || idx >= blob_len(argvars[0].vval.v_blob)) |
| 3740 | rettv->vval.v_number = -1; |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 3741 | else |
Bram Moolenaar | 2ea773b | 2019-01-15 22:16:42 +0100 | [diff] [blame] | 3742 | { |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 3743 | rettv->vval.v_number = blob_get(argvars[0].vval.v_blob, idx); |
Bram Moolenaar | 2ea773b | 2019-01-15 22:16:42 +0100 | [diff] [blame] | 3744 | tv = rettv; |
| 3745 | } |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 3746 | } |
| 3747 | } |
| 3748 | else if (argvars[0].v_type == VAR_LIST) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3749 | { |
| 3750 | if ((l = argvars[0].vval.v_list) != NULL) |
| 3751 | { |
| 3752 | int error = FALSE; |
| 3753 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3754 | li = list_find(l, (long)tv_get_number_chk(&argvars[1], &error)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3755 | if (!error && li != NULL) |
| 3756 | tv = &li->li_tv; |
| 3757 | } |
| 3758 | } |
| 3759 | else if (argvars[0].v_type == VAR_DICT) |
| 3760 | { |
| 3761 | if ((d = argvars[0].vval.v_dict) != NULL) |
| 3762 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3763 | di = dict_find(d, tv_get_string(&argvars[1]), -1); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3764 | if (di != NULL) |
| 3765 | tv = &di->di_tv; |
| 3766 | } |
| 3767 | } |
| 3768 | else if (argvars[0].v_type == VAR_PARTIAL || argvars[0].v_type == VAR_FUNC) |
| 3769 | { |
| 3770 | partial_T *pt; |
| 3771 | partial_T fref_pt; |
| 3772 | |
| 3773 | if (argvars[0].v_type == VAR_PARTIAL) |
| 3774 | pt = argvars[0].vval.v_partial; |
| 3775 | else |
| 3776 | { |
Bram Moolenaar | a80faa8 | 2020-04-12 19:37:17 +0200 | [diff] [blame] | 3777 | CLEAR_FIELD(fref_pt); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3778 | fref_pt.pt_name = argvars[0].vval.v_string; |
| 3779 | pt = &fref_pt; |
| 3780 | } |
| 3781 | |
| 3782 | if (pt != NULL) |
| 3783 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 3784 | char_u *what = tv_get_string(&argvars[1]); |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3785 | char_u *n; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3786 | |
| 3787 | if (STRCMP(what, "func") == 0 || STRCMP(what, "name") == 0) |
| 3788 | { |
| 3789 | rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING); |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3790 | n = partial_name(pt); |
| 3791 | if (n == NULL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3792 | rettv->vval.v_string = NULL; |
| 3793 | else |
Bram Moolenaar | 437bafe | 2016-08-01 15:40:54 +0200 | [diff] [blame] | 3794 | { |
| 3795 | rettv->vval.v_string = vim_strsave(n); |
| 3796 | if (rettv->v_type == VAR_FUNC) |
| 3797 | func_ref(rettv->vval.v_string); |
| 3798 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3799 | } |
| 3800 | else if (STRCMP(what, "dict") == 0) |
Bram Moolenaar | f91aac5 | 2019-07-28 13:21:01 +0200 | [diff] [blame] | 3801 | { |
| 3802 | what_is_dict = TRUE; |
| 3803 | if (pt->pt_dict != NULL) |
| 3804 | rettv_dict_set(rettv, pt->pt_dict); |
| 3805 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3806 | else if (STRCMP(what, "args") == 0) |
| 3807 | { |
| 3808 | rettv->v_type = VAR_LIST; |
| 3809 | if (rettv_list_alloc(rettv) == OK) |
| 3810 | { |
| 3811 | int i; |
| 3812 | |
| 3813 | for (i = 0; i < pt->pt_argc; ++i) |
| 3814 | list_append_tv(rettv->vval.v_list, &pt->pt_argv[i]); |
| 3815 | } |
| 3816 | } |
| 3817 | else |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 3818 | semsg(_(e_invarg2), what); |
Bram Moolenaar | f91aac5 | 2019-07-28 13:21:01 +0200 | [diff] [blame] | 3819 | |
| 3820 | // When {what} == "dict" and pt->pt_dict == NULL, evaluate the |
| 3821 | // third argument |
| 3822 | if (!what_is_dict) |
| 3823 | return; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3824 | } |
| 3825 | } |
| 3826 | else |
Bram Moolenaar | 0d17f0d | 2019-01-22 22:20:38 +0100 | [diff] [blame] | 3827 | semsg(_(e_listdictblobarg), "get()"); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3828 | |
| 3829 | if (tv == NULL) |
| 3830 | { |
| 3831 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 3832 | copy_tv(&argvars[2], rettv); |
| 3833 | } |
| 3834 | else |
| 3835 | copy_tv(tv, rettv); |
| 3836 | } |
| 3837 | |
Bram Moolenaar | b5ae48e | 2016-08-12 22:23:25 +0200 | [diff] [blame] | 3838 | /* |
Bram Moolenaar | 07ad816 | 2018-02-13 13:59:59 +0100 | [diff] [blame] | 3839 | * "getchangelist()" function |
| 3840 | */ |
| 3841 | static void |
| 3842 | f_getchangelist(typval_T *argvars, typval_T *rettv) |
| 3843 | { |
| 3844 | #ifdef FEAT_JUMPLIST |
| 3845 | buf_T *buf; |
| 3846 | int i; |
| 3847 | list_T *l; |
| 3848 | dict_T *d; |
| 3849 | #endif |
| 3850 | |
| 3851 | if (rettv_list_alloc(rettv) != OK) |
| 3852 | return; |
| 3853 | |
| 3854 | #ifdef FEAT_JUMPLIST |
Bram Moolenaar | 4c313b1 | 2019-08-24 22:58:31 +0200 | [diff] [blame] | 3855 | if (argvars[0].v_type == VAR_UNKNOWN) |
| 3856 | buf = curbuf; |
| 3857 | else |
Bram Moolenaar | a5d3841 | 2020-09-02 21:02:35 +0200 | [diff] [blame] | 3858 | buf = tv_get_buf_from_arg(&argvars[0]); |
Bram Moolenaar | 07ad816 | 2018-02-13 13:59:59 +0100 | [diff] [blame] | 3859 | if (buf == NULL) |
| 3860 | return; |
| 3861 | |
| 3862 | l = list_alloc(); |
| 3863 | if (l == NULL) |
| 3864 | return; |
| 3865 | |
| 3866 | if (list_append_list(rettv->vval.v_list, l) == FAIL) |
| 3867 | return; |
| 3868 | /* |
| 3869 | * The current window change list index tracks only the position in the |
| 3870 | * current buffer change list. For other buffers, use the change list |
| 3871 | * length as the current index. |
| 3872 | */ |
| 3873 | list_append_number(rettv->vval.v_list, |
| 3874 | (varnumber_T)((buf == curwin->w_buffer) |
| 3875 | ? curwin->w_changelistidx : buf->b_changelistlen)); |
| 3876 | |
| 3877 | for (i = 0; i < buf->b_changelistlen; ++i) |
| 3878 | { |
| 3879 | if (buf->b_changelist[i].lnum == 0) |
| 3880 | continue; |
| 3881 | if ((d = dict_alloc()) == NULL) |
| 3882 | return; |
| 3883 | if (list_append_dict(l, d) == FAIL) |
| 3884 | return; |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 3885 | dict_add_number(d, "lnum", (long)buf->b_changelist[i].lnum); |
| 3886 | dict_add_number(d, "col", (long)buf->b_changelist[i].col); |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 3887 | dict_add_number(d, "coladd", (long)buf->b_changelist[i].coladd); |
Bram Moolenaar | 07ad816 | 2018-02-13 13:59:59 +0100 | [diff] [blame] | 3888 | } |
| 3889 | #endif |
| 3890 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3891 | |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 3892 | static void |
| 3893 | getpos_both( |
| 3894 | typval_T *argvars, |
| 3895 | typval_T *rettv, |
| 3896 | int getcurpos, |
| 3897 | int charcol) |
| 3898 | { |
| 3899 | pos_T *fp = NULL; |
| 3900 | pos_T pos; |
| 3901 | win_T *wp = curwin; |
| 3902 | list_T *l; |
| 3903 | int fnum = -1; |
| 3904 | |
| 3905 | if (rettv_list_alloc(rettv) == OK) |
| 3906 | { |
| 3907 | l = rettv->vval.v_list; |
| 3908 | if (getcurpos) |
| 3909 | { |
| 3910 | if (argvars[0].v_type != VAR_UNKNOWN) |
| 3911 | { |
| 3912 | wp = find_win_by_nr_or_id(&argvars[0]); |
| 3913 | if (wp != NULL) |
| 3914 | fp = &wp->w_cursor; |
| 3915 | } |
| 3916 | else |
| 3917 | fp = &curwin->w_cursor; |
| 3918 | if (fp != NULL && charcol) |
| 3919 | { |
| 3920 | pos = *fp; |
Bram Moolenaar | 9145846 | 2021-01-13 20:08:38 +0100 | [diff] [blame] | 3921 | pos.col = |
| 3922 | buf_byteidx_to_charidx(wp->w_buffer, pos.lnum, pos.col); |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 3923 | fp = &pos; |
| 3924 | } |
| 3925 | } |
| 3926 | else |
| 3927 | fp = var2fpos(&argvars[0], TRUE, &fnum, charcol); |
| 3928 | if (fnum != -1) |
| 3929 | list_append_number(l, (varnumber_T)fnum); |
| 3930 | else |
| 3931 | list_append_number(l, (varnumber_T)0); |
| 3932 | list_append_number(l, (fp != NULL) ? (varnumber_T)fp->lnum |
| 3933 | : (varnumber_T)0); |
| 3934 | list_append_number(l, (fp != NULL) |
| 3935 | ? (varnumber_T)(fp->col == MAXCOL ? MAXCOL : fp->col + 1) |
| 3936 | : (varnumber_T)0); |
| 3937 | list_append_number(l, (fp != NULL) ? (varnumber_T)fp->coladd : |
| 3938 | (varnumber_T)0); |
| 3939 | if (getcurpos) |
| 3940 | { |
| 3941 | int save_set_curswant = curwin->w_set_curswant; |
| 3942 | colnr_T save_curswant = curwin->w_curswant; |
| 3943 | colnr_T save_virtcol = curwin->w_virtcol; |
| 3944 | |
| 3945 | if (wp == curwin) |
| 3946 | update_curswant(); |
| 3947 | list_append_number(l, wp == NULL ? 0 : wp->w_curswant == MAXCOL |
| 3948 | ? (varnumber_T)MAXCOL : (varnumber_T)wp->w_curswant + 1); |
| 3949 | |
| 3950 | // Do not change "curswant", as it is unexpected that a get |
| 3951 | // function has a side effect. |
| 3952 | if (wp == curwin && save_set_curswant) |
| 3953 | { |
| 3954 | curwin->w_set_curswant = save_set_curswant; |
| 3955 | curwin->w_curswant = save_curswant; |
| 3956 | curwin->w_virtcol = save_virtcol; |
| 3957 | curwin->w_valid &= ~VALID_VIRTCOL; |
| 3958 | } |
| 3959 | } |
| 3960 | } |
| 3961 | else |
| 3962 | rettv->vval.v_number = FALSE; |
| 3963 | } |
| 3964 | |
| 3965 | /* |
| 3966 | * "getcharpos()" function |
| 3967 | */ |
| 3968 | static void |
| 3969 | f_getcharpos(typval_T *argvars UNUSED, typval_T *rettv) |
| 3970 | { |
| 3971 | getpos_both(argvars, rettv, FALSE, TRUE); |
| 3972 | } |
| 3973 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3974 | /* |
| 3975 | * "getcharsearch()" function |
| 3976 | */ |
| 3977 | static void |
| 3978 | f_getcharsearch(typval_T *argvars UNUSED, typval_T *rettv) |
| 3979 | { |
| 3980 | if (rettv_dict_alloc(rettv) != FAIL) |
| 3981 | { |
| 3982 | dict_T *dict = rettv->vval.v_dict; |
| 3983 | |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 3984 | dict_add_string(dict, "char", last_csearch()); |
| 3985 | dict_add_number(dict, "forward", last_csearch_forward()); |
| 3986 | dict_add_number(dict, "until", last_csearch_until()); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 3987 | } |
| 3988 | } |
| 3989 | |
| 3990 | /* |
Bram Moolenaar | 691ddee | 2019-05-09 14:52:41 +0200 | [diff] [blame] | 3991 | * "getenv()" function |
| 3992 | */ |
| 3993 | static void |
| 3994 | f_getenv(typval_T *argvars, typval_T *rettv) |
| 3995 | { |
| 3996 | int mustfree = FALSE; |
| 3997 | char_u *p = vim_getenv(tv_get_string(&argvars[0]), &mustfree); |
| 3998 | |
| 3999 | if (p == NULL) |
| 4000 | { |
| 4001 | rettv->v_type = VAR_SPECIAL; |
| 4002 | rettv->vval.v_number = VVAL_NULL; |
| 4003 | return; |
| 4004 | } |
| 4005 | if (!mustfree) |
| 4006 | p = vim_strsave(p); |
| 4007 | rettv->vval.v_string = p; |
| 4008 | rettv->v_type = VAR_STRING; |
| 4009 | } |
| 4010 | |
| 4011 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4012 | * "getfontname()" function |
| 4013 | */ |
| 4014 | static void |
| 4015 | f_getfontname(typval_T *argvars UNUSED, typval_T *rettv) |
| 4016 | { |
| 4017 | rettv->v_type = VAR_STRING; |
| 4018 | rettv->vval.v_string = NULL; |
| 4019 | #ifdef FEAT_GUI |
| 4020 | if (gui.in_use) |
| 4021 | { |
| 4022 | GuiFont font; |
| 4023 | char_u *name = NULL; |
| 4024 | |
| 4025 | if (argvars[0].v_type == VAR_UNKNOWN) |
| 4026 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 4027 | // Get the "Normal" font. Either the name saved by |
| 4028 | // hl_set_font_name() or from the font ID. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4029 | font = gui.norm_font; |
| 4030 | name = hl_get_font_name(); |
| 4031 | } |
| 4032 | else |
| 4033 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 4034 | name = tv_get_string(&argvars[0]); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 4035 | if (STRCMP(name, "*") == 0) // don't use font dialog |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4036 | return; |
| 4037 | font = gui_mch_get_font(name, FALSE); |
| 4038 | if (font == NOFONT) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 4039 | return; // Invalid font name, return empty string. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4040 | } |
| 4041 | rettv->vval.v_string = gui_mch_get_fontname(font, name); |
| 4042 | if (argvars[0].v_type != VAR_UNKNOWN) |
| 4043 | gui_mch_free_font(font); |
| 4044 | } |
| 4045 | #endif |
| 4046 | } |
| 4047 | |
| 4048 | /* |
Bram Moolenaar | 4f50588 | 2018-02-10 21:06:32 +0100 | [diff] [blame] | 4049 | * "getjumplist()" function |
| 4050 | */ |
| 4051 | static void |
| 4052 | f_getjumplist(typval_T *argvars, typval_T *rettv) |
| 4053 | { |
| 4054 | #ifdef FEAT_JUMPLIST |
| 4055 | win_T *wp; |
| 4056 | int i; |
| 4057 | list_T *l; |
| 4058 | dict_T *d; |
| 4059 | #endif |
| 4060 | |
| 4061 | if (rettv_list_alloc(rettv) != OK) |
| 4062 | return; |
| 4063 | |
| 4064 | #ifdef FEAT_JUMPLIST |
Bram Moolenaar | 00aa069 | 2019-04-27 20:37:57 +0200 | [diff] [blame] | 4065 | wp = find_tabwin(&argvars[0], &argvars[1], NULL); |
Bram Moolenaar | 4f50588 | 2018-02-10 21:06:32 +0100 | [diff] [blame] | 4066 | if (wp == NULL) |
| 4067 | return; |
| 4068 | |
Bram Moolenaar | 57ee2b6 | 2019-02-12 22:15:06 +0100 | [diff] [blame] | 4069 | cleanup_jumplist(wp, TRUE); |
| 4070 | |
Bram Moolenaar | 4f50588 | 2018-02-10 21:06:32 +0100 | [diff] [blame] | 4071 | l = list_alloc(); |
| 4072 | if (l == NULL) |
| 4073 | return; |
| 4074 | |
| 4075 | if (list_append_list(rettv->vval.v_list, l) == FAIL) |
| 4076 | return; |
| 4077 | list_append_number(rettv->vval.v_list, (varnumber_T)wp->w_jumplistidx); |
| 4078 | |
| 4079 | for (i = 0; i < wp->w_jumplistlen; ++i) |
| 4080 | { |
Bram Moolenaar | a7e18d2 | 2018-02-11 14:29:49 +0100 | [diff] [blame] | 4081 | if (wp->w_jumplist[i].fmark.mark.lnum == 0) |
| 4082 | continue; |
Bram Moolenaar | 4f50588 | 2018-02-10 21:06:32 +0100 | [diff] [blame] | 4083 | if ((d = dict_alloc()) == NULL) |
| 4084 | return; |
| 4085 | if (list_append_dict(l, d) == FAIL) |
| 4086 | return; |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 4087 | dict_add_number(d, "lnum", (long)wp->w_jumplist[i].fmark.mark.lnum); |
| 4088 | dict_add_number(d, "col", (long)wp->w_jumplist[i].fmark.mark.col); |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 4089 | dict_add_number(d, "coladd", (long)wp->w_jumplist[i].fmark.mark.coladd); |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 4090 | dict_add_number(d, "bufnr", (long)wp->w_jumplist[i].fmark.fnum); |
Bram Moolenaar | a7e18d2 | 2018-02-11 14:29:49 +0100 | [diff] [blame] | 4091 | if (wp->w_jumplist[i].fname != NULL) |
Bram Moolenaar | e0be167 | 2018-07-08 16:50:37 +0200 | [diff] [blame] | 4092 | dict_add_string(d, "filename", wp->w_jumplist[i].fname); |
Bram Moolenaar | 4f50588 | 2018-02-10 21:06:32 +0100 | [diff] [blame] | 4093 | } |
| 4094 | #endif |
| 4095 | } |
| 4096 | |
| 4097 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4098 | * "getpid()" function |
| 4099 | */ |
| 4100 | static void |
| 4101 | f_getpid(typval_T *argvars UNUSED, typval_T *rettv) |
| 4102 | { |
| 4103 | rettv->vval.v_number = mch_get_pid(); |
| 4104 | } |
| 4105 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4106 | /* |
| 4107 | * "getcurpos()" function |
| 4108 | */ |
| 4109 | static void |
| 4110 | f_getcurpos(typval_T *argvars, typval_T *rettv) |
| 4111 | { |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 4112 | getpos_both(argvars, rettv, TRUE, FALSE); |
| 4113 | } |
| 4114 | |
| 4115 | static void |
| 4116 | f_getcursorcharpos(typval_T *argvars, typval_T *rettv) |
| 4117 | { |
| 4118 | getpos_both(argvars, rettv, TRUE, TRUE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4119 | } |
| 4120 | |
| 4121 | /* |
| 4122 | * "getpos(string)" function |
| 4123 | */ |
| 4124 | static void |
| 4125 | f_getpos(typval_T *argvars, typval_T *rettv) |
| 4126 | { |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 4127 | getpos_both(argvars, rettv, FALSE, FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4128 | } |
| 4129 | |
| 4130 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4131 | * "getreg()" function |
| 4132 | */ |
| 4133 | static void |
| 4134 | f_getreg(typval_T *argvars, typval_T *rettv) |
| 4135 | { |
| 4136 | char_u *strregname; |
| 4137 | int regname; |
| 4138 | int arg2 = FALSE; |
| 4139 | int return_list = FALSE; |
| 4140 | int error = FALSE; |
| 4141 | |
| 4142 | if (argvars[0].v_type != VAR_UNKNOWN) |
| 4143 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 4144 | strregname = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 418a29f | 2021-02-10 22:23:41 +0100 | [diff] [blame] | 4145 | if (strregname == NULL) |
| 4146 | error = TRUE; |
| 4147 | else if (in_vim9script() && STRLEN(strregname) > 1) |
| 4148 | { |
| 4149 | semsg(_(e_register_name_must_be_one_char_str), strregname); |
| 4150 | error = TRUE; |
| 4151 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4152 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 4153 | { |
Bram Moolenaar | 67ff97d | 2020-09-02 21:45:54 +0200 | [diff] [blame] | 4154 | arg2 = (int)tv_get_bool_chk(&argvars[1], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4155 | if (!error && argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 67ff97d | 2020-09-02 21:45:54 +0200 | [diff] [blame] | 4156 | return_list = (int)tv_get_bool_chk(&argvars[2], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4157 | } |
| 4158 | } |
| 4159 | else |
| 4160 | strregname = get_vim_var_str(VV_REG); |
| 4161 | |
| 4162 | if (error) |
| 4163 | return; |
| 4164 | |
| 4165 | regname = (strregname == NULL ? '"' : *strregname); |
| 4166 | if (regname == 0) |
| 4167 | regname = '"'; |
| 4168 | |
| 4169 | if (return_list) |
| 4170 | { |
| 4171 | rettv->v_type = VAR_LIST; |
| 4172 | rettv->vval.v_list = (list_T *)get_reg_contents(regname, |
| 4173 | (arg2 ? GREG_EXPR_SRC : 0) | GREG_LIST); |
| 4174 | if (rettv->vval.v_list == NULL) |
| 4175 | (void)rettv_list_alloc(rettv); |
| 4176 | else |
| 4177 | ++rettv->vval.v_list->lv_refcount; |
| 4178 | } |
| 4179 | else |
| 4180 | { |
| 4181 | rettv->v_type = VAR_STRING; |
| 4182 | rettv->vval.v_string = get_reg_contents(regname, |
| 4183 | arg2 ? GREG_EXPR_SRC : 0); |
| 4184 | } |
| 4185 | } |
| 4186 | |
| 4187 | /* |
| 4188 | * "getregtype()" function |
| 4189 | */ |
| 4190 | static void |
| 4191 | f_getregtype(typval_T *argvars, typval_T *rettv) |
| 4192 | { |
| 4193 | char_u *strregname; |
| 4194 | int regname; |
| 4195 | char_u buf[NUMBUFLEN + 2]; |
| 4196 | long reglen = 0; |
| 4197 | |
| 4198 | if (argvars[0].v_type != VAR_UNKNOWN) |
| 4199 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 4200 | strregname = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 418a29f | 2021-02-10 22:23:41 +0100 | [diff] [blame] | 4201 | if (strregname != NULL && in_vim9script() && STRLEN(strregname) > 1) |
| 4202 | { |
| 4203 | semsg(_(e_register_name_must_be_one_char_str), strregname); |
| 4204 | strregname = NULL; |
| 4205 | } |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 4206 | if (strregname == NULL) // type error; errmsg already given |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4207 | { |
| 4208 | rettv->v_type = VAR_STRING; |
| 4209 | rettv->vval.v_string = NULL; |
| 4210 | return; |
| 4211 | } |
| 4212 | } |
| 4213 | else |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 4214 | // Default to v:register |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4215 | strregname = get_vim_var_str(VV_REG); |
| 4216 | |
| 4217 | regname = (strregname == NULL ? '"' : *strregname); |
| 4218 | if (regname == 0) |
| 4219 | regname = '"'; |
| 4220 | |
| 4221 | buf[0] = NUL; |
| 4222 | buf[1] = NUL; |
| 4223 | switch (get_reg_type(regname, ®len)) |
| 4224 | { |
| 4225 | case MLINE: buf[0] = 'V'; break; |
| 4226 | case MCHAR: buf[0] = 'v'; break; |
| 4227 | case MBLOCK: |
| 4228 | buf[0] = Ctrl_V; |
| 4229 | sprintf((char *)buf + 1, "%ld", reglen + 1); |
| 4230 | break; |
| 4231 | } |
| 4232 | rettv->v_type = VAR_STRING; |
| 4233 | rettv->vval.v_string = vim_strsave(buf); |
| 4234 | } |
| 4235 | |
Bram Moolenaar | b5ae48e | 2016-08-12 22:23:25 +0200 | [diff] [blame] | 4236 | /* |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 4237 | * "gettagstack()" function |
| 4238 | */ |
| 4239 | static void |
| 4240 | f_gettagstack(typval_T *argvars, typval_T *rettv) |
| 4241 | { |
| 4242 | win_T *wp = curwin; // default is current window |
| 4243 | |
| 4244 | if (rettv_dict_alloc(rettv) != OK) |
| 4245 | return; |
| 4246 | |
| 4247 | if (argvars[0].v_type != VAR_UNKNOWN) |
| 4248 | { |
| 4249 | wp = find_win_by_nr_or_id(&argvars[0]); |
| 4250 | if (wp == NULL) |
| 4251 | return; |
| 4252 | } |
| 4253 | |
| 4254 | get_tagstack(wp, rettv->vval.v_dict); |
| 4255 | } |
| 4256 | |
Bram Moolenaar | 0b39c3f | 2020-08-30 15:52:10 +0200 | [diff] [blame] | 4257 | /* |
| 4258 | * "gettext()" function |
| 4259 | */ |
| 4260 | static void |
| 4261 | f_gettext(typval_T *argvars, typval_T *rettv) |
| 4262 | { |
| 4263 | if (argvars[0].v_type != VAR_STRING |
| 4264 | || argvars[0].vval.v_string == NULL |
| 4265 | || *argvars[0].vval.v_string == NUL) |
| 4266 | { |
| 4267 | semsg(_(e_invarg2), tv_get_string(&argvars[0])); |
| 4268 | } |
| 4269 | else |
| 4270 | { |
| 4271 | rettv->v_type = VAR_STRING; |
| 4272 | rettv->vval.v_string = vim_strsave( |
| 4273 | (char_u *)_(argvars[0].vval.v_string)); |
| 4274 | } |
| 4275 | } |
| 4276 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 4277 | // for VIM_VERSION_ defines |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4278 | #include "version.h" |
| 4279 | |
| 4280 | /* |
| 4281 | * "has()" function |
| 4282 | */ |
Bram Moolenaar | a259d8d | 2020-01-31 20:10:50 +0100 | [diff] [blame] | 4283 | void |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4284 | f_has(typval_T *argvars, typval_T *rettv) |
| 4285 | { |
| 4286 | int i; |
| 4287 | char_u *name; |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4288 | int x = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4289 | int n = FALSE; |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4290 | typedef struct { |
| 4291 | char *name; |
| 4292 | short present; |
| 4293 | } has_item_T; |
| 4294 | static has_item_T has_list[] = |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4295 | { |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4296 | {"amiga", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4297 | #ifdef AMIGA |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4298 | 1 |
Bram Moolenaar | 39536dd | 2019-01-29 22:58:21 +0100 | [diff] [blame] | 4299 | #else |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4300 | 0 |
Bram Moolenaar | 39536dd | 2019-01-29 22:58:21 +0100 | [diff] [blame] | 4301 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4302 | }, |
| 4303 | {"arp", |
| 4304 | #if defined(AMIGA) && defined(FEAT_ARP) |
| 4305 | 1 |
| 4306 | #else |
| 4307 | 0 |
| 4308 | #endif |
| 4309 | }, |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4310 | {"haiku", |
| 4311 | #ifdef __HAIKU__ |
| 4312 | 1 |
| 4313 | #else |
| 4314 | 0 |
| 4315 | #endif |
| 4316 | }, |
| 4317 | {"bsd", |
| 4318 | #if defined(BSD) && !defined(MACOS_X) |
| 4319 | 1 |
| 4320 | #else |
| 4321 | 0 |
| 4322 | #endif |
| 4323 | }, |
| 4324 | {"hpux", |
| 4325 | #ifdef hpux |
| 4326 | 1 |
| 4327 | #else |
| 4328 | 0 |
| 4329 | #endif |
| 4330 | }, |
| 4331 | {"linux", |
| 4332 | #ifdef __linux__ |
| 4333 | 1 |
| 4334 | #else |
| 4335 | 0 |
| 4336 | #endif |
| 4337 | }, |
| 4338 | {"mac", // Mac OS X (and, once, Mac OS Classic) |
| 4339 | #ifdef MACOS_X |
| 4340 | 1 |
| 4341 | #else |
| 4342 | 0 |
| 4343 | #endif |
| 4344 | }, |
| 4345 | {"osx", // Mac OS X |
| 4346 | #ifdef MACOS_X |
| 4347 | 1 |
| 4348 | #else |
| 4349 | 0 |
| 4350 | #endif |
| 4351 | }, |
| 4352 | {"macunix", // Mac OS X, with the darwin feature |
| 4353 | #if defined(MACOS_X) && defined(MACOS_X_DARWIN) |
| 4354 | 1 |
| 4355 | #else |
| 4356 | 0 |
| 4357 | #endif |
| 4358 | }, |
| 4359 | {"osxdarwin", // synonym for macunix |
| 4360 | #if defined(MACOS_X) && defined(MACOS_X_DARWIN) |
| 4361 | 1 |
| 4362 | #else |
| 4363 | 0 |
| 4364 | #endif |
| 4365 | }, |
| 4366 | {"qnx", |
| 4367 | #ifdef __QNX__ |
| 4368 | 1 |
| 4369 | #else |
| 4370 | 0 |
| 4371 | #endif |
| 4372 | }, |
| 4373 | {"sun", |
| 4374 | #ifdef SUN_SYSTEM |
| 4375 | 1 |
| 4376 | #else |
| 4377 | 0 |
| 4378 | #endif |
| 4379 | }, |
| 4380 | {"unix", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4381 | #ifdef UNIX |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4382 | 1 |
| 4383 | #else |
| 4384 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4385 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4386 | }, |
| 4387 | {"vms", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4388 | #ifdef VMS |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4389 | 1 |
| 4390 | #else |
| 4391 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4392 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4393 | }, |
| 4394 | {"win32", |
Bram Moolenaar | 4f97475 | 2019-02-17 17:44:42 +0100 | [diff] [blame] | 4395 | #ifdef MSWIN |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4396 | 1 |
| 4397 | #else |
| 4398 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4399 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4400 | }, |
| 4401 | {"win32unix", |
Bram Moolenaar | 1eed532 | 2019-02-26 17:03:54 +0100 | [diff] [blame] | 4402 | #if defined(UNIX) && defined(__CYGWIN__) |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4403 | 1 |
| 4404 | #else |
| 4405 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4406 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4407 | }, |
| 4408 | {"win64", |
Bram Moolenaar | 44b443c | 2019-02-18 22:14:18 +0100 | [diff] [blame] | 4409 | #ifdef _WIN64 |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4410 | 1 |
| 4411 | #else |
| 4412 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4413 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4414 | }, |
| 4415 | {"ebcdic", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4416 | #ifdef EBCDIC |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4417 | 1 |
| 4418 | #else |
| 4419 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4420 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4421 | }, |
| 4422 | {"fname_case", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4423 | #ifndef CASE_INSENSITIVE_FILENAME |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4424 | 1 |
| 4425 | #else |
| 4426 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4427 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4428 | }, |
| 4429 | {"acl", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4430 | #ifdef HAVE_ACL |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4431 | 1 |
| 4432 | #else |
| 4433 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4434 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4435 | }, |
| 4436 | {"arabic", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4437 | #ifdef FEAT_ARABIC |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4438 | 1 |
| 4439 | #else |
| 4440 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4441 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4442 | }, |
| 4443 | {"autocmd", 1}, |
| 4444 | {"autochdir", |
Bram Moolenaar | 83ec2a7 | 2018-07-27 22:08:59 +0200 | [diff] [blame] | 4445 | #ifdef FEAT_AUTOCHDIR |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4446 | 1 |
| 4447 | #else |
| 4448 | 0 |
Bram Moolenaar | 83ec2a7 | 2018-07-27 22:08:59 +0200 | [diff] [blame] | 4449 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4450 | }, |
| 4451 | {"autoservername", |
Bram Moolenaar | e42a6d2 | 2017-11-12 19:21:51 +0100 | [diff] [blame] | 4452 | #ifdef FEAT_AUTOSERVERNAME |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4453 | 1 |
| 4454 | #else |
| 4455 | 0 |
Bram Moolenaar | e42a6d2 | 2017-11-12 19:21:51 +0100 | [diff] [blame] | 4456 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4457 | }, |
| 4458 | {"balloon_eval", |
Bram Moolenaar | c3719bd | 2017-11-18 22:13:31 +0100 | [diff] [blame] | 4459 | #ifdef FEAT_BEVAL_GUI |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4460 | 1 |
| 4461 | #else |
| 4462 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4463 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4464 | }, |
| 4465 | {"balloon_multiline", |
| 4466 | #if defined(FEAT_BEVAL_GUI) && !defined(FEAT_GUI_MSWIN) |
| 4467 | // MS-Windows requires runtime check, see below |
| 4468 | 1 |
| 4469 | #else |
| 4470 | 0 |
| 4471 | #endif |
| 4472 | }, |
| 4473 | {"balloon_eval_term", |
Bram Moolenaar | c3719bd | 2017-11-18 22:13:31 +0100 | [diff] [blame] | 4474 | #ifdef FEAT_BEVAL_TERM |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4475 | 1 |
| 4476 | #else |
| 4477 | 0 |
Bram Moolenaar | 51b0f37 | 2017-11-18 18:52:04 +0100 | [diff] [blame] | 4478 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4479 | }, |
| 4480 | {"builtin_terms", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4481 | #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS) |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4482 | 1 |
| 4483 | #else |
| 4484 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4485 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4486 | }, |
| 4487 | {"all_builtin_terms", |
| 4488 | #if defined(ALL_BUILTIN_TCAPS) |
| 4489 | 1 |
| 4490 | #else |
| 4491 | 0 |
| 4492 | #endif |
| 4493 | }, |
| 4494 | {"browsefilter", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4495 | #if defined(FEAT_BROWSE) && (defined(USE_FILE_CHOOSER) \ |
Bram Moolenaar | 4f97475 | 2019-02-17 17:44:42 +0100 | [diff] [blame] | 4496 | || defined(FEAT_GUI_MSWIN) \ |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4497 | || defined(FEAT_GUI_MOTIF)) |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4498 | 1 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4499 | #else |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4500 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 4501 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4502 | }, |
| 4503 | {"byte_offset", |
| 4504 | #ifdef FEAT_BYTEOFF |
| 4505 | 1 |
| 4506 | #else |
| 4507 | 0 |
| 4508 | #endif |
| 4509 | }, |
| 4510 | {"channel", |
| 4511 | #ifdef FEAT_JOB_CHANNEL |
| 4512 | 1 |
| 4513 | #else |
| 4514 | 0 |
| 4515 | #endif |
| 4516 | }, |
| 4517 | {"cindent", |
| 4518 | #ifdef FEAT_CINDENT |
| 4519 | 1 |
| 4520 | #else |
| 4521 | 0 |
| 4522 | #endif |
| 4523 | }, |
| 4524 | {"clientserver", |
| 4525 | #ifdef FEAT_CLIENTSERVER |
| 4526 | 1 |
| 4527 | #else |
| 4528 | 0 |
| 4529 | #endif |
| 4530 | }, |
| 4531 | {"clipboard", |
| 4532 | #ifdef FEAT_CLIPBOARD |
| 4533 | 1 |
| 4534 | #else |
| 4535 | 0 |
| 4536 | #endif |
| 4537 | }, |
| 4538 | {"cmdline_compl", 1}, |
| 4539 | {"cmdline_hist", 1}, |
Bram Moolenaar | 21829c5 | 2021-01-26 22:42:21 +0100 | [diff] [blame] | 4540 | {"cmdwin", |
| 4541 | #ifdef FEAT_CMDWIN |
| 4542 | 1 |
| 4543 | #else |
| 4544 | 0 |
| 4545 | #endif |
| 4546 | }, |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4547 | {"comments", 1}, |
| 4548 | {"conceal", |
| 4549 | #ifdef FEAT_CONCEAL |
| 4550 | 1 |
| 4551 | #else |
| 4552 | 0 |
| 4553 | #endif |
| 4554 | }, |
| 4555 | {"cryptv", |
| 4556 | #ifdef FEAT_CRYPT |
| 4557 | 1 |
| 4558 | #else |
| 4559 | 0 |
| 4560 | #endif |
| 4561 | }, |
| 4562 | {"crypt-blowfish", |
| 4563 | #ifdef FEAT_CRYPT |
| 4564 | 1 |
| 4565 | #else |
| 4566 | 0 |
| 4567 | #endif |
| 4568 | }, |
| 4569 | {"crypt-blowfish2", |
| 4570 | #ifdef FEAT_CRYPT |
| 4571 | 1 |
| 4572 | #else |
| 4573 | 0 |
| 4574 | #endif |
| 4575 | }, |
| 4576 | {"cscope", |
| 4577 | #ifdef FEAT_CSCOPE |
| 4578 | 1 |
| 4579 | #else |
| 4580 | 0 |
| 4581 | #endif |
| 4582 | }, |
| 4583 | {"cursorbind", 1}, |
| 4584 | {"cursorshape", |
| 4585 | #ifdef CURSOR_SHAPE |
| 4586 | 1 |
| 4587 | #else |
| 4588 | 0 |
| 4589 | #endif |
| 4590 | }, |
| 4591 | {"debug", |
| 4592 | #ifdef DEBUG |
| 4593 | 1 |
| 4594 | #else |
| 4595 | 0 |
| 4596 | #endif |
| 4597 | }, |
| 4598 | {"dialog_con", |
| 4599 | #ifdef FEAT_CON_DIALOG |
| 4600 | 1 |
| 4601 | #else |
| 4602 | 0 |
| 4603 | #endif |
| 4604 | }, |
| 4605 | {"dialog_gui", |
| 4606 | #ifdef FEAT_GUI_DIALOG |
| 4607 | 1 |
| 4608 | #else |
| 4609 | 0 |
| 4610 | #endif |
| 4611 | }, |
| 4612 | {"diff", |
| 4613 | #ifdef FEAT_DIFF |
| 4614 | 1 |
| 4615 | #else |
| 4616 | 0 |
| 4617 | #endif |
| 4618 | }, |
| 4619 | {"digraphs", |
| 4620 | #ifdef FEAT_DIGRAPHS |
| 4621 | 1 |
| 4622 | #else |
| 4623 | 0 |
| 4624 | #endif |
| 4625 | }, |
| 4626 | {"directx", |
| 4627 | #ifdef FEAT_DIRECTX |
| 4628 | 1 |
| 4629 | #else |
| 4630 | 0 |
| 4631 | #endif |
| 4632 | }, |
| 4633 | {"dnd", |
| 4634 | #ifdef FEAT_DND |
| 4635 | 1 |
| 4636 | #else |
| 4637 | 0 |
| 4638 | #endif |
| 4639 | }, |
Bram Moolenaar | 1d1ce61 | 2021-06-27 19:02:52 +0200 | [diff] [blame] | 4640 | {"drop_file", |
| 4641 | #ifdef HAVE_DROP_FILE |
| 4642 | 1 |
| 4643 | #else |
| 4644 | 0 |
| 4645 | #endif |
| 4646 | }, |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4647 | {"emacs_tags", |
| 4648 | #ifdef FEAT_EMACS_TAGS |
| 4649 | 1 |
| 4650 | #else |
| 4651 | 0 |
| 4652 | #endif |
| 4653 | }, |
| 4654 | {"eval", 1}, // always present, of course! |
| 4655 | {"ex_extra", 1}, // graduated feature |
| 4656 | {"extra_search", |
| 4657 | #ifdef FEAT_SEARCH_EXTRA |
| 4658 | 1 |
| 4659 | #else |
| 4660 | 0 |
| 4661 | #endif |
| 4662 | }, |
| 4663 | {"file_in_path", |
| 4664 | #ifdef FEAT_SEARCHPATH |
| 4665 | 1 |
| 4666 | #else |
| 4667 | 0 |
| 4668 | #endif |
| 4669 | }, |
| 4670 | {"filterpipe", |
| 4671 | #if defined(FEAT_FILTERPIPE) && !defined(VIMDLL) |
| 4672 | 1 |
| 4673 | #else |
| 4674 | 0 |
| 4675 | #endif |
| 4676 | }, |
| 4677 | {"find_in_path", |
| 4678 | #ifdef FEAT_FIND_ID |
| 4679 | 1 |
| 4680 | #else |
| 4681 | 0 |
| 4682 | #endif |
| 4683 | }, |
| 4684 | {"float", |
| 4685 | #ifdef FEAT_FLOAT |
| 4686 | 1 |
| 4687 | #else |
| 4688 | 0 |
| 4689 | #endif |
| 4690 | }, |
| 4691 | {"folding", |
| 4692 | #ifdef FEAT_FOLDING |
| 4693 | 1 |
| 4694 | #else |
| 4695 | 0 |
| 4696 | #endif |
| 4697 | }, |
| 4698 | {"footer", |
| 4699 | #ifdef FEAT_FOOTER |
| 4700 | 1 |
| 4701 | #else |
| 4702 | 0 |
| 4703 | #endif |
| 4704 | }, |
| 4705 | {"fork", |
| 4706 | #if !defined(USE_SYSTEM) && defined(UNIX) |
| 4707 | 1 |
| 4708 | #else |
| 4709 | 0 |
| 4710 | #endif |
| 4711 | }, |
| 4712 | {"gettext", |
| 4713 | #ifdef FEAT_GETTEXT |
| 4714 | 1 |
| 4715 | #else |
| 4716 | 0 |
| 4717 | #endif |
| 4718 | }, |
| 4719 | {"gui", |
| 4720 | #ifdef FEAT_GUI |
| 4721 | 1 |
| 4722 | #else |
| 4723 | 0 |
| 4724 | #endif |
| 4725 | }, |
| 4726 | {"gui_neXtaw", |
| 4727 | #if defined(FEAT_GUI_ATHENA) && defined(FEAT_GUI_NEXTAW) |
| 4728 | 1 |
| 4729 | #else |
| 4730 | 0 |
| 4731 | #endif |
| 4732 | }, |
| 4733 | {"gui_athena", |
| 4734 | #if defined(FEAT_GUI_ATHENA) && !defined(FEAT_GUI_NEXTAW) |
| 4735 | 1 |
| 4736 | #else |
| 4737 | 0 |
| 4738 | #endif |
| 4739 | }, |
| 4740 | {"gui_gtk", |
| 4741 | #ifdef FEAT_GUI_GTK |
| 4742 | 1 |
| 4743 | #else |
| 4744 | 0 |
| 4745 | #endif |
| 4746 | }, |
| 4747 | {"gui_gtk2", |
| 4748 | #if defined(FEAT_GUI_GTK) && !defined(USE_GTK3) |
| 4749 | 1 |
| 4750 | #else |
| 4751 | 0 |
| 4752 | #endif |
| 4753 | }, |
| 4754 | {"gui_gtk3", |
| 4755 | #if defined(FEAT_GUI_GTK) && defined(USE_GTK3) |
| 4756 | 1 |
| 4757 | #else |
| 4758 | 0 |
| 4759 | #endif |
| 4760 | }, |
| 4761 | {"gui_gnome", |
| 4762 | #ifdef FEAT_GUI_GNOME |
| 4763 | 1 |
| 4764 | #else |
| 4765 | 0 |
| 4766 | #endif |
| 4767 | }, |
| 4768 | {"gui_haiku", |
| 4769 | #ifdef FEAT_GUI_HAIKU |
| 4770 | 1 |
| 4771 | #else |
| 4772 | 0 |
| 4773 | #endif |
| 4774 | }, |
Bram Moolenaar | 097148e | 2020-08-11 21:58:20 +0200 | [diff] [blame] | 4775 | {"gui_mac", 0}, |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4776 | {"gui_motif", |
| 4777 | #ifdef FEAT_GUI_MOTIF |
| 4778 | 1 |
| 4779 | #else |
| 4780 | 0 |
| 4781 | #endif |
| 4782 | }, |
| 4783 | {"gui_photon", |
| 4784 | #ifdef FEAT_GUI_PHOTON |
| 4785 | 1 |
| 4786 | #else |
| 4787 | 0 |
| 4788 | #endif |
| 4789 | }, |
| 4790 | {"gui_win32", |
| 4791 | #ifdef FEAT_GUI_MSWIN |
| 4792 | 1 |
| 4793 | #else |
| 4794 | 0 |
| 4795 | #endif |
| 4796 | }, |
| 4797 | {"iconv", |
| 4798 | #if defined(HAVE_ICONV_H) && defined(USE_ICONV) |
| 4799 | 1 |
| 4800 | #else |
| 4801 | 0 |
| 4802 | #endif |
| 4803 | }, |
| 4804 | {"insert_expand", 1}, |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 4805 | {"ipv6", |
| 4806 | #ifdef FEAT_IPV6 |
| 4807 | 1 |
| 4808 | #else |
| 4809 | 0 |
| 4810 | #endif |
| 4811 | }, |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 4812 | {"job", |
| 4813 | #ifdef FEAT_JOB_CHANNEL |
| 4814 | 1 |
| 4815 | #else |
| 4816 | 0 |
| 4817 | #endif |
| 4818 | }, |
| 4819 | {"jumplist", |
| 4820 | #ifdef FEAT_JUMPLIST |
| 4821 | 1 |
| 4822 | #else |
| 4823 | 0 |
| 4824 | #endif |
| 4825 | }, |
| 4826 | {"keymap", |
| 4827 | #ifdef FEAT_KEYMAP |
| 4828 | 1 |
| 4829 | #else |
| 4830 | 0 |
| 4831 | #endif |
| 4832 | }, |
| 4833 | {"lambda", 1}, // always with FEAT_EVAL, since 7.4.2120 with closure |
| 4834 | {"langmap", |
| 4835 | #ifdef FEAT_LANGMAP |
| 4836 | 1 |
| 4837 | #else |
| 4838 | 0 |
| 4839 | #endif |
| 4840 | }, |
| 4841 | {"libcall", |
| 4842 | #ifdef FEAT_LIBCALL |
| 4843 | 1 |
| 4844 | #else |
| 4845 | 0 |
| 4846 | #endif |
| 4847 | }, |
| 4848 | {"linebreak", |
| 4849 | #ifdef FEAT_LINEBREAK |
| 4850 | 1 |
| 4851 | #else |
| 4852 | 0 |
| 4853 | #endif |
| 4854 | }, |
| 4855 | {"lispindent", |
| 4856 | #ifdef FEAT_LISP |
| 4857 | 1 |
| 4858 | #else |
| 4859 | 0 |
| 4860 | #endif |
| 4861 | }, |
| 4862 | {"listcmds", 1}, |
| 4863 | {"localmap", 1}, |
| 4864 | {"lua", |
| 4865 | #if defined(FEAT_LUA) && !defined(DYNAMIC_LUA) |
| 4866 | 1 |
| 4867 | #else |
| 4868 | 0 |
| 4869 | #endif |
| 4870 | }, |
| 4871 | {"menu", |
| 4872 | #ifdef FEAT_MENU |
| 4873 | 1 |
| 4874 | #else |
| 4875 | 0 |
| 4876 | #endif |
| 4877 | }, |
| 4878 | {"mksession", |
| 4879 | #ifdef FEAT_SESSION |
| 4880 | 1 |
| 4881 | #else |
| 4882 | 0 |
| 4883 | #endif |
| 4884 | }, |
| 4885 | {"modify_fname", 1}, |
| 4886 | {"mouse", 1}, |
| 4887 | {"mouseshape", |
| 4888 | #ifdef FEAT_MOUSESHAPE |
| 4889 | 1 |
| 4890 | #else |
| 4891 | 0 |
| 4892 | #endif |
| 4893 | }, |
| 4894 | {"mouse_dec", |
| 4895 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_DEC) |
| 4896 | 1 |
| 4897 | #else |
| 4898 | 0 |
| 4899 | #endif |
| 4900 | }, |
| 4901 | {"mouse_gpm", |
| 4902 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_GPM) |
| 4903 | 1 |
| 4904 | #else |
| 4905 | 0 |
| 4906 | #endif |
| 4907 | }, |
| 4908 | {"mouse_jsbterm", |
| 4909 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_JSB) |
| 4910 | 1 |
| 4911 | #else |
| 4912 | 0 |
| 4913 | #endif |
| 4914 | }, |
| 4915 | {"mouse_netterm", |
| 4916 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_NET) |
| 4917 | 1 |
| 4918 | #else |
| 4919 | 0 |
| 4920 | #endif |
| 4921 | }, |
| 4922 | {"mouse_pterm", |
| 4923 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_PTERM) |
| 4924 | 1 |
| 4925 | #else |
| 4926 | 0 |
| 4927 | #endif |
| 4928 | }, |
| 4929 | {"mouse_sgr", |
| 4930 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM) |
| 4931 | 1 |
| 4932 | #else |
| 4933 | 0 |
| 4934 | #endif |
| 4935 | }, |
| 4936 | {"mouse_sysmouse", |
| 4937 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_SYSMOUSE) |
| 4938 | 1 |
| 4939 | #else |
| 4940 | 0 |
| 4941 | #endif |
| 4942 | }, |
| 4943 | {"mouse_urxvt", |
| 4944 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_URXVT) |
| 4945 | 1 |
| 4946 | #else |
| 4947 | 0 |
| 4948 | #endif |
| 4949 | }, |
| 4950 | {"mouse_xterm", |
| 4951 | #if (defined(UNIX) || defined(VMS)) && defined(FEAT_MOUSE_XTERM) |
| 4952 | 1 |
| 4953 | #else |
| 4954 | 0 |
| 4955 | #endif |
| 4956 | }, |
| 4957 | {"multi_byte", 1}, |
| 4958 | {"multi_byte_ime", |
| 4959 | #ifdef FEAT_MBYTE_IME |
| 4960 | 1 |
| 4961 | #else |
| 4962 | 0 |
| 4963 | #endif |
| 4964 | }, |
| 4965 | {"multi_lang", |
| 4966 | #ifdef FEAT_MULTI_LANG |
| 4967 | 1 |
| 4968 | #else |
| 4969 | 0 |
| 4970 | #endif |
| 4971 | }, |
| 4972 | {"mzscheme", |
| 4973 | #if defined(FEAT_MZSCHEME) && !defined(DYNAMIC_MZSCHEME) |
| 4974 | 1 |
| 4975 | #else |
| 4976 | 0 |
| 4977 | #endif |
| 4978 | }, |
| 4979 | {"num64", 1}, |
| 4980 | {"ole", |
| 4981 | #ifdef FEAT_OLE |
| 4982 | 1 |
| 4983 | #else |
| 4984 | 0 |
| 4985 | #endif |
| 4986 | }, |
| 4987 | {"packages", |
| 4988 | #ifdef FEAT_EVAL |
| 4989 | 1 |
| 4990 | #else |
| 4991 | 0 |
| 4992 | #endif |
| 4993 | }, |
| 4994 | {"path_extra", |
| 4995 | #ifdef FEAT_PATH_EXTRA |
| 4996 | 1 |
| 4997 | #else |
| 4998 | 0 |
| 4999 | #endif |
| 5000 | }, |
| 5001 | {"perl", |
| 5002 | #if defined(FEAT_PERL) && !defined(DYNAMIC_PERL) |
| 5003 | 1 |
| 5004 | #else |
| 5005 | 0 |
| 5006 | #endif |
| 5007 | }, |
| 5008 | {"persistent_undo", |
| 5009 | #ifdef FEAT_PERSISTENT_UNDO |
| 5010 | 1 |
| 5011 | #else |
| 5012 | 0 |
| 5013 | #endif |
| 5014 | }, |
| 5015 | {"python_compiled", |
| 5016 | #if defined(FEAT_PYTHON) |
| 5017 | 1 |
| 5018 | #else |
| 5019 | 0 |
| 5020 | #endif |
| 5021 | }, |
| 5022 | {"python_dynamic", |
| 5023 | #if defined(FEAT_PYTHON) && defined(DYNAMIC_PYTHON) |
| 5024 | 1 |
| 5025 | #else |
| 5026 | 0 |
| 5027 | #endif |
| 5028 | }, |
| 5029 | {"python", |
| 5030 | #if defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON) |
| 5031 | 1 |
| 5032 | #else |
| 5033 | 0 |
| 5034 | #endif |
| 5035 | }, |
| 5036 | {"pythonx", |
| 5037 | #if (defined(FEAT_PYTHON) && !defined(DYNAMIC_PYTHON)) \ |
| 5038 | || (defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3)) |
| 5039 | 1 |
| 5040 | #else |
| 5041 | 0 |
| 5042 | #endif |
| 5043 | }, |
| 5044 | {"python3_compiled", |
| 5045 | #if defined(FEAT_PYTHON3) |
| 5046 | 1 |
| 5047 | #else |
| 5048 | 0 |
| 5049 | #endif |
| 5050 | }, |
| 5051 | {"python3_dynamic", |
| 5052 | #if defined(FEAT_PYTHON3) && defined(DYNAMIC_PYTHON3) |
| 5053 | 1 |
| 5054 | #else |
| 5055 | 0 |
| 5056 | #endif |
| 5057 | }, |
| 5058 | {"python3", |
| 5059 | #if defined(FEAT_PYTHON3) && !defined(DYNAMIC_PYTHON3) |
| 5060 | 1 |
| 5061 | #else |
| 5062 | 0 |
| 5063 | #endif |
| 5064 | }, |
| 5065 | {"popupwin", |
| 5066 | #ifdef FEAT_PROP_POPUP |
| 5067 | 1 |
| 5068 | #else |
| 5069 | 0 |
| 5070 | #endif |
| 5071 | }, |
| 5072 | {"postscript", |
| 5073 | #ifdef FEAT_POSTSCRIPT |
| 5074 | 1 |
| 5075 | #else |
| 5076 | 0 |
| 5077 | #endif |
| 5078 | }, |
| 5079 | {"printer", |
| 5080 | #ifdef FEAT_PRINTER |
| 5081 | 1 |
| 5082 | #else |
| 5083 | 0 |
| 5084 | #endif |
| 5085 | }, |
| 5086 | {"profile", |
| 5087 | #ifdef FEAT_PROFILE |
| 5088 | 1 |
| 5089 | #else |
| 5090 | 0 |
| 5091 | #endif |
| 5092 | }, |
| 5093 | {"reltime", |
| 5094 | #ifdef FEAT_RELTIME |
| 5095 | 1 |
| 5096 | #else |
| 5097 | 0 |
| 5098 | #endif |
| 5099 | }, |
| 5100 | {"quickfix", |
| 5101 | #ifdef FEAT_QUICKFIX |
| 5102 | 1 |
| 5103 | #else |
| 5104 | 0 |
| 5105 | #endif |
| 5106 | }, |
| 5107 | {"rightleft", |
| 5108 | #ifdef FEAT_RIGHTLEFT |
| 5109 | 1 |
| 5110 | #else |
| 5111 | 0 |
| 5112 | #endif |
| 5113 | }, |
| 5114 | {"ruby", |
| 5115 | #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY) |
| 5116 | 1 |
| 5117 | #else |
| 5118 | 0 |
| 5119 | #endif |
| 5120 | }, |
| 5121 | {"scrollbind", 1}, |
| 5122 | {"showcmd", |
| 5123 | #ifdef FEAT_CMDL_INFO |
| 5124 | 1 |
| 5125 | #else |
| 5126 | 0 |
| 5127 | #endif |
| 5128 | }, |
| 5129 | {"cmdline_info", |
| 5130 | #ifdef FEAT_CMDL_INFO |
| 5131 | 1 |
| 5132 | #else |
| 5133 | 0 |
| 5134 | #endif |
| 5135 | }, |
| 5136 | {"signs", |
| 5137 | #ifdef FEAT_SIGNS |
| 5138 | 1 |
| 5139 | #else |
| 5140 | 0 |
| 5141 | #endif |
| 5142 | }, |
| 5143 | {"smartindent", |
| 5144 | #ifdef FEAT_SMARTINDENT |
| 5145 | 1 |
| 5146 | #else |
| 5147 | 0 |
| 5148 | #endif |
| 5149 | }, |
| 5150 | {"startuptime", |
| 5151 | #ifdef STARTUPTIME |
| 5152 | 1 |
| 5153 | #else |
| 5154 | 0 |
| 5155 | #endif |
| 5156 | }, |
| 5157 | {"statusline", |
| 5158 | #ifdef FEAT_STL_OPT |
| 5159 | 1 |
| 5160 | #else |
| 5161 | 0 |
| 5162 | #endif |
| 5163 | }, |
| 5164 | {"netbeans_intg", |
| 5165 | #ifdef FEAT_NETBEANS_INTG |
| 5166 | 1 |
| 5167 | #else |
| 5168 | 0 |
| 5169 | #endif |
| 5170 | }, |
Christian Brabandt | f573c6e | 2021-06-20 14:02:16 +0200 | [diff] [blame] | 5171 | {"sodium", |
| 5172 | #ifdef FEAT_SODIUM |
| 5173 | 1 |
| 5174 | #else |
| 5175 | 0 |
| 5176 | #endif |
| 5177 | }, |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5178 | {"sound", |
| 5179 | #ifdef FEAT_SOUND |
| 5180 | 1 |
| 5181 | #else |
| 5182 | 0 |
| 5183 | #endif |
| 5184 | }, |
| 5185 | {"spell", |
| 5186 | #ifdef FEAT_SPELL |
| 5187 | 1 |
| 5188 | #else |
| 5189 | 0 |
| 5190 | #endif |
| 5191 | }, |
| 5192 | {"syntax", |
| 5193 | #ifdef FEAT_SYN_HL |
| 5194 | 1 |
| 5195 | #else |
| 5196 | 0 |
| 5197 | #endif |
| 5198 | }, |
| 5199 | {"system", |
| 5200 | #if defined(USE_SYSTEM) || !defined(UNIX) |
| 5201 | 1 |
| 5202 | #else |
| 5203 | 0 |
| 5204 | #endif |
| 5205 | }, |
| 5206 | {"tag_binary", |
| 5207 | #ifdef FEAT_TAG_BINS |
| 5208 | 1 |
| 5209 | #else |
| 5210 | 0 |
| 5211 | #endif |
| 5212 | }, |
| 5213 | {"tcl", |
| 5214 | #if defined(FEAT_TCL) && !defined(DYNAMIC_TCL) |
| 5215 | 1 |
| 5216 | #else |
| 5217 | 0 |
| 5218 | #endif |
| 5219 | }, |
| 5220 | {"termguicolors", |
| 5221 | #ifdef FEAT_TERMGUICOLORS |
| 5222 | 1 |
| 5223 | #else |
| 5224 | 0 |
| 5225 | #endif |
| 5226 | }, |
| 5227 | {"terminal", |
| 5228 | #if defined(FEAT_TERMINAL) && !defined(MSWIN) |
| 5229 | 1 |
| 5230 | #else |
| 5231 | 0 |
| 5232 | #endif |
| 5233 | }, |
| 5234 | {"terminfo", |
| 5235 | #ifdef TERMINFO |
| 5236 | 1 |
| 5237 | #else |
| 5238 | 0 |
| 5239 | #endif |
| 5240 | }, |
| 5241 | {"termresponse", |
| 5242 | #ifdef FEAT_TERMRESPONSE |
| 5243 | 1 |
| 5244 | #else |
| 5245 | 0 |
| 5246 | #endif |
| 5247 | }, |
| 5248 | {"textobjects", |
| 5249 | #ifdef FEAT_TEXTOBJ |
| 5250 | 1 |
| 5251 | #else |
| 5252 | 0 |
| 5253 | #endif |
| 5254 | }, |
| 5255 | {"textprop", |
| 5256 | #ifdef FEAT_PROP_POPUP |
| 5257 | 1 |
| 5258 | #else |
| 5259 | 0 |
| 5260 | #endif |
| 5261 | }, |
| 5262 | {"tgetent", |
| 5263 | #ifdef HAVE_TGETENT |
| 5264 | 1 |
| 5265 | #else |
| 5266 | 0 |
| 5267 | #endif |
| 5268 | }, |
| 5269 | {"timers", |
| 5270 | #ifdef FEAT_TIMERS |
| 5271 | 1 |
| 5272 | #else |
| 5273 | 0 |
| 5274 | #endif |
| 5275 | }, |
| 5276 | {"title", |
| 5277 | #ifdef FEAT_TITLE |
| 5278 | 1 |
| 5279 | #else |
| 5280 | 0 |
| 5281 | #endif |
| 5282 | }, |
| 5283 | {"toolbar", |
| 5284 | #ifdef FEAT_TOOLBAR |
| 5285 | 1 |
| 5286 | #else |
| 5287 | 0 |
| 5288 | #endif |
| 5289 | }, |
| 5290 | {"unnamedplus", |
| 5291 | #if defined(FEAT_CLIPBOARD) && defined(FEAT_X11) |
| 5292 | 1 |
| 5293 | #else |
| 5294 | 0 |
| 5295 | #endif |
| 5296 | }, |
| 5297 | {"user-commands", 1}, // was accidentally included in 5.4 |
| 5298 | {"user_commands", 1}, |
| 5299 | {"vartabs", |
| 5300 | #ifdef FEAT_VARTABS |
| 5301 | 1 |
| 5302 | #else |
| 5303 | 0 |
| 5304 | #endif |
| 5305 | }, |
| 5306 | {"vertsplit", 1}, |
| 5307 | {"viminfo", |
| 5308 | #ifdef FEAT_VIMINFO |
| 5309 | 1 |
| 5310 | #else |
| 5311 | 0 |
| 5312 | #endif |
| 5313 | }, |
| 5314 | {"vimscript-1", 1}, |
| 5315 | {"vimscript-2", 1}, |
| 5316 | {"vimscript-3", 1}, |
| 5317 | {"vimscript-4", 1}, |
| 5318 | {"virtualedit", 1}, |
| 5319 | {"visual", 1}, |
| 5320 | {"visualextra", 1}, |
| 5321 | {"vreplace", 1}, |
| 5322 | {"vtp", |
| 5323 | #ifdef FEAT_VTP |
| 5324 | 1 |
| 5325 | #else |
| 5326 | 0 |
| 5327 | #endif |
| 5328 | }, |
| 5329 | {"wildignore", |
| 5330 | #ifdef FEAT_WILDIGN |
| 5331 | 1 |
| 5332 | #else |
| 5333 | 0 |
| 5334 | #endif |
| 5335 | }, |
| 5336 | {"wildmenu", |
| 5337 | #ifdef FEAT_WILDMENU |
| 5338 | 1 |
| 5339 | #else |
| 5340 | 0 |
| 5341 | #endif |
| 5342 | }, |
| 5343 | {"windows", 1}, |
| 5344 | {"winaltkeys", |
| 5345 | #ifdef FEAT_WAK |
| 5346 | 1 |
| 5347 | #else |
| 5348 | 0 |
| 5349 | #endif |
| 5350 | }, |
| 5351 | {"writebackup", |
| 5352 | #ifdef FEAT_WRITEBACKUP |
| 5353 | 1 |
| 5354 | #else |
| 5355 | 0 |
| 5356 | #endif |
| 5357 | }, |
| 5358 | {"xim", |
| 5359 | #ifdef FEAT_XIM |
| 5360 | 1 |
| 5361 | #else |
| 5362 | 0 |
| 5363 | #endif |
| 5364 | }, |
| 5365 | {"xfontset", |
| 5366 | #ifdef FEAT_XFONTSET |
| 5367 | 1 |
| 5368 | #else |
| 5369 | 0 |
| 5370 | #endif |
| 5371 | }, |
| 5372 | {"xpm", |
| 5373 | #if defined(FEAT_XPM_W32) || defined(HAVE_XPM) |
| 5374 | 1 |
| 5375 | #else |
| 5376 | 0 |
| 5377 | #endif |
| 5378 | }, |
| 5379 | {"xpm_w32", // for backward compatibility |
| 5380 | #ifdef FEAT_XPM_W32 |
| 5381 | 1 |
| 5382 | #else |
| 5383 | 0 |
| 5384 | #endif |
| 5385 | }, |
| 5386 | {"xsmp", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5387 | #ifdef USE_XSMP |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5388 | 1 |
| 5389 | #else |
| 5390 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5391 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5392 | }, |
| 5393 | {"xsmp_interact", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5394 | #ifdef USE_XSMP_INTERACT |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5395 | 1 |
| 5396 | #else |
| 5397 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5398 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5399 | }, |
| 5400 | {"xterm_clipboard", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5401 | #ifdef FEAT_XCLIPBOARD |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5402 | 1 |
| 5403 | #else |
| 5404 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5405 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5406 | }, |
| 5407 | {"xterm_save", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5408 | #ifdef FEAT_XTERM_SAVE |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5409 | 1 |
| 5410 | #else |
| 5411 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5412 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5413 | }, |
| 5414 | {"X11", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5415 | #if defined(UNIX) && defined(FEAT_X11) |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5416 | 1 |
| 5417 | #else |
| 5418 | 0 |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5419 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5420 | }, |
| 5421 | {NULL, 0} |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5422 | }; |
| 5423 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5424 | name = tv_get_string(&argvars[0]); |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5425 | for (i = 0; has_list[i].name != NULL; ++i) |
| 5426 | if (STRICMP(name, has_list[i].name) == 0) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5427 | { |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5428 | x = TRUE; |
| 5429 | n = has_list[i].present; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5430 | break; |
| 5431 | } |
| 5432 | |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5433 | // features also in has_list[] but sometimes enabled at runtime |
| 5434 | if (x == TRUE && n == FALSE) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5435 | { |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5436 | if (0) |
Bram Moolenaar | 86b9a3e | 2020-04-07 19:57:29 +0200 | [diff] [blame] | 5437 | { |
| 5438 | // intentionally empty |
| 5439 | } |
Bram Moolenaar | 4f97475 | 2019-02-17 17:44:42 +0100 | [diff] [blame] | 5440 | #if defined(FEAT_BEVAL) && defined(FEAT_GUI_MSWIN) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5441 | else if (STRICMP(name, "balloon_multiline") == 0) |
| 5442 | n = multiline_balloon_available(); |
| 5443 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5444 | #ifdef VIMDLL |
| 5445 | else if (STRICMP(name, "filterpipe") == 0) |
| 5446 | n = gui.in_use || gui.starting; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5447 | #endif |
| 5448 | #if defined(USE_ICONV) && defined(DYNAMIC_ICONV) |
| 5449 | else if (STRICMP(name, "iconv") == 0) |
| 5450 | n = iconv_enabled(FALSE); |
| 5451 | #endif |
| 5452 | #ifdef DYNAMIC_LUA |
| 5453 | else if (STRICMP(name, "lua") == 0) |
| 5454 | n = lua_enabled(FALSE); |
| 5455 | #endif |
| 5456 | #ifdef DYNAMIC_MZSCHEME |
| 5457 | else if (STRICMP(name, "mzscheme") == 0) |
| 5458 | n = mzscheme_enabled(FALSE); |
| 5459 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5460 | #ifdef DYNAMIC_PERL |
| 5461 | else if (STRICMP(name, "perl") == 0) |
| 5462 | n = perl_enabled(FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5463 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5464 | #ifdef DYNAMIC_PYTHON |
| 5465 | else if (STRICMP(name, "python") == 0) |
| 5466 | n = python_enabled(FALSE); |
| 5467 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5468 | #ifdef DYNAMIC_PYTHON3 |
| 5469 | else if (STRICMP(name, "python3") == 0) |
| 5470 | n = python3_enabled(FALSE); |
| 5471 | #endif |
Bram Moolenaar | f42dd3c | 2017-01-28 16:06:38 +0100 | [diff] [blame] | 5472 | #if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3) |
| 5473 | else if (STRICMP(name, "pythonx") == 0) |
| 5474 | { |
| 5475 | # if defined(DYNAMIC_PYTHON) && defined(DYNAMIC_PYTHON3) |
| 5476 | if (p_pyx == 0) |
| 5477 | n = python3_enabled(FALSE) || python_enabled(FALSE); |
| 5478 | else if (p_pyx == 3) |
| 5479 | n = python3_enabled(FALSE); |
| 5480 | else if (p_pyx == 2) |
| 5481 | n = python_enabled(FALSE); |
| 5482 | # elif defined(DYNAMIC_PYTHON) |
| 5483 | n = python_enabled(FALSE); |
| 5484 | # elif defined(DYNAMIC_PYTHON3) |
| 5485 | n = python3_enabled(FALSE); |
| 5486 | # endif |
| 5487 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5488 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5489 | #ifdef DYNAMIC_RUBY |
| 5490 | else if (STRICMP(name, "ruby") == 0) |
| 5491 | n = ruby_enabled(FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5492 | #endif |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5493 | #ifdef DYNAMIC_TCL |
| 5494 | else if (STRICMP(name, "tcl") == 0) |
| 5495 | n = tcl_enabled(FALSE); |
Bram Moolenaar | 4b8366b | 2019-05-04 17:34:34 +0200 | [diff] [blame] | 5496 | #endif |
Bram Moolenaar | 4f97475 | 2019-02-17 17:44:42 +0100 | [diff] [blame] | 5497 | #if defined(FEAT_TERMINAL) && defined(MSWIN) |
Bram Moolenaar | a83e396 | 2017-08-17 14:39:07 +0200 | [diff] [blame] | 5498 | else if (STRICMP(name, "terminal") == 0) |
| 5499 | n = terminal_enabled(); |
| 5500 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5501 | } |
| 5502 | |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5503 | // features not in has_list[] |
| 5504 | if (x == FALSE) |
| 5505 | { |
| 5506 | if (STRNICMP(name, "patch", 5) == 0) |
| 5507 | { |
| 5508 | x = TRUE; |
| 5509 | if (name[5] == '-' |
| 5510 | && STRLEN(name) >= 11 |
| 5511 | && vim_isdigit(name[6]) |
| 5512 | && vim_isdigit(name[8]) |
| 5513 | && vim_isdigit(name[10])) |
| 5514 | { |
| 5515 | int major = atoi((char *)name + 6); |
| 5516 | int minor = atoi((char *)name + 8); |
| 5517 | |
| 5518 | // Expect "patch-9.9.01234". |
| 5519 | n = (major < VIM_VERSION_MAJOR |
| 5520 | || (major == VIM_VERSION_MAJOR |
| 5521 | && (minor < VIM_VERSION_MINOR |
| 5522 | || (minor == VIM_VERSION_MINOR |
| 5523 | && has_patch(atoi((char *)name + 10)))))); |
| 5524 | } |
| 5525 | else |
| 5526 | n = has_patch(atoi((char *)name + 5)); |
| 5527 | } |
| 5528 | else if (STRICMP(name, "vim_starting") == 0) |
| 5529 | { |
| 5530 | x = TRUE; |
| 5531 | n = (starting != 0); |
| 5532 | } |
| 5533 | else if (STRICMP(name, "ttyin") == 0) |
| 5534 | { |
| 5535 | x = TRUE; |
| 5536 | n = mch_input_isatty(); |
| 5537 | } |
| 5538 | else if (STRICMP(name, "ttyout") == 0) |
| 5539 | { |
| 5540 | x = TRUE; |
| 5541 | n = stdout_isatty; |
| 5542 | } |
| 5543 | else if (STRICMP(name, "multi_byte_encoding") == 0) |
| 5544 | { |
| 5545 | x = TRUE; |
| 5546 | n = has_mbyte; |
| 5547 | } |
| 5548 | else if (STRICMP(name, "gui_running") == 0) |
| 5549 | { |
| 5550 | x = TRUE; |
| 5551 | #ifdef FEAT_GUI |
| 5552 | n = (gui.in_use || gui.starting); |
| 5553 | #endif |
| 5554 | } |
| 5555 | else if (STRICMP(name, "browse") == 0) |
| 5556 | { |
| 5557 | x = TRUE; |
| 5558 | #if defined(FEAT_GUI) && defined(FEAT_BROWSE) |
| 5559 | n = gui.in_use; // gui_mch_browse() works when GUI is running |
| 5560 | #endif |
| 5561 | } |
| 5562 | else if (STRICMP(name, "syntax_items") == 0) |
| 5563 | { |
| 5564 | x = TRUE; |
| 5565 | #ifdef FEAT_SYN_HL |
| 5566 | n = syntax_present(curwin); |
| 5567 | #endif |
| 5568 | } |
| 5569 | else if (STRICMP(name, "vcon") == 0) |
| 5570 | { |
| 5571 | x = TRUE; |
| 5572 | #ifdef FEAT_VTP |
| 5573 | n = is_term_win32() && has_vtp_working(); |
| 5574 | #endif |
| 5575 | } |
| 5576 | else if (STRICMP(name, "netbeans_enabled") == 0) |
| 5577 | { |
| 5578 | x = TRUE; |
| 5579 | #ifdef FEAT_NETBEANS_INTG |
| 5580 | n = netbeans_active(); |
| 5581 | #endif |
| 5582 | } |
| 5583 | else if (STRICMP(name, "mouse_gpm_enabled") == 0) |
| 5584 | { |
| 5585 | x = TRUE; |
| 5586 | #ifdef FEAT_MOUSE_GPM |
| 5587 | n = gpm_enabled(); |
| 5588 | #endif |
| 5589 | } |
| 5590 | else if (STRICMP(name, "conpty") == 0) |
| 5591 | { |
| 5592 | x = TRUE; |
| 5593 | #if defined(FEAT_TERMINAL) && defined(MSWIN) |
| 5594 | n = use_conpty(); |
| 5595 | #endif |
| 5596 | } |
| 5597 | else if (STRICMP(name, "clipboard_working") == 0) |
| 5598 | { |
| 5599 | x = TRUE; |
| 5600 | #ifdef FEAT_CLIPBOARD |
| 5601 | n = clip_star.available; |
| 5602 | #endif |
| 5603 | } |
| 5604 | } |
| 5605 | |
Bram Moolenaar | 04637e2 | 2020-09-05 18:45:29 +0200 | [diff] [blame] | 5606 | if (argvars[1].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[1])) |
Bram Moolenaar | 7929651 | 2020-03-22 16:17:14 +0100 | [diff] [blame] | 5607 | // return whether feature could ever be enabled |
| 5608 | rettv->vval.v_number = x; |
| 5609 | else |
| 5610 | // return whether feature is enabled |
| 5611 | rettv->vval.v_number = n; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5612 | } |
| 5613 | |
| 5614 | /* |
Bram Moolenaar | 8cebd43 | 2020-11-08 12:49:47 +0100 | [diff] [blame] | 5615 | * Return TRUE if "feature" can change later. |
| 5616 | * Also when checking for the feature has side effects, such as loading a DLL. |
| 5617 | */ |
| 5618 | int |
| 5619 | dynamic_feature(char_u *feature) |
| 5620 | { |
| 5621 | return (feature == NULL |
| 5622 | #if defined(FEAT_BEVAL) && defined(FEAT_GUI_MSWIN) |
| 5623 | || STRICMP(feature, "balloon_multiline") == 0 |
| 5624 | #endif |
| 5625 | #if defined(FEAT_GUI) && defined(FEAT_BROWSE) |
| 5626 | || (STRICMP(feature, "browse") == 0 && !gui.in_use) |
| 5627 | #endif |
| 5628 | #ifdef VIMDLL |
| 5629 | || STRICMP(feature, "filterpipe") == 0 |
| 5630 | #endif |
Bram Moolenaar | 29b281b | 2020-11-10 20:58:00 +0100 | [diff] [blame] | 5631 | #if defined(FEAT_GUI) && !defined(ALWAYS_USE_GUI) && !defined(VIMDLL) |
Bram Moolenaar | 8cebd43 | 2020-11-08 12:49:47 +0100 | [diff] [blame] | 5632 | // this can only change on Unix where the ":gui" command could be |
| 5633 | // used. |
| 5634 | || (STRICMP(feature, "gui_running") == 0 && !gui.in_use) |
| 5635 | #endif |
| 5636 | #if defined(USE_ICONV) && defined(DYNAMIC_ICONV) |
| 5637 | || STRICMP(feature, "iconv") == 0 |
| 5638 | #endif |
| 5639 | #ifdef DYNAMIC_LUA |
| 5640 | || STRICMP(feature, "lua") == 0 |
| 5641 | #endif |
| 5642 | #ifdef FEAT_MOUSE_GPM |
| 5643 | || (STRICMP(feature, "mouse_gpm_enabled") == 0 && !gpm_enabled()) |
| 5644 | #endif |
| 5645 | #ifdef DYNAMIC_MZSCHEME |
| 5646 | || STRICMP(feature, "mzscheme") == 0 |
| 5647 | #endif |
| 5648 | #ifdef FEAT_NETBEANS_INTG |
| 5649 | || STRICMP(feature, "netbeans_enabled") == 0 |
| 5650 | #endif |
| 5651 | #ifdef DYNAMIC_PERL |
| 5652 | || STRICMP(feature, "perl") == 0 |
| 5653 | #endif |
| 5654 | #ifdef DYNAMIC_PYTHON |
| 5655 | || STRICMP(feature, "python") == 0 |
| 5656 | #endif |
| 5657 | #ifdef DYNAMIC_PYTHON3 |
| 5658 | || STRICMP(feature, "python3") == 0 |
| 5659 | #endif |
| 5660 | #if defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3) |
| 5661 | || STRICMP(feature, "pythonx") == 0 |
| 5662 | #endif |
| 5663 | #ifdef DYNAMIC_RUBY |
| 5664 | || STRICMP(feature, "ruby") == 0 |
| 5665 | #endif |
| 5666 | #ifdef FEAT_SYN_HL |
| 5667 | || STRICMP(feature, "syntax_items") == 0 |
| 5668 | #endif |
| 5669 | #ifdef DYNAMIC_TCL |
| 5670 | || STRICMP(feature, "tcl") == 0 |
| 5671 | #endif |
| 5672 | // once "starting" is zero it will stay that way |
| 5673 | || (STRICMP(feature, "vim_starting") == 0 && starting != 0) |
| 5674 | || STRICMP(feature, "multi_byte_encoding") == 0 |
| 5675 | #if defined(FEAT_TERMINAL) && defined(MSWIN) |
| 5676 | || STRICMP(feature, "conpty") == 0 |
| 5677 | #endif |
| 5678 | ); |
| 5679 | } |
| 5680 | |
| 5681 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5682 | * "haslocaldir()" function |
| 5683 | */ |
| 5684 | static void |
| 5685 | f_haslocaldir(typval_T *argvars, typval_T *rettv) |
| 5686 | { |
Bram Moolenaar | 00aa069 | 2019-04-27 20:37:57 +0200 | [diff] [blame] | 5687 | tabpage_T *tp = NULL; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5688 | win_T *wp = NULL; |
| 5689 | |
Bram Moolenaar | 00aa069 | 2019-04-27 20:37:57 +0200 | [diff] [blame] | 5690 | wp = find_tabwin(&argvars[0], &argvars[1], &tp); |
| 5691 | |
| 5692 | // Check for window-local and tab-local directories |
| 5693 | if (wp != NULL && wp->w_localdir != NULL) |
| 5694 | rettv->vval.v_number = 1; |
| 5695 | else if (tp != NULL && tp->tp_localdir != NULL) |
| 5696 | rettv->vval.v_number = 2; |
| 5697 | else |
| 5698 | rettv->vval.v_number = 0; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5699 | } |
| 5700 | |
| 5701 | /* |
| 5702 | * "hasmapto()" function |
| 5703 | */ |
| 5704 | static void |
| 5705 | f_hasmapto(typval_T *argvars, typval_T *rettv) |
| 5706 | { |
| 5707 | char_u *name; |
| 5708 | char_u *mode; |
| 5709 | char_u buf[NUMBUFLEN]; |
| 5710 | int abbr = FALSE; |
| 5711 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5712 | name = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5713 | if (argvars[1].v_type == VAR_UNKNOWN) |
| 5714 | mode = (char_u *)"nvo"; |
| 5715 | else |
| 5716 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5717 | mode = tv_get_string_buf(&argvars[1], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5718 | if (argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 04d594b | 2020-09-02 22:25:35 +0200 | [diff] [blame] | 5719 | abbr = (int)tv_get_bool(&argvars[2]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5720 | } |
| 5721 | |
| 5722 | if (map_to_exists(name, mode, abbr)) |
| 5723 | rettv->vval.v_number = TRUE; |
| 5724 | else |
| 5725 | rettv->vval.v_number = FALSE; |
| 5726 | } |
| 5727 | |
| 5728 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5729 | * "highlightID(name)" function |
| 5730 | */ |
| 5731 | static void |
| 5732 | f_hlID(typval_T *argvars, typval_T *rettv) |
| 5733 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5734 | rettv->vval.v_number = syn_name2id(tv_get_string(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5735 | } |
| 5736 | |
| 5737 | /* |
| 5738 | * "highlight_exists()" function |
| 5739 | */ |
| 5740 | static void |
| 5741 | f_hlexists(typval_T *argvars, typval_T *rettv) |
| 5742 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5743 | rettv->vval.v_number = highlight_exists(tv_get_string(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5744 | } |
| 5745 | |
| 5746 | /* |
| 5747 | * "hostname()" function |
| 5748 | */ |
| 5749 | static void |
| 5750 | f_hostname(typval_T *argvars UNUSED, typval_T *rettv) |
| 5751 | { |
| 5752 | char_u hostname[256]; |
| 5753 | |
| 5754 | mch_get_host_name(hostname, 256); |
| 5755 | rettv->v_type = VAR_STRING; |
| 5756 | rettv->vval.v_string = vim_strsave(hostname); |
| 5757 | } |
| 5758 | |
| 5759 | /* |
| 5760 | * iconv() function |
| 5761 | */ |
| 5762 | static void |
| 5763 | f_iconv(typval_T *argvars UNUSED, typval_T *rettv) |
| 5764 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5765 | char_u buf1[NUMBUFLEN]; |
| 5766 | char_u buf2[NUMBUFLEN]; |
| 5767 | char_u *from, *to, *str; |
| 5768 | vimconv_T vimconv; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5769 | |
| 5770 | rettv->v_type = VAR_STRING; |
| 5771 | rettv->vval.v_string = NULL; |
| 5772 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5773 | str = tv_get_string(&argvars[0]); |
| 5774 | from = enc_canonize(enc_skip(tv_get_string_buf(&argvars[1], buf1))); |
| 5775 | to = enc_canonize(enc_skip(tv_get_string_buf(&argvars[2], buf2))); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5776 | vimconv.vc_type = CONV_NONE; |
| 5777 | convert_setup(&vimconv, from, to); |
| 5778 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5779 | // If the encodings are equal, no conversion needed. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5780 | if (vimconv.vc_type == CONV_NONE) |
| 5781 | rettv->vval.v_string = vim_strsave(str); |
| 5782 | else |
| 5783 | rettv->vval.v_string = string_convert(&vimconv, str, NULL); |
| 5784 | |
| 5785 | convert_setup(&vimconv, NULL, NULL); |
| 5786 | vim_free(from); |
| 5787 | vim_free(to); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5788 | } |
| 5789 | |
| 5790 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5791 | * "index()" function |
| 5792 | */ |
| 5793 | static void |
| 5794 | f_index(typval_T *argvars, typval_T *rettv) |
| 5795 | { |
| 5796 | list_T *l; |
| 5797 | listitem_T *item; |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 5798 | blob_T *b; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5799 | long idx = 0; |
| 5800 | int ic = FALSE; |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 5801 | int error = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5802 | |
| 5803 | rettv->vval.v_number = -1; |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 5804 | if (argvars[0].v_type == VAR_BLOB) |
| 5805 | { |
| 5806 | typval_T tv; |
| 5807 | int start = 0; |
| 5808 | |
| 5809 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 5810 | { |
| 5811 | start = tv_get_number_chk(&argvars[2], &error); |
| 5812 | if (error) |
| 5813 | return; |
| 5814 | } |
| 5815 | b = argvars[0].vval.v_blob; |
| 5816 | if (b == NULL) |
| 5817 | return; |
Bram Moolenaar | 05500ec | 2019-01-13 19:10:33 +0100 | [diff] [blame] | 5818 | if (start < 0) |
| 5819 | { |
| 5820 | start = blob_len(b) + start; |
| 5821 | if (start < 0) |
| 5822 | start = 0; |
| 5823 | } |
| 5824 | |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 5825 | for (idx = start; idx < blob_len(b); ++idx) |
| 5826 | { |
| 5827 | tv.v_type = VAR_NUMBER; |
| 5828 | tv.vval.v_number = blob_get(b, idx); |
| 5829 | if (tv_equal(&tv, &argvars[1], ic, FALSE)) |
| 5830 | { |
| 5831 | rettv->vval.v_number = idx; |
| 5832 | return; |
| 5833 | } |
| 5834 | } |
| 5835 | return; |
| 5836 | } |
| 5837 | else if (argvars[0].v_type != VAR_LIST) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5838 | { |
Bram Moolenaar | 0d17f0d | 2019-01-22 22:20:38 +0100 | [diff] [blame] | 5839 | emsg(_(e_listblobreq)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5840 | return; |
| 5841 | } |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 5842 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5843 | l = argvars[0].vval.v_list; |
| 5844 | if (l != NULL) |
| 5845 | { |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 5846 | CHECK_LIST_MATERIALIZE(l); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5847 | item = l->lv_first; |
| 5848 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 5849 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5850 | // Start at specified item. Use the cached index that list_find() |
| 5851 | // sets, so that a negative number also works. |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5852 | item = list_find(l, (long)tv_get_number_chk(&argvars[2], &error)); |
Bram Moolenaar | 0ff6aad | 2020-01-29 21:27:21 +0100 | [diff] [blame] | 5853 | idx = l->lv_u.mat.lv_idx; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5854 | if (argvars[3].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 6c553f9 | 2020-09-02 22:10:34 +0200 | [diff] [blame] | 5855 | ic = (int)tv_get_bool_chk(&argvars[3], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5856 | if (error) |
| 5857 | item = NULL; |
| 5858 | } |
| 5859 | |
| 5860 | for ( ; item != NULL; item = item->li_next, ++idx) |
| 5861 | if (tv_equal(&item->li_tv, &argvars[1], ic, FALSE)) |
| 5862 | { |
| 5863 | rettv->vval.v_number = idx; |
| 5864 | break; |
| 5865 | } |
| 5866 | } |
| 5867 | } |
| 5868 | |
| 5869 | static int inputsecret_flag = 0; |
| 5870 | |
| 5871 | /* |
| 5872 | * "input()" function |
| 5873 | * Also handles inputsecret() when inputsecret is set. |
| 5874 | */ |
| 5875 | static void |
| 5876 | f_input(typval_T *argvars, typval_T *rettv) |
| 5877 | { |
| 5878 | get_user_input(argvars, rettv, FALSE, inputsecret_flag); |
| 5879 | } |
| 5880 | |
| 5881 | /* |
| 5882 | * "inputdialog()" function |
| 5883 | */ |
| 5884 | static void |
| 5885 | f_inputdialog(typval_T *argvars, typval_T *rettv) |
| 5886 | { |
| 5887 | #if defined(FEAT_GUI_TEXTDIALOG) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5888 | // Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5889 | if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL) |
| 5890 | { |
| 5891 | char_u *message; |
| 5892 | char_u buf[NUMBUFLEN]; |
| 5893 | char_u *defstr = (char_u *)""; |
| 5894 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5895 | message = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5896 | if (argvars[1].v_type != VAR_UNKNOWN |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5897 | && (defstr = tv_get_string_buf_chk(&argvars[1], buf)) != NULL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5898 | vim_strncpy(IObuff, defstr, IOSIZE - 1); |
| 5899 | else |
| 5900 | IObuff[0] = NUL; |
| 5901 | if (message != NULL && defstr != NULL |
| 5902 | && do_dialog(VIM_QUESTION, NULL, message, |
| 5903 | (char_u *)_("&OK\n&Cancel"), 1, IObuff, FALSE) == 1) |
| 5904 | rettv->vval.v_string = vim_strsave(IObuff); |
| 5905 | else |
| 5906 | { |
| 5907 | if (message != NULL && defstr != NULL |
| 5908 | && argvars[1].v_type != VAR_UNKNOWN |
| 5909 | && argvars[2].v_type != VAR_UNKNOWN) |
| 5910 | rettv->vval.v_string = vim_strsave( |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 5911 | tv_get_string_buf(&argvars[2], buf)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5912 | else |
| 5913 | rettv->vval.v_string = NULL; |
| 5914 | } |
| 5915 | rettv->v_type = VAR_STRING; |
| 5916 | } |
| 5917 | else |
| 5918 | #endif |
| 5919 | get_user_input(argvars, rettv, TRUE, inputsecret_flag); |
| 5920 | } |
| 5921 | |
| 5922 | /* |
| 5923 | * "inputlist()" function |
| 5924 | */ |
| 5925 | static void |
| 5926 | f_inputlist(typval_T *argvars, typval_T *rettv) |
| 5927 | { |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 5928 | list_T *l; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5929 | listitem_T *li; |
| 5930 | int selected; |
| 5931 | int mouse_used; |
| 5932 | |
| 5933 | #ifdef NO_CONSOLE_INPUT |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5934 | // While starting up, there is no place to enter text. When running tests |
| 5935 | // with --not-a-term we assume feedkeys() will be used. |
Bram Moolenaar | 91d348a | 2017-07-29 20:16:03 +0200 | [diff] [blame] | 5936 | if (no_console_input() && !is_not_a_term()) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5937 | return; |
| 5938 | #endif |
| 5939 | if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL) |
| 5940 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 5941 | semsg(_(e_listarg), "inputlist()"); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5942 | return; |
| 5943 | } |
| 5944 | |
| 5945 | msg_start(); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5946 | msg_row = Rows - 1; // for when 'cmdheight' > 1 |
| 5947 | lines_left = Rows; // avoid more prompt |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5948 | msg_scroll = TRUE; |
| 5949 | msg_clr_eos(); |
| 5950 | |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 5951 | l = argvars[0].vval.v_list; |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 5952 | CHECK_LIST_MATERIALIZE(l); |
Bram Moolenaar | 00d253e | 2020-04-06 22:13:01 +0200 | [diff] [blame] | 5953 | FOR_ALL_LIST_ITEMS(l, li) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5954 | { |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 5955 | msg_puts((char *)tv_get_string(&li->li_tv)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5956 | msg_putchar('\n'); |
| 5957 | } |
| 5958 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5959 | // Ask for choice. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5960 | selected = prompt_for_number(&mouse_used); |
| 5961 | if (mouse_used) |
| 5962 | selected -= lines_left; |
| 5963 | |
| 5964 | rettv->vval.v_number = selected; |
| 5965 | } |
| 5966 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5967 | static garray_T ga_userinput = {0, 0, sizeof(tasave_T), 4, NULL}; |
| 5968 | |
| 5969 | /* |
| 5970 | * "inputrestore()" function |
| 5971 | */ |
| 5972 | static void |
| 5973 | f_inputrestore(typval_T *argvars UNUSED, typval_T *rettv) |
| 5974 | { |
| 5975 | if (ga_userinput.ga_len > 0) |
| 5976 | { |
| 5977 | --ga_userinput.ga_len; |
| 5978 | restore_typeahead((tasave_T *)(ga_userinput.ga_data) |
Bram Moolenaar | c41badb | 2021-06-07 22:04:52 +0200 | [diff] [blame] | 5979 | + ga_userinput.ga_len, TRUE); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5980 | // default return is zero == OK |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5981 | } |
| 5982 | else if (p_verbose > 1) |
| 5983 | { |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 5984 | verb_msg(_("called inputrestore() more often than inputsave()")); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5985 | rettv->vval.v_number = 1; // Failed |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5986 | } |
| 5987 | } |
| 5988 | |
| 5989 | /* |
| 5990 | * "inputsave()" function |
| 5991 | */ |
| 5992 | static void |
| 5993 | f_inputsave(typval_T *argvars UNUSED, typval_T *rettv) |
| 5994 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 5995 | // Add an entry to the stack of typeahead storage. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 5996 | if (ga_grow(&ga_userinput, 1) == OK) |
| 5997 | { |
| 5998 | save_typeahead((tasave_T *)(ga_userinput.ga_data) |
| 5999 | + ga_userinput.ga_len); |
| 6000 | ++ga_userinput.ga_len; |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6001 | // default return is zero == OK |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6002 | } |
| 6003 | else |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6004 | rettv->vval.v_number = 1; // Failed |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6005 | } |
| 6006 | |
| 6007 | /* |
| 6008 | * "inputsecret()" function |
| 6009 | */ |
| 6010 | static void |
| 6011 | f_inputsecret(typval_T *argvars, typval_T *rettv) |
| 6012 | { |
| 6013 | ++cmdline_star; |
| 6014 | ++inputsecret_flag; |
| 6015 | f_input(argvars, rettv); |
| 6016 | --cmdline_star; |
| 6017 | --inputsecret_flag; |
| 6018 | } |
| 6019 | |
| 6020 | /* |
Bram Moolenaar | 67a2deb | 2019-11-25 00:05:32 +0100 | [diff] [blame] | 6021 | * "interrupt()" function |
| 6022 | */ |
| 6023 | static void |
| 6024 | f_interrupt(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 6025 | { |
| 6026 | got_int = TRUE; |
| 6027 | } |
| 6028 | |
| 6029 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6030 | * "invert(expr)" function |
| 6031 | */ |
| 6032 | static void |
| 6033 | f_invert(typval_T *argvars, typval_T *rettv) |
| 6034 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6035 | rettv->vval.v_number = ~tv_get_number_chk(&argvars[0], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6036 | } |
| 6037 | |
| 6038 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6039 | * "islocked()" function |
| 6040 | */ |
| 6041 | static void |
| 6042 | f_islocked(typval_T *argvars, typval_T *rettv) |
| 6043 | { |
| 6044 | lval_T lv; |
| 6045 | char_u *end; |
| 6046 | dictitem_T *di; |
| 6047 | |
| 6048 | rettv->vval.v_number = -1; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6049 | end = get_lval(tv_get_string(&argvars[0]), NULL, &lv, FALSE, FALSE, |
Bram Moolenaar | 3a25773 | 2017-02-21 20:47:13 +0100 | [diff] [blame] | 6050 | GLV_NO_AUTOLOAD | GLV_READ_ONLY, FNE_CHECK_START); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6051 | if (end != NULL && lv.ll_name != NULL) |
| 6052 | { |
| 6053 | if (*end != NUL) |
Bram Moolenaar | 2d06bfd | 2020-07-23 17:16:18 +0200 | [diff] [blame] | 6054 | semsg(_(e_trailing_arg), end); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6055 | else |
| 6056 | { |
| 6057 | if (lv.ll_tv == NULL) |
| 6058 | { |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 6059 | di = find_var(lv.ll_name, NULL, TRUE); |
| 6060 | if (di != NULL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6061 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6062 | // Consider a variable locked when: |
| 6063 | // 1. the variable itself is locked |
| 6064 | // 2. the value of the variable is locked. |
| 6065 | // 3. the List or Dict value is locked. |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 6066 | rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK) |
| 6067 | || tv_islocked(&di->di_tv)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6068 | } |
| 6069 | } |
| 6070 | else if (lv.ll_range) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 6071 | emsg(_("E786: Range not allowed")); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6072 | else if (lv.ll_newkey != NULL) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 6073 | semsg(_(e_dictkey), lv.ll_newkey); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6074 | else if (lv.ll_list != NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6075 | // List item. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6076 | rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv); |
| 6077 | else |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6078 | // Dictionary item. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6079 | rettv->vval.v_number = tv_islocked(&lv.ll_di->di_tv); |
| 6080 | } |
| 6081 | } |
| 6082 | |
| 6083 | clear_lval(&lv); |
| 6084 | } |
| 6085 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6086 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6087 | * "last_buffer_nr()" function. |
| 6088 | */ |
| 6089 | static void |
| 6090 | f_last_buffer_nr(typval_T *argvars UNUSED, typval_T *rettv) |
| 6091 | { |
| 6092 | int n = 0; |
| 6093 | buf_T *buf; |
| 6094 | |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 6095 | FOR_ALL_BUFFERS(buf) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6096 | if (n < buf->b_fnum) |
| 6097 | n = buf->b_fnum; |
| 6098 | |
| 6099 | rettv->vval.v_number = n; |
| 6100 | } |
| 6101 | |
| 6102 | /* |
| 6103 | * "len()" function |
| 6104 | */ |
| 6105 | static void |
| 6106 | f_len(typval_T *argvars, typval_T *rettv) |
| 6107 | { |
| 6108 | switch (argvars[0].v_type) |
| 6109 | { |
| 6110 | case VAR_STRING: |
| 6111 | case VAR_NUMBER: |
| 6112 | rettv->vval.v_number = (varnumber_T)STRLEN( |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6113 | tv_get_string(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6114 | break; |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 6115 | case VAR_BLOB: |
| 6116 | rettv->vval.v_number = blob_len(argvars[0].vval.v_blob); |
| 6117 | break; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6118 | case VAR_LIST: |
| 6119 | rettv->vval.v_number = list_len(argvars[0].vval.v_list); |
| 6120 | break; |
| 6121 | case VAR_DICT: |
| 6122 | rettv->vval.v_number = dict_len(argvars[0].vval.v_dict); |
| 6123 | break; |
| 6124 | case VAR_UNKNOWN: |
Bram Moolenaar | 4c68375 | 2020-04-05 21:38:23 +0200 | [diff] [blame] | 6125 | case VAR_ANY: |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 6126 | case VAR_VOID: |
Bram Moolenaar | 9b4a15d | 2020-01-11 16:05:23 +0100 | [diff] [blame] | 6127 | case VAR_BOOL: |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6128 | case VAR_SPECIAL: |
| 6129 | case VAR_FLOAT: |
| 6130 | case VAR_FUNC: |
| 6131 | case VAR_PARTIAL: |
| 6132 | case VAR_JOB: |
| 6133 | case VAR_CHANNEL: |
Bram Moolenaar | f18332f | 2021-05-07 17:55:55 +0200 | [diff] [blame] | 6134 | case VAR_INSTR: |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 6135 | emsg(_("E701: Invalid type for len()")); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6136 | break; |
| 6137 | } |
| 6138 | } |
| 6139 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6140 | static void |
Bram Moolenaar | 6d721c7 | 2017-01-17 16:56:28 +0100 | [diff] [blame] | 6141 | libcall_common(typval_T *argvars UNUSED, typval_T *rettv, int type) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6142 | { |
| 6143 | #ifdef FEAT_LIBCALL |
| 6144 | char_u *string_in; |
| 6145 | char_u **string_result; |
| 6146 | int nr_result; |
| 6147 | #endif |
| 6148 | |
| 6149 | rettv->v_type = type; |
| 6150 | if (type != VAR_NUMBER) |
| 6151 | rettv->vval.v_string = NULL; |
| 6152 | |
| 6153 | if (check_restricted() || check_secure()) |
| 6154 | return; |
| 6155 | |
| 6156 | #ifdef FEAT_LIBCALL |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6157 | // The first two args must be strings, otherwise it's meaningless |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6158 | if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING) |
| 6159 | { |
| 6160 | string_in = NULL; |
| 6161 | if (argvars[2].v_type == VAR_STRING) |
| 6162 | string_in = argvars[2].vval.v_string; |
| 6163 | if (type == VAR_NUMBER) |
| 6164 | string_result = NULL; |
| 6165 | else |
| 6166 | string_result = &rettv->vval.v_string; |
| 6167 | if (mch_libcall(argvars[0].vval.v_string, |
| 6168 | argvars[1].vval.v_string, |
| 6169 | string_in, |
| 6170 | argvars[2].vval.v_number, |
| 6171 | string_result, |
| 6172 | &nr_result) == OK |
| 6173 | && type == VAR_NUMBER) |
| 6174 | rettv->vval.v_number = nr_result; |
| 6175 | } |
| 6176 | #endif |
| 6177 | } |
| 6178 | |
| 6179 | /* |
| 6180 | * "libcall()" function |
| 6181 | */ |
| 6182 | static void |
| 6183 | f_libcall(typval_T *argvars, typval_T *rettv) |
| 6184 | { |
| 6185 | libcall_common(argvars, rettv, VAR_STRING); |
| 6186 | } |
| 6187 | |
| 6188 | /* |
| 6189 | * "libcallnr()" function |
| 6190 | */ |
| 6191 | static void |
| 6192 | f_libcallnr(typval_T *argvars, typval_T *rettv) |
| 6193 | { |
| 6194 | libcall_common(argvars, rettv, VAR_NUMBER); |
| 6195 | } |
| 6196 | |
| 6197 | /* |
Bram Moolenaar | 8e0a8e7 | 2019-09-02 22:56:24 +0200 | [diff] [blame] | 6198 | * "line(string, [winid])" function |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6199 | */ |
| 6200 | static void |
| 6201 | f_line(typval_T *argvars, typval_T *rettv) |
| 6202 | { |
| 6203 | linenr_T lnum = 0; |
Bram Moolenaar | 8e0a8e7 | 2019-09-02 22:56:24 +0200 | [diff] [blame] | 6204 | pos_T *fp = NULL; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6205 | int fnum; |
Bram Moolenaar | 8e0a8e7 | 2019-09-02 22:56:24 +0200 | [diff] [blame] | 6206 | int id; |
| 6207 | tabpage_T *tp; |
| 6208 | win_T *wp; |
| 6209 | win_T *save_curwin; |
| 6210 | tabpage_T *save_curtab; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6211 | |
Bram Moolenaar | 8e0a8e7 | 2019-09-02 22:56:24 +0200 | [diff] [blame] | 6212 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 6213 | { |
| 6214 | // use window specified in the second argument |
| 6215 | id = (int)tv_get_number(&argvars[1]); |
| 6216 | wp = win_id2wp_tp(id, &tp); |
| 6217 | if (wp != NULL && tp != NULL) |
| 6218 | { |
| 6219 | if (switch_win_noblock(&save_curwin, &save_curtab, wp, tp, TRUE) |
| 6220 | == OK) |
| 6221 | { |
| 6222 | check_cursor(); |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 6223 | fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE); |
Bram Moolenaar | 8e0a8e7 | 2019-09-02 22:56:24 +0200 | [diff] [blame] | 6224 | } |
| 6225 | restore_win_noblock(save_curwin, save_curtab, TRUE); |
| 6226 | } |
| 6227 | } |
| 6228 | else |
| 6229 | // use current window |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 6230 | fp = var2fpos(&argvars[0], TRUE, &fnum, FALSE); |
Bram Moolenaar | 8e0a8e7 | 2019-09-02 22:56:24 +0200 | [diff] [blame] | 6231 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6232 | if (fp != NULL) |
| 6233 | lnum = fp->lnum; |
| 6234 | rettv->vval.v_number = lnum; |
| 6235 | } |
| 6236 | |
| 6237 | /* |
| 6238 | * "line2byte(lnum)" function |
| 6239 | */ |
| 6240 | static void |
| 6241 | f_line2byte(typval_T *argvars UNUSED, typval_T *rettv) |
| 6242 | { |
| 6243 | #ifndef FEAT_BYTEOFF |
| 6244 | rettv->vval.v_number = -1; |
| 6245 | #else |
| 6246 | linenr_T lnum; |
| 6247 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6248 | lnum = tv_get_lnum(argvars); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6249 | if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1) |
| 6250 | rettv->vval.v_number = -1; |
| 6251 | else |
| 6252 | rettv->vval.v_number = ml_find_line_or_offset(curbuf, lnum, NULL); |
| 6253 | if (rettv->vval.v_number >= 0) |
| 6254 | ++rettv->vval.v_number; |
| 6255 | #endif |
| 6256 | } |
| 6257 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6258 | #ifdef FEAT_LUA |
| 6259 | /* |
| 6260 | * "luaeval()" function |
| 6261 | */ |
| 6262 | static void |
| 6263 | f_luaeval(typval_T *argvars, typval_T *rettv) |
| 6264 | { |
| 6265 | char_u *str; |
| 6266 | char_u buf[NUMBUFLEN]; |
| 6267 | |
Bram Moolenaar | 8c62a08 | 2019-02-08 14:34:10 +0100 | [diff] [blame] | 6268 | if (check_restricted() || check_secure()) |
| 6269 | return; |
| 6270 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6271 | str = tv_get_string_buf(&argvars[0], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6272 | do_luaeval(str, argvars + 1, rettv); |
| 6273 | } |
| 6274 | #endif |
| 6275 | |
| 6276 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6277 | * "maparg()" function |
| 6278 | */ |
| 6279 | static void |
| 6280 | f_maparg(typval_T *argvars, typval_T *rettv) |
| 6281 | { |
| 6282 | get_maparg(argvars, rettv, TRUE); |
| 6283 | } |
| 6284 | |
| 6285 | /* |
| 6286 | * "mapcheck()" function |
| 6287 | */ |
| 6288 | static void |
| 6289 | f_mapcheck(typval_T *argvars, typval_T *rettv) |
| 6290 | { |
| 6291 | get_maparg(argvars, rettv, FALSE); |
| 6292 | } |
| 6293 | |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6294 | typedef enum |
| 6295 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6296 | MATCH_END, // matchend() |
| 6297 | MATCH_MATCH, // match() |
| 6298 | MATCH_STR, // matchstr() |
| 6299 | MATCH_LIST, // matchlist() |
| 6300 | MATCH_POS // matchstrpos() |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6301 | } matchtype_T; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6302 | |
| 6303 | static void |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6304 | find_some_match(typval_T *argvars, typval_T *rettv, matchtype_T type) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6305 | { |
| 6306 | char_u *str = NULL; |
| 6307 | long len = 0; |
| 6308 | char_u *expr = NULL; |
| 6309 | char_u *pat; |
| 6310 | regmatch_T regmatch; |
| 6311 | char_u patbuf[NUMBUFLEN]; |
| 6312 | char_u strbuf[NUMBUFLEN]; |
| 6313 | char_u *save_cpo; |
| 6314 | long start = 0; |
| 6315 | long nth = 1; |
| 6316 | colnr_T startcol = 0; |
| 6317 | int match = 0; |
| 6318 | list_T *l = NULL; |
| 6319 | listitem_T *li = NULL; |
| 6320 | long idx = 0; |
| 6321 | char_u *tofree = NULL; |
| 6322 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6323 | // Make 'cpoptions' empty, the 'l' flag should not be used here. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6324 | save_cpo = p_cpo; |
Bram Moolenaar | e5a2dc8 | 2021-01-03 19:52:05 +0100 | [diff] [blame] | 6325 | p_cpo = empty_option; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6326 | |
| 6327 | rettv->vval.v_number = -1; |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6328 | if (type == MATCH_LIST || type == MATCH_POS) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6329 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6330 | // type MATCH_LIST: return empty list when there are no matches. |
| 6331 | // type MATCH_POS: return ["", -1, -1, -1] |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6332 | if (rettv_list_alloc(rettv) == FAIL) |
| 6333 | goto theend; |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6334 | if (type == MATCH_POS |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6335 | && (list_append_string(rettv->vval.v_list, |
| 6336 | (char_u *)"", 0) == FAIL |
| 6337 | || list_append_number(rettv->vval.v_list, |
| 6338 | (varnumber_T)-1) == FAIL |
| 6339 | || list_append_number(rettv->vval.v_list, |
| 6340 | (varnumber_T)-1) == FAIL |
| 6341 | || list_append_number(rettv->vval.v_list, |
| 6342 | (varnumber_T)-1) == FAIL)) |
| 6343 | { |
| 6344 | list_free(rettv->vval.v_list); |
| 6345 | rettv->vval.v_list = NULL; |
| 6346 | goto theend; |
| 6347 | } |
| 6348 | } |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6349 | else if (type == MATCH_STR) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6350 | { |
| 6351 | rettv->v_type = VAR_STRING; |
| 6352 | rettv->vval.v_string = NULL; |
| 6353 | } |
| 6354 | |
| 6355 | if (argvars[0].v_type == VAR_LIST) |
| 6356 | { |
| 6357 | if ((l = argvars[0].vval.v_list) == NULL) |
| 6358 | goto theend; |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 6359 | CHECK_LIST_MATERIALIZE(l); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6360 | li = l->lv_first; |
| 6361 | } |
| 6362 | else |
| 6363 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6364 | expr = str = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6365 | len = (long)STRLEN(str); |
| 6366 | } |
| 6367 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6368 | pat = tv_get_string_buf_chk(&argvars[1], patbuf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6369 | if (pat == NULL) |
| 6370 | goto theend; |
| 6371 | |
| 6372 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 6373 | { |
| 6374 | int error = FALSE; |
| 6375 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6376 | start = (long)tv_get_number_chk(&argvars[2], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6377 | if (error) |
| 6378 | goto theend; |
| 6379 | if (l != NULL) |
| 6380 | { |
| 6381 | li = list_find(l, start); |
| 6382 | if (li == NULL) |
| 6383 | goto theend; |
Bram Moolenaar | 0ff6aad | 2020-01-29 21:27:21 +0100 | [diff] [blame] | 6384 | idx = l->lv_u.mat.lv_idx; // use the cached index |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6385 | } |
| 6386 | else |
| 6387 | { |
| 6388 | if (start < 0) |
| 6389 | start = 0; |
| 6390 | if (start > len) |
| 6391 | goto theend; |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6392 | // When "count" argument is there ignore matches before "start", |
| 6393 | // otherwise skip part of the string. Differs when pattern is "^" |
| 6394 | // or "\<". |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6395 | if (argvars[3].v_type != VAR_UNKNOWN) |
| 6396 | startcol = start; |
| 6397 | else |
| 6398 | { |
| 6399 | str += start; |
| 6400 | len -= start; |
| 6401 | } |
| 6402 | } |
| 6403 | |
| 6404 | if (argvars[3].v_type != VAR_UNKNOWN) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6405 | nth = (long)tv_get_number_chk(&argvars[3], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6406 | if (error) |
| 6407 | goto theend; |
| 6408 | } |
| 6409 | |
| 6410 | regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); |
| 6411 | if (regmatch.regprog != NULL) |
| 6412 | { |
| 6413 | regmatch.rm_ic = p_ic; |
| 6414 | |
| 6415 | for (;;) |
| 6416 | { |
| 6417 | if (l != NULL) |
| 6418 | { |
| 6419 | if (li == NULL) |
| 6420 | { |
| 6421 | match = FALSE; |
| 6422 | break; |
| 6423 | } |
| 6424 | vim_free(tofree); |
| 6425 | expr = str = echo_string(&li->li_tv, &tofree, strbuf, 0); |
| 6426 | if (str == NULL) |
| 6427 | break; |
| 6428 | } |
| 6429 | |
| 6430 | match = vim_regexec_nl(®match, str, (colnr_T)startcol); |
| 6431 | |
| 6432 | if (match && --nth <= 0) |
| 6433 | break; |
| 6434 | if (l == NULL && !match) |
| 6435 | break; |
| 6436 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6437 | // Advance to just after the match. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6438 | if (l != NULL) |
| 6439 | { |
| 6440 | li = li->li_next; |
| 6441 | ++idx; |
| 6442 | } |
| 6443 | else |
| 6444 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6445 | startcol = (colnr_T)(regmatch.startp[0] |
| 6446 | + (*mb_ptr2len)(regmatch.startp[0]) - str); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6447 | if (startcol > (colnr_T)len |
| 6448 | || str + startcol <= regmatch.startp[0]) |
| 6449 | { |
| 6450 | match = FALSE; |
| 6451 | break; |
| 6452 | } |
| 6453 | } |
| 6454 | } |
| 6455 | |
| 6456 | if (match) |
| 6457 | { |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6458 | if (type == MATCH_POS) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6459 | { |
| 6460 | listitem_T *li1 = rettv->vval.v_list->lv_first; |
| 6461 | listitem_T *li2 = li1->li_next; |
| 6462 | listitem_T *li3 = li2->li_next; |
| 6463 | listitem_T *li4 = li3->li_next; |
| 6464 | |
| 6465 | vim_free(li1->li_tv.vval.v_string); |
| 6466 | li1->li_tv.vval.v_string = vim_strnsave(regmatch.startp[0], |
Bram Moolenaar | df44a27 | 2020-06-07 20:49:05 +0200 | [diff] [blame] | 6467 | regmatch.endp[0] - regmatch.startp[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6468 | li3->li_tv.vval.v_number = |
| 6469 | (varnumber_T)(regmatch.startp[0] - expr); |
| 6470 | li4->li_tv.vval.v_number = |
| 6471 | (varnumber_T)(regmatch.endp[0] - expr); |
| 6472 | if (l != NULL) |
| 6473 | li2->li_tv.vval.v_number = (varnumber_T)idx; |
| 6474 | } |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6475 | else if (type == MATCH_LIST) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6476 | { |
| 6477 | int i; |
| 6478 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6479 | // return list with matched string and submatches |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6480 | for (i = 0; i < NSUBEXP; ++i) |
| 6481 | { |
| 6482 | if (regmatch.endp[i] == NULL) |
| 6483 | { |
| 6484 | if (list_append_string(rettv->vval.v_list, |
| 6485 | (char_u *)"", 0) == FAIL) |
| 6486 | break; |
| 6487 | } |
| 6488 | else if (list_append_string(rettv->vval.v_list, |
| 6489 | regmatch.startp[i], |
| 6490 | (int)(regmatch.endp[i] - regmatch.startp[i])) |
| 6491 | == FAIL) |
| 6492 | break; |
| 6493 | } |
| 6494 | } |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6495 | else if (type == MATCH_STR) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6496 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6497 | // return matched string |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6498 | if (l != NULL) |
| 6499 | copy_tv(&li->li_tv, rettv); |
| 6500 | else |
| 6501 | rettv->vval.v_string = vim_strnsave(regmatch.startp[0], |
Bram Moolenaar | df44a27 | 2020-06-07 20:49:05 +0200 | [diff] [blame] | 6502 | regmatch.endp[0] - regmatch.startp[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6503 | } |
| 6504 | else if (l != NULL) |
| 6505 | rettv->vval.v_number = idx; |
| 6506 | else |
| 6507 | { |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6508 | if (type != MATCH_END) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6509 | rettv->vval.v_number = |
| 6510 | (varnumber_T)(regmatch.startp[0] - str); |
| 6511 | else |
| 6512 | rettv->vval.v_number = |
| 6513 | (varnumber_T)(regmatch.endp[0] - str); |
| 6514 | rettv->vval.v_number += (varnumber_T)(str - expr); |
| 6515 | } |
| 6516 | } |
| 6517 | vim_regfree(regmatch.regprog); |
| 6518 | } |
| 6519 | |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6520 | theend: |
| 6521 | if (type == MATCH_POS && l == NULL && rettv->vval.v_list != NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6522 | // matchstrpos() without a list: drop the second item. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6523 | listitem_remove(rettv->vval.v_list, |
| 6524 | rettv->vval.v_list->lv_first->li_next); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6525 | vim_free(tofree); |
| 6526 | p_cpo = save_cpo; |
| 6527 | } |
| 6528 | |
| 6529 | /* |
| 6530 | * "match()" function |
| 6531 | */ |
| 6532 | static void |
| 6533 | f_match(typval_T *argvars, typval_T *rettv) |
| 6534 | { |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6535 | find_some_match(argvars, rettv, MATCH_MATCH); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6536 | } |
| 6537 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6538 | /* |
| 6539 | * "matchend()" function |
| 6540 | */ |
| 6541 | static void |
| 6542 | f_matchend(typval_T *argvars, typval_T *rettv) |
| 6543 | { |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6544 | find_some_match(argvars, rettv, MATCH_END); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6545 | } |
| 6546 | |
| 6547 | /* |
| 6548 | * "matchlist()" function |
| 6549 | */ |
| 6550 | static void |
| 6551 | f_matchlist(typval_T *argvars, typval_T *rettv) |
| 6552 | { |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6553 | find_some_match(argvars, rettv, MATCH_LIST); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6554 | } |
| 6555 | |
| 6556 | /* |
| 6557 | * "matchstr()" function |
| 6558 | */ |
| 6559 | static void |
| 6560 | f_matchstr(typval_T *argvars, typval_T *rettv) |
| 6561 | { |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6562 | find_some_match(argvars, rettv, MATCH_STR); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6563 | } |
| 6564 | |
| 6565 | /* |
| 6566 | * "matchstrpos()" function |
| 6567 | */ |
| 6568 | static void |
| 6569 | f_matchstrpos(typval_T *argvars, typval_T *rettv) |
| 6570 | { |
Bram Moolenaar | 8d9f0ef | 2017-08-27 13:51:01 +0200 | [diff] [blame] | 6571 | find_some_match(argvars, rettv, MATCH_POS); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6572 | } |
| 6573 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6574 | static void |
| 6575 | max_min(typval_T *argvars, typval_T *rettv, int domax) |
| 6576 | { |
| 6577 | varnumber_T n = 0; |
| 6578 | varnumber_T i; |
| 6579 | int error = FALSE; |
| 6580 | |
| 6581 | if (argvars[0].v_type == VAR_LIST) |
| 6582 | { |
| 6583 | list_T *l; |
| 6584 | listitem_T *li; |
| 6585 | |
| 6586 | l = argvars[0].vval.v_list; |
Bram Moolenaar | 9f2d020 | 2020-01-30 16:40:10 +0100 | [diff] [blame] | 6587 | if (l != NULL && l->lv_len > 0) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6588 | { |
Bram Moolenaar | 9f2d020 | 2020-01-30 16:40:10 +0100 | [diff] [blame] | 6589 | if (l->lv_first == &range_list_item) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6590 | { |
Bram Moolenaar | 9f2d020 | 2020-01-30 16:40:10 +0100 | [diff] [blame] | 6591 | if ((l->lv_u.nonmat.lv_stride > 0) ^ domax) |
| 6592 | n = l->lv_u.nonmat.lv_start; |
| 6593 | else |
| 6594 | n = l->lv_u.nonmat.lv_start + (l->lv_len - 1) |
| 6595 | * l->lv_u.nonmat.lv_stride; |
| 6596 | } |
| 6597 | else |
| 6598 | { |
| 6599 | li = l->lv_first; |
| 6600 | if (li != NULL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6601 | { |
Bram Moolenaar | 9f2d020 | 2020-01-30 16:40:10 +0100 | [diff] [blame] | 6602 | n = tv_get_number_chk(&li->li_tv, &error); |
Bram Moolenaar | ab65fc7 | 2021-02-04 22:07:16 +0100 | [diff] [blame] | 6603 | if (error) |
| 6604 | return; // type error; errmsg already given |
Bram Moolenaar | 9f2d020 | 2020-01-30 16:40:10 +0100 | [diff] [blame] | 6605 | for (;;) |
| 6606 | { |
| 6607 | li = li->li_next; |
| 6608 | if (li == NULL) |
| 6609 | break; |
| 6610 | i = tv_get_number_chk(&li->li_tv, &error); |
Bram Moolenaar | ab65fc7 | 2021-02-04 22:07:16 +0100 | [diff] [blame] | 6611 | if (error) |
| 6612 | return; // type error; errmsg already given |
Bram Moolenaar | 9f2d020 | 2020-01-30 16:40:10 +0100 | [diff] [blame] | 6613 | if (domax ? i > n : i < n) |
| 6614 | n = i; |
| 6615 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6616 | } |
| 6617 | } |
| 6618 | } |
| 6619 | } |
| 6620 | else if (argvars[0].v_type == VAR_DICT) |
| 6621 | { |
| 6622 | dict_T *d; |
| 6623 | int first = TRUE; |
| 6624 | hashitem_T *hi; |
| 6625 | int todo; |
| 6626 | |
| 6627 | d = argvars[0].vval.v_dict; |
| 6628 | if (d != NULL) |
| 6629 | { |
| 6630 | todo = (int)d->dv_hashtab.ht_used; |
| 6631 | for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi) |
| 6632 | { |
| 6633 | if (!HASHITEM_EMPTY(hi)) |
| 6634 | { |
| 6635 | --todo; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6636 | i = tv_get_number_chk(&HI2DI(hi)->di_tv, &error); |
Bram Moolenaar | ab65fc7 | 2021-02-04 22:07:16 +0100 | [diff] [blame] | 6637 | if (error) |
| 6638 | return; // type error; errmsg already given |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6639 | if (first) |
| 6640 | { |
| 6641 | n = i; |
| 6642 | first = FALSE; |
| 6643 | } |
| 6644 | else if (domax ? i > n : i < n) |
| 6645 | n = i; |
| 6646 | } |
| 6647 | } |
| 6648 | } |
| 6649 | } |
| 6650 | else |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 6651 | semsg(_(e_listdictarg), domax ? "max()" : "min()"); |
Bram Moolenaar | ab65fc7 | 2021-02-04 22:07:16 +0100 | [diff] [blame] | 6652 | |
| 6653 | rettv->vval.v_number = n; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6654 | } |
| 6655 | |
| 6656 | /* |
| 6657 | * "max()" function |
| 6658 | */ |
| 6659 | static void |
| 6660 | f_max(typval_T *argvars, typval_T *rettv) |
| 6661 | { |
| 6662 | max_min(argvars, rettv, TRUE); |
| 6663 | } |
| 6664 | |
| 6665 | /* |
| 6666 | * "min()" function |
| 6667 | */ |
| 6668 | static void |
| 6669 | f_min(typval_T *argvars, typval_T *rettv) |
| 6670 | { |
| 6671 | max_min(argvars, rettv, FALSE); |
| 6672 | } |
| 6673 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6674 | #if defined(FEAT_MZSCHEME) || defined(PROTO) |
| 6675 | /* |
| 6676 | * "mzeval()" function |
| 6677 | */ |
| 6678 | static void |
| 6679 | f_mzeval(typval_T *argvars, typval_T *rettv) |
| 6680 | { |
| 6681 | char_u *str; |
| 6682 | char_u buf[NUMBUFLEN]; |
| 6683 | |
Bram Moolenaar | 8c62a08 | 2019-02-08 14:34:10 +0100 | [diff] [blame] | 6684 | if (check_restricted() || check_secure()) |
| 6685 | return; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6686 | str = tv_get_string_buf(&argvars[0], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6687 | do_mzeval(str, rettv); |
| 6688 | } |
| 6689 | |
| 6690 | void |
| 6691 | mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv) |
| 6692 | { |
| 6693 | typval_T argvars[3]; |
| 6694 | |
| 6695 | argvars[0].v_type = VAR_STRING; |
| 6696 | argvars[0].vval.v_string = name; |
| 6697 | copy_tv(args, &argvars[1]); |
| 6698 | argvars[2].v_type = VAR_UNKNOWN; |
| 6699 | f_call(argvars, rettv); |
| 6700 | clear_tv(&argvars[1]); |
| 6701 | } |
| 6702 | #endif |
| 6703 | |
| 6704 | /* |
| 6705 | * "nextnonblank()" function |
| 6706 | */ |
| 6707 | static void |
| 6708 | f_nextnonblank(typval_T *argvars, typval_T *rettv) |
| 6709 | { |
| 6710 | linenr_T lnum; |
| 6711 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6712 | for (lnum = tv_get_lnum(argvars); ; ++lnum) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6713 | { |
| 6714 | if (lnum < 0 || lnum > curbuf->b_ml.ml_line_count) |
| 6715 | { |
| 6716 | lnum = 0; |
| 6717 | break; |
| 6718 | } |
| 6719 | if (*skipwhite(ml_get(lnum)) != NUL) |
| 6720 | break; |
| 6721 | } |
| 6722 | rettv->vval.v_number = lnum; |
| 6723 | } |
| 6724 | |
| 6725 | /* |
| 6726 | * "nr2char()" function |
| 6727 | */ |
| 6728 | static void |
| 6729 | f_nr2char(typval_T *argvars, typval_T *rettv) |
| 6730 | { |
| 6731 | char_u buf[NUMBUFLEN]; |
| 6732 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6733 | if (has_mbyte) |
| 6734 | { |
| 6735 | int utf8 = 0; |
| 6736 | |
| 6737 | if (argvars[1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | ed6a430 | 2020-09-05 20:29:41 +0200 | [diff] [blame] | 6738 | utf8 = (int)tv_get_bool_chk(&argvars[1], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6739 | if (utf8) |
Bram Moolenaar | bdace83 | 2019-03-02 10:13:42 +0100 | [diff] [blame] | 6740 | buf[utf_char2bytes((int)tv_get_number(&argvars[0]), buf)] = NUL; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6741 | else |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6742 | buf[(*mb_char2bytes)((int)tv_get_number(&argvars[0]), buf)] = NUL; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6743 | } |
| 6744 | else |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6745 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6746 | buf[0] = (char_u)tv_get_number(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6747 | buf[1] = NUL; |
| 6748 | } |
| 6749 | rettv->v_type = VAR_STRING; |
| 6750 | rettv->vval.v_string = vim_strsave(buf); |
| 6751 | } |
| 6752 | |
| 6753 | /* |
| 6754 | * "or(expr, expr)" function |
| 6755 | */ |
| 6756 | static void |
| 6757 | f_or(typval_T *argvars, typval_T *rettv) |
| 6758 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6759 | rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL) |
| 6760 | | tv_get_number_chk(&argvars[1], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6761 | } |
| 6762 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6763 | #ifdef FEAT_PERL |
| 6764 | /* |
| 6765 | * "perleval()" function |
| 6766 | */ |
| 6767 | static void |
| 6768 | f_perleval(typval_T *argvars, typval_T *rettv) |
| 6769 | { |
| 6770 | char_u *str; |
| 6771 | char_u buf[NUMBUFLEN]; |
| 6772 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6773 | str = tv_get_string_buf(&argvars[0], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6774 | do_perleval(str, rettv); |
| 6775 | } |
| 6776 | #endif |
| 6777 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6778 | /* |
| 6779 | * "prevnonblank()" function |
| 6780 | */ |
| 6781 | static void |
| 6782 | f_prevnonblank(typval_T *argvars, typval_T *rettv) |
| 6783 | { |
| 6784 | linenr_T lnum; |
| 6785 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6786 | lnum = tv_get_lnum(argvars); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6787 | if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) |
| 6788 | lnum = 0; |
| 6789 | else |
| 6790 | while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL) |
| 6791 | --lnum; |
| 6792 | rettv->vval.v_number = lnum; |
| 6793 | } |
| 6794 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6795 | // This dummy va_list is here because: |
| 6796 | // - passing a NULL pointer doesn't work when va_list isn't a pointer |
| 6797 | // - locally in the function results in a "used before set" warning |
| 6798 | // - using va_start() to initialize it gives "function with fixed args" error |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6799 | static va_list ap; |
| 6800 | |
| 6801 | /* |
| 6802 | * "printf()" function |
| 6803 | */ |
| 6804 | static void |
| 6805 | f_printf(typval_T *argvars, typval_T *rettv) |
| 6806 | { |
| 6807 | char_u buf[NUMBUFLEN]; |
| 6808 | int len; |
| 6809 | char_u *s; |
| 6810 | int saved_did_emsg = did_emsg; |
| 6811 | char *fmt; |
| 6812 | |
| 6813 | rettv->v_type = VAR_STRING; |
| 6814 | rettv->vval.v_string = NULL; |
| 6815 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 6816 | // Get the required length, allocate the buffer and do it for real. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6817 | did_emsg = FALSE; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6818 | fmt = (char *)tv_get_string_buf(&argvars[0], buf); |
Bram Moolenaar | 8327d1d | 2017-07-11 22:34:51 +0200 | [diff] [blame] | 6819 | len = vim_vsnprintf_typval(NULL, 0, fmt, ap, argvars + 1); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6820 | if (!did_emsg) |
| 6821 | { |
| 6822 | s = alloc(len + 1); |
| 6823 | if (s != NULL) |
| 6824 | { |
| 6825 | rettv->vval.v_string = s; |
Bram Moolenaar | 8327d1d | 2017-07-11 22:34:51 +0200 | [diff] [blame] | 6826 | (void)vim_vsnprintf_typval((char *)s, len + 1, fmt, |
| 6827 | ap, argvars + 1); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6828 | } |
| 6829 | } |
| 6830 | did_emsg |= saved_did_emsg; |
| 6831 | } |
| 6832 | |
| 6833 | /* |
Bram Moolenaar | e9bd572 | 2019-08-17 19:36:06 +0200 | [diff] [blame] | 6834 | * "pum_getpos()" function |
| 6835 | */ |
| 6836 | static void |
| 6837 | f_pum_getpos(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 6838 | { |
| 6839 | if (rettv_dict_alloc(rettv) != OK) |
| 6840 | return; |
Bram Moolenaar | e9bd572 | 2019-08-17 19:36:06 +0200 | [diff] [blame] | 6841 | pum_set_event_info(rettv->vval.v_dict); |
Bram Moolenaar | e9bd572 | 2019-08-17 19:36:06 +0200 | [diff] [blame] | 6842 | } |
| 6843 | |
| 6844 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6845 | * "pumvisible()" function |
| 6846 | */ |
| 6847 | static void |
| 6848 | f_pumvisible(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 6849 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6850 | if (pum_visible()) |
| 6851 | rettv->vval.v_number = 1; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6852 | } |
| 6853 | |
| 6854 | #ifdef FEAT_PYTHON3 |
| 6855 | /* |
| 6856 | * "py3eval()" function |
| 6857 | */ |
| 6858 | static void |
| 6859 | f_py3eval(typval_T *argvars, typval_T *rettv) |
| 6860 | { |
| 6861 | char_u *str; |
| 6862 | char_u buf[NUMBUFLEN]; |
| 6863 | |
Bram Moolenaar | 8c62a08 | 2019-02-08 14:34:10 +0100 | [diff] [blame] | 6864 | if (check_restricted() || check_secure()) |
| 6865 | return; |
| 6866 | |
Bram Moolenaar | f42dd3c | 2017-01-28 16:06:38 +0100 | [diff] [blame] | 6867 | if (p_pyx == 0) |
| 6868 | p_pyx = 3; |
| 6869 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6870 | str = tv_get_string_buf(&argvars[0], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6871 | do_py3eval(str, rettv); |
| 6872 | } |
| 6873 | #endif |
| 6874 | |
| 6875 | #ifdef FEAT_PYTHON |
| 6876 | /* |
| 6877 | * "pyeval()" function |
| 6878 | */ |
| 6879 | static void |
| 6880 | f_pyeval(typval_T *argvars, typval_T *rettv) |
| 6881 | { |
| 6882 | char_u *str; |
| 6883 | char_u buf[NUMBUFLEN]; |
| 6884 | |
Bram Moolenaar | 8c62a08 | 2019-02-08 14:34:10 +0100 | [diff] [blame] | 6885 | if (check_restricted() || check_secure()) |
| 6886 | return; |
| 6887 | |
Bram Moolenaar | f42dd3c | 2017-01-28 16:06:38 +0100 | [diff] [blame] | 6888 | if (p_pyx == 0) |
| 6889 | p_pyx = 2; |
| 6890 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 6891 | str = tv_get_string_buf(&argvars[0], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6892 | do_pyeval(str, rettv); |
| 6893 | } |
| 6894 | #endif |
| 6895 | |
Bram Moolenaar | f42dd3c | 2017-01-28 16:06:38 +0100 | [diff] [blame] | 6896 | #if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) |
| 6897 | /* |
| 6898 | * "pyxeval()" function |
| 6899 | */ |
| 6900 | static void |
| 6901 | f_pyxeval(typval_T *argvars, typval_T *rettv) |
| 6902 | { |
Bram Moolenaar | 8c62a08 | 2019-02-08 14:34:10 +0100 | [diff] [blame] | 6903 | if (check_restricted() || check_secure()) |
| 6904 | return; |
| 6905 | |
Bram Moolenaar | f42dd3c | 2017-01-28 16:06:38 +0100 | [diff] [blame] | 6906 | # if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3) |
| 6907 | init_pyxversion(); |
| 6908 | if (p_pyx == 2) |
| 6909 | f_pyeval(argvars, rettv); |
| 6910 | else |
| 6911 | f_py3eval(argvars, rettv); |
| 6912 | # elif defined(FEAT_PYTHON) |
| 6913 | f_pyeval(argvars, rettv); |
| 6914 | # elif defined(FEAT_PYTHON3) |
| 6915 | f_py3eval(argvars, rettv); |
| 6916 | # endif |
| 6917 | } |
| 6918 | #endif |
| 6919 | |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 6920 | static UINT32_T srand_seed_for_testing = 0; |
| 6921 | static int srand_seed_for_testing_is_used = FALSE; |
| 6922 | |
| 6923 | static void |
| 6924 | f_test_srand_seed(typval_T *argvars, typval_T *rettv UNUSED) |
| 6925 | { |
| 6926 | if (argvars[0].v_type == VAR_UNKNOWN) |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 6927 | srand_seed_for_testing_is_used = FALSE; |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 6928 | else |
| 6929 | { |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 6930 | srand_seed_for_testing = (UINT32_T)tv_get_number(&argvars[0]); |
| 6931 | srand_seed_for_testing_is_used = TRUE; |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 6932 | } |
| 6933 | } |
| 6934 | |
| 6935 | static void |
| 6936 | init_srand(UINT32_T *x) |
| 6937 | { |
| 6938 | #ifndef MSWIN |
| 6939 | static int dev_urandom_state = NOTDONE; // FAIL or OK once tried |
| 6940 | #endif |
| 6941 | |
| 6942 | if (srand_seed_for_testing_is_used) |
| 6943 | { |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 6944 | *x = srand_seed_for_testing; |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 6945 | return; |
| 6946 | } |
| 6947 | #ifndef MSWIN |
| 6948 | if (dev_urandom_state != FAIL) |
| 6949 | { |
| 6950 | int fd = open("/dev/urandom", O_RDONLY); |
| 6951 | struct { |
| 6952 | union { |
| 6953 | UINT32_T number; |
| 6954 | char bytes[sizeof(UINT32_T)]; |
| 6955 | } contents; |
| 6956 | } buf; |
| 6957 | |
| 6958 | // Attempt reading /dev/urandom. |
| 6959 | if (fd == -1) |
| 6960 | dev_urandom_state = FAIL; |
| 6961 | else |
| 6962 | { |
| 6963 | buf.contents.number = 0; |
| 6964 | if (read(fd, buf.contents.bytes, sizeof(UINT32_T)) |
| 6965 | != sizeof(UINT32_T)) |
| 6966 | dev_urandom_state = FAIL; |
| 6967 | else |
| 6968 | { |
| 6969 | dev_urandom_state = OK; |
| 6970 | *x = buf.contents.number; |
| 6971 | } |
| 6972 | close(fd); |
| 6973 | } |
| 6974 | } |
| 6975 | if (dev_urandom_state != OK) |
| 6976 | // Reading /dev/urandom doesn't work, fall back to time(). |
| 6977 | #endif |
| 6978 | *x = vim_time(); |
| 6979 | } |
| 6980 | |
| 6981 | #define ROTL(x, k) ((x << k) | (x >> (32 - k))) |
| 6982 | #define SPLITMIX32(x, z) ( \ |
| 6983 | z = (x += 0x9e3779b9), \ |
| 6984 | z = (z ^ (z >> 16)) * 0x85ebca6b, \ |
| 6985 | z = (z ^ (z >> 13)) * 0xc2b2ae35, \ |
| 6986 | z ^ (z >> 16) \ |
| 6987 | ) |
| 6988 | #define SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w) \ |
| 6989 | result = ROTL(y * 5, 7) * 9; \ |
| 6990 | t = y << 9; \ |
| 6991 | z ^= x; \ |
| 6992 | w ^= y; \ |
| 6993 | y ^= z, x ^= w; \ |
| 6994 | z ^= t; \ |
| 6995 | w = ROTL(w, 11); |
| 6996 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 6997 | /* |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 6998 | * "rand()" function |
| 6999 | */ |
| 7000 | static void |
| 7001 | f_rand(typval_T *argvars, typval_T *rettv) |
| 7002 | { |
| 7003 | list_T *l = NULL; |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 7004 | static UINT32_T gx, gy, gz, gw; |
| 7005 | static int initialized = FALSE; |
Bram Moolenaar | f8c1f92 | 2019-11-28 22:13:14 +0100 | [diff] [blame] | 7006 | listitem_T *lx, *ly, *lz, *lw; |
Bram Moolenaar | 0fd797e | 2020-11-05 20:46:32 +0100 | [diff] [blame] | 7007 | UINT32_T x = 0, y, z, w, t, result; |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7008 | |
| 7009 | if (argvars[0].v_type == VAR_UNKNOWN) |
| 7010 | { |
Bram Moolenaar | f8c1f92 | 2019-11-28 22:13:14 +0100 | [diff] [blame] | 7011 | // When no argument is given use the global seed list. |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 7012 | if (initialized == FALSE) |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7013 | { |
Bram Moolenaar | f8c1f92 | 2019-11-28 22:13:14 +0100 | [diff] [blame] | 7014 | // Initialize the global seed list. |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 7015 | init_srand(&x); |
| 7016 | |
| 7017 | gx = SPLITMIX32(x, z); |
| 7018 | gy = SPLITMIX32(x, z); |
| 7019 | gz = SPLITMIX32(x, z); |
| 7020 | gw = SPLITMIX32(x, z); |
| 7021 | initialized = TRUE; |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7022 | } |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 7023 | |
| 7024 | SHUFFLE_XOSHIRO128STARSTAR(gx, gy, gz, gw); |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7025 | } |
| 7026 | else if (argvars[0].v_type == VAR_LIST) |
| 7027 | { |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7028 | l = argvars[0].vval.v_list; |
Bram Moolenaar | f8c1f92 | 2019-11-28 22:13:14 +0100 | [diff] [blame] | 7029 | if (l == NULL || list_len(l) != 4) |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7030 | goto theend; |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 7031 | |
| 7032 | lx = list_find(l, 0L); |
| 7033 | ly = list_find(l, 1L); |
| 7034 | lz = list_find(l, 2L); |
| 7035 | lw = list_find(l, 3L); |
| 7036 | if (lx->li_tv.v_type != VAR_NUMBER) goto theend; |
| 7037 | if (ly->li_tv.v_type != VAR_NUMBER) goto theend; |
| 7038 | if (lz->li_tv.v_type != VAR_NUMBER) goto theend; |
| 7039 | if (lw->li_tv.v_type != VAR_NUMBER) goto theend; |
| 7040 | x = (UINT32_T)lx->li_tv.vval.v_number; |
| 7041 | y = (UINT32_T)ly->li_tv.vval.v_number; |
| 7042 | z = (UINT32_T)lz->li_tv.vval.v_number; |
| 7043 | w = (UINT32_T)lw->li_tv.vval.v_number; |
| 7044 | |
| 7045 | SHUFFLE_XOSHIRO128STARSTAR(x, y, z, w); |
| 7046 | |
| 7047 | lx->li_tv.vval.v_number = (varnumber_T)x; |
| 7048 | ly->li_tv.vval.v_number = (varnumber_T)y; |
| 7049 | lz->li_tv.vval.v_number = (varnumber_T)z; |
| 7050 | lw->li_tv.vval.v_number = (varnumber_T)w; |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7051 | } |
| 7052 | else |
| 7053 | goto theend; |
| 7054 | |
| 7055 | rettv->v_type = VAR_NUMBER; |
Bram Moolenaar | f8c1f92 | 2019-11-28 22:13:14 +0100 | [diff] [blame] | 7056 | rettv->vval.v_number = (varnumber_T)result; |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7057 | return; |
| 7058 | |
| 7059 | theend: |
| 7060 | semsg(_(e_invarg2), tv_get_string(&argvars[0])); |
Bram Moolenaar | f8c1f92 | 2019-11-28 22:13:14 +0100 | [diff] [blame] | 7061 | rettv->v_type = VAR_NUMBER; |
| 7062 | rettv->vval.v_number = -1; |
Bram Moolenaar | 06b0b4b | 2019-11-25 15:40:55 +0100 | [diff] [blame] | 7063 | } |
| 7064 | |
| 7065 | /* |
Bram Moolenaar | 4f645c5 | 2020-02-08 16:40:39 +0100 | [diff] [blame] | 7066 | * "srand()" function |
| 7067 | */ |
| 7068 | static void |
| 7069 | f_srand(typval_T *argvars, typval_T *rettv) |
| 7070 | { |
| 7071 | UINT32_T x = 0, z; |
| 7072 | |
| 7073 | if (rettv_list_alloc(rettv) == FAIL) |
| 7074 | return; |
| 7075 | if (argvars[0].v_type == VAR_UNKNOWN) |
| 7076 | { |
| 7077 | init_srand(&x); |
| 7078 | } |
| 7079 | else |
| 7080 | { |
| 7081 | int error = FALSE; |
| 7082 | |
| 7083 | x = (UINT32_T)tv_get_number_chk(&argvars[0], &error); |
| 7084 | if (error) |
| 7085 | return; |
| 7086 | } |
| 7087 | |
| 7088 | list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z)); |
| 7089 | list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z)); |
| 7090 | list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z)); |
| 7091 | list_append_number(rettv->vval.v_list, (varnumber_T)SPLITMIX32(x, z)); |
| 7092 | } |
| 7093 | |
| 7094 | #undef ROTL |
| 7095 | #undef SPLITMIX32 |
| 7096 | #undef SHUFFLE_XOSHIRO128STARSTAR |
| 7097 | |
| 7098 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7099 | * "range()" function |
| 7100 | */ |
| 7101 | static void |
| 7102 | f_range(typval_T *argvars, typval_T *rettv) |
| 7103 | { |
| 7104 | varnumber_T start; |
| 7105 | varnumber_T end; |
| 7106 | varnumber_T stride = 1; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7107 | int error = FALSE; |
| 7108 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7109 | start = tv_get_number_chk(&argvars[0], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7110 | if (argvars[1].v_type == VAR_UNKNOWN) |
| 7111 | { |
| 7112 | end = start - 1; |
| 7113 | start = 0; |
| 7114 | } |
| 7115 | else |
| 7116 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7117 | end = tv_get_number_chk(&argvars[1], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7118 | if (argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7119 | stride = tv_get_number_chk(&argvars[2], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7120 | } |
| 7121 | |
| 7122 | if (error) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7123 | return; // type error; errmsg already given |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7124 | if (stride == 0) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 7125 | emsg(_("E726: Stride is zero")); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7126 | else if (stride > 0 ? end + 1 < start : end - 1 > start) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 7127 | emsg(_("E727: Start past end")); |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 7128 | else if (rettv_list_alloc(rettv) == OK) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7129 | { |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 7130 | list_T *list = rettv->vval.v_list; |
| 7131 | |
| 7132 | // Create a non-materialized list. This is much more efficient and |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 7133 | // works with ":for". If used otherwise CHECK_LIST_MATERIALIZE() must |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 7134 | // be called. |
| 7135 | list->lv_first = &range_list_item; |
Bram Moolenaar | 0ff6aad | 2020-01-29 21:27:21 +0100 | [diff] [blame] | 7136 | list->lv_u.nonmat.lv_start = start; |
| 7137 | list->lv_u.nonmat.lv_end = end; |
| 7138 | list->lv_u.nonmat.lv_stride = stride; |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 7139 | list->lv_len = (end - start) / stride + 1; |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 7140 | } |
| 7141 | } |
| 7142 | |
| 7143 | /* |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 7144 | * Materialize "list". |
| 7145 | * Do not call directly, use CHECK_LIST_MATERIALIZE() |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 7146 | */ |
| 7147 | void |
| 7148 | range_list_materialize(list_T *list) |
| 7149 | { |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 7150 | varnumber_T start = list->lv_u.nonmat.lv_start; |
| 7151 | varnumber_T end = list->lv_u.nonmat.lv_end; |
| 7152 | int stride = list->lv_u.nonmat.lv_stride; |
| 7153 | varnumber_T i; |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 7154 | |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 7155 | list->lv_first = NULL; |
| 7156 | list->lv_u.mat.lv_last = NULL; |
| 7157 | list->lv_len = 0; |
| 7158 | list->lv_u.mat.lv_idx_item = NULL; |
| 7159 | for (i = start; stride > 0 ? i <= end : i >= end; i += stride) |
| 7160 | if (list_append_number(list, (varnumber_T)i) == FAIL) |
| 7161 | break; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7162 | } |
| 7163 | |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 7164 | /* |
| 7165 | * "getreginfo()" function |
| 7166 | */ |
| 7167 | static void |
| 7168 | f_getreginfo(typval_T *argvars, typval_T *rettv) |
| 7169 | { |
| 7170 | char_u *strregname; |
| 7171 | int regname; |
| 7172 | char_u buf[NUMBUFLEN + 2]; |
| 7173 | long reglen = 0; |
| 7174 | dict_T *dict; |
| 7175 | list_T *list; |
| 7176 | |
| 7177 | if (argvars[0].v_type != VAR_UNKNOWN) |
| 7178 | { |
| 7179 | strregname = tv_get_string_chk(&argvars[0]); |
| 7180 | if (strregname == NULL) |
| 7181 | return; |
Bram Moolenaar | 418a29f | 2021-02-10 22:23:41 +0100 | [diff] [blame] | 7182 | if (in_vim9script() && STRLEN(strregname) > 1) |
| 7183 | { |
| 7184 | semsg(_(e_register_name_must_be_one_char_str), strregname); |
| 7185 | return; |
| 7186 | } |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 7187 | } |
| 7188 | else |
| 7189 | strregname = get_vim_var_str(VV_REG); |
| 7190 | |
| 7191 | regname = (strregname == NULL ? '"' : *strregname); |
| 7192 | if (regname == 0 || regname == '@') |
| 7193 | regname = '"'; |
| 7194 | |
| 7195 | if (rettv_dict_alloc(rettv) == FAIL) |
| 7196 | return; |
| 7197 | dict = rettv->vval.v_dict; |
| 7198 | |
| 7199 | list = (list_T *)get_reg_contents(regname, GREG_EXPR_SRC | GREG_LIST); |
| 7200 | if (list == NULL) |
| 7201 | return; |
Bram Moolenaar | 9163919 | 2020-06-29 19:55:58 +0200 | [diff] [blame] | 7202 | (void)dict_add_list(dict, "regcontents", list); |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 7203 | |
| 7204 | buf[0] = NUL; |
| 7205 | buf[1] = NUL; |
| 7206 | switch (get_reg_type(regname, ®len)) |
| 7207 | { |
| 7208 | case MLINE: buf[0] = 'V'; break; |
| 7209 | case MCHAR: buf[0] = 'v'; break; |
| 7210 | case MBLOCK: |
| 7211 | vim_snprintf((char *)buf, sizeof(buf), "%c%ld", Ctrl_V, |
| 7212 | reglen + 1); |
| 7213 | break; |
| 7214 | } |
Bram Moolenaar | 9163919 | 2020-06-29 19:55:58 +0200 | [diff] [blame] | 7215 | (void)dict_add_string(dict, (char *)"regtype", buf); |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 7216 | |
| 7217 | buf[0] = get_register_name(get_unname_register()); |
| 7218 | buf[1] = NUL; |
| 7219 | if (regname == '"') |
Bram Moolenaar | 9163919 | 2020-06-29 19:55:58 +0200 | [diff] [blame] | 7220 | (void)dict_add_string(dict, (char *)"points_to", buf); |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 7221 | else |
| 7222 | { |
| 7223 | dictitem_T *item = dictitem_alloc((char_u *)"isunnamed"); |
| 7224 | |
| 7225 | if (item != NULL) |
| 7226 | { |
| 7227 | item->di_tv.v_type = VAR_SPECIAL; |
| 7228 | item->di_tv.vval.v_number = regname == buf[0] |
Bram Moolenaar | 418a29f | 2021-02-10 22:23:41 +0100 | [diff] [blame] | 7229 | ? VVAL_TRUE : VVAL_FALSE; |
Bram Moolenaar | 9163919 | 2020-06-29 19:55:58 +0200 | [diff] [blame] | 7230 | (void)dict_add(dict, item); |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 7231 | } |
| 7232 | } |
| 7233 | } |
| 7234 | |
Bram Moolenaar | 0b6d911 | 2018-05-22 20:35:17 +0200 | [diff] [blame] | 7235 | static void |
| 7236 | return_register(int regname, typval_T *rettv) |
| 7237 | { |
| 7238 | char_u buf[2] = {0, 0}; |
| 7239 | |
| 7240 | buf[0] = (char_u)regname; |
| 7241 | rettv->v_type = VAR_STRING; |
| 7242 | rettv->vval.v_string = vim_strsave(buf); |
| 7243 | } |
| 7244 | |
| 7245 | /* |
| 7246 | * "reg_executing()" function |
| 7247 | */ |
| 7248 | static void |
| 7249 | f_reg_executing(typval_T *argvars UNUSED, typval_T *rettv) |
| 7250 | { |
| 7251 | return_register(reg_executing, rettv); |
| 7252 | } |
| 7253 | |
| 7254 | /* |
| 7255 | * "reg_recording()" function |
| 7256 | */ |
| 7257 | static void |
| 7258 | f_reg_recording(typval_T *argvars UNUSED, typval_T *rettv) |
| 7259 | { |
| 7260 | return_register(reg_recording, rettv); |
| 7261 | } |
| 7262 | |
Bram Moolenaar | 7416f3e | 2017-03-18 18:10:13 +0100 | [diff] [blame] | 7263 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7264 | * "rename({from}, {to})" function |
| 7265 | */ |
| 7266 | static void |
| 7267 | f_rename(typval_T *argvars, typval_T *rettv) |
| 7268 | { |
| 7269 | char_u buf[NUMBUFLEN]; |
| 7270 | |
| 7271 | if (check_restricted() || check_secure()) |
| 7272 | rettv->vval.v_number = -1; |
| 7273 | else |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7274 | rettv->vval.v_number = vim_rename(tv_get_string(&argvars[0]), |
| 7275 | tv_get_string_buf(&argvars[1], buf)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7276 | } |
| 7277 | |
| 7278 | /* |
| 7279 | * "repeat()" function |
| 7280 | */ |
| 7281 | static void |
| 7282 | f_repeat(typval_T *argvars, typval_T *rettv) |
| 7283 | { |
| 7284 | char_u *p; |
| 7285 | int n; |
| 7286 | int slen; |
| 7287 | int len; |
| 7288 | char_u *r; |
| 7289 | int i; |
| 7290 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7291 | n = (int)tv_get_number(&argvars[1]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7292 | if (argvars[0].v_type == VAR_LIST) |
| 7293 | { |
| 7294 | if (rettv_list_alloc(rettv) == OK && argvars[0].vval.v_list != NULL) |
| 7295 | while (n-- > 0) |
| 7296 | if (list_extend(rettv->vval.v_list, |
| 7297 | argvars[0].vval.v_list, NULL) == FAIL) |
| 7298 | break; |
| 7299 | } |
| 7300 | else |
| 7301 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7302 | p = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7303 | rettv->v_type = VAR_STRING; |
| 7304 | rettv->vval.v_string = NULL; |
| 7305 | |
| 7306 | slen = (int)STRLEN(p); |
| 7307 | len = slen * n; |
| 7308 | if (len <= 0) |
| 7309 | return; |
| 7310 | |
| 7311 | r = alloc(len + 1); |
| 7312 | if (r != NULL) |
| 7313 | { |
| 7314 | for (i = 0; i < n; i++) |
| 7315 | mch_memmove(r + i * slen, p, (size_t)slen); |
| 7316 | r[len] = NUL; |
| 7317 | } |
| 7318 | |
| 7319 | rettv->vval.v_string = r; |
| 7320 | } |
| 7321 | } |
| 7322 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7323 | #define SP_NOMOVE 0x01 // don't move cursor |
| 7324 | #define SP_REPEAT 0x02 // repeat to find outer pair |
| 7325 | #define SP_RETCOUNT 0x04 // return matchcount |
| 7326 | #define SP_SETPCMARK 0x08 // set previous context mark |
| 7327 | #define SP_START 0x10 // accept match at start position |
| 7328 | #define SP_SUBPAT 0x20 // return nr of matching sub-pattern |
| 7329 | #define SP_END 0x40 // leave cursor at end of match |
| 7330 | #define SP_COLUMN 0x80 // start at cursor column |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7331 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7332 | /* |
| 7333 | * Get flags for a search function. |
| 7334 | * Possibly sets "p_ws". |
| 7335 | * Returns BACKWARD, FORWARD or zero (for an error). |
| 7336 | */ |
| 7337 | static int |
| 7338 | get_search_arg(typval_T *varp, int *flagsp) |
| 7339 | { |
| 7340 | int dir = FORWARD; |
| 7341 | char_u *flags; |
| 7342 | char_u nbuf[NUMBUFLEN]; |
| 7343 | int mask; |
| 7344 | |
| 7345 | if (varp->v_type != VAR_UNKNOWN) |
| 7346 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7347 | flags = tv_get_string_buf_chk(varp, nbuf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7348 | if (flags == NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7349 | return 0; // type error; errmsg already given |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7350 | while (*flags != NUL) |
| 7351 | { |
| 7352 | switch (*flags) |
| 7353 | { |
| 7354 | case 'b': dir = BACKWARD; break; |
| 7355 | case 'w': p_ws = TRUE; break; |
| 7356 | case 'W': p_ws = FALSE; break; |
| 7357 | default: mask = 0; |
| 7358 | if (flagsp != NULL) |
| 7359 | switch (*flags) |
| 7360 | { |
| 7361 | case 'c': mask = SP_START; break; |
| 7362 | case 'e': mask = SP_END; break; |
| 7363 | case 'm': mask = SP_RETCOUNT; break; |
| 7364 | case 'n': mask = SP_NOMOVE; break; |
| 7365 | case 'p': mask = SP_SUBPAT; break; |
| 7366 | case 'r': mask = SP_REPEAT; break; |
| 7367 | case 's': mask = SP_SETPCMARK; break; |
| 7368 | case 'z': mask = SP_COLUMN; break; |
| 7369 | } |
| 7370 | if (mask == 0) |
| 7371 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 7372 | semsg(_(e_invarg2), flags); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7373 | dir = 0; |
| 7374 | } |
| 7375 | else |
| 7376 | *flagsp |= mask; |
| 7377 | } |
| 7378 | if (dir == 0) |
| 7379 | break; |
| 7380 | ++flags; |
| 7381 | } |
| 7382 | } |
| 7383 | return dir; |
| 7384 | } |
| 7385 | |
| 7386 | /* |
| 7387 | * Shared by search() and searchpos() functions. |
| 7388 | */ |
| 7389 | static int |
| 7390 | search_cmn(typval_T *argvars, pos_T *match_pos, int *flagsp) |
| 7391 | { |
| 7392 | int flags; |
| 7393 | char_u *pat; |
| 7394 | pos_T pos; |
| 7395 | pos_T save_cursor; |
| 7396 | int save_p_ws = p_ws; |
| 7397 | int dir; |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7398 | int retval = 0; // default: FAIL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7399 | long lnum_stop = 0; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7400 | #ifdef FEAT_RELTIME |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7401 | proftime_T tm; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7402 | long time_limit = 0; |
| 7403 | #endif |
| 7404 | int options = SEARCH_KEEP; |
| 7405 | int subpatnum; |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7406 | searchit_arg_T sia; |
Bram Moolenaar | a9c0104 | 2020-06-07 14:50:50 +0200 | [diff] [blame] | 7407 | int use_skip = FALSE; |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7408 | pos_T firstpos; |
| 7409 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7410 | pat = tv_get_string(&argvars[0]); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7411 | dir = get_search_arg(&argvars[1], flagsp); // may set p_ws |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7412 | if (dir == 0) |
| 7413 | goto theend; |
| 7414 | flags = *flagsp; |
| 7415 | if (flags & SP_START) |
| 7416 | options |= SEARCH_START; |
| 7417 | if (flags & SP_END) |
| 7418 | options |= SEARCH_END; |
| 7419 | if (flags & SP_COLUMN) |
| 7420 | options |= SEARCH_COL; |
| 7421 | |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7422 | // Optional arguments: line number to stop searching, timeout and skip. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7423 | if (argvars[1].v_type != VAR_UNKNOWN && argvars[2].v_type != VAR_UNKNOWN) |
| 7424 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7425 | lnum_stop = (long)tv_get_number_chk(&argvars[2], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7426 | if (lnum_stop < 0) |
| 7427 | goto theend; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7428 | if (argvars[3].v_type != VAR_UNKNOWN) |
| 7429 | { |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7430 | #ifdef FEAT_RELTIME |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7431 | time_limit = (long)tv_get_number_chk(&argvars[3], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7432 | if (time_limit < 0) |
| 7433 | goto theend; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7434 | #endif |
Bram Moolenaar | a9c0104 | 2020-06-07 14:50:50 +0200 | [diff] [blame] | 7435 | use_skip = eval_expr_valid_arg(&argvars[4]); |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7436 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7437 | } |
| 7438 | |
| 7439 | #ifdef FEAT_RELTIME |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7440 | // Set the time limit, if there is one. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7441 | profile_setlimit(time_limit, &tm); |
| 7442 | #endif |
| 7443 | |
| 7444 | /* |
| 7445 | * This function does not accept SP_REPEAT and SP_RETCOUNT flags. |
| 7446 | * Check to make sure only those flags are set. |
| 7447 | * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both |
| 7448 | * flags cannot be set. Check for that condition also. |
| 7449 | */ |
| 7450 | if (((flags & (SP_REPEAT | SP_RETCOUNT)) != 0) |
| 7451 | || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK))) |
| 7452 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 7453 | semsg(_(e_invarg2), tv_get_string(&argvars[1])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7454 | goto theend; |
| 7455 | } |
| 7456 | |
| 7457 | pos = save_cursor = curwin->w_cursor; |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7458 | CLEAR_FIELD(firstpos); |
Bram Moolenaar | a80faa8 | 2020-04-12 19:37:17 +0200 | [diff] [blame] | 7459 | CLEAR_FIELD(sia); |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7460 | sia.sa_stop_lnum = (linenr_T)lnum_stop; |
| 7461 | #ifdef FEAT_RELTIME |
| 7462 | sia.sa_tm = &tm; |
| 7463 | #endif |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7464 | |
| 7465 | // Repeat until {skip} returns FALSE. |
| 7466 | for (;;) |
| 7467 | { |
| 7468 | subpatnum = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L, |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7469 | options, RE_SEARCH, &sia); |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7470 | // finding the first match again means there is no match where {skip} |
| 7471 | // evaluates to zero. |
| 7472 | if (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos)) |
| 7473 | subpatnum = FAIL; |
| 7474 | |
Bram Moolenaar | a9c0104 | 2020-06-07 14:50:50 +0200 | [diff] [blame] | 7475 | if (subpatnum == FAIL || !use_skip) |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7476 | // didn't find it or no skip argument |
| 7477 | break; |
| 7478 | firstpos = pos; |
| 7479 | |
Bram Moolenaar | a9c0104 | 2020-06-07 14:50:50 +0200 | [diff] [blame] | 7480 | // If the skip expression matches, ignore this match. |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7481 | { |
| 7482 | int do_skip; |
| 7483 | int err; |
| 7484 | pos_T save_pos = curwin->w_cursor; |
| 7485 | |
| 7486 | curwin->w_cursor = pos; |
Bram Moolenaar | a9c0104 | 2020-06-07 14:50:50 +0200 | [diff] [blame] | 7487 | err = FALSE; |
| 7488 | do_skip = eval_expr_to_bool(&argvars[4], &err); |
Bram Moolenaar | adc17a5 | 2020-06-06 18:37:51 +0200 | [diff] [blame] | 7489 | curwin->w_cursor = save_pos; |
| 7490 | if (err) |
| 7491 | { |
| 7492 | // Evaluating {skip} caused an error, break here. |
| 7493 | subpatnum = FAIL; |
| 7494 | break; |
| 7495 | } |
| 7496 | if (!do_skip) |
| 7497 | break; |
| 7498 | } |
| 7499 | } |
| 7500 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7501 | if (subpatnum != FAIL) |
| 7502 | { |
| 7503 | if (flags & SP_SUBPAT) |
| 7504 | retval = subpatnum; |
| 7505 | else |
| 7506 | retval = pos.lnum; |
| 7507 | if (flags & SP_SETPCMARK) |
| 7508 | setpcmark(); |
| 7509 | curwin->w_cursor = pos; |
| 7510 | if (match_pos != NULL) |
| 7511 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7512 | // Store the match cursor position |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7513 | match_pos->lnum = pos.lnum; |
| 7514 | match_pos->col = pos.col + 1; |
| 7515 | } |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7516 | // "/$" will put the cursor after the end of the line, may need to |
| 7517 | // correct that here |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7518 | check_cursor(); |
| 7519 | } |
| 7520 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7521 | // If 'n' flag is used: restore cursor position. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7522 | if (flags & SP_NOMOVE) |
| 7523 | curwin->w_cursor = save_cursor; |
| 7524 | else |
| 7525 | curwin->w_set_curswant = TRUE; |
| 7526 | theend: |
| 7527 | p_ws = save_p_ws; |
| 7528 | |
| 7529 | return retval; |
| 7530 | } |
| 7531 | |
Bram Moolenaar | e99be0e | 2019-03-26 22:51:09 +0100 | [diff] [blame] | 7532 | #ifdef FEAT_RUBY |
| 7533 | /* |
| 7534 | * "rubyeval()" function |
| 7535 | */ |
| 7536 | static void |
| 7537 | f_rubyeval(typval_T *argvars, typval_T *rettv) |
| 7538 | { |
| 7539 | char_u *str; |
| 7540 | char_u buf[NUMBUFLEN]; |
| 7541 | |
| 7542 | str = tv_get_string_buf(&argvars[0], buf); |
| 7543 | do_rubyeval(str, rettv); |
| 7544 | } |
| 7545 | #endif |
| 7546 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7547 | /* |
| 7548 | * "screenattr()" function |
| 7549 | */ |
| 7550 | static void |
| 7551 | f_screenattr(typval_T *argvars, typval_T *rettv) |
| 7552 | { |
| 7553 | int row; |
| 7554 | int col; |
| 7555 | int c; |
| 7556 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7557 | row = (int)tv_get_number_chk(&argvars[0], NULL) - 1; |
| 7558 | col = (int)tv_get_number_chk(&argvars[1], NULL) - 1; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7559 | if (row < 0 || row >= screen_Rows |
| 7560 | || col < 0 || col >= screen_Columns) |
| 7561 | c = -1; |
| 7562 | else |
| 7563 | c = ScreenAttrs[LineOffset[row] + col]; |
| 7564 | rettv->vval.v_number = c; |
| 7565 | } |
| 7566 | |
| 7567 | /* |
| 7568 | * "screenchar()" function |
| 7569 | */ |
| 7570 | static void |
| 7571 | f_screenchar(typval_T *argvars, typval_T *rettv) |
| 7572 | { |
| 7573 | int row; |
| 7574 | int col; |
| 7575 | int off; |
| 7576 | int c; |
| 7577 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7578 | row = (int)tv_get_number_chk(&argvars[0], NULL) - 1; |
| 7579 | col = (int)tv_get_number_chk(&argvars[1], NULL) - 1; |
Bram Moolenaar | 2912abb | 2019-03-29 14:16:42 +0100 | [diff] [blame] | 7580 | if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7581 | c = -1; |
| 7582 | else |
| 7583 | { |
| 7584 | off = LineOffset[row] + col; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7585 | if (enc_utf8 && ScreenLinesUC[off] != 0) |
| 7586 | c = ScreenLinesUC[off]; |
| 7587 | else |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7588 | c = ScreenLines[off]; |
| 7589 | } |
| 7590 | rettv->vval.v_number = c; |
| 7591 | } |
| 7592 | |
| 7593 | /* |
Bram Moolenaar | 2912abb | 2019-03-29 14:16:42 +0100 | [diff] [blame] | 7594 | * "screenchars()" function |
| 7595 | */ |
| 7596 | static void |
| 7597 | f_screenchars(typval_T *argvars, typval_T *rettv) |
| 7598 | { |
| 7599 | int row; |
| 7600 | int col; |
| 7601 | int off; |
| 7602 | int c; |
| 7603 | int i; |
| 7604 | |
| 7605 | if (rettv_list_alloc(rettv) == FAIL) |
| 7606 | return; |
| 7607 | row = (int)tv_get_number_chk(&argvars[0], NULL) - 1; |
| 7608 | col = (int)tv_get_number_chk(&argvars[1], NULL) - 1; |
| 7609 | if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns) |
| 7610 | return; |
| 7611 | |
| 7612 | off = LineOffset[row] + col; |
| 7613 | if (enc_utf8 && ScreenLinesUC[off] != 0) |
| 7614 | c = ScreenLinesUC[off]; |
| 7615 | else |
| 7616 | c = ScreenLines[off]; |
| 7617 | list_append_number(rettv->vval.v_list, (varnumber_T)c); |
| 7618 | |
| 7619 | if (enc_utf8) |
| 7620 | |
| 7621 | for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i) |
| 7622 | list_append_number(rettv->vval.v_list, |
| 7623 | (varnumber_T)ScreenLinesC[i][off]); |
| 7624 | } |
| 7625 | |
| 7626 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7627 | * "screencol()" function |
| 7628 | * |
| 7629 | * First column is 1 to be consistent with virtcol(). |
| 7630 | */ |
| 7631 | static void |
| 7632 | f_screencol(typval_T *argvars UNUSED, typval_T *rettv) |
| 7633 | { |
| 7634 | rettv->vval.v_number = screen_screencol() + 1; |
| 7635 | } |
| 7636 | |
| 7637 | /* |
| 7638 | * "screenrow()" function |
| 7639 | */ |
| 7640 | static void |
| 7641 | f_screenrow(typval_T *argvars UNUSED, typval_T *rettv) |
| 7642 | { |
| 7643 | rettv->vval.v_number = screen_screenrow() + 1; |
| 7644 | } |
| 7645 | |
| 7646 | /* |
Bram Moolenaar | 2912abb | 2019-03-29 14:16:42 +0100 | [diff] [blame] | 7647 | * "screenstring()" function |
| 7648 | */ |
| 7649 | static void |
| 7650 | f_screenstring(typval_T *argvars, typval_T *rettv) |
| 7651 | { |
| 7652 | int row; |
| 7653 | int col; |
| 7654 | int off; |
| 7655 | int c; |
| 7656 | int i; |
| 7657 | char_u buf[MB_MAXBYTES + 1]; |
| 7658 | int buflen = 0; |
| 7659 | |
| 7660 | rettv->vval.v_string = NULL; |
| 7661 | rettv->v_type = VAR_STRING; |
| 7662 | |
| 7663 | row = (int)tv_get_number_chk(&argvars[0], NULL) - 1; |
| 7664 | col = (int)tv_get_number_chk(&argvars[1], NULL) - 1; |
| 7665 | if (row < 0 || row >= screen_Rows || col < 0 || col >= screen_Columns) |
| 7666 | return; |
| 7667 | |
| 7668 | off = LineOffset[row] + col; |
| 7669 | if (enc_utf8 && ScreenLinesUC[off] != 0) |
| 7670 | c = ScreenLinesUC[off]; |
| 7671 | else |
| 7672 | c = ScreenLines[off]; |
| 7673 | buflen += mb_char2bytes(c, buf); |
| 7674 | |
Bram Moolenaar | f138728 | 2021-03-22 17:11:15 +0100 | [diff] [blame] | 7675 | if (enc_utf8 && ScreenLinesUC[off] != 0) |
Bram Moolenaar | 2912abb | 2019-03-29 14:16:42 +0100 | [diff] [blame] | 7676 | for (i = 0; i < Screen_mco && ScreenLinesC[i][off] != 0; ++i) |
| 7677 | buflen += mb_char2bytes(ScreenLinesC[i][off], buf + buflen); |
| 7678 | |
| 7679 | buf[buflen] = NUL; |
| 7680 | rettv->vval.v_string = vim_strsave(buf); |
| 7681 | } |
| 7682 | |
| 7683 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7684 | * "search()" function |
| 7685 | */ |
| 7686 | static void |
| 7687 | f_search(typval_T *argvars, typval_T *rettv) |
| 7688 | { |
| 7689 | int flags = 0; |
| 7690 | |
| 7691 | rettv->vval.v_number = search_cmn(argvars, NULL, &flags); |
| 7692 | } |
| 7693 | |
| 7694 | /* |
| 7695 | * "searchdecl()" function |
| 7696 | */ |
| 7697 | static void |
| 7698 | f_searchdecl(typval_T *argvars, typval_T *rettv) |
| 7699 | { |
Bram Moolenaar | 30788d3 | 2020-09-05 21:35:16 +0200 | [diff] [blame] | 7700 | int locally = TRUE; |
| 7701 | int thisblock = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7702 | int error = FALSE; |
| 7703 | char_u *name; |
| 7704 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7705 | rettv->vval.v_number = 1; // default: FAIL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7706 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7707 | name = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7708 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 7709 | { |
Bram Moolenaar | 30788d3 | 2020-09-05 21:35:16 +0200 | [diff] [blame] | 7710 | locally = !(int)tv_get_bool_chk(&argvars[1], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7711 | if (!error && argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 30788d3 | 2020-09-05 21:35:16 +0200 | [diff] [blame] | 7712 | thisblock = (int)tv_get_bool_chk(&argvars[2], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7713 | } |
| 7714 | if (!error && name != NULL) |
| 7715 | rettv->vval.v_number = find_decl(name, (int)STRLEN(name), |
| 7716 | locally, thisblock, SEARCH_KEEP) == FAIL; |
| 7717 | } |
| 7718 | |
| 7719 | /* |
| 7720 | * Used by searchpair() and searchpairpos() |
| 7721 | */ |
| 7722 | static int |
| 7723 | searchpair_cmn(typval_T *argvars, pos_T *match_pos) |
| 7724 | { |
| 7725 | char_u *spat, *mpat, *epat; |
Bram Moolenaar | 4857048 | 2017-10-30 21:48:41 +0100 | [diff] [blame] | 7726 | typval_T *skip; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7727 | int save_p_ws = p_ws; |
| 7728 | int dir; |
| 7729 | int flags = 0; |
| 7730 | char_u nbuf1[NUMBUFLEN]; |
| 7731 | char_u nbuf2[NUMBUFLEN]; |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7732 | int retval = 0; // default: FAIL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7733 | long lnum_stop = 0; |
| 7734 | long time_limit = 0; |
| 7735 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7736 | // Get the three pattern arguments: start, middle, end. Will result in an |
| 7737 | // error if not a valid argument. |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7738 | spat = tv_get_string_chk(&argvars[0]); |
| 7739 | mpat = tv_get_string_buf_chk(&argvars[1], nbuf1); |
| 7740 | epat = tv_get_string_buf_chk(&argvars[2], nbuf2); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7741 | if (spat == NULL || mpat == NULL || epat == NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7742 | goto theend; // type error |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7743 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7744 | // Handle the optional fourth argument: flags |
| 7745 | dir = get_search_arg(&argvars[3], &flags); // may set p_ws |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7746 | if (dir == 0) |
| 7747 | goto theend; |
| 7748 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7749 | // Don't accept SP_END or SP_SUBPAT. |
| 7750 | // Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7751 | if ((flags & (SP_END | SP_SUBPAT)) != 0 |
| 7752 | || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK))) |
| 7753 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 7754 | semsg(_(e_invarg2), tv_get_string(&argvars[3])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7755 | goto theend; |
| 7756 | } |
| 7757 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7758 | // Using 'r' implies 'W', otherwise it doesn't work. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7759 | if (flags & SP_REPEAT) |
| 7760 | p_ws = FALSE; |
| 7761 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7762 | // Optional fifth argument: skip expression |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7763 | if (argvars[3].v_type == VAR_UNKNOWN |
| 7764 | || argvars[4].v_type == VAR_UNKNOWN) |
Bram Moolenaar | 4857048 | 2017-10-30 21:48:41 +0100 | [diff] [blame] | 7765 | skip = NULL; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7766 | else |
| 7767 | { |
Bram Moolenaar | a9c0104 | 2020-06-07 14:50:50 +0200 | [diff] [blame] | 7768 | // Type is checked later. |
Bram Moolenaar | 4857048 | 2017-10-30 21:48:41 +0100 | [diff] [blame] | 7769 | skip = &argvars[4]; |
Bram Moolenaar | a9c0104 | 2020-06-07 14:50:50 +0200 | [diff] [blame] | 7770 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7771 | if (argvars[5].v_type != VAR_UNKNOWN) |
| 7772 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7773 | lnum_stop = (long)tv_get_number_chk(&argvars[5], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7774 | if (lnum_stop < 0) |
Bram Moolenaar | 3dddb09 | 2018-06-24 19:01:59 +0200 | [diff] [blame] | 7775 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 7776 | semsg(_(e_invarg2), tv_get_string(&argvars[5])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7777 | goto theend; |
Bram Moolenaar | 3dddb09 | 2018-06-24 19:01:59 +0200 | [diff] [blame] | 7778 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7779 | #ifdef FEAT_RELTIME |
| 7780 | if (argvars[6].v_type != VAR_UNKNOWN) |
| 7781 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 7782 | time_limit = (long)tv_get_number_chk(&argvars[6], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7783 | if (time_limit < 0) |
Bram Moolenaar | 3dddb09 | 2018-06-24 19:01:59 +0200 | [diff] [blame] | 7784 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 7785 | semsg(_(e_invarg2), tv_get_string(&argvars[6])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7786 | goto theend; |
Bram Moolenaar | 3dddb09 | 2018-06-24 19:01:59 +0200 | [diff] [blame] | 7787 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7788 | } |
| 7789 | #endif |
| 7790 | } |
| 7791 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7792 | |
| 7793 | retval = do_searchpair(spat, mpat, epat, dir, skip, flags, |
| 7794 | match_pos, lnum_stop, time_limit); |
| 7795 | |
| 7796 | theend: |
| 7797 | p_ws = save_p_ws; |
| 7798 | |
| 7799 | return retval; |
| 7800 | } |
| 7801 | |
| 7802 | /* |
| 7803 | * "searchpair()" function |
| 7804 | */ |
| 7805 | static void |
| 7806 | f_searchpair(typval_T *argvars, typval_T *rettv) |
| 7807 | { |
| 7808 | rettv->vval.v_number = searchpair_cmn(argvars, NULL); |
| 7809 | } |
| 7810 | |
| 7811 | /* |
| 7812 | * "searchpairpos()" function |
| 7813 | */ |
| 7814 | static void |
| 7815 | f_searchpairpos(typval_T *argvars, typval_T *rettv) |
| 7816 | { |
| 7817 | pos_T match_pos; |
| 7818 | int lnum = 0; |
| 7819 | int col = 0; |
| 7820 | |
| 7821 | if (rettv_list_alloc(rettv) == FAIL) |
| 7822 | return; |
| 7823 | |
| 7824 | if (searchpair_cmn(argvars, &match_pos) > 0) |
| 7825 | { |
| 7826 | lnum = match_pos.lnum; |
| 7827 | col = match_pos.col; |
| 7828 | } |
| 7829 | |
| 7830 | list_append_number(rettv->vval.v_list, (varnumber_T)lnum); |
| 7831 | list_append_number(rettv->vval.v_list, (varnumber_T)col); |
| 7832 | } |
| 7833 | |
| 7834 | /* |
| 7835 | * Search for a start/middle/end thing. |
| 7836 | * Used by searchpair(), see its documentation for the details. |
| 7837 | * Returns 0 or -1 for no match, |
| 7838 | */ |
| 7839 | long |
| 7840 | do_searchpair( |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7841 | char_u *spat, // start pattern |
| 7842 | char_u *mpat, // middle pattern |
| 7843 | char_u *epat, // end pattern |
| 7844 | int dir, // BACKWARD or FORWARD |
| 7845 | typval_T *skip, // skip expression |
| 7846 | int flags, // SP_SETPCMARK and other SP_ values |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7847 | pos_T *match_pos, |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7848 | linenr_T lnum_stop, // stop at this line if not zero |
| 7849 | long time_limit UNUSED) // stop after this many msec |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7850 | { |
| 7851 | char_u *save_cpo; |
| 7852 | char_u *pat, *pat2 = NULL, *pat3 = NULL; |
| 7853 | long retval = 0; |
| 7854 | pos_T pos; |
| 7855 | pos_T firstpos; |
| 7856 | pos_T foundpos; |
| 7857 | pos_T save_cursor; |
| 7858 | pos_T save_pos; |
| 7859 | int n; |
| 7860 | int r; |
| 7861 | int nest = 1; |
Bram Moolenaar | 4857048 | 2017-10-30 21:48:41 +0100 | [diff] [blame] | 7862 | int use_skip = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7863 | int err; |
| 7864 | int options = SEARCH_KEEP; |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7865 | #ifdef FEAT_RELTIME |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7866 | proftime_T tm; |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7867 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7868 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7869 | // Make 'cpoptions' empty, the 'l' flag should not be used here. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7870 | save_cpo = p_cpo; |
| 7871 | p_cpo = empty_option; |
| 7872 | |
| 7873 | #ifdef FEAT_RELTIME |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7874 | // Set the time limit, if there is one. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7875 | profile_setlimit(time_limit, &tm); |
| 7876 | #endif |
| 7877 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7878 | // Make two search patterns: start/end (pat2, for in nested pairs) and |
| 7879 | // start/middle/end (pat3, for the top pair). |
Bram Moolenaar | 964b374 | 2019-05-24 18:54:09 +0200 | [diff] [blame] | 7880 | pat2 = alloc(STRLEN(spat) + STRLEN(epat) + 17); |
| 7881 | pat3 = alloc(STRLEN(spat) + STRLEN(mpat) + STRLEN(epat) + 25); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7882 | if (pat2 == NULL || pat3 == NULL) |
| 7883 | goto theend; |
Bram Moolenaar | 6e450a5 | 2017-01-06 20:03:58 +0100 | [diff] [blame] | 7884 | sprintf((char *)pat2, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)", spat, epat); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7885 | if (*mpat == NUL) |
| 7886 | STRCPY(pat3, pat2); |
| 7887 | else |
Bram Moolenaar | 6e450a5 | 2017-01-06 20:03:58 +0100 | [diff] [blame] | 7888 | sprintf((char *)pat3, "\\m\\(%s\\m\\)\\|\\(%s\\m\\)\\|\\(%s\\m\\)", |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7889 | spat, epat, mpat); |
| 7890 | if (flags & SP_START) |
| 7891 | options |= SEARCH_START; |
| 7892 | |
Bram Moolenaar | 4857048 | 2017-10-30 21:48:41 +0100 | [diff] [blame] | 7893 | if (skip != NULL) |
Bram Moolenaar | a9c0104 | 2020-06-07 14:50:50 +0200 | [diff] [blame] | 7894 | use_skip = eval_expr_valid_arg(skip); |
Bram Moolenaar | 4857048 | 2017-10-30 21:48:41 +0100 | [diff] [blame] | 7895 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7896 | save_cursor = curwin->w_cursor; |
| 7897 | pos = curwin->w_cursor; |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 7898 | CLEAR_POS(&firstpos); |
| 7899 | CLEAR_POS(&foundpos); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7900 | pat = pat3; |
| 7901 | for (;;) |
| 7902 | { |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7903 | searchit_arg_T sia; |
| 7904 | |
Bram Moolenaar | a80faa8 | 2020-04-12 19:37:17 +0200 | [diff] [blame] | 7905 | CLEAR_FIELD(sia); |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7906 | sia.sa_stop_lnum = lnum_stop; |
| 7907 | #ifdef FEAT_RELTIME |
| 7908 | sia.sa_tm = &tm; |
| 7909 | #endif |
Bram Moolenaar | 5d24a22 | 2018-12-23 19:10:09 +0100 | [diff] [blame] | 7910 | n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L, |
Bram Moolenaar | 92ea26b | 2019-10-18 20:53:34 +0200 | [diff] [blame] | 7911 | options, RE_SEARCH, &sia); |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 7912 | if (n == FAIL || (firstpos.lnum != 0 && EQUAL_POS(pos, firstpos))) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7913 | // didn't find it or found the first match again: FAIL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7914 | break; |
| 7915 | |
| 7916 | if (firstpos.lnum == 0) |
| 7917 | firstpos = pos; |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 7918 | if (EQUAL_POS(pos, foundpos)) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7919 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7920 | // Found the same position again. Can happen with a pattern that |
| 7921 | // has "\zs" at the end and searching backwards. Advance one |
| 7922 | // character and try again. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7923 | if (dir == BACKWARD) |
| 7924 | decl(&pos); |
| 7925 | else |
| 7926 | incl(&pos); |
| 7927 | } |
| 7928 | foundpos = pos; |
| 7929 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7930 | // clear the start flag to avoid getting stuck here |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7931 | options &= ~SEARCH_START; |
| 7932 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7933 | // If the skip pattern matches, ignore this match. |
Bram Moolenaar | 4857048 | 2017-10-30 21:48:41 +0100 | [diff] [blame] | 7934 | if (use_skip) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7935 | { |
| 7936 | save_pos = curwin->w_cursor; |
| 7937 | curwin->w_cursor = pos; |
Bram Moolenaar | 4857048 | 2017-10-30 21:48:41 +0100 | [diff] [blame] | 7938 | err = FALSE; |
| 7939 | r = eval_expr_to_bool(skip, &err); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7940 | curwin->w_cursor = save_pos; |
| 7941 | if (err) |
| 7942 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7943 | // Evaluating {skip} caused an error, break here. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7944 | curwin->w_cursor = save_cursor; |
| 7945 | retval = -1; |
| 7946 | break; |
| 7947 | } |
| 7948 | if (r) |
| 7949 | continue; |
| 7950 | } |
| 7951 | |
| 7952 | if ((dir == BACKWARD && n == 3) || (dir == FORWARD && n == 2)) |
| 7953 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7954 | // Found end when searching backwards or start when searching |
| 7955 | // forward: nested pair. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7956 | ++nest; |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7957 | pat = pat2; // nested, don't search for middle |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7958 | } |
| 7959 | else |
| 7960 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7961 | // Found end when searching forward or start when searching |
| 7962 | // backward: end of (nested) pair; or found middle in outer pair. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7963 | if (--nest == 1) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7964 | pat = pat3; // outer level, search for middle |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7965 | } |
| 7966 | |
| 7967 | if (nest == 0) |
| 7968 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7969 | // Found the match: return matchcount or line number. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7970 | if (flags & SP_RETCOUNT) |
| 7971 | ++retval; |
| 7972 | else |
| 7973 | retval = pos.lnum; |
| 7974 | if (flags & SP_SETPCMARK) |
| 7975 | setpcmark(); |
| 7976 | curwin->w_cursor = pos; |
| 7977 | if (!(flags & SP_REPEAT)) |
| 7978 | break; |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7979 | nest = 1; // search for next unmatched |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7980 | } |
| 7981 | } |
| 7982 | |
| 7983 | if (match_pos != NULL) |
| 7984 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7985 | // Store the match cursor position |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7986 | match_pos->lnum = curwin->w_cursor.lnum; |
| 7987 | match_pos->col = curwin->w_cursor.col + 1; |
| 7988 | } |
| 7989 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 7990 | // If 'n' flag is used or search failed: restore cursor position. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 7991 | if ((flags & SP_NOMOVE) || retval == 0) |
| 7992 | curwin->w_cursor = save_cursor; |
| 7993 | |
| 7994 | theend: |
| 7995 | vim_free(pat2); |
| 7996 | vim_free(pat3); |
| 7997 | if (p_cpo == empty_option) |
| 7998 | p_cpo = save_cpo; |
| 7999 | else |
Bram Moolenaar | e5a2dc8 | 2021-01-03 19:52:05 +0100 | [diff] [blame] | 8000 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8001 | // Darn, evaluating the {skip} expression changed the value. |
Bram Moolenaar | e5a2dc8 | 2021-01-03 19:52:05 +0100 | [diff] [blame] | 8002 | // If it's still empty it was changed and restored, need to restore in |
| 8003 | // the complicated way. |
| 8004 | if (*p_cpo == NUL) |
| 8005 | set_option_value((char_u *)"cpo", 0L, save_cpo, 0); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8006 | free_string_option(save_cpo); |
Bram Moolenaar | e5a2dc8 | 2021-01-03 19:52:05 +0100 | [diff] [blame] | 8007 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8008 | |
| 8009 | return retval; |
| 8010 | } |
| 8011 | |
| 8012 | /* |
| 8013 | * "searchpos()" function |
| 8014 | */ |
| 8015 | static void |
| 8016 | f_searchpos(typval_T *argvars, typval_T *rettv) |
| 8017 | { |
| 8018 | pos_T match_pos; |
| 8019 | int lnum = 0; |
| 8020 | int col = 0; |
| 8021 | int n; |
| 8022 | int flags = 0; |
| 8023 | |
| 8024 | if (rettv_list_alloc(rettv) == FAIL) |
| 8025 | return; |
| 8026 | |
| 8027 | n = search_cmn(argvars, &match_pos, &flags); |
| 8028 | if (n > 0) |
| 8029 | { |
| 8030 | lnum = match_pos.lnum; |
| 8031 | col = match_pos.col; |
| 8032 | } |
| 8033 | |
| 8034 | list_append_number(rettv->vval.v_list, (varnumber_T)lnum); |
| 8035 | list_append_number(rettv->vval.v_list, (varnumber_T)col); |
| 8036 | if (flags & SP_SUBPAT) |
| 8037 | list_append_number(rettv->vval.v_list, (varnumber_T)n); |
| 8038 | } |
| 8039 | |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 8040 | /* |
| 8041 | * Set the cursor or mark position. |
Christian Brabandt | 98703d7 | 2021-06-24 19:55:27 +0200 | [diff] [blame] | 8042 | * If 'charpos' is TRUE, then use the column number as a character offset. |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 8043 | * Otherwise use the column number as a byte offset. |
| 8044 | */ |
| 8045 | static void |
| 8046 | set_position(typval_T *argvars, typval_T *rettv, int charpos) |
| 8047 | { |
| 8048 | pos_T pos; |
| 8049 | int fnum; |
| 8050 | char_u *name; |
| 8051 | colnr_T curswant = -1; |
| 8052 | |
| 8053 | rettv->vval.v_number = -1; |
| 8054 | |
| 8055 | name = tv_get_string_chk(argvars); |
| 8056 | if (name != NULL) |
| 8057 | { |
| 8058 | if (list2fpos(&argvars[1], &pos, &fnum, &curswant, charpos) == OK) |
| 8059 | { |
| 8060 | if (pos.col != MAXCOL && --pos.col < 0) |
| 8061 | pos.col = 0; |
| 8062 | if ((name[0] == '.' && name[1] == NUL)) |
| 8063 | { |
| 8064 | // set cursor; "fnum" is ignored |
| 8065 | curwin->w_cursor = pos; |
| 8066 | if (curswant >= 0) |
| 8067 | { |
| 8068 | curwin->w_curswant = curswant - 1; |
| 8069 | curwin->w_set_curswant = FALSE; |
| 8070 | } |
| 8071 | check_cursor(); |
| 8072 | rettv->vval.v_number = 0; |
| 8073 | } |
| 8074 | else if (name[0] == '\'' && name[1] != NUL && name[2] == NUL) |
| 8075 | { |
| 8076 | // set mark |
| 8077 | if (setmark_pos(name[1], &pos, fnum) == OK) |
| 8078 | rettv->vval.v_number = 0; |
| 8079 | } |
| 8080 | else |
| 8081 | emsg(_(e_invarg)); |
| 8082 | } |
| 8083 | } |
| 8084 | } |
| 8085 | /* |
| 8086 | * "setcharpos()" function |
| 8087 | */ |
| 8088 | static void |
| 8089 | f_setcharpos(typval_T *argvars, typval_T *rettv) |
| 8090 | { |
| 8091 | set_position(argvars, rettv, TRUE); |
| 8092 | } |
| 8093 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8094 | static void |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8095 | f_setcharsearch(typval_T *argvars, typval_T *rettv UNUSED) |
| 8096 | { |
| 8097 | dict_T *d; |
| 8098 | dictitem_T *di; |
| 8099 | char_u *csearch; |
| 8100 | |
| 8101 | if (argvars[0].v_type != VAR_DICT) |
| 8102 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 8103 | emsg(_(e_dictreq)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8104 | return; |
| 8105 | } |
| 8106 | |
| 8107 | if ((d = argvars[0].vval.v_dict) != NULL) |
| 8108 | { |
Bram Moolenaar | 8f66717 | 2018-12-14 15:38:31 +0100 | [diff] [blame] | 8109 | csearch = dict_get_string(d, (char_u *)"char", FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8110 | if (csearch != NULL) |
| 8111 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8112 | if (enc_utf8) |
| 8113 | { |
| 8114 | int pcc[MAX_MCO]; |
| 8115 | int c = utfc_ptr2char(csearch, pcc); |
| 8116 | |
| 8117 | set_last_csearch(c, csearch, utfc_ptr2len(csearch)); |
| 8118 | } |
| 8119 | else |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8120 | set_last_csearch(PTR2CHAR(csearch), |
Bram Moolenaar | 1614a14 | 2019-10-06 22:00:13 +0200 | [diff] [blame] | 8121 | csearch, mb_ptr2len(csearch)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8122 | } |
| 8123 | |
| 8124 | di = dict_find(d, (char_u *)"forward", -1); |
| 8125 | if (di != NULL) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8126 | set_csearch_direction((int)tv_get_number(&di->di_tv) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8127 | ? FORWARD : BACKWARD); |
| 8128 | |
| 8129 | di = dict_find(d, (char_u *)"until", -1); |
| 8130 | if (di != NULL) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8131 | set_csearch_until(!!tv_get_number(&di->di_tv)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8132 | } |
| 8133 | } |
| 8134 | |
| 8135 | /* |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 8136 | * "setcursorcharpos" function |
| 8137 | */ |
| 8138 | static void |
Bram Moolenaar | 3af15ab | 2021-01-17 16:16:23 +0100 | [diff] [blame] | 8139 | f_setcursorcharpos(typval_T *argvars, typval_T *rettv) |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 8140 | { |
| 8141 | set_cursorpos(argvars, rettv, TRUE); |
| 8142 | } |
| 8143 | |
| 8144 | /* |
Bram Moolenaar | 691ddee | 2019-05-09 14:52:41 +0200 | [diff] [blame] | 8145 | * "setenv()" function |
| 8146 | */ |
| 8147 | static void |
| 8148 | f_setenv(typval_T *argvars, typval_T *rettv UNUSED) |
| 8149 | { |
| 8150 | char_u namebuf[NUMBUFLEN]; |
| 8151 | char_u valbuf[NUMBUFLEN]; |
| 8152 | char_u *name = tv_get_string_buf(&argvars[0], namebuf); |
| 8153 | |
| 8154 | if (argvars[1].v_type == VAR_SPECIAL |
| 8155 | && argvars[1].vval.v_number == VVAL_NULL) |
| 8156 | vim_unsetenv(name); |
| 8157 | else |
| 8158 | vim_setenv(name, tv_get_string_buf(&argvars[1], valbuf)); |
| 8159 | } |
| 8160 | |
| 8161 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8162 | * "setfperm({fname}, {mode})" function |
| 8163 | */ |
| 8164 | static void |
| 8165 | f_setfperm(typval_T *argvars, typval_T *rettv) |
| 8166 | { |
| 8167 | char_u *fname; |
| 8168 | char_u modebuf[NUMBUFLEN]; |
| 8169 | char_u *mode_str; |
| 8170 | int i; |
| 8171 | int mask; |
| 8172 | int mode = 0; |
| 8173 | |
| 8174 | rettv->vval.v_number = 0; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8175 | fname = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8176 | if (fname == NULL) |
| 8177 | return; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8178 | mode_str = tv_get_string_buf_chk(&argvars[1], modebuf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8179 | if (mode_str == NULL) |
| 8180 | return; |
| 8181 | if (STRLEN(mode_str) != 9) |
| 8182 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 8183 | semsg(_(e_invarg2), mode_str); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8184 | return; |
| 8185 | } |
| 8186 | |
| 8187 | mask = 1; |
| 8188 | for (i = 8; i >= 0; --i) |
| 8189 | { |
| 8190 | if (mode_str[i] != '-') |
| 8191 | mode |= mask; |
| 8192 | mask = mask << 1; |
| 8193 | } |
| 8194 | rettv->vval.v_number = mch_setperm(fname, mode) == OK; |
| 8195 | } |
| 8196 | |
| 8197 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8198 | * "setpos()" function |
| 8199 | */ |
| 8200 | static void |
| 8201 | f_setpos(typval_T *argvars, typval_T *rettv) |
| 8202 | { |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 8203 | set_position(argvars, rettv, FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8204 | } |
| 8205 | |
| 8206 | /* |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 8207 | * Translate a register type string to the yank type and block length |
| 8208 | */ |
| 8209 | static int |
| 8210 | get_yank_type(char_u **pp, char_u *yank_type, long *block_len) |
| 8211 | { |
| 8212 | char_u *stropt = *pp; |
| 8213 | switch (*stropt) |
| 8214 | { |
| 8215 | case 'v': case 'c': // character-wise selection |
| 8216 | *yank_type = MCHAR; |
| 8217 | break; |
| 8218 | case 'V': case 'l': // line-wise selection |
| 8219 | *yank_type = MLINE; |
| 8220 | break; |
| 8221 | case 'b': case Ctrl_V: // block-wise selection |
| 8222 | *yank_type = MBLOCK; |
| 8223 | if (VIM_ISDIGIT(stropt[1])) |
| 8224 | { |
| 8225 | ++stropt; |
| 8226 | *block_len = getdigits(&stropt) - 1; |
| 8227 | --stropt; |
| 8228 | } |
| 8229 | break; |
| 8230 | default: |
| 8231 | return FAIL; |
| 8232 | } |
| 8233 | *pp = stropt; |
| 8234 | return OK; |
| 8235 | } |
| 8236 | |
| 8237 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8238 | * "setreg()" function |
| 8239 | */ |
| 8240 | static void |
| 8241 | f_setreg(typval_T *argvars, typval_T *rettv) |
| 8242 | { |
| 8243 | int regname; |
| 8244 | char_u *strregname; |
| 8245 | char_u *stropt; |
| 8246 | char_u *strval; |
| 8247 | int append; |
| 8248 | char_u yank_type; |
| 8249 | long block_len; |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8250 | typval_T *regcontents; |
| 8251 | int pointreg; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8252 | |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8253 | pointreg = 0; |
| 8254 | regcontents = NULL; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8255 | block_len = -1; |
| 8256 | yank_type = MAUTO; |
| 8257 | append = FALSE; |
| 8258 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8259 | strregname = tv_get_string_chk(argvars); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8260 | rettv->vval.v_number = 1; // FAIL is default |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8261 | |
| 8262 | if (strregname == NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8263 | return; // type error; errmsg already given |
Bram Moolenaar | 418a29f | 2021-02-10 22:23:41 +0100 | [diff] [blame] | 8264 | if (in_vim9script() && STRLEN(strregname) > 1) |
| 8265 | { |
| 8266 | semsg(_(e_register_name_must_be_one_char_str), strregname); |
| 8267 | return; |
| 8268 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8269 | regname = *strregname; |
| 8270 | if (regname == 0 || regname == '@') |
| 8271 | regname = '"'; |
| 8272 | |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8273 | if (argvars[1].v_type == VAR_DICT) |
| 8274 | { |
| 8275 | dict_T *d = argvars[1].vval.v_dict; |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 8276 | dictitem_T *di; |
| 8277 | |
| 8278 | if (d == NULL || d->dv_hashtab.ht_used == 0) |
| 8279 | { |
| 8280 | // Empty dict, clear the register (like setreg(0, [])) |
| 8281 | char_u *lstval[2] = {NULL, NULL}; |
| 8282 | write_reg_contents_lst(regname, lstval, 0, FALSE, MAUTO, -1); |
| 8283 | return; |
| 8284 | } |
| 8285 | |
| 8286 | di = dict_find(d, (char_u *)"regcontents", -1); |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8287 | if (di != NULL) |
| 8288 | regcontents = &di->di_tv; |
| 8289 | |
| 8290 | stropt = dict_get_string(d, (char_u *)"regtype", FALSE); |
| 8291 | if (stropt != NULL) |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 8292 | { |
| 8293 | int ret = get_yank_type(&stropt, &yank_type, &block_len); |
| 8294 | |
| 8295 | if (ret == FAIL || *++stropt != NUL) |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8296 | { |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 8297 | semsg(_(e_invargval), "value"); |
| 8298 | return; |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8299 | } |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 8300 | } |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8301 | |
| 8302 | if (regname == '"') |
| 8303 | { |
| 8304 | stropt = dict_get_string(d, (char_u *)"points_to", FALSE); |
| 8305 | if (stropt != NULL) |
| 8306 | { |
| 8307 | pointreg = *stropt; |
| 8308 | regname = pointreg; |
| 8309 | } |
| 8310 | } |
Bram Moolenaar | 6a95058 | 2020-08-28 16:39:33 +0200 | [diff] [blame] | 8311 | else if (dict_get_bool(d, (char_u *)"isunnamed", -1) > 0) |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8312 | pointreg = regname; |
| 8313 | } |
| 8314 | else |
| 8315 | regcontents = &argvars[1]; |
| 8316 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8317 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 8318 | { |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 8319 | if (yank_type != MAUTO) |
| 8320 | { |
| 8321 | semsg(_(e_toomanyarg), "setreg"); |
| 8322 | return; |
| 8323 | } |
| 8324 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8325 | stropt = tv_get_string_chk(&argvars[2]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8326 | if (stropt == NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8327 | return; // type error |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8328 | for (; *stropt != NUL; ++stropt) |
| 8329 | switch (*stropt) |
| 8330 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8331 | case 'a': case 'A': // append |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8332 | append = TRUE; |
| 8333 | break; |
Bram Moolenaar | 7633fe5 | 2020-06-22 19:10:56 +0200 | [diff] [blame] | 8334 | default: |
| 8335 | get_yank_type(&stropt, &yank_type, &block_len); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8336 | } |
| 8337 | } |
| 8338 | |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8339 | if (regcontents && regcontents->v_type == VAR_LIST) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8340 | { |
| 8341 | char_u **lstval; |
| 8342 | char_u **allocval; |
| 8343 | char_u buf[NUMBUFLEN]; |
| 8344 | char_u **curval; |
| 8345 | char_u **curallocval; |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8346 | list_T *ll = regcontents->vval.v_list; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8347 | listitem_T *li; |
| 8348 | int len; |
| 8349 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8350 | // If the list is NULL handle like an empty list. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8351 | len = ll == NULL ? 0 : ll->lv_len; |
| 8352 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8353 | // First half: use for pointers to result lines; second half: use for |
| 8354 | // pointers to allocated copies. |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 8355 | lstval = ALLOC_MULT(char_u *, (len + 1) * 2); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8356 | if (lstval == NULL) |
| 8357 | return; |
| 8358 | curval = lstval; |
| 8359 | allocval = lstval + len + 2; |
| 8360 | curallocval = allocval; |
| 8361 | |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 8362 | if (ll != NULL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8363 | { |
Bram Moolenaar | 7e9f351 | 2020-05-13 22:44:22 +0200 | [diff] [blame] | 8364 | CHECK_LIST_MATERIALIZE(ll); |
Bram Moolenaar | 00d253e | 2020-04-06 22:13:01 +0200 | [diff] [blame] | 8365 | FOR_ALL_LIST_ITEMS(ll, li) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8366 | { |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 8367 | strval = tv_get_string_buf_chk(&li->li_tv, buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8368 | if (strval == NULL) |
| 8369 | goto free_lstval; |
Bram Moolenaar | 50985eb | 2020-01-27 22:09:39 +0100 | [diff] [blame] | 8370 | if (strval == buf) |
| 8371 | { |
| 8372 | // Need to make a copy, next tv_get_string_buf_chk() will |
| 8373 | // overwrite the string. |
| 8374 | strval = vim_strsave(buf); |
| 8375 | if (strval == NULL) |
| 8376 | goto free_lstval; |
| 8377 | *curallocval++ = strval; |
| 8378 | } |
| 8379 | *curval++ = strval; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8380 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8381 | } |
| 8382 | *curval++ = NULL; |
| 8383 | |
| 8384 | write_reg_contents_lst(regname, lstval, -1, |
| 8385 | append, yank_type, block_len); |
| 8386 | free_lstval: |
| 8387 | while (curallocval > allocval) |
| 8388 | vim_free(*--curallocval); |
| 8389 | vim_free(lstval); |
| 8390 | } |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8391 | else if (regcontents) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8392 | { |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8393 | strval = tv_get_string_chk(regcontents); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8394 | if (strval == NULL) |
| 8395 | return; |
| 8396 | write_reg_contents_ex(regname, strval, -1, |
| 8397 | append, yank_type, block_len); |
| 8398 | } |
Bram Moolenaar | bb861e2 | 2020-06-07 18:16:36 +0200 | [diff] [blame] | 8399 | if (pointreg != 0) |
| 8400 | get_yank_register(pointreg, TRUE); |
| 8401 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8402 | rettv->vval.v_number = 0; |
| 8403 | } |
| 8404 | |
| 8405 | /* |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 8406 | * "settagstack()" function |
| 8407 | */ |
| 8408 | static void |
| 8409 | f_settagstack(typval_T *argvars, typval_T *rettv) |
| 8410 | { |
| 8411 | static char *e_invact2 = N_("E962: Invalid action: '%s'"); |
| 8412 | win_T *wp; |
| 8413 | dict_T *d; |
| 8414 | int action = 'r'; |
| 8415 | |
| 8416 | rettv->vval.v_number = -1; |
| 8417 | |
| 8418 | // first argument: window number or id |
| 8419 | wp = find_win_by_nr_or_id(&argvars[0]); |
| 8420 | if (wp == NULL) |
| 8421 | return; |
| 8422 | |
| 8423 | // second argument: dict with items to set in the tag stack |
| 8424 | if (argvars[1].v_type != VAR_DICT) |
| 8425 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 8426 | emsg(_(e_dictreq)); |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 8427 | return; |
| 8428 | } |
| 8429 | d = argvars[1].vval.v_dict; |
| 8430 | if (d == NULL) |
| 8431 | return; |
| 8432 | |
| 8433 | // third argument: action - 'a' for append and 'r' for replace. |
| 8434 | // default is to replace the stack. |
| 8435 | if (argvars[2].v_type == VAR_UNKNOWN) |
| 8436 | action = 'r'; |
| 8437 | else if (argvars[2].v_type == VAR_STRING) |
| 8438 | { |
| 8439 | char_u *actstr; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8440 | actstr = tv_get_string_chk(&argvars[2]); |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 8441 | if (actstr == NULL) |
| 8442 | return; |
Bram Moolenaar | 271fa08 | 2020-01-02 14:02:16 +0100 | [diff] [blame] | 8443 | if ((*actstr == 'r' || *actstr == 'a' || *actstr == 't') |
| 8444 | && actstr[1] == NUL) |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 8445 | action = *actstr; |
| 8446 | else |
| 8447 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 8448 | semsg(_(e_invact2), actstr); |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 8449 | return; |
| 8450 | } |
| 8451 | } |
| 8452 | else |
| 8453 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 8454 | emsg(_(e_stringreq)); |
Bram Moolenaar | f49cc60 | 2018-11-11 15:21:05 +0100 | [diff] [blame] | 8455 | return; |
| 8456 | } |
| 8457 | |
| 8458 | if (set_tagstack(wp, d, action) == OK) |
| 8459 | rettv->vval.v_number = 0; |
| 8460 | } |
| 8461 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8462 | #ifdef FEAT_CRYPT |
| 8463 | /* |
| 8464 | * "sha256({string})" function |
| 8465 | */ |
| 8466 | static void |
| 8467 | f_sha256(typval_T *argvars, typval_T *rettv) |
| 8468 | { |
| 8469 | char_u *p; |
| 8470 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8471 | p = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8472 | rettv->vval.v_string = vim_strsave( |
| 8473 | sha256_bytes(p, (int)STRLEN(p), NULL, 0)); |
| 8474 | rettv->v_type = VAR_STRING; |
| 8475 | } |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8476 | #endif // FEAT_CRYPT |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8477 | |
| 8478 | /* |
| 8479 | * "shellescape({string})" function |
| 8480 | */ |
| 8481 | static void |
| 8482 | f_shellescape(typval_T *argvars, typval_T *rettv) |
| 8483 | { |
Bram Moolenaar | 2061552 | 2017-06-05 18:46:26 +0200 | [diff] [blame] | 8484 | int do_special = non_zero_arg(&argvars[1]); |
| 8485 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8486 | rettv->vval.v_string = vim_strsave_shellescape( |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8487 | tv_get_string(&argvars[0]), do_special, do_special); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8488 | rettv->v_type = VAR_STRING; |
| 8489 | } |
| 8490 | |
| 8491 | /* |
| 8492 | * shiftwidth() function |
| 8493 | */ |
| 8494 | static void |
| 8495 | f_shiftwidth(typval_T *argvars UNUSED, typval_T *rettv) |
| 8496 | { |
Bram Moolenaar | f951416 | 2018-11-22 03:08:29 +0100 | [diff] [blame] | 8497 | rettv->vval.v_number = 0; |
| 8498 | |
| 8499 | if (argvars[0].v_type != VAR_UNKNOWN) |
| 8500 | { |
| 8501 | long col; |
| 8502 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8503 | col = (long)tv_get_number_chk(argvars, NULL); |
Bram Moolenaar | f951416 | 2018-11-22 03:08:29 +0100 | [diff] [blame] | 8504 | if (col < 0) |
| 8505 | return; // type error; errmsg already given |
| 8506 | #ifdef FEAT_VARTABS |
| 8507 | rettv->vval.v_number = get_sw_value_col(curbuf, col); |
| 8508 | return; |
| 8509 | #endif |
| 8510 | } |
| 8511 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8512 | rettv->vval.v_number = get_sw_value(curbuf); |
| 8513 | } |
| 8514 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8515 | /* |
| 8516 | * "soundfold({word})" function |
| 8517 | */ |
| 8518 | static void |
| 8519 | f_soundfold(typval_T *argvars, typval_T *rettv) |
| 8520 | { |
| 8521 | char_u *s; |
| 8522 | |
| 8523 | rettv->v_type = VAR_STRING; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8524 | s = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8525 | #ifdef FEAT_SPELL |
| 8526 | rettv->vval.v_string = eval_soundfold(s); |
| 8527 | #else |
| 8528 | rettv->vval.v_string = vim_strsave(s); |
| 8529 | #endif |
| 8530 | } |
| 8531 | |
| 8532 | /* |
| 8533 | * "spellbadword()" function |
| 8534 | */ |
| 8535 | static void |
| 8536 | f_spellbadword(typval_T *argvars UNUSED, typval_T *rettv) |
| 8537 | { |
| 8538 | char_u *word = (char_u *)""; |
| 8539 | hlf_T attr = HLF_COUNT; |
| 8540 | int len = 0; |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8541 | #ifdef FEAT_SPELL |
| 8542 | int wo_spell_save = curwin->w_p_spell; |
| 8543 | |
| 8544 | if (!curwin->w_p_spell) |
| 8545 | { |
| 8546 | did_set_spelllang(curwin); |
| 8547 | curwin->w_p_spell = TRUE; |
| 8548 | } |
| 8549 | |
| 8550 | if (*curwin->w_s->b_p_spl == NUL) |
| 8551 | { |
| 8552 | emsg(_(e_no_spell)); |
| 8553 | curwin->w_p_spell = wo_spell_save; |
| 8554 | return; |
| 8555 | } |
| 8556 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8557 | |
| 8558 | if (rettv_list_alloc(rettv) == FAIL) |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8559 | { |
| 8560 | #ifdef FEAT_SPELL |
| 8561 | curwin->w_p_spell = wo_spell_save; |
| 8562 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8563 | return; |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8564 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8565 | |
| 8566 | #ifdef FEAT_SPELL |
| 8567 | if (argvars[0].v_type == VAR_UNKNOWN) |
| 8568 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8569 | // Find the start and length of the badly spelled word. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8570 | len = spell_move_to(curwin, FORWARD, TRUE, TRUE, &attr); |
| 8571 | if (len != 0) |
Bram Moolenaar | b73fa62 | 2017-12-21 20:27:47 +0100 | [diff] [blame] | 8572 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8573 | word = ml_get_cursor(); |
Bram Moolenaar | b73fa62 | 2017-12-21 20:27:47 +0100 | [diff] [blame] | 8574 | curwin->w_set_curswant = TRUE; |
| 8575 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8576 | } |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8577 | else if (*curbuf->b_s.b_p_spl != NUL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8578 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8579 | char_u *str = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8580 | int capcol = -1; |
| 8581 | |
| 8582 | if (str != NULL) |
| 8583 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8584 | // Check the argument for spelling. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8585 | while (*str != NUL) |
| 8586 | { |
| 8587 | len = spell_check(curwin, str, &attr, &capcol, FALSE); |
| 8588 | if (attr != HLF_COUNT) |
| 8589 | { |
| 8590 | word = str; |
| 8591 | break; |
| 8592 | } |
| 8593 | str += len; |
Bram Moolenaar | 66ab916 | 2018-07-20 20:28:48 +0200 | [diff] [blame] | 8594 | capcol -= len; |
Bram Moolenaar | 0c779e8 | 2019-08-09 17:01:02 +0200 | [diff] [blame] | 8595 | len = 0; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8596 | } |
| 8597 | } |
| 8598 | } |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8599 | curwin->w_p_spell = wo_spell_save; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8600 | #endif |
| 8601 | |
| 8602 | list_append_string(rettv->vval.v_list, word, len); |
| 8603 | list_append_string(rettv->vval.v_list, (char_u *)( |
| 8604 | attr == HLF_SPB ? "bad" : |
| 8605 | attr == HLF_SPR ? "rare" : |
| 8606 | attr == HLF_SPL ? "local" : |
| 8607 | attr == HLF_SPC ? "caps" : |
| 8608 | ""), -1); |
| 8609 | } |
| 8610 | |
| 8611 | /* |
| 8612 | * "spellsuggest()" function |
| 8613 | */ |
| 8614 | static void |
| 8615 | f_spellsuggest(typval_T *argvars UNUSED, typval_T *rettv) |
| 8616 | { |
| 8617 | #ifdef FEAT_SPELL |
| 8618 | char_u *str; |
| 8619 | int typeerr = FALSE; |
| 8620 | int maxcount; |
| 8621 | garray_T ga; |
| 8622 | int i; |
| 8623 | listitem_T *li; |
| 8624 | int need_capital = FALSE; |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8625 | int wo_spell_save = curwin->w_p_spell; |
| 8626 | |
| 8627 | if (!curwin->w_p_spell) |
| 8628 | { |
| 8629 | did_set_spelllang(curwin); |
| 8630 | curwin->w_p_spell = TRUE; |
| 8631 | } |
| 8632 | |
| 8633 | if (*curwin->w_s->b_p_spl == NUL) |
| 8634 | { |
| 8635 | emsg(_(e_no_spell)); |
| 8636 | curwin->w_p_spell = wo_spell_save; |
| 8637 | return; |
| 8638 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8639 | #endif |
| 8640 | |
| 8641 | if (rettv_list_alloc(rettv) == FAIL) |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8642 | { |
| 8643 | #ifdef FEAT_SPELL |
| 8644 | curwin->w_p_spell = wo_spell_save; |
| 8645 | #endif |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8646 | return; |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8647 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8648 | |
| 8649 | #ifdef FEAT_SPELL |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8650 | if (*curwin->w_s->b_p_spl != NUL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8651 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8652 | str = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8653 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 8654 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8655 | maxcount = (int)tv_get_number_chk(&argvars[1], &typeerr); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8656 | if (maxcount <= 0) |
| 8657 | return; |
| 8658 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 8659 | { |
Bram Moolenaar | 7c27f33 | 2020-09-05 22:45:55 +0200 | [diff] [blame] | 8660 | need_capital = (int)tv_get_bool_chk(&argvars[2], &typeerr); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8661 | if (typeerr) |
| 8662 | return; |
| 8663 | } |
| 8664 | } |
| 8665 | else |
| 8666 | maxcount = 25; |
| 8667 | |
| 8668 | spell_suggest_list(&ga, str, maxcount, need_capital, FALSE); |
| 8669 | |
| 8670 | for (i = 0; i < ga.ga_len; ++i) |
| 8671 | { |
| 8672 | str = ((char_u **)ga.ga_data)[i]; |
| 8673 | |
| 8674 | li = listitem_alloc(); |
| 8675 | if (li == NULL) |
| 8676 | vim_free(str); |
| 8677 | else |
| 8678 | { |
| 8679 | li->li_tv.v_type = VAR_STRING; |
| 8680 | li->li_tv.v_lock = 0; |
| 8681 | li->li_tv.vval.v_string = str; |
| 8682 | list_append(rettv->vval.v_list, li); |
| 8683 | } |
| 8684 | } |
| 8685 | ga_clear(&ga); |
| 8686 | } |
Bram Moolenaar | 152e79e | 2020-06-10 15:32:08 +0200 | [diff] [blame] | 8687 | curwin->w_p_spell = wo_spell_save; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8688 | #endif |
| 8689 | } |
| 8690 | |
| 8691 | static void |
| 8692 | f_split(typval_T *argvars, typval_T *rettv) |
| 8693 | { |
| 8694 | char_u *str; |
| 8695 | char_u *end; |
| 8696 | char_u *pat = NULL; |
| 8697 | regmatch_T regmatch; |
| 8698 | char_u patbuf[NUMBUFLEN]; |
| 8699 | char_u *save_cpo; |
| 8700 | int match; |
| 8701 | colnr_T col = 0; |
| 8702 | int keepempty = FALSE; |
| 8703 | int typeerr = FALSE; |
| 8704 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8705 | // Make 'cpoptions' empty, the 'l' flag should not be used here. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8706 | save_cpo = p_cpo; |
Bram Moolenaar | e5a2dc8 | 2021-01-03 19:52:05 +0100 | [diff] [blame] | 8707 | p_cpo = empty_option; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8708 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8709 | str = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8710 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 8711 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8712 | pat = tv_get_string_buf_chk(&argvars[1], patbuf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8713 | if (pat == NULL) |
| 8714 | typeerr = TRUE; |
| 8715 | if (argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 3986b94 | 2020-09-06 16:09:04 +0200 | [diff] [blame] | 8716 | keepempty = (int)tv_get_bool_chk(&argvars[2], &typeerr); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8717 | } |
| 8718 | if (pat == NULL || *pat == NUL) |
| 8719 | pat = (char_u *)"[\\x01- ]\\+"; |
| 8720 | |
| 8721 | if (rettv_list_alloc(rettv) == FAIL) |
Bram Moolenaar | 7d5e744 | 2020-07-21 22:25:51 +0200 | [diff] [blame] | 8722 | goto theend; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8723 | if (typeerr) |
Bram Moolenaar | 7d5e744 | 2020-07-21 22:25:51 +0200 | [diff] [blame] | 8724 | goto theend; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8725 | |
| 8726 | regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); |
| 8727 | if (regmatch.regprog != NULL) |
| 8728 | { |
| 8729 | regmatch.rm_ic = FALSE; |
| 8730 | while (*str != NUL || keepempty) |
| 8731 | { |
| 8732 | if (*str == NUL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8733 | match = FALSE; // empty item at the end |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8734 | else |
| 8735 | match = vim_regexec_nl(®match, str, col); |
| 8736 | if (match) |
| 8737 | end = regmatch.startp[0]; |
| 8738 | else |
| 8739 | end = str + STRLEN(str); |
| 8740 | if (keepempty || end > str || (rettv->vval.v_list->lv_len > 0 |
| 8741 | && *str != NUL && match && end < regmatch.endp[0])) |
| 8742 | { |
| 8743 | if (list_append_string(rettv->vval.v_list, str, |
| 8744 | (int)(end - str)) == FAIL) |
| 8745 | break; |
| 8746 | } |
| 8747 | if (!match) |
| 8748 | break; |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 8749 | // Advance to just after the match. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8750 | if (regmatch.endp[0] > str) |
| 8751 | col = 0; |
| 8752 | else |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 8753 | // Don't get stuck at the same match. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8754 | col = (*mb_ptr2len)(regmatch.endp[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8755 | str = regmatch.endp[0]; |
| 8756 | } |
| 8757 | |
| 8758 | vim_regfree(regmatch.regprog); |
| 8759 | } |
| 8760 | |
Bram Moolenaar | 7d5e744 | 2020-07-21 22:25:51 +0200 | [diff] [blame] | 8761 | theend: |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8762 | p_cpo = save_cpo; |
| 8763 | } |
| 8764 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8765 | /* |
Bram Moolenaar | 9d40128 | 2019-04-06 13:18:12 +0200 | [diff] [blame] | 8766 | * "str2list()" function |
| 8767 | */ |
| 8768 | static void |
| 8769 | f_str2list(typval_T *argvars, typval_T *rettv) |
| 8770 | { |
| 8771 | char_u *p; |
| 8772 | int utf8 = FALSE; |
| 8773 | |
| 8774 | if (rettv_list_alloc(rettv) == FAIL) |
| 8775 | return; |
| 8776 | |
| 8777 | if (argvars[1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | a48f786 | 2020-09-05 20:16:57 +0200 | [diff] [blame] | 8778 | utf8 = (int)tv_get_bool_chk(&argvars[1], NULL); |
Bram Moolenaar | 9d40128 | 2019-04-06 13:18:12 +0200 | [diff] [blame] | 8779 | |
| 8780 | p = tv_get_string(&argvars[0]); |
| 8781 | |
| 8782 | if (has_mbyte || utf8) |
| 8783 | { |
| 8784 | int (*ptr2len)(char_u *); |
| 8785 | int (*ptr2char)(char_u *); |
| 8786 | |
| 8787 | if (utf8 || enc_utf8) |
| 8788 | { |
| 8789 | ptr2len = utf_ptr2len; |
| 8790 | ptr2char = utf_ptr2char; |
| 8791 | } |
| 8792 | else |
| 8793 | { |
| 8794 | ptr2len = mb_ptr2len; |
| 8795 | ptr2char = mb_ptr2char; |
| 8796 | } |
| 8797 | |
| 8798 | for ( ; *p != NUL; p += (*ptr2len)(p)) |
| 8799 | list_append_number(rettv->vval.v_list, (*ptr2char)(p)); |
| 8800 | } |
| 8801 | else |
| 8802 | for ( ; *p != NUL; ++p) |
| 8803 | list_append_number(rettv->vval.v_list, *p); |
| 8804 | } |
| 8805 | |
| 8806 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8807 | * "str2nr()" function |
| 8808 | */ |
| 8809 | static void |
| 8810 | f_str2nr(typval_T *argvars, typval_T *rettv) |
| 8811 | { |
| 8812 | int base = 10; |
| 8813 | char_u *p; |
| 8814 | varnumber_T n; |
Bram Moolenaar | 60a8de2 | 2019-09-15 14:33:22 +0200 | [diff] [blame] | 8815 | int what = 0; |
Bram Moolenaar | 08243d2 | 2017-01-10 16:12:29 +0100 | [diff] [blame] | 8816 | int isneg; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8817 | |
| 8818 | if (argvars[1].v_type != VAR_UNKNOWN) |
| 8819 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8820 | base = (int)tv_get_number(&argvars[1]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8821 | if (base != 2 && base != 8 && base != 10 && base != 16) |
| 8822 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 8823 | emsg(_(e_invarg)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8824 | return; |
| 8825 | } |
Bram Moolenaar | 3986b94 | 2020-09-06 16:09:04 +0200 | [diff] [blame] | 8826 | if (argvars[2].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[2])) |
Bram Moolenaar | 60a8de2 | 2019-09-15 14:33:22 +0200 | [diff] [blame] | 8827 | what |= STR2NR_QUOTE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8828 | } |
| 8829 | |
Bram Moolenaar | f2b26bc | 2021-01-30 23:05:11 +0100 | [diff] [blame] | 8830 | p = skipwhite(tv_get_string_strict(&argvars[0])); |
Bram Moolenaar | 08243d2 | 2017-01-10 16:12:29 +0100 | [diff] [blame] | 8831 | isneg = (*p == '-'); |
| 8832 | if (*p == '+' || *p == '-') |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8833 | p = skipwhite(p + 1); |
| 8834 | switch (base) |
| 8835 | { |
Bram Moolenaar | 60a8de2 | 2019-09-15 14:33:22 +0200 | [diff] [blame] | 8836 | case 2: what |= STR2NR_BIN + STR2NR_FORCE; break; |
Bram Moolenaar | c17e66c | 2020-06-02 21:38:22 +0200 | [diff] [blame] | 8837 | case 8: what |= STR2NR_OCT + STR2NR_OOCT + STR2NR_FORCE; break; |
Bram Moolenaar | 60a8de2 | 2019-09-15 14:33:22 +0200 | [diff] [blame] | 8838 | case 16: what |= STR2NR_HEX + STR2NR_FORCE; break; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8839 | } |
Bram Moolenaar | 16e9b85 | 2019-05-19 19:59:35 +0200 | [diff] [blame] | 8840 | vim_str2nr(p, NULL, NULL, what, &n, NULL, 0, FALSE); |
| 8841 | // Text after the number is silently ignored. |
Bram Moolenaar | 08243d2 | 2017-01-10 16:12:29 +0100 | [diff] [blame] | 8842 | if (isneg) |
| 8843 | rettv->vval.v_number = -n; |
| 8844 | else |
| 8845 | rettv->vval.v_number = n; |
| 8846 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8847 | } |
| 8848 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8849 | /* |
| 8850 | * "strgetchar()" function |
| 8851 | */ |
| 8852 | static void |
| 8853 | f_strgetchar(typval_T *argvars, typval_T *rettv) |
| 8854 | { |
| 8855 | char_u *str; |
| 8856 | int len; |
| 8857 | int error = FALSE; |
| 8858 | int charidx; |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 8859 | int byteidx = 0; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8860 | |
| 8861 | rettv->vval.v_number = -1; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8862 | str = tv_get_string_chk(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8863 | if (str == NULL) |
| 8864 | return; |
| 8865 | len = (int)STRLEN(str); |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8866 | charidx = (int)tv_get_number_chk(&argvars[1], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8867 | if (error) |
| 8868 | return; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8869 | |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 8870 | while (charidx >= 0 && byteidx < len) |
| 8871 | { |
| 8872 | if (charidx == 0) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8873 | { |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 8874 | rettv->vval.v_number = mb_ptr2char(str + byteidx); |
| 8875 | break; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8876 | } |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 8877 | --charidx; |
| 8878 | byteidx += MB_CPTR2LEN(str + byteidx); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8879 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8880 | } |
| 8881 | |
| 8882 | /* |
| 8883 | * "stridx()" function |
| 8884 | */ |
| 8885 | static void |
| 8886 | f_stridx(typval_T *argvars, typval_T *rettv) |
| 8887 | { |
| 8888 | char_u buf[NUMBUFLEN]; |
| 8889 | char_u *needle; |
| 8890 | char_u *haystack; |
| 8891 | char_u *save_haystack; |
| 8892 | char_u *pos; |
| 8893 | int start_idx; |
| 8894 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8895 | needle = tv_get_string_chk(&argvars[1]); |
| 8896 | save_haystack = haystack = tv_get_string_buf_chk(&argvars[0], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8897 | rettv->vval.v_number = -1; |
| 8898 | if (needle == NULL || haystack == NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8899 | return; // type error; errmsg already given |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8900 | |
| 8901 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 8902 | { |
| 8903 | int error = FALSE; |
| 8904 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8905 | start_idx = (int)tv_get_number_chk(&argvars[2], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8906 | if (error || start_idx >= (int)STRLEN(haystack)) |
| 8907 | return; |
| 8908 | if (start_idx >= 0) |
| 8909 | haystack += start_idx; |
| 8910 | } |
| 8911 | |
| 8912 | pos = (char_u *)strstr((char *)haystack, (char *)needle); |
| 8913 | if (pos != NULL) |
| 8914 | rettv->vval.v_number = (varnumber_T)(pos - save_haystack); |
| 8915 | } |
| 8916 | |
| 8917 | /* |
| 8918 | * "string()" function |
| 8919 | */ |
Bram Moolenaar | 461a7fc | 2018-12-22 13:28:07 +0100 | [diff] [blame] | 8920 | void |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8921 | f_string(typval_T *argvars, typval_T *rettv) |
| 8922 | { |
| 8923 | char_u *tofree; |
| 8924 | char_u numbuf[NUMBUFLEN]; |
| 8925 | |
| 8926 | rettv->v_type = VAR_STRING; |
| 8927 | rettv->vval.v_string = tv2string(&argvars[0], &tofree, numbuf, |
| 8928 | get_copyID()); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 8929 | // Make a copy if we have a value but it's not in allocated memory. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8930 | if (rettv->vval.v_string != NULL && tofree == NULL) |
| 8931 | rettv->vval.v_string = vim_strsave(rettv->vval.v_string); |
| 8932 | } |
| 8933 | |
| 8934 | /* |
| 8935 | * "strlen()" function |
| 8936 | */ |
| 8937 | static void |
| 8938 | f_strlen(typval_T *argvars, typval_T *rettv) |
| 8939 | { |
| 8940 | rettv->vval.v_number = (varnumber_T)(STRLEN( |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8941 | tv_get_string(&argvars[0]))); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8942 | } |
| 8943 | |
Bram Moolenaar | 70ce8a1 | 2021-03-14 19:02:09 +0100 | [diff] [blame] | 8944 | static void |
| 8945 | strchar_common(typval_T *argvars, typval_T *rettv, int skipcc) |
| 8946 | { |
| 8947 | char_u *s = tv_get_string(&argvars[0]); |
| 8948 | varnumber_T len = 0; |
| 8949 | int (*func_mb_ptr2char_adv)(char_u **pp); |
| 8950 | |
| 8951 | func_mb_ptr2char_adv = skipcc ? mb_ptr2char_adv : mb_cptr2char_adv; |
| 8952 | while (*s != NUL) |
| 8953 | { |
| 8954 | func_mb_ptr2char_adv(&s); |
| 8955 | ++len; |
| 8956 | } |
| 8957 | rettv->vval.v_number = len; |
| 8958 | } |
| 8959 | |
| 8960 | /* |
| 8961 | * "strcharlen()" function |
| 8962 | */ |
| 8963 | static void |
| 8964 | f_strcharlen(typval_T *argvars, typval_T *rettv) |
| 8965 | { |
| 8966 | strchar_common(argvars, rettv, TRUE); |
| 8967 | } |
| 8968 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8969 | /* |
| 8970 | * "strchars()" function |
| 8971 | */ |
| 8972 | static void |
| 8973 | f_strchars(typval_T *argvars, typval_T *rettv) |
| 8974 | { |
Bram Moolenaar | 239f8d9 | 2021-01-17 13:21:20 +0100 | [diff] [blame] | 8975 | varnumber_T skipcc = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8976 | |
| 8977 | if (argvars[1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 239f8d9 | 2021-01-17 13:21:20 +0100 | [diff] [blame] | 8978 | skipcc = tv_get_bool(&argvars[1]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8979 | if (skipcc < 0 || skipcc > 1) |
Bram Moolenaar | bade44e | 2020-09-26 22:39:24 +0200 | [diff] [blame] | 8980 | semsg(_(e_using_number_as_bool_nr), skipcc); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8981 | else |
Bram Moolenaar | 70ce8a1 | 2021-03-14 19:02:09 +0100 | [diff] [blame] | 8982 | strchar_common(argvars, rettv, skipcc); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8983 | } |
| 8984 | |
| 8985 | /* |
| 8986 | * "strdisplaywidth()" function |
| 8987 | */ |
| 8988 | static void |
| 8989 | f_strdisplaywidth(typval_T *argvars, typval_T *rettv) |
| 8990 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8991 | char_u *s = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8992 | int col = 0; |
| 8993 | |
| 8994 | if (argvars[1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 8995 | col = (int)tv_get_number(&argvars[1]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 8996 | |
| 8997 | rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col); |
| 8998 | } |
| 8999 | |
| 9000 | /* |
| 9001 | * "strwidth()" function |
| 9002 | */ |
| 9003 | static void |
| 9004 | f_strwidth(typval_T *argvars, typval_T *rettv) |
| 9005 | { |
Bram Moolenaar | 3cfa5b1 | 2021-06-06 14:14:39 +0200 | [diff] [blame] | 9006 | char_u *s = tv_get_string_strict(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9007 | |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 9008 | rettv->vval.v_number = (varnumber_T)(mb_string2cells(s, -1)); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9009 | } |
| 9010 | |
| 9011 | /* |
| 9012 | * "strcharpart()" function |
| 9013 | */ |
| 9014 | static void |
| 9015 | f_strcharpart(typval_T *argvars, typval_T *rettv) |
| 9016 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9017 | char_u *p; |
| 9018 | int nchar; |
| 9019 | int nbyte = 0; |
| 9020 | int charlen; |
Bram Moolenaar | 02b4d9b | 2021-03-14 19:46:45 +0100 | [diff] [blame] | 9021 | int skipcc = FALSE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9022 | int len = 0; |
| 9023 | int slen; |
| 9024 | int error = FALSE; |
| 9025 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9026 | p = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9027 | slen = (int)STRLEN(p); |
| 9028 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9029 | nchar = (int)tv_get_number_chk(&argvars[1], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9030 | if (!error) |
| 9031 | { |
Bram Moolenaar | 02b4d9b | 2021-03-14 19:46:45 +0100 | [diff] [blame] | 9032 | if (argvars[2].v_type != VAR_UNKNOWN |
| 9033 | && argvars[3].v_type != VAR_UNKNOWN) |
| 9034 | { |
| 9035 | skipcc = tv_get_bool(&argvars[3]); |
| 9036 | if (skipcc < 0 || skipcc > 1) |
| 9037 | { |
| 9038 | semsg(_(e_using_number_as_bool_nr), skipcc); |
| 9039 | return; |
| 9040 | } |
| 9041 | } |
| 9042 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9043 | if (nchar > 0) |
| 9044 | while (nchar > 0 && nbyte < slen) |
| 9045 | { |
Bram Moolenaar | 02b4d9b | 2021-03-14 19:46:45 +0100 | [diff] [blame] | 9046 | if (skipcc) |
| 9047 | nbyte += mb_ptr2len(p + nbyte); |
| 9048 | else |
| 9049 | nbyte += MB_CPTR2LEN(p + nbyte); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9050 | --nchar; |
| 9051 | } |
| 9052 | else |
| 9053 | nbyte = nchar; |
| 9054 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 9055 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9056 | charlen = (int)tv_get_number(&argvars[2]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9057 | while (charlen > 0 && nbyte + len < slen) |
| 9058 | { |
| 9059 | int off = nbyte + len; |
| 9060 | |
| 9061 | if (off < 0) |
| 9062 | len += 1; |
| 9063 | else |
Bram Moolenaar | 02b4d9b | 2021-03-14 19:46:45 +0100 | [diff] [blame] | 9064 | { |
| 9065 | if (skipcc) |
| 9066 | len += mb_ptr2len(p + off); |
| 9067 | else |
| 9068 | len += MB_CPTR2LEN(p + off); |
| 9069 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9070 | --charlen; |
| 9071 | } |
| 9072 | } |
| 9073 | else |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9074 | len = slen - nbyte; // default: all bytes that are available. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9075 | } |
| 9076 | |
| 9077 | /* |
| 9078 | * Only return the overlap between the specified part and the actual |
| 9079 | * string. |
| 9080 | */ |
| 9081 | if (nbyte < 0) |
| 9082 | { |
| 9083 | len += nbyte; |
| 9084 | nbyte = 0; |
| 9085 | } |
| 9086 | else if (nbyte > slen) |
| 9087 | nbyte = slen; |
| 9088 | if (len < 0) |
| 9089 | len = 0; |
| 9090 | else if (nbyte + len > slen) |
| 9091 | len = slen - nbyte; |
| 9092 | |
| 9093 | rettv->v_type = VAR_STRING; |
| 9094 | rettv->vval.v_string = vim_strnsave(p + nbyte, len); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9095 | } |
| 9096 | |
| 9097 | /* |
| 9098 | * "strpart()" function |
| 9099 | */ |
| 9100 | static void |
| 9101 | f_strpart(typval_T *argvars, typval_T *rettv) |
| 9102 | { |
| 9103 | char_u *p; |
| 9104 | int n; |
| 9105 | int len; |
| 9106 | int slen; |
| 9107 | int error = FALSE; |
| 9108 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9109 | p = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9110 | slen = (int)STRLEN(p); |
| 9111 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9112 | n = (int)tv_get_number_chk(&argvars[1], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9113 | if (error) |
| 9114 | len = 0; |
| 9115 | else if (argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9116 | len = (int)tv_get_number(&argvars[2]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9117 | else |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9118 | len = slen - n; // default len: all bytes that are available. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9119 | |
Bram Moolenaar | 6c53fca | 2020-08-23 17:34:46 +0200 | [diff] [blame] | 9120 | // Only return the overlap between the specified part and the actual |
| 9121 | // string. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9122 | if (n < 0) |
| 9123 | { |
| 9124 | len += n; |
| 9125 | n = 0; |
| 9126 | } |
| 9127 | else if (n > slen) |
| 9128 | n = slen; |
| 9129 | if (len < 0) |
| 9130 | len = 0; |
| 9131 | else if (n + len > slen) |
| 9132 | len = slen - n; |
| 9133 | |
Bram Moolenaar | 6c53fca | 2020-08-23 17:34:46 +0200 | [diff] [blame] | 9134 | if (argvars[2].v_type != VAR_UNKNOWN && argvars[3].v_type != VAR_UNKNOWN) |
| 9135 | { |
| 9136 | int off; |
| 9137 | |
| 9138 | // length in characters |
| 9139 | for (off = n; off < slen && len > 0; --len) |
| 9140 | off += mb_ptr2len(p + off); |
| 9141 | len = off - n; |
| 9142 | } |
| 9143 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9144 | rettv->v_type = VAR_STRING; |
| 9145 | rettv->vval.v_string = vim_strnsave(p + n, len); |
| 9146 | } |
| 9147 | |
| 9148 | /* |
| 9149 | * "strridx()" function |
| 9150 | */ |
| 9151 | static void |
| 9152 | f_strridx(typval_T *argvars, typval_T *rettv) |
| 9153 | { |
| 9154 | char_u buf[NUMBUFLEN]; |
| 9155 | char_u *needle; |
| 9156 | char_u *haystack; |
| 9157 | char_u *rest; |
| 9158 | char_u *lastmatch = NULL; |
| 9159 | int haystack_len, end_idx; |
| 9160 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9161 | needle = tv_get_string_chk(&argvars[1]); |
| 9162 | haystack = tv_get_string_buf_chk(&argvars[0], buf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9163 | |
| 9164 | rettv->vval.v_number = -1; |
| 9165 | if (needle == NULL || haystack == NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9166 | return; // type error; errmsg already given |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9167 | |
| 9168 | haystack_len = (int)STRLEN(haystack); |
| 9169 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 9170 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9171 | // Third argument: upper limit for index |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9172 | end_idx = (int)tv_get_number_chk(&argvars[2], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9173 | if (end_idx < 0) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9174 | return; // can never find a match |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9175 | } |
| 9176 | else |
| 9177 | end_idx = haystack_len; |
| 9178 | |
| 9179 | if (*needle == NUL) |
| 9180 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9181 | // Empty string matches past the end. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9182 | lastmatch = haystack + end_idx; |
| 9183 | } |
| 9184 | else |
| 9185 | { |
| 9186 | for (rest = haystack; *rest != '\0'; ++rest) |
| 9187 | { |
| 9188 | rest = (char_u *)strstr((char *)rest, (char *)needle); |
| 9189 | if (rest == NULL || rest > haystack + end_idx) |
| 9190 | break; |
| 9191 | lastmatch = rest; |
| 9192 | } |
| 9193 | } |
| 9194 | |
| 9195 | if (lastmatch == NULL) |
| 9196 | rettv->vval.v_number = -1; |
| 9197 | else |
| 9198 | rettv->vval.v_number = (varnumber_T)(lastmatch - haystack); |
| 9199 | } |
| 9200 | |
| 9201 | /* |
| 9202 | * "strtrans()" function |
| 9203 | */ |
| 9204 | static void |
| 9205 | f_strtrans(typval_T *argvars, typval_T *rettv) |
| 9206 | { |
| 9207 | rettv->v_type = VAR_STRING; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9208 | rettv->vval.v_string = transstr(tv_get_string(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9209 | } |
| 9210 | |
| 9211 | /* |
| 9212 | * "submatch()" function |
| 9213 | */ |
| 9214 | static void |
| 9215 | f_submatch(typval_T *argvars, typval_T *rettv) |
| 9216 | { |
| 9217 | int error = FALSE; |
| 9218 | int no; |
| 9219 | int retList = 0; |
| 9220 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9221 | no = (int)tv_get_number_chk(&argvars[0], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9222 | if (error) |
| 9223 | return; |
Bram Moolenaar | 989f592 | 2016-08-21 15:26:54 +0200 | [diff] [blame] | 9224 | if (no < 0 || no >= NSUBEXP) |
| 9225 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 9226 | semsg(_("E935: invalid submatch number: %d"), no); |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 9227 | return; |
Bram Moolenaar | 989f592 | 2016-08-21 15:26:54 +0200 | [diff] [blame] | 9228 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9229 | if (argvars[1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | ad30470 | 2020-09-06 18:22:53 +0200 | [diff] [blame] | 9230 | retList = (int)tv_get_bool_chk(&argvars[1], &error); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9231 | if (error) |
| 9232 | return; |
| 9233 | |
| 9234 | if (retList == 0) |
| 9235 | { |
| 9236 | rettv->v_type = VAR_STRING; |
| 9237 | rettv->vval.v_string = reg_submatch(no); |
| 9238 | } |
| 9239 | else |
| 9240 | { |
| 9241 | rettv->v_type = VAR_LIST; |
| 9242 | rettv->vval.v_list = reg_submatch_list(no); |
| 9243 | } |
| 9244 | } |
| 9245 | |
| 9246 | /* |
| 9247 | * "substitute()" function |
| 9248 | */ |
| 9249 | static void |
| 9250 | f_substitute(typval_T *argvars, typval_T *rettv) |
| 9251 | { |
| 9252 | char_u patbuf[NUMBUFLEN]; |
| 9253 | char_u subbuf[NUMBUFLEN]; |
| 9254 | char_u flagsbuf[NUMBUFLEN]; |
| 9255 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9256 | char_u *str = tv_get_string_chk(&argvars[0]); |
| 9257 | char_u *pat = tv_get_string_buf_chk(&argvars[1], patbuf); |
Bram Moolenaar | 72ab729 | 2016-07-19 19:10:51 +0200 | [diff] [blame] | 9258 | char_u *sub = NULL; |
| 9259 | typval_T *expr = NULL; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9260 | char_u *flg = tv_get_string_buf_chk(&argvars[3], flagsbuf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9261 | |
Bram Moolenaar | 72ab729 | 2016-07-19 19:10:51 +0200 | [diff] [blame] | 9262 | if (argvars[2].v_type == VAR_FUNC || argvars[2].v_type == VAR_PARTIAL) |
| 9263 | expr = &argvars[2]; |
| 9264 | else |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9265 | sub = tv_get_string_buf_chk(&argvars[2], subbuf); |
Bram Moolenaar | 72ab729 | 2016-07-19 19:10:51 +0200 | [diff] [blame] | 9266 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9267 | rettv->v_type = VAR_STRING; |
Bram Moolenaar | 72ab729 | 2016-07-19 19:10:51 +0200 | [diff] [blame] | 9268 | if (str == NULL || pat == NULL || (sub == NULL && expr == NULL) |
| 9269 | || flg == NULL) |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9270 | rettv->vval.v_string = NULL; |
| 9271 | else |
Bram Moolenaar | 72ab729 | 2016-07-19 19:10:51 +0200 | [diff] [blame] | 9272 | rettv->vval.v_string = do_string_sub(str, pat, sub, expr, flg); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9273 | } |
| 9274 | |
| 9275 | /* |
Bram Moolenaar | 00f123a | 2018-08-21 20:28:54 +0200 | [diff] [blame] | 9276 | * "swapinfo(swap_filename)" function |
| 9277 | */ |
| 9278 | static void |
| 9279 | f_swapinfo(typval_T *argvars, typval_T *rettv) |
| 9280 | { |
| 9281 | if (rettv_dict_alloc(rettv) == OK) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9282 | get_b0_dict(tv_get_string(argvars), rettv->vval.v_dict); |
Bram Moolenaar | 00f123a | 2018-08-21 20:28:54 +0200 | [diff] [blame] | 9283 | } |
| 9284 | |
| 9285 | /* |
Bram Moolenaar | 110bd60 | 2018-09-16 18:46:59 +0200 | [diff] [blame] | 9286 | * "swapname(expr)" function |
| 9287 | */ |
| 9288 | static void |
| 9289 | f_swapname(typval_T *argvars, typval_T *rettv) |
| 9290 | { |
| 9291 | buf_T *buf; |
| 9292 | |
| 9293 | rettv->v_type = VAR_STRING; |
Bram Moolenaar | f2d79fa | 2019-01-03 22:19:27 +0100 | [diff] [blame] | 9294 | buf = tv_get_buf(&argvars[0], FALSE); |
Bram Moolenaar | 110bd60 | 2018-09-16 18:46:59 +0200 | [diff] [blame] | 9295 | if (buf == NULL || buf->b_ml.ml_mfp == NULL |
| 9296 | || buf->b_ml.ml_mfp->mf_fname == NULL) |
| 9297 | rettv->vval.v_string = NULL; |
| 9298 | else |
| 9299 | rettv->vval.v_string = vim_strsave(buf->b_ml.ml_mfp->mf_fname); |
| 9300 | } |
| 9301 | |
| 9302 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9303 | * "synID(lnum, col, trans)" function |
| 9304 | */ |
| 9305 | static void |
| 9306 | f_synID(typval_T *argvars UNUSED, typval_T *rettv) |
| 9307 | { |
| 9308 | int id = 0; |
| 9309 | #ifdef FEAT_SYN_HL |
| 9310 | linenr_T lnum; |
| 9311 | colnr_T col; |
| 9312 | int trans; |
| 9313 | int transerr = FALSE; |
| 9314 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9315 | lnum = tv_get_lnum(argvars); // -1 on type error |
| 9316 | col = (linenr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error |
Bram Moolenaar | fcb6d70 | 2020-09-05 21:41:56 +0200 | [diff] [blame] | 9317 | trans = (int)tv_get_bool_chk(&argvars[2], &transerr); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9318 | |
| 9319 | if (!transerr && lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count |
| 9320 | && col >= 0 && col < (long)STRLEN(ml_get(lnum))) |
| 9321 | id = syn_get_id(curwin, lnum, (colnr_T)col, trans, NULL, FALSE); |
| 9322 | #endif |
| 9323 | |
| 9324 | rettv->vval.v_number = id; |
| 9325 | } |
| 9326 | |
| 9327 | /* |
| 9328 | * "synIDattr(id, what [, mode])" function |
| 9329 | */ |
| 9330 | static void |
| 9331 | f_synIDattr(typval_T *argvars UNUSED, typval_T *rettv) |
| 9332 | { |
| 9333 | char_u *p = NULL; |
| 9334 | #ifdef FEAT_SYN_HL |
| 9335 | int id; |
| 9336 | char_u *what; |
| 9337 | char_u *mode; |
| 9338 | char_u modebuf[NUMBUFLEN]; |
| 9339 | int modec; |
| 9340 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9341 | id = (int)tv_get_number(&argvars[0]); |
| 9342 | what = tv_get_string(&argvars[1]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9343 | if (argvars[2].v_type != VAR_UNKNOWN) |
| 9344 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9345 | mode = tv_get_string_buf(&argvars[2], modebuf); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9346 | modec = TOLOWER_ASC(mode[0]); |
| 9347 | if (modec != 't' && modec != 'c' && modec != 'g') |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9348 | modec = 0; // replace invalid with current |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9349 | } |
| 9350 | else |
| 9351 | { |
| 9352 | #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) |
| 9353 | if (USE_24BIT) |
| 9354 | modec = 'g'; |
| 9355 | else |
| 9356 | #endif |
| 9357 | if (t_colors > 1) |
Dominique Pelle | 4781d6f | 2021-05-18 21:46:31 +0200 | [diff] [blame] | 9358 | modec = 'c'; |
| 9359 | else |
| 9360 | modec = 't'; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9361 | } |
| 9362 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9363 | switch (TOLOWER_ASC(what[0])) |
| 9364 | { |
| 9365 | case 'b': |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9366 | if (TOLOWER_ASC(what[1]) == 'g') // bg[#] |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9367 | p = highlight_color(id, what, modec); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9368 | else // bold |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9369 | p = highlight_has_attr(id, HL_BOLD, modec); |
| 9370 | break; |
| 9371 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9372 | case 'f': // fg[#] or font |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9373 | p = highlight_color(id, what, modec); |
| 9374 | break; |
| 9375 | |
| 9376 | case 'i': |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9377 | if (TOLOWER_ASC(what[1]) == 'n') // inverse |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9378 | p = highlight_has_attr(id, HL_INVERSE, modec); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9379 | else // italic |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9380 | p = highlight_has_attr(id, HL_ITALIC, modec); |
| 9381 | break; |
| 9382 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9383 | case 'n': // name |
Bram Moolenaar | c96272e | 2017-03-26 13:50:09 +0200 | [diff] [blame] | 9384 | p = get_highlight_name_ext(NULL, id - 1, FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9385 | break; |
| 9386 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9387 | case 'r': // reverse |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9388 | p = highlight_has_attr(id, HL_INVERSE, modec); |
| 9389 | break; |
| 9390 | |
| 9391 | case 's': |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9392 | if (TOLOWER_ASC(what[1]) == 'p') // sp[#] |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9393 | p = highlight_color(id, what, modec); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9394 | // strikeout |
Bram Moolenaar | cf4b00c | 2017-09-02 18:33:56 +0200 | [diff] [blame] | 9395 | else if (TOLOWER_ASC(what[1]) == 't' && |
| 9396 | TOLOWER_ASC(what[2]) == 'r') |
| 9397 | p = highlight_has_attr(id, HL_STRIKETHROUGH, modec); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9398 | else // standout |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9399 | p = highlight_has_attr(id, HL_STANDOUT, modec); |
| 9400 | break; |
| 9401 | |
| 9402 | case 'u': |
Bram Moolenaar | 391c362 | 2020-09-29 20:59:17 +0200 | [diff] [blame] | 9403 | if (TOLOWER_ASC(what[1]) == 'l') // ul |
| 9404 | p = highlight_color(id, what, modec); |
| 9405 | else if (STRLEN(what) <= 5 || TOLOWER_ASC(what[5]) != 'c') |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9406 | // underline |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9407 | p = highlight_has_attr(id, HL_UNDERLINE, modec); |
| 9408 | else |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9409 | // undercurl |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9410 | p = highlight_has_attr(id, HL_UNDERCURL, modec); |
| 9411 | break; |
| 9412 | } |
| 9413 | |
| 9414 | if (p != NULL) |
| 9415 | p = vim_strsave(p); |
| 9416 | #endif |
| 9417 | rettv->v_type = VAR_STRING; |
| 9418 | rettv->vval.v_string = p; |
| 9419 | } |
| 9420 | |
| 9421 | /* |
| 9422 | * "synIDtrans(id)" function |
| 9423 | */ |
| 9424 | static void |
| 9425 | f_synIDtrans(typval_T *argvars UNUSED, typval_T *rettv) |
| 9426 | { |
| 9427 | int id; |
| 9428 | |
| 9429 | #ifdef FEAT_SYN_HL |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9430 | id = (int)tv_get_number(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9431 | |
| 9432 | if (id > 0) |
| 9433 | id = syn_get_final_id(id); |
| 9434 | else |
| 9435 | #endif |
| 9436 | id = 0; |
| 9437 | |
| 9438 | rettv->vval.v_number = id; |
| 9439 | } |
| 9440 | |
| 9441 | /* |
| 9442 | * "synconcealed(lnum, col)" function |
| 9443 | */ |
| 9444 | static void |
| 9445 | f_synconcealed(typval_T *argvars UNUSED, typval_T *rettv) |
| 9446 | { |
| 9447 | #if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL) |
| 9448 | linenr_T lnum; |
| 9449 | colnr_T col; |
| 9450 | int syntax_flags = 0; |
| 9451 | int cchar; |
| 9452 | int matchid = 0; |
| 9453 | char_u str[NUMBUFLEN]; |
| 9454 | #endif |
| 9455 | |
Bram Moolenaar | 45cf6e9 | 2017-04-30 20:25:19 +0200 | [diff] [blame] | 9456 | rettv_list_set(rettv, NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9457 | |
| 9458 | #if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9459 | lnum = tv_get_lnum(argvars); // -1 on type error |
| 9460 | col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9461 | |
Bram Moolenaar | a80faa8 | 2020-04-12 19:37:17 +0200 | [diff] [blame] | 9462 | CLEAR_FIELD(str); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9463 | |
| 9464 | if (rettv_list_alloc(rettv) != FAIL) |
| 9465 | { |
| 9466 | if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count |
| 9467 | && col >= 0 && col <= (long)STRLEN(ml_get(lnum)) |
| 9468 | && curwin->w_p_cole > 0) |
| 9469 | { |
| 9470 | (void)syn_get_id(curwin, lnum, col, FALSE, NULL, FALSE); |
| 9471 | syntax_flags = get_syntax_info(&matchid); |
| 9472 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9473 | // get the conceal character |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9474 | if ((syntax_flags & HL_CONCEAL) && curwin->w_p_cole < 3) |
| 9475 | { |
| 9476 | cchar = syn_get_sub_char(); |
Bram Moolenaar | 4d78589 | 2017-06-22 22:00:50 +0200 | [diff] [blame] | 9477 | if (cchar == NUL && curwin->w_p_cole == 1) |
Bram Moolenaar | eed9d46 | 2021-02-15 20:38:25 +0100 | [diff] [blame] | 9478 | cchar = (curwin->w_lcs_chars.conceal == NUL) ? ' ' |
| 9479 | : curwin->w_lcs_chars.conceal; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9480 | if (cchar != NUL) |
| 9481 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9482 | if (has_mbyte) |
| 9483 | (*mb_char2bytes)(cchar, str); |
| 9484 | else |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9485 | str[0] = cchar; |
| 9486 | } |
| 9487 | } |
| 9488 | } |
| 9489 | |
| 9490 | list_append_number(rettv->vval.v_list, |
| 9491 | (syntax_flags & HL_CONCEAL) != 0); |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9492 | // -1 to auto-determine strlen |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9493 | list_append_string(rettv->vval.v_list, str, -1); |
| 9494 | list_append_number(rettv->vval.v_list, matchid); |
| 9495 | } |
| 9496 | #endif |
| 9497 | } |
| 9498 | |
| 9499 | /* |
| 9500 | * "synstack(lnum, col)" function |
| 9501 | */ |
| 9502 | static void |
| 9503 | f_synstack(typval_T *argvars UNUSED, typval_T *rettv) |
| 9504 | { |
| 9505 | #ifdef FEAT_SYN_HL |
| 9506 | linenr_T lnum; |
| 9507 | colnr_T col; |
| 9508 | int i; |
| 9509 | int id; |
| 9510 | #endif |
| 9511 | |
Bram Moolenaar | 45cf6e9 | 2017-04-30 20:25:19 +0200 | [diff] [blame] | 9512 | rettv_list_set(rettv, NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9513 | |
| 9514 | #ifdef FEAT_SYN_HL |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9515 | lnum = tv_get_lnum(argvars); // -1 on type error |
| 9516 | col = (colnr_T)tv_get_number(&argvars[1]) - 1; // -1 on type error |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9517 | |
| 9518 | if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count |
| 9519 | && col >= 0 && col <= (long)STRLEN(ml_get(lnum)) |
| 9520 | && rettv_list_alloc(rettv) != FAIL) |
| 9521 | { |
| 9522 | (void)syn_get_id(curwin, lnum, (colnr_T)col, FALSE, NULL, TRUE); |
| 9523 | for (i = 0; ; ++i) |
| 9524 | { |
| 9525 | id = syn_get_stack_item(i); |
| 9526 | if (id < 0) |
| 9527 | break; |
| 9528 | if (list_append_number(rettv->vval.v_list, id) == FAIL) |
| 9529 | break; |
| 9530 | } |
| 9531 | } |
| 9532 | #endif |
| 9533 | } |
| 9534 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9535 | /* |
| 9536 | * "tabpagebuflist()" function |
| 9537 | */ |
| 9538 | static void |
| 9539 | f_tabpagebuflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 9540 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9541 | tabpage_T *tp; |
| 9542 | win_T *wp = NULL; |
| 9543 | |
| 9544 | if (argvars[0].v_type == VAR_UNKNOWN) |
| 9545 | wp = firstwin; |
| 9546 | else |
| 9547 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9548 | tp = find_tabpage((int)tv_get_number(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9549 | if (tp != NULL) |
| 9550 | wp = (tp == curtab) ? firstwin : tp->tp_firstwin; |
| 9551 | } |
| 9552 | if (wp != NULL && rettv_list_alloc(rettv) != FAIL) |
| 9553 | { |
| 9554 | for (; wp != NULL; wp = wp->w_next) |
| 9555 | if (list_append_number(rettv->vval.v_list, |
| 9556 | wp->w_buffer->b_fnum) == FAIL) |
| 9557 | break; |
| 9558 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9559 | } |
| 9560 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9561 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9562 | * "tagfiles()" function |
| 9563 | */ |
| 9564 | static void |
| 9565 | f_tagfiles(typval_T *argvars UNUSED, typval_T *rettv) |
| 9566 | { |
| 9567 | char_u *fname; |
| 9568 | tagname_T tn; |
| 9569 | int first; |
| 9570 | |
| 9571 | if (rettv_list_alloc(rettv) == FAIL) |
| 9572 | return; |
| 9573 | fname = alloc(MAXPATHL); |
| 9574 | if (fname == NULL) |
| 9575 | return; |
| 9576 | |
| 9577 | for (first = TRUE; ; first = FALSE) |
| 9578 | if (get_tagfname(&tn, first, fname) == FAIL |
| 9579 | || list_append_string(rettv->vval.v_list, fname, -1) == FAIL) |
| 9580 | break; |
| 9581 | tagname_free(&tn); |
| 9582 | vim_free(fname); |
| 9583 | } |
| 9584 | |
| 9585 | /* |
| 9586 | * "taglist()" function |
| 9587 | */ |
| 9588 | static void |
| 9589 | f_taglist(typval_T *argvars, typval_T *rettv) |
| 9590 | { |
Bram Moolenaar | c6aafba | 2017-03-21 17:09:10 +0100 | [diff] [blame] | 9591 | char_u *fname = NULL; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9592 | char_u *tag_pattern; |
| 9593 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9594 | tag_pattern = tv_get_string(&argvars[0]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9595 | |
| 9596 | rettv->vval.v_number = FALSE; |
| 9597 | if (*tag_pattern == NUL) |
| 9598 | return; |
| 9599 | |
Bram Moolenaar | c6aafba | 2017-03-21 17:09:10 +0100 | [diff] [blame] | 9600 | if (argvars[1].v_type != VAR_UNKNOWN) |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9601 | fname = tv_get_string(&argvars[1]); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9602 | if (rettv_list_alloc(rettv) == OK) |
Bram Moolenaar | c6aafba | 2017-03-21 17:09:10 +0100 | [diff] [blame] | 9603 | (void)get_tags(rettv->vval.v_list, tag_pattern, fname); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9604 | } |
| 9605 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9606 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9607 | * "tolower(string)" function |
| 9608 | */ |
| 9609 | static void |
| 9610 | f_tolower(typval_T *argvars, typval_T *rettv) |
| 9611 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9612 | rettv->v_type = VAR_STRING; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9613 | rettv->vval.v_string = strlow_save(tv_get_string(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9614 | } |
| 9615 | |
| 9616 | /* |
| 9617 | * "toupper(string)" function |
| 9618 | */ |
| 9619 | static void |
| 9620 | f_toupper(typval_T *argvars, typval_T *rettv) |
| 9621 | { |
| 9622 | rettv->v_type = VAR_STRING; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9623 | rettv->vval.v_string = strup_save(tv_get_string(&argvars[0])); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9624 | } |
| 9625 | |
| 9626 | /* |
| 9627 | * "tr(string, fromstr, tostr)" function |
| 9628 | */ |
| 9629 | static void |
| 9630 | f_tr(typval_T *argvars, typval_T *rettv) |
| 9631 | { |
| 9632 | char_u *in_str; |
| 9633 | char_u *fromstr; |
| 9634 | char_u *tostr; |
| 9635 | char_u *p; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9636 | int inlen; |
| 9637 | int fromlen; |
| 9638 | int tolen; |
| 9639 | int idx; |
| 9640 | char_u *cpstr; |
| 9641 | int cplen; |
| 9642 | int first = TRUE; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9643 | char_u buf[NUMBUFLEN]; |
| 9644 | char_u buf2[NUMBUFLEN]; |
| 9645 | garray_T ga; |
| 9646 | |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9647 | in_str = tv_get_string(&argvars[0]); |
| 9648 | fromstr = tv_get_string_buf_chk(&argvars[1], buf); |
| 9649 | tostr = tv_get_string_buf_chk(&argvars[2], buf2); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9650 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9651 | // Default return value: empty string. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9652 | rettv->v_type = VAR_STRING; |
| 9653 | rettv->vval.v_string = NULL; |
| 9654 | if (fromstr == NULL || tostr == NULL) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9655 | return; // type error; errmsg already given |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9656 | ga_init2(&ga, (int)sizeof(char), 80); |
| 9657 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9658 | if (!has_mbyte) |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9659 | // not multi-byte: fromstr and tostr must be the same length |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9660 | if (STRLEN(fromstr) != STRLEN(tostr)) |
| 9661 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9662 | error: |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 9663 | semsg(_(e_invarg2), fromstr); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9664 | ga_clear(&ga); |
| 9665 | return; |
| 9666 | } |
| 9667 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9668 | // fromstr and tostr have to contain the same number of chars |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9669 | while (*in_str != NUL) |
| 9670 | { |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9671 | if (has_mbyte) |
| 9672 | { |
| 9673 | inlen = (*mb_ptr2len)(in_str); |
| 9674 | cpstr = in_str; |
| 9675 | cplen = inlen; |
| 9676 | idx = 0; |
| 9677 | for (p = fromstr; *p != NUL; p += fromlen) |
| 9678 | { |
| 9679 | fromlen = (*mb_ptr2len)(p); |
| 9680 | if (fromlen == inlen && STRNCMP(in_str, p, inlen) == 0) |
| 9681 | { |
| 9682 | for (p = tostr; *p != NUL; p += tolen) |
| 9683 | { |
| 9684 | tolen = (*mb_ptr2len)(p); |
| 9685 | if (idx-- == 0) |
| 9686 | { |
| 9687 | cplen = tolen; |
| 9688 | cpstr = p; |
| 9689 | break; |
| 9690 | } |
| 9691 | } |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9692 | if (*p == NUL) // tostr is shorter than fromstr |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9693 | goto error; |
| 9694 | break; |
| 9695 | } |
| 9696 | ++idx; |
| 9697 | } |
| 9698 | |
| 9699 | if (first && cpstr == in_str) |
| 9700 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9701 | // Check that fromstr and tostr have the same number of |
| 9702 | // (multi-byte) characters. Done only once when a character |
| 9703 | // of in_str doesn't appear in fromstr. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9704 | first = FALSE; |
| 9705 | for (p = tostr; *p != NUL; p += tolen) |
| 9706 | { |
| 9707 | tolen = (*mb_ptr2len)(p); |
| 9708 | --idx; |
| 9709 | } |
| 9710 | if (idx != 0) |
| 9711 | goto error; |
| 9712 | } |
| 9713 | |
| 9714 | (void)ga_grow(&ga, cplen); |
| 9715 | mch_memmove((char *)ga.ga_data + ga.ga_len, cpstr, (size_t)cplen); |
| 9716 | ga.ga_len += cplen; |
| 9717 | |
| 9718 | in_str += inlen; |
| 9719 | } |
| 9720 | else |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9721 | { |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9722 | // When not using multi-byte chars we can do it faster. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9723 | p = vim_strchr(fromstr, *in_str); |
| 9724 | if (p != NULL) |
| 9725 | ga_append(&ga, tostr[p - fromstr]); |
| 9726 | else |
| 9727 | ga_append(&ga, *in_str); |
| 9728 | ++in_str; |
| 9729 | } |
| 9730 | } |
| 9731 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9732 | // add a terminating NUL |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9733 | (void)ga_grow(&ga, 1); |
| 9734 | ga_append(&ga, NUL); |
| 9735 | |
| 9736 | rettv->vval.v_string = ga.ga_data; |
| 9737 | } |
| 9738 | |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9739 | /* |
| 9740 | * "trim({expr})" function |
| 9741 | */ |
| 9742 | static void |
| 9743 | f_trim(typval_T *argvars, typval_T *rettv) |
| 9744 | { |
| 9745 | char_u buf1[NUMBUFLEN]; |
| 9746 | char_u buf2[NUMBUFLEN]; |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9747 | char_u *head = tv_get_string_buf_chk(&argvars[0], buf1); |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9748 | char_u *mask = NULL; |
| 9749 | char_u *tail; |
| 9750 | char_u *prev; |
| 9751 | char_u *p; |
| 9752 | int c1; |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9753 | int dir = 0; |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9754 | |
| 9755 | rettv->v_type = VAR_STRING; |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9756 | rettv->vval.v_string = NULL; |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9757 | if (head == NULL) |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9758 | return; |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9759 | |
| 9760 | if (argvars[1].v_type == VAR_STRING) |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9761 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9762 | mask = tv_get_string_buf_chk(&argvars[1], buf2); |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9763 | |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9764 | if (argvars[2].v_type != VAR_UNKNOWN) |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9765 | { |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9766 | int error = 0; |
| 9767 | |
| 9768 | // leading or trailing characters to trim |
| 9769 | dir = (int)tv_get_number_chk(&argvars[2], &error); |
| 9770 | if (error) |
| 9771 | return; |
| 9772 | if (dir < 0 || dir > 2) |
| 9773 | { |
| 9774 | semsg(_(e_invarg2), tv_get_string(&argvars[2])); |
| 9775 | return; |
| 9776 | } |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9777 | } |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9778 | } |
| 9779 | |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9780 | if (dir == 0 || dir == 1) |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9781 | { |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9782 | // Trim leading characters |
| 9783 | while (*head != NUL) |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9784 | { |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9785 | c1 = PTR2CHAR(head); |
| 9786 | if (mask == NULL) |
| 9787 | { |
| 9788 | if (c1 > ' ' && c1 != 0xa0) |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9789 | break; |
Bram Moolenaar | 2245ae1 | 2020-05-31 22:20:36 +0200 | [diff] [blame] | 9790 | } |
| 9791 | else |
| 9792 | { |
| 9793 | for (p = mask; *p != NUL; MB_PTR_ADV(p)) |
| 9794 | if (c1 == PTR2CHAR(p)) |
| 9795 | break; |
| 9796 | if (*p == NUL) |
| 9797 | break; |
| 9798 | } |
| 9799 | MB_PTR_ADV(head); |
| 9800 | } |
| 9801 | } |
| 9802 | |
| 9803 | tail = head + STRLEN(head); |
| 9804 | if (dir == 0 || dir == 2) |
| 9805 | { |
| 9806 | // Trim trailing characters |
| 9807 | for (; tail > head; tail = prev) |
| 9808 | { |
| 9809 | prev = tail; |
| 9810 | MB_PTR_BACK(head, prev); |
| 9811 | c1 = PTR2CHAR(prev); |
| 9812 | if (mask == NULL) |
| 9813 | { |
| 9814 | if (c1 > ' ' && c1 != 0xa0) |
| 9815 | break; |
| 9816 | } |
| 9817 | else |
| 9818 | { |
| 9819 | for (p = mask; *p != NUL; MB_PTR_ADV(p)) |
| 9820 | if (c1 == PTR2CHAR(p)) |
| 9821 | break; |
| 9822 | if (*p == NUL) |
| 9823 | break; |
| 9824 | } |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9825 | } |
| 9826 | } |
Bram Moolenaar | df44a27 | 2020-06-07 20:49:05 +0200 | [diff] [blame] | 9827 | rettv->vval.v_string = vim_strnsave(head, tail - head); |
Bram Moolenaar | 295ac5a | 2018-03-22 23:04:02 +0100 | [diff] [blame] | 9828 | } |
| 9829 | |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9830 | /* |
| 9831 | * "type(expr)" function |
| 9832 | */ |
| 9833 | static void |
| 9834 | f_type(typval_T *argvars, typval_T *rettv) |
| 9835 | { |
| 9836 | int n = -1; |
| 9837 | |
| 9838 | switch (argvars[0].v_type) |
| 9839 | { |
Bram Moolenaar | 9b4a15d | 2020-01-11 16:05:23 +0100 | [diff] [blame] | 9840 | case VAR_NUMBER: n = VAR_TYPE_NUMBER; break; |
| 9841 | case VAR_STRING: n = VAR_TYPE_STRING; break; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9842 | case VAR_PARTIAL: |
Bram Moolenaar | 9b4a15d | 2020-01-11 16:05:23 +0100 | [diff] [blame] | 9843 | case VAR_FUNC: n = VAR_TYPE_FUNC; break; |
| 9844 | case VAR_LIST: n = VAR_TYPE_LIST; break; |
| 9845 | case VAR_DICT: n = VAR_TYPE_DICT; break; |
| 9846 | case VAR_FLOAT: n = VAR_TYPE_FLOAT; break; |
| 9847 | case VAR_BOOL: n = VAR_TYPE_BOOL; break; |
| 9848 | case VAR_SPECIAL: n = VAR_TYPE_NONE; break; |
Bram Moolenaar | f562e72 | 2016-07-19 17:25:25 +0200 | [diff] [blame] | 9849 | case VAR_JOB: n = VAR_TYPE_JOB; break; |
| 9850 | case VAR_CHANNEL: n = VAR_TYPE_CHANNEL; break; |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 9851 | case VAR_BLOB: n = VAR_TYPE_BLOB; break; |
Bram Moolenaar | f18332f | 2021-05-07 17:55:55 +0200 | [diff] [blame] | 9852 | case VAR_INSTR: n = VAR_TYPE_INSTR; break; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9853 | case VAR_UNKNOWN: |
Bram Moolenaar | 4c68375 | 2020-04-05 21:38:23 +0200 | [diff] [blame] | 9854 | case VAR_ANY: |
Bram Moolenaar | 8a7d654 | 2020-01-26 15:56:19 +0100 | [diff] [blame] | 9855 | case VAR_VOID: |
Bram Moolenaar | dd58923 | 2020-02-29 17:38:12 +0100 | [diff] [blame] | 9856 | internal_error_no_abort("f_type(UNKNOWN)"); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9857 | n = -1; |
| 9858 | break; |
| 9859 | } |
| 9860 | rettv->vval.v_number = n; |
| 9861 | } |
| 9862 | |
| 9863 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9864 | * "virtcol(string)" function |
| 9865 | */ |
| 9866 | static void |
| 9867 | f_virtcol(typval_T *argvars, typval_T *rettv) |
| 9868 | { |
| 9869 | colnr_T vcol = 0; |
| 9870 | pos_T *fp; |
| 9871 | int fnum = curbuf->b_fnum; |
Bram Moolenaar | b3d33d8 | 2020-01-15 20:36:55 +0100 | [diff] [blame] | 9872 | int len; |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9873 | |
Bram Moolenaar | 6f02b00 | 2021-01-10 20:22:54 +0100 | [diff] [blame] | 9874 | fp = var2fpos(&argvars[0], FALSE, &fnum, FALSE); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9875 | if (fp != NULL && fp->lnum <= curbuf->b_ml.ml_line_count |
| 9876 | && fnum == curbuf->b_fnum) |
| 9877 | { |
Bram Moolenaar | b3d33d8 | 2020-01-15 20:36:55 +0100 | [diff] [blame] | 9878 | // Limit the column to a valid value, getvvcol() doesn't check. |
| 9879 | if (fp->col < 0) |
| 9880 | fp->col = 0; |
| 9881 | else |
| 9882 | { |
| 9883 | len = (int)STRLEN(ml_get(fp->lnum)); |
| 9884 | if (fp->col > len) |
| 9885 | fp->col = len; |
| 9886 | } |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9887 | getvvcol(curwin, fp, NULL, NULL, &vcol); |
| 9888 | ++vcol; |
| 9889 | } |
| 9890 | |
| 9891 | rettv->vval.v_number = vcol; |
| 9892 | } |
| 9893 | |
| 9894 | /* |
| 9895 | * "visualmode()" function |
| 9896 | */ |
| 9897 | static void |
| 9898 | f_visualmode(typval_T *argvars, typval_T *rettv) |
| 9899 | { |
| 9900 | char_u str[2]; |
| 9901 | |
| 9902 | rettv->v_type = VAR_STRING; |
| 9903 | str[0] = curbuf->b_visual_mode_eval; |
| 9904 | str[1] = NUL; |
| 9905 | rettv->vval.v_string = vim_strsave(str); |
| 9906 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9907 | // A non-zero number or non-empty string argument: reset mode. |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9908 | if (non_zero_arg(&argvars[0])) |
| 9909 | curbuf->b_visual_mode_eval = NUL; |
| 9910 | } |
| 9911 | |
| 9912 | /* |
| 9913 | * "wildmenumode()" function |
| 9914 | */ |
| 9915 | static void |
| 9916 | f_wildmenumode(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 9917 | { |
| 9918 | #ifdef FEAT_WILDMENU |
| 9919 | if (wild_menu_showing) |
| 9920 | rettv->vval.v_number = 1; |
| 9921 | #endif |
| 9922 | } |
| 9923 | |
| 9924 | /* |
Bram Moolenaar | 0c1e374 | 2019-12-27 13:49:24 +0100 | [diff] [blame] | 9925 | * "windowsversion()" function |
| 9926 | */ |
| 9927 | static void |
| 9928 | f_windowsversion(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
| 9929 | { |
| 9930 | rettv->v_type = VAR_STRING; |
| 9931 | rettv->vval.v_string = vim_strsave((char_u *)windowsVersion); |
| 9932 | } |
| 9933 | |
| 9934 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9935 | * "wordcount()" function |
| 9936 | */ |
| 9937 | static void |
| 9938 | f_wordcount(typval_T *argvars UNUSED, typval_T *rettv) |
| 9939 | { |
| 9940 | if (rettv_dict_alloc(rettv) == FAIL) |
| 9941 | return; |
| 9942 | cursor_pos_info(rettv->vval.v_dict); |
| 9943 | } |
| 9944 | |
| 9945 | /* |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9946 | * "xor(expr, expr)" function |
| 9947 | */ |
| 9948 | static void |
| 9949 | f_xor(typval_T *argvars, typval_T *rettv) |
| 9950 | { |
Bram Moolenaar | d155d7a | 2018-12-21 16:04:21 +0100 | [diff] [blame] | 9951 | rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL) |
| 9952 | ^ tv_get_number_chk(&argvars[1], NULL); |
Bram Moolenaar | 73dad1e | 2016-07-17 22:13:49 +0200 | [diff] [blame] | 9953 | } |
| 9954 | |
Bram Moolenaar | 5d18efe | 2019-12-01 21:11:22 +0100 | [diff] [blame] | 9955 | #endif // FEAT_EVAL |