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 * vim9compile.c: :def and dealing with instructions 12 */ 13 14 #define USING_FLOAT_STUFF 15 #include "vim.h" 16 17 #if defined(FEAT_EVAL) || defined(PROTO) 18 19 #ifdef VMS 20 # include <float.h> 21 #endif 22 23 #define DEFINE_VIM9_GLOBALS 24 #include "vim9.h" 25 26 // values for ctx_skip 27 typedef enum { 28 SKIP_NOT, // condition is a constant, produce code 29 SKIP_YES, // condition is a constant, do NOT produce code 30 SKIP_UNKNOWN // condition is not a constant, produce code 31 } skip_T; 32 33 /* 34 * Chain of jump instructions where the end label needs to be set. 35 */ 36 typedef struct endlabel_S endlabel_T; 37 struct endlabel_S { 38 endlabel_T *el_next; // chain end_label locations 39 int el_end_label; // instruction idx where to set end 40 }; 41 42 /* 43 * info specific for the scope of :if / elseif / else 44 */ 45 typedef struct { 46 int is_seen_else; 47 int is_seen_skip_not; // a block was unconditionally executed 48 int is_had_return; // every block ends in :return 49 int is_if_label; // instruction idx at IF or ELSEIF 50 endlabel_T *is_end_label; // instructions to set end label 51 } ifscope_T; 52 53 /* 54 * info specific for the scope of :while 55 */ 56 typedef struct { 57 int ws_top_label; // instruction idx at WHILE 58 endlabel_T *ws_end_label; // instructions to set end 59 } whilescope_T; 60 61 /* 62 * info specific for the scope of :for 63 */ 64 typedef struct { 65 int fs_top_label; // instruction idx at FOR 66 endlabel_T *fs_end_label; // break instructions 67 } forscope_T; 68 69 /* 70 * info specific for the scope of :try 71 */ 72 typedef struct { 73 int ts_try_label; // instruction idx at TRY 74 endlabel_T *ts_end_label; // jump to :finally or :endtry 75 int ts_catch_label; // instruction idx of last CATCH 76 int ts_caught_all; // "catch" without argument encountered 77 } tryscope_T; 78 79 typedef enum { 80 NO_SCOPE, 81 IF_SCOPE, 82 WHILE_SCOPE, 83 FOR_SCOPE, 84 TRY_SCOPE, 85 BLOCK_SCOPE 86 } scopetype_T; 87 88 /* 89 * Info for one scope, pointed to by "ctx_scope". 90 */ 91 typedef struct scope_S scope_T; 92 struct scope_S { 93 scope_T *se_outer; // scope containing this one 94 scopetype_T se_type; 95 int se_local_count; // ctx_locals.ga_len before scope 96 skip_T se_skip_save; // ctx_skip before the block 97 union { 98 ifscope_T se_if; 99 whilescope_T se_while; 100 forscope_T se_for; 101 tryscope_T se_try; 102 } se_u; 103 }; 104 105 /* 106 * Entry for "ctx_locals". Used for arguments and local variables. 107 */ 108 typedef struct { 109 char_u *lv_name; 110 type_T *lv_type; 111 int lv_idx; // index of the variable on the stack 112 int lv_from_outer; // nesting level, using ctx_outer scope 113 int lv_const; // when TRUE cannot be assigned to 114 int lv_arg; // when TRUE this is an argument 115 } lvar_T; 116 117 /* 118 * Context for compiling lines of Vim script. 119 * Stores info about the local variables and condition stack. 120 */ 121 struct cctx_S { 122 ufunc_T *ctx_ufunc; // current function 123 int ctx_lnum; // line number in current function 124 char_u *ctx_line_start; // start of current line or NULL 125 garray_T ctx_instr; // generated instructions 126 127 int ctx_profiling; // when TRUE generate ISN_PROF_START 128 129 garray_T ctx_locals; // currently visible local variables 130 int ctx_locals_count; // total number of local variables 131 132 int ctx_has_closure; // set to one if a closures was created in 133 // the function 134 135 garray_T ctx_imports; // imported items 136 137 skip_T ctx_skip; 138 scope_T *ctx_scope; // current scope, NULL at toplevel 139 int ctx_had_return; // last seen statement was "return" 140 141 cctx_T *ctx_outer; // outer scope for lambda or nested 142 // function 143 int ctx_outer_used; // var in ctx_outer was used 144 145 garray_T ctx_type_stack; // type of each item on the stack 146 garray_T *ctx_type_list; // list of pointers to allocated types 147 148 int ctx_has_cmdmod; // ISN_CMDMOD was generated 149 }; 150 151 static void delete_def_function_contents(dfunc_T *dfunc, int mark_deleted); 152 153 /* 154 * Lookup variable "name" in the local scope and return it in "lvar". 155 * "lvar->lv_from_outer" is incremented accordingly. 156 * If "lvar" is NULL only check if the variable can be found. 157 * Return FAIL if not found. 158 */ 159 static int 160 lookup_local(char_u *name, size_t len, lvar_T *lvar, cctx_T *cctx) 161 { 162 int idx; 163 lvar_T *lvp; 164 165 if (len == 0) 166 return FAIL; 167 168 // Find local in current function scope. 169 for (idx = 0; idx < cctx->ctx_locals.ga_len; ++idx) 170 { 171 lvp = ((lvar_T *)cctx->ctx_locals.ga_data) + idx; 172 if (STRNCMP(name, lvp->lv_name, len) == 0 173 && STRLEN(lvp->lv_name) == len) 174 { 175 if (lvar != NULL) 176 { 177 *lvar = *lvp; 178 lvar->lv_from_outer = 0; 179 } 180 return OK; 181 } 182 } 183 184 // Find local in outer function scope. 185 if (cctx->ctx_outer != NULL) 186 { 187 if (lookup_local(name, len, lvar, cctx->ctx_outer) == OK) 188 { 189 if (lvar != NULL) 190 { 191 cctx->ctx_outer_used = TRUE; 192 ++lvar->lv_from_outer; 193 } 194 return OK; 195 } 196 } 197 198 return FAIL; 199 } 200 201 /* 202 * Lookup an argument in the current function and an enclosing function. 203 * Returns the argument index in "idxp" 204 * Returns the argument type in "type" 205 * Sets "gen_load_outer" to TRUE if found in outer scope. 206 * Returns OK when found, FAIL otherwise. 207 */ 208 static int 209 arg_exists( 210 char_u *name, 211 size_t len, 212 int *idxp, 213 type_T **type, 214 int *gen_load_outer, 215 cctx_T *cctx) 216 { 217 int idx; 218 char_u *va_name; 219 220 if (len == 0) 221 return FAIL; 222 for (idx = 0; idx < cctx->ctx_ufunc->uf_args.ga_len; ++idx) 223 { 224 char_u *arg = FUNCARG(cctx->ctx_ufunc, idx); 225 226 if (STRNCMP(name, arg, len) == 0 && arg[len] == NUL) 227 { 228 if (idxp != NULL) 229 { 230 // Arguments are located above the frame pointer. One further 231 // if there is a vararg argument 232 *idxp = idx - (cctx->ctx_ufunc->uf_args.ga_len 233 + STACK_FRAME_SIZE) 234 + (cctx->ctx_ufunc->uf_va_name != NULL ? -1 : 0); 235 236 if (cctx->ctx_ufunc->uf_arg_types != NULL) 237 *type = cctx->ctx_ufunc->uf_arg_types[idx]; 238 else 239 *type = &t_any; 240 } 241 return OK; 242 } 243 } 244 245 va_name = cctx->ctx_ufunc->uf_va_name; 246 if (va_name != NULL 247 && STRNCMP(name, va_name, len) == 0 && va_name[len] == NUL) 248 { 249 if (idxp != NULL) 250 { 251 // varargs is always the last argument 252 *idxp = -STACK_FRAME_SIZE - 1; 253 *type = cctx->ctx_ufunc->uf_va_type; 254 } 255 return OK; 256 } 257 258 if (cctx->ctx_outer != NULL) 259 { 260 // Lookup the name for an argument of the outer function. 261 if (arg_exists(name, len, idxp, type, gen_load_outer, cctx->ctx_outer) 262 == OK) 263 { 264 if (gen_load_outer != NULL) 265 ++*gen_load_outer; 266 return OK; 267 } 268 } 269 270 return FAIL; 271 } 272 273 /* 274 * Lookup a script-local variable in the current script, possibly defined in a 275 * block that contains the function "cctx->ctx_ufunc". 276 * "cctx" is NULL at the script level. 277 * If "len" is <= 0 "name" must be NUL terminated. 278 * Return NULL when not found. 279 */ 280 static sallvar_T * 281 find_script_var(char_u *name, size_t len, cctx_T *cctx) 282 { 283 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); 284 hashitem_T *hi; 285 int cc; 286 sallvar_T *sav; 287 ufunc_T *ufunc; 288 289 // Find the list of all script variables with the right name. 290 if (len > 0) 291 { 292 cc = name[len]; 293 name[len] = NUL; 294 } 295 hi = hash_find(&si->sn_all_vars.dv_hashtab, name); 296 if (len > 0) 297 name[len] = cc; 298 if (HASHITEM_EMPTY(hi)) 299 return NULL; 300 301 sav = HI2SAV(hi); 302 if (sav->sav_block_id == 0 || cctx == NULL) 303 // variable defined in the script scope or not in a function. 304 return sav; 305 306 // Go over the variables with this name and find one that was visible 307 // from the function. 308 ufunc = cctx->ctx_ufunc; 309 while (sav != NULL) 310 { 311 int idx; 312 313 // Go over the blocks that this function was defined in. If the 314 // variable block ID matches it was visible to the function. 315 for (idx = 0; idx < ufunc->uf_block_depth; ++idx) 316 if (ufunc->uf_block_ids[idx] == sav->sav_block_id) 317 return sav; 318 sav = sav->sav_next; 319 } 320 321 return NULL; 322 } 323 324 /* 325 * Return TRUE if the script context is Vim9 script. 326 */ 327 static int 328 script_is_vim9() 329 { 330 return SCRIPT_ITEM(current_sctx.sc_sid)->sn_version == SCRIPT_VERSION_VIM9; 331 } 332 333 /* 334 * Lookup a variable (without s: prefix) in the current script. 335 * If "vim9script" is TRUE the script must be Vim9 script. Used for "var" 336 * without "s:". 337 * "cctx" is NULL at the script level. 338 * Returns OK or FAIL. 339 */ 340 int 341 script_var_exists(char_u *name, size_t len, int vim9script, cctx_T *cctx) 342 { 343 int is_vim9_script; 344 345 if (current_sctx.sc_sid <= 0) 346 return FAIL; 347 is_vim9_script = script_is_vim9(); 348 if (vim9script && !is_vim9_script) 349 return FAIL; 350 if (is_vim9_script) 351 { 352 // Check script variables that were visible where the function was 353 // defined. 354 if (find_script_var(name, len, cctx) != NULL) 355 return OK; 356 } 357 else 358 { 359 hashtab_T *ht = &SCRIPT_VARS(current_sctx.sc_sid); 360 dictitem_T *di; 361 int cc; 362 363 // Check script variables that are currently visible 364 cc = name[len]; 365 name[len] = NUL; 366 di = find_var_in_ht(ht, 0, name, TRUE); 367 name[len] = cc; 368 if (di != NULL) 369 return OK; 370 } 371 372 return FAIL; 373 } 374 375 /* 376 * Return TRUE if "name" is a local variable, argument, script variable or 377 * imported. 378 */ 379 static int 380 variable_exists(char_u *name, size_t len, cctx_T *cctx) 381 { 382 return (cctx != NULL 383 && (lookup_local(name, len, NULL, cctx) == OK 384 || arg_exists(name, len, NULL, NULL, NULL, cctx) == OK)) 385 || script_var_exists(name, len, FALSE, cctx) == OK 386 || find_imported(name, len, cctx) != NULL; 387 } 388 389 /* 390 * Return TRUE if "name" is a local variable, argument, script variable, 391 * imported or function. 392 */ 393 static int 394 item_exists(char_u *name, size_t len, int cmd UNUSED, cctx_T *cctx) 395 { 396 int is_global; 397 char_u *p; 398 399 if (variable_exists(name, len, cctx)) 400 return TRUE; 401 402 // This is similar to what is in lookup_scriptitem(): 403 // Find a function, so that a following "->" works. 404 // Require "(" or "->" to follow, "Cmd" is a user command while "Cmd()" is 405 // a function call. 406 p = skipwhite(name + len); 407 408 if (name[len] == '(' || (p[0] == '-' && p[1] == '>')) 409 { 410 // Do not check for an internal function, since it might also be a 411 // valid command, such as ":split" versuse "split()". 412 // Skip "g:" before a function name. 413 is_global = (name[0] == 'g' && name[1] == ':'); 414 return find_func(is_global ? name + 2 : name, is_global, cctx) != NULL; 415 } 416 return FALSE; 417 } 418 419 /* 420 * Check if "p[len]" is already defined, either in script "import_sid" or in 421 * compilation context "cctx". "cctx" is NULL at the script level. 422 * Does not check the global namespace. 423 * If "is_arg" is TRUE the error message is for an argument name. 424 * Return FAIL and give an error if it defined. 425 */ 426 int 427 check_defined(char_u *p, size_t len, cctx_T *cctx, int is_arg) 428 { 429 int c = p[len]; 430 ufunc_T *ufunc = NULL; 431 432 if (script_var_exists(p, len, FALSE, cctx) == OK) 433 { 434 if (is_arg) 435 semsg(_(e_argument_already_declared_in_script_str), p); 436 else 437 semsg(_(e_variable_already_declared_in_script_str), p); 438 return FAIL; 439 } 440 441 p[len] = NUL; 442 if ((cctx != NULL 443 && (lookup_local(p, len, NULL, cctx) == OK 444 || arg_exists(p, len, NULL, NULL, NULL, cctx) == OK)) 445 || find_imported(p, len, cctx) != NULL 446 || (ufunc = find_func_even_dead(p, FALSE, cctx)) != NULL) 447 { 448 // A local or script-local function can shadow a global function. 449 if (ufunc == NULL || !func_is_global(ufunc) 450 || (p[0] == 'g' && p[1] == ':')) 451 { 452 if (is_arg) 453 semsg(_(e_argument_name_shadows_existing_variable_str), p); 454 else 455 semsg(_(e_name_already_defined_str), p); 456 p[len] = c; 457 return FAIL; 458 } 459 } 460 p[len] = c; 461 return OK; 462 } 463 464 465 ///////////////////////////////////////////////////////////////////// 466 // Following generate_ functions expect the caller to call ga_grow(). 467 468 #define RETURN_NULL_IF_SKIP(cctx) if (cctx->ctx_skip == SKIP_YES) return NULL 469 #define RETURN_OK_IF_SKIP(cctx) if (cctx->ctx_skip == SKIP_YES) return OK 470 471 /* 472 * Generate an instruction without arguments. 473 * Returns a pointer to the new instruction, NULL if failed. 474 */ 475 static isn_T * 476 generate_instr(cctx_T *cctx, isntype_T isn_type) 477 { 478 garray_T *instr = &cctx->ctx_instr; 479 isn_T *isn; 480 481 RETURN_NULL_IF_SKIP(cctx); 482 if (ga_grow(instr, 1) == FAIL) 483 return NULL; 484 isn = ((isn_T *)instr->ga_data) + instr->ga_len; 485 isn->isn_type = isn_type; 486 isn->isn_lnum = cctx->ctx_lnum + 1; 487 ++instr->ga_len; 488 489 return isn; 490 } 491 492 /* 493 * Generate an instruction without arguments. 494 * "drop" will be removed from the stack. 495 * Returns a pointer to the new instruction, NULL if failed. 496 */ 497 static isn_T * 498 generate_instr_drop(cctx_T *cctx, isntype_T isn_type, int drop) 499 { 500 garray_T *stack = &cctx->ctx_type_stack; 501 502 RETURN_NULL_IF_SKIP(cctx); 503 stack->ga_len -= drop; 504 return generate_instr(cctx, isn_type); 505 } 506 507 /* 508 * Generate instruction "isn_type" and put "type" on the type stack. 509 */ 510 static isn_T * 511 generate_instr_type(cctx_T *cctx, isntype_T isn_type, type_T *type) 512 { 513 isn_T *isn; 514 garray_T *stack = &cctx->ctx_type_stack; 515 516 if ((isn = generate_instr(cctx, isn_type)) == NULL) 517 return NULL; 518 519 if (ga_grow(stack, 1) == FAIL) 520 return NULL; 521 ((type_T **)stack->ga_data)[stack->ga_len] = type == NULL ? &t_any : type; 522 ++stack->ga_len; 523 524 return isn; 525 } 526 527 /* 528 * If type at "offset" isn't already VAR_STRING then generate ISN_2STRING. 529 * But only for simple types. 530 */ 531 static int 532 may_generate_2STRING(int offset, cctx_T *cctx) 533 { 534 isn_T *isn; 535 isntype_T isntype = ISN_2STRING; 536 garray_T *stack = &cctx->ctx_type_stack; 537 type_T **type; 538 539 RETURN_OK_IF_SKIP(cctx); 540 type = ((type_T **)stack->ga_data) + stack->ga_len + offset; 541 switch ((*type)->tt_type) 542 { 543 // nothing to be done 544 case VAR_STRING: return OK; 545 546 // conversion possible 547 case VAR_SPECIAL: 548 case VAR_BOOL: 549 case VAR_NUMBER: 550 case VAR_FLOAT: 551 break; 552 553 // conversion possible (with runtime check) 554 case VAR_ANY: 555 case VAR_UNKNOWN: 556 isntype = ISN_2STRING_ANY; 557 break; 558 559 // conversion not possible 560 case VAR_VOID: 561 case VAR_BLOB: 562 case VAR_FUNC: 563 case VAR_PARTIAL: 564 case VAR_LIST: 565 case VAR_DICT: 566 case VAR_JOB: 567 case VAR_CHANNEL: 568 to_string_error((*type)->tt_type); 569 return FAIL; 570 } 571 572 *type = &t_string; 573 if ((isn = generate_instr(cctx, isntype)) == NULL) 574 return FAIL; 575 isn->isn_arg.number = offset; 576 577 return OK; 578 } 579 580 static int 581 check_number_or_float(vartype_T type1, vartype_T type2, char_u *op) 582 { 583 if (!((type1 == VAR_NUMBER || type1 == VAR_FLOAT || type1 == VAR_ANY) 584 && (type2 == VAR_NUMBER || type2 == VAR_FLOAT 585 || type2 == VAR_ANY))) 586 { 587 if (*op == '+') 588 emsg(_(e_wrong_argument_type_for_plus)); 589 else 590 semsg(_(e_char_requires_number_or_float_arguments), *op); 591 return FAIL; 592 } 593 return OK; 594 } 595 596 static int 597 generate_add_instr( 598 cctx_T *cctx, 599 vartype_T vartype, 600 type_T *type1, 601 type_T *type2) 602 { 603 garray_T *stack = &cctx->ctx_type_stack; 604 isn_T *isn = generate_instr_drop(cctx, 605 vartype == VAR_NUMBER ? ISN_OPNR 606 : vartype == VAR_LIST ? ISN_ADDLIST 607 : vartype == VAR_BLOB ? ISN_ADDBLOB 608 #ifdef FEAT_FLOAT 609 : vartype == VAR_FLOAT ? ISN_OPFLOAT 610 #endif 611 : ISN_OPANY, 1); 612 613 if (vartype != VAR_LIST && vartype != VAR_BLOB 614 && type1->tt_type != VAR_ANY 615 && type2->tt_type != VAR_ANY 616 && check_number_or_float( 617 type1->tt_type, type2->tt_type, (char_u *)"+") == FAIL) 618 return FAIL; 619 620 if (isn != NULL) 621 isn->isn_arg.op.op_type = EXPR_ADD; 622 623 // When concatenating two lists with different member types the member type 624 // becomes "any". 625 if (vartype == VAR_LIST 626 && type1->tt_type == VAR_LIST && type2->tt_type == VAR_LIST 627 && type1->tt_member != type2->tt_member) 628 (((type_T **)stack->ga_data)[stack->ga_len - 1]) = &t_list_any; 629 630 return isn == NULL ? FAIL : OK; 631 } 632 633 /* 634 * Get the type to use for an instruction for an operation on "type1" and 635 * "type2". If they are matching use a type-specific instruction. Otherwise 636 * fall back to runtime type checking. 637 */ 638 static vartype_T 639 operator_type(type_T *type1, type_T *type2) 640 { 641 if (type1->tt_type == type2->tt_type 642 && (type1->tt_type == VAR_NUMBER 643 || type1->tt_type == VAR_LIST 644 #ifdef FEAT_FLOAT 645 || type1->tt_type == VAR_FLOAT 646 #endif 647 || type1->tt_type == VAR_BLOB)) 648 return type1->tt_type; 649 return VAR_ANY; 650 } 651 652 /* 653 * Generate an instruction with two arguments. The instruction depends on the 654 * type of the arguments. 655 */ 656 static int 657 generate_two_op(cctx_T *cctx, char_u *op) 658 { 659 garray_T *stack = &cctx->ctx_type_stack; 660 type_T *type1; 661 type_T *type2; 662 vartype_T vartype; 663 isn_T *isn; 664 665 RETURN_OK_IF_SKIP(cctx); 666 667 // Get the known type of the two items on the stack. 668 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2]; 669 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 670 vartype = operator_type(type1, type2); 671 672 switch (*op) 673 { 674 case '+': 675 if (generate_add_instr(cctx, vartype, type1, type2) == FAIL) 676 return FAIL; 677 break; 678 679 case '-': 680 case '*': 681 case '/': if (check_number_or_float(type1->tt_type, type2->tt_type, 682 op) == FAIL) 683 return FAIL; 684 if (vartype == VAR_NUMBER) 685 isn = generate_instr_drop(cctx, ISN_OPNR, 1); 686 #ifdef FEAT_FLOAT 687 else if (vartype == VAR_FLOAT) 688 isn = generate_instr_drop(cctx, ISN_OPFLOAT, 1); 689 #endif 690 else 691 isn = generate_instr_drop(cctx, ISN_OPANY, 1); 692 if (isn != NULL) 693 isn->isn_arg.op.op_type = *op == '*' 694 ? EXPR_MULT : *op == '/'? EXPR_DIV : EXPR_SUB; 695 break; 696 697 case '%': if ((type1->tt_type != VAR_ANY 698 && type1->tt_type != VAR_NUMBER) 699 || (type2->tt_type != VAR_ANY 700 && type2->tt_type != VAR_NUMBER)) 701 { 702 emsg(_(e_percent_requires_number_arguments)); 703 return FAIL; 704 } 705 isn = generate_instr_drop(cctx, 706 vartype == VAR_NUMBER ? ISN_OPNR : ISN_OPANY, 1); 707 if (isn != NULL) 708 isn->isn_arg.op.op_type = EXPR_REM; 709 break; 710 } 711 712 // correct type of result 713 if (vartype == VAR_ANY) 714 { 715 type_T *type = &t_any; 716 717 #ifdef FEAT_FLOAT 718 // float+number and number+float results in float 719 if ((type1->tt_type == VAR_NUMBER || type1->tt_type == VAR_FLOAT) 720 && (type2->tt_type == VAR_NUMBER || type2->tt_type == VAR_FLOAT)) 721 type = &t_float; 722 #endif 723 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type; 724 } 725 726 return OK; 727 } 728 729 /* 730 * Get the instruction to use for comparing "type1" with "type2" 731 * Return ISN_DROP when failed. 732 */ 733 static isntype_T 734 get_compare_isn(exprtype_T exprtype, vartype_T type1, vartype_T type2) 735 { 736 isntype_T isntype = ISN_DROP; 737 738 if (type1 == VAR_UNKNOWN) 739 type1 = VAR_ANY; 740 if (type2 == VAR_UNKNOWN) 741 type2 = VAR_ANY; 742 743 if (type1 == type2) 744 { 745 switch (type1) 746 { 747 case VAR_BOOL: isntype = ISN_COMPAREBOOL; break; 748 case VAR_SPECIAL: isntype = ISN_COMPARESPECIAL; break; 749 case VAR_NUMBER: isntype = ISN_COMPARENR; break; 750 case VAR_FLOAT: isntype = ISN_COMPAREFLOAT; break; 751 case VAR_STRING: isntype = ISN_COMPARESTRING; break; 752 case VAR_BLOB: isntype = ISN_COMPAREBLOB; break; 753 case VAR_LIST: isntype = ISN_COMPARELIST; break; 754 case VAR_DICT: isntype = ISN_COMPAREDICT; break; 755 case VAR_FUNC: isntype = ISN_COMPAREFUNC; break; 756 default: isntype = ISN_COMPAREANY; break; 757 } 758 } 759 else if (type1 == VAR_ANY || type2 == VAR_ANY 760 || ((type1 == VAR_NUMBER || type1 == VAR_FLOAT) 761 && (type2 == VAR_NUMBER || type2 == VAR_FLOAT))) 762 isntype = ISN_COMPAREANY; 763 764 if ((exprtype == EXPR_IS || exprtype == EXPR_ISNOT) 765 && (isntype == ISN_COMPAREBOOL 766 || isntype == ISN_COMPARESPECIAL 767 || isntype == ISN_COMPARENR 768 || isntype == ISN_COMPAREFLOAT)) 769 { 770 semsg(_(e_cannot_use_str_with_str), 771 exprtype == EXPR_IS ? "is" : "isnot" , vartype_name(type1)); 772 return ISN_DROP; 773 } 774 if (isntype == ISN_DROP 775 || ((exprtype != EXPR_EQUAL && exprtype != EXPR_NEQUAL 776 && (type1 == VAR_BOOL || type1 == VAR_SPECIAL 777 || type2 == VAR_BOOL || type2 == VAR_SPECIAL))) 778 || ((exprtype != EXPR_EQUAL && exprtype != EXPR_NEQUAL 779 && exprtype != EXPR_IS && exprtype != EXPR_ISNOT 780 && (type1 == VAR_BLOB || type2 == VAR_BLOB 781 || type1 == VAR_LIST || type2 == VAR_LIST)))) 782 { 783 semsg(_(e_cannot_compare_str_with_str), 784 vartype_name(type1), vartype_name(type2)); 785 return ISN_DROP; 786 } 787 return isntype; 788 } 789 790 int 791 check_compare_types(exprtype_T type, typval_T *tv1, typval_T *tv2) 792 { 793 if (get_compare_isn(type, tv1->v_type, tv2->v_type) == ISN_DROP) 794 return FAIL; 795 return OK; 796 } 797 798 /* 799 * Generate an ISN_COMPARE* instruction with a boolean result. 800 */ 801 static int 802 generate_COMPARE(cctx_T *cctx, exprtype_T exprtype, int ic) 803 { 804 isntype_T isntype; 805 isn_T *isn; 806 garray_T *stack = &cctx->ctx_type_stack; 807 vartype_T type1; 808 vartype_T type2; 809 810 RETURN_OK_IF_SKIP(cctx); 811 812 // Get the known type of the two items on the stack. If they are matching 813 // use a type-specific instruction. Otherwise fall back to runtime type 814 // checking. 815 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2]->tt_type; 816 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type; 817 isntype = get_compare_isn(exprtype, type1, type2); 818 if (isntype == ISN_DROP) 819 return FAIL; 820 821 if ((isn = generate_instr(cctx, isntype)) == NULL) 822 return FAIL; 823 isn->isn_arg.op.op_type = exprtype; 824 isn->isn_arg.op.op_ic = ic; 825 826 // takes two arguments, puts one bool back 827 if (stack->ga_len >= 2) 828 { 829 --stack->ga_len; 830 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool; 831 } 832 833 return OK; 834 } 835 836 /* 837 * Generate an ISN_2BOOL instruction. 838 */ 839 static int 840 generate_2BOOL(cctx_T *cctx, int invert) 841 { 842 isn_T *isn; 843 garray_T *stack = &cctx->ctx_type_stack; 844 845 RETURN_OK_IF_SKIP(cctx); 846 if ((isn = generate_instr(cctx, ISN_2BOOL)) == NULL) 847 return FAIL; 848 isn->isn_arg.number = invert; 849 850 // type becomes bool 851 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool; 852 853 return OK; 854 } 855 856 /* 857 * Generate an ISN_COND2BOOL instruction. 858 */ 859 static int 860 generate_COND2BOOL(cctx_T *cctx) 861 { 862 isn_T *isn; 863 garray_T *stack = &cctx->ctx_type_stack; 864 865 RETURN_OK_IF_SKIP(cctx); 866 if ((isn = generate_instr(cctx, ISN_COND2BOOL)) == NULL) 867 return FAIL; 868 869 // type becomes bool 870 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool; 871 872 return OK; 873 } 874 875 static int 876 generate_TYPECHECK( 877 cctx_T *cctx, 878 type_T *expected, 879 int offset, 880 int argidx) 881 { 882 isn_T *isn; 883 garray_T *stack = &cctx->ctx_type_stack; 884 885 RETURN_OK_IF_SKIP(cctx); 886 if ((isn = generate_instr(cctx, ISN_CHECKTYPE)) == NULL) 887 return FAIL; 888 isn->isn_arg.type.ct_type = alloc_type(expected); 889 isn->isn_arg.type.ct_off = (int8_T)offset; 890 isn->isn_arg.type.ct_arg_idx = (int8_T)argidx; 891 892 // type becomes expected 893 ((type_T **)stack->ga_data)[stack->ga_len + offset] = expected; 894 895 return OK; 896 } 897 898 static int 899 generate_SETTYPE( 900 cctx_T *cctx, 901 type_T *expected) 902 { 903 isn_T *isn; 904 905 RETURN_OK_IF_SKIP(cctx); 906 if ((isn = generate_instr(cctx, ISN_SETTYPE)) == NULL) 907 return FAIL; 908 isn->isn_arg.type.ct_type = alloc_type(expected); 909 return OK; 910 } 911 912 /* 913 * Return TRUE if "actual" could be "expected" and a runtime typecheck is to be 914 * used. Return FALSE if the types will never match. 915 */ 916 int 917 use_typecheck(type_T *actual, type_T *expected) 918 { 919 if (actual->tt_type == VAR_ANY 920 || actual->tt_type == VAR_UNKNOWN 921 || (actual->tt_type == VAR_FUNC 922 && (expected->tt_type == VAR_FUNC 923 || expected->tt_type == VAR_PARTIAL) 924 && (actual->tt_member == &t_any || actual->tt_argcount < 0) 925 && ((actual->tt_member == &t_void) 926 == (expected->tt_member == &t_void)))) 927 return TRUE; 928 if ((actual->tt_type == VAR_LIST || actual->tt_type == VAR_DICT) 929 && actual->tt_type == expected->tt_type) 930 // This takes care of a nested list or dict. 931 return use_typecheck(actual->tt_member, expected->tt_member); 932 return FALSE; 933 } 934 935 /* 936 * Check that 937 * - "actual" matches "expected" type or 938 * - "actual" is a type that can be "expected" type: add a runtime check; or 939 * - return FAIL. 940 * If "actual_is_const" is TRUE then the type won't change at runtime, do not 941 * generate a TYPECHECK. 942 */ 943 int 944 need_type( 945 type_T *actual, 946 type_T *expected, 947 int offset, 948 int arg_idx, 949 cctx_T *cctx, 950 int silent, 951 int actual_is_const) 952 { 953 where_T where; 954 955 if (expected == &t_bool && actual != &t_bool 956 && (actual->tt_flags & TTFLAG_BOOL_OK)) 957 { 958 // Using "0", "1" or the result of an expression with "&&" or "||" as a 959 // boolean is OK but requires a conversion. 960 generate_2BOOL(cctx, FALSE); 961 return OK; 962 } 963 964 where.wt_index = arg_idx; 965 where.wt_variable = FALSE; 966 if (check_type(expected, actual, FALSE, where) == OK) 967 return OK; 968 969 // If the actual type can be the expected type add a runtime check. 970 // If it's a constant a runtime check makes no sense. 971 if (!actual_is_const && use_typecheck(actual, expected)) 972 { 973 generate_TYPECHECK(cctx, expected, offset, arg_idx); 974 return OK; 975 } 976 977 if (!silent) 978 arg_type_mismatch(expected, actual, arg_idx); 979 return FAIL; 980 } 981 982 /* 983 * Check that the top of the type stack has a type that can be used as a 984 * condition. Give an error and return FAIL if not. 985 */ 986 static int 987 bool_on_stack(cctx_T *cctx) 988 { 989 garray_T *stack = &cctx->ctx_type_stack; 990 type_T *type; 991 992 type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 993 if (type == &t_bool) 994 return OK; 995 996 if (type == &t_any || type == &t_number) 997 // Number 0 and 1 are OK to use as a bool. "any" could also be a bool. 998 // This requires a runtime type check. 999 return generate_COND2BOOL(cctx); 1000 1001 return need_type(type, &t_bool, -1, 0, cctx, FALSE, FALSE); 1002 } 1003 1004 /* 1005 * Generate an ISN_PUSHNR instruction. 1006 */ 1007 static int 1008 generate_PUSHNR(cctx_T *cctx, varnumber_T number) 1009 { 1010 isn_T *isn; 1011 garray_T *stack = &cctx->ctx_type_stack; 1012 1013 RETURN_OK_IF_SKIP(cctx); 1014 if ((isn = generate_instr_type(cctx, ISN_PUSHNR, &t_number)) == NULL) 1015 return FAIL; 1016 isn->isn_arg.number = number; 1017 1018 if (number == 0 || number == 1) 1019 // A 0 or 1 number can also be used as a bool. 1020 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_number_bool; 1021 return OK; 1022 } 1023 1024 /* 1025 * Generate an ISN_PUSHBOOL instruction. 1026 */ 1027 static int 1028 generate_PUSHBOOL(cctx_T *cctx, varnumber_T number) 1029 { 1030 isn_T *isn; 1031 1032 RETURN_OK_IF_SKIP(cctx); 1033 if ((isn = generate_instr_type(cctx, ISN_PUSHBOOL, &t_bool)) == NULL) 1034 return FAIL; 1035 isn->isn_arg.number = number; 1036 1037 return OK; 1038 } 1039 1040 /* 1041 * Generate an ISN_PUSHSPEC instruction. 1042 */ 1043 static int 1044 generate_PUSHSPEC(cctx_T *cctx, varnumber_T number) 1045 { 1046 isn_T *isn; 1047 1048 RETURN_OK_IF_SKIP(cctx); 1049 if ((isn = generate_instr_type(cctx, ISN_PUSHSPEC, &t_special)) == NULL) 1050 return FAIL; 1051 isn->isn_arg.number = number; 1052 1053 return OK; 1054 } 1055 1056 #ifdef FEAT_FLOAT 1057 /* 1058 * Generate an ISN_PUSHF instruction. 1059 */ 1060 static int 1061 generate_PUSHF(cctx_T *cctx, float_T fnumber) 1062 { 1063 isn_T *isn; 1064 1065 RETURN_OK_IF_SKIP(cctx); 1066 if ((isn = generate_instr_type(cctx, ISN_PUSHF, &t_float)) == NULL) 1067 return FAIL; 1068 isn->isn_arg.fnumber = fnumber; 1069 1070 return OK; 1071 } 1072 #endif 1073 1074 /* 1075 * Generate an ISN_PUSHS instruction. 1076 * Consumes "str". 1077 */ 1078 static int 1079 generate_PUSHS(cctx_T *cctx, char_u *str) 1080 { 1081 isn_T *isn; 1082 1083 if (cctx->ctx_skip == SKIP_YES) 1084 { 1085 vim_free(str); 1086 return OK; 1087 } 1088 if ((isn = generate_instr_type(cctx, ISN_PUSHS, &t_string)) == NULL) 1089 return FAIL; 1090 isn->isn_arg.string = str; 1091 1092 return OK; 1093 } 1094 1095 /* 1096 * Generate an ISN_PUSHCHANNEL instruction. 1097 * Consumes "channel". 1098 */ 1099 static int 1100 generate_PUSHCHANNEL(cctx_T *cctx, channel_T *channel) 1101 { 1102 isn_T *isn; 1103 1104 RETURN_OK_IF_SKIP(cctx); 1105 if ((isn = generate_instr_type(cctx, ISN_PUSHCHANNEL, &t_channel)) == NULL) 1106 return FAIL; 1107 isn->isn_arg.channel = channel; 1108 1109 return OK; 1110 } 1111 1112 /* 1113 * Generate an ISN_PUSHJOB instruction. 1114 * Consumes "job". 1115 */ 1116 static int 1117 generate_PUSHJOB(cctx_T *cctx, job_T *job) 1118 { 1119 isn_T *isn; 1120 1121 RETURN_OK_IF_SKIP(cctx); 1122 if ((isn = generate_instr_type(cctx, ISN_PUSHJOB, &t_channel)) == NULL) 1123 return FAIL; 1124 isn->isn_arg.job = job; 1125 1126 return OK; 1127 } 1128 1129 /* 1130 * Generate an ISN_PUSHBLOB instruction. 1131 * Consumes "blob". 1132 */ 1133 static int 1134 generate_PUSHBLOB(cctx_T *cctx, blob_T *blob) 1135 { 1136 isn_T *isn; 1137 1138 RETURN_OK_IF_SKIP(cctx); 1139 if ((isn = generate_instr_type(cctx, ISN_PUSHBLOB, &t_blob)) == NULL) 1140 return FAIL; 1141 isn->isn_arg.blob = blob; 1142 1143 return OK; 1144 } 1145 1146 /* 1147 * Generate an ISN_PUSHFUNC instruction with name "name". 1148 * Consumes "name". 1149 */ 1150 static int 1151 generate_PUSHFUNC(cctx_T *cctx, char_u *name, type_T *type) 1152 { 1153 isn_T *isn; 1154 1155 RETURN_OK_IF_SKIP(cctx); 1156 if ((isn = generate_instr_type(cctx, ISN_PUSHFUNC, type)) == NULL) 1157 return FAIL; 1158 isn->isn_arg.string = name == NULL ? NULL : vim_strsave(name); 1159 1160 return OK; 1161 } 1162 1163 /* 1164 * Generate an ISN_GETITEM instruction with "index". 1165 */ 1166 static int 1167 generate_GETITEM(cctx_T *cctx, int index) 1168 { 1169 isn_T *isn; 1170 garray_T *stack = &cctx->ctx_type_stack; 1171 type_T *type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 1172 type_T *item_type = &t_any; 1173 1174 RETURN_OK_IF_SKIP(cctx); 1175 1176 if (type->tt_type != VAR_LIST) 1177 { 1178 // cannot happen, caller has checked the type 1179 emsg(_(e_listreq)); 1180 return FAIL; 1181 } 1182 item_type = type->tt_member; 1183 if ((isn = generate_instr(cctx, ISN_GETITEM)) == NULL) 1184 return FAIL; 1185 isn->isn_arg.number = index; 1186 1187 // add the item type to the type stack 1188 if (ga_grow(stack, 1) == FAIL) 1189 return FAIL; 1190 ((type_T **)stack->ga_data)[stack->ga_len] = item_type; 1191 ++stack->ga_len; 1192 return OK; 1193 } 1194 1195 /* 1196 * Generate an ISN_SLICE instruction with "count". 1197 */ 1198 static int 1199 generate_SLICE(cctx_T *cctx, int count) 1200 { 1201 isn_T *isn; 1202 1203 RETURN_OK_IF_SKIP(cctx); 1204 if ((isn = generate_instr(cctx, ISN_SLICE)) == NULL) 1205 return FAIL; 1206 isn->isn_arg.number = count; 1207 return OK; 1208 } 1209 1210 /* 1211 * Generate an ISN_CHECKLEN instruction with "min_len". 1212 */ 1213 static int 1214 generate_CHECKLEN(cctx_T *cctx, int min_len, int more_OK) 1215 { 1216 isn_T *isn; 1217 1218 RETURN_OK_IF_SKIP(cctx); 1219 1220 if ((isn = generate_instr(cctx, ISN_CHECKLEN)) == NULL) 1221 return FAIL; 1222 isn->isn_arg.checklen.cl_min_len = min_len; 1223 isn->isn_arg.checklen.cl_more_OK = more_OK; 1224 1225 return OK; 1226 } 1227 1228 /* 1229 * Generate an ISN_STORE instruction. 1230 */ 1231 static int 1232 generate_STORE(cctx_T *cctx, isntype_T isn_type, int idx, char_u *name) 1233 { 1234 isn_T *isn; 1235 1236 RETURN_OK_IF_SKIP(cctx); 1237 if ((isn = generate_instr_drop(cctx, isn_type, 1)) == NULL) 1238 return FAIL; 1239 if (name != NULL) 1240 isn->isn_arg.string = vim_strsave(name); 1241 else 1242 isn->isn_arg.number = idx; 1243 1244 return OK; 1245 } 1246 1247 /* 1248 * Generate an ISN_STOREOUTER instruction. 1249 */ 1250 static int 1251 generate_STOREOUTER(cctx_T *cctx, int idx, int level) 1252 { 1253 isn_T *isn; 1254 1255 RETURN_OK_IF_SKIP(cctx); 1256 if ((isn = generate_instr_drop(cctx, ISN_STOREOUTER, 1)) == NULL) 1257 return FAIL; 1258 isn->isn_arg.outer.outer_idx = idx; 1259 isn->isn_arg.outer.outer_depth = level; 1260 1261 return OK; 1262 } 1263 1264 /* 1265 * Generate an ISN_STORENR instruction (short for ISN_PUSHNR + ISN_STORE) 1266 */ 1267 static int 1268 generate_STORENR(cctx_T *cctx, int idx, varnumber_T value) 1269 { 1270 isn_T *isn; 1271 1272 RETURN_OK_IF_SKIP(cctx); 1273 if ((isn = generate_instr(cctx, ISN_STORENR)) == NULL) 1274 return FAIL; 1275 isn->isn_arg.storenr.stnr_idx = idx; 1276 isn->isn_arg.storenr.stnr_val = value; 1277 1278 return OK; 1279 } 1280 1281 /* 1282 * Generate an ISN_STOREOPT instruction 1283 */ 1284 static int 1285 generate_STOREOPT(cctx_T *cctx, char_u *name, int opt_flags) 1286 { 1287 isn_T *isn; 1288 1289 RETURN_OK_IF_SKIP(cctx); 1290 if ((isn = generate_instr_drop(cctx, ISN_STOREOPT, 1)) == NULL) 1291 return FAIL; 1292 isn->isn_arg.storeopt.so_name = vim_strsave(name); 1293 isn->isn_arg.storeopt.so_flags = opt_flags; 1294 1295 return OK; 1296 } 1297 1298 /* 1299 * Generate an ISN_LOAD or similar instruction. 1300 */ 1301 static int 1302 generate_LOAD( 1303 cctx_T *cctx, 1304 isntype_T isn_type, 1305 int idx, 1306 char_u *name, 1307 type_T *type) 1308 { 1309 isn_T *isn; 1310 1311 RETURN_OK_IF_SKIP(cctx); 1312 if ((isn = generate_instr_type(cctx, isn_type, type)) == NULL) 1313 return FAIL; 1314 if (name != NULL) 1315 isn->isn_arg.string = vim_strsave(name); 1316 else 1317 isn->isn_arg.number = idx; 1318 1319 return OK; 1320 } 1321 1322 /* 1323 * Generate an ISN_LOADOUTER instruction 1324 */ 1325 static int 1326 generate_LOADOUTER( 1327 cctx_T *cctx, 1328 int idx, 1329 int nesting, 1330 type_T *type) 1331 { 1332 isn_T *isn; 1333 1334 RETURN_OK_IF_SKIP(cctx); 1335 if ((isn = generate_instr_type(cctx, ISN_LOADOUTER, type)) == NULL) 1336 return FAIL; 1337 isn->isn_arg.outer.outer_idx = idx; 1338 isn->isn_arg.outer.outer_depth = nesting; 1339 1340 return OK; 1341 } 1342 1343 /* 1344 * Generate an ISN_LOADV instruction for v:var. 1345 */ 1346 static int 1347 generate_LOADV( 1348 cctx_T *cctx, 1349 char_u *name, 1350 int error) 1351 { 1352 int di_flags; 1353 int vidx = find_vim_var(name, &di_flags); 1354 type_T *type; 1355 1356 RETURN_OK_IF_SKIP(cctx); 1357 if (vidx < 0) 1358 { 1359 if (error) 1360 semsg(_(e_variable_not_found_str), name); 1361 return FAIL; 1362 } 1363 type = typval2type_vimvar(get_vim_var_tv(vidx), cctx->ctx_type_list); 1364 1365 return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, type); 1366 } 1367 1368 /* 1369 * Generate an ISN_UNLET instruction. 1370 */ 1371 static int 1372 generate_UNLET(cctx_T *cctx, isntype_T isn_type, char_u *name, int forceit) 1373 { 1374 isn_T *isn; 1375 1376 RETURN_OK_IF_SKIP(cctx); 1377 if ((isn = generate_instr(cctx, isn_type)) == NULL) 1378 return FAIL; 1379 isn->isn_arg.unlet.ul_name = vim_strsave(name); 1380 isn->isn_arg.unlet.ul_forceit = forceit; 1381 1382 return OK; 1383 } 1384 1385 /* 1386 * Generate an ISN_LOCKCONST instruction. 1387 */ 1388 static int 1389 generate_LOCKCONST(cctx_T *cctx) 1390 { 1391 isn_T *isn; 1392 1393 RETURN_OK_IF_SKIP(cctx); 1394 if ((isn = generate_instr(cctx, ISN_LOCKCONST)) == NULL) 1395 return FAIL; 1396 return OK; 1397 } 1398 1399 /* 1400 * Generate an ISN_LOADS instruction. 1401 */ 1402 static int 1403 generate_OLDSCRIPT( 1404 cctx_T *cctx, 1405 isntype_T isn_type, 1406 char_u *name, 1407 int sid, 1408 type_T *type) 1409 { 1410 isn_T *isn; 1411 1412 RETURN_OK_IF_SKIP(cctx); 1413 if (isn_type == ISN_LOADS) 1414 isn = generate_instr_type(cctx, isn_type, type); 1415 else 1416 isn = generate_instr_drop(cctx, isn_type, 1); 1417 if (isn == NULL) 1418 return FAIL; 1419 isn->isn_arg.loadstore.ls_name = vim_strsave(name); 1420 isn->isn_arg.loadstore.ls_sid = sid; 1421 1422 return OK; 1423 } 1424 1425 /* 1426 * Generate an ISN_LOADSCRIPT or ISN_STORESCRIPT instruction. 1427 */ 1428 static int 1429 generate_VIM9SCRIPT( 1430 cctx_T *cctx, 1431 isntype_T isn_type, 1432 int sid, 1433 int idx, 1434 type_T *type) 1435 { 1436 isn_T *isn; 1437 scriptref_T *sref; 1438 scriptitem_T *si = SCRIPT_ITEM(sid); 1439 1440 RETURN_OK_IF_SKIP(cctx); 1441 if (isn_type == ISN_LOADSCRIPT) 1442 isn = generate_instr_type(cctx, isn_type, type); 1443 else 1444 isn = generate_instr_drop(cctx, isn_type, 1); 1445 if (isn == NULL) 1446 return FAIL; 1447 1448 // This requires three arguments, which doesn't fit in an instruction, thus 1449 // we need to allocate a struct for this. 1450 sref = ALLOC_ONE(scriptref_T); 1451 if (sref == NULL) 1452 return FAIL; 1453 isn->isn_arg.script.scriptref = sref; 1454 sref->sref_sid = sid; 1455 sref->sref_idx = idx; 1456 sref->sref_seq = si->sn_script_seq; 1457 sref->sref_type = type; 1458 return OK; 1459 } 1460 1461 /* 1462 * Generate an ISN_NEWLIST instruction. 1463 */ 1464 static int 1465 generate_NEWLIST(cctx_T *cctx, int count) 1466 { 1467 isn_T *isn; 1468 garray_T *stack = &cctx->ctx_type_stack; 1469 type_T *type; 1470 type_T *member; 1471 1472 RETURN_OK_IF_SKIP(cctx); 1473 if ((isn = generate_instr(cctx, ISN_NEWLIST)) == NULL) 1474 return FAIL; 1475 isn->isn_arg.number = count; 1476 1477 // get the member type from all the items on the stack. 1478 if (count == 0) 1479 member = &t_void; 1480 else 1481 member = get_member_type_from_stack( 1482 ((type_T **)stack->ga_data) + stack->ga_len, count, 1, 1483 cctx->ctx_type_list); 1484 type = get_list_type(member, cctx->ctx_type_list); 1485 1486 // drop the value types 1487 stack->ga_len -= count; 1488 1489 // add the list type to the type stack 1490 if (ga_grow(stack, 1) == FAIL) 1491 return FAIL; 1492 ((type_T **)stack->ga_data)[stack->ga_len] = type; 1493 ++stack->ga_len; 1494 1495 return OK; 1496 } 1497 1498 /* 1499 * Generate an ISN_NEWDICT instruction. 1500 */ 1501 static int 1502 generate_NEWDICT(cctx_T *cctx, int count) 1503 { 1504 isn_T *isn; 1505 garray_T *stack = &cctx->ctx_type_stack; 1506 type_T *type; 1507 type_T *member; 1508 1509 RETURN_OK_IF_SKIP(cctx); 1510 if ((isn = generate_instr(cctx, ISN_NEWDICT)) == NULL) 1511 return FAIL; 1512 isn->isn_arg.number = count; 1513 1514 if (count == 0) 1515 member = &t_void; 1516 else 1517 member = get_member_type_from_stack( 1518 ((type_T **)stack->ga_data) + stack->ga_len, count, 2, 1519 cctx->ctx_type_list); 1520 type = get_dict_type(member, cctx->ctx_type_list); 1521 1522 // drop the key and value types 1523 stack->ga_len -= 2 * count; 1524 1525 // add the dict type to the type stack 1526 if (ga_grow(stack, 1) == FAIL) 1527 return FAIL; 1528 ((type_T **)stack->ga_data)[stack->ga_len] = type; 1529 ++stack->ga_len; 1530 1531 return OK; 1532 } 1533 1534 /* 1535 * Generate an ISN_FUNCREF instruction. 1536 */ 1537 static int 1538 generate_FUNCREF(cctx_T *cctx, ufunc_T *ufunc) 1539 { 1540 isn_T *isn; 1541 garray_T *stack = &cctx->ctx_type_stack; 1542 1543 RETURN_OK_IF_SKIP(cctx); 1544 if ((isn = generate_instr(cctx, ISN_FUNCREF)) == NULL) 1545 return FAIL; 1546 isn->isn_arg.funcref.fr_func = ufunc->uf_dfunc_idx; 1547 cctx->ctx_has_closure = 1; 1548 1549 // If the referenced function is a closure, it may use items further up in 1550 // the nested context, including this one. 1551 if (ufunc->uf_flags & FC_CLOSURE) 1552 cctx->ctx_ufunc->uf_flags |= FC_CLOSURE; 1553 1554 if (ga_grow(stack, 1) == FAIL) 1555 return FAIL; 1556 ((type_T **)stack->ga_data)[stack->ga_len] = 1557 ufunc->uf_func_type == NULL ? &t_func_any : ufunc->uf_func_type; 1558 ++stack->ga_len; 1559 1560 return OK; 1561 } 1562 1563 /* 1564 * Generate an ISN_NEWFUNC instruction. 1565 * "lambda_name" and "func_name" must be in allocated memory and will be 1566 * consumed. 1567 */ 1568 static int 1569 generate_NEWFUNC(cctx_T *cctx, char_u *lambda_name, char_u *func_name) 1570 { 1571 isn_T *isn; 1572 1573 if (cctx->ctx_skip == SKIP_YES) 1574 { 1575 vim_free(lambda_name); 1576 vim_free(func_name); 1577 return OK; 1578 } 1579 if ((isn = generate_instr(cctx, ISN_NEWFUNC)) == NULL) 1580 { 1581 vim_free(lambda_name); 1582 vim_free(func_name); 1583 return FAIL; 1584 } 1585 isn->isn_arg.newfunc.nf_lambda = lambda_name; 1586 isn->isn_arg.newfunc.nf_global = func_name; 1587 1588 return OK; 1589 } 1590 1591 /* 1592 * Generate an ISN_DEF instruction: list functions 1593 */ 1594 static int 1595 generate_DEF(cctx_T *cctx, char_u *name, size_t len) 1596 { 1597 isn_T *isn; 1598 1599 RETURN_OK_IF_SKIP(cctx); 1600 if ((isn = generate_instr(cctx, ISN_DEF)) == NULL) 1601 return FAIL; 1602 if (len > 0) 1603 { 1604 isn->isn_arg.string = vim_strnsave(name, len); 1605 if (isn->isn_arg.string == NULL) 1606 return FAIL; 1607 } 1608 return OK; 1609 } 1610 1611 /* 1612 * Generate an ISN_JUMP instruction. 1613 */ 1614 static int 1615 generate_JUMP(cctx_T *cctx, jumpwhen_T when, int where) 1616 { 1617 isn_T *isn; 1618 garray_T *stack = &cctx->ctx_type_stack; 1619 1620 RETURN_OK_IF_SKIP(cctx); 1621 if ((isn = generate_instr(cctx, ISN_JUMP)) == NULL) 1622 return FAIL; 1623 isn->isn_arg.jump.jump_when = when; 1624 isn->isn_arg.jump.jump_where = where; 1625 1626 if (when != JUMP_ALWAYS && stack->ga_len > 0) 1627 --stack->ga_len; 1628 1629 return OK; 1630 } 1631 1632 /* 1633 * Generate an ISN_JUMP_IF_ARG_SET instruction. 1634 */ 1635 static int 1636 generate_JUMP_IF_ARG_SET(cctx_T *cctx, int arg_off) 1637 { 1638 isn_T *isn; 1639 1640 RETURN_OK_IF_SKIP(cctx); 1641 if ((isn = generate_instr(cctx, ISN_JUMP_IF_ARG_SET)) == NULL) 1642 return FAIL; 1643 isn->isn_arg.jumparg.jump_arg_off = arg_off; 1644 // jump_where is set later 1645 return OK; 1646 } 1647 1648 static int 1649 generate_FOR(cctx_T *cctx, int loop_idx) 1650 { 1651 isn_T *isn; 1652 garray_T *stack = &cctx->ctx_type_stack; 1653 1654 RETURN_OK_IF_SKIP(cctx); 1655 if ((isn = generate_instr(cctx, ISN_FOR)) == NULL) 1656 return FAIL; 1657 isn->isn_arg.forloop.for_idx = loop_idx; 1658 1659 if (ga_grow(stack, 1) == FAIL) 1660 return FAIL; 1661 // type doesn't matter, will be stored next 1662 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any; 1663 ++stack->ga_len; 1664 1665 return OK; 1666 } 1667 /* 1668 * Generate an ISN_TRYCONT instruction. 1669 */ 1670 static int 1671 generate_TRYCONT(cctx_T *cctx, int levels, int where) 1672 { 1673 isn_T *isn; 1674 1675 RETURN_OK_IF_SKIP(cctx); 1676 if ((isn = generate_instr(cctx, ISN_TRYCONT)) == NULL) 1677 return FAIL; 1678 isn->isn_arg.trycont.tct_levels = levels; 1679 isn->isn_arg.trycont.tct_where = where; 1680 1681 return OK; 1682 } 1683 1684 1685 /* 1686 * Generate an ISN_BCALL instruction. 1687 * "method_call" is TRUE for "value->method()" 1688 * Return FAIL if the number of arguments is wrong. 1689 */ 1690 static int 1691 generate_BCALL(cctx_T *cctx, int func_idx, int argcount, int method_call) 1692 { 1693 isn_T *isn; 1694 garray_T *stack = &cctx->ctx_type_stack; 1695 int argoff; 1696 type_T **argtypes = NULL; 1697 type_T *maptype = NULL; 1698 1699 RETURN_OK_IF_SKIP(cctx); 1700 argoff = check_internal_func(func_idx, argcount); 1701 if (argoff < 0) 1702 return FAIL; 1703 1704 if (method_call && argoff > 1) 1705 { 1706 if ((isn = generate_instr(cctx, ISN_SHUFFLE)) == NULL) 1707 return FAIL; 1708 isn->isn_arg.shuffle.shfl_item = argcount; 1709 isn->isn_arg.shuffle.shfl_up = argoff - 1; 1710 } 1711 1712 if (argcount > 0) 1713 { 1714 // Check the types of the arguments. 1715 argtypes = ((type_T **)stack->ga_data) + stack->ga_len - argcount; 1716 if (internal_func_check_arg_types(argtypes, func_idx, argcount, 1717 cctx) == FAIL) 1718 return FAIL; 1719 if (internal_func_is_map(func_idx)) 1720 maptype = *argtypes; 1721 } 1722 1723 if ((isn = generate_instr(cctx, ISN_BCALL)) == NULL) 1724 return FAIL; 1725 isn->isn_arg.bfunc.cbf_idx = func_idx; 1726 isn->isn_arg.bfunc.cbf_argcount = argcount; 1727 1728 // Drop the argument types and push the return type. 1729 stack->ga_len -= argcount; 1730 if (ga_grow(stack, 1) == FAIL) 1731 return FAIL; 1732 ((type_T **)stack->ga_data)[stack->ga_len] = 1733 internal_func_ret_type(func_idx, argcount, argtypes); 1734 ++stack->ga_len; 1735 1736 if (maptype != NULL && maptype->tt_member != NULL 1737 && maptype->tt_member != &t_any) 1738 // Check that map() didn't change the item types. 1739 generate_TYPECHECK(cctx, maptype, -1, 1); 1740 1741 return OK; 1742 } 1743 1744 /* 1745 * Generate an ISN_LISTAPPEND instruction. Works like add(). 1746 * Argument count is already checked. 1747 */ 1748 static int 1749 generate_LISTAPPEND(cctx_T *cctx) 1750 { 1751 garray_T *stack = &cctx->ctx_type_stack; 1752 type_T *list_type; 1753 type_T *item_type; 1754 type_T *expected; 1755 1756 // Caller already checked that list_type is a list. 1757 list_type = ((type_T **)stack->ga_data)[stack->ga_len - 2]; 1758 item_type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 1759 expected = list_type->tt_member; 1760 if (need_type(item_type, expected, -1, 0, cctx, FALSE, FALSE) == FAIL) 1761 return FAIL; 1762 1763 if (generate_instr(cctx, ISN_LISTAPPEND) == NULL) 1764 return FAIL; 1765 1766 --stack->ga_len; // drop the argument 1767 return OK; 1768 } 1769 1770 /* 1771 * Generate an ISN_BLOBAPPEND instruction. Works like add(). 1772 * Argument count is already checked. 1773 */ 1774 static int 1775 generate_BLOBAPPEND(cctx_T *cctx) 1776 { 1777 garray_T *stack = &cctx->ctx_type_stack; 1778 type_T *item_type; 1779 1780 // Caller already checked that blob_type is a blob. 1781 item_type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 1782 if (need_type(item_type, &t_number, -1, 0, cctx, FALSE, FALSE) == FAIL) 1783 return FAIL; 1784 1785 if (generate_instr(cctx, ISN_BLOBAPPEND) == NULL) 1786 return FAIL; 1787 1788 --stack->ga_len; // drop the argument 1789 return OK; 1790 } 1791 1792 /* 1793 * Return TRUE if "ufunc" should be compiled, taking into account whether 1794 * "profile" indicates profiling is to be done. 1795 */ 1796 int 1797 func_needs_compiling(ufunc_T *ufunc, int profile UNUSED) 1798 { 1799 switch (ufunc->uf_def_status) 1800 { 1801 case UF_NOT_COMPILED: break; 1802 case UF_TO_BE_COMPILED: return TRUE; 1803 case UF_COMPILED: 1804 { 1805 #ifdef FEAT_PROFILE 1806 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 1807 + ufunc->uf_dfunc_idx; 1808 1809 return profile ? dfunc->df_instr_prof == NULL 1810 : dfunc->df_instr == NULL; 1811 #else 1812 break; 1813 #endif 1814 } 1815 case UF_COMPILING: break; 1816 } 1817 return FALSE; 1818 } 1819 1820 /* 1821 * Generate an ISN_DCALL or ISN_UCALL instruction. 1822 * Return FAIL if the number of arguments is wrong. 1823 */ 1824 static int 1825 generate_CALL(cctx_T *cctx, ufunc_T *ufunc, int pushed_argcount) 1826 { 1827 isn_T *isn; 1828 garray_T *stack = &cctx->ctx_type_stack; 1829 int regular_args = ufunc->uf_args.ga_len; 1830 int argcount = pushed_argcount; 1831 1832 RETURN_OK_IF_SKIP(cctx); 1833 if (argcount > regular_args && !has_varargs(ufunc)) 1834 { 1835 semsg(_(e_toomanyarg), printable_func_name(ufunc)); 1836 return FAIL; 1837 } 1838 if (argcount < regular_args - ufunc->uf_def_args.ga_len) 1839 { 1840 semsg(_(e_toofewarg), printable_func_name(ufunc)); 1841 return FAIL; 1842 } 1843 1844 if (ufunc->uf_def_status != UF_NOT_COMPILED) 1845 { 1846 int i; 1847 1848 for (i = 0; i < argcount; ++i) 1849 { 1850 type_T *expected; 1851 type_T *actual; 1852 1853 actual = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i]; 1854 if (actual == &t_special 1855 && i >= regular_args - ufunc->uf_def_args.ga_len) 1856 { 1857 // assume v:none used for default argument value 1858 continue; 1859 } 1860 if (i < regular_args) 1861 { 1862 if (ufunc->uf_arg_types == NULL) 1863 continue; 1864 expected = ufunc->uf_arg_types[i]; 1865 } 1866 else if (ufunc->uf_va_type == NULL || ufunc->uf_va_type == &t_any) 1867 // possibly a lambda or "...: any" 1868 expected = &t_any; 1869 else 1870 expected = ufunc->uf_va_type->tt_member; 1871 if (need_type(actual, expected, -argcount + i, i + 1, cctx, 1872 TRUE, FALSE) == FAIL) 1873 { 1874 arg_type_mismatch(expected, actual, i + 1); 1875 return FAIL; 1876 } 1877 } 1878 if (func_needs_compiling(ufunc, PROFILING(ufunc)) 1879 && compile_def_function(ufunc, ufunc->uf_ret_type == NULL, 1880 PROFILING(ufunc), NULL) == FAIL) 1881 return FAIL; 1882 } 1883 1884 if ((isn = generate_instr(cctx, 1885 ufunc->uf_def_status != UF_NOT_COMPILED ? ISN_DCALL 1886 : ISN_UCALL)) == NULL) 1887 return FAIL; 1888 if (isn->isn_type == ISN_DCALL) 1889 { 1890 isn->isn_arg.dfunc.cdf_idx = ufunc->uf_dfunc_idx; 1891 isn->isn_arg.dfunc.cdf_argcount = argcount; 1892 } 1893 else 1894 { 1895 // A user function may be deleted and redefined later, can't use the 1896 // ufunc pointer, need to look it up again at runtime. 1897 isn->isn_arg.ufunc.cuf_name = vim_strsave(ufunc->uf_name); 1898 isn->isn_arg.ufunc.cuf_argcount = argcount; 1899 } 1900 1901 stack->ga_len -= argcount; // drop the arguments 1902 if (ga_grow(stack, 1) == FAIL) 1903 return FAIL; 1904 // add return value 1905 ((type_T **)stack->ga_data)[stack->ga_len] = ufunc->uf_ret_type; 1906 ++stack->ga_len; 1907 1908 return OK; 1909 } 1910 1911 /* 1912 * Generate an ISN_UCALL instruction when the function isn't defined yet. 1913 */ 1914 static int 1915 generate_UCALL(cctx_T *cctx, char_u *name, int argcount) 1916 { 1917 isn_T *isn; 1918 garray_T *stack = &cctx->ctx_type_stack; 1919 1920 RETURN_OK_IF_SKIP(cctx); 1921 if ((isn = generate_instr(cctx, ISN_UCALL)) == NULL) 1922 return FAIL; 1923 isn->isn_arg.ufunc.cuf_name = vim_strsave(name); 1924 isn->isn_arg.ufunc.cuf_argcount = argcount; 1925 1926 stack->ga_len -= argcount; // drop the arguments 1927 if (ga_grow(stack, 1) == FAIL) 1928 return FAIL; 1929 // add return value 1930 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any; 1931 ++stack->ga_len; 1932 1933 return OK; 1934 } 1935 1936 /* 1937 * Generate an ISN_PCALL instruction. 1938 * "type" is the type of the FuncRef. 1939 */ 1940 static int 1941 generate_PCALL( 1942 cctx_T *cctx, 1943 int argcount, 1944 char_u *name, 1945 type_T *type, 1946 int at_top) 1947 { 1948 isn_T *isn; 1949 garray_T *stack = &cctx->ctx_type_stack; 1950 type_T *ret_type; 1951 1952 RETURN_OK_IF_SKIP(cctx); 1953 1954 if (type->tt_type == VAR_ANY) 1955 ret_type = &t_any; 1956 else if (type->tt_type == VAR_FUNC || type->tt_type == VAR_PARTIAL) 1957 { 1958 if (type->tt_argcount != -1) 1959 { 1960 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0; 1961 1962 if (argcount < type->tt_min_argcount - varargs) 1963 { 1964 semsg(_(e_toofewarg), name); 1965 return FAIL; 1966 } 1967 if (!varargs && argcount > type->tt_argcount) 1968 { 1969 semsg(_(e_toomanyarg), name); 1970 return FAIL; 1971 } 1972 if (type->tt_args != NULL) 1973 { 1974 int i; 1975 1976 for (i = 0; i < argcount; ++i) 1977 { 1978 int offset = -argcount + i - 1; 1979 type_T *actual = ((type_T **)stack->ga_data)[ 1980 stack->ga_len + offset]; 1981 type_T *expected; 1982 1983 if (varargs && i >= type->tt_argcount - 1) 1984 expected = type->tt_args[ 1985 type->tt_argcount - 1]->tt_member; 1986 else if (i >= type->tt_min_argcount 1987 && actual == &t_special) 1988 expected = &t_any; 1989 else 1990 expected = type->tt_args[i]; 1991 if (need_type(actual, expected, offset, i + 1, 1992 cctx, TRUE, FALSE) == FAIL) 1993 { 1994 arg_type_mismatch(expected, actual, i + 1); 1995 return FAIL; 1996 } 1997 } 1998 } 1999 } 2000 ret_type = type->tt_member; 2001 } 2002 else 2003 { 2004 semsg(_(e_not_callable_type_str), name); 2005 return FAIL; 2006 } 2007 2008 if ((isn = generate_instr(cctx, ISN_PCALL)) == NULL) 2009 return FAIL; 2010 isn->isn_arg.pfunc.cpf_top = at_top; 2011 isn->isn_arg.pfunc.cpf_argcount = argcount; 2012 2013 stack->ga_len -= argcount; // drop the arguments 2014 2015 // drop the funcref/partial, get back the return value 2016 ((type_T **)stack->ga_data)[stack->ga_len - 1] = ret_type; 2017 2018 // If partial is above the arguments it must be cleared and replaced with 2019 // the return value. 2020 if (at_top && generate_instr(cctx, ISN_PCALL_END) == NULL) 2021 return FAIL; 2022 2023 return OK; 2024 } 2025 2026 /* 2027 * Generate an ISN_STRINGMEMBER instruction. 2028 */ 2029 static int 2030 generate_STRINGMEMBER(cctx_T *cctx, char_u *name, size_t len) 2031 { 2032 isn_T *isn; 2033 garray_T *stack = &cctx->ctx_type_stack; 2034 type_T *type; 2035 2036 RETURN_OK_IF_SKIP(cctx); 2037 if ((isn = generate_instr(cctx, ISN_STRINGMEMBER)) == NULL) 2038 return FAIL; 2039 isn->isn_arg.string = vim_strnsave(name, len); 2040 2041 // check for dict type 2042 type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 2043 if (type->tt_type != VAR_DICT && type != &t_any) 2044 { 2045 emsg(_(e_dictreq)); 2046 return FAIL; 2047 } 2048 // change dict type to dict member type 2049 if (type->tt_type == VAR_DICT) 2050 { 2051 ((type_T **)stack->ga_data)[stack->ga_len - 1] = 2052 type->tt_member == &t_unknown ? &t_any : type->tt_member; 2053 } 2054 2055 return OK; 2056 } 2057 2058 /* 2059 * Generate an ISN_ECHO instruction. 2060 */ 2061 static int 2062 generate_ECHO(cctx_T *cctx, int with_white, int count) 2063 { 2064 isn_T *isn; 2065 2066 RETURN_OK_IF_SKIP(cctx); 2067 if ((isn = generate_instr_drop(cctx, ISN_ECHO, count)) == NULL) 2068 return FAIL; 2069 isn->isn_arg.echo.echo_with_white = with_white; 2070 isn->isn_arg.echo.echo_count = count; 2071 2072 return OK; 2073 } 2074 2075 /* 2076 * Generate an ISN_EXECUTE/ISN_ECHOMSG/ISN_ECHOERR instruction. 2077 */ 2078 static int 2079 generate_MULT_EXPR(cctx_T *cctx, isntype_T isn_type, int count) 2080 { 2081 isn_T *isn; 2082 2083 if ((isn = generate_instr_drop(cctx, isn_type, count)) == NULL) 2084 return FAIL; 2085 isn->isn_arg.number = count; 2086 2087 return OK; 2088 } 2089 2090 /* 2091 * Generate an ISN_PUT instruction. 2092 */ 2093 static int 2094 generate_PUT(cctx_T *cctx, int regname, linenr_T lnum) 2095 { 2096 isn_T *isn; 2097 2098 RETURN_OK_IF_SKIP(cctx); 2099 if ((isn = generate_instr(cctx, ISN_PUT)) == NULL) 2100 return FAIL; 2101 isn->isn_arg.put.put_regname = regname; 2102 isn->isn_arg.put.put_lnum = lnum; 2103 return OK; 2104 } 2105 2106 static int 2107 generate_EXEC(cctx_T *cctx, char_u *line) 2108 { 2109 isn_T *isn; 2110 2111 RETURN_OK_IF_SKIP(cctx); 2112 if ((isn = generate_instr(cctx, ISN_EXEC)) == NULL) 2113 return FAIL; 2114 isn->isn_arg.string = vim_strsave(line); 2115 return OK; 2116 } 2117 2118 static int 2119 generate_EXECCONCAT(cctx_T *cctx, int count) 2120 { 2121 isn_T *isn; 2122 2123 if ((isn = generate_instr_drop(cctx, ISN_EXECCONCAT, count)) == NULL) 2124 return FAIL; 2125 isn->isn_arg.number = count; 2126 return OK; 2127 } 2128 2129 /* 2130 * Generate ISN_RANGE. Consumes "range". Return OK/FAIL. 2131 */ 2132 static int 2133 generate_RANGE(cctx_T *cctx, char_u *range) 2134 { 2135 isn_T *isn; 2136 garray_T *stack = &cctx->ctx_type_stack; 2137 2138 if ((isn = generate_instr(cctx, ISN_RANGE)) == NULL) 2139 return FAIL; 2140 isn->isn_arg.string = range; 2141 2142 if (ga_grow(stack, 1) == FAIL) 2143 return FAIL; 2144 ((type_T **)stack->ga_data)[stack->ga_len] = &t_number; 2145 ++stack->ga_len; 2146 return OK; 2147 } 2148 2149 static int 2150 generate_UNPACK(cctx_T *cctx, int var_count, int semicolon) 2151 { 2152 isn_T *isn; 2153 2154 RETURN_OK_IF_SKIP(cctx); 2155 if ((isn = generate_instr(cctx, ISN_UNPACK)) == NULL) 2156 return FAIL; 2157 isn->isn_arg.unpack.unp_count = var_count; 2158 isn->isn_arg.unpack.unp_semicolon = semicolon; 2159 return OK; 2160 } 2161 2162 /* 2163 * Generate an instruction for any command modifiers. 2164 */ 2165 static int 2166 generate_cmdmods(cctx_T *cctx, cmdmod_T *cmod) 2167 { 2168 isn_T *isn; 2169 2170 if (has_cmdmod(cmod)) 2171 { 2172 cctx->ctx_has_cmdmod = TRUE; 2173 2174 if ((isn = generate_instr(cctx, ISN_CMDMOD)) == NULL) 2175 return FAIL; 2176 isn->isn_arg.cmdmod.cf_cmdmod = ALLOC_ONE(cmdmod_T); 2177 if (isn->isn_arg.cmdmod.cf_cmdmod == NULL) 2178 return FAIL; 2179 mch_memmove(isn->isn_arg.cmdmod.cf_cmdmod, cmod, sizeof(cmdmod_T)); 2180 // filter program now belongs to the instruction 2181 cmod->cmod_filter_regmatch.regprog = NULL; 2182 } 2183 2184 return OK; 2185 } 2186 2187 static int 2188 generate_undo_cmdmods(cctx_T *cctx) 2189 { 2190 if (cctx->ctx_has_cmdmod && generate_instr(cctx, ISN_CMDMOD_REV) == NULL) 2191 return FAIL; 2192 cctx->ctx_has_cmdmod = FALSE; 2193 return OK; 2194 } 2195 2196 static int 2197 misplaced_cmdmod(cctx_T *cctx) 2198 { 2199 garray_T *instr = &cctx->ctx_instr; 2200 2201 if (cctx->ctx_has_cmdmod 2202 && ((isn_T *)instr->ga_data)[instr->ga_len - 1].isn_type 2203 == ISN_CMDMOD) 2204 { 2205 emsg(_(e_misplaced_command_modifier)); 2206 return TRUE; 2207 } 2208 return FALSE; 2209 } 2210 2211 /* 2212 * Get the index of the current instruction. 2213 * This compenstates for a preceding ISN_CMDMOD and ISN_PROF_START. 2214 */ 2215 static int 2216 current_instr_idx(cctx_T *cctx) 2217 { 2218 garray_T *instr = &cctx->ctx_instr; 2219 int idx = instr->ga_len; 2220 2221 if (cctx->ctx_has_cmdmod && ((isn_T *)instr->ga_data)[idx - 1] 2222 .isn_type == ISN_CMDMOD) 2223 --idx; 2224 #ifdef FEAT_PROFILE 2225 if (cctx->ctx_profiling && ((isn_T *)instr->ga_data)[idx - 1] 2226 .isn_type == ISN_PROF_START) 2227 --idx; 2228 #endif 2229 return idx; 2230 } 2231 2232 #ifdef FEAT_PROFILE 2233 static void 2234 may_generate_prof_end(cctx_T *cctx, int prof_lnum) 2235 { 2236 if (cctx->ctx_profiling && prof_lnum >= 0) 2237 generate_instr(cctx, ISN_PROF_END); 2238 } 2239 #endif 2240 2241 /* 2242 * Reserve space for a local variable. 2243 * Return the variable or NULL if it failed. 2244 */ 2245 static lvar_T * 2246 reserve_local( 2247 cctx_T *cctx, 2248 char_u *name, 2249 size_t len, 2250 int isConst, 2251 type_T *type) 2252 { 2253 lvar_T *lvar; 2254 2255 if (arg_exists(name, len, NULL, NULL, NULL, cctx) == OK) 2256 { 2257 emsg_namelen(_(e_str_is_used_as_argument), name, (int)len); 2258 return NULL; 2259 } 2260 2261 if (ga_grow(&cctx->ctx_locals, 1) == FAIL) 2262 return NULL; 2263 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + cctx->ctx_locals.ga_len++; 2264 CLEAR_POINTER(lvar); 2265 2266 // Every local variable uses the next entry on the stack. We could re-use 2267 // the last ones when leaving a scope, but then variables used in a closure 2268 // might get overwritten. To keep things simple do not re-use stack 2269 // entries. This is less efficient, but memory is cheap these days. 2270 lvar->lv_idx = cctx->ctx_locals_count++; 2271 2272 lvar->lv_name = vim_strnsave(name, len == 0 ? STRLEN(name) : len); 2273 lvar->lv_const = isConst; 2274 lvar->lv_type = type; 2275 2276 return lvar; 2277 } 2278 2279 /* 2280 * Remove local variables above "new_top". 2281 */ 2282 static void 2283 unwind_locals(cctx_T *cctx, int new_top) 2284 { 2285 if (cctx->ctx_locals.ga_len > new_top) 2286 { 2287 int idx; 2288 lvar_T *lvar; 2289 2290 for (idx = new_top; idx < cctx->ctx_locals.ga_len; ++idx) 2291 { 2292 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx; 2293 vim_free(lvar->lv_name); 2294 } 2295 } 2296 cctx->ctx_locals.ga_len = new_top; 2297 } 2298 2299 /* 2300 * Free all local variables. 2301 */ 2302 static void 2303 free_locals(cctx_T *cctx) 2304 { 2305 unwind_locals(cctx, 0); 2306 ga_clear(&cctx->ctx_locals); 2307 } 2308 2309 /* 2310 * If "check_writable" is ASSIGN_CONST give an error if the variable was 2311 * defined with :final or :const, if "check_writable" is ASSIGN_FINAL give an 2312 * error if the variable was defined with :const. 2313 */ 2314 static int 2315 check_item_writable(svar_T *sv, int check_writable, char_u *name) 2316 { 2317 if ((check_writable == ASSIGN_CONST && sv->sv_const != 0) 2318 || (check_writable == ASSIGN_FINAL 2319 && sv->sv_const == ASSIGN_CONST)) 2320 { 2321 semsg(_(e_readonlyvar), name); 2322 return FAIL; 2323 } 2324 return OK; 2325 } 2326 2327 /* 2328 * Find "name" in script-local items of script "sid". 2329 * Pass "check_writable" to check_item_writable(). 2330 * Returns the index in "sn_var_vals" if found. 2331 * If found but not in "sn_var_vals" returns -1. 2332 * If not found or the variable is not writable returns -2. 2333 */ 2334 int 2335 get_script_item_idx(int sid, char_u *name, int check_writable, cctx_T *cctx) 2336 { 2337 hashtab_T *ht; 2338 dictitem_T *di; 2339 scriptitem_T *si = SCRIPT_ITEM(sid); 2340 svar_T *sv; 2341 int idx; 2342 2343 if (!SCRIPT_ID_VALID(sid)) 2344 return -1; 2345 if (sid == current_sctx.sc_sid) 2346 { 2347 sallvar_T *sav = find_script_var(name, 0, cctx); 2348 2349 if (sav == NULL) 2350 return -2; 2351 idx = sav->sav_var_vals_idx; 2352 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; 2353 if (check_item_writable(sv, check_writable, name) == FAIL) 2354 return -2; 2355 return idx; 2356 } 2357 2358 // First look the name up in the hashtable. 2359 ht = &SCRIPT_VARS(sid); 2360 di = find_var_in_ht(ht, 0, name, TRUE); 2361 if (di == NULL) 2362 return -2; 2363 2364 // Now find the svar_T index in sn_var_vals. 2365 for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx) 2366 { 2367 sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; 2368 if (sv->sv_tv == &di->di_tv) 2369 { 2370 if (check_item_writable(sv, check_writable, name) == FAIL) 2371 return -2; 2372 return idx; 2373 } 2374 } 2375 return -1; 2376 } 2377 2378 /* 2379 * Find "name" in imported items of the current script or in "cctx" if not 2380 * NULL. 2381 */ 2382 imported_T * 2383 find_imported(char_u *name, size_t len, cctx_T *cctx) 2384 { 2385 int idx; 2386 2387 if (!SCRIPT_ID_VALID(current_sctx.sc_sid)) 2388 return NULL; 2389 if (cctx != NULL) 2390 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx) 2391 { 2392 imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data) 2393 + idx; 2394 2395 if (len == 0 ? STRCMP(name, import->imp_name) == 0 2396 : STRLEN(import->imp_name) == len 2397 && STRNCMP(name, import->imp_name, len) == 0) 2398 return import; 2399 } 2400 2401 return find_imported_in_script(name, len, current_sctx.sc_sid); 2402 } 2403 2404 imported_T * 2405 find_imported_in_script(char_u *name, size_t len, int sid) 2406 { 2407 scriptitem_T *si; 2408 int idx; 2409 2410 if (!SCRIPT_ID_VALID(sid)) 2411 return NULL; 2412 si = SCRIPT_ITEM(sid); 2413 for (idx = 0; idx < si->sn_imports.ga_len; ++idx) 2414 { 2415 imported_T *import = ((imported_T *)si->sn_imports.ga_data) + idx; 2416 2417 if (len == 0 ? STRCMP(name, import->imp_name) == 0 2418 : STRLEN(import->imp_name) == len 2419 && STRNCMP(name, import->imp_name, len) == 0) 2420 return import; 2421 } 2422 return NULL; 2423 } 2424 2425 /* 2426 * Free all imported variables. 2427 */ 2428 static void 2429 free_imported(cctx_T *cctx) 2430 { 2431 int idx; 2432 2433 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx) 2434 { 2435 imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data) + idx; 2436 2437 vim_free(import->imp_name); 2438 } 2439 ga_clear(&cctx->ctx_imports); 2440 } 2441 2442 /* 2443 * Return a pointer to the next line that isn't empty or only contains a 2444 * comment. Skips over white space. 2445 * Returns NULL if there is none. 2446 */ 2447 char_u * 2448 peek_next_line_from_context(cctx_T *cctx) 2449 { 2450 int lnum = cctx->ctx_lnum; 2451 2452 while (++lnum < cctx->ctx_ufunc->uf_lines.ga_len) 2453 { 2454 char_u *line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[lnum]; 2455 char_u *p; 2456 2457 // ignore NULLs inserted for continuation lines 2458 if (line != NULL) 2459 { 2460 p = skipwhite(line); 2461 if (vim9_bad_comment(p)) 2462 return NULL; 2463 if (*p != NUL && !vim9_comment_start(p)) 2464 return p; 2465 } 2466 } 2467 return NULL; 2468 } 2469 2470 /* 2471 * Called when checking for a following operator at "arg". When the rest of 2472 * the line is empty or only a comment, peek the next line. If there is a next 2473 * line return a pointer to it and set "nextp". 2474 * Otherwise skip over white space. 2475 */ 2476 static char_u * 2477 may_peek_next_line(cctx_T *cctx, char_u *arg, char_u **nextp) 2478 { 2479 char_u *p = skipwhite(arg); 2480 2481 *nextp = NULL; 2482 if (*p == NUL || (VIM_ISWHITE(*arg) && vim9_comment_start(p))) 2483 { 2484 *nextp = peek_next_line_from_context(cctx); 2485 if (*nextp != NULL) 2486 return *nextp; 2487 } 2488 return p; 2489 } 2490 2491 /* 2492 * Get the next line of the function from "cctx". 2493 * Skips over empty lines. Skips over comment lines if "skip_comment" is TRUE. 2494 * Returns NULL when at the end. 2495 */ 2496 char_u * 2497 next_line_from_context(cctx_T *cctx, int skip_comment) 2498 { 2499 char_u *line; 2500 2501 do 2502 { 2503 ++cctx->ctx_lnum; 2504 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len) 2505 { 2506 line = NULL; 2507 break; 2508 } 2509 line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum]; 2510 cctx->ctx_line_start = line; 2511 SOURCING_LNUM = cctx->ctx_lnum + 1; 2512 } while (line == NULL || *skipwhite(line) == NUL 2513 || (skip_comment && vim9_comment_start(skipwhite(line)))); 2514 return line; 2515 } 2516 2517 /* 2518 * Skip over white space at "whitep" and assign to "*arg". 2519 * If "*arg" is at the end of the line, advance to the next line. 2520 * Also when "whitep" points to white space and "*arg" is on a "#". 2521 * Return FAIL if beyond the last line, "*arg" is unmodified then. 2522 */ 2523 static int 2524 may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx) 2525 { 2526 *arg = skipwhite(whitep); 2527 if (vim9_bad_comment(*arg)) 2528 return FAIL; 2529 if (**arg == NUL || (VIM_ISWHITE(*whitep) && vim9_comment_start(*arg))) 2530 { 2531 char_u *next = next_line_from_context(cctx, TRUE); 2532 2533 if (next == NULL) 2534 return FAIL; 2535 *arg = skipwhite(next); 2536 } 2537 return OK; 2538 } 2539 2540 /* 2541 * Idem, and give an error when failed. 2542 */ 2543 static int 2544 may_get_next_line_error(char_u *whitep, char_u **arg, cctx_T *cctx) 2545 { 2546 if (may_get_next_line(whitep, arg, cctx) == FAIL) 2547 { 2548 SOURCING_LNUM = cctx->ctx_lnum + 1; 2549 emsg(_(e_line_incomplete)); 2550 return FAIL; 2551 } 2552 return OK; 2553 } 2554 2555 2556 // Structure passed between the compile_expr* functions to keep track of 2557 // constants that have been parsed but for which no code was produced yet. If 2558 // possible expressions on these constants are applied at compile time. If 2559 // that is not possible, the code to push the constants needs to be generated 2560 // before other instructions. 2561 // Using 50 should be more than enough of 5 levels of (). 2562 #define PPSIZE 50 2563 typedef struct { 2564 typval_T pp_tv[PPSIZE]; // stack of ppconst constants 2565 int pp_used; // active entries in pp_tv[] 2566 int pp_is_const; // all generated code was constants, used for a 2567 // list or dict with constant members 2568 } ppconst_T; 2569 2570 static int compile_expr0_ext(char_u **arg, cctx_T *cctx, int *is_const); 2571 static int compile_expr0(char_u **arg, cctx_T *cctx); 2572 static int compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst); 2573 2574 /* 2575 * Generate a PUSH instruction for "tv". 2576 * "tv" will be consumed or cleared. 2577 * Nothing happens if "tv" is NULL or of type VAR_UNKNOWN; 2578 */ 2579 static int 2580 generate_tv_PUSH(cctx_T *cctx, typval_T *tv) 2581 { 2582 if (tv != NULL) 2583 { 2584 switch (tv->v_type) 2585 { 2586 case VAR_UNKNOWN: 2587 break; 2588 case VAR_BOOL: 2589 generate_PUSHBOOL(cctx, tv->vval.v_number); 2590 break; 2591 case VAR_SPECIAL: 2592 generate_PUSHSPEC(cctx, tv->vval.v_number); 2593 break; 2594 case VAR_NUMBER: 2595 generate_PUSHNR(cctx, tv->vval.v_number); 2596 break; 2597 #ifdef FEAT_FLOAT 2598 case VAR_FLOAT: 2599 generate_PUSHF(cctx, tv->vval.v_float); 2600 break; 2601 #endif 2602 case VAR_BLOB: 2603 generate_PUSHBLOB(cctx, tv->vval.v_blob); 2604 tv->vval.v_blob = NULL; 2605 break; 2606 case VAR_STRING: 2607 generate_PUSHS(cctx, tv->vval.v_string); 2608 tv->vval.v_string = NULL; 2609 break; 2610 default: 2611 iemsg("constant type not supported"); 2612 clear_tv(tv); 2613 return FAIL; 2614 } 2615 tv->v_type = VAR_UNKNOWN; 2616 } 2617 return OK; 2618 } 2619 2620 /* 2621 * Generate code for any ppconst entries. 2622 */ 2623 static int 2624 generate_ppconst(cctx_T *cctx, ppconst_T *ppconst) 2625 { 2626 int i; 2627 int ret = OK; 2628 int save_skip = cctx->ctx_skip; 2629 2630 cctx->ctx_skip = SKIP_NOT; 2631 for (i = 0; i < ppconst->pp_used; ++i) 2632 if (generate_tv_PUSH(cctx, &ppconst->pp_tv[i]) == FAIL) 2633 ret = FAIL; 2634 ppconst->pp_used = 0; 2635 cctx->ctx_skip = save_skip; 2636 return ret; 2637 } 2638 2639 /* 2640 * Clear ppconst constants. Used when failing. 2641 */ 2642 static void 2643 clear_ppconst(ppconst_T *ppconst) 2644 { 2645 int i; 2646 2647 for (i = 0; i < ppconst->pp_used; ++i) 2648 clear_tv(&ppconst->pp_tv[i]); 2649 ppconst->pp_used = 0; 2650 } 2651 2652 /* 2653 * Compile getting a member from a list/dict/string/blob. Stack has the 2654 * indexable value and the index. 2655 */ 2656 static int 2657 compile_member(int is_slice, cctx_T *cctx) 2658 { 2659 type_T **typep; 2660 garray_T *stack = &cctx->ctx_type_stack; 2661 vartype_T vtype; 2662 type_T *valtype; 2663 2664 // We can index a list and a dict. If we don't know the type 2665 // we can use the index value type. 2666 // TODO: If we don't know use an instruction to figure it out at 2667 // runtime. 2668 typep = ((type_T **)stack->ga_data) + stack->ga_len 2669 - (is_slice ? 3 : 2); 2670 vtype = (*typep)->tt_type; 2671 valtype = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 2672 // If the index is a string, the variable must be a Dict. 2673 if (*typep == &t_any && valtype == &t_string) 2674 vtype = VAR_DICT; 2675 if (vtype == VAR_STRING || vtype == VAR_LIST || vtype == VAR_BLOB) 2676 { 2677 if (need_type(valtype, &t_number, -1, 0, cctx, FALSE, FALSE) == FAIL) 2678 return FAIL; 2679 if (is_slice) 2680 { 2681 valtype = ((type_T **)stack->ga_data)[stack->ga_len - 2]; 2682 if (need_type(valtype, &t_number, -2, 0, cctx, 2683 FALSE, FALSE) == FAIL) 2684 return FAIL; 2685 } 2686 } 2687 2688 if (vtype == VAR_DICT) 2689 { 2690 if (is_slice) 2691 { 2692 emsg(_(e_cannot_slice_dictionary)); 2693 return FAIL; 2694 } 2695 if ((*typep)->tt_type == VAR_DICT) 2696 { 2697 *typep = (*typep)->tt_member; 2698 if (*typep == &t_unknown) 2699 // empty dict was used 2700 *typep = &t_any; 2701 } 2702 else 2703 { 2704 if (need_type(*typep, &t_dict_any, -2, 0, cctx, 2705 FALSE, FALSE) == FAIL) 2706 return FAIL; 2707 *typep = &t_any; 2708 } 2709 if (may_generate_2STRING(-1, cctx) == FAIL) 2710 return FAIL; 2711 if (generate_instr_drop(cctx, ISN_MEMBER, 1) == FAIL) 2712 return FAIL; 2713 } 2714 else if (vtype == VAR_STRING) 2715 { 2716 *typep = &t_string; 2717 if ((is_slice 2718 ? generate_instr_drop(cctx, ISN_STRSLICE, 2) 2719 : generate_instr_drop(cctx, ISN_STRINDEX, 1)) == FAIL) 2720 return FAIL; 2721 } 2722 else if (vtype == VAR_BLOB) 2723 { 2724 emsg("Sorry, blob index and slice not implemented yet"); 2725 return FAIL; 2726 } 2727 else if (vtype == VAR_LIST || *typep == &t_any) 2728 { 2729 if (is_slice) 2730 { 2731 if (generate_instr_drop(cctx, 2732 vtype == VAR_LIST ? ISN_LISTSLICE : ISN_ANYSLICE, 2733 2) == FAIL) 2734 return FAIL; 2735 } 2736 else 2737 { 2738 if ((*typep)->tt_type == VAR_LIST) 2739 { 2740 *typep = (*typep)->tt_member; 2741 if (*typep == &t_unknown) 2742 // empty list was used 2743 *typep = &t_any; 2744 } 2745 if (generate_instr_drop(cctx, 2746 vtype == VAR_LIST ? ISN_LISTINDEX : ISN_ANYINDEX, 1) == FAIL) 2747 return FAIL; 2748 } 2749 } 2750 else 2751 { 2752 emsg(_(e_string_list_dict_or_blob_required)); 2753 return FAIL; 2754 } 2755 return OK; 2756 } 2757 2758 /* 2759 * Generate an instruction to load script-local variable "name", without the 2760 * leading "s:". 2761 * Also finds imported variables. 2762 */ 2763 static int 2764 compile_load_scriptvar( 2765 cctx_T *cctx, 2766 char_u *name, // variable NUL terminated 2767 char_u *start, // start of variable 2768 char_u **end, // end of variable 2769 int error) // when TRUE may give error 2770 { 2771 scriptitem_T *si; 2772 int idx; 2773 imported_T *import; 2774 2775 if (!SCRIPT_ID_VALID(current_sctx.sc_sid)) 2776 return FAIL; 2777 si = SCRIPT_ITEM(current_sctx.sc_sid); 2778 idx = get_script_item_idx(current_sctx.sc_sid, name, 0, cctx); 2779 if (idx == -1 || si->sn_version != SCRIPT_VERSION_VIM9) 2780 { 2781 // variable is not in sn_var_vals: old style script. 2782 return generate_OLDSCRIPT(cctx, ISN_LOADS, name, current_sctx.sc_sid, 2783 &t_any); 2784 } 2785 if (idx >= 0) 2786 { 2787 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; 2788 2789 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT, 2790 current_sctx.sc_sid, idx, sv->sv_type); 2791 return OK; 2792 } 2793 2794 import = find_imported(name, 0, cctx); 2795 if (import != NULL) 2796 { 2797 if (import->imp_flags & IMP_FLAGS_STAR) 2798 { 2799 char_u *p = skipwhite(*end); 2800 char_u *exp_name; 2801 int cc; 2802 ufunc_T *ufunc; 2803 type_T *type; 2804 2805 // Used "import * as Name", need to lookup the member. 2806 if (*p != '.') 2807 { 2808 semsg(_(e_expected_dot_after_name_str), start); 2809 return FAIL; 2810 } 2811 ++p; 2812 if (VIM_ISWHITE(*p)) 2813 { 2814 emsg(_(e_no_white_space_allowed_after_dot)); 2815 return FAIL; 2816 } 2817 2818 // isolate one name 2819 exp_name = p; 2820 while (eval_isnamec(*p)) 2821 ++p; 2822 cc = *p; 2823 *p = NUL; 2824 2825 idx = find_exported(import->imp_sid, exp_name, &ufunc, &type, 2826 cctx, TRUE); 2827 *p = cc; 2828 p = skipwhite(p); 2829 *end = p; 2830 2831 if (idx < 0) 2832 { 2833 if (*p == '(' && ufunc != NULL) 2834 { 2835 generate_PUSHFUNC(cctx, ufunc->uf_name, import->imp_type); 2836 return OK; 2837 } 2838 return FAIL; 2839 } 2840 2841 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT, 2842 import->imp_sid, 2843 idx, 2844 type); 2845 } 2846 else if (import->imp_funcname != NULL) 2847 generate_PUSHFUNC(cctx, import->imp_funcname, import->imp_type); 2848 else 2849 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT, 2850 import->imp_sid, 2851 import->imp_var_vals_idx, 2852 import->imp_type); 2853 return OK; 2854 } 2855 2856 if (error) 2857 semsg(_(e_item_not_found_str), name); 2858 return FAIL; 2859 } 2860 2861 static int 2862 generate_funcref(cctx_T *cctx, char_u *name) 2863 { 2864 ufunc_T *ufunc = find_func(name, FALSE, cctx); 2865 2866 if (ufunc == NULL) 2867 return FAIL; 2868 2869 // Need to compile any default values to get the argument types. 2870 if (func_needs_compiling(ufunc, PROFILING(ufunc)) 2871 && compile_def_function(ufunc, TRUE, PROFILING(ufunc), NULL) 2872 == FAIL) 2873 return FAIL; 2874 return generate_PUSHFUNC(cctx, ufunc->uf_name, ufunc->uf_func_type); 2875 } 2876 2877 /* 2878 * Compile a variable name into a load instruction. 2879 * "end" points to just after the name. 2880 * "is_expr" is TRUE when evaluating an expression, might be a funcref. 2881 * When "error" is FALSE do not give an error when not found. 2882 */ 2883 static int 2884 compile_load( 2885 char_u **arg, 2886 char_u *end_arg, 2887 cctx_T *cctx, 2888 int is_expr, 2889 int error) 2890 { 2891 type_T *type; 2892 char_u *name = NULL; 2893 char_u *end = end_arg; 2894 int res = FAIL; 2895 int prev_called_emsg = called_emsg; 2896 2897 if (*(*arg + 1) == ':') 2898 { 2899 // load namespaced variable 2900 if (end <= *arg + 2) 2901 { 2902 isntype_T isn_type; 2903 2904 switch (**arg) 2905 { 2906 case 'g': isn_type = ISN_LOADGDICT; break; 2907 case 'w': isn_type = ISN_LOADWDICT; break; 2908 case 't': isn_type = ISN_LOADTDICT; break; 2909 case 'b': isn_type = ISN_LOADBDICT; break; 2910 default: 2911 semsg(_(e_namespace_not_supported_str), *arg); 2912 goto theend; 2913 } 2914 if (generate_instr_type(cctx, isn_type, &t_dict_any) == NULL) 2915 goto theend; 2916 res = OK; 2917 } 2918 else 2919 { 2920 isntype_T isn_type = ISN_DROP; 2921 2922 name = vim_strnsave(*arg + 2, end - (*arg + 2)); 2923 if (name == NULL) 2924 return FAIL; 2925 2926 switch (**arg) 2927 { 2928 case 'v': res = generate_LOADV(cctx, name, error); 2929 break; 2930 case 's': res = compile_load_scriptvar(cctx, name, 2931 NULL, &end, error); 2932 break; 2933 case 'g': if (vim_strchr(name, AUTOLOAD_CHAR) == NULL) 2934 isn_type = ISN_LOADG; 2935 else 2936 { 2937 isn_type = ISN_LOADAUTO; 2938 vim_free(name); 2939 name = vim_strnsave(*arg, end - *arg); 2940 if (name == NULL) 2941 return FAIL; 2942 } 2943 break; 2944 case 'w': isn_type = ISN_LOADW; break; 2945 case 't': isn_type = ISN_LOADT; break; 2946 case 'b': isn_type = ISN_LOADB; break; 2947 default: // cannot happen, just in case 2948 semsg(_(e_namespace_not_supported_str), *arg); 2949 goto theend; 2950 } 2951 if (isn_type != ISN_DROP) 2952 { 2953 // Global, Buffer-local, Window-local and Tabpage-local 2954 // variables can be defined later, thus we don't check if it 2955 // exists, give error at runtime. 2956 res = generate_LOAD(cctx, isn_type, 0, name, &t_any); 2957 } 2958 } 2959 } 2960 else 2961 { 2962 size_t len = end - *arg; 2963 int idx; 2964 int gen_load = FALSE; 2965 int gen_load_outer = 0; 2966 2967 name = vim_strnsave(*arg, end - *arg); 2968 if (name == NULL) 2969 return FAIL; 2970 2971 if (arg_exists(*arg, len, &idx, &type, &gen_load_outer, cctx) == OK) 2972 { 2973 if (gen_load_outer == 0) 2974 gen_load = TRUE; 2975 } 2976 else 2977 { 2978 lvar_T lvar; 2979 2980 if (lookup_local(*arg, len, &lvar, cctx) == OK) 2981 { 2982 type = lvar.lv_type; 2983 idx = lvar.lv_idx; 2984 if (lvar.lv_from_outer != 0) 2985 gen_load_outer = lvar.lv_from_outer; 2986 else 2987 gen_load = TRUE; 2988 } 2989 else 2990 { 2991 // "var" can be script-local even without using "s:" if it 2992 // already exists in a Vim9 script or when it's imported. 2993 if (script_var_exists(*arg, len, TRUE, cctx) == OK 2994 || find_imported(name, 0, cctx) != NULL) 2995 res = compile_load_scriptvar(cctx, name, *arg, &end, FALSE); 2996 2997 // When evaluating an expression and the name starts with an 2998 // uppercase letter or "x:" it can be a user defined function. 2999 // TODO: this is just guessing 3000 if (res == FAIL && is_expr 3001 && (ASCII_ISUPPER(*name) || name[1] == ':')) 3002 res = generate_funcref(cctx, name); 3003 } 3004 } 3005 if (gen_load) 3006 res = generate_LOAD(cctx, ISN_LOAD, idx, NULL, type); 3007 if (gen_load_outer > 0) 3008 { 3009 res = generate_LOADOUTER(cctx, idx, gen_load_outer, type); 3010 cctx->ctx_outer_used = TRUE; 3011 } 3012 } 3013 3014 *arg = end; 3015 3016 theend: 3017 if (res == FAIL && error && called_emsg == prev_called_emsg) 3018 semsg(_(e_variable_not_found_str), name); 3019 vim_free(name); 3020 return res; 3021 } 3022 3023 /* 3024 * Compile the argument expressions. 3025 * "arg" points to just after the "(" and is advanced to after the ")" 3026 */ 3027 static int 3028 compile_arguments(char_u **arg, cctx_T *cctx, int *argcount) 3029 { 3030 char_u *p = *arg; 3031 char_u *whitep = *arg; 3032 int must_end = FALSE; 3033 3034 for (;;) 3035 { 3036 if (may_get_next_line(whitep, &p, cctx) == FAIL) 3037 goto failret; 3038 if (*p == ')') 3039 { 3040 *arg = p + 1; 3041 return OK; 3042 } 3043 if (must_end) 3044 { 3045 semsg(_(e_missing_comma_before_argument_str), p); 3046 return FAIL; 3047 } 3048 3049 if (compile_expr0(&p, cctx) == FAIL) 3050 return FAIL; 3051 ++*argcount; 3052 3053 if (*p != ',' && *skipwhite(p) == ',') 3054 { 3055 semsg(_(e_no_white_space_allowed_before_str_str), ",", p); 3056 p = skipwhite(p); 3057 } 3058 if (*p == ',') 3059 { 3060 ++p; 3061 if (*p != NUL && !VIM_ISWHITE(*p)) 3062 semsg(_(e_white_space_required_after_str_str), ",", p - 1); 3063 } 3064 else 3065 must_end = TRUE; 3066 whitep = p; 3067 p = skipwhite(p); 3068 } 3069 failret: 3070 emsg(_(e_missing_close)); 3071 return FAIL; 3072 } 3073 3074 /* 3075 * Compile a function call: name(arg1, arg2) 3076 * "arg" points to "name", "arg + varlen" to the "(". 3077 * "argcount_init" is 1 for "value->method()" 3078 * Instructions: 3079 * EVAL arg1 3080 * EVAL arg2 3081 * BCALL / DCALL / UCALL 3082 */ 3083 static int 3084 compile_call( 3085 char_u **arg, 3086 size_t varlen, 3087 cctx_T *cctx, 3088 ppconst_T *ppconst, 3089 int argcount_init) 3090 { 3091 char_u *name = *arg; 3092 char_u *p; 3093 int argcount = argcount_init; 3094 char_u namebuf[100]; 3095 char_u fname_buf[FLEN_FIXED + 1]; 3096 char_u *tofree = NULL; 3097 int error = FCERR_NONE; 3098 ufunc_T *ufunc = NULL; 3099 int res = FAIL; 3100 int is_autoload; 3101 3102 // we can evaluate "has('name')" at compile time 3103 if (varlen == 3 && STRNCMP(*arg, "has", 3) == 0) 3104 { 3105 char_u *s = skipwhite(*arg + varlen + 1); 3106 typval_T argvars[2]; 3107 3108 argvars[0].v_type = VAR_UNKNOWN; 3109 if (*s == '"') 3110 (void)eval_string(&s, &argvars[0], TRUE); 3111 else if (*s == '\'') 3112 (void)eval_lit_string(&s, &argvars[0], TRUE); 3113 s = skipwhite(s); 3114 if (*s == ')' && argvars[0].v_type == VAR_STRING 3115 && !dynamic_feature(argvars[0].vval.v_string)) 3116 { 3117 typval_T *tv = &ppconst->pp_tv[ppconst->pp_used]; 3118 3119 *arg = s + 1; 3120 argvars[1].v_type = VAR_UNKNOWN; 3121 tv->v_type = VAR_NUMBER; 3122 tv->vval.v_number = 0; 3123 f_has(argvars, tv); 3124 clear_tv(&argvars[0]); 3125 ++ppconst->pp_used; 3126 return OK; 3127 } 3128 clear_tv(&argvars[0]); 3129 } 3130 3131 if (generate_ppconst(cctx, ppconst) == FAIL) 3132 return FAIL; 3133 3134 if (varlen >= sizeof(namebuf)) 3135 { 3136 semsg(_(e_name_too_long_str), name); 3137 return FAIL; 3138 } 3139 vim_strncpy(namebuf, *arg, varlen); 3140 name = fname_trans_sid(namebuf, fname_buf, &tofree, &error); 3141 3142 *arg = skipwhite(*arg + varlen + 1); 3143 if (compile_arguments(arg, cctx, &argcount) == FAIL) 3144 goto theend; 3145 3146 is_autoload = vim_strchr(name, AUTOLOAD_CHAR) != NULL; 3147 if (ASCII_ISLOWER(*name) && name[1] != ':' && !is_autoload) 3148 { 3149 int idx; 3150 3151 // builtin function 3152 idx = find_internal_func(name); 3153 if (idx >= 0) 3154 { 3155 if (STRCMP(name, "flatten") == 0) 3156 { 3157 emsg(_(e_cannot_use_flatten_in_vim9_script)); 3158 goto theend; 3159 } 3160 3161 if (STRCMP(name, "add") == 0 && argcount == 2) 3162 { 3163 garray_T *stack = &cctx->ctx_type_stack; 3164 type_T *type = ((type_T **)stack->ga_data)[ 3165 stack->ga_len - 2]; 3166 3167 // add() can be compiled to instructions if we know the type 3168 if (type->tt_type == VAR_LIST) 3169 { 3170 // inline "add(list, item)" so that the type can be checked 3171 res = generate_LISTAPPEND(cctx); 3172 idx = -1; 3173 } 3174 else if (type->tt_type == VAR_BLOB) 3175 { 3176 // inline "add(blob, nr)" so that the type can be checked 3177 res = generate_BLOBAPPEND(cctx); 3178 idx = -1; 3179 } 3180 } 3181 3182 if (idx >= 0) 3183 res = generate_BCALL(cctx, idx, argcount, argcount_init == 1); 3184 } 3185 else 3186 semsg(_(e_unknownfunc), namebuf); 3187 goto theend; 3188 } 3189 3190 // An argument or local variable can be a function reference, this 3191 // overrules a function name. 3192 if (lookup_local(namebuf, varlen, NULL, cctx) == FAIL 3193 && arg_exists(namebuf, varlen, NULL, NULL, NULL, cctx) != OK) 3194 { 3195 // If we can find the function by name generate the right call. 3196 // Skip global functions here, a local funcref takes precedence. 3197 ufunc = find_func(name, FALSE, cctx); 3198 if (ufunc != NULL && !func_is_global(ufunc)) 3199 { 3200 res = generate_CALL(cctx, ufunc, argcount); 3201 goto theend; 3202 } 3203 } 3204 3205 // If the name is a variable, load it and use PCALL. 3206 // Not for g:Func(), we don't know if it is a variable or not. 3207 // Not for eome#Func(), it will be loaded later. 3208 p = namebuf; 3209 if (STRNCMP(namebuf, "g:", 2) != 0 && !is_autoload 3210 && compile_load(&p, namebuf + varlen, cctx, FALSE, FALSE) == OK) 3211 { 3212 garray_T *stack = &cctx->ctx_type_stack; 3213 type_T *type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 3214 3215 res = generate_PCALL(cctx, argcount, namebuf, type, FALSE); 3216 goto theend; 3217 } 3218 3219 // If we can find a global function by name generate the right call. 3220 if (ufunc != NULL) 3221 { 3222 res = generate_CALL(cctx, ufunc, argcount); 3223 goto theend; 3224 } 3225 3226 // A global function may be defined only later. Need to figure out at 3227 // runtime. Also handles a FuncRef at runtime. 3228 if (STRNCMP(namebuf, "g:", 2) == 0 || is_autoload) 3229 res = generate_UCALL(cctx, name, argcount); 3230 else 3231 semsg(_(e_unknownfunc), namebuf); 3232 3233 theend: 3234 vim_free(tofree); 3235 return res; 3236 } 3237 3238 // like NAMESPACE_CHAR but with 'a' and 'l'. 3239 #define VIM9_NAMESPACE_CHAR (char_u *)"bgstvw" 3240 3241 /* 3242 * Find the end of a variable or function name. Unlike find_name_end() this 3243 * does not recognize magic braces. 3244 * When "use_namespace" is TRUE recognize "b:", "s:", etc. 3245 * Return a pointer to just after the name. Equal to "arg" if there is no 3246 * valid name. 3247 */ 3248 char_u * 3249 to_name_end(char_u *arg, int use_namespace) 3250 { 3251 char_u *p; 3252 3253 // Quick check for valid starting character. 3254 if (!eval_isnamec1(*arg)) 3255 return arg; 3256 3257 for (p = arg + 1; *p != NUL && eval_isnamec(*p); MB_PTR_ADV(p)) 3258 // Include a namespace such as "s:var" and "v:var". But "n:" is not 3259 // and can be used in slice "[n:]". 3260 if (*p == ':' && (p != arg + 1 3261 || !use_namespace 3262 || vim_strchr(VIM9_NAMESPACE_CHAR, *arg) == NULL)) 3263 break; 3264 return p; 3265 } 3266 3267 /* 3268 * Like to_name_end() but also skip over a list or dict constant. 3269 * This intentionally does not handle line continuation. 3270 */ 3271 char_u * 3272 to_name_const_end(char_u *arg) 3273 { 3274 char_u *p = to_name_end(arg, TRUE); 3275 typval_T rettv; 3276 3277 if (p == arg && *arg == '[') 3278 { 3279 3280 // Can be "[1, 2, 3]->Func()". 3281 if (eval_list(&p, &rettv, NULL, FALSE) == FAIL) 3282 p = arg; 3283 } 3284 return p; 3285 } 3286 3287 /* 3288 * parse a list: [expr, expr] 3289 * "*arg" points to the '['. 3290 * ppconst->pp_is_const is set if all items are a constant. 3291 */ 3292 static int 3293 compile_list(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 3294 { 3295 char_u *p = skipwhite(*arg + 1); 3296 char_u *whitep = *arg + 1; 3297 int count = 0; 3298 int is_const; 3299 int is_all_const = TRUE; // reset when non-const encountered 3300 3301 for (;;) 3302 { 3303 if (may_get_next_line(whitep, &p, cctx) == FAIL) 3304 { 3305 semsg(_(e_list_end), *arg); 3306 return FAIL; 3307 } 3308 if (*p == ',') 3309 { 3310 semsg(_(e_no_white_space_allowed_before_str_str), ",", p); 3311 return FAIL; 3312 } 3313 if (*p == ']') 3314 { 3315 ++p; 3316 break; 3317 } 3318 if (compile_expr0_ext(&p, cctx, &is_const) == FAIL) 3319 return FAIL; 3320 if (!is_const) 3321 is_all_const = FALSE; 3322 ++count; 3323 if (*p == ',') 3324 { 3325 ++p; 3326 if (*p != ']' && !IS_WHITE_OR_NUL(*p)) 3327 { 3328 semsg(_(e_white_space_required_after_str_str), ",", p - 1); 3329 return FAIL; 3330 } 3331 } 3332 whitep = p; 3333 p = skipwhite(p); 3334 } 3335 *arg = p; 3336 3337 ppconst->pp_is_const = is_all_const; 3338 return generate_NEWLIST(cctx, count); 3339 } 3340 3341 /* 3342 * Parse a lambda: "(arg, arg) => expr" 3343 * "*arg" points to the '('. 3344 * Returns OK/FAIL when a lambda is recognized, NOTDONE if it's not a lambda. 3345 */ 3346 static int 3347 compile_lambda(char_u **arg, cctx_T *cctx) 3348 { 3349 int r; 3350 typval_T rettv; 3351 ufunc_T *ufunc; 3352 evalarg_T evalarg; 3353 3354 CLEAR_FIELD(evalarg); 3355 evalarg.eval_flags = EVAL_EVALUATE; 3356 evalarg.eval_cctx = cctx; 3357 3358 // Get the funcref in "rettv". 3359 r = get_lambda_tv(arg, &rettv, TRUE, &evalarg); 3360 if (r != OK) 3361 { 3362 clear_evalarg(&evalarg, NULL); 3363 return r; 3364 } 3365 3366 // "rettv" will now be a partial referencing the function. 3367 ufunc = rettv.vval.v_partial->pt_func; 3368 ++ufunc->uf_refcount; 3369 clear_tv(&rettv); 3370 3371 // Compile the function into instructions. 3372 compile_def_function(ufunc, TRUE, PROFILING(ufunc), cctx); 3373 3374 // evalarg.eval_tofree_cmdline may have a copy of the last line and "*arg" 3375 // points into it. Point to the original line to avoid a dangling pointer. 3376 if (evalarg.eval_tofree_cmdline != NULL) 3377 { 3378 size_t off = *arg - evalarg.eval_tofree_cmdline; 3379 3380 *arg = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum] 3381 + off; 3382 } 3383 3384 clear_evalarg(&evalarg, NULL); 3385 3386 if (ufunc->uf_def_status == UF_COMPILED) 3387 { 3388 // The return type will now be known. 3389 set_function_type(ufunc); 3390 3391 // The function reference count will be 1. When the ISN_FUNCREF 3392 // instruction is deleted the reference count is decremented and the 3393 // function is freed. 3394 return generate_FUNCREF(cctx, ufunc); 3395 } 3396 3397 func_ptr_unref(ufunc); 3398 return FAIL; 3399 } 3400 3401 /* 3402 * parse a dict: {key: val, [key]: val} 3403 * "*arg" points to the '{'. 3404 * ppconst->pp_is_const is set if all item values are a constant. 3405 */ 3406 static int 3407 compile_dict(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 3408 { 3409 garray_T *instr = &cctx->ctx_instr; 3410 int count = 0; 3411 dict_T *d = dict_alloc(); 3412 dictitem_T *item; 3413 char_u *whitep = *arg + 1; 3414 char_u *p; 3415 int is_const; 3416 int is_all_const = TRUE; // reset when non-const encountered 3417 3418 if (d == NULL) 3419 return FAIL; 3420 if (generate_ppconst(cctx, ppconst) == FAIL) 3421 return FAIL; 3422 for (;;) 3423 { 3424 char_u *key = NULL; 3425 3426 if (may_get_next_line(whitep, arg, cctx) == FAIL) 3427 { 3428 *arg = NULL; 3429 goto failret; 3430 } 3431 3432 if (**arg == '}') 3433 break; 3434 3435 if (**arg == '[') 3436 { 3437 isn_T *isn; 3438 3439 // {[expr]: value} uses an evaluated key. 3440 *arg = skipwhite(*arg + 1); 3441 if (compile_expr0(arg, cctx) == FAIL) 3442 return FAIL; 3443 isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1; 3444 if (isn->isn_type == ISN_PUSHNR) 3445 { 3446 char buf[NUMBUFLEN]; 3447 3448 // Convert to string at compile time. 3449 vim_snprintf(buf, NUMBUFLEN, "%lld", isn->isn_arg.number); 3450 isn->isn_type = ISN_PUSHS; 3451 isn->isn_arg.string = vim_strsave((char_u *)buf); 3452 } 3453 if (isn->isn_type == ISN_PUSHS) 3454 key = isn->isn_arg.string; 3455 else if (may_generate_2STRING(-1, cctx) == FAIL) 3456 return FAIL; 3457 *arg = skipwhite(*arg); 3458 if (**arg != ']') 3459 { 3460 emsg(_(e_missing_matching_bracket_after_dict_key)); 3461 return FAIL; 3462 } 3463 ++*arg; 3464 } 3465 else 3466 { 3467 // {"name": value}, 3468 // {'name': value}, 3469 // {name: value} use "name" as a literal key 3470 key = get_literal_key(arg); 3471 if (key == NULL) 3472 return FAIL; 3473 if (generate_PUSHS(cctx, key) == FAIL) 3474 return FAIL; 3475 } 3476 3477 // Check for duplicate keys, if using string keys. 3478 if (key != NULL) 3479 { 3480 item = dict_find(d, key, -1); 3481 if (item != NULL) 3482 { 3483 semsg(_(e_duplicate_key), key); 3484 goto failret; 3485 } 3486 item = dictitem_alloc(key); 3487 if (item != NULL) 3488 { 3489 item->di_tv.v_type = VAR_UNKNOWN; 3490 item->di_tv.v_lock = 0; 3491 if (dict_add(d, item) == FAIL) 3492 dictitem_free(item); 3493 } 3494 } 3495 3496 if (**arg != ':') 3497 { 3498 if (*skipwhite(*arg) == ':') 3499 semsg(_(e_no_white_space_allowed_before_str_str), ":", *arg); 3500 else 3501 semsg(_(e_missing_dict_colon), *arg); 3502 return FAIL; 3503 } 3504 whitep = *arg + 1; 3505 if (!IS_WHITE_OR_NUL(*whitep)) 3506 { 3507 semsg(_(e_white_space_required_after_str_str), ":", *arg); 3508 return FAIL; 3509 } 3510 3511 if (may_get_next_line(whitep, arg, cctx) == FAIL) 3512 { 3513 *arg = NULL; 3514 goto failret; 3515 } 3516 3517 if (compile_expr0_ext(arg, cctx, &is_const) == FAIL) 3518 return FAIL; 3519 if (!is_const) 3520 is_all_const = FALSE; 3521 ++count; 3522 3523 whitep = *arg; 3524 if (may_get_next_line(whitep, arg, cctx) == FAIL) 3525 { 3526 *arg = NULL; 3527 goto failret; 3528 } 3529 if (**arg == '}') 3530 break; 3531 if (**arg != ',') 3532 { 3533 semsg(_(e_missing_dict_comma), *arg); 3534 goto failret; 3535 } 3536 if (IS_WHITE_OR_NUL(*whitep)) 3537 { 3538 semsg(_(e_no_white_space_allowed_before_str_str), ",", whitep); 3539 return FAIL; 3540 } 3541 whitep = *arg + 1; 3542 if (!IS_WHITE_OR_NUL(*whitep)) 3543 { 3544 semsg(_(e_white_space_required_after_str_str), ",", *arg); 3545 return FAIL; 3546 } 3547 *arg = skipwhite(whitep); 3548 } 3549 3550 *arg = *arg + 1; 3551 3552 // Allow for following comment, after at least one space. 3553 p = skipwhite(*arg); 3554 if (VIM_ISWHITE(**arg) && vim9_comment_start(p)) 3555 *arg += STRLEN(*arg); 3556 3557 dict_unref(d); 3558 ppconst->pp_is_const = is_all_const; 3559 return generate_NEWDICT(cctx, count); 3560 3561 failret: 3562 if (*arg == NULL) 3563 { 3564 semsg(_(e_missing_dict_end), _("[end of lines]")); 3565 *arg = (char_u *)""; 3566 } 3567 dict_unref(d); 3568 return FAIL; 3569 } 3570 3571 /* 3572 * Compile "&option". 3573 */ 3574 static int 3575 compile_get_option(char_u **arg, cctx_T *cctx) 3576 { 3577 typval_T rettv; 3578 char_u *start = *arg; 3579 int ret; 3580 3581 // parse the option and get the current value to get the type. 3582 rettv.v_type = VAR_UNKNOWN; 3583 ret = eval_option(arg, &rettv, TRUE); 3584 if (ret == OK) 3585 { 3586 // include the '&' in the name, eval_option() expects it. 3587 char_u *name = vim_strnsave(start, *arg - start); 3588 type_T *type = rettv.v_type == VAR_BOOL ? &t_bool 3589 : rettv.v_type == VAR_NUMBER ? &t_number : &t_string; 3590 3591 ret = generate_LOAD(cctx, ISN_LOADOPT, 0, name, type); 3592 vim_free(name); 3593 } 3594 clear_tv(&rettv); 3595 3596 return ret; 3597 } 3598 3599 /* 3600 * Compile "$VAR". 3601 */ 3602 static int 3603 compile_get_env(char_u **arg, cctx_T *cctx) 3604 { 3605 char_u *start = *arg; 3606 int len; 3607 int ret; 3608 char_u *name; 3609 3610 ++*arg; 3611 len = get_env_len(arg); 3612 if (len == 0) 3613 { 3614 semsg(_(e_syntax_error_at_str), start - 1); 3615 return FAIL; 3616 } 3617 3618 // include the '$' in the name, eval_env_var() expects it. 3619 name = vim_strnsave(start, len + 1); 3620 ret = generate_LOAD(cctx, ISN_LOADENV, 0, name, &t_string); 3621 vim_free(name); 3622 return ret; 3623 } 3624 3625 /* 3626 * Compile "@r". 3627 */ 3628 static int 3629 compile_get_register(char_u **arg, cctx_T *cctx) 3630 { 3631 int ret; 3632 3633 ++*arg; 3634 if (**arg == NUL) 3635 { 3636 semsg(_(e_syntax_error_at_str), *arg - 1); 3637 return FAIL; 3638 } 3639 if (!valid_yank_reg(**arg, FALSE)) 3640 { 3641 emsg_invreg(**arg); 3642 return FAIL; 3643 } 3644 ret = generate_LOAD(cctx, ISN_LOADREG, **arg, NULL, &t_string); 3645 ++*arg; 3646 return ret; 3647 } 3648 3649 /* 3650 * Apply leading '!', '-' and '+' to constant "rettv". 3651 * When "numeric_only" is TRUE do not apply '!'. 3652 */ 3653 static int 3654 apply_leader(typval_T *rettv, int numeric_only, char_u *start, char_u **end) 3655 { 3656 char_u *p = *end; 3657 3658 // this works from end to start 3659 while (p > start) 3660 { 3661 --p; 3662 if (*p == '-' || *p == '+') 3663 { 3664 // only '-' has an effect, for '+' we only check the type 3665 #ifdef FEAT_FLOAT 3666 if (rettv->v_type == VAR_FLOAT) 3667 { 3668 if (*p == '-') 3669 rettv->vval.v_float = -rettv->vval.v_float; 3670 } 3671 else 3672 #endif 3673 { 3674 varnumber_T val; 3675 int error = FALSE; 3676 3677 // tv_get_number_chk() accepts a string, but we don't want that 3678 // here 3679 if (check_not_string(rettv) == FAIL) 3680 return FAIL; 3681 val = tv_get_number_chk(rettv, &error); 3682 clear_tv(rettv); 3683 if (error) 3684 return FAIL; 3685 if (*p == '-') 3686 val = -val; 3687 rettv->v_type = VAR_NUMBER; 3688 rettv->vval.v_number = val; 3689 } 3690 } 3691 else if (numeric_only) 3692 { 3693 ++p; 3694 break; 3695 } 3696 else if (*p == '!') 3697 { 3698 int v = tv2bool(rettv); 3699 3700 // '!' is permissive in the type. 3701 clear_tv(rettv); 3702 rettv->v_type = VAR_BOOL; 3703 rettv->vval.v_number = v ? VVAL_FALSE : VVAL_TRUE; 3704 } 3705 } 3706 *end = p; 3707 return OK; 3708 } 3709 3710 /* 3711 * Recognize v: variables that are constants and set "rettv". 3712 */ 3713 static void 3714 get_vim_constant(char_u **arg, typval_T *rettv) 3715 { 3716 if (STRNCMP(*arg, "v:true", 6) == 0) 3717 { 3718 rettv->v_type = VAR_BOOL; 3719 rettv->vval.v_number = VVAL_TRUE; 3720 *arg += 6; 3721 } 3722 else if (STRNCMP(*arg, "v:false", 7) == 0) 3723 { 3724 rettv->v_type = VAR_BOOL; 3725 rettv->vval.v_number = VVAL_FALSE; 3726 *arg += 7; 3727 } 3728 else if (STRNCMP(*arg, "v:null", 6) == 0) 3729 { 3730 rettv->v_type = VAR_SPECIAL; 3731 rettv->vval.v_number = VVAL_NULL; 3732 *arg += 6; 3733 } 3734 else if (STRNCMP(*arg, "v:none", 6) == 0) 3735 { 3736 rettv->v_type = VAR_SPECIAL; 3737 rettv->vval.v_number = VVAL_NONE; 3738 *arg += 6; 3739 } 3740 } 3741 3742 exprtype_T 3743 get_compare_type(char_u *p, int *len, int *type_is) 3744 { 3745 exprtype_T type = EXPR_UNKNOWN; 3746 int i; 3747 3748 switch (p[0]) 3749 { 3750 case '=': if (p[1] == '=') 3751 type = EXPR_EQUAL; 3752 else if (p[1] == '~') 3753 type = EXPR_MATCH; 3754 break; 3755 case '!': if (p[1] == '=') 3756 type = EXPR_NEQUAL; 3757 else if (p[1] == '~') 3758 type = EXPR_NOMATCH; 3759 break; 3760 case '>': if (p[1] != '=') 3761 { 3762 type = EXPR_GREATER; 3763 *len = 1; 3764 } 3765 else 3766 type = EXPR_GEQUAL; 3767 break; 3768 case '<': if (p[1] != '=') 3769 { 3770 type = EXPR_SMALLER; 3771 *len = 1; 3772 } 3773 else 3774 type = EXPR_SEQUAL; 3775 break; 3776 case 'i': if (p[1] == 's') 3777 { 3778 // "is" and "isnot"; but not a prefix of a name 3779 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't') 3780 *len = 5; 3781 i = p[*len]; 3782 if (!isalnum(i) && i != '_') 3783 { 3784 type = *len == 2 ? EXPR_IS : EXPR_ISNOT; 3785 *type_is = TRUE; 3786 } 3787 } 3788 break; 3789 } 3790 return type; 3791 } 3792 3793 /* 3794 * Skip over an expression, ignoring most errors. 3795 */ 3796 static void 3797 skip_expr_cctx(char_u **arg, cctx_T *cctx) 3798 { 3799 evalarg_T evalarg; 3800 3801 CLEAR_FIELD(evalarg); 3802 evalarg.eval_cctx = cctx; 3803 skip_expr(arg, &evalarg); 3804 } 3805 3806 /* 3807 * Compile code to apply '-', '+' and '!'. 3808 * When "numeric_only" is TRUE do not apply '!'. 3809 */ 3810 static int 3811 compile_leader(cctx_T *cctx, int numeric_only, char_u *start, char_u **end) 3812 { 3813 char_u *p = *end; 3814 3815 // this works from end to start 3816 while (p > start) 3817 { 3818 --p; 3819 while (VIM_ISWHITE(*p)) 3820 --p; 3821 if (*p == '-' || *p == '+') 3822 { 3823 int negate = *p == '-'; 3824 isn_T *isn; 3825 3826 // TODO: check type 3827 while (p > start && (p[-1] == '-' || p[-1] == '+')) 3828 { 3829 --p; 3830 if (*p == '-') 3831 negate = !negate; 3832 } 3833 // only '-' has an effect, for '+' we only check the type 3834 if (negate) 3835 isn = generate_instr(cctx, ISN_NEGATENR); 3836 else 3837 isn = generate_instr(cctx, ISN_CHECKNR); 3838 if (isn == NULL) 3839 return FAIL; 3840 } 3841 else if (numeric_only) 3842 { 3843 ++p; 3844 break; 3845 } 3846 else 3847 { 3848 int invert = *p == '!'; 3849 3850 while (p > start && (p[-1] == '!' || VIM_ISWHITE(p[-1]))) 3851 { 3852 if (p[-1] == '!') 3853 invert = !invert; 3854 --p; 3855 } 3856 if (generate_2BOOL(cctx, invert) == FAIL) 3857 return FAIL; 3858 } 3859 } 3860 *end = p; 3861 return OK; 3862 } 3863 3864 /* 3865 * Compile "(expression)": recursive! 3866 * Return FAIL/OK. 3867 */ 3868 static int 3869 compile_parenthesis(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 3870 { 3871 int ret; 3872 char_u *p = *arg + 1; 3873 3874 if (may_get_next_line_error(p, arg, cctx) == FAIL) 3875 return FAIL; 3876 if (ppconst->pp_used <= PPSIZE - 10) 3877 { 3878 ret = compile_expr1(arg, cctx, ppconst); 3879 } 3880 else 3881 { 3882 // Not enough space in ppconst, flush constants. 3883 if (generate_ppconst(cctx, ppconst) == FAIL) 3884 return FAIL; 3885 ret = compile_expr0(arg, cctx); 3886 } 3887 if (may_get_next_line_error(*arg, arg, cctx) == FAIL) 3888 return FAIL; 3889 if (**arg == ')') 3890 ++*arg; 3891 else if (ret == OK) 3892 { 3893 emsg(_(e_missing_close)); 3894 ret = FAIL; 3895 } 3896 return ret; 3897 } 3898 3899 /* 3900 * Compile whatever comes after "name" or "name()". 3901 * Advances "*arg" only when something was recognized. 3902 */ 3903 static int 3904 compile_subscript( 3905 char_u **arg, 3906 cctx_T *cctx, 3907 char_u *start_leader, 3908 char_u **end_leader, 3909 ppconst_T *ppconst) 3910 { 3911 char_u *name_start = *end_leader; 3912 3913 for (;;) 3914 { 3915 char_u *p = skipwhite(*arg); 3916 3917 if (*p == NUL || (VIM_ISWHITE(**arg) && vim9_comment_start(p))) 3918 { 3919 char_u *next = peek_next_line_from_context(cctx); 3920 3921 // If a following line starts with "->{" or "->X" advance to that 3922 // line, so that a line break before "->" is allowed. 3923 // Also if a following line starts with ".x". 3924 if (next != NULL && 3925 ((next[0] == '-' && next[1] == '>' 3926 && (next[2] == '{' || ASCII_ISALPHA(next[2]))) 3927 || (next[0] == '.' && eval_isdictc(next[1])))) 3928 { 3929 next = next_line_from_context(cctx, TRUE); 3930 if (next == NULL) 3931 return FAIL; 3932 *arg = next; 3933 p = skipwhite(*arg); 3934 } 3935 } 3936 3937 // Do not skip over white space to find the "(", "execute 'x' ()" is 3938 // not a function call. 3939 if (**arg == '(') 3940 { 3941 garray_T *stack = &cctx->ctx_type_stack; 3942 type_T *type; 3943 int argcount = 0; 3944 3945 if (generate_ppconst(cctx, ppconst) == FAIL) 3946 return FAIL; 3947 ppconst->pp_is_const = FALSE; 3948 3949 // funcref(arg) 3950 type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 3951 3952 *arg = skipwhite(p + 1); 3953 if (compile_arguments(arg, cctx, &argcount) == FAIL) 3954 return FAIL; 3955 if (generate_PCALL(cctx, argcount, name_start, type, TRUE) == FAIL) 3956 return FAIL; 3957 } 3958 else if (*p == '-' && p[1] == '>') 3959 { 3960 char_u *pstart = p; 3961 3962 if (generate_ppconst(cctx, ppconst) == FAIL) 3963 return FAIL; 3964 ppconst->pp_is_const = FALSE; 3965 3966 // something->method() 3967 // Apply the '!', '-' and '+' first: 3968 // -1.0->func() works like (-1.0)->func() 3969 if (compile_leader(cctx, TRUE, start_leader, end_leader) == FAIL) 3970 return FAIL; 3971 3972 p += 2; 3973 *arg = skipwhite(p); 3974 // No line break supported right after "->". 3975 if (**arg == '(') 3976 { 3977 int argcount = 1; 3978 garray_T *stack = &cctx->ctx_type_stack; 3979 int type_idx_start = stack->ga_len; 3980 type_T *type; 3981 int expr_isn_start = cctx->ctx_instr.ga_len; 3982 int expr_isn_end; 3983 int arg_isn_count; 3984 3985 // Funcref call: list->(Refs[2])(arg) 3986 // or lambda: list->((arg) => expr)(arg) 3987 // 3988 // Fist compile the function expression. 3989 if (compile_parenthesis(arg, cctx, ppconst) == FAIL) 3990 return FAIL; 3991 3992 // Remember the next instruction index, where the instructions 3993 // for arguments are being written. 3994 expr_isn_end = cctx->ctx_instr.ga_len; 3995 3996 // Compile the arguments. 3997 if (**arg != '(') 3998 { 3999 if (*skipwhite(*arg) == '(') 4000 emsg(_(e_nowhitespace)); 4001 else 4002 semsg(_(e_missing_paren), *arg); 4003 return FAIL; 4004 } 4005 *arg = skipwhite(*arg + 1); 4006 if (compile_arguments(arg, cctx, &argcount) == FAIL) 4007 return FAIL; 4008 4009 // Move the instructions for the arguments to before the 4010 // instructions of the expression and move the type of the 4011 // expression after the argument types. This is what ISN_PCALL 4012 // expects. 4013 stack = &cctx->ctx_type_stack; 4014 arg_isn_count = cctx->ctx_instr.ga_len - expr_isn_end; 4015 if (arg_isn_count > 0) 4016 { 4017 int expr_isn_count = expr_isn_end - expr_isn_start; 4018 isn_T *isn = ALLOC_MULT(isn_T, expr_isn_count); 4019 4020 if (isn == NULL) 4021 return FAIL; 4022 mch_memmove(isn, ((isn_T *)cctx->ctx_instr.ga_data) 4023 + expr_isn_start, 4024 sizeof(isn_T) * expr_isn_count); 4025 mch_memmove(((isn_T *)cctx->ctx_instr.ga_data) 4026 + expr_isn_start, 4027 ((isn_T *)cctx->ctx_instr.ga_data) + expr_isn_end, 4028 sizeof(isn_T) * arg_isn_count); 4029 mch_memmove(((isn_T *)cctx->ctx_instr.ga_data) 4030 + expr_isn_start + arg_isn_count, 4031 isn, sizeof(isn_T) * expr_isn_count); 4032 vim_free(isn); 4033 4034 type = ((type_T **)stack->ga_data)[type_idx_start]; 4035 mch_memmove(((type_T **)stack->ga_data) + type_idx_start, 4036 ((type_T **)stack->ga_data) + type_idx_start + 1, 4037 sizeof(type_T *) 4038 * (stack->ga_len - type_idx_start - 1)); 4039 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type; 4040 } 4041 4042 type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 4043 if (generate_PCALL(cctx, argcount, 4044 (char_u *)"[expression]", type, FALSE) == FAIL) 4045 return FAIL; 4046 } 4047 else 4048 { 4049 // method call: list->method() 4050 p = *arg; 4051 if (!eval_isnamec1(*p)) 4052 { 4053 semsg(_(e_trailing_arg), pstart); 4054 return FAIL; 4055 } 4056 if (ASCII_ISALPHA(*p) && p[1] == ':') 4057 p += 2; 4058 for ( ; eval_isnamec(*p); ++p) 4059 ; 4060 if (*p != '(') 4061 { 4062 semsg(_(e_missing_paren), *arg); 4063 return FAIL; 4064 } 4065 // TODO: base value may not be the first argument 4066 if (compile_call(arg, p - *arg, cctx, ppconst, 1) == FAIL) 4067 return FAIL; 4068 } 4069 } 4070 else if (**arg == '[') 4071 { 4072 int is_slice = FALSE; 4073 4074 // list index: list[123] 4075 // dict member: dict[key] 4076 // string index: text[123] 4077 // TODO: blob index 4078 // TODO: more arguments 4079 // TODO: recognize list or dict at runtime 4080 if (generate_ppconst(cctx, ppconst) == FAIL) 4081 return FAIL; 4082 ppconst->pp_is_const = FALSE; 4083 4084 ++p; 4085 if (may_get_next_line_error(p, arg, cctx) == FAIL) 4086 return FAIL; 4087 if (**arg == ':') 4088 { 4089 // missing first index is equal to zero 4090 generate_PUSHNR(cctx, 0); 4091 } 4092 else 4093 { 4094 if (compile_expr0(arg, cctx) == FAIL) 4095 return FAIL; 4096 if (**arg == ':') 4097 { 4098 semsg(_(e_white_space_required_before_and_after_str_at_str), 4099 ":", *arg); 4100 return FAIL; 4101 } 4102 if (may_get_next_line_error(*arg, arg, cctx) == FAIL) 4103 return FAIL; 4104 *arg = skipwhite(*arg); 4105 } 4106 if (**arg == ':') 4107 { 4108 is_slice = TRUE; 4109 ++*arg; 4110 if (!IS_WHITE_OR_NUL(**arg) && **arg != ']') 4111 { 4112 semsg(_(e_white_space_required_before_and_after_str_at_str), 4113 ":", *arg); 4114 return FAIL; 4115 } 4116 if (may_get_next_line_error(*arg, arg, cctx) == FAIL) 4117 return FAIL; 4118 if (**arg == ']') 4119 // missing second index is equal to end of string 4120 generate_PUSHNR(cctx, -1); 4121 else 4122 { 4123 if (compile_expr0(arg, cctx) == FAIL) 4124 return FAIL; 4125 if (may_get_next_line_error(*arg, arg, cctx) == FAIL) 4126 return FAIL; 4127 *arg = skipwhite(*arg); 4128 } 4129 } 4130 4131 if (**arg != ']') 4132 { 4133 emsg(_(e_missbrac)); 4134 return FAIL; 4135 } 4136 *arg = *arg + 1; 4137 4138 if (compile_member(is_slice, cctx) == FAIL) 4139 return FAIL; 4140 } 4141 else if (*p == '.' && p[1] != '.') 4142 { 4143 // dictionary member: dict.name 4144 if (generate_ppconst(cctx, ppconst) == FAIL) 4145 return FAIL; 4146 ppconst->pp_is_const = FALSE; 4147 4148 *arg = p + 1; 4149 if (IS_WHITE_OR_NUL(**arg)) 4150 { 4151 emsg(_(e_missing_name_after_dot)); 4152 return FAIL; 4153 } 4154 p = *arg; 4155 if (eval_isdictc(*p)) 4156 while (eval_isnamec(*p)) 4157 MB_PTR_ADV(p); 4158 if (p == *arg) 4159 { 4160 semsg(_(e_syntax_error_at_str), *arg); 4161 return FAIL; 4162 } 4163 if (generate_STRINGMEMBER(cctx, *arg, p - *arg) == FAIL) 4164 return FAIL; 4165 *arg = p; 4166 } 4167 else 4168 break; 4169 } 4170 4171 // TODO - see handle_subscript(): 4172 // Turn "dict.Func" into a partial for "Func" bound to "dict". 4173 // Don't do this when "Func" is already a partial that was bound 4174 // explicitly (pt_auto is FALSE). 4175 4176 return OK; 4177 } 4178 4179 /* 4180 * Compile an expression at "*arg" and add instructions to "cctx->ctx_instr". 4181 * "arg" is advanced until after the expression, skipping white space. 4182 * 4183 * If the value is a constant "ppconst->pp_used" will be non-zero. 4184 * Before instructions are generated, any values in "ppconst" will generated. 4185 * 4186 * This is the compiling equivalent of eval1(), eval2(), etc. 4187 */ 4188 4189 /* 4190 * number number constant 4191 * 0zFFFFFFFF Blob constant 4192 * "string" string constant 4193 * 'string' literal string constant 4194 * &option-name option value 4195 * @r register contents 4196 * identifier variable value 4197 * function() function call 4198 * $VAR environment variable 4199 * (expression) nested expression 4200 * [expr, expr] List 4201 * {key: val, [key]: val} Dictionary 4202 * 4203 * Also handle: 4204 * ! in front logical NOT 4205 * - in front unary minus 4206 * + in front unary plus (ignored) 4207 * trailing (arg) funcref/partial call 4208 * trailing [] subscript in String or List 4209 * trailing .name entry in Dictionary 4210 * trailing ->name() method call 4211 */ 4212 static int 4213 compile_expr7( 4214 char_u **arg, 4215 cctx_T *cctx, 4216 ppconst_T *ppconst) 4217 { 4218 char_u *start_leader, *end_leader; 4219 int ret = OK; 4220 typval_T *rettv = &ppconst->pp_tv[ppconst->pp_used]; 4221 int used_before = ppconst->pp_used; 4222 4223 ppconst->pp_is_const = FALSE; 4224 4225 /* 4226 * Skip '!', '-' and '+' characters. They are handled later. 4227 */ 4228 start_leader = *arg; 4229 if (eval_leader(arg, TRUE) == FAIL) 4230 return FAIL; 4231 end_leader = *arg; 4232 4233 rettv->v_type = VAR_UNKNOWN; 4234 switch (**arg) 4235 { 4236 /* 4237 * Number constant. 4238 */ 4239 case '0': // also for blob starting with 0z 4240 case '1': 4241 case '2': 4242 case '3': 4243 case '4': 4244 case '5': 4245 case '6': 4246 case '7': 4247 case '8': 4248 case '9': 4249 case '.': if (eval_number(arg, rettv, TRUE, FALSE) == FAIL) 4250 return FAIL; 4251 // Apply "-" and "+" just before the number now, right to 4252 // left. Matters especially when "->" follows. Stops at 4253 // '!'. 4254 if (apply_leader(rettv, TRUE, 4255 start_leader, &end_leader) == FAIL) 4256 { 4257 clear_tv(rettv); 4258 return FAIL; 4259 } 4260 break; 4261 4262 /* 4263 * String constant: "string". 4264 */ 4265 case '"': if (eval_string(arg, rettv, TRUE) == FAIL) 4266 return FAIL; 4267 break; 4268 4269 /* 4270 * Literal string constant: 'str''ing'. 4271 */ 4272 case '\'': if (eval_lit_string(arg, rettv, TRUE) == FAIL) 4273 return FAIL; 4274 break; 4275 4276 /* 4277 * Constant Vim variable. 4278 */ 4279 case 'v': get_vim_constant(arg, rettv); 4280 ret = NOTDONE; 4281 break; 4282 4283 /* 4284 * "true" constant 4285 */ 4286 case 't': if (STRNCMP(*arg, "true", 4) == 0 4287 && !eval_isnamec((*arg)[4])) 4288 { 4289 *arg += 4; 4290 rettv->v_type = VAR_BOOL; 4291 rettv->vval.v_number = VVAL_TRUE; 4292 } 4293 else 4294 ret = NOTDONE; 4295 break; 4296 4297 /* 4298 * "false" constant 4299 */ 4300 case 'f': if (STRNCMP(*arg, "false", 5) == 0 4301 && !eval_isnamec((*arg)[5])) 4302 { 4303 *arg += 5; 4304 rettv->v_type = VAR_BOOL; 4305 rettv->vval.v_number = VVAL_FALSE; 4306 } 4307 else 4308 ret = NOTDONE; 4309 break; 4310 4311 /* 4312 * "null" constant 4313 */ 4314 case 'n': if (STRNCMP(*arg, "null", 4) == 0 4315 && !eval_isnamec((*arg)[4])) 4316 { 4317 *arg += 4; 4318 rettv->v_type = VAR_SPECIAL; 4319 rettv->vval.v_number = VVAL_NULL; 4320 } 4321 else 4322 ret = NOTDONE; 4323 break; 4324 4325 /* 4326 * List: [expr, expr] 4327 */ 4328 case '[': if (generate_ppconst(cctx, ppconst) == FAIL) 4329 return FAIL; 4330 ret = compile_list(arg, cctx, ppconst); 4331 break; 4332 4333 /* 4334 * Dictionary: {'key': val, 'key': val} 4335 */ 4336 case '{': if (generate_ppconst(cctx, ppconst) == FAIL) 4337 return FAIL; 4338 ret = compile_dict(arg, cctx, ppconst); 4339 break; 4340 4341 /* 4342 * Option value: &name 4343 */ 4344 case '&': if (generate_ppconst(cctx, ppconst) == FAIL) 4345 return FAIL; 4346 ret = compile_get_option(arg, cctx); 4347 break; 4348 4349 /* 4350 * Environment variable: $VAR. 4351 */ 4352 case '$': if (generate_ppconst(cctx, ppconst) == FAIL) 4353 return FAIL; 4354 ret = compile_get_env(arg, cctx); 4355 break; 4356 4357 /* 4358 * Register contents: @r. 4359 */ 4360 case '@': if (generate_ppconst(cctx, ppconst) == FAIL) 4361 return FAIL; 4362 ret = compile_get_register(arg, cctx); 4363 break; 4364 /* 4365 * nested expression: (expression). 4366 * lambda: (arg, arg) => expr 4367 * funcref: (arg, arg) => { statement } 4368 */ 4369 case '(': // if compile_lambda returns NOTDONE then it must be (expr) 4370 ret = compile_lambda(arg, cctx); 4371 if (ret == NOTDONE) 4372 ret = compile_parenthesis(arg, cctx, ppconst); 4373 break; 4374 4375 default: ret = NOTDONE; 4376 break; 4377 } 4378 if (ret == FAIL) 4379 return FAIL; 4380 4381 if (rettv->v_type != VAR_UNKNOWN && used_before == ppconst->pp_used) 4382 { 4383 if (cctx->ctx_skip == SKIP_YES) 4384 clear_tv(rettv); 4385 else 4386 // A constant expression can possibly be handled compile time, 4387 // return the value instead of generating code. 4388 ++ppconst->pp_used; 4389 } 4390 else if (ret == NOTDONE) 4391 { 4392 char_u *p; 4393 int r; 4394 4395 if (!eval_isnamec1(**arg)) 4396 { 4397 if (!vim9_bad_comment(*arg)) 4398 { 4399 if (ends_excmd(*skipwhite(*arg))) 4400 semsg(_(e_empty_expression_str), *arg); 4401 else 4402 semsg(_(e_name_expected_str), *arg); 4403 } 4404 return FAIL; 4405 } 4406 4407 // "name" or "name()" 4408 p = to_name_end(*arg, TRUE); 4409 if (*p == '(') 4410 { 4411 r = compile_call(arg, p - *arg, cctx, ppconst, 0); 4412 } 4413 else 4414 { 4415 if (generate_ppconst(cctx, ppconst) == FAIL) 4416 return FAIL; 4417 r = compile_load(arg, p, cctx, TRUE, TRUE); 4418 } 4419 if (r == FAIL) 4420 return FAIL; 4421 } 4422 4423 // Handle following "[]", ".member", etc. 4424 // Then deal with prefixed '-', '+' and '!', if not done already. 4425 if (compile_subscript(arg, cctx, start_leader, &end_leader, 4426 ppconst) == FAIL) 4427 return FAIL; 4428 if (ppconst->pp_used > 0) 4429 { 4430 // apply the '!', '-' and '+' before the constant 4431 rettv = &ppconst->pp_tv[ppconst->pp_used - 1]; 4432 if (apply_leader(rettv, FALSE, start_leader, &end_leader) == FAIL) 4433 return FAIL; 4434 return OK; 4435 } 4436 if (compile_leader(cctx, FALSE, start_leader, &end_leader) == FAIL) 4437 return FAIL; 4438 return OK; 4439 } 4440 4441 /* 4442 * Give the "white on both sides" error, taking the operator from "p[len]". 4443 */ 4444 void 4445 error_white_both(char_u *op, int len) 4446 { 4447 char_u buf[10]; 4448 4449 vim_strncpy(buf, op, len); 4450 semsg(_(e_white_space_required_before_and_after_str_at_str), buf, op); 4451 } 4452 4453 /* 4454 * <type>expr7: runtime type check / conversion 4455 */ 4456 static int 4457 compile_expr7t(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4458 { 4459 type_T *want_type = NULL; 4460 4461 // Recognize <type> 4462 if (**arg == '<' && eval_isnamec1((*arg)[1])) 4463 { 4464 ++*arg; 4465 want_type = parse_type(arg, cctx->ctx_type_list, TRUE); 4466 if (want_type == NULL) 4467 return FAIL; 4468 4469 if (**arg != '>') 4470 { 4471 if (*skipwhite(*arg) == '>') 4472 semsg(_(e_no_white_space_allowed_before_str_str), ">", *arg); 4473 else 4474 emsg(_(e_missing_gt)); 4475 return FAIL; 4476 } 4477 ++*arg; 4478 if (may_get_next_line_error(*arg, arg, cctx) == FAIL) 4479 return FAIL; 4480 } 4481 4482 if (compile_expr7(arg, cctx, ppconst) == FAIL) 4483 return FAIL; 4484 4485 if (want_type != NULL) 4486 { 4487 garray_T *stack = &cctx->ctx_type_stack; 4488 type_T *actual; 4489 where_T where; 4490 4491 generate_ppconst(cctx, ppconst); 4492 actual = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 4493 where.wt_index = 0; 4494 where.wt_variable = FALSE; 4495 if (check_type(want_type, actual, FALSE, where) == FAIL) 4496 { 4497 if (need_type(actual, want_type, -1, 0, cctx, FALSE, FALSE) == FAIL) 4498 return FAIL; 4499 } 4500 } 4501 4502 return OK; 4503 } 4504 4505 /* 4506 * * number multiplication 4507 * / number division 4508 * % number modulo 4509 */ 4510 static int 4511 compile_expr6(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4512 { 4513 char_u *op; 4514 char_u *next; 4515 int ppconst_used = ppconst->pp_used; 4516 4517 // get the first expression 4518 if (compile_expr7t(arg, cctx, ppconst) == FAIL) 4519 return FAIL; 4520 4521 /* 4522 * Repeat computing, until no "*", "/" or "%" is following. 4523 */ 4524 for (;;) 4525 { 4526 op = may_peek_next_line(cctx, *arg, &next); 4527 if (*op != '*' && *op != '/' && *op != '%') 4528 break; 4529 if (next != NULL) 4530 { 4531 *arg = next_line_from_context(cctx, TRUE); 4532 op = skipwhite(*arg); 4533 } 4534 4535 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[1])) 4536 { 4537 error_white_both(op, 1); 4538 return FAIL; 4539 } 4540 if (may_get_next_line_error(op + 1, arg, cctx) == FAIL) 4541 return FAIL; 4542 4543 // get the second expression 4544 if (compile_expr7t(arg, cctx, ppconst) == FAIL) 4545 return FAIL; 4546 4547 if (ppconst->pp_used == ppconst_used + 2 4548 && ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER 4549 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER) 4550 { 4551 typval_T *tv1 = &ppconst->pp_tv[ppconst_used]; 4552 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1]; 4553 varnumber_T res = 0; 4554 int failed = FALSE; 4555 4556 // both are numbers: compute the result 4557 switch (*op) 4558 { 4559 case '*': res = tv1->vval.v_number * tv2->vval.v_number; 4560 break; 4561 case '/': res = num_divide(tv1->vval.v_number, 4562 tv2->vval.v_number, &failed); 4563 break; 4564 case '%': res = num_modulus(tv1->vval.v_number, 4565 tv2->vval.v_number, &failed); 4566 break; 4567 } 4568 if (failed) 4569 return FAIL; 4570 tv1->vval.v_number = res; 4571 --ppconst->pp_used; 4572 } 4573 else 4574 { 4575 generate_ppconst(cctx, ppconst); 4576 generate_two_op(cctx, op); 4577 } 4578 } 4579 4580 return OK; 4581 } 4582 4583 /* 4584 * + number addition or list/blobl concatenation 4585 * - number subtraction 4586 * .. string concatenation 4587 */ 4588 static int 4589 compile_expr5(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4590 { 4591 char_u *op; 4592 char_u *next; 4593 int oplen; 4594 int ppconst_used = ppconst->pp_used; 4595 4596 // get the first variable 4597 if (compile_expr6(arg, cctx, ppconst) == FAIL) 4598 return FAIL; 4599 4600 /* 4601 * Repeat computing, until no "+", "-" or ".." is following. 4602 */ 4603 for (;;) 4604 { 4605 op = may_peek_next_line(cctx, *arg, &next); 4606 if (*op != '+' && *op != '-' && !(*op == '.' && *(op + 1) == '.')) 4607 break; 4608 oplen = (*op == '.' ? 2 : 1); 4609 if (next != NULL) 4610 { 4611 *arg = next_line_from_context(cctx, TRUE); 4612 op = skipwhite(*arg); 4613 } 4614 4615 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[oplen])) 4616 { 4617 error_white_both(op, oplen); 4618 return FAIL; 4619 } 4620 4621 if (may_get_next_line_error(op + oplen, arg, cctx) == FAIL) 4622 return FAIL; 4623 4624 // get the second expression 4625 if (compile_expr6(arg, cctx, ppconst) == FAIL) 4626 return FAIL; 4627 4628 if (ppconst->pp_used == ppconst_used + 2 4629 && (*op == '.' 4630 ? (ppconst->pp_tv[ppconst_used].v_type == VAR_STRING 4631 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_STRING) 4632 : (ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER 4633 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER))) 4634 { 4635 typval_T *tv1 = &ppconst->pp_tv[ppconst_used]; 4636 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1]; 4637 4638 // concat/subtract/add constant numbers 4639 if (*op == '+') 4640 tv1->vval.v_number = tv1->vval.v_number + tv2->vval.v_number; 4641 else if (*op == '-') 4642 tv1->vval.v_number = tv1->vval.v_number - tv2->vval.v_number; 4643 else 4644 { 4645 // concatenate constant strings 4646 char_u *s1 = tv1->vval.v_string; 4647 char_u *s2 = tv2->vval.v_string; 4648 size_t len1 = STRLEN(s1); 4649 4650 tv1->vval.v_string = alloc((int)(len1 + STRLEN(s2) + 1)); 4651 if (tv1->vval.v_string == NULL) 4652 { 4653 clear_ppconst(ppconst); 4654 return FAIL; 4655 } 4656 mch_memmove(tv1->vval.v_string, s1, len1); 4657 STRCPY(tv1->vval.v_string + len1, s2); 4658 vim_free(s1); 4659 vim_free(s2); 4660 } 4661 --ppconst->pp_used; 4662 } 4663 else 4664 { 4665 generate_ppconst(cctx, ppconst); 4666 ppconst->pp_is_const = FALSE; 4667 if (*op == '.') 4668 { 4669 if (may_generate_2STRING(-2, cctx) == FAIL 4670 || may_generate_2STRING(-1, cctx) == FAIL) 4671 return FAIL; 4672 generate_instr_drop(cctx, ISN_CONCAT, 1); 4673 } 4674 else 4675 generate_two_op(cctx, op); 4676 } 4677 } 4678 4679 return OK; 4680 } 4681 4682 /* 4683 * expr5a == expr5b 4684 * expr5a =~ expr5b 4685 * expr5a != expr5b 4686 * expr5a !~ expr5b 4687 * expr5a > expr5b 4688 * expr5a >= expr5b 4689 * expr5a < expr5b 4690 * expr5a <= expr5b 4691 * expr5a is expr5b 4692 * expr5a isnot expr5b 4693 * 4694 * Produces instructions: 4695 * EVAL expr5a Push result of "expr5a" 4696 * EVAL expr5b Push result of "expr5b" 4697 * COMPARE one of the compare instructions 4698 */ 4699 static int 4700 compile_expr4(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4701 { 4702 exprtype_T type = EXPR_UNKNOWN; 4703 char_u *p; 4704 char_u *next; 4705 int len = 2; 4706 int type_is = FALSE; 4707 int ppconst_used = ppconst->pp_used; 4708 4709 // get the first variable 4710 if (compile_expr5(arg, cctx, ppconst) == FAIL) 4711 return FAIL; 4712 4713 p = may_peek_next_line(cctx, *arg, &next); 4714 type = get_compare_type(p, &len, &type_is); 4715 4716 /* 4717 * If there is a comparative operator, use it. 4718 */ 4719 if (type != EXPR_UNKNOWN) 4720 { 4721 int ic = FALSE; // Default: do not ignore case 4722 4723 if (next != NULL) 4724 { 4725 *arg = next_line_from_context(cctx, TRUE); 4726 p = skipwhite(*arg); 4727 } 4728 if (type_is && (p[len] == '?' || p[len] == '#')) 4729 { 4730 semsg(_(e_invexpr2), *arg); 4731 return FAIL; 4732 } 4733 // extra question mark appended: ignore case 4734 if (p[len] == '?') 4735 { 4736 ic = TRUE; 4737 ++len; 4738 } 4739 // extra '#' appended: match case (ignored) 4740 else if (p[len] == '#') 4741 ++len; 4742 // nothing appended: match case 4743 4744 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[len])) 4745 { 4746 error_white_both(p, len); 4747 return FAIL; 4748 } 4749 4750 // get the second variable 4751 if (may_get_next_line_error(p + len, arg, cctx) == FAIL) 4752 return FAIL; 4753 4754 if (compile_expr5(arg, cctx, ppconst) == FAIL) 4755 return FAIL; 4756 4757 if (ppconst->pp_used == ppconst_used + 2) 4758 { 4759 typval_T * tv1 = &ppconst->pp_tv[ppconst->pp_used - 2]; 4760 typval_T *tv2 = &ppconst->pp_tv[ppconst->pp_used - 1]; 4761 int ret; 4762 4763 // Both sides are a constant, compute the result now. 4764 // First check for a valid combination of types, this is more 4765 // strict than typval_compare(). 4766 if (check_compare_types(type, tv1, tv2) == FAIL) 4767 ret = FAIL; 4768 else 4769 { 4770 ret = typval_compare(tv1, tv2, type, ic); 4771 tv1->v_type = VAR_BOOL; 4772 tv1->vval.v_number = tv1->vval.v_number 4773 ? VVAL_TRUE : VVAL_FALSE; 4774 clear_tv(tv2); 4775 --ppconst->pp_used; 4776 } 4777 return ret; 4778 } 4779 4780 generate_ppconst(cctx, ppconst); 4781 return generate_COMPARE(cctx, type, ic); 4782 } 4783 4784 return OK; 4785 } 4786 4787 static int compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst); 4788 4789 /* 4790 * Compile || or &&. 4791 */ 4792 static int 4793 compile_and_or( 4794 char_u **arg, 4795 cctx_T *cctx, 4796 char *op, 4797 ppconst_T *ppconst, 4798 int ppconst_used UNUSED) 4799 { 4800 char_u *next; 4801 char_u *p = may_peek_next_line(cctx, *arg, &next); 4802 int opchar = *op; 4803 4804 if (p[0] == opchar && p[1] == opchar) 4805 { 4806 garray_T *instr = &cctx->ctx_instr; 4807 garray_T end_ga; 4808 4809 /* 4810 * Repeat until there is no following "||" or "&&" 4811 */ 4812 ga_init2(&end_ga, sizeof(int), 10); 4813 while (p[0] == opchar && p[1] == opchar) 4814 { 4815 long start_lnum = SOURCING_LNUM; 4816 int start_ctx_lnum = cctx->ctx_lnum; 4817 int save_lnum; 4818 4819 if (next != NULL) 4820 { 4821 *arg = next_line_from_context(cctx, TRUE); 4822 p = skipwhite(*arg); 4823 } 4824 4825 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[2])) 4826 { 4827 semsg(_(e_white_space_required_before_and_after_str_at_str), 4828 op, p); 4829 return FAIL; 4830 } 4831 4832 // TODO: use ppconst if the value is a constant and check 4833 // evaluating to bool 4834 generate_ppconst(cctx, ppconst); 4835 4836 // Every part must evaluate to a bool. 4837 SOURCING_LNUM = start_lnum; 4838 save_lnum = cctx->ctx_lnum; 4839 cctx->ctx_lnum = start_ctx_lnum; 4840 if (bool_on_stack(cctx) == FAIL) 4841 { 4842 cctx->ctx_lnum = save_lnum; 4843 ga_clear(&end_ga); 4844 return FAIL; 4845 } 4846 cctx->ctx_lnum = save_lnum; 4847 4848 if (ga_grow(&end_ga, 1) == FAIL) 4849 { 4850 ga_clear(&end_ga); 4851 return FAIL; 4852 } 4853 *(((int *)end_ga.ga_data) + end_ga.ga_len) = instr->ga_len; 4854 ++end_ga.ga_len; 4855 generate_JUMP(cctx, opchar == '|' 4856 ? JUMP_IF_COND_TRUE : JUMP_IF_COND_FALSE, 0); 4857 4858 // eval the next expression 4859 if (may_get_next_line_error(p + 2, arg, cctx) == FAIL) 4860 { 4861 ga_clear(&end_ga); 4862 return FAIL; 4863 } 4864 4865 if ((opchar == '|' ? compile_expr3(arg, cctx, ppconst) 4866 : compile_expr4(arg, cctx, ppconst)) == FAIL) 4867 { 4868 ga_clear(&end_ga); 4869 return FAIL; 4870 } 4871 4872 p = may_peek_next_line(cctx, *arg, &next); 4873 } 4874 generate_ppconst(cctx, ppconst); 4875 4876 // Every part must evaluate to a bool. 4877 if (bool_on_stack(cctx) == FAIL) 4878 { 4879 ga_clear(&end_ga); 4880 return FAIL; 4881 } 4882 4883 // Fill in the end label in all jumps. 4884 while (end_ga.ga_len > 0) 4885 { 4886 isn_T *isn; 4887 4888 --end_ga.ga_len; 4889 isn = ((isn_T *)instr->ga_data) 4890 + *(((int *)end_ga.ga_data) + end_ga.ga_len); 4891 isn->isn_arg.jump.jump_where = instr->ga_len; 4892 } 4893 ga_clear(&end_ga); 4894 } 4895 4896 return OK; 4897 } 4898 4899 /* 4900 * expr4a && expr4a && expr4a logical AND 4901 * 4902 * Produces instructions: 4903 * EVAL expr4a Push result of "expr4a" 4904 * COND2BOOL convert to bool if needed 4905 * JUMP_IF_COND_FALSE end 4906 * EVAL expr4b Push result of "expr4b" 4907 * JUMP_IF_COND_FALSE end 4908 * EVAL expr4c Push result of "expr4c" 4909 * end: 4910 */ 4911 static int 4912 compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4913 { 4914 int ppconst_used = ppconst->pp_used; 4915 4916 // get the first variable 4917 if (compile_expr4(arg, cctx, ppconst) == FAIL) 4918 return FAIL; 4919 4920 // || and && work almost the same 4921 return compile_and_or(arg, cctx, "&&", ppconst, ppconst_used); 4922 } 4923 4924 /* 4925 * expr3a || expr3b || expr3c logical OR 4926 * 4927 * Produces instructions: 4928 * EVAL expr3a Push result of "expr3a" 4929 * COND2BOOL convert to bool if needed 4930 * JUMP_IF_COND_TRUE end 4931 * EVAL expr3b Push result of "expr3b" 4932 * JUMP_IF_COND_TRUE end 4933 * EVAL expr3c Push result of "expr3c" 4934 * end: 4935 */ 4936 static int 4937 compile_expr2(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4938 { 4939 int ppconst_used = ppconst->pp_used; 4940 4941 // eval the first expression 4942 if (compile_expr3(arg, cctx, ppconst) == FAIL) 4943 return FAIL; 4944 4945 // || and && work almost the same 4946 return compile_and_or(arg, cctx, "||", ppconst, ppconst_used); 4947 } 4948 4949 /* 4950 * Toplevel expression: expr2 ? expr1a : expr1b 4951 * Produces instructions: 4952 * EVAL expr2 Push result of "expr2" 4953 * JUMP_IF_FALSE alt jump if false 4954 * EVAL expr1a 4955 * JUMP_ALWAYS end 4956 * alt: EVAL expr1b 4957 * end: 4958 * 4959 * Toplevel expression: expr2 ?? expr1 4960 * Produces instructions: 4961 * EVAL expr2 Push result of "expr2" 4962 * JUMP_AND_KEEP_IF_TRUE end jump if true 4963 * EVAL expr1 4964 * end: 4965 */ 4966 static int 4967 compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4968 { 4969 char_u *p; 4970 int ppconst_used = ppconst->pp_used; 4971 char_u *next; 4972 4973 // Ignore all kinds of errors when not producing code. 4974 if (cctx->ctx_skip == SKIP_YES) 4975 { 4976 skip_expr_cctx(arg, cctx); 4977 return OK; 4978 } 4979 4980 // Evaluate the first expression. 4981 if (compile_expr2(arg, cctx, ppconst) == FAIL) 4982 return FAIL; 4983 4984 p = may_peek_next_line(cctx, *arg, &next); 4985 if (*p == '?') 4986 { 4987 int op_falsy = p[1] == '?'; 4988 garray_T *instr = &cctx->ctx_instr; 4989 garray_T *stack = &cctx->ctx_type_stack; 4990 int alt_idx = instr->ga_len; 4991 int end_idx = 0; 4992 isn_T *isn; 4993 type_T *type1 = NULL; 4994 int has_const_expr = FALSE; 4995 int const_value = FALSE; 4996 int save_skip = cctx->ctx_skip; 4997 4998 if (next != NULL) 4999 { 5000 *arg = next_line_from_context(cctx, TRUE); 5001 p = skipwhite(*arg); 5002 } 5003 5004 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1 + op_falsy])) 5005 { 5006 semsg(_(e_white_space_required_before_and_after_str_at_str), 5007 op_falsy ? "??" : "?", *arg); 5008 return FAIL; 5009 } 5010 5011 if (ppconst->pp_used == ppconst_used + 1) 5012 { 5013 // the condition is a constant, we know whether the ? or the : 5014 // expression is to be evaluated. 5015 has_const_expr = TRUE; 5016 if (op_falsy) 5017 const_value = tv2bool(&ppconst->pp_tv[ppconst_used]); 5018 else 5019 { 5020 int error = FALSE; 5021 5022 const_value = tv_get_bool_chk(&ppconst->pp_tv[ppconst_used], 5023 &error); 5024 if (error) 5025 return FAIL; 5026 } 5027 cctx->ctx_skip = save_skip == SKIP_YES || 5028 (op_falsy ? const_value : !const_value) ? SKIP_YES : SKIP_NOT; 5029 5030 if (op_falsy && cctx->ctx_skip == SKIP_YES) 5031 // "left ?? right" and "left" is truthy: produce "left" 5032 generate_ppconst(cctx, ppconst); 5033 else 5034 { 5035 clear_tv(&ppconst->pp_tv[ppconst_used]); 5036 --ppconst->pp_used; 5037 } 5038 } 5039 else 5040 { 5041 generate_ppconst(cctx, ppconst); 5042 if (op_falsy) 5043 end_idx = instr->ga_len; 5044 generate_JUMP(cctx, op_falsy 5045 ? JUMP_AND_KEEP_IF_TRUE : JUMP_IF_FALSE, 0); 5046 if (op_falsy) 5047 type1 = ((type_T **)stack->ga_data)[stack->ga_len]; 5048 } 5049 5050 // evaluate the second expression; any type is accepted 5051 if (may_get_next_line_error(p + 1 + op_falsy, arg, cctx) == FAIL) 5052 return FAIL; 5053 if (compile_expr1(arg, cctx, ppconst) == FAIL) 5054 return FAIL; 5055 5056 if (!has_const_expr) 5057 { 5058 generate_ppconst(cctx, ppconst); 5059 5060 if (!op_falsy) 5061 { 5062 // remember the type and drop it 5063 --stack->ga_len; 5064 type1 = ((type_T **)stack->ga_data)[stack->ga_len]; 5065 5066 end_idx = instr->ga_len; 5067 generate_JUMP(cctx, JUMP_ALWAYS, 0); 5068 5069 // jump here from JUMP_IF_FALSE 5070 isn = ((isn_T *)instr->ga_data) + alt_idx; 5071 isn->isn_arg.jump.jump_where = instr->ga_len; 5072 } 5073 } 5074 5075 if (!op_falsy) 5076 { 5077 // Check for the ":". 5078 p = may_peek_next_line(cctx, *arg, &next); 5079 if (*p != ':') 5080 { 5081 emsg(_(e_missing_colon)); 5082 return FAIL; 5083 } 5084 if (next != NULL) 5085 { 5086 *arg = next_line_from_context(cctx, TRUE); 5087 p = skipwhite(*arg); 5088 } 5089 5090 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1])) 5091 { 5092 semsg(_(e_white_space_required_before_and_after_str_at_str), 5093 ":", p); 5094 return FAIL; 5095 } 5096 5097 // evaluate the third expression 5098 if (has_const_expr) 5099 cctx->ctx_skip = save_skip == SKIP_YES || const_value 5100 ? SKIP_YES : SKIP_NOT; 5101 if (may_get_next_line_error(p + 1, arg, cctx) == FAIL) 5102 return FAIL; 5103 if (compile_expr1(arg, cctx, ppconst) == FAIL) 5104 return FAIL; 5105 } 5106 5107 if (!has_const_expr) 5108 { 5109 type_T **typep; 5110 5111 generate_ppconst(cctx, ppconst); 5112 5113 // If the types differ, the result has a more generic type. 5114 typep = ((type_T **)stack->ga_data) + stack->ga_len - 1; 5115 common_type(type1, *typep, typep, cctx->ctx_type_list); 5116 5117 // jump here from JUMP_ALWAYS or JUMP_AND_KEEP_IF_TRUE 5118 isn = ((isn_T *)instr->ga_data) + end_idx; 5119 isn->isn_arg.jump.jump_where = instr->ga_len; 5120 } 5121 5122 cctx->ctx_skip = save_skip; 5123 } 5124 return OK; 5125 } 5126 5127 /* 5128 * Toplevel expression. 5129 * Sets "is_const" (if not NULL) to indicate the value is a constant. 5130 * Returns OK or FAIL. 5131 */ 5132 static int 5133 compile_expr0_ext(char_u **arg, cctx_T *cctx, int *is_const) 5134 { 5135 ppconst_T ppconst; 5136 5137 CLEAR_FIELD(ppconst); 5138 if (compile_expr1(arg, cctx, &ppconst) == FAIL) 5139 { 5140 clear_ppconst(&ppconst); 5141 return FAIL; 5142 } 5143 if (is_const != NULL) 5144 *is_const = ppconst.pp_used > 0 || ppconst.pp_is_const; 5145 if (generate_ppconst(cctx, &ppconst) == FAIL) 5146 return FAIL; 5147 return OK; 5148 } 5149 5150 /* 5151 * Toplevel expression. 5152 */ 5153 static int 5154 compile_expr0(char_u **arg, cctx_T *cctx) 5155 { 5156 return compile_expr0_ext(arg, cctx, NULL); 5157 } 5158 5159 /* 5160 * compile "return [expr]" 5161 */ 5162 static char_u * 5163 compile_return(char_u *arg, int check_return_type, cctx_T *cctx) 5164 { 5165 char_u *p = arg; 5166 garray_T *stack = &cctx->ctx_type_stack; 5167 type_T *stack_type; 5168 5169 if (*p != NUL && *p != '|' && *p != '\n') 5170 { 5171 // compile return argument into instructions 5172 if (compile_expr0(&p, cctx) == FAIL) 5173 return NULL; 5174 5175 if (cctx->ctx_skip != SKIP_YES) 5176 { 5177 stack_type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 5178 if (check_return_type && (cctx->ctx_ufunc->uf_ret_type == NULL 5179 || cctx->ctx_ufunc->uf_ret_type == &t_unknown 5180 || cctx->ctx_ufunc->uf_ret_type == &t_any)) 5181 { 5182 cctx->ctx_ufunc->uf_ret_type = stack_type; 5183 } 5184 else 5185 { 5186 if (cctx->ctx_ufunc->uf_ret_type->tt_type == VAR_VOID 5187 && stack_type->tt_type != VAR_VOID 5188 && stack_type->tt_type != VAR_UNKNOWN) 5189 { 5190 emsg(_(e_returning_value_in_function_without_return_type)); 5191 return NULL; 5192 } 5193 if (need_type(stack_type, cctx->ctx_ufunc->uf_ret_type, -1, 5194 0, cctx, FALSE, FALSE) == FAIL) 5195 return NULL; 5196 } 5197 } 5198 } 5199 else 5200 { 5201 // "check_return_type" cannot be TRUE, only used for a lambda which 5202 // always has an argument. 5203 if (cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_VOID 5204 && cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_UNKNOWN) 5205 { 5206 emsg(_(e_missing_return_value)); 5207 return NULL; 5208 } 5209 5210 // No argument, return zero. 5211 generate_PUSHNR(cctx, 0); 5212 } 5213 5214 // Undo any command modifiers. 5215 generate_undo_cmdmods(cctx); 5216 5217 if (cctx->ctx_skip != SKIP_YES && generate_instr(cctx, ISN_RETURN) == NULL) 5218 return NULL; 5219 5220 // "return val | endif" is possible 5221 return skipwhite(p); 5222 } 5223 5224 /* 5225 * Get a line from the compilation context, compatible with exarg_T getline(). 5226 * Return a pointer to the line in allocated memory. 5227 * Return NULL for end-of-file or some error. 5228 */ 5229 static char_u * 5230 exarg_getline( 5231 int c UNUSED, 5232 void *cookie, 5233 int indent UNUSED, 5234 getline_opt_T options UNUSED) 5235 { 5236 cctx_T *cctx = (cctx_T *)cookie; 5237 char_u *p; 5238 5239 for (;;) 5240 { 5241 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len - 1) 5242 return NULL; 5243 ++cctx->ctx_lnum; 5244 p = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum]; 5245 // Comment lines result in NULL pointers, skip them. 5246 if (p != NULL) 5247 return vim_strsave(p); 5248 } 5249 } 5250 5251 void 5252 fill_exarg_from_cctx(exarg_T *eap, cctx_T *cctx) 5253 { 5254 eap->getline = exarg_getline; 5255 eap->cookie = cctx; 5256 } 5257 5258 /* 5259 * Compile a nested :def command. 5260 */ 5261 static char_u * 5262 compile_nested_function(exarg_T *eap, cctx_T *cctx) 5263 { 5264 int is_global = *eap->arg == 'g' && eap->arg[1] == ':'; 5265 char_u *name_start = eap->arg; 5266 char_u *name_end = to_name_end(eap->arg, TRUE); 5267 char_u *lambda_name; 5268 ufunc_T *ufunc; 5269 int r = FAIL; 5270 5271 if (eap->forceit) 5272 { 5273 emsg(_(e_cannot_use_bang_with_nested_def)); 5274 return NULL; 5275 } 5276 5277 if (*name_start == '/') 5278 { 5279 name_end = skip_regexp(name_start + 1, '/', TRUE); 5280 if (*name_end == '/') 5281 ++name_end; 5282 eap->nextcmd = check_nextcmd(name_end); 5283 } 5284 if (name_end == name_start || *skipwhite(name_end) != '(') 5285 { 5286 if (!ends_excmd2(name_start, name_end)) 5287 { 5288 semsg(_(e_invalid_command_str), eap->cmd); 5289 return NULL; 5290 } 5291 5292 // "def" or "def Name": list functions 5293 if (generate_DEF(cctx, name_start, name_end - name_start) == FAIL) 5294 return NULL; 5295 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd; 5296 } 5297 5298 // Only g:Func() can use a namespace. 5299 if (name_start[1] == ':' && !is_global) 5300 { 5301 semsg(_(e_namespace_not_supported_str), name_start); 5302 return NULL; 5303 } 5304 if (check_defined(name_start, name_end - name_start, cctx, FALSE) == FAIL) 5305 return NULL; 5306 5307 eap->arg = name_end; 5308 fill_exarg_from_cctx(eap, cctx); 5309 5310 eap->forceit = FALSE; 5311 lambda_name = vim_strsave(get_lambda_name()); 5312 if (lambda_name == NULL) 5313 return NULL; 5314 ufunc = define_function(eap, lambda_name); 5315 5316 if (ufunc == NULL) 5317 { 5318 r = eap->skip ? OK : FAIL; 5319 goto theend; 5320 } 5321 5322 // copy over the block scope IDs before compiling 5323 if (!is_global && cctx->ctx_ufunc->uf_block_depth > 0) 5324 { 5325 int block_depth = cctx->ctx_ufunc->uf_block_depth; 5326 5327 ufunc->uf_block_ids = ALLOC_MULT(int, block_depth); 5328 if (ufunc->uf_block_ids != NULL) 5329 { 5330 mch_memmove(ufunc->uf_block_ids, cctx->ctx_ufunc->uf_block_ids, 5331 sizeof(int) * block_depth); 5332 ufunc->uf_block_depth = block_depth; 5333 } 5334 } 5335 5336 if (func_needs_compiling(ufunc, PROFILING(ufunc)) 5337 && compile_def_function(ufunc, TRUE, PROFILING(ufunc), cctx) 5338 == FAIL) 5339 { 5340 func_ptr_unref(ufunc); 5341 goto theend; 5342 } 5343 5344 if (is_global) 5345 { 5346 char_u *func_name = vim_strnsave(name_start + 2, 5347 name_end - name_start - 2); 5348 5349 if (func_name == NULL) 5350 r = FAIL; 5351 else 5352 { 5353 r = generate_NEWFUNC(cctx, lambda_name, func_name); 5354 lambda_name = NULL; 5355 } 5356 } 5357 else 5358 { 5359 // Define a local variable for the function reference. 5360 lvar_T *lvar = reserve_local(cctx, name_start, name_end - name_start, 5361 TRUE, ufunc->uf_func_type); 5362 5363 if (lvar == NULL) 5364 goto theend; 5365 if (generate_FUNCREF(cctx, ufunc) == FAIL) 5366 goto theend; 5367 r = generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL); 5368 } 5369 // TODO: warning for trailing text? 5370 5371 theend: 5372 vim_free(lambda_name); 5373 return r == FAIL ? NULL : (char_u *)""; 5374 } 5375 5376 /* 5377 * Return the length of an assignment operator, or zero if there isn't one. 5378 */ 5379 int 5380 assignment_len(char_u *p, int *heredoc) 5381 { 5382 if (*p == '=') 5383 { 5384 if (p[1] == '<' && p[2] == '<') 5385 { 5386 *heredoc = TRUE; 5387 return 3; 5388 } 5389 return 1; 5390 } 5391 if (vim_strchr((char_u *)"+-*/%", *p) != NULL && p[1] == '=') 5392 return 2; 5393 if (STRNCMP(p, "..=", 3) == 0) 5394 return 3; 5395 return 0; 5396 } 5397 5398 // words that cannot be used as a variable 5399 static char *reserved[] = { 5400 "true", 5401 "false", 5402 "null", 5403 NULL 5404 }; 5405 5406 // Destination for an assignment or ":unlet" with an index. 5407 typedef enum { 5408 dest_local, 5409 dest_option, 5410 dest_env, 5411 dest_global, 5412 dest_buffer, 5413 dest_window, 5414 dest_tab, 5415 dest_vimvar, 5416 dest_script, 5417 dest_reg, 5418 dest_expr, 5419 } assign_dest_T; 5420 5421 // Used by compile_lhs() to store information about the LHS of an assignment 5422 // and one argument of ":unlet" with an index. 5423 typedef struct { 5424 assign_dest_T lhs_dest; // type of destination 5425 5426 char_u *lhs_name; // allocated name including 5427 // "[expr]" or ".name". 5428 size_t lhs_varlen; // length of the variable without 5429 // "[expr]" or ".name" 5430 char_u *lhs_dest_end; // end of the destination, including 5431 // "[expr]" or ".name". 5432 5433 int lhs_has_index; // has "[expr]" or ".name" 5434 5435 int lhs_new_local; // create new local variable 5436 int lhs_opt_flags; // for when destination is an option 5437 int lhs_vimvaridx; // for when destination is a v:var 5438 5439 lvar_T lhs_local_lvar; // used for existing local destination 5440 lvar_T lhs_arg_lvar; // used for argument destination 5441 lvar_T *lhs_lvar; // points to destination lvar 5442 int lhs_scriptvar_sid; 5443 int lhs_scriptvar_idx; 5444 5445 int lhs_has_type; // type was specified 5446 type_T *lhs_type; 5447 type_T *lhs_member_type; 5448 } lhs_T; 5449 5450 /* 5451 * Generate the load instruction for "name". 5452 */ 5453 static void 5454 generate_loadvar( 5455 cctx_T *cctx, 5456 assign_dest_T dest, 5457 char_u *name, 5458 lvar_T *lvar, 5459 type_T *type) 5460 { 5461 switch (dest) 5462 { 5463 case dest_option: 5464 // TODO: check the option exists 5465 generate_LOAD(cctx, ISN_LOADOPT, 0, name, type); 5466 break; 5467 case dest_global: 5468 if (vim_strchr(name, AUTOLOAD_CHAR) == NULL) 5469 generate_LOAD(cctx, ISN_LOADG, 0, name + 2, type); 5470 else 5471 generate_LOAD(cctx, ISN_LOADAUTO, 0, name, type); 5472 break; 5473 case dest_buffer: 5474 generate_LOAD(cctx, ISN_LOADB, 0, name + 2, type); 5475 break; 5476 case dest_window: 5477 generate_LOAD(cctx, ISN_LOADW, 0, name + 2, type); 5478 break; 5479 case dest_tab: 5480 generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type); 5481 break; 5482 case dest_script: 5483 compile_load_scriptvar(cctx, 5484 name + (name[1] == ':' ? 2 : 0), NULL, NULL, TRUE); 5485 break; 5486 case dest_env: 5487 // Include $ in the name here 5488 generate_LOAD(cctx, ISN_LOADENV, 0, name, type); 5489 break; 5490 case dest_reg: 5491 generate_LOAD(cctx, ISN_LOADREG, name[1], NULL, &t_string); 5492 break; 5493 case dest_vimvar: 5494 generate_LOADV(cctx, name + 2, TRUE); 5495 break; 5496 case dest_local: 5497 if (lvar->lv_from_outer > 0) 5498 generate_LOADOUTER(cctx, lvar->lv_idx, lvar->lv_from_outer, 5499 type); 5500 else 5501 generate_LOAD(cctx, ISN_LOAD, lvar->lv_idx, NULL, type); 5502 break; 5503 case dest_expr: 5504 // list or dict value should already be on the stack. 5505 break; 5506 } 5507 } 5508 5509 /* 5510 * Skip over "[expr]" or ".member". 5511 * Does not check for any errors. 5512 */ 5513 static char_u * 5514 skip_index(char_u *start) 5515 { 5516 char_u *p = start; 5517 5518 if (*p == '[') 5519 { 5520 p = skipwhite(p + 1); 5521 (void)skip_expr(&p, NULL); 5522 p = skipwhite(p); 5523 if (*p == ']') 5524 return p + 1; 5525 return p; 5526 } 5527 // if (*p == '.') 5528 return to_name_end(p + 1, TRUE); 5529 } 5530 5531 void 5532 vim9_declare_error(char_u *name) 5533 { 5534 char *scope = ""; 5535 5536 switch (*name) 5537 { 5538 case 'g': scope = _("global"); break; 5539 case 'b': scope = _("buffer"); break; 5540 case 'w': scope = _("window"); break; 5541 case 't': scope = _("tab"); break; 5542 case 'v': scope = "v:"; break; 5543 case '$': semsg(_(e_cannot_declare_an_environment_variable), name); 5544 return; 5545 case '&': semsg(_(e_cannot_declare_an_option), name); 5546 return; 5547 case '@': semsg(_(e_cannot_declare_a_register_str), name); 5548 return; 5549 default: return; 5550 } 5551 semsg(_(e_cannot_declare_a_scope_variable), scope, name); 5552 } 5553 5554 /* 5555 * For one assignment figure out the type of destination. Return it in "dest". 5556 * When not recognized "dest" is not set. 5557 * For an option "opt_flags" is set. 5558 * For a v:var "vimvaridx" is set. 5559 * "type" is set to the destination type if known, unchanted otherwise. 5560 * Return FAIL if an error message was given. 5561 */ 5562 static int 5563 get_var_dest( 5564 char_u *name, 5565 assign_dest_T *dest, 5566 int cmdidx, 5567 int *opt_flags, 5568 int *vimvaridx, 5569 type_T **type, 5570 cctx_T *cctx) 5571 { 5572 char_u *p; 5573 5574 if (*name == '&') 5575 { 5576 int cc; 5577 long numval; 5578 getoption_T opt_type; 5579 5580 *dest = dest_option; 5581 if (cmdidx == CMD_final || cmdidx == CMD_const) 5582 { 5583 emsg(_(e_const_option)); 5584 return FAIL; 5585 } 5586 p = name; 5587 p = find_option_end(&p, opt_flags); 5588 if (p == NULL) 5589 { 5590 // cannot happen? 5591 emsg(_(e_letunexp)); 5592 return FAIL; 5593 } 5594 cc = *p; 5595 *p = NUL; 5596 opt_type = get_option_value(skip_option_env_lead(name), 5597 &numval, NULL, *opt_flags); 5598 *p = cc; 5599 switch (opt_type) 5600 { 5601 case gov_unknown: 5602 semsg(_(e_unknown_option), name); 5603 return FAIL; 5604 case gov_string: 5605 case gov_hidden_string: 5606 *type = &t_string; 5607 break; 5608 case gov_bool: 5609 case gov_hidden_bool: 5610 *type = &t_bool; 5611 break; 5612 case gov_number: 5613 case gov_hidden_number: 5614 *type = &t_number; 5615 break; 5616 } 5617 } 5618 else if (*name == '$') 5619 { 5620 *dest = dest_env; 5621 *type = &t_string; 5622 } 5623 else if (*name == '@') 5624 { 5625 if (!valid_yank_reg(name[1], FALSE) || name[1] == '.') 5626 { 5627 emsg_invreg(name[1]); 5628 return FAIL; 5629 } 5630 *dest = dest_reg; 5631 *type = &t_string; 5632 } 5633 else if (STRNCMP(name, "g:", 2) == 0) 5634 { 5635 *dest = dest_global; 5636 } 5637 else if (STRNCMP(name, "b:", 2) == 0) 5638 { 5639 *dest = dest_buffer; 5640 } 5641 else if (STRNCMP(name, "w:", 2) == 0) 5642 { 5643 *dest = dest_window; 5644 } 5645 else if (STRNCMP(name, "t:", 2) == 0) 5646 { 5647 *dest = dest_tab; 5648 } 5649 else if (STRNCMP(name, "v:", 2) == 0) 5650 { 5651 typval_T *vtv; 5652 int di_flags; 5653 5654 *vimvaridx = find_vim_var(name + 2, &di_flags); 5655 if (*vimvaridx < 0) 5656 { 5657 semsg(_(e_variable_not_found_str), name); 5658 return FAIL; 5659 } 5660 // We use the current value of "sandbox" here, is that OK? 5661 if (var_check_ro(di_flags, name, FALSE)) 5662 return FAIL; 5663 *dest = dest_vimvar; 5664 vtv = get_vim_var_tv(*vimvaridx); 5665 *type = typval2type_vimvar(vtv, cctx->ctx_type_list); 5666 } 5667 return OK; 5668 } 5669 5670 /* 5671 * Generate a STORE instruction for "dest", not being "dest_local". 5672 * Return FAIL when out of memory. 5673 */ 5674 static int 5675 generate_store_var( 5676 cctx_T *cctx, 5677 assign_dest_T dest, 5678 int opt_flags, 5679 int vimvaridx, 5680 int scriptvar_idx, 5681 int scriptvar_sid, 5682 type_T *type, 5683 char_u *name) 5684 { 5685 switch (dest) 5686 { 5687 case dest_option: 5688 return generate_STOREOPT(cctx, skip_option_env_lead(name), 5689 opt_flags); 5690 case dest_global: 5691 // include g: with the name, easier to execute that way 5692 return generate_STORE(cctx, vim_strchr(name, AUTOLOAD_CHAR) == NULL 5693 ? ISN_STOREG : ISN_STOREAUTO, 0, name); 5694 case dest_buffer: 5695 // include b: with the name, easier to execute that way 5696 return generate_STORE(cctx, ISN_STOREB, 0, name); 5697 case dest_window: 5698 // include w: with the name, easier to execute that way 5699 return generate_STORE(cctx, ISN_STOREW, 0, name); 5700 case dest_tab: 5701 // include t: with the name, easier to execute that way 5702 return generate_STORE(cctx, ISN_STORET, 0, name); 5703 case dest_env: 5704 return generate_STORE(cctx, ISN_STOREENV, 0, name + 1); 5705 case dest_reg: 5706 return generate_STORE(cctx, ISN_STOREREG, name[1], NULL); 5707 case dest_vimvar: 5708 return generate_STORE(cctx, ISN_STOREV, vimvaridx, NULL); 5709 case dest_script: 5710 if (scriptvar_idx < 0) 5711 // "s:" may be included in the name. 5712 return generate_OLDSCRIPT(cctx, ISN_STORES, name, 5713 scriptvar_sid, type); 5714 return generate_VIM9SCRIPT(cctx, ISN_STORESCRIPT, 5715 scriptvar_sid, scriptvar_idx, type); 5716 case dest_local: 5717 case dest_expr: 5718 // cannot happen 5719 break; 5720 } 5721 return FAIL; 5722 } 5723 5724 static int 5725 is_decl_command(int cmdidx) 5726 { 5727 return cmdidx == CMD_let || cmdidx == CMD_var 5728 || cmdidx == CMD_final || cmdidx == CMD_const; 5729 } 5730 5731 /* 5732 * Figure out the LHS type and other properties for an assignment or one item 5733 * of ":unlet" with an index. 5734 * Returns OK or FAIL. 5735 */ 5736 static int 5737 compile_lhs( 5738 char_u *var_start, 5739 lhs_T *lhs, 5740 int cmdidx, 5741 int heredoc, 5742 int oplen, 5743 cctx_T *cctx) 5744 { 5745 char_u *var_end; 5746 int is_decl = is_decl_command(cmdidx); 5747 5748 CLEAR_POINTER(lhs); 5749 lhs->lhs_dest = dest_local; 5750 lhs->lhs_vimvaridx = -1; 5751 lhs->lhs_scriptvar_idx = -1; 5752 5753 // "dest_end" is the end of the destination, including "[expr]" or 5754 // ".name". 5755 // "var_end" is the end of the variable/option/etc. name. 5756 lhs->lhs_dest_end = skip_var_one(var_start, FALSE); 5757 if (*var_start == '@') 5758 var_end = var_start + 2; 5759 else 5760 { 5761 // skip over the leading "&", "&l:", "&g:" and "$" 5762 var_end = skip_option_env_lead(var_start); 5763 var_end = to_name_end(var_end, TRUE); 5764 } 5765 5766 // "a: type" is declaring variable "a" with a type, not dict "a:". 5767 if (is_decl && lhs->lhs_dest_end == var_start + 2 5768 && lhs->lhs_dest_end[-1] == ':') 5769 --lhs->lhs_dest_end; 5770 if (is_decl && var_end == var_start + 2 && var_end[-1] == ':') 5771 --var_end; 5772 5773 // compute the length of the destination without "[expr]" or ".name" 5774 lhs->lhs_varlen = var_end - var_start; 5775 lhs->lhs_name = vim_strnsave(var_start, lhs->lhs_varlen); 5776 if (lhs->lhs_name == NULL) 5777 return FAIL; 5778 5779 if (lhs->lhs_dest_end > var_start + lhs->lhs_varlen) 5780 // Something follows after the variable: "var[idx]" or "var.key". 5781 lhs->lhs_has_index = TRUE; 5782 5783 if (heredoc) 5784 lhs->lhs_type = &t_list_string; 5785 else 5786 lhs->lhs_type = &t_any; 5787 5788 if (cctx->ctx_skip != SKIP_YES) 5789 { 5790 int declare_error = FALSE; 5791 5792 if (get_var_dest(lhs->lhs_name, &lhs->lhs_dest, cmdidx, 5793 &lhs->lhs_opt_flags, &lhs->lhs_vimvaridx, 5794 &lhs->lhs_type, cctx) == FAIL) 5795 return FAIL; 5796 if (lhs->lhs_dest != dest_local 5797 && cmdidx != CMD_const && cmdidx != CMD_final) 5798 { 5799 // Specific kind of variable recognized. 5800 declare_error = is_decl; 5801 } 5802 else 5803 { 5804 int idx; 5805 5806 // No specific kind of variable recognized, just a name. 5807 for (idx = 0; reserved[idx] != NULL; ++idx) 5808 if (STRCMP(reserved[idx], lhs->lhs_name) == 0) 5809 { 5810 semsg(_(e_cannot_use_reserved_name), lhs->lhs_name); 5811 return FAIL; 5812 } 5813 5814 5815 if (lookup_local(var_start, lhs->lhs_varlen, 5816 &lhs->lhs_local_lvar, cctx) == OK) 5817 lhs->lhs_lvar = &lhs->lhs_local_lvar; 5818 else 5819 { 5820 CLEAR_FIELD(lhs->lhs_arg_lvar); 5821 if (arg_exists(var_start, lhs->lhs_varlen, 5822 &lhs->lhs_arg_lvar.lv_idx, &lhs->lhs_arg_lvar.lv_type, 5823 &lhs->lhs_arg_lvar.lv_from_outer, cctx) == OK) 5824 { 5825 if (is_decl) 5826 { 5827 semsg(_(e_str_is_used_as_argument), lhs->lhs_name); 5828 return FAIL; 5829 } 5830 lhs->lhs_lvar = &lhs->lhs_arg_lvar; 5831 } 5832 } 5833 if (lhs->lhs_lvar != NULL) 5834 { 5835 if (is_decl) 5836 { 5837 semsg(_(e_variable_already_declared), lhs->lhs_name); 5838 return FAIL; 5839 } 5840 } 5841 else 5842 { 5843 int script_namespace = lhs->lhs_varlen > 1 5844 && STRNCMP(var_start, "s:", 2) == 0; 5845 int script_var = (script_namespace 5846 ? script_var_exists(var_start + 2, lhs->lhs_varlen - 2, 5847 FALSE, cctx) 5848 : script_var_exists(var_start, lhs->lhs_varlen, 5849 FALSE, cctx)) == OK; 5850 imported_T *import = 5851 find_imported(var_start, lhs->lhs_varlen, cctx); 5852 5853 if (script_namespace || script_var || import != NULL) 5854 { 5855 char_u *rawname = lhs->lhs_name 5856 + (lhs->lhs_name[1] == ':' ? 2 : 0); 5857 5858 if (is_decl) 5859 { 5860 if (script_namespace) 5861 semsg(_(e_cannot_declare_script_variable_in_function), 5862 lhs->lhs_name); 5863 else 5864 semsg(_(e_variable_already_declared_in_script_str), 5865 lhs->lhs_name); 5866 return FAIL; 5867 } 5868 else if (cctx->ctx_ufunc->uf_script_ctx_version 5869 == SCRIPT_VERSION_VIM9 5870 && script_namespace 5871 && !script_var && import == NULL) 5872 { 5873 semsg(_(e_unknown_variable_str), lhs->lhs_name); 5874 return FAIL; 5875 } 5876 5877 lhs->lhs_dest = dest_script; 5878 5879 // existing script-local variables should have a type 5880 lhs->lhs_scriptvar_sid = current_sctx.sc_sid; 5881 if (import != NULL) 5882 lhs->lhs_scriptvar_sid = import->imp_sid; 5883 if (SCRIPT_ID_VALID(lhs->lhs_scriptvar_sid)) 5884 { 5885 // Check writable only when no index follows. 5886 lhs->lhs_scriptvar_idx = get_script_item_idx( 5887 lhs->lhs_scriptvar_sid, rawname, 5888 lhs->lhs_has_index ? ASSIGN_FINAL : ASSIGN_CONST, 5889 cctx); 5890 if (lhs->lhs_scriptvar_idx >= 0) 5891 { 5892 scriptitem_T *si = SCRIPT_ITEM( 5893 lhs->lhs_scriptvar_sid); 5894 svar_T *sv = 5895 ((svar_T *)si->sn_var_vals.ga_data) 5896 + lhs->lhs_scriptvar_idx; 5897 lhs->lhs_type = sv->sv_type; 5898 } 5899 } 5900 } 5901 else if (check_defined(var_start, lhs->lhs_varlen, cctx, FALSE) 5902 == FAIL) 5903 return FAIL; 5904 } 5905 } 5906 5907 if (declare_error) 5908 { 5909 vim9_declare_error(lhs->lhs_name); 5910 return FAIL; 5911 } 5912 } 5913 5914 // handle "a:name" as a name, not index "name" on "a" 5915 if (lhs->lhs_varlen > 1 || var_start[lhs->lhs_varlen] != ':') 5916 var_end = lhs->lhs_dest_end; 5917 5918 if (lhs->lhs_dest != dest_option) 5919 { 5920 if (is_decl && *var_end == ':') 5921 { 5922 char_u *p; 5923 5924 // parse optional type: "let var: type = expr" 5925 if (!VIM_ISWHITE(var_end[1])) 5926 { 5927 semsg(_(e_white_space_required_after_str_str), ":", var_end); 5928 return FAIL; 5929 } 5930 p = skipwhite(var_end + 1); 5931 lhs->lhs_type = parse_type(&p, cctx->ctx_type_list, TRUE); 5932 if (lhs->lhs_type == NULL) 5933 return FAIL; 5934 lhs->lhs_has_type = TRUE; 5935 } 5936 else if (lhs->lhs_lvar != NULL) 5937 lhs->lhs_type = lhs->lhs_lvar->lv_type; 5938 } 5939 5940 if (oplen == 3 && !heredoc 5941 && lhs->lhs_dest != dest_global 5942 && !lhs->lhs_has_index 5943 && lhs->lhs_type->tt_type != VAR_STRING 5944 && lhs->lhs_type->tt_type != VAR_ANY) 5945 { 5946 emsg(_(e_can_only_concatenate_to_string)); 5947 return FAIL; 5948 } 5949 5950 if (lhs->lhs_lvar == NULL && lhs->lhs_dest == dest_local 5951 && cctx->ctx_skip != SKIP_YES) 5952 { 5953 if (oplen > 1 && !heredoc) 5954 { 5955 // +=, /=, etc. require an existing variable 5956 semsg(_(e_cannot_use_operator_on_new_variable), lhs->lhs_name); 5957 return FAIL; 5958 } 5959 if (!is_decl) 5960 { 5961 semsg(_(e_unknown_variable_str), lhs->lhs_name); 5962 return FAIL; 5963 } 5964 5965 // Check the name is valid for a funcref. 5966 if ((lhs->lhs_type->tt_type == VAR_FUNC 5967 || lhs->lhs_type->tt_type == VAR_PARTIAL) 5968 && var_wrong_func_name(lhs->lhs_name, TRUE)) 5969 return FAIL; 5970 5971 // New local variable. 5972 lhs->lhs_lvar = reserve_local(cctx, var_start, lhs->lhs_varlen, 5973 cmdidx == CMD_final || cmdidx == CMD_const, lhs->lhs_type); 5974 if (lhs->lhs_lvar == NULL) 5975 return FAIL; 5976 lhs->lhs_new_local = TRUE; 5977 } 5978 5979 lhs->lhs_member_type = lhs->lhs_type; 5980 if (lhs->lhs_has_index) 5981 { 5982 // Something follows after the variable: "var[idx]" or "var.key". 5983 // TODO: should we also handle "->func()" here? 5984 if (is_decl) 5985 { 5986 emsg(_(e_cannot_use_index_when_declaring_variable)); 5987 return FAIL; 5988 } 5989 5990 if (var_start[lhs->lhs_varlen] == '[' 5991 || var_start[lhs->lhs_varlen] == '.') 5992 { 5993 char_u *after = var_start + lhs->lhs_varlen; 5994 char_u *p; 5995 5996 // Only the last index is used below, if there are others 5997 // before it generate code for the expression. Thus for 5998 // "ll[1][2]" the expression is "ll[1]" and "[2]" is the index. 5999 for (;;) 6000 { 6001 p = skip_index(after); 6002 if (*p != '[' && *p != '.') 6003 break; 6004 after = p; 6005 } 6006 if (after > var_start + lhs->lhs_varlen) 6007 { 6008 lhs->lhs_varlen = after - var_start; 6009 lhs->lhs_dest = dest_expr; 6010 // We don't know the type before evaluating the expression, 6011 // use "any" until then. 6012 lhs->lhs_type = &t_any; 6013 } 6014 6015 if (lhs->lhs_type->tt_member == NULL) 6016 lhs->lhs_member_type = &t_any; 6017 else 6018 lhs->lhs_member_type = lhs->lhs_type->tt_member; 6019 } 6020 else 6021 { 6022 semsg("Not supported yet: %s", var_start); 6023 return FAIL; 6024 } 6025 } 6026 return OK; 6027 } 6028 6029 /* 6030 * For an assignment with an index, compile the "idx" in "var[idx]" or "key" in 6031 * "var.key". 6032 */ 6033 static int 6034 compile_assign_index( 6035 char_u *var_start, 6036 lhs_T *lhs, 6037 int is_assign, 6038 int *range, 6039 cctx_T *cctx) 6040 { 6041 size_t varlen = lhs->lhs_varlen; 6042 char_u *p; 6043 int r = OK; 6044 6045 p = var_start + varlen; 6046 if (*p == '[') 6047 { 6048 p = skipwhite(p + 1); 6049 r = compile_expr0(&p, cctx); 6050 6051 if (r == OK && *skipwhite(p) == ':') 6052 { 6053 // unlet var[idx : idx] 6054 if (is_assign) 6055 { 6056 semsg(_(e_cannot_use_range_with_assignment_str), p); 6057 return FAIL; 6058 } 6059 *range = TRUE; 6060 p = skipwhite(p); 6061 if (!IS_WHITE_OR_NUL(p[-1]) || !IS_WHITE_OR_NUL(p[1])) 6062 { 6063 semsg(_(e_white_space_required_before_and_after_str_at_str), 6064 ":", p); 6065 return FAIL; 6066 } 6067 p = skipwhite(p + 1); 6068 r = compile_expr0(&p, cctx); 6069 } 6070 6071 if (r == OK && *skipwhite(p) != ']') 6072 { 6073 // this should not happen 6074 emsg(_(e_missbrac)); 6075 r = FAIL; 6076 } 6077 } 6078 else // if (*p == '.') 6079 { 6080 char_u *key_end = to_name_end(p + 1, TRUE); 6081 char_u *key = vim_strnsave(p + 1, key_end - p - 1); 6082 6083 r = generate_PUSHS(cctx, key); 6084 } 6085 return r; 6086 } 6087 6088 /* 6089 * For a LHS with an index, load the variable to be indexed. 6090 */ 6091 static int 6092 compile_load_lhs( 6093 lhs_T *lhs, 6094 char_u *var_start, 6095 type_T *rhs_type, 6096 cctx_T *cctx) 6097 { 6098 if (lhs->lhs_dest == dest_expr) 6099 { 6100 size_t varlen = lhs->lhs_varlen; 6101 int c = var_start[varlen]; 6102 char_u *p = var_start; 6103 garray_T *stack = &cctx->ctx_type_stack; 6104 6105 // Evaluate "ll[expr]" of "ll[expr][idx]" 6106 var_start[varlen] = NUL; 6107 if (compile_expr0(&p, cctx) == OK && p != var_start + varlen) 6108 { 6109 // this should not happen 6110 emsg(_(e_missbrac)); 6111 var_start[varlen] = c; 6112 return FAIL; 6113 } 6114 var_start[varlen] = c; 6115 6116 lhs->lhs_type = stack->ga_len == 0 ? &t_void 6117 : ((type_T **)stack->ga_data)[stack->ga_len - 1]; 6118 // now we can properly check the type 6119 if (rhs_type != NULL && lhs->lhs_type->tt_member != NULL 6120 && rhs_type != &t_void 6121 && need_type(rhs_type, lhs->lhs_type->tt_member, -2, 0, cctx, 6122 FALSE, FALSE) == FAIL) 6123 return FAIL; 6124 } 6125 else 6126 generate_loadvar(cctx, lhs->lhs_dest, lhs->lhs_name, 6127 lhs->lhs_lvar, lhs->lhs_type); 6128 return OK; 6129 } 6130 6131 /* 6132 * Assignment to a list or dict member, or ":unlet" for the item, using the 6133 * information in "lhs". 6134 * Returns OK or FAIL. 6135 */ 6136 static int 6137 compile_assign_unlet( 6138 char_u *var_start, 6139 lhs_T *lhs, 6140 int is_assign, 6141 type_T *rhs_type, 6142 cctx_T *cctx) 6143 { 6144 vartype_T dest_type; 6145 garray_T *stack = &cctx->ctx_type_stack; 6146 int range = FALSE; 6147 6148 if (compile_assign_index(var_start, lhs, is_assign, &range, cctx) == FAIL) 6149 return FAIL; 6150 6151 if (lhs->lhs_type == &t_any) 6152 { 6153 // Index on variable of unknown type: check at runtime. 6154 dest_type = VAR_ANY; 6155 } 6156 else 6157 { 6158 dest_type = lhs->lhs_type->tt_type; 6159 if (dest_type == VAR_DICT && range) 6160 { 6161 emsg(e_cannot_use_range_with_dictionary); 6162 return FAIL; 6163 } 6164 if (dest_type == VAR_DICT && may_generate_2STRING(-1, cctx) == FAIL) 6165 return FAIL; 6166 if (dest_type == VAR_LIST) 6167 { 6168 if (range 6169 && need_type(((type_T **)stack->ga_data)[stack->ga_len - 2], 6170 &t_number, -1, 0, cctx, FALSE, FALSE) == FAIL) 6171 return FAIL; 6172 if (need_type(((type_T **)stack->ga_data)[stack->ga_len - 1], 6173 &t_number, -1, 0, cctx, FALSE, FALSE) == FAIL) 6174 return FAIL; 6175 } 6176 } 6177 6178 // Load the dict or list. On the stack we then have: 6179 // - value (for assignment, not for :unlet) 6180 // - index 6181 // - for [a : b] second index 6182 // - variable 6183 if (compile_load_lhs(lhs, var_start, rhs_type, cctx) == FAIL) 6184 return FAIL; 6185 6186 if (dest_type == VAR_LIST || dest_type == VAR_DICT || dest_type == VAR_ANY) 6187 { 6188 if (is_assign) 6189 { 6190 isn_T *isn = generate_instr_drop(cctx, ISN_STOREINDEX, 3); 6191 6192 if (isn == NULL) 6193 return FAIL; 6194 isn->isn_arg.vartype = dest_type; 6195 } 6196 else if (range) 6197 { 6198 if (generate_instr_drop(cctx, ISN_UNLETRANGE, 3) == NULL) 6199 return FAIL; 6200 } 6201 else 6202 { 6203 if (generate_instr_drop(cctx, ISN_UNLETINDEX, 2) == NULL) 6204 return FAIL; 6205 } 6206 } 6207 else 6208 { 6209 emsg(_(e_indexable_type_required)); 6210 return FAIL; 6211 } 6212 6213 return OK; 6214 } 6215 6216 /* 6217 * Compile declaration and assignment: 6218 * "let name" 6219 * "var name = expr" 6220 * "final name = expr" 6221 * "const name = expr" 6222 * "name = expr" 6223 * "arg" points to "name". 6224 * Return NULL for an error. 6225 * Return "arg" if it does not look like a variable list. 6226 */ 6227 static char_u * 6228 compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx) 6229 { 6230 char_u *var_start; 6231 char_u *p; 6232 char_u *end = arg; 6233 char_u *ret = NULL; 6234 int var_count = 0; 6235 int var_idx; 6236 int semicolon = 0; 6237 garray_T *instr = &cctx->ctx_instr; 6238 garray_T *stack = &cctx->ctx_type_stack; 6239 char_u *op; 6240 int oplen = 0; 6241 int heredoc = FALSE; 6242 type_T *rhs_type = &t_any; 6243 char_u *sp; 6244 int is_decl = is_decl_command(cmdidx); 6245 lhs_T lhs; 6246 long start_lnum = SOURCING_LNUM; 6247 6248 // Skip over the "var" or "[var, var]" to get to any "=". 6249 p = skip_var_list(arg, TRUE, &var_count, &semicolon, TRUE); 6250 if (p == NULL) 6251 return *arg == '[' ? arg : NULL; 6252 6253 if (var_count > 0 && is_decl) 6254 { 6255 // TODO: should we allow this, and figure out type inference from list 6256 // members? 6257 emsg(_(e_cannot_use_list_for_declaration)); 6258 return NULL; 6259 } 6260 lhs.lhs_name = NULL; 6261 6262 sp = p; 6263 p = skipwhite(p); 6264 op = p; 6265 oplen = assignment_len(p, &heredoc); 6266 6267 if (var_count > 0 && oplen == 0) 6268 // can be something like "[1, 2]->func()" 6269 return arg; 6270 6271 if (oplen > 0 && (!VIM_ISWHITE(*sp) || !IS_WHITE_OR_NUL(op[oplen]))) 6272 { 6273 error_white_both(op, oplen); 6274 return NULL; 6275 } 6276 6277 if (heredoc) 6278 { 6279 list_T *l; 6280 listitem_T *li; 6281 6282 // [let] varname =<< [trim] {end} 6283 eap->getline = exarg_getline; 6284 eap->cookie = cctx; 6285 l = heredoc_get(eap, op + 3, FALSE); 6286 if (l == NULL) 6287 return NULL; 6288 6289 if (cctx->ctx_skip != SKIP_YES) 6290 { 6291 // Push each line and the create the list. 6292 FOR_ALL_LIST_ITEMS(l, li) 6293 { 6294 generate_PUSHS(cctx, li->li_tv.vval.v_string); 6295 li->li_tv.vval.v_string = NULL; 6296 } 6297 generate_NEWLIST(cctx, l->lv_len); 6298 } 6299 list_free(l); 6300 p += STRLEN(p); 6301 end = p; 6302 } 6303 else if (var_count > 0) 6304 { 6305 char_u *wp; 6306 6307 // for "[var, var] = expr" evaluate the expression here, loop over the 6308 // list of variables below. 6309 // A line break may follow the "=". 6310 6311 wp = op + oplen; 6312 if (may_get_next_line_error(wp, &p, cctx) == FAIL) 6313 return FAIL; 6314 if (compile_expr0(&p, cctx) == FAIL) 6315 return NULL; 6316 end = p; 6317 6318 if (cctx->ctx_skip != SKIP_YES) 6319 { 6320 type_T *stacktype; 6321 6322 stacktype = stack->ga_len == 0 ? &t_void 6323 : ((type_T **)stack->ga_data)[stack->ga_len - 1]; 6324 if (stacktype->tt_type == VAR_VOID) 6325 { 6326 emsg(_(e_cannot_use_void_value)); 6327 goto theend; 6328 } 6329 if (need_type(stacktype, &t_list_any, -1, 0, cctx, 6330 FALSE, FALSE) == FAIL) 6331 goto theend; 6332 // TODO: check the length of a constant list here 6333 generate_CHECKLEN(cctx, semicolon ? var_count - 1 : var_count, 6334 semicolon); 6335 if (stacktype->tt_member != NULL) 6336 rhs_type = stacktype->tt_member; 6337 } 6338 } 6339 6340 /* 6341 * Loop over variables in "[var, var] = expr". 6342 * For "var = expr" and "let var: type" this is done only once. 6343 */ 6344 if (var_count > 0) 6345 var_start = skipwhite(arg + 1); // skip over the "[" 6346 else 6347 var_start = arg; 6348 for (var_idx = 0; var_idx == 0 || var_idx < var_count; var_idx++) 6349 { 6350 int instr_count = -1; 6351 6352 vim_free(lhs.lhs_name); 6353 6354 /* 6355 * Figure out the LHS type and other properties. 6356 */ 6357 if (compile_lhs(var_start, &lhs, cmdidx, heredoc, oplen, cctx) == FAIL) 6358 goto theend; 6359 6360 if (!lhs.lhs_has_index && lhs.lhs_lvar == &lhs.lhs_arg_lvar) 6361 { 6362 semsg(_(e_cannot_assign_to_argument), lhs.lhs_name); 6363 goto theend; 6364 } 6365 if (!is_decl && lhs.lhs_lvar != NULL 6366 && lhs.lhs_lvar->lv_const && !lhs.lhs_has_index) 6367 { 6368 semsg(_(e_cannot_assign_to_constant), lhs.lhs_name); 6369 goto theend; 6370 } 6371 6372 if (!heredoc) 6373 { 6374 if (cctx->ctx_skip == SKIP_YES) 6375 { 6376 if (oplen > 0 && var_count == 0) 6377 { 6378 // skip over the "=" and the expression 6379 p = skipwhite(op + oplen); 6380 compile_expr0(&p, cctx); 6381 } 6382 } 6383 else if (oplen > 0) 6384 { 6385 int is_const = FALSE; 6386 char_u *wp; 6387 6388 // For "var = expr" evaluate the expression. 6389 if (var_count == 0) 6390 { 6391 int r; 6392 6393 // for "+=", "*=", "..=" etc. first load the current value 6394 if (*op != '=') 6395 { 6396 compile_load_lhs(&lhs, var_start, NULL, cctx); 6397 6398 if (lhs.lhs_has_index) 6399 { 6400 int range = FALSE; 6401 6402 // Get member from list or dict. First compile the 6403 // index value. 6404 if (compile_assign_index(var_start, &lhs, 6405 TRUE, &range, cctx) == FAIL) 6406 goto theend; 6407 6408 // Get the member. 6409 if (compile_member(FALSE, cctx) == FAIL) 6410 goto theend; 6411 } 6412 } 6413 6414 // Compile the expression. Temporarily hide the new local 6415 // variable here, it is not available to this expression. 6416 if (lhs.lhs_new_local) 6417 --cctx->ctx_locals.ga_len; 6418 instr_count = instr->ga_len; 6419 wp = op + oplen; 6420 if (may_get_next_line_error(wp, &p, cctx) == FAIL) 6421 { 6422 if (lhs.lhs_new_local) 6423 ++cctx->ctx_locals.ga_len; 6424 goto theend; 6425 } 6426 r = compile_expr0_ext(&p, cctx, &is_const); 6427 if (lhs.lhs_new_local) 6428 ++cctx->ctx_locals.ga_len; 6429 if (r == FAIL) 6430 goto theend; 6431 } 6432 else if (semicolon && var_idx == var_count - 1) 6433 { 6434 // For "[var; var] = expr" get the rest of the list 6435 if (generate_SLICE(cctx, var_count - 1) == FAIL) 6436 goto theend; 6437 } 6438 else 6439 { 6440 // For "[var, var] = expr" get the "var_idx" item from the 6441 // list. 6442 if (generate_GETITEM(cctx, var_idx) == FAIL) 6443 goto theend; 6444 } 6445 6446 rhs_type = stack->ga_len == 0 ? &t_void 6447 : ((type_T **)stack->ga_data)[stack->ga_len - 1]; 6448 if (lhs.lhs_lvar != NULL && (is_decl || !lhs.lhs_has_type)) 6449 { 6450 if ((rhs_type->tt_type == VAR_FUNC 6451 || rhs_type->tt_type == VAR_PARTIAL) 6452 && !lhs.lhs_has_index 6453 && var_wrong_func_name(lhs.lhs_name, TRUE)) 6454 goto theend; 6455 6456 if (lhs.lhs_new_local && !lhs.lhs_has_type) 6457 { 6458 if (rhs_type->tt_type == VAR_VOID) 6459 { 6460 emsg(_(e_cannot_use_void_value)); 6461 goto theend; 6462 } 6463 else 6464 { 6465 // An empty list or dict has a &t_unknown member, 6466 // for a variable that implies &t_any. 6467 if (rhs_type == &t_list_empty) 6468 lhs.lhs_lvar->lv_type = &t_list_any; 6469 else if (rhs_type == &t_dict_empty) 6470 lhs.lhs_lvar->lv_type = &t_dict_any; 6471 else if (rhs_type == &t_unknown) 6472 lhs.lhs_lvar->lv_type = &t_any; 6473 else 6474 lhs.lhs_lvar->lv_type = rhs_type; 6475 } 6476 } 6477 else if (*op == '=') 6478 { 6479 type_T *use_type = lhs.lhs_lvar->lv_type; 6480 6481 // Without operator check type here, otherwise below. 6482 // Use the line number of the assignment. 6483 SOURCING_LNUM = start_lnum; 6484 if (lhs.lhs_has_index) 6485 use_type = lhs.lhs_member_type; 6486 if (need_type(rhs_type, use_type, -1, 0, cctx, 6487 FALSE, is_const) == FAIL) 6488 goto theend; 6489 } 6490 } 6491 else if (*p != '=' && need_type(rhs_type, lhs.lhs_member_type, 6492 -1, 0, cctx, FALSE, FALSE) == FAIL) 6493 goto theend; 6494 } 6495 else if (cmdidx == CMD_final) 6496 { 6497 emsg(_(e_final_requires_a_value)); 6498 goto theend; 6499 } 6500 else if (cmdidx == CMD_const) 6501 { 6502 emsg(_(e_const_requires_a_value)); 6503 goto theend; 6504 } 6505 else if (!lhs.lhs_has_type || lhs.lhs_dest == dest_option) 6506 { 6507 emsg(_(e_type_or_initialization_required)); 6508 goto theend; 6509 } 6510 else 6511 { 6512 // variables are always initialized 6513 if (ga_grow(instr, 1) == FAIL) 6514 goto theend; 6515 switch (lhs.lhs_member_type->tt_type) 6516 { 6517 case VAR_BOOL: 6518 generate_PUSHBOOL(cctx, VVAL_FALSE); 6519 break; 6520 case VAR_FLOAT: 6521 #ifdef FEAT_FLOAT 6522 generate_PUSHF(cctx, 0.0); 6523 #endif 6524 break; 6525 case VAR_STRING: 6526 generate_PUSHS(cctx, NULL); 6527 break; 6528 case VAR_BLOB: 6529 generate_PUSHBLOB(cctx, blob_alloc()); 6530 break; 6531 case VAR_FUNC: 6532 generate_PUSHFUNC(cctx, NULL, &t_func_void); 6533 break; 6534 case VAR_LIST: 6535 generate_NEWLIST(cctx, 0); 6536 break; 6537 case VAR_DICT: 6538 generate_NEWDICT(cctx, 0); 6539 break; 6540 case VAR_JOB: 6541 generate_PUSHJOB(cctx, NULL); 6542 break; 6543 case VAR_CHANNEL: 6544 generate_PUSHCHANNEL(cctx, NULL); 6545 break; 6546 case VAR_NUMBER: 6547 case VAR_UNKNOWN: 6548 case VAR_ANY: 6549 case VAR_PARTIAL: 6550 case VAR_VOID: 6551 case VAR_SPECIAL: // cannot happen 6552 generate_PUSHNR(cctx, 0); 6553 break; 6554 } 6555 } 6556 if (var_count == 0) 6557 end = p; 6558 } 6559 6560 // no need to parse more when skipping 6561 if (cctx->ctx_skip == SKIP_YES) 6562 break; 6563 6564 if (oplen > 0 && *op != '=') 6565 { 6566 type_T *expected; 6567 type_T *stacktype; 6568 6569 if (*op == '.') 6570 expected = &t_string; 6571 else 6572 expected = lhs.lhs_member_type; 6573 stacktype = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 6574 if ( 6575 #ifdef FEAT_FLOAT 6576 // If variable is float operation with number is OK. 6577 !(expected == &t_float && stacktype == &t_number) && 6578 #endif 6579 need_type(stacktype, expected, -1, 0, cctx, 6580 FALSE, FALSE) == FAIL) 6581 goto theend; 6582 6583 if (*op == '.') 6584 { 6585 if (generate_instr_drop(cctx, ISN_CONCAT, 1) == NULL) 6586 goto theend; 6587 } 6588 else if (*op == '+') 6589 { 6590 if (generate_add_instr(cctx, 6591 operator_type(lhs.lhs_member_type, stacktype), 6592 lhs.lhs_member_type, stacktype) == FAIL) 6593 goto theend; 6594 } 6595 else if (generate_two_op(cctx, op) == FAIL) 6596 goto theend; 6597 } 6598 6599 if (lhs.lhs_has_index) 6600 { 6601 // Use the info in "lhs" to store the value at the index in the 6602 // list or dict. 6603 if (compile_assign_unlet(var_start, &lhs, TRUE, rhs_type, cctx) 6604 == FAIL) 6605 goto theend; 6606 } 6607 else 6608 { 6609 if (is_decl && cmdidx == CMD_const && (lhs.lhs_dest == dest_script 6610 || lhs.lhs_dest == dest_global 6611 || lhs.lhs_dest == dest_local)) 6612 // ":const var": lock the value, but not referenced variables 6613 generate_LOCKCONST(cctx); 6614 6615 if (is_decl 6616 && (lhs.lhs_type->tt_type == VAR_DICT 6617 || lhs.lhs_type->tt_type == VAR_LIST) 6618 && lhs.lhs_type->tt_member != NULL 6619 && lhs.lhs_type->tt_member != &t_any 6620 && lhs.lhs_type->tt_member != &t_unknown) 6621 // Set the type in the list or dict, so that it can be checked, 6622 // also in legacy script. 6623 generate_SETTYPE(cctx, lhs.lhs_type); 6624 6625 if (lhs.lhs_dest != dest_local) 6626 { 6627 if (generate_store_var(cctx, lhs.lhs_dest, 6628 lhs.lhs_opt_flags, lhs.lhs_vimvaridx, 6629 lhs.lhs_scriptvar_idx, lhs.lhs_scriptvar_sid, 6630 lhs.lhs_type, lhs.lhs_name) == FAIL) 6631 goto theend; 6632 } 6633 else if (lhs.lhs_lvar != NULL) 6634 { 6635 isn_T *isn = ((isn_T *)instr->ga_data) 6636 + instr->ga_len - 1; 6637 6638 // optimization: turn "var = 123" from ISN_PUSHNR + 6639 // ISN_STORE into ISN_STORENR 6640 if (lhs.lhs_lvar->lv_from_outer == 0 6641 && instr->ga_len == instr_count + 1 6642 && isn->isn_type == ISN_PUSHNR) 6643 { 6644 varnumber_T val = isn->isn_arg.number; 6645 6646 isn->isn_type = ISN_STORENR; 6647 isn->isn_arg.storenr.stnr_idx = lhs.lhs_lvar->lv_idx; 6648 isn->isn_arg.storenr.stnr_val = val; 6649 if (stack->ga_len > 0) 6650 --stack->ga_len; 6651 } 6652 else if (lhs.lhs_lvar->lv_from_outer > 0) 6653 generate_STOREOUTER(cctx, lhs.lhs_lvar->lv_idx, 6654 lhs.lhs_lvar->lv_from_outer); 6655 else 6656 generate_STORE(cctx, ISN_STORE, lhs.lhs_lvar->lv_idx, NULL); 6657 } 6658 } 6659 6660 if (var_idx + 1 < var_count) 6661 var_start = skipwhite(lhs.lhs_dest_end + 1); 6662 } 6663 6664 // for "[var, var] = expr" drop the "expr" value 6665 if (var_count > 0 && !semicolon) 6666 { 6667 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL) 6668 goto theend; 6669 } 6670 6671 ret = skipwhite(end); 6672 6673 theend: 6674 vim_free(lhs.lhs_name); 6675 return ret; 6676 } 6677 6678 /* 6679 * Check for an assignment at "eap->cmd", compile it if found. 6680 * Return NOTDONE if there is none, FAIL for failure, OK if done. 6681 */ 6682 static int 6683 may_compile_assignment(exarg_T *eap, char_u **line, cctx_T *cctx) 6684 { 6685 char_u *pskip; 6686 char_u *p; 6687 6688 // Assuming the command starts with a variable or function name, 6689 // find what follows. 6690 // Skip over "var.member", "var[idx]" and the like. 6691 // Also "&opt = val", "$ENV = val" and "@r = val". 6692 pskip = (*eap->cmd == '&' || *eap->cmd == '$' || *eap->cmd == '@') 6693 ? eap->cmd + 1 : eap->cmd; 6694 p = to_name_end(pskip, TRUE); 6695 if (p > eap->cmd && *p != NUL) 6696 { 6697 char_u *var_end; 6698 int oplen; 6699 int heredoc; 6700 6701 if (eap->cmd[0] == '@') 6702 var_end = eap->cmd + 2; 6703 else 6704 var_end = find_name_end(pskip, NULL, NULL, 6705 FNE_CHECK_START | FNE_INCL_BR); 6706 oplen = assignment_len(skipwhite(var_end), &heredoc); 6707 if (oplen > 0) 6708 { 6709 size_t len = p - eap->cmd; 6710 6711 // Recognize an assignment if we recognize the variable 6712 // name: 6713 // "g:var = expr" 6714 // "local = expr" where "local" is a local var. 6715 // "script = expr" where "script" is a script-local var. 6716 // "import = expr" where "import" is an imported var 6717 // "&opt = expr" 6718 // "$ENV = expr" 6719 // "@r = expr" 6720 if (*eap->cmd == '&' 6721 || *eap->cmd == '$' 6722 || *eap->cmd == '@' 6723 || ((len) > 2 && eap->cmd[1] == ':') 6724 || variable_exists(eap->cmd, len, cctx)) 6725 { 6726 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx); 6727 if (*line == NULL || *line == eap->cmd) 6728 return FAIL; 6729 return OK; 6730 } 6731 } 6732 } 6733 6734 if (*eap->cmd == '[') 6735 { 6736 // [var, var] = expr 6737 *line = compile_assignment(eap->cmd, eap, CMD_SIZE, cctx); 6738 if (*line == NULL) 6739 return FAIL; 6740 if (*line != eap->cmd) 6741 return OK; 6742 } 6743 return NOTDONE; 6744 } 6745 6746 /* 6747 * Check if "name" can be "unlet". 6748 */ 6749 int 6750 check_vim9_unlet(char_u *name) 6751 { 6752 if (name[1] != ':' || vim_strchr((char_u *)"gwtb", *name) == NULL) 6753 { 6754 // "unlet s:var" is allowed in legacy script. 6755 if (*name == 's' && !script_is_vim9()) 6756 return OK; 6757 semsg(_(e_cannot_unlet_str), name); 6758 return FAIL; 6759 } 6760 return OK; 6761 } 6762 6763 /* 6764 * Callback passed to ex_unletlock(). 6765 */ 6766 static int 6767 compile_unlet( 6768 lval_T *lvp, 6769 char_u *name_end, 6770 exarg_T *eap, 6771 int deep UNUSED, 6772 void *coookie) 6773 { 6774 cctx_T *cctx = coookie; 6775 char_u *p = lvp->ll_name; 6776 int cc = *name_end; 6777 int ret = OK; 6778 6779 if (cctx->ctx_skip == SKIP_YES) 6780 return OK; 6781 6782 *name_end = NUL; 6783 if (*p == '$') 6784 { 6785 // :unlet $ENV_VAR 6786 ret = generate_UNLET(cctx, ISN_UNLETENV, p + 1, eap->forceit); 6787 } 6788 else if (vim_strchr(p, '.') != NULL || vim_strchr(p, '[') != NULL) 6789 { 6790 lhs_T lhs; 6791 6792 // This is similar to assigning: lookup the list/dict, compile the 6793 // idx/key. Then instead of storing the value unlet the item. 6794 // unlet {list}[idx] 6795 // unlet {dict}[key] dict.key 6796 // 6797 // Figure out the LHS type and other properties. 6798 // 6799 ret = compile_lhs(p, &lhs, CMD_unlet, FALSE, 0, cctx); 6800 6801 // : unlet an indexed item 6802 if (!lhs.lhs_has_index) 6803 { 6804 iemsg("called compile_lhs() without an index"); 6805 ret = FAIL; 6806 } 6807 else 6808 { 6809 // Use the info in "lhs" to unlet the item at the index in the 6810 // list or dict. 6811 ret = compile_assign_unlet(p, &lhs, FALSE, &t_void, cctx); 6812 } 6813 6814 vim_free(lhs.lhs_name); 6815 } 6816 else if (check_vim9_unlet(p) == FAIL) 6817 { 6818 ret = FAIL; 6819 } 6820 else 6821 { 6822 // Normal name. Only supports g:, w:, t: and b: namespaces. 6823 ret = generate_UNLET(cctx, ISN_UNLET, p, eap->forceit); 6824 } 6825 6826 *name_end = cc; 6827 return ret; 6828 } 6829 6830 /* 6831 * Callback passed to ex_unletlock(). 6832 */ 6833 static int 6834 compile_lock_unlock( 6835 lval_T *lvp, 6836 char_u *name_end, 6837 exarg_T *eap, 6838 int deep UNUSED, 6839 void *coookie) 6840 { 6841 cctx_T *cctx = coookie; 6842 int cc = *name_end; 6843 char_u *p = lvp->ll_name; 6844 int ret = OK; 6845 size_t len; 6846 char_u *buf; 6847 6848 if (cctx->ctx_skip == SKIP_YES) 6849 return OK; 6850 6851 // Cannot use :lockvar and :unlockvar on local variables. 6852 if (p[1] != ':') 6853 { 6854 char_u *end = skip_var_one(p, FALSE); 6855 6856 if (lookup_local(p, end - p, NULL, cctx) == OK) 6857 { 6858 emsg(_(e_cannot_lock_unlock_local_variable)); 6859 return FAIL; 6860 } 6861 } 6862 6863 // Checking is done at runtime. 6864 *name_end = NUL; 6865 len = name_end - p + 20; 6866 buf = alloc(len); 6867 if (buf == NULL) 6868 ret = FAIL; 6869 else 6870 { 6871 vim_snprintf((char *)buf, len, "%s %s", 6872 eap->cmdidx == CMD_lockvar ? "lockvar" : "unlockvar", 6873 p); 6874 ret = generate_EXEC(cctx, buf); 6875 6876 vim_free(buf); 6877 *name_end = cc; 6878 } 6879 return ret; 6880 } 6881 6882 /* 6883 * compile "unlet var", "lock var" and "unlock var" 6884 * "arg" points to "var". 6885 */ 6886 static char_u * 6887 compile_unletlock(char_u *arg, exarg_T *eap, cctx_T *cctx) 6888 { 6889 ex_unletlock(eap, arg, 0, GLV_NO_AUTOLOAD | GLV_COMPILING, 6890 eap->cmdidx == CMD_unlet ? compile_unlet : compile_lock_unlock, 6891 cctx); 6892 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd; 6893 } 6894 6895 /* 6896 * Compile an :import command. 6897 */ 6898 static char_u * 6899 compile_import(char_u *arg, cctx_T *cctx) 6900 { 6901 return handle_import(arg, &cctx->ctx_imports, 0, NULL, cctx); 6902 } 6903 6904 /* 6905 * generate a jump to the ":endif"/":endfor"/":endwhile"/":finally"/":endtry". 6906 */ 6907 static int 6908 compile_jump_to_end(endlabel_T **el, jumpwhen_T when, cctx_T *cctx) 6909 { 6910 garray_T *instr = &cctx->ctx_instr; 6911 endlabel_T *endlabel = ALLOC_CLEAR_ONE(endlabel_T); 6912 6913 if (endlabel == NULL) 6914 return FAIL; 6915 endlabel->el_next = *el; 6916 *el = endlabel; 6917 endlabel->el_end_label = instr->ga_len; 6918 6919 generate_JUMP(cctx, when, 0); 6920 return OK; 6921 } 6922 6923 static void 6924 compile_fill_jump_to_end(endlabel_T **el, int jump_where, cctx_T *cctx) 6925 { 6926 garray_T *instr = &cctx->ctx_instr; 6927 6928 while (*el != NULL) 6929 { 6930 endlabel_T *cur = (*el); 6931 isn_T *isn; 6932 6933 isn = ((isn_T *)instr->ga_data) + cur->el_end_label; 6934 isn->isn_arg.jump.jump_where = jump_where; 6935 *el = cur->el_next; 6936 vim_free(cur); 6937 } 6938 } 6939 6940 static void 6941 compile_free_jump_to_end(endlabel_T **el) 6942 { 6943 while (*el != NULL) 6944 { 6945 endlabel_T *cur = (*el); 6946 6947 *el = cur->el_next; 6948 vim_free(cur); 6949 } 6950 } 6951 6952 /* 6953 * Create a new scope and set up the generic items. 6954 */ 6955 static scope_T * 6956 new_scope(cctx_T *cctx, scopetype_T type) 6957 { 6958 scope_T *scope = ALLOC_CLEAR_ONE(scope_T); 6959 6960 if (scope == NULL) 6961 return NULL; 6962 scope->se_outer = cctx->ctx_scope; 6963 cctx->ctx_scope = scope; 6964 scope->se_type = type; 6965 scope->se_local_count = cctx->ctx_locals.ga_len; 6966 return scope; 6967 } 6968 6969 /* 6970 * Free the current scope and go back to the outer scope. 6971 */ 6972 static void 6973 drop_scope(cctx_T *cctx) 6974 { 6975 scope_T *scope = cctx->ctx_scope; 6976 6977 if (scope == NULL) 6978 { 6979 iemsg("calling drop_scope() without a scope"); 6980 return; 6981 } 6982 cctx->ctx_scope = scope->se_outer; 6983 switch (scope->se_type) 6984 { 6985 case IF_SCOPE: 6986 compile_free_jump_to_end(&scope->se_u.se_if.is_end_label); break; 6987 case FOR_SCOPE: 6988 compile_free_jump_to_end(&scope->se_u.se_for.fs_end_label); break; 6989 case WHILE_SCOPE: 6990 compile_free_jump_to_end(&scope->se_u.se_while.ws_end_label); break; 6991 case TRY_SCOPE: 6992 compile_free_jump_to_end(&scope->se_u.se_try.ts_end_label); break; 6993 case NO_SCOPE: 6994 case BLOCK_SCOPE: 6995 break; 6996 } 6997 vim_free(scope); 6998 } 6999 7000 /* 7001 * compile "if expr" 7002 * 7003 * "if expr" Produces instructions: 7004 * EVAL expr Push result of "expr" 7005 * JUMP_IF_FALSE end 7006 * ... body ... 7007 * end: 7008 * 7009 * "if expr | else" Produces instructions: 7010 * EVAL expr Push result of "expr" 7011 * JUMP_IF_FALSE else 7012 * ... body ... 7013 * JUMP_ALWAYS end 7014 * else: 7015 * ... body ... 7016 * end: 7017 * 7018 * "if expr1 | elseif expr2 | else" Produces instructions: 7019 * EVAL expr Push result of "expr" 7020 * JUMP_IF_FALSE elseif 7021 * ... body ... 7022 * JUMP_ALWAYS end 7023 * elseif: 7024 * EVAL expr Push result of "expr" 7025 * JUMP_IF_FALSE else 7026 * ... body ... 7027 * JUMP_ALWAYS end 7028 * else: 7029 * ... body ... 7030 * end: 7031 */ 7032 static char_u * 7033 compile_if(char_u *arg, cctx_T *cctx) 7034 { 7035 char_u *p = arg; 7036 garray_T *instr = &cctx->ctx_instr; 7037 int instr_count = instr->ga_len; 7038 scope_T *scope; 7039 skip_T skip_save = cctx->ctx_skip; 7040 ppconst_T ppconst; 7041 7042 CLEAR_FIELD(ppconst); 7043 if (compile_expr1(&p, cctx, &ppconst) == FAIL) 7044 { 7045 clear_ppconst(&ppconst); 7046 return NULL; 7047 } 7048 if (!ends_excmd2(arg, skipwhite(p))) 7049 { 7050 semsg(_(e_trailing_arg), p); 7051 return NULL; 7052 } 7053 if (cctx->ctx_skip == SKIP_YES) 7054 clear_ppconst(&ppconst); 7055 else if (instr->ga_len == instr_count && ppconst.pp_used == 1) 7056 { 7057 int error = FALSE; 7058 int v; 7059 7060 // The expression results in a constant. 7061 v = tv_get_bool_chk(&ppconst.pp_tv[0], &error); 7062 clear_ppconst(&ppconst); 7063 if (error) 7064 return NULL; 7065 cctx->ctx_skip = v ? SKIP_NOT : SKIP_YES; 7066 } 7067 else 7068 { 7069 // Not a constant, generate instructions for the expression. 7070 cctx->ctx_skip = SKIP_UNKNOWN; 7071 if (generate_ppconst(cctx, &ppconst) == FAIL) 7072 return NULL; 7073 if (bool_on_stack(cctx) == FAIL) 7074 return NULL; 7075 } 7076 7077 // CMDMOD_REV must come before the jump 7078 generate_undo_cmdmods(cctx); 7079 7080 scope = new_scope(cctx, IF_SCOPE); 7081 if (scope == NULL) 7082 return NULL; 7083 scope->se_skip_save = skip_save; 7084 // "is_had_return" will be reset if any block does not end in :return 7085 scope->se_u.se_if.is_had_return = TRUE; 7086 7087 if (cctx->ctx_skip == SKIP_UNKNOWN) 7088 { 7089 // "where" is set when ":elseif", "else" or ":endif" is found 7090 scope->se_u.se_if.is_if_label = instr->ga_len; 7091 generate_JUMP(cctx, JUMP_IF_FALSE, 0); 7092 } 7093 else 7094 scope->se_u.se_if.is_if_label = -1; 7095 7096 #ifdef FEAT_PROFILE 7097 if (cctx->ctx_profiling && cctx->ctx_skip == SKIP_YES 7098 && skip_save != SKIP_YES) 7099 { 7100 // generated a profile start, need to generate a profile end, since it 7101 // won't be done after returning 7102 cctx->ctx_skip = SKIP_NOT; 7103 generate_instr(cctx, ISN_PROF_END); 7104 cctx->ctx_skip = SKIP_YES; 7105 } 7106 #endif 7107 7108 return p; 7109 } 7110 7111 static char_u * 7112 compile_elseif(char_u *arg, cctx_T *cctx) 7113 { 7114 char_u *p = arg; 7115 garray_T *instr = &cctx->ctx_instr; 7116 int instr_count = instr->ga_len; 7117 isn_T *isn; 7118 scope_T *scope = cctx->ctx_scope; 7119 ppconst_T ppconst; 7120 skip_T save_skip = cctx->ctx_skip; 7121 7122 if (scope == NULL || scope->se_type != IF_SCOPE) 7123 { 7124 emsg(_(e_elseif_without_if)); 7125 return NULL; 7126 } 7127 unwind_locals(cctx, scope->se_local_count); 7128 if (!cctx->ctx_had_return) 7129 scope->se_u.se_if.is_had_return = FALSE; 7130 7131 if (cctx->ctx_skip == SKIP_NOT) 7132 { 7133 // previous block was executed, this one and following will not 7134 cctx->ctx_skip = SKIP_YES; 7135 scope->se_u.se_if.is_seen_skip_not = TRUE; 7136 } 7137 if (scope->se_u.se_if.is_seen_skip_not) 7138 { 7139 // A previous block was executed, skip over expression and bail out. 7140 // Do not count the "elseif" for profiling and cmdmod 7141 instr->ga_len = current_instr_idx(cctx); 7142 7143 skip_expr_cctx(&p, cctx); 7144 return p; 7145 } 7146 7147 if (cctx->ctx_skip == SKIP_UNKNOWN) 7148 { 7149 int moved_cmdmod = FALSE; 7150 7151 // Move any CMDMOD instruction to after the jump 7152 if (((isn_T *)instr->ga_data)[instr->ga_len - 1].isn_type == ISN_CMDMOD) 7153 { 7154 if (ga_grow(instr, 1) == FAIL) 7155 return NULL; 7156 ((isn_T *)instr->ga_data)[instr->ga_len] = 7157 ((isn_T *)instr->ga_data)[instr->ga_len - 1]; 7158 --instr->ga_len; 7159 moved_cmdmod = TRUE; 7160 } 7161 7162 if (compile_jump_to_end(&scope->se_u.se_if.is_end_label, 7163 JUMP_ALWAYS, cctx) == FAIL) 7164 return NULL; 7165 // previous "if" or "elseif" jumps here 7166 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label; 7167 isn->isn_arg.jump.jump_where = instr->ga_len; 7168 if (moved_cmdmod) 7169 ++instr->ga_len; 7170 } 7171 7172 // compile "expr"; if we know it evaluates to FALSE skip the block 7173 CLEAR_FIELD(ppconst); 7174 if (cctx->ctx_skip == SKIP_YES) 7175 { 7176 cctx->ctx_skip = SKIP_UNKNOWN; 7177 #ifdef FEAT_PROFILE 7178 if (cctx->ctx_profiling) 7179 { 7180 // the previous block was skipped, need to profile this line 7181 generate_instr(cctx, ISN_PROF_START); 7182 instr_count = instr->ga_len; 7183 } 7184 #endif 7185 } 7186 if (compile_expr1(&p, cctx, &ppconst) == FAIL) 7187 { 7188 clear_ppconst(&ppconst); 7189 return NULL; 7190 } 7191 cctx->ctx_skip = save_skip; 7192 if (!ends_excmd2(arg, skipwhite(p))) 7193 { 7194 semsg(_(e_trailing_arg), p); 7195 return NULL; 7196 } 7197 if (scope->se_skip_save == SKIP_YES) 7198 clear_ppconst(&ppconst); 7199 else if (instr->ga_len == instr_count && ppconst.pp_used == 1) 7200 { 7201 int error = FALSE; 7202 int v; 7203 7204 // The expression results in a constant. 7205 // TODO: how about nesting? 7206 v = tv_get_bool_chk(&ppconst.pp_tv[0], &error); 7207 if (error) 7208 return NULL; 7209 cctx->ctx_skip = v ? SKIP_NOT : SKIP_YES; 7210 clear_ppconst(&ppconst); 7211 scope->se_u.se_if.is_if_label = -1; 7212 } 7213 else 7214 { 7215 // Not a constant, generate instructions for the expression. 7216 cctx->ctx_skip = SKIP_UNKNOWN; 7217 if (generate_ppconst(cctx, &ppconst) == FAIL) 7218 return NULL; 7219 if (bool_on_stack(cctx) == FAIL) 7220 return NULL; 7221 7222 // CMDMOD_REV must come before the jump 7223 generate_undo_cmdmods(cctx); 7224 7225 // "where" is set when ":elseif", "else" or ":endif" is found 7226 scope->se_u.se_if.is_if_label = instr->ga_len; 7227 generate_JUMP(cctx, JUMP_IF_FALSE, 0); 7228 } 7229 7230 return p; 7231 } 7232 7233 static char_u * 7234 compile_else(char_u *arg, cctx_T *cctx) 7235 { 7236 char_u *p = arg; 7237 garray_T *instr = &cctx->ctx_instr; 7238 isn_T *isn; 7239 scope_T *scope = cctx->ctx_scope; 7240 7241 if (scope == NULL || scope->se_type != IF_SCOPE) 7242 { 7243 emsg(_(e_else_without_if)); 7244 return NULL; 7245 } 7246 unwind_locals(cctx, scope->se_local_count); 7247 if (!cctx->ctx_had_return) 7248 scope->se_u.se_if.is_had_return = FALSE; 7249 scope->se_u.se_if.is_seen_else = TRUE; 7250 7251 #ifdef FEAT_PROFILE 7252 if (cctx->ctx_profiling) 7253 { 7254 if (cctx->ctx_skip == SKIP_NOT 7255 && ((isn_T *)instr->ga_data)[instr->ga_len - 1] 7256 .isn_type == ISN_PROF_START) 7257 // the previous block was executed, do not count "else" for profiling 7258 --instr->ga_len; 7259 if (cctx->ctx_skip == SKIP_YES && !scope->se_u.se_if.is_seen_skip_not) 7260 { 7261 // the previous block was not executed, this one will, do count the 7262 // "else" for profiling 7263 cctx->ctx_skip = SKIP_NOT; 7264 generate_instr(cctx, ISN_PROF_END); 7265 generate_instr(cctx, ISN_PROF_START); 7266 cctx->ctx_skip = SKIP_YES; 7267 } 7268 } 7269 #endif 7270 7271 if (!scope->se_u.se_if.is_seen_skip_not && scope->se_skip_save != SKIP_YES) 7272 { 7273 // jump from previous block to the end, unless the else block is empty 7274 if (cctx->ctx_skip == SKIP_UNKNOWN) 7275 { 7276 if (!cctx->ctx_had_return 7277 && compile_jump_to_end(&scope->se_u.se_if.is_end_label, 7278 JUMP_ALWAYS, cctx) == FAIL) 7279 return NULL; 7280 } 7281 7282 if (cctx->ctx_skip == SKIP_UNKNOWN) 7283 { 7284 if (scope->se_u.se_if.is_if_label >= 0) 7285 { 7286 // previous "if" or "elseif" jumps here 7287 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label; 7288 isn->isn_arg.jump.jump_where = instr->ga_len; 7289 scope->se_u.se_if.is_if_label = -1; 7290 } 7291 } 7292 7293 if (cctx->ctx_skip != SKIP_UNKNOWN) 7294 cctx->ctx_skip = cctx->ctx_skip == SKIP_YES ? SKIP_NOT : SKIP_YES; 7295 } 7296 7297 return p; 7298 } 7299 7300 static char_u * 7301 compile_endif(char_u *arg, cctx_T *cctx) 7302 { 7303 scope_T *scope = cctx->ctx_scope; 7304 ifscope_T *ifscope; 7305 garray_T *instr = &cctx->ctx_instr; 7306 isn_T *isn; 7307 7308 if (misplaced_cmdmod(cctx)) 7309 return NULL; 7310 7311 if (scope == NULL || scope->se_type != IF_SCOPE) 7312 { 7313 emsg(_(e_endif_without_if)); 7314 return NULL; 7315 } 7316 ifscope = &scope->se_u.se_if; 7317 unwind_locals(cctx, scope->se_local_count); 7318 if (!cctx->ctx_had_return) 7319 ifscope->is_had_return = FALSE; 7320 7321 if (scope->se_u.se_if.is_if_label >= 0) 7322 { 7323 // previous "if" or "elseif" jumps here 7324 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label; 7325 isn->isn_arg.jump.jump_where = instr->ga_len; 7326 } 7327 // Fill in the "end" label in jumps at the end of the blocks. 7328 compile_fill_jump_to_end(&ifscope->is_end_label, instr->ga_len, cctx); 7329 7330 #ifdef FEAT_PROFILE 7331 // even when skipping we count the endif as executed, unless the block it's 7332 // in is skipped 7333 if (cctx->ctx_profiling && cctx->ctx_skip == SKIP_YES 7334 && scope->se_skip_save != SKIP_YES) 7335 { 7336 cctx->ctx_skip = SKIP_NOT; 7337 generate_instr(cctx, ISN_PROF_START); 7338 } 7339 #endif 7340 cctx->ctx_skip = scope->se_skip_save; 7341 7342 // If all the blocks end in :return and there is an :else then the 7343 // had_return flag is set. 7344 cctx->ctx_had_return = ifscope->is_had_return && ifscope->is_seen_else; 7345 7346 drop_scope(cctx); 7347 return arg; 7348 } 7349 7350 /* 7351 * Compile "for var in expr": 7352 * 7353 * Produces instructions: 7354 * PUSHNR -1 7355 * STORE loop-idx Set index to -1 7356 * EVAL expr result of "expr" on top of stack 7357 * top: FOR loop-idx, end Increment index, use list on bottom of stack 7358 * - if beyond end, jump to "end" 7359 * - otherwise get item from list and push it 7360 * STORE var Store item in "var" 7361 * ... body ... 7362 * JUMP top Jump back to repeat 7363 * end: DROP Drop the result of "expr" 7364 * 7365 * Compile "for [var1, var2] in expr" - as above, but instead of "STORE var": 7366 * UNPACK 2 Split item in 2 7367 * STORE var1 Store item in "var1" 7368 * STORE var2 Store item in "var2" 7369 */ 7370 static char_u * 7371 compile_for(char_u *arg_start, cctx_T *cctx) 7372 { 7373 char_u *arg; 7374 char_u *arg_end; 7375 char_u *name = NULL; 7376 char_u *p; 7377 char_u *wp; 7378 int var_count = 0; 7379 int semicolon = FALSE; 7380 size_t varlen; 7381 garray_T *stack = &cctx->ctx_type_stack; 7382 scope_T *scope; 7383 lvar_T *loop_lvar; // loop iteration variable 7384 lvar_T *var_lvar; // variable for "var" 7385 type_T *vartype; 7386 type_T *item_type = &t_any; 7387 int idx; 7388 7389 p = skip_var_list(arg_start, TRUE, &var_count, &semicolon, FALSE); 7390 if (p == NULL) 7391 return NULL; 7392 if (var_count == 0) 7393 var_count = 1; 7394 7395 // consume "in" 7396 wp = p; 7397 if (may_get_next_line_error(wp, &p, cctx) == FAIL) 7398 return NULL; 7399 if (STRNCMP(p, "in", 2) != 0 || !IS_WHITE_OR_NUL(p[2])) 7400 { 7401 emsg(_(e_missing_in)); 7402 return NULL; 7403 } 7404 wp = p + 2; 7405 if (may_get_next_line_error(wp, &p, cctx) == FAIL) 7406 return NULL; 7407 7408 scope = new_scope(cctx, FOR_SCOPE); 7409 if (scope == NULL) 7410 return NULL; 7411 7412 // Reserve a variable to store the loop iteration counter and initialize it 7413 // to -1. 7414 loop_lvar = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number); 7415 if (loop_lvar == NULL) 7416 { 7417 // out of memory 7418 drop_scope(cctx); 7419 return NULL; 7420 } 7421 generate_STORENR(cctx, loop_lvar->lv_idx, -1); 7422 7423 // compile "expr", it remains on the stack until "endfor" 7424 arg = p; 7425 if (compile_expr0(&arg, cctx) == FAIL) 7426 { 7427 drop_scope(cctx); 7428 return NULL; 7429 } 7430 arg_end = arg; 7431 7432 // If we know the type of "var" and it is a not a list or string we can 7433 // give an error now. 7434 vartype = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 7435 if (vartype->tt_type != VAR_LIST && vartype->tt_type != VAR_STRING 7436 && vartype->tt_type != VAR_ANY) 7437 { 7438 // TODO: support Blob 7439 semsg(_(e_for_loop_on_str_not_supported), 7440 vartype_name(vartype->tt_type)); 7441 drop_scope(cctx); 7442 return NULL; 7443 } 7444 7445 if (vartype->tt_type == VAR_LIST && vartype->tt_member->tt_type != VAR_ANY) 7446 { 7447 if (var_count == 1) 7448 item_type = vartype->tt_member; 7449 else if (vartype->tt_member->tt_type == VAR_LIST 7450 && vartype->tt_member->tt_member->tt_type != VAR_ANY) 7451 item_type = vartype->tt_member->tt_member; 7452 } 7453 7454 // CMDMOD_REV must come before the FOR instruction 7455 generate_undo_cmdmods(cctx); 7456 7457 // "for_end" is set when ":endfor" is found 7458 scope->se_u.se_for.fs_top_label = current_instr_idx(cctx); 7459 generate_FOR(cctx, loop_lvar->lv_idx); 7460 7461 arg = arg_start; 7462 if (var_count > 1) 7463 { 7464 generate_UNPACK(cctx, var_count, semicolon); 7465 arg = skipwhite(arg + 1); // skip white after '[' 7466 7467 // the list item is replaced by a number of items 7468 if (ga_grow(stack, var_count - 1) == FAIL) 7469 { 7470 drop_scope(cctx); 7471 return NULL; 7472 } 7473 --stack->ga_len; 7474 for (idx = 0; idx < var_count; ++idx) 7475 { 7476 ((type_T **)stack->ga_data)[stack->ga_len] = 7477 (semicolon && idx == 0) ? vartype : item_type; 7478 ++stack->ga_len; 7479 } 7480 } 7481 7482 for (idx = 0; idx < var_count; ++idx) 7483 { 7484 assign_dest_T dest = dest_local; 7485 int opt_flags = 0; 7486 int vimvaridx = -1; 7487 type_T *type = &t_any; 7488 7489 p = skip_var_one(arg, FALSE); 7490 varlen = p - arg; 7491 name = vim_strnsave(arg, varlen); 7492 if (name == NULL) 7493 goto failed; 7494 7495 // TODO: script var not supported? 7496 if (get_var_dest(name, &dest, CMD_for, &opt_flags, 7497 &vimvaridx, &type, cctx) == FAIL) 7498 goto failed; 7499 if (dest != dest_local) 7500 { 7501 if (generate_store_var(cctx, dest, opt_flags, vimvaridx, 7502 0, 0, type, name) == FAIL) 7503 goto failed; 7504 } 7505 else 7506 { 7507 if (lookup_local(arg, varlen, NULL, cctx) == OK) 7508 { 7509 semsg(_(e_variable_already_declared), arg); 7510 goto failed; 7511 } 7512 7513 if (STRNCMP(name, "s:", 2) == 0) 7514 { 7515 semsg(_(e_cannot_declare_script_variable_in_function), name); 7516 goto failed; 7517 } 7518 7519 // Reserve a variable to store "var". 7520 // TODO: check for type 7521 var_lvar = reserve_local(cctx, arg, varlen, FALSE, &t_any); 7522 if (var_lvar == NULL) 7523 // out of memory or used as an argument 7524 goto failed; 7525 7526 if (semicolon && idx == var_count - 1) 7527 var_lvar->lv_type = vartype; 7528 else 7529 var_lvar->lv_type = item_type; 7530 generate_STORE(cctx, ISN_STORE, var_lvar->lv_idx, NULL); 7531 } 7532 7533 if (*p == ':') 7534 p = skip_type(skipwhite(p + 1), FALSE); 7535 if (*p == ',' || *p == ';') 7536 ++p; 7537 arg = skipwhite(p); 7538 vim_free(name); 7539 } 7540 7541 return arg_end; 7542 7543 failed: 7544 vim_free(name); 7545 drop_scope(cctx); 7546 return NULL; 7547 } 7548 7549 /* 7550 * compile "endfor" 7551 */ 7552 static char_u * 7553 compile_endfor(char_u *arg, cctx_T *cctx) 7554 { 7555 garray_T *instr = &cctx->ctx_instr; 7556 scope_T *scope = cctx->ctx_scope; 7557 forscope_T *forscope; 7558 isn_T *isn; 7559 7560 if (misplaced_cmdmod(cctx)) 7561 return NULL; 7562 7563 if (scope == NULL || scope->se_type != FOR_SCOPE) 7564 { 7565 emsg(_(e_for)); 7566 return NULL; 7567 } 7568 forscope = &scope->se_u.se_for; 7569 cctx->ctx_scope = scope->se_outer; 7570 unwind_locals(cctx, scope->se_local_count); 7571 7572 // At end of ":for" scope jump back to the FOR instruction. 7573 generate_JUMP(cctx, JUMP_ALWAYS, forscope->fs_top_label); 7574 7575 // Fill in the "end" label in the FOR statement so it can jump here 7576 isn = ((isn_T *)instr->ga_data) + forscope->fs_top_label; 7577 isn->isn_arg.forloop.for_end = instr->ga_len; 7578 7579 // Fill in the "end" label any BREAK statements 7580 compile_fill_jump_to_end(&forscope->fs_end_label, instr->ga_len, cctx); 7581 7582 // Below the ":for" scope drop the "expr" list from the stack. 7583 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL) 7584 return NULL; 7585 7586 vim_free(scope); 7587 7588 return arg; 7589 } 7590 7591 /* 7592 * compile "while expr" 7593 * 7594 * Produces instructions: 7595 * top: EVAL expr Push result of "expr" 7596 * JUMP_IF_FALSE end jump if false 7597 * ... body ... 7598 * JUMP top Jump back to repeat 7599 * end: 7600 * 7601 */ 7602 static char_u * 7603 compile_while(char_u *arg, cctx_T *cctx) 7604 { 7605 char_u *p = arg; 7606 scope_T *scope; 7607 7608 scope = new_scope(cctx, WHILE_SCOPE); 7609 if (scope == NULL) 7610 return NULL; 7611 7612 // "endwhile" jumps back here, one before when profiling or using cmdmods 7613 scope->se_u.se_while.ws_top_label = current_instr_idx(cctx); 7614 7615 // compile "expr" 7616 if (compile_expr0(&p, cctx) == FAIL) 7617 return NULL; 7618 if (!ends_excmd2(arg, skipwhite(p))) 7619 { 7620 semsg(_(e_trailing_arg), p); 7621 return NULL; 7622 } 7623 7624 if (bool_on_stack(cctx) == FAIL) 7625 return FAIL; 7626 7627 // CMDMOD_REV must come before the jump 7628 generate_undo_cmdmods(cctx); 7629 7630 // "while_end" is set when ":endwhile" is found 7631 if (compile_jump_to_end(&scope->se_u.se_while.ws_end_label, 7632 JUMP_IF_FALSE, cctx) == FAIL) 7633 return FAIL; 7634 7635 return p; 7636 } 7637 7638 /* 7639 * compile "endwhile" 7640 */ 7641 static char_u * 7642 compile_endwhile(char_u *arg, cctx_T *cctx) 7643 { 7644 scope_T *scope = cctx->ctx_scope; 7645 garray_T *instr = &cctx->ctx_instr; 7646 7647 if (misplaced_cmdmod(cctx)) 7648 return NULL; 7649 if (scope == NULL || scope->se_type != WHILE_SCOPE) 7650 { 7651 emsg(_(e_while)); 7652 return NULL; 7653 } 7654 cctx->ctx_scope = scope->se_outer; 7655 unwind_locals(cctx, scope->se_local_count); 7656 7657 #ifdef FEAT_PROFILE 7658 // count the endwhile before jumping 7659 may_generate_prof_end(cctx, cctx->ctx_lnum); 7660 #endif 7661 7662 // At end of ":for" scope jump back to the FOR instruction. 7663 generate_JUMP(cctx, JUMP_ALWAYS, scope->se_u.se_while.ws_top_label); 7664 7665 // Fill in the "end" label in the WHILE statement so it can jump here. 7666 // And in any jumps for ":break" 7667 compile_fill_jump_to_end(&scope->se_u.se_while.ws_end_label, 7668 instr->ga_len, cctx); 7669 7670 vim_free(scope); 7671 7672 return arg; 7673 } 7674 7675 /* 7676 * compile "continue" 7677 */ 7678 static char_u * 7679 compile_continue(char_u *arg, cctx_T *cctx) 7680 { 7681 scope_T *scope = cctx->ctx_scope; 7682 int try_scopes = 0; 7683 int loop_label; 7684 7685 for (;;) 7686 { 7687 if (scope == NULL) 7688 { 7689 emsg(_(e_continue)); 7690 return NULL; 7691 } 7692 if (scope->se_type == FOR_SCOPE) 7693 { 7694 loop_label = scope->se_u.se_for.fs_top_label; 7695 break; 7696 } 7697 if (scope->se_type == WHILE_SCOPE) 7698 { 7699 loop_label = scope->se_u.se_while.ws_top_label; 7700 break; 7701 } 7702 if (scope->se_type == TRY_SCOPE) 7703 ++try_scopes; 7704 scope = scope->se_outer; 7705 } 7706 7707 if (try_scopes > 0) 7708 // Inside one or more try/catch blocks we first need to jump to the 7709 // "finally" or "endtry" to cleanup. 7710 generate_TRYCONT(cctx, try_scopes, loop_label); 7711 else 7712 // Jump back to the FOR or WHILE instruction. 7713 generate_JUMP(cctx, JUMP_ALWAYS, loop_label); 7714 7715 return arg; 7716 } 7717 7718 /* 7719 * compile "break" 7720 */ 7721 static char_u * 7722 compile_break(char_u *arg, cctx_T *cctx) 7723 { 7724 scope_T *scope = cctx->ctx_scope; 7725 endlabel_T **el; 7726 7727 for (;;) 7728 { 7729 if (scope == NULL) 7730 { 7731 emsg(_(e_break)); 7732 return NULL; 7733 } 7734 if (scope->se_type == FOR_SCOPE || scope->se_type == WHILE_SCOPE) 7735 break; 7736 scope = scope->se_outer; 7737 } 7738 7739 // Jump to the end of the FOR or WHILE loop. 7740 if (scope->se_type == FOR_SCOPE) 7741 el = &scope->se_u.se_for.fs_end_label; 7742 else 7743 el = &scope->se_u.se_while.ws_end_label; 7744 if (compile_jump_to_end(el, JUMP_ALWAYS, cctx) == FAIL) 7745 return FAIL; 7746 7747 return arg; 7748 } 7749 7750 /* 7751 * compile "{" start of block 7752 */ 7753 static char_u * 7754 compile_block(char_u *arg, cctx_T *cctx) 7755 { 7756 if (new_scope(cctx, BLOCK_SCOPE) == NULL) 7757 return NULL; 7758 return skipwhite(arg + 1); 7759 } 7760 7761 /* 7762 * compile end of block: drop one scope 7763 */ 7764 static void 7765 compile_endblock(cctx_T *cctx) 7766 { 7767 scope_T *scope = cctx->ctx_scope; 7768 7769 cctx->ctx_scope = scope->se_outer; 7770 unwind_locals(cctx, scope->se_local_count); 7771 vim_free(scope); 7772 } 7773 7774 /* 7775 * compile "try" 7776 * Creates a new scope for the try-endtry, pointing to the first catch and 7777 * finally. 7778 * Creates another scope for the "try" block itself. 7779 * TRY instruction sets up exception handling at runtime. 7780 * 7781 * "try" 7782 * TRY -> catch1, -> finally push trystack entry 7783 * ... try block 7784 * "throw {exception}" 7785 * EVAL {exception} 7786 * THROW create exception 7787 * ... try block 7788 * " catch {expr}" 7789 * JUMP -> finally 7790 * catch1: PUSH exception 7791 * EVAL {expr} 7792 * MATCH 7793 * JUMP nomatch -> catch2 7794 * CATCH remove exception 7795 * ... catch block 7796 * " catch" 7797 * JUMP -> finally 7798 * catch2: CATCH remove exception 7799 * ... catch block 7800 * " finally" 7801 * finally: 7802 * ... finally block 7803 * " endtry" 7804 * ENDTRY pop trystack entry, may rethrow 7805 */ 7806 static char_u * 7807 compile_try(char_u *arg, cctx_T *cctx) 7808 { 7809 garray_T *instr = &cctx->ctx_instr; 7810 scope_T *try_scope; 7811 scope_T *scope; 7812 7813 if (misplaced_cmdmod(cctx)) 7814 return NULL; 7815 7816 // scope that holds the jumps that go to catch/finally/endtry 7817 try_scope = new_scope(cctx, TRY_SCOPE); 7818 if (try_scope == NULL) 7819 return NULL; 7820 7821 if (cctx->ctx_skip != SKIP_YES) 7822 { 7823 isn_T *isn; 7824 7825 // "try_catch" is set when the first ":catch" is found or when no catch 7826 // is found and ":finally" is found. 7827 // "try_finally" is set when ":finally" is found 7828 // "try_endtry" is set when ":endtry" is found 7829 try_scope->se_u.se_try.ts_try_label = instr->ga_len; 7830 if ((isn = generate_instr(cctx, ISN_TRY)) == NULL) 7831 return NULL; 7832 isn->isn_arg.try.try_ref = ALLOC_CLEAR_ONE(tryref_T); 7833 if (isn->isn_arg.try.try_ref == NULL) 7834 return NULL; 7835 } 7836 7837 // scope for the try block itself 7838 scope = new_scope(cctx, BLOCK_SCOPE); 7839 if (scope == NULL) 7840 return NULL; 7841 7842 return arg; 7843 } 7844 7845 /* 7846 * compile "catch {expr}" 7847 */ 7848 static char_u * 7849 compile_catch(char_u *arg, cctx_T *cctx UNUSED) 7850 { 7851 scope_T *scope = cctx->ctx_scope; 7852 garray_T *instr = &cctx->ctx_instr; 7853 char_u *p; 7854 isn_T *isn; 7855 7856 if (misplaced_cmdmod(cctx)) 7857 return NULL; 7858 7859 // end block scope from :try or :catch 7860 if (scope != NULL && scope->se_type == BLOCK_SCOPE) 7861 compile_endblock(cctx); 7862 scope = cctx->ctx_scope; 7863 7864 // Error if not in a :try scope 7865 if (scope == NULL || scope->se_type != TRY_SCOPE) 7866 { 7867 emsg(_(e_catch)); 7868 return NULL; 7869 } 7870 7871 if (scope->se_u.se_try.ts_caught_all) 7872 { 7873 emsg(_(e_catch_unreachable_after_catch_all)); 7874 return NULL; 7875 } 7876 7877 if (cctx->ctx_skip != SKIP_YES) 7878 { 7879 #ifdef FEAT_PROFILE 7880 // the profile-start should be after the jump 7881 if (cctx->ctx_profiling && ((isn_T *)instr->ga_data)[instr->ga_len - 1] 7882 .isn_type == ISN_PROF_START) 7883 --instr->ga_len; 7884 #endif 7885 // Jump from end of previous block to :finally or :endtry 7886 if (compile_jump_to_end(&scope->se_u.se_try.ts_end_label, 7887 JUMP_ALWAYS, cctx) == FAIL) 7888 return NULL; 7889 7890 // End :try or :catch scope: set value in ISN_TRY instruction 7891 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label; 7892 if (isn->isn_arg.try.try_ref->try_catch == 0) 7893 isn->isn_arg.try.try_ref->try_catch = instr->ga_len; 7894 if (scope->se_u.se_try.ts_catch_label != 0) 7895 { 7896 // Previous catch without match jumps here 7897 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label; 7898 isn->isn_arg.jump.jump_where = instr->ga_len; 7899 } 7900 #ifdef FEAT_PROFILE 7901 if (cctx->ctx_profiling) 7902 { 7903 // a "throw" that jumps here needs to be counted 7904 generate_instr(cctx, ISN_PROF_END); 7905 // the "catch" is also counted 7906 generate_instr(cctx, ISN_PROF_START); 7907 } 7908 #endif 7909 } 7910 7911 p = skipwhite(arg); 7912 if (ends_excmd2(arg, p)) 7913 { 7914 scope->se_u.se_try.ts_caught_all = TRUE; 7915 scope->se_u.se_try.ts_catch_label = 0; 7916 } 7917 else 7918 { 7919 char_u *end; 7920 char_u *pat; 7921 char_u *tofree = NULL; 7922 int dropped = 0; 7923 int len; 7924 7925 // Push v:exception, push {expr} and MATCH 7926 generate_instr_type(cctx, ISN_PUSHEXC, &t_string); 7927 7928 end = skip_regexp_ex(p + 1, *p, TRUE, &tofree, &dropped, NULL); 7929 if (*end != *p) 7930 { 7931 semsg(_(e_separator_mismatch_str), p); 7932 vim_free(tofree); 7933 return FAIL; 7934 } 7935 if (tofree == NULL) 7936 len = (int)(end - (p + 1)); 7937 else 7938 len = (int)(end - tofree); 7939 pat = vim_strnsave(tofree == NULL ? p + 1 : tofree, len); 7940 vim_free(tofree); 7941 p += len + 2 + dropped; 7942 if (pat == NULL) 7943 return FAIL; 7944 if (generate_PUSHS(cctx, pat) == FAIL) 7945 return FAIL; 7946 7947 if (generate_COMPARE(cctx, EXPR_MATCH, FALSE) == FAIL) 7948 return NULL; 7949 7950 scope->se_u.se_try.ts_catch_label = instr->ga_len; 7951 if (generate_JUMP(cctx, JUMP_IF_FALSE, 0) == FAIL) 7952 return NULL; 7953 } 7954 7955 if (cctx->ctx_skip != SKIP_YES && generate_instr(cctx, ISN_CATCH) == NULL) 7956 return NULL; 7957 7958 if (new_scope(cctx, BLOCK_SCOPE) == NULL) 7959 return NULL; 7960 return p; 7961 } 7962 7963 static char_u * 7964 compile_finally(char_u *arg, cctx_T *cctx) 7965 { 7966 scope_T *scope = cctx->ctx_scope; 7967 garray_T *instr = &cctx->ctx_instr; 7968 isn_T *isn; 7969 int this_instr; 7970 7971 if (misplaced_cmdmod(cctx)) 7972 return NULL; 7973 7974 // end block scope from :try or :catch 7975 if (scope != NULL && scope->se_type == BLOCK_SCOPE) 7976 compile_endblock(cctx); 7977 scope = cctx->ctx_scope; 7978 7979 // Error if not in a :try scope 7980 if (scope == NULL || scope->se_type != TRY_SCOPE) 7981 { 7982 emsg(_(e_finally)); 7983 return NULL; 7984 } 7985 7986 // End :catch or :finally scope: set value in ISN_TRY instruction 7987 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label; 7988 if (isn->isn_arg.try.try_ref->try_finally != 0) 7989 { 7990 emsg(_(e_finally_dup)); 7991 return NULL; 7992 } 7993 7994 this_instr = instr->ga_len; 7995 #ifdef FEAT_PROFILE 7996 if (cctx->ctx_profiling && ((isn_T *)instr->ga_data)[instr->ga_len - 1] 7997 .isn_type == ISN_PROF_START) 7998 // jump to the profile start of the "finally" 7999 --this_instr; 8000 #endif 8001 8002 // Fill in the "end" label in jumps at the end of the blocks. 8003 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, 8004 this_instr, cctx); 8005 8006 // If there is no :catch then an exception jumps to :finally. 8007 if (isn->isn_arg.try.try_ref->try_catch == 0) 8008 isn->isn_arg.try.try_ref->try_catch = this_instr; 8009 isn->isn_arg.try.try_ref->try_finally = this_instr; 8010 if (scope->se_u.se_try.ts_catch_label != 0) 8011 { 8012 // Previous catch without match jumps here 8013 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label; 8014 isn->isn_arg.jump.jump_where = this_instr; 8015 scope->se_u.se_try.ts_catch_label = 0; 8016 } 8017 if (generate_instr(cctx, ISN_FINALLY) == NULL) 8018 return NULL; 8019 8020 // TODO: set index in ts_finally_label jumps 8021 8022 return arg; 8023 } 8024 8025 static char_u * 8026 compile_endtry(char_u *arg, cctx_T *cctx) 8027 { 8028 scope_T *scope = cctx->ctx_scope; 8029 garray_T *instr = &cctx->ctx_instr; 8030 isn_T *try_isn; 8031 8032 if (misplaced_cmdmod(cctx)) 8033 return NULL; 8034 8035 // end block scope from :catch or :finally 8036 if (scope != NULL && scope->se_type == BLOCK_SCOPE) 8037 compile_endblock(cctx); 8038 scope = cctx->ctx_scope; 8039 8040 // Error if not in a :try scope 8041 if (scope == NULL || scope->se_type != TRY_SCOPE) 8042 { 8043 if (scope == NULL) 8044 emsg(_(e_no_endtry)); 8045 else if (scope->se_type == WHILE_SCOPE) 8046 emsg(_(e_endwhile)); 8047 else if (scope->se_type == FOR_SCOPE) 8048 emsg(_(e_endfor)); 8049 else 8050 emsg(_(e_endif)); 8051 return NULL; 8052 } 8053 8054 try_isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label; 8055 if (cctx->ctx_skip != SKIP_YES) 8056 { 8057 if (try_isn->isn_arg.try.try_ref->try_catch == 0 8058 && try_isn->isn_arg.try.try_ref->try_finally == 0) 8059 { 8060 emsg(_(e_missing_catch_or_finally)); 8061 return NULL; 8062 } 8063 8064 #ifdef FEAT_PROFILE 8065 if (cctx->ctx_profiling && ((isn_T *)instr->ga_data)[instr->ga_len - 1] 8066 .isn_type == ISN_PROF_START) 8067 // move the profile start after "endtry" so that it's not counted when 8068 // the exception is rethrown. 8069 --instr->ga_len; 8070 #endif 8071 8072 // Fill in the "end" label in jumps at the end of the blocks, if not 8073 // done by ":finally". 8074 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, 8075 instr->ga_len, cctx); 8076 8077 if (scope->se_u.se_try.ts_catch_label != 0) 8078 { 8079 // Last catch without match jumps here 8080 isn_T *isn = ((isn_T *)instr->ga_data) 8081 + scope->se_u.se_try.ts_catch_label; 8082 isn->isn_arg.jump.jump_where = instr->ga_len; 8083 } 8084 } 8085 8086 compile_endblock(cctx); 8087 8088 if (cctx->ctx_skip != SKIP_YES) 8089 { 8090 // End :catch or :finally scope: set instruction index in ISN_TRY 8091 // instruction 8092 try_isn->isn_arg.try.try_ref->try_endtry = instr->ga_len; 8093 if (cctx->ctx_skip != SKIP_YES 8094 && generate_instr(cctx, ISN_ENDTRY) == NULL) 8095 return NULL; 8096 #ifdef FEAT_PROFILE 8097 if (cctx->ctx_profiling) 8098 generate_instr(cctx, ISN_PROF_START); 8099 #endif 8100 } 8101 return arg; 8102 } 8103 8104 /* 8105 * compile "throw {expr}" 8106 */ 8107 static char_u * 8108 compile_throw(char_u *arg, cctx_T *cctx UNUSED) 8109 { 8110 char_u *p = skipwhite(arg); 8111 8112 if (compile_expr0(&p, cctx) == FAIL) 8113 return NULL; 8114 if (cctx->ctx_skip == SKIP_YES) 8115 return p; 8116 if (may_generate_2STRING(-1, cctx) == FAIL) 8117 return NULL; 8118 if (generate_instr_drop(cctx, ISN_THROW, 1) == NULL) 8119 return NULL; 8120 8121 return p; 8122 } 8123 8124 /* 8125 * compile "echo expr" 8126 * compile "echomsg expr" 8127 * compile "echoerr expr" 8128 * compile "execute expr" 8129 */ 8130 static char_u * 8131 compile_mult_expr(char_u *arg, int cmdidx, cctx_T *cctx) 8132 { 8133 char_u *p = arg; 8134 char_u *prev = arg; 8135 int count = 0; 8136 8137 for (;;) 8138 { 8139 if (ends_excmd2(prev, p)) 8140 break; 8141 if (compile_expr0(&p, cctx) == FAIL) 8142 return NULL; 8143 ++count; 8144 prev = p; 8145 p = skipwhite(p); 8146 } 8147 8148 if (count > 0) 8149 { 8150 if (cmdidx == CMD_echo || cmdidx == CMD_echon) 8151 generate_ECHO(cctx, cmdidx == CMD_echo, count); 8152 else if (cmdidx == CMD_execute) 8153 generate_MULT_EXPR(cctx, ISN_EXECUTE, count); 8154 else if (cmdidx == CMD_echomsg) 8155 generate_MULT_EXPR(cctx, ISN_ECHOMSG, count); 8156 else 8157 generate_MULT_EXPR(cctx, ISN_ECHOERR, count); 8158 } 8159 return p; 8160 } 8161 8162 /* 8163 * If "eap" has a range that is not a constant generate an ISN_RANGE 8164 * instruction to compute it and return OK. 8165 * Otherwise return FAIL, the caller must deal with any range. 8166 */ 8167 static int 8168 compile_variable_range(exarg_T *eap, cctx_T *cctx) 8169 { 8170 char_u *range_end = skip_range(eap->cmd, TRUE, NULL); 8171 char_u *p = skipdigits(eap->cmd); 8172 8173 if (p == range_end) 8174 return FAIL; 8175 return generate_RANGE(cctx, vim_strnsave(eap->cmd, range_end - eap->cmd)); 8176 } 8177 8178 /* 8179 * :put r 8180 * :put ={expr} 8181 */ 8182 static char_u * 8183 compile_put(char_u *arg, exarg_T *eap, cctx_T *cctx) 8184 { 8185 char_u *line = arg; 8186 linenr_T lnum; 8187 char *errormsg; 8188 int above = eap->forceit; 8189 8190 eap->regname = *line; 8191 8192 if (eap->regname == '=') 8193 { 8194 char_u *p = line + 1; 8195 8196 if (compile_expr0(&p, cctx) == FAIL) 8197 return NULL; 8198 line = p; 8199 } 8200 else if (eap->regname != NUL) 8201 ++line; 8202 8203 if (compile_variable_range(eap, cctx) == OK) 8204 { 8205 lnum = above ? LNUM_VARIABLE_RANGE_ABOVE : LNUM_VARIABLE_RANGE; 8206 } 8207 else 8208 { 8209 // Either no range or a number. 8210 // "errormsg" will not be set because the range is ADDR_LINES. 8211 if (parse_cmd_address(eap, &errormsg, FALSE) == FAIL) 8212 // cannot happen 8213 return NULL; 8214 if (eap->addr_count == 0) 8215 lnum = -1; 8216 else 8217 lnum = eap->line2; 8218 if (above) 8219 --lnum; 8220 } 8221 8222 generate_PUT(cctx, eap->regname, lnum); 8223 return line; 8224 } 8225 8226 /* 8227 * A command that is not compiled, execute with legacy code. 8228 */ 8229 static char_u * 8230 compile_exec(char_u *line, exarg_T *eap, cctx_T *cctx) 8231 { 8232 char_u *p; 8233 int has_expr = FALSE; 8234 char_u *nextcmd = (char_u *)""; 8235 8236 if (cctx->ctx_skip == SKIP_YES) 8237 goto theend; 8238 8239 if (eap->cmdidx >= 0 && eap->cmdidx < CMD_SIZE) 8240 { 8241 long argt = eap->argt; 8242 int usefilter = FALSE; 8243 8244 has_expr = argt & (EX_XFILE | EX_EXPAND); 8245 8246 // If the command can be followed by a bar, find the bar and truncate 8247 // it, so that the following command can be compiled. 8248 // The '|' is overwritten with a NUL, it is put back below. 8249 if ((eap->cmdidx == CMD_write || eap->cmdidx == CMD_read) 8250 && *eap->arg == '!') 8251 // :w !filter or :r !filter or :r! filter 8252 usefilter = TRUE; 8253 if ((argt & EX_TRLBAR) && !usefilter) 8254 { 8255 eap->argt = argt; 8256 separate_nextcmd(eap); 8257 if (eap->nextcmd != NULL) 8258 nextcmd = eap->nextcmd; 8259 } 8260 else if (eap->cmdidx == CMD_wincmd) 8261 { 8262 p = eap->arg; 8263 if (*p != NUL) 8264 ++p; 8265 if (*p == 'g' || *p == Ctrl_G) 8266 ++p; 8267 p = skipwhite(p); 8268 if (*p == '|') 8269 { 8270 *p = NUL; 8271 nextcmd = p + 1; 8272 } 8273 } 8274 } 8275 8276 if (eap->cmdidx == CMD_syntax && STRNCMP(eap->arg, "include ", 8) == 0) 8277 { 8278 // expand filename in "syntax include [@group] filename" 8279 has_expr = TRUE; 8280 eap->arg = skipwhite(eap->arg + 7); 8281 if (*eap->arg == '@') 8282 eap->arg = skiptowhite(eap->arg); 8283 } 8284 8285 if ((eap->cmdidx == CMD_global || eap->cmdidx == CMD_vglobal) 8286 && STRLEN(eap->arg) > 4) 8287 { 8288 int delim = *eap->arg; 8289 8290 p = skip_regexp_ex(eap->arg + 1, delim, TRUE, NULL, NULL, NULL); 8291 if (*p == delim) 8292 { 8293 eap->arg = p + 1; 8294 has_expr = TRUE; 8295 } 8296 } 8297 8298 if (eap->cmdidx == CMD_folddoopen || eap->cmdidx == CMD_folddoclosed) 8299 { 8300 // TODO: should only expand when appropriate for the command 8301 eap->arg = skiptowhite(eap->arg); 8302 has_expr = TRUE; 8303 } 8304 8305 if (has_expr && (p = (char_u *)strstr((char *)eap->arg, "`=")) != NULL) 8306 { 8307 int count = 0; 8308 char_u *start = skipwhite(line); 8309 8310 // :cmd xxx`=expr1`yyy`=expr2`zzz 8311 // PUSHS ":cmd xxx" 8312 // eval expr1 8313 // PUSHS "yyy" 8314 // eval expr2 8315 // PUSHS "zzz" 8316 // EXECCONCAT 5 8317 for (;;) 8318 { 8319 if (p > start) 8320 { 8321 generate_PUSHS(cctx, vim_strnsave(start, p - start)); 8322 ++count; 8323 } 8324 p += 2; 8325 if (compile_expr0(&p, cctx) == FAIL) 8326 return NULL; 8327 may_generate_2STRING(-1, cctx); 8328 ++count; 8329 p = skipwhite(p); 8330 if (*p != '`') 8331 { 8332 emsg(_(e_missing_backtick)); 8333 return NULL; 8334 } 8335 start = p + 1; 8336 8337 p = (char_u *)strstr((char *)start, "`="); 8338 if (p == NULL) 8339 { 8340 if (*skipwhite(start) != NUL) 8341 { 8342 generate_PUSHS(cctx, vim_strsave(start)); 8343 ++count; 8344 } 8345 break; 8346 } 8347 } 8348 generate_EXECCONCAT(cctx, count); 8349 } 8350 else 8351 generate_EXEC(cctx, line); 8352 8353 theend: 8354 if (*nextcmd != NUL) 8355 { 8356 // the parser expects a pointer to the bar, put it back 8357 --nextcmd; 8358 *nextcmd = '|'; 8359 } 8360 8361 return nextcmd; 8362 } 8363 8364 /* 8365 * Add a function to the list of :def functions. 8366 * This sets "ufunc->uf_dfunc_idx" but the function isn't compiled yet. 8367 */ 8368 static int 8369 add_def_function(ufunc_T *ufunc) 8370 { 8371 dfunc_T *dfunc; 8372 8373 if (def_functions.ga_len == 0) 8374 { 8375 // The first position is not used, so that a zero uf_dfunc_idx means it 8376 // wasn't set. 8377 if (ga_grow(&def_functions, 1) == FAIL) 8378 return FAIL; 8379 ++def_functions.ga_len; 8380 } 8381 8382 // Add the function to "def_functions". 8383 if (ga_grow(&def_functions, 1) == FAIL) 8384 return FAIL; 8385 dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len; 8386 CLEAR_POINTER(dfunc); 8387 dfunc->df_idx = def_functions.ga_len; 8388 ufunc->uf_dfunc_idx = dfunc->df_idx; 8389 dfunc->df_ufunc = ufunc; 8390 dfunc->df_name = vim_strsave(ufunc->uf_name); 8391 ++dfunc->df_refcount; 8392 ++def_functions.ga_len; 8393 return OK; 8394 } 8395 8396 /* 8397 * After ex_function() has collected all the function lines: parse and compile 8398 * the lines into instructions. 8399 * Adds the function to "def_functions". 8400 * When "check_return_type" is set then set ufunc->uf_ret_type to the type of 8401 * the return statement (used for lambda). When uf_ret_type is already set 8402 * then check that it matches. 8403 * When "profiling" is true add ISN_PROF_START instructions. 8404 * "outer_cctx" is set for a nested function. 8405 * This can be used recursively through compile_lambda(), which may reallocate 8406 * "def_functions". 8407 * Returns OK or FAIL. 8408 */ 8409 int 8410 compile_def_function( 8411 ufunc_T *ufunc, 8412 int check_return_type, 8413 int profiling UNUSED, 8414 cctx_T *outer_cctx) 8415 { 8416 char_u *line = NULL; 8417 char_u *p; 8418 char *errormsg = NULL; // error message 8419 cctx_T cctx; 8420 garray_T *instr; 8421 int did_emsg_before = did_emsg; 8422 int ret = FAIL; 8423 sctx_T save_current_sctx = current_sctx; 8424 int save_estack_compiling = estack_compiling; 8425 int do_estack_push; 8426 int new_def_function = FALSE; 8427 #ifdef FEAT_PROFILE 8428 int prof_lnum = -1; 8429 #endif 8430 8431 // When using a function that was compiled before: Free old instructions. 8432 // The index is reused. Otherwise add a new entry in "def_functions". 8433 if (ufunc->uf_dfunc_idx > 0) 8434 { 8435 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 8436 + ufunc->uf_dfunc_idx; 8437 delete_def_function_contents(dfunc, FALSE); 8438 } 8439 else 8440 { 8441 if (add_def_function(ufunc) == FAIL) 8442 return FAIL; 8443 new_def_function = TRUE; 8444 } 8445 8446 ufunc->uf_def_status = UF_COMPILING; 8447 8448 CLEAR_FIELD(cctx); 8449 8450 #ifdef FEAT_PROFILE 8451 cctx.ctx_profiling = profiling; 8452 #endif 8453 cctx.ctx_ufunc = ufunc; 8454 cctx.ctx_lnum = -1; 8455 cctx.ctx_outer = outer_cctx; 8456 ga_init2(&cctx.ctx_locals, sizeof(lvar_T), 10); 8457 ga_init2(&cctx.ctx_type_stack, sizeof(type_T *), 50); 8458 ga_init2(&cctx.ctx_imports, sizeof(imported_T), 10); 8459 cctx.ctx_type_list = &ufunc->uf_type_list; 8460 ga_init2(&cctx.ctx_instr, sizeof(isn_T), 50); 8461 instr = &cctx.ctx_instr; 8462 8463 // Set the context to the function, it may be compiled when called from 8464 // another script. Set the script version to the most modern one. 8465 // The line number will be set in next_line_from_context(). 8466 current_sctx = ufunc->uf_script_ctx; 8467 current_sctx.sc_version = SCRIPT_VERSION_VIM9; 8468 8469 // Make sure error messages are OK. 8470 do_estack_push = !estack_top_is_ufunc(ufunc, 1); 8471 if (do_estack_push) 8472 estack_push_ufunc(ufunc, 1); 8473 estack_compiling = TRUE; 8474 8475 if (ufunc->uf_def_args.ga_len > 0) 8476 { 8477 int count = ufunc->uf_def_args.ga_len; 8478 int first_def_arg = ufunc->uf_args.ga_len - count; 8479 int uf_args_len = ufunc->uf_args.ga_len; 8480 int i; 8481 char_u *arg; 8482 int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0); 8483 int did_set_arg_type = FALSE; 8484 8485 // Produce instructions for the default values of optional arguments. 8486 SOURCING_LNUM = 0; // line number unknown 8487 for (i = 0; i < count; ++i) 8488 { 8489 garray_T *stack = &cctx.ctx_type_stack; 8490 type_T *val_type; 8491 int arg_idx = first_def_arg + i; 8492 where_T where; 8493 int r; 8494 int jump_instr_idx = instr->ga_len; 8495 isn_T *isn; 8496 8497 // Use a JUMP_IF_ARG_SET instruction to skip if the value was given. 8498 if (generate_JUMP_IF_ARG_SET(&cctx, i - count - off) == FAIL) 8499 goto erret; 8500 8501 // Make sure later arguments are not found. 8502 ufunc->uf_args.ga_len = i; 8503 8504 arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i]; 8505 r = compile_expr0(&arg, &cctx); 8506 8507 ufunc->uf_args.ga_len = uf_args_len; 8508 if (r == FAIL) 8509 goto erret; 8510 8511 // If no type specified use the type of the default value. 8512 // Otherwise check that the default value type matches the 8513 // specified type. 8514 val_type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 8515 where.wt_index = arg_idx + 1; 8516 where.wt_variable = FALSE; 8517 if (ufunc->uf_arg_types[arg_idx] == &t_unknown) 8518 { 8519 did_set_arg_type = TRUE; 8520 ufunc->uf_arg_types[arg_idx] = val_type; 8521 } 8522 else if (check_type(ufunc->uf_arg_types[arg_idx], val_type, 8523 TRUE, where) == FAIL) 8524 goto erret; 8525 8526 if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL) 8527 goto erret; 8528 8529 // set instruction index in JUMP_IF_ARG_SET to here 8530 isn = ((isn_T *)instr->ga_data) + jump_instr_idx; 8531 isn->isn_arg.jumparg.jump_where = instr->ga_len; 8532 } 8533 8534 if (did_set_arg_type) 8535 set_function_type(ufunc); 8536 } 8537 8538 /* 8539 * Loop over all the lines of the function and generate instructions. 8540 */ 8541 for (;;) 8542 { 8543 exarg_T ea; 8544 int starts_with_colon = FALSE; 8545 char_u *cmd; 8546 cmdmod_T local_cmdmod; 8547 8548 // Bail out on the first error to avoid a flood of errors and report 8549 // the right line number when inside try/catch. 8550 if (did_emsg_before != did_emsg) 8551 goto erret; 8552 8553 if (line != NULL && *line == '|') 8554 // the line continues after a '|' 8555 ++line; 8556 else if (line != NULL && *skipwhite(line) != NUL 8557 && !(*line == '#' && (line == cctx.ctx_line_start 8558 || VIM_ISWHITE(line[-1])))) 8559 { 8560 semsg(_(e_trailing_arg), line); 8561 goto erret; 8562 } 8563 else if (line != NULL && vim9_bad_comment(skipwhite(line))) 8564 goto erret; 8565 else 8566 { 8567 line = next_line_from_context(&cctx, FALSE); 8568 if (cctx.ctx_lnum >= ufunc->uf_lines.ga_len) 8569 { 8570 // beyond the last line 8571 #ifdef FEAT_PROFILE 8572 if (cctx.ctx_skip != SKIP_YES) 8573 may_generate_prof_end(&cctx, prof_lnum); 8574 #endif 8575 break; 8576 } 8577 } 8578 8579 CLEAR_FIELD(ea); 8580 ea.cmdlinep = &line; 8581 ea.cmd = skipwhite(line); 8582 8583 if (*ea.cmd == '#') 8584 { 8585 // "#" starts a comment 8586 line = (char_u *)""; 8587 continue; 8588 } 8589 8590 #ifdef FEAT_PROFILE 8591 if (cctx.ctx_profiling && cctx.ctx_lnum != prof_lnum && 8592 cctx.ctx_skip != SKIP_YES) 8593 { 8594 may_generate_prof_end(&cctx, prof_lnum); 8595 8596 prof_lnum = cctx.ctx_lnum; 8597 generate_instr(&cctx, ISN_PROF_START); 8598 } 8599 #endif 8600 8601 // Some things can be recognized by the first character. 8602 switch (*ea.cmd) 8603 { 8604 case '}': 8605 { 8606 // "}" ends a block scope 8607 scopetype_T stype = cctx.ctx_scope == NULL 8608 ? NO_SCOPE : cctx.ctx_scope->se_type; 8609 8610 if (stype == BLOCK_SCOPE) 8611 { 8612 compile_endblock(&cctx); 8613 line = ea.cmd; 8614 } 8615 else 8616 { 8617 emsg(_(e_using_rcurly_outside_if_block_scope)); 8618 goto erret; 8619 } 8620 if (line != NULL) 8621 line = skipwhite(ea.cmd + 1); 8622 continue; 8623 } 8624 8625 case '{': 8626 // "{" starts a block scope 8627 // "{'a': 1}->func() is something else 8628 if (ends_excmd(*skipwhite(ea.cmd + 1))) 8629 { 8630 line = compile_block(ea.cmd, &cctx); 8631 continue; 8632 } 8633 break; 8634 } 8635 8636 /* 8637 * COMMAND MODIFIERS 8638 */ 8639 cctx.ctx_has_cmdmod = FALSE; 8640 if (parse_command_modifiers(&ea, &errormsg, &local_cmdmod, FALSE) 8641 == FAIL) 8642 { 8643 if (errormsg != NULL) 8644 goto erret; 8645 // empty line or comment 8646 line = (char_u *)""; 8647 continue; 8648 } 8649 generate_cmdmods(&cctx, &local_cmdmod); 8650 undo_cmdmod(&local_cmdmod); 8651 8652 // Check if there was a colon after the last command modifier or before 8653 // the current position. 8654 for (p = ea.cmd; p >= line; --p) 8655 { 8656 if (*p == ':') 8657 starts_with_colon = TRUE; 8658 if (p < ea.cmd && !VIM_ISWHITE(*p)) 8659 break; 8660 } 8661 8662 // Skip ":call" to get to the function name. 8663 p = ea.cmd; 8664 if (checkforcmd(&ea.cmd, "call", 3)) 8665 { 8666 if (*ea.cmd == '(') 8667 // not for "call()" 8668 ea.cmd = p; 8669 else 8670 ea.cmd = skipwhite(ea.cmd); 8671 } 8672 8673 if (!starts_with_colon) 8674 { 8675 int assign; 8676 8677 // Check for assignment after command modifiers. 8678 assign = may_compile_assignment(&ea, &line, &cctx); 8679 if (assign == OK) 8680 goto nextline; 8681 if (assign == FAIL) 8682 goto erret; 8683 } 8684 8685 /* 8686 * COMMAND after range 8687 * 'text'->func() should not be confused with 'a mark 8688 */ 8689 cmd = ea.cmd; 8690 if (*cmd != '\'' || starts_with_colon) 8691 { 8692 ea.cmd = skip_range(ea.cmd, TRUE, NULL); 8693 if (ea.cmd > cmd) 8694 { 8695 if (!starts_with_colon) 8696 { 8697 semsg(_(e_colon_required_before_range_str), cmd); 8698 goto erret; 8699 } 8700 ea.addr_count = 1; 8701 if (ends_excmd2(line, ea.cmd)) 8702 { 8703 // A range without a command: jump to the line. 8704 // TODO: compile to a more efficient command, possibly 8705 // calling parse_cmd_address(). 8706 ea.cmdidx = CMD_SIZE; 8707 line = compile_exec(line, &ea, &cctx); 8708 goto nextline; 8709 } 8710 } 8711 } 8712 p = find_ex_command(&ea, NULL, starts_with_colon 8713 ? NULL : item_exists, &cctx); 8714 8715 if (p == NULL) 8716 { 8717 if (cctx.ctx_skip != SKIP_YES) 8718 emsg(_(e_ambiguous_use_of_user_defined_command)); 8719 goto erret; 8720 } 8721 8722 if (p == ea.cmd && ea.cmdidx != CMD_SIZE) 8723 { 8724 if (cctx.ctx_skip == SKIP_YES) 8725 { 8726 line += STRLEN(line); 8727 goto nextline; 8728 } 8729 8730 // Expression or function call. 8731 if (ea.cmdidx != CMD_eval) 8732 { 8733 // CMD_var cannot happen, compile_assignment() above would be 8734 // used. Most likely an assignment to a non-existing variable. 8735 semsg(_(e_command_not_recognized_str), ea.cmd); 8736 goto erret; 8737 } 8738 } 8739 8740 if (cctx.ctx_had_return 8741 && ea.cmdidx != CMD_elseif 8742 && ea.cmdidx != CMD_else 8743 && ea.cmdidx != CMD_endif 8744 && ea.cmdidx != CMD_endfor 8745 && ea.cmdidx != CMD_endwhile 8746 && ea.cmdidx != CMD_catch 8747 && ea.cmdidx != CMD_finally 8748 && ea.cmdidx != CMD_endtry) 8749 { 8750 emsg(_(e_unreachable_code_after_return)); 8751 goto erret; 8752 } 8753 8754 p = skipwhite(p); 8755 if (ea.cmdidx != CMD_SIZE 8756 && ea.cmdidx != CMD_write && ea.cmdidx != CMD_read) 8757 { 8758 if (ea.cmdidx >= 0) 8759 ea.argt = excmd_get_argt(ea.cmdidx); 8760 if ((ea.argt & EX_BANG) && *p == '!') 8761 { 8762 ea.forceit = TRUE; 8763 p = skipwhite(p + 1); 8764 } 8765 } 8766 8767 switch (ea.cmdidx) 8768 { 8769 case CMD_def: 8770 ea.arg = p; 8771 line = compile_nested_function(&ea, &cctx); 8772 break; 8773 8774 case CMD_function: 8775 // TODO: should we allow this, e.g. to declare a global 8776 // function? 8777 emsg(_(e_cannot_use_function_inside_def)); 8778 goto erret; 8779 8780 case CMD_return: 8781 line = compile_return(p, check_return_type, &cctx); 8782 cctx.ctx_had_return = TRUE; 8783 break; 8784 8785 case CMD_let: 8786 emsg(_(e_cannot_use_let_in_vim9_script)); 8787 break; 8788 case CMD_var: 8789 case CMD_final: 8790 case CMD_const: 8791 line = compile_assignment(p, &ea, ea.cmdidx, &cctx); 8792 if (line == p) 8793 line = NULL; 8794 break; 8795 8796 case CMD_unlet: 8797 case CMD_unlockvar: 8798 case CMD_lockvar: 8799 line = compile_unletlock(p, &ea, &cctx); 8800 break; 8801 8802 case CMD_import: 8803 line = compile_import(p, &cctx); 8804 break; 8805 8806 case CMD_if: 8807 line = compile_if(p, &cctx); 8808 break; 8809 case CMD_elseif: 8810 line = compile_elseif(p, &cctx); 8811 cctx.ctx_had_return = FALSE; 8812 break; 8813 case CMD_else: 8814 line = compile_else(p, &cctx); 8815 cctx.ctx_had_return = FALSE; 8816 break; 8817 case CMD_endif: 8818 line = compile_endif(p, &cctx); 8819 break; 8820 8821 case CMD_while: 8822 line = compile_while(p, &cctx); 8823 break; 8824 case CMD_endwhile: 8825 line = compile_endwhile(p, &cctx); 8826 cctx.ctx_had_return = FALSE; 8827 break; 8828 8829 case CMD_for: 8830 line = compile_for(p, &cctx); 8831 break; 8832 case CMD_endfor: 8833 line = compile_endfor(p, &cctx); 8834 cctx.ctx_had_return = FALSE; 8835 break; 8836 case CMD_continue: 8837 line = compile_continue(p, &cctx); 8838 break; 8839 case CMD_break: 8840 line = compile_break(p, &cctx); 8841 break; 8842 8843 case CMD_try: 8844 line = compile_try(p, &cctx); 8845 break; 8846 case CMD_catch: 8847 line = compile_catch(p, &cctx); 8848 cctx.ctx_had_return = FALSE; 8849 break; 8850 case CMD_finally: 8851 line = compile_finally(p, &cctx); 8852 cctx.ctx_had_return = FALSE; 8853 break; 8854 case CMD_endtry: 8855 line = compile_endtry(p, &cctx); 8856 cctx.ctx_had_return = FALSE; 8857 break; 8858 case CMD_throw: 8859 line = compile_throw(p, &cctx); 8860 break; 8861 8862 case CMD_eval: 8863 if (compile_expr0(&p, &cctx) == FAIL) 8864 goto erret; 8865 8866 // drop the result 8867 generate_instr_drop(&cctx, ISN_DROP, 1); 8868 8869 line = skipwhite(p); 8870 break; 8871 8872 case CMD_echo: 8873 case CMD_echon: 8874 case CMD_execute: 8875 case CMD_echomsg: 8876 case CMD_echoerr: 8877 line = compile_mult_expr(p, ea.cmdidx, &cctx); 8878 break; 8879 8880 case CMD_put: 8881 ea.cmd = cmd; 8882 line = compile_put(p, &ea, &cctx); 8883 break; 8884 8885 // TODO: any other commands with an expression argument? 8886 8887 case CMD_append: 8888 case CMD_change: 8889 case CMD_insert: 8890 case CMD_k: 8891 case CMD_t: 8892 case CMD_xit: 8893 not_in_vim9(&ea); 8894 goto erret; 8895 8896 case CMD_SIZE: 8897 if (cctx.ctx_skip != SKIP_YES) 8898 { 8899 semsg(_(e_invalid_command_str), ea.cmd); 8900 goto erret; 8901 } 8902 // We don't check for a next command here. 8903 line = (char_u *)""; 8904 break; 8905 8906 default: 8907 if (cctx.ctx_skip == SKIP_YES) 8908 { 8909 // We don't check for a next command here. 8910 line = (char_u *)""; 8911 } 8912 else 8913 { 8914 // Not recognized, execute with do_cmdline_cmd(). 8915 ea.arg = p; 8916 line = compile_exec(line, &ea, &cctx); 8917 } 8918 break; 8919 } 8920 nextline: 8921 if (line == NULL) 8922 goto erret; 8923 line = skipwhite(line); 8924 8925 // Undo any command modifiers. 8926 generate_undo_cmdmods(&cctx); 8927 8928 if (cctx.ctx_type_stack.ga_len < 0) 8929 { 8930 iemsg("Type stack underflow"); 8931 goto erret; 8932 } 8933 } 8934 8935 if (cctx.ctx_scope != NULL) 8936 { 8937 if (cctx.ctx_scope->se_type == IF_SCOPE) 8938 emsg(_(e_endif)); 8939 else if (cctx.ctx_scope->se_type == WHILE_SCOPE) 8940 emsg(_(e_endwhile)); 8941 else if (cctx.ctx_scope->se_type == FOR_SCOPE) 8942 emsg(_(e_endfor)); 8943 else 8944 emsg(_(e_missing_rcurly)); 8945 goto erret; 8946 } 8947 8948 if (!cctx.ctx_had_return) 8949 { 8950 if (ufunc->uf_ret_type->tt_type != VAR_VOID) 8951 { 8952 emsg(_(e_missing_return_statement)); 8953 goto erret; 8954 } 8955 8956 // Return zero if there is no return at the end. 8957 generate_instr(&cctx, ISN_RETURN_ZERO); 8958 } 8959 8960 { 8961 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 8962 + ufunc->uf_dfunc_idx; 8963 dfunc->df_deleted = FALSE; 8964 dfunc->df_script_seq = current_sctx.sc_seq; 8965 #ifdef FEAT_PROFILE 8966 if (cctx.ctx_profiling) 8967 { 8968 dfunc->df_instr_prof = instr->ga_data; 8969 dfunc->df_instr_prof_count = instr->ga_len; 8970 } 8971 else 8972 #endif 8973 { 8974 dfunc->df_instr = instr->ga_data; 8975 dfunc->df_instr_count = instr->ga_len; 8976 } 8977 dfunc->df_varcount = cctx.ctx_locals_count; 8978 dfunc->df_has_closure = cctx.ctx_has_closure; 8979 if (cctx.ctx_outer_used) 8980 ufunc->uf_flags |= FC_CLOSURE; 8981 ufunc->uf_def_status = UF_COMPILED; 8982 } 8983 8984 ret = OK; 8985 8986 erret: 8987 if (ret == FAIL) 8988 { 8989 int idx; 8990 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 8991 + ufunc->uf_dfunc_idx; 8992 8993 for (idx = 0; idx < instr->ga_len; ++idx) 8994 delete_instr(((isn_T *)instr->ga_data) + idx); 8995 ga_clear(instr); 8996 VIM_CLEAR(dfunc->df_name); 8997 8998 // If using the last entry in the table and it was added above, we 8999 // might as well remove it. 9000 if (!dfunc->df_deleted && new_def_function 9001 && ufunc->uf_dfunc_idx == def_functions.ga_len - 1) 9002 { 9003 --def_functions.ga_len; 9004 ufunc->uf_dfunc_idx = 0; 9005 } 9006 ufunc->uf_def_status = UF_NOT_COMPILED; 9007 9008 while (cctx.ctx_scope != NULL) 9009 drop_scope(&cctx); 9010 9011 // Don't execute this function body. 9012 ga_clear_strings(&ufunc->uf_lines); 9013 9014 if (errormsg != NULL) 9015 emsg(errormsg); 9016 else if (did_emsg == did_emsg_before) 9017 emsg(_(e_compiling_def_function_failed)); 9018 } 9019 9020 current_sctx = save_current_sctx; 9021 estack_compiling = save_estack_compiling; 9022 if (do_estack_push) 9023 estack_pop(); 9024 9025 free_imported(&cctx); 9026 free_locals(&cctx); 9027 ga_clear(&cctx.ctx_type_stack); 9028 return ret; 9029 } 9030 9031 void 9032 set_function_type(ufunc_T *ufunc) 9033 { 9034 int varargs = ufunc->uf_va_name != NULL; 9035 int argcount = ufunc->uf_args.ga_len; 9036 9037 // Create a type for the function, with the return type and any 9038 // argument types. 9039 // A vararg is included in uf_args.ga_len but not in uf_arg_types. 9040 // The type is included in "tt_args". 9041 if (argcount > 0 || varargs) 9042 { 9043 if (ufunc->uf_type_list.ga_itemsize == 0) 9044 ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10); 9045 ufunc->uf_func_type = alloc_func_type(ufunc->uf_ret_type, 9046 argcount, &ufunc->uf_type_list); 9047 // Add argument types to the function type. 9048 if (func_type_add_arg_types(ufunc->uf_func_type, 9049 argcount + varargs, 9050 &ufunc->uf_type_list) == FAIL) 9051 return; 9052 ufunc->uf_func_type->tt_argcount = argcount + varargs; 9053 ufunc->uf_func_type->tt_min_argcount = 9054 argcount - ufunc->uf_def_args.ga_len; 9055 if (ufunc->uf_arg_types == NULL) 9056 { 9057 int i; 9058 9059 // lambda does not have argument types. 9060 for (i = 0; i < argcount; ++i) 9061 ufunc->uf_func_type->tt_args[i] = &t_any; 9062 } 9063 else 9064 mch_memmove(ufunc->uf_func_type->tt_args, 9065 ufunc->uf_arg_types, sizeof(type_T *) * argcount); 9066 if (varargs) 9067 { 9068 ufunc->uf_func_type->tt_args[argcount] = 9069 ufunc->uf_va_type == NULL ? &t_any : ufunc->uf_va_type; 9070 ufunc->uf_func_type->tt_flags = TTFLAG_VARARGS; 9071 } 9072 } 9073 else 9074 // No arguments, can use a predefined type. 9075 ufunc->uf_func_type = get_func_type(ufunc->uf_ret_type, 9076 argcount, &ufunc->uf_type_list); 9077 } 9078 9079 9080 /* 9081 * Delete an instruction, free what it contains. 9082 */ 9083 void 9084 delete_instr(isn_T *isn) 9085 { 9086 switch (isn->isn_type) 9087 { 9088 case ISN_DEF: 9089 case ISN_EXEC: 9090 case ISN_LOADAUTO: 9091 case ISN_LOADB: 9092 case ISN_LOADENV: 9093 case ISN_LOADG: 9094 case ISN_LOADOPT: 9095 case ISN_LOADT: 9096 case ISN_LOADW: 9097 case ISN_PUSHEXC: 9098 case ISN_PUSHFUNC: 9099 case ISN_PUSHS: 9100 case ISN_RANGE: 9101 case ISN_STOREAUTO: 9102 case ISN_STOREB: 9103 case ISN_STOREENV: 9104 case ISN_STOREG: 9105 case ISN_STORET: 9106 case ISN_STOREW: 9107 case ISN_STRINGMEMBER: 9108 vim_free(isn->isn_arg.string); 9109 break; 9110 9111 case ISN_LOADS: 9112 case ISN_STORES: 9113 vim_free(isn->isn_arg.loadstore.ls_name); 9114 break; 9115 9116 case ISN_UNLET: 9117 case ISN_UNLETENV: 9118 vim_free(isn->isn_arg.unlet.ul_name); 9119 break; 9120 9121 case ISN_STOREOPT: 9122 vim_free(isn->isn_arg.storeopt.so_name); 9123 break; 9124 9125 case ISN_PUSHBLOB: // push blob isn_arg.blob 9126 blob_unref(isn->isn_arg.blob); 9127 break; 9128 9129 case ISN_PUSHJOB: 9130 #ifdef FEAT_JOB_CHANNEL 9131 job_unref(isn->isn_arg.job); 9132 #endif 9133 break; 9134 9135 case ISN_PUSHCHANNEL: 9136 #ifdef FEAT_JOB_CHANNEL 9137 channel_unref(isn->isn_arg.channel); 9138 #endif 9139 break; 9140 9141 case ISN_UCALL: 9142 vim_free(isn->isn_arg.ufunc.cuf_name); 9143 break; 9144 9145 case ISN_FUNCREF: 9146 { 9147 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 9148 + isn->isn_arg.funcref.fr_func; 9149 ufunc_T *ufunc = dfunc->df_ufunc; 9150 9151 if (ufunc != NULL && func_name_refcount(ufunc->uf_name)) 9152 func_ptr_unref(ufunc); 9153 } 9154 break; 9155 9156 case ISN_DCALL: 9157 { 9158 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 9159 + isn->isn_arg.dfunc.cdf_idx; 9160 9161 if (dfunc->df_ufunc != NULL 9162 && func_name_refcount(dfunc->df_ufunc->uf_name)) 9163 func_ptr_unref(dfunc->df_ufunc); 9164 } 9165 break; 9166 9167 case ISN_NEWFUNC: 9168 { 9169 char_u *lambda = isn->isn_arg.newfunc.nf_lambda; 9170 ufunc_T *ufunc = find_func_even_dead(lambda, TRUE, NULL); 9171 9172 if (ufunc != NULL) 9173 { 9174 unlink_def_function(ufunc); 9175 func_ptr_unref(ufunc); 9176 } 9177 9178 vim_free(lambda); 9179 vim_free(isn->isn_arg.newfunc.nf_global); 9180 } 9181 break; 9182 9183 case ISN_CHECKTYPE: 9184 case ISN_SETTYPE: 9185 free_type(isn->isn_arg.type.ct_type); 9186 break; 9187 9188 case ISN_CMDMOD: 9189 vim_regfree(isn->isn_arg.cmdmod.cf_cmdmod 9190 ->cmod_filter_regmatch.regprog); 9191 vim_free(isn->isn_arg.cmdmod.cf_cmdmod); 9192 break; 9193 9194 case ISN_LOADSCRIPT: 9195 case ISN_STORESCRIPT: 9196 vim_free(isn->isn_arg.script.scriptref); 9197 break; 9198 9199 case ISN_TRY: 9200 vim_free(isn->isn_arg.try.try_ref); 9201 break; 9202 9203 case ISN_2BOOL: 9204 case ISN_2STRING: 9205 case ISN_2STRING_ANY: 9206 case ISN_ADDBLOB: 9207 case ISN_ADDLIST: 9208 case ISN_ANYINDEX: 9209 case ISN_ANYSLICE: 9210 case ISN_BCALL: 9211 case ISN_BLOBAPPEND: 9212 case ISN_CATCH: 9213 case ISN_CHECKLEN: 9214 case ISN_CHECKNR: 9215 case ISN_CMDMOD_REV: 9216 case ISN_COMPAREANY: 9217 case ISN_COMPAREBLOB: 9218 case ISN_COMPAREBOOL: 9219 case ISN_COMPAREDICT: 9220 case ISN_COMPAREFLOAT: 9221 case ISN_COMPAREFUNC: 9222 case ISN_COMPARELIST: 9223 case ISN_COMPARENR: 9224 case ISN_COMPARESPECIAL: 9225 case ISN_COMPARESTRING: 9226 case ISN_CONCAT: 9227 case ISN_COND2BOOL: 9228 case ISN_DROP: 9229 case ISN_ECHO: 9230 case ISN_ECHOERR: 9231 case ISN_ECHOMSG: 9232 case ISN_ENDTRY: 9233 case ISN_EXECCONCAT: 9234 case ISN_EXECUTE: 9235 case ISN_FINALLY: 9236 case ISN_FOR: 9237 case ISN_GETITEM: 9238 case ISN_JUMP: 9239 case ISN_JUMP_IF_ARG_SET: 9240 case ISN_LISTAPPEND: 9241 case ISN_LISTINDEX: 9242 case ISN_LISTSLICE: 9243 case ISN_LOAD: 9244 case ISN_LOADBDICT: 9245 case ISN_LOADGDICT: 9246 case ISN_LOADOUTER: 9247 case ISN_LOADREG: 9248 case ISN_LOADTDICT: 9249 case ISN_LOADV: 9250 case ISN_LOADWDICT: 9251 case ISN_LOCKCONST: 9252 case ISN_MEMBER: 9253 case ISN_NEGATENR: 9254 case ISN_NEWDICT: 9255 case ISN_NEWLIST: 9256 case ISN_OPANY: 9257 case ISN_OPFLOAT: 9258 case ISN_OPNR: 9259 case ISN_PCALL: 9260 case ISN_PCALL_END: 9261 case ISN_PROF_END: 9262 case ISN_PROF_START: 9263 case ISN_PUSHBOOL: 9264 case ISN_PUSHF: 9265 case ISN_PUSHNR: 9266 case ISN_PUSHSPEC: 9267 case ISN_PUT: 9268 case ISN_RETURN: 9269 case ISN_RETURN_ZERO: 9270 case ISN_SHUFFLE: 9271 case ISN_SLICE: 9272 case ISN_STORE: 9273 case ISN_STOREINDEX: 9274 case ISN_STORENR: 9275 case ISN_STOREOUTER: 9276 case ISN_STOREREG: 9277 case ISN_STOREV: 9278 case ISN_STRINDEX: 9279 case ISN_STRSLICE: 9280 case ISN_THROW: 9281 case ISN_TRYCONT: 9282 case ISN_UNLETINDEX: 9283 case ISN_UNLETRANGE: 9284 case ISN_UNPACK: 9285 // nothing allocated 9286 break; 9287 } 9288 } 9289 9290 /* 9291 * Free all instructions for "dfunc" except df_name. 9292 */ 9293 static void 9294 delete_def_function_contents(dfunc_T *dfunc, int mark_deleted) 9295 { 9296 int idx; 9297 9298 ga_clear(&dfunc->df_def_args_isn); 9299 9300 if (dfunc->df_instr != NULL) 9301 { 9302 for (idx = 0; idx < dfunc->df_instr_count; ++idx) 9303 delete_instr(dfunc->df_instr + idx); 9304 VIM_CLEAR(dfunc->df_instr); 9305 dfunc->df_instr = NULL; 9306 } 9307 #ifdef FEAT_PROFILE 9308 if (dfunc->df_instr_prof != NULL) 9309 { 9310 for (idx = 0; idx < dfunc->df_instr_prof_count; ++idx) 9311 delete_instr(dfunc->df_instr_prof + idx); 9312 VIM_CLEAR(dfunc->df_instr_prof); 9313 dfunc->df_instr_prof = NULL; 9314 } 9315 #endif 9316 9317 if (mark_deleted) 9318 dfunc->df_deleted = TRUE; 9319 if (dfunc->df_ufunc != NULL) 9320 dfunc->df_ufunc->uf_def_status = UF_NOT_COMPILED; 9321 } 9322 9323 /* 9324 * When a user function is deleted, clear the contents of any associated def 9325 * function, unless another user function still uses it. 9326 * The position in def_functions can be re-used. 9327 */ 9328 void 9329 unlink_def_function(ufunc_T *ufunc) 9330 { 9331 if (ufunc->uf_dfunc_idx > 0) 9332 { 9333 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 9334 + ufunc->uf_dfunc_idx; 9335 9336 if (--dfunc->df_refcount <= 0) 9337 delete_def_function_contents(dfunc, TRUE); 9338 ufunc->uf_def_status = UF_NOT_COMPILED; 9339 ufunc->uf_dfunc_idx = 0; 9340 if (dfunc->df_ufunc == ufunc) 9341 dfunc->df_ufunc = NULL; 9342 } 9343 } 9344 9345 /* 9346 * Used when a user function refers to an existing dfunc. 9347 */ 9348 void 9349 link_def_function(ufunc_T *ufunc) 9350 { 9351 if (ufunc->uf_dfunc_idx > 0) 9352 { 9353 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 9354 + ufunc->uf_dfunc_idx; 9355 9356 ++dfunc->df_refcount; 9357 } 9358 } 9359 9360 #if defined(EXITFREE) || defined(PROTO) 9361 /* 9362 * Free all functions defined with ":def". 9363 */ 9364 void 9365 free_def_functions(void) 9366 { 9367 int idx; 9368 9369 for (idx = 0; idx < def_functions.ga_len; ++idx) 9370 { 9371 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) + idx; 9372 9373 delete_def_function_contents(dfunc, TRUE); 9374 vim_free(dfunc->df_name); 9375 } 9376 9377 ga_clear(&def_functions); 9378 } 9379 #endif 9380 9381 9382 #endif // FEAT_EVAL 9383