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 * vim9type.c: handling of types 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 /* 24 * Allocate memory for a type_T and add the pointer to type_gap, so that it can 25 * be easily freed later. 26 */ 27 type_T * 28 get_type_ptr(garray_T *type_gap) 29 { 30 type_T *type; 31 32 if (ga_grow(type_gap, 1) == FAIL) 33 return NULL; 34 type = ALLOC_CLEAR_ONE(type_T); 35 if (type != NULL) 36 { 37 ((type_T **)type_gap->ga_data)[type_gap->ga_len] = type; 38 ++type_gap->ga_len; 39 } 40 return type; 41 } 42 43 void 44 clear_type_list(garray_T *gap) 45 { 46 while (gap->ga_len > 0) 47 vim_free(((type_T **)gap->ga_data)[--gap->ga_len]); 48 ga_clear(gap); 49 } 50 51 /* 52 * Take a type that is using entries in a growarray and turn it into a type 53 * with allocated entries. 54 */ 55 type_T * 56 alloc_type(type_T *type) 57 { 58 type_T *ret; 59 60 if (type == NULL) 61 return NULL; 62 63 // A fixed type never contains allocated types, return as-is. 64 if (type->tt_flags & TTFLAG_STATIC) 65 return type; 66 67 ret = ALLOC_ONE(type_T); 68 *ret = *type; 69 70 if (ret->tt_member != NULL) 71 ret->tt_member = alloc_type(ret->tt_member); 72 if (type->tt_args != NULL) 73 { 74 int i; 75 76 ret->tt_args = ALLOC_MULT(type_T *, type->tt_argcount); 77 if (ret->tt_args != NULL) 78 for (i = 0; i < type->tt_argcount; ++i) 79 ret->tt_args[i] = alloc_type(type->tt_args[i]); 80 } 81 82 return ret; 83 } 84 85 /* 86 * Free a type that was created with alloc_type(). 87 */ 88 void 89 free_type(type_T *type) 90 { 91 int i; 92 93 if (type == NULL || (type->tt_flags & TTFLAG_STATIC)) 94 return; 95 if (type->tt_args != NULL) 96 { 97 for (i = 0; i < type->tt_argcount; ++i) 98 free_type(type->tt_args[i]); 99 vim_free(type->tt_args); 100 } 101 free_type(type->tt_member); 102 vim_free(type); 103 } 104 105 type_T * 106 get_list_type(type_T *member_type, garray_T *type_gap) 107 { 108 type_T *type; 109 110 // recognize commonly used types 111 if (member_type->tt_type == VAR_ANY) 112 return &t_list_any; 113 if (member_type->tt_type == VAR_VOID 114 || member_type->tt_type == VAR_UNKNOWN) 115 return &t_list_empty; 116 if (member_type->tt_type == VAR_BOOL) 117 return &t_list_bool; 118 if (member_type->tt_type == VAR_NUMBER) 119 return &t_list_number; 120 if (member_type->tt_type == VAR_STRING) 121 return &t_list_string; 122 123 // Not a common type, create a new entry. 124 type = get_type_ptr(type_gap); 125 if (type == NULL) 126 return &t_any; 127 type->tt_type = VAR_LIST; 128 type->tt_member = member_type; 129 type->tt_argcount = 0; 130 type->tt_args = NULL; 131 return type; 132 } 133 134 type_T * 135 get_dict_type(type_T *member_type, garray_T *type_gap) 136 { 137 type_T *type; 138 139 // recognize commonly used types 140 if (member_type->tt_type == VAR_ANY) 141 return &t_dict_any; 142 if (member_type->tt_type == VAR_VOID 143 || member_type->tt_type == VAR_UNKNOWN) 144 return &t_dict_empty; 145 if (member_type->tt_type == VAR_BOOL) 146 return &t_dict_bool; 147 if (member_type->tt_type == VAR_NUMBER) 148 return &t_dict_number; 149 if (member_type->tt_type == VAR_STRING) 150 return &t_dict_string; 151 152 // Not a common type, create a new entry. 153 type = get_type_ptr(type_gap); 154 if (type == NULL) 155 return &t_any; 156 type->tt_type = VAR_DICT; 157 type->tt_member = member_type; 158 type->tt_argcount = 0; 159 type->tt_args = NULL; 160 return type; 161 } 162 163 /* 164 * Allocate a new type for a function. 165 */ 166 type_T * 167 alloc_func_type(type_T *ret_type, int argcount, garray_T *type_gap) 168 { 169 type_T *type = get_type_ptr(type_gap); 170 171 if (type == NULL) 172 return &t_any; 173 type->tt_type = VAR_FUNC; 174 type->tt_member = ret_type; 175 type->tt_argcount = argcount; 176 type->tt_args = NULL; 177 return type; 178 } 179 180 /* 181 * Get a function type, based on the return type "ret_type". 182 * If "argcount" is -1 or 0 a predefined type can be used. 183 * If "argcount" > 0 always create a new type, so that arguments can be added. 184 */ 185 type_T * 186 get_func_type(type_T *ret_type, int argcount, garray_T *type_gap) 187 { 188 // recognize commonly used types 189 if (argcount <= 0) 190 { 191 if (ret_type == &t_unknown) 192 { 193 // (argcount == 0) is not possible 194 return &t_func_unknown; 195 } 196 if (ret_type == &t_void) 197 { 198 if (argcount == 0) 199 return &t_func_0_void; 200 else 201 return &t_func_void; 202 } 203 if (ret_type == &t_any) 204 { 205 if (argcount == 0) 206 return &t_func_0_any; 207 else 208 return &t_func_any; 209 } 210 if (ret_type == &t_number) 211 { 212 if (argcount == 0) 213 return &t_func_0_number; 214 else 215 return &t_func_number; 216 } 217 if (ret_type == &t_string) 218 { 219 if (argcount == 0) 220 return &t_func_0_string; 221 else 222 return &t_func_string; 223 } 224 } 225 226 return alloc_func_type(ret_type, argcount, type_gap); 227 } 228 229 /* 230 * For a function type, reserve space for "argcount" argument types (including 231 * vararg). 232 */ 233 int 234 func_type_add_arg_types( 235 type_T *functype, 236 int argcount, 237 garray_T *type_gap) 238 { 239 // To make it easy to free the space needed for the argument types, add the 240 // pointer to type_gap. 241 if (ga_grow(type_gap, 1) == FAIL) 242 return FAIL; 243 functype->tt_args = ALLOC_CLEAR_MULT(type_T *, argcount); 244 if (functype->tt_args == NULL) 245 return FAIL; 246 ((type_T **)type_gap->ga_data)[type_gap->ga_len] = 247 (void *)functype->tt_args; 248 ++type_gap->ga_len; 249 return OK; 250 } 251 252 /* 253 * Get a type_T for a typval_T. 254 * "type_gap" is used to temporarily create types in. 255 */ 256 static type_T * 257 typval2type_int(typval_T *tv, garray_T *type_gap) 258 { 259 type_T *type; 260 type_T *member_type = &t_any; 261 int argcount = 0; 262 263 if (tv->v_type == VAR_NUMBER) 264 return &t_number; 265 if (tv->v_type == VAR_BOOL) 266 return &t_bool; 267 if (tv->v_type == VAR_STRING) 268 return &t_string; 269 270 if (tv->v_type == VAR_LIST) 271 { 272 list_T *l = tv->vval.v_list; 273 listitem_T *li; 274 275 if (l == NULL || l->lv_first == NULL) 276 return &t_list_empty; 277 if (l->lv_first == &range_list_item) 278 return &t_list_number; 279 280 // Use the common type of all members. 281 member_type = typval2type(&l->lv_first->li_tv, type_gap); 282 for (li = l->lv_first->li_next; li != NULL; li = li->li_next) 283 common_type(typval2type(&li->li_tv, type_gap), 284 member_type, &member_type, type_gap); 285 return get_list_type(member_type, type_gap); 286 } 287 288 if (tv->v_type == VAR_DICT) 289 { 290 dict_iterator_T iter; 291 typval_T *value; 292 293 if (tv->vval.v_dict == NULL 294 || tv->vval.v_dict->dv_hashtab.ht_used == 0) 295 return &t_dict_empty; 296 297 // Use the common type of all values. 298 dict_iterate_start(tv, &iter); 299 dict_iterate_next(&iter, &value); 300 member_type = typval2type(value, type_gap); 301 while (dict_iterate_next(&iter, &value) != NULL) 302 common_type(typval2type(value, type_gap), 303 member_type, &member_type, type_gap); 304 return get_dict_type(member_type, type_gap); 305 } 306 307 if (tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL) 308 { 309 char_u *name = NULL; 310 ufunc_T *ufunc = NULL; 311 312 if (tv->v_type == VAR_PARTIAL) 313 { 314 if (tv->vval.v_partial->pt_func != NULL) 315 ufunc = tv->vval.v_partial->pt_func; 316 else 317 name = tv->vval.v_partial->pt_name; 318 } 319 else 320 name = tv->vval.v_string; 321 if (name != NULL) 322 { 323 int idx = find_internal_func(name); 324 325 if (idx >= 0) 326 { 327 // TODO: get actual arg count and types 328 argcount = -1; 329 member_type = internal_func_ret_type(idx, 0, NULL); 330 } 331 else 332 ufunc = find_func(name, FALSE, NULL); 333 } 334 if (ufunc != NULL) 335 { 336 // May need to get the argument types from default values by 337 // compiling the function. 338 if (ufunc->uf_def_status == UF_TO_BE_COMPILED 339 && compile_def_function(ufunc, TRUE, NULL) == FAIL) 340 return NULL; 341 if (ufunc->uf_func_type != NULL) 342 return ufunc->uf_func_type; 343 } 344 } 345 346 type = get_type_ptr(type_gap); 347 if (type == NULL) 348 return NULL; 349 type->tt_type = tv->v_type; 350 type->tt_argcount = argcount; 351 type->tt_member = member_type; 352 353 return type; 354 } 355 356 /* 357 * Return TRUE if "tv" is not a bool but should be converted to bool. 358 */ 359 int 360 need_convert_to_bool(type_T *type, typval_T *tv) 361 { 362 return type != NULL && type == &t_bool && tv->v_type != VAR_BOOL 363 && ((tv->v_lock & VAR_BOOL_OK) 364 || (tv->v_type == VAR_NUMBER 365 && (tv->vval.v_number == 0 || tv->vval.v_number == 1))); 366 } 367 368 /* 369 * Get a type_T for a typval_T and handle VAR_BOOL_OK. 370 * "type_list" is used to temporarily create types in. 371 */ 372 type_T * 373 typval2type(typval_T *tv, garray_T *type_gap) 374 { 375 type_T *type = typval2type_int(tv, type_gap); 376 377 if (type != NULL && type != &t_bool 378 && ((tv->v_type == VAR_NUMBER 379 && (tv->vval.v_number == 0 || tv->vval.v_number == 1)) 380 || (tv->v_lock & VAR_BOOL_OK))) 381 { 382 type_T *newtype = get_type_ptr(type_gap); 383 384 // Number 0 and 1 and expression with "&&" or "||" can also be used 385 // for bool. 386 if (newtype != NULL) 387 { 388 *newtype = *type; 389 newtype->tt_flags = TTFLAG_BOOL_OK; 390 type = newtype; 391 } 392 } 393 return type; 394 } 395 396 /* 397 * Get a type_T for a typval_T, used for v: variables. 398 * "type_list" is used to temporarily create types in. 399 */ 400 type_T * 401 typval2type_vimvar(typval_T *tv, garray_T *type_gap) 402 { 403 if (tv->v_type == VAR_LIST) // e.g. for v:oldfiles 404 return &t_list_string; 405 if (tv->v_type == VAR_DICT) // e.g. for v:completed_item 406 return &t_dict_any; 407 return typval2type(tv, type_gap); 408 } 409 410 411 /* 412 * Return FAIL if "expected" and "actual" don't match. 413 */ 414 int 415 check_typval_type(type_T *expected, typval_T *actual_tv, int argidx) 416 { 417 garray_T type_list; 418 type_T *actual_type; 419 int res = FAIL; 420 421 ga_init2(&type_list, sizeof(type_T *), 10); 422 actual_type = typval2type(actual_tv, &type_list); 423 if (actual_type != NULL) 424 res = check_type(expected, actual_type, TRUE, argidx); 425 clear_type_list(&type_list); 426 return res; 427 } 428 429 void 430 type_mismatch(type_T *expected, type_T *actual) 431 { 432 arg_type_mismatch(expected, actual, 0); 433 } 434 435 void 436 arg_type_mismatch(type_T *expected, type_T *actual, int argidx) 437 { 438 char *tofree1, *tofree2; 439 char *typename1 = type_name(expected, &tofree1); 440 char *typename2 = type_name(actual, &tofree2); 441 442 if (argidx > 0) 443 semsg(_(e_argument_nr_type_mismatch_expected_str_but_got_str), 444 argidx, typename1, typename2); 445 else 446 semsg(_(e_type_mismatch_expected_str_but_got_str), 447 typename1, typename2); 448 vim_free(tofree1); 449 vim_free(tofree2); 450 } 451 452 /* 453 * Check if the expected and actual types match. 454 * Does not allow for assigning "any" to a specific type. 455 * When "argidx" > 0 it is included in the error message. 456 */ 457 int 458 check_type(type_T *expected, type_T *actual, int give_msg, int argidx) 459 { 460 int ret = OK; 461 462 // When expected is "unknown" we accept any actual type. 463 // When expected is "any" we accept any actual type except "void". 464 if (expected->tt_type != VAR_UNKNOWN 465 && !(expected->tt_type == VAR_ANY && actual->tt_type != VAR_VOID)) 466 467 { 468 // tt_type should match, except that a "partial" can be assigned to a 469 // variable with type "func". 470 if (!(expected->tt_type == actual->tt_type 471 || (expected->tt_type == VAR_FUNC 472 && actual->tt_type == VAR_PARTIAL))) 473 { 474 if (expected->tt_type == VAR_BOOL 475 && (actual->tt_flags & TTFLAG_BOOL_OK)) 476 // Using number 0 or 1 for bool is OK. 477 return OK; 478 if (give_msg) 479 arg_type_mismatch(expected, actual, argidx); 480 return FAIL; 481 } 482 if (expected->tt_type == VAR_DICT || expected->tt_type == VAR_LIST) 483 { 484 // "unknown" is used for an empty list or dict 485 if (actual->tt_member != &t_unknown) 486 ret = check_type(expected->tt_member, actual->tt_member, 487 FALSE, 0); 488 } 489 else if (expected->tt_type == VAR_FUNC) 490 { 491 if (expected->tt_member != &t_unknown) 492 ret = check_type(expected->tt_member, actual->tt_member, 493 FALSE, 0); 494 if (ret == OK && expected->tt_argcount != -1 495 && actual->tt_argcount != -1 496 && (actual->tt_argcount < expected->tt_min_argcount 497 || actual->tt_argcount > expected->tt_argcount)) 498 ret = FAIL; 499 if (expected->tt_args != NULL && actual->tt_args != NULL) 500 { 501 int i; 502 503 for (i = 0; i < expected->tt_argcount; ++i) 504 // Allow for using "any" argument type, lambda's have them. 505 if (actual->tt_args[i] != &t_any && check_type( 506 expected->tt_args[i], actual->tt_args[i], FALSE, 0) 507 == FAIL) 508 { 509 ret = FAIL; 510 break; 511 } 512 } 513 } 514 if (ret == FAIL && give_msg) 515 arg_type_mismatch(expected, actual, argidx); 516 } 517 return ret; 518 } 519 520 /* 521 * Skip over a type definition and return a pointer to just after it. 522 * When "optional" is TRUE then a leading "?" is accepted. 523 */ 524 char_u * 525 skip_type(char_u *start, int optional) 526 { 527 char_u *p = start; 528 529 if (optional && *p == '?') 530 ++p; 531 while (ASCII_ISALNUM(*p) || *p == '_') 532 ++p; 533 534 // Skip over "<type>"; this is permissive about white space. 535 if (*skipwhite(p) == '<') 536 { 537 p = skipwhite(p); 538 p = skip_type(skipwhite(p + 1), FALSE); 539 p = skipwhite(p); 540 if (*p == '>') 541 ++p; 542 } 543 else if ((*p == '(' || (*p == ':' && VIM_ISWHITE(p[1]))) 544 && STRNCMP("func", start, 4) == 0) 545 { 546 if (*p == '(') 547 { 548 // handle func(args): type 549 ++p; 550 while (*p != ')' && *p != NUL) 551 { 552 char_u *sp = p; 553 554 if (STRNCMP(p, "...", 3) == 0) 555 p += 3; 556 p = skip_type(p, TRUE); 557 if (p == sp) 558 return p; // syntax error 559 if (*p == ',') 560 p = skipwhite(p + 1); 561 } 562 if (*p == ')') 563 { 564 if (p[1] == ':') 565 p = skip_type(skipwhite(p + 2), FALSE); 566 else 567 ++p; 568 } 569 } 570 else 571 { 572 // handle func: return_type 573 p = skip_type(skipwhite(p + 1), FALSE); 574 } 575 } 576 577 return p; 578 } 579 580 /* 581 * Parse the member type: "<type>" and return "type" with the member set. 582 * Use "type_gap" if a new type needs to be added. 583 * Returns NULL in case of failure. 584 */ 585 static type_T * 586 parse_type_member(char_u **arg, type_T *type, garray_T *type_gap) 587 { 588 type_T *member_type; 589 int prev_called_emsg = called_emsg; 590 591 if (**arg != '<') 592 { 593 if (*skipwhite(*arg) == '<') 594 semsg(_(e_no_white_space_allowed_before_str), "<"); 595 else 596 emsg(_(e_missing_type)); 597 return type; 598 } 599 *arg = skipwhite(*arg + 1); 600 601 member_type = parse_type(arg, type_gap); 602 603 *arg = skipwhite(*arg); 604 if (**arg != '>' && called_emsg == prev_called_emsg) 605 { 606 emsg(_(e_missing_gt_after_type)); 607 return type; 608 } 609 ++*arg; 610 611 if (type->tt_type == VAR_LIST) 612 return get_list_type(member_type, type_gap); 613 return get_dict_type(member_type, type_gap); 614 } 615 616 /* 617 * Parse a type at "arg" and advance over it. 618 * Return &t_any for failure. 619 */ 620 type_T * 621 parse_type(char_u **arg, garray_T *type_gap) 622 { 623 char_u *p = *arg; 624 size_t len; 625 626 // skip over the first word 627 while (ASCII_ISALNUM(*p) || *p == '_') 628 ++p; 629 len = p - *arg; 630 631 switch (**arg) 632 { 633 case 'a': 634 if (len == 3 && STRNCMP(*arg, "any", len) == 0) 635 { 636 *arg += len; 637 return &t_any; 638 } 639 break; 640 case 'b': 641 if (len == 4 && STRNCMP(*arg, "bool", len) == 0) 642 { 643 *arg += len; 644 return &t_bool; 645 } 646 if (len == 4 && STRNCMP(*arg, "blob", len) == 0) 647 { 648 *arg += len; 649 return &t_blob; 650 } 651 break; 652 case 'c': 653 if (len == 7 && STRNCMP(*arg, "channel", len) == 0) 654 { 655 *arg += len; 656 return &t_channel; 657 } 658 break; 659 case 'd': 660 if (len == 4 && STRNCMP(*arg, "dict", len) == 0) 661 { 662 *arg += len; 663 return parse_type_member(arg, &t_dict_any, type_gap); 664 } 665 break; 666 case 'f': 667 if (len == 5 && STRNCMP(*arg, "float", len) == 0) 668 { 669 #ifdef FEAT_FLOAT 670 *arg += len; 671 return &t_float; 672 #else 673 emsg(_(e_this_vim_is_not_compiled_with_float_support)); 674 return &t_any; 675 #endif 676 } 677 if (len == 4 && STRNCMP(*arg, "func", len) == 0) 678 { 679 type_T *type; 680 type_T *ret_type = &t_unknown; 681 int argcount = -1; 682 int flags = 0; 683 int first_optional = -1; 684 type_T *arg_type[MAX_FUNC_ARGS + 1]; 685 686 // func({type}, ...{type}): {type} 687 *arg += len; 688 if (**arg == '(') 689 { 690 // "func" may or may not return a value, "func()" does 691 // not return a value. 692 ret_type = &t_void; 693 694 p = ++*arg; 695 argcount = 0; 696 while (*p != NUL && *p != ')') 697 { 698 if (*p == '?') 699 { 700 if (first_optional == -1) 701 first_optional = argcount; 702 ++p; 703 } 704 else if (STRNCMP(p, "...", 3) == 0) 705 { 706 flags |= TTFLAG_VARARGS; 707 p += 3; 708 } 709 else if (first_optional != -1) 710 { 711 emsg(_(e_mandatory_argument_after_optional_argument)); 712 return &t_any; 713 } 714 715 arg_type[argcount++] = parse_type(&p, type_gap); 716 717 // Nothing comes after "...{type}". 718 if (flags & TTFLAG_VARARGS) 719 break; 720 721 if (*p != ',' && *skipwhite(p) == ',') 722 { 723 semsg(_(e_no_white_space_allowed_before_str), ","); 724 return &t_any; 725 } 726 if (*p == ',') 727 { 728 ++p; 729 if (!VIM_ISWHITE(*p)) 730 { 731 semsg(_(e_white_space_required_after_str), ","); 732 return &t_any; 733 } 734 } 735 p = skipwhite(p); 736 if (argcount == MAX_FUNC_ARGS) 737 { 738 emsg(_(e_too_many_argument_types)); 739 return &t_any; 740 } 741 } 742 743 p = skipwhite(p); 744 if (*p != ')') 745 { 746 emsg(_(e_missing_close)); 747 return &t_any; 748 } 749 *arg = p + 1; 750 } 751 if (**arg == ':') 752 { 753 // parse return type 754 ++*arg; 755 if (!VIM_ISWHITE(**arg)) 756 semsg(_(e_white_space_required_after_str), ":"); 757 *arg = skipwhite(*arg); 758 ret_type = parse_type(arg, type_gap); 759 } 760 if (flags == 0 && first_optional == -1 && argcount <= 0) 761 type = get_func_type(ret_type, argcount, type_gap); 762 else 763 { 764 type = alloc_func_type(ret_type, argcount, type_gap); 765 type->tt_flags = flags; 766 if (argcount > 0) 767 { 768 type->tt_argcount = argcount; 769 type->tt_min_argcount = first_optional == -1 770 ? argcount : first_optional; 771 if (func_type_add_arg_types(type, argcount, 772 type_gap) == FAIL) 773 return &t_any; 774 mch_memmove(type->tt_args, arg_type, 775 sizeof(type_T *) * argcount); 776 } 777 } 778 return type; 779 } 780 break; 781 case 'j': 782 if (len == 3 && STRNCMP(*arg, "job", len) == 0) 783 { 784 *arg += len; 785 return &t_job; 786 } 787 break; 788 case 'l': 789 if (len == 4 && STRNCMP(*arg, "list", len) == 0) 790 { 791 *arg += len; 792 return parse_type_member(arg, &t_list_any, type_gap); 793 } 794 break; 795 case 'n': 796 if (len == 6 && STRNCMP(*arg, "number", len) == 0) 797 { 798 *arg += len; 799 return &t_number; 800 } 801 break; 802 case 's': 803 if (len == 6 && STRNCMP(*arg, "string", len) == 0) 804 { 805 *arg += len; 806 return &t_string; 807 } 808 break; 809 case 'v': 810 if (len == 4 && STRNCMP(*arg, "void", len) == 0) 811 { 812 *arg += len; 813 return &t_void; 814 } 815 break; 816 } 817 818 semsg(_(e_type_not_recognized_str), *arg); 819 return &t_any; 820 } 821 822 /* 823 * Check if "type1" and "type2" are exactly the same. 824 */ 825 static int 826 equal_type(type_T *type1, type_T *type2) 827 { 828 int i; 829 830 if (type1->tt_type != type2->tt_type) 831 return FALSE; 832 switch (type1->tt_type) 833 { 834 case VAR_UNKNOWN: 835 case VAR_ANY: 836 case VAR_VOID: 837 case VAR_SPECIAL: 838 case VAR_BOOL: 839 case VAR_NUMBER: 840 case VAR_FLOAT: 841 case VAR_STRING: 842 case VAR_BLOB: 843 case VAR_JOB: 844 case VAR_CHANNEL: 845 break; // not composite is always OK 846 case VAR_LIST: 847 case VAR_DICT: 848 return equal_type(type1->tt_member, type2->tt_member); 849 case VAR_FUNC: 850 case VAR_PARTIAL: 851 if (!equal_type(type1->tt_member, type2->tt_member) 852 || type1->tt_argcount != type2->tt_argcount) 853 return FALSE; 854 if (type1->tt_argcount < 0 855 || type1->tt_args == NULL || type2->tt_args == NULL) 856 return TRUE; 857 for (i = 0; i < type1->tt_argcount; ++i) 858 if (!equal_type(type1->tt_args[i], type2->tt_args[i])) 859 return FALSE; 860 return TRUE; 861 } 862 return TRUE; 863 } 864 865 /* 866 * Find the common type of "type1" and "type2" and put it in "dest". 867 * "type2" and "dest" may be the same. 868 */ 869 void 870 common_type(type_T *type1, type_T *type2, type_T **dest, garray_T *type_gap) 871 { 872 if (equal_type(type1, type2)) 873 { 874 *dest = type1; 875 return; 876 } 877 878 // If either is VAR_UNKNOWN use the other type. An empty list/dict has no 879 // specific type. 880 if (type1->tt_type == VAR_UNKNOWN) 881 { 882 *dest = type2; 883 return; 884 } 885 if (type2->tt_type == VAR_UNKNOWN) 886 { 887 *dest = type1; 888 return; 889 } 890 891 if (type1->tt_type == type2->tt_type) 892 { 893 if (type1->tt_type == VAR_LIST || type2->tt_type == VAR_DICT) 894 { 895 type_T *common; 896 897 common_type(type1->tt_member, type2->tt_member, &common, type_gap); 898 if (type1->tt_type == VAR_LIST) 899 *dest = get_list_type(common, type_gap); 900 else 901 *dest = get_dict_type(common, type_gap); 902 return; 903 } 904 if (type1->tt_type == VAR_FUNC) 905 { 906 type_T *common; 907 908 common_type(type1->tt_member, type2->tt_member, &common, type_gap); 909 if (type1->tt_argcount == type2->tt_argcount 910 && type1->tt_argcount >= 0) 911 { 912 int argcount = type1->tt_argcount; 913 int i; 914 915 *dest = alloc_func_type(common, argcount, type_gap); 916 if (type1->tt_args != NULL && type2->tt_args != NULL) 917 { 918 if (func_type_add_arg_types(*dest, argcount, 919 type_gap) == OK) 920 for (i = 0; i < argcount; ++i) 921 common_type(type1->tt_args[i], type2->tt_args[i], 922 &(*dest)->tt_args[i], type_gap); 923 } 924 } 925 else 926 *dest = alloc_func_type(common, -1, type_gap); 927 return; 928 } 929 } 930 931 *dest = &t_any; 932 } 933 934 /* 935 * Get the member type of a dict or list from the items on the stack. 936 * "stack_top" points just after the last type on the type stack. 937 * For a list "skip" is 1, for a dict "skip" is 2, keys are skipped. 938 * Returns &t_void for an empty list or dict. 939 * Otherwise finds the common type of all items. 940 */ 941 type_T * 942 get_member_type_from_stack( 943 type_T **stack_top, 944 int count, 945 int skip, 946 garray_T *type_gap) 947 { 948 int i; 949 type_T *result; 950 type_T *type; 951 952 // Use "any" for an empty list or dict. 953 if (count == 0) 954 return &t_unknown; 955 956 // Use the first value type for the list member type, then find the common 957 // type from following items. 958 result = *(stack_top -(count * skip) + skip - 1); 959 for (i = 1; i < count; ++i) 960 { 961 if (result == &t_any) 962 break; // won't get more common 963 type = *(stack_top -((count - i) * skip) + skip - 1); 964 common_type(type, result, &result, type_gap); 965 } 966 967 return result; 968 } 969 970 char * 971 vartype_name(vartype_T type) 972 { 973 switch (type) 974 { 975 case VAR_UNKNOWN: break; 976 case VAR_ANY: return "any"; 977 case VAR_VOID: return "void"; 978 case VAR_SPECIAL: return "special"; 979 case VAR_BOOL: return "bool"; 980 case VAR_NUMBER: return "number"; 981 case VAR_FLOAT: return "float"; 982 case VAR_STRING: return "string"; 983 case VAR_BLOB: return "blob"; 984 case VAR_JOB: return "job"; 985 case VAR_CHANNEL: return "channel"; 986 case VAR_LIST: return "list"; 987 case VAR_DICT: return "dict"; 988 989 case VAR_FUNC: 990 case VAR_PARTIAL: return "func"; 991 } 992 return "unknown"; 993 } 994 995 /* 996 * Return the name of a type. 997 * The result may be in allocated memory, in which case "tofree" is set. 998 */ 999 char * 1000 type_name(type_T *type, char **tofree) 1001 { 1002 char *name = vartype_name(type->tt_type); 1003 1004 *tofree = NULL; 1005 if (type->tt_type == VAR_LIST || type->tt_type == VAR_DICT) 1006 { 1007 char *member_free; 1008 char *member_name = type_name(type->tt_member, &member_free); 1009 size_t len; 1010 1011 len = STRLEN(name) + STRLEN(member_name) + 3; 1012 *tofree = alloc(len); 1013 if (*tofree != NULL) 1014 { 1015 vim_snprintf(*tofree, len, "%s<%s>", name, member_name); 1016 vim_free(member_free); 1017 return *tofree; 1018 } 1019 } 1020 if (type->tt_type == VAR_FUNC) 1021 { 1022 garray_T ga; 1023 int i; 1024 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0; 1025 1026 ga_init2(&ga, 1, 100); 1027 if (ga_grow(&ga, 20) == FAIL) 1028 return "[unknown]"; 1029 STRCPY(ga.ga_data, "func("); 1030 ga.ga_len += 5; 1031 1032 for (i = 0; i < type->tt_argcount; ++i) 1033 { 1034 char *arg_free; 1035 char *arg_type; 1036 int len; 1037 1038 if (type->tt_args == NULL) 1039 arg_type = "[unknown]"; 1040 else 1041 arg_type = type_name(type->tt_args[i], &arg_free); 1042 if (i > 0) 1043 { 1044 STRCPY((char *)ga.ga_data + ga.ga_len, ", "); 1045 ga.ga_len += 2; 1046 } 1047 len = (int)STRLEN(arg_type); 1048 if (ga_grow(&ga, len + 8) == FAIL) 1049 { 1050 vim_free(arg_free); 1051 ga_clear(&ga); 1052 return "[unknown]"; 1053 } 1054 if (varargs && i == type->tt_argcount - 1) 1055 ga_concat(&ga, (char_u *)"..."); 1056 else if (i >= type->tt_min_argcount) 1057 *((char *)ga.ga_data + ga.ga_len++) = '?'; 1058 ga_concat(&ga, (char_u *)arg_type); 1059 vim_free(arg_free); 1060 } 1061 if (type->tt_argcount < 0) 1062 // any number of arguments 1063 ga_concat(&ga, (char_u *)"..."); 1064 1065 if (type->tt_member == &t_void) 1066 STRCPY((char *)ga.ga_data + ga.ga_len, ")"); 1067 else 1068 { 1069 char *ret_free; 1070 char *ret_name = type_name(type->tt_member, &ret_free); 1071 int len; 1072 1073 len = (int)STRLEN(ret_name) + 4; 1074 if (ga_grow(&ga, len) == FAIL) 1075 { 1076 vim_free(ret_free); 1077 ga_clear(&ga); 1078 return "[unknown]"; 1079 } 1080 STRCPY((char *)ga.ga_data + ga.ga_len, "): "); 1081 STRCPY((char *)ga.ga_data + ga.ga_len + 3, ret_name); 1082 vim_free(ret_free); 1083 } 1084 *tofree = ga.ga_data; 1085 return ga.ga_data; 1086 } 1087 1088 return name; 1089 } 1090 1091 #endif // FEAT_EVAL 1092