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 * vim9script.c: :vim9script, :import, :export and friends 12 */ 13 14 #include "vim.h" 15 16 #if defined(FEAT_EVAL) 17 # include "vim9.h" 18 #endif 19 20 /* 21 * Return TRUE when currently using Vim9 script syntax. 22 * Does not go up the stack, a ":function" inside vim9script uses legacy 23 * syntax. 24 */ 25 int 26 in_vim9script(void) 27 { 28 // "sc_version" is also set when compiling a ":def" function in legacy 29 // script. 30 return (current_sctx.sc_version == SCRIPT_VERSION_VIM9 31 || (cmdmod.cmod_flags & CMOD_VIM9CMD)) 32 && !(cmdmod.cmod_flags & CMOD_LEGACY); 33 } 34 35 #if defined(FEAT_EVAL) || defined(PROTO) 36 /* 37 * Return TRUE if the current script is Vim9 script. 38 * This also returns TRUE in a legacy function in a Vim9 script. 39 */ 40 int 41 current_script_is_vim9(void) 42 { 43 return SCRIPT_ID_VALID(current_sctx.sc_sid) 44 && SCRIPT_ITEM(current_sctx.sc_sid)->sn_version 45 == SCRIPT_VERSION_VIM9; 46 } 47 #endif 48 49 /* 50 * ":vim9script". 51 */ 52 void 53 ex_vim9script(exarg_T *eap UNUSED) 54 { 55 #ifdef FEAT_EVAL 56 int sid = current_sctx.sc_sid; 57 scriptitem_T *si; 58 59 if (!getline_equal(eap->getline, eap->cookie, getsourceline)) 60 { 61 emsg(_(e_vim9script_can_only_be_used_in_script)); 62 return; 63 } 64 65 si = SCRIPT_ITEM(sid); 66 if (si->sn_state == SN_STATE_HAD_COMMAND) 67 { 68 emsg(_(e_vim9script_must_be_first_command_in_script)); 69 return; 70 } 71 if (!IS_WHITE_OR_NUL(*eap->arg) && STRCMP(eap->arg, "noclear") != 0) 72 { 73 semsg(_(e_invarg2), eap->arg); 74 return; 75 } 76 if (si->sn_state == SN_STATE_RELOAD && IS_WHITE_OR_NUL(*eap->arg)) 77 { 78 hashtab_T *ht = &SCRIPT_VARS(sid); 79 80 // Reloading a script without the "noclear" argument: clear 81 // script-local variables and functions. 82 hashtab_free_contents(ht); 83 hash_init(ht); 84 delete_script_functions(sid); 85 86 // old imports and script variables are no longer valid 87 free_imports_and_script_vars(sid); 88 } 89 si->sn_state = SN_STATE_HAD_COMMAND; 90 91 current_sctx.sc_version = SCRIPT_VERSION_VIM9; 92 si->sn_version = SCRIPT_VERSION_VIM9; 93 94 if (STRCMP(p_cpo, CPO_VIM) != 0) 95 { 96 si->sn_save_cpo = vim_strsave(p_cpo); 97 set_option_value((char_u *)"cpo", 0L, (char_u *)CPO_VIM, OPT_NO_REDRAW); 98 } 99 #else 100 // No check for this being the first command, it doesn't matter. 101 current_sctx.sc_version = SCRIPT_VERSION_VIM9; 102 #endif 103 } 104 105 /* 106 * When in Vim9 script give an error and return FAIL. 107 */ 108 int 109 not_in_vim9(exarg_T *eap) 110 { 111 if (in_vim9script()) 112 switch (eap->cmdidx) 113 { 114 case CMD_k: 115 if (eap->addr_count > 0) 116 { 117 emsg(_(e_norange)); 118 return FAIL; 119 } 120 // FALLTHROUGH 121 case CMD_append: 122 case CMD_change: 123 case CMD_insert: 124 case CMD_open: 125 case CMD_t: 126 case CMD_xit: 127 semsg(_(e_command_not_supported_in_vim9_script_missing_var_str), eap->cmd); 128 return FAIL; 129 default: break; 130 } 131 return OK; 132 } 133 134 /* 135 * Give an error message if "p" points at "#{" and return TRUE. 136 * This avoids that using a legacy style #{} dictionary leads to difficult to 137 * understand errors. 138 */ 139 int 140 vim9_bad_comment(char_u *p) 141 { 142 if (p[0] == '#' && p[1] == '{' && p[2] != '{') 143 { 144 emsg(_(e_cannot_use_hash_curly_to_start_comment)); 145 return TRUE; 146 } 147 return FALSE; 148 } 149 150 /* 151 * Return TRUE if "p" points at a "#" not followed by one '{'. 152 * Does not check for white space. 153 */ 154 int 155 vim9_comment_start(char_u *p) 156 { 157 return p[0] == '#' && (p[1] != '{' || p[2] == '{'); 158 } 159 160 #if defined(FEAT_EVAL) || defined(PROTO) 161 162 /* 163 * "++nr" and "--nr" commands. 164 */ 165 void 166 ex_incdec(exarg_T *eap) 167 { 168 char_u *cmd = eap->cmd; 169 char_u *nextcmd = eap->nextcmd; 170 size_t len = STRLEN(eap->cmd) + 8; 171 172 if (VIM_ISWHITE(cmd[2])) 173 { 174 semsg(_(e_no_white_space_allowed_after_str_str), 175 eap->cmdidx == CMD_increment ? "++" : "--", eap->cmd); 176 return; 177 } 178 179 // This works like "nr += 1" or "nr -= 1". 180 // Add a '|' to avoid looking in the next line. 181 eap->cmd = alloc(len); 182 if (eap->cmd == NULL) 183 return; 184 vim_snprintf((char *)eap->cmd, len, "%s %c= 1 |", cmd + 2, 185 eap->cmdidx == CMD_increment ? '+' : '-'); 186 eap->arg = eap->cmd; 187 eap->cmdidx = CMD_var; 188 eap->nextcmd = NULL; 189 ex_let(eap); 190 vim_free(eap->cmd); 191 eap->cmd = cmd; 192 eap->nextcmd = nextcmd; 193 } 194 195 /* 196 * ":export let Name: type" 197 * ":export const Name: type" 198 * ":export def Name(..." 199 * ":export class Name ..." 200 */ 201 void 202 ex_export(exarg_T *eap) 203 { 204 if (!in_vim9script()) 205 { 206 emsg(_(e_export_can_only_be_used_in_vim9script)); 207 return; 208 } 209 210 eap->cmd = eap->arg; 211 (void)find_ex_command(eap, NULL, lookup_scriptitem, NULL); 212 switch (eap->cmdidx) 213 { 214 case CMD_let: 215 case CMD_var: 216 case CMD_final: 217 case CMD_const: 218 case CMD_def: 219 // case CMD_class: 220 is_export = TRUE; 221 do_cmdline(eap->cmd, eap->getline, eap->cookie, 222 DOCMD_VERBOSE + DOCMD_NOWAIT); 223 224 // The command will reset "is_export" when exporting an item. 225 if (is_export) 226 { 227 emsg(_(e_export_with_invalid_argument)); 228 is_export = FALSE; 229 } 230 break; 231 default: 232 emsg(_(e_invalid_command_after_export)); 233 break; 234 } 235 } 236 237 /* 238 * Add a new imported item entry to the current script. 239 */ 240 static imported_T * 241 new_imported(garray_T *gap) 242 { 243 if (ga_grow(gap, 1) == OK) 244 return ((imported_T *)gap->ga_data + gap->ga_len++); 245 return NULL; 246 } 247 248 /* 249 * Free all imported items in script "sid". 250 */ 251 void 252 free_imports_and_script_vars(int sid) 253 { 254 scriptitem_T *si = SCRIPT_ITEM(sid); 255 int idx; 256 257 for (idx = 0; idx < si->sn_imports.ga_len; ++idx) 258 { 259 imported_T *imp = ((imported_T *)si->sn_imports.ga_data) + idx; 260 261 vim_free(imp->imp_name); 262 } 263 ga_clear(&si->sn_imports); 264 265 free_all_script_vars(si); 266 267 clear_type_list(&si->sn_type_list); 268 } 269 270 /* 271 * Mark all imports as possible to redefine. Used when a script is loaded 272 * again but not cleared. 273 */ 274 void 275 mark_imports_for_reload(int sid) 276 { 277 scriptitem_T *si = SCRIPT_ITEM(sid); 278 int idx; 279 280 for (idx = 0; idx < si->sn_imports.ga_len; ++idx) 281 { 282 imported_T *imp = ((imported_T *)si->sn_imports.ga_data) + idx; 283 284 imp->imp_flags |= IMP_FLAGS_RELOAD; 285 } 286 } 287 288 /* 289 * ":import Item from 'filename'" 290 * ":import Item as Alias from 'filename'" 291 * ":import {Item} from 'filename'". 292 * ":import {Item as Alias} from 'filename'" 293 * ":import {Item, Item} from 'filename'" 294 * ":import {Item, Item as Alias} from 'filename'" 295 * 296 * ":import * as Name from 'filename'" 297 */ 298 void 299 ex_import(exarg_T *eap) 300 { 301 char_u *cmd_end; 302 evalarg_T evalarg; 303 304 if (!getline_equal(eap->getline, eap->cookie, getsourceline)) 305 { 306 emsg(_(e_import_can_only_be_used_in_script)); 307 return; 308 } 309 fill_evalarg_from_eap(&evalarg, eap, eap->skip); 310 311 cmd_end = handle_import(eap->arg, NULL, current_sctx.sc_sid, 312 &evalarg, NULL); 313 if (cmd_end != NULL) 314 eap->nextcmd = check_nextcmd(cmd_end); 315 clear_evalarg(&evalarg, eap); 316 } 317 318 /* 319 * Find an exported item in "sid" matching the name at "*argp". 320 * When it is a variable return the index. 321 * When it is a user function return "*ufunc". 322 * When not found returns -1 and "*ufunc" is NULL. 323 */ 324 int 325 find_exported( 326 int sid, 327 char_u *name, 328 ufunc_T **ufunc, 329 type_T **type, 330 cctx_T *cctx, 331 int verbose) 332 { 333 int idx = -1; 334 svar_T *sv; 335 scriptitem_T *script = SCRIPT_ITEM(sid); 336 337 // Find name in "script". 338 idx = get_script_item_idx(sid, name, 0, cctx); 339 if (idx >= 0) 340 { 341 sv = ((svar_T *)script->sn_var_vals.ga_data) + idx; 342 if (!sv->sv_export) 343 { 344 if (verbose) 345 semsg(_(e_item_not_exported_in_script_str), name); 346 return -1; 347 } 348 *type = sv->sv_type; 349 *ufunc = NULL; 350 } 351 else 352 { 353 char_u buffer[200]; 354 char_u *funcname; 355 356 // it could be a user function. 357 if (STRLEN(name) < sizeof(buffer) - 15) 358 funcname = buffer; 359 else 360 { 361 funcname = alloc(STRLEN(name) + 15); 362 if (funcname == NULL) 363 return -1; 364 } 365 funcname[0] = K_SPECIAL; 366 funcname[1] = KS_EXTRA; 367 funcname[2] = (int)KE_SNR; 368 sprintf((char *)funcname + 3, "%ld_%s", (long)sid, name); 369 *ufunc = find_func(funcname, FALSE, NULL); 370 if (funcname != buffer) 371 vim_free(funcname); 372 373 if (*ufunc == NULL) 374 { 375 if (verbose) 376 semsg(_(e_item_not_found_in_script_str), name); 377 return -1; 378 } 379 else if (((*ufunc)->uf_flags & FC_EXPORT) == 0) 380 { 381 if (verbose) 382 semsg(_(e_item_not_exported_in_script_str), name); 383 *ufunc = NULL; 384 return -1; 385 } 386 } 387 388 return idx; 389 } 390 391 /* 392 * Handle an ":import" command and add the resulting imported_T to "gap", when 393 * not NULL, or script "import_sid" sn_imports. 394 * "cctx" is NULL at the script level. 395 * Returns a pointer to after the command or NULL in case of failure 396 */ 397 char_u * 398 handle_import( 399 char_u *arg_start, 400 garray_T *gap, 401 int import_sid, 402 evalarg_T *evalarg, 403 void *cctx) 404 { 405 char_u *arg = arg_start; 406 char_u *cmd_end = NULL; 407 int ret = FAIL; 408 typval_T tv; 409 int sid = -1; 410 int res; 411 int mult = FALSE; 412 garray_T names; 413 garray_T as_names; 414 415 ga_init2(&names, sizeof(char_u *), 10); 416 ga_init2(&as_names, sizeof(char_u *), 10); 417 if (*arg == '{') 418 { 419 // "import {item, item} from ..." 420 mult = TRUE; 421 arg = skipwhite_and_linebreak(arg + 1, evalarg); 422 } 423 424 for (;;) 425 { 426 char_u *p = arg; 427 int had_comma = FALSE; 428 char_u *as_name = NULL; 429 430 // accept "*" or "Name" 431 if (!mult && arg[0] == '*' && IS_WHITE_OR_NUL(arg[1])) 432 ++arg; 433 else 434 while (eval_isnamec(*arg)) 435 ++arg; 436 if (p == arg) 437 break; 438 if (ga_grow(&names, 1) == FAIL || ga_grow(&as_names, 1) == FAIL) 439 goto erret; 440 ((char_u **)names.ga_data)[names.ga_len] = vim_strnsave(p, arg - p); 441 ++names.ga_len; 442 443 arg = skipwhite_and_linebreak(arg, evalarg); 444 if (STRNCMP("as", arg, 2) == 0 && IS_WHITE_OR_NUL(arg[2])) 445 { 446 // skip over "as Name "; no line break allowed after "as" 447 arg = skipwhite(arg + 2); 448 p = arg; 449 if (eval_isnamec1(*arg)) 450 while (eval_isnamec(*arg)) 451 ++arg; 452 if (check_defined(p, arg - p, cctx, FALSE) == FAIL) 453 goto erret; 454 as_name = vim_strnsave(p, arg - p); 455 arg = skipwhite_and_linebreak(arg, evalarg); 456 } 457 else if (*arg_start == '*') 458 { 459 emsg(_(e_missing_as_after_star)); 460 goto erret; 461 } 462 // without "as Name" the as_names entry is NULL 463 ((char_u **)as_names.ga_data)[as_names.ga_len] = as_name; 464 ++as_names.ga_len; 465 466 if (!mult) 467 break; 468 if (*arg == ',') 469 { 470 had_comma = TRUE; 471 ++arg; 472 } 473 arg = skipwhite_and_linebreak(arg, evalarg); 474 if (*arg == '}') 475 { 476 ++arg; 477 break; 478 } 479 if (!had_comma) 480 { 481 emsg(_(e_missing_comma_in_import)); 482 goto erret; 483 } 484 } 485 arg = skipwhite_and_linebreak(arg, evalarg); 486 487 if (names.ga_len == 0) 488 { 489 emsg(_(e_syntax_error_in_import)); 490 goto erret; 491 } 492 493 if (STRNCMP("from", arg, 4) != 0 || !IS_WHITE_OR_NUL(arg[4])) 494 { 495 emsg(_(e_missing_from)); 496 goto erret; 497 } 498 499 arg = skipwhite_and_linebreak(arg + 4, evalarg); 500 tv.v_type = VAR_UNKNOWN; 501 // TODO: should we accept any expression? 502 if (*arg == '\'') 503 ret = eval_lit_string(&arg, &tv, TRUE); 504 else if (*arg == '"') 505 ret = eval_string(&arg, &tv, TRUE); 506 if (ret == FAIL || tv.vval.v_string == NULL || *tv.vval.v_string == NUL) 507 { 508 emsg(_(e_invalid_string_after_from)); 509 goto erret; 510 } 511 cmd_end = arg; 512 513 /* 514 * find script file 515 */ 516 if (*tv.vval.v_string == '.') 517 { 518 size_t len; 519 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); 520 char_u *tail = gettail(si->sn_name); 521 char_u *from_name; 522 523 // Relative to current script: "./name.vim", "../../name.vim". 524 len = STRLEN(si->sn_name) - STRLEN(tail) + STRLEN(tv.vval.v_string) + 2; 525 from_name = alloc((int)len); 526 if (from_name == NULL) 527 { 528 clear_tv(&tv); 529 goto erret; 530 } 531 vim_strncpy(from_name, si->sn_name, tail - si->sn_name); 532 add_pathsep(from_name); 533 STRCAT(from_name, tv.vval.v_string); 534 simplify_filename(from_name); 535 536 res = do_source(from_name, FALSE, DOSO_NONE, &sid); 537 vim_free(from_name); 538 } 539 else if (mch_isFullName(tv.vval.v_string)) 540 { 541 // Absolute path: "/tmp/name.vim" 542 res = do_source(tv.vval.v_string, FALSE, DOSO_NONE, &sid); 543 } 544 else 545 { 546 size_t len = 7 + STRLEN(tv.vval.v_string) + 1; 547 char_u *from_name; 548 549 // Find file in "import" subdirs in 'runtimepath'. 550 from_name = alloc((int)len); 551 if (from_name == NULL) 552 { 553 clear_tv(&tv); 554 goto erret; 555 } 556 vim_snprintf((char *)from_name, len, "import/%s", tv.vval.v_string); 557 res = source_in_path(p_rtp, from_name, DIP_NOAFTER, &sid); 558 vim_free(from_name); 559 } 560 561 if (res == FAIL || sid <= 0) 562 { 563 semsg(_(e_could_not_import_str), tv.vval.v_string); 564 clear_tv(&tv); 565 goto erret; 566 } 567 clear_tv(&tv); 568 569 if (*arg_start == '*') 570 { 571 imported_T *imported; 572 char_u *as_name = ((char_u **)as_names.ga_data)[0]; 573 574 // "import * as That" 575 imported = find_imported(as_name, STRLEN(as_name), cctx); 576 if (imported != NULL && imported->imp_sid == sid) 577 { 578 if (imported->imp_flags & IMP_FLAGS_RELOAD) 579 // import already defined on a previous script load 580 imported->imp_flags &= ~IMP_FLAGS_RELOAD; 581 else 582 { 583 semsg(_(e_name_already_defined_str), as_name); 584 goto erret; 585 } 586 } 587 588 imported = new_imported(gap != NULL ? gap 589 : &SCRIPT_ITEM(import_sid)->sn_imports); 590 if (imported == NULL) 591 goto erret; 592 imported->imp_name = as_name; 593 ((char_u **)as_names.ga_data)[0] = NULL; 594 imported->imp_sid = sid; 595 imported->imp_flags = IMP_FLAGS_STAR; 596 } 597 else 598 { 599 int i; 600 601 arg = arg_start; 602 if (*arg == '{') 603 arg = skipwhite(arg + 1); 604 for (i = 0; i < names.ga_len; ++i) 605 { 606 char_u *name = ((char_u **)names.ga_data)[i]; 607 char_u *as_name = ((char_u **)as_names.ga_data)[i]; 608 size_t len = STRLEN(name); 609 int idx; 610 imported_T *imported; 611 ufunc_T *ufunc = NULL; 612 type_T *type; 613 614 idx = find_exported(sid, name, &ufunc, &type, cctx, TRUE); 615 616 if (idx < 0 && ufunc == NULL) 617 goto erret; 618 619 // If already imported with the same propertis and the 620 // IMP_FLAGS_RELOAD set then we keep that entry. Otherwise create 621 // a new one (and give an error for an existing import). 622 imported = find_imported(name, len, cctx); 623 if (imported != NULL 624 && (imported->imp_flags & IMP_FLAGS_RELOAD) 625 && imported->imp_sid == sid 626 && (idx >= 0 627 ? (equal_type(imported->imp_type, type) 628 && imported->imp_var_vals_idx == idx) 629 : (equal_type(imported->imp_type, ufunc->uf_func_type) 630 && STRCMP(imported->imp_funcname, 631 ufunc->uf_name) == 0))) 632 { 633 imported->imp_flags &= ~IMP_FLAGS_RELOAD; 634 } 635 else 636 { 637 if (as_name == NULL 638 && check_defined(name, len, cctx, FALSE) == FAIL) 639 goto erret; 640 641 imported = new_imported(gap != NULL ? gap 642 : &SCRIPT_ITEM(import_sid)->sn_imports); 643 if (imported == NULL) 644 goto erret; 645 646 if (as_name == NULL) 647 { 648 imported->imp_name = name; 649 ((char_u **)names.ga_data)[i] = NULL; 650 } 651 else 652 { 653 // "import This as That ..." 654 imported->imp_name = as_name; 655 ((char_u **)as_names.ga_data)[i] = NULL; 656 } 657 imported->imp_sid = sid; 658 if (idx >= 0) 659 { 660 imported->imp_type = type; 661 imported->imp_var_vals_idx = idx; 662 } 663 else 664 { 665 imported->imp_type = ufunc->uf_func_type; 666 imported->imp_funcname = ufunc->uf_name; 667 } 668 } 669 } 670 } 671 erret: 672 ga_clear_strings(&names); 673 ga_clear_strings(&as_names); 674 return cmd_end; 675 } 676 677 /* 678 * Declare a script-local variable without init: "let var: type". 679 * "const" is an error since the value is missing. 680 * Returns a pointer to after the type. 681 */ 682 char_u * 683 vim9_declare_scriptvar(exarg_T *eap, char_u *arg) 684 { 685 char_u *p; 686 char_u *name; 687 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); 688 type_T *type; 689 typval_T init_tv; 690 691 if (eap->cmdidx == CMD_final || eap->cmdidx == CMD_const) 692 { 693 if (eap->cmdidx == CMD_final) 694 emsg(_(e_final_requires_a_value)); 695 else 696 emsg(_(e_const_requires_a_value)); 697 return arg + STRLEN(arg); 698 } 699 700 // Check for valid starting character. 701 if (!eval_isnamec1(*arg)) 702 { 703 semsg(_(e_invarg2), arg); 704 return arg + STRLEN(arg); 705 } 706 707 for (p = arg + 1; *p != NUL && eval_isnamec(*p); MB_PTR_ADV(p)) 708 if (*p == ':' && (VIM_ISWHITE(p[1]) || p != arg + 1)) 709 break; 710 711 if (*p != ':') 712 { 713 emsg(_(e_type_or_initialization_required)); 714 return arg + STRLEN(arg); 715 } 716 if (!VIM_ISWHITE(p[1])) 717 { 718 semsg(_(e_white_space_required_after_str_str), ":", p); 719 return arg + STRLEN(arg); 720 } 721 name = vim_strnsave(arg, p - arg); 722 723 // parse type, check for reserved name 724 p = skipwhite(p + 1); 725 type = parse_type(&p, &si->sn_type_list, TRUE); 726 if (type == NULL || check_reserved_name(name) == FAIL) 727 { 728 vim_free(name); 729 return p; 730 } 731 732 // Create the variable with 0/NULL value. 733 CLEAR_FIELD(init_tv); 734 if (type->tt_type == VAR_ANY) 735 // A variable of type "any" is not possible, just use zero instead 736 init_tv.v_type = VAR_NUMBER; 737 else 738 init_tv.v_type = type->tt_type; 739 set_var_const(name, type, &init_tv, FALSE, 0, 0); 740 741 vim_free(name); 742 return p; 743 } 744 745 /* 746 * Vim9 part of adding a script variable: add it to sn_all_vars (lookup by name 747 * with a hashtable) and sn_var_vals (lookup by index). 748 * When "create" is TRUE this is a new variable, otherwise find and update an 749 * existing variable. 750 * "flags" can have ASSIGN_FINAL or ASSIGN_CONST. 751 * When "*type" is NULL use "tv" for the type and update "*type". If 752 * "do_member" is TRUE also use the member type, otherwise use "any". 753 */ 754 void 755 update_vim9_script_var( 756 int create, 757 dictitem_T *di, 758 int flags, 759 typval_T *tv, 760 type_T **type, 761 int do_member) 762 { 763 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); 764 hashitem_T *hi; 765 svar_T *sv; 766 767 if (create) 768 { 769 sallvar_T *newsav; 770 771 // Store a pointer to the typval_T, so that it can be found by index 772 // instead of using a hastab lookup. 773 if (ga_grow(&si->sn_var_vals, 1) == FAIL) 774 return; 775 776 sv = ((svar_T *)si->sn_var_vals.ga_data) + si->sn_var_vals.ga_len; 777 newsav = (sallvar_T *)alloc_clear( 778 sizeof(sallvar_T) + STRLEN(di->di_key)); 779 if (newsav == NULL) 780 return; 781 782 sv->sv_tv = &di->di_tv; 783 sv->sv_const = (flags & ASSIGN_FINAL) ? ASSIGN_FINAL 784 : (flags & ASSIGN_CONST) ? ASSIGN_CONST : 0; 785 sv->sv_export = is_export; 786 newsav->sav_var_vals_idx = si->sn_var_vals.ga_len; 787 ++si->sn_var_vals.ga_len; 788 STRCPY(&newsav->sav_key, di->di_key); 789 sv->sv_name = newsav->sav_key; 790 newsav->sav_di = di; 791 newsav->sav_block_id = si->sn_current_block_id; 792 793 hi = hash_find(&si->sn_all_vars.dv_hashtab, newsav->sav_key); 794 if (!HASHITEM_EMPTY(hi)) 795 { 796 sallvar_T *sav = HI2SAV(hi); 797 798 // variable with this name exists in another block 799 while (sav->sav_next != NULL) 800 sav = sav->sav_next; 801 sav->sav_next = newsav; 802 } 803 else 804 // new variable name 805 hash_add(&si->sn_all_vars.dv_hashtab, newsav->sav_key); 806 } 807 else 808 { 809 sv = find_typval_in_script(&di->di_tv); 810 } 811 if (sv != NULL) 812 { 813 if (*type == NULL) 814 *type = typval2type(tv, get_copyID(), &si->sn_type_list, 815 do_member); 816 sv->sv_type = *type; 817 } 818 819 // let ex_export() know the export worked. 820 is_export = FALSE; 821 } 822 823 /* 824 * Hide a script variable when leaving a block. 825 * "idx" is de index in sn_var_vals. 826 * When "func_defined" is non-zero then a function was defined in this block, 827 * the variable may be accessed by it. Otherwise the variable can be cleared. 828 */ 829 void 830 hide_script_var(scriptitem_T *si, int idx, int func_defined) 831 { 832 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; 833 hashtab_T *script_ht = get_script_local_ht(); 834 hashtab_T *all_ht = &si->sn_all_vars.dv_hashtab; 835 hashitem_T *script_hi; 836 hashitem_T *all_hi; 837 838 // Remove a variable declared inside the block, if it still exists. 839 // If it was added in a nested block it will already have been removed. 840 // The typval is moved into the sallvar_T. 841 script_hi = hash_find(script_ht, sv->sv_name); 842 all_hi = hash_find(all_ht, sv->sv_name); 843 if (!HASHITEM_EMPTY(script_hi) && !HASHITEM_EMPTY(all_hi)) 844 { 845 dictitem_T *di = HI2DI(script_hi); 846 sallvar_T *sav = HI2SAV(all_hi); 847 sallvar_T *sav_prev = NULL; 848 849 // There can be multiple entries with the same name in different 850 // blocks, find the right one. 851 while (sav != NULL && sav->sav_var_vals_idx != idx) 852 { 853 sav_prev = sav; 854 sav = sav->sav_next; 855 } 856 if (sav != NULL) 857 { 858 if (func_defined) 859 { 860 // move the typval from the dictitem to the sallvar 861 sav->sav_tv = di->di_tv; 862 di->di_tv.v_type = VAR_UNKNOWN; 863 sav->sav_flags = di->di_flags; 864 sav->sav_di = NULL; 865 sv->sv_tv = &sav->sav_tv; 866 } 867 else 868 { 869 if (sav_prev == NULL) 870 hash_remove(all_ht, all_hi); 871 else 872 sav_prev->sav_next = sav->sav_next; 873 sv->sv_name = NULL; 874 vim_free(sav); 875 } 876 delete_var(script_ht, script_hi); 877 } 878 } 879 } 880 881 /* 882 * Free the script variables from "sn_all_vars". 883 */ 884 void 885 free_all_script_vars(scriptitem_T *si) 886 { 887 int todo; 888 hashtab_T *ht = &si->sn_all_vars.dv_hashtab; 889 hashitem_T *hi; 890 sallvar_T *sav; 891 sallvar_T *sav_next; 892 893 hash_lock(ht); 894 todo = (int)ht->ht_used; 895 for (hi = ht->ht_array; todo > 0; ++hi) 896 { 897 if (!HASHITEM_EMPTY(hi)) 898 { 899 --todo; 900 901 // Free the variable. Don't remove it from the hashtab, ht_array 902 // might change then. hash_clear() takes care of it later. 903 sav = HI2SAV(hi); 904 while (sav != NULL) 905 { 906 sav_next = sav->sav_next; 907 if (sav->sav_di == NULL) 908 clear_tv(&sav->sav_tv); 909 vim_free(sav); 910 sav = sav_next; 911 } 912 } 913 } 914 hash_clear(ht); 915 hash_init(ht); 916 917 ga_clear(&si->sn_var_vals); 918 919 // existing commands using script variable indexes are no longer valid 920 si->sn_script_seq = current_sctx.sc_seq; 921 } 922 923 /* 924 * Find the script-local variable that links to "dest". 925 * Returns NULL if not found. 926 */ 927 svar_T * 928 find_typval_in_script(typval_T *dest) 929 { 930 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); 931 int idx; 932 933 if (si->sn_version != SCRIPT_VERSION_VIM9) 934 // legacy script doesn't store variable types 935 return NULL; 936 937 // Find the svar_T in sn_var_vals. 938 for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx) 939 { 940 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; 941 942 // If "sv_name" is NULL the variable was hidden when leaving a block, 943 // don't check "sv_tv" then, it might be used for another variable now. 944 if (sv->sv_name != NULL && sv->sv_tv == dest) 945 return sv; 946 } 947 iemsg("find_typval_in_script(): not found"); 948 return NULL; 949 } 950 951 /* 952 * Check if the type of script variable "dest" allows assigning "value". 953 * If needed convert "value" to a bool. 954 */ 955 int 956 check_script_var_type( 957 typval_T *dest, 958 typval_T *value, 959 char_u *name, 960 where_T where) 961 { 962 svar_T *sv = find_typval_in_script(dest); 963 int ret; 964 965 if (sv != NULL) 966 { 967 if (sv->sv_const != 0) 968 { 969 semsg(_(e_readonlyvar), name); 970 return FAIL; 971 } 972 ret = check_typval_type(sv->sv_type, value, where); 973 if (ret == OK && need_convert_to_bool(sv->sv_type, value)) 974 { 975 int val = tv2bool(value); 976 977 clear_tv(value); 978 value->v_type = VAR_BOOL; 979 value->v_lock = 0; 980 value->vval.v_number = val ? VVAL_TRUE : VVAL_FALSE; 981 } 982 return ret; 983 } 984 985 return OK; // not really 986 } 987 988 // words that cannot be used as a variable 989 static char *reserved[] = { 990 "true", 991 "false", 992 "null", 993 "this", 994 NULL 995 }; 996 997 int 998 check_reserved_name(char_u *name) 999 { 1000 int idx; 1001 1002 for (idx = 0; reserved[idx] != NULL; ++idx) 1003 if (STRCMP(reserved[idx], name) == 0) 1004 { 1005 semsg(_(e_cannot_use_reserved_name), name); 1006 return FAIL; 1007 } 1008 return OK; 1009 } 1010 1011 #endif // FEAT_EVAL 1012