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