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 /* 27 * Chain of jump instructions where the end label needs to be set. 28 */ 29 typedef struct endlabel_S endlabel_T; 30 struct endlabel_S { 31 endlabel_T *el_next; // chain end_label locations 32 int el_end_label; // instruction idx where to set end 33 }; 34 35 /* 36 * info specific for the scope of :if / elseif / else 37 */ 38 typedef struct { 39 int is_if_label; // instruction idx at IF or ELSEIF 40 endlabel_T *is_end_label; // instructions to set end label 41 } ifscope_T; 42 43 /* 44 * info specific for the scope of :while 45 */ 46 typedef struct { 47 int ws_top_label; // instruction idx at WHILE 48 endlabel_T *ws_end_label; // instructions to set end 49 } whilescope_T; 50 51 /* 52 * info specific for the scope of :for 53 */ 54 typedef struct { 55 int fs_top_label; // instruction idx at FOR 56 endlabel_T *fs_end_label; // break instructions 57 } forscope_T; 58 59 /* 60 * info specific for the scope of :try 61 */ 62 typedef struct { 63 int ts_try_label; // instruction idx at TRY 64 endlabel_T *ts_end_label; // jump to :finally or :endtry 65 int ts_catch_label; // instruction idx of last CATCH 66 int ts_caught_all; // "catch" without argument encountered 67 } tryscope_T; 68 69 typedef enum { 70 NO_SCOPE, 71 IF_SCOPE, 72 WHILE_SCOPE, 73 FOR_SCOPE, 74 TRY_SCOPE, 75 BLOCK_SCOPE 76 } scopetype_T; 77 78 /* 79 * Info for one scope, pointed to by "ctx_scope". 80 */ 81 typedef struct scope_S scope_T; 82 struct scope_S { 83 scope_T *se_outer; // scope containing this one 84 scopetype_T se_type; 85 int se_local_count; // ctx_locals.ga_len before scope 86 union { 87 ifscope_T se_if; 88 whilescope_T se_while; 89 forscope_T se_for; 90 tryscope_T se_try; 91 } se_u; 92 }; 93 94 /* 95 * Entry for "ctx_locals". Used for arguments and local variables. 96 */ 97 typedef struct { 98 char_u *lv_name; 99 type_T *lv_type; 100 int lv_idx; // index of the variable on the stack 101 int lv_from_outer; // when TRUE using ctx_outer scope 102 int lv_const; // when TRUE cannot be assigned to 103 int lv_arg; // when TRUE this is an argument 104 } lvar_T; 105 106 /* 107 * Context for compiling lines of Vim script. 108 * Stores info about the local variables and condition stack. 109 */ 110 struct cctx_S { 111 ufunc_T *ctx_ufunc; // current function 112 int ctx_lnum; // line number in current function 113 char_u *ctx_line_start; // start of current line or NULL 114 garray_T ctx_instr; // generated instructions 115 116 garray_T ctx_locals; // currently visible local variables 117 int ctx_locals_count; // total number of local variables 118 119 int ctx_closure_count; // number of closures created in the 120 // function 121 122 garray_T ctx_imports; // imported items 123 124 int ctx_skip; // when TRUE skip commands, when FALSE skip 125 // commands after "else" 126 scope_T *ctx_scope; // current scope, NULL at toplevel 127 128 cctx_T *ctx_outer; // outer scope for lambda or nested 129 // function 130 int ctx_outer_used; // var in ctx_outer was used 131 132 garray_T ctx_type_stack; // type of each item on the stack 133 garray_T *ctx_type_list; // list of pointers to allocated types 134 }; 135 136 static char e_var_notfound[] = N_("E1001: variable not found: %s"); 137 static char e_syntax_at[] = N_("E1002: Syntax error at %s"); 138 static char e_used_as_arg[] = N_("E1006: %s is used as an argument"); 139 140 static void delete_def_function_contents(dfunc_T *dfunc); 141 static void arg_type_mismatch(type_T *expected, type_T *actual, int argidx); 142 static int check_type(type_T *expected, type_T *actual, int give_msg); 143 144 /* 145 * Lookup variable "name" in the local scope and return it. 146 * Return NULL if not found. 147 */ 148 static lvar_T * 149 lookup_local(char_u *name, size_t len, cctx_T *cctx) 150 { 151 int idx; 152 lvar_T *lvar; 153 154 if (len == 0) 155 return NULL; 156 157 // Find local in current function scope. 158 for (idx = 0; idx < cctx->ctx_locals.ga_len; ++idx) 159 { 160 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx; 161 if (STRNCMP(name, lvar->lv_name, len) == 0 162 && STRLEN(lvar->lv_name) == len) 163 { 164 lvar->lv_from_outer = FALSE; 165 return lvar; 166 } 167 } 168 169 // Find local in outer function scope. 170 if (cctx->ctx_outer != NULL) 171 { 172 lvar = lookup_local(name, len, cctx->ctx_outer); 173 if (lvar != NULL) 174 { 175 // TODO: are there situations we should not mark the outer scope as 176 // used? 177 cctx->ctx_outer_used = TRUE; 178 lvar->lv_from_outer = TRUE; 179 return lvar; 180 } 181 } 182 183 return NULL; 184 } 185 186 /* 187 * Lookup an argument in the current function and an enclosing function. 188 * Returns the argument index in "idxp" 189 * Returns the argument type in "type" 190 * Sets "gen_load_outer" to TRUE if found in outer scope. 191 * Returns OK when found, FAIL otherwise. 192 */ 193 static int 194 lookup_arg( 195 char_u *name, 196 size_t len, 197 int *idxp, 198 type_T **type, 199 int *gen_load_outer, 200 cctx_T *cctx) 201 { 202 int idx; 203 char_u *va_name; 204 205 if (len == 0) 206 return FAIL; 207 for (idx = 0; idx < cctx->ctx_ufunc->uf_args.ga_len; ++idx) 208 { 209 char_u *arg = FUNCARG(cctx->ctx_ufunc, idx); 210 211 if (STRNCMP(name, arg, len) == 0 && arg[len] == NUL) 212 { 213 if (idxp != NULL) 214 { 215 // Arguments are located above the frame pointer. One further 216 // if there is a vararg argument 217 *idxp = idx - (cctx->ctx_ufunc->uf_args.ga_len 218 + STACK_FRAME_SIZE) 219 + (cctx->ctx_ufunc->uf_va_name != NULL ? -1 : 0); 220 221 if (cctx->ctx_ufunc->uf_arg_types != NULL) 222 *type = cctx->ctx_ufunc->uf_arg_types[idx]; 223 else 224 *type = &t_any; 225 } 226 return OK; 227 } 228 } 229 230 va_name = cctx->ctx_ufunc->uf_va_name; 231 if (va_name != NULL 232 && STRNCMP(name, va_name, len) == 0 && va_name[len] == NUL) 233 { 234 if (idxp != NULL) 235 { 236 // varargs is always the last argument 237 *idxp = -STACK_FRAME_SIZE - 1; 238 *type = cctx->ctx_ufunc->uf_va_type; 239 } 240 return OK; 241 } 242 243 if (cctx->ctx_outer != NULL) 244 { 245 // Lookup the name for an argument of the outer function. 246 if (lookup_arg(name, len, idxp, type, gen_load_outer, cctx->ctx_outer) 247 == OK) 248 { 249 *gen_load_outer = TRUE; 250 return OK; 251 } 252 } 253 254 return FAIL; 255 } 256 257 /* 258 * Lookup a variable in the current script. 259 * Returns OK or FAIL. 260 */ 261 static int 262 lookup_script(char_u *name, size_t len) 263 { 264 int cc; 265 hashtab_T *ht = &SCRIPT_VARS(current_sctx.sc_sid); 266 dictitem_T *di; 267 268 cc = name[len]; 269 name[len] = NUL; 270 di = find_var_in_ht(ht, 0, name, TRUE); 271 name[len] = cc; 272 return di == NULL ? FAIL: OK; 273 } 274 275 /* 276 * Check if "p[len]" is already defined, either in script "import_sid" or in 277 * compilation context "cctx". 278 * Return FAIL and give an error if it defined. 279 */ 280 int 281 check_defined(char_u *p, int len, cctx_T *cctx) 282 { 283 if (lookup_script(p, len) == OK 284 || (cctx != NULL 285 && (lookup_local(p, len, cctx) != NULL 286 || find_imported(p, len, cctx) != NULL))) 287 { 288 semsg("E1073: imported name already defined: %s", p); 289 return FAIL; 290 } 291 return OK; 292 } 293 294 /* 295 * Allocate memory for a type_T and add the pointer to type_gap, so that it can 296 * be freed later. 297 */ 298 static type_T * 299 alloc_type(garray_T *type_gap) 300 { 301 type_T *type; 302 303 if (ga_grow(type_gap, 1) == FAIL) 304 return NULL; 305 type = ALLOC_CLEAR_ONE(type_T); 306 if (type != NULL) 307 { 308 ((type_T **)type_gap->ga_data)[type_gap->ga_len] = type; 309 ++type_gap->ga_len; 310 } 311 return type; 312 } 313 314 static type_T * 315 get_list_type(type_T *member_type, garray_T *type_gap) 316 { 317 type_T *type; 318 319 // recognize commonly used types 320 if (member_type->tt_type == VAR_ANY) 321 return &t_list_any; 322 if (member_type->tt_type == VAR_VOID 323 || member_type->tt_type == VAR_UNKNOWN) 324 return &t_list_empty; 325 if (member_type->tt_type == VAR_BOOL) 326 return &t_list_bool; 327 if (member_type->tt_type == VAR_NUMBER) 328 return &t_list_number; 329 if (member_type->tt_type == VAR_STRING) 330 return &t_list_string; 331 332 // Not a common type, create a new entry. 333 type = alloc_type(type_gap); 334 if (type == NULL) 335 return &t_any; 336 type->tt_type = VAR_LIST; 337 type->tt_member = member_type; 338 type->tt_argcount = 0; 339 type->tt_args = NULL; 340 return type; 341 } 342 343 static type_T * 344 get_dict_type(type_T *member_type, garray_T *type_gap) 345 { 346 type_T *type; 347 348 // recognize commonly used types 349 if (member_type->tt_type == VAR_ANY) 350 return &t_dict_any; 351 if (member_type->tt_type == VAR_VOID 352 || member_type->tt_type == VAR_UNKNOWN) 353 return &t_dict_empty; 354 if (member_type->tt_type == VAR_BOOL) 355 return &t_dict_bool; 356 if (member_type->tt_type == VAR_NUMBER) 357 return &t_dict_number; 358 if (member_type->tt_type == VAR_STRING) 359 return &t_dict_string; 360 361 // Not a common type, create a new entry. 362 type = alloc_type(type_gap); 363 if (type == NULL) 364 return &t_any; 365 type->tt_type = VAR_DICT; 366 type->tt_member = member_type; 367 type->tt_argcount = 0; 368 type->tt_args = NULL; 369 return type; 370 } 371 372 /* 373 * Allocate a new type for a function. 374 */ 375 static type_T * 376 alloc_func_type(type_T *ret_type, int argcount, garray_T *type_gap) 377 { 378 type_T *type = alloc_type(type_gap); 379 380 if (type == NULL) 381 return &t_any; 382 type->tt_type = VAR_FUNC; 383 type->tt_member = ret_type; 384 type->tt_argcount = argcount; 385 type->tt_args = NULL; 386 return type; 387 } 388 389 /* 390 * Get a function type, based on the return type "ret_type". 391 * If "argcount" is -1 or 0 a predefined type can be used. 392 * If "argcount" > 0 always create a new type, so that arguments can be added. 393 */ 394 static type_T * 395 get_func_type(type_T *ret_type, int argcount, garray_T *type_gap) 396 { 397 // recognize commonly used types 398 if (argcount <= 0) 399 { 400 if (ret_type == &t_unknown) 401 { 402 // (argcount == 0) is not possible 403 return &t_func_unknown; 404 } 405 if (ret_type == &t_void) 406 { 407 if (argcount == 0) 408 return &t_func_0_void; 409 else 410 return &t_func_void; 411 } 412 if (ret_type == &t_any) 413 { 414 if (argcount == 0) 415 return &t_func_0_any; 416 else 417 return &t_func_any; 418 } 419 if (ret_type == &t_number) 420 { 421 if (argcount == 0) 422 return &t_func_0_number; 423 else 424 return &t_func_number; 425 } 426 if (ret_type == &t_string) 427 { 428 if (argcount == 0) 429 return &t_func_0_string; 430 else 431 return &t_func_string; 432 } 433 } 434 435 return alloc_func_type(ret_type, argcount, type_gap); 436 } 437 438 /* 439 * For a function type, reserve space for "argcount" argument types (including 440 * vararg). 441 */ 442 static int 443 func_type_add_arg_types( 444 type_T *functype, 445 int argcount, 446 garray_T *type_gap) 447 { 448 // To make it easy to free the space needed for the argument types, add the 449 // pointer to type_gap. 450 if (ga_grow(type_gap, 1) == FAIL) 451 return FAIL; 452 functype->tt_args = ALLOC_CLEAR_MULT(type_T *, argcount); 453 if (functype->tt_args == NULL) 454 return FAIL; 455 ((type_T **)type_gap->ga_data)[type_gap->ga_len] = 456 (void *)functype->tt_args; 457 ++type_gap->ga_len; 458 return OK; 459 } 460 461 /* 462 * Return the type_T for a typval. Only for primitive types. 463 */ 464 static type_T * 465 typval2type(typval_T *tv) 466 { 467 if (tv->v_type == VAR_NUMBER) 468 return &t_number; 469 if (tv->v_type == VAR_BOOL) 470 return &t_bool; // not used 471 if (tv->v_type == VAR_STRING) 472 return &t_string; 473 if (tv->v_type == VAR_LIST) // e.g. for v:oldfiles 474 return &t_list_string; 475 if (tv->v_type == VAR_DICT) // e.g. for v:completed_item 476 return &t_dict_any; 477 return &t_any; // not used 478 } 479 480 static void 481 type_mismatch(type_T *expected, type_T *actual) 482 { 483 char *tofree1, *tofree2; 484 485 semsg(_("E1013: type mismatch, expected %s but got %s"), 486 type_name(expected, &tofree1), type_name(actual, &tofree2)); 487 vim_free(tofree1); 488 vim_free(tofree2); 489 } 490 491 static void 492 arg_type_mismatch(type_T *expected, type_T *actual, int argidx) 493 { 494 char *tofree1, *tofree2; 495 496 semsg(_("E1013: argument %d: type mismatch, expected %s but got %s"), 497 argidx, 498 type_name(expected, &tofree1), type_name(actual, &tofree2)); 499 vim_free(tofree1); 500 vim_free(tofree2); 501 } 502 503 /* 504 * Check if the expected and actual types match. 505 * Does not allow for assigning "any" to a specific type. 506 */ 507 static int 508 check_type(type_T *expected, type_T *actual, int give_msg) 509 { 510 int ret = OK; 511 512 // When expected is "unknown" we accept any actual type. 513 // When expected is "any" we accept any actual type except "void". 514 if (expected->tt_type != VAR_UNKNOWN 515 && !(expected->tt_type == VAR_ANY && actual->tt_type != VAR_VOID)) 516 517 { 518 if (expected->tt_type != actual->tt_type) 519 { 520 if (give_msg) 521 type_mismatch(expected, actual); 522 return FAIL; 523 } 524 if (expected->tt_type == VAR_DICT || expected->tt_type == VAR_LIST) 525 { 526 // "unknown" is used for an empty list or dict 527 if (actual->tt_member != &t_unknown) 528 ret = check_type(expected->tt_member, actual->tt_member, FALSE); 529 } 530 else if (expected->tt_type == VAR_FUNC) 531 { 532 if (expected->tt_member != &t_unknown) 533 ret = check_type(expected->tt_member, actual->tt_member, FALSE); 534 if (ret == OK && expected->tt_argcount != -1 535 && (actual->tt_argcount < expected->tt_min_argcount 536 || actual->tt_argcount > expected->tt_argcount)) 537 ret = FAIL; 538 } 539 if (ret == FAIL && give_msg) 540 type_mismatch(expected, actual); 541 } 542 return ret; 543 } 544 545 ///////////////////////////////////////////////////////////////////// 546 // Following generate_ functions expect the caller to call ga_grow(). 547 548 #define RETURN_NULL_IF_SKIP(cctx) if (cctx->ctx_skip == TRUE) return NULL 549 #define RETURN_OK_IF_SKIP(cctx) if (cctx->ctx_skip == TRUE) return OK 550 551 /* 552 * Generate an instruction without arguments. 553 * Returns a pointer to the new instruction, NULL if failed. 554 */ 555 static isn_T * 556 generate_instr(cctx_T *cctx, isntype_T isn_type) 557 { 558 garray_T *instr = &cctx->ctx_instr; 559 isn_T *isn; 560 561 RETURN_NULL_IF_SKIP(cctx); 562 if (ga_grow(instr, 1) == FAIL) 563 return NULL; 564 isn = ((isn_T *)instr->ga_data) + instr->ga_len; 565 isn->isn_type = isn_type; 566 isn->isn_lnum = cctx->ctx_lnum + 1; 567 ++instr->ga_len; 568 569 return isn; 570 } 571 572 /* 573 * Generate an instruction without arguments. 574 * "drop" will be removed from the stack. 575 * Returns a pointer to the new instruction, NULL if failed. 576 */ 577 static isn_T * 578 generate_instr_drop(cctx_T *cctx, isntype_T isn_type, int drop) 579 { 580 garray_T *stack = &cctx->ctx_type_stack; 581 582 RETURN_NULL_IF_SKIP(cctx); 583 stack->ga_len -= drop; 584 return generate_instr(cctx, isn_type); 585 } 586 587 /* 588 * Generate instruction "isn_type" and put "type" on the type stack. 589 */ 590 static isn_T * 591 generate_instr_type(cctx_T *cctx, isntype_T isn_type, type_T *type) 592 { 593 isn_T *isn; 594 garray_T *stack = &cctx->ctx_type_stack; 595 596 if ((isn = generate_instr(cctx, isn_type)) == NULL) 597 return NULL; 598 599 if (ga_grow(stack, 1) == FAIL) 600 return NULL; 601 ((type_T **)stack->ga_data)[stack->ga_len] = type; 602 ++stack->ga_len; 603 604 return isn; 605 } 606 607 /* 608 * If type at "offset" isn't already VAR_STRING then generate ISN_2STRING. 609 */ 610 static int 611 may_generate_2STRING(int offset, cctx_T *cctx) 612 { 613 isn_T *isn; 614 garray_T *stack = &cctx->ctx_type_stack; 615 type_T **type = ((type_T **)stack->ga_data) + stack->ga_len + offset; 616 617 if ((*type)->tt_type == VAR_STRING) 618 return OK; 619 *type = &t_string; 620 621 if ((isn = generate_instr(cctx, ISN_2STRING)) == NULL) 622 return FAIL; 623 isn->isn_arg.number = offset; 624 625 return OK; 626 } 627 628 static int 629 check_number_or_float(vartype_T type1, vartype_T type2, char_u *op) 630 { 631 if (!((type1 == VAR_NUMBER || type1 == VAR_FLOAT || type1 == VAR_ANY) 632 && (type2 == VAR_NUMBER || type2 == VAR_FLOAT 633 || type2 == VAR_ANY))) 634 { 635 if (*op == '+') 636 emsg(_("E1035: wrong argument type for +")); 637 else 638 semsg(_("E1036: %c requires number or float arguments"), *op); 639 return FAIL; 640 } 641 return OK; 642 } 643 644 /* 645 * Generate an instruction with two arguments. The instruction depends on the 646 * type of the arguments. 647 */ 648 static int 649 generate_two_op(cctx_T *cctx, char_u *op) 650 { 651 garray_T *stack = &cctx->ctx_type_stack; 652 type_T *type1; 653 type_T *type2; 654 vartype_T vartype; 655 isn_T *isn; 656 657 RETURN_OK_IF_SKIP(cctx); 658 659 // Get the known type of the two items on the stack. If they are matching 660 // use a type-specific instruction. Otherwise fall back to runtime type 661 // checking. 662 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2]; 663 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 664 vartype = VAR_ANY; 665 if (type1->tt_type == type2->tt_type 666 && (type1->tt_type == VAR_NUMBER 667 || type1->tt_type == VAR_LIST 668 #ifdef FEAT_FLOAT 669 || type1->tt_type == VAR_FLOAT 670 #endif 671 || type1->tt_type == VAR_BLOB)) 672 vartype = type1->tt_type; 673 674 switch (*op) 675 { 676 case '+': if (vartype != VAR_LIST && vartype != VAR_BLOB 677 && type1->tt_type != VAR_ANY 678 && type2->tt_type != VAR_ANY 679 && check_number_or_float( 680 type1->tt_type, type2->tt_type, op) == FAIL) 681 return FAIL; 682 isn = generate_instr_drop(cctx, 683 vartype == VAR_NUMBER ? ISN_OPNR 684 : vartype == VAR_LIST ? ISN_ADDLIST 685 : vartype == VAR_BLOB ? ISN_ADDBLOB 686 #ifdef FEAT_FLOAT 687 : vartype == VAR_FLOAT ? ISN_OPFLOAT 688 #endif 689 : ISN_OPANY, 1); 690 if (isn != NULL) 691 isn->isn_arg.op.op_type = EXPR_ADD; 692 break; 693 694 case '-': 695 case '*': 696 case '/': if (check_number_or_float(type1->tt_type, type2->tt_type, 697 op) == FAIL) 698 return FAIL; 699 if (vartype == VAR_NUMBER) 700 isn = generate_instr_drop(cctx, ISN_OPNR, 1); 701 #ifdef FEAT_FLOAT 702 else if (vartype == VAR_FLOAT) 703 isn = generate_instr_drop(cctx, ISN_OPFLOAT, 1); 704 #endif 705 else 706 isn = generate_instr_drop(cctx, ISN_OPANY, 1); 707 if (isn != NULL) 708 isn->isn_arg.op.op_type = *op == '*' 709 ? EXPR_MULT : *op == '/'? EXPR_DIV : EXPR_SUB; 710 break; 711 712 case '%': if ((type1->tt_type != VAR_ANY 713 && type1->tt_type != VAR_NUMBER) 714 || (type2->tt_type != VAR_ANY 715 && type2->tt_type != VAR_NUMBER)) 716 { 717 emsg(_("E1035: % requires number arguments")); 718 return FAIL; 719 } 720 isn = generate_instr_drop(cctx, 721 vartype == VAR_NUMBER ? ISN_OPNR : ISN_OPANY, 1); 722 if (isn != NULL) 723 isn->isn_arg.op.op_type = EXPR_REM; 724 break; 725 } 726 727 // correct type of result 728 if (vartype == VAR_ANY) 729 { 730 type_T *type = &t_any; 731 732 #ifdef FEAT_FLOAT 733 // float+number and number+float results in float 734 if ((type1->tt_type == VAR_NUMBER || type1->tt_type == VAR_FLOAT) 735 && (type2->tt_type == VAR_NUMBER || type2->tt_type == VAR_FLOAT)) 736 type = &t_float; 737 #endif 738 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type; 739 } 740 741 return OK; 742 } 743 744 /* 745 * Get the instruction to use for comparing "type1" with "type2" 746 * Return ISN_DROP when failed. 747 */ 748 static isntype_T 749 get_compare_isn(exptype_T exptype, vartype_T type1, vartype_T type2) 750 { 751 isntype_T isntype = ISN_DROP; 752 753 if (type1 == VAR_UNKNOWN) 754 type1 = VAR_ANY; 755 if (type2 == VAR_UNKNOWN) 756 type2 = VAR_ANY; 757 758 if (type1 == type2) 759 { 760 switch (type1) 761 { 762 case VAR_BOOL: isntype = ISN_COMPAREBOOL; break; 763 case VAR_SPECIAL: isntype = ISN_COMPARESPECIAL; break; 764 case VAR_NUMBER: isntype = ISN_COMPARENR; break; 765 case VAR_FLOAT: isntype = ISN_COMPAREFLOAT; break; 766 case VAR_STRING: isntype = ISN_COMPARESTRING; break; 767 case VAR_BLOB: isntype = ISN_COMPAREBLOB; break; 768 case VAR_LIST: isntype = ISN_COMPARELIST; break; 769 case VAR_DICT: isntype = ISN_COMPAREDICT; break; 770 case VAR_FUNC: isntype = ISN_COMPAREFUNC; break; 771 default: isntype = ISN_COMPAREANY; break; 772 } 773 } 774 else if (type1 == VAR_ANY || type2 == VAR_ANY 775 || ((type1 == VAR_NUMBER || type1 == VAR_FLOAT) 776 && (type2 == VAR_NUMBER || type2 ==VAR_FLOAT))) 777 isntype = ISN_COMPAREANY; 778 779 if ((exptype == EXPR_IS || exptype == EXPR_ISNOT) 780 && (isntype == ISN_COMPAREBOOL 781 || isntype == ISN_COMPARESPECIAL 782 || isntype == ISN_COMPARENR 783 || isntype == ISN_COMPAREFLOAT)) 784 { 785 semsg(_("E1037: Cannot use \"%s\" with %s"), 786 exptype == EXPR_IS ? "is" : "isnot" , vartype_name(type1)); 787 return ISN_DROP; 788 } 789 if (isntype == ISN_DROP 790 || ((exptype != EXPR_EQUAL && exptype != EXPR_NEQUAL 791 && (type1 == VAR_BOOL || type1 == VAR_SPECIAL 792 || type2 == VAR_BOOL || type2 == VAR_SPECIAL))) 793 || ((exptype != EXPR_EQUAL && exptype != EXPR_NEQUAL 794 && exptype != EXPR_IS && exptype != EXPR_ISNOT 795 && (type1 == VAR_BLOB || type2 == VAR_BLOB 796 || type1 == VAR_LIST || type2 == VAR_LIST)))) 797 { 798 semsg(_("E1072: Cannot compare %s with %s"), 799 vartype_name(type1), vartype_name(type2)); 800 return ISN_DROP; 801 } 802 return isntype; 803 } 804 805 /* 806 * Generate an ISN_COMPARE* instruction with a boolean result. 807 */ 808 static int 809 generate_COMPARE(cctx_T *cctx, exptype_T exptype, int ic) 810 { 811 isntype_T isntype; 812 isn_T *isn; 813 garray_T *stack = &cctx->ctx_type_stack; 814 vartype_T type1; 815 vartype_T type2; 816 817 RETURN_OK_IF_SKIP(cctx); 818 819 // Get the known type of the two items on the stack. If they are matching 820 // use a type-specific instruction. Otherwise fall back to runtime type 821 // checking. 822 type1 = ((type_T **)stack->ga_data)[stack->ga_len - 2]->tt_type; 823 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type; 824 isntype = get_compare_isn(exptype, type1, type2); 825 if (isntype == ISN_DROP) 826 return FAIL; 827 828 if ((isn = generate_instr(cctx, isntype)) == NULL) 829 return FAIL; 830 isn->isn_arg.op.op_type = exptype; 831 isn->isn_arg.op.op_ic = ic; 832 833 // takes two arguments, puts one bool back 834 if (stack->ga_len >= 2) 835 { 836 --stack->ga_len; 837 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool; 838 } 839 840 return OK; 841 } 842 843 /* 844 * Generate an ISN_2BOOL instruction. 845 */ 846 static int 847 generate_2BOOL(cctx_T *cctx, int invert) 848 { 849 isn_T *isn; 850 garray_T *stack = &cctx->ctx_type_stack; 851 852 RETURN_OK_IF_SKIP(cctx); 853 if ((isn = generate_instr(cctx, ISN_2BOOL)) == NULL) 854 return FAIL; 855 isn->isn_arg.number = invert; 856 857 // type becomes bool 858 ((type_T **)stack->ga_data)[stack->ga_len - 1] = &t_bool; 859 860 return OK; 861 } 862 863 static int 864 generate_TYPECHECK(cctx_T *cctx, type_T *vartype, int offset) 865 { 866 isn_T *isn; 867 garray_T *stack = &cctx->ctx_type_stack; 868 869 RETURN_OK_IF_SKIP(cctx); 870 if ((isn = generate_instr(cctx, ISN_CHECKTYPE)) == NULL) 871 return FAIL; 872 // TODO: whole type, e.g. for a function also arg and return types 873 isn->isn_arg.type.ct_type = vartype->tt_type; 874 isn->isn_arg.type.ct_off = offset; 875 876 // type becomes vartype 877 ((type_T **)stack->ga_data)[stack->ga_len + offset] = vartype; 878 879 return OK; 880 } 881 882 /* 883 * Check that 884 * - "actual" is "expected" type or 885 * - "actual" is a type that can be "expected" type: add a runtime check; or 886 * - return FAIL. 887 */ 888 static int 889 need_type(type_T *actual, type_T *expected, int offset, cctx_T *cctx) 890 { 891 if (check_type(expected, actual, FALSE) == OK) 892 return OK; 893 if (actual->tt_type != VAR_ANY 894 && actual->tt_type != VAR_UNKNOWN 895 && !(actual->tt_type == VAR_FUNC 896 && (actual->tt_member == &t_any || actual->tt_argcount < 0))) 897 { 898 type_mismatch(expected, actual); 899 return FAIL; 900 } 901 generate_TYPECHECK(cctx, expected, offset); 902 return OK; 903 } 904 905 /* 906 * Generate an ISN_PUSHNR instruction. 907 */ 908 static int 909 generate_PUSHNR(cctx_T *cctx, varnumber_T number) 910 { 911 isn_T *isn; 912 913 RETURN_OK_IF_SKIP(cctx); 914 if ((isn = generate_instr_type(cctx, ISN_PUSHNR, &t_number)) == NULL) 915 return FAIL; 916 isn->isn_arg.number = number; 917 918 return OK; 919 } 920 921 /* 922 * Generate an ISN_PUSHBOOL instruction. 923 */ 924 static int 925 generate_PUSHBOOL(cctx_T *cctx, varnumber_T number) 926 { 927 isn_T *isn; 928 929 RETURN_OK_IF_SKIP(cctx); 930 if ((isn = generate_instr_type(cctx, ISN_PUSHBOOL, &t_bool)) == NULL) 931 return FAIL; 932 isn->isn_arg.number = number; 933 934 return OK; 935 } 936 937 /* 938 * Generate an ISN_PUSHSPEC instruction. 939 */ 940 static int 941 generate_PUSHSPEC(cctx_T *cctx, varnumber_T number) 942 { 943 isn_T *isn; 944 945 RETURN_OK_IF_SKIP(cctx); 946 if ((isn = generate_instr_type(cctx, ISN_PUSHSPEC, &t_special)) == NULL) 947 return FAIL; 948 isn->isn_arg.number = number; 949 950 return OK; 951 } 952 953 #ifdef FEAT_FLOAT 954 /* 955 * Generate an ISN_PUSHF instruction. 956 */ 957 static int 958 generate_PUSHF(cctx_T *cctx, float_T fnumber) 959 { 960 isn_T *isn; 961 962 RETURN_OK_IF_SKIP(cctx); 963 if ((isn = generate_instr_type(cctx, ISN_PUSHF, &t_float)) == NULL) 964 return FAIL; 965 isn->isn_arg.fnumber = fnumber; 966 967 return OK; 968 } 969 #endif 970 971 /* 972 * Generate an ISN_PUSHS instruction. 973 * Consumes "str". 974 */ 975 static int 976 generate_PUSHS(cctx_T *cctx, char_u *str) 977 { 978 isn_T *isn; 979 980 RETURN_OK_IF_SKIP(cctx); 981 if ((isn = generate_instr_type(cctx, ISN_PUSHS, &t_string)) == NULL) 982 return FAIL; 983 isn->isn_arg.string = str; 984 985 return OK; 986 } 987 988 /* 989 * Generate an ISN_PUSHCHANNEL instruction. 990 * Consumes "channel". 991 */ 992 static int 993 generate_PUSHCHANNEL(cctx_T *cctx, channel_T *channel) 994 { 995 isn_T *isn; 996 997 RETURN_OK_IF_SKIP(cctx); 998 if ((isn = generate_instr_type(cctx, ISN_PUSHCHANNEL, &t_channel)) == NULL) 999 return FAIL; 1000 isn->isn_arg.channel = channel; 1001 1002 return OK; 1003 } 1004 1005 /* 1006 * Generate an ISN_PUSHJOB instruction. 1007 * Consumes "job". 1008 */ 1009 static int 1010 generate_PUSHJOB(cctx_T *cctx, job_T *job) 1011 { 1012 isn_T *isn; 1013 1014 RETURN_OK_IF_SKIP(cctx); 1015 if ((isn = generate_instr_type(cctx, ISN_PUSHJOB, &t_channel)) == NULL) 1016 return FAIL; 1017 isn->isn_arg.job = job; 1018 1019 return OK; 1020 } 1021 1022 /* 1023 * Generate an ISN_PUSHBLOB instruction. 1024 * Consumes "blob". 1025 */ 1026 static int 1027 generate_PUSHBLOB(cctx_T *cctx, blob_T *blob) 1028 { 1029 isn_T *isn; 1030 1031 RETURN_OK_IF_SKIP(cctx); 1032 if ((isn = generate_instr_type(cctx, ISN_PUSHBLOB, &t_blob)) == NULL) 1033 return FAIL; 1034 isn->isn_arg.blob = blob; 1035 1036 return OK; 1037 } 1038 1039 /* 1040 * Generate an ISN_PUSHFUNC instruction with name "name". 1041 * Consumes "name". 1042 */ 1043 static int 1044 generate_PUSHFUNC(cctx_T *cctx, char_u *name, type_T *type) 1045 { 1046 isn_T *isn; 1047 1048 RETURN_OK_IF_SKIP(cctx); 1049 if ((isn = generate_instr_type(cctx, ISN_PUSHFUNC, type)) == NULL) 1050 return FAIL; 1051 isn->isn_arg.string = name; 1052 1053 return OK; 1054 } 1055 1056 /* 1057 * Generate an ISN_STORE instruction. 1058 */ 1059 static int 1060 generate_STORE(cctx_T *cctx, isntype_T isn_type, int idx, char_u *name) 1061 { 1062 isn_T *isn; 1063 1064 RETURN_OK_IF_SKIP(cctx); 1065 if ((isn = generate_instr_drop(cctx, isn_type, 1)) == NULL) 1066 return FAIL; 1067 if (name != NULL) 1068 isn->isn_arg.string = vim_strsave(name); 1069 else 1070 isn->isn_arg.number = idx; 1071 1072 return OK; 1073 } 1074 1075 /* 1076 * Generate an ISN_STORENR instruction (short for ISN_PUSHNR + ISN_STORE) 1077 */ 1078 static int 1079 generate_STORENR(cctx_T *cctx, int idx, varnumber_T value) 1080 { 1081 isn_T *isn; 1082 1083 RETURN_OK_IF_SKIP(cctx); 1084 if ((isn = generate_instr(cctx, ISN_STORENR)) == NULL) 1085 return FAIL; 1086 isn->isn_arg.storenr.stnr_idx = idx; 1087 isn->isn_arg.storenr.stnr_val = value; 1088 1089 return OK; 1090 } 1091 1092 /* 1093 * Generate an ISN_STOREOPT instruction 1094 */ 1095 static int 1096 generate_STOREOPT(cctx_T *cctx, char_u *name, int opt_flags) 1097 { 1098 isn_T *isn; 1099 1100 RETURN_OK_IF_SKIP(cctx); 1101 if ((isn = generate_instr(cctx, ISN_STOREOPT)) == NULL) 1102 return FAIL; 1103 isn->isn_arg.storeopt.so_name = vim_strsave(name); 1104 isn->isn_arg.storeopt.so_flags = opt_flags; 1105 1106 return OK; 1107 } 1108 1109 /* 1110 * Generate an ISN_LOAD or similar instruction. 1111 */ 1112 static int 1113 generate_LOAD( 1114 cctx_T *cctx, 1115 isntype_T isn_type, 1116 int idx, 1117 char_u *name, 1118 type_T *type) 1119 { 1120 isn_T *isn; 1121 1122 RETURN_OK_IF_SKIP(cctx); 1123 if ((isn = generate_instr_type(cctx, isn_type, type)) == NULL) 1124 return FAIL; 1125 if (name != NULL) 1126 isn->isn_arg.string = vim_strsave(name); 1127 else 1128 isn->isn_arg.number = idx; 1129 1130 return OK; 1131 } 1132 1133 /* 1134 * Generate an ISN_LOADV instruction for v:var. 1135 */ 1136 static int 1137 generate_LOADV( 1138 cctx_T *cctx, 1139 char_u *name, 1140 int error) 1141 { 1142 int di_flags; 1143 int vidx = find_vim_var(name, &di_flags); 1144 type_T *type; 1145 1146 RETURN_OK_IF_SKIP(cctx); 1147 if (vidx < 0) 1148 { 1149 if (error) 1150 semsg(_(e_var_notfound), name); 1151 return FAIL; 1152 } 1153 type = typval2type(get_vim_var_tv(vidx)); 1154 1155 return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, type); 1156 } 1157 1158 /* 1159 * Generate an ISN_UNLET instruction. 1160 */ 1161 static int 1162 generate_UNLET(cctx_T *cctx, isntype_T isn_type, char_u *name, int forceit) 1163 { 1164 isn_T *isn; 1165 1166 RETURN_OK_IF_SKIP(cctx); 1167 if ((isn = generate_instr(cctx, isn_type)) == NULL) 1168 return FAIL; 1169 isn->isn_arg.unlet.ul_name = vim_strsave(name); 1170 isn->isn_arg.unlet.ul_forceit = forceit; 1171 1172 return OK; 1173 } 1174 1175 /* 1176 * Generate an ISN_LOADS instruction. 1177 */ 1178 static int 1179 generate_OLDSCRIPT( 1180 cctx_T *cctx, 1181 isntype_T isn_type, 1182 char_u *name, 1183 int sid, 1184 type_T *type) 1185 { 1186 isn_T *isn; 1187 1188 RETURN_OK_IF_SKIP(cctx); 1189 if (isn_type == ISN_LOADS) 1190 isn = generate_instr_type(cctx, isn_type, type); 1191 else 1192 isn = generate_instr_drop(cctx, isn_type, 1); 1193 if (isn == NULL) 1194 return FAIL; 1195 isn->isn_arg.loadstore.ls_name = vim_strsave(name); 1196 isn->isn_arg.loadstore.ls_sid = sid; 1197 1198 return OK; 1199 } 1200 1201 /* 1202 * Generate an ISN_LOADSCRIPT or ISN_STORESCRIPT instruction. 1203 */ 1204 static int 1205 generate_VIM9SCRIPT( 1206 cctx_T *cctx, 1207 isntype_T isn_type, 1208 int sid, 1209 int idx, 1210 type_T *type) 1211 { 1212 isn_T *isn; 1213 1214 RETURN_OK_IF_SKIP(cctx); 1215 if (isn_type == ISN_LOADSCRIPT) 1216 isn = generate_instr_type(cctx, isn_type, type); 1217 else 1218 isn = generate_instr_drop(cctx, isn_type, 1); 1219 if (isn == NULL) 1220 return FAIL; 1221 isn->isn_arg.script.script_sid = sid; 1222 isn->isn_arg.script.script_idx = idx; 1223 return OK; 1224 } 1225 1226 /* 1227 * Generate an ISN_NEWLIST instruction. 1228 */ 1229 static int 1230 generate_NEWLIST(cctx_T *cctx, int count) 1231 { 1232 isn_T *isn; 1233 garray_T *stack = &cctx->ctx_type_stack; 1234 type_T *type; 1235 type_T *member; 1236 1237 RETURN_OK_IF_SKIP(cctx); 1238 if ((isn = generate_instr(cctx, ISN_NEWLIST)) == NULL) 1239 return FAIL; 1240 isn->isn_arg.number = count; 1241 1242 // drop the value types 1243 stack->ga_len -= count; 1244 1245 // Use the first value type for the list member type. Use "any" for an 1246 // empty list. 1247 if (count > 0) 1248 member = ((type_T **)stack->ga_data)[stack->ga_len]; 1249 else 1250 member = &t_void; 1251 type = get_list_type(member, cctx->ctx_type_list); 1252 1253 // add the list type to the type stack 1254 if (ga_grow(stack, 1) == FAIL) 1255 return FAIL; 1256 ((type_T **)stack->ga_data)[stack->ga_len] = type; 1257 ++stack->ga_len; 1258 1259 return OK; 1260 } 1261 1262 /* 1263 * Generate an ISN_NEWDICT instruction. 1264 */ 1265 static int 1266 generate_NEWDICT(cctx_T *cctx, int count) 1267 { 1268 isn_T *isn; 1269 garray_T *stack = &cctx->ctx_type_stack; 1270 type_T *type; 1271 type_T *member; 1272 1273 RETURN_OK_IF_SKIP(cctx); 1274 if ((isn = generate_instr(cctx, ISN_NEWDICT)) == NULL) 1275 return FAIL; 1276 isn->isn_arg.number = count; 1277 1278 // drop the key and value types 1279 stack->ga_len -= 2 * count; 1280 1281 // Use the first value type for the list member type. Use "void" for an 1282 // empty dict. 1283 if (count > 0) 1284 member = ((type_T **)stack->ga_data)[stack->ga_len + 1]; 1285 else 1286 member = &t_void; 1287 type = get_dict_type(member, cctx->ctx_type_list); 1288 1289 // add the dict type to the type stack 1290 if (ga_grow(stack, 1) == FAIL) 1291 return FAIL; 1292 ((type_T **)stack->ga_data)[stack->ga_len] = type; 1293 ++stack->ga_len; 1294 1295 return OK; 1296 } 1297 1298 /* 1299 * Generate an ISN_FUNCREF instruction. 1300 */ 1301 static int 1302 generate_FUNCREF(cctx_T *cctx, int dfunc_idx) 1303 { 1304 isn_T *isn; 1305 garray_T *stack = &cctx->ctx_type_stack; 1306 1307 RETURN_OK_IF_SKIP(cctx); 1308 if ((isn = generate_instr(cctx, ISN_FUNCREF)) == NULL) 1309 return FAIL; 1310 isn->isn_arg.funcref.fr_func = dfunc_idx; 1311 isn->isn_arg.funcref.fr_var_idx = cctx->ctx_closure_count++; 1312 1313 if (ga_grow(stack, 1) == FAIL) 1314 return FAIL; 1315 ((type_T **)stack->ga_data)[stack->ga_len] = &t_func_any; 1316 // TODO: argument and return types 1317 ++stack->ga_len; 1318 1319 return OK; 1320 } 1321 1322 /* 1323 * Generate an ISN_JUMP instruction. 1324 */ 1325 static int 1326 generate_JUMP(cctx_T *cctx, jumpwhen_T when, int where) 1327 { 1328 isn_T *isn; 1329 garray_T *stack = &cctx->ctx_type_stack; 1330 1331 RETURN_OK_IF_SKIP(cctx); 1332 if ((isn = generate_instr(cctx, ISN_JUMP)) == NULL) 1333 return FAIL; 1334 isn->isn_arg.jump.jump_when = when; 1335 isn->isn_arg.jump.jump_where = where; 1336 1337 if (when != JUMP_ALWAYS && stack->ga_len > 0) 1338 --stack->ga_len; 1339 1340 return OK; 1341 } 1342 1343 static int 1344 generate_FOR(cctx_T *cctx, int loop_idx) 1345 { 1346 isn_T *isn; 1347 garray_T *stack = &cctx->ctx_type_stack; 1348 1349 RETURN_OK_IF_SKIP(cctx); 1350 if ((isn = generate_instr(cctx, ISN_FOR)) == NULL) 1351 return FAIL; 1352 isn->isn_arg.forloop.for_idx = loop_idx; 1353 1354 if (ga_grow(stack, 1) == FAIL) 1355 return FAIL; 1356 // type doesn't matter, will be stored next 1357 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any; 1358 ++stack->ga_len; 1359 1360 return OK; 1361 } 1362 1363 /* 1364 * Generate an ISN_BCALL instruction. 1365 * Return FAIL if the number of arguments is wrong. 1366 */ 1367 static int 1368 generate_BCALL(cctx_T *cctx, int func_idx, int argcount) 1369 { 1370 isn_T *isn; 1371 garray_T *stack = &cctx->ctx_type_stack; 1372 type_T *argtypes[MAX_FUNC_ARGS]; 1373 int i; 1374 1375 RETURN_OK_IF_SKIP(cctx); 1376 if (check_internal_func(func_idx, argcount) == FAIL) 1377 return FAIL; 1378 1379 if ((isn = generate_instr(cctx, ISN_BCALL)) == NULL) 1380 return FAIL; 1381 isn->isn_arg.bfunc.cbf_idx = func_idx; 1382 isn->isn_arg.bfunc.cbf_argcount = argcount; 1383 1384 for (i = 0; i < argcount; ++i) 1385 argtypes[i] = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i]; 1386 1387 stack->ga_len -= argcount; // drop the arguments 1388 if (ga_grow(stack, 1) == FAIL) 1389 return FAIL; 1390 ((type_T **)stack->ga_data)[stack->ga_len] = 1391 internal_func_ret_type(func_idx, argcount, argtypes); 1392 ++stack->ga_len; // add return value 1393 1394 return OK; 1395 } 1396 1397 /* 1398 * Generate an ISN_DCALL or ISN_UCALL instruction. 1399 * Return FAIL if the number of arguments is wrong. 1400 */ 1401 static int 1402 generate_CALL(cctx_T *cctx, ufunc_T *ufunc, int pushed_argcount) 1403 { 1404 isn_T *isn; 1405 garray_T *stack = &cctx->ctx_type_stack; 1406 int regular_args = ufunc->uf_args.ga_len; 1407 int argcount = pushed_argcount; 1408 1409 RETURN_OK_IF_SKIP(cctx); 1410 if (argcount > regular_args && !has_varargs(ufunc)) 1411 { 1412 semsg(_(e_toomanyarg), ufunc->uf_name); 1413 return FAIL; 1414 } 1415 if (argcount < regular_args - ufunc->uf_def_args.ga_len) 1416 { 1417 semsg(_(e_toofewarg), ufunc->uf_name); 1418 return FAIL; 1419 } 1420 1421 if (ufunc->uf_dfunc_idx >= 0) 1422 { 1423 int i; 1424 1425 for (i = 0; i < argcount; ++i) 1426 { 1427 type_T *expected; 1428 type_T *actual; 1429 1430 if (i < regular_args) 1431 { 1432 if (ufunc->uf_arg_types == NULL) 1433 continue; 1434 expected = ufunc->uf_arg_types[i]; 1435 } 1436 else 1437 expected = ufunc->uf_va_type->tt_member; 1438 actual = ((type_T **)stack->ga_data)[stack->ga_len - argcount + i]; 1439 if (need_type(actual, expected, -argcount + i, cctx) == FAIL) 1440 { 1441 arg_type_mismatch(expected, actual, i + 1); 1442 return FAIL; 1443 } 1444 } 1445 } 1446 1447 if ((isn = generate_instr(cctx, 1448 ufunc->uf_dfunc_idx >= 0 ? ISN_DCALL : ISN_UCALL)) == NULL) 1449 return FAIL; 1450 if (ufunc->uf_dfunc_idx >= 0) 1451 { 1452 isn->isn_arg.dfunc.cdf_idx = ufunc->uf_dfunc_idx; 1453 isn->isn_arg.dfunc.cdf_argcount = argcount; 1454 } 1455 else 1456 { 1457 // A user function may be deleted and redefined later, can't use the 1458 // ufunc pointer, need to look it up again at runtime. 1459 isn->isn_arg.ufunc.cuf_name = vim_strsave(ufunc->uf_name); 1460 isn->isn_arg.ufunc.cuf_argcount = argcount; 1461 } 1462 1463 stack->ga_len -= argcount; // drop the arguments 1464 if (ga_grow(stack, 1) == FAIL) 1465 return FAIL; 1466 // add return value 1467 ((type_T **)stack->ga_data)[stack->ga_len] = ufunc->uf_ret_type; 1468 ++stack->ga_len; 1469 1470 return OK; 1471 } 1472 1473 /* 1474 * Generate an ISN_UCALL instruction when the function isn't defined yet. 1475 */ 1476 static int 1477 generate_UCALL(cctx_T *cctx, char_u *name, int argcount) 1478 { 1479 isn_T *isn; 1480 garray_T *stack = &cctx->ctx_type_stack; 1481 1482 RETURN_OK_IF_SKIP(cctx); 1483 if ((isn = generate_instr(cctx, ISN_UCALL)) == NULL) 1484 return FAIL; 1485 isn->isn_arg.ufunc.cuf_name = vim_strsave(name); 1486 isn->isn_arg.ufunc.cuf_argcount = argcount; 1487 1488 stack->ga_len -= argcount; // drop the arguments 1489 if (ga_grow(stack, 1) == FAIL) 1490 return FAIL; 1491 // add return value 1492 ((type_T **)stack->ga_data)[stack->ga_len] = &t_any; 1493 ++stack->ga_len; 1494 1495 return OK; 1496 } 1497 1498 /* 1499 * Generate an ISN_PCALL instruction. 1500 * "type" is the type of the FuncRef. 1501 */ 1502 static int 1503 generate_PCALL( 1504 cctx_T *cctx, 1505 int argcount, 1506 char_u *name, 1507 type_T *type, 1508 int at_top) 1509 { 1510 isn_T *isn; 1511 garray_T *stack = &cctx->ctx_type_stack; 1512 type_T *ret_type; 1513 1514 RETURN_OK_IF_SKIP(cctx); 1515 1516 if (type->tt_type == VAR_ANY) 1517 ret_type = &t_any; 1518 else if (type->tt_type == VAR_FUNC || type->tt_type == VAR_PARTIAL) 1519 { 1520 if (type->tt_argcount != -1) 1521 { 1522 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0; 1523 1524 if (argcount < type->tt_min_argcount - varargs) 1525 { 1526 semsg(_(e_toofewarg), "[reference]"); 1527 return FAIL; 1528 } 1529 if (!varargs && argcount > type->tt_argcount) 1530 { 1531 semsg(_(e_toomanyarg), "[reference]"); 1532 return FAIL; 1533 } 1534 } 1535 ret_type = type->tt_member; 1536 } 1537 else 1538 { 1539 semsg(_("E1085: Not a callable type: %s"), name); 1540 return FAIL; 1541 } 1542 1543 if ((isn = generate_instr(cctx, ISN_PCALL)) == NULL) 1544 return FAIL; 1545 isn->isn_arg.pfunc.cpf_top = at_top; 1546 isn->isn_arg.pfunc.cpf_argcount = argcount; 1547 1548 stack->ga_len -= argcount; // drop the arguments 1549 1550 // drop the funcref/partial, get back the return value 1551 ((type_T **)stack->ga_data)[stack->ga_len - 1] = ret_type; 1552 1553 // If partial is above the arguments it must be cleared and replaced with 1554 // the return value. 1555 if (at_top && generate_instr(cctx, ISN_PCALL_END) == NULL) 1556 return FAIL; 1557 1558 return OK; 1559 } 1560 1561 /* 1562 * Generate an ISN_STRINGMEMBER instruction. 1563 */ 1564 static int 1565 generate_STRINGMEMBER(cctx_T *cctx, char_u *name, size_t len) 1566 { 1567 isn_T *isn; 1568 garray_T *stack = &cctx->ctx_type_stack; 1569 type_T *type; 1570 1571 RETURN_OK_IF_SKIP(cctx); 1572 if ((isn = generate_instr(cctx, ISN_STRINGMEMBER)) == NULL) 1573 return FAIL; 1574 isn->isn_arg.string = vim_strnsave(name, (int)len); 1575 1576 // check for dict type 1577 type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 1578 if (type->tt_type != VAR_DICT && type != &t_any) 1579 { 1580 emsg(_(e_dictreq)); 1581 return FAIL; 1582 } 1583 // change dict type to dict member type 1584 if (type->tt_type == VAR_DICT) 1585 ((type_T **)stack->ga_data)[stack->ga_len - 1] = type->tt_member; 1586 1587 return OK; 1588 } 1589 1590 /* 1591 * Generate an ISN_ECHO instruction. 1592 */ 1593 static int 1594 generate_ECHO(cctx_T *cctx, int with_white, int count) 1595 { 1596 isn_T *isn; 1597 1598 RETURN_OK_IF_SKIP(cctx); 1599 if ((isn = generate_instr_drop(cctx, ISN_ECHO, count)) == NULL) 1600 return FAIL; 1601 isn->isn_arg.echo.echo_with_white = with_white; 1602 isn->isn_arg.echo.echo_count = count; 1603 1604 return OK; 1605 } 1606 1607 /* 1608 * Generate an ISN_EXECUTE/ISN_ECHOMSG/ISN_ECHOERR instruction. 1609 */ 1610 static int 1611 generate_MULT_EXPR(cctx_T *cctx, isntype_T isn_type, int count) 1612 { 1613 isn_T *isn; 1614 1615 if ((isn = generate_instr_drop(cctx, isn_type, count)) == NULL) 1616 return FAIL; 1617 isn->isn_arg.number = count; 1618 1619 return OK; 1620 } 1621 1622 static int 1623 generate_EXEC(cctx_T *cctx, char_u *line) 1624 { 1625 isn_T *isn; 1626 1627 RETURN_OK_IF_SKIP(cctx); 1628 if ((isn = generate_instr(cctx, ISN_EXEC)) == NULL) 1629 return FAIL; 1630 isn->isn_arg.string = vim_strsave(line); 1631 return OK; 1632 } 1633 1634 static int 1635 generate_EXECCONCAT(cctx_T *cctx, int count) 1636 { 1637 isn_T *isn; 1638 1639 if ((isn = generate_instr_drop(cctx, ISN_EXECCONCAT, count)) == NULL) 1640 return FAIL; 1641 isn->isn_arg.number = count; 1642 return OK; 1643 } 1644 1645 /* 1646 * Reserve space for a local variable. 1647 * Return the variable or NULL if it failed. 1648 */ 1649 static lvar_T * 1650 reserve_local(cctx_T *cctx, char_u *name, size_t len, int isConst, type_T *type) 1651 { 1652 lvar_T *lvar; 1653 1654 if (lookup_arg(name, len, NULL, NULL, NULL, cctx) == OK) 1655 { 1656 emsg_namelen(_(e_used_as_arg), name, (int)len); 1657 return NULL; 1658 } 1659 1660 if (ga_grow(&cctx->ctx_locals, 1) == FAIL) 1661 return NULL; 1662 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + cctx->ctx_locals.ga_len++; 1663 1664 // Every local variable uses the next entry on the stack. We could re-use 1665 // the last ones when leaving a scope, but then variables used in a closure 1666 // might get overwritten. To keep things simple do not re-use stack 1667 // entries. This is less efficient, but memory is cheap these days. 1668 lvar->lv_idx = cctx->ctx_locals_count++; 1669 1670 lvar->lv_name = vim_strnsave(name, (int)(len == 0 ? STRLEN(name) : len)); 1671 lvar->lv_const = isConst; 1672 lvar->lv_type = type; 1673 1674 return lvar; 1675 } 1676 1677 /* 1678 * Remove local variables above "new_top". 1679 */ 1680 static void 1681 unwind_locals(cctx_T *cctx, int new_top) 1682 { 1683 if (cctx->ctx_locals.ga_len > new_top) 1684 { 1685 int idx; 1686 lvar_T *lvar; 1687 1688 for (idx = new_top; idx < cctx->ctx_locals.ga_len; ++idx) 1689 { 1690 lvar = ((lvar_T *)cctx->ctx_locals.ga_data) + idx; 1691 vim_free(lvar->lv_name); 1692 } 1693 } 1694 cctx->ctx_locals.ga_len = new_top; 1695 } 1696 1697 /* 1698 * Free all local variables. 1699 */ 1700 static void 1701 free_locals(cctx_T *cctx) 1702 { 1703 unwind_locals(cctx, 0); 1704 ga_clear(&cctx->ctx_locals); 1705 } 1706 1707 /* 1708 * Skip over a type definition and return a pointer to just after it. 1709 */ 1710 char_u * 1711 skip_type(char_u *start) 1712 { 1713 char_u *p = start; 1714 1715 while (ASCII_ISALNUM(*p) || *p == '_') 1716 ++p; 1717 1718 // Skip over "<type>"; this is permissive about white space. 1719 if (*skipwhite(p) == '<') 1720 { 1721 p = skipwhite(p); 1722 p = skip_type(skipwhite(p + 1)); 1723 p = skipwhite(p); 1724 if (*p == '>') 1725 ++p; 1726 } 1727 else if (*p == '(' && STRNCMP("func", start, 4) == 0) 1728 { 1729 // handle func(args): type 1730 ++p; 1731 while (*p != ')' && *p != NUL) 1732 { 1733 char_u *sp = p; 1734 1735 p = skip_type(p); 1736 if (p == sp) 1737 return p; // syntax error 1738 if (*p == ',') 1739 p = skipwhite(p + 1); 1740 } 1741 if (*p == ')') 1742 { 1743 if (p[1] == ':') 1744 p = skip_type(skipwhite(p + 2)); 1745 else 1746 p = skipwhite(p + 1); 1747 } 1748 } 1749 1750 return p; 1751 } 1752 1753 /* 1754 * Parse the member type: "<type>" and return "type" with the member set. 1755 * Use "type_gap" if a new type needs to be added. 1756 * Returns NULL in case of failure. 1757 */ 1758 static type_T * 1759 parse_type_member(char_u **arg, type_T *type, garray_T *type_gap) 1760 { 1761 type_T *member_type; 1762 int prev_called_emsg = called_emsg; 1763 1764 if (**arg != '<') 1765 { 1766 if (*skipwhite(*arg) == '<') 1767 semsg(_(e_no_white_before), "<"); 1768 else 1769 emsg(_("E1008: Missing <type>")); 1770 return type; 1771 } 1772 *arg = skipwhite(*arg + 1); 1773 1774 member_type = parse_type(arg, type_gap); 1775 1776 *arg = skipwhite(*arg); 1777 if (**arg != '>' && called_emsg == prev_called_emsg) 1778 { 1779 emsg(_("E1009: Missing > after type")); 1780 return type; 1781 } 1782 ++*arg; 1783 1784 if (type->tt_type == VAR_LIST) 1785 return get_list_type(member_type, type_gap); 1786 return get_dict_type(member_type, type_gap); 1787 } 1788 1789 /* 1790 * Parse a type at "arg" and advance over it. 1791 * Return &t_any for failure. 1792 */ 1793 type_T * 1794 parse_type(char_u **arg, garray_T *type_gap) 1795 { 1796 char_u *p = *arg; 1797 size_t len; 1798 1799 // skip over the first word 1800 while (ASCII_ISALNUM(*p) || *p == '_') 1801 ++p; 1802 len = p - *arg; 1803 1804 switch (**arg) 1805 { 1806 case 'a': 1807 if (len == 3 && STRNCMP(*arg, "any", len) == 0) 1808 { 1809 *arg += len; 1810 return &t_any; 1811 } 1812 break; 1813 case 'b': 1814 if (len == 4 && STRNCMP(*arg, "bool", len) == 0) 1815 { 1816 *arg += len; 1817 return &t_bool; 1818 } 1819 if (len == 4 && STRNCMP(*arg, "blob", len) == 0) 1820 { 1821 *arg += len; 1822 return &t_blob; 1823 } 1824 break; 1825 case 'c': 1826 if (len == 7 && STRNCMP(*arg, "channel", len) == 0) 1827 { 1828 *arg += len; 1829 return &t_channel; 1830 } 1831 break; 1832 case 'd': 1833 if (len == 4 && STRNCMP(*arg, "dict", len) == 0) 1834 { 1835 *arg += len; 1836 return parse_type_member(arg, &t_dict_any, type_gap); 1837 } 1838 break; 1839 case 'f': 1840 if (len == 5 && STRNCMP(*arg, "float", len) == 0) 1841 { 1842 #ifdef FEAT_FLOAT 1843 *arg += len; 1844 return &t_float; 1845 #else 1846 emsg(_("E1076: This Vim is not compiled with float support")); 1847 return &t_any; 1848 #endif 1849 } 1850 if (len == 4 && STRNCMP(*arg, "func", len) == 0) 1851 { 1852 type_T *type; 1853 type_T *ret_type = &t_unknown; 1854 int argcount = -1; 1855 int flags = 0; 1856 int first_optional = -1; 1857 type_T *arg_type[MAX_FUNC_ARGS + 1]; 1858 1859 // func({type}, ...{type}): {type} 1860 *arg += len; 1861 if (**arg == '(') 1862 { 1863 // "func" may or may not return a value, "func()" does 1864 // not return a value. 1865 ret_type = &t_void; 1866 1867 p = ++*arg; 1868 argcount = 0; 1869 while (*p != NUL && *p != ')') 1870 { 1871 if (*p == '?') 1872 { 1873 if (first_optional == -1) 1874 first_optional = argcount; 1875 ++p; 1876 } 1877 else if (first_optional != -1) 1878 { 1879 emsg(_("E1007: mandatory argument after optional argument")); 1880 return &t_any; 1881 } 1882 else if (STRNCMP(p, "...", 3) == 0) 1883 { 1884 flags |= TTFLAG_VARARGS; 1885 p += 3; 1886 } 1887 1888 arg_type[argcount++] = parse_type(&p, type_gap); 1889 1890 // Nothing comes after "...{type}". 1891 if (flags & TTFLAG_VARARGS) 1892 break; 1893 1894 if (*p != ',' && *skipwhite(p) == ',') 1895 { 1896 semsg(_(e_no_white_before), ","); 1897 return &t_any; 1898 } 1899 if (*p == ',') 1900 { 1901 ++p; 1902 if (!VIM_ISWHITE(*p)) 1903 { 1904 semsg(_(e_white_after), ","); 1905 return &t_any; 1906 } 1907 } 1908 p = skipwhite(p); 1909 if (argcount == MAX_FUNC_ARGS) 1910 { 1911 emsg(_("E740: Too many argument types")); 1912 return &t_any; 1913 } 1914 } 1915 1916 p = skipwhite(p); 1917 if (*p != ')') 1918 { 1919 emsg(_(e_missing_close)); 1920 return &t_any; 1921 } 1922 *arg = p + 1; 1923 } 1924 if (**arg == ':') 1925 { 1926 // parse return type 1927 ++*arg; 1928 if (!VIM_ISWHITE(**arg)) 1929 semsg(_(e_white_after), ":"); 1930 *arg = skipwhite(*arg); 1931 ret_type = parse_type(arg, type_gap); 1932 } 1933 if (flags == 0 && first_optional == -1 && argcount <= 0) 1934 type = get_func_type(ret_type, argcount, type_gap); 1935 else 1936 { 1937 type = alloc_func_type(ret_type, argcount, type_gap); 1938 type->tt_flags = flags; 1939 if (argcount > 0) 1940 { 1941 type->tt_argcount = argcount; 1942 type->tt_min_argcount = first_optional == -1 1943 ? argcount : first_optional; 1944 if (func_type_add_arg_types(type, argcount, 1945 type_gap) == FAIL) 1946 return &t_any; 1947 mch_memmove(type->tt_args, arg_type, 1948 sizeof(type_T *) * argcount); 1949 } 1950 } 1951 return type; 1952 } 1953 break; 1954 case 'j': 1955 if (len == 3 && STRNCMP(*arg, "job", len) == 0) 1956 { 1957 *arg += len; 1958 return &t_job; 1959 } 1960 break; 1961 case 'l': 1962 if (len == 4 && STRNCMP(*arg, "list", len) == 0) 1963 { 1964 *arg += len; 1965 return parse_type_member(arg, &t_list_any, type_gap); 1966 } 1967 break; 1968 case 'n': 1969 if (len == 6 && STRNCMP(*arg, "number", len) == 0) 1970 { 1971 *arg += len; 1972 return &t_number; 1973 } 1974 break; 1975 case 's': 1976 if (len == 6 && STRNCMP(*arg, "string", len) == 0) 1977 { 1978 *arg += len; 1979 return &t_string; 1980 } 1981 break; 1982 case 'v': 1983 if (len == 4 && STRNCMP(*arg, "void", len) == 0) 1984 { 1985 *arg += len; 1986 return &t_void; 1987 } 1988 break; 1989 } 1990 1991 semsg(_("E1010: Type not recognized: %s"), *arg); 1992 return &t_any; 1993 } 1994 1995 /* 1996 * Check if "type1" and "type2" are exactly the same. 1997 */ 1998 static int 1999 equal_type(type_T *type1, type_T *type2) 2000 { 2001 int i; 2002 2003 if (type1->tt_type != type2->tt_type) 2004 return FALSE; 2005 switch (type1->tt_type) 2006 { 2007 case VAR_UNKNOWN: 2008 case VAR_ANY: 2009 case VAR_VOID: 2010 case VAR_SPECIAL: 2011 case VAR_BOOL: 2012 case VAR_NUMBER: 2013 case VAR_FLOAT: 2014 case VAR_STRING: 2015 case VAR_BLOB: 2016 case VAR_JOB: 2017 case VAR_CHANNEL: 2018 break; // not composite is always OK 2019 case VAR_LIST: 2020 case VAR_DICT: 2021 return equal_type(type1->tt_member, type2->tt_member); 2022 case VAR_FUNC: 2023 case VAR_PARTIAL: 2024 if (!equal_type(type1->tt_member, type2->tt_member) 2025 || type1->tt_argcount != type2->tt_argcount) 2026 return FALSE; 2027 if (type1->tt_argcount < 0 2028 || type1->tt_args == NULL || type2->tt_args == NULL) 2029 return TRUE; 2030 for (i = 0; i < type1->tt_argcount; ++i) 2031 if (!equal_type(type1->tt_args[i], type2->tt_args[i])) 2032 return FALSE; 2033 return TRUE; 2034 } 2035 return TRUE; 2036 } 2037 2038 /* 2039 * Find the common type of "type1" and "type2" and put it in "dest". 2040 * "type2" and "dest" may be the same. 2041 */ 2042 static void 2043 common_type(type_T *type1, type_T *type2, type_T **dest, garray_T *type_gap) 2044 { 2045 if (equal_type(type1, type2)) 2046 { 2047 *dest = type1; 2048 return; 2049 } 2050 2051 if (type1->tt_type == type2->tt_type) 2052 { 2053 if (type1->tt_type == VAR_LIST || type2->tt_type == VAR_DICT) 2054 { 2055 type_T *common; 2056 2057 common_type(type1->tt_member, type2->tt_member, &common, type_gap); 2058 if (type1->tt_type == VAR_LIST) 2059 *dest = get_list_type(common, type_gap); 2060 else 2061 *dest = get_dict_type(common, type_gap); 2062 return; 2063 } 2064 if (type1->tt_type == VAR_FUNC) 2065 { 2066 type_T *common; 2067 2068 common_type(type1->tt_member, type2->tt_member, &common, type_gap); 2069 if (type1->tt_argcount == type2->tt_argcount 2070 && type1->tt_argcount >= 0) 2071 { 2072 int argcount = type1->tt_argcount; 2073 int i; 2074 2075 *dest = alloc_func_type(common, argcount, type_gap); 2076 if (type1->tt_args != NULL && type2->tt_args != NULL) 2077 { 2078 if (func_type_add_arg_types(*dest, argcount, 2079 type_gap) == OK) 2080 for (i = 0; i < argcount; ++i) 2081 common_type(type1->tt_args[i], type2->tt_args[i], 2082 &(*dest)->tt_args[i], type_gap); 2083 } 2084 } 2085 else 2086 *dest = alloc_func_type(common, -1, type_gap); 2087 return; 2088 } 2089 } 2090 2091 *dest = &t_any; 2092 } 2093 2094 char * 2095 vartype_name(vartype_T type) 2096 { 2097 switch (type) 2098 { 2099 case VAR_UNKNOWN: break; 2100 case VAR_ANY: return "any"; 2101 case VAR_VOID: return "void"; 2102 case VAR_SPECIAL: return "special"; 2103 case VAR_BOOL: return "bool"; 2104 case VAR_NUMBER: return "number"; 2105 case VAR_FLOAT: return "float"; 2106 case VAR_STRING: return "string"; 2107 case VAR_BLOB: return "blob"; 2108 case VAR_JOB: return "job"; 2109 case VAR_CHANNEL: return "channel"; 2110 case VAR_LIST: return "list"; 2111 case VAR_DICT: return "dict"; 2112 2113 case VAR_FUNC: 2114 case VAR_PARTIAL: return "func"; 2115 } 2116 return "unknown"; 2117 } 2118 2119 /* 2120 * Return the name of a type. 2121 * The result may be in allocated memory, in which case "tofree" is set. 2122 */ 2123 char * 2124 type_name(type_T *type, char **tofree) 2125 { 2126 char *name = vartype_name(type->tt_type); 2127 2128 *tofree = NULL; 2129 if (type->tt_type == VAR_LIST || type->tt_type == VAR_DICT) 2130 { 2131 char *member_free; 2132 char *member_name = type_name(type->tt_member, &member_free); 2133 size_t len; 2134 2135 len = STRLEN(name) + STRLEN(member_name) + 3; 2136 *tofree = alloc(len); 2137 if (*tofree != NULL) 2138 { 2139 vim_snprintf(*tofree, len, "%s<%s>", name, member_name); 2140 vim_free(member_free); 2141 return *tofree; 2142 } 2143 } 2144 if (type->tt_type == VAR_FUNC) 2145 { 2146 garray_T ga; 2147 int i; 2148 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0; 2149 2150 ga_init2(&ga, 1, 100); 2151 if (ga_grow(&ga, 20) == FAIL) 2152 return "[unknown]"; 2153 *tofree = ga.ga_data; 2154 STRCPY(ga.ga_data, "func("); 2155 ga.ga_len += 5; 2156 2157 for (i = 0; i < type->tt_argcount; ++i) 2158 { 2159 char *arg_free; 2160 char *arg_type; 2161 int len; 2162 2163 if (type->tt_args == NULL) 2164 arg_type = "[unknown]"; 2165 else 2166 arg_type = type_name(type->tt_args[i], &arg_free); 2167 if (i > 0) 2168 { 2169 STRCPY((char *)ga.ga_data + ga.ga_len, ", "); 2170 ga.ga_len += 2; 2171 } 2172 len = (int)STRLEN(arg_type); 2173 if (ga_grow(&ga, len + 8) == FAIL) 2174 { 2175 vim_free(arg_free); 2176 return "[unknown]"; 2177 } 2178 *tofree = ga.ga_data; 2179 if (varargs && i == type->tt_argcount - 1) 2180 { 2181 STRCPY((char *)ga.ga_data + ga.ga_len, "..."); 2182 ga.ga_len += 3; 2183 } 2184 else if (i >= type->tt_min_argcount) 2185 *((char *)ga.ga_data + ga.ga_len++) = '?'; 2186 STRCPY((char *)ga.ga_data + ga.ga_len, arg_type); 2187 ga.ga_len += len; 2188 vim_free(arg_free); 2189 } 2190 2191 if (type->tt_member == &t_void) 2192 STRCPY((char *)ga.ga_data + ga.ga_len, ")"); 2193 else 2194 { 2195 char *ret_free; 2196 char *ret_name = type_name(type->tt_member, &ret_free); 2197 int len; 2198 2199 len = (int)STRLEN(ret_name) + 4; 2200 if (ga_grow(&ga, len) == FAIL) 2201 { 2202 vim_free(ret_free); 2203 return "[unknown]"; 2204 } 2205 *tofree = ga.ga_data; 2206 STRCPY((char *)ga.ga_data + ga.ga_len, "): "); 2207 STRCPY((char *)ga.ga_data + ga.ga_len + 3, ret_name); 2208 vim_free(ret_free); 2209 } 2210 return ga.ga_data; 2211 } 2212 2213 return name; 2214 } 2215 2216 /* 2217 * Find "name" in script-local items of script "sid". 2218 * Returns the index in "sn_var_vals" if found. 2219 * If found but not in "sn_var_vals" returns -1. 2220 * If not found returns -2. 2221 */ 2222 int 2223 get_script_item_idx(int sid, char_u *name, int check_writable) 2224 { 2225 hashtab_T *ht; 2226 dictitem_T *di; 2227 scriptitem_T *si = SCRIPT_ITEM(sid); 2228 int idx; 2229 2230 // First look the name up in the hashtable. 2231 if (sid <= 0 || sid > script_items.ga_len) 2232 return -1; 2233 ht = &SCRIPT_VARS(sid); 2234 di = find_var_in_ht(ht, 0, name, TRUE); 2235 if (di == NULL) 2236 return -2; 2237 2238 // Now find the svar_T index in sn_var_vals. 2239 for (idx = 0; idx < si->sn_var_vals.ga_len; ++idx) 2240 { 2241 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; 2242 2243 if (sv->sv_tv == &di->di_tv) 2244 { 2245 if (check_writable && sv->sv_const) 2246 semsg(_(e_readonlyvar), name); 2247 return idx; 2248 } 2249 } 2250 return -1; 2251 } 2252 2253 /* 2254 * Find "name" in imported items of the current script/ 2255 */ 2256 imported_T * 2257 find_imported(char_u *name, size_t len, cctx_T *cctx) 2258 { 2259 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); 2260 int idx; 2261 2262 if (cctx != NULL) 2263 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx) 2264 { 2265 imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data) 2266 + idx; 2267 2268 if (len == 0 ? STRCMP(name, import->imp_name) == 0 2269 : STRLEN(import->imp_name) == len 2270 && STRNCMP(name, import->imp_name, len) == 0) 2271 return import; 2272 } 2273 2274 for (idx = 0; idx < si->sn_imports.ga_len; ++idx) 2275 { 2276 imported_T *import = ((imported_T *)si->sn_imports.ga_data) + idx; 2277 2278 if (len == 0 ? STRCMP(name, import->imp_name) == 0 2279 : STRLEN(import->imp_name) == len 2280 && STRNCMP(name, import->imp_name, len) == 0) 2281 return import; 2282 } 2283 return NULL; 2284 } 2285 2286 /* 2287 * Free all imported variables. 2288 */ 2289 static void 2290 free_imported(cctx_T *cctx) 2291 { 2292 int idx; 2293 2294 for (idx = 0; idx < cctx->ctx_imports.ga_len; ++idx) 2295 { 2296 imported_T *import = ((imported_T *)cctx->ctx_imports.ga_data) + idx; 2297 2298 vim_free(import->imp_name); 2299 } 2300 ga_clear(&cctx->ctx_imports); 2301 } 2302 2303 /* 2304 * Get the next line of the function from "cctx". 2305 * Returns NULL when at the end. 2306 */ 2307 static char_u * 2308 next_line_from_context(cctx_T *cctx) 2309 { 2310 char_u *line; 2311 2312 do 2313 { 2314 ++cctx->ctx_lnum; 2315 if (cctx->ctx_lnum >= cctx->ctx_ufunc->uf_lines.ga_len) 2316 { 2317 line = NULL; 2318 break; 2319 } 2320 line = ((char_u **)cctx->ctx_ufunc->uf_lines.ga_data)[cctx->ctx_lnum]; 2321 cctx->ctx_line_start = line; 2322 SOURCING_LNUM = cctx->ctx_ufunc->uf_script_ctx.sc_lnum 2323 + cctx->ctx_lnum + 1; 2324 } while (line == NULL || *skipwhite(line) == NUL); 2325 return line; 2326 } 2327 2328 /* 2329 * Return TRUE if "p" points at a "#" but not at "#{". 2330 */ 2331 static int 2332 comment_start(char_u *p) 2333 { 2334 return p[0] == '#' && p[1] != '{'; 2335 } 2336 2337 /* 2338 * If "*arg" is at the end of the line, advance to the next line. 2339 * Also when "whitep" points to white space and "*arg" is on a "#". 2340 * Return FAIL if beyond the last line, "*arg" is unmodified then. 2341 */ 2342 static int 2343 may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx) 2344 { 2345 if (**arg == NUL || (VIM_ISWHITE(*whitep) && comment_start(*arg))) 2346 { 2347 char_u *next = next_line_from_context(cctx); 2348 2349 if (next == NULL) 2350 return FAIL; 2351 *arg = skipwhite(next); 2352 } 2353 return OK; 2354 } 2355 2356 // Structure passed between the compile_expr* functions to keep track of 2357 // constants that have been parsed but for which no code was produced yet. If 2358 // possible expressions on these constants are applied at compile time. If 2359 // that is not possible, the code to push the constants needs to be generated 2360 // before other instructions. 2361 // Using 50 should be more than enough of 5 levels of (). 2362 #define PPSIZE 50 2363 typedef struct { 2364 typval_T pp_tv[PPSIZE]; // stack of ppconst constants 2365 int pp_used; // active entries in pp_tv[] 2366 } ppconst_T; 2367 2368 static int compile_expr0(char_u **arg, cctx_T *cctx); 2369 static int compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst); 2370 2371 /* 2372 * Generate a PUSH instruction for "tv". 2373 * "tv" will be consumed or cleared. 2374 * Nothing happens if "tv" is NULL or of type VAR_UNKNOWN; 2375 */ 2376 static int 2377 generate_tv_PUSH(cctx_T *cctx, typval_T *tv) 2378 { 2379 if (tv != NULL) 2380 { 2381 switch (tv->v_type) 2382 { 2383 case VAR_UNKNOWN: 2384 break; 2385 case VAR_BOOL: 2386 generate_PUSHBOOL(cctx, tv->vval.v_number); 2387 break; 2388 case VAR_SPECIAL: 2389 generate_PUSHSPEC(cctx, tv->vval.v_number); 2390 break; 2391 case VAR_NUMBER: 2392 generate_PUSHNR(cctx, tv->vval.v_number); 2393 break; 2394 #ifdef FEAT_FLOAT 2395 case VAR_FLOAT: 2396 generate_PUSHF(cctx, tv->vval.v_float); 2397 break; 2398 #endif 2399 case VAR_BLOB: 2400 generate_PUSHBLOB(cctx, tv->vval.v_blob); 2401 tv->vval.v_blob = NULL; 2402 break; 2403 case VAR_STRING: 2404 generate_PUSHS(cctx, tv->vval.v_string); 2405 tv->vval.v_string = NULL; 2406 break; 2407 default: 2408 iemsg("constant type not supported"); 2409 clear_tv(tv); 2410 return FAIL; 2411 } 2412 tv->v_type = VAR_UNKNOWN; 2413 } 2414 return OK; 2415 } 2416 2417 /* 2418 * Generate code for any ppconst entries. 2419 */ 2420 static int 2421 generate_ppconst(cctx_T *cctx, ppconst_T *ppconst) 2422 { 2423 int i; 2424 int ret = OK; 2425 int save_skip = cctx->ctx_skip; 2426 2427 cctx->ctx_skip = FALSE; 2428 for (i = 0; i < ppconst->pp_used; ++i) 2429 if (generate_tv_PUSH(cctx, &ppconst->pp_tv[i]) == FAIL) 2430 ret = FAIL; 2431 ppconst->pp_used = 0; 2432 cctx->ctx_skip = save_skip; 2433 return ret; 2434 } 2435 2436 /* 2437 * Clear ppconst constants. Used when failing. 2438 */ 2439 static void 2440 clear_ppconst(ppconst_T *ppconst) 2441 { 2442 int i; 2443 2444 for (i = 0; i < ppconst->pp_used; ++i) 2445 clear_tv(&ppconst->pp_tv[i]); 2446 ppconst->pp_used = 0; 2447 } 2448 2449 /* 2450 * Generate an instruction to load script-local variable "name", without the 2451 * leading "s:". 2452 * Also finds imported variables. 2453 */ 2454 static int 2455 compile_load_scriptvar( 2456 cctx_T *cctx, 2457 char_u *name, // variable NUL terminated 2458 char_u *start, // start of variable 2459 char_u **end, // end of variable 2460 int error) // when TRUE may give error 2461 { 2462 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); 2463 int idx = get_script_item_idx(current_sctx.sc_sid, name, FALSE); 2464 imported_T *import; 2465 2466 if (idx == -1 || si->sn_version != SCRIPT_VERSION_VIM9) 2467 { 2468 // variable is not in sn_var_vals: old style script. 2469 return generate_OLDSCRIPT(cctx, ISN_LOADS, name, current_sctx.sc_sid, 2470 &t_any); 2471 } 2472 if (idx >= 0) 2473 { 2474 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; 2475 2476 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT, 2477 current_sctx.sc_sid, idx, sv->sv_type); 2478 return OK; 2479 } 2480 2481 import = find_imported(name, 0, cctx); 2482 if (import != NULL) 2483 { 2484 if (import->imp_all) 2485 { 2486 char_u *p = skipwhite(*end); 2487 int name_len; 2488 ufunc_T *ufunc; 2489 type_T *type; 2490 2491 // Used "import * as Name", need to lookup the member. 2492 if (*p != '.') 2493 { 2494 semsg(_("E1060: expected dot after name: %s"), start); 2495 return FAIL; 2496 } 2497 ++p; 2498 if (VIM_ISWHITE(*p)) 2499 { 2500 emsg(_("E1074: no white space allowed after dot")); 2501 return FAIL; 2502 } 2503 2504 idx = find_exported(import->imp_sid, &p, &name_len, &ufunc, &type); 2505 // TODO: what if it is a function? 2506 if (idx < 0) 2507 return FAIL; 2508 *end = p; 2509 2510 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT, 2511 import->imp_sid, 2512 idx, 2513 type); 2514 } 2515 else 2516 { 2517 // TODO: check this is a variable, not a function? 2518 generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT, 2519 import->imp_sid, 2520 import->imp_var_vals_idx, 2521 import->imp_type); 2522 } 2523 return OK; 2524 } 2525 2526 if (error) 2527 semsg(_("E1050: Item not found: %s"), name); 2528 return FAIL; 2529 } 2530 2531 static int 2532 generate_funcref(cctx_T *cctx, char_u *name) 2533 { 2534 ufunc_T *ufunc = find_func(name, FALSE, cctx); 2535 2536 if (ufunc == NULL) 2537 return FAIL; 2538 2539 return generate_PUSHFUNC(cctx, vim_strsave(name), ufunc->uf_func_type); 2540 } 2541 2542 /* 2543 * Compile a variable name into a load instruction. 2544 * "end" points to just after the name. 2545 * When "error" is FALSE do not give an error when not found. 2546 */ 2547 static int 2548 compile_load(char_u **arg, char_u *end_arg, cctx_T *cctx, int error) 2549 { 2550 type_T *type; 2551 char_u *name; 2552 char_u *end = end_arg; 2553 int res = FAIL; 2554 int prev_called_emsg = called_emsg; 2555 2556 if (*(*arg + 1) == ':') 2557 { 2558 // load namespaced variable 2559 if (end <= *arg + 2) 2560 name = vim_strsave((char_u *)"[empty]"); 2561 else 2562 name = vim_strnsave(*arg + 2, end - (*arg + 2)); 2563 if (name == NULL) 2564 return FAIL; 2565 2566 if (**arg == 'v') 2567 { 2568 res = generate_LOADV(cctx, name, error); 2569 } 2570 else if (**arg == 'g') 2571 { 2572 // Global variables can be defined later, thus we don't check if it 2573 // exists, give error at runtime. 2574 res = generate_LOAD(cctx, ISN_LOADG, 0, name, &t_any); 2575 } 2576 else if (**arg == 's') 2577 { 2578 res = compile_load_scriptvar(cctx, name, NULL, NULL, error); 2579 } 2580 else if (**arg == 'b') 2581 { 2582 // Buffer-local variables can be defined later, thus we don't check 2583 // if it exists, give error at runtime. 2584 res = generate_LOAD(cctx, ISN_LOADB, 0, name, &t_any); 2585 } 2586 else if (**arg == 'w') 2587 { 2588 // Window-local variables can be defined later, thus we don't check 2589 // if it exists, give error at runtime. 2590 res = generate_LOAD(cctx, ISN_LOADW, 0, name, &t_any); 2591 } 2592 else if (**arg == 't') 2593 { 2594 // Tabpage-local variables can be defined later, thus we don't 2595 // check if it exists, give error at runtime. 2596 res = generate_LOAD(cctx, ISN_LOADT, 0, name, &t_any); 2597 } 2598 else 2599 { 2600 semsg("E1075: Namespace not supported: %s", *arg); 2601 goto theend; 2602 } 2603 } 2604 else 2605 { 2606 size_t len = end - *arg; 2607 int idx; 2608 int gen_load = FALSE; 2609 int gen_load_outer = FALSE; 2610 2611 name = vim_strnsave(*arg, end - *arg); 2612 if (name == NULL) 2613 return FAIL; 2614 2615 if (lookup_arg(*arg, len, &idx, &type, &gen_load_outer, cctx) == OK) 2616 { 2617 if (!gen_load_outer) 2618 gen_load = TRUE; 2619 } 2620 else 2621 { 2622 lvar_T *lvar = lookup_local(*arg, len, cctx); 2623 2624 if (lvar != NULL) 2625 { 2626 type = lvar->lv_type; 2627 idx = lvar->lv_idx; 2628 if (lvar->lv_from_outer) 2629 gen_load_outer = TRUE; 2630 else 2631 gen_load = TRUE; 2632 } 2633 else 2634 { 2635 // "var" can be script-local even without using "s:" if it 2636 // already exists. 2637 if (SCRIPT_ITEM(current_sctx.sc_sid)->sn_version 2638 == SCRIPT_VERSION_VIM9 2639 || lookup_script(*arg, len) == OK) 2640 res = compile_load_scriptvar(cctx, name, *arg, &end, 2641 FALSE); 2642 2643 // When the name starts with an uppercase letter or "x:" it 2644 // can be a user defined function. 2645 if (res == FAIL && (ASCII_ISUPPER(*name) || name[1] == ':')) 2646 res = generate_funcref(cctx, name); 2647 } 2648 } 2649 if (gen_load) 2650 res = generate_LOAD(cctx, ISN_LOAD, idx, NULL, type); 2651 if (gen_load_outer) 2652 res = generate_LOAD(cctx, ISN_LOADOUTER, idx, NULL, type); 2653 } 2654 2655 *arg = end; 2656 2657 theend: 2658 if (res == FAIL && error && called_emsg == prev_called_emsg) 2659 semsg(_(e_var_notfound), name); 2660 vim_free(name); 2661 return res; 2662 } 2663 2664 /* 2665 * Compile the argument expressions. 2666 * "arg" points to just after the "(" and is advanced to after the ")" 2667 */ 2668 static int 2669 compile_arguments(char_u **arg, cctx_T *cctx, int *argcount) 2670 { 2671 char_u *p = *arg; 2672 char_u *whitep = *arg; 2673 2674 for (;;) 2675 { 2676 while (*p == NUL || (VIM_ISWHITE(*whitep) && comment_start(p))) 2677 { 2678 p = next_line_from_context(cctx); 2679 if (p == NULL) 2680 goto failret; 2681 whitep = (char_u *)" "; 2682 p = skipwhite(p); 2683 } 2684 if (*p == ')') 2685 { 2686 *arg = p + 1; 2687 return OK; 2688 } 2689 2690 if (compile_expr0(&p, cctx) == FAIL) 2691 return FAIL; 2692 ++*argcount; 2693 2694 if (*p != ',' && *skipwhite(p) == ',') 2695 { 2696 semsg(_(e_no_white_before), ","); 2697 p = skipwhite(p); 2698 } 2699 if (*p == ',') 2700 { 2701 ++p; 2702 if (*p != NUL && !VIM_ISWHITE(*p)) 2703 semsg(_(e_white_after), ","); 2704 } 2705 whitep = p; 2706 p = skipwhite(p); 2707 } 2708 failret: 2709 emsg(_(e_missing_close)); 2710 return FAIL; 2711 } 2712 2713 /* 2714 * Compile a function call: name(arg1, arg2) 2715 * "arg" points to "name", "arg + varlen" to the "(". 2716 * "argcount_init" is 1 for "value->method()" 2717 * Instructions: 2718 * EVAL arg1 2719 * EVAL arg2 2720 * BCALL / DCALL / UCALL 2721 */ 2722 static int 2723 compile_call( 2724 char_u **arg, 2725 size_t varlen, 2726 cctx_T *cctx, 2727 ppconst_T *ppconst, 2728 int argcount_init) 2729 { 2730 char_u *name = *arg; 2731 char_u *p; 2732 int argcount = argcount_init; 2733 char_u namebuf[100]; 2734 char_u fname_buf[FLEN_FIXED + 1]; 2735 char_u *tofree = NULL; 2736 int error = FCERR_NONE; 2737 ufunc_T *ufunc; 2738 int res = FAIL; 2739 2740 // we can evaluate "has('name')" at compile time 2741 if (varlen == 3 && STRNCMP(*arg, "has", 3) == 0) 2742 { 2743 char_u *s = skipwhite(*arg + varlen + 1); 2744 typval_T argvars[2]; 2745 2746 argvars[0].v_type = VAR_UNKNOWN; 2747 if (*s == '"') 2748 (void)get_string_tv(&s, &argvars[0], TRUE); 2749 else if (*s == '\'') 2750 (void)get_lit_string_tv(&s, &argvars[0], TRUE); 2751 s = skipwhite(s); 2752 if (*s == ')' && argvars[0].v_type == VAR_STRING) 2753 { 2754 typval_T *tv = &ppconst->pp_tv[ppconst->pp_used]; 2755 2756 *arg = s + 1; 2757 argvars[1].v_type = VAR_UNKNOWN; 2758 tv->v_type = VAR_NUMBER; 2759 tv->vval.v_number = 0; 2760 f_has(argvars, tv); 2761 clear_tv(&argvars[0]); 2762 ++ppconst->pp_used; 2763 return OK; 2764 } 2765 clear_tv(&argvars[0]); 2766 } 2767 2768 if (generate_ppconst(cctx, ppconst) == FAIL) 2769 return FAIL; 2770 2771 if (varlen >= sizeof(namebuf)) 2772 { 2773 semsg(_("E1011: name too long: %s"), name); 2774 return FAIL; 2775 } 2776 vim_strncpy(namebuf, *arg, varlen); 2777 name = fname_trans_sid(namebuf, fname_buf, &tofree, &error); 2778 2779 *arg = skipwhite(*arg + varlen + 1); 2780 if (compile_arguments(arg, cctx, &argcount) == FAIL) 2781 goto theend; 2782 2783 if (ASCII_ISLOWER(*name) && name[1] != ':') 2784 { 2785 int idx; 2786 2787 // builtin function 2788 idx = find_internal_func(name); 2789 if (idx >= 0) 2790 res = generate_BCALL(cctx, idx, argcount); 2791 else 2792 semsg(_(e_unknownfunc), namebuf); 2793 goto theend; 2794 } 2795 2796 // If we can find the function by name generate the right call. 2797 ufunc = find_func(name, FALSE, cctx); 2798 if (ufunc != NULL) 2799 { 2800 res = generate_CALL(cctx, ufunc, argcount); 2801 goto theend; 2802 } 2803 2804 // If the name is a variable, load it and use PCALL. 2805 // Not for g:Func(), we don't know if it is a variable or not. 2806 p = namebuf; 2807 if (STRNCMP(namebuf, "g:", 2) != 0 2808 && compile_load(&p, namebuf + varlen, cctx, FALSE) == OK) 2809 { 2810 garray_T *stack = &cctx->ctx_type_stack; 2811 type_T *type; 2812 2813 type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 2814 res = generate_PCALL(cctx, argcount, namebuf, type, FALSE); 2815 goto theend; 2816 } 2817 2818 // A global function may be defined only later. Need to figure out at 2819 // runtime. Also handles a FuncRef at runtime. 2820 if (STRNCMP(namebuf, "g:", 2) == 0) 2821 res = generate_UCALL(cctx, name, argcount); 2822 else 2823 semsg(_(e_unknownfunc), namebuf); 2824 2825 theend: 2826 vim_free(tofree); 2827 return res; 2828 } 2829 2830 // like NAMESPACE_CHAR but with 'a' and 'l'. 2831 #define VIM9_NAMESPACE_CHAR (char_u *)"bgstvw" 2832 2833 /* 2834 * Find the end of a variable or function name. Unlike find_name_end() this 2835 * does not recognize magic braces. 2836 * When "namespace" is TRUE recognize "b:", "s:", etc. 2837 * Return a pointer to just after the name. Equal to "arg" if there is no 2838 * valid name. 2839 */ 2840 static char_u * 2841 to_name_end(char_u *arg, int namespace) 2842 { 2843 char_u *p; 2844 2845 // Quick check for valid starting character. 2846 if (!eval_isnamec1(*arg)) 2847 return arg; 2848 2849 for (p = arg + 1; *p != NUL && eval_isnamec(*p); MB_PTR_ADV(p)) 2850 // Include a namespace such as "s:var" and "v:var". But "n:" is not 2851 // and can be used in slice "[n:]". 2852 if (*p == ':' && (p != arg + 1 2853 || !namespace 2854 || vim_strchr(VIM9_NAMESPACE_CHAR, *arg) == NULL)) 2855 break; 2856 return p; 2857 } 2858 2859 /* 2860 * Like to_name_end() but also skip over a list or dict constant. 2861 */ 2862 char_u * 2863 to_name_const_end(char_u *arg) 2864 { 2865 char_u *p = to_name_end(arg, TRUE); 2866 typval_T rettv; 2867 2868 if (p == arg && *arg == '[') 2869 { 2870 2871 // Can be "[1, 2, 3]->Func()". 2872 if (get_list_tv(&p, &rettv, 0, FALSE) == FAIL) 2873 p = arg; 2874 } 2875 else if (p == arg && *arg == '#' && arg[1] == '{') 2876 { 2877 // Can be "#{a: 1}->Func()". 2878 ++p; 2879 if (eval_dict(&p, &rettv, 0, TRUE) == FAIL) 2880 p = arg; 2881 } 2882 else if (p == arg && *arg == '{') 2883 { 2884 int ret = get_lambda_tv(&p, &rettv, FALSE); 2885 2886 // Can be "{x -> ret}()". 2887 // Can be "{'a': 1}->Func()". 2888 if (ret == NOTDONE) 2889 ret = eval_dict(&p, &rettv, 0, FALSE); 2890 if (ret != OK) 2891 p = arg; 2892 } 2893 2894 return p; 2895 } 2896 2897 /* 2898 * parse a list: [expr, expr] 2899 * "*arg" points to the '['. 2900 */ 2901 static int 2902 compile_list(char_u **arg, cctx_T *cctx) 2903 { 2904 char_u *p = skipwhite(*arg + 1); 2905 char_u *whitep = *arg + 1; 2906 int count = 0; 2907 2908 for (;;) 2909 { 2910 while (*p == NUL || (VIM_ISWHITE(*whitep) && comment_start(p))) 2911 { 2912 p = next_line_from_context(cctx); 2913 if (p == NULL) 2914 { 2915 semsg(_(e_list_end), *arg); 2916 return FAIL; 2917 } 2918 whitep = (char_u *)" "; 2919 p = skipwhite(p); 2920 } 2921 if (*p == ']') 2922 { 2923 ++p; 2924 // Allow for following comment, after at least one space. 2925 if (VIM_ISWHITE(*p) && *skipwhite(p) == '"') 2926 p += STRLEN(p); 2927 break; 2928 } 2929 if (compile_expr0(&p, cctx) == FAIL) 2930 break; 2931 ++count; 2932 if (*p == ',') 2933 ++p; 2934 whitep = p; 2935 p = skipwhite(p); 2936 } 2937 *arg = p; 2938 2939 generate_NEWLIST(cctx, count); 2940 return OK; 2941 } 2942 2943 /* 2944 * parse a lambda: {arg, arg -> expr} 2945 * "*arg" points to the '{'. 2946 */ 2947 static int 2948 compile_lambda(char_u **arg, cctx_T *cctx) 2949 { 2950 typval_T rettv; 2951 ufunc_T *ufunc; 2952 2953 // Get the funcref in "rettv". 2954 if (get_lambda_tv(arg, &rettv, TRUE) != OK) 2955 return FAIL; 2956 2957 ufunc = rettv.vval.v_partial->pt_func; 2958 ++ufunc->uf_refcount; 2959 clear_tv(&rettv); 2960 ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10); 2961 2962 // The function will have one line: "return {expr}". 2963 // Compile it into instructions. 2964 compile_def_function(ufunc, TRUE, cctx); 2965 2966 if (ufunc->uf_dfunc_idx >= 0) 2967 return generate_FUNCREF(cctx, ufunc->uf_dfunc_idx); 2968 return FAIL; 2969 } 2970 2971 /* 2972 * Compile a lamda call: expr->{lambda}(args) 2973 * "arg" points to the "{". 2974 */ 2975 static int 2976 compile_lambda_call(char_u **arg, cctx_T *cctx) 2977 { 2978 ufunc_T *ufunc; 2979 typval_T rettv; 2980 int argcount = 1; 2981 int ret = FAIL; 2982 2983 // Get the funcref in "rettv". 2984 if (get_lambda_tv(arg, &rettv, TRUE) == FAIL) 2985 return FAIL; 2986 2987 if (**arg != '(') 2988 { 2989 if (*skipwhite(*arg) == '(') 2990 emsg(_(e_nowhitespace)); 2991 else 2992 semsg(_(e_missing_paren), "lambda"); 2993 clear_tv(&rettv); 2994 return FAIL; 2995 } 2996 2997 ufunc = rettv.vval.v_partial->pt_func; 2998 ++ufunc->uf_refcount; 2999 clear_tv(&rettv); 3000 ga_init2(&ufunc->uf_type_list, sizeof(type_T *), 10); 3001 3002 // The function will have one line: "return {expr}". 3003 // Compile it into instructions. 3004 compile_def_function(ufunc, TRUE, cctx); 3005 3006 // compile the arguments 3007 *arg = skipwhite(*arg + 1); 3008 if (compile_arguments(arg, cctx, &argcount) == OK) 3009 // call the compiled function 3010 ret = generate_CALL(cctx, ufunc, argcount); 3011 3012 return ret; 3013 } 3014 3015 /* 3016 * parse a dict: {'key': val} or #{key: val} 3017 * "*arg" points to the '{'. 3018 */ 3019 static int 3020 compile_dict(char_u **arg, cctx_T *cctx, int literal) 3021 { 3022 garray_T *instr = &cctx->ctx_instr; 3023 int count = 0; 3024 dict_T *d = dict_alloc(); 3025 dictitem_T *item; 3026 char_u *whitep = *arg; 3027 char_u *p; 3028 3029 if (d == NULL) 3030 return FAIL; 3031 *arg = skipwhite(*arg + 1); 3032 for (;;) 3033 { 3034 char_u *key = NULL; 3035 3036 while (**arg == NUL || (literal && **arg == '"') 3037 || (VIM_ISWHITE(*whitep) && comment_start(*arg))) 3038 { 3039 *arg = next_line_from_context(cctx); 3040 if (*arg == NULL) 3041 goto failret; 3042 whitep = (char_u *)" "; 3043 *arg = skipwhite(*arg); 3044 } 3045 3046 if (**arg == '}') 3047 break; 3048 3049 if (literal) 3050 { 3051 char_u *end = to_name_end(*arg, !literal); 3052 3053 if (end == *arg) 3054 { 3055 semsg(_("E1014: Invalid key: %s"), *arg); 3056 return FAIL; 3057 } 3058 key = vim_strnsave(*arg, end - *arg); 3059 if (generate_PUSHS(cctx, key) == FAIL) 3060 return FAIL; 3061 *arg = end; 3062 } 3063 else 3064 { 3065 isn_T *isn; 3066 3067 if (compile_expr0(arg, cctx) == FAIL) 3068 return FAIL; 3069 // TODO: check type is string 3070 isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1; 3071 if (isn->isn_type == ISN_PUSHS) 3072 key = isn->isn_arg.string; 3073 } 3074 3075 // Check for duplicate keys, if using string keys. 3076 if (key != NULL) 3077 { 3078 item = dict_find(d, key, -1); 3079 if (item != NULL) 3080 { 3081 semsg(_(e_duplicate_key), key); 3082 goto failret; 3083 } 3084 item = dictitem_alloc(key); 3085 if (item != NULL) 3086 { 3087 item->di_tv.v_type = VAR_UNKNOWN; 3088 item->di_tv.v_lock = 0; 3089 if (dict_add(d, item) == FAIL) 3090 dictitem_free(item); 3091 } 3092 } 3093 3094 *arg = skipwhite(*arg); 3095 if (**arg != ':') 3096 { 3097 semsg(_(e_missing_dict_colon), *arg); 3098 return FAIL; 3099 } 3100 3101 whitep = *arg + 1; 3102 *arg = skipwhite(*arg + 1); 3103 while (**arg == NUL || (VIM_ISWHITE(*whitep) && comment_start(*arg))) 3104 { 3105 *arg = next_line_from_context(cctx); 3106 if (*arg == NULL) 3107 goto failret; 3108 whitep = (char_u *)" "; 3109 *arg = skipwhite(*arg); 3110 } 3111 3112 if (compile_expr0(arg, cctx) == FAIL) 3113 return FAIL; 3114 ++count; 3115 3116 whitep = *arg; 3117 p = skipwhite(*arg); 3118 while (*p == NUL || (VIM_ISWHITE(*whitep) && comment_start(p))) 3119 { 3120 *arg = next_line_from_context(cctx); 3121 if (*arg == NULL) 3122 goto failret; 3123 whitep = (char_u *)" "; 3124 *arg = skipwhite(*arg); 3125 p = *arg; 3126 } 3127 if (**arg == '}') 3128 break; 3129 if (**arg != ',') 3130 { 3131 semsg(_(e_missing_dict_comma), *arg); 3132 goto failret; 3133 } 3134 whitep = *arg + 1; 3135 *arg = skipwhite(*arg + 1); 3136 } 3137 3138 *arg = *arg + 1; 3139 3140 // Allow for following comment, after at least one space. 3141 p = skipwhite(*arg); 3142 if (VIM_ISWHITE(**arg) && (*p == '"' || comment_start(p))) 3143 *arg += STRLEN(*arg); 3144 3145 dict_unref(d); 3146 return generate_NEWDICT(cctx, count); 3147 3148 failret: 3149 if (*arg == NULL) 3150 semsg(_(e_missing_dict_end), _("[end of lines]")); 3151 dict_unref(d); 3152 return FAIL; 3153 } 3154 3155 /* 3156 * Compile "&option". 3157 */ 3158 static int 3159 compile_get_option(char_u **arg, cctx_T *cctx) 3160 { 3161 typval_T rettv; 3162 char_u *start = *arg; 3163 int ret; 3164 3165 // parse the option and get the current value to get the type. 3166 rettv.v_type = VAR_UNKNOWN; 3167 ret = get_option_tv(arg, &rettv, TRUE); 3168 if (ret == OK) 3169 { 3170 // include the '&' in the name, get_option_tv() expects it. 3171 char_u *name = vim_strnsave(start, *arg - start); 3172 type_T *type = rettv.v_type == VAR_NUMBER ? &t_number : &t_string; 3173 3174 ret = generate_LOAD(cctx, ISN_LOADOPT, 0, name, type); 3175 vim_free(name); 3176 } 3177 clear_tv(&rettv); 3178 3179 return ret; 3180 } 3181 3182 /* 3183 * Compile "$VAR". 3184 */ 3185 static int 3186 compile_get_env(char_u **arg, cctx_T *cctx) 3187 { 3188 char_u *start = *arg; 3189 int len; 3190 int ret; 3191 char_u *name; 3192 3193 ++*arg; 3194 len = get_env_len(arg); 3195 if (len == 0) 3196 { 3197 semsg(_(e_syntax_at), start - 1); 3198 return FAIL; 3199 } 3200 3201 // include the '$' in the name, get_env_tv() expects it. 3202 name = vim_strnsave(start, len + 1); 3203 ret = generate_LOAD(cctx, ISN_LOADENV, 0, name, &t_string); 3204 vim_free(name); 3205 return ret; 3206 } 3207 3208 /* 3209 * Compile "@r". 3210 */ 3211 static int 3212 compile_get_register(char_u **arg, cctx_T *cctx) 3213 { 3214 int ret; 3215 3216 ++*arg; 3217 if (**arg == NUL) 3218 { 3219 semsg(_(e_syntax_at), *arg - 1); 3220 return FAIL; 3221 } 3222 if (!valid_yank_reg(**arg, TRUE)) 3223 { 3224 emsg_invreg(**arg); 3225 return FAIL; 3226 } 3227 ret = generate_LOAD(cctx, ISN_LOADREG, **arg, NULL, &t_string); 3228 ++*arg; 3229 return ret; 3230 } 3231 3232 /* 3233 * Apply leading '!', '-' and '+' to constant "rettv". 3234 */ 3235 static int 3236 apply_leader(typval_T *rettv, char_u *start, char_u *end) 3237 { 3238 char_u *p = end; 3239 3240 // this works from end to start 3241 while (p > start) 3242 { 3243 --p; 3244 if (*p == '-' || *p == '+') 3245 { 3246 // only '-' has an effect, for '+' we only check the type 3247 #ifdef FEAT_FLOAT 3248 if (rettv->v_type == VAR_FLOAT) 3249 { 3250 if (*p == '-') 3251 rettv->vval.v_float = -rettv->vval.v_float; 3252 } 3253 else 3254 #endif 3255 { 3256 varnumber_T val; 3257 int error = FALSE; 3258 3259 // tv_get_number_chk() accepts a string, but we don't want that 3260 // here 3261 if (check_not_string(rettv) == FAIL) 3262 return FAIL; 3263 val = tv_get_number_chk(rettv, &error); 3264 clear_tv(rettv); 3265 if (error) 3266 return FAIL; 3267 if (*p == '-') 3268 val = -val; 3269 rettv->v_type = VAR_NUMBER; 3270 rettv->vval.v_number = val; 3271 } 3272 } 3273 else 3274 { 3275 int v = tv2bool(rettv); 3276 3277 // '!' is permissive in the type. 3278 clear_tv(rettv); 3279 rettv->v_type = VAR_BOOL; 3280 rettv->vval.v_number = v ? VVAL_FALSE : VVAL_TRUE; 3281 } 3282 } 3283 return OK; 3284 } 3285 3286 /* 3287 * Recognize v: variables that are constants and set "rettv". 3288 */ 3289 static void 3290 get_vim_constant(char_u **arg, typval_T *rettv) 3291 { 3292 if (STRNCMP(*arg, "v:true", 6) == 0) 3293 { 3294 rettv->v_type = VAR_BOOL; 3295 rettv->vval.v_number = VVAL_TRUE; 3296 *arg += 6; 3297 } 3298 else if (STRNCMP(*arg, "v:false", 7) == 0) 3299 { 3300 rettv->v_type = VAR_BOOL; 3301 rettv->vval.v_number = VVAL_FALSE; 3302 *arg += 7; 3303 } 3304 else if (STRNCMP(*arg, "v:null", 6) == 0) 3305 { 3306 rettv->v_type = VAR_SPECIAL; 3307 rettv->vval.v_number = VVAL_NULL; 3308 *arg += 6; 3309 } 3310 else if (STRNCMP(*arg, "v:none", 6) == 0) 3311 { 3312 rettv->v_type = VAR_SPECIAL; 3313 rettv->vval.v_number = VVAL_NONE; 3314 *arg += 6; 3315 } 3316 } 3317 3318 static exptype_T 3319 get_compare_type(char_u *p, int *len, int *type_is) 3320 { 3321 exptype_T type = EXPR_UNKNOWN; 3322 int i; 3323 3324 switch (p[0]) 3325 { 3326 case '=': if (p[1] == '=') 3327 type = EXPR_EQUAL; 3328 else if (p[1] == '~') 3329 type = EXPR_MATCH; 3330 break; 3331 case '!': if (p[1] == '=') 3332 type = EXPR_NEQUAL; 3333 else if (p[1] == '~') 3334 type = EXPR_NOMATCH; 3335 break; 3336 case '>': if (p[1] != '=') 3337 { 3338 type = EXPR_GREATER; 3339 *len = 1; 3340 } 3341 else 3342 type = EXPR_GEQUAL; 3343 break; 3344 case '<': if (p[1] != '=') 3345 { 3346 type = EXPR_SMALLER; 3347 *len = 1; 3348 } 3349 else 3350 type = EXPR_SEQUAL; 3351 break; 3352 case 'i': if (p[1] == 's') 3353 { 3354 // "is" and "isnot"; but not a prefix of a name 3355 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't') 3356 *len = 5; 3357 i = p[*len]; 3358 if (!isalnum(i) && i != '_') 3359 { 3360 type = *len == 2 ? EXPR_IS : EXPR_ISNOT; 3361 *type_is = TRUE; 3362 } 3363 } 3364 break; 3365 } 3366 return type; 3367 } 3368 3369 /* 3370 * Compile code to apply '-', '+' and '!'. 3371 */ 3372 static int 3373 compile_leader(cctx_T *cctx, char_u *start, char_u *end) 3374 { 3375 char_u *p = end; 3376 3377 // this works from end to start 3378 while (p > start) 3379 { 3380 --p; 3381 if (*p == '-' || *p == '+') 3382 { 3383 int negate = *p == '-'; 3384 isn_T *isn; 3385 3386 // TODO: check type 3387 while (p > start && (p[-1] == '-' || p[-1] == '+')) 3388 { 3389 --p; 3390 if (*p == '-') 3391 negate = !negate; 3392 } 3393 // only '-' has an effect, for '+' we only check the type 3394 if (negate) 3395 isn = generate_instr(cctx, ISN_NEGATENR); 3396 else 3397 isn = generate_instr(cctx, ISN_CHECKNR); 3398 if (isn == NULL) 3399 return FAIL; 3400 } 3401 else 3402 { 3403 int invert = TRUE; 3404 3405 while (p > start && p[-1] == '!') 3406 { 3407 --p; 3408 invert = !invert; 3409 } 3410 if (generate_2BOOL(cctx, invert) == FAIL) 3411 return FAIL; 3412 } 3413 } 3414 return OK; 3415 } 3416 3417 /* 3418 * Compile whatever comes after "name" or "name()". 3419 */ 3420 static int 3421 compile_subscript( 3422 char_u **arg, 3423 cctx_T *cctx, 3424 char_u **start_leader, 3425 char_u *end_leader, 3426 ppconst_T *ppconst) 3427 { 3428 for (;;) 3429 { 3430 if (**arg == '(') 3431 { 3432 garray_T *stack = &cctx->ctx_type_stack; 3433 type_T *type; 3434 int argcount = 0; 3435 3436 if (generate_ppconst(cctx, ppconst) == FAIL) 3437 return FAIL; 3438 3439 // funcref(arg) 3440 type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 3441 3442 *arg = skipwhite(*arg + 1); 3443 if (compile_arguments(arg, cctx, &argcount) == FAIL) 3444 return FAIL; 3445 if (generate_PCALL(cctx, argcount, end_leader, type, TRUE) == FAIL) 3446 return FAIL; 3447 } 3448 else if (**arg == '-' && (*arg)[1] == '>') 3449 { 3450 char_u *p; 3451 3452 if (generate_ppconst(cctx, ppconst) == FAIL) 3453 return FAIL; 3454 3455 // something->method() 3456 // Apply the '!', '-' and '+' first: 3457 // -1.0->func() works like (-1.0)->func() 3458 if (compile_leader(cctx, *start_leader, end_leader) == FAIL) 3459 return FAIL; 3460 *start_leader = end_leader; // don't apply again later 3461 3462 *arg = skipwhite(*arg + 2); 3463 if (**arg == '{') 3464 { 3465 // lambda call: list->{lambda} 3466 if (compile_lambda_call(arg, cctx) == FAIL) 3467 return FAIL; 3468 } 3469 else 3470 { 3471 // method call: list->method() 3472 p = *arg; 3473 if (ASCII_ISALPHA(*p) && p[1] == ':') 3474 p += 2; 3475 for ( ; eval_isnamec1(*p); ++p) 3476 ; 3477 if (*p != '(') 3478 { 3479 semsg(_(e_missing_paren), *arg); 3480 return FAIL; 3481 } 3482 // TODO: base value may not be the first argument 3483 if (compile_call(arg, p - *arg, cctx, ppconst, 1) == FAIL) 3484 return FAIL; 3485 } 3486 } 3487 else if (**arg == '[') 3488 { 3489 garray_T *stack = &cctx->ctx_type_stack; 3490 type_T **typep; 3491 3492 // list index: list[123] 3493 // dict member: dict[key] 3494 // TODO: blob index 3495 // TODO: more arguments 3496 // TODO: recognize list or dict at runtime 3497 if (generate_ppconst(cctx, ppconst) == FAIL) 3498 return FAIL; 3499 3500 *arg = skipwhite(*arg + 1); 3501 if (compile_expr0(arg, cctx) == FAIL) 3502 return FAIL; 3503 3504 if (**arg != ']') 3505 { 3506 emsg(_(e_missbrac)); 3507 return FAIL; 3508 } 3509 *arg = *arg + 1; 3510 3511 typep = ((type_T **)stack->ga_data) + stack->ga_len - 2; 3512 if ((*typep)->tt_type == VAR_LIST || (*typep) == &t_any) 3513 { 3514 if ((*typep)->tt_type == VAR_LIST) 3515 *typep = (*typep)->tt_member; 3516 if (generate_instr_drop(cctx, ISN_INDEX, 1) == FAIL) 3517 return FAIL; 3518 } 3519 else if ((*typep)->tt_type == VAR_DICT) 3520 { 3521 *typep = (*typep)->tt_member; 3522 if (may_generate_2STRING(-1, cctx) == FAIL) 3523 return FAIL; 3524 if (generate_instr_drop(cctx, ISN_MEMBER, 1) == FAIL) 3525 return FAIL; 3526 } 3527 else 3528 { 3529 emsg(_(e_listdictblobreq)); 3530 return FAIL; 3531 } 3532 } 3533 else if (**arg == '.' && (*arg)[1] != '.') 3534 { 3535 char_u *p; 3536 3537 if (generate_ppconst(cctx, ppconst) == FAIL) 3538 return FAIL; 3539 3540 ++*arg; 3541 p = *arg; 3542 // dictionary member: dict.name 3543 if (eval_isnamec1(*p)) 3544 while (eval_isnamec(*p)) 3545 MB_PTR_ADV(p); 3546 if (p == *arg) 3547 { 3548 semsg(_(e_syntax_at), *arg); 3549 return FAIL; 3550 } 3551 if (generate_STRINGMEMBER(cctx, *arg, p - *arg) == FAIL) 3552 return FAIL; 3553 *arg = p; 3554 } 3555 else 3556 break; 3557 } 3558 3559 // TODO - see handle_subscript(): 3560 // Turn "dict.Func" into a partial for "Func" bound to "dict". 3561 // Don't do this when "Func" is already a partial that was bound 3562 // explicitly (pt_auto is FALSE). 3563 3564 return OK; 3565 } 3566 3567 /* 3568 * Compile an expression at "*arg" and add instructions to "cctx->ctx_instr". 3569 * "arg" is advanced until after the expression, skipping white space. 3570 * 3571 * If the value is a constant "ppconst->pp_ret" will be set. 3572 * Before instructions are generated, any values in "ppconst" will generated. 3573 * 3574 * This is the compiling equivalent of eval1(), eval2(), etc. 3575 */ 3576 3577 /* 3578 * number number constant 3579 * 0zFFFFFFFF Blob constant 3580 * "string" string constant 3581 * 'string' literal string constant 3582 * &option-name option value 3583 * @r register contents 3584 * identifier variable value 3585 * function() function call 3586 * $VAR environment variable 3587 * (expression) nested expression 3588 * [expr, expr] List 3589 * {key: val, key: val} Dictionary 3590 * #{key: val, key: val} Dictionary with literal keys 3591 * 3592 * Also handle: 3593 * ! in front logical NOT 3594 * - in front unary minus 3595 * + in front unary plus (ignored) 3596 * trailing (arg) funcref/partial call 3597 * trailing [] subscript in String or List 3598 * trailing .name entry in Dictionary 3599 * trailing ->name() method call 3600 */ 3601 static int 3602 compile_expr7( 3603 char_u **arg, 3604 cctx_T *cctx, 3605 ppconst_T *ppconst) 3606 { 3607 char_u *start_leader, *end_leader; 3608 int ret = OK; 3609 typval_T *rettv = &ppconst->pp_tv[ppconst->pp_used]; 3610 int used_before = ppconst->pp_used; 3611 3612 /* 3613 * Skip '!', '-' and '+' characters. They are handled later. 3614 */ 3615 start_leader = *arg; 3616 while (**arg == '!' || **arg == '-' || **arg == '+') 3617 *arg = skipwhite(*arg + 1); 3618 end_leader = *arg; 3619 3620 rettv->v_type = VAR_UNKNOWN; 3621 switch (**arg) 3622 { 3623 /* 3624 * Number constant. 3625 */ 3626 case '0': // also for blob starting with 0z 3627 case '1': 3628 case '2': 3629 case '3': 3630 case '4': 3631 case '5': 3632 case '6': 3633 case '7': 3634 case '8': 3635 case '9': 3636 case '.': if (get_number_tv(arg, rettv, TRUE, FALSE) == FAIL) 3637 return FAIL; 3638 break; 3639 3640 /* 3641 * String constant: "string". 3642 */ 3643 case '"': if (get_string_tv(arg, rettv, TRUE) == FAIL) 3644 return FAIL; 3645 break; 3646 3647 /* 3648 * Literal string constant: 'str''ing'. 3649 */ 3650 case '\'': if (get_lit_string_tv(arg, rettv, TRUE) == FAIL) 3651 return FAIL; 3652 break; 3653 3654 /* 3655 * Constant Vim variable. 3656 */ 3657 case 'v': get_vim_constant(arg, rettv); 3658 ret = NOTDONE; 3659 break; 3660 3661 /* 3662 * "true" constant 3663 */ 3664 case 't': if (STRNCMP(*arg, "true", 4) == 0 3665 && !eval_isnamec((*arg)[4])) 3666 { 3667 *arg += 4; 3668 rettv->v_type = VAR_BOOL; 3669 rettv->vval.v_number = VVAL_TRUE; 3670 } 3671 else 3672 ret = NOTDONE; 3673 break; 3674 3675 /* 3676 * "false" constant 3677 */ 3678 case 'f': if (STRNCMP(*arg, "false", 5) == 0 3679 && !eval_isnamec((*arg)[5])) 3680 { 3681 *arg += 5; 3682 rettv->v_type = VAR_BOOL; 3683 rettv->vval.v_number = VVAL_FALSE; 3684 } 3685 else 3686 ret = NOTDONE; 3687 break; 3688 3689 /* 3690 * List: [expr, expr] 3691 */ 3692 case '[': ret = compile_list(arg, cctx); 3693 break; 3694 3695 /* 3696 * Dictionary: #{key: val, key: val} 3697 */ 3698 case '#': if ((*arg)[1] == '{') 3699 { 3700 ++*arg; 3701 ret = compile_dict(arg, cctx, TRUE); 3702 } 3703 else 3704 ret = NOTDONE; 3705 break; 3706 3707 /* 3708 * Lambda: {arg, arg -> expr} 3709 * Dictionary: {'key': val, 'key': val} 3710 */ 3711 case '{': { 3712 char_u *start = skipwhite(*arg + 1); 3713 3714 // Find out what comes after the arguments. 3715 // TODO: pass getline function 3716 ret = get_function_args(&start, '-', NULL, 3717 NULL, NULL, NULL, TRUE, NULL, NULL); 3718 if (ret != FAIL && *start == '>') 3719 ret = compile_lambda(arg, cctx); 3720 else 3721 ret = compile_dict(arg, cctx, FALSE); 3722 } 3723 break; 3724 3725 /* 3726 * Option value: &name 3727 */ 3728 case '&': ret = compile_get_option(arg, cctx); 3729 break; 3730 3731 /* 3732 * Environment variable: $VAR. 3733 */ 3734 case '$': ret = compile_get_env(arg, cctx); 3735 break; 3736 3737 /* 3738 * Register contents: @r. 3739 */ 3740 case '@': ret = compile_get_register(arg, cctx); 3741 break; 3742 /* 3743 * nested expression: (expression). 3744 */ 3745 case '(': *arg = skipwhite(*arg + 1); 3746 3747 // recursive! 3748 if (ppconst->pp_used <= PPSIZE - 10) 3749 { 3750 ret = compile_expr1(arg, cctx, ppconst); 3751 } 3752 else 3753 { 3754 // Not enough space in ppconst, flush constants. 3755 if (generate_ppconst(cctx, ppconst) == FAIL) 3756 return FAIL; 3757 ret = compile_expr0(arg, cctx); 3758 } 3759 *arg = skipwhite(*arg); 3760 if (**arg == ')') 3761 ++*arg; 3762 else if (ret == OK) 3763 { 3764 emsg(_(e_missing_close)); 3765 ret = FAIL; 3766 } 3767 break; 3768 3769 default: ret = NOTDONE; 3770 break; 3771 } 3772 if (ret == FAIL) 3773 return FAIL; 3774 3775 if (rettv->v_type != VAR_UNKNOWN && used_before == ppconst->pp_used) 3776 { 3777 // apply the '!', '-' and '+' before the constant 3778 if (apply_leader(rettv, start_leader, end_leader) == FAIL) 3779 { 3780 clear_tv(rettv); 3781 return FAIL; 3782 } 3783 start_leader = end_leader; // don't apply again below 3784 3785 if (cctx->ctx_skip == TRUE) 3786 clear_tv(rettv); 3787 else 3788 // A constant expression can possibly be handled compile time, 3789 // return the value instead of generating code. 3790 ++ppconst->pp_used; 3791 } 3792 else if (ret == NOTDONE) 3793 { 3794 char_u *p; 3795 int r; 3796 3797 if (!eval_isnamec1(**arg)) 3798 { 3799 semsg(_("E1015: Name expected: %s"), *arg); 3800 return FAIL; 3801 } 3802 3803 // "name" or "name()" 3804 p = to_name_end(*arg, TRUE); 3805 if (*p == '(') 3806 { 3807 r = compile_call(arg, p - *arg, cctx, ppconst, 0); 3808 } 3809 else 3810 { 3811 if (generate_ppconst(cctx, ppconst) == FAIL) 3812 return FAIL; 3813 r = compile_load(arg, p, cctx, TRUE); 3814 } 3815 if (r == FAIL) 3816 return FAIL; 3817 } 3818 3819 // Handle following "[]", ".member", etc. 3820 // Then deal with prefixed '-', '+' and '!', if not done already. 3821 if (compile_subscript(arg, cctx, &start_leader, end_leader, 3822 ppconst) == FAIL) 3823 return FAIL; 3824 if (ppconst->pp_used > 0) 3825 { 3826 // apply the '!', '-' and '+' before the constant 3827 rettv = &ppconst->pp_tv[ppconst->pp_used - 1]; 3828 if (apply_leader(rettv, start_leader, end_leader) == FAIL) 3829 return FAIL; 3830 return OK; 3831 } 3832 if (compile_leader(cctx, start_leader, end_leader) == FAIL) 3833 return FAIL; 3834 return OK; 3835 } 3836 3837 /* 3838 * * number multiplication 3839 * / number division 3840 * % number modulo 3841 */ 3842 static int 3843 compile_expr6(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 3844 { 3845 char_u *op; 3846 int ppconst_used = ppconst->pp_used; 3847 3848 // get the first expression 3849 if (compile_expr7(arg, cctx, ppconst) == FAIL) 3850 return FAIL; 3851 3852 /* 3853 * Repeat computing, until no "*", "/" or "%" is following. 3854 */ 3855 for (;;) 3856 { 3857 op = skipwhite(*arg); 3858 if (*op != '*' && *op != '/' && *op != '%') 3859 break; 3860 3861 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[1])) 3862 { 3863 char_u buf[3]; 3864 3865 vim_strncpy(buf, op, 1); 3866 semsg(_(e_white_both), buf); 3867 return FAIL; 3868 } 3869 *arg = skipwhite(op + 1); 3870 if (may_get_next_line(op + 1, arg, cctx) == FAIL) 3871 return FAIL; 3872 3873 // get the second expression 3874 if (compile_expr7(arg, cctx, ppconst) == FAIL) 3875 return FAIL; 3876 3877 if (ppconst->pp_used == ppconst_used + 2 3878 && ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER 3879 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER) 3880 { 3881 typval_T *tv1 = &ppconst->pp_tv[ppconst_used]; 3882 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1]; 3883 varnumber_T res = 0; 3884 3885 // both are numbers: compute the result 3886 switch (*op) 3887 { 3888 case '*': res = tv1->vval.v_number * tv2->vval.v_number; 3889 break; 3890 case '/': res = tv1->vval.v_number / tv2->vval.v_number; 3891 break; 3892 case '%': res = tv1->vval.v_number % tv2->vval.v_number; 3893 break; 3894 } 3895 tv1->vval.v_number = res; 3896 --ppconst->pp_used; 3897 } 3898 else 3899 { 3900 generate_ppconst(cctx, ppconst); 3901 generate_two_op(cctx, op); 3902 } 3903 } 3904 3905 return OK; 3906 } 3907 3908 /* 3909 * + number addition 3910 * - number subtraction 3911 * .. string concatenation 3912 */ 3913 static int 3914 compile_expr5(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 3915 { 3916 char_u *op; 3917 int oplen; 3918 int ppconst_used = ppconst->pp_used; 3919 3920 // get the first variable 3921 if (compile_expr6(arg, cctx, ppconst) == FAIL) 3922 return FAIL; 3923 3924 /* 3925 * Repeat computing, until no "+", "-" or ".." is following. 3926 */ 3927 for (;;) 3928 { 3929 op = skipwhite(*arg); 3930 if (*op != '+' && *op != '-' && !(*op == '.' && (*(*arg + 1) == '.'))) 3931 break; 3932 oplen = (*op == '.' ? 2 : 1); 3933 3934 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(op[oplen])) 3935 { 3936 char_u buf[3]; 3937 3938 vim_strncpy(buf, op, oplen); 3939 semsg(_(e_white_both), buf); 3940 return FAIL; 3941 } 3942 3943 *arg = skipwhite(op + oplen); 3944 if (may_get_next_line(op + oplen, arg, cctx) == FAIL) 3945 return FAIL; 3946 3947 // get the second expression 3948 if (compile_expr6(arg, cctx, ppconst) == FAIL) 3949 return FAIL; 3950 3951 if (ppconst->pp_used == ppconst_used + 2 3952 && (*op == '.' 3953 ? (ppconst->pp_tv[ppconst_used].v_type == VAR_STRING 3954 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_STRING) 3955 : (ppconst->pp_tv[ppconst_used].v_type == VAR_NUMBER 3956 && ppconst->pp_tv[ppconst_used + 1].v_type == VAR_NUMBER))) 3957 { 3958 typval_T *tv1 = &ppconst->pp_tv[ppconst_used]; 3959 typval_T *tv2 = &ppconst->pp_tv[ppconst_used + 1]; 3960 3961 // concat/subtract/add constant numbers 3962 if (*op == '+') 3963 tv1->vval.v_number = tv1->vval.v_number + tv2->vval.v_number; 3964 else if (*op == '-') 3965 tv1->vval.v_number = tv1->vval.v_number - tv2->vval.v_number; 3966 else 3967 { 3968 // concatenate constant strings 3969 char_u *s1 = tv1->vval.v_string; 3970 char_u *s2 = tv2->vval.v_string; 3971 size_t len1 = STRLEN(s1); 3972 3973 tv1->vval.v_string = alloc((int)(len1 + STRLEN(s2) + 1)); 3974 if (tv1->vval.v_string == NULL) 3975 { 3976 clear_ppconst(ppconst); 3977 return FAIL; 3978 } 3979 mch_memmove(tv1->vval.v_string, s1, len1); 3980 STRCPY(tv1->vval.v_string + len1, s2); 3981 vim_free(s1); 3982 vim_free(s2); 3983 } 3984 --ppconst->pp_used; 3985 } 3986 else 3987 { 3988 generate_ppconst(cctx, ppconst); 3989 if (*op == '.') 3990 { 3991 if (may_generate_2STRING(-2, cctx) == FAIL 3992 || may_generate_2STRING(-1, cctx) == FAIL) 3993 return FAIL; 3994 generate_instr_drop(cctx, ISN_CONCAT, 1); 3995 } 3996 else 3997 generate_two_op(cctx, op); 3998 } 3999 } 4000 4001 return OK; 4002 } 4003 4004 /* 4005 * expr5a == expr5b 4006 * expr5a =~ expr5b 4007 * expr5a != expr5b 4008 * expr5a !~ expr5b 4009 * expr5a > expr5b 4010 * expr5a >= expr5b 4011 * expr5a < expr5b 4012 * expr5a <= expr5b 4013 * expr5a is expr5b 4014 * expr5a isnot expr5b 4015 * 4016 * Produces instructions: 4017 * EVAL expr5a Push result of "expr5a" 4018 * EVAL expr5b Push result of "expr5b" 4019 * COMPARE one of the compare instructions 4020 */ 4021 static int 4022 compile_expr4(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4023 { 4024 exptype_T type = EXPR_UNKNOWN; 4025 char_u *p; 4026 int len = 2; 4027 int type_is = FALSE; 4028 int ppconst_used = ppconst->pp_used; 4029 4030 // get the first variable 4031 if (compile_expr5(arg, cctx, ppconst) == FAIL) 4032 return FAIL; 4033 4034 p = skipwhite(*arg); 4035 type = get_compare_type(p, &len, &type_is); 4036 4037 /* 4038 * If there is a comparative operator, use it. 4039 */ 4040 if (type != EXPR_UNKNOWN) 4041 { 4042 int ic = FALSE; // Default: do not ignore case 4043 4044 if (type_is && (p[len] == '?' || p[len] == '#')) 4045 { 4046 semsg(_(e_invexpr2), *arg); 4047 return FAIL; 4048 } 4049 // extra question mark appended: ignore case 4050 if (p[len] == '?') 4051 { 4052 ic = TRUE; 4053 ++len; 4054 } 4055 // extra '#' appended: match case (ignored) 4056 else if (p[len] == '#') 4057 ++len; 4058 // nothing appended: match case 4059 4060 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[len])) 4061 { 4062 char_u buf[7]; 4063 4064 vim_strncpy(buf, p, len); 4065 semsg(_(e_white_both), buf); 4066 return FAIL; 4067 } 4068 4069 // get the second variable 4070 *arg = skipwhite(p + len); 4071 if (may_get_next_line(p + len, arg, cctx) == FAIL) 4072 return FAIL; 4073 4074 if (compile_expr5(arg, cctx, ppconst) == FAIL) 4075 return FAIL; 4076 4077 if (ppconst->pp_used == ppconst_used + 2) 4078 { 4079 typval_T * tv1 = &ppconst->pp_tv[ppconst->pp_used - 2]; 4080 typval_T *tv2 = &ppconst->pp_tv[ppconst->pp_used - 1]; 4081 int ret; 4082 4083 // Both sides are a constant, compute the result now. 4084 // First check for a valid combination of types, this is more 4085 // strict than typval_compare(). 4086 if (get_compare_isn(type, tv1->v_type, tv2->v_type) == ISN_DROP) 4087 ret = FAIL; 4088 else 4089 { 4090 ret = typval_compare(tv1, tv2, type, ic); 4091 tv1->v_type = VAR_BOOL; 4092 tv1->vval.v_number = tv1->vval.v_number 4093 ? VVAL_TRUE : VVAL_FALSE; 4094 clear_tv(tv2); 4095 --ppconst->pp_used; 4096 } 4097 return ret; 4098 } 4099 4100 generate_ppconst(cctx, ppconst); 4101 return generate_COMPARE(cctx, type, ic); 4102 } 4103 4104 return OK; 4105 } 4106 4107 static int compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst); 4108 4109 /* 4110 * Compile || or &&. 4111 */ 4112 static int 4113 compile_and_or( 4114 char_u **arg, 4115 cctx_T *cctx, 4116 char *op, 4117 ppconst_T *ppconst, 4118 int ppconst_used UNUSED) 4119 { 4120 char_u *p = skipwhite(*arg); 4121 int opchar = *op; 4122 4123 if (p[0] == opchar && p[1] == opchar) 4124 { 4125 garray_T *instr = &cctx->ctx_instr; 4126 garray_T end_ga; 4127 4128 /* 4129 * Repeat until there is no following "||" or "&&" 4130 */ 4131 ga_init2(&end_ga, sizeof(int), 10); 4132 while (p[0] == opchar && p[1] == opchar) 4133 { 4134 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[2])) 4135 { 4136 semsg(_(e_white_both), op); 4137 return FAIL; 4138 } 4139 4140 // TODO: use ppconst if the value is a constant 4141 generate_ppconst(cctx, ppconst); 4142 4143 if (ga_grow(&end_ga, 1) == FAIL) 4144 { 4145 ga_clear(&end_ga); 4146 return FAIL; 4147 } 4148 *(((int *)end_ga.ga_data) + end_ga.ga_len) = instr->ga_len; 4149 ++end_ga.ga_len; 4150 generate_JUMP(cctx, opchar == '|' 4151 ? JUMP_AND_KEEP_IF_TRUE : JUMP_AND_KEEP_IF_FALSE, 0); 4152 4153 // eval the next expression 4154 *arg = skipwhite(p + 2); 4155 if (may_get_next_line(p + 2, arg, cctx) == FAIL) 4156 return FAIL; 4157 4158 if ((opchar == '|' ? compile_expr3(arg, cctx, ppconst) 4159 : compile_expr4(arg, cctx, ppconst)) == FAIL) 4160 { 4161 ga_clear(&end_ga); 4162 return FAIL; 4163 } 4164 p = skipwhite(*arg); 4165 } 4166 generate_ppconst(cctx, ppconst); 4167 4168 // Fill in the end label in all jumps. 4169 while (end_ga.ga_len > 0) 4170 { 4171 isn_T *isn; 4172 4173 --end_ga.ga_len; 4174 isn = ((isn_T *)instr->ga_data) 4175 + *(((int *)end_ga.ga_data) + end_ga.ga_len); 4176 isn->isn_arg.jump.jump_where = instr->ga_len; 4177 } 4178 ga_clear(&end_ga); 4179 } 4180 4181 return OK; 4182 } 4183 4184 /* 4185 * expr4a && expr4a && expr4a logical AND 4186 * 4187 * Produces instructions: 4188 * EVAL expr4a Push result of "expr4a" 4189 * JUMP_AND_KEEP_IF_FALSE end 4190 * EVAL expr4b Push result of "expr4b" 4191 * JUMP_AND_KEEP_IF_FALSE end 4192 * EVAL expr4c Push result of "expr4c" 4193 * end: 4194 */ 4195 static int 4196 compile_expr3(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4197 { 4198 int ppconst_used = ppconst->pp_used; 4199 4200 // get the first variable 4201 if (compile_expr4(arg, cctx, ppconst) == FAIL) 4202 return FAIL; 4203 4204 // || and && work almost the same 4205 return compile_and_or(arg, cctx, "&&", ppconst, ppconst_used); 4206 } 4207 4208 /* 4209 * expr3a || expr3b || expr3c logical OR 4210 * 4211 * Produces instructions: 4212 * EVAL expr3a Push result of "expr3a" 4213 * JUMP_AND_KEEP_IF_TRUE end 4214 * EVAL expr3b Push result of "expr3b" 4215 * JUMP_AND_KEEP_IF_TRUE end 4216 * EVAL expr3c Push result of "expr3c" 4217 * end: 4218 */ 4219 static int 4220 compile_expr2(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4221 { 4222 int ppconst_used = ppconst->pp_used; 4223 4224 // eval the first expression 4225 if (compile_expr3(arg, cctx, ppconst) == FAIL) 4226 return FAIL; 4227 4228 // || and && work almost the same 4229 return compile_and_or(arg, cctx, "||", ppconst, ppconst_used); 4230 } 4231 4232 /* 4233 * Toplevel expression: expr2 ? expr1a : expr1b 4234 * 4235 * Produces instructions: 4236 * EVAL expr2 Push result of "expr" 4237 * JUMP_IF_FALSE alt jump if false 4238 * EVAL expr1a 4239 * JUMP_ALWAYS end 4240 * alt: EVAL expr1b 4241 * end: 4242 */ 4243 static int 4244 compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst) 4245 { 4246 char_u *p; 4247 int ppconst_used = ppconst->pp_used; 4248 4249 // Evaluate the first expression. 4250 if (compile_expr2(arg, cctx, ppconst) == FAIL) 4251 return FAIL; 4252 4253 p = skipwhite(*arg); 4254 if (*p == '?') 4255 { 4256 garray_T *instr = &cctx->ctx_instr; 4257 garray_T *stack = &cctx->ctx_type_stack; 4258 int alt_idx = instr->ga_len; 4259 int end_idx; 4260 isn_T *isn; 4261 type_T *type1; 4262 type_T *type2; 4263 int has_const_expr = FALSE; 4264 int const_value = FALSE; 4265 int save_skip = cctx->ctx_skip; 4266 4267 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1])) 4268 { 4269 semsg(_(e_white_both), "?"); 4270 return FAIL; 4271 } 4272 4273 if (ppconst->pp_used == ppconst_used + 1) 4274 { 4275 // the condition is a constant, we know whether the ? or the : 4276 // expression is to be evaluated. 4277 has_const_expr = TRUE; 4278 const_value = tv2bool(&ppconst->pp_tv[ppconst_used]); 4279 clear_tv(&ppconst->pp_tv[ppconst_used]); 4280 --ppconst->pp_used; 4281 cctx->ctx_skip = save_skip == TRUE || !const_value; 4282 } 4283 else 4284 { 4285 generate_ppconst(cctx, ppconst); 4286 generate_JUMP(cctx, JUMP_IF_FALSE, 0); 4287 } 4288 4289 // evaluate the second expression; any type is accepted 4290 *arg = skipwhite(p + 1); 4291 if (may_get_next_line(p + 1, arg, cctx) == FAIL) 4292 return FAIL; 4293 if (compile_expr1(arg, cctx, ppconst) == FAIL) 4294 return FAIL; 4295 4296 if (!has_const_expr) 4297 { 4298 generate_ppconst(cctx, ppconst); 4299 4300 // remember the type and drop it 4301 --stack->ga_len; 4302 type1 = ((type_T **)stack->ga_data)[stack->ga_len]; 4303 4304 end_idx = instr->ga_len; 4305 generate_JUMP(cctx, JUMP_ALWAYS, 0); 4306 4307 // jump here from JUMP_IF_FALSE 4308 isn = ((isn_T *)instr->ga_data) + alt_idx; 4309 isn->isn_arg.jump.jump_where = instr->ga_len; 4310 } 4311 4312 // Check for the ":". 4313 p = skipwhite(*arg); 4314 if (*p != ':') 4315 { 4316 emsg(_(e_missing_colon)); 4317 return FAIL; 4318 } 4319 if (!IS_WHITE_OR_NUL(**arg) || !IS_WHITE_OR_NUL(p[1])) 4320 { 4321 semsg(_(e_white_both), ":"); 4322 return FAIL; 4323 } 4324 4325 // evaluate the third expression 4326 if (has_const_expr) 4327 cctx->ctx_skip = save_skip == TRUE || const_value; 4328 *arg = skipwhite(p + 1); 4329 if (may_get_next_line(p + 1, arg, cctx) == FAIL) 4330 return FAIL; 4331 if (compile_expr1(arg, cctx, ppconst) == FAIL) 4332 return FAIL; 4333 4334 if (!has_const_expr) 4335 { 4336 generate_ppconst(cctx, ppconst); 4337 4338 // If the types differ, the result has a more generic type. 4339 type2 = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 4340 common_type(type1, type2, &type2, cctx->ctx_type_list); 4341 4342 // jump here from JUMP_ALWAYS 4343 isn = ((isn_T *)instr->ga_data) + end_idx; 4344 isn->isn_arg.jump.jump_where = instr->ga_len; 4345 } 4346 4347 cctx->ctx_skip = save_skip; 4348 } 4349 return OK; 4350 } 4351 4352 /* 4353 * Toplevel expression. 4354 */ 4355 static int 4356 compile_expr0(char_u **arg, cctx_T *cctx) 4357 { 4358 ppconst_T ppconst; 4359 4360 CLEAR_FIELD(ppconst); 4361 if (compile_expr1(arg, cctx, &ppconst) == FAIL) 4362 { 4363 clear_ppconst(&ppconst); 4364 return FAIL; 4365 } 4366 if (generate_ppconst(cctx, &ppconst) == FAIL) 4367 return FAIL; 4368 return OK; 4369 } 4370 4371 /* 4372 * compile "return [expr]" 4373 */ 4374 static char_u * 4375 compile_return(char_u *arg, int set_return_type, cctx_T *cctx) 4376 { 4377 char_u *p = arg; 4378 garray_T *stack = &cctx->ctx_type_stack; 4379 type_T *stack_type; 4380 4381 if (*p != NUL && *p != '|' && *p != '\n') 4382 { 4383 // compile return argument into instructions 4384 if (compile_expr0(&p, cctx) == FAIL) 4385 return NULL; 4386 4387 stack_type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 4388 if (set_return_type) 4389 cctx->ctx_ufunc->uf_ret_type = stack_type; 4390 else if (need_type(stack_type, cctx->ctx_ufunc->uf_ret_type, -1, cctx) 4391 == FAIL) 4392 return NULL; 4393 } 4394 else 4395 { 4396 // "set_return_type" cannot be TRUE, only used for a lambda which 4397 // always has an argument. 4398 if (cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_VOID 4399 && cctx->ctx_ufunc->uf_ret_type->tt_type != VAR_UNKNOWN) 4400 { 4401 emsg(_("E1003: Missing return value")); 4402 return NULL; 4403 } 4404 4405 // No argument, return zero. 4406 generate_PUSHNR(cctx, 0); 4407 } 4408 4409 if (generate_instr(cctx, ISN_RETURN) == NULL) 4410 return NULL; 4411 4412 // "return val | endif" is possible 4413 return skipwhite(p); 4414 } 4415 4416 /* 4417 * Get a line from the compilation context, compatible with exarg_T getline(). 4418 * Return a pointer to the line in allocated memory. 4419 * Return NULL for end-of-file or some error. 4420 */ 4421 static char_u * 4422 exarg_getline( 4423 int c UNUSED, 4424 void *cookie, 4425 int indent UNUSED, 4426 int do_concat UNUSED) 4427 { 4428 cctx_T *cctx = (cctx_T *)cookie; 4429 4430 if (cctx->ctx_lnum == cctx->ctx_ufunc->uf_lines.ga_len) 4431 { 4432 iemsg("Heredoc got to end"); 4433 return NULL; 4434 } 4435 ++cctx->ctx_lnum; 4436 return vim_strsave(((char_u **)cctx->ctx_ufunc->uf_lines.ga_data) 4437 [cctx->ctx_lnum]); 4438 } 4439 4440 /* 4441 * Compile a nested :def command. 4442 */ 4443 static char_u * 4444 compile_nested_function(exarg_T *eap, cctx_T *cctx) 4445 { 4446 char_u *name_start = eap->arg; 4447 char_u *name_end = to_name_end(eap->arg, FALSE); 4448 char_u *name = get_lambda_name(); 4449 lvar_T *lvar; 4450 ufunc_T *ufunc; 4451 4452 eap->arg = name_end; 4453 eap->getline = exarg_getline; 4454 eap->cookie = cctx; 4455 eap->skip = cctx->ctx_skip == TRUE; 4456 eap->forceit = FALSE; 4457 ufunc = def_function(eap, name, cctx, TRUE); 4458 4459 if (ufunc == NULL || ufunc->uf_dfunc_idx < 0) 4460 return NULL; 4461 4462 // Define a local variable for the function reference. 4463 lvar = reserve_local(cctx, name_start, name_end - name_start, 4464 TRUE, ufunc->uf_func_type); 4465 4466 if (generate_FUNCREF(cctx, ufunc->uf_dfunc_idx) == FAIL 4467 || generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL) == FAIL) 4468 return NULL; 4469 4470 // TODO: warning for trailing text? 4471 return (char_u *)""; 4472 } 4473 4474 /* 4475 * Return the length of an assignment operator, or zero if there isn't one. 4476 */ 4477 int 4478 assignment_len(char_u *p, int *heredoc) 4479 { 4480 if (*p == '=') 4481 { 4482 if (p[1] == '<' && p[2] == '<') 4483 { 4484 *heredoc = TRUE; 4485 return 3; 4486 } 4487 return 1; 4488 } 4489 if (vim_strchr((char_u *)"+-*/%", *p) != NULL && p[1] == '=') 4490 return 2; 4491 if (STRNCMP(p, "..=", 3) == 0) 4492 return 3; 4493 return 0; 4494 } 4495 4496 // words that cannot be used as a variable 4497 static char *reserved[] = { 4498 "true", 4499 "false", 4500 NULL 4501 }; 4502 4503 typedef enum { 4504 dest_local, 4505 dest_option, 4506 dest_env, 4507 dest_global, 4508 dest_buffer, 4509 dest_window, 4510 dest_tab, 4511 dest_vimvar, 4512 dest_script, 4513 dest_reg, 4514 } assign_dest_T; 4515 4516 /* 4517 * Generate the load instruction for "name". 4518 */ 4519 static void 4520 generate_loadvar( 4521 cctx_T *cctx, 4522 assign_dest_T dest, 4523 char_u *name, 4524 lvar_T *lvar, 4525 type_T *type) 4526 { 4527 switch (dest) 4528 { 4529 case dest_option: 4530 // TODO: check the option exists 4531 generate_LOAD(cctx, ISN_LOADOPT, 0, name, type); 4532 break; 4533 case dest_global: 4534 generate_LOAD(cctx, ISN_LOADG, 0, name + 2, type); 4535 break; 4536 case dest_buffer: 4537 generate_LOAD(cctx, ISN_LOADB, 0, name + 2, type); 4538 break; 4539 case dest_window: 4540 generate_LOAD(cctx, ISN_LOADW, 0, name + 2, type); 4541 break; 4542 case dest_tab: 4543 generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type); 4544 break; 4545 case dest_script: 4546 compile_load_scriptvar(cctx, 4547 name + (name[1] == ':' ? 2 : 0), NULL, NULL, TRUE); 4548 break; 4549 case dest_env: 4550 // Include $ in the name here 4551 generate_LOAD(cctx, ISN_LOADENV, 0, name, type); 4552 break; 4553 case dest_reg: 4554 generate_LOAD(cctx, ISN_LOADREG, name[1], NULL, &t_string); 4555 break; 4556 case dest_vimvar: 4557 generate_LOADV(cctx, name + 2, TRUE); 4558 break; 4559 case dest_local: 4560 if (lvar->lv_from_outer) 4561 generate_LOAD(cctx, ISN_LOADOUTER, lvar->lv_idx, 4562 NULL, type); 4563 else 4564 generate_LOAD(cctx, ISN_LOAD, lvar->lv_idx, NULL, type); 4565 break; 4566 } 4567 } 4568 4569 /* 4570 * compile "let var [= expr]", "const var = expr" and "var = expr" 4571 * "arg" points to "var". 4572 */ 4573 static char_u * 4574 compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx) 4575 { 4576 char_u *var_end; 4577 char_u *p; 4578 char_u *end = arg; 4579 char_u *ret = NULL; 4580 int var_count = 0; 4581 int semicolon = 0; 4582 size_t varlen; 4583 garray_T *instr = &cctx->ctx_instr; 4584 garray_T *stack = &cctx->ctx_type_stack; 4585 int new_local = FALSE; 4586 char_u *op; 4587 int opt_type; 4588 assign_dest_T dest = dest_local; 4589 int opt_flags = 0; 4590 int vimvaridx = -1; 4591 int oplen = 0; 4592 int heredoc = FALSE; 4593 type_T *type = &t_any; 4594 type_T *member_type = &t_any; 4595 lvar_T *lvar = NULL; 4596 lvar_T arg_lvar; 4597 char_u *name; 4598 char_u *sp; 4599 int has_type = FALSE; 4600 int has_index = FALSE; 4601 int is_decl = cmdidx == CMD_let || cmdidx == CMD_const; 4602 int instr_count = -1; 4603 4604 var_end = skip_var_list(arg, FALSE, &var_count, &semicolon); 4605 if (var_end == NULL) 4606 return NULL; 4607 if (var_count > 0) 4608 { 4609 // TODO: let [var, var] = list 4610 emsg("Cannot handle a list yet"); 4611 return NULL; 4612 } 4613 4614 p = (*arg == '&' || *arg == '$' || *arg == '@') ? arg + 1 : arg; 4615 p = to_name_end(p, TRUE); 4616 4617 // "a: type" is declaring variable "a" with a type, not "a:". 4618 if (is_decl && var_end == arg + 2 && var_end[-1] == ':') 4619 --var_end; 4620 if (is_decl && p == arg + 2 && p[-1] == ':') 4621 --p; 4622 4623 varlen = p - arg; 4624 name = vim_strnsave(arg, (int)varlen); 4625 if (name == NULL) 4626 return NULL; 4627 4628 if (cctx->ctx_skip != TRUE) 4629 { 4630 if (*arg == '&') 4631 { 4632 int cc; 4633 long numval; 4634 4635 dest = dest_option; 4636 if (cmdidx == CMD_const) 4637 { 4638 emsg(_(e_const_option)); 4639 goto theend; 4640 } 4641 if (is_decl) 4642 { 4643 semsg(_("E1052: Cannot declare an option: %s"), arg); 4644 goto theend; 4645 } 4646 p = arg; 4647 p = find_option_end(&p, &opt_flags); 4648 if (p == NULL) 4649 { 4650 // cannot happen? 4651 emsg(_(e_letunexp)); 4652 goto theend; 4653 } 4654 cc = *p; 4655 *p = NUL; 4656 opt_type = get_option_value(arg + 1, &numval, NULL, opt_flags); 4657 *p = cc; 4658 if (opt_type == -3) 4659 { 4660 semsg(_(e_unknown_option), arg); 4661 goto theend; 4662 } 4663 if (opt_type == -2 || opt_type == 0) 4664 type = &t_string; 4665 else 4666 type = &t_number; // both number and boolean option 4667 } 4668 else if (*arg == '$') 4669 { 4670 dest = dest_env; 4671 type = &t_string; 4672 if (is_decl) 4673 { 4674 semsg(_("E1065: Cannot declare an environment variable: %s"), 4675 name); 4676 goto theend; 4677 } 4678 } 4679 else if (*arg == '@') 4680 { 4681 if (!valid_yank_reg(arg[1], TRUE)) 4682 { 4683 emsg_invreg(arg[1]); 4684 goto theend; 4685 } 4686 dest = dest_reg; 4687 type = &t_string; 4688 if (is_decl) 4689 { 4690 semsg(_("E1066: Cannot declare a register: %s"), name); 4691 goto theend; 4692 } 4693 } 4694 else if (STRNCMP(arg, "g:", 2) == 0) 4695 { 4696 dest = dest_global; 4697 if (is_decl) 4698 { 4699 semsg(_("E1016: Cannot declare a global variable: %s"), name); 4700 goto theend; 4701 } 4702 } 4703 else if (STRNCMP(arg, "b:", 2) == 0) 4704 { 4705 dest = dest_buffer; 4706 if (is_decl) 4707 { 4708 semsg(_("E1078: Cannot declare a buffer variable: %s"), name); 4709 goto theend; 4710 } 4711 } 4712 else if (STRNCMP(arg, "w:", 2) == 0) 4713 { 4714 dest = dest_window; 4715 if (is_decl) 4716 { 4717 semsg(_("E1079: Cannot declare a window variable: %s"), name); 4718 goto theend; 4719 } 4720 } 4721 else if (STRNCMP(arg, "t:", 2) == 0) 4722 { 4723 dest = dest_tab; 4724 if (is_decl) 4725 { 4726 semsg(_("E1080: Cannot declare a tab variable: %s"), name); 4727 goto theend; 4728 } 4729 } 4730 else if (STRNCMP(arg, "v:", 2) == 0) 4731 { 4732 typval_T *vtv; 4733 int di_flags; 4734 4735 vimvaridx = find_vim_var(name + 2, &di_flags); 4736 if (vimvaridx < 0) 4737 { 4738 semsg(_(e_var_notfound), arg); 4739 goto theend; 4740 } 4741 // We use the current value of "sandbox" here, is that OK? 4742 if (var_check_ro(di_flags, name, FALSE)) 4743 goto theend; 4744 dest = dest_vimvar; 4745 vtv = get_vim_var_tv(vimvaridx); 4746 type = typval2type(vtv); 4747 if (is_decl) 4748 { 4749 semsg(_("E1064: Cannot declare a v: variable: %s"), name); 4750 goto theend; 4751 } 4752 } 4753 else 4754 { 4755 int idx; 4756 4757 for (idx = 0; reserved[idx] != NULL; ++idx) 4758 if (STRCMP(reserved[idx], name) == 0) 4759 { 4760 semsg(_("E1034: Cannot use reserved name %s"), name); 4761 goto theend; 4762 } 4763 4764 lvar = lookup_local(arg, varlen, cctx); 4765 if (lvar == NULL) 4766 { 4767 CLEAR_FIELD(arg_lvar); 4768 if (lookup_arg(arg, varlen, 4769 &arg_lvar.lv_idx, &arg_lvar.lv_type, 4770 &arg_lvar.lv_from_outer, cctx) == OK) 4771 { 4772 if (is_decl) 4773 { 4774 semsg(_(e_used_as_arg), name); 4775 goto theend; 4776 } 4777 lvar = &arg_lvar; 4778 } 4779 } 4780 if (lvar != NULL) 4781 { 4782 if (is_decl) 4783 { 4784 semsg(_("E1017: Variable already declared: %s"), name); 4785 goto theend; 4786 } 4787 else if (lvar->lv_const) 4788 { 4789 semsg(_("E1018: Cannot assign to a constant: %s"), name); 4790 goto theend; 4791 } 4792 } 4793 else if (STRNCMP(arg, "s:", 2) == 0 4794 || lookup_script(arg, varlen) == OK 4795 || find_imported(arg, varlen, cctx) != NULL) 4796 { 4797 dest = dest_script; 4798 if (is_decl) 4799 { 4800 semsg(_("E1054: Variable already declared in the script: %s"), 4801 name); 4802 goto theend; 4803 } 4804 } 4805 else if (name[1] == ':' && name[2] != NUL) 4806 { 4807 semsg(_("E1082: Cannot use a namespaced variable: %s"), name); 4808 goto theend; 4809 } 4810 else if (!is_decl) 4811 { 4812 semsg(_("E1089: unknown variable: %s"), name); 4813 goto theend; 4814 } 4815 } 4816 } 4817 4818 // handle "a:name" as a name, not index "name" on "a" 4819 if (varlen > 1 || arg[varlen] != ':') 4820 p = var_end; 4821 4822 if (dest != dest_option) 4823 { 4824 if (is_decl && *p == ':') 4825 { 4826 // parse optional type: "let var: type = expr" 4827 if (!VIM_ISWHITE(p[1])) 4828 { 4829 semsg(_(e_white_after), ":"); 4830 goto theend; 4831 } 4832 p = skipwhite(p + 1); 4833 type = parse_type(&p, cctx->ctx_type_list); 4834 has_type = TRUE; 4835 } 4836 else if (lvar != NULL) 4837 type = lvar->lv_type; 4838 } 4839 4840 sp = p; 4841 p = skipwhite(p); 4842 op = p; 4843 oplen = assignment_len(p, &heredoc); 4844 if (oplen > 0 && (!VIM_ISWHITE(*sp) || !VIM_ISWHITE(op[oplen]))) 4845 { 4846 char_u buf[4]; 4847 4848 vim_strncpy(buf, op, oplen); 4849 semsg(_(e_white_both), buf); 4850 } 4851 4852 if (oplen == 3 && !heredoc && dest != dest_global 4853 && type->tt_type != VAR_STRING && type->tt_type != VAR_ANY) 4854 { 4855 emsg(_("E1019: Can only concatenate to string")); 4856 goto theend; 4857 } 4858 4859 if (lvar == NULL && dest == dest_local && cctx->ctx_skip != TRUE) 4860 { 4861 if (oplen > 1 && !heredoc) 4862 { 4863 // +=, /=, etc. require an existing variable 4864 semsg(_("E1020: cannot use an operator on a new variable: %s"), 4865 name); 4866 goto theend; 4867 } 4868 4869 // new local variable 4870 if (type->tt_type == VAR_FUNC && var_check_func_name(name, TRUE)) 4871 goto theend; 4872 lvar = reserve_local(cctx, arg, varlen, cmdidx == CMD_const, type); 4873 if (lvar == NULL) 4874 goto theend; 4875 new_local = TRUE; 4876 } 4877 4878 member_type = type; 4879 if (var_end > arg + varlen) 4880 { 4881 // Something follows after the variable: "var[idx]". 4882 if (is_decl) 4883 { 4884 emsg(_("E1087: cannot use an index when declaring a variable")); 4885 goto theend; 4886 } 4887 4888 if (arg[varlen] == '[') 4889 { 4890 has_index = TRUE; 4891 if (type->tt_member == NULL) 4892 { 4893 semsg(_("E1088: cannot use an index on %s"), name); 4894 goto theend; 4895 } 4896 member_type = type->tt_member; 4897 } 4898 else 4899 { 4900 semsg("Not supported yet: %s", arg); 4901 goto theend; 4902 } 4903 } 4904 else if (lvar == &arg_lvar) 4905 { 4906 semsg(_("E1090: Cannot assign to argument %s"), name); 4907 goto theend; 4908 } 4909 4910 if (heredoc) 4911 { 4912 list_T *l; 4913 listitem_T *li; 4914 4915 // [let] varname =<< [trim] {end} 4916 eap->getline = exarg_getline; 4917 eap->cookie = cctx; 4918 l = heredoc_get(eap, op + 3, FALSE); 4919 4920 // Push each line and the create the list. 4921 FOR_ALL_LIST_ITEMS(l, li) 4922 { 4923 generate_PUSHS(cctx, li->li_tv.vval.v_string); 4924 li->li_tv.vval.v_string = NULL; 4925 } 4926 generate_NEWLIST(cctx, l->lv_len); 4927 type = &t_list_string; 4928 member_type = &t_list_string; 4929 list_free(l); 4930 p += STRLEN(p); 4931 } 4932 else if (oplen > 0) 4933 { 4934 int r; 4935 4936 // for "+=", "*=", "..=" etc. first load the current value 4937 if (*op != '=') 4938 { 4939 generate_loadvar(cctx, dest, name, lvar, type); 4940 4941 if (has_index) 4942 { 4943 // TODO: get member from list or dict 4944 emsg("Index with operation not supported yet"); 4945 goto theend; 4946 } 4947 } 4948 4949 // Compile the expression. Temporarily hide the new local variable 4950 // here, it is not available to this expression. 4951 if (new_local) 4952 --cctx->ctx_locals.ga_len; 4953 instr_count = instr->ga_len; 4954 p = skipwhite(p + oplen); 4955 r = compile_expr0(&p, cctx); 4956 if (new_local) 4957 ++cctx->ctx_locals.ga_len; 4958 if (r == FAIL) 4959 goto theend; 4960 4961 if (cctx->ctx_skip != TRUE) 4962 { 4963 type_T *stacktype; 4964 4965 stacktype = stack->ga_len == 0 ? &t_void 4966 : ((type_T **)stack->ga_data)[stack->ga_len - 1]; 4967 if (lvar != NULL && (is_decl || !has_type)) 4968 { 4969 if (new_local && !has_type) 4970 { 4971 if (stacktype->tt_type == VAR_VOID) 4972 { 4973 emsg(_("E1031: Cannot use void value")); 4974 goto theend; 4975 } 4976 else 4977 { 4978 // An empty list or dict has a &t_void member, for a 4979 // variable that implies &t_any. 4980 if (stacktype == &t_list_empty) 4981 lvar->lv_type = &t_list_any; 4982 else if (stacktype == &t_dict_empty) 4983 lvar->lv_type = &t_dict_any; 4984 else 4985 lvar->lv_type = stacktype; 4986 } 4987 } 4988 else 4989 { 4990 type_T *use_type = lvar->lv_type; 4991 4992 if (has_index) 4993 { 4994 use_type = use_type->tt_member; 4995 if (use_type == NULL) 4996 use_type = &t_void; 4997 } 4998 if (need_type(stacktype, use_type, -1, cctx) == FAIL) 4999 goto theend; 5000 } 5001 } 5002 else if (*p != '=' && need_type(stacktype, member_type, -1, 5003 cctx) == FAIL) 5004 goto theend; 5005 } 5006 } 5007 else if (cmdidx == CMD_const) 5008 { 5009 emsg(_("E1021: const requires a value")); 5010 goto theend; 5011 } 5012 else if (!has_type || dest == dest_option) 5013 { 5014 emsg(_("E1022: type or initialization required")); 5015 goto theend; 5016 } 5017 else 5018 { 5019 // variables are always initialized 5020 if (ga_grow(instr, 1) == FAIL) 5021 goto theend; 5022 switch (member_type->tt_type) 5023 { 5024 case VAR_BOOL: 5025 generate_PUSHBOOL(cctx, VVAL_FALSE); 5026 break; 5027 case VAR_FLOAT: 5028 #ifdef FEAT_FLOAT 5029 generate_PUSHF(cctx, 0.0); 5030 #endif 5031 break; 5032 case VAR_STRING: 5033 generate_PUSHS(cctx, NULL); 5034 break; 5035 case VAR_BLOB: 5036 generate_PUSHBLOB(cctx, NULL); 5037 break; 5038 case VAR_FUNC: 5039 generate_PUSHFUNC(cctx, NULL, &t_func_void); 5040 break; 5041 case VAR_LIST: 5042 generate_NEWLIST(cctx, 0); 5043 break; 5044 case VAR_DICT: 5045 generate_NEWDICT(cctx, 0); 5046 break; 5047 case VAR_JOB: 5048 generate_PUSHJOB(cctx, NULL); 5049 break; 5050 case VAR_CHANNEL: 5051 generate_PUSHCHANNEL(cctx, NULL); 5052 break; 5053 case VAR_NUMBER: 5054 case VAR_UNKNOWN: 5055 case VAR_ANY: 5056 case VAR_PARTIAL: 5057 case VAR_VOID: 5058 case VAR_SPECIAL: // cannot happen 5059 generate_PUSHNR(cctx, 0); 5060 break; 5061 } 5062 } 5063 end = p; 5064 5065 if (oplen > 0 && *op != '=') 5066 { 5067 type_T *expected = &t_number; 5068 type_T *stacktype; 5069 5070 // TODO: if type is known use float or any operation 5071 5072 if (*op == '.') 5073 expected = &t_string; 5074 stacktype = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 5075 if (need_type(stacktype, expected, -1, cctx) == FAIL) 5076 goto theend; 5077 5078 if (*op == '.') 5079 generate_instr_drop(cctx, ISN_CONCAT, 1); 5080 else 5081 { 5082 isn_T *isn = generate_instr_drop(cctx, ISN_OPNR, 1); 5083 5084 if (isn == NULL) 5085 goto theend; 5086 switch (*op) 5087 { 5088 case '+': isn->isn_arg.op.op_type = EXPR_ADD; break; 5089 case '-': isn->isn_arg.op.op_type = EXPR_SUB; break; 5090 case '*': isn->isn_arg.op.op_type = EXPR_MULT; break; 5091 case '/': isn->isn_arg.op.op_type = EXPR_DIV; break; 5092 case '%': isn->isn_arg.op.op_type = EXPR_REM; break; 5093 } 5094 } 5095 } 5096 5097 if (has_index) 5098 { 5099 int r; 5100 5101 // Compile the "idx" in "var[idx]". 5102 if (new_local) 5103 --cctx->ctx_locals.ga_len; 5104 p = skipwhite(arg + varlen + 1); 5105 r = compile_expr0(&p, cctx); 5106 if (new_local) 5107 ++cctx->ctx_locals.ga_len; 5108 if (r == FAIL) 5109 goto theend; 5110 if (*skipwhite(p) != ']') 5111 { 5112 emsg(_(e_missbrac)); 5113 goto theend; 5114 } 5115 if (type->tt_type == VAR_DICT 5116 && may_generate_2STRING(-1, cctx) == FAIL) 5117 goto theend; 5118 if (type->tt_type == VAR_LIST 5119 && ((type_T **)stack->ga_data)[stack->ga_len - 1]->tt_type 5120 != VAR_NUMBER) 5121 { 5122 emsg(_(e_number_exp)); 5123 goto theend; 5124 } 5125 5126 // Load the dict or list. On the stack we then have: 5127 // - value 5128 // - index 5129 // - variable 5130 generate_loadvar(cctx, dest, name, lvar, type); 5131 5132 if (type->tt_type == VAR_LIST) 5133 { 5134 if (generate_instr_drop(cctx, ISN_STORELIST, 3) == FAIL) 5135 return FAIL; 5136 } 5137 else if (type->tt_type == VAR_DICT) 5138 { 5139 if (generate_instr_drop(cctx, ISN_STOREDICT, 3) == FAIL) 5140 return FAIL; 5141 } 5142 else 5143 { 5144 emsg(_(e_listreq)); 5145 goto theend; 5146 } 5147 } 5148 else 5149 { 5150 switch (dest) 5151 { 5152 case dest_option: 5153 generate_STOREOPT(cctx, name + 1, opt_flags); 5154 break; 5155 case dest_global: 5156 // include g: with the name, easier to execute that way 5157 generate_STORE(cctx, ISN_STOREG, 0, name); 5158 break; 5159 case dest_buffer: 5160 // include b: with the name, easier to execute that way 5161 generate_STORE(cctx, ISN_STOREB, 0, name); 5162 break; 5163 case dest_window: 5164 // include w: with the name, easier to execute that way 5165 generate_STORE(cctx, ISN_STOREW, 0, name); 5166 break; 5167 case dest_tab: 5168 // include t: with the name, easier to execute that way 5169 generate_STORE(cctx, ISN_STORET, 0, name); 5170 break; 5171 case dest_env: 5172 generate_STORE(cctx, ISN_STOREENV, 0, name + 1); 5173 break; 5174 case dest_reg: 5175 generate_STORE(cctx, ISN_STOREREG, name[1], NULL); 5176 break; 5177 case dest_vimvar: 5178 generate_STORE(cctx, ISN_STOREV, vimvaridx, NULL); 5179 break; 5180 case dest_script: 5181 { 5182 char_u *rawname = name + (name[1] == ':' ? 2 : 0); 5183 imported_T *import = NULL; 5184 int sid = current_sctx.sc_sid; 5185 int idx; 5186 5187 if (name[1] != ':') 5188 { 5189 import = find_imported(name, 0, cctx); 5190 if (import != NULL) 5191 sid = import->imp_sid; 5192 } 5193 5194 idx = get_script_item_idx(sid, rawname, TRUE); 5195 // TODO: specific type 5196 if (idx < 0) 5197 { 5198 char_u *name_s = name; 5199 5200 // Include s: in the name for store_var() 5201 if (name[1] != ':') 5202 { 5203 int len = (int)STRLEN(name) + 3; 5204 5205 name_s = alloc(len); 5206 if (name_s == NULL) 5207 name_s = name; 5208 else 5209 vim_snprintf((char *)name_s, len, "s:%s", name); 5210 } 5211 generate_OLDSCRIPT(cctx, ISN_STORES, name_s, sid, 5212 &t_any); 5213 if (name_s != name) 5214 vim_free(name_s); 5215 } 5216 else 5217 generate_VIM9SCRIPT(cctx, ISN_STORESCRIPT, 5218 sid, idx, &t_any); 5219 } 5220 break; 5221 case dest_local: 5222 if (lvar != NULL) 5223 { 5224 isn_T *isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1; 5225 5226 // optimization: turn "var = 123" from ISN_PUSHNR + 5227 // ISN_STORE into ISN_STORENR 5228 if (!lvar->lv_from_outer && instr->ga_len == instr_count + 1 5229 && isn->isn_type == ISN_PUSHNR) 5230 { 5231 varnumber_T val = isn->isn_arg.number; 5232 5233 isn->isn_type = ISN_STORENR; 5234 isn->isn_arg.storenr.stnr_idx = lvar->lv_idx; 5235 isn->isn_arg.storenr.stnr_val = val; 5236 if (stack->ga_len > 0) 5237 --stack->ga_len; 5238 } 5239 else if (lvar->lv_from_outer) 5240 generate_STORE(cctx, ISN_STOREOUTER, lvar->lv_idx, 5241 NULL); 5242 else 5243 generate_STORE(cctx, ISN_STORE, lvar->lv_idx, NULL); 5244 } 5245 break; 5246 } 5247 } 5248 ret = end; 5249 5250 theend: 5251 vim_free(name); 5252 return ret; 5253 } 5254 5255 /* 5256 * Check if "name" can be "unlet". 5257 */ 5258 int 5259 check_vim9_unlet(char_u *name) 5260 { 5261 if (name[1] != ':' || vim_strchr((char_u *)"gwtb", *name) == NULL) 5262 { 5263 semsg(_("E1081: Cannot unlet %s"), name); 5264 return FAIL; 5265 } 5266 return OK; 5267 } 5268 5269 /* 5270 * Callback passed to ex_unletlock(). 5271 */ 5272 static int 5273 compile_unlet( 5274 lval_T *lvp, 5275 char_u *name_end, 5276 exarg_T *eap, 5277 int deep UNUSED, 5278 void *coookie) 5279 { 5280 cctx_T *cctx = coookie; 5281 5282 if (lvp->ll_tv == NULL) 5283 { 5284 char_u *p = lvp->ll_name; 5285 int cc = *name_end; 5286 int ret = OK; 5287 5288 // Normal name. Only supports g:, w:, t: and b: namespaces. 5289 *name_end = NUL; 5290 if (*p == '$') 5291 ret = generate_UNLET(cctx, ISN_UNLETENV, p + 1, eap->forceit); 5292 else if (check_vim9_unlet(p) == FAIL) 5293 ret = FAIL; 5294 else 5295 ret = generate_UNLET(cctx, ISN_UNLET, p, eap->forceit); 5296 5297 *name_end = cc; 5298 return ret; 5299 } 5300 5301 // TODO: unlet {list}[idx] 5302 // TODO: unlet {dict}[key] 5303 emsg("Sorry, :unlet not fully implemented yet"); 5304 return FAIL; 5305 } 5306 5307 /* 5308 * compile "unlet var", "lock var" and "unlock var" 5309 * "arg" points to "var". 5310 */ 5311 static char_u * 5312 compile_unletlock(char_u *arg, exarg_T *eap, cctx_T *cctx) 5313 { 5314 char_u *p = arg; 5315 5316 if (eap->cmdidx != CMD_unlet) 5317 { 5318 emsg("Sorry, :lock and unlock not implemented yet"); 5319 return NULL; 5320 } 5321 5322 if (*p == '!') 5323 { 5324 p = skipwhite(p + 1); 5325 eap->forceit = TRUE; 5326 } 5327 5328 ex_unletlock(eap, p, 0, GLV_NO_AUTOLOAD, compile_unlet, cctx); 5329 return eap->nextcmd == NULL ? (char_u *)"" : eap->nextcmd; 5330 } 5331 5332 /* 5333 * Compile an :import command. 5334 */ 5335 static char_u * 5336 compile_import(char_u *arg, cctx_T *cctx) 5337 { 5338 return handle_import(arg, &cctx->ctx_imports, 0, cctx); 5339 } 5340 5341 /* 5342 * generate a jump to the ":endif"/":endfor"/":endwhile"/":finally"/":endtry". 5343 */ 5344 static int 5345 compile_jump_to_end(endlabel_T **el, jumpwhen_T when, cctx_T *cctx) 5346 { 5347 garray_T *instr = &cctx->ctx_instr; 5348 endlabel_T *endlabel = ALLOC_CLEAR_ONE(endlabel_T); 5349 5350 if (endlabel == NULL) 5351 return FAIL; 5352 endlabel->el_next = *el; 5353 *el = endlabel; 5354 endlabel->el_end_label = instr->ga_len; 5355 5356 generate_JUMP(cctx, when, 0); 5357 return OK; 5358 } 5359 5360 static void 5361 compile_fill_jump_to_end(endlabel_T **el, cctx_T *cctx) 5362 { 5363 garray_T *instr = &cctx->ctx_instr; 5364 5365 while (*el != NULL) 5366 { 5367 endlabel_T *cur = (*el); 5368 isn_T *isn; 5369 5370 isn = ((isn_T *)instr->ga_data) + cur->el_end_label; 5371 isn->isn_arg.jump.jump_where = instr->ga_len; 5372 *el = cur->el_next; 5373 vim_free(cur); 5374 } 5375 } 5376 5377 static void 5378 compile_free_jump_to_end(endlabel_T **el) 5379 { 5380 while (*el != NULL) 5381 { 5382 endlabel_T *cur = (*el); 5383 5384 *el = cur->el_next; 5385 vim_free(cur); 5386 } 5387 } 5388 5389 /* 5390 * Create a new scope and set up the generic items. 5391 */ 5392 static scope_T * 5393 new_scope(cctx_T *cctx, scopetype_T type) 5394 { 5395 scope_T *scope = ALLOC_CLEAR_ONE(scope_T); 5396 5397 if (scope == NULL) 5398 return NULL; 5399 scope->se_outer = cctx->ctx_scope; 5400 cctx->ctx_scope = scope; 5401 scope->se_type = type; 5402 scope->se_local_count = cctx->ctx_locals.ga_len; 5403 return scope; 5404 } 5405 5406 /* 5407 * Free the current scope and go back to the outer scope. 5408 */ 5409 static void 5410 drop_scope(cctx_T *cctx) 5411 { 5412 scope_T *scope = cctx->ctx_scope; 5413 5414 if (scope == NULL) 5415 { 5416 iemsg("calling drop_scope() without a scope"); 5417 return; 5418 } 5419 cctx->ctx_scope = scope->se_outer; 5420 switch (scope->se_type) 5421 { 5422 case IF_SCOPE: 5423 compile_free_jump_to_end(&scope->se_u.se_if.is_end_label); break; 5424 case FOR_SCOPE: 5425 compile_free_jump_to_end(&scope->se_u.se_for.fs_end_label); break; 5426 case WHILE_SCOPE: 5427 compile_free_jump_to_end(&scope->se_u.se_while.ws_end_label); break; 5428 case TRY_SCOPE: 5429 compile_free_jump_to_end(&scope->se_u.se_try.ts_end_label); break; 5430 case NO_SCOPE: 5431 case BLOCK_SCOPE: 5432 break; 5433 } 5434 vim_free(scope); 5435 } 5436 5437 /* 5438 * compile "if expr" 5439 * 5440 * "if expr" Produces instructions: 5441 * EVAL expr Push result of "expr" 5442 * JUMP_IF_FALSE end 5443 * ... body ... 5444 * end: 5445 * 5446 * "if expr | else" Produces instructions: 5447 * EVAL expr Push result of "expr" 5448 * JUMP_IF_FALSE else 5449 * ... body ... 5450 * JUMP_ALWAYS end 5451 * else: 5452 * ... body ... 5453 * end: 5454 * 5455 * "if expr1 | elseif expr2 | else" Produces instructions: 5456 * EVAL expr Push result of "expr" 5457 * JUMP_IF_FALSE elseif 5458 * ... body ... 5459 * JUMP_ALWAYS end 5460 * elseif: 5461 * EVAL expr Push result of "expr" 5462 * JUMP_IF_FALSE else 5463 * ... body ... 5464 * JUMP_ALWAYS end 5465 * else: 5466 * ... body ... 5467 * end: 5468 */ 5469 static char_u * 5470 compile_if(char_u *arg, cctx_T *cctx) 5471 { 5472 char_u *p = arg; 5473 garray_T *instr = &cctx->ctx_instr; 5474 int instr_count = instr->ga_len; 5475 scope_T *scope; 5476 ppconst_T ppconst; 5477 5478 CLEAR_FIELD(ppconst); 5479 if (compile_expr1(&p, cctx, &ppconst) == FAIL) 5480 { 5481 clear_ppconst(&ppconst); 5482 return NULL; 5483 } 5484 if (instr->ga_len == instr_count && ppconst.pp_used == 1) 5485 { 5486 // The expression results in a constant. 5487 // TODO: how about nesting? 5488 cctx->ctx_skip = tv2bool(&ppconst.pp_tv[0]) ? FALSE : TRUE; 5489 clear_ppconst(&ppconst); 5490 } 5491 else 5492 { 5493 // Not a constant, generate instructions for the expression. 5494 cctx->ctx_skip = MAYBE; 5495 if (generate_ppconst(cctx, &ppconst) == FAIL) 5496 return NULL; 5497 } 5498 5499 scope = new_scope(cctx, IF_SCOPE); 5500 if (scope == NULL) 5501 return NULL; 5502 5503 if (cctx->ctx_skip == MAYBE) 5504 { 5505 // "where" is set when ":elseif", "else" or ":endif" is found 5506 scope->se_u.se_if.is_if_label = instr->ga_len; 5507 generate_JUMP(cctx, JUMP_IF_FALSE, 0); 5508 } 5509 else 5510 scope->se_u.se_if.is_if_label = -1; 5511 5512 return p; 5513 } 5514 5515 static char_u * 5516 compile_elseif(char_u *arg, cctx_T *cctx) 5517 { 5518 char_u *p = arg; 5519 garray_T *instr = &cctx->ctx_instr; 5520 int instr_count = instr->ga_len; 5521 isn_T *isn; 5522 scope_T *scope = cctx->ctx_scope; 5523 ppconst_T ppconst; 5524 5525 if (scope == NULL || scope->se_type != IF_SCOPE) 5526 { 5527 emsg(_(e_elseif_without_if)); 5528 return NULL; 5529 } 5530 unwind_locals(cctx, scope->se_local_count); 5531 5532 if (cctx->ctx_skip == MAYBE) 5533 { 5534 if (compile_jump_to_end(&scope->se_u.se_if.is_end_label, 5535 JUMP_ALWAYS, cctx) == FAIL) 5536 return NULL; 5537 // previous "if" or "elseif" jumps here 5538 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label; 5539 isn->isn_arg.jump.jump_where = instr->ga_len; 5540 } 5541 5542 // compile "expr"; if we know it evaluates to FALSE skip the block 5543 CLEAR_FIELD(ppconst); 5544 if (compile_expr1(&p, cctx, &ppconst) == FAIL) 5545 { 5546 clear_ppconst(&ppconst); 5547 return NULL; 5548 } 5549 if (instr->ga_len == instr_count && ppconst.pp_used == 1) 5550 { 5551 // The expression results in a constant. 5552 // TODO: how about nesting? 5553 cctx->ctx_skip = tv2bool(&ppconst.pp_tv[0]) ? FALSE : TRUE; 5554 clear_ppconst(&ppconst); 5555 scope->se_u.se_if.is_if_label = -1; 5556 } 5557 else 5558 { 5559 // Not a constant, generate instructions for the expression. 5560 cctx->ctx_skip = MAYBE; 5561 if (generate_ppconst(cctx, &ppconst) == FAIL) 5562 return NULL; 5563 5564 // "where" is set when ":elseif", "else" or ":endif" is found 5565 scope->se_u.se_if.is_if_label = instr->ga_len; 5566 generate_JUMP(cctx, JUMP_IF_FALSE, 0); 5567 } 5568 5569 return p; 5570 } 5571 5572 static char_u * 5573 compile_else(char_u *arg, cctx_T *cctx) 5574 { 5575 char_u *p = arg; 5576 garray_T *instr = &cctx->ctx_instr; 5577 isn_T *isn; 5578 scope_T *scope = cctx->ctx_scope; 5579 5580 if (scope == NULL || scope->se_type != IF_SCOPE) 5581 { 5582 emsg(_(e_else_without_if)); 5583 return NULL; 5584 } 5585 unwind_locals(cctx, scope->se_local_count); 5586 5587 // jump from previous block to the end, unless the else block is empty 5588 if (cctx->ctx_skip == MAYBE) 5589 { 5590 if (compile_jump_to_end(&scope->se_u.se_if.is_end_label, 5591 JUMP_ALWAYS, cctx) == FAIL) 5592 return NULL; 5593 } 5594 5595 if (cctx->ctx_skip == MAYBE) 5596 { 5597 if (scope->se_u.se_if.is_if_label >= 0) 5598 { 5599 // previous "if" or "elseif" jumps here 5600 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label; 5601 isn->isn_arg.jump.jump_where = instr->ga_len; 5602 scope->se_u.se_if.is_if_label = -1; 5603 } 5604 } 5605 5606 if (cctx->ctx_skip != MAYBE) 5607 cctx->ctx_skip = !cctx->ctx_skip; 5608 5609 return p; 5610 } 5611 5612 static char_u * 5613 compile_endif(char_u *arg, cctx_T *cctx) 5614 { 5615 scope_T *scope = cctx->ctx_scope; 5616 ifscope_T *ifscope; 5617 garray_T *instr = &cctx->ctx_instr; 5618 isn_T *isn; 5619 5620 if (scope == NULL || scope->se_type != IF_SCOPE) 5621 { 5622 emsg(_(e_endif_without_if)); 5623 return NULL; 5624 } 5625 ifscope = &scope->se_u.se_if; 5626 unwind_locals(cctx, scope->se_local_count); 5627 5628 if (scope->se_u.se_if.is_if_label >= 0) 5629 { 5630 // previous "if" or "elseif" jumps here 5631 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_if.is_if_label; 5632 isn->isn_arg.jump.jump_where = instr->ga_len; 5633 } 5634 // Fill in the "end" label in jumps at the end of the blocks. 5635 compile_fill_jump_to_end(&ifscope->is_end_label, cctx); 5636 cctx->ctx_skip = FALSE; 5637 5638 drop_scope(cctx); 5639 return arg; 5640 } 5641 5642 /* 5643 * compile "for var in expr" 5644 * 5645 * Produces instructions: 5646 * PUSHNR -1 5647 * STORE loop-idx Set index to -1 5648 * EVAL expr Push result of "expr" 5649 * top: FOR loop-idx, end Increment index, use list on bottom of stack 5650 * - if beyond end, jump to "end" 5651 * - otherwise get item from list and push it 5652 * STORE var Store item in "var" 5653 * ... body ... 5654 * JUMP top Jump back to repeat 5655 * end: DROP Drop the result of "expr" 5656 * 5657 */ 5658 static char_u * 5659 compile_for(char_u *arg, cctx_T *cctx) 5660 { 5661 char_u *p; 5662 size_t varlen; 5663 garray_T *instr = &cctx->ctx_instr; 5664 garray_T *stack = &cctx->ctx_type_stack; 5665 scope_T *scope; 5666 lvar_T *loop_lvar; // loop iteration variable 5667 lvar_T *var_lvar; // variable for "var" 5668 type_T *vartype; 5669 5670 // TODO: list of variables: "for [key, value] in dict" 5671 // parse "var" 5672 for (p = arg; eval_isnamec1(*p); ++p) 5673 ; 5674 varlen = p - arg; 5675 var_lvar = lookup_local(arg, varlen, cctx); 5676 if (var_lvar != NULL) 5677 { 5678 semsg(_("E1023: variable already defined: %s"), arg); 5679 return NULL; 5680 } 5681 5682 // consume "in" 5683 p = skipwhite(p); 5684 if (STRNCMP(p, "in", 2) != 0 || !VIM_ISWHITE(p[2])) 5685 { 5686 emsg(_(e_missing_in)); 5687 return NULL; 5688 } 5689 p = skipwhite(p + 2); 5690 5691 5692 scope = new_scope(cctx, FOR_SCOPE); 5693 if (scope == NULL) 5694 return NULL; 5695 5696 // Reserve a variable to store the loop iteration counter. 5697 loop_lvar = reserve_local(cctx, (char_u *)"", 0, FALSE, &t_number); 5698 if (loop_lvar == NULL) 5699 { 5700 // out of memory 5701 drop_scope(cctx); 5702 return NULL; 5703 } 5704 5705 // Reserve a variable to store "var" 5706 var_lvar = reserve_local(cctx, arg, varlen, FALSE, &t_any); 5707 if (var_lvar == NULL) 5708 { 5709 // out of memory or used as an argument 5710 drop_scope(cctx); 5711 return NULL; 5712 } 5713 5714 generate_STORENR(cctx, loop_lvar->lv_idx, -1); 5715 5716 // compile "expr", it remains on the stack until "endfor" 5717 arg = p; 5718 if (compile_expr0(&arg, cctx) == FAIL) 5719 { 5720 drop_scope(cctx); 5721 return NULL; 5722 } 5723 5724 // now we know the type of "var" 5725 vartype = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 5726 if (vartype->tt_type != VAR_LIST) 5727 { 5728 emsg(_("E1024: need a List to iterate over")); 5729 drop_scope(cctx); 5730 return NULL; 5731 } 5732 if (vartype->tt_member->tt_type != VAR_ANY) 5733 var_lvar->lv_type = vartype->tt_member; 5734 5735 // "for_end" is set when ":endfor" is found 5736 scope->se_u.se_for.fs_top_label = instr->ga_len; 5737 5738 generate_FOR(cctx, loop_lvar->lv_idx); 5739 generate_STORE(cctx, ISN_STORE, var_lvar->lv_idx, NULL); 5740 5741 return arg; 5742 } 5743 5744 /* 5745 * compile "endfor" 5746 */ 5747 static char_u * 5748 compile_endfor(char_u *arg, cctx_T *cctx) 5749 { 5750 garray_T *instr = &cctx->ctx_instr; 5751 scope_T *scope = cctx->ctx_scope; 5752 forscope_T *forscope; 5753 isn_T *isn; 5754 5755 if (scope == NULL || scope->se_type != FOR_SCOPE) 5756 { 5757 emsg(_(e_for)); 5758 return NULL; 5759 } 5760 forscope = &scope->se_u.se_for; 5761 cctx->ctx_scope = scope->se_outer; 5762 unwind_locals(cctx, scope->se_local_count); 5763 5764 // At end of ":for" scope jump back to the FOR instruction. 5765 generate_JUMP(cctx, JUMP_ALWAYS, forscope->fs_top_label); 5766 5767 // Fill in the "end" label in the FOR statement so it can jump here 5768 isn = ((isn_T *)instr->ga_data) + forscope->fs_top_label; 5769 isn->isn_arg.forloop.for_end = instr->ga_len; 5770 5771 // Fill in the "end" label any BREAK statements 5772 compile_fill_jump_to_end(&forscope->fs_end_label, cctx); 5773 5774 // Below the ":for" scope drop the "expr" list from the stack. 5775 if (generate_instr_drop(cctx, ISN_DROP, 1) == NULL) 5776 return NULL; 5777 5778 vim_free(scope); 5779 5780 return arg; 5781 } 5782 5783 /* 5784 * compile "while expr" 5785 * 5786 * Produces instructions: 5787 * top: EVAL expr Push result of "expr" 5788 * JUMP_IF_FALSE end jump if false 5789 * ... body ... 5790 * JUMP top Jump back to repeat 5791 * end: 5792 * 5793 */ 5794 static char_u * 5795 compile_while(char_u *arg, cctx_T *cctx) 5796 { 5797 char_u *p = arg; 5798 garray_T *instr = &cctx->ctx_instr; 5799 scope_T *scope; 5800 5801 scope = new_scope(cctx, WHILE_SCOPE); 5802 if (scope == NULL) 5803 return NULL; 5804 5805 scope->se_u.se_while.ws_top_label = instr->ga_len; 5806 5807 // compile "expr" 5808 if (compile_expr0(&p, cctx) == FAIL) 5809 return NULL; 5810 5811 // "while_end" is set when ":endwhile" is found 5812 if (compile_jump_to_end(&scope->se_u.se_while.ws_end_label, 5813 JUMP_IF_FALSE, cctx) == FAIL) 5814 return FAIL; 5815 5816 return p; 5817 } 5818 5819 /* 5820 * compile "endwhile" 5821 */ 5822 static char_u * 5823 compile_endwhile(char_u *arg, cctx_T *cctx) 5824 { 5825 scope_T *scope = cctx->ctx_scope; 5826 5827 if (scope == NULL || scope->se_type != WHILE_SCOPE) 5828 { 5829 emsg(_(e_while)); 5830 return NULL; 5831 } 5832 cctx->ctx_scope = scope->se_outer; 5833 unwind_locals(cctx, scope->se_local_count); 5834 5835 // At end of ":for" scope jump back to the FOR instruction. 5836 generate_JUMP(cctx, JUMP_ALWAYS, scope->se_u.se_while.ws_top_label); 5837 5838 // Fill in the "end" label in the WHILE statement so it can jump here. 5839 // And in any jumps for ":break" 5840 compile_fill_jump_to_end(&scope->se_u.se_while.ws_end_label, cctx); 5841 5842 vim_free(scope); 5843 5844 return arg; 5845 } 5846 5847 /* 5848 * compile "continue" 5849 */ 5850 static char_u * 5851 compile_continue(char_u *arg, cctx_T *cctx) 5852 { 5853 scope_T *scope = cctx->ctx_scope; 5854 5855 for (;;) 5856 { 5857 if (scope == NULL) 5858 { 5859 emsg(_(e_continue)); 5860 return NULL; 5861 } 5862 if (scope->se_type == FOR_SCOPE || scope->se_type == WHILE_SCOPE) 5863 break; 5864 scope = scope->se_outer; 5865 } 5866 5867 // Jump back to the FOR or WHILE instruction. 5868 generate_JUMP(cctx, JUMP_ALWAYS, 5869 scope->se_type == FOR_SCOPE ? scope->se_u.se_for.fs_top_label 5870 : scope->se_u.se_while.ws_top_label); 5871 return arg; 5872 } 5873 5874 /* 5875 * compile "break" 5876 */ 5877 static char_u * 5878 compile_break(char_u *arg, cctx_T *cctx) 5879 { 5880 scope_T *scope = cctx->ctx_scope; 5881 endlabel_T **el; 5882 5883 for (;;) 5884 { 5885 if (scope == NULL) 5886 { 5887 emsg(_(e_break)); 5888 return NULL; 5889 } 5890 if (scope->se_type == FOR_SCOPE || scope->se_type == WHILE_SCOPE) 5891 break; 5892 scope = scope->se_outer; 5893 } 5894 5895 // Jump to the end of the FOR or WHILE loop. 5896 if (scope->se_type == FOR_SCOPE) 5897 el = &scope->se_u.se_for.fs_end_label; 5898 else 5899 el = &scope->se_u.se_while.ws_end_label; 5900 if (compile_jump_to_end(el, JUMP_ALWAYS, cctx) == FAIL) 5901 return FAIL; 5902 5903 return arg; 5904 } 5905 5906 /* 5907 * compile "{" start of block 5908 */ 5909 static char_u * 5910 compile_block(char_u *arg, cctx_T *cctx) 5911 { 5912 if (new_scope(cctx, BLOCK_SCOPE) == NULL) 5913 return NULL; 5914 return skipwhite(arg + 1); 5915 } 5916 5917 /* 5918 * compile end of block: drop one scope 5919 */ 5920 static void 5921 compile_endblock(cctx_T *cctx) 5922 { 5923 scope_T *scope = cctx->ctx_scope; 5924 5925 cctx->ctx_scope = scope->se_outer; 5926 unwind_locals(cctx, scope->se_local_count); 5927 vim_free(scope); 5928 } 5929 5930 /* 5931 * compile "try" 5932 * Creates a new scope for the try-endtry, pointing to the first catch and 5933 * finally. 5934 * Creates another scope for the "try" block itself. 5935 * TRY instruction sets up exception handling at runtime. 5936 * 5937 * "try" 5938 * TRY -> catch1, -> finally push trystack entry 5939 * ... try block 5940 * "throw {exception}" 5941 * EVAL {exception} 5942 * THROW create exception 5943 * ... try block 5944 * " catch {expr}" 5945 * JUMP -> finally 5946 * catch1: PUSH exeception 5947 * EVAL {expr} 5948 * MATCH 5949 * JUMP nomatch -> catch2 5950 * CATCH remove exception 5951 * ... catch block 5952 * " catch" 5953 * JUMP -> finally 5954 * catch2: CATCH remove exception 5955 * ... catch block 5956 * " finally" 5957 * finally: 5958 * ... finally block 5959 * " endtry" 5960 * ENDTRY pop trystack entry, may rethrow 5961 */ 5962 static char_u * 5963 compile_try(char_u *arg, cctx_T *cctx) 5964 { 5965 garray_T *instr = &cctx->ctx_instr; 5966 scope_T *try_scope; 5967 scope_T *scope; 5968 5969 // scope that holds the jumps that go to catch/finally/endtry 5970 try_scope = new_scope(cctx, TRY_SCOPE); 5971 if (try_scope == NULL) 5972 return NULL; 5973 5974 // "catch" is set when the first ":catch" is found. 5975 // "finally" is set when ":finally" or ":endtry" is found 5976 try_scope->se_u.se_try.ts_try_label = instr->ga_len; 5977 if (generate_instr(cctx, ISN_TRY) == NULL) 5978 return NULL; 5979 5980 // scope for the try block itself 5981 scope = new_scope(cctx, BLOCK_SCOPE); 5982 if (scope == NULL) 5983 return NULL; 5984 5985 return arg; 5986 } 5987 5988 /* 5989 * compile "catch {expr}" 5990 */ 5991 static char_u * 5992 compile_catch(char_u *arg, cctx_T *cctx UNUSED) 5993 { 5994 scope_T *scope = cctx->ctx_scope; 5995 garray_T *instr = &cctx->ctx_instr; 5996 char_u *p; 5997 isn_T *isn; 5998 5999 // end block scope from :try or :catch 6000 if (scope != NULL && scope->se_type == BLOCK_SCOPE) 6001 compile_endblock(cctx); 6002 scope = cctx->ctx_scope; 6003 6004 // Error if not in a :try scope 6005 if (scope == NULL || scope->se_type != TRY_SCOPE) 6006 { 6007 emsg(_(e_catch)); 6008 return NULL; 6009 } 6010 6011 if (scope->se_u.se_try.ts_caught_all) 6012 { 6013 emsg(_("E1033: catch unreachable after catch-all")); 6014 return NULL; 6015 } 6016 6017 // Jump from end of previous block to :finally or :endtry 6018 if (compile_jump_to_end(&scope->se_u.se_try.ts_end_label, 6019 JUMP_ALWAYS, cctx) == FAIL) 6020 return NULL; 6021 6022 // End :try or :catch scope: set value in ISN_TRY instruction 6023 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label; 6024 if (isn->isn_arg.try.try_catch == 0) 6025 isn->isn_arg.try.try_catch = instr->ga_len; 6026 if (scope->se_u.se_try.ts_catch_label != 0) 6027 { 6028 // Previous catch without match jumps here 6029 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label; 6030 isn->isn_arg.jump.jump_where = instr->ga_len; 6031 } 6032 6033 p = skipwhite(arg); 6034 if (ends_excmd2(arg, p)) 6035 { 6036 scope->se_u.se_try.ts_caught_all = TRUE; 6037 scope->se_u.se_try.ts_catch_label = 0; 6038 } 6039 else 6040 { 6041 char_u *end; 6042 char_u *pat; 6043 char_u *tofree = NULL; 6044 int dropped = 0; 6045 int len; 6046 6047 // Push v:exception, push {expr} and MATCH 6048 generate_instr_type(cctx, ISN_PUSHEXC, &t_string); 6049 6050 end = skip_regexp_ex(p + 1, *p, TRUE, &tofree, &dropped); 6051 if (*end != *p) 6052 { 6053 semsg(_("E1067: Separator mismatch: %s"), p); 6054 vim_free(tofree); 6055 return FAIL; 6056 } 6057 if (tofree == NULL) 6058 len = (int)(end - (p + 1)); 6059 else 6060 len = (int)(end - tofree); 6061 pat = vim_strnsave(tofree == NULL ? p + 1 : tofree, len); 6062 vim_free(tofree); 6063 p += len + 2 + dropped; 6064 if (pat == NULL) 6065 return FAIL; 6066 if (generate_PUSHS(cctx, pat) == FAIL) 6067 return FAIL; 6068 6069 if (generate_COMPARE(cctx, EXPR_MATCH, FALSE) == FAIL) 6070 return NULL; 6071 6072 scope->se_u.se_try.ts_catch_label = instr->ga_len; 6073 if (generate_JUMP(cctx, JUMP_IF_FALSE, 0) == FAIL) 6074 return NULL; 6075 } 6076 6077 if (generate_instr(cctx, ISN_CATCH) == NULL) 6078 return NULL; 6079 6080 if (new_scope(cctx, BLOCK_SCOPE) == NULL) 6081 return NULL; 6082 return p; 6083 } 6084 6085 static char_u * 6086 compile_finally(char_u *arg, cctx_T *cctx) 6087 { 6088 scope_T *scope = cctx->ctx_scope; 6089 garray_T *instr = &cctx->ctx_instr; 6090 isn_T *isn; 6091 6092 // end block scope from :try or :catch 6093 if (scope != NULL && scope->se_type == BLOCK_SCOPE) 6094 compile_endblock(cctx); 6095 scope = cctx->ctx_scope; 6096 6097 // Error if not in a :try scope 6098 if (scope == NULL || scope->se_type != TRY_SCOPE) 6099 { 6100 emsg(_(e_finally)); 6101 return NULL; 6102 } 6103 6104 // End :catch or :finally scope: set value in ISN_TRY instruction 6105 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label; 6106 if (isn->isn_arg.try.try_finally != 0) 6107 { 6108 emsg(_(e_finally_dup)); 6109 return NULL; 6110 } 6111 6112 // Fill in the "end" label in jumps at the end of the blocks. 6113 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, cctx); 6114 6115 isn->isn_arg.try.try_finally = instr->ga_len; 6116 if (scope->se_u.se_try.ts_catch_label != 0) 6117 { 6118 // Previous catch without match jumps here 6119 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_catch_label; 6120 isn->isn_arg.jump.jump_where = instr->ga_len; 6121 } 6122 6123 // TODO: set index in ts_finally_label jumps 6124 6125 return arg; 6126 } 6127 6128 static char_u * 6129 compile_endtry(char_u *arg, cctx_T *cctx) 6130 { 6131 scope_T *scope = cctx->ctx_scope; 6132 garray_T *instr = &cctx->ctx_instr; 6133 isn_T *isn; 6134 6135 // end block scope from :catch or :finally 6136 if (scope != NULL && scope->se_type == BLOCK_SCOPE) 6137 compile_endblock(cctx); 6138 scope = cctx->ctx_scope; 6139 6140 // Error if not in a :try scope 6141 if (scope == NULL || scope->se_type != TRY_SCOPE) 6142 { 6143 if (scope == NULL) 6144 emsg(_(e_no_endtry)); 6145 else if (scope->se_type == WHILE_SCOPE) 6146 emsg(_(e_endwhile)); 6147 else if (scope->se_type == FOR_SCOPE) 6148 emsg(_(e_endfor)); 6149 else 6150 emsg(_(e_endif)); 6151 return NULL; 6152 } 6153 6154 isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label; 6155 if (isn->isn_arg.try.try_catch == 0 && isn->isn_arg.try.try_finally == 0) 6156 { 6157 emsg(_("E1032: missing :catch or :finally")); 6158 return NULL; 6159 } 6160 6161 // Fill in the "end" label in jumps at the end of the blocks, if not done 6162 // by ":finally". 6163 compile_fill_jump_to_end(&scope->se_u.se_try.ts_end_label, cctx); 6164 6165 // End :catch or :finally scope: set value in ISN_TRY instruction 6166 if (isn->isn_arg.try.try_finally == 0) 6167 isn->isn_arg.try.try_finally = instr->ga_len; 6168 compile_endblock(cctx); 6169 6170 if (generate_instr(cctx, ISN_ENDTRY) == NULL) 6171 return NULL; 6172 return arg; 6173 } 6174 6175 /* 6176 * compile "throw {expr}" 6177 */ 6178 static char_u * 6179 compile_throw(char_u *arg, cctx_T *cctx UNUSED) 6180 { 6181 char_u *p = skipwhite(arg); 6182 6183 if (compile_expr0(&p, cctx) == FAIL) 6184 return NULL; 6185 if (may_generate_2STRING(-1, cctx) == FAIL) 6186 return NULL; 6187 if (generate_instr_drop(cctx, ISN_THROW, 1) == NULL) 6188 return NULL; 6189 6190 return p; 6191 } 6192 6193 /* 6194 * compile "echo expr" 6195 * compile "echomsg expr" 6196 * compile "echoerr expr" 6197 * compile "execute expr" 6198 */ 6199 static char_u * 6200 compile_mult_expr(char_u *arg, int cmdidx, cctx_T *cctx) 6201 { 6202 char_u *p = arg; 6203 int count = 0; 6204 6205 for (;;) 6206 { 6207 if (compile_expr0(&p, cctx) == FAIL) 6208 return NULL; 6209 ++count; 6210 p = skipwhite(p); 6211 if (ends_excmd(*p)) 6212 break; 6213 } 6214 6215 if (cmdidx == CMD_echo || cmdidx == CMD_echon) 6216 generate_ECHO(cctx, cmdidx == CMD_echo, count); 6217 else if (cmdidx == CMD_execute) 6218 generate_MULT_EXPR(cctx, ISN_EXECUTE, count); 6219 else if (cmdidx == CMD_echomsg) 6220 generate_MULT_EXPR(cctx, ISN_ECHOMSG, count); 6221 else 6222 generate_MULT_EXPR(cctx, ISN_ECHOERR, count); 6223 return p; 6224 } 6225 6226 /* 6227 * A command that is not compiled, execute with legacy code. 6228 */ 6229 static char_u * 6230 compile_exec(char_u *line, exarg_T *eap, cctx_T *cctx) 6231 { 6232 char_u *p; 6233 int has_expr = FALSE; 6234 6235 if (cctx->ctx_skip == TRUE) 6236 goto theend; 6237 6238 if (eap->cmdidx >= 0 && eap->cmdidx < CMD_SIZE) 6239 has_expr = (excmd_get_argt(eap->cmdidx) & (EX_XFILE | EX_EXPAND)); 6240 if (eap->cmdidx == CMD_syntax && STRNCMP(eap->arg, "include ", 8) == 0) 6241 { 6242 // expand filename in "syntax include [@group] filename" 6243 has_expr = TRUE; 6244 eap->arg = skipwhite(eap->arg + 7); 6245 if (*eap->arg == '@') 6246 eap->arg = skiptowhite(eap->arg); 6247 } 6248 6249 if (has_expr && (p = (char_u *)strstr((char *)eap->arg, "`=")) != NULL) 6250 { 6251 int count = 0; 6252 char_u *start = skipwhite(line); 6253 6254 // :cmd xxx`=expr1`yyy`=expr2`zzz 6255 // PUSHS ":cmd xxx" 6256 // eval expr1 6257 // PUSHS "yyy" 6258 // eval expr2 6259 // PUSHS "zzz" 6260 // EXECCONCAT 5 6261 for (;;) 6262 { 6263 if (p > start) 6264 { 6265 generate_PUSHS(cctx, vim_strnsave(start, (int)(p - start))); 6266 ++count; 6267 } 6268 p += 2; 6269 if (compile_expr0(&p, cctx) == FAIL) 6270 return NULL; 6271 may_generate_2STRING(-1, cctx); 6272 ++count; 6273 p = skipwhite(p); 6274 if (*p != '`') 6275 { 6276 emsg(_("E1083: missing backtick")); 6277 return NULL; 6278 } 6279 start = p + 1; 6280 6281 p = (char_u *)strstr((char *)start, "`="); 6282 if (p == NULL) 6283 { 6284 if (*skipwhite(start) != NUL) 6285 { 6286 generate_PUSHS(cctx, vim_strsave(start)); 6287 ++count; 6288 } 6289 break; 6290 } 6291 } 6292 generate_EXECCONCAT(cctx, count); 6293 } 6294 else 6295 generate_EXEC(cctx, line); 6296 6297 theend: 6298 return (char_u *)""; 6299 } 6300 6301 /* 6302 * Add a function to the list of :def functions. 6303 * This "sets ufunc->uf_dfunc_idx" but the function isn't compiled yet. 6304 */ 6305 int 6306 add_def_function(ufunc_T *ufunc) 6307 { 6308 dfunc_T *dfunc; 6309 6310 // Add the function to "def_functions". 6311 if (ga_grow(&def_functions, 1) == FAIL) 6312 return FAIL; 6313 dfunc = ((dfunc_T *)def_functions.ga_data) + def_functions.ga_len; 6314 CLEAR_POINTER(dfunc); 6315 dfunc->df_idx = def_functions.ga_len; 6316 ufunc->uf_dfunc_idx = dfunc->df_idx; 6317 dfunc->df_ufunc = ufunc; 6318 ++def_functions.ga_len; 6319 return OK; 6320 } 6321 6322 /* 6323 * After ex_function() has collected all the function lines: parse and compile 6324 * the lines into instructions. 6325 * Adds the function to "def_functions". 6326 * When "set_return_type" is set then set ufunc->uf_ret_type to the type of the 6327 * return statement (used for lambda). 6328 * "outer_cctx" is set for a nested function. 6329 * This can be used recursively through compile_lambda(), which may reallocate 6330 * "def_functions". 6331 */ 6332 void 6333 compile_def_function(ufunc_T *ufunc, int set_return_type, cctx_T *outer_cctx) 6334 { 6335 char_u *line = NULL; 6336 char_u *p; 6337 char *errormsg = NULL; // error message 6338 int had_return = FALSE; 6339 cctx_T cctx; 6340 garray_T *instr; 6341 int called_emsg_before = called_emsg; 6342 int ret = FAIL; 6343 sctx_T save_current_sctx = current_sctx; 6344 int emsg_before = called_emsg; 6345 6346 if (ufunc->uf_dfunc_idx >= 0) 6347 { 6348 // Redefining a function that was compiled before. 6349 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 6350 + ufunc->uf_dfunc_idx; 6351 // Free old instructions. 6352 delete_def_function_contents(dfunc); 6353 } 6354 else if (add_def_function(ufunc) == FAIL) 6355 return; 6356 6357 CLEAR_FIELD(cctx); 6358 cctx.ctx_ufunc = ufunc; 6359 cctx.ctx_lnum = -1; 6360 cctx.ctx_outer = outer_cctx; 6361 ga_init2(&cctx.ctx_locals, sizeof(lvar_T), 10); 6362 ga_init2(&cctx.ctx_type_stack, sizeof(type_T *), 50); 6363 ga_init2(&cctx.ctx_imports, sizeof(imported_T), 10); 6364 cctx.ctx_type_list = &ufunc->uf_type_list; 6365 ga_init2(&cctx.ctx_instr, sizeof(isn_T), 50); 6366 instr = &cctx.ctx_instr; 6367 6368 // Most modern script version. 6369 current_sctx.sc_version = SCRIPT_VERSION_VIM9; 6370 6371 if (ufunc->uf_def_args.ga_len > 0) 6372 { 6373 int count = ufunc->uf_def_args.ga_len; 6374 int first_def_arg = ufunc->uf_args.ga_len - count; 6375 int i; 6376 char_u *arg; 6377 int off = STACK_FRAME_SIZE + (ufunc->uf_va_name != NULL ? 1 : 0); 6378 6379 // Produce instructions for the default values of optional arguments. 6380 // Store the instruction index in uf_def_arg_idx[] so that we know 6381 // where to start when the function is called, depending on the number 6382 // of arguments. 6383 ufunc->uf_def_arg_idx = ALLOC_CLEAR_MULT(int, count + 1); 6384 if (ufunc->uf_def_arg_idx == NULL) 6385 goto erret; 6386 for (i = 0; i < count; ++i) 6387 { 6388 garray_T *stack = &cctx.ctx_type_stack; 6389 type_T *val_type; 6390 int arg_idx = first_def_arg + i; 6391 6392 ufunc->uf_def_arg_idx[i] = instr->ga_len; 6393 arg = ((char_u **)(ufunc->uf_def_args.ga_data))[i]; 6394 if (compile_expr0(&arg, &cctx) == FAIL) 6395 goto erret; 6396 6397 // If no type specified use the type of the default value. 6398 // Otherwise check that the default value type matches the 6399 // specified type. 6400 val_type = ((type_T **)stack->ga_data)[stack->ga_len - 1]; 6401 if (ufunc->uf_arg_types[arg_idx] == &t_unknown) 6402 ufunc->uf_arg_types[arg_idx] = val_type; 6403 else if (check_type(ufunc->uf_arg_types[i], val_type, FALSE) 6404 == FAIL) 6405 { 6406 arg_type_mismatch(ufunc->uf_arg_types[arg_idx], val_type, 6407 arg_idx + 1); 6408 goto erret; 6409 } 6410 6411 if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL) 6412 goto erret; 6413 } 6414 ufunc->uf_def_arg_idx[count] = instr->ga_len; 6415 } 6416 6417 /* 6418 * Loop over all the lines of the function and generate instructions. 6419 */ 6420 for (;;) 6421 { 6422 exarg_T ea; 6423 int starts_with_colon = FALSE; 6424 6425 // Bail out on the first error to avoid a flood of errors and report 6426 // the right line number when inside try/catch. 6427 if (emsg_before != called_emsg) 6428 goto erret; 6429 6430 if (line != NULL && *line == '|') 6431 // the line continues after a '|' 6432 ++line; 6433 else if (line != NULL && *line != NUL 6434 && !(*line == '#' && (line == cctx.ctx_line_start 6435 || VIM_ISWHITE(line[-1])))) 6436 { 6437 semsg(_("E488: Trailing characters: %s"), line); 6438 goto erret; 6439 } 6440 else 6441 { 6442 line = next_line_from_context(&cctx); 6443 if (cctx.ctx_lnum >= ufunc->uf_lines.ga_len) 6444 // beyond the last line 6445 break; 6446 } 6447 emsg_before = called_emsg; 6448 6449 had_return = FALSE; 6450 CLEAR_FIELD(ea); 6451 ea.cmdlinep = &line; 6452 ea.cmd = skipwhite(line); 6453 6454 // Some things can be recognized by the first character. 6455 switch (*ea.cmd) 6456 { 6457 case '#': 6458 // "#" starts a comment, but "#{" does not. 6459 if (ea.cmd[1] != '{') 6460 { 6461 line = (char_u *)""; 6462 continue; 6463 } 6464 break; 6465 6466 case '}': 6467 { 6468 // "}" ends a block scope 6469 scopetype_T stype = cctx.ctx_scope == NULL 6470 ? NO_SCOPE : cctx.ctx_scope->se_type; 6471 6472 if (stype == BLOCK_SCOPE) 6473 { 6474 compile_endblock(&cctx); 6475 line = ea.cmd; 6476 } 6477 else 6478 { 6479 emsg(_("E1025: using } outside of a block scope")); 6480 goto erret; 6481 } 6482 if (line != NULL) 6483 line = skipwhite(ea.cmd + 1); 6484 continue; 6485 } 6486 6487 case '{': 6488 // "{" starts a block scope 6489 // "{'a': 1}->func() is something else 6490 if (ends_excmd(*skipwhite(ea.cmd + 1))) 6491 { 6492 line = compile_block(ea.cmd, &cctx); 6493 continue; 6494 } 6495 break; 6496 6497 case ':': 6498 starts_with_colon = TRUE; 6499 break; 6500 } 6501 6502 /* 6503 * COMMAND MODIFIERS 6504 */ 6505 if (parse_command_modifiers(&ea, &errormsg, FALSE) == FAIL) 6506 { 6507 if (errormsg != NULL) 6508 goto erret; 6509 // empty line or comment 6510 line = (char_u *)""; 6511 continue; 6512 } 6513 6514 // Skip ":call" to get to the function name. 6515 if (checkforcmd(&ea.cmd, "call", 3)) 6516 ea.cmd = skipwhite(ea.cmd); 6517 6518 if (!starts_with_colon) 6519 { 6520 char_u *pskip; 6521 6522 // Assuming the command starts with a variable or function name, 6523 // find what follows. 6524 // Skip over "var.member", "var[idx]" and the like. 6525 // Also "&opt = val", "$ENV = val" and "@r = val". 6526 pskip = (*ea.cmd == '&' || *ea.cmd == '$' || *ea.cmd == '@') 6527 ? ea.cmd + 1 : ea.cmd; 6528 p = to_name_end(pskip, TRUE); 6529 if (p > ea.cmd && *p != NUL) 6530 { 6531 char_u *var_end; 6532 int oplen; 6533 int heredoc; 6534 6535 var_end = find_name_end(pskip, NULL, NULL, 6536 FNE_CHECK_START | FNE_INCL_BR); 6537 oplen = assignment_len(skipwhite(var_end), &heredoc); 6538 if (oplen > 0) 6539 { 6540 size_t len = p - ea.cmd; 6541 6542 // Recognize an assignment if we recognize the variable 6543 // name: 6544 // "g:var = expr" 6545 // "local = expr" where "local" is a local var. 6546 // "script = expr" where "script" is a script-local var. 6547 // "import = expr" where "import" is an imported var 6548 // "&opt = expr" 6549 // "$ENV = expr" 6550 // "@r = expr" 6551 if (*ea.cmd == '&' 6552 || *ea.cmd == '$' 6553 || *ea.cmd == '@' 6554 || ((len) > 2 && ea.cmd[1] == ':') 6555 || lookup_local(ea.cmd, len, &cctx) != NULL 6556 || lookup_arg(ea.cmd, len, NULL, NULL, 6557 NULL, &cctx) == OK 6558 || lookup_script(ea.cmd, len) == OK 6559 || find_imported(ea.cmd, len, &cctx) != NULL) 6560 { 6561 line = compile_assignment(ea.cmd, &ea, CMD_SIZE, &cctx); 6562 if (line == NULL) 6563 goto erret; 6564 continue; 6565 } 6566 } 6567 } 6568 } 6569 6570 /* 6571 * COMMAND after range 6572 */ 6573 ea.cmd = skip_range(ea.cmd, NULL); 6574 p = find_ex_command(&ea, NULL, starts_with_colon ? NULL 6575 : (void *(*)(char_u *, size_t, cctx_T *))lookup_local, 6576 &cctx); 6577 6578 if (p == ea.cmd && ea.cmdidx != CMD_SIZE) 6579 { 6580 if (cctx.ctx_skip == TRUE) 6581 { 6582 line += STRLEN(line); 6583 continue; 6584 } 6585 6586 // Expression or function call. 6587 if (ea.cmdidx == CMD_eval) 6588 { 6589 p = ea.cmd; 6590 if (compile_expr0(&p, &cctx) == FAIL) 6591 goto erret; 6592 6593 // drop the return value 6594 generate_instr_drop(&cctx, ISN_DROP, 1); 6595 line = p; 6596 continue; 6597 } 6598 // CMD_let cannot happen, compile_assignment() above is used 6599 iemsg("Command from find_ex_command() not handled"); 6600 goto erret; 6601 } 6602 6603 p = skipwhite(p); 6604 6605 if (cctx.ctx_skip == TRUE 6606 && ea.cmdidx != CMD_elseif 6607 && ea.cmdidx != CMD_else 6608 && ea.cmdidx != CMD_endif) 6609 { 6610 line = (char_u *)""; 6611 continue; 6612 } 6613 6614 switch (ea.cmdidx) 6615 { 6616 case CMD_def: 6617 ea.arg = p; 6618 line = compile_nested_function(&ea, &cctx); 6619 break; 6620 6621 case CMD_function: 6622 emsg(_("E1086: Cannot use :function inside :def")); 6623 goto erret; 6624 6625 case CMD_return: 6626 line = compile_return(p, set_return_type, &cctx); 6627 had_return = TRUE; 6628 break; 6629 6630 case CMD_let: 6631 case CMD_const: 6632 line = compile_assignment(p, &ea, ea.cmdidx, &cctx); 6633 break; 6634 6635 case CMD_unlet: 6636 case CMD_unlockvar: 6637 case CMD_lockvar: 6638 line = compile_unletlock(p, &ea, &cctx); 6639 break; 6640 6641 case CMD_import: 6642 line = compile_import(p, &cctx); 6643 break; 6644 6645 case CMD_if: 6646 line = compile_if(p, &cctx); 6647 break; 6648 case CMD_elseif: 6649 line = compile_elseif(p, &cctx); 6650 break; 6651 case CMD_else: 6652 line = compile_else(p, &cctx); 6653 break; 6654 case CMD_endif: 6655 line = compile_endif(p, &cctx); 6656 break; 6657 6658 case CMD_while: 6659 line = compile_while(p, &cctx); 6660 break; 6661 case CMD_endwhile: 6662 line = compile_endwhile(p, &cctx); 6663 break; 6664 6665 case CMD_for: 6666 line = compile_for(p, &cctx); 6667 break; 6668 case CMD_endfor: 6669 line = compile_endfor(p, &cctx); 6670 break; 6671 case CMD_continue: 6672 line = compile_continue(p, &cctx); 6673 break; 6674 case CMD_break: 6675 line = compile_break(p, &cctx); 6676 break; 6677 6678 case CMD_try: 6679 line = compile_try(p, &cctx); 6680 break; 6681 case CMD_catch: 6682 line = compile_catch(p, &cctx); 6683 break; 6684 case CMD_finally: 6685 line = compile_finally(p, &cctx); 6686 break; 6687 case CMD_endtry: 6688 line = compile_endtry(p, &cctx); 6689 break; 6690 case CMD_throw: 6691 line = compile_throw(p, &cctx); 6692 break; 6693 6694 case CMD_echo: 6695 case CMD_echon: 6696 case CMD_execute: 6697 case CMD_echomsg: 6698 case CMD_echoerr: 6699 line = compile_mult_expr(p, ea.cmdidx, &cctx); 6700 break; 6701 6702 default: 6703 // TODO: other commands with an expression argument 6704 // Not recognized, execute with do_cmdline_cmd(). 6705 ea.arg = p; 6706 line = compile_exec(line, &ea, &cctx); 6707 break; 6708 } 6709 if (line == NULL) 6710 goto erret; 6711 line = skipwhite(line); 6712 6713 if (cctx.ctx_type_stack.ga_len < 0) 6714 { 6715 iemsg("Type stack underflow"); 6716 goto erret; 6717 } 6718 } 6719 6720 if (cctx.ctx_scope != NULL) 6721 { 6722 if (cctx.ctx_scope->se_type == IF_SCOPE) 6723 emsg(_(e_endif)); 6724 else if (cctx.ctx_scope->se_type == WHILE_SCOPE) 6725 emsg(_(e_endwhile)); 6726 else if (cctx.ctx_scope->se_type == FOR_SCOPE) 6727 emsg(_(e_endfor)); 6728 else 6729 emsg(_("E1026: Missing }")); 6730 goto erret; 6731 } 6732 6733 if (!had_return) 6734 { 6735 if (ufunc->uf_ret_type->tt_type != VAR_VOID) 6736 { 6737 emsg(_("E1027: Missing return statement")); 6738 goto erret; 6739 } 6740 6741 // Return zero if there is no return at the end. 6742 generate_PUSHNR(&cctx, 0); 6743 generate_instr(&cctx, ISN_RETURN); 6744 } 6745 6746 { 6747 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 6748 + ufunc->uf_dfunc_idx; 6749 dfunc->df_deleted = FALSE; 6750 dfunc->df_instr = instr->ga_data; 6751 dfunc->df_instr_count = instr->ga_len; 6752 dfunc->df_varcount = cctx.ctx_locals_count; 6753 dfunc->df_closure_count = cctx.ctx_closure_count; 6754 if (cctx.ctx_outer_used) 6755 ufunc->uf_flags |= FC_CLOSURE; 6756 } 6757 6758 { 6759 int varargs = ufunc->uf_va_name != NULL; 6760 int argcount = ufunc->uf_args.ga_len; 6761 6762 // Create a type for the function, with the return type and any 6763 // argument types. 6764 // A vararg is included in uf_args.ga_len but not in uf_arg_types. 6765 // The type is included in "tt_args". 6766 if (argcount > 0 || varargs) 6767 { 6768 ufunc->uf_func_type = alloc_func_type(ufunc->uf_ret_type, 6769 argcount, &ufunc->uf_type_list); 6770 // Add argument types to the function type. 6771 if (func_type_add_arg_types(ufunc->uf_func_type, 6772 argcount + varargs, 6773 &ufunc->uf_type_list) == FAIL) 6774 { 6775 ret = FAIL; 6776 goto erret; 6777 } 6778 ufunc->uf_func_type->tt_argcount = argcount + varargs; 6779 ufunc->uf_func_type->tt_min_argcount = 6780 argcount - ufunc->uf_def_args.ga_len; 6781 if (ufunc->uf_arg_types == NULL) 6782 { 6783 int i; 6784 6785 // lambda does not have argument types. 6786 for (i = 0; i < argcount; ++i) 6787 ufunc->uf_func_type->tt_args[i] = &t_any; 6788 } 6789 else 6790 mch_memmove(ufunc->uf_func_type->tt_args, 6791 ufunc->uf_arg_types, sizeof(type_T *) * argcount); 6792 if (varargs) 6793 { 6794 ufunc->uf_func_type->tt_args[argcount] = 6795 ufunc->uf_va_type == NULL ? &t_any : ufunc->uf_va_type; 6796 ufunc->uf_func_type->tt_flags = TTFLAG_VARARGS; 6797 } 6798 } 6799 else 6800 // No arguments, can use a predefined type. 6801 ufunc->uf_func_type = get_func_type(ufunc->uf_ret_type, 6802 argcount, &ufunc->uf_type_list); 6803 6804 } 6805 6806 ret = OK; 6807 6808 erret: 6809 if (ret == FAIL) 6810 { 6811 int idx; 6812 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 6813 + ufunc->uf_dfunc_idx; 6814 6815 for (idx = 0; idx < instr->ga_len; ++idx) 6816 delete_instr(((isn_T *)instr->ga_data) + idx); 6817 ga_clear(instr); 6818 6819 ufunc->uf_dfunc_idx = -1; 6820 if (!dfunc->df_deleted) 6821 --def_functions.ga_len; 6822 6823 while (cctx.ctx_scope != NULL) 6824 drop_scope(&cctx); 6825 6826 // Don't execute this function body. 6827 ga_clear_strings(&ufunc->uf_lines); 6828 6829 if (errormsg != NULL) 6830 emsg(errormsg); 6831 else if (called_emsg == called_emsg_before) 6832 emsg(_("E1028: compile_def_function failed")); 6833 } 6834 6835 current_sctx = save_current_sctx; 6836 free_imported(&cctx); 6837 free_locals(&cctx); 6838 ga_clear(&cctx.ctx_type_stack); 6839 } 6840 6841 /* 6842 * Delete an instruction, free what it contains. 6843 */ 6844 void 6845 delete_instr(isn_T *isn) 6846 { 6847 switch (isn->isn_type) 6848 { 6849 case ISN_EXEC: 6850 case ISN_LOADENV: 6851 case ISN_LOADG: 6852 case ISN_LOADB: 6853 case ISN_LOADW: 6854 case ISN_LOADT: 6855 case ISN_LOADOPT: 6856 case ISN_STRINGMEMBER: 6857 case ISN_PUSHEXC: 6858 case ISN_PUSHS: 6859 case ISN_STOREENV: 6860 case ISN_STOREG: 6861 case ISN_STOREB: 6862 case ISN_STOREW: 6863 case ISN_STORET: 6864 case ISN_PUSHFUNC: 6865 vim_free(isn->isn_arg.string); 6866 break; 6867 6868 case ISN_LOADS: 6869 case ISN_STORES: 6870 vim_free(isn->isn_arg.loadstore.ls_name); 6871 break; 6872 6873 case ISN_UNLET: 6874 case ISN_UNLETENV: 6875 vim_free(isn->isn_arg.unlet.ul_name); 6876 break; 6877 6878 case ISN_STOREOPT: 6879 vim_free(isn->isn_arg.storeopt.so_name); 6880 break; 6881 6882 case ISN_PUSHBLOB: // push blob isn_arg.blob 6883 blob_unref(isn->isn_arg.blob); 6884 break; 6885 6886 case ISN_PUSHJOB: 6887 #ifdef FEAT_JOB_CHANNEL 6888 job_unref(isn->isn_arg.job); 6889 #endif 6890 break; 6891 6892 case ISN_PUSHCHANNEL: 6893 #ifdef FEAT_JOB_CHANNEL 6894 channel_unref(isn->isn_arg.channel); 6895 #endif 6896 break; 6897 6898 case ISN_UCALL: 6899 vim_free(isn->isn_arg.ufunc.cuf_name); 6900 break; 6901 6902 case ISN_FUNCREF: 6903 { 6904 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 6905 + isn->isn_arg.funcref.fr_func; 6906 func_ptr_unref(dfunc->df_ufunc); 6907 } 6908 break; 6909 6910 case ISN_2BOOL: 6911 case ISN_2STRING: 6912 case ISN_ADDBLOB: 6913 case ISN_ADDLIST: 6914 case ISN_BCALL: 6915 case ISN_CATCH: 6916 case ISN_CHECKNR: 6917 case ISN_CHECKTYPE: 6918 case ISN_COMPAREANY: 6919 case ISN_COMPAREBLOB: 6920 case ISN_COMPAREBOOL: 6921 case ISN_COMPAREDICT: 6922 case ISN_COMPAREFLOAT: 6923 case ISN_COMPAREFUNC: 6924 case ISN_COMPARELIST: 6925 case ISN_COMPARENR: 6926 case ISN_COMPARESPECIAL: 6927 case ISN_COMPARESTRING: 6928 case ISN_CONCAT: 6929 case ISN_DCALL: 6930 case ISN_DROP: 6931 case ISN_ECHO: 6932 case ISN_ECHOERR: 6933 case ISN_ECHOMSG: 6934 case ISN_ENDTRY: 6935 case ISN_EXECCONCAT: 6936 case ISN_EXECUTE: 6937 case ISN_FOR: 6938 case ISN_INDEX: 6939 case ISN_MEMBER: 6940 case ISN_JUMP: 6941 case ISN_LOAD: 6942 case ISN_LOADOUTER: 6943 case ISN_LOADSCRIPT: 6944 case ISN_LOADREG: 6945 case ISN_LOADV: 6946 case ISN_NEGATENR: 6947 case ISN_NEWDICT: 6948 case ISN_NEWLIST: 6949 case ISN_OPNR: 6950 case ISN_OPFLOAT: 6951 case ISN_OPANY: 6952 case ISN_PCALL: 6953 case ISN_PCALL_END: 6954 case ISN_PUSHF: 6955 case ISN_PUSHNR: 6956 case ISN_PUSHBOOL: 6957 case ISN_PUSHSPEC: 6958 case ISN_RETURN: 6959 case ISN_STORE: 6960 case ISN_STOREOUTER: 6961 case ISN_STOREV: 6962 case ISN_STORENR: 6963 case ISN_STOREREG: 6964 case ISN_STORESCRIPT: 6965 case ISN_STOREDICT: 6966 case ISN_STORELIST: 6967 case ISN_THROW: 6968 case ISN_TRY: 6969 // nothing allocated 6970 break; 6971 } 6972 } 6973 6974 /* 6975 * Free all instructions for "dfunc". 6976 */ 6977 static void 6978 delete_def_function_contents(dfunc_T *dfunc) 6979 { 6980 int idx; 6981 6982 ga_clear(&dfunc->df_def_args_isn); 6983 6984 if (dfunc->df_instr != NULL) 6985 { 6986 for (idx = 0; idx < dfunc->df_instr_count; ++idx) 6987 delete_instr(dfunc->df_instr + idx); 6988 VIM_CLEAR(dfunc->df_instr); 6989 } 6990 6991 dfunc->df_deleted = TRUE; 6992 } 6993 6994 /* 6995 * When a user function is deleted, delete any associated def function. 6996 */ 6997 void 6998 delete_def_function(ufunc_T *ufunc) 6999 { 7000 if (ufunc->uf_dfunc_idx >= 0) 7001 { 7002 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) 7003 + ufunc->uf_dfunc_idx; 7004 7005 delete_def_function_contents(dfunc); 7006 } 7007 } 7008 7009 #if defined(EXITFREE) || defined(PROTO) 7010 /* 7011 * Free all functions defined with ":def". 7012 */ 7013 void 7014 free_def_functions(void) 7015 { 7016 int idx; 7017 7018 for (idx = 0; idx < def_functions.ga_len; ++idx) 7019 { 7020 dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data) + idx; 7021 7022 delete_def_function_contents(dfunc); 7023 } 7024 7025 ga_clear(&def_functions); 7026 } 7027 #endif 7028 7029 7030 #endif // FEAT_EVAL 7031