1 /* vi:set ts=8 sts=4 sw=4 noet: 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 * userfunc.c: User defined function support 12 */ 13 14 #include "vim.h" 15 16 #if defined(FEAT_EVAL) || defined(PROTO) 17 /* 18 * All user-defined functions are found in this hashtable. 19 */ 20 static hashtab_T func_hashtab; 21 22 // Used by get_func_tv() 23 static garray_T funcargs = GA_EMPTY; 24 25 // pointer to funccal for currently active function 26 static funccall_T *current_funccal = NULL; 27 28 // Pointer to list of previously used funccal, still around because some 29 // item in it is still being used. 30 static funccall_T *previous_funccal = NULL; 31 32 static char *e_funcexts = N_("E122: Function %s already exists, add ! to replace it"); 33 static char *e_funcdict = N_("E717: Dictionary entry already exists"); 34 static char *e_funcref = N_("E718: Funcref required"); 35 static char *e_nofunc = N_("E130: Unknown function: %s"); 36 37 static void funccal_unref(funccall_T *fc, ufunc_T *fp, int force); 38 39 void 40 func_init() 41 { 42 hash_init(&func_hashtab); 43 } 44 45 /* 46 * Return the function hash table 47 */ 48 hashtab_T * 49 func_tbl_get(void) 50 { 51 return &func_hashtab; 52 } 53 54 /* 55 * Get one function argument. 56 * If "argtypes" is not NULL also get the type: "arg: type". 57 * Return a pointer to after the type. 58 * When something is wrong return "arg". 59 */ 60 static char_u * 61 one_function_arg(char_u *arg, garray_T *newargs, garray_T *argtypes, int skip) 62 { 63 char_u *p = arg; 64 char_u *arg_copy = NULL; 65 66 while (ASCII_ISALNUM(*p) || *p == '_') 67 ++p; 68 if (arg == p || isdigit(*arg) 69 || (p - arg == 9 && STRNCMP(arg, "firstline", 9) == 0) 70 || (p - arg == 8 && STRNCMP(arg, "lastline", 8) == 0)) 71 { 72 if (!skip) 73 semsg(_("E125: Illegal argument: %s"), arg); 74 return arg; 75 } 76 if (newargs != NULL && ga_grow(newargs, 1) == FAIL) 77 return arg; 78 if (newargs != NULL) 79 { 80 int c; 81 int i; 82 83 c = *p; 84 *p = NUL; 85 arg_copy = vim_strsave(arg); 86 if (arg_copy == NULL) 87 { 88 *p = c; 89 return arg; 90 } 91 92 // Check for duplicate argument name. 93 for (i = 0; i < newargs->ga_len; ++i) 94 if (STRCMP(((char_u **)(newargs->ga_data))[i], arg_copy) == 0) 95 { 96 semsg(_("E853: Duplicate argument name: %s"), arg_copy); 97 vim_free(arg_copy); 98 return arg; 99 } 100 ((char_u **)(newargs->ga_data))[newargs->ga_len] = arg_copy; 101 newargs->ga_len++; 102 103 *p = c; 104 } 105 106 // get any type from "arg: type" 107 if (argtypes != NULL && ga_grow(argtypes, 1) == OK) 108 { 109 char_u *type = NULL; 110 111 if (VIM_ISWHITE(*p) && *skipwhite(p) == ':') 112 { 113 semsg(_(e_no_white_space_allowed_before_colon_str), 114 arg_copy == NULL ? arg : arg_copy); 115 p = skipwhite(p); 116 } 117 if (*p == ':') 118 { 119 ++p; 120 if (!VIM_ISWHITE(*p)) 121 { 122 semsg(_(e_white_space_required_after), ":"); 123 return arg; 124 } 125 type = skipwhite(p); 126 p = skip_type(type, TRUE); 127 type = vim_strnsave(type, p - type); 128 } 129 else if (*skipwhite(p) != '=') 130 { 131 semsg(_(e_missing_argument_type_for_str), 132 arg_copy == NULL ? arg : arg_copy); 133 return arg; 134 } 135 ((char_u **)argtypes->ga_data)[argtypes->ga_len++] = type; 136 } 137 138 return p; 139 } 140 141 /* 142 * Get function arguments. 143 */ 144 int 145 get_function_args( 146 char_u **argp, 147 char_u endchar, 148 garray_T *newargs, 149 garray_T *argtypes, // NULL unless using :def 150 int *varargs, 151 garray_T *default_args, 152 int skip, 153 exarg_T *eap, 154 char_u **line_to_free) 155 { 156 int mustend = FALSE; 157 char_u *arg = *argp; 158 char_u *p = arg; 159 int c; 160 int any_default = FALSE; 161 char_u *expr; 162 char_u *whitep = arg; 163 164 if (newargs != NULL) 165 ga_init2(newargs, (int)sizeof(char_u *), 3); 166 if (argtypes != NULL) 167 ga_init2(argtypes, (int)sizeof(char_u *), 3); 168 if (default_args != NULL) 169 ga_init2(default_args, (int)sizeof(char_u *), 3); 170 171 if (varargs != NULL) 172 *varargs = FALSE; 173 174 /* 175 * Isolate the arguments: "arg1, arg2, ...)" 176 */ 177 while (*p != endchar) 178 { 179 while (eap != NULL && eap->getline != NULL 180 && (*p == NUL || (VIM_ISWHITE(*whitep) && *p == '#'))) 181 { 182 char_u *theline; 183 184 // End of the line, get the next one. 185 theline = eap->getline(':', eap->cookie, 0, TRUE); 186 if (theline == NULL) 187 break; 188 vim_free(*line_to_free); 189 *line_to_free = theline; 190 whitep = (char_u *)" "; 191 p = skipwhite(theline); 192 } 193 194 if (mustend && *p != endchar) 195 { 196 if (!skip) 197 semsg(_(e_invarg2), *argp); 198 break; 199 } 200 if (*p == endchar) 201 break; 202 203 if (p[0] == '.' && p[1] == '.' && p[2] == '.') 204 { 205 if (varargs != NULL) 206 *varargs = TRUE; 207 p += 3; 208 mustend = TRUE; 209 210 if (argtypes != NULL) 211 { 212 // ...name: list<type> 213 if (!ASCII_ISALPHA(*p)) 214 { 215 emsg(_(e_missing_name_after_dots)); 216 break; 217 } 218 219 arg = p; 220 p = one_function_arg(p, newargs, argtypes, skip); 221 if (p == arg) 222 break; 223 } 224 } 225 else 226 { 227 arg = p; 228 p = one_function_arg(p, newargs, argtypes, skip); 229 if (p == arg) 230 break; 231 232 if (*skipwhite(p) == '=' && default_args != NULL) 233 { 234 typval_T rettv; 235 236 // find the end of the expression (doesn't evaluate it) 237 any_default = TRUE; 238 p = skipwhite(p) + 1; 239 whitep = p; 240 p = skipwhite(p); 241 expr = p; 242 if (eval1(&p, &rettv, NULL) != FAIL) 243 { 244 if (ga_grow(default_args, 1) == FAIL) 245 goto err_ret; 246 247 // trim trailing whitespace 248 while (p > expr && VIM_ISWHITE(p[-1])) 249 p--; 250 c = *p; 251 *p = NUL; 252 expr = vim_strsave(expr); 253 if (expr == NULL) 254 { 255 *p = c; 256 goto err_ret; 257 } 258 ((char_u **)(default_args->ga_data)) 259 [default_args->ga_len] = expr; 260 default_args->ga_len++; 261 *p = c; 262 } 263 else 264 mustend = TRUE; 265 } 266 else if (any_default) 267 { 268 emsg(_("E989: Non-default argument follows default argument")); 269 goto err_ret; 270 } 271 if (*p == ',') 272 { 273 ++p; 274 // Don't give this error when skipping, it makes the "->" not 275 // found in "{k,v -> x}" and give a confusing error. 276 if (!skip && in_vim9script() 277 && !IS_WHITE_OR_NUL(*p) && *p != endchar) 278 { 279 semsg(_(e_white_space_required_after), ","); 280 goto err_ret; 281 } 282 } 283 else 284 mustend = TRUE; 285 } 286 whitep = p; 287 p = skipwhite(p); 288 } 289 290 if (*p != endchar) 291 goto err_ret; 292 ++p; // skip "endchar" 293 294 *argp = p; 295 return OK; 296 297 err_ret: 298 if (newargs != NULL) 299 ga_clear_strings(newargs); 300 if (default_args != NULL) 301 ga_clear_strings(default_args); 302 return FAIL; 303 } 304 305 /* 306 * Register function "fp" as using "current_funccal" as its scope. 307 */ 308 static int 309 register_closure(ufunc_T *fp) 310 { 311 if (fp->uf_scoped == current_funccal) 312 // no change 313 return OK; 314 funccal_unref(fp->uf_scoped, fp, FALSE); 315 fp->uf_scoped = current_funccal; 316 current_funccal->fc_refcount++; 317 318 if (ga_grow(¤t_funccal->fc_funcs, 1) == FAIL) 319 return FAIL; 320 ((ufunc_T **)current_funccal->fc_funcs.ga_data) 321 [current_funccal->fc_funcs.ga_len++] = fp; 322 return OK; 323 } 324 325 static void 326 set_ufunc_name(ufunc_T *fp, char_u *name) 327 { 328 STRCPY(fp->uf_name, name); 329 330 if (name[0] == K_SPECIAL) 331 { 332 fp->uf_name_exp = alloc(STRLEN(name) + 3); 333 if (fp->uf_name_exp != NULL) 334 { 335 STRCPY(fp->uf_name_exp, "<SNR>"); 336 STRCAT(fp->uf_name_exp, fp->uf_name + 3); 337 } 338 } 339 } 340 341 /* 342 * Get a name for a lambda. Returned in static memory. 343 */ 344 char_u * 345 get_lambda_name(void) 346 { 347 static char_u name[30]; 348 static int lambda_no = 0; 349 350 sprintf((char*)name, "<lambda>%d", ++lambda_no); 351 return name; 352 } 353 354 #if defined(FEAT_LUA) || defined(PROTO) 355 /* 356 * Registers a native C callback which can be called from Vim script. 357 * Returns the name of the Vim script function. 358 */ 359 char_u * 360 register_cfunc(cfunc_T cb, cfunc_free_T cb_free, void *state) 361 { 362 char_u *name = get_lambda_name(); 363 ufunc_T *fp; 364 365 fp = alloc_clear(offsetof(ufunc_T, uf_name) + STRLEN(name) + 1); 366 if (fp == NULL) 367 return NULL; 368 369 fp->uf_def_status = UF_NOT_COMPILED; 370 fp->uf_refcount = 1; 371 fp->uf_varargs = TRUE; 372 fp->uf_flags = FC_CFUNC; 373 fp->uf_calls = 0; 374 fp->uf_script_ctx = current_sctx; 375 fp->uf_cb = cb; 376 fp->uf_cb_free = cb_free; 377 fp->uf_cb_state = state; 378 379 set_ufunc_name(fp, name); 380 hash_add(&func_hashtab, UF2HIKEY(fp)); 381 382 return name; 383 } 384 #endif 385 386 /* 387 * Parse a lambda expression and get a Funcref from "*arg". 388 * Return OK or FAIL. Returns NOTDONE for dict or {expr}. 389 */ 390 int 391 get_lambda_tv(char_u **arg, typval_T *rettv, evalarg_T *evalarg) 392 { 393 int evaluate = evalarg != NULL 394 && (evalarg->eval_flags & EVAL_EVALUATE); 395 garray_T newargs; 396 garray_T newlines; 397 garray_T *pnewargs; 398 ufunc_T *fp = NULL; 399 partial_T *pt = NULL; 400 int varargs; 401 int ret; 402 char_u *s; 403 char_u *start, *end; 404 int *old_eval_lavars = eval_lavars_used; 405 int eval_lavars = FALSE; 406 char_u *tofree = NULL; 407 408 ga_init(&newargs); 409 ga_init(&newlines); 410 411 // First, check if this is a lambda expression. "->" must exist. 412 s = skipwhite(*arg + 1); 413 ret = get_function_args(&s, '-', NULL, NULL, NULL, NULL, TRUE, 414 NULL, NULL); 415 if (ret == FAIL || *s != '>') 416 return NOTDONE; 417 418 // Parse the arguments again. 419 if (evaluate) 420 pnewargs = &newargs; 421 else 422 pnewargs = NULL; 423 *arg = skipwhite(*arg + 1); 424 // TODO: argument types 425 ret = get_function_args(arg, '-', pnewargs, NULL, &varargs, NULL, FALSE, 426 NULL, NULL); 427 if (ret == FAIL || **arg != '>') 428 goto errret; 429 430 // Set up a flag for checking local variables and arguments. 431 if (evaluate) 432 eval_lavars_used = &eval_lavars; 433 434 // Get the start and the end of the expression. 435 *arg = skipwhite_and_linebreak(*arg + 1, evalarg); 436 start = *arg; 437 ret = skip_expr_concatenate(arg, &start, &end, evalarg); 438 if (ret == FAIL) 439 goto errret; 440 if (evalarg != NULL) 441 { 442 // avoid that the expression gets freed when another line break follows 443 tofree = evalarg->eval_tofree; 444 evalarg->eval_tofree = NULL; 445 } 446 447 *arg = skipwhite_and_linebreak(*arg, evalarg); 448 if (**arg != '}') 449 { 450 semsg(_("E451: Expected }: %s"), *arg); 451 goto errret; 452 } 453 ++*arg; 454 455 if (evaluate) 456 { 457 int len; 458 int flags = 0; 459 char_u *p; 460 char_u *name = get_lambda_name(); 461 462 fp = alloc_clear(offsetof(ufunc_T, uf_name) + STRLEN(name) + 1); 463 if (fp == NULL) 464 goto errret; 465 fp->uf_def_status = UF_NOT_COMPILED; 466 pt = ALLOC_CLEAR_ONE(partial_T); 467 if (pt == NULL) 468 goto errret; 469 470 ga_init2(&newlines, (int)sizeof(char_u *), 1); 471 if (ga_grow(&newlines, 1) == FAIL) 472 goto errret; 473 474 // Add "return " before the expression. 475 len = 7 + (int)(end - start) + 1; 476 p = alloc(len); 477 if (p == NULL) 478 goto errret; 479 ((char_u **)(newlines.ga_data))[newlines.ga_len++] = p; 480 STRCPY(p, "return "); 481 vim_strncpy(p + 7, start, end - start); 482 if (strstr((char *)p + 7, "a:") == NULL) 483 // No a: variables are used for sure. 484 flags |= FC_NOARGS; 485 486 fp->uf_refcount = 1; 487 set_ufunc_name(fp, name); 488 hash_add(&func_hashtab, UF2HIKEY(fp)); 489 fp->uf_args = newargs; 490 ga_init(&fp->uf_def_args); 491 fp->uf_lines = newlines; 492 if (current_funccal != NULL && eval_lavars) 493 { 494 flags |= FC_CLOSURE; 495 if (register_closure(fp) == FAIL) 496 goto errret; 497 } 498 else 499 fp->uf_scoped = NULL; 500 501 #ifdef FEAT_PROFILE 502 if (prof_def_func()) 503 func_do_profile(fp); 504 #endif 505 if (sandbox) 506 flags |= FC_SANDBOX; 507 // can be called with more args than uf_args.ga_len 508 fp->uf_varargs = TRUE; 509 fp->uf_flags = flags; 510 fp->uf_calls = 0; 511 fp->uf_script_ctx = current_sctx; 512 fp->uf_script_ctx.sc_lnum += SOURCING_LNUM - newlines.ga_len; 513 514 pt->pt_func = fp; 515 pt->pt_refcount = 1; 516 rettv->vval.v_partial = pt; 517 rettv->v_type = VAR_PARTIAL; 518 } 519 520 eval_lavars_used = old_eval_lavars; 521 if (evalarg != NULL && evalarg->eval_tofree == NULL) 522 evalarg->eval_tofree = tofree; 523 else 524 vim_free(tofree); 525 return OK; 526 527 errret: 528 ga_clear_strings(&newargs); 529 ga_clear_strings(&newlines); 530 vim_free(fp); 531 vim_free(pt); 532 if (evalarg != NULL && evalarg->eval_tofree == NULL) 533 evalarg->eval_tofree = tofree; 534 else 535 vim_free(tofree); 536 eval_lavars_used = old_eval_lavars; 537 return FAIL; 538 } 539 540 /* 541 * Check if "name" is a variable of type VAR_FUNC. If so, return the function 542 * name it contains, otherwise return "name". 543 * If "partialp" is not NULL, and "name" is of type VAR_PARTIAL also set 544 * "partialp". 545 */ 546 char_u * 547 deref_func_name(char_u *name, int *lenp, partial_T **partialp, int no_autoload) 548 { 549 dictitem_T *v; 550 int cc; 551 char_u *s; 552 553 if (partialp != NULL) 554 *partialp = NULL; 555 556 cc = name[*lenp]; 557 name[*lenp] = NUL; 558 v = find_var(name, NULL, no_autoload); 559 name[*lenp] = cc; 560 if (v != NULL && v->di_tv.v_type == VAR_FUNC) 561 { 562 if (v->di_tv.vval.v_string == NULL) 563 { 564 *lenp = 0; 565 return (char_u *)""; // just in case 566 } 567 s = v->di_tv.vval.v_string; 568 *lenp = (int)STRLEN(s); 569 return s; 570 } 571 572 if (v != NULL && v->di_tv.v_type == VAR_PARTIAL) 573 { 574 partial_T *pt = v->di_tv.vval.v_partial; 575 576 if (pt == NULL) 577 { 578 *lenp = 0; 579 return (char_u *)""; // just in case 580 } 581 if (partialp != NULL) 582 *partialp = pt; 583 s = partial_name(pt); 584 *lenp = (int)STRLEN(s); 585 return s; 586 } 587 588 return name; 589 } 590 591 /* 592 * Give an error message with a function name. Handle <SNR> things. 593 * "ermsg" is to be passed without translation, use N_() instead of _(). 594 */ 595 void 596 emsg_funcname(char *ermsg, char_u *name) 597 { 598 char_u *p; 599 600 if (*name == K_SPECIAL) 601 p = concat_str((char_u *)"<SNR>", name + 3); 602 else 603 p = name; 604 semsg(_(ermsg), p); 605 if (p != name) 606 vim_free(p); 607 } 608 609 /* 610 * Allocate a variable for the result of a function. 611 * Return OK or FAIL. 612 */ 613 int 614 get_func_tv( 615 char_u *name, // name of the function 616 int len, // length of "name" or -1 to use strlen() 617 typval_T *rettv, 618 char_u **arg, // argument, pointing to the '(' 619 evalarg_T *evalarg, // for line continuation 620 funcexe_T *funcexe) // various values 621 { 622 char_u *argp; 623 int ret = OK; 624 typval_T argvars[MAX_FUNC_ARGS + 1]; // vars for arguments 625 int argcount = 0; // number of arguments found 626 627 /* 628 * Get the arguments. 629 */ 630 argp = *arg; 631 while (argcount < MAX_FUNC_ARGS - (funcexe->partial == NULL ? 0 632 : funcexe->partial->pt_argc)) 633 { 634 // skip the '(' or ',' and possibly line breaks 635 argp = skipwhite_and_linebreak(argp + 1, evalarg); 636 637 if (*argp == ')' || *argp == ',' || *argp == NUL) 638 break; 639 if (eval1(&argp, &argvars[argcount], evalarg) == FAIL) 640 { 641 ret = FAIL; 642 break; 643 } 644 ++argcount; 645 // The comma should come right after the argument, but this wasn't 646 // checked previously, thus only enforce it in Vim9 script. 647 if (!in_vim9script()) 648 argp = skipwhite(argp); 649 if (*argp != ',') 650 break; 651 } 652 argp = skipwhite_and_linebreak(argp, evalarg); 653 if (*argp == ')') 654 ++argp; 655 else 656 ret = FAIL; 657 658 if (ret == OK) 659 { 660 int i = 0; 661 662 if (get_vim_var_nr(VV_TESTING)) 663 { 664 // Prepare for calling test_garbagecollect_now(), need to know 665 // what variables are used on the call stack. 666 if (funcargs.ga_itemsize == 0) 667 ga_init2(&funcargs, (int)sizeof(typval_T *), 50); 668 for (i = 0; i < argcount; ++i) 669 if (ga_grow(&funcargs, 1) == OK) 670 ((typval_T **)funcargs.ga_data)[funcargs.ga_len++] = 671 &argvars[i]; 672 } 673 674 ret = call_func(name, len, rettv, argcount, argvars, funcexe); 675 676 funcargs.ga_len -= i; 677 } 678 else if (!aborting()) 679 { 680 if (argcount == MAX_FUNC_ARGS) 681 emsg_funcname(N_("E740: Too many arguments for function %s"), name); 682 else 683 emsg_funcname(N_("E116: Invalid arguments for function %s"), name); 684 } 685 686 while (--argcount >= 0) 687 clear_tv(&argvars[argcount]); 688 689 if (in_vim9script()) 690 *arg = argp; 691 else 692 *arg = skipwhite(argp); 693 return ret; 694 } 695 696 /* 697 * Return TRUE if "p" starts with "<SID>" or "s:". 698 * Only works if eval_fname_script() returned non-zero for "p"! 699 */ 700 static int 701 eval_fname_sid(char_u *p) 702 { 703 return (*p == 's' || TOUPPER_ASC(p[2]) == 'I'); 704 } 705 706 /* 707 * In a script change <SID>name() and s:name() to K_SNR 123_name(). 708 * Change <SNR>123_name() to K_SNR 123_name(). 709 * Use "fname_buf[FLEN_FIXED + 1]" when it fits, otherwise allocate memory 710 * (slow). 711 */ 712 char_u * 713 fname_trans_sid(char_u *name, char_u *fname_buf, char_u **tofree, int *error) 714 { 715 int llen; 716 char_u *fname; 717 int i; 718 719 llen = eval_fname_script(name); 720 if (llen > 0) 721 { 722 fname_buf[0] = K_SPECIAL; 723 fname_buf[1] = KS_EXTRA; 724 fname_buf[2] = (int)KE_SNR; 725 i = 3; 726 if (eval_fname_sid(name)) // "<SID>" or "s:" 727 { 728 if (current_sctx.sc_sid <= 0) 729 *error = FCERR_SCRIPT; 730 else 731 { 732 sprintf((char *)fname_buf + 3, "%ld_", 733 (long)current_sctx.sc_sid); 734 i = (int)STRLEN(fname_buf); 735 } 736 } 737 if (i + STRLEN(name + llen) < FLEN_FIXED) 738 { 739 STRCPY(fname_buf + i, name + llen); 740 fname = fname_buf; 741 } 742 else 743 { 744 fname = alloc(i + STRLEN(name + llen) + 1); 745 if (fname == NULL) 746 *error = FCERR_OTHER; 747 else 748 { 749 *tofree = fname; 750 mch_memmove(fname, fname_buf, (size_t)i); 751 STRCPY(fname + i, name + llen); 752 } 753 } 754 } 755 else 756 fname = name; 757 return fname; 758 } 759 760 /* 761 * Find a function "name" in script "sid". 762 */ 763 static ufunc_T * 764 find_func_with_sid(char_u *name, int sid) 765 { 766 hashitem_T *hi; 767 char_u buffer[200]; 768 769 buffer[0] = K_SPECIAL; 770 buffer[1] = KS_EXTRA; 771 buffer[2] = (int)KE_SNR; 772 vim_snprintf((char *)buffer + 3, sizeof(buffer) - 3, "%ld_%s", 773 (long)sid, name); 774 hi = hash_find(&func_hashtab, buffer); 775 if (!HASHITEM_EMPTY(hi)) 776 return HI2UF(hi); 777 778 return NULL; 779 } 780 781 /* 782 * Find a function by name, return pointer to it in ufuncs. 783 * When "is_global" is true don't find script-local or imported functions. 784 * Return NULL for unknown function. 785 */ 786 ufunc_T * 787 find_func_even_dead(char_u *name, int is_global, cctx_T *cctx) 788 { 789 hashitem_T *hi; 790 ufunc_T *func; 791 imported_T *imported; 792 793 if (!is_global) 794 { 795 int vim9script = in_vim9script(); 796 char_u *after_script = NULL; 797 long sid = 0; 798 799 if (vim9script) 800 { 801 // Find script-local function before global one. 802 func = find_func_with_sid(name, current_sctx.sc_sid); 803 if (func != NULL) 804 return func; 805 } 806 807 if (name[0] == K_SPECIAL 808 && name[1] == KS_EXTRA 809 && name[2] == KE_SNR) 810 { 811 // Caller changes s: to <SNR>99_name. 812 813 after_script = name + 3; 814 sid = getdigits(&after_script); 815 if (*after_script == '_') 816 ++after_script; 817 else 818 after_script = NULL; 819 } 820 if (vim9script || after_script != NULL) 821 { 822 // Find imported function before global one. 823 if (after_script != NULL && sid != current_sctx.sc_sid) 824 imported = find_imported_in_script(after_script, 0, sid); 825 else 826 imported = find_imported(after_script == NULL 827 ? name : after_script, 0, cctx); 828 if (imported != NULL && imported->imp_funcname != NULL) 829 { 830 hi = hash_find(&func_hashtab, imported->imp_funcname); 831 if (!HASHITEM_EMPTY(hi)) 832 return HI2UF(hi); 833 } 834 } 835 } 836 837 hi = hash_find(&func_hashtab, 838 STRNCMP(name, "g:", 2) == 0 ? name + 2 : name); 839 if (!HASHITEM_EMPTY(hi)) 840 return HI2UF(hi); 841 842 return NULL; 843 } 844 845 /* 846 * Find a function by name, return pointer to it in ufuncs. 847 * "cctx" is passed in a :def function to find imported functions. 848 * Return NULL for unknown or dead function. 849 */ 850 ufunc_T * 851 find_func(char_u *name, int is_global, cctx_T *cctx) 852 { 853 ufunc_T *fp = find_func_even_dead(name, is_global, cctx); 854 855 if (fp != NULL && (fp->uf_flags & FC_DEAD) == 0) 856 return fp; 857 return NULL; 858 } 859 860 /* 861 * Copy the function name of "fp" to buffer "buf". 862 * "buf" must be able to hold the function name plus three bytes. 863 * Takes care of script-local function names. 864 */ 865 static void 866 cat_func_name(char_u *buf, ufunc_T *fp) 867 { 868 if (fp->uf_name[0] == K_SPECIAL) 869 { 870 STRCPY(buf, "<SNR>"); 871 STRCAT(buf, fp->uf_name + 3); 872 } 873 else 874 STRCPY(buf, fp->uf_name); 875 } 876 877 /* 878 * Add a number variable "name" to dict "dp" with value "nr". 879 */ 880 static void 881 add_nr_var( 882 dict_T *dp, 883 dictitem_T *v, 884 char *name, 885 varnumber_T nr) 886 { 887 STRCPY(v->di_key, name); 888 v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; 889 hash_add(&dp->dv_hashtab, DI2HIKEY(v)); 890 v->di_tv.v_type = VAR_NUMBER; 891 v->di_tv.v_lock = VAR_FIXED; 892 v->di_tv.vval.v_number = nr; 893 } 894 895 /* 896 * Free "fc". 897 */ 898 static void 899 free_funccal(funccall_T *fc) 900 { 901 int i; 902 903 for (i = 0; i < fc->fc_funcs.ga_len; ++i) 904 { 905 ufunc_T *fp = ((ufunc_T **)(fc->fc_funcs.ga_data))[i]; 906 907 // When garbage collecting a funccall_T may be freed before the 908 // function that references it, clear its uf_scoped field. 909 // The function may have been redefined and point to another 910 // funccall_T, don't clear it then. 911 if (fp != NULL && fp->uf_scoped == fc) 912 fp->uf_scoped = NULL; 913 } 914 ga_clear(&fc->fc_funcs); 915 916 func_ptr_unref(fc->func); 917 vim_free(fc); 918 } 919 920 /* 921 * Free "fc" and what it contains. 922 * Can be called only when "fc" is kept beyond the period of it called, 923 * i.e. after cleanup_function_call(fc). 924 */ 925 static void 926 free_funccal_contents(funccall_T *fc) 927 { 928 listitem_T *li; 929 930 // Free all l: variables. 931 vars_clear(&fc->l_vars.dv_hashtab); 932 933 // Free all a: variables. 934 vars_clear(&fc->l_avars.dv_hashtab); 935 936 // Free the a:000 variables. 937 FOR_ALL_LIST_ITEMS(&fc->l_varlist, li) 938 clear_tv(&li->li_tv); 939 940 free_funccal(fc); 941 } 942 943 /* 944 * Handle the last part of returning from a function: free the local hashtable. 945 * Unless it is still in use by a closure. 946 */ 947 static void 948 cleanup_function_call(funccall_T *fc) 949 { 950 int may_free_fc = fc->fc_refcount <= 0; 951 int free_fc = TRUE; 952 953 current_funccal = fc->caller; 954 955 // Free all l: variables if not referred. 956 if (may_free_fc && fc->l_vars.dv_refcount == DO_NOT_FREE_CNT) 957 vars_clear(&fc->l_vars.dv_hashtab); 958 else 959 free_fc = FALSE; 960 961 // If the a:000 list and the l: and a: dicts are not referenced and 962 // there is no closure using it, we can free the funccall_T and what's 963 // in it. 964 if (may_free_fc && fc->l_avars.dv_refcount == DO_NOT_FREE_CNT) 965 vars_clear_ext(&fc->l_avars.dv_hashtab, FALSE); 966 else 967 { 968 int todo; 969 hashitem_T *hi; 970 dictitem_T *di; 971 972 free_fc = FALSE; 973 974 // Make a copy of the a: variables, since we didn't do that above. 975 todo = (int)fc->l_avars.dv_hashtab.ht_used; 976 for (hi = fc->l_avars.dv_hashtab.ht_array; todo > 0; ++hi) 977 { 978 if (!HASHITEM_EMPTY(hi)) 979 { 980 --todo; 981 di = HI2DI(hi); 982 copy_tv(&di->di_tv, &di->di_tv); 983 } 984 } 985 } 986 987 if (may_free_fc && fc->l_varlist.lv_refcount == DO_NOT_FREE_CNT) 988 fc->l_varlist.lv_first = NULL; 989 else 990 { 991 listitem_T *li; 992 993 free_fc = FALSE; 994 995 // Make a copy of the a:000 items, since we didn't do that above. 996 FOR_ALL_LIST_ITEMS(&fc->l_varlist, li) 997 copy_tv(&li->li_tv, &li->li_tv); 998 } 999 1000 if (free_fc) 1001 free_funccal(fc); 1002 else 1003 { 1004 static int made_copy = 0; 1005 1006 // "fc" is still in use. This can happen when returning "a:000", 1007 // assigning "l:" to a global variable or defining a closure. 1008 // Link "fc" in the list for garbage collection later. 1009 fc->caller = previous_funccal; 1010 previous_funccal = fc; 1011 1012 if (want_garbage_collect) 1013 // If garbage collector is ready, clear count. 1014 made_copy = 0; 1015 else if (++made_copy >= (int)((4096 * 1024) / sizeof(*fc))) 1016 { 1017 // We have made a lot of copies, worth 4 Mbyte. This can happen 1018 // when repetitively calling a function that creates a reference to 1019 // itself somehow. Call the garbage collector soon to avoid using 1020 // too much memory. 1021 made_copy = 0; 1022 want_garbage_collect = TRUE; 1023 } 1024 } 1025 } 1026 /* 1027 * Unreference "fc": decrement the reference count and free it when it 1028 * becomes zero. "fp" is detached from "fc". 1029 * When "force" is TRUE we are exiting. 1030 */ 1031 static void 1032 funccal_unref(funccall_T *fc, ufunc_T *fp, int force) 1033 { 1034 funccall_T **pfc; 1035 int i; 1036 1037 if (fc == NULL) 1038 return; 1039 1040 if (--fc->fc_refcount <= 0 && (force || ( 1041 fc->l_varlist.lv_refcount == DO_NOT_FREE_CNT 1042 && fc->l_vars.dv_refcount == DO_NOT_FREE_CNT 1043 && fc->l_avars.dv_refcount == DO_NOT_FREE_CNT))) 1044 for (pfc = &previous_funccal; *pfc != NULL; pfc = &(*pfc)->caller) 1045 { 1046 if (fc == *pfc) 1047 { 1048 *pfc = fc->caller; 1049 free_funccal_contents(fc); 1050 return; 1051 } 1052 } 1053 for (i = 0; i < fc->fc_funcs.ga_len; ++i) 1054 if (((ufunc_T **)(fc->fc_funcs.ga_data))[i] == fp) 1055 ((ufunc_T **)(fc->fc_funcs.ga_data))[i] = NULL; 1056 } 1057 1058 /* 1059 * Remove the function from the function hashtable. If the function was 1060 * deleted while it still has references this was already done. 1061 * Return TRUE if the entry was deleted, FALSE if it wasn't found. 1062 */ 1063 static int 1064 func_remove(ufunc_T *fp) 1065 { 1066 hashitem_T *hi; 1067 1068 // Return if it was already virtually deleted. 1069 if (fp->uf_flags & FC_DEAD) 1070 return FALSE; 1071 1072 hi = hash_find(&func_hashtab, UF2HIKEY(fp)); 1073 if (!HASHITEM_EMPTY(hi)) 1074 { 1075 // When there is a def-function index do not actually remove the 1076 // function, so we can find the index when defining the function again. 1077 // Do remove it when it's a copy. 1078 if (fp->uf_def_status == UF_COMPILED && (fp->uf_flags & FC_COPY) == 0) 1079 fp->uf_flags |= FC_DEAD; 1080 else 1081 hash_remove(&func_hashtab, hi); 1082 return TRUE; 1083 } 1084 return FALSE; 1085 } 1086 1087 static void 1088 func_clear_items(ufunc_T *fp) 1089 { 1090 ga_clear_strings(&(fp->uf_args)); 1091 ga_clear_strings(&(fp->uf_def_args)); 1092 ga_clear_strings(&(fp->uf_lines)); 1093 VIM_CLEAR(fp->uf_arg_types); 1094 VIM_CLEAR(fp->uf_def_arg_idx); 1095 VIM_CLEAR(fp->uf_va_name); 1096 clear_type_list(&fp->uf_type_list); 1097 1098 #ifdef FEAT_LUA 1099 if (fp->uf_cb_free != NULL) 1100 { 1101 fp->uf_cb_free(fp->uf_cb_state); 1102 fp->uf_cb_free = NULL; 1103 } 1104 1105 fp->uf_cb_state = NULL; 1106 fp->uf_cb = NULL; 1107 #endif 1108 #ifdef FEAT_PROFILE 1109 VIM_CLEAR(fp->uf_tml_count); 1110 VIM_CLEAR(fp->uf_tml_total); 1111 VIM_CLEAR(fp->uf_tml_self); 1112 #endif 1113 } 1114 1115 /* 1116 * Free all things that a function contains. Does not free the function 1117 * itself, use func_free() for that. 1118 * When "force" is TRUE we are exiting. 1119 */ 1120 static void 1121 func_clear(ufunc_T *fp, int force) 1122 { 1123 if (fp->uf_cleared) 1124 return; 1125 fp->uf_cleared = TRUE; 1126 1127 // clear this function 1128 func_clear_items(fp); 1129 funccal_unref(fp->uf_scoped, fp, force); 1130 if ((fp->uf_flags & FC_COPY) == 0) 1131 clear_def_function(fp); 1132 } 1133 1134 /* 1135 * Free a function and remove it from the list of functions. Does not free 1136 * what a function contains, call func_clear() first. 1137 * When "force" is TRUE we are exiting. 1138 */ 1139 static void 1140 func_free(ufunc_T *fp, int force) 1141 { 1142 // Only remove it when not done already, otherwise we would remove a newer 1143 // version of the function with the same name. 1144 if ((fp->uf_flags & (FC_DELETED | FC_REMOVED)) == 0) 1145 func_remove(fp); 1146 1147 if ((fp->uf_flags & FC_DEAD) == 0 || force) 1148 { 1149 VIM_CLEAR(fp->uf_name_exp); 1150 vim_free(fp); 1151 } 1152 } 1153 1154 /* 1155 * Free all things that a function contains and free the function itself. 1156 * When "force" is TRUE we are exiting. 1157 */ 1158 static void 1159 func_clear_free(ufunc_T *fp, int force) 1160 { 1161 func_clear(fp, force); 1162 if (force || fp->uf_dfunc_idx == 0 || (fp->uf_flags & FC_COPY)) 1163 func_free(fp, force); 1164 else 1165 fp->uf_flags |= FC_DEAD; 1166 } 1167 1168 /* 1169 * Copy already defined function "lambda" to a new function with name "global". 1170 * This is for when a compiled function defines a global function. 1171 */ 1172 void 1173 copy_func(char_u *lambda, char_u *global) 1174 { 1175 ufunc_T *ufunc = find_func_even_dead(lambda, TRUE, NULL); 1176 ufunc_T *fp; 1177 1178 if (ufunc == NULL) 1179 semsg(_(e_lambda_function_not_found_str), lambda); 1180 else 1181 { 1182 // TODO: handle ! to overwrite 1183 fp = find_func(global, TRUE, NULL); 1184 if (fp != NULL) 1185 { 1186 semsg(_(e_funcexts), global); 1187 return; 1188 } 1189 1190 fp = alloc_clear(offsetof(ufunc_T, uf_name) + STRLEN(global) + 1); 1191 if (fp == NULL) 1192 return; 1193 1194 fp->uf_varargs = ufunc->uf_varargs; 1195 fp->uf_flags = (ufunc->uf_flags & ~FC_VIM9) | FC_COPY; 1196 fp->uf_def_status = ufunc->uf_def_status; 1197 fp->uf_dfunc_idx = ufunc->uf_dfunc_idx; 1198 if (ga_copy_strings(&ufunc->uf_args, &fp->uf_args) == FAIL 1199 || ga_copy_strings(&ufunc->uf_def_args, &fp->uf_def_args) 1200 == FAIL 1201 || ga_copy_strings(&ufunc->uf_lines, &fp->uf_lines) == FAIL) 1202 goto failed; 1203 1204 fp->uf_name_exp = ufunc->uf_name_exp == NULL ? NULL 1205 : vim_strsave(ufunc->uf_name_exp); 1206 if (ufunc->uf_arg_types != NULL) 1207 { 1208 fp->uf_arg_types = ALLOC_MULT(type_T *, fp->uf_args.ga_len); 1209 if (fp->uf_arg_types == NULL) 1210 goto failed; 1211 mch_memmove(fp->uf_arg_types, ufunc->uf_arg_types, 1212 sizeof(type_T *) * fp->uf_args.ga_len); 1213 } 1214 if (ufunc->uf_def_arg_idx != NULL) 1215 { 1216 fp->uf_def_arg_idx = ALLOC_MULT(int, fp->uf_def_args.ga_len + 1); 1217 if (fp->uf_def_arg_idx == NULL) 1218 goto failed; 1219 mch_memmove(fp->uf_def_arg_idx, ufunc->uf_def_arg_idx, 1220 sizeof(int) * fp->uf_def_args.ga_len + 1); 1221 } 1222 if (ufunc->uf_va_name != NULL) 1223 { 1224 fp->uf_va_name = vim_strsave(ufunc->uf_va_name); 1225 if (fp->uf_va_name == NULL) 1226 goto failed; 1227 } 1228 1229 fp->uf_refcount = 1; 1230 STRCPY(fp->uf_name, global); 1231 hash_add(&func_hashtab, UF2HIKEY(fp)); 1232 } 1233 return; 1234 1235 failed: 1236 func_clear_free(fp, TRUE); 1237 } 1238 1239 1240 /* 1241 * Call a user function. 1242 */ 1243 static void 1244 call_user_func( 1245 ufunc_T *fp, // pointer to function 1246 int argcount, // nr of args 1247 typval_T *argvars, // arguments 1248 typval_T *rettv, // return value 1249 funcexe_T *funcexe, // context 1250 dict_T *selfdict) // Dictionary for "self" 1251 { 1252 sctx_T save_current_sctx; 1253 int using_sandbox = FALSE; 1254 funccall_T *fc; 1255 int save_did_emsg; 1256 int default_arg_err = FALSE; 1257 static int depth = 0; 1258 dictitem_T *v; 1259 int fixvar_idx = 0; // index in fixvar[] 1260 int i; 1261 int ai; 1262 int islambda = FALSE; 1263 char_u numbuf[NUMBUFLEN]; 1264 char_u *name; 1265 #ifdef FEAT_PROFILE 1266 proftime_T wait_start; 1267 proftime_T call_start; 1268 int started_profiling = FALSE; 1269 #endif 1270 ESTACK_CHECK_DECLARATION 1271 1272 // If depth of calling is getting too high, don't execute the function 1273 if (depth >= p_mfd) 1274 { 1275 emsg(_("E132: Function call depth is higher than 'maxfuncdepth'")); 1276 rettv->v_type = VAR_NUMBER; 1277 rettv->vval.v_number = -1; 1278 return; 1279 } 1280 ++depth; 1281 1282 line_breakcheck(); // check for CTRL-C hit 1283 1284 fc = ALLOC_CLEAR_ONE(funccall_T); 1285 if (fc == NULL) 1286 return; 1287 fc->caller = current_funccal; 1288 current_funccal = fc; 1289 fc->func = fp; 1290 fc->rettv = rettv; 1291 fc->level = ex_nesting_level; 1292 // Check if this function has a breakpoint. 1293 fc->breakpoint = dbg_find_breakpoint(FALSE, fp->uf_name, (linenr_T)0); 1294 fc->dbg_tick = debug_tick; 1295 // Set up fields for closure. 1296 ga_init2(&fc->fc_funcs, sizeof(ufunc_T *), 1); 1297 func_ptr_ref(fp); 1298 1299 if (fp->uf_def_status != UF_NOT_COMPILED) 1300 { 1301 estack_push_ufunc(fp, 1); 1302 save_current_sctx = current_sctx; 1303 current_sctx = fp->uf_script_ctx; 1304 1305 // Execute the function, possibly compiling it first. 1306 call_def_function(fp, argcount, argvars, funcexe->partial, rettv); 1307 --depth; 1308 current_funccal = fc->caller; 1309 1310 estack_pop(); 1311 current_sctx = save_current_sctx; 1312 free_funccal(fc); 1313 return; 1314 } 1315 1316 if (STRNCMP(fp->uf_name, "<lambda>", 8) == 0) 1317 islambda = TRUE; 1318 1319 /* 1320 * Note about using fc->fixvar[]: This is an array of FIXVAR_CNT variables 1321 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free 1322 * each argument variable and saves a lot of time. 1323 */ 1324 /* 1325 * Init l: variables. 1326 */ 1327 init_var_dict(&fc->l_vars, &fc->l_vars_var, VAR_DEF_SCOPE); 1328 if (selfdict != NULL) 1329 { 1330 // Set l:self to "selfdict". Use "name" to avoid a warning from 1331 // some compiler that checks the destination size. 1332 v = &fc->fixvar[fixvar_idx++].var; 1333 name = v->di_key; 1334 STRCPY(name, "self"); 1335 v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; 1336 hash_add(&fc->l_vars.dv_hashtab, DI2HIKEY(v)); 1337 v->di_tv.v_type = VAR_DICT; 1338 v->di_tv.v_lock = 0; 1339 v->di_tv.vval.v_dict = selfdict; 1340 ++selfdict->dv_refcount; 1341 } 1342 1343 /* 1344 * Init a: variables, unless none found (in lambda). 1345 * Set a:0 to "argcount" less number of named arguments, if >= 0. 1346 * Set a:000 to a list with room for the "..." arguments. 1347 */ 1348 init_var_dict(&fc->l_avars, &fc->l_avars_var, VAR_SCOPE); 1349 if ((fp->uf_flags & FC_NOARGS) == 0) 1350 add_nr_var(&fc->l_avars, &fc->fixvar[fixvar_idx++].var, "0", 1351 (varnumber_T)(argcount >= fp->uf_args.ga_len 1352 ? argcount - fp->uf_args.ga_len : 0)); 1353 fc->l_avars.dv_lock = VAR_FIXED; 1354 if ((fp->uf_flags & FC_NOARGS) == 0) 1355 { 1356 // Use "name" to avoid a warning from some compiler that checks the 1357 // destination size. 1358 v = &fc->fixvar[fixvar_idx++].var; 1359 name = v->di_key; 1360 STRCPY(name, "000"); 1361 v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; 1362 hash_add(&fc->l_avars.dv_hashtab, DI2HIKEY(v)); 1363 v->di_tv.v_type = VAR_LIST; 1364 v->di_tv.v_lock = VAR_FIXED; 1365 v->di_tv.vval.v_list = &fc->l_varlist; 1366 } 1367 CLEAR_FIELD(fc->l_varlist); 1368 fc->l_varlist.lv_refcount = DO_NOT_FREE_CNT; 1369 fc->l_varlist.lv_lock = VAR_FIXED; 1370 1371 /* 1372 * Set a:firstline to "firstline" and a:lastline to "lastline". 1373 * Set a:name to named arguments. 1374 * Set a:N to the "..." arguments. 1375 * Skipped when no a: variables used (in lambda). 1376 */ 1377 if ((fp->uf_flags & FC_NOARGS) == 0) 1378 { 1379 add_nr_var(&fc->l_avars, &fc->fixvar[fixvar_idx++].var, "firstline", 1380 (varnumber_T)funcexe->firstline); 1381 add_nr_var(&fc->l_avars, &fc->fixvar[fixvar_idx++].var, "lastline", 1382 (varnumber_T)funcexe->lastline); 1383 } 1384 for (i = 0; i < argcount || i < fp->uf_args.ga_len; ++i) 1385 { 1386 int addlocal = FALSE; 1387 typval_T def_rettv; 1388 int isdefault = FALSE; 1389 1390 ai = i - fp->uf_args.ga_len; 1391 if (ai < 0) 1392 { 1393 // named argument a:name 1394 name = FUNCARG(fp, i); 1395 if (islambda) 1396 addlocal = TRUE; 1397 1398 // evaluate named argument default expression 1399 isdefault = ai + fp->uf_def_args.ga_len >= 0 1400 && (i >= argcount || (argvars[i].v_type == VAR_SPECIAL 1401 && argvars[i].vval.v_number == VVAL_NONE)); 1402 if (isdefault) 1403 { 1404 char_u *default_expr = NULL; 1405 def_rettv.v_type = VAR_NUMBER; 1406 def_rettv.vval.v_number = -1; 1407 1408 default_expr = ((char_u **)(fp->uf_def_args.ga_data)) 1409 [ai + fp->uf_def_args.ga_len]; 1410 if (eval1(&default_expr, &def_rettv, &EVALARG_EVALUATE) == FAIL) 1411 { 1412 default_arg_err = 1; 1413 break; 1414 } 1415 } 1416 } 1417 else 1418 { 1419 if ((fp->uf_flags & FC_NOARGS) != 0) 1420 // Bail out if no a: arguments used (in lambda). 1421 break; 1422 1423 // "..." argument a:1, a:2, etc. 1424 sprintf((char *)numbuf, "%d", ai + 1); 1425 name = numbuf; 1426 } 1427 if (fixvar_idx < FIXVAR_CNT && STRLEN(name) <= VAR_SHORT_LEN) 1428 { 1429 v = &fc->fixvar[fixvar_idx++].var; 1430 v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; 1431 STRCPY(v->di_key, name); 1432 } 1433 else 1434 { 1435 v = dictitem_alloc(name); 1436 if (v == NULL) 1437 break; 1438 v->di_flags |= DI_FLAGS_RO | DI_FLAGS_FIX; 1439 } 1440 1441 // Note: the values are copied directly to avoid alloc/free. 1442 // "argvars" must have VAR_FIXED for v_lock. 1443 v->di_tv = isdefault ? def_rettv : argvars[i]; 1444 v->di_tv.v_lock = VAR_FIXED; 1445 1446 if (addlocal) 1447 { 1448 // Named arguments should be accessed without the "a:" prefix in 1449 // lambda expressions. Add to the l: dict. 1450 copy_tv(&v->di_tv, &v->di_tv); 1451 hash_add(&fc->l_vars.dv_hashtab, DI2HIKEY(v)); 1452 } 1453 else 1454 hash_add(&fc->l_avars.dv_hashtab, DI2HIKEY(v)); 1455 1456 if (ai >= 0 && ai < MAX_FUNC_ARGS) 1457 { 1458 listitem_T *li = &fc->l_listitems[ai]; 1459 1460 li->li_tv = argvars[i]; 1461 li->li_tv.v_lock = VAR_FIXED; 1462 list_append(&fc->l_varlist, li); 1463 } 1464 } 1465 1466 // Don't redraw while executing the function. 1467 ++RedrawingDisabled; 1468 1469 if (fp->uf_flags & FC_SANDBOX) 1470 { 1471 using_sandbox = TRUE; 1472 ++sandbox; 1473 } 1474 1475 estack_push_ufunc(fp, 1); 1476 ESTACK_CHECK_SETUP 1477 if (p_verbose >= 12) 1478 { 1479 ++no_wait_return; 1480 verbose_enter_scroll(); 1481 1482 smsg(_("calling %s"), SOURCING_NAME); 1483 if (p_verbose >= 14) 1484 { 1485 char_u buf[MSG_BUF_LEN]; 1486 char_u numbuf2[NUMBUFLEN]; 1487 char_u *tofree; 1488 char_u *s; 1489 1490 msg_puts("("); 1491 for (i = 0; i < argcount; ++i) 1492 { 1493 if (i > 0) 1494 msg_puts(", "); 1495 if (argvars[i].v_type == VAR_NUMBER) 1496 msg_outnum((long)argvars[i].vval.v_number); 1497 else 1498 { 1499 // Do not want errors such as E724 here. 1500 ++emsg_off; 1501 s = tv2string(&argvars[i], &tofree, numbuf2, 0); 1502 --emsg_off; 1503 if (s != NULL) 1504 { 1505 if (vim_strsize(s) > MSG_BUF_CLEN) 1506 { 1507 trunc_string(s, buf, MSG_BUF_CLEN, MSG_BUF_LEN); 1508 s = buf; 1509 } 1510 msg_puts((char *)s); 1511 vim_free(tofree); 1512 } 1513 } 1514 } 1515 msg_puts(")"); 1516 } 1517 msg_puts("\n"); // don't overwrite this either 1518 1519 verbose_leave_scroll(); 1520 --no_wait_return; 1521 } 1522 #ifdef FEAT_PROFILE 1523 if (do_profiling == PROF_YES) 1524 { 1525 if (!fp->uf_profiling && has_profiling(FALSE, fp->uf_name, NULL)) 1526 { 1527 started_profiling = TRUE; 1528 func_do_profile(fp); 1529 } 1530 if (fp->uf_profiling 1531 || (fc->caller != NULL && fc->caller->func->uf_profiling)) 1532 { 1533 ++fp->uf_tm_count; 1534 profile_start(&call_start); 1535 profile_zero(&fp->uf_tm_children); 1536 } 1537 script_prof_save(&wait_start); 1538 } 1539 #endif 1540 1541 save_current_sctx = current_sctx; 1542 current_sctx = fp->uf_script_ctx; 1543 save_did_emsg = did_emsg; 1544 did_emsg = FALSE; 1545 1546 if (default_arg_err && (fp->uf_flags & FC_ABORT)) 1547 did_emsg = TRUE; 1548 else if (islambda) 1549 { 1550 char_u *p = *(char_u **)fp->uf_lines.ga_data + 7; 1551 1552 // A Lambda always has the command "return {expr}". It is much faster 1553 // to evaluate {expr} directly. 1554 ++ex_nesting_level; 1555 (void)eval1(&p, rettv, &EVALARG_EVALUATE); 1556 --ex_nesting_level; 1557 } 1558 else 1559 // call do_cmdline() to execute the lines 1560 do_cmdline(NULL, get_func_line, (void *)fc, 1561 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT); 1562 1563 --RedrawingDisabled; 1564 1565 // when the function was aborted because of an error, return -1 1566 if ((did_emsg && (fp->uf_flags & FC_ABORT)) || rettv->v_type == VAR_UNKNOWN) 1567 { 1568 clear_tv(rettv); 1569 rettv->v_type = VAR_NUMBER; 1570 rettv->vval.v_number = -1; 1571 } 1572 1573 #ifdef FEAT_PROFILE 1574 if (do_profiling == PROF_YES && (fp->uf_profiling 1575 || (fc->caller != NULL && fc->caller->func->uf_profiling))) 1576 { 1577 profile_end(&call_start); 1578 profile_sub_wait(&wait_start, &call_start); 1579 profile_add(&fp->uf_tm_total, &call_start); 1580 profile_self(&fp->uf_tm_self, &call_start, &fp->uf_tm_children); 1581 if (fc->caller != NULL && fc->caller->func->uf_profiling) 1582 { 1583 profile_add(&fc->caller->func->uf_tm_children, &call_start); 1584 profile_add(&fc->caller->func->uf_tml_children, &call_start); 1585 } 1586 if (started_profiling) 1587 // make a ":profdel func" stop profiling the function 1588 fp->uf_profiling = FALSE; 1589 } 1590 #endif 1591 1592 // when being verbose, mention the return value 1593 if (p_verbose >= 12) 1594 { 1595 ++no_wait_return; 1596 verbose_enter_scroll(); 1597 1598 if (aborting()) 1599 smsg(_("%s aborted"), SOURCING_NAME); 1600 else if (fc->rettv->v_type == VAR_NUMBER) 1601 smsg(_("%s returning #%ld"), SOURCING_NAME, 1602 (long)fc->rettv->vval.v_number); 1603 else 1604 { 1605 char_u buf[MSG_BUF_LEN]; 1606 char_u numbuf2[NUMBUFLEN]; 1607 char_u *tofree; 1608 char_u *s; 1609 1610 // The value may be very long. Skip the middle part, so that we 1611 // have some idea how it starts and ends. smsg() would always 1612 // truncate it at the end. Don't want errors such as E724 here. 1613 ++emsg_off; 1614 s = tv2string(fc->rettv, &tofree, numbuf2, 0); 1615 --emsg_off; 1616 if (s != NULL) 1617 { 1618 if (vim_strsize(s) > MSG_BUF_CLEN) 1619 { 1620 trunc_string(s, buf, MSG_BUF_CLEN, MSG_BUF_LEN); 1621 s = buf; 1622 } 1623 smsg(_("%s returning %s"), SOURCING_NAME, s); 1624 vim_free(tofree); 1625 } 1626 } 1627 msg_puts("\n"); // don't overwrite this either 1628 1629 verbose_leave_scroll(); 1630 --no_wait_return; 1631 } 1632 1633 ESTACK_CHECK_NOW 1634 estack_pop(); 1635 current_sctx = save_current_sctx; 1636 #ifdef FEAT_PROFILE 1637 if (do_profiling == PROF_YES) 1638 script_prof_restore(&wait_start); 1639 #endif 1640 if (using_sandbox) 1641 --sandbox; 1642 1643 if (p_verbose >= 12 && SOURCING_NAME != NULL) 1644 { 1645 ++no_wait_return; 1646 verbose_enter_scroll(); 1647 1648 smsg(_("continuing in %s"), SOURCING_NAME); 1649 msg_puts("\n"); // don't overwrite this either 1650 1651 verbose_leave_scroll(); 1652 --no_wait_return; 1653 } 1654 1655 did_emsg |= save_did_emsg; 1656 --depth; 1657 1658 cleanup_function_call(fc); 1659 } 1660 1661 /* 1662 * Call a user function after checking the arguments. 1663 */ 1664 int 1665 call_user_func_check( 1666 ufunc_T *fp, 1667 int argcount, 1668 typval_T *argvars, 1669 typval_T *rettv, 1670 funcexe_T *funcexe, 1671 dict_T *selfdict) 1672 { 1673 int error; 1674 int regular_args = fp->uf_args.ga_len; 1675 1676 if (fp->uf_flags & FC_RANGE && funcexe->doesrange != NULL) 1677 *funcexe->doesrange = TRUE; 1678 if (argcount < regular_args - fp->uf_def_args.ga_len) 1679 error = FCERR_TOOFEW; 1680 else if (!has_varargs(fp) && argcount > regular_args) 1681 error = FCERR_TOOMANY; 1682 else if ((fp->uf_flags & FC_DICT) && selfdict == NULL) 1683 error = FCERR_DICT; 1684 else 1685 { 1686 int did_save_redo = FALSE; 1687 save_redo_T save_redo; 1688 1689 /* 1690 * Call the user function. 1691 * Save and restore search patterns, script variables and 1692 * redo buffer. 1693 */ 1694 save_search_patterns(); 1695 if (!ins_compl_active()) 1696 { 1697 saveRedobuff(&save_redo); 1698 did_save_redo = TRUE; 1699 } 1700 ++fp->uf_calls; 1701 call_user_func(fp, argcount, argvars, rettv, funcexe, 1702 (fp->uf_flags & FC_DICT) ? selfdict : NULL); 1703 if (--fp->uf_calls <= 0 && fp->uf_refcount <= 0) 1704 // Function was unreferenced while being used, free it now. 1705 func_clear_free(fp, FALSE); 1706 if (did_save_redo) 1707 restoreRedobuff(&save_redo); 1708 restore_search_patterns(); 1709 error = FCERR_NONE; 1710 } 1711 return error; 1712 } 1713 1714 /* 1715 * There are two kinds of function names: 1716 * 1. ordinary names, function defined with :function 1717 * 2. numbered functions and lambdas 1718 * For the first we only count the name stored in func_hashtab as a reference, 1719 * using function() does not count as a reference, because the function is 1720 * looked up by name. 1721 */ 1722 static int 1723 func_name_refcount(char_u *name) 1724 { 1725 return isdigit(*name) || *name == '<'; 1726 } 1727 1728 static funccal_entry_T *funccal_stack = NULL; 1729 1730 /* 1731 * Save the current function call pointer, and set it to NULL. 1732 * Used when executing autocommands and for ":source". 1733 */ 1734 void 1735 save_funccal(funccal_entry_T *entry) 1736 { 1737 entry->top_funccal = current_funccal; 1738 entry->next = funccal_stack; 1739 funccal_stack = entry; 1740 current_funccal = NULL; 1741 } 1742 1743 void 1744 restore_funccal(void) 1745 { 1746 if (funccal_stack == NULL) 1747 iemsg("INTERNAL: restore_funccal()"); 1748 else 1749 { 1750 current_funccal = funccal_stack->top_funccal; 1751 funccal_stack = funccal_stack->next; 1752 } 1753 } 1754 1755 funccall_T * 1756 get_current_funccal(void) 1757 { 1758 return current_funccal; 1759 } 1760 1761 /* 1762 * Mark all functions of script "sid" as deleted. 1763 */ 1764 void 1765 delete_script_functions(int sid) 1766 { 1767 hashitem_T *hi; 1768 ufunc_T *fp; 1769 long_u todo = 1; 1770 char_u buf[30]; 1771 size_t len; 1772 1773 buf[0] = K_SPECIAL; 1774 buf[1] = KS_EXTRA; 1775 buf[2] = (int)KE_SNR; 1776 sprintf((char *)buf + 3, "%d_", sid); 1777 len = STRLEN(buf); 1778 1779 while (todo > 0) 1780 { 1781 todo = func_hashtab.ht_used; 1782 for (hi = func_hashtab.ht_array; todo > 0; ++hi) 1783 if (!HASHITEM_EMPTY(hi)) 1784 { 1785 fp = HI2UF(hi); 1786 if (STRNCMP(fp->uf_name, buf, len) == 0) 1787 { 1788 int changed = func_hashtab.ht_changed; 1789 1790 fp->uf_flags |= FC_DEAD; 1791 func_clear(fp, TRUE); 1792 // When clearing a function another function can be cleared 1793 // as a side effect. When that happens start over. 1794 if (changed != func_hashtab.ht_changed) 1795 break; 1796 } 1797 --todo; 1798 } 1799 } 1800 } 1801 1802 #if defined(EXITFREE) || defined(PROTO) 1803 void 1804 free_all_functions(void) 1805 { 1806 hashitem_T *hi; 1807 ufunc_T *fp; 1808 long_u skipped = 0; 1809 long_u todo = 1; 1810 int changed; 1811 1812 // Clean up the current_funccal chain and the funccal stack. 1813 while (current_funccal != NULL) 1814 { 1815 clear_tv(current_funccal->rettv); 1816 cleanup_function_call(current_funccal); 1817 if (current_funccal == NULL && funccal_stack != NULL) 1818 restore_funccal(); 1819 } 1820 1821 // First clear what the functions contain. Since this may lower the 1822 // reference count of a function, it may also free a function and change 1823 // the hash table. Restart if that happens. 1824 while (todo > 0) 1825 { 1826 todo = func_hashtab.ht_used; 1827 for (hi = func_hashtab.ht_array; todo > 0; ++hi) 1828 if (!HASHITEM_EMPTY(hi)) 1829 { 1830 // clear the def function index now 1831 fp = HI2UF(hi); 1832 fp->uf_flags &= ~FC_DEAD; 1833 fp->uf_def_status = UF_NOT_COMPILED; 1834 1835 // Only free functions that are not refcounted, those are 1836 // supposed to be freed when no longer referenced. 1837 if (func_name_refcount(fp->uf_name)) 1838 ++skipped; 1839 else 1840 { 1841 changed = func_hashtab.ht_changed; 1842 func_clear(fp, TRUE); 1843 if (changed != func_hashtab.ht_changed) 1844 { 1845 skipped = 0; 1846 break; 1847 } 1848 } 1849 --todo; 1850 } 1851 } 1852 1853 // Now actually free the functions. Need to start all over every time, 1854 // because func_free() may change the hash table. 1855 skipped = 0; 1856 while (func_hashtab.ht_used > skipped) 1857 { 1858 todo = func_hashtab.ht_used; 1859 for (hi = func_hashtab.ht_array; todo > 0; ++hi) 1860 if (!HASHITEM_EMPTY(hi)) 1861 { 1862 --todo; 1863 // Only free functions that are not refcounted, those are 1864 // supposed to be freed when no longer referenced. 1865 fp = HI2UF(hi); 1866 if (func_name_refcount(fp->uf_name)) 1867 ++skipped; 1868 else 1869 { 1870 func_free(fp, FALSE); 1871 skipped = 0; 1872 break; 1873 } 1874 } 1875 } 1876 if (skipped == 0) 1877 hash_clear(&func_hashtab); 1878 1879 free_def_functions(); 1880 } 1881 #endif 1882 1883 /* 1884 * Return TRUE if "name" looks like a builtin function name: starts with a 1885 * lower case letter and doesn't contain AUTOLOAD_CHAR or ':'. 1886 * "len" is the length of "name", or -1 for NUL terminated. 1887 */ 1888 int 1889 builtin_function(char_u *name, int len) 1890 { 1891 char_u *p; 1892 1893 if (!ASCII_ISLOWER(name[0]) || name[1] == ':') 1894 return FALSE; 1895 p = vim_strchr(name, AUTOLOAD_CHAR); 1896 return p == NULL || (len > 0 && p > name + len); 1897 } 1898 1899 int 1900 func_call( 1901 char_u *name, 1902 typval_T *args, 1903 partial_T *partial, 1904 dict_T *selfdict, 1905 typval_T *rettv) 1906 { 1907 list_T *l = args->vval.v_list; 1908 listitem_T *item; 1909 typval_T argv[MAX_FUNC_ARGS + 1]; 1910 int argc = 0; 1911 int r = 0; 1912 1913 CHECK_LIST_MATERIALIZE(l); 1914 FOR_ALL_LIST_ITEMS(l, item) 1915 { 1916 if (argc == MAX_FUNC_ARGS - (partial == NULL ? 0 : partial->pt_argc)) 1917 { 1918 emsg(_("E699: Too many arguments")); 1919 break; 1920 } 1921 // Make a copy of each argument. This is needed to be able to set 1922 // v_lock to VAR_FIXED in the copy without changing the original list. 1923 copy_tv(&item->li_tv, &argv[argc++]); 1924 } 1925 1926 if (item == NULL) 1927 { 1928 funcexe_T funcexe; 1929 1930 CLEAR_FIELD(funcexe); 1931 funcexe.firstline = curwin->w_cursor.lnum; 1932 funcexe.lastline = curwin->w_cursor.lnum; 1933 funcexe.evaluate = TRUE; 1934 funcexe.partial = partial; 1935 funcexe.selfdict = selfdict; 1936 r = call_func(name, -1, rettv, argc, argv, &funcexe); 1937 } 1938 1939 // Free the arguments. 1940 while (argc > 0) 1941 clear_tv(&argv[--argc]); 1942 1943 return r; 1944 } 1945 1946 static int callback_depth = 0; 1947 1948 int 1949 get_callback_depth(void) 1950 { 1951 return callback_depth; 1952 } 1953 1954 /* 1955 * Invoke call_func() with a callback. 1956 */ 1957 int 1958 call_callback( 1959 callback_T *callback, 1960 int len, // length of "name" or -1 to use strlen() 1961 typval_T *rettv, // return value goes here 1962 int argcount, // number of "argvars" 1963 typval_T *argvars) // vars for arguments, must have "argcount" 1964 // PLUS ONE elements! 1965 { 1966 funcexe_T funcexe; 1967 int ret; 1968 1969 CLEAR_FIELD(funcexe); 1970 funcexe.evaluate = TRUE; 1971 funcexe.partial = callback->cb_partial; 1972 ++callback_depth; 1973 ret = call_func(callback->cb_name, len, rettv, argcount, argvars, &funcexe); 1974 --callback_depth; 1975 return ret; 1976 } 1977 1978 /* 1979 * Give an error message for the result of a function. 1980 * Nothing if "error" is FCERR_NONE. 1981 */ 1982 void 1983 user_func_error(int error, char_u *name) 1984 { 1985 switch (error) 1986 { 1987 case FCERR_UNKNOWN: 1988 emsg_funcname(e_unknownfunc, name); 1989 break; 1990 case FCERR_NOTMETHOD: 1991 emsg_funcname( 1992 N_("E276: Cannot use function as a method: %s"), name); 1993 break; 1994 case FCERR_DELETED: 1995 emsg_funcname(N_(e_func_deleted), name); 1996 break; 1997 case FCERR_TOOMANY: 1998 emsg_funcname((char *)e_toomanyarg, name); 1999 break; 2000 case FCERR_TOOFEW: 2001 emsg_funcname((char *)e_toofewarg, name); 2002 break; 2003 case FCERR_SCRIPT: 2004 emsg_funcname( 2005 N_("E120: Using <SID> not in a script context: %s"), name); 2006 break; 2007 case FCERR_DICT: 2008 emsg_funcname( 2009 N_("E725: Calling dict function without Dictionary: %s"), 2010 name); 2011 break; 2012 } 2013 } 2014 2015 /* 2016 * Call a function with its resolved parameters 2017 * 2018 * Return FAIL when the function can't be called, OK otherwise. 2019 * Also returns OK when an error was encountered while executing the function. 2020 */ 2021 int 2022 call_func( 2023 char_u *funcname, // name of the function 2024 int len, // length of "name" or -1 to use strlen() 2025 typval_T *rettv, // return value goes here 2026 int argcount_in, // number of "argvars" 2027 typval_T *argvars_in, // vars for arguments, must have "argcount" 2028 // PLUS ONE elements! 2029 funcexe_T *funcexe) // more arguments 2030 { 2031 int ret = FAIL; 2032 int error = FCERR_NONE; 2033 int i; 2034 ufunc_T *fp = NULL; 2035 char_u fname_buf[FLEN_FIXED + 1]; 2036 char_u *tofree = NULL; 2037 char_u *fname = NULL; 2038 char_u *name = NULL; 2039 int argcount = argcount_in; 2040 typval_T *argvars = argvars_in; 2041 dict_T *selfdict = funcexe->selfdict; 2042 typval_T argv[MAX_FUNC_ARGS + 1]; // used when "partial" or 2043 // "funcexe->basetv" is not NULL 2044 int argv_clear = 0; 2045 int argv_base = 0; 2046 partial_T *partial = funcexe->partial; 2047 2048 // Initialize rettv so that it is safe for caller to invoke clear_tv(rettv) 2049 // even when call_func() returns FAIL. 2050 rettv->v_type = VAR_UNKNOWN; 2051 2052 if (partial != NULL) 2053 fp = partial->pt_func; 2054 if (fp == NULL) 2055 { 2056 // Make a copy of the name, if it comes from a funcref variable it 2057 // could be changed or deleted in the called function. 2058 name = len > 0 ? vim_strnsave(funcname, len) : vim_strsave(funcname); 2059 if (name == NULL) 2060 return ret; 2061 2062 fname = fname_trans_sid(name, fname_buf, &tofree, &error); 2063 } 2064 2065 if (funcexe->doesrange != NULL) 2066 *funcexe->doesrange = FALSE; 2067 2068 if (partial != NULL) 2069 { 2070 // When the function has a partial with a dict and there is a dict 2071 // argument, use the dict argument. That is backwards compatible. 2072 // When the dict was bound explicitly use the one from the partial. 2073 if (partial->pt_dict != NULL && (selfdict == NULL || !partial->pt_auto)) 2074 selfdict = partial->pt_dict; 2075 if (error == FCERR_NONE && partial->pt_argc > 0) 2076 { 2077 for (argv_clear = 0; argv_clear < partial->pt_argc; ++argv_clear) 2078 { 2079 if (argv_clear + argcount_in >= MAX_FUNC_ARGS) 2080 { 2081 error = FCERR_TOOMANY; 2082 goto theend; 2083 } 2084 copy_tv(&partial->pt_argv[argv_clear], &argv[argv_clear]); 2085 } 2086 for (i = 0; i < argcount_in; ++i) 2087 argv[i + argv_clear] = argvars_in[i]; 2088 argvars = argv; 2089 argcount = partial->pt_argc + argcount_in; 2090 } 2091 } 2092 2093 if (error == FCERR_NONE && funcexe->evaluate) 2094 { 2095 char_u *rfname = fname; 2096 int is_global = FALSE; 2097 2098 // Skip "g:" before a function name. 2099 if (fp == NULL && fname[0] == 'g' && fname[1] == ':') 2100 { 2101 is_global = TRUE; 2102 rfname = fname + 2; 2103 } 2104 2105 rettv->v_type = VAR_NUMBER; // default rettv is number zero 2106 rettv->vval.v_number = 0; 2107 error = FCERR_UNKNOWN; 2108 2109 if (fp != NULL || !builtin_function(rfname, -1)) 2110 { 2111 /* 2112 * User defined function. 2113 */ 2114 if (fp == NULL) 2115 fp = find_func(rfname, is_global, NULL); 2116 2117 // Trigger FuncUndefined event, may load the function. 2118 if (fp == NULL 2119 && apply_autocmds(EVENT_FUNCUNDEFINED, 2120 rfname, rfname, TRUE, NULL) 2121 && !aborting()) 2122 { 2123 // executed an autocommand, search for the function again 2124 fp = find_func(rfname, is_global, NULL); 2125 } 2126 // Try loading a package. 2127 if (fp == NULL && script_autoload(rfname, TRUE) && !aborting()) 2128 { 2129 // loaded a package, search for the function again 2130 fp = find_func(rfname, is_global, NULL); 2131 } 2132 if (fp == NULL) 2133 { 2134 char_u *p = untrans_function_name(rfname); 2135 2136 // If using Vim9 script try not local to the script. 2137 // Don't do this if the name starts with "s:". 2138 if (p != NULL && (funcname[0] != 's' || funcname[1] != ':')) 2139 fp = find_func(p, is_global, NULL); 2140 } 2141 2142 if (fp != NULL && (fp->uf_flags & FC_DELETED)) 2143 error = FCERR_DELETED; 2144 #ifdef FEAT_LUA 2145 else if (fp != NULL && (fp->uf_flags & FC_CFUNC)) 2146 { 2147 cfunc_T cb = fp->uf_cb; 2148 2149 error = (*cb)(argcount, argvars, rettv, fp->uf_cb_state); 2150 } 2151 #endif 2152 else if (fp != NULL) 2153 { 2154 if (funcexe->argv_func != NULL) 2155 // postponed filling in the arguments, do it now 2156 argcount = funcexe->argv_func(argcount, argvars, argv_clear, 2157 fp->uf_args.ga_len); 2158 2159 if (funcexe->basetv != NULL) 2160 { 2161 // Method call: base->Method() 2162 mch_memmove(&argv[1], argvars, sizeof(typval_T) * argcount); 2163 argv[0] = *funcexe->basetv; 2164 argcount++; 2165 argvars = argv; 2166 argv_base = 1; 2167 } 2168 2169 error = call_user_func_check(fp, argcount, argvars, rettv, 2170 funcexe, selfdict); 2171 } 2172 } 2173 else if (funcexe->basetv != NULL) 2174 { 2175 /* 2176 * expr->method(): Find the method name in the table, call its 2177 * implementation with the base as one of the arguments. 2178 */ 2179 error = call_internal_method(fname, argcount, argvars, rettv, 2180 funcexe->basetv); 2181 } 2182 else 2183 { 2184 /* 2185 * Find the function name in the table, call its implementation. 2186 */ 2187 error = call_internal_func(fname, argcount, argvars, rettv); 2188 } 2189 2190 /* 2191 * The function call (or "FuncUndefined" autocommand sequence) might 2192 * have been aborted by an error, an interrupt, or an explicitly thrown 2193 * exception that has not been caught so far. This situation can be 2194 * tested for by calling aborting(). For an error in an internal 2195 * function or for the "E132" error in call_user_func(), however, the 2196 * throw point at which the "force_abort" flag (temporarily reset by 2197 * emsg()) is normally updated has not been reached yet. We need to 2198 * update that flag first to make aborting() reliable. 2199 */ 2200 update_force_abort(); 2201 } 2202 if (error == FCERR_NONE) 2203 ret = OK; 2204 2205 theend: 2206 /* 2207 * Report an error unless the argument evaluation or function call has been 2208 * cancelled due to an aborting error, an interrupt, or an exception. 2209 */ 2210 if (!aborting()) 2211 { 2212 user_func_error(error, (name != NULL) ? name : funcname); 2213 } 2214 2215 // clear the copies made from the partial 2216 while (argv_clear > 0) 2217 clear_tv(&argv[--argv_clear + argv_base]); 2218 2219 vim_free(tofree); 2220 vim_free(name); 2221 2222 return ret; 2223 } 2224 2225 char_u * 2226 printable_func_name(ufunc_T *fp) 2227 { 2228 return fp->uf_name_exp != NULL ? fp->uf_name_exp : fp->uf_name; 2229 } 2230 2231 /* 2232 * List the head of the function: "function name(arg1, arg2)". 2233 */ 2234 static void 2235 list_func_head(ufunc_T *fp, int indent) 2236 { 2237 int j; 2238 2239 msg_start(); 2240 if (indent) 2241 msg_puts(" "); 2242 if (fp->uf_def_status != UF_NOT_COMPILED) 2243 msg_puts("def "); 2244 else 2245 msg_puts("function "); 2246 msg_puts((char *)printable_func_name(fp)); 2247 msg_putchar('('); 2248 for (j = 0; j < fp->uf_args.ga_len; ++j) 2249 { 2250 if (j) 2251 msg_puts(", "); 2252 msg_puts((char *)FUNCARG(fp, j)); 2253 if (fp->uf_arg_types != NULL) 2254 { 2255 char *tofree; 2256 2257 msg_puts(": "); 2258 msg_puts(type_name(fp->uf_arg_types[j], &tofree)); 2259 vim_free(tofree); 2260 } 2261 if (j >= fp->uf_args.ga_len - fp->uf_def_args.ga_len) 2262 { 2263 msg_puts(" = "); 2264 msg_puts(((char **)(fp->uf_def_args.ga_data)) 2265 [j - fp->uf_args.ga_len + fp->uf_def_args.ga_len]); 2266 } 2267 } 2268 if (fp->uf_varargs) 2269 { 2270 if (j) 2271 msg_puts(", "); 2272 msg_puts("..."); 2273 } 2274 if (fp->uf_va_name != NULL) 2275 { 2276 if (j) 2277 msg_puts(", "); 2278 msg_puts("..."); 2279 msg_puts((char *)fp->uf_va_name); 2280 if (fp->uf_va_type) 2281 { 2282 char *tofree; 2283 2284 msg_puts(": "); 2285 msg_puts(type_name(fp->uf_va_type, &tofree)); 2286 vim_free(tofree); 2287 } 2288 } 2289 msg_putchar(')'); 2290 2291 if (fp->uf_def_status != UF_NOT_COMPILED) 2292 { 2293 if (fp->uf_ret_type != &t_void) 2294 { 2295 char *tofree; 2296 2297 msg_puts(": "); 2298 msg_puts(type_name(fp->uf_ret_type, &tofree)); 2299 vim_free(tofree); 2300 } 2301 } 2302 else if (fp->uf_flags & FC_ABORT) 2303 msg_puts(" abort"); 2304 if (fp->uf_flags & FC_RANGE) 2305 msg_puts(" range"); 2306 if (fp->uf_flags & FC_DICT) 2307 msg_puts(" dict"); 2308 if (fp->uf_flags & FC_CLOSURE) 2309 msg_puts(" closure"); 2310 msg_clr_eos(); 2311 if (p_verbose > 0) 2312 last_set_msg(fp->uf_script_ctx); 2313 } 2314 2315 /* 2316 * Get a function name, translating "<SID>" and "<SNR>". 2317 * Also handles a Funcref in a List or Dictionary. 2318 * Returns the function name in allocated memory, or NULL for failure. 2319 * Set "*is_global" to TRUE when the function must be global, unless 2320 * "is_global" is NULL. 2321 * flags: 2322 * TFN_INT: internal function name OK 2323 * TFN_QUIET: be quiet 2324 * TFN_NO_AUTOLOAD: do not use script autoloading 2325 * TFN_NO_DEREF: do not dereference a Funcref 2326 * Advances "pp" to just after the function name (if no error). 2327 */ 2328 char_u * 2329 trans_function_name( 2330 char_u **pp, 2331 int *is_global, 2332 int skip, // only find the end, don't evaluate 2333 int flags, 2334 funcdict_T *fdp, // return: info about dictionary used 2335 partial_T **partial) // return: partial of a FuncRef 2336 { 2337 char_u *name = NULL; 2338 char_u *start; 2339 char_u *end; 2340 int lead; 2341 char_u sid_buf[20]; 2342 int len; 2343 int extra = 0; 2344 lval_T lv; 2345 int vim9script; 2346 2347 if (fdp != NULL) 2348 CLEAR_POINTER(fdp); 2349 start = *pp; 2350 2351 // Check for hard coded <SNR>: already translated function ID (from a user 2352 // command). 2353 if ((*pp)[0] == K_SPECIAL && (*pp)[1] == KS_EXTRA 2354 && (*pp)[2] == (int)KE_SNR) 2355 { 2356 *pp += 3; 2357 len = get_id_len(pp) + 3; 2358 return vim_strnsave(start, len); 2359 } 2360 2361 // A name starting with "<SID>" or "<SNR>" is local to a script. But 2362 // don't skip over "s:", get_lval() needs it for "s:dict.func". 2363 lead = eval_fname_script(start); 2364 if (lead > 2) 2365 start += lead; 2366 2367 // Note that TFN_ flags use the same values as GLV_ flags. 2368 end = get_lval(start, NULL, &lv, FALSE, skip, flags | GLV_READ_ONLY, 2369 lead > 2 ? 0 : FNE_CHECK_START); 2370 if (end == start) 2371 { 2372 if (!skip) 2373 emsg(_("E129: Function name required")); 2374 goto theend; 2375 } 2376 if (end == NULL || (lv.ll_tv != NULL && (lead > 2 || lv.ll_range))) 2377 { 2378 /* 2379 * Report an invalid expression in braces, unless the expression 2380 * evaluation has been cancelled due to an aborting error, an 2381 * interrupt, or an exception. 2382 */ 2383 if (!aborting()) 2384 { 2385 if (end != NULL) 2386 semsg(_(e_invarg2), start); 2387 } 2388 else 2389 *pp = find_name_end(start, NULL, NULL, FNE_INCL_BR); 2390 goto theend; 2391 } 2392 2393 if (lv.ll_tv != NULL) 2394 { 2395 if (fdp != NULL) 2396 { 2397 fdp->fd_dict = lv.ll_dict; 2398 fdp->fd_newkey = lv.ll_newkey; 2399 lv.ll_newkey = NULL; 2400 fdp->fd_di = lv.ll_di; 2401 } 2402 if (lv.ll_tv->v_type == VAR_FUNC && lv.ll_tv->vval.v_string != NULL) 2403 { 2404 name = vim_strsave(lv.ll_tv->vval.v_string); 2405 *pp = end; 2406 } 2407 else if (lv.ll_tv->v_type == VAR_PARTIAL 2408 && lv.ll_tv->vval.v_partial != NULL) 2409 { 2410 name = vim_strsave(partial_name(lv.ll_tv->vval.v_partial)); 2411 *pp = end; 2412 if (partial != NULL) 2413 *partial = lv.ll_tv->vval.v_partial; 2414 } 2415 else 2416 { 2417 if (!skip && !(flags & TFN_QUIET) && (fdp == NULL 2418 || lv.ll_dict == NULL || fdp->fd_newkey == NULL)) 2419 emsg(_(e_funcref)); 2420 else 2421 *pp = end; 2422 name = NULL; 2423 } 2424 goto theend; 2425 } 2426 2427 if (lv.ll_name == NULL) 2428 { 2429 // Error found, but continue after the function name. 2430 *pp = end; 2431 goto theend; 2432 } 2433 2434 // Check if the name is a Funcref. If so, use the value. 2435 if (lv.ll_exp_name != NULL) 2436 { 2437 len = (int)STRLEN(lv.ll_exp_name); 2438 name = deref_func_name(lv.ll_exp_name, &len, partial, 2439 flags & TFN_NO_AUTOLOAD); 2440 if (name == lv.ll_exp_name) 2441 name = NULL; 2442 } 2443 else if (!(flags & TFN_NO_DEREF)) 2444 { 2445 len = (int)(end - *pp); 2446 name = deref_func_name(*pp, &len, partial, flags & TFN_NO_AUTOLOAD); 2447 if (name == *pp) 2448 name = NULL; 2449 } 2450 if (name != NULL) 2451 { 2452 name = vim_strsave(name); 2453 *pp = end; 2454 if (STRNCMP(name, "<SNR>", 5) == 0) 2455 { 2456 // Change "<SNR>" to the byte sequence. 2457 name[0] = K_SPECIAL; 2458 name[1] = KS_EXTRA; 2459 name[2] = (int)KE_SNR; 2460 mch_memmove(name + 3, name + 5, STRLEN(name + 5) + 1); 2461 } 2462 goto theend; 2463 } 2464 2465 if (lv.ll_exp_name != NULL) 2466 { 2467 len = (int)STRLEN(lv.ll_exp_name); 2468 if (lead <= 2 && lv.ll_name == lv.ll_exp_name 2469 && STRNCMP(lv.ll_name, "s:", 2) == 0) 2470 { 2471 // When there was "s:" already or the name expanded to get a 2472 // leading "s:" then remove it. 2473 lv.ll_name += 2; 2474 len -= 2; 2475 lead = 2; 2476 } 2477 } 2478 else 2479 { 2480 // skip over "s:" and "g:" 2481 if (lead == 2 || (lv.ll_name[0] == 'g' && lv.ll_name[1] == ':')) 2482 { 2483 if (is_global != NULL && lv.ll_name[0] == 'g') 2484 *is_global = TRUE; 2485 lv.ll_name += 2; 2486 } 2487 len = (int)(end - lv.ll_name); 2488 } 2489 2490 // In Vim9 script a user function is script-local by default. 2491 vim9script = ASCII_ISUPPER(*start) && in_vim9script(); 2492 2493 /* 2494 * Copy the function name to allocated memory. 2495 * Accept <SID>name() inside a script, translate into <SNR>123_name(). 2496 * Accept <SNR>123_name() outside a script. 2497 */ 2498 if (skip) 2499 lead = 0; // do nothing 2500 else if (lead > 0 || vim9script) 2501 { 2502 if (!vim9script) 2503 lead = 3; 2504 if (vim9script || (lv.ll_exp_name != NULL 2505 && eval_fname_sid(lv.ll_exp_name)) 2506 || eval_fname_sid(*pp)) 2507 { 2508 // It's script-local, "s:" or "<SID>" 2509 if (current_sctx.sc_sid <= 0) 2510 { 2511 emsg(_(e_usingsid)); 2512 goto theend; 2513 } 2514 sprintf((char *)sid_buf, "%ld_", (long)current_sctx.sc_sid); 2515 if (vim9script) 2516 extra = 3 + (int)STRLEN(sid_buf); 2517 else 2518 lead += (int)STRLEN(sid_buf); 2519 } 2520 } 2521 else if (!(flags & TFN_INT) && builtin_function(lv.ll_name, len)) 2522 { 2523 semsg(_("E128: Function name must start with a capital or \"s:\": %s"), 2524 start); 2525 goto theend; 2526 } 2527 if (!skip && !(flags & TFN_QUIET) && !(flags & TFN_NO_DEREF)) 2528 { 2529 char_u *cp = vim_strchr(lv.ll_name, ':'); 2530 2531 if (cp != NULL && cp < end) 2532 { 2533 semsg(_("E884: Function name cannot contain a colon: %s"), start); 2534 goto theend; 2535 } 2536 } 2537 2538 name = alloc(len + lead + extra + 1); 2539 if (name != NULL) 2540 { 2541 if (!skip && (lead > 0 || vim9script)) 2542 { 2543 name[0] = K_SPECIAL; 2544 name[1] = KS_EXTRA; 2545 name[2] = (int)KE_SNR; 2546 if (vim9script || lead > 3) // If it's "<SID>" 2547 STRCPY(name + 3, sid_buf); 2548 } 2549 mch_memmove(name + lead + extra, lv.ll_name, (size_t)len); 2550 name[lead + extra + len] = NUL; 2551 } 2552 *pp = end; 2553 2554 theend: 2555 clear_lval(&lv); 2556 return name; 2557 } 2558 2559 /* 2560 * Assuming "name" is the result of trans_function_name() and it was prefixed 2561 * to use the script-local name, return the unmodified name (points into 2562 * "name"). Otherwise return NULL. 2563 * This can be used to first search for a script-local function and fall back 2564 * to the global function if not found. 2565 */ 2566 char_u * 2567 untrans_function_name(char_u *name) 2568 { 2569 char_u *p; 2570 2571 if (*name == K_SPECIAL && in_vim9script()) 2572 { 2573 p = vim_strchr(name, '_'); 2574 if (p != NULL) 2575 return p + 1; 2576 } 2577 return NULL; 2578 } 2579 2580 /* 2581 * List functions. When "regmatch" is NULL all of then. 2582 * Otherwise functions matching "regmatch". 2583 */ 2584 static void 2585 list_functions(regmatch_T *regmatch) 2586 { 2587 int changed = func_hashtab.ht_changed; 2588 long_u todo = func_hashtab.ht_used; 2589 hashitem_T *hi; 2590 2591 for (hi = func_hashtab.ht_array; todo > 0 && !got_int; ++hi) 2592 { 2593 if (!HASHITEM_EMPTY(hi)) 2594 { 2595 ufunc_T *fp = HI2UF(hi); 2596 2597 --todo; 2598 if ((fp->uf_flags & FC_DEAD) == 0 2599 && (regmatch == NULL 2600 ? !message_filtered(fp->uf_name) 2601 && !func_name_refcount(fp->uf_name) 2602 : !isdigit(*fp->uf_name) 2603 && vim_regexec(regmatch, fp->uf_name, 0))) 2604 { 2605 list_func_head(fp, FALSE); 2606 if (changed != func_hashtab.ht_changed) 2607 { 2608 emsg(_("E454: function list was modified")); 2609 return; 2610 } 2611 } 2612 } 2613 } 2614 } 2615 2616 /* 2617 * ":function" also supporting nested ":def". 2618 * When "name_arg" is not NULL this is a nested function, using "name_arg" for 2619 * the function name. 2620 * Returns a pointer to the function or NULL if no function defined. 2621 */ 2622 ufunc_T * 2623 def_function(exarg_T *eap, char_u *name_arg) 2624 { 2625 char_u *theline; 2626 char_u *line_to_free = NULL; 2627 int j; 2628 int c; 2629 int saved_did_emsg; 2630 int saved_wait_return = need_wait_return; 2631 char_u *name = name_arg; 2632 int is_global = FALSE; 2633 char_u *p; 2634 char_u *arg; 2635 char_u *line_arg = NULL; 2636 garray_T newargs; 2637 garray_T argtypes; 2638 garray_T default_args; 2639 garray_T newlines; 2640 int varargs = FALSE; 2641 int flags = 0; 2642 char_u *ret_type = NULL; 2643 ufunc_T *fp = NULL; 2644 int overwrite = FALSE; 2645 int indent; 2646 int nesting; 2647 #define MAX_FUNC_NESTING 50 2648 char nesting_def[MAX_FUNC_NESTING]; 2649 dictitem_T *v; 2650 funcdict_T fudi; 2651 static int func_nr = 0; // number for nameless function 2652 int paren; 2653 hashitem_T *hi; 2654 int do_concat = TRUE; 2655 linenr_T sourcing_lnum_off; 2656 linenr_T sourcing_lnum_top; 2657 int is_heredoc = FALSE; 2658 char_u *skip_until = NULL; 2659 char_u *heredoc_trimmed = NULL; 2660 int vim9script = in_vim9script(); 2661 imported_T *import = NULL; 2662 2663 /* 2664 * ":function" without argument: list functions. 2665 */ 2666 if (ends_excmd2(eap->cmd, eap->arg)) 2667 { 2668 if (!eap->skip) 2669 list_functions(NULL); 2670 eap->nextcmd = check_nextcmd(eap->arg); 2671 return NULL; 2672 } 2673 2674 /* 2675 * ":function /pat": list functions matching pattern. 2676 */ 2677 if (*eap->arg == '/') 2678 { 2679 p = skip_regexp(eap->arg + 1, '/', TRUE); 2680 if (!eap->skip) 2681 { 2682 regmatch_T regmatch; 2683 2684 c = *p; 2685 *p = NUL; 2686 regmatch.regprog = vim_regcomp(eap->arg + 1, RE_MAGIC); 2687 *p = c; 2688 if (regmatch.regprog != NULL) 2689 { 2690 regmatch.rm_ic = p_ic; 2691 list_functions(®match); 2692 vim_regfree(regmatch.regprog); 2693 } 2694 } 2695 if (*p == '/') 2696 ++p; 2697 eap->nextcmd = check_nextcmd(p); 2698 return NULL; 2699 } 2700 2701 ga_init(&newargs); 2702 ga_init(&argtypes); 2703 ga_init(&default_args); 2704 2705 /* 2706 * Get the function name. There are these situations: 2707 * func normal function name 2708 * "name" == func, "fudi.fd_dict" == NULL 2709 * dict.func new dictionary entry 2710 * "name" == NULL, "fudi.fd_dict" set, 2711 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func 2712 * dict.func existing dict entry with a Funcref 2713 * "name" == func, "fudi.fd_dict" set, 2714 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL 2715 * dict.func existing dict entry that's not a Funcref 2716 * "name" == NULL, "fudi.fd_dict" set, 2717 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL 2718 * s:func script-local function name 2719 * g:func global function name, same as "func" 2720 */ 2721 p = eap->arg; 2722 if (name_arg != NULL) 2723 { 2724 // nested function, argument is (args). 2725 paren = TRUE; 2726 CLEAR_FIELD(fudi); 2727 } 2728 else 2729 { 2730 name = trans_function_name(&p, &is_global, eap->skip, 2731 TFN_NO_AUTOLOAD, &fudi, NULL); 2732 paren = (vim_strchr(p, '(') != NULL); 2733 if (name == NULL && (fudi.fd_dict == NULL || !paren) && !eap->skip) 2734 { 2735 /* 2736 * Return on an invalid expression in braces, unless the expression 2737 * evaluation has been cancelled due to an aborting error, an 2738 * interrupt, or an exception. 2739 */ 2740 if (!aborting()) 2741 { 2742 if (!eap->skip && fudi.fd_newkey != NULL) 2743 semsg(_(e_dictkey), fudi.fd_newkey); 2744 vim_free(fudi.fd_newkey); 2745 return NULL; 2746 } 2747 else 2748 eap->skip = TRUE; 2749 } 2750 } 2751 2752 // An error in a function call during evaluation of an expression in magic 2753 // braces should not cause the function not to be defined. 2754 saved_did_emsg = did_emsg; 2755 did_emsg = FALSE; 2756 2757 /* 2758 * ":function func" with only function name: list function. 2759 */ 2760 if (!paren) 2761 { 2762 if (!ends_excmd(*skipwhite(p))) 2763 { 2764 semsg(_(e_trailing_arg), p); 2765 goto ret_free; 2766 } 2767 eap->nextcmd = check_nextcmd(p); 2768 if (eap->nextcmd != NULL) 2769 *p = NUL; 2770 if (!eap->skip && !got_int) 2771 { 2772 fp = find_func(name, is_global, NULL); 2773 if (fp == NULL && ASCII_ISUPPER(*eap->arg)) 2774 { 2775 char_u *up = untrans_function_name(name); 2776 2777 // With Vim9 script the name was made script-local, if not 2778 // found try again with the original name. 2779 if (up != NULL) 2780 fp = find_func(up, FALSE, NULL); 2781 } 2782 2783 if (fp != NULL) 2784 { 2785 list_func_head(fp, TRUE); 2786 for (j = 0; j < fp->uf_lines.ga_len && !got_int; ++j) 2787 { 2788 if (FUNCLINE(fp, j) == NULL) 2789 continue; 2790 msg_putchar('\n'); 2791 msg_outnum((long)(j + 1)); 2792 if (j < 9) 2793 msg_putchar(' '); 2794 if (j < 99) 2795 msg_putchar(' '); 2796 msg_prt_line(FUNCLINE(fp, j), FALSE); 2797 out_flush(); // show a line at a time 2798 ui_breakcheck(); 2799 } 2800 if (!got_int) 2801 { 2802 msg_putchar('\n'); 2803 if (fp->uf_def_status != UF_NOT_COMPILED) 2804 msg_puts(" enddef"); 2805 else 2806 msg_puts(" endfunction"); 2807 } 2808 } 2809 else 2810 emsg_funcname(N_("E123: Undefined function: %s"), eap->arg); 2811 } 2812 goto ret_free; 2813 } 2814 2815 /* 2816 * ":function name(arg1, arg2)" Define function. 2817 */ 2818 p = skipwhite(p); 2819 if (*p != '(') 2820 { 2821 if (!eap->skip) 2822 { 2823 semsg(_("E124: Missing '(': %s"), eap->arg); 2824 goto ret_free; 2825 } 2826 // attempt to continue by skipping some text 2827 if (vim_strchr(p, '(') != NULL) 2828 p = vim_strchr(p, '('); 2829 } 2830 p = skipwhite(p + 1); 2831 2832 // In Vim9 script only global functions can be redefined. 2833 if (vim9script && eap->forceit && !is_global) 2834 { 2835 emsg(_(e_nobang)); 2836 goto ret_free; 2837 } 2838 2839 ga_init2(&newlines, (int)sizeof(char_u *), 3); 2840 2841 if (!eap->skip && name_arg == NULL) 2842 { 2843 // Check the name of the function. Unless it's a dictionary function 2844 // (that we are overwriting). 2845 if (name != NULL) 2846 arg = name; 2847 else 2848 arg = fudi.fd_newkey; 2849 if (arg != NULL && (fudi.fd_di == NULL 2850 || (fudi.fd_di->di_tv.v_type != VAR_FUNC 2851 && fudi.fd_di->di_tv.v_type != VAR_PARTIAL))) 2852 { 2853 if (*arg == K_SPECIAL) 2854 j = 3; 2855 else 2856 j = 0; 2857 while (arg[j] != NUL && (j == 0 ? eval_isnamec1(arg[j]) 2858 : eval_isnamec(arg[j]))) 2859 ++j; 2860 if (arg[j] != NUL) 2861 emsg_funcname((char *)e_invarg2, arg); 2862 } 2863 // Disallow using the g: dict. 2864 if (fudi.fd_dict != NULL && fudi.fd_dict->dv_scope == VAR_DEF_SCOPE) 2865 emsg(_("E862: Cannot use g: here")); 2866 } 2867 2868 // This may get more lines and make the pointers into the first line 2869 // invalid. 2870 if (get_function_args(&p, ')', &newargs, 2871 eap->cmdidx == CMD_def ? &argtypes : NULL, 2872 &varargs, &default_args, eap->skip, 2873 eap, &line_to_free) == FAIL) 2874 goto errret_2; 2875 2876 if (eap->cmdidx == CMD_def) 2877 { 2878 // find the return type: :def Func(): type 2879 if (*p == ':') 2880 { 2881 ret_type = skipwhite(p + 1); 2882 p = skip_type(ret_type, FALSE); 2883 if (p > ret_type) 2884 { 2885 ret_type = vim_strnsave(ret_type, p - ret_type); 2886 p = skipwhite(p); 2887 } 2888 else 2889 { 2890 semsg(_(e_expected_type_str), ret_type); 2891 ret_type = NULL; 2892 } 2893 } 2894 p = skipwhite(p); 2895 } 2896 else 2897 // find extra arguments "range", "dict", "abort" and "closure" 2898 for (;;) 2899 { 2900 p = skipwhite(p); 2901 if (STRNCMP(p, "range", 5) == 0) 2902 { 2903 flags |= FC_RANGE; 2904 p += 5; 2905 } 2906 else if (STRNCMP(p, "dict", 4) == 0) 2907 { 2908 flags |= FC_DICT; 2909 p += 4; 2910 } 2911 else if (STRNCMP(p, "abort", 5) == 0) 2912 { 2913 flags |= FC_ABORT; 2914 p += 5; 2915 } 2916 else if (STRNCMP(p, "closure", 7) == 0) 2917 { 2918 flags |= FC_CLOSURE; 2919 p += 7; 2920 if (current_funccal == NULL) 2921 { 2922 emsg_funcname(N_("E932: Closure function should not be at top level: %s"), 2923 name == NULL ? (char_u *)"" : name); 2924 goto erret; 2925 } 2926 } 2927 else 2928 break; 2929 } 2930 2931 // When there is a line break use what follows for the function body. 2932 // Makes 'exe "func Test()\n...\nendfunc"' work. 2933 if (*p == '\n') 2934 line_arg = p + 1; 2935 else if (*p != NUL 2936 && !(*p == '"' && (!vim9script || eap->cmdidx == CMD_function) 2937 && eap->cmdidx != CMD_def) 2938 && !(*p == '#' && (vim9script || eap->cmdidx == CMD_def)) 2939 && !eap->skip 2940 && !did_emsg) 2941 semsg(_(e_trailing_arg), p); 2942 2943 /* 2944 * Read the body of the function, until "}", ":endfunction" or ":enddef" is 2945 * found. 2946 */ 2947 if (KeyTyped) 2948 { 2949 // Check if the function already exists, don't let the user type the 2950 // whole function before telling him it doesn't work! For a script we 2951 // need to skip the body to be able to find what follows. 2952 if (!eap->skip && !eap->forceit) 2953 { 2954 if (fudi.fd_dict != NULL && fudi.fd_newkey == NULL) 2955 emsg(_(e_funcdict)); 2956 else if (name != NULL && find_func(name, is_global, NULL) != NULL) 2957 emsg_funcname(e_funcexts, name); 2958 } 2959 2960 if (!eap->skip && did_emsg) 2961 goto erret; 2962 2963 msg_putchar('\n'); // don't overwrite the function name 2964 cmdline_row = msg_row; 2965 } 2966 2967 // Save the starting line number. 2968 sourcing_lnum_top = SOURCING_LNUM; 2969 2970 // Detect having skipped over comment lines to find the return 2971 // type. Add NULL lines to keep the line count correct. 2972 sourcing_lnum_off = get_sourced_lnum(eap->getline, eap->cookie); 2973 if (SOURCING_LNUM < sourcing_lnum_off) 2974 { 2975 sourcing_lnum_off -= SOURCING_LNUM; 2976 if (ga_grow(&newlines, sourcing_lnum_off) == FAIL) 2977 goto erret; 2978 while (sourcing_lnum_off-- > 0) 2979 ((char_u **)(newlines.ga_data))[newlines.ga_len++] = NULL; 2980 } 2981 2982 indent = 2; 2983 nesting = 0; 2984 nesting_def[nesting] = (eap->cmdidx == CMD_def); 2985 for (;;) 2986 { 2987 if (KeyTyped) 2988 { 2989 msg_scroll = TRUE; 2990 saved_wait_return = FALSE; 2991 } 2992 need_wait_return = FALSE; 2993 2994 if (line_arg != NULL) 2995 { 2996 // Use eap->arg, split up in parts by line breaks. 2997 theline = line_arg; 2998 p = vim_strchr(theline, '\n'); 2999 if (p == NULL) 3000 line_arg += STRLEN(line_arg); 3001 else 3002 { 3003 *p = NUL; 3004 line_arg = p + 1; 3005 } 3006 } 3007 else 3008 { 3009 vim_free(line_to_free); 3010 if (eap->getline == NULL) 3011 theline = getcmdline(':', 0L, indent, do_concat); 3012 else 3013 theline = eap->getline(':', eap->cookie, indent, do_concat); 3014 line_to_free = theline; 3015 } 3016 if (KeyTyped) 3017 lines_left = Rows - 1; 3018 if (theline == NULL) 3019 { 3020 if (eap->cmdidx == CMD_def) 3021 emsg(_(e_missing_enddef)); 3022 else 3023 emsg(_("E126: Missing :endfunction")); 3024 goto erret; 3025 } 3026 3027 // Detect line continuation: SOURCING_LNUM increased more than one. 3028 sourcing_lnum_off = get_sourced_lnum(eap->getline, eap->cookie); 3029 if (SOURCING_LNUM < sourcing_lnum_off) 3030 sourcing_lnum_off -= SOURCING_LNUM; 3031 else 3032 sourcing_lnum_off = 0; 3033 3034 if (skip_until != NULL) 3035 { 3036 // Don't check for ":endfunc"/":enddef" between 3037 // * ":append" and "." 3038 // * ":python <<EOF" and "EOF" 3039 // * ":let {var-name} =<< [trim] {marker}" and "{marker}" 3040 if (heredoc_trimmed == NULL 3041 || (is_heredoc && skipwhite(theline) == theline) 3042 || STRNCMP(theline, heredoc_trimmed, 3043 STRLEN(heredoc_trimmed)) == 0) 3044 { 3045 if (heredoc_trimmed == NULL) 3046 p = theline; 3047 else if (is_heredoc) 3048 p = skipwhite(theline) == theline 3049 ? theline : theline + STRLEN(heredoc_trimmed); 3050 else 3051 p = theline + STRLEN(heredoc_trimmed); 3052 if (STRCMP(p, skip_until) == 0) 3053 { 3054 VIM_CLEAR(skip_until); 3055 VIM_CLEAR(heredoc_trimmed); 3056 do_concat = TRUE; 3057 is_heredoc = FALSE; 3058 } 3059 } 3060 } 3061 else 3062 { 3063 // skip ':' and blanks 3064 for (p = theline; VIM_ISWHITE(*p) || *p == ':'; ++p) 3065 ; 3066 3067 // Check for "endfunction" or "enddef". 3068 if (checkforcmd(&p, nesting_def[nesting] 3069 ? "enddef" : "endfunction", 4) && nesting-- == 0) 3070 { 3071 char_u *nextcmd = NULL; 3072 3073 if (*p == '|') 3074 nextcmd = p + 1; 3075 else if (line_arg != NULL && *skipwhite(line_arg) != NUL) 3076 nextcmd = line_arg; 3077 else if (*p != NUL && *p != '"' && p_verbose > 0) 3078 give_warning2(eap->cmdidx == CMD_def 3079 ? (char_u *)_("W1001: Text found after :enddef: %s") 3080 : (char_u *)_("W22: Text found after :endfunction: %s"), 3081 p, TRUE); 3082 if (nextcmd != NULL) 3083 { 3084 // Another command follows. If the line came from "eap" we 3085 // can simply point into it, otherwise we need to change 3086 // "eap->cmdlinep". 3087 eap->nextcmd = nextcmd; 3088 if (line_to_free != NULL) 3089 { 3090 vim_free(*eap->cmdlinep); 3091 *eap->cmdlinep = line_to_free; 3092 line_to_free = NULL; 3093 } 3094 } 3095 break; 3096 } 3097 3098 // Increase indent inside "if", "while", "for" and "try", decrease 3099 // at "end". 3100 if (indent > 2 && (*p == '}' || STRNCMP(p, "end", 3) == 0)) 3101 indent -= 2; 3102 else if (STRNCMP(p, "if", 2) == 0 3103 || STRNCMP(p, "wh", 2) == 0 3104 || STRNCMP(p, "for", 3) == 0 3105 || STRNCMP(p, "try", 3) == 0) 3106 indent += 2; 3107 3108 // Check for defining a function inside this function. 3109 // Only recognize "def" inside "def", not inside "function", 3110 // For backwards compatibility, see Test_function_python(). 3111 c = *p; 3112 if (checkforcmd(&p, "function", 2) 3113 || (eap->cmdidx == CMD_def && checkforcmd(&p, "def", 3))) 3114 { 3115 if (*p == '!') 3116 p = skipwhite(p + 1); 3117 p += eval_fname_script(p); 3118 vim_free(trans_function_name(&p, NULL, TRUE, 0, NULL, NULL)); 3119 if (*skipwhite(p) == '(') 3120 { 3121 if (nesting == MAX_FUNC_NESTING - 1) 3122 emsg(_(e_function_nesting_too_deep)); 3123 else 3124 { 3125 ++nesting; 3126 nesting_def[nesting] = (c == 'd'); 3127 indent += 2; 3128 } 3129 } 3130 } 3131 3132 // Check for ":append", ":change", ":insert". Not for :def. 3133 p = skip_range(p, NULL); 3134 if (eap->cmdidx != CMD_def 3135 && ((p[0] == 'a' && (!ASCII_ISALPHA(p[1]) || p[1] == 'p')) 3136 || (p[0] == 'c' 3137 && (!ASCII_ISALPHA(p[1]) || (p[1] == 'h' 3138 && (!ASCII_ISALPHA(p[2]) || (p[2] == 'a' 3139 && (STRNCMP(&p[3], "nge", 3) != 0 3140 || !ASCII_ISALPHA(p[6]))))))) 3141 || (p[0] == 'i' 3142 && (!ASCII_ISALPHA(p[1]) || (p[1] == 'n' 3143 && (!ASCII_ISALPHA(p[2]) 3144 || (p[2] == 's' 3145 && (!ASCII_ISALPHA(p[3]) 3146 || p[3] == 'e')))))))) 3147 skip_until = vim_strsave((char_u *)"."); 3148 3149 // Check for ":python <<EOF", ":tcl <<EOF", etc. 3150 arg = skipwhite(skiptowhite(p)); 3151 if (arg[0] == '<' && arg[1] =='<' 3152 && ((p[0] == 'p' && p[1] == 'y' 3153 && (!ASCII_ISALNUM(p[2]) || p[2] == 't' 3154 || ((p[2] == '3' || p[2] == 'x') 3155 && !ASCII_ISALPHA(p[3])))) 3156 || (p[0] == 'p' && p[1] == 'e' 3157 && (!ASCII_ISALPHA(p[2]) || p[2] == 'r')) 3158 || (p[0] == 't' && p[1] == 'c' 3159 && (!ASCII_ISALPHA(p[2]) || p[2] == 'l')) 3160 || (p[0] == 'l' && p[1] == 'u' && p[2] == 'a' 3161 && !ASCII_ISALPHA(p[3])) 3162 || (p[0] == 'r' && p[1] == 'u' && p[2] == 'b' 3163 && (!ASCII_ISALPHA(p[3]) || p[3] == 'y')) 3164 || (p[0] == 'm' && p[1] == 'z' 3165 && (!ASCII_ISALPHA(p[2]) || p[2] == 's')) 3166 )) 3167 { 3168 // ":python <<" continues until a dot, like ":append" 3169 p = skipwhite(arg + 2); 3170 if (STRNCMP(p, "trim", 4) == 0) 3171 { 3172 // Ignore leading white space. 3173 p = skipwhite(p + 4); 3174 heredoc_trimmed = vim_strnsave(theline, 3175 skipwhite(theline) - theline); 3176 } 3177 if (*p == NUL) 3178 skip_until = vim_strsave((char_u *)"."); 3179 else 3180 skip_until = vim_strnsave(p, skiptowhite(p) - p); 3181 do_concat = FALSE; 3182 is_heredoc = TRUE; 3183 } 3184 3185 // Check for ":let v =<< [trim] EOF" 3186 // and ":let [a, b] =<< [trim] EOF" 3187 arg = skipwhite(skiptowhite(p)); 3188 if (*arg == '[') 3189 arg = vim_strchr(arg, ']'); 3190 if (arg != NULL) 3191 { 3192 arg = skipwhite(skiptowhite(arg)); 3193 if ( arg[0] == '=' && arg[1] == '<' && arg[2] =='<' 3194 && ((p[0] == 'l' 3195 && p[1] == 'e' 3196 && (!ASCII_ISALNUM(p[2]) 3197 || (p[2] == 't' && !ASCII_ISALNUM(p[3])))))) 3198 { 3199 p = skipwhite(arg + 3); 3200 if (STRNCMP(p, "trim", 4) == 0) 3201 { 3202 // Ignore leading white space. 3203 p = skipwhite(p + 4); 3204 heredoc_trimmed = vim_strnsave(theline, 3205 skipwhite(theline) - theline); 3206 } 3207 skip_until = vim_strnsave(p, skiptowhite(p) - p); 3208 do_concat = FALSE; 3209 is_heredoc = TRUE; 3210 } 3211 } 3212 } 3213 3214 // Add the line to the function. 3215 if (ga_grow(&newlines, 1 + sourcing_lnum_off) == FAIL) 3216 goto erret; 3217 3218 // Copy the line to newly allocated memory. get_one_sourceline() 3219 // allocates 250 bytes per line, this saves 80% on average. The cost 3220 // is an extra alloc/free. 3221 p = vim_strsave(theline); 3222 if (p == NULL) 3223 goto erret; 3224 ((char_u **)(newlines.ga_data))[newlines.ga_len++] = p; 3225 3226 // Add NULL lines for continuation lines, so that the line count is 3227 // equal to the index in the growarray. 3228 while (sourcing_lnum_off-- > 0) 3229 ((char_u **)(newlines.ga_data))[newlines.ga_len++] = NULL; 3230 3231 // Check for end of eap->arg. 3232 if (line_arg != NULL && *line_arg == NUL) 3233 line_arg = NULL; 3234 } 3235 3236 // Don't define the function when skipping commands or when an error was 3237 // detected. 3238 if (eap->skip || did_emsg) 3239 goto erret; 3240 3241 /* 3242 * If there are no errors, add the function 3243 */ 3244 if (fudi.fd_dict == NULL) 3245 { 3246 hashtab_T *ht; 3247 3248 v = find_var(name, &ht, FALSE); 3249 if (v != NULL && v->di_tv.v_type == VAR_FUNC) 3250 { 3251 emsg_funcname(N_("E707: Function name conflicts with variable: %s"), 3252 name); 3253 goto erret; 3254 } 3255 3256 fp = find_func_even_dead(name, is_global, NULL); 3257 if (vim9script) 3258 { 3259 char_u *uname = untrans_function_name(name); 3260 3261 import = find_imported(uname == NULL ? name : uname, 0, NULL); 3262 } 3263 3264 if (fp != NULL || import != NULL) 3265 { 3266 int dead = fp != NULL && (fp->uf_flags & FC_DEAD); 3267 3268 // Function can be replaced with "function!" and when sourcing the 3269 // same script again, but only once. 3270 // A name that is used by an import can not be overruled. 3271 if (import != NULL 3272 || (!dead && !eap->forceit 3273 && (fp->uf_script_ctx.sc_sid != current_sctx.sc_sid 3274 || fp->uf_script_ctx.sc_seq == current_sctx.sc_seq))) 3275 { 3276 if (vim9script) 3277 emsg_funcname(e_name_already_defined, name); 3278 else 3279 emsg_funcname(e_funcexts, name); 3280 goto erret; 3281 } 3282 if (fp->uf_calls > 0) 3283 { 3284 emsg_funcname( 3285 N_("E127: Cannot redefine function %s: It is in use"), 3286 name); 3287 goto erret; 3288 } 3289 if (fp->uf_refcount > 1) 3290 { 3291 // This function is referenced somewhere, don't redefine it but 3292 // create a new one. 3293 --fp->uf_refcount; 3294 fp->uf_flags |= FC_REMOVED; 3295 fp = NULL; 3296 overwrite = TRUE; 3297 } 3298 else 3299 { 3300 char_u *exp_name = fp->uf_name_exp; 3301 3302 // redefine existing function, keep the expanded name 3303 VIM_CLEAR(name); 3304 fp->uf_name_exp = NULL; 3305 func_clear_items(fp); 3306 fp->uf_name_exp = exp_name; 3307 fp->uf_flags &= ~FC_DEAD; 3308 #ifdef FEAT_PROFILE 3309 fp->uf_profiling = FALSE; 3310 fp->uf_prof_initialized = FALSE; 3311 #endif 3312 clear_def_function(fp); 3313 } 3314 } 3315 } 3316 else 3317 { 3318 char numbuf[20]; 3319 3320 fp = NULL; 3321 if (fudi.fd_newkey == NULL && !eap->forceit) 3322 { 3323 emsg(_(e_funcdict)); 3324 goto erret; 3325 } 3326 if (fudi.fd_di == NULL) 3327 { 3328 // Can't add a function to a locked dictionary 3329 if (var_check_lock(fudi.fd_dict->dv_lock, eap->arg, FALSE)) 3330 goto erret; 3331 } 3332 // Can't change an existing function if it is locked 3333 else if (var_check_lock(fudi.fd_di->di_tv.v_lock, eap->arg, FALSE)) 3334 goto erret; 3335 3336 // Give the function a sequential number. Can only be used with a 3337 // Funcref! 3338 vim_free(name); 3339 sprintf(numbuf, "%d", ++func_nr); 3340 name = vim_strsave((char_u *)numbuf); 3341 if (name == NULL) 3342 goto erret; 3343 } 3344 3345 if (fp == NULL) 3346 { 3347 if (fudi.fd_dict == NULL && vim_strchr(name, AUTOLOAD_CHAR) != NULL) 3348 { 3349 int slen, plen; 3350 char_u *scriptname; 3351 3352 // Check that the autoload name matches the script name. 3353 j = FAIL; 3354 if (SOURCING_NAME != NULL) 3355 { 3356 scriptname = autoload_name(name); 3357 if (scriptname != NULL) 3358 { 3359 p = vim_strchr(scriptname, '/'); 3360 plen = (int)STRLEN(p); 3361 slen = (int)STRLEN(SOURCING_NAME); 3362 if (slen > plen && fnamecmp(p, 3363 SOURCING_NAME + slen - plen) == 0) 3364 j = OK; 3365 vim_free(scriptname); 3366 } 3367 } 3368 if (j == FAIL) 3369 { 3370 semsg(_("E746: Function name does not match script file name: %s"), name); 3371 goto erret; 3372 } 3373 } 3374 3375 fp = alloc_clear(offsetof(ufunc_T, uf_name) + STRLEN(name) + 1); 3376 if (fp == NULL) 3377 goto erret; 3378 fp->uf_def_status = eap->cmdidx == CMD_def ? UF_TO_BE_COMPILED 3379 : UF_NOT_COMPILED; 3380 3381 if (fudi.fd_dict != NULL) 3382 { 3383 if (fudi.fd_di == NULL) 3384 { 3385 // add new dict entry 3386 fudi.fd_di = dictitem_alloc(fudi.fd_newkey); 3387 if (fudi.fd_di == NULL) 3388 { 3389 vim_free(fp); 3390 fp = NULL; 3391 goto erret; 3392 } 3393 if (dict_add(fudi.fd_dict, fudi.fd_di) == FAIL) 3394 { 3395 vim_free(fudi.fd_di); 3396 vim_free(fp); 3397 fp = NULL; 3398 goto erret; 3399 } 3400 } 3401 else 3402 // overwrite existing dict entry 3403 clear_tv(&fudi.fd_di->di_tv); 3404 fudi.fd_di->di_tv.v_type = VAR_FUNC; 3405 fudi.fd_di->di_tv.vval.v_string = vim_strsave(name); 3406 3407 // behave like "dict" was used 3408 flags |= FC_DICT; 3409 } 3410 3411 // insert the new function in the function list 3412 set_ufunc_name(fp, name); 3413 if (overwrite) 3414 { 3415 hi = hash_find(&func_hashtab, name); 3416 hi->hi_key = UF2HIKEY(fp); 3417 } 3418 else if (hash_add(&func_hashtab, UF2HIKEY(fp)) == FAIL) 3419 { 3420 vim_free(fp); 3421 fp = NULL; 3422 goto erret; 3423 } 3424 fp->uf_refcount = 1; 3425 } 3426 fp->uf_args = newargs; 3427 fp->uf_def_args = default_args; 3428 fp->uf_ret_type = &t_any; 3429 fp->uf_func_type = &t_func_any; 3430 3431 if (eap->cmdidx == CMD_def) 3432 { 3433 int lnum_save = SOURCING_LNUM; 3434 3435 fp->uf_def_status = UF_TO_BE_COMPILED; 3436 3437 // error messages are for the first function line 3438 SOURCING_LNUM = sourcing_lnum_top; 3439 3440 // parse the argument types 3441 ga_init2(&fp->uf_type_list, sizeof(type_T *), 10); 3442 3443 if (argtypes.ga_len > 0) 3444 { 3445 // When "varargs" is set the last name/type goes into uf_va_name 3446 // and uf_va_type. 3447 int len = argtypes.ga_len - (varargs ? 1 : 0); 3448 3449 if (len > 0) 3450 fp->uf_arg_types = ALLOC_CLEAR_MULT(type_T *, len); 3451 if (fp->uf_arg_types != NULL) 3452 { 3453 int i; 3454 type_T *type; 3455 3456 for (i = 0; i < len; ++ i) 3457 { 3458 p = ((char_u **)argtypes.ga_data)[i]; 3459 if (p == NULL) 3460 // will get the type from the default value 3461 type = &t_unknown; 3462 else 3463 type = parse_type(&p, &fp->uf_type_list); 3464 if (type == NULL) 3465 { 3466 SOURCING_LNUM = lnum_save; 3467 goto errret_2; 3468 } 3469 fp->uf_arg_types[i] = type; 3470 } 3471 } 3472 if (varargs) 3473 { 3474 // Move the last argument "...name: type" to uf_va_name and 3475 // uf_va_type. 3476 fp->uf_va_name = ((char_u **)fp->uf_args.ga_data) 3477 [fp->uf_args.ga_len - 1]; 3478 --fp->uf_args.ga_len; 3479 p = ((char_u **)argtypes.ga_data)[len]; 3480 if (p == NULL) 3481 // todo: get type from default value 3482 fp->uf_va_type = &t_any; 3483 else 3484 fp->uf_va_type = parse_type(&p, &fp->uf_type_list); 3485 if (fp->uf_va_type == NULL) 3486 { 3487 SOURCING_LNUM = lnum_save; 3488 goto errret_2; 3489 } 3490 } 3491 varargs = FALSE; 3492 } 3493 3494 // parse the return type, if any 3495 if (ret_type == NULL) 3496 fp->uf_ret_type = &t_void; 3497 else 3498 { 3499 p = ret_type; 3500 fp->uf_ret_type = parse_type(&p, &fp->uf_type_list); 3501 } 3502 SOURCING_LNUM = lnum_save; 3503 } 3504 else 3505 fp->uf_def_status = UF_NOT_COMPILED; 3506 3507 fp->uf_lines = newlines; 3508 if ((flags & FC_CLOSURE) != 0) 3509 { 3510 if (register_closure(fp) == FAIL) 3511 goto erret; 3512 } 3513 else 3514 fp->uf_scoped = NULL; 3515 3516 #ifdef FEAT_PROFILE 3517 if (prof_def_func()) 3518 func_do_profile(fp); 3519 #endif 3520 fp->uf_varargs = varargs; 3521 if (sandbox) 3522 flags |= FC_SANDBOX; 3523 if (vim9script && !ASCII_ISUPPER(*fp->uf_name)) 3524 flags |= FC_VIM9; 3525 fp->uf_flags = flags; 3526 fp->uf_calls = 0; 3527 fp->uf_cleared = FALSE; 3528 fp->uf_script_ctx = current_sctx; 3529 fp->uf_script_ctx_version = current_sctx.sc_version; 3530 fp->uf_script_ctx.sc_lnum += sourcing_lnum_top; 3531 if (is_export) 3532 { 3533 fp->uf_flags |= FC_EXPORT; 3534 // let ex_export() know the export worked. 3535 is_export = FALSE; 3536 } 3537 3538 if (eap->cmdidx == CMD_def) 3539 set_function_type(fp); 3540 else if (fp->uf_script_ctx.sc_version == SCRIPT_VERSION_VIM9) 3541 // :func does not use Vim9 script syntax, even in a Vim9 script file 3542 fp->uf_script_ctx.sc_version = SCRIPT_VERSION_MAX; 3543 3544 goto ret_free; 3545 3546 erret: 3547 ga_clear_strings(&newargs); 3548 ga_clear_strings(&default_args); 3549 errret_2: 3550 ga_clear_strings(&newlines); 3551 ret_free: 3552 ga_clear_strings(&argtypes); 3553 vim_free(skip_until); 3554 vim_free(line_to_free); 3555 vim_free(fudi.fd_newkey); 3556 if (name != name_arg) 3557 vim_free(name); 3558 vim_free(ret_type); 3559 did_emsg |= saved_did_emsg; 3560 need_wait_return |= saved_wait_return; 3561 3562 return fp; 3563 } 3564 3565 /* 3566 * ":function" 3567 */ 3568 void 3569 ex_function(exarg_T *eap) 3570 { 3571 (void)def_function(eap, NULL); 3572 } 3573 3574 /* 3575 * :defcompile - compile all :def functions in the current script. 3576 */ 3577 void 3578 ex_defcompile(exarg_T *eap UNUSED) 3579 { 3580 long todo = (long)func_hashtab.ht_used; 3581 int changed = func_hashtab.ht_changed; 3582 hashitem_T *hi; 3583 ufunc_T *ufunc; 3584 3585 for (hi = func_hashtab.ht_array; todo > 0 && !got_int; ++hi) 3586 { 3587 if (!HASHITEM_EMPTY(hi)) 3588 { 3589 --todo; 3590 ufunc = HI2UF(hi); 3591 if (ufunc->uf_script_ctx.sc_sid == current_sctx.sc_sid 3592 && ufunc->uf_def_status == UF_TO_BE_COMPILED) 3593 { 3594 compile_def_function(ufunc, FALSE, NULL); 3595 3596 if (func_hashtab.ht_changed != changed) 3597 { 3598 // a function has been added or removed, need to start over 3599 todo = (long)func_hashtab.ht_used; 3600 changed = func_hashtab.ht_changed; 3601 hi = func_hashtab.ht_array; 3602 --hi; 3603 } 3604 } 3605 } 3606 } 3607 } 3608 3609 /* 3610 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case). 3611 * Return 2 if "p" starts with "s:". 3612 * Return 0 otherwise. 3613 */ 3614 int 3615 eval_fname_script(char_u *p) 3616 { 3617 // Use MB_STRICMP() because in Turkish comparing the "I" may not work with 3618 // the standard library function. 3619 if (p[0] == '<' && (MB_STRNICMP(p + 1, "SID>", 4) == 0 3620 || MB_STRNICMP(p + 1, "SNR>", 4) == 0)) 3621 return 5; 3622 if (p[0] == 's' && p[1] == ':') 3623 return 2; 3624 return 0; 3625 } 3626 3627 int 3628 translated_function_exists(char_u *name, int is_global) 3629 { 3630 if (builtin_function(name, -1)) 3631 return has_internal_func(name); 3632 return find_func(name, is_global, NULL) != NULL; 3633 } 3634 3635 /* 3636 * Return TRUE when "ufunc" has old-style "..." varargs 3637 * or named varargs "...name: type". 3638 */ 3639 int 3640 has_varargs(ufunc_T *ufunc) 3641 { 3642 return ufunc->uf_varargs || ufunc->uf_va_name != NULL; 3643 } 3644 3645 /* 3646 * Return TRUE if a function "name" exists. 3647 * If "no_defef" is TRUE, do not dereference a Funcref. 3648 */ 3649 int 3650 function_exists(char_u *name, int no_deref) 3651 { 3652 char_u *nm = name; 3653 char_u *p; 3654 int n = FALSE; 3655 int flag; 3656 int is_global = FALSE; 3657 3658 flag = TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD; 3659 if (no_deref) 3660 flag |= TFN_NO_DEREF; 3661 p = trans_function_name(&nm, &is_global, FALSE, flag, NULL, NULL); 3662 nm = skipwhite(nm); 3663 3664 // Only accept "funcname", "funcname ", "funcname (..." and 3665 // "funcname(...", not "funcname!...". 3666 if (p != NULL && (*nm == NUL || *nm == '(')) 3667 n = translated_function_exists(p, is_global); 3668 vim_free(p); 3669 return n; 3670 } 3671 3672 #if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) || defined(PROTO) 3673 char_u * 3674 get_expanded_name(char_u *name, int check) 3675 { 3676 char_u *nm = name; 3677 char_u *p; 3678 int is_global = FALSE; 3679 3680 p = trans_function_name(&nm, &is_global, FALSE, 3681 TFN_INT|TFN_QUIET, NULL, NULL); 3682 3683 if (p != NULL && *nm == NUL 3684 && (!check || translated_function_exists(p, is_global))) 3685 return p; 3686 3687 vim_free(p); 3688 return NULL; 3689 } 3690 #endif 3691 3692 /* 3693 * Function given to ExpandGeneric() to obtain the list of user defined 3694 * function names. 3695 */ 3696 char_u * 3697 get_user_func_name(expand_T *xp, int idx) 3698 { 3699 static long_u done; 3700 static int changed; 3701 static hashitem_T *hi; 3702 ufunc_T *fp; 3703 3704 if (idx == 0) 3705 { 3706 done = 0; 3707 hi = func_hashtab.ht_array; 3708 changed = func_hashtab.ht_changed; 3709 } 3710 if (changed == func_hashtab.ht_changed && done < func_hashtab.ht_used) 3711 { 3712 if (done++ > 0) 3713 ++hi; 3714 while (HASHITEM_EMPTY(hi)) 3715 ++hi; 3716 fp = HI2UF(hi); 3717 3718 // don't show dead, dict and lambda functions 3719 if ((fp->uf_flags & FC_DEAD) || (fp->uf_flags & FC_DICT) 3720 || STRNCMP(fp->uf_name, "<lambda>", 8) == 0) 3721 return (char_u *)""; 3722 3723 if (STRLEN(fp->uf_name) + 4 >= IOSIZE) 3724 return fp->uf_name; // prevents overflow 3725 3726 cat_func_name(IObuff, fp); 3727 if (xp->xp_context != EXPAND_USER_FUNC) 3728 { 3729 STRCAT(IObuff, "("); 3730 if (!has_varargs(fp) && fp->uf_args.ga_len == 0) 3731 STRCAT(IObuff, ")"); 3732 } 3733 return IObuff; 3734 } 3735 return NULL; 3736 } 3737 3738 /* 3739 * ":delfunction {name}" 3740 */ 3741 void 3742 ex_delfunction(exarg_T *eap) 3743 { 3744 ufunc_T *fp = NULL; 3745 char_u *p; 3746 char_u *name; 3747 funcdict_T fudi; 3748 int is_global = FALSE; 3749 3750 p = eap->arg; 3751 name = trans_function_name(&p, &is_global, eap->skip, 0, &fudi, NULL); 3752 vim_free(fudi.fd_newkey); 3753 if (name == NULL) 3754 { 3755 if (fudi.fd_dict != NULL && !eap->skip) 3756 emsg(_(e_funcref)); 3757 return; 3758 } 3759 if (!ends_excmd(*skipwhite(p))) 3760 { 3761 vim_free(name); 3762 semsg(_(e_trailing_arg), p); 3763 return; 3764 } 3765 eap->nextcmd = check_nextcmd(p); 3766 if (eap->nextcmd != NULL) 3767 *p = NUL; 3768 3769 if (!eap->skip) 3770 fp = find_func(name, is_global, NULL); 3771 vim_free(name); 3772 3773 if (!eap->skip) 3774 { 3775 if (fp == NULL) 3776 { 3777 if (!eap->forceit) 3778 semsg(_(e_nofunc), eap->arg); 3779 return; 3780 } 3781 if (fp->uf_calls > 0) 3782 { 3783 semsg(_("E131: Cannot delete function %s: It is in use"), eap->arg); 3784 return; 3785 } 3786 if (fp->uf_flags & FC_VIM9) 3787 { 3788 semsg(_(e_cannot_delete_vim9_script_function_str), eap->arg); 3789 return; 3790 } 3791 3792 if (fudi.fd_dict != NULL) 3793 { 3794 // Delete the dict item that refers to the function, it will 3795 // invoke func_unref() and possibly delete the function. 3796 dictitem_remove(fudi.fd_dict, fudi.fd_di); 3797 } 3798 else 3799 { 3800 // A normal function (not a numbered function or lambda) has a 3801 // refcount of 1 for the entry in the hashtable. When deleting 3802 // it and the refcount is more than one, it should be kept. 3803 // A numbered function and lambda should be kept if the refcount is 3804 // one or more. 3805 if (fp->uf_refcount > (func_name_refcount(fp->uf_name) ? 0 : 1)) 3806 { 3807 // Function is still referenced somewhere. Don't free it but 3808 // do remove it from the hashtable. 3809 if (func_remove(fp)) 3810 fp->uf_refcount--; 3811 fp->uf_flags |= FC_DELETED; 3812 } 3813 else 3814 func_clear_free(fp, FALSE); 3815 } 3816 } 3817 } 3818 3819 /* 3820 * Unreference a Function: decrement the reference count and free it when it 3821 * becomes zero. 3822 */ 3823 void 3824 func_unref(char_u *name) 3825 { 3826 ufunc_T *fp = NULL; 3827 3828 if (name == NULL || !func_name_refcount(name)) 3829 return; 3830 fp = find_func(name, FALSE, NULL); 3831 if (fp == NULL && isdigit(*name)) 3832 { 3833 #ifdef EXITFREE 3834 if (!entered_free_all_mem) 3835 #endif 3836 internal_error("func_unref()"); 3837 } 3838 if (fp != NULL && --fp->uf_refcount <= 0) 3839 { 3840 // Only delete it when it's not being used. Otherwise it's done 3841 // when "uf_calls" becomes zero. 3842 if (fp->uf_calls == 0) 3843 func_clear_free(fp, FALSE); 3844 } 3845 } 3846 3847 /* 3848 * Unreference a Function: decrement the reference count and free it when it 3849 * becomes zero. 3850 */ 3851 void 3852 func_ptr_unref(ufunc_T *fp) 3853 { 3854 if (fp != NULL && --fp->uf_refcount <= 0) 3855 { 3856 // Only delete it when it's not being used. Otherwise it's done 3857 // when "uf_calls" becomes zero. 3858 if (fp->uf_calls == 0) 3859 func_clear_free(fp, FALSE); 3860 } 3861 } 3862 3863 /* 3864 * Count a reference to a Function. 3865 */ 3866 void 3867 func_ref(char_u *name) 3868 { 3869 ufunc_T *fp; 3870 3871 if (name == NULL || !func_name_refcount(name)) 3872 return; 3873 fp = find_func(name, FALSE, NULL); 3874 if (fp != NULL) 3875 ++fp->uf_refcount; 3876 else if (isdigit(*name)) 3877 // Only give an error for a numbered function. 3878 // Fail silently, when named or lambda function isn't found. 3879 internal_error("func_ref()"); 3880 } 3881 3882 /* 3883 * Count a reference to a Function. 3884 */ 3885 void 3886 func_ptr_ref(ufunc_T *fp) 3887 { 3888 if (fp != NULL) 3889 ++fp->uf_refcount; 3890 } 3891 3892 /* 3893 * Return TRUE if items in "fc" do not have "copyID". That means they are not 3894 * referenced from anywhere that is in use. 3895 */ 3896 static int 3897 can_free_funccal(funccall_T *fc, int copyID) 3898 { 3899 return (fc->l_varlist.lv_copyID != copyID 3900 && fc->l_vars.dv_copyID != copyID 3901 && fc->l_avars.dv_copyID != copyID 3902 && fc->fc_copyID != copyID); 3903 } 3904 3905 /* 3906 * ":return [expr]" 3907 */ 3908 void 3909 ex_return(exarg_T *eap) 3910 { 3911 char_u *arg = eap->arg; 3912 typval_T rettv; 3913 int returning = FALSE; 3914 evalarg_T evalarg; 3915 3916 if (current_funccal == NULL) 3917 { 3918 emsg(_("E133: :return not inside a function")); 3919 return; 3920 } 3921 3922 CLEAR_FIELD(evalarg); 3923 evalarg.eval_flags = eap->skip ? 0 : EVAL_EVALUATE; 3924 3925 if (eap->skip) 3926 ++emsg_skip; 3927 3928 eap->nextcmd = NULL; 3929 if ((*arg != NUL && *arg != '|' && *arg != '\n') 3930 && eval0(arg, &rettv, eap, &evalarg) != FAIL) 3931 { 3932 if (!eap->skip) 3933 returning = do_return(eap, FALSE, TRUE, &rettv); 3934 else 3935 clear_tv(&rettv); 3936 } 3937 // It's safer to return also on error. 3938 else if (!eap->skip) 3939 { 3940 // In return statement, cause_abort should be force_abort. 3941 update_force_abort(); 3942 3943 /* 3944 * Return unless the expression evaluation has been cancelled due to an 3945 * aborting error, an interrupt, or an exception. 3946 */ 3947 if (!aborting()) 3948 returning = do_return(eap, FALSE, TRUE, NULL); 3949 } 3950 3951 // When skipping or the return gets pending, advance to the next command 3952 // in this line (!returning). Otherwise, ignore the rest of the line. 3953 // Following lines will be ignored by get_func_line(). 3954 if (returning) 3955 eap->nextcmd = NULL; 3956 else if (eap->nextcmd == NULL) // no argument 3957 eap->nextcmd = check_nextcmd(arg); 3958 3959 if (eap->skip) 3960 --emsg_skip; 3961 clear_evalarg(&evalarg, eap); 3962 } 3963 3964 /* 3965 * ":1,25call func(arg1, arg2)" function call. 3966 */ 3967 void 3968 ex_call(exarg_T *eap) 3969 { 3970 char_u *arg = eap->arg; 3971 char_u *startarg; 3972 char_u *name; 3973 char_u *tofree; 3974 int len; 3975 typval_T rettv; 3976 linenr_T lnum; 3977 int doesrange; 3978 int failed = FALSE; 3979 funcdict_T fudi; 3980 partial_T *partial = NULL; 3981 evalarg_T evalarg; 3982 3983 fill_evalarg_from_eap(&evalarg, eap, eap->skip); 3984 if (eap->skip) 3985 { 3986 // trans_function_name() doesn't work well when skipping, use eval0() 3987 // instead to skip to any following command, e.g. for: 3988 // :if 0 | call dict.foo().bar() | endif 3989 ++emsg_skip; 3990 if (eval0(eap->arg, &rettv, eap, &evalarg) != FAIL) 3991 clear_tv(&rettv); 3992 --emsg_skip; 3993 clear_evalarg(&evalarg, eap); 3994 return; 3995 } 3996 3997 tofree = trans_function_name(&arg, NULL, eap->skip, 3998 TFN_INT, &fudi, &partial); 3999 if (fudi.fd_newkey != NULL) 4000 { 4001 // Still need to give an error message for missing key. 4002 semsg(_(e_dictkey), fudi.fd_newkey); 4003 vim_free(fudi.fd_newkey); 4004 } 4005 if (tofree == NULL) 4006 return; 4007 4008 // Increase refcount on dictionary, it could get deleted when evaluating 4009 // the arguments. 4010 if (fudi.fd_dict != NULL) 4011 ++fudi.fd_dict->dv_refcount; 4012 4013 // If it is the name of a variable of type VAR_FUNC or VAR_PARTIAL use its 4014 // contents. For VAR_PARTIAL get its partial, unless we already have one 4015 // from trans_function_name(). 4016 len = (int)STRLEN(tofree); 4017 name = deref_func_name(tofree, &len, 4018 partial != NULL ? NULL : &partial, FALSE); 4019 4020 // Skip white space to allow ":call func ()". Not good, but required for 4021 // backward compatibility. 4022 startarg = skipwhite(arg); 4023 rettv.v_type = VAR_UNKNOWN; // clear_tv() uses this 4024 4025 if (*startarg != '(') 4026 { 4027 semsg(_(e_missing_paren), eap->arg); 4028 goto end; 4029 } 4030 4031 /* 4032 * When skipping, evaluate the function once, to find the end of the 4033 * arguments. 4034 * When the function takes a range, this is discovered after the first 4035 * call, and the loop is broken. 4036 */ 4037 if (eap->skip) 4038 { 4039 ++emsg_skip; 4040 lnum = eap->line2; // do it once, also with an invalid range 4041 } 4042 else 4043 lnum = eap->line1; 4044 for ( ; lnum <= eap->line2; ++lnum) 4045 { 4046 funcexe_T funcexe; 4047 4048 if (!eap->skip && eap->addr_count > 0) 4049 { 4050 if (lnum > curbuf->b_ml.ml_line_count) 4051 { 4052 // If the function deleted lines or switched to another buffer 4053 // the line number may become invalid. 4054 emsg(_(e_invrange)); 4055 break; 4056 } 4057 curwin->w_cursor.lnum = lnum; 4058 curwin->w_cursor.col = 0; 4059 curwin->w_cursor.coladd = 0; 4060 } 4061 arg = startarg; 4062 4063 CLEAR_FIELD(funcexe); 4064 funcexe.firstline = eap->line1; 4065 funcexe.lastline = eap->line2; 4066 funcexe.doesrange = &doesrange; 4067 funcexe.evaluate = !eap->skip; 4068 funcexe.partial = partial; 4069 funcexe.selfdict = fudi.fd_dict; 4070 if (get_func_tv(name, -1, &rettv, &arg, &evalarg, &funcexe) == FAIL) 4071 { 4072 failed = TRUE; 4073 break; 4074 } 4075 if (has_watchexpr()) 4076 dbg_check_breakpoint(eap); 4077 4078 // Handle a function returning a Funcref, Dictionary or List. 4079 if (handle_subscript(&arg, &rettv, 4080 eap->skip ? NULL : &EVALARG_EVALUATE, TRUE) == FAIL) 4081 { 4082 failed = TRUE; 4083 break; 4084 } 4085 4086 clear_tv(&rettv); 4087 if (doesrange || eap->skip) 4088 break; 4089 4090 // Stop when immediately aborting on error, or when an interrupt 4091 // occurred or an exception was thrown but not caught. 4092 // get_func_tv() returned OK, so that the check for trailing 4093 // characters below is executed. 4094 if (aborting()) 4095 break; 4096 } 4097 if (eap->skip) 4098 --emsg_skip; 4099 clear_evalarg(&evalarg, eap); 4100 4101 // When inside :try we need to check for following "| catch". 4102 if (!failed || eap->cstack->cs_trylevel > 0) 4103 { 4104 // Check for trailing illegal characters and a following command. 4105 arg = skipwhite(arg); 4106 if (!ends_excmd2(eap->arg, arg)) 4107 { 4108 if (!failed) 4109 { 4110 emsg_severe = TRUE; 4111 semsg(_(e_trailing_arg), arg); 4112 } 4113 } 4114 else 4115 eap->nextcmd = check_nextcmd(arg); 4116 } 4117 4118 end: 4119 dict_unref(fudi.fd_dict); 4120 vim_free(tofree); 4121 } 4122 4123 /* 4124 * Return from a function. Possibly makes the return pending. Also called 4125 * for a pending return at the ":endtry" or after returning from an extra 4126 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set 4127 * when called due to a ":return" command. "rettv" may point to a typval_T 4128 * with the return rettv. Returns TRUE when the return can be carried out, 4129 * FALSE when the return gets pending. 4130 */ 4131 int 4132 do_return( 4133 exarg_T *eap, 4134 int reanimate, 4135 int is_cmd, 4136 void *rettv) 4137 { 4138 int idx; 4139 cstack_T *cstack = eap->cstack; 4140 4141 if (reanimate) 4142 // Undo the return. 4143 current_funccal->returned = FALSE; 4144 4145 /* 4146 * Cleanup (and inactivate) conditionals, but stop when a try conditional 4147 * not in its finally clause (which then is to be executed next) is found. 4148 * In this case, make the ":return" pending for execution at the ":endtry". 4149 * Otherwise, return normally. 4150 */ 4151 idx = cleanup_conditionals(eap->cstack, 0, TRUE); 4152 if (idx >= 0) 4153 { 4154 cstack->cs_pending[idx] = CSTP_RETURN; 4155 4156 if (!is_cmd && !reanimate) 4157 // A pending return again gets pending. "rettv" points to an 4158 // allocated variable with the rettv of the original ":return"'s 4159 // argument if present or is NULL else. 4160 cstack->cs_rettv[idx] = rettv; 4161 else 4162 { 4163 // When undoing a return in order to make it pending, get the stored 4164 // return rettv. 4165 if (reanimate) 4166 rettv = current_funccal->rettv; 4167 4168 if (rettv != NULL) 4169 { 4170 // Store the value of the pending return. 4171 if ((cstack->cs_rettv[idx] = alloc_tv()) != NULL) 4172 *(typval_T *)cstack->cs_rettv[idx] = *(typval_T *)rettv; 4173 else 4174 emsg(_(e_outofmem)); 4175 } 4176 else 4177 cstack->cs_rettv[idx] = NULL; 4178 4179 if (reanimate) 4180 { 4181 // The pending return value could be overwritten by a ":return" 4182 // without argument in a finally clause; reset the default 4183 // return value. 4184 current_funccal->rettv->v_type = VAR_NUMBER; 4185 current_funccal->rettv->vval.v_number = 0; 4186 } 4187 } 4188 report_make_pending(CSTP_RETURN, rettv); 4189 } 4190 else 4191 { 4192 current_funccal->returned = TRUE; 4193 4194 // If the return is carried out now, store the return value. For 4195 // a return immediately after reanimation, the value is already 4196 // there. 4197 if (!reanimate && rettv != NULL) 4198 { 4199 clear_tv(current_funccal->rettv); 4200 *current_funccal->rettv = *(typval_T *)rettv; 4201 if (!is_cmd) 4202 vim_free(rettv); 4203 } 4204 } 4205 4206 return idx < 0; 4207 } 4208 4209 /* 4210 * Free the variable with a pending return value. 4211 */ 4212 void 4213 discard_pending_return(void *rettv) 4214 { 4215 free_tv((typval_T *)rettv); 4216 } 4217 4218 /* 4219 * Generate a return command for producing the value of "rettv". The result 4220 * is an allocated string. Used by report_pending() for verbose messages. 4221 */ 4222 char_u * 4223 get_return_cmd(void *rettv) 4224 { 4225 char_u *s = NULL; 4226 char_u *tofree = NULL; 4227 char_u numbuf[NUMBUFLEN]; 4228 4229 if (rettv != NULL) 4230 s = echo_string((typval_T *)rettv, &tofree, numbuf, 0); 4231 if (s == NULL) 4232 s = (char_u *)""; 4233 4234 STRCPY(IObuff, ":return "); 4235 STRNCPY(IObuff + 8, s, IOSIZE - 8); 4236 if (STRLEN(s) + 8 >= IOSIZE) 4237 STRCPY(IObuff + IOSIZE - 4, "..."); 4238 vim_free(tofree); 4239 return vim_strsave(IObuff); 4240 } 4241 4242 /* 4243 * Get next function line. 4244 * Called by do_cmdline() to get the next line. 4245 * Returns allocated string, or NULL for end of function. 4246 */ 4247 char_u * 4248 get_func_line( 4249 int c UNUSED, 4250 void *cookie, 4251 int indent UNUSED, 4252 int do_concat UNUSED) 4253 { 4254 funccall_T *fcp = (funccall_T *)cookie; 4255 ufunc_T *fp = fcp->func; 4256 char_u *retval; 4257 garray_T *gap; // growarray with function lines 4258 4259 // If breakpoints have been added/deleted need to check for it. 4260 if (fcp->dbg_tick != debug_tick) 4261 { 4262 fcp->breakpoint = dbg_find_breakpoint(FALSE, fp->uf_name, 4263 SOURCING_LNUM); 4264 fcp->dbg_tick = debug_tick; 4265 } 4266 #ifdef FEAT_PROFILE 4267 if (do_profiling == PROF_YES) 4268 func_line_end(cookie); 4269 #endif 4270 4271 gap = &fp->uf_lines; 4272 if (((fp->uf_flags & FC_ABORT) && did_emsg && !aborted_in_try()) 4273 || fcp->returned) 4274 retval = NULL; 4275 else 4276 { 4277 // Skip NULL lines (continuation lines). 4278 while (fcp->linenr < gap->ga_len 4279 && ((char_u **)(gap->ga_data))[fcp->linenr] == NULL) 4280 ++fcp->linenr; 4281 if (fcp->linenr >= gap->ga_len) 4282 retval = NULL; 4283 else 4284 { 4285 retval = vim_strsave(((char_u **)(gap->ga_data))[fcp->linenr++]); 4286 SOURCING_LNUM = fcp->linenr; 4287 #ifdef FEAT_PROFILE 4288 if (do_profiling == PROF_YES) 4289 func_line_start(cookie); 4290 #endif 4291 } 4292 } 4293 4294 // Did we encounter a breakpoint? 4295 if (fcp->breakpoint != 0 && fcp->breakpoint <= SOURCING_LNUM) 4296 { 4297 dbg_breakpoint(fp->uf_name, SOURCING_LNUM); 4298 // Find next breakpoint. 4299 fcp->breakpoint = dbg_find_breakpoint(FALSE, fp->uf_name, 4300 SOURCING_LNUM); 4301 fcp->dbg_tick = debug_tick; 4302 } 4303 4304 return retval; 4305 } 4306 4307 /* 4308 * Return TRUE if the currently active function should be ended, because a 4309 * return was encountered or an error occurred. Used inside a ":while". 4310 */ 4311 int 4312 func_has_ended(void *cookie) 4313 { 4314 funccall_T *fcp = (funccall_T *)cookie; 4315 4316 // Ignore the "abort" flag if the abortion behavior has been changed due to 4317 // an error inside a try conditional. 4318 return (((fcp->func->uf_flags & FC_ABORT) && did_emsg && !aborted_in_try()) 4319 || fcp->returned); 4320 } 4321 4322 /* 4323 * return TRUE if cookie indicates a function which "abort"s on errors. 4324 */ 4325 int 4326 func_has_abort( 4327 void *cookie) 4328 { 4329 return ((funccall_T *)cookie)->func->uf_flags & FC_ABORT; 4330 } 4331 4332 4333 /* 4334 * Turn "dict.Func" into a partial for "Func" bound to "dict". 4335 * Don't do this when "Func" is already a partial that was bound 4336 * explicitly (pt_auto is FALSE). 4337 * Changes "rettv" in-place. 4338 * Returns the updated "selfdict_in". 4339 */ 4340 dict_T * 4341 make_partial(dict_T *selfdict_in, typval_T *rettv) 4342 { 4343 char_u *fname; 4344 char_u *tofree = NULL; 4345 ufunc_T *fp; 4346 char_u fname_buf[FLEN_FIXED + 1]; 4347 int error; 4348 dict_T *selfdict = selfdict_in; 4349 4350 if (rettv->v_type == VAR_PARTIAL && rettv->vval.v_partial->pt_func != NULL) 4351 fp = rettv->vval.v_partial->pt_func; 4352 else 4353 { 4354 fname = rettv->v_type == VAR_FUNC ? rettv->vval.v_string 4355 : rettv->vval.v_partial->pt_name; 4356 // Translate "s:func" to the stored function name. 4357 fname = fname_trans_sid(fname, fname_buf, &tofree, &error); 4358 fp = find_func(fname, FALSE, NULL); 4359 vim_free(tofree); 4360 } 4361 4362 if (fp != NULL && (fp->uf_flags & FC_DICT)) 4363 { 4364 partial_T *pt = ALLOC_CLEAR_ONE(partial_T); 4365 4366 if (pt != NULL) 4367 { 4368 pt->pt_refcount = 1; 4369 pt->pt_dict = selfdict; 4370 pt->pt_auto = TRUE; 4371 selfdict = NULL; 4372 if (rettv->v_type == VAR_FUNC) 4373 { 4374 // Just a function: Take over the function name and use 4375 // selfdict. 4376 pt->pt_name = rettv->vval.v_string; 4377 } 4378 else 4379 { 4380 partial_T *ret_pt = rettv->vval.v_partial; 4381 int i; 4382 4383 // Partial: copy the function name, use selfdict and copy 4384 // args. Can't take over name or args, the partial might 4385 // be referenced elsewhere. 4386 if (ret_pt->pt_name != NULL) 4387 { 4388 pt->pt_name = vim_strsave(ret_pt->pt_name); 4389 func_ref(pt->pt_name); 4390 } 4391 else 4392 { 4393 pt->pt_func = ret_pt->pt_func; 4394 func_ptr_ref(pt->pt_func); 4395 } 4396 if (ret_pt->pt_argc > 0) 4397 { 4398 pt->pt_argv = ALLOC_MULT(typval_T, ret_pt->pt_argc); 4399 if (pt->pt_argv == NULL) 4400 // out of memory: drop the arguments 4401 pt->pt_argc = 0; 4402 else 4403 { 4404 pt->pt_argc = ret_pt->pt_argc; 4405 for (i = 0; i < pt->pt_argc; i++) 4406 copy_tv(&ret_pt->pt_argv[i], &pt->pt_argv[i]); 4407 } 4408 } 4409 partial_unref(ret_pt); 4410 } 4411 rettv->v_type = VAR_PARTIAL; 4412 rettv->vval.v_partial = pt; 4413 } 4414 } 4415 return selfdict; 4416 } 4417 4418 /* 4419 * Return the name of the executed function. 4420 */ 4421 char_u * 4422 func_name(void *cookie) 4423 { 4424 return ((funccall_T *)cookie)->func->uf_name; 4425 } 4426 4427 /* 4428 * Return the address holding the next breakpoint line for a funccall cookie. 4429 */ 4430 linenr_T * 4431 func_breakpoint(void *cookie) 4432 { 4433 return &((funccall_T *)cookie)->breakpoint; 4434 } 4435 4436 /* 4437 * Return the address holding the debug tick for a funccall cookie. 4438 */ 4439 int * 4440 func_dbg_tick(void *cookie) 4441 { 4442 return &((funccall_T *)cookie)->dbg_tick; 4443 } 4444 4445 /* 4446 * Return the nesting level for a funccall cookie. 4447 */ 4448 int 4449 func_level(void *cookie) 4450 { 4451 return ((funccall_T *)cookie)->level; 4452 } 4453 4454 /* 4455 * Return TRUE when a function was ended by a ":return" command. 4456 */ 4457 int 4458 current_func_returned(void) 4459 { 4460 return current_funccal->returned; 4461 } 4462 4463 int 4464 free_unref_funccal(int copyID, int testing) 4465 { 4466 int did_free = FALSE; 4467 int did_free_funccal = FALSE; 4468 funccall_T *fc, **pfc; 4469 4470 for (pfc = &previous_funccal; *pfc != NULL; ) 4471 { 4472 if (can_free_funccal(*pfc, copyID)) 4473 { 4474 fc = *pfc; 4475 *pfc = fc->caller; 4476 free_funccal_contents(fc); 4477 did_free = TRUE; 4478 did_free_funccal = TRUE; 4479 } 4480 else 4481 pfc = &(*pfc)->caller; 4482 } 4483 if (did_free_funccal) 4484 // When a funccal was freed some more items might be garbage 4485 // collected, so run again. 4486 (void)garbage_collect(testing); 4487 4488 return did_free; 4489 } 4490 4491 /* 4492 * Get function call environment based on backtrace debug level 4493 */ 4494 static funccall_T * 4495 get_funccal(void) 4496 { 4497 int i; 4498 funccall_T *funccal; 4499 funccall_T *temp_funccal; 4500 4501 funccal = current_funccal; 4502 if (debug_backtrace_level > 0) 4503 { 4504 for (i = 0; i < debug_backtrace_level; i++) 4505 { 4506 temp_funccal = funccal->caller; 4507 if (temp_funccal) 4508 funccal = temp_funccal; 4509 else 4510 // backtrace level overflow. reset to max 4511 debug_backtrace_level = i; 4512 } 4513 } 4514 return funccal; 4515 } 4516 4517 /* 4518 * Return the hashtable used for local variables in the current funccal. 4519 * Return NULL if there is no current funccal. 4520 */ 4521 hashtab_T * 4522 get_funccal_local_ht() 4523 { 4524 if (current_funccal == NULL || current_funccal->l_vars.dv_refcount == 0) 4525 return NULL; 4526 return &get_funccal()->l_vars.dv_hashtab; 4527 } 4528 4529 /* 4530 * Return the l: scope variable. 4531 * Return NULL if there is no current funccal. 4532 */ 4533 dictitem_T * 4534 get_funccal_local_var() 4535 { 4536 if (current_funccal == NULL || current_funccal->l_vars.dv_refcount == 0) 4537 return NULL; 4538 return &get_funccal()->l_vars_var; 4539 } 4540 4541 /* 4542 * Return the hashtable used for argument in the current funccal. 4543 * Return NULL if there is no current funccal. 4544 */ 4545 hashtab_T * 4546 get_funccal_args_ht() 4547 { 4548 if (current_funccal == NULL || current_funccal->l_vars.dv_refcount == 0) 4549 return NULL; 4550 return &get_funccal()->l_avars.dv_hashtab; 4551 } 4552 4553 /* 4554 * Return the a: scope variable. 4555 * Return NULL if there is no current funccal. 4556 */ 4557 dictitem_T * 4558 get_funccal_args_var() 4559 { 4560 if (current_funccal == NULL || current_funccal->l_vars.dv_refcount == 0) 4561 return NULL; 4562 return &get_funccal()->l_avars_var; 4563 } 4564 4565 /* 4566 * List function variables, if there is a function. 4567 */ 4568 void 4569 list_func_vars(int *first) 4570 { 4571 if (current_funccal != NULL && current_funccal->l_vars.dv_refcount > 0) 4572 list_hashtable_vars(¤t_funccal->l_vars.dv_hashtab, 4573 "l:", FALSE, first); 4574 } 4575 4576 /* 4577 * If "ht" is the hashtable for local variables in the current funccal, return 4578 * the dict that contains it. 4579 * Otherwise return NULL. 4580 */ 4581 dict_T * 4582 get_current_funccal_dict(hashtab_T *ht) 4583 { 4584 if (current_funccal != NULL 4585 && ht == ¤t_funccal->l_vars.dv_hashtab) 4586 return ¤t_funccal->l_vars; 4587 return NULL; 4588 } 4589 4590 /* 4591 * Search hashitem in parent scope. 4592 */ 4593 hashitem_T * 4594 find_hi_in_scoped_ht(char_u *name, hashtab_T **pht) 4595 { 4596 funccall_T *old_current_funccal = current_funccal; 4597 hashtab_T *ht; 4598 hashitem_T *hi = NULL; 4599 char_u *varname; 4600 4601 if (current_funccal == NULL || current_funccal->func->uf_scoped == NULL) 4602 return NULL; 4603 4604 // Search in parent scope, which can be referenced from a lambda. 4605 current_funccal = current_funccal->func->uf_scoped; 4606 while (current_funccal != NULL) 4607 { 4608 ht = find_var_ht(name, &varname); 4609 if (ht != NULL && *varname != NUL) 4610 { 4611 hi = hash_find(ht, varname); 4612 if (!HASHITEM_EMPTY(hi)) 4613 { 4614 *pht = ht; 4615 break; 4616 } 4617 } 4618 if (current_funccal == current_funccal->func->uf_scoped) 4619 break; 4620 current_funccal = current_funccal->func->uf_scoped; 4621 } 4622 current_funccal = old_current_funccal; 4623 4624 return hi; 4625 } 4626 4627 /* 4628 * Search variable in parent scope. 4629 */ 4630 dictitem_T * 4631 find_var_in_scoped_ht(char_u *name, int no_autoload) 4632 { 4633 dictitem_T *v = NULL; 4634 funccall_T *old_current_funccal = current_funccal; 4635 hashtab_T *ht; 4636 char_u *varname; 4637 4638 if (current_funccal == NULL || current_funccal->func->uf_scoped == NULL) 4639 return NULL; 4640 4641 // Search in parent scope which is possible to reference from lambda 4642 current_funccal = current_funccal->func->uf_scoped; 4643 while (current_funccal) 4644 { 4645 ht = find_var_ht(name, &varname); 4646 if (ht != NULL && *varname != NUL) 4647 { 4648 v = find_var_in_ht(ht, *name, varname, no_autoload); 4649 if (v != NULL) 4650 break; 4651 } 4652 if (current_funccal == current_funccal->func->uf_scoped) 4653 break; 4654 current_funccal = current_funccal->func->uf_scoped; 4655 } 4656 current_funccal = old_current_funccal; 4657 4658 return v; 4659 } 4660 4661 /* 4662 * Set "copyID + 1" in previous_funccal and callers. 4663 */ 4664 int 4665 set_ref_in_previous_funccal(int copyID) 4666 { 4667 int abort = FALSE; 4668 funccall_T *fc; 4669 4670 for (fc = previous_funccal; !abort && fc != NULL; fc = fc->caller) 4671 { 4672 fc->fc_copyID = copyID + 1; 4673 abort = abort 4674 || set_ref_in_ht(&fc->l_vars.dv_hashtab, copyID + 1, NULL) 4675 || set_ref_in_ht(&fc->l_avars.dv_hashtab, copyID + 1, NULL) 4676 || set_ref_in_list_items(&fc->l_varlist, copyID + 1, NULL); 4677 } 4678 return abort; 4679 } 4680 4681 static int 4682 set_ref_in_funccal(funccall_T *fc, int copyID) 4683 { 4684 int abort = FALSE; 4685 4686 if (fc->fc_copyID != copyID) 4687 { 4688 fc->fc_copyID = copyID; 4689 abort = abort 4690 || set_ref_in_ht(&fc->l_vars.dv_hashtab, copyID, NULL) 4691 || set_ref_in_ht(&fc->l_avars.dv_hashtab, copyID, NULL) 4692 || set_ref_in_list_items(&fc->l_varlist, copyID, NULL) 4693 || set_ref_in_func(NULL, fc->func, copyID); 4694 } 4695 return abort; 4696 } 4697 4698 /* 4699 * Set "copyID" in all local vars and arguments in the call stack. 4700 */ 4701 int 4702 set_ref_in_call_stack(int copyID) 4703 { 4704 int abort = FALSE; 4705 funccall_T *fc; 4706 funccal_entry_T *entry; 4707 4708 for (fc = current_funccal; !abort && fc != NULL; fc = fc->caller) 4709 abort = abort || set_ref_in_funccal(fc, copyID); 4710 4711 // Also go through the funccal_stack. 4712 for (entry = funccal_stack; !abort && entry != NULL; entry = entry->next) 4713 for (fc = entry->top_funccal; !abort && fc != NULL; fc = fc->caller) 4714 abort = abort || set_ref_in_funccal(fc, copyID); 4715 4716 return abort; 4717 } 4718 4719 /* 4720 * Set "copyID" in all functions available by name. 4721 */ 4722 int 4723 set_ref_in_functions(int copyID) 4724 { 4725 int todo; 4726 hashitem_T *hi = NULL; 4727 int abort = FALSE; 4728 ufunc_T *fp; 4729 4730 todo = (int)func_hashtab.ht_used; 4731 for (hi = func_hashtab.ht_array; todo > 0 && !got_int; ++hi) 4732 { 4733 if (!HASHITEM_EMPTY(hi)) 4734 { 4735 --todo; 4736 fp = HI2UF(hi); 4737 if (!func_name_refcount(fp->uf_name)) 4738 abort = abort || set_ref_in_func(NULL, fp, copyID); 4739 } 4740 } 4741 return abort; 4742 } 4743 4744 /* 4745 * Set "copyID" in all function arguments. 4746 */ 4747 int 4748 set_ref_in_func_args(int copyID) 4749 { 4750 int i; 4751 int abort = FALSE; 4752 4753 for (i = 0; i < funcargs.ga_len; ++i) 4754 abort = abort || set_ref_in_item(((typval_T **)funcargs.ga_data)[i], 4755 copyID, NULL, NULL); 4756 return abort; 4757 } 4758 4759 /* 4760 * Mark all lists and dicts referenced through function "name" with "copyID". 4761 * Returns TRUE if setting references failed somehow. 4762 */ 4763 int 4764 set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID) 4765 { 4766 ufunc_T *fp = fp_in; 4767 funccall_T *fc; 4768 int error = FCERR_NONE; 4769 char_u fname_buf[FLEN_FIXED + 1]; 4770 char_u *tofree = NULL; 4771 char_u *fname; 4772 int abort = FALSE; 4773 4774 if (name == NULL && fp_in == NULL) 4775 return FALSE; 4776 4777 if (fp_in == NULL) 4778 { 4779 fname = fname_trans_sid(name, fname_buf, &tofree, &error); 4780 fp = find_func(fname, FALSE, NULL); 4781 } 4782 if (fp != NULL) 4783 { 4784 for (fc = fp->uf_scoped; fc != NULL; fc = fc->func->uf_scoped) 4785 abort = abort || set_ref_in_funccal(fc, copyID); 4786 } 4787 4788 vim_free(tofree); 4789 return abort; 4790 } 4791 4792 #endif // FEAT_EVAL 4793