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 * vim9execute.c: execute Vim9 script 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 #include "vim9.h" 24 25 // Structure put on ec_trystack when ISN_TRY is encountered. 26 typedef struct { 27 int tcd_frame_idx; // ec_frame_idx when ISN_TRY was encountered 28 int tcd_catch_idx; // instruction of the first catch 29 int tcd_finally_idx; // instruction of the finally block 30 int tcd_caught; // catch block entered 31 int tcd_return; // when TRUE return from end of :finally 32 } trycmd_T; 33 34 35 // A stack is used to store: 36 // - arguments passed to a :def function 37 // - info about the calling function, to use when returning 38 // - local variables 39 // - temporary values 40 // 41 // In detail (FP == Frame Pointer): 42 // arg1 first argument from caller (if present) 43 // arg2 second argument from caller (if present) 44 // extra_arg1 any missing optional argument default value 45 // FP -> cur_func calling function 46 // current previous instruction pointer 47 // frame_ptr previous Frame Pointer 48 // var1 space for local variable 49 // var2 space for local variable 50 // .... fixed space for max. number of local variables 51 // temp temporary values 52 // .... flexible space for temporary values (can grow big) 53 54 /* 55 * Execution context. 56 */ 57 typedef struct { 58 garray_T ec_stack; // stack of typval_T values 59 int ec_frame_idx; // index in ec_stack: context of ec_dfunc_idx 60 61 garray_T *ec_outer_stack; // stack used for closures 62 int ec_outer_frame; // stack frame in ec_outer_stack 63 64 garray_T ec_trystack; // stack of trycmd_T values 65 int ec_in_catch; // when TRUE in catch or finally block 66 67 int ec_dfunc_idx; // current function index 68 isn_T *ec_instr; // array with instructions 69 int ec_iidx; // index in ec_instr: instruction to execute 70 } ectx_T; 71 72 // Get pointer to item relative to the bottom of the stack, -1 is the last one. 73 #define STACK_TV_BOT(idx) (((typval_T *)ectx->ec_stack.ga_data) + ectx->ec_stack.ga_len + idx) 74 75 void 76 to_string_error(vartype_T vartype) 77 { 78 semsg(_(e_cannot_convert_str_to_string), vartype_name(vartype)); 79 } 80 81 /* 82 * Return the number of arguments, including optional arguments and any vararg. 83 */ 84 static int 85 ufunc_argcount(ufunc_T *ufunc) 86 { 87 return ufunc->uf_args.ga_len + (ufunc->uf_va_name != NULL ? 1 : 0); 88 } 89 90 /* 91 * Set the instruction index, depending on omitted arguments, where the default 92 * values are to be computed. If all optional arguments are present, start 93 * with the function body. 94 * The expression evaluation is at the start of the instructions: 95 * 0 -> EVAL default1 96 * STORE arg[-2] 97 * 1 -> EVAL default2 98 * STORE arg[-1] 99 * 2 -> function body 100 */ 101 static void 102 init_instr_idx(ufunc_T *ufunc, int argcount, ectx_T *ectx) 103 { 104 if (ufunc->uf_def_args.ga_len == 0) 105 ectx->ec_iidx = 0; 106 else 107 { 108 int defcount = ufunc->uf_args.ga_len - argcount; 109 110 // If there is a varargs argument defcount can be negative, no defaults 111 // to evaluate then. 112 if (defcount < 0) 113 defcount = 0; 114 ectx->ec_iidx = ufunc->uf_def_arg_idx[ 115 ufunc->uf_def_args.ga_len - defcount]; 116 } 117 } 118 119 /* 120 * Create a new list from "count" items at the bottom of the stack. 121 * When "count" is zero an empty list is added to the stack. 122 */ 123 static int 124 exe_newlist(int count, ectx_T *ectx) 125 { 126 list_T *list = list_alloc_with_items(count); 127 int idx; 128 typval_T *tv; 129 130 if (list == NULL) 131 return FAIL; 132 for (idx = 0; idx < count; ++idx) 133 list_set_item(list, idx, STACK_TV_BOT(idx - count)); 134 135 if (count > 0) 136 ectx->ec_stack.ga_len -= count - 1; 137 else if (GA_GROW(&ectx->ec_stack, 1) == FAIL) 138 return FAIL; 139 else 140 ++ectx->ec_stack.ga_len; 141 tv = STACK_TV_BOT(-1); 142 tv->v_type = VAR_LIST; 143 tv->vval.v_list = list; 144 ++list->lv_refcount; 145 return OK; 146 } 147 148 /* 149 * Call compiled function "cdf_idx" from compiled code. 150 * 151 * Stack has: 152 * - current arguments (already there) 153 * - omitted optional argument (default values) added here 154 * - stack frame: 155 * - pointer to calling function 156 * - Index of next instruction in calling function 157 * - previous frame pointer 158 * - reserved space for local variables 159 */ 160 static int 161 call_dfunc(int cdf_idx, int argcount_arg, ectx_T *ectx) 162 { 163 int argcount = argcount_arg; 164 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) + cdf_idx; 165 ufunc_T *ufunc = dfunc->df_ufunc; 166 int arg_to_add; 167 int vararg_count = 0; 168 int idx; 169 estack_T *entry; 170 171 if (dfunc->df_deleted) 172 { 173 emsg_funcname(e_func_deleted, ufunc->uf_name); 174 return FAIL; 175 } 176 177 if (ufunc->uf_va_name != NULL) 178 { 179 // Need to make a list out of the vararg arguments. 180 // Stack at time of call with 2 varargs: 181 // normal_arg 182 // optional_arg 183 // vararg_1 184 // vararg_2 185 // After creating the list: 186 // normal_arg 187 // optional_arg 188 // vararg-list 189 // With missing optional arguments we get: 190 // normal_arg 191 // After creating the list 192 // normal_arg 193 // (space for optional_arg) 194 // vararg-list 195 vararg_count = argcount - ufunc->uf_args.ga_len; 196 if (vararg_count < 0) 197 vararg_count = 0; 198 else 199 argcount -= vararg_count; 200 if (exe_newlist(vararg_count, ectx) == FAIL) 201 return FAIL; 202 203 vararg_count = 1; 204 } 205 206 arg_to_add = ufunc->uf_args.ga_len - argcount; 207 if (arg_to_add < 0) 208 { 209 if (arg_to_add == -1) 210 emsg(_(e_one_argument_too_many)); 211 else 212 semsg(_(e_nr_arguments_too_many), -arg_to_add); 213 return FAIL; 214 } 215 if (ga_grow(&ectx->ec_stack, arg_to_add + 3 216 + dfunc->df_varcount + dfunc->df_closure_count) == FAIL) 217 return FAIL; 218 219 // Move the vararg-list to below the missing optional arguments. 220 if (vararg_count > 0 && arg_to_add > 0) 221 *STACK_TV_BOT(arg_to_add - 1) = *STACK_TV_BOT(-1); 222 223 // Reserve space for omitted optional arguments, filled in soon. 224 for (idx = 0; idx < arg_to_add; ++idx) 225 STACK_TV_BOT(idx - vararg_count)->v_type = VAR_UNKNOWN; 226 ectx->ec_stack.ga_len += arg_to_add; 227 228 // Store current execution state in stack frame for ISN_RETURN. 229 STACK_TV_BOT(0)->vval.v_number = ectx->ec_dfunc_idx; 230 STACK_TV_BOT(1)->vval.v_number = ectx->ec_iidx; 231 STACK_TV_BOT(2)->vval.v_number = ectx->ec_frame_idx; 232 ectx->ec_frame_idx = ectx->ec_stack.ga_len; 233 234 // Initialize local variables 235 for (idx = 0; idx < dfunc->df_varcount + dfunc->df_closure_count; ++idx) 236 STACK_TV_BOT(STACK_FRAME_SIZE + idx)->v_type = VAR_UNKNOWN; 237 ectx->ec_stack.ga_len += STACK_FRAME_SIZE 238 + dfunc->df_varcount + dfunc->df_closure_count; 239 240 // Set execution state to the start of the called function. 241 ectx->ec_dfunc_idx = cdf_idx; 242 ectx->ec_instr = dfunc->df_instr; 243 entry = estack_push_ufunc(dfunc->df_ufunc, 1); 244 if (entry != NULL) 245 { 246 // Set the script context to the script where the function was defined. 247 // TODO: save more than the SID? 248 entry->es_save_sid = current_sctx.sc_sid; 249 current_sctx.sc_sid = ufunc->uf_script_ctx.sc_sid; 250 } 251 252 // Decide where to start execution, handles optional arguments. 253 init_instr_idx(ufunc, argcount, ectx); 254 255 return OK; 256 } 257 258 // Get pointer to item in the stack. 259 #define STACK_TV(idx) (((typval_T *)ectx->ec_stack.ga_data) + idx) 260 261 /* 262 * Used when returning from a function: Check if any closure is still 263 * referenced. If so then move the arguments and variables to a separate piece 264 * of stack to be used when the closure is called. 265 * When "free_arguments" is TRUE the arguments are to be freed. 266 * Returns FAIL when out of memory. 267 */ 268 static int 269 handle_closure_in_use(ectx_T *ectx, int free_arguments) 270 { 271 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 272 + ectx->ec_dfunc_idx; 273 int argcount = ufunc_argcount(dfunc->df_ufunc); 274 int top = ectx->ec_frame_idx - argcount; 275 int idx; 276 typval_T *tv; 277 int closure_in_use = FALSE; 278 279 // Check if any created closure is still in use. 280 for (idx = 0; idx < dfunc->df_closure_count; ++idx) 281 { 282 tv = STACK_TV(ectx->ec_frame_idx + STACK_FRAME_SIZE 283 + dfunc->df_varcount + idx); 284 if (tv->v_type == VAR_PARTIAL && tv->vval.v_partial != NULL 285 && tv->vval.v_partial->pt_refcount > 1) 286 { 287 int refcount = tv->vval.v_partial->pt_refcount; 288 int i; 289 290 // A Reference in a local variables doesn't count, it gets 291 // unreferenced on return. 292 for (i = 0; i < dfunc->df_varcount; ++i) 293 { 294 typval_T *stv = STACK_TV(ectx->ec_frame_idx 295 + STACK_FRAME_SIZE + i); 296 if (stv->v_type == VAR_PARTIAL 297 && tv->vval.v_partial == stv->vval.v_partial) 298 --refcount; 299 } 300 if (refcount > 1) 301 { 302 closure_in_use = TRUE; 303 break; 304 } 305 } 306 } 307 308 if (closure_in_use) 309 { 310 funcstack_T *funcstack = ALLOC_CLEAR_ONE(funcstack_T); 311 typval_T *stack; 312 313 // A closure is using the arguments and/or local variables. 314 // Move them to the called function. 315 if (funcstack == NULL) 316 return FAIL; 317 funcstack->fs_ga.ga_len = argcount + STACK_FRAME_SIZE 318 + dfunc->df_varcount; 319 stack = ALLOC_CLEAR_MULT(typval_T, funcstack->fs_ga.ga_len); 320 funcstack->fs_ga.ga_data = stack; 321 if (stack == NULL) 322 { 323 vim_free(funcstack); 324 return FAIL; 325 } 326 327 // Move or copy the arguments. 328 for (idx = 0; idx < argcount; ++idx) 329 { 330 tv = STACK_TV(top + idx); 331 if (free_arguments) 332 { 333 *(stack + idx) = *tv; 334 tv->v_type = VAR_UNKNOWN; 335 } 336 else 337 copy_tv(tv, stack + idx); 338 } 339 // Move the local variables. 340 for (idx = 0; idx < dfunc->df_varcount; ++idx) 341 { 342 tv = STACK_TV(ectx->ec_frame_idx + STACK_FRAME_SIZE + idx); 343 344 // Do not copy a partial created for a local function. 345 // TODO: this won't work if the closure actually uses it. But when 346 // keeping it it gets complicated: it will create a reference cycle 347 // inside the partial, thus needs special handling for garbage 348 // collection. 349 if (tv->v_type == VAR_PARTIAL && tv->vval.v_partial != NULL) 350 { 351 int i; 352 typval_T *ctv; 353 354 for (i = 0; i < dfunc->df_closure_count; ++i) 355 { 356 ctv = STACK_TV(ectx->ec_frame_idx + STACK_FRAME_SIZE 357 + dfunc->df_varcount + i); 358 if (tv->vval.v_partial == ctv->vval.v_partial) 359 break; 360 } 361 if (i < dfunc->df_closure_count) 362 { 363 (stack + argcount + STACK_FRAME_SIZE + idx)->v_type = 364 VAR_UNKNOWN; 365 continue; 366 } 367 } 368 369 *(stack + argcount + STACK_FRAME_SIZE + idx) = *tv; 370 tv->v_type = VAR_UNKNOWN; 371 } 372 373 for (idx = 0; idx < dfunc->df_closure_count; ++idx) 374 { 375 tv = STACK_TV(ectx->ec_frame_idx + STACK_FRAME_SIZE 376 + dfunc->df_varcount + idx); 377 if (tv->v_type == VAR_PARTIAL) 378 { 379 partial_T *partial = tv->vval.v_partial; 380 381 if (partial->pt_refcount > 1) 382 { 383 ++funcstack->fs_refcount; 384 partial->pt_funcstack = funcstack; 385 partial->pt_ectx_stack = &funcstack->fs_ga; 386 partial->pt_ectx_frame = ectx->ec_frame_idx - top; 387 } 388 } 389 } 390 } 391 392 return OK; 393 } 394 395 /* 396 * Return from the current function. 397 */ 398 static int 399 func_return(ectx_T *ectx) 400 { 401 int idx; 402 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 403 + ectx->ec_dfunc_idx; 404 int argcount = ufunc_argcount(dfunc->df_ufunc); 405 int top = ectx->ec_frame_idx - argcount; 406 estack_T *entry; 407 408 // execution context goes one level up 409 entry = estack_pop(); 410 if (entry != NULL) 411 current_sctx.sc_sid = entry->es_save_sid; 412 413 if (handle_closure_in_use(ectx, TRUE) == FAIL) 414 return FAIL; 415 416 // Clear the arguments. 417 for (idx = top; idx < ectx->ec_frame_idx; ++idx) 418 clear_tv(STACK_TV(idx)); 419 420 // Clear local variables and temp values, but not the return value. 421 for (idx = ectx->ec_frame_idx + STACK_FRAME_SIZE; 422 idx < ectx->ec_stack.ga_len - 1; ++idx) 423 clear_tv(STACK_TV(idx)); 424 425 // Restore the previous frame. 426 ectx->ec_dfunc_idx = STACK_TV(ectx->ec_frame_idx)->vval.v_number; 427 ectx->ec_iidx = STACK_TV(ectx->ec_frame_idx + 1)->vval.v_number; 428 ectx->ec_frame_idx = STACK_TV(ectx->ec_frame_idx + 2)->vval.v_number; 429 dfunc = ((dfunc_T *)def_functions.ga_data) + ectx->ec_dfunc_idx; 430 ectx->ec_instr = dfunc->df_instr; 431 432 // Reset the stack to the position before the call, move the return value 433 // to the top of the stack. 434 idx = ectx->ec_stack.ga_len - 1; 435 ectx->ec_stack.ga_len = top + 1; 436 *STACK_TV_BOT(-1) = *STACK_TV(idx); 437 438 return OK; 439 } 440 441 #undef STACK_TV 442 443 /* 444 * Prepare arguments and rettv for calling a builtin or user function. 445 */ 446 static int 447 call_prepare(int argcount, typval_T *argvars, ectx_T *ectx) 448 { 449 int idx; 450 typval_T *tv; 451 452 // Move arguments from bottom of the stack to argvars[] and add terminator. 453 for (idx = 0; idx < argcount; ++idx) 454 argvars[idx] = *STACK_TV_BOT(idx - argcount); 455 argvars[argcount].v_type = VAR_UNKNOWN; 456 457 // Result replaces the arguments on the stack. 458 if (argcount > 0) 459 ectx->ec_stack.ga_len -= argcount - 1; 460 else if (GA_GROW(&ectx->ec_stack, 1) == FAIL) 461 return FAIL; 462 else 463 ++ectx->ec_stack.ga_len; 464 465 // Default return value is zero. 466 tv = STACK_TV_BOT(-1); 467 tv->v_type = VAR_NUMBER; 468 tv->vval.v_number = 0; 469 470 return OK; 471 } 472 473 // Ugly global to avoid passing the execution context around through many 474 // layers. 475 static ectx_T *current_ectx = NULL; 476 477 /* 478 * Call a builtin function by index. 479 */ 480 static int 481 call_bfunc(int func_idx, int argcount, ectx_T *ectx) 482 { 483 typval_T argvars[MAX_FUNC_ARGS]; 484 int idx; 485 int did_emsg_before = did_emsg; 486 ectx_T *prev_ectx = current_ectx; 487 488 if (call_prepare(argcount, argvars, ectx) == FAIL) 489 return FAIL; 490 491 // Call the builtin function. Set "current_ectx" so that when it 492 // recursively invokes call_def_function() a closure context can be set. 493 current_ectx = ectx; 494 call_internal_func_by_idx(func_idx, argvars, STACK_TV_BOT(-1)); 495 current_ectx = prev_ectx; 496 497 // Clear the arguments. 498 for (idx = 0; idx < argcount; ++idx) 499 clear_tv(&argvars[idx]); 500 501 if (did_emsg != did_emsg_before) 502 return FAIL; 503 return OK; 504 } 505 506 /* 507 * Execute a user defined function. 508 * "iptr" can be used to replace the instruction with a more efficient one. 509 */ 510 static int 511 call_ufunc(ufunc_T *ufunc, int argcount, ectx_T *ectx, isn_T *iptr) 512 { 513 typval_T argvars[MAX_FUNC_ARGS]; 514 funcexe_T funcexe; 515 int error; 516 int idx; 517 int called_emsg_before = called_emsg; 518 519 if (ufunc->uf_def_status == UF_TO_BE_COMPILED 520 && compile_def_function(ufunc, FALSE, NULL) == FAIL) 521 return FAIL; 522 if (ufunc->uf_def_status == UF_COMPILED) 523 { 524 // The function has been compiled, can call it quickly. For a function 525 // that was defined later: we can call it directly next time. 526 if (iptr != NULL) 527 { 528 delete_instr(iptr); 529 iptr->isn_type = ISN_DCALL; 530 iptr->isn_arg.dfunc.cdf_idx = ufunc->uf_dfunc_idx; 531 iptr->isn_arg.dfunc.cdf_argcount = argcount; 532 } 533 return call_dfunc(ufunc->uf_dfunc_idx, argcount, ectx); 534 } 535 536 if (call_prepare(argcount, argvars, ectx) == FAIL) 537 return FAIL; 538 CLEAR_FIELD(funcexe); 539 funcexe.evaluate = TRUE; 540 541 // Call the user function. Result goes in last position on the stack. 542 // TODO: add selfdict if there is one 543 error = call_user_func_check(ufunc, argcount, argvars, 544 STACK_TV_BOT(-1), &funcexe, NULL); 545 546 // Clear the arguments. 547 for (idx = 0; idx < argcount; ++idx) 548 clear_tv(&argvars[idx]); 549 550 if (error != FCERR_NONE) 551 { 552 user_func_error(error, ufunc->uf_name); 553 return FAIL; 554 } 555 if (called_emsg > called_emsg_before) 556 // Error other than from calling the function itself. 557 return FAIL; 558 return OK; 559 } 560 561 /* 562 * Return TRUE if an error was given or CTRL-C was pressed. 563 */ 564 static int 565 vim9_aborting(int prev_called_emsg) 566 { 567 return called_emsg > prev_called_emsg || got_int || did_throw; 568 } 569 570 /* 571 * Execute a function by "name". 572 * This can be a builtin function or a user function. 573 * "iptr" can be used to replace the instruction with a more efficient one. 574 * Returns FAIL if not found without an error message. 575 */ 576 static int 577 call_by_name(char_u *name, int argcount, ectx_T *ectx, isn_T *iptr) 578 { 579 ufunc_T *ufunc; 580 581 if (builtin_function(name, -1)) 582 { 583 int func_idx = find_internal_func(name); 584 585 if (func_idx < 0) 586 return FAIL; 587 if (check_internal_func(func_idx, argcount) < 0) 588 return FAIL; 589 return call_bfunc(func_idx, argcount, ectx); 590 } 591 592 ufunc = find_func(name, FALSE, NULL); 593 594 if (ufunc == NULL) 595 { 596 int called_emsg_before = called_emsg; 597 598 if (script_autoload(name, TRUE)) 599 // loaded a package, search for the function again 600 ufunc = find_func(name, FALSE, NULL); 601 if (vim9_aborting(called_emsg_before)) 602 return FAIL; // bail out if loading the script caused an error 603 } 604 605 if (ufunc != NULL) 606 return call_ufunc(ufunc, argcount, ectx, iptr); 607 608 return FAIL; 609 } 610 611 static int 612 call_partial(typval_T *tv, int argcount_arg, ectx_T *ectx) 613 { 614 int argcount = argcount_arg; 615 char_u *name = NULL; 616 int called_emsg_before = called_emsg; 617 618 if (tv->v_type == VAR_PARTIAL) 619 { 620 partial_T *pt = tv->vval.v_partial; 621 int i; 622 623 if (pt->pt_argc > 0) 624 { 625 // Make space for arguments from the partial, shift the "argcount" 626 // arguments up. 627 if (ga_grow(&ectx->ec_stack, pt->pt_argc) == FAIL) 628 return FAIL; 629 for (i = 1; i <= argcount; ++i) 630 *STACK_TV_BOT(-i + pt->pt_argc) = *STACK_TV_BOT(-i); 631 ectx->ec_stack.ga_len += pt->pt_argc; 632 argcount += pt->pt_argc; 633 634 // copy the arguments from the partial onto the stack 635 for (i = 0; i < pt->pt_argc; ++i) 636 copy_tv(&pt->pt_argv[i], STACK_TV_BOT(-argcount + i)); 637 } 638 639 if (pt->pt_func != NULL) 640 { 641 int ret = call_ufunc(pt->pt_func, argcount, ectx, NULL); 642 643 // closure may need the function context where it was defined 644 ectx->ec_outer_stack = pt->pt_ectx_stack; 645 ectx->ec_outer_frame = pt->pt_ectx_frame; 646 647 return ret; 648 } 649 name = pt->pt_name; 650 } 651 else if (tv->v_type == VAR_FUNC) 652 name = tv->vval.v_string; 653 if (name == NULL || call_by_name(name, argcount, ectx, NULL) == FAIL) 654 { 655 if (called_emsg == called_emsg_before) 656 semsg(_(e_unknownfunc), 657 name == NULL ? (char_u *)"[unknown]" : name); 658 return FAIL; 659 } 660 return OK; 661 } 662 663 /* 664 * Store "tv" in variable "name". 665 * This is for s: and g: variables. 666 */ 667 static void 668 store_var(char_u *name, typval_T *tv) 669 { 670 funccal_entry_T entry; 671 672 save_funccal(&entry); 673 set_var_const(name, NULL, tv, FALSE, LET_NO_COMMAND); 674 restore_funccal(); 675 } 676 677 678 /* 679 * Execute a function by "name". 680 * This can be a builtin function, user function or a funcref. 681 * "iptr" can be used to replace the instruction with a more efficient one. 682 */ 683 static int 684 call_eval_func(char_u *name, int argcount, ectx_T *ectx, isn_T *iptr) 685 { 686 int called_emsg_before = called_emsg; 687 int res; 688 689 res = call_by_name(name, argcount, ectx, iptr); 690 if (res == FAIL && called_emsg == called_emsg_before) 691 { 692 dictitem_T *v; 693 694 v = find_var(name, NULL, FALSE); 695 if (v == NULL) 696 { 697 semsg(_(e_unknownfunc), name); 698 return FAIL; 699 } 700 if (v->di_tv.v_type != VAR_PARTIAL && v->di_tv.v_type != VAR_FUNC) 701 { 702 semsg(_(e_unknownfunc), name); 703 return FAIL; 704 } 705 return call_partial(&v->di_tv, argcount, ectx); 706 } 707 return res; 708 } 709 710 /* 711 * Call a "def" function from old Vim script. 712 * Return OK or FAIL. 713 */ 714 int 715 call_def_function( 716 ufunc_T *ufunc, 717 int argc_arg, // nr of arguments 718 typval_T *argv, // arguments 719 partial_T *partial, // optional partial for context 720 typval_T *rettv) // return value 721 { 722 ectx_T ectx; // execution context 723 int argc = argc_arg; 724 int initial_frame_idx; 725 typval_T *tv; 726 int idx; 727 int ret = FAIL; 728 int defcount = ufunc->uf_args.ga_len - argc; 729 int save_sc_version = current_sctx.sc_version; 730 int breakcheck_count = 0; 731 int called_emsg_before = called_emsg; 732 733 // Get pointer to item in the stack. 734 #define STACK_TV(idx) (((typval_T *)ectx.ec_stack.ga_data) + idx) 735 736 // Get pointer to item at the bottom of the stack, -1 is the bottom. 737 #undef STACK_TV_BOT 738 #define STACK_TV_BOT(idx) (((typval_T *)ectx.ec_stack.ga_data) + ectx.ec_stack.ga_len + idx) 739 740 // Get pointer to a local variable on the stack. Negative for arguments. 741 #define STACK_TV_VAR(idx) (((typval_T *)ectx.ec_stack.ga_data) + ectx.ec_frame_idx + STACK_FRAME_SIZE + idx) 742 743 // Like STACK_TV_VAR but use the outer scope 744 #define STACK_OUT_TV_VAR(idx) (((typval_T *)ectx.ec_outer_stack->ga_data) + ectx.ec_outer_frame + STACK_FRAME_SIZE + idx) 745 746 if (ufunc->uf_def_status == UF_NOT_COMPILED 747 || (ufunc->uf_def_status == UF_TO_BE_COMPILED 748 && compile_def_function(ufunc, FALSE, NULL) == FAIL)) 749 { 750 if (called_emsg == called_emsg_before) 751 semsg(_(e_function_is_not_compiled_str), 752 printable_func_name(ufunc)); 753 return FAIL; 754 } 755 756 { 757 // Check the function was really compiled. 758 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 759 + ufunc->uf_dfunc_idx; 760 if (dfunc->df_instr == NULL) 761 { 762 iemsg("using call_def_function() on not compiled function"); 763 return FAIL; 764 } 765 } 766 767 CLEAR_FIELD(ectx); 768 ectx.ec_dfunc_idx = ufunc->uf_dfunc_idx; 769 ga_init2(&ectx.ec_stack, sizeof(typval_T), 500); 770 if (ga_grow(&ectx.ec_stack, 20) == FAIL) 771 return FAIL; 772 ga_init2(&ectx.ec_trystack, sizeof(trycmd_T), 10); 773 774 // Put arguments on the stack. 775 for (idx = 0; idx < argc; ++idx) 776 { 777 if (ufunc->uf_arg_types != NULL && idx < ufunc->uf_args.ga_len 778 && check_typval_type(ufunc->uf_arg_types[idx], &argv[idx]) 779 == FAIL) 780 goto failed_early; 781 copy_tv(&argv[idx], STACK_TV_BOT(0)); 782 ++ectx.ec_stack.ga_len; 783 } 784 785 // Turn varargs into a list. Empty list if no args. 786 if (ufunc->uf_va_name != NULL) 787 { 788 int vararg_count = argc - ufunc->uf_args.ga_len; 789 790 if (vararg_count < 0) 791 vararg_count = 0; 792 else 793 argc -= vararg_count; 794 if (exe_newlist(vararg_count, &ectx) == FAIL) 795 goto failed_early; 796 797 // Check the type of the list items. 798 tv = STACK_TV_BOT(-1); 799 if (ufunc->uf_va_type != NULL 800 && ufunc->uf_va_type->tt_member != &t_any 801 && tv->vval.v_list != NULL) 802 { 803 type_T *expected = ufunc->uf_va_type->tt_member; 804 listitem_T *li = tv->vval.v_list->lv_first; 805 806 for (idx = 0; idx < vararg_count; ++idx) 807 { 808 if (check_typval_type(expected, &li->li_tv) == FAIL) 809 goto failed_early; 810 li = li->li_next; 811 } 812 } 813 814 if (defcount > 0) 815 // Move varargs list to below missing default arguments. 816 *STACK_TV_BOT(defcount - 1) = *STACK_TV_BOT(-1); 817 --ectx.ec_stack.ga_len; 818 } 819 820 // Make space for omitted arguments, will store default value below. 821 // Any varargs list goes after them. 822 if (defcount > 0) 823 for (idx = 0; idx < defcount; ++idx) 824 { 825 STACK_TV_BOT(0)->v_type = VAR_UNKNOWN; 826 ++ectx.ec_stack.ga_len; 827 } 828 if (ufunc->uf_va_name != NULL) 829 ++ectx.ec_stack.ga_len; 830 831 // Frame pointer points to just after arguments. 832 ectx.ec_frame_idx = ectx.ec_stack.ga_len; 833 initial_frame_idx = ectx.ec_frame_idx; 834 835 if (partial != NULL) 836 { 837 if (partial->pt_ectx_stack == NULL && current_ectx != NULL) 838 { 839 // TODO: is this always the right way? 840 ectx.ec_outer_stack = ¤t_ectx->ec_stack; 841 ectx.ec_outer_frame = current_ectx->ec_frame_idx; 842 } 843 else 844 { 845 ectx.ec_outer_stack = partial->pt_ectx_stack; 846 ectx.ec_outer_frame = partial->pt_ectx_frame; 847 } 848 } 849 850 // dummy frame entries 851 for (idx = 0; idx < STACK_FRAME_SIZE; ++idx) 852 { 853 STACK_TV(ectx.ec_stack.ga_len)->v_type = VAR_UNKNOWN; 854 ++ectx.ec_stack.ga_len; 855 } 856 857 { 858 // Reserve space for local variables and closure references. 859 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 860 + ufunc->uf_dfunc_idx; 861 int count = dfunc->df_varcount + dfunc->df_closure_count; 862 863 for (idx = 0; idx < count; ++idx) 864 STACK_TV_VAR(idx)->v_type = VAR_UNKNOWN; 865 ectx.ec_stack.ga_len += count; 866 867 ectx.ec_instr = dfunc->df_instr; 868 } 869 870 // Commands behave like vim9script. 871 current_sctx.sc_version = SCRIPT_VERSION_VIM9; 872 873 // Decide where to start execution, handles optional arguments. 874 init_instr_idx(ufunc, argc, &ectx); 875 876 for (;;) 877 { 878 isn_T *iptr; 879 880 if (++breakcheck_count >= 100) 881 { 882 line_breakcheck(); 883 breakcheck_count = 0; 884 } 885 if (got_int) 886 { 887 // Turn CTRL-C into an exception. 888 got_int = FALSE; 889 if (throw_exception("Vim:Interrupt", ET_INTERRUPT, NULL) == FAIL) 890 goto failed; 891 did_throw = TRUE; 892 } 893 894 if (did_emsg && msg_list != NULL && *msg_list != NULL) 895 { 896 // Turn an error message into an exception. 897 did_emsg = FALSE; 898 if (throw_exception(*msg_list, ET_ERROR, NULL) == FAIL) 899 goto failed; 900 did_throw = TRUE; 901 *msg_list = NULL; 902 } 903 904 if (did_throw && !ectx.ec_in_catch) 905 { 906 garray_T *trystack = &ectx.ec_trystack; 907 trycmd_T *trycmd = NULL; 908 909 // An exception jumps to the first catch, finally, or returns from 910 // the current function. 911 if (trystack->ga_len > 0) 912 trycmd = ((trycmd_T *)trystack->ga_data) + trystack->ga_len - 1; 913 if (trycmd != NULL && trycmd->tcd_frame_idx == ectx.ec_frame_idx) 914 { 915 // jump to ":catch" or ":finally" 916 ectx.ec_in_catch = TRUE; 917 ectx.ec_iidx = trycmd->tcd_catch_idx; 918 } 919 else 920 { 921 // Not inside try or need to return from current functions. 922 // Push a dummy return value. 923 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 924 goto failed; 925 tv = STACK_TV_BOT(0); 926 tv->v_type = VAR_NUMBER; 927 tv->vval.v_number = 0; 928 ++ectx.ec_stack.ga_len; 929 if (ectx.ec_frame_idx == initial_frame_idx) 930 { 931 // At the toplevel we are done. 932 need_rethrow = TRUE; 933 if (handle_closure_in_use(&ectx, FALSE) == FAIL) 934 goto failed; 935 goto done; 936 } 937 938 if (func_return(&ectx) == FAIL) 939 goto failed; 940 } 941 continue; 942 } 943 944 iptr = &ectx.ec_instr[ectx.ec_iidx++]; 945 switch (iptr->isn_type) 946 { 947 // execute Ex command line 948 case ISN_EXEC: 949 SOURCING_LNUM = iptr->isn_lnum; 950 do_cmdline_cmd(iptr->isn_arg.string); 951 break; 952 953 // execute Ex command from pieces on the stack 954 case ISN_EXECCONCAT: 955 { 956 int count = iptr->isn_arg.number; 957 size_t len = 0; 958 int pass; 959 int i; 960 char_u *cmd = NULL; 961 char_u *str; 962 963 for (pass = 1; pass <= 2; ++pass) 964 { 965 for (i = 0; i < count; ++i) 966 { 967 tv = STACK_TV_BOT(i - count); 968 str = tv->vval.v_string; 969 if (str != NULL && *str != NUL) 970 { 971 if (pass == 2) 972 STRCPY(cmd + len, str); 973 len += STRLEN(str); 974 } 975 if (pass == 2) 976 clear_tv(tv); 977 } 978 if (pass == 1) 979 { 980 cmd = alloc(len + 1); 981 if (cmd == NULL) 982 goto failed; 983 len = 0; 984 } 985 } 986 987 SOURCING_LNUM = iptr->isn_lnum; 988 do_cmdline_cmd(cmd); 989 vim_free(cmd); 990 } 991 break; 992 993 // execute :echo {string} ... 994 case ISN_ECHO: 995 { 996 int count = iptr->isn_arg.echo.echo_count; 997 int atstart = TRUE; 998 int needclr = TRUE; 999 1000 for (idx = 0; idx < count; ++idx) 1001 { 1002 tv = STACK_TV_BOT(idx - count); 1003 echo_one(tv, iptr->isn_arg.echo.echo_with_white, 1004 &atstart, &needclr); 1005 clear_tv(tv); 1006 } 1007 if (needclr) 1008 msg_clr_eos(); 1009 ectx.ec_stack.ga_len -= count; 1010 } 1011 break; 1012 1013 // :execute {string} ... 1014 // :echomsg {string} ... 1015 // :echoerr {string} ... 1016 case ISN_EXECUTE: 1017 case ISN_ECHOMSG: 1018 case ISN_ECHOERR: 1019 { 1020 int count = iptr->isn_arg.number; 1021 garray_T ga; 1022 char_u buf[NUMBUFLEN]; 1023 char_u *p; 1024 int len; 1025 int failed = FALSE; 1026 1027 ga_init2(&ga, 1, 80); 1028 for (idx = 0; idx < count; ++idx) 1029 { 1030 tv = STACK_TV_BOT(idx - count); 1031 if (tv->v_type == VAR_CHANNEL || tv->v_type == VAR_JOB) 1032 { 1033 SOURCING_LNUM = iptr->isn_lnum; 1034 emsg(_(e_inval_string)); 1035 break; 1036 } 1037 else 1038 p = tv_get_string_buf(tv, buf); 1039 1040 len = (int)STRLEN(p); 1041 if (ga_grow(&ga, len + 2) == FAIL) 1042 failed = TRUE; 1043 else 1044 { 1045 if (ga.ga_len > 0) 1046 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' '; 1047 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p); 1048 ga.ga_len += len; 1049 } 1050 clear_tv(tv); 1051 } 1052 ectx.ec_stack.ga_len -= count; 1053 1054 if (!failed && ga.ga_data != NULL) 1055 { 1056 if (iptr->isn_type == ISN_EXECUTE) 1057 do_cmdline_cmd((char_u *)ga.ga_data); 1058 else 1059 { 1060 msg_sb_eol(); 1061 if (iptr->isn_type == ISN_ECHOMSG) 1062 { 1063 msg_attr(ga.ga_data, echo_attr); 1064 out_flush(); 1065 } 1066 else 1067 { 1068 SOURCING_LNUM = iptr->isn_lnum; 1069 emsg(ga.ga_data); 1070 } 1071 } 1072 } 1073 ga_clear(&ga); 1074 } 1075 break; 1076 1077 // load local variable or argument 1078 case ISN_LOAD: 1079 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1080 goto failed; 1081 copy_tv(STACK_TV_VAR(iptr->isn_arg.number), STACK_TV_BOT(0)); 1082 ++ectx.ec_stack.ga_len; 1083 break; 1084 1085 // load variable or argument from outer scope 1086 case ISN_LOADOUTER: 1087 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1088 goto failed; 1089 copy_tv(STACK_OUT_TV_VAR(iptr->isn_arg.number), 1090 STACK_TV_BOT(0)); 1091 ++ectx.ec_stack.ga_len; 1092 break; 1093 1094 // load v: variable 1095 case ISN_LOADV: 1096 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1097 goto failed; 1098 copy_tv(get_vim_var_tv(iptr->isn_arg.number), STACK_TV_BOT(0)); 1099 ++ectx.ec_stack.ga_len; 1100 break; 1101 1102 // load s: variable in Vim9 script 1103 case ISN_LOADSCRIPT: 1104 { 1105 scriptitem_T *si = 1106 SCRIPT_ITEM(iptr->isn_arg.script.script_sid); 1107 svar_T *sv; 1108 1109 sv = ((svar_T *)si->sn_var_vals.ga_data) 1110 + iptr->isn_arg.script.script_idx; 1111 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1112 goto failed; 1113 copy_tv(sv->sv_tv, STACK_TV_BOT(0)); 1114 ++ectx.ec_stack.ga_len; 1115 } 1116 break; 1117 1118 // load s: variable in old script 1119 case ISN_LOADS: 1120 { 1121 hashtab_T *ht = &SCRIPT_VARS( 1122 iptr->isn_arg.loadstore.ls_sid); 1123 char_u *name = iptr->isn_arg.loadstore.ls_name; 1124 dictitem_T *di = find_var_in_ht(ht, 0, name, TRUE); 1125 1126 if (di == NULL) 1127 { 1128 SOURCING_LNUM = iptr->isn_lnum; 1129 semsg(_(e_undefined_variable_str), name); 1130 goto on_error; 1131 } 1132 else 1133 { 1134 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1135 goto failed; 1136 copy_tv(&di->di_tv, STACK_TV_BOT(0)); 1137 ++ectx.ec_stack.ga_len; 1138 } 1139 } 1140 break; 1141 1142 // load g:/b:/w:/t: variable 1143 case ISN_LOADG: 1144 case ISN_LOADB: 1145 case ISN_LOADW: 1146 case ISN_LOADT: 1147 { 1148 dictitem_T *di = NULL; 1149 hashtab_T *ht = NULL; 1150 char namespace; 1151 1152 switch (iptr->isn_type) 1153 { 1154 case ISN_LOADG: 1155 ht = get_globvar_ht(); 1156 namespace = 'g'; 1157 break; 1158 case ISN_LOADB: 1159 ht = &curbuf->b_vars->dv_hashtab; 1160 namespace = 'b'; 1161 break; 1162 case ISN_LOADW: 1163 ht = &curwin->w_vars->dv_hashtab; 1164 namespace = 'w'; 1165 break; 1166 case ISN_LOADT: 1167 ht = &curtab->tp_vars->dv_hashtab; 1168 namespace = 't'; 1169 break; 1170 default: // Cannot reach here 1171 goto failed; 1172 } 1173 di = find_var_in_ht(ht, 0, iptr->isn_arg.string, TRUE); 1174 1175 if (di == NULL) 1176 { 1177 SOURCING_LNUM = iptr->isn_lnum; 1178 semsg(_(e_undefined_variable_char_str), 1179 namespace, iptr->isn_arg.string); 1180 goto on_error; 1181 } 1182 else 1183 { 1184 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1185 goto failed; 1186 copy_tv(&di->di_tv, STACK_TV_BOT(0)); 1187 ++ectx.ec_stack.ga_len; 1188 } 1189 } 1190 break; 1191 1192 // load g:/b:/w:/t: namespace 1193 case ISN_LOADGDICT: 1194 case ISN_LOADBDICT: 1195 case ISN_LOADWDICT: 1196 case ISN_LOADTDICT: 1197 { 1198 dict_T *d = NULL; 1199 1200 switch (iptr->isn_type) 1201 { 1202 case ISN_LOADGDICT: d = get_globvar_dict(); break; 1203 case ISN_LOADBDICT: d = curbuf->b_vars; break; 1204 case ISN_LOADWDICT: d = curwin->w_vars; break; 1205 case ISN_LOADTDICT: d = curtab->tp_vars; break; 1206 default: // Cannot reach here 1207 goto failed; 1208 } 1209 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1210 goto failed; 1211 tv = STACK_TV_BOT(0); 1212 tv->v_type = VAR_DICT; 1213 tv->v_lock = 0; 1214 tv->vval.v_dict = d; 1215 ++ectx.ec_stack.ga_len; 1216 } 1217 break; 1218 1219 // load &option 1220 case ISN_LOADOPT: 1221 { 1222 typval_T optval; 1223 char_u *name = iptr->isn_arg.string; 1224 1225 // This is not expected to fail, name is checked during 1226 // compilation: don't set SOURCING_LNUM. 1227 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1228 goto failed; 1229 if (eval_option(&name, &optval, TRUE) == FAIL) 1230 goto failed; 1231 *STACK_TV_BOT(0) = optval; 1232 ++ectx.ec_stack.ga_len; 1233 } 1234 break; 1235 1236 // load $ENV 1237 case ISN_LOADENV: 1238 { 1239 typval_T optval; 1240 char_u *name = iptr->isn_arg.string; 1241 1242 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1243 goto failed; 1244 // name is always valid, checked when compiling 1245 (void)eval_env_var(&name, &optval, TRUE); 1246 *STACK_TV_BOT(0) = optval; 1247 ++ectx.ec_stack.ga_len; 1248 } 1249 break; 1250 1251 // load @register 1252 case ISN_LOADREG: 1253 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1254 goto failed; 1255 tv = STACK_TV_BOT(0); 1256 tv->v_type = VAR_STRING; 1257 tv->v_lock = 0; 1258 tv->vval.v_string = get_reg_contents( 1259 iptr->isn_arg.number, GREG_EXPR_SRC); 1260 ++ectx.ec_stack.ga_len; 1261 break; 1262 1263 // store local variable 1264 case ISN_STORE: 1265 --ectx.ec_stack.ga_len; 1266 tv = STACK_TV_VAR(iptr->isn_arg.number); 1267 clear_tv(tv); 1268 *tv = *STACK_TV_BOT(0); 1269 break; 1270 1271 // store variable or argument in outer scope 1272 case ISN_STOREOUTER: 1273 --ectx.ec_stack.ga_len; 1274 tv = STACK_OUT_TV_VAR(iptr->isn_arg.number); 1275 clear_tv(tv); 1276 *tv = *STACK_TV_BOT(0); 1277 break; 1278 1279 // store s: variable in old script 1280 case ISN_STORES: 1281 { 1282 hashtab_T *ht = &SCRIPT_VARS( 1283 iptr->isn_arg.loadstore.ls_sid); 1284 char_u *name = iptr->isn_arg.loadstore.ls_name; 1285 dictitem_T *di = find_var_in_ht(ht, 0, name + 2, TRUE); 1286 1287 --ectx.ec_stack.ga_len; 1288 if (di == NULL) 1289 store_var(name, STACK_TV_BOT(0)); 1290 else 1291 { 1292 clear_tv(&di->di_tv); 1293 di->di_tv = *STACK_TV_BOT(0); 1294 } 1295 } 1296 break; 1297 1298 // store script-local variable in Vim9 script 1299 case ISN_STORESCRIPT: 1300 { 1301 scriptitem_T *si = SCRIPT_ITEM( 1302 iptr->isn_arg.script.script_sid); 1303 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) 1304 + iptr->isn_arg.script.script_idx; 1305 1306 --ectx.ec_stack.ga_len; 1307 clear_tv(sv->sv_tv); 1308 *sv->sv_tv = *STACK_TV_BOT(0); 1309 } 1310 break; 1311 1312 // store option 1313 case ISN_STOREOPT: 1314 { 1315 long n = 0; 1316 char_u *s = NULL; 1317 char *msg; 1318 1319 --ectx.ec_stack.ga_len; 1320 tv = STACK_TV_BOT(0); 1321 if (tv->v_type == VAR_STRING) 1322 { 1323 s = tv->vval.v_string; 1324 if (s == NULL) 1325 s = (char_u *)""; 1326 } 1327 else 1328 // must be VAR_NUMBER, CHECKTYPE makes sure 1329 n = tv->vval.v_number; 1330 msg = set_option_value(iptr->isn_arg.storeopt.so_name, 1331 n, s, iptr->isn_arg.storeopt.so_flags); 1332 clear_tv(tv); 1333 if (msg != NULL) 1334 { 1335 SOURCING_LNUM = iptr->isn_lnum; 1336 emsg(_(msg)); 1337 goto on_error; 1338 } 1339 } 1340 break; 1341 1342 // store $ENV 1343 case ISN_STOREENV: 1344 --ectx.ec_stack.ga_len; 1345 tv = STACK_TV_BOT(0); 1346 vim_setenv_ext(iptr->isn_arg.string, tv_get_string(tv)); 1347 clear_tv(tv); 1348 break; 1349 1350 // store @r 1351 case ISN_STOREREG: 1352 { 1353 int reg = iptr->isn_arg.number; 1354 1355 --ectx.ec_stack.ga_len; 1356 tv = STACK_TV_BOT(0); 1357 write_reg_contents(reg == '@' ? '"' : reg, 1358 tv_get_string(tv), -1, FALSE); 1359 clear_tv(tv); 1360 } 1361 break; 1362 1363 // store v: variable 1364 case ISN_STOREV: 1365 --ectx.ec_stack.ga_len; 1366 if (set_vim_var_tv(iptr->isn_arg.number, STACK_TV_BOT(0)) 1367 == FAIL) 1368 // should not happen, type is checked when compiling 1369 goto on_error; 1370 break; 1371 1372 // store g:/b:/w:/t: variable 1373 case ISN_STOREG: 1374 case ISN_STOREB: 1375 case ISN_STOREW: 1376 case ISN_STORET: 1377 { 1378 dictitem_T *di; 1379 hashtab_T *ht; 1380 switch (iptr->isn_type) 1381 { 1382 case ISN_STOREG: 1383 ht = get_globvar_ht(); 1384 break; 1385 case ISN_STOREB: 1386 ht = &curbuf->b_vars->dv_hashtab; 1387 break; 1388 case ISN_STOREW: 1389 ht = &curwin->w_vars->dv_hashtab; 1390 break; 1391 case ISN_STORET: 1392 ht = &curtab->tp_vars->dv_hashtab; 1393 break; 1394 default: // Cannot reach here 1395 goto failed; 1396 } 1397 1398 --ectx.ec_stack.ga_len; 1399 di = find_var_in_ht(ht, 0, iptr->isn_arg.string + 2, TRUE); 1400 if (di == NULL) 1401 store_var(iptr->isn_arg.string, STACK_TV_BOT(0)); 1402 else 1403 { 1404 clear_tv(&di->di_tv); 1405 di->di_tv = *STACK_TV_BOT(0); 1406 } 1407 } 1408 break; 1409 1410 // store number in local variable 1411 case ISN_STORENR: 1412 tv = STACK_TV_VAR(iptr->isn_arg.storenr.stnr_idx); 1413 clear_tv(tv); 1414 tv->v_type = VAR_NUMBER; 1415 tv->vval.v_number = iptr->isn_arg.storenr.stnr_val; 1416 break; 1417 1418 // store value in list variable 1419 case ISN_STORELIST: 1420 { 1421 typval_T *tv_idx = STACK_TV_BOT(-2); 1422 varnumber_T lidx = tv_idx->vval.v_number; 1423 typval_T *tv_list = STACK_TV_BOT(-1); 1424 list_T *list = tv_list->vval.v_list; 1425 1426 if (lidx < 0 && list->lv_len + lidx >= 0) 1427 // negative index is relative to the end 1428 lidx = list->lv_len + lidx; 1429 if (lidx < 0 || lidx > list->lv_len) 1430 { 1431 SOURCING_LNUM = iptr->isn_lnum; 1432 semsg(_(e_listidx), lidx); 1433 goto on_error; 1434 } 1435 tv = STACK_TV_BOT(-3); 1436 if (lidx < list->lv_len) 1437 { 1438 listitem_T *li = list_find(list, lidx); 1439 1440 // overwrite existing list item 1441 clear_tv(&li->li_tv); 1442 li->li_tv = *tv; 1443 } 1444 else 1445 { 1446 // append to list, only fails when out of memory 1447 if (list_append_tv(list, tv) == FAIL) 1448 goto failed; 1449 clear_tv(tv); 1450 } 1451 clear_tv(tv_idx); 1452 clear_tv(tv_list); 1453 ectx.ec_stack.ga_len -= 3; 1454 } 1455 break; 1456 1457 // store value in dict variable 1458 case ISN_STOREDICT: 1459 { 1460 typval_T *tv_key = STACK_TV_BOT(-2); 1461 char_u *key = tv_key->vval.v_string; 1462 typval_T *tv_dict = STACK_TV_BOT(-1); 1463 dict_T *dict = tv_dict->vval.v_dict; 1464 dictitem_T *di; 1465 1466 if (dict == NULL) 1467 { 1468 SOURCING_LNUM = iptr->isn_lnum; 1469 emsg(_(e_dictionary_not_set)); 1470 goto on_error; 1471 } 1472 if (key == NULL) 1473 key = (char_u *)""; 1474 tv = STACK_TV_BOT(-3); 1475 di = dict_find(dict, key, -1); 1476 if (di != NULL) 1477 { 1478 // overwrite existing value 1479 clear_tv(&di->di_tv); 1480 di->di_tv = *tv; 1481 } 1482 else 1483 { 1484 // add to dict, only fails when out of memory 1485 if (dict_add_tv(dict, (char *)key, tv) == FAIL) 1486 goto failed; 1487 clear_tv(tv); 1488 } 1489 clear_tv(tv_key); 1490 clear_tv(tv_dict); 1491 ectx.ec_stack.ga_len -= 3; 1492 } 1493 break; 1494 1495 // push constant 1496 case ISN_PUSHNR: 1497 case ISN_PUSHBOOL: 1498 case ISN_PUSHSPEC: 1499 case ISN_PUSHF: 1500 case ISN_PUSHS: 1501 case ISN_PUSHBLOB: 1502 case ISN_PUSHFUNC: 1503 case ISN_PUSHCHANNEL: 1504 case ISN_PUSHJOB: 1505 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1506 goto failed; 1507 tv = STACK_TV_BOT(0); 1508 tv->v_lock = 0; 1509 ++ectx.ec_stack.ga_len; 1510 switch (iptr->isn_type) 1511 { 1512 case ISN_PUSHNR: 1513 tv->v_type = VAR_NUMBER; 1514 tv->vval.v_number = iptr->isn_arg.number; 1515 break; 1516 case ISN_PUSHBOOL: 1517 tv->v_type = VAR_BOOL; 1518 tv->vval.v_number = iptr->isn_arg.number; 1519 break; 1520 case ISN_PUSHSPEC: 1521 tv->v_type = VAR_SPECIAL; 1522 tv->vval.v_number = iptr->isn_arg.number; 1523 break; 1524 #ifdef FEAT_FLOAT 1525 case ISN_PUSHF: 1526 tv->v_type = VAR_FLOAT; 1527 tv->vval.v_float = iptr->isn_arg.fnumber; 1528 break; 1529 #endif 1530 case ISN_PUSHBLOB: 1531 blob_copy(iptr->isn_arg.blob, tv); 1532 break; 1533 case ISN_PUSHFUNC: 1534 tv->v_type = VAR_FUNC; 1535 if (iptr->isn_arg.string == NULL) 1536 tv->vval.v_string = NULL; 1537 else 1538 tv->vval.v_string = 1539 vim_strsave(iptr->isn_arg.string); 1540 break; 1541 case ISN_PUSHCHANNEL: 1542 #ifdef FEAT_JOB_CHANNEL 1543 tv->v_type = VAR_CHANNEL; 1544 tv->vval.v_channel = iptr->isn_arg.channel; 1545 if (tv->vval.v_channel != NULL) 1546 ++tv->vval.v_channel->ch_refcount; 1547 #endif 1548 break; 1549 case ISN_PUSHJOB: 1550 #ifdef FEAT_JOB_CHANNEL 1551 tv->v_type = VAR_JOB; 1552 tv->vval.v_job = iptr->isn_arg.job; 1553 if (tv->vval.v_job != NULL) 1554 ++tv->vval.v_job->jv_refcount; 1555 #endif 1556 break; 1557 default: 1558 tv->v_type = VAR_STRING; 1559 tv->vval.v_string = vim_strsave( 1560 iptr->isn_arg.string == NULL 1561 ? (char_u *)"" : iptr->isn_arg.string); 1562 } 1563 break; 1564 1565 case ISN_UNLET: 1566 if (do_unlet(iptr->isn_arg.unlet.ul_name, 1567 iptr->isn_arg.unlet.ul_forceit) == FAIL) 1568 goto on_error; 1569 break; 1570 case ISN_UNLETENV: 1571 vim_unsetenv(iptr->isn_arg.unlet.ul_name); 1572 break; 1573 1574 // create a list from items on the stack; uses a single allocation 1575 // for the list header and the items 1576 case ISN_NEWLIST: 1577 if (exe_newlist(iptr->isn_arg.number, &ectx) == FAIL) 1578 goto failed; 1579 break; 1580 1581 // create a dict from items on the stack 1582 case ISN_NEWDICT: 1583 { 1584 int count = iptr->isn_arg.number; 1585 dict_T *dict = dict_alloc(); 1586 dictitem_T *item; 1587 1588 if (dict == NULL) 1589 goto failed; 1590 for (idx = 0; idx < count; ++idx) 1591 { 1592 // have already checked key type is VAR_STRING 1593 tv = STACK_TV_BOT(2 * (idx - count)); 1594 // check key is unique 1595 item = dict_find(dict, tv->vval.v_string, -1); 1596 if (item != NULL) 1597 { 1598 SOURCING_LNUM = iptr->isn_lnum; 1599 semsg(_(e_duplicate_key), tv->vval.v_string); 1600 dict_unref(dict); 1601 goto on_error; 1602 } 1603 item = dictitem_alloc(tv->vval.v_string); 1604 clear_tv(tv); 1605 if (item == NULL) 1606 { 1607 dict_unref(dict); 1608 goto failed; 1609 } 1610 item->di_tv = *STACK_TV_BOT(2 * (idx - count) + 1); 1611 item->di_tv.v_lock = 0; 1612 if (dict_add(dict, item) == FAIL) 1613 { 1614 // can this ever happen? 1615 dict_unref(dict); 1616 goto failed; 1617 } 1618 } 1619 1620 if (count > 0) 1621 ectx.ec_stack.ga_len -= 2 * count - 1; 1622 else if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1623 goto failed; 1624 else 1625 ++ectx.ec_stack.ga_len; 1626 tv = STACK_TV_BOT(-1); 1627 tv->v_type = VAR_DICT; 1628 tv->v_lock = 0; 1629 tv->vval.v_dict = dict; 1630 ++dict->dv_refcount; 1631 } 1632 break; 1633 1634 // call a :def function 1635 case ISN_DCALL: 1636 if (call_dfunc(iptr->isn_arg.dfunc.cdf_idx, 1637 iptr->isn_arg.dfunc.cdf_argcount, 1638 &ectx) == FAIL) 1639 goto on_error; 1640 break; 1641 1642 // call a builtin function 1643 case ISN_BCALL: 1644 SOURCING_LNUM = iptr->isn_lnum; 1645 if (call_bfunc(iptr->isn_arg.bfunc.cbf_idx, 1646 iptr->isn_arg.bfunc.cbf_argcount, 1647 &ectx) == FAIL) 1648 goto on_error; 1649 break; 1650 1651 // call a funcref or partial 1652 case ISN_PCALL: 1653 { 1654 cpfunc_T *pfunc = &iptr->isn_arg.pfunc; 1655 int r; 1656 typval_T partial_tv; 1657 1658 SOURCING_LNUM = iptr->isn_lnum; 1659 if (pfunc->cpf_top) 1660 { 1661 // funcref is above the arguments 1662 tv = STACK_TV_BOT(-pfunc->cpf_argcount - 1); 1663 } 1664 else 1665 { 1666 // Get the funcref from the stack. 1667 --ectx.ec_stack.ga_len; 1668 partial_tv = *STACK_TV_BOT(0); 1669 tv = &partial_tv; 1670 } 1671 r = call_partial(tv, pfunc->cpf_argcount, &ectx); 1672 if (tv == &partial_tv) 1673 clear_tv(&partial_tv); 1674 if (r == FAIL) 1675 goto on_error; 1676 } 1677 break; 1678 1679 case ISN_PCALL_END: 1680 // PCALL finished, arguments have been consumed and replaced by 1681 // the return value. Now clear the funcref from the stack, 1682 // and move the return value in its place. 1683 --ectx.ec_stack.ga_len; 1684 clear_tv(STACK_TV_BOT(-1)); 1685 *STACK_TV_BOT(-1) = *STACK_TV_BOT(0); 1686 break; 1687 1688 // call a user defined function or funcref/partial 1689 case ISN_UCALL: 1690 { 1691 cufunc_T *cufunc = &iptr->isn_arg.ufunc; 1692 1693 SOURCING_LNUM = iptr->isn_lnum; 1694 if (call_eval_func(cufunc->cuf_name, 1695 cufunc->cuf_argcount, &ectx, iptr) == FAIL) 1696 goto on_error; 1697 } 1698 break; 1699 1700 // return from a :def function call 1701 case ISN_RETURN: 1702 { 1703 garray_T *trystack = &ectx.ec_trystack; 1704 trycmd_T *trycmd = NULL; 1705 1706 if (trystack->ga_len > 0) 1707 trycmd = ((trycmd_T *)trystack->ga_data) 1708 + trystack->ga_len - 1; 1709 if (trycmd != NULL 1710 && trycmd->tcd_frame_idx == ectx.ec_frame_idx 1711 && trycmd->tcd_finally_idx != 0) 1712 { 1713 // jump to ":finally" 1714 ectx.ec_iidx = trycmd->tcd_finally_idx; 1715 trycmd->tcd_return = TRUE; 1716 } 1717 else 1718 goto func_return; 1719 } 1720 break; 1721 1722 // push a function reference to a compiled function 1723 case ISN_FUNCREF: 1724 { 1725 partial_T *pt = NULL; 1726 dfunc_T *pt_dfunc; 1727 1728 pt = ALLOC_CLEAR_ONE(partial_T); 1729 if (pt == NULL) 1730 goto failed; 1731 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1732 { 1733 vim_free(pt); 1734 goto failed; 1735 } 1736 pt_dfunc = ((dfunc_T *)def_functions.ga_data) 1737 + iptr->isn_arg.funcref.fr_func; 1738 pt->pt_func = pt_dfunc->df_ufunc; 1739 pt->pt_refcount = 1; 1740 ++pt_dfunc->df_ufunc->uf_refcount; 1741 1742 if (pt_dfunc->df_ufunc->uf_flags & FC_CLOSURE) 1743 { 1744 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 1745 + ectx.ec_dfunc_idx; 1746 1747 // The closure needs to find arguments and local 1748 // variables in the current stack. 1749 pt->pt_ectx_stack = &ectx.ec_stack; 1750 pt->pt_ectx_frame = ectx.ec_frame_idx; 1751 1752 // If this function returns and the closure is still 1753 // used, we need to make a copy of the context 1754 // (arguments and local variables). Store a reference 1755 // to the partial so we can handle that. 1756 ++pt->pt_refcount; 1757 tv = STACK_TV_VAR(dfunc->df_varcount 1758 + iptr->isn_arg.funcref.fr_var_idx); 1759 if (tv->v_type == VAR_PARTIAL) 1760 { 1761 // TODO: use a garray_T on ectx. 1762 SOURCING_LNUM = iptr->isn_lnum; 1763 emsg("Multiple closures not supported yet"); 1764 goto failed; 1765 } 1766 tv->v_type = VAR_PARTIAL; 1767 tv->vval.v_partial = pt; 1768 } 1769 1770 tv = STACK_TV_BOT(0); 1771 ++ectx.ec_stack.ga_len; 1772 tv->vval.v_partial = pt; 1773 tv->v_type = VAR_PARTIAL; 1774 tv->v_lock = 0; 1775 } 1776 break; 1777 1778 // Create a global function from a lambda. 1779 case ISN_NEWFUNC: 1780 { 1781 newfunc_T *newfunc = &iptr->isn_arg.newfunc; 1782 1783 copy_func(newfunc->nf_lambda, newfunc->nf_global); 1784 } 1785 break; 1786 1787 // jump if a condition is met 1788 case ISN_JUMP: 1789 { 1790 jumpwhen_T when = iptr->isn_arg.jump.jump_when; 1791 int jump = TRUE; 1792 1793 if (when != JUMP_ALWAYS) 1794 { 1795 tv = STACK_TV_BOT(-1); 1796 jump = tv2bool(tv); 1797 if (when == JUMP_IF_FALSE 1798 || when == JUMP_AND_KEEP_IF_FALSE) 1799 jump = !jump; 1800 if (when == JUMP_IF_FALSE || !jump) 1801 { 1802 // drop the value from the stack 1803 clear_tv(tv); 1804 --ectx.ec_stack.ga_len; 1805 } 1806 } 1807 if (jump) 1808 ectx.ec_iidx = iptr->isn_arg.jump.jump_where; 1809 } 1810 break; 1811 1812 // top of a for loop 1813 case ISN_FOR: 1814 { 1815 list_T *list = STACK_TV_BOT(-1)->vval.v_list; 1816 typval_T *idxtv = 1817 STACK_TV_VAR(iptr->isn_arg.forloop.for_idx); 1818 1819 // push the next item from the list 1820 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1821 goto failed; 1822 if (++idxtv->vval.v_number >= list->lv_len) 1823 // past the end of the list, jump to "endfor" 1824 ectx.ec_iidx = iptr->isn_arg.forloop.for_end; 1825 else if (list->lv_first == &range_list_item) 1826 { 1827 // non-materialized range() list 1828 tv = STACK_TV_BOT(0); 1829 tv->v_type = VAR_NUMBER; 1830 tv->v_lock = 0; 1831 tv->vval.v_number = list_find_nr( 1832 list, idxtv->vval.v_number, NULL); 1833 ++ectx.ec_stack.ga_len; 1834 } 1835 else 1836 { 1837 listitem_T *li = list_find(list, idxtv->vval.v_number); 1838 1839 copy_tv(&li->li_tv, STACK_TV_BOT(0)); 1840 ++ectx.ec_stack.ga_len; 1841 } 1842 } 1843 break; 1844 1845 // start of ":try" block 1846 case ISN_TRY: 1847 { 1848 trycmd_T *trycmd = NULL; 1849 1850 if (GA_GROW(&ectx.ec_trystack, 1) == FAIL) 1851 goto failed; 1852 trycmd = ((trycmd_T *)ectx.ec_trystack.ga_data) 1853 + ectx.ec_trystack.ga_len; 1854 ++ectx.ec_trystack.ga_len; 1855 ++trylevel; 1856 trycmd->tcd_frame_idx = ectx.ec_frame_idx; 1857 trycmd->tcd_catch_idx = iptr->isn_arg.try.try_catch; 1858 trycmd->tcd_finally_idx = iptr->isn_arg.try.try_finally; 1859 trycmd->tcd_caught = FALSE; 1860 } 1861 break; 1862 1863 case ISN_PUSHEXC: 1864 if (current_exception == NULL) 1865 { 1866 SOURCING_LNUM = iptr->isn_lnum; 1867 iemsg("Evaluating catch while current_exception is NULL"); 1868 goto failed; 1869 } 1870 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 1871 goto failed; 1872 tv = STACK_TV_BOT(0); 1873 ++ectx.ec_stack.ga_len; 1874 tv->v_type = VAR_STRING; 1875 tv->v_lock = 0; 1876 tv->vval.v_string = vim_strsave( 1877 (char_u *)current_exception->value); 1878 break; 1879 1880 case ISN_CATCH: 1881 { 1882 garray_T *trystack = &ectx.ec_trystack; 1883 1884 if (trystack->ga_len > 0) 1885 { 1886 trycmd_T *trycmd = ((trycmd_T *)trystack->ga_data) 1887 + trystack->ga_len - 1; 1888 trycmd->tcd_caught = TRUE; 1889 } 1890 did_emsg = got_int = did_throw = FALSE; 1891 catch_exception(current_exception); 1892 } 1893 break; 1894 1895 // end of ":try" block 1896 case ISN_ENDTRY: 1897 { 1898 garray_T *trystack = &ectx.ec_trystack; 1899 1900 if (trystack->ga_len > 0) 1901 { 1902 trycmd_T *trycmd = NULL; 1903 1904 --trystack->ga_len; 1905 --trylevel; 1906 ectx.ec_in_catch = FALSE; 1907 trycmd = ((trycmd_T *)trystack->ga_data) 1908 + trystack->ga_len; 1909 if (trycmd->tcd_caught && current_exception != NULL) 1910 { 1911 // discard the exception 1912 if (caught_stack == current_exception) 1913 caught_stack = caught_stack->caught; 1914 discard_current_exception(); 1915 } 1916 1917 if (trycmd->tcd_return) 1918 goto func_return; 1919 } 1920 } 1921 break; 1922 1923 case ISN_THROW: 1924 --ectx.ec_stack.ga_len; 1925 tv = STACK_TV_BOT(0); 1926 if (throw_exception(tv->vval.v_string, ET_USER, NULL) == FAIL) 1927 { 1928 vim_free(tv->vval.v_string); 1929 goto failed; 1930 } 1931 did_throw = TRUE; 1932 break; 1933 1934 // compare with special values 1935 case ISN_COMPAREBOOL: 1936 case ISN_COMPARESPECIAL: 1937 { 1938 typval_T *tv1 = STACK_TV_BOT(-2); 1939 typval_T *tv2 = STACK_TV_BOT(-1); 1940 varnumber_T arg1 = tv1->vval.v_number; 1941 varnumber_T arg2 = tv2->vval.v_number; 1942 int res; 1943 1944 switch (iptr->isn_arg.op.op_type) 1945 { 1946 case EXPR_EQUAL: res = arg1 == arg2; break; 1947 case EXPR_NEQUAL: res = arg1 != arg2; break; 1948 default: res = 0; break; 1949 } 1950 1951 --ectx.ec_stack.ga_len; 1952 tv1->v_type = VAR_BOOL; 1953 tv1->vval.v_number = res ? VVAL_TRUE : VVAL_FALSE; 1954 } 1955 break; 1956 1957 // Operation with two number arguments 1958 case ISN_OPNR: 1959 case ISN_COMPARENR: 1960 { 1961 typval_T *tv1 = STACK_TV_BOT(-2); 1962 typval_T *tv2 = STACK_TV_BOT(-1); 1963 varnumber_T arg1 = tv1->vval.v_number; 1964 varnumber_T arg2 = tv2->vval.v_number; 1965 varnumber_T res; 1966 1967 switch (iptr->isn_arg.op.op_type) 1968 { 1969 case EXPR_MULT: res = arg1 * arg2; break; 1970 case EXPR_DIV: res = arg1 / arg2; break; 1971 case EXPR_REM: res = arg1 % arg2; break; 1972 case EXPR_SUB: res = arg1 - arg2; break; 1973 case EXPR_ADD: res = arg1 + arg2; break; 1974 1975 case EXPR_EQUAL: res = arg1 == arg2; break; 1976 case EXPR_NEQUAL: res = arg1 != arg2; break; 1977 case EXPR_GREATER: res = arg1 > arg2; break; 1978 case EXPR_GEQUAL: res = arg1 >= arg2; break; 1979 case EXPR_SMALLER: res = arg1 < arg2; break; 1980 case EXPR_SEQUAL: res = arg1 <= arg2; break; 1981 default: res = 0; break; 1982 } 1983 1984 --ectx.ec_stack.ga_len; 1985 if (iptr->isn_type == ISN_COMPARENR) 1986 { 1987 tv1->v_type = VAR_BOOL; 1988 tv1->vval.v_number = res ? VVAL_TRUE : VVAL_FALSE; 1989 } 1990 else 1991 tv1->vval.v_number = res; 1992 } 1993 break; 1994 1995 // Computation with two float arguments 1996 case ISN_OPFLOAT: 1997 case ISN_COMPAREFLOAT: 1998 #ifdef FEAT_FLOAT 1999 { 2000 typval_T *tv1 = STACK_TV_BOT(-2); 2001 typval_T *tv2 = STACK_TV_BOT(-1); 2002 float_T arg1 = tv1->vval.v_float; 2003 float_T arg2 = tv2->vval.v_float; 2004 float_T res = 0; 2005 int cmp = FALSE; 2006 2007 switch (iptr->isn_arg.op.op_type) 2008 { 2009 case EXPR_MULT: res = arg1 * arg2; break; 2010 case EXPR_DIV: res = arg1 / arg2; break; 2011 case EXPR_SUB: res = arg1 - arg2; break; 2012 case EXPR_ADD: res = arg1 + arg2; break; 2013 2014 case EXPR_EQUAL: cmp = arg1 == arg2; break; 2015 case EXPR_NEQUAL: cmp = arg1 != arg2; break; 2016 case EXPR_GREATER: cmp = arg1 > arg2; break; 2017 case EXPR_GEQUAL: cmp = arg1 >= arg2; break; 2018 case EXPR_SMALLER: cmp = arg1 < arg2; break; 2019 case EXPR_SEQUAL: cmp = arg1 <= arg2; break; 2020 default: cmp = 0; break; 2021 } 2022 --ectx.ec_stack.ga_len; 2023 if (iptr->isn_type == ISN_COMPAREFLOAT) 2024 { 2025 tv1->v_type = VAR_BOOL; 2026 tv1->vval.v_number = cmp ? VVAL_TRUE : VVAL_FALSE; 2027 } 2028 else 2029 tv1->vval.v_float = res; 2030 } 2031 #endif 2032 break; 2033 2034 case ISN_COMPARELIST: 2035 { 2036 typval_T *tv1 = STACK_TV_BOT(-2); 2037 typval_T *tv2 = STACK_TV_BOT(-1); 2038 list_T *arg1 = tv1->vval.v_list; 2039 list_T *arg2 = tv2->vval.v_list; 2040 int cmp = FALSE; 2041 int ic = iptr->isn_arg.op.op_ic; 2042 2043 switch (iptr->isn_arg.op.op_type) 2044 { 2045 case EXPR_EQUAL: cmp = 2046 list_equal(arg1, arg2, ic, FALSE); break; 2047 case EXPR_NEQUAL: cmp = 2048 !list_equal(arg1, arg2, ic, FALSE); break; 2049 case EXPR_IS: cmp = arg1 == arg2; break; 2050 case EXPR_ISNOT: cmp = arg1 != arg2; break; 2051 default: cmp = 0; break; 2052 } 2053 --ectx.ec_stack.ga_len; 2054 clear_tv(tv1); 2055 clear_tv(tv2); 2056 tv1->v_type = VAR_BOOL; 2057 tv1->vval.v_number = cmp ? VVAL_TRUE : VVAL_FALSE; 2058 } 2059 break; 2060 2061 case ISN_COMPAREBLOB: 2062 { 2063 typval_T *tv1 = STACK_TV_BOT(-2); 2064 typval_T *tv2 = STACK_TV_BOT(-1); 2065 blob_T *arg1 = tv1->vval.v_blob; 2066 blob_T *arg2 = tv2->vval.v_blob; 2067 int cmp = FALSE; 2068 2069 switch (iptr->isn_arg.op.op_type) 2070 { 2071 case EXPR_EQUAL: cmp = blob_equal(arg1, arg2); break; 2072 case EXPR_NEQUAL: cmp = !blob_equal(arg1, arg2); break; 2073 case EXPR_IS: cmp = arg1 == arg2; break; 2074 case EXPR_ISNOT: cmp = arg1 != arg2; break; 2075 default: cmp = 0; break; 2076 } 2077 --ectx.ec_stack.ga_len; 2078 clear_tv(tv1); 2079 clear_tv(tv2); 2080 tv1->v_type = VAR_BOOL; 2081 tv1->vval.v_number = cmp ? VVAL_TRUE : VVAL_FALSE; 2082 } 2083 break; 2084 2085 // TODO: handle separately 2086 case ISN_COMPARESTRING: 2087 case ISN_COMPAREDICT: 2088 case ISN_COMPAREFUNC: 2089 case ISN_COMPAREANY: 2090 { 2091 typval_T *tv1 = STACK_TV_BOT(-2); 2092 typval_T *tv2 = STACK_TV_BOT(-1); 2093 exptype_T exptype = iptr->isn_arg.op.op_type; 2094 int ic = iptr->isn_arg.op.op_ic; 2095 2096 typval_compare(tv1, tv2, exptype, ic); 2097 clear_tv(tv2); 2098 --ectx.ec_stack.ga_len; 2099 } 2100 break; 2101 2102 case ISN_ADDLIST: 2103 case ISN_ADDBLOB: 2104 { 2105 typval_T *tv1 = STACK_TV_BOT(-2); 2106 typval_T *tv2 = STACK_TV_BOT(-1); 2107 2108 if (iptr->isn_type == ISN_ADDLIST) 2109 eval_addlist(tv1, tv2); 2110 else 2111 eval_addblob(tv1, tv2); 2112 clear_tv(tv2); 2113 --ectx.ec_stack.ga_len; 2114 } 2115 break; 2116 2117 // Computation with two arguments of unknown type 2118 case ISN_OPANY: 2119 { 2120 typval_T *tv1 = STACK_TV_BOT(-2); 2121 typval_T *tv2 = STACK_TV_BOT(-1); 2122 varnumber_T n1, n2; 2123 #ifdef FEAT_FLOAT 2124 float_T f1 = 0, f2 = 0; 2125 #endif 2126 int error = FALSE; 2127 2128 if (iptr->isn_arg.op.op_type == EXPR_ADD) 2129 { 2130 if (tv1->v_type == VAR_LIST && tv2->v_type == VAR_LIST) 2131 { 2132 eval_addlist(tv1, tv2); 2133 clear_tv(tv2); 2134 --ectx.ec_stack.ga_len; 2135 break; 2136 } 2137 else if (tv1->v_type == VAR_BLOB 2138 && tv2->v_type == VAR_BLOB) 2139 { 2140 eval_addblob(tv1, tv2); 2141 clear_tv(tv2); 2142 --ectx.ec_stack.ga_len; 2143 break; 2144 } 2145 } 2146 #ifdef FEAT_FLOAT 2147 if (tv1->v_type == VAR_FLOAT) 2148 { 2149 f1 = tv1->vval.v_float; 2150 n1 = 0; 2151 } 2152 else 2153 #endif 2154 { 2155 n1 = tv_get_number_chk(tv1, &error); 2156 if (error) 2157 goto on_error; 2158 #ifdef FEAT_FLOAT 2159 if (tv2->v_type == VAR_FLOAT) 2160 f1 = n1; 2161 #endif 2162 } 2163 #ifdef FEAT_FLOAT 2164 if (tv2->v_type == VAR_FLOAT) 2165 { 2166 f2 = tv2->vval.v_float; 2167 n2 = 0; 2168 } 2169 else 2170 #endif 2171 { 2172 n2 = tv_get_number_chk(tv2, &error); 2173 if (error) 2174 goto on_error; 2175 #ifdef FEAT_FLOAT 2176 if (tv1->v_type == VAR_FLOAT) 2177 f2 = n2; 2178 #endif 2179 } 2180 #ifdef FEAT_FLOAT 2181 // if there is a float on either side the result is a float 2182 if (tv1->v_type == VAR_FLOAT || tv2->v_type == VAR_FLOAT) 2183 { 2184 switch (iptr->isn_arg.op.op_type) 2185 { 2186 case EXPR_MULT: f1 = f1 * f2; break; 2187 case EXPR_DIV: f1 = f1 / f2; break; 2188 case EXPR_SUB: f1 = f1 - f2; break; 2189 case EXPR_ADD: f1 = f1 + f2; break; 2190 default: SOURCING_LNUM = iptr->isn_lnum; 2191 emsg(_(e_modulus)); 2192 goto on_error; 2193 } 2194 clear_tv(tv1); 2195 clear_tv(tv2); 2196 tv1->v_type = VAR_FLOAT; 2197 tv1->vval.v_float = f1; 2198 --ectx.ec_stack.ga_len; 2199 } 2200 else 2201 #endif 2202 { 2203 switch (iptr->isn_arg.op.op_type) 2204 { 2205 case EXPR_MULT: n1 = n1 * n2; break; 2206 case EXPR_DIV: n1 = num_divide(n1, n2); break; 2207 case EXPR_SUB: n1 = n1 - n2; break; 2208 case EXPR_ADD: n1 = n1 + n2; break; 2209 default: n1 = num_modulus(n1, n2); break; 2210 } 2211 clear_tv(tv1); 2212 clear_tv(tv2); 2213 tv1->v_type = VAR_NUMBER; 2214 tv1->vval.v_number = n1; 2215 --ectx.ec_stack.ga_len; 2216 } 2217 } 2218 break; 2219 2220 case ISN_CONCAT: 2221 { 2222 char_u *str1 = STACK_TV_BOT(-2)->vval.v_string; 2223 char_u *str2 = STACK_TV_BOT(-1)->vval.v_string; 2224 char_u *res; 2225 2226 res = concat_str(str1, str2); 2227 clear_tv(STACK_TV_BOT(-2)); 2228 clear_tv(STACK_TV_BOT(-1)); 2229 --ectx.ec_stack.ga_len; 2230 STACK_TV_BOT(-1)->vval.v_string = res; 2231 } 2232 break; 2233 2234 case ISN_STRINDEX: 2235 { 2236 varnumber_T n; 2237 char_u *res; 2238 2239 // string index: string is at stack-2, index at stack-1 2240 tv = STACK_TV_BOT(-2); 2241 if (tv->v_type != VAR_STRING) 2242 { 2243 SOURCING_LNUM = iptr->isn_lnum; 2244 emsg(_(e_stringreq)); 2245 goto on_error; 2246 } 2247 2248 tv = STACK_TV_BOT(-1); 2249 if (tv->v_type != VAR_NUMBER) 2250 { 2251 SOURCING_LNUM = iptr->isn_lnum; 2252 emsg(_(e_number_exp)); 2253 goto on_error; 2254 } 2255 n = tv->vval.v_number; 2256 2257 // The resulting variable is a string of a single 2258 // character. If the index is too big or negative the 2259 // result is empty. 2260 --ectx.ec_stack.ga_len; 2261 tv = STACK_TV_BOT(-1); 2262 res = char_from_string(tv->vval.v_string, n); 2263 vim_free(tv->vval.v_string); 2264 tv->vval.v_string = res; 2265 } 2266 break; 2267 2268 case ISN_LISTINDEX: 2269 { 2270 list_T *list; 2271 varnumber_T n; 2272 listitem_T *li; 2273 typval_T temp_tv; 2274 2275 // list index: list is at stack-2, index at stack-1 2276 tv = STACK_TV_BOT(-2); 2277 if (tv->v_type != VAR_LIST) 2278 { 2279 SOURCING_LNUM = iptr->isn_lnum; 2280 emsg(_(e_listreq)); 2281 goto on_error; 2282 } 2283 list = tv->vval.v_list; 2284 2285 tv = STACK_TV_BOT(-1); 2286 if (tv->v_type != VAR_NUMBER) 2287 { 2288 SOURCING_LNUM = iptr->isn_lnum; 2289 emsg(_(e_number_exp)); 2290 goto on_error; 2291 } 2292 n = tv->vval.v_number; 2293 clear_tv(tv); 2294 if ((li = list_find(list, n)) == NULL) 2295 { 2296 SOURCING_LNUM = iptr->isn_lnum; 2297 semsg(_(e_listidx), n); 2298 goto on_error; 2299 } 2300 --ectx.ec_stack.ga_len; 2301 // Clear the list after getting the item, to avoid that it 2302 // makes the item invalid. 2303 tv = STACK_TV_BOT(-1); 2304 temp_tv = *tv; 2305 copy_tv(&li->li_tv, tv); 2306 clear_tv(&temp_tv); 2307 } 2308 break; 2309 2310 case ISN_SLICE: 2311 { 2312 list_T *list; 2313 int count = iptr->isn_arg.number; 2314 2315 // type will have been checked to be a list 2316 tv = STACK_TV_BOT(-1); 2317 list = tv->vval.v_list; 2318 2319 // no error for short list, expect it to be checked earlier 2320 if (list != NULL && list->lv_len >= count) 2321 { 2322 list_T *newlist = list_slice(list, 2323 count, list->lv_len - 1); 2324 2325 if (newlist != NULL) 2326 { 2327 list_unref(list); 2328 tv->vval.v_list = newlist; 2329 ++newlist->lv_refcount; 2330 } 2331 } 2332 } 2333 break; 2334 2335 case ISN_GETITEM: 2336 { 2337 listitem_T *li; 2338 int index = iptr->isn_arg.number; 2339 2340 // Get list item: list is at stack-1, push item. 2341 // List type and length is checked for when compiling. 2342 tv = STACK_TV_BOT(-1); 2343 li = list_find(tv->vval.v_list, index); 2344 2345 if (GA_GROW(&ectx.ec_stack, 1) == FAIL) 2346 goto failed; 2347 ++ectx.ec_stack.ga_len; 2348 copy_tv(&li->li_tv, STACK_TV_BOT(-1)); 2349 } 2350 break; 2351 2352 case ISN_MEMBER: 2353 { 2354 dict_T *dict; 2355 char_u *key; 2356 dictitem_T *di; 2357 typval_T temp_tv; 2358 2359 // dict member: dict is at stack-2, key at stack-1 2360 tv = STACK_TV_BOT(-2); 2361 // no need to check for VAR_DICT, CHECKTYPE will check. 2362 dict = tv->vval.v_dict; 2363 2364 tv = STACK_TV_BOT(-1); 2365 // no need to check for VAR_STRING, 2STRING will check. 2366 key = tv->vval.v_string; 2367 2368 if ((di = dict_find(dict, key, -1)) == NULL) 2369 { 2370 SOURCING_LNUM = iptr->isn_lnum; 2371 semsg(_(e_dictkey), key); 2372 goto on_error; 2373 } 2374 clear_tv(tv); 2375 --ectx.ec_stack.ga_len; 2376 // Clear the dict after getting the item, to avoid that it 2377 // make the item invalid. 2378 tv = STACK_TV_BOT(-1); 2379 temp_tv = *tv; 2380 copy_tv(&di->di_tv, tv); 2381 clear_tv(&temp_tv); 2382 } 2383 break; 2384 2385 // dict member with string key 2386 case ISN_STRINGMEMBER: 2387 { 2388 dict_T *dict; 2389 dictitem_T *di; 2390 typval_T temp_tv; 2391 2392 tv = STACK_TV_BOT(-1); 2393 if (tv->v_type != VAR_DICT || tv->vval.v_dict == NULL) 2394 { 2395 SOURCING_LNUM = iptr->isn_lnum; 2396 emsg(_(e_dictreq)); 2397 goto on_error; 2398 } 2399 dict = tv->vval.v_dict; 2400 2401 if ((di = dict_find(dict, iptr->isn_arg.string, -1)) 2402 == NULL) 2403 { 2404 SOURCING_LNUM = iptr->isn_lnum; 2405 semsg(_(e_dictkey), iptr->isn_arg.string); 2406 goto on_error; 2407 } 2408 // Clear the dict after getting the item, to avoid that it 2409 // make the item invalid. 2410 temp_tv = *tv; 2411 copy_tv(&di->di_tv, tv); 2412 clear_tv(&temp_tv); 2413 } 2414 break; 2415 2416 case ISN_NEGATENR: 2417 tv = STACK_TV_BOT(-1); 2418 if (tv->v_type != VAR_NUMBER 2419 #ifdef FEAT_FLOAT 2420 && tv->v_type != VAR_FLOAT 2421 #endif 2422 ) 2423 { 2424 SOURCING_LNUM = iptr->isn_lnum; 2425 emsg(_(e_number_exp)); 2426 goto on_error; 2427 } 2428 #ifdef FEAT_FLOAT 2429 if (tv->v_type == VAR_FLOAT) 2430 tv->vval.v_float = -tv->vval.v_float; 2431 else 2432 #endif 2433 tv->vval.v_number = -tv->vval.v_number; 2434 break; 2435 2436 case ISN_CHECKNR: 2437 { 2438 int error = FALSE; 2439 2440 tv = STACK_TV_BOT(-1); 2441 if (check_not_string(tv) == FAIL) 2442 goto on_error; 2443 (void)tv_get_number_chk(tv, &error); 2444 if (error) 2445 goto on_error; 2446 } 2447 break; 2448 2449 case ISN_CHECKTYPE: 2450 { 2451 checktype_T *ct = &iptr->isn_arg.type; 2452 2453 tv = STACK_TV_BOT(ct->ct_off); 2454 // TODO: better type comparison 2455 if (tv->v_type != ct->ct_type 2456 && !((tv->v_type == VAR_PARTIAL 2457 && ct->ct_type == VAR_FUNC) 2458 || (tv->v_type == VAR_FUNC 2459 && ct->ct_type == VAR_PARTIAL))) 2460 { 2461 SOURCING_LNUM = iptr->isn_lnum; 2462 semsg(_(e_expected_str_but_got_str), 2463 vartype_name(ct->ct_type), 2464 vartype_name(tv->v_type)); 2465 goto on_error; 2466 } 2467 } 2468 break; 2469 2470 case ISN_CHECKLEN: 2471 { 2472 int min_len = iptr->isn_arg.checklen.cl_min_len; 2473 list_T *list = NULL; 2474 2475 tv = STACK_TV_BOT(-1); 2476 if (tv->v_type == VAR_LIST) 2477 list = tv->vval.v_list; 2478 if (list == NULL || list->lv_len < min_len 2479 || (list->lv_len > min_len 2480 && !iptr->isn_arg.checklen.cl_more_OK)) 2481 { 2482 SOURCING_LNUM = iptr->isn_lnum; 2483 semsg(_(e_expected_nr_items_but_got_nr), 2484 min_len, list == NULL ? 0 : list->lv_len); 2485 goto on_error; 2486 } 2487 } 2488 break; 2489 2490 case ISN_2BOOL: 2491 { 2492 int n; 2493 2494 tv = STACK_TV_BOT(-1); 2495 n = tv2bool(tv); 2496 if (iptr->isn_arg.number) // invert 2497 n = !n; 2498 clear_tv(tv); 2499 tv->v_type = VAR_BOOL; 2500 tv->vval.v_number = n ? VVAL_TRUE : VVAL_FALSE; 2501 } 2502 break; 2503 2504 case ISN_2STRING: 2505 case ISN_2STRING_ANY: 2506 { 2507 char_u *str; 2508 2509 tv = STACK_TV_BOT(iptr->isn_arg.number); 2510 if (tv->v_type != VAR_STRING) 2511 { 2512 if (iptr->isn_type == ISN_2STRING_ANY) 2513 { 2514 switch (tv->v_type) 2515 { 2516 case VAR_SPECIAL: 2517 case VAR_BOOL: 2518 case VAR_NUMBER: 2519 case VAR_FLOAT: 2520 case VAR_BLOB: break; 2521 default: to_string_error(tv->v_type); 2522 goto on_error; 2523 } 2524 } 2525 str = typval_tostring(tv); 2526 clear_tv(tv); 2527 tv->v_type = VAR_STRING; 2528 tv->vval.v_string = str; 2529 } 2530 } 2531 break; 2532 2533 case ISN_SHUFFLE: 2534 { 2535 typval_T tmp_tv; 2536 int item = iptr->isn_arg.shuffle.shfl_item; 2537 int up = iptr->isn_arg.shuffle.shfl_up; 2538 2539 tmp_tv = *STACK_TV_BOT(-item); 2540 for ( ; up > 0 && item > 1; --up) 2541 { 2542 *STACK_TV_BOT(-item) = *STACK_TV_BOT(-item + 1); 2543 --item; 2544 } 2545 *STACK_TV_BOT(-item) = tmp_tv; 2546 } 2547 break; 2548 2549 case ISN_DROP: 2550 --ectx.ec_stack.ga_len; 2551 clear_tv(STACK_TV_BOT(0)); 2552 break; 2553 } 2554 continue; 2555 2556 func_return: 2557 // Restore previous function. If the frame pointer is zero then there 2558 // is none and we are done. 2559 if (ectx.ec_frame_idx == initial_frame_idx) 2560 { 2561 if (handle_closure_in_use(&ectx, FALSE) == FAIL) 2562 // only fails when out of memory 2563 goto failed; 2564 goto done; 2565 } 2566 if (func_return(&ectx) == FAIL) 2567 // only fails when out of memory 2568 goto failed; 2569 continue; 2570 2571 on_error: 2572 if (trylevel == 0) 2573 goto failed; 2574 } 2575 2576 done: 2577 // function finished, get result from the stack. 2578 tv = STACK_TV_BOT(-1); 2579 *rettv = *tv; 2580 tv->v_type = VAR_UNKNOWN; 2581 ret = OK; 2582 2583 failed: 2584 // When failed need to unwind the call stack. 2585 while (ectx.ec_frame_idx != initial_frame_idx) 2586 func_return(&ectx); 2587 failed_early: 2588 current_sctx.sc_version = save_sc_version; 2589 2590 // Free all local variables, but not arguments. 2591 for (idx = 0; idx < ectx.ec_stack.ga_len; ++idx) 2592 clear_tv(STACK_TV(idx)); 2593 2594 vim_free(ectx.ec_stack.ga_data); 2595 vim_free(ectx.ec_trystack.ga_data); 2596 2597 if (ret != OK && called_emsg == called_emsg_before) 2598 semsg(_(e_unknown_error_while_executing_str), 2599 printable_func_name(ufunc)); 2600 return ret; 2601 } 2602 2603 /* 2604 * ":dissassemble". 2605 * We don't really need this at runtime, but we do have tests that require it, 2606 * so always include this. 2607 */ 2608 void 2609 ex_disassemble(exarg_T *eap) 2610 { 2611 char_u *arg = eap->arg; 2612 char_u *fname; 2613 ufunc_T *ufunc; 2614 dfunc_T *dfunc; 2615 isn_T *instr; 2616 int current; 2617 int line_idx = 0; 2618 int prev_current = 0; 2619 int is_global = FALSE; 2620 2621 if (STRNCMP(arg, "<lambda>", 8) == 0) 2622 { 2623 arg += 8; 2624 (void)getdigits(&arg); 2625 fname = vim_strnsave(eap->arg, arg - eap->arg); 2626 } 2627 else 2628 fname = trans_function_name(&arg, &is_global, FALSE, 2629 TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD, NULL, NULL); 2630 if (fname == NULL) 2631 { 2632 semsg(_(e_invarg2), eap->arg); 2633 return; 2634 } 2635 2636 ufunc = find_func(fname, is_global, NULL); 2637 if (ufunc == NULL) 2638 { 2639 char_u *p = untrans_function_name(fname); 2640 2641 if (p != NULL) 2642 // Try again without making it script-local. 2643 ufunc = find_func(p, FALSE, NULL); 2644 } 2645 vim_free(fname); 2646 if (ufunc == NULL) 2647 { 2648 semsg(_(e_cannot_find_function_str), eap->arg); 2649 return; 2650 } 2651 if (ufunc->uf_def_status == UF_TO_BE_COMPILED 2652 && compile_def_function(ufunc, FALSE, NULL) == FAIL) 2653 return; 2654 if (ufunc->uf_def_status != UF_COMPILED) 2655 { 2656 semsg(_(e_function_is_not_compiled_str), eap->arg); 2657 return; 2658 } 2659 if (ufunc->uf_name_exp != NULL) 2660 msg((char *)ufunc->uf_name_exp); 2661 else 2662 msg((char *)ufunc->uf_name); 2663 2664 dfunc = ((dfunc_T *)def_functions.ga_data) + ufunc->uf_dfunc_idx; 2665 instr = dfunc->df_instr; 2666 for (current = 0; current < dfunc->df_instr_count; ++current) 2667 { 2668 isn_T *iptr = &instr[current]; 2669 char *line; 2670 2671 while (line_idx < iptr->isn_lnum && line_idx < ufunc->uf_lines.ga_len) 2672 { 2673 if (current > prev_current) 2674 { 2675 msg_puts("\n\n"); 2676 prev_current = current; 2677 } 2678 line = ((char **)ufunc->uf_lines.ga_data)[line_idx++]; 2679 if (line != NULL) 2680 msg(line); 2681 } 2682 2683 switch (iptr->isn_type) 2684 { 2685 case ISN_EXEC: 2686 smsg("%4d EXEC %s", current, iptr->isn_arg.string); 2687 break; 2688 case ISN_EXECCONCAT: 2689 smsg("%4d EXECCONCAT %lld", current, 2690 (long long)iptr->isn_arg.number); 2691 break; 2692 case ISN_ECHO: 2693 { 2694 echo_T *echo = &iptr->isn_arg.echo; 2695 2696 smsg("%4d %s %d", current, 2697 echo->echo_with_white ? "ECHO" : "ECHON", 2698 echo->echo_count); 2699 } 2700 break; 2701 case ISN_EXECUTE: 2702 smsg("%4d EXECUTE %lld", current, 2703 (long long)(iptr->isn_arg.number)); 2704 break; 2705 case ISN_ECHOMSG: 2706 smsg("%4d ECHOMSG %lld", current, 2707 (long long)(iptr->isn_arg.number)); 2708 break; 2709 case ISN_ECHOERR: 2710 smsg("%4d ECHOERR %lld", current, 2711 (long long)(iptr->isn_arg.number)); 2712 break; 2713 case ISN_LOAD: 2714 case ISN_LOADOUTER: 2715 { 2716 char *add = iptr->isn_type == ISN_LOAD ? "" : "OUTER"; 2717 2718 if (iptr->isn_arg.number < 0) 2719 smsg("%4d LOAD%s arg[%lld]", current, add, 2720 (long long)(iptr->isn_arg.number 2721 + STACK_FRAME_SIZE)); 2722 else 2723 smsg("%4d LOAD%s $%lld", current, add, 2724 (long long)(iptr->isn_arg.number)); 2725 } 2726 break; 2727 case ISN_LOADV: 2728 smsg("%4d LOADV v:%s", current, 2729 get_vim_var_name(iptr->isn_arg.number)); 2730 break; 2731 case ISN_LOADSCRIPT: 2732 { 2733 scriptitem_T *si = 2734 SCRIPT_ITEM(iptr->isn_arg.script.script_sid); 2735 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) 2736 + iptr->isn_arg.script.script_idx; 2737 2738 smsg("%4d LOADSCRIPT %s from %s", current, 2739 sv->sv_name, si->sn_name); 2740 } 2741 break; 2742 case ISN_LOADS: 2743 { 2744 scriptitem_T *si = SCRIPT_ITEM( 2745 iptr->isn_arg.loadstore.ls_sid); 2746 2747 smsg("%4d LOADS s:%s from %s", current, 2748 iptr->isn_arg.loadstore.ls_name, si->sn_name); 2749 } 2750 break; 2751 case ISN_LOADG: 2752 smsg("%4d LOADG g:%s", current, iptr->isn_arg.string); 2753 break; 2754 case ISN_LOADB: 2755 smsg("%4d LOADB b:%s", current, iptr->isn_arg.string); 2756 break; 2757 case ISN_LOADW: 2758 smsg("%4d LOADW w:%s", current, iptr->isn_arg.string); 2759 break; 2760 case ISN_LOADT: 2761 smsg("%4d LOADT t:%s", current, iptr->isn_arg.string); 2762 break; 2763 case ISN_LOADGDICT: 2764 smsg("%4d LOAD g:", current); 2765 break; 2766 case ISN_LOADBDICT: 2767 smsg("%4d LOAD b:", current); 2768 break; 2769 case ISN_LOADWDICT: 2770 smsg("%4d LOAD w:", current); 2771 break; 2772 case ISN_LOADTDICT: 2773 smsg("%4d LOAD t:", current); 2774 break; 2775 case ISN_LOADOPT: 2776 smsg("%4d LOADOPT %s", current, iptr->isn_arg.string); 2777 break; 2778 case ISN_LOADENV: 2779 smsg("%4d LOADENV %s", current, iptr->isn_arg.string); 2780 break; 2781 case ISN_LOADREG: 2782 smsg("%4d LOADREG @%c", current, (int)(iptr->isn_arg.number)); 2783 break; 2784 2785 case ISN_STORE: 2786 case ISN_STOREOUTER: 2787 { 2788 char *add = iptr->isn_type == ISN_STORE ? "" : "OUTER"; 2789 2790 if (iptr->isn_arg.number < 0) 2791 smsg("%4d STORE%s arg[%lld]", current, add, 2792 (long long)(iptr->isn_arg.number + STACK_FRAME_SIZE)); 2793 else 2794 smsg("%4d STORE%s $%lld", current, add, 2795 (long long)(iptr->isn_arg.number)); 2796 } 2797 break; 2798 case ISN_STOREV: 2799 smsg("%4d STOREV v:%s", current, 2800 get_vim_var_name(iptr->isn_arg.number)); 2801 break; 2802 case ISN_STOREG: 2803 smsg("%4d STOREG %s", current, iptr->isn_arg.string); 2804 break; 2805 case ISN_STOREB: 2806 smsg("%4d STOREB %s", current, iptr->isn_arg.string); 2807 break; 2808 case ISN_STOREW: 2809 smsg("%4d STOREW %s", current, iptr->isn_arg.string); 2810 break; 2811 case ISN_STORET: 2812 smsg("%4d STORET %s", current, iptr->isn_arg.string); 2813 break; 2814 case ISN_STORES: 2815 { 2816 scriptitem_T *si = SCRIPT_ITEM( 2817 iptr->isn_arg.loadstore.ls_sid); 2818 2819 smsg("%4d STORES %s in %s", current, 2820 iptr->isn_arg.loadstore.ls_name, si->sn_name); 2821 } 2822 break; 2823 case ISN_STORESCRIPT: 2824 { 2825 scriptitem_T *si = 2826 SCRIPT_ITEM(iptr->isn_arg.script.script_sid); 2827 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) 2828 + iptr->isn_arg.script.script_idx; 2829 2830 smsg("%4d STORESCRIPT %s in %s", current, 2831 sv->sv_name, si->sn_name); 2832 } 2833 break; 2834 case ISN_STOREOPT: 2835 smsg("%4d STOREOPT &%s", current, 2836 iptr->isn_arg.storeopt.so_name); 2837 break; 2838 case ISN_STOREENV: 2839 smsg("%4d STOREENV $%s", current, iptr->isn_arg.string); 2840 break; 2841 case ISN_STOREREG: 2842 smsg("%4d STOREREG @%c", current, (int)iptr->isn_arg.number); 2843 break; 2844 case ISN_STORENR: 2845 smsg("%4d STORE %lld in $%d", current, 2846 iptr->isn_arg.storenr.stnr_val, 2847 iptr->isn_arg.storenr.stnr_idx); 2848 break; 2849 2850 case ISN_STORELIST: 2851 smsg("%4d STORELIST", current); 2852 break; 2853 2854 case ISN_STOREDICT: 2855 smsg("%4d STOREDICT", current); 2856 break; 2857 2858 // constants 2859 case ISN_PUSHNR: 2860 smsg("%4d PUSHNR %lld", current, 2861 (long long)(iptr->isn_arg.number)); 2862 break; 2863 case ISN_PUSHBOOL: 2864 case ISN_PUSHSPEC: 2865 smsg("%4d PUSH %s", current, 2866 get_var_special_name(iptr->isn_arg.number)); 2867 break; 2868 case ISN_PUSHF: 2869 #ifdef FEAT_FLOAT 2870 smsg("%4d PUSHF %g", current, iptr->isn_arg.fnumber); 2871 #endif 2872 break; 2873 case ISN_PUSHS: 2874 smsg("%4d PUSHS \"%s\"", current, iptr->isn_arg.string); 2875 break; 2876 case ISN_PUSHBLOB: 2877 { 2878 char_u *r; 2879 char_u numbuf[NUMBUFLEN]; 2880 char_u *tofree; 2881 2882 r = blob2string(iptr->isn_arg.blob, &tofree, numbuf); 2883 smsg("%4d PUSHBLOB %s", current, r); 2884 vim_free(tofree); 2885 } 2886 break; 2887 case ISN_PUSHFUNC: 2888 { 2889 char *name = (char *)iptr->isn_arg.string; 2890 2891 smsg("%4d PUSHFUNC \"%s\"", current, 2892 name == NULL ? "[none]" : name); 2893 } 2894 break; 2895 case ISN_PUSHCHANNEL: 2896 #ifdef FEAT_JOB_CHANNEL 2897 { 2898 channel_T *channel = iptr->isn_arg.channel; 2899 2900 smsg("%4d PUSHCHANNEL %d", current, 2901 channel == NULL ? 0 : channel->ch_id); 2902 } 2903 #endif 2904 break; 2905 case ISN_PUSHJOB: 2906 #ifdef FEAT_JOB_CHANNEL 2907 { 2908 typval_T tv; 2909 char_u *name; 2910 2911 tv.v_type = VAR_JOB; 2912 tv.vval.v_job = iptr->isn_arg.job; 2913 name = tv_get_string(&tv); 2914 smsg("%4d PUSHJOB \"%s\"", current, name); 2915 } 2916 #endif 2917 break; 2918 case ISN_PUSHEXC: 2919 smsg("%4d PUSH v:exception", current); 2920 break; 2921 case ISN_UNLET: 2922 smsg("%4d UNLET%s %s", current, 2923 iptr->isn_arg.unlet.ul_forceit ? "!" : "", 2924 iptr->isn_arg.unlet.ul_name); 2925 break; 2926 case ISN_UNLETENV: 2927 smsg("%4d UNLETENV%s $%s", current, 2928 iptr->isn_arg.unlet.ul_forceit ? "!" : "", 2929 iptr->isn_arg.unlet.ul_name); 2930 break; 2931 case ISN_NEWLIST: 2932 smsg("%4d NEWLIST size %lld", current, 2933 (long long)(iptr->isn_arg.number)); 2934 break; 2935 case ISN_NEWDICT: 2936 smsg("%4d NEWDICT size %lld", current, 2937 (long long)(iptr->isn_arg.number)); 2938 break; 2939 2940 // function call 2941 case ISN_BCALL: 2942 { 2943 cbfunc_T *cbfunc = &iptr->isn_arg.bfunc; 2944 2945 smsg("%4d BCALL %s(argc %d)", current, 2946 internal_func_name(cbfunc->cbf_idx), 2947 cbfunc->cbf_argcount); 2948 } 2949 break; 2950 case ISN_DCALL: 2951 { 2952 cdfunc_T *cdfunc = &iptr->isn_arg.dfunc; 2953 dfunc_T *df = ((dfunc_T *)def_functions.ga_data) 2954 + cdfunc->cdf_idx; 2955 2956 smsg("%4d DCALL %s(argc %d)", current, 2957 df->df_ufunc->uf_name_exp != NULL 2958 ? df->df_ufunc->uf_name_exp 2959 : df->df_ufunc->uf_name, cdfunc->cdf_argcount); 2960 } 2961 break; 2962 case ISN_UCALL: 2963 { 2964 cufunc_T *cufunc = &iptr->isn_arg.ufunc; 2965 2966 smsg("%4d UCALL %s(argc %d)", current, 2967 cufunc->cuf_name, cufunc->cuf_argcount); 2968 } 2969 break; 2970 case ISN_PCALL: 2971 { 2972 cpfunc_T *cpfunc = &iptr->isn_arg.pfunc; 2973 2974 smsg("%4d PCALL%s (argc %d)", current, 2975 cpfunc->cpf_top ? " top" : "", cpfunc->cpf_argcount); 2976 } 2977 break; 2978 case ISN_PCALL_END: 2979 smsg("%4d PCALL end", current); 2980 break; 2981 case ISN_RETURN: 2982 smsg("%4d RETURN", current); 2983 break; 2984 case ISN_FUNCREF: 2985 { 2986 funcref_T *funcref = &iptr->isn_arg.funcref; 2987 dfunc_T *df = ((dfunc_T *)def_functions.ga_data) 2988 + funcref->fr_func; 2989 2990 smsg("%4d FUNCREF %s $%d", current, df->df_ufunc->uf_name, 2991 funcref->fr_var_idx + dfunc->df_varcount); 2992 } 2993 break; 2994 2995 case ISN_NEWFUNC: 2996 { 2997 newfunc_T *newfunc = &iptr->isn_arg.newfunc; 2998 2999 smsg("%4d NEWFUNC %s %s", current, 3000 newfunc->nf_lambda, newfunc->nf_global); 3001 } 3002 break; 3003 3004 case ISN_JUMP: 3005 { 3006 char *when = "?"; 3007 3008 switch (iptr->isn_arg.jump.jump_when) 3009 { 3010 case JUMP_ALWAYS: 3011 when = "JUMP"; 3012 break; 3013 case JUMP_AND_KEEP_IF_TRUE: 3014 when = "JUMP_AND_KEEP_IF_TRUE"; 3015 break; 3016 case JUMP_IF_FALSE: 3017 when = "JUMP_IF_FALSE"; 3018 break; 3019 case JUMP_AND_KEEP_IF_FALSE: 3020 when = "JUMP_AND_KEEP_IF_FALSE"; 3021 break; 3022 } 3023 smsg("%4d %s -> %d", current, when, 3024 iptr->isn_arg.jump.jump_where); 3025 } 3026 break; 3027 3028 case ISN_FOR: 3029 { 3030 forloop_T *forloop = &iptr->isn_arg.forloop; 3031 3032 smsg("%4d FOR $%d -> %d", current, 3033 forloop->for_idx, forloop->for_end); 3034 } 3035 break; 3036 3037 case ISN_TRY: 3038 { 3039 try_T *try = &iptr->isn_arg.try; 3040 3041 smsg("%4d TRY catch -> %d, finally -> %d", current, 3042 try->try_catch, try->try_finally); 3043 } 3044 break; 3045 case ISN_CATCH: 3046 // TODO 3047 smsg("%4d CATCH", current); 3048 break; 3049 case ISN_ENDTRY: 3050 smsg("%4d ENDTRY", current); 3051 break; 3052 case ISN_THROW: 3053 smsg("%4d THROW", current); 3054 break; 3055 3056 // expression operations on number 3057 case ISN_OPNR: 3058 case ISN_OPFLOAT: 3059 case ISN_OPANY: 3060 { 3061 char *what; 3062 char *ins; 3063 3064 switch (iptr->isn_arg.op.op_type) 3065 { 3066 case EXPR_MULT: what = "*"; break; 3067 case EXPR_DIV: what = "/"; break; 3068 case EXPR_REM: what = "%"; break; 3069 case EXPR_SUB: what = "-"; break; 3070 case EXPR_ADD: what = "+"; break; 3071 default: what = "???"; break; 3072 } 3073 switch (iptr->isn_type) 3074 { 3075 case ISN_OPNR: ins = "OPNR"; break; 3076 case ISN_OPFLOAT: ins = "OPFLOAT"; break; 3077 case ISN_OPANY: ins = "OPANY"; break; 3078 default: ins = "???"; break; 3079 } 3080 smsg("%4d %s %s", current, ins, what); 3081 } 3082 break; 3083 3084 case ISN_COMPAREBOOL: 3085 case ISN_COMPARESPECIAL: 3086 case ISN_COMPARENR: 3087 case ISN_COMPAREFLOAT: 3088 case ISN_COMPARESTRING: 3089 case ISN_COMPAREBLOB: 3090 case ISN_COMPARELIST: 3091 case ISN_COMPAREDICT: 3092 case ISN_COMPAREFUNC: 3093 case ISN_COMPAREANY: 3094 { 3095 char *p; 3096 char buf[10]; 3097 char *type; 3098 3099 switch (iptr->isn_arg.op.op_type) 3100 { 3101 case EXPR_EQUAL: p = "=="; break; 3102 case EXPR_NEQUAL: p = "!="; break; 3103 case EXPR_GREATER: p = ">"; break; 3104 case EXPR_GEQUAL: p = ">="; break; 3105 case EXPR_SMALLER: p = "<"; break; 3106 case EXPR_SEQUAL: p = "<="; break; 3107 case EXPR_MATCH: p = "=~"; break; 3108 case EXPR_IS: p = "is"; break; 3109 case EXPR_ISNOT: p = "isnot"; break; 3110 case EXPR_NOMATCH: p = "!~"; break; 3111 default: p = "???"; break; 3112 } 3113 STRCPY(buf, p); 3114 if (iptr->isn_arg.op.op_ic == TRUE) 3115 strcat(buf, "?"); 3116 switch(iptr->isn_type) 3117 { 3118 case ISN_COMPAREBOOL: type = "COMPAREBOOL"; break; 3119 case ISN_COMPARESPECIAL: 3120 type = "COMPARESPECIAL"; break; 3121 case ISN_COMPARENR: type = "COMPARENR"; break; 3122 case ISN_COMPAREFLOAT: type = "COMPAREFLOAT"; break; 3123 case ISN_COMPARESTRING: 3124 type = "COMPARESTRING"; break; 3125 case ISN_COMPAREBLOB: type = "COMPAREBLOB"; break; 3126 case ISN_COMPARELIST: type = "COMPARELIST"; break; 3127 case ISN_COMPAREDICT: type = "COMPAREDICT"; break; 3128 case ISN_COMPAREFUNC: type = "COMPAREFUNC"; break; 3129 case ISN_COMPAREANY: type = "COMPAREANY"; break; 3130 default: type = "???"; break; 3131 } 3132 3133 smsg("%4d %s %s", current, type, buf); 3134 } 3135 break; 3136 3137 case ISN_ADDLIST: smsg("%4d ADDLIST", current); break; 3138 case ISN_ADDBLOB: smsg("%4d ADDBLOB", current); break; 3139 3140 // expression operations 3141 case ISN_CONCAT: smsg("%4d CONCAT", current); break; 3142 case ISN_STRINDEX: smsg("%4d STRINDEX", current); break; 3143 case ISN_LISTINDEX: smsg("%4d LISTINDEX", current); break; 3144 case ISN_SLICE: smsg("%4d SLICE %lld", 3145 current, iptr->isn_arg.number); break; 3146 case ISN_GETITEM: smsg("%4d ITEM %lld", 3147 current, iptr->isn_arg.number); break; 3148 case ISN_MEMBER: smsg("%4d MEMBER", current); break; 3149 case ISN_STRINGMEMBER: smsg("%4d MEMBER %s", current, 3150 iptr->isn_arg.string); break; 3151 case ISN_NEGATENR: smsg("%4d NEGATENR", current); break; 3152 3153 case ISN_CHECKNR: smsg("%4d CHECKNR", current); break; 3154 case ISN_CHECKTYPE: smsg("%4d CHECKTYPE %s stack[%d]", current, 3155 vartype_name(iptr->isn_arg.type.ct_type), 3156 iptr->isn_arg.type.ct_off); 3157 break; 3158 case ISN_CHECKLEN: smsg("%4d CHECKLEN %s%d", current, 3159 iptr->isn_arg.checklen.cl_more_OK ? ">= " : "", 3160 iptr->isn_arg.checklen.cl_min_len); 3161 break; 3162 case ISN_2BOOL: if (iptr->isn_arg.number) 3163 smsg("%4d INVERT (!val)", current); 3164 else 3165 smsg("%4d 2BOOL (!!val)", current); 3166 break; 3167 case ISN_2STRING: smsg("%4d 2STRING stack[%lld]", current, 3168 (long long)(iptr->isn_arg.number)); 3169 break; 3170 case ISN_2STRING_ANY: smsg("%4d 2STRING_ANY stack[%lld]", current, 3171 (long long)(iptr->isn_arg.number)); 3172 break; 3173 3174 case ISN_SHUFFLE: smsg("%4d SHUFFLE %d up %d", current, 3175 iptr->isn_arg.shuffle.shfl_item, 3176 iptr->isn_arg.shuffle.shfl_up); 3177 break; 3178 case ISN_DROP: smsg("%4d DROP", current); break; 3179 } 3180 3181 out_flush(); // output one line at a time 3182 ui_breakcheck(); 3183 if (got_int) 3184 break; 3185 } 3186 } 3187 3188 /* 3189 * Return TRUE when "tv" is not falsey: non-zero, non-empty string, non-empty 3190 * list, etc. Mostly like what JavaScript does, except that empty list and 3191 * empty dictionary are FALSE. 3192 */ 3193 int 3194 tv2bool(typval_T *tv) 3195 { 3196 switch (tv->v_type) 3197 { 3198 case VAR_NUMBER: 3199 return tv->vval.v_number != 0; 3200 case VAR_FLOAT: 3201 #ifdef FEAT_FLOAT 3202 return tv->vval.v_float != 0.0; 3203 #else 3204 break; 3205 #endif 3206 case VAR_PARTIAL: 3207 return tv->vval.v_partial != NULL; 3208 case VAR_FUNC: 3209 case VAR_STRING: 3210 return tv->vval.v_string != NULL && *tv->vval.v_string != NUL; 3211 case VAR_LIST: 3212 return tv->vval.v_list != NULL && tv->vval.v_list->lv_len > 0; 3213 case VAR_DICT: 3214 return tv->vval.v_dict != NULL 3215 && tv->vval.v_dict->dv_hashtab.ht_used > 0; 3216 case VAR_BOOL: 3217 case VAR_SPECIAL: 3218 return tv->vval.v_number == VVAL_TRUE ? TRUE : FALSE; 3219 case VAR_JOB: 3220 #ifdef FEAT_JOB_CHANNEL 3221 return tv->vval.v_job != NULL; 3222 #else 3223 break; 3224 #endif 3225 case VAR_CHANNEL: 3226 #ifdef FEAT_JOB_CHANNEL 3227 return tv->vval.v_channel != NULL; 3228 #else 3229 break; 3230 #endif 3231 case VAR_BLOB: 3232 return tv->vval.v_blob != NULL && tv->vval.v_blob->bv_ga.ga_len > 0; 3233 case VAR_UNKNOWN: 3234 case VAR_ANY: 3235 case VAR_VOID: 3236 break; 3237 } 3238 return FALSE; 3239 } 3240 3241 /* 3242 * If "tv" is a string give an error and return FAIL. 3243 */ 3244 int 3245 check_not_string(typval_T *tv) 3246 { 3247 if (tv->v_type == VAR_STRING) 3248 { 3249 emsg(_(e_using_string_as_number)); 3250 clear_tv(tv); 3251 return FAIL; 3252 } 3253 return OK; 3254 } 3255 3256 3257 #endif // FEAT_EVAL 3258