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