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