Mercurial > vim

comparison src/evalfunc.c @ 17986:5c8906f653f5 v8.1.1989

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
patch 8.1.1989: the evalfunc.c file is still too big Commit: https://github.com/vim/vim/commit/af7645d3733fdd3cd2df03ec7b653601d26969ef Author: Bram Moolenaar <Bram@vim.org> Date: Thu Sep 5 22:33:28 2019 +0200 patch 8.1.1989: the evalfunc.c file is still too big Problem: The evalfunc.c file is still too big. Solution: Move f_pathshorten() to filepath.c. Move f_cscope_connection() to if_cscope.c. Move diff_ functions to diff.c. Move timer_ functions to ex_cmds2.c. move callback functions to evalvars.c.
author Bram Moolenaar <Bram@vim.org>
date Thu, 05 Sep 2019 22:45:04 +0200
parents 2029737e6a22
children 0dcc2ee838dd
comparison
equal deleted inserted replaced
17985:9b43688b26bf 17986:5c8906f653f5
68 static void f_copy(typval_T *argvars, typval_T *rettv); 68 static void f_copy(typval_T *argvars, typval_T *rettv);
69 #ifdef FEAT_FLOAT 69 #ifdef FEAT_FLOAT
70 static void f_cos(typval_T *argvars, typval_T *rettv); 70 static void f_cos(typval_T *argvars, typval_T *rettv);
71 static void f_cosh(typval_T *argvars, typval_T *rettv); 71 static void f_cosh(typval_T *argvars, typval_T *rettv);
72 #endif 72 #endif
73 static void f_cscope_connection(typval_T *argvars, typval_T *rettv);
74 static void f_cursor(typval_T *argsvars, typval_T *rettv); 73 static void f_cursor(typval_T *argsvars, typval_T *rettv);
75 #ifdef MSWIN 74 #ifdef MSWIN
76 static void f_debugbreak(typval_T *argvars, typval_T *rettv); 75 static void f_debugbreak(typval_T *argvars, typval_T *rettv);
77 #endif 76 #endif
78 static void f_deepcopy(typval_T *argvars, typval_T *rettv); 77 static void f_deepcopy(typval_T *argvars, typval_T *rettv);
79 static void f_deletebufline(typval_T *argvars, typval_T *rettv); 78 static void f_deletebufline(typval_T *argvars, typval_T *rettv);
80 static void f_did_filetype(typval_T *argvars, typval_T *rettv); 79 static void f_did_filetype(typval_T *argvars, typval_T *rettv);
81 static void f_diff_filler(typval_T *argvars, typval_T *rettv);
82 static void f_diff_hlID(typval_T *argvars, typval_T *rettv);
83 static void f_empty(typval_T *argvars, typval_T *rettv); 80 static void f_empty(typval_T *argvars, typval_T *rettv);
84 static void f_environ(typval_T *argvars, typval_T *rettv); 81 static void f_environ(typval_T *argvars, typval_T *rettv);
85 static void f_escape(typval_T *argvars, typval_T *rettv); 82 static void f_escape(typval_T *argvars, typval_T *rettv);
86 static void f_eval(typval_T *argvars, typval_T *rettv); 83 static void f_eval(typval_T *argvars, typval_T *rettv);
87 static void f_eventhandler(typval_T *argvars, typval_T *rettv); 84 static void f_eventhandler(typval_T *argvars, typval_T *rettv);
176 static void f_mzeval(typval_T *argvars, typval_T *rettv); 173 static void f_mzeval(typval_T *argvars, typval_T *rettv);
177 #endif 174 #endif
178 static void f_nextnonblank(typval_T *argvars, typval_T *rettv); 175 static void f_nextnonblank(typval_T *argvars, typval_T *rettv);
179 static void f_nr2char(typval_T *argvars, typval_T *rettv); 176 static void f_nr2char(typval_T *argvars, typval_T *rettv);
180 static void f_or(typval_T *argvars, typval_T *rettv); 177 static void f_or(typval_T *argvars, typval_T *rettv);
181 static void f_pathshorten(typval_T *argvars, typval_T *rettv);
182 #ifdef FEAT_PERL 178 #ifdef FEAT_PERL
183 static void f_perleval(typval_T *argvars, typval_T *rettv); 179 static void f_perleval(typval_T *argvars, typval_T *rettv);
184 #endif 180 #endif
185 #ifdef FEAT_FLOAT 181 #ifdef FEAT_FLOAT
186 static void f_pow(typval_T *argvars, typval_T *rettv); 182 static void f_pow(typval_T *argvars, typval_T *rettv);
288 static void f_taglist(typval_T *argvars, typval_T *rettv); 284 static void f_taglist(typval_T *argvars, typval_T *rettv);
289 static void f_tagfiles(typval_T *argvars, typval_T *rettv); 285 static void f_tagfiles(typval_T *argvars, typval_T *rettv);
290 #ifdef FEAT_FLOAT 286 #ifdef FEAT_FLOAT
291 static void f_tan(typval_T *argvars, typval_T *rettv); 287 static void f_tan(typval_T *argvars, typval_T *rettv);
292 static void f_tanh(typval_T *argvars, typval_T *rettv); 288 static void f_tanh(typval_T *argvars, typval_T *rettv);
293 #endif
294 #ifdef FEAT_TIMERS
295 static void f_timer_info(typval_T *argvars, typval_T *rettv);
296 static void f_timer_pause(typval_T *argvars, typval_T *rettv);
297 static void f_timer_start(typval_T *argvars, typval_T *rettv);
298 static void f_timer_stop(typval_T *argvars, typval_T *rettv);
299 static void f_timer_stopall(typval_T *argvars, typval_T *rettv);
300 #endif 289 #endif
301 static void f_tolower(typval_T *argvars, typval_T *rettv); 290 static void f_tolower(typval_T *argvars, typval_T *rettv);
302 static void f_toupper(typval_T *argvars, typval_T *rettv); 291 static void f_toupper(typval_T *argvars, typval_T *rettv);
303 static void f_tr(typval_T *argvars, typval_T *rettv); 292 static void f_tr(typval_T *argvars, typval_T *rettv);
304 static void f_trim(typval_T *argvars, typval_T *rettv); 293 static void f_trim(typval_T *argvars, typval_T *rettv);
2093 rettv->vval.v_float = 0.0; 2082 rettv->vval.v_float = 0.0;
2094 } 2083 }
2095 #endif 2084 #endif
2096 2085
2097 /* 2086 /*
2098 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
2099 *
2100 * Checks the existence of a cscope connection.
2101 */
2102 static void
2103 f_cscope_connection(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2104 {
2105 #ifdef FEAT_CSCOPE
2106 int num = 0;
2107 char_u *dbpath = NULL;
2108 char_u *prepend = NULL;
2109 char_u buf[NUMBUFLEN];
2110
2111 if (argvars[0].v_type != VAR_UNKNOWN
2112 && argvars[1].v_type != VAR_UNKNOWN)
2113 {
2114 num = (int)tv_get_number(&argvars[0]);
2115 dbpath = tv_get_string(&argvars[1]);
2116 if (argvars[2].v_type != VAR_UNKNOWN)
2117 prepend = tv_get_string_buf(&argvars[2], buf);
2118 }
2119
2120 rettv->vval.v_number = cs_connection(num, dbpath, prepend);
2121 #endif
2122 }
2123
2124 /*
2125 * "cursor(lnum, col)" function, or 2087 * "cursor(lnum, col)" function, or
2126 * "cursor(list)" 2088 * "cursor(list)"
2127 * 2089 *
2128 * Moves the cursor to the specified line and column. 2090 * Moves the cursor to the specified line and column.
2129 * Returns 0 when the position could be set, -1 otherwise. 2091 * Returns 0 when the position could be set, -1 otherwise.
2317 */ 2279 */
2318 static void 2280 static void
2319 f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED) 2281 f_did_filetype(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2320 { 2282 {
2321 rettv->vval.v_number = did_filetype; 2283 rettv->vval.v_number = did_filetype;
2322 }
2323
2324 /*
2325 * "diff_filler()" function
2326 */
2327 static void
2328 f_diff_filler(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2329 {
2330 #ifdef FEAT_DIFF
2331 rettv->vval.v_number = diff_check_fill(curwin, tv_get_lnum(argvars));
2332 #endif
2333 }
2334
2335 /*
2336 * "diff_hlID()" function
2337 */
2338 static void
2339 f_diff_hlID(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
2340 {
2341 #ifdef FEAT_DIFF
2342 linenr_T lnum = tv_get_lnum(argvars);
2343 static linenr_T prev_lnum = 0;
2344 static varnumber_T changedtick = 0;
2345 static int fnum = 0;
2346 static int change_start = 0;
2347 static int change_end = 0;
2348 static hlf_T hlID = (hlf_T)0;
2349 int filler_lines;
2350 int col;
2351
2352 if (lnum < 0) /* ignore type error in {lnum} arg */
2353 lnum = 0;
2354 if (lnum != prev_lnum
2355 || changedtick != CHANGEDTICK(curbuf)
2356 || fnum != curbuf->b_fnum)
2357 {
2358 /* New line, buffer, change: need to get the values. */
2359 filler_lines = diff_check(curwin, lnum);
2360 if (filler_lines < 0)
2361 {
2362 if (filler_lines == -1)
2363 {
2364 change_start = MAXCOL;
2365 change_end = -1;
2366 if (diff_find_change(curwin, lnum, &change_start, &change_end))
2367 hlID = HLF_ADD; /* added line */
2368 else
2369 hlID = HLF_CHD; /* changed line */
2370 }
2371 else
2372 hlID = HLF_ADD; /* added line */
2373 }
2374 else
2375 hlID = (hlf_T)0;
2376 prev_lnum = lnum;
2377 changedtick = CHANGEDTICK(curbuf);
2378 fnum = curbuf->b_fnum;
2379 }
2380
2381 if (hlID == HLF_CHD || hlID == HLF_TXD)
2382 {
2383 col = tv_get_number(&argvars[1]) - 1; /* ignore type error in {col} */
2384 if (col >= change_start && col <= change_end)
2385 hlID = HLF_TXD; /* changed text */
2386 else
2387 hlID = HLF_CHD; /* changed line */
2388 }
2389 rettv->vval.v_number = hlID == (hlf_T)0 ? 0 : (int)hlID;
2390 #endif
2391 } 2284 }
2392 2285
2393 /* 2286 /*
2394 * "empty({expr})" function 2287 * "empty({expr})" function
2395 */ 2288 */
6356 { 6249 {
6357 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL) 6250 rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
6358 | tv_get_number_chk(&argvars[1], NULL); 6251 | tv_get_number_chk(&argvars[1], NULL);
6359 } 6252 }
6360 6253
6361 /*
6362 * "pathshorten()" function
6363 */
6364 static void
6365 f_pathshorten(typval_T *argvars, typval_T *rettv)
6366 {
6367 char_u *p;
6368
6369 rettv->v_type = VAR_STRING;
6370 p = tv_get_string_chk(&argvars[0]);
6371 if (p == NULL)
6372 rettv->vval.v_string = NULL;
6373 else
6374 {
6375 p = vim_strsave(p);
6376 rettv->vval.v_string = p;
6377 if (p != NULL)
6378 shorten_dir(p);
6379 }
6380 }
6381
6382 #ifdef FEAT_PERL 6254 #ifdef FEAT_PERL
6383 /* 6255 /*
6384 * "perleval()" function 6256 * "perleval()" function
6385 */ 6257 */
6386 static void 6258 static void
9471 rettv->vval.v_float = 0.0; 9343 rettv->vval.v_float = 0.0;
9472 } 9344 }
9473 #endif 9345 #endif
9474 9346
9475 /* 9347 /*
9476 * Get a callback from "arg". It can be a Funcref or a function name.
9477 * When "arg" is zero return an empty string.
9478 * "cb_name" is not allocated.
9479 * "cb_name" is set to NULL for an invalid argument.
9480 */
9481 callback_T
9482 get_callback(typval_T *arg)
9483 {
9484 callback_T res;
9485
9486 res.cb_free_name = FALSE;
9487 if (arg->v_type == VAR_PARTIAL && arg->vval.v_partial != NULL)
9488 {
9489 res.cb_partial = arg->vval.v_partial;
9490 ++res.cb_partial->pt_refcount;
9491 res.cb_name = partial_name(res.cb_partial);
9492 }
9493 else
9494 {
9495 res.cb_partial = NULL;
9496 if (arg->v_type == VAR_FUNC || arg->v_type == VAR_STRING)
9497 {
9498 // Note that we don't make a copy of the string.
9499 res.cb_name = arg->vval.v_string;
9500 func_ref(res.cb_name);
9501 }
9502 else if (arg->v_type == VAR_NUMBER && arg->vval.v_number == 0)
9503 {
9504 res.cb_name = (char_u *)"";
9505 }
9506 else
9507 {
9508 emsg(_("E921: Invalid callback argument"));
9509 res.cb_name = NULL;
9510 }
9511 }
9512 return res;
9513 }
9514
9515 /*
9516 * Copy a callback into a typval_T.
9517 */
9518 void
9519 put_callback(callback_T *cb, typval_T *tv)
9520 {
9521 if (cb->cb_partial != NULL)
9522 {
9523 tv->v_type = VAR_PARTIAL;
9524 tv->vval.v_partial = cb->cb_partial;
9525 ++tv->vval.v_partial->pt_refcount;
9526 }
9527 else
9528 {
9529 tv->v_type = VAR_FUNC;
9530 tv->vval.v_string = vim_strsave(cb->cb_name);
9531 func_ref(cb->cb_name);
9532 }
9533 }
9534
9535 /*
9536 * Make a copy of "src" into "dest", allocating the function name if needed,
9537 * without incrementing the refcount.
9538 */
9539 void
9540 set_callback(callback_T *dest, callback_T *src)
9541 {
9542 if (src->cb_partial == NULL)
9543 {
9544 // just a function name, make a copy
9545 dest->cb_name = vim_strsave(src->cb_name);
9546 dest->cb_free_name = TRUE;
9547 }
9548 else
9549 {
9550 // cb_name is a pointer into cb_partial
9551 dest->cb_name = src->cb_name;
9552 dest->cb_free_name = FALSE;
9553 }
9554 dest->cb_partial = src->cb_partial;
9555 }
9556
9557 /*
9558 * Unref/free "callback" returned by get_callback() or set_callback().
9559 */
9560 void
9561 free_callback(callback_T *callback)
9562 {
9563 if (callback->cb_partial != NULL)
9564 {
9565 partial_unref(callback->cb_partial);
9566 callback->cb_partial = NULL;
9567 }
9568 else if (callback->cb_name != NULL)
9569 func_unref(callback->cb_name);
9570 if (callback->cb_free_name)
9571 {
9572 vim_free(callback->cb_name);
9573 callback->cb_free_name = FALSE;
9574 }
9575 callback->cb_name = NULL;
9576 }
9577
9578 #ifdef FEAT_TIMERS
9579 /*
9580 * "timer_info([timer])" function
9581 */
9582 static void
9583 f_timer_info(typval_T *argvars, typval_T *rettv)
9584 {
9585 timer_T *timer = NULL;
9586
9587 if (rettv_list_alloc(rettv) != OK)
9588 return;
9589 if (argvars[0].v_type != VAR_UNKNOWN)
9590 {
9591 if (argvars[0].v_type != VAR_NUMBER)
9592 emsg(_(e_number_exp));
9593 else
9594 {
9595 timer = find_timer((int)tv_get_number(&argvars[0]));
9596 if (timer != NULL)
9597 add_timer_info(rettv, timer);
9598 }
9599 }
9600 else
9601 add_timer_info_all(rettv);
9602 }
9603
9604 /*
9605 * "timer_pause(timer, paused)" function
9606 */
9607 static void
9608 f_timer_pause(typval_T *argvars, typval_T *rettv UNUSED)
9609 {
9610 timer_T *timer = NULL;
9611 int paused = (int)tv_get_number(&argvars[1]);
9612
9613 if (argvars[0].v_type != VAR_NUMBER)
9614 emsg(_(e_number_exp));
9615 else
9616 {
9617 timer = find_timer((int)tv_get_number(&argvars[0]));
9618 if (timer != NULL)
9619 timer->tr_paused = paused;
9620 }
9621 }
9622
9623 /*
9624 * "timer_start(time, callback [, options])" function
9625 */
9626 static void
9627 f_timer_start(typval_T *argvars, typval_T *rettv)
9628 {
9629 long msec = (long)tv_get_number(&argvars[0]);
9630 timer_T *timer;
9631 int repeat = 0;
9632 callback_T callback;
9633 dict_T *dict;
9634
9635 rettv->vval.v_number = -1;
9636 if (check_secure())
9637 return;
9638 if (argvars[2].v_type != VAR_UNKNOWN)
9639 {
9640 if (argvars[2].v_type != VAR_DICT
9641 || (dict = argvars[2].vval.v_dict) == NULL)
9642 {
9643 semsg(_(e_invarg2), tv_get_string(&argvars[2]));
9644 return;
9645 }
9646 if (dict_find(dict, (char_u *)"repeat", -1) != NULL)
9647 repeat = dict_get_number(dict, (char_u *)"repeat");
9648 }
9649
9650 callback = get_callback(&argvars[1]);
9651 if (callback.cb_name == NULL)
9652 return;
9653
9654 timer = create_timer(msec, repeat);
9655 if (timer == NULL)
9656 free_callback(&callback);
9657 else
9658 {
9659 set_callback(&timer->tr_callback, &callback);
9660 rettv->vval.v_number = (varnumber_T)timer->tr_id;
9661 }
9662 }
9663
9664 /*
9665 * "timer_stop(timer)" function
9666 */
9667 static void
9668 f_timer_stop(typval_T *argvars, typval_T *rettv UNUSED)
9669 {
9670 timer_T *timer;
9671
9672 if (argvars[0].v_type != VAR_NUMBER)
9673 {
9674 emsg(_(e_number_exp));
9675 return;
9676 }
9677 timer = find_timer((int)tv_get_number(&argvars[0]));
9678 if (timer != NULL)
9679 stop_timer(timer);
9680 }
9681
9682 /*
9683 * "timer_stopall()" function
9684 */
9685 static void
9686 f_timer_stopall(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
9687 {
9688 stop_all_timers();
9689 }
9690 #endif
9691
9692 /*
9693 * "tolower(string)" function 9348 * "tolower(string)" function
9694 */ 9349 */
9695 static void 9350 static void
9696 f_tolower(typval_T *argvars, typval_T *rettv) 9351 f_tolower(typval_T *argvars, typval_T *rettv)
9697 { 9352 {