Mercurial > vim
annotate src/eval.c @ 24677:cac5f0bf7376 v8.2.2877
patch 8.2.2877: insufficient tests for popup menu rightleft
Commit: https://github.com/vim/vim/commit/1e615669c0f1f4125001b2c01c30b00d8c68035e
Author: Yegappan Lakshmanan <yegappan@yahoo.com>
Date: Sat May 22 17:12:46 2021 +0200
patch 8.2.2877: insufficient tests for popup menu rightleft
Problem: Insufficient tests for popup menu rightleft.
Solution: Add tests. (Yegappan Lakshmanan, closes https://github.com/vim/vim/issues/8235)
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Sat, 22 May 2021 17:15:05 +0200 |
| parents | 3876d9629ebd |
| children | ad7cac75b2d1 |
| rev | line source |
|---|---|
|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
10000
diff
changeset
|
1 /* vi:set ts=8 sts=4 sw=4 noet: |
| 7 | 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 * eval.c: Expression evaluation. | |
| 12 */ | |
|
8295
18fd94bd4eb8
commit https://github.com/vim/vim/commit/fefecb0fbe14c44d46f91036d76bbb6c28162da8
Christian Brabandt <cb@256bit.org>
parents:
8291
diff
changeset
|
13 #define USING_FLOAT_STUFF |
| 7 | 14 |
| 15 #include "vim.h" | |
| 16 | |
| 1624 | 17 #if defined(FEAT_EVAL) || defined(PROTO) |
| 18 | |
|
2529
2aaa88366cbb
Fix for float values on VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2513
diff
changeset
|
19 #ifdef VMS |
|
2aaa88366cbb
Fix for float values on VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2513
diff
changeset
|
20 # include <float.h> |
|
2aaa88366cbb
Fix for float values on VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2513
diff
changeset
|
21 #endif |
|
2aaa88366cbb
Fix for float values on VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2513
diff
changeset
|
22 |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
23 #define NAMESPACE_CHAR (char_u *)"abglstvw" |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
24 |
| 142 | 25 /* |
| 364 | 26 * When recursively copying lists and dicts we need to remember which ones we |
| 27 * have done to avoid endless recursiveness. This unique ID is used for that. | |
| 1891 | 28 * The last bit is used for previous_funccal, ignored when comparing. |
| 364 | 29 */ |
| 30 static int current_copyID = 0; | |
| 5973 | 31 |
| 7 | 32 /* |
| 76 | 33 * Info used by a ":for" loop. |
| 34 */ | |
| 137 | 35 typedef struct |
| 76 | 36 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
37 int fi_semicolon; // TRUE if ending in '; var]' |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
38 int fi_varcount; // nr of variables in the list |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
39 int fi_break_count; // nr of line breaks encountered |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
40 listwatch_T fi_lw; // keep an eye on the item used. |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
41 list_T *fi_list; // list being used |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
42 int fi_bi; // index of blob |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
43 blob_T *fi_blob; // blob being used |
|
24234
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
44 char_u *fi_string; // copy of string being used |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
45 int fi_byte_idx; // byte index in fi_string |
| 137 | 46 } forinfo_T; |
| 76 | 47 |
|
7720
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
48 static int tv_op(typval_T *tv1, typval_T *tv2, char_u *op); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
49 static int eval2(char_u **arg, typval_T *rettv, evalarg_T *evalarg); |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
50 static int eval3(char_u **arg, typval_T *rettv, evalarg_T *evalarg); |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
51 static int eval4(char_u **arg, typval_T *rettv, evalarg_T *evalarg); |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
52 static int eval5(char_u **arg, typval_T *rettv, evalarg_T *evalarg); |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
53 static int eval6(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int want_string); |
|
24518
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
54 static int eval7t(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int want_string); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
55 static int eval7(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int want_string); |
|
21032
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
56 static int eval7_leader(typval_T *rettv, int numeric_only, char_u *start_leader, char_u **end_leaderp); |
|
7720
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
57 |
|
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
58 static int free_unref_items(int copyID); |
|
17789
0f7ae8010787
patch 8.1.1891: functions used in one file are global
Bram Moolenaar <Bram@vim.org>
parents:
17781
diff
changeset
|
59 static char_u *make_expanded_name(char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end); |
|
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
60 |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
61 /* |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
62 * Return "n1" divided by "n2", taking care of dividing by zero. |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
63 * If "failed" is not NULL set it to TRUE when dividing by zero fails. |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
64 */ |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
65 varnumber_T |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
66 num_divide(varnumber_T n1, varnumber_T n2, int *failed) |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
67 { |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
68 varnumber_T result; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
69 |
|
23673
6d35bc0f161e
patch 8.2.2378: Vim9: no error message for dividing by zero
Bram Moolenaar <Bram@vim.org>
parents:
23628
diff
changeset
|
70 if (n2 == 0) |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
71 { |
|
23673
6d35bc0f161e
patch 8.2.2378: Vim9: no error message for dividing by zero
Bram Moolenaar <Bram@vim.org>
parents:
23628
diff
changeset
|
72 if (in_vim9script()) |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
73 { |
|
23673
6d35bc0f161e
patch 8.2.2378: Vim9: no error message for dividing by zero
Bram Moolenaar <Bram@vim.org>
parents:
23628
diff
changeset
|
74 emsg(_(e_divide_by_zero)); |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
75 if (failed != NULL) |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
76 *failed = TRUE; |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
77 } |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
78 if (n1 == 0) |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
79 result = VARNUM_MIN; // similar to NaN |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
80 else if (n1 < 0) |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
81 result = -VARNUM_MAX; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
82 else |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
83 result = VARNUM_MAX; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
84 } |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
85 else |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
86 result = n1 / n2; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
87 |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
88 return result; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
89 } |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
90 |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
91 /* |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
92 * Return "n1" modulus "n2", taking care of dividing by zero. |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
93 * If "failed" is not NULL set it to TRUE when dividing by zero fails. |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
94 */ |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
95 varnumber_T |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
96 num_modulus(varnumber_T n1, varnumber_T n2, int *failed) |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
97 { |
|
23673
6d35bc0f161e
patch 8.2.2378: Vim9: no error message for dividing by zero
Bram Moolenaar <Bram@vim.org>
parents:
23628
diff
changeset
|
98 if (n2 == 0 && in_vim9script()) |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
99 { |
|
23673
6d35bc0f161e
patch 8.2.2378: Vim9: no error message for dividing by zero
Bram Moolenaar <Bram@vim.org>
parents:
23628
diff
changeset
|
100 emsg(_(e_divide_by_zero)); |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
101 if (failed != NULL) |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
102 *failed = TRUE; |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
103 } |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
104 return (n2 == 0) ? 0 : (n1 % n2); |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
105 } |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
106 |
|
10567
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
107 #if defined(EBCDIC) || defined(PROTO) |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
108 /* |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
109 * Compare struct fst by function name. |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
110 */ |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
111 static int |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
112 compare_func_name(const void *s1, const void *s2) |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
113 { |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
114 struct fst *p1 = (struct fst *)s1; |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
115 struct fst *p2 = (struct fst *)s2; |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
116 |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
117 return STRCMP(p1->f_name, p2->f_name); |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
118 } |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
119 |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
120 /* |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
121 * Sort the function table by function name. |
|
15490
98c35d312987
patch 8.1.0753: printf format not checked for semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15482
diff
changeset
|
122 * The sorting of the table above is ASCII dependent. |
|
10567
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
123 * On machines using EBCDIC we have to sort it. |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
124 */ |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
125 static void |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
126 sortFunctions(void) |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
127 { |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
128 int funcCnt = (int)(sizeof(functions) / sizeof(struct fst)) - 1; |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
129 |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
130 qsort(functions, (size_t)funcCnt, sizeof(struct fst), compare_func_name); |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
131 } |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
132 #endif |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
133 |
| 137 | 134 /* |
| 135 * Initialize the global and v: variables. | |
| 136 */ | |
| 137 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
138 eval_init(void) |
| 137 | 139 { |
|
17885
5e2d8840da11
patch 8.1.1939: code for handling v: variables in generic eval file
Bram Moolenaar <Bram@vim.org>
parents:
17873
diff
changeset
|
140 evalvars_init(); |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
141 func_init(); |
| 137 | 142 |
|
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
143 #ifdef EBCDIC |
|
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
144 /* |
| 3178 | 145 * Sort the function table, to enable binary search. |
|
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
146 */ |
|
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
147 sortFunctions(); |
|
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
148 #endif |
| 137 | 149 } |
| 150 | |
| 357 | 151 #if defined(EXITFREE) || defined(PROTO) |
| 152 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
153 eval_clear(void) |
| 357 | 154 { |
|
17885
5e2d8840da11
patch 8.1.1939: code for handling v: variables in generic eval file
Bram Moolenaar <Bram@vim.org>
parents:
17873
diff
changeset
|
155 evalvars_clear(); |
|
19108
44c6498535c9
patch 8.2.0114: info about sourced scripts is scattered
Bram Moolenaar <Bram@vim.org>
parents:
19102
diff
changeset
|
156 free_scriptnames(); // must come after evalvars_clear(). |
| 2849 | 157 free_locales(); |
| 357 | 158 |
|
17922
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
159 // autoloaded script names |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
160 free_autoload_scriptnames(); |
| 855 | 161 |
|
16967
586d625e21b4
patch 8.1.1484: some tests are slow
Bram Moolenaar <Bram@vim.org>
parents:
16872
diff
changeset
|
162 // unreferenced lists and dicts |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
163 (void)garbage_collect(FALSE); |
|
16969
8c794a694d66
patch 8.1.1485: double free when garbage_collect() is used in autocommand
Bram Moolenaar <Bram@vim.org>
parents:
16967
diff
changeset
|
164 |
|
8c794a694d66
patch 8.1.1485: double free when garbage_collect() is used in autocommand
Bram Moolenaar <Bram@vim.org>
parents:
16967
diff
changeset
|
165 // functions not garbage collected |
|
8c794a694d66
patch 8.1.1485: double free when garbage_collect() is used in autocommand
Bram Moolenaar <Bram@vim.org>
parents:
16967
diff
changeset
|
166 free_all_functions(); |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
167 } |
|
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
168 #endif |
| 137 | 169 |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
170 void |
|
21096
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
171 fill_evalarg_from_eap(evalarg_T *evalarg, exarg_T *eap, int skip) |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
172 { |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
173 CLEAR_FIELD(*evalarg); |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
174 evalarg->eval_flags = skip ? 0 : EVAL_EVALUATE; |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
175 if (eap != NULL && getline_equal(eap->getline, eap->cookie, getsourceline)) |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
176 { |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
177 evalarg->eval_getline = eap->getline; |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
178 evalarg->eval_cookie = eap->cookie; |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
179 } |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
180 } |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
181 |
| 7 | 182 /* |
| 183 * Top level evaluation function, returning a boolean. | |
| 184 * Sets "error" to TRUE if there was an error. | |
| 185 * Return TRUE or FALSE. | |
| 186 */ | |
| 187 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
188 eval_to_bool( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
189 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
190 int *error, |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
191 exarg_T *eap, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
192 int skip) // only parse, don't execute |
| 7 | 193 { |
| 137 | 194 typval_T tv; |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
195 varnumber_T retval = FALSE; |
|
21050
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
196 evalarg_T evalarg; |
|
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
197 |
|
21096
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
198 fill_evalarg_from_eap(&evalarg, eap, skip); |
| 7 | 199 |
| 200 if (skip) | |
| 201 ++emsg_skip; | |
|
21050
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
202 if (eval0(arg, &tv, eap, &evalarg) == FAIL) |
| 7 | 203 *error = TRUE; |
| 204 else | |
| 205 { | |
| 206 *error = FALSE; | |
| 207 if (!skip) | |
| 208 { | |
|
21733
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
209 if (in_vim9script()) |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
210 retval = tv_get_bool_chk(&tv, error); |
|
21733
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
211 else |
|
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
212 retval = (tv_get_number_chk(&tv, error) != 0); |
| 71 | 213 clear_tv(&tv); |
| 7 | 214 } |
| 215 } | |
| 216 if (skip) | |
| 217 --emsg_skip; | |
|
21050
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
218 clear_evalarg(&evalarg, eap); |
| 7 | 219 |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
220 return (int)retval; |
| 7 | 221 } |
| 222 | |
|
15478
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
223 /* |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
224 * Call eval1() and give an error message if not done at a lower level. |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
225 */ |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
226 static int |
|
21098
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
227 eval1_emsg(char_u **arg, typval_T *rettv, exarg_T *eap) |
|
15478
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
228 { |
|
15482
18dd04f7c4a1
patch 8.1.0749: error message contains garbage
Bram Moolenaar <Bram@vim.org>
parents:
15478
diff
changeset
|
229 char_u *start = *arg; |
|
15478
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
230 int ret; |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
231 int did_emsg_before = did_emsg; |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
232 int called_emsg_before = called_emsg; |
|
21098
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
233 evalarg_T evalarg; |
|
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
234 |
|
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
235 fill_evalarg_from_eap(&evalarg, eap, eap != NULL && eap->skip); |
|
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
236 |
|
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
237 ret = eval1(arg, rettv, &evalarg); |
|
15478
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
238 if (ret == FAIL) |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
239 { |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
240 // Report the invalid expression unless the expression evaluation has |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
241 // been cancelled due to an aborting error, an interrupt, or an |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
242 // exception, or we already gave a more specific error. |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
243 // Also check called_emsg for when using assert_fails(). |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
244 if (!aborting() && did_emsg == did_emsg_before |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
245 && called_emsg == called_emsg_before) |
|
15482
18dd04f7c4a1
patch 8.1.0749: error message contains garbage
Bram Moolenaar <Bram@vim.org>
parents:
15478
diff
changeset
|
246 semsg(_(e_invexpr2), start); |
|
15478
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
247 } |
|
21098
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
248 clear_evalarg(&evalarg, eap); |
|
15478
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
249 return ret; |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
250 } |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
251 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
252 /* |
|
20731
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
253 * Return whether a typval is a valid expression to pass to eval_expr_typval() |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
254 * or eval_expr_to_bool(). An empty string returns FALSE; |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
255 */ |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
256 int |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
257 eval_expr_valid_arg(typval_T *tv) |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
258 { |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
259 return tv->v_type != VAR_UNKNOWN |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
260 && (tv->v_type != VAR_STRING |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
261 || (tv->vval.v_string != NULL && *tv->vval.v_string != NUL)); |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
262 } |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
263 |
|
ab27db64f1fb
patch 8.2.0918: duplicate code for evaluating expression argument
Bram Moolenaar <Bram@vim.org>
parents:
20587
diff
changeset
|
264 /* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
265 * Evaluate an expression, which can be a function, partial or string. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
266 * Pass arguments "argv[argc]". |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
267 * Return the result in "rettv" and OK or FAIL. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
268 */ |
|
16231
0761a4c111a7
patch 8.1.1120: cannot easily get directory entry matches
Bram Moolenaar <Bram@vim.org>
parents:
16223
diff
changeset
|
269 int |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
270 eval_expr_typval(typval_T *expr, typval_T *argv, int argc, typval_T *rettv) |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
271 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
272 char_u *s; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
273 char_u buf[NUMBUFLEN]; |
|
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
274 funcexe_T funcexe; |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
275 |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
276 if (expr->v_type == VAR_FUNC) |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
277 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
278 s = expr->vval.v_string; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
279 if (s == NULL || *s == NUL) |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
280 return FAIL; |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
281 CLEAR_FIELD(funcexe); |
|
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
282 funcexe.evaluate = TRUE; |
|
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
283 if (call_func(s, -1, rettv, argc, argv, &funcexe) == FAIL) |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
284 return FAIL; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
285 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
286 else if (expr->v_type == VAR_PARTIAL) |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
287 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
288 partial_T *partial = expr->vval.v_partial; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
289 |
|
20156
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
290 if (partial == NULL) |
|
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
291 return FAIL; |
|
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
292 |
|
20528
489cb75c76b6
patch 8.2.0818: Vim9: using a discovery phase doesn't work well
Bram Moolenaar <Bram@vim.org>
parents:
20526
diff
changeset
|
293 if (partial->pt_func != NULL |
|
20943
1693ca876049
patch 8.2.1023: Vim9: redefining a function uses a new index every time
Bram Moolenaar <Bram@vim.org>
parents:
20871
diff
changeset
|
294 && partial->pt_func->uf_def_status != UF_NOT_COMPILED) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
295 { |
|
20433
5950284a517f
patch 8.2.0771: Vim9: cannot call a compiled closure from not compiled code
Bram Moolenaar <Bram@vim.org>
parents:
20401
diff
changeset
|
296 if (call_def_function(partial->pt_func, argc, argv, |
|
5950284a517f
patch 8.2.0771: Vim9: cannot call a compiled closure from not compiled code
Bram Moolenaar <Bram@vim.org>
parents:
20401
diff
changeset
|
297 partial, rettv) == FAIL) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
298 return FAIL; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
299 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
300 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
301 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
302 s = partial_name(partial); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
303 if (s == NULL || *s == NUL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
304 return FAIL; |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
305 CLEAR_FIELD(funcexe); |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
306 funcexe.evaluate = TRUE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
307 funcexe.partial = partial; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
308 if (call_func(s, -1, rettv, argc, argv, &funcexe) == FAIL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
309 return FAIL; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
310 } |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
311 } |
|
24606
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
312 else if (expr->v_type == VAR_INSTR) |
|
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
313 { |
|
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
314 return exe_typval_instr(expr, rettv); |
|
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
315 } |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
316 else |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
317 { |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
318 s = tv_get_string_buf_chk(expr, buf); |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
319 if (s == NULL) |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
320 return FAIL; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
321 s = skipwhite(s); |
|
21098
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
322 if (eval1_emsg(&s, rettv, NULL) == FAIL) |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
323 return FAIL; |
|
21620
46956b6811a1
patch 8.2.1360: stray error for white space after expression
Bram Moolenaar <Bram@vim.org>
parents:
21552
diff
changeset
|
324 if (*skipwhite(s) != NUL) // check for trailing chars after expr |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
325 { |
|
14331
f8280e1bfc84
patch 8.1.0181: memory leak with trailing characters in skip expression
Christian Brabandt <cb@256bit.org>
parents:
14071
diff
changeset
|
326 clear_tv(rettv); |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
327 semsg(_(e_invexpr2), s); |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
328 return FAIL; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
329 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
330 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
331 return OK; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
332 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
333 |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
334 /* |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
335 * Like eval_to_bool() but using a typval_T instead of a string. |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
336 * Works for string, funcref and partial. |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
337 */ |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
338 int |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
339 eval_expr_to_bool(typval_T *expr, int *error) |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
340 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
341 typval_T rettv; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
342 int res; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
343 |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
344 if (eval_expr_typval(expr, NULL, 0, &rettv) == FAIL) |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
345 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
346 *error = TRUE; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
347 return FALSE; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
348 } |
|
21861
cd8dafe937ba
patch 8.2.1480: Vim9: skip expression in search() gives error
Bram Moolenaar <Bram@vim.org>
parents:
21847
diff
changeset
|
349 res = (tv_get_bool_chk(&rettv, error) != 0); |
|
12722
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
350 clear_tv(&rettv); |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
351 return res; |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
352 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
353 |
| 7 | 354 /* |
| 355 * Top level evaluation function, returning a string. If "skip" is TRUE, | |
| 356 * only parsing to "nextcmd" is done, without reporting errors. Return | |
| 357 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE. | |
| 358 */ | |
| 359 char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
360 eval_to_string_skip( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
361 char_u *arg, |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
362 exarg_T *eap, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
363 int skip) // only parse, don't execute |
| 7 | 364 { |
| 137 | 365 typval_T tv; |
| 7 | 366 char_u *retval; |
|
21094
376b520312d6
patch 8.2.1098: Vim9: cannot use line break in :throw argument
Bram Moolenaar <Bram@vim.org>
parents:
21077
diff
changeset
|
367 evalarg_T evalarg; |
|
376b520312d6
patch 8.2.1098: Vim9: cannot use line break in :throw argument
Bram Moolenaar <Bram@vim.org>
parents:
21077
diff
changeset
|
368 |
|
21096
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
369 fill_evalarg_from_eap(&evalarg, eap, skip); |
| 7 | 370 if (skip) |
| 371 ++emsg_skip; | |
|
21094
376b520312d6
patch 8.2.1098: Vim9: cannot use line break in :throw argument
Bram Moolenaar <Bram@vim.org>
parents:
21077
diff
changeset
|
372 if (eval0(arg, &tv, eap, &evalarg) == FAIL || skip) |
| 7 | 373 retval = NULL; |
| 374 else | |
| 375 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
376 retval = vim_strsave(tv_get_string(&tv)); |
| 71 | 377 clear_tv(&tv); |
| 7 | 378 } |
| 379 if (skip) | |
| 380 --emsg_skip; | |
|
21094
376b520312d6
patch 8.2.1098: Vim9: cannot use line break in :throw argument
Bram Moolenaar <Bram@vim.org>
parents:
21077
diff
changeset
|
381 clear_evalarg(&evalarg, eap); |
| 7 | 382 |
| 383 return retval; | |
| 384 } | |
| 385 | |
| 386 /* | |
| 9 | 387 * Skip over an expression at "*pp". |
| 388 * Return FAIL for an error, OK otherwise. | |
| 389 */ | |
| 390 int | |
|
22685
80b4e604d1d5
patch 8.2.1891: Vim9: skipping over expression doesn't handle line breaks
Bram Moolenaar <Bram@vim.org>
parents:
22683
diff
changeset
|
391 skip_expr(char_u **pp, evalarg_T *evalarg) |
| 9 | 392 { |
| 137 | 393 typval_T rettv; |
| 9 | 394 |
| 395 *pp = skipwhite(*pp); | |
|
22685
80b4e604d1d5
patch 8.2.1891: Vim9: skipping over expression doesn't handle line breaks
Bram Moolenaar <Bram@vim.org>
parents:
22683
diff
changeset
|
396 return eval1(pp, &rettv, evalarg); |
| 9 | 397 } |
| 398 | |
| 399 /* | |
|
24553
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
400 * Skip over an expression at "*arg". |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
401 * If in Vim9 script and line breaks are encountered, the lines are |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
402 * concatenated. "evalarg->eval_tofree" will be set accordingly. |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
403 * "arg" is advanced to just after the expression. |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
404 * "start" is set to the start of the expression, "end" to just after the end. |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
405 * Also when the expression is copied to allocated memory. |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
406 * Return FAIL for an error, OK otherwise. |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
407 */ |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
408 int |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
409 skip_expr_concatenate( |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
410 char_u **arg, |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
411 char_u **start, |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
412 char_u **end, |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
413 evalarg_T *evalarg) |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
414 { |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
415 typval_T rettv; |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
416 int res; |
|
21279
8d1d11afd8c8
patch 8.2.1190: Vim9: checking for Vim9 syntax is spread out
Bram Moolenaar <Bram@vim.org>
parents:
21277
diff
changeset
|
417 int vim9script = in_vim9script(); |
|
22021
514d622473af
patch 8.2.1560: using NULL pointers in some code
Bram Moolenaar <Bram@vim.org>
parents:
22004
diff
changeset
|
418 garray_T *gap = evalarg == NULL ? NULL : &evalarg->eval_ga; |
|
24655
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
419 garray_T *freegap = evalarg == NULL ? NULL : &evalarg->eval_freega; |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
420 int save_flags = evalarg == NULL ? 0 : evalarg->eval_flags; |
|
21865
c16af87df654
patch 8.2.1482: Vim9: crash when using a nested lambda
Bram Moolenaar <Bram@vim.org>
parents:
21861
diff
changeset
|
421 int evaluate = evalarg == NULL |
|
c16af87df654
patch 8.2.1482: Vim9: crash when using a nested lambda
Bram Moolenaar <Bram@vim.org>
parents:
21861
diff
changeset
|
422 ? FALSE : (evalarg->eval_flags & EVAL_EVALUATE); |
|
c16af87df654
patch 8.2.1482: Vim9: crash when using a nested lambda
Bram Moolenaar <Bram@vim.org>
parents:
21861
diff
changeset
|
423 |
|
c16af87df654
patch 8.2.1482: Vim9: crash when using a nested lambda
Bram Moolenaar <Bram@vim.org>
parents:
21861
diff
changeset
|
424 if (vim9script && evaluate |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
425 && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL)) |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
426 { |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
427 ga_init2(gap, sizeof(char_u *), 10); |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
428 // leave room for "start" |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
429 if (ga_grow(gap, 1) == OK) |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
430 ++gap->ga_len; |
|
24655
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
431 ga_init2(freegap, sizeof(char_u *), 10); |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
432 } |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
433 *start = *arg; |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
434 |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
435 // Don't evaluate the expression. |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
436 if (evalarg != NULL) |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
437 evalarg->eval_flags &= ~EVAL_EVALUATE; |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
438 *arg = skipwhite(*arg); |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
439 res = eval1(arg, &rettv, evalarg); |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
440 *end = *arg; |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
441 if (evalarg != NULL) |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
442 evalarg->eval_flags = save_flags; |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
443 |
|
21865
c16af87df654
patch 8.2.1482: Vim9: crash when using a nested lambda
Bram Moolenaar <Bram@vim.org>
parents:
21861
diff
changeset
|
444 if (vim9script && evaluate |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
445 && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL)) |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
446 { |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
447 if (evalarg->eval_ga.ga_len == 1) |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
448 { |
|
24655
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
449 // just the one line, no need to concatenate |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
450 ga_clear(gap); |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
451 gap->ga_itemsize = 0; |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
452 } |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
453 else |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
454 { |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
455 char_u *p; |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
456 size_t endoff = STRLEN(*arg); |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
457 |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
458 // Line breaks encountered, concatenate all the lines. |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
459 *((char_u **)gap->ga_data) = *start; |
|
24553
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
460 p = ga_concat_strings(gap, " "); |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
461 |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
462 // free the lines only when using getsourceline() |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
463 if (evalarg->eval_cookie != NULL) |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
464 { |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
465 // Do not free the first line, the caller can still use it. |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
466 *((char_u **)gap->ga_data) = NULL; |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
467 // Do not free the last line, "arg" points into it, free it |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
468 // later. |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
469 vim_free(evalarg->eval_tofree); |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
470 evalarg->eval_tofree = |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
471 ((char_u **)gap->ga_data)[gap->ga_len - 1]; |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
472 ((char_u **)gap->ga_data)[gap->ga_len - 1] = NULL; |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
473 ga_clear_strings(gap); |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
474 } |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
475 else |
|
24655
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
476 { |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
477 ga_clear(gap); |
|
24655
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
478 |
|
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
479 // free lines that were explicitly marked for freeing |
|
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
480 ga_clear_strings(freegap); |
|
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
481 } |
|
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
482 |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
483 gap->ga_itemsize = 0; |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
484 if (p == NULL) |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
485 return FAIL; |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
486 *start = p; |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
487 vim_free(evalarg->eval_tofree_lambda); |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
488 evalarg->eval_tofree_lambda = p; |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
489 // Compute "end" relative to the end. |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
490 *end = *start + STRLEN(*start) - endoff; |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
491 } |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
492 } |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
493 |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
494 return res; |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
495 } |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
496 |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
497 /* |
|
23628
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
498 * Convert "tv" to a string. |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
499 * When "convert" is TRUE convert a List into a sequence of lines and convert |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
500 * a Float to a String. |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
501 * Returns an allocated string (NULL when out of memory). |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
502 */ |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
503 char_u * |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
504 typval2string(typval_T *tv, int convert) |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
505 { |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
506 garray_T ga; |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
507 char_u *retval; |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
508 #ifdef FEAT_FLOAT |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
509 char_u numbuf[NUMBUFLEN]; |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
510 #endif |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
511 |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
512 if (convert && tv->v_type == VAR_LIST) |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
513 { |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
514 ga_init2(&ga, (int)sizeof(char), 80); |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
515 if (tv->vval.v_list != NULL) |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
516 { |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
517 list_join(&ga, tv->vval.v_list, (char_u *)"\n", TRUE, FALSE, 0); |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
518 if (tv->vval.v_list->lv_len > 0) |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
519 ga_append(&ga, NL); |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
520 } |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
521 ga_append(&ga, NUL); |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
522 retval = (char_u *)ga.ga_data; |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
523 } |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
524 #ifdef FEAT_FLOAT |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
525 else if (convert && tv->v_type == VAR_FLOAT) |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
526 { |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
527 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv->vval.v_float); |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
528 retval = vim_strsave(numbuf); |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
529 } |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
530 #endif |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
531 else |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
532 retval = vim_strsave(tv_get_string(tv)); |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
533 return retval; |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
534 } |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
535 |
|
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
536 /* |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
537 * Top level evaluation function, returning a string. Does not handle line |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
538 * breaks. |
| 1713 | 539 * When "convert" is TRUE convert a List into a sequence of lines and convert |
| 540 * a Float to a String. | |
| 7 | 541 * Return pointer to allocated memory, or NULL for failure. |
| 542 */ | |
| 543 char_u * | |
|
22732
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
544 eval_to_string_eap( |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
545 char_u *arg, |
|
22732
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
546 int convert, |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
547 exarg_T *eap) |
| 7 | 548 { |
| 137 | 549 typval_T tv; |
| 7 | 550 char_u *retval; |
|
22732
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
551 evalarg_T evalarg; |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
552 |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
553 fill_evalarg_from_eap(&evalarg, eap, eap != NULL && eap->skip); |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
554 if (eval0(arg, &tv, NULL, &evalarg) == FAIL) |
| 7 | 555 retval = NULL; |
| 556 else | |
| 557 { | |
|
23628
b26bbc03126a
patch 8.2.2356: Vim9: ":put =expr" does not handle a list properly
Bram Moolenaar <Bram@vim.org>
parents:
23604
diff
changeset
|
558 retval = typval2string(&tv, convert); |
| 71 | 559 clear_tv(&tv); |
| 7 | 560 } |
|
22732
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
561 clear_evalarg(&evalarg, NULL); |
| 7 | 562 |
| 563 return retval; | |
| 564 } | |
| 565 | |
|
22732
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
566 char_u * |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
567 eval_to_string( |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
568 char_u *arg, |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
569 int convert) |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
570 { |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
571 return eval_to_string_eap(arg, convert, NULL); |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
572 } |
|
4c21a3a47707
patch 8.2.1914: Vim9: cannot put line break in expression for '=' register
Bram Moolenaar <Bram@vim.org>
parents:
22685
diff
changeset
|
573 |
| 7 | 574 /* |
| 634 | 575 * Call eval_to_string() without using current local variables and using |
|
20229
06a1dd50463e
patch 8.2.0670: cannot change window when evaluating 'completefunc'
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
576 * textwinlock. When "use_sandbox" is TRUE use the sandbox. |
|
21775
6922d78b4d52
patch 8.2.1437: Vim9: 'statusline' is evaluated using Vim9 script syntax
Bram Moolenaar <Bram@vim.org>
parents:
21771
diff
changeset
|
577 * Use legacy Vim script syntax. |
| 7 | 578 */ |
| 579 char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
580 eval_to_string_safe( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
581 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
582 int use_sandbox) |
| 7 | 583 { |
| 584 char_u *retval; | |
|
14927
162d79d273e6
patch 8.1.0475: memory not freed on exit when quit in autocmd
Bram Moolenaar <Bram@vim.org>
parents:
14897
diff
changeset
|
585 funccal_entry_T funccal_entry; |
|
21775
6922d78b4d52
patch 8.2.1437: Vim9: 'statusline' is evaluated using Vim9 script syntax
Bram Moolenaar <Bram@vim.org>
parents:
21771
diff
changeset
|
586 int save_sc_version = current_sctx.sc_version; |
|
6922d78b4d52
patch 8.2.1437: Vim9: 'statusline' is evaluated using Vim9 script syntax
Bram Moolenaar <Bram@vim.org>
parents:
21771
diff
changeset
|
587 |
|
6922d78b4d52
patch 8.2.1437: Vim9: 'statusline' is evaluated using Vim9 script syntax
Bram Moolenaar <Bram@vim.org>
parents:
21771
diff
changeset
|
588 current_sctx.sc_version = 1; |
|
14927
162d79d273e6
patch 8.1.0475: memory not freed on exit when quit in autocmd
Bram Moolenaar <Bram@vim.org>
parents:
14897
diff
changeset
|
589 save_funccal(&funccal_entry); |
| 634 | 590 if (use_sandbox) |
| 591 ++sandbox; | |
|
20229
06a1dd50463e
patch 8.2.0670: cannot change window when evaluating 'completefunc'
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
592 ++textwinlock; |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
593 retval = eval_to_string(arg, FALSE); |
| 634 | 594 if (use_sandbox) |
| 595 --sandbox; | |
|
20229
06a1dd50463e
patch 8.2.0670: cannot change window when evaluating 'completefunc'
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
596 --textwinlock; |
|
14927
162d79d273e6
patch 8.1.0475: memory not freed on exit when quit in autocmd
Bram Moolenaar <Bram@vim.org>
parents:
14897
diff
changeset
|
597 restore_funccal(); |
|
21775
6922d78b4d52
patch 8.2.1437: Vim9: 'statusline' is evaluated using Vim9 script syntax
Bram Moolenaar <Bram@vim.org>
parents:
21771
diff
changeset
|
598 current_sctx.sc_version = save_sc_version; |
| 7 | 599 return retval; |
| 600 } | |
| 601 | |
| 602 /* | |
| 603 * Top level evaluation function, returning a number. | |
| 604 * Evaluates "expr" silently. | |
| 605 * Returns -1 for an error. | |
| 606 */ | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
607 varnumber_T |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
608 eval_to_number(char_u *expr) |
| 7 | 609 { |
| 137 | 610 typval_T rettv; |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
611 varnumber_T retval; |
| 97 | 612 char_u *p = skipwhite(expr); |
| 7 | 613 |
| 614 ++emsg_off; | |
| 615 | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
616 if (eval1(&p, &rettv, &EVALARG_EVALUATE) == FAIL) |
| 7 | 617 retval = -1; |
| 618 else | |
| 619 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
620 retval = tv_get_number_chk(&rettv, NULL); |
| 71 | 621 clear_tv(&rettv); |
| 7 | 622 } |
| 623 --emsg_off; | |
| 624 | |
| 625 return retval; | |
| 626 } | |
| 627 | |
| 446 | 628 /* |
| 625 | 629 * Top level evaluation function. |
| 630 * Returns an allocated typval_T with the result. | |
| 631 * Returns NULL when there is an error. | |
| 446 | 632 */ |
| 633 typval_T * | |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
634 eval_expr(char_u *arg, exarg_T *eap) |
| 446 | 635 { |
| 636 typval_T *tv; | |
|
21096
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
637 evalarg_T evalarg; |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
638 |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
639 fill_evalarg_from_eap(&evalarg, eap, eap != NULL && eap->skip); |
| 446 | 640 |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16796
diff
changeset
|
641 tv = ALLOC_ONE(typval_T); |
|
21096
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
642 if (tv != NULL && eval0(arg, tv, eap, &evalarg) == FAIL) |
|
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
13037
diff
changeset
|
643 VIM_CLEAR(tv); |
|
21096
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
644 |
|
74e5e212e550
patch 8.2.1099: Vim9: cannot use line break in :cexpr argument
Bram Moolenaar <Bram@vim.org>
parents:
21094
diff
changeset
|
645 clear_evalarg(&evalarg, eap); |
| 446 | 646 return tv; |
| 647 } | |
| 648 | |
| 7 | 649 /* |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10926
diff
changeset
|
650 * Call some Vim script function and return the result in "*rettv". |
|
14071
c1fcfafa8d1a
patch 8.1.0053: first argument of 'completefunc' has inconsistent type
Christian Brabandt <cb@256bit.org>
parents:
13923
diff
changeset
|
651 * Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] |
|
c1fcfafa8d1a
patch 8.1.0053: first argument of 'completefunc' has inconsistent type
Christian Brabandt <cb@256bit.org>
parents:
13923
diff
changeset
|
652 * should have type VAR_UNKNOWN. |
| 408 | 653 * Returns OK or FAIL. |
| 654 */ | |
| 3078 | 655 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
656 call_vim_function( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
657 char_u *func, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
658 int argc, |
|
14071
c1fcfafa8d1a
patch 8.1.0053: first argument of 'completefunc' has inconsistent type
Christian Brabandt <cb@256bit.org>
parents:
13923
diff
changeset
|
659 typval_T *argv, |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
660 typval_T *rettv) |
|
14071
c1fcfafa8d1a
patch 8.1.0053: first argument of 'completefunc' has inconsistent type
Christian Brabandt <cb@256bit.org>
parents:
13923
diff
changeset
|
661 { |
| 408 | 662 int ret; |
|
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
663 funcexe_T funcexe; |
| 7 | 664 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
665 rettv->v_type = VAR_UNKNOWN; // clear_tv() uses this |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
666 CLEAR_FIELD(funcexe); |
|
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
667 funcexe.firstline = curwin->w_cursor.lnum; |
|
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
668 funcexe.lastline = curwin->w_cursor.lnum; |
|
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
669 funcexe.evaluate = TRUE; |
|
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
670 ret = call_func(func, -1, rettv, argc, argv, &funcexe); |
| 408 | 671 if (ret == FAIL) |
| 672 clear_tv(rettv); | |
| 673 | |
| 674 return ret; | |
| 675 } | |
| 676 | |
| 4133 | 677 /* |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10926
diff
changeset
|
678 * Call Vim script function "func" and return the result as a number. |
| 4133 | 679 * Returns -1 when calling the function fails. |
|
14071
c1fcfafa8d1a
patch 8.1.0053: first argument of 'completefunc' has inconsistent type
Christian Brabandt <cb@256bit.org>
parents:
13923
diff
changeset
|
680 * Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] should |
|
c1fcfafa8d1a
patch 8.1.0053: first argument of 'completefunc' has inconsistent type
Christian Brabandt <cb@256bit.org>
parents:
13923
diff
changeset
|
681 * have type VAR_UNKNOWN. |
| 4133 | 682 */ |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
683 varnumber_T |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
684 call_func_retnr( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
685 char_u *func, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
686 int argc, |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
687 typval_T *argv) |
| 4133 | 688 { |
| 689 typval_T rettv; | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
690 varnumber_T retval; |
| 4133 | 691 |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
692 if (call_vim_function(func, argc, argv, &rettv) == FAIL) |
| 4133 | 693 return -1; |
| 694 | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
695 retval = tv_get_number_chk(&rettv, NULL); |
| 4133 | 696 clear_tv(&rettv); |
| 697 return retval; | |
| 698 } | |
| 699 | |
| 408 | 700 /* |
|
23281
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
701 * Call Vim script function like call_func_retnr() and drop the result. |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
702 * Returns FAIL when calling the function fails. |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
703 */ |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
704 int |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
705 call_func_noret( |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
706 char_u *func, |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
707 int argc, |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
708 typval_T *argv) |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
709 { |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
710 typval_T rettv; |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
711 |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
712 if (call_vim_function(func, argc, argv, &rettv) == FAIL) |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
713 return FAIL; |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
714 clear_tv(&rettv); |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
715 return OK; |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
716 } |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
717 |
|
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
718 /* |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10926
diff
changeset
|
719 * Call Vim script function "func" and return the result as a string. |
|
23281
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
720 * Uses "argv" and "argc" as call_func_retnr(). |
| 453 | 721 * Returns NULL when calling the function fails. |
| 408 | 722 */ |
| 723 void * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
724 call_func_retstr( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
725 char_u *func, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
726 int argc, |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
727 typval_T *argv) |
| 408 | 728 { |
| 729 typval_T rettv; | |
| 453 | 730 char_u *retval; |
| 408 | 731 |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
732 if (call_vim_function(func, argc, argv, &rettv) == FAIL) |
| 408 | 733 return NULL; |
| 734 | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
735 retval = vim_strsave(tv_get_string(&rettv)); |
| 408 | 736 clear_tv(&rettv); |
| 7 | 737 return retval; |
| 738 } | |
| 1322 | 739 |
| 453 | 740 /* |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10926
diff
changeset
|
741 * Call Vim script function "func" and return the result as a List. |
|
23281
5b4db8035d1d
patch 8.2.2186: Vim9: error when using 'opfunc'
Bram Moolenaar <Bram@vim.org>
parents:
23239
diff
changeset
|
742 * Uses "argv" and "argc" as call_func_retnr(). |
| 1690 | 743 * Returns NULL when there is something wrong. |
| 408 | 744 */ |
| 745 void * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
746 call_func_retlist( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
747 char_u *func, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
748 int argc, |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
749 typval_T *argv) |
| 408 | 750 { |
| 751 typval_T rettv; | |
| 752 | |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
753 if (call_vim_function(func, argc, argv, &rettv) == FAIL) |
| 408 | 754 return NULL; |
| 755 | |
| 756 if (rettv.v_type != VAR_LIST) | |
| 757 { | |
| 758 clear_tv(&rettv); | |
| 759 return NULL; | |
| 760 } | |
| 761 | |
| 762 return rettv.vval.v_list; | |
| 763 } | |
| 1322 | 764 |
| 7 | 765 #ifdef FEAT_FOLDING |
| 766 /* | |
|
23527
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
767 * Evaluate "arg", which is 'foldexpr'. |
|
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
768 * Note: caller must set "curwin" to match "arg". |
|
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
769 * Returns the foldlevel, and any character preceding it in "*cp". Doesn't |
|
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
770 * give error messages. |
| 7 | 771 */ |
| 772 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
773 eval_foldexpr(char_u *arg, int *cp) |
| 7 | 774 { |
| 137 | 775 typval_T tv; |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
776 varnumber_T retval; |
| 7 | 777 char_u *s; |
| 681 | 778 int use_sandbox = was_set_insecurely((char_u *)"foldexpr", |
| 779 OPT_LOCAL); | |
| 7 | 780 |
| 781 ++emsg_off; | |
| 634 | 782 if (use_sandbox) |
| 783 ++sandbox; | |
|
20229
06a1dd50463e
patch 8.2.0670: cannot change window when evaluating 'completefunc'
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
784 ++textwinlock; |
| 7 | 785 *cp = NUL; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
786 if (eval0(arg, &tv, NULL, &EVALARG_EVALUATE) == FAIL) |
| 7 | 787 retval = 0; |
| 788 else | |
| 789 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
790 // If the result is a number, just return the number. |
| 71 | 791 if (tv.v_type == VAR_NUMBER) |
| 792 retval = tv.vval.v_number; | |
| 156 | 793 else if (tv.v_type != VAR_STRING || tv.vval.v_string == NULL) |
| 7 | 794 retval = 0; |
| 795 else | |
| 796 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
797 // If the result is a string, check if there is a non-digit before |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
798 // the number. |
| 71 | 799 s = tv.vval.v_string; |
| 7 | 800 if (!VIM_ISDIGIT(*s) && *s != '-') |
| 801 *cp = *s++; | |
| 802 retval = atol((char *)s); | |
| 803 } | |
| 71 | 804 clear_tv(&tv); |
| 7 | 805 } |
| 806 --emsg_off; | |
| 634 | 807 if (use_sandbox) |
| 808 --sandbox; | |
|
20229
06a1dd50463e
patch 8.2.0670: cannot change window when evaluating 'completefunc'
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
809 --textwinlock; |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
810 clear_evalarg(&EVALARG_EVALUATE, NULL); |
| 7 | 811 |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
812 return (int)retval; |
| 7 | 813 } |
| 814 #endif | |
| 815 | |
| 816 /* | |
| 110 | 817 * Get an lval: variable, Dict item or List item that can be assigned a value |
| 818 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]", | |
| 819 * "name.key", "name.key[expr]" etc. | |
| 820 * Indexing only works if "name" is an existing List or Dictionary. | |
| 821 * "name" points to the start of the name. | |
| 822 * If "rettv" is not NULL it points to the value to be assigned. | |
| 823 * "unlet" is TRUE for ":unlet": slightly different behavior when something is | |
| 824 * wrong; must end in space or cmd separator. | |
| 825 * | |
| 5604 | 826 * flags: |
| 827 * GLV_QUIET: do not give error messages | |
|
10912
fd1760f8c215
patch 8.0.0345: islocked('d.changedtick') does not work
Christian Brabandt <cb@256bit.org>
parents:
10910
diff
changeset
|
828 * GLV_READ_ONLY: will not change the variable |
| 5604 | 829 * GLV_NO_AUTOLOAD: do not use script autoloading |
| 830 * | |
| 110 | 831 * Returns a pointer to just after the name, including indexes. |
| 124 | 832 * When an evaluation error occurs "lp->ll_name" is NULL; |
| 110 | 833 * Returns NULL for a parsing error. Still need to free items in "lp"! |
| 71 | 834 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
835 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
836 get_lval( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
837 char_u *name, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
838 typval_T *rettv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
839 lval_T *lp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
840 int unlet, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
841 int skip, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
842 int flags, // GLV_ values |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
843 int fne_flags) // flags for find_name_end() |
| 110 | 844 { |
| 845 char_u *p; | |
| 846 char_u *expr_start, *expr_end; | |
| 847 int cc; | |
| 137 | 848 dictitem_T *v; |
| 849 typval_T var1; | |
| 850 typval_T var2; | |
| 110 | 851 int empty1 = FALSE; |
| 137 | 852 listitem_T *ni; |
| 100 | 853 char_u *key = NULL; |
| 854 int len; | |
|
22963
317462da618a
patch 8.2.2028: Coverity warns for using an uninitialized variable
Bram Moolenaar <Bram@vim.org>
parents:
22866
diff
changeset
|
855 hashtab_T *ht = NULL; |
| 5604 | 856 int quiet = flags & GLV_QUIET; |
|
23527
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
857 int writing; |
| 71 | 858 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
859 // Clear everything in "lp". |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
860 CLEAR_POINTER(lp); |
| 110 | 861 |
|
23495
1f85acfb23cd
patch 8.2.2290: Vim9: unlet of global variable cannot be compiled
Bram Moolenaar <Bram@vim.org>
parents:
23493
diff
changeset
|
862 if (skip || (flags & GLV_COMPILING)) |
| 110 | 863 { |
|
23495
1f85acfb23cd
patch 8.2.2290: Vim9: unlet of global variable cannot be compiled
Bram Moolenaar <Bram@vim.org>
parents:
23493
diff
changeset
|
864 // When skipping or compiling just find the end of the name. |
| 110 | 865 lp->ll_name = name; |
|
21077
794bf2be08be
patch 8.2.1090: may use NULL pointer when skipping over name
Bram Moolenaar <Bram@vim.org>
parents:
21058
diff
changeset
|
866 lp->ll_name_end = find_name_end(name, NULL, NULL, |
|
794bf2be08be
patch 8.2.1090: may use NULL pointer when skipping over name
Bram Moolenaar <Bram@vim.org>
parents:
21058
diff
changeset
|
867 FNE_INCL_BR | fne_flags); |
|
794bf2be08be
patch 8.2.1090: may use NULL pointer when skipping over name
Bram Moolenaar <Bram@vim.org>
parents:
21058
diff
changeset
|
868 return lp->ll_name_end; |
| 110 | 869 } |
| 870 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
871 // Find the end of the name. |
| 271 | 872 p = find_name_end(name, &expr_start, &expr_end, fne_flags); |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
873 lp->ll_name_end = p; |
| 110 | 874 if (expr_start != NULL) |
| 875 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
876 // Don't expand the name when we already know there is an error. |
|
11129
f4ea50924c6d
patch 8.0.0452: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11127
diff
changeset
|
877 if (unlet && !VIM_ISWHITE(*p) && !ends_excmd(*p) |
| 110 | 878 && *p != '[' && *p != '.') |
| 879 { | |
|
21461
4dfd00f481fb
patch 8.2.1281: the "trailing characters" error can be hard to understand
Bram Moolenaar <Bram@vim.org>
parents:
21447
diff
changeset
|
880 semsg(_(e_trailing_arg), p); |
| 110 | 881 return NULL; |
| 882 } | |
| 883 | |
| 884 lp->ll_exp_name = make_expanded_name(name, expr_start, expr_end, p); | |
| 885 if (lp->ll_exp_name == NULL) | |
| 886 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
887 // Report an invalid expression in braces, unless the |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
888 // expression evaluation has been cancelled due to an |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
889 // aborting error, an interrupt, or an exception. |
| 110 | 890 if (!aborting() && !quiet) |
| 891 { | |
| 121 | 892 emsg_severe = TRUE; |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
893 semsg(_(e_invarg2), name); |
| 110 | 894 return NULL; |
| 895 } | |
| 896 } | |
| 897 lp->ll_name = lp->ll_exp_name; | |
| 898 } | |
| 899 else | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
900 { |
| 110 | 901 lp->ll_name = name; |
| 902 | |
|
21674
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
903 if (in_vim9script()) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
904 { |
|
21674
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
905 // "a: type" is declaring variable "a" with a type, not "a:". |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
906 if (p == name + 2 && p[-1] == ':') |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
907 { |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
908 --p; |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
909 lp->ll_name_end = p; |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
910 } |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
911 if (*p == ':') |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
912 { |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
913 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
914 char_u *tp = skipwhite(p + 1); |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
915 |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
916 // parse the type after the name |
|
23332
cdb706d5c43d
patch 8.2.2209: Vim9: return type of => lambda not parsed
Bram Moolenaar <Bram@vim.org>
parents:
23322
diff
changeset
|
917 lp->ll_type = parse_type(&tp, &si->sn_type_list, !quiet); |
|
cdb706d5c43d
patch 8.2.2209: Vim9: return type of => lambda not parsed
Bram Moolenaar <Bram@vim.org>
parents:
23322
diff
changeset
|
918 if (lp->ll_type == NULL && !quiet) |
|
cdb706d5c43d
patch 8.2.2209: Vim9: return type of => lambda not parsed
Bram Moolenaar <Bram@vim.org>
parents:
23322
diff
changeset
|
919 return NULL; |
|
21674
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
920 lp->ll_name_end = tp; |
|
f303d6a01a3e
patch 8.2.1387: Vim9: cannot assign to single letter variable with type
Bram Moolenaar <Bram@vim.org>
parents:
21656
diff
changeset
|
921 } |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
922 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
923 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
924 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
925 // Without [idx] or .key we are done. |
| 110 | 926 if ((*p != '[' && *p != '.') || lp->ll_name == NULL) |
| 927 return p; | |
| 928 | |
| 929 cc = *p; | |
| 930 *p = NUL; | |
|
23527
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
931 // When we would write to the variable pass &ht and prevent autoload. |
|
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
932 writing = !(flags & GLV_READ_ONLY); |
|
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
933 v = find_var(lp->ll_name, writing ? &ht : NULL, |
|
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
934 (flags & GLV_NO_AUTOLOAD) || writing); |
| 110 | 935 if (v == NULL && !quiet) |
|
21821
0deb6f96a5a3
patch 8.2.1460: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
21775
diff
changeset
|
936 semsg(_(e_undefined_variable_str), lp->ll_name); |
| 110 | 937 *p = cc; |
| 71 | 938 if (v == NULL) |
| 939 return NULL; | |
| 940 | |
|
23239
a789a688e37d
patch 8.2.2165: Vim9: assignment to dict member does not work
Bram Moolenaar <Bram@vim.org>
parents:
23233
diff
changeset
|
941 if (in_vim9script() && (flags & GLV_NO_DECL) == 0) |
|
a789a688e37d
patch 8.2.2165: Vim9: assignment to dict member does not work
Bram Moolenaar <Bram@vim.org>
parents:
23233
diff
changeset
|
942 { |
|
a789a688e37d
patch 8.2.2165: Vim9: assignment to dict member does not work
Bram Moolenaar <Bram@vim.org>
parents:
23233
diff
changeset
|
943 if (!quiet) |
|
a789a688e37d
patch 8.2.2165: Vim9: assignment to dict member does not work
Bram Moolenaar <Bram@vim.org>
parents:
23233
diff
changeset
|
944 semsg(_(e_variable_already_declared), lp->ll_name); |
|
a789a688e37d
patch 8.2.2165: Vim9: assignment to dict member does not work
Bram Moolenaar <Bram@vim.org>
parents:
23233
diff
changeset
|
945 return NULL; |
|
a789a688e37d
patch 8.2.2165: Vim9: assignment to dict member does not work
Bram Moolenaar <Bram@vim.org>
parents:
23233
diff
changeset
|
946 } |
|
a789a688e37d
patch 8.2.2165: Vim9: assignment to dict member does not work
Bram Moolenaar <Bram@vim.org>
parents:
23233
diff
changeset
|
947 |
| 110 | 948 /* |
| 949 * Loop until no more [idx] or .key is following. | |
| 950 */ | |
| 137 | 951 lp->ll_tv = &v->di_tv; |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
952 var1.v_type = VAR_UNKNOWN; |
|
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
953 var2.v_type = VAR_UNKNOWN; |
| 110 | 954 while (*p == '[' || (*p == '.' && lp->ll_tv->v_type == VAR_DICT)) |
| 955 { | |
| 956 if (!(lp->ll_tv->v_type == VAR_LIST && lp->ll_tv->vval.v_list != NULL) | |
|
22365
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
957 && !(lp->ll_tv->v_type == VAR_DICT) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
958 && !(lp->ll_tv->v_type == VAR_BLOB |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
959 && lp->ll_tv->vval.v_blob != NULL)) |
| 110 | 960 { |
| 961 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
962 emsg(_("E689: Can only index a List, Dictionary or Blob")); |
| 110 | 963 return NULL; |
| 964 } | |
| 965 if (lp->ll_range) | |
| 966 { | |
| 967 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
968 emsg(_("E708: [:] must come last")); |
| 110 | 969 return NULL; |
| 71 | 970 } |
| 88 | 971 |
|
22529
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
972 if (in_vim9script() && lp->ll_valtype == NULL |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
973 && lp->ll_tv == &v->di_tv |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
974 && ht != NULL && ht == get_script_local_ht()) |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
975 { |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
976 svar_T *sv = find_typval_in_script(lp->ll_tv); |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
977 |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
978 // Vim9 script local variable: get the type |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
979 if (sv != NULL) |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
980 lp->ll_valtype = sv->sv_type; |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
981 } |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
982 |
| 100 | 983 len = -1; |
| 984 if (*p == '.') | |
| 985 { | |
| 986 key = p + 1; | |
| 987 for (len = 0; ASCII_ISALNUM(key[len]) || key[len] == '_'; ++len) | |
| 988 ; | |
| 989 if (len == 0) | |
| 990 { | |
| 110 | 991 if (!quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
992 emsg(_(e_emptykey)); |
| 110 | 993 return NULL; |
| 88 | 994 } |
| 100 | 995 p = key + len; |
| 996 } | |
| 997 else | |
| 998 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
999 // Get the index [expr] or the first index [expr: ]. |
| 88 | 1000 p = skipwhite(p + 1); |
| 100 | 1001 if (*p == ':') |
| 1002 empty1 = TRUE; | |
| 88 | 1003 else |
| 1004 { | |
| 100 | 1005 empty1 = FALSE; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
1006 if (eval1(&p, &var1, &EVALARG_EVALUATE) == FAIL) // recursive! |
| 110 | 1007 return NULL; |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1008 if (tv_get_string_chk(&var1) == NULL) |
| 323 | 1009 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1010 // not a number or string |
| 323 | 1011 clear_tv(&var1); |
| 1012 return NULL; | |
| 1013 } | |
|
21622
1f2066e3975a
patch 8.2.1361: error for white space after expression in assignment
Bram Moolenaar <Bram@vim.org>
parents:
21620
diff
changeset
|
1014 p = skipwhite(p); |
| 100 | 1015 } |
| 1016 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1017 // Optionally get the second index [ :expr]. |
| 100 | 1018 if (*p == ':') |
| 1019 { | |
| 110 | 1020 if (lp->ll_tv->v_type == VAR_DICT) |
| 1021 { | |
| 1022 if (!quiet) | |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
1023 emsg(_(e_cannot_slice_dictionary)); |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1024 clear_tv(&var1); |
| 110 | 1025 return NULL; |
| 1026 } | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1027 if (rettv != NULL |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1028 && !(rettv->v_type == VAR_LIST |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1029 && rettv->vval.v_list != NULL) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1030 && !(rettv->v_type == VAR_BLOB |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1031 && rettv->vval.v_blob != NULL)) |
| 110 | 1032 { |
| 1033 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1034 emsg(_("E709: [:] requires a List or Blob value")); |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1035 clear_tv(&var1); |
| 110 | 1036 return NULL; |
| 88 | 1037 } |
| 100 | 1038 p = skipwhite(p + 1); |
| 1039 if (*p == ']') | |
| 110 | 1040 lp->ll_empty2 = TRUE; |
| 100 | 1041 else |
| 1042 { | |
| 110 | 1043 lp->ll_empty2 = FALSE; |
|
20397
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
1044 // recursive! |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
1045 if (eval1(&p, &var2, &EVALARG_EVALUATE) == FAIL) |
| 100 | 1046 { |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1047 clear_tv(&var1); |
| 110 | 1048 return NULL; |
| 100 | 1049 } |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1050 if (tv_get_string_chk(&var2) == NULL) |
| 323 | 1051 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1052 // not a number or string |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1053 clear_tv(&var1); |
| 323 | 1054 clear_tv(&var2); |
| 1055 return NULL; | |
| 1056 } | |
| 100 | 1057 } |
| 110 | 1058 lp->ll_range = TRUE; |
| 100 | 1059 } |
| 1060 else | |
| 110 | 1061 lp->ll_range = FALSE; |
| 100 | 1062 |
| 1063 if (*p != ']') | |
| 1064 { | |
| 110 | 1065 if (!quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1066 emsg(_(e_missbrac)); |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1067 clear_tv(&var1); |
|
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1068 clear_tv(&var2); |
| 110 | 1069 return NULL; |
| 100 | 1070 } |
| 1071 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1072 // Skip to past ']'. |
| 100 | 1073 ++p; |
| 1074 } | |
| 1075 | |
| 110 | 1076 if (lp->ll_tv->v_type == VAR_DICT) |
| 100 | 1077 { |
| 1078 if (len == -1) | |
| 1079 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1080 // "[key]": get key from "var1" |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1081 key = tv_get_string_chk(&var1); // is number or string |
|
8839
9fa567d13551
commit https://github.com/vim/vim/commit/0921ecff1c5a74541bad6c073e8ade32247403d8
Christian Brabandt <cb@256bit.org>
parents:
8831
diff
changeset
|
1082 if (key == NULL) |
|
9fa567d13551
commit https://github.com/vim/vim/commit/0921ecff1c5a74541bad6c073e8ade32247403d8
Christian Brabandt <cb@256bit.org>
parents:
8831
diff
changeset
|
1083 { |
| 100 | 1084 clear_tv(&var1); |
| 110 | 1085 return NULL; |
| 1086 } | |
| 1087 } | |
| 117 | 1088 lp->ll_list = NULL; |
|
22365
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1089 |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1090 // a NULL dict is equivalent with an empty dict |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1091 if (lp->ll_tv->vval.v_dict == NULL) |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1092 { |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1093 lp->ll_tv->vval.v_dict = dict_alloc(); |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1094 if (lp->ll_tv->vval.v_dict == NULL) |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1095 { |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1096 clear_tv(&var1); |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1097 return NULL; |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1098 } |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1099 ++lp->ll_tv->vval.v_dict->dv_refcount; |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1100 } |
| 117 | 1101 lp->ll_dict = lp->ll_tv->vval.v_dict; |
|
22365
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1102 |
| 121 | 1103 lp->ll_di = dict_find(lp->ll_dict, key, len); |
| 2739 | 1104 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1105 // When assigning to a scope dictionary check that a function and |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1106 // variable name is valid (only variable name unless it is l: or |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1107 // g: dictionary). Disallow overwriting a builtin function. |
| 3687 | 1108 if (rettv != NULL && lp->ll_dict->dv_scope != 0) |
| 1109 { | |
| 1110 int prevval; | |
| 1111 int wrong; | |
| 1112 | |
| 1113 if (len != -1) | |
| 1114 { | |
| 1115 prevval = key[len]; | |
| 1116 key[len] = NUL; | |
| 1117 } | |
|
4819
8c4324e6f477
updated for version 7.3.1156
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1118 else |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1119 prevval = 0; // avoid compiler warning |
| 3687 | 1120 wrong = (lp->ll_dict->dv_scope == VAR_DEF_SCOPE |
| 1121 && rettv->v_type == VAR_FUNC | |
|
21691
f41c646cb8b9
patch 8.2.1395: Vim9: no error if declaring a funcref with lower case letter
Bram Moolenaar <Bram@vim.org>
parents:
21674
diff
changeset
|
1122 && var_wrong_func_name(key, lp->ll_di == NULL)) |
|
23233
657216220293
patch 8.2.2162: Vim9: Cannot load or store autoload variables
Bram Moolenaar <Bram@vim.org>
parents:
23229
diff
changeset
|
1123 || !valid_varname(key, TRUE); |
| 3687 | 1124 if (len != -1) |
| 1125 key[len] = prevval; | |
| 1126 if (wrong) | |
|
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20126
diff
changeset
|
1127 { |
|
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20126
diff
changeset
|
1128 clear_tv(&var1); |
| 2739 | 1129 return NULL; |
|
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20126
diff
changeset
|
1130 } |
| 2739 | 1131 } |
| 1132 | |
|
22529
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1133 if (lp->ll_valtype != NULL) |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1134 // use the type of the member |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1135 lp->ll_valtype = lp->ll_valtype->tt_member; |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1136 |
| 110 | 1137 if (lp->ll_di == NULL) |
| 100 | 1138 { |
|
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
1139 // Can't add "v:" or "a:" variable. |
|
17922
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
1140 if (lp->ll_dict == get_vimvar_dict() |
|
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
1141 || &lp->ll_dict->dv_hashtab == get_funccal_args_ht()) |
| 2739 | 1142 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1143 semsg(_(e_illvar), name); |
|
16013
93b08b92a049
patch 8.1.1012: memory leak with E461
Bram Moolenaar <Bram@vim.org>
parents:
15969
diff
changeset
|
1144 clear_tv(&var1); |
| 2739 | 1145 return NULL; |
| 1146 } | |
| 1147 | |
|
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
1148 // Key does not exist in dict: may need to add it. |
| 110 | 1149 if (*p == '[' || *p == '.' || unlet) |
| 1150 { | |
| 1151 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1152 semsg(_(e_dictkey), key); |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1153 clear_tv(&var1); |
| 110 | 1154 return NULL; |
| 100 | 1155 } |
| 1156 if (len == -1) | |
| 110 | 1157 lp->ll_newkey = vim_strsave(key); |
| 100 | 1158 else |
| 110 | 1159 lp->ll_newkey = vim_strnsave(key, len); |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1160 clear_tv(&var1); |
| 110 | 1161 if (lp->ll_newkey == NULL) |
| 100 | 1162 p = NULL; |
| 1163 break; | |
| 1164 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1165 // existing variable, need to check if it can be changed |
|
10912
fd1760f8c215
patch 8.0.0345: islocked('d.changedtick') does not work
Christian Brabandt <cb@256bit.org>
parents:
10910
diff
changeset
|
1166 else if ((flags & GLV_READ_ONLY) == 0 |
|
22298
07e48ee8c3bb
patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9
Bram Moolenaar <Bram@vim.org>
parents:
22272
diff
changeset
|
1167 && (var_check_ro(lp->ll_di->di_flags, name, FALSE) |
|
07e48ee8c3bb
patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9
Bram Moolenaar <Bram@vim.org>
parents:
22272
diff
changeset
|
1168 || var_check_lock(lp->ll_di->di_flags, name, FALSE))) |
|
10910
8bff367672a4
patch 8.0.0344: unlet command leaks memory
Christian Brabandt <cb@256bit.org>
parents:
10908
diff
changeset
|
1169 { |
|
8bff367672a4
patch 8.0.0344: unlet command leaks memory
Christian Brabandt <cb@256bit.org>
parents:
10908
diff
changeset
|
1170 clear_tv(&var1); |
| 2739 | 1171 return NULL; |
|
10910
8bff367672a4
patch 8.0.0344: unlet command leaks memory
Christian Brabandt <cb@256bit.org>
parents:
10908
diff
changeset
|
1172 } |
| 2739 | 1173 |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1174 clear_tv(&var1); |
| 110 | 1175 lp->ll_tv = &lp->ll_di->di_tv; |
| 100 | 1176 } |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1177 else if (lp->ll_tv->v_type == VAR_BLOB) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1178 { |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1179 long bloblen = blob_len(lp->ll_tv->vval.v_blob); |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1180 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1181 /* |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1182 * Get the number and item for the only or first index of the List. |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1183 */ |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1184 if (empty1) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1185 lp->ll_n1 = 0; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1186 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1187 // is number or string |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1188 lp->ll_n1 = (long)tv_get_number(&var1); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1189 clear_tv(&var1); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1190 |
|
24454
53216e87f21c
patch 8.2.2767: compiler warning for unused argument
Bram Moolenaar <Bram@vim.org>
parents:
24450
diff
changeset
|
1191 if (check_blob_index(bloblen, lp->ll_n1, quiet) == FAIL) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1192 { |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1193 clear_tv(&var2); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1194 return NULL; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1195 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1196 if (lp->ll_range && !lp->ll_empty2) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1197 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1198 lp->ll_n2 = (long)tv_get_number(&var2); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1199 clear_tv(&var2); |
|
24450
3e1886f1e875
patch 8.2.2765: Vim9: not all blob operations work
Bram Moolenaar <Bram@vim.org>
parents:
24440
diff
changeset
|
1200 if (check_blob_range(bloblen, lp->ll_n1, lp->ll_n2, quiet) |
|
3e1886f1e875
patch 8.2.2765: Vim9: not all blob operations work
Bram Moolenaar <Bram@vim.org>
parents:
24440
diff
changeset
|
1201 == FAIL) |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1202 return NULL; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1203 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1204 lp->ll_blob = lp->ll_tv->vval.v_blob; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1205 lp->ll_tv = NULL; |
|
16036
89fb86821b4a
patch 8.1.1023: may use NULL pointer when indexing a blob
Bram Moolenaar <Bram@vim.org>
parents:
16013
diff
changeset
|
1206 break; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1207 } |
| 100 | 1208 else |
| 1209 { | |
| 1210 /* | |
| 1211 * Get the number and item for the only or first index of the List. | |
| 1212 */ | |
| 1213 if (empty1) | |
| 110 | 1214 lp->ll_n1 = 0; |
| 100 | 1215 else |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1216 // is number or string |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1217 lp->ll_n1 = (long)tv_get_number(&var1); |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1218 clear_tv(&var1); |
|
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1219 |
| 117 | 1220 lp->ll_dict = NULL; |
| 110 | 1221 lp->ll_list = lp->ll_tv->vval.v_list; |
|
23982
9fcd71d0db89
patch 8.2.2533: Vim9: cannot use a range with :unlet
Bram Moolenaar <Bram@vim.org>
parents:
23972
diff
changeset
|
1222 lp->ll_li = list_find_index(lp->ll_list, &lp->ll_n1); |
| 842 | 1223 if (lp->ll_li == NULL) |
| 1224 { | |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1225 clear_tv(&var2); |
| 2772 | 1226 if (!quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1227 semsg(_(e_listidx), lp->ll_n1); |
| 110 | 1228 return NULL; |
| 100 | 1229 } |
| 1230 | |
|
22529
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1231 if (lp->ll_valtype != NULL) |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1232 // use the type of the member |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1233 lp->ll_valtype = lp->ll_valtype->tt_member; |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1234 |
| 100 | 1235 /* |
| 1236 * May need to find the item or absolute index for the second | |
| 1237 * index of a range. | |
| 110 | 1238 * When no index given: "lp->ll_empty2" is TRUE. |
| 1239 * Otherwise "lp->ll_n2" is set to the second index. | |
| 100 | 1240 */ |
| 110 | 1241 if (lp->ll_range && !lp->ll_empty2) |
| 1242 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1243 lp->ll_n2 = (long)tv_get_number(&var2); |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1244 // is number or string |
| 88 | 1245 clear_tv(&var2); |
| 110 | 1246 if (lp->ll_n2 < 0) |
| 1247 { | |
| 1248 ni = list_find(lp->ll_list, lp->ll_n2); | |
| 100 | 1249 if (ni == NULL) |
| 2772 | 1250 { |
| 1251 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1252 semsg(_(e_listidx), lp->ll_n2); |
| 110 | 1253 return NULL; |
| 2772 | 1254 } |
| 110 | 1255 lp->ll_n2 = list_idx_of_item(lp->ll_list, ni); |
| 1256 } | |
| 1257 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1258 // Check that lp->ll_n2 isn't before lp->ll_n1. |
| 110 | 1259 if (lp->ll_n1 < 0) |
| 1260 lp->ll_n1 = list_idx_of_item(lp->ll_list, lp->ll_li); | |
| 1261 if (lp->ll_n2 < lp->ll_n1) | |
| 2772 | 1262 { |
| 1263 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1264 semsg(_(e_listidx), lp->ll_n2); |
| 110 | 1265 return NULL; |
| 2772 | 1266 } |
| 110 | 1267 } |
| 1268 | |
| 1269 lp->ll_tv = &lp->ll_li->li_tv; | |
| 1270 } | |
| 1271 } | |
| 1272 | |
|
10926
7dab3a9cb933
patch 8.0.0352: not easy to see when a typval needs to be cleared
Christian Brabandt <cb@256bit.org>
parents:
10912
diff
changeset
|
1273 clear_tv(&var1); |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1274 lp->ll_name_end = p; |
| 110 | 1275 return p; |
| 1276 } | |
| 1277 | |
| 1278 /* | |
| 137 | 1279 * Clear lval "lp" that was filled by get_lval(). |
| 110 | 1280 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
1281 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1282 clear_lval(lval_T *lp) |
| 110 | 1283 { |
| 1284 vim_free(lp->ll_exp_name); | |
| 1285 vim_free(lp->ll_newkey); | |
| 1286 } | |
| 1287 | |
| 1288 /* | |
| 151 | 1289 * Set a variable that was parsed by get_lval() to "rettv". |
| 110 | 1290 * "endp" points to just after the parsed name. |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1291 * "op" is NULL, "+" for "+=", "-" for "-=", "*" for "*=", "/" for "/=", |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1292 * "%" for "%=", "." for ".=" or "=" for "=". |
| 117 | 1293 */ |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
1294 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1295 set_var_lval( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1296 lval_T *lp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1297 char_u *endp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1298 typval_T *rettv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1299 int copy, |
|
23917
4b417b776b95
patch 8.2.2501: not always clear where an error is reported
Bram Moolenaar <Bram@vim.org>
parents:
23835
diff
changeset
|
1300 int flags, // ASSIGN_CONST, ASSIGN_NO_DECL |
|
4b417b776b95
patch 8.2.2501: not always clear where an error is reported
Bram Moolenaar <Bram@vim.org>
parents:
23835
diff
changeset
|
1301 char_u *op, |
|
4b417b776b95
patch 8.2.2501: not always clear where an error is reported
Bram Moolenaar <Bram@vim.org>
parents:
23835
diff
changeset
|
1302 int var_idx) // index for "let [a, b] = list" |
| 110 | 1303 { |
| 1304 int cc; | |
| 137 | 1305 listitem_T *ri; |
| 1306 dictitem_T *di; | |
| 110 | 1307 |
| 1308 if (lp->ll_tv == NULL) | |
| 1309 { | |
|
10889
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1310 cc = *endp; |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1311 *endp = NUL; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1312 if (lp->ll_blob != NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1313 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1314 int error = FALSE, val; |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1315 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1316 if (op != NULL && *op != '=') |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1317 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1318 semsg(_(e_letwrong), op); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1319 return; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1320 } |
|
22298
07e48ee8c3bb
patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9
Bram Moolenaar <Bram@vim.org>
parents:
22272
diff
changeset
|
1321 if (value_check_lock(lp->ll_blob->bv_lock, lp->ll_name, FALSE)) |
|
21847
fb74a3387694
patch 8.2.1473: items in a list given to :const can still be modified
Bram Moolenaar <Bram@vim.org>
parents:
21837
diff
changeset
|
1322 return; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1323 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1324 if (lp->ll_range && rettv->v_type == VAR_BLOB) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1325 { |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1326 if (lp->ll_empty2) |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1327 lp->ll_n2 = blob_len(lp->ll_blob) - 1; |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1328 |
|
24434
602e528a8e43
patch 8.2.2757: Vim9: blob tests for legacy and Vim9 script are separate
Bram Moolenaar <Bram@vim.org>
parents:
24432
diff
changeset
|
1329 if (blob_set_range(lp->ll_blob, lp->ll_n1, lp->ll_n2, |
|
602e528a8e43
patch 8.2.2757: Vim9: blob tests for legacy and Vim9 script are separate
Bram Moolenaar <Bram@vim.org>
parents:
24432
diff
changeset
|
1330 rettv) == FAIL) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1331 return; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1332 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1333 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1334 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1335 val = (int)tv_get_number_chk(rettv, &error); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1336 if (!error) |
|
24486
5e0db87e5184
patch 8.2.2783: duplicate code for setting byte in blob, blob test may fail
Bram Moolenaar <Bram@vim.org>
parents:
24454
diff
changeset
|
1337 blob_set_append(lp->ll_blob, lp->ll_n1, val); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1338 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1339 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1340 else if (op != NULL && *op != '=') |
|
10889
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1341 { |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1342 typval_T tv; |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1343 |
|
24440
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1344 if ((flags & (ASSIGN_CONST | ASSIGN_FINAL)) |
|
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1345 && (flags & ASSIGN_FOR_LOOP) == 0) |
|
17079
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1346 { |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1347 emsg(_(e_cannot_mod)); |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1348 *endp = cc; |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1349 return; |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1350 } |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1351 |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1352 // handle +=, -=, *=, /=, %= and .= |
|
10889
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1353 di = NULL; |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
1354 if (eval_variable(lp->ll_name, (int)STRLEN(lp->ll_name), |
|
24112
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
1355 &tv, &di, EVAL_VAR_VERBOSE) == OK) |
|
10889
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1356 { |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1357 if ((di == NULL |
|
15780
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
1358 || (!var_check_ro(di->di_flags, lp->ll_name, FALSE) |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
1359 && !tv_check_lock(&di->di_tv, lp->ll_name, FALSE))) |
|
10889
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1360 && tv_op(&tv, rettv, op) == OK) |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1361 set_var(lp->ll_name, &tv, FALSE); |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1362 clear_tv(&tv); |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1363 } |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1364 } |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1365 else |
|
21443
66386ca8a69f
patch 8.2.1272: Vim9: type not checked if declaration also assigns value
Bram Moolenaar <Bram@vim.org>
parents:
21425
diff
changeset
|
1366 { |
|
66386ca8a69f
patch 8.2.1272: Vim9: type not checked if declaration also assigns value
Bram Moolenaar <Bram@vim.org>
parents:
21425
diff
changeset
|
1367 if (lp->ll_type != NULL |
|
23917
4b417b776b95
patch 8.2.2501: not always clear where an error is reported
Bram Moolenaar <Bram@vim.org>
parents:
23835
diff
changeset
|
1368 && check_typval_arg_type(lp->ll_type, rettv, 0) == FAIL) |
|
21443
66386ca8a69f
patch 8.2.1272: Vim9: type not checked if declaration also assigns value
Bram Moolenaar <Bram@vim.org>
parents:
21425
diff
changeset
|
1369 return; |
|
23917
4b417b776b95
patch 8.2.2501: not always clear where an error is reported
Bram Moolenaar <Bram@vim.org>
parents:
23835
diff
changeset
|
1370 set_var_const(lp->ll_name, lp->ll_type, rettv, copy, |
|
4b417b776b95
patch 8.2.2501: not always clear where an error is reported
Bram Moolenaar <Bram@vim.org>
parents:
23835
diff
changeset
|
1371 flags, var_idx); |
|
21443
66386ca8a69f
patch 8.2.1272: Vim9: type not checked if declaration also assigns value
Bram Moolenaar <Bram@vim.org>
parents:
21425
diff
changeset
|
1372 } |
|
10889
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1373 *endp = cc; |
| 110 | 1374 } |
|
22298
07e48ee8c3bb
patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9
Bram Moolenaar <Bram@vim.org>
parents:
22272
diff
changeset
|
1375 else if (value_check_lock(lp->ll_newkey == NULL |
| 151 | 1376 ? lp->ll_tv->v_lock |
| 6773 | 1377 : lp->ll_tv->vval.v_dict->dv_lock, lp->ll_name, FALSE)) |
| 151 | 1378 ; |
| 110 | 1379 else if (lp->ll_range) |
| 1380 { | |
| 6166 | 1381 listitem_T *ll_li = lp->ll_li; |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1382 int ll_n1 = lp->ll_n1; |
| 6166 | 1383 |
|
24440
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1384 if ((flags & (ASSIGN_CONST | ASSIGN_FINAL)) |
|
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1385 && (flags & ASSIGN_FOR_LOOP) == 0) |
|
17079
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1386 { |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1387 emsg(_("E996: Cannot lock a range")); |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1388 return; |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1389 } |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1390 |
| 6166 | 1391 /* |
| 1392 * Check whether any of the list items is locked | |
| 1393 */ | |
| 6422 | 1394 for (ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; ) |
| 6166 | 1395 { |
|
22298
07e48ee8c3bb
patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9
Bram Moolenaar <Bram@vim.org>
parents:
22272
diff
changeset
|
1396 if (value_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE)) |
| 6166 | 1397 return; |
| 1398 ri = ri->li_next; | |
| 1399 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == ll_n1)) | |
| 1400 break; | |
| 1401 ll_li = ll_li->li_next; | |
| 1402 ++ll_n1; | |
| 1403 } | |
| 1404 | |
| 110 | 1405 /* |
| 1406 * Assign the List values to the list items. | |
| 1407 */ | |
| 1408 for (ri = rettv->vval.v_list->lv_first; ri != NULL; ) | |
| 1409 { | |
| 117 | 1410 if (op != NULL && *op != '=') |
| 1411 tv_op(&lp->ll_li->li_tv, &ri->li_tv, op); | |
| 1412 else | |
| 1413 { | |
| 1414 clear_tv(&lp->ll_li->li_tv); | |
| 1415 copy_tv(&ri->li_tv, &lp->ll_li->li_tv); | |
| 1416 } | |
| 110 | 1417 ri = ri->li_next; |
| 1418 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == lp->ll_n1)) | |
| 1419 break; | |
| 1420 if (lp->ll_li->li_next == NULL) | |
| 1421 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1422 // Need to add an empty item. |
| 533 | 1423 if (list_append_number(lp->ll_list, 0) == FAIL) |
| 110 | 1424 { |
| 1425 ri = NULL; | |
| 88 | 1426 break; |
| 110 | 1427 } |
| 1428 } | |
| 1429 lp->ll_li = lp->ll_li->li_next; | |
| 1430 ++lp->ll_n1; | |
| 1431 } | |
| 1432 if (ri != NULL) | |
|
22975
a943b175586a
patch 8.2.2034: Vim9: list unpack in for statement not compiled yet
Bram Moolenaar <Bram@vim.org>
parents:
22963
diff
changeset
|
1433 emsg(_(e_list_value_has_more_items_than_targets)); |
| 117 | 1434 else if (lp->ll_empty2 |
| 1435 ? (lp->ll_li != NULL && lp->ll_li->li_next != NULL) | |
| 110 | 1436 : lp->ll_n1 != lp->ll_n2) |
|
22975
a943b175586a
patch 8.2.2034: Vim9: list unpack in for statement not compiled yet
Bram Moolenaar <Bram@vim.org>
parents:
22963
diff
changeset
|
1437 emsg(_(e_list_value_does_not_have_enough_items)); |
| 110 | 1438 } |
| 1439 else | |
| 1440 { | |
| 1441 /* | |
| 1442 * Assign to a List or Dictionary item. | |
| 1443 */ | |
|
24440
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1444 if ((flags & (ASSIGN_CONST | ASSIGN_FINAL)) |
|
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1445 && (flags & ASSIGN_FOR_LOOP) == 0) |
|
17079
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1446 { |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1447 emsg(_("E996: Cannot lock a list or dict")); |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1448 return; |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1449 } |
|
22529
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1450 |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1451 if (lp->ll_valtype != NULL |
|
23917
4b417b776b95
patch 8.2.2501: not always clear where an error is reported
Bram Moolenaar <Bram@vim.org>
parents:
23835
diff
changeset
|
1452 && check_typval_arg_type(lp->ll_valtype, rettv, 0) == FAIL) |
|
22529
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1453 return; |
|
35ef9b0a81a3
patch 8.2.1813: Vim9: can assign wrong type to script dict
Bram Moolenaar <Bram@vim.org>
parents:
22500
diff
changeset
|
1454 |
| 110 | 1455 if (lp->ll_newkey != NULL) |
| 1456 { | |
| 117 | 1457 if (op != NULL && *op != '=') |
| 1458 { | |
|
24363
1a145eb83a28
patch 8.2.2722: Vim9: crash when using LHS with double index
Bram Moolenaar <Bram@vim.org>
parents:
24343
diff
changeset
|
1459 semsg(_(e_dictkey), lp->ll_newkey); |
| 117 | 1460 return; |
| 1461 } | |
| 1462 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1463 // Need to add an item to the Dictionary. |
| 121 | 1464 di = dictitem_alloc(lp->ll_newkey); |
| 110 | 1465 if (di == NULL) |
| 1466 return; | |
| 121 | 1467 if (dict_add(lp->ll_tv->vval.v_dict, di) == FAIL) |
| 1468 { | |
| 1469 vim_free(di); | |
| 1470 return; | |
| 1471 } | |
| 110 | 1472 lp->ll_tv = &di->di_tv; |
| 1473 } | |
| 117 | 1474 else if (op != NULL && *op != '=') |
| 1475 { | |
| 1476 tv_op(lp->ll_tv, rettv, op); | |
| 1477 return; | |
| 1478 } | |
| 110 | 1479 else |
| 1480 clear_tv(lp->ll_tv); | |
| 1481 | |
| 1482 /* | |
| 1483 * Assign the value to the variable or list item. | |
| 1484 */ | |
| 1485 if (copy) | |
| 1486 copy_tv(rettv, lp->ll_tv); | |
| 1487 else | |
| 1488 { | |
| 1489 *lp->ll_tv = *rettv; | |
| 156 | 1490 lp->ll_tv->v_lock = 0; |
| 110 | 1491 init_tv(rettv); |
| 1492 } | |
| 1493 } | |
| 7 | 1494 } |
| 1495 | |
| 76 | 1496 /* |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1497 * Handle "tv1 += tv2", "tv1 -= tv2", "tv1 *= tv2", "tv1 /= tv2", "tv1 %= tv2" |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1498 * and "tv1 .= tv2" |
| 117 | 1499 * Returns OK or FAIL. |
| 1500 */ | |
| 1501 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1502 tv_op(typval_T *tv1, typval_T *tv2, char_u *op) |
| 117 | 1503 { |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
1504 varnumber_T n; |
| 117 | 1505 char_u numbuf[NUMBUFLEN]; |
| 1506 char_u *s; | |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
1507 int failed = FALSE; |
| 117 | 1508 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1509 // Can't do anything with a Funcref, Dict, v:true on the right. |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
1510 if (tv2->v_type != VAR_FUNC && tv2->v_type != VAR_DICT |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
1511 && tv2->v_type != VAR_BOOL && tv2->v_type != VAR_SPECIAL) |
| 117 | 1512 { |
| 1513 switch (tv1->v_type) | |
| 1514 { | |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
1515 case VAR_UNKNOWN: |
|
19922
1f42c49c3d29
patch 8.2.0517: Vim9: cannot separate "func" and "func(): void"
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
1516 case VAR_ANY: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1517 case VAR_VOID: |
| 117 | 1518 case VAR_DICT: |
| 1519 case VAR_FUNC: | |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
1520 case VAR_PARTIAL: |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
1521 case VAR_BOOL: |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
1522 case VAR_SPECIAL: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
1523 case VAR_JOB: |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
1524 case VAR_CHANNEL: |
|
24606
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
1525 case VAR_INSTR: |
| 117 | 1526 break; |
| 1527 | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1528 case VAR_BLOB: |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1529 if (*op != '+' || tv2->v_type != VAR_BLOB) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1530 break; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1531 // BLOB += BLOB |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1532 if (tv1->vval.v_blob != NULL && tv2->vval.v_blob != NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1533 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1534 blob_T *b1 = tv1->vval.v_blob; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1535 blob_T *b2 = tv2->vval.v_blob; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1536 int i, len = blob_len(b2); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1537 for (i = 0; i < len; i++) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1538 ga_append(&b1->bv_ga, blob_get(b2, i)); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1539 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1540 return OK; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1541 |
| 117 | 1542 case VAR_LIST: |
| 1543 if (*op != '+' || tv2->v_type != VAR_LIST) | |
| 1544 break; | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1545 // List += List |
|
22365
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1546 if (tv2->vval.v_list != NULL) |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1547 { |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1548 if (tv1->vval.v_list == NULL) |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1549 { |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1550 tv1->vval.v_list = tv2->vval.v_list; |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1551 ++tv1->vval.v_list->lv_refcount; |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1552 } |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1553 else |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1554 list_extend(tv1->vval.v_list, tv2->vval.v_list, NULL); |
|
a4866826cebc
patch 8.2.1731: Vim9: cannot use += to append to empty NULL list
Bram Moolenaar <Bram@vim.org>
parents:
22298
diff
changeset
|
1555 } |
| 117 | 1556 return OK; |
| 1557 | |
| 1558 case VAR_NUMBER: | |
| 1559 case VAR_STRING: | |
| 1560 if (tv2->v_type == VAR_LIST) | |
| 1561 break; | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1562 if (vim_strchr((char_u *)"+-*/%", *op) != NULL) |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1563 { |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1564 // nr += nr , nr -= nr , nr *=nr , nr /= nr , nr %= nr |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1565 n = tv_get_number(tv1); |
| 1624 | 1566 #ifdef FEAT_FLOAT |
| 1567 if (tv2->v_type == VAR_FLOAT) | |
| 1568 { | |
| 1569 float_T f = n; | |
| 1570 | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1571 if (*op == '%') |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1572 break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1573 switch (*op) |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1574 { |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1575 case '+': f += tv2->vval.v_float; break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1576 case '-': f -= tv2->vval.v_float; break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1577 case '*': f *= tv2->vval.v_float; break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1578 case '/': f /= tv2->vval.v_float; break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1579 } |
| 1624 | 1580 clear_tv(tv1); |
| 1581 tv1->v_type = VAR_FLOAT; | |
| 1582 tv1->vval.v_float = f; | |
| 1583 } | |
| 117 | 1584 else |
| 1624 | 1585 #endif |
| 1586 { | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1587 switch (*op) |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1588 { |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1589 case '+': n += tv_get_number(tv2); break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1590 case '-': n -= tv_get_number(tv2); break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1591 case '*': n *= tv_get_number(tv2); break; |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
1592 case '/': n = num_divide(n, tv_get_number(tv2), |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
1593 &failed); break; |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
1594 case '%': n = num_modulus(n, tv_get_number(tv2), |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
1595 &failed); break; |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1596 } |
| 1624 | 1597 clear_tv(tv1); |
| 1598 tv1->v_type = VAR_NUMBER; | |
| 1599 tv1->vval.v_number = n; | |
| 1600 } | |
| 1601 } | |
| 1602 else | |
| 1603 { | |
| 1604 if (tv2->v_type == VAR_FLOAT) | |
| 1605 break; | |
| 1606 | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1607 // str .= str |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1608 s = tv_get_string(tv1); |
|
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1609 s = concat_str(s, tv_get_string_buf(tv2, numbuf)); |
| 117 | 1610 clear_tv(tv1); |
| 1611 tv1->v_type = VAR_STRING; | |
| 1612 tv1->vval.v_string = s; | |
| 1613 } | |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
1614 return failed ? FAIL : OK; |
| 1624 | 1615 |
| 1616 case VAR_FLOAT: | |
|
8364
991d8fd4d841
commit https://github.com/vim/vim/commit/5fac467474376a844407cecc0ff481510ead221c
Christian Brabandt <cb@256bit.org>
parents:
8350
diff
changeset
|
1617 #ifdef FEAT_FLOAT |
| 1624 | 1618 { |
| 1619 float_T f; | |
| 1620 | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1621 if (*op == '%' || *op == '.' |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1622 || (tv2->v_type != VAR_FLOAT |
| 1624 | 1623 && tv2->v_type != VAR_NUMBER |
| 1624 && tv2->v_type != VAR_STRING)) | |
| 1625 break; | |
| 1626 if (tv2->v_type == VAR_FLOAT) | |
| 1627 f = tv2->vval.v_float; | |
| 1628 else | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1629 f = tv_get_number(tv2); |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1630 switch (*op) |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1631 { |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1632 case '+': tv1->vval.v_float += f; break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1633 case '-': tv1->vval.v_float -= f; break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1634 case '*': tv1->vval.v_float *= f; break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1635 case '/': tv1->vval.v_float /= f; break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1636 } |
| 1624 | 1637 } |
|
8364
991d8fd4d841
commit https://github.com/vim/vim/commit/5fac467474376a844407cecc0ff481510ead221c
Christian Brabandt <cb@256bit.org>
parents:
8350
diff
changeset
|
1638 #endif |
| 1624 | 1639 return OK; |
| 117 | 1640 } |
| 1641 } | |
| 1642 | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1643 semsg(_(e_letwrong), op); |
| 117 | 1644 return FAIL; |
| 1645 } | |
| 1646 | |
| 1647 /* | |
| 76 | 1648 * Evaluate the expression used in a ":for var in expr" command. |
| 1649 * "arg" points to "var". | |
| 1650 * Set "*errp" to TRUE for an error, FALSE otherwise; | |
| 1651 * Return a pointer that holds the info. Null when there is an error. | |
| 1652 */ | |
| 1653 void * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1654 eval_for_line( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1655 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1656 int *errp, |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
1657 exarg_T *eap, |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1658 evalarg_T *evalarg) |
| 76 | 1659 { |
| 137 | 1660 forinfo_T *fi; |
| 76 | 1661 char_u *expr; |
| 137 | 1662 typval_T tv; |
| 1663 list_T *l; | |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1664 int skip = !(evalarg->eval_flags & EVAL_EVALUATE); |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1665 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1666 *errp = TRUE; // default: there is an error |
| 76 | 1667 |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16796
diff
changeset
|
1668 fi = ALLOC_CLEAR_ONE(forinfo_T); |
| 76 | 1669 if (fi == NULL) |
| 1670 return NULL; | |
| 1671 | |
|
20859
876e16c48bd1
patch 8.2.0981: Vim9: cannot compile "[var, var] = list"
Bram Moolenaar <Bram@vim.org>
parents:
20751
diff
changeset
|
1672 expr = skip_var_list(arg, TRUE, &fi->fi_varcount, &fi->fi_semicolon, FALSE); |
| 76 | 1673 if (expr == NULL) |
| 1674 return fi; | |
| 1675 | |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1676 expr = skipwhite_and_linebreak(expr, evalarg); |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1677 if (expr[0] != 'i' || expr[1] != 'n' |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1678 || !(expr[2] == NUL || VIM_ISWHITE(expr[2]))) |
| 76 | 1679 { |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1680 emsg(_(e_missing_in)); |
| 76 | 1681 return fi; |
| 1682 } | |
| 1683 | |
| 1684 if (skip) | |
| 1685 ++emsg_skip; | |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1686 expr = skipwhite_and_linebreak(expr + 2, evalarg); |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1687 if (eval0(expr, &tv, eap, evalarg) == OK) |
| 76 | 1688 { |
| 1689 *errp = FALSE; | |
| 1690 if (!skip) | |
| 1691 { | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1692 if (tv.v_type == VAR_LIST) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1693 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1694 l = tv.vval.v_list; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1695 if (l == NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1696 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1697 // a null list is like an empty list: do nothing |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1698 clear_tv(&tv); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1699 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1700 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1701 { |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1702 // Need a real list here. |
|
20392
4c317d8c1051
patch 8.2.0751: Vim9: performance can be improved
Bram Moolenaar <Bram@vim.org>
parents:
20295
diff
changeset
|
1703 CHECK_LIST_MATERIALIZE(l); |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1704 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1705 // No need to increment the refcount, it's already set for |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1706 // the list being used in "tv". |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1707 fi->fi_list = l; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1708 list_add_watch(l, &fi->fi_lw); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1709 fi->fi_lw.lw_item = l->lv_first; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1710 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1711 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1712 else if (tv.v_type == VAR_BLOB) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1713 { |
|
15581
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1714 fi->fi_bi = 0; |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1715 if (tv.vval.v_blob != NULL) |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1716 { |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1717 typval_T btv; |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1718 |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1719 // Make a copy, so that the iteration still works when the |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1720 // blob is changed. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1721 blob_copy(tv.vval.v_blob, &btv); |
|
15581
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1722 fi->fi_blob = btv.vval.v_blob; |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1723 } |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1724 clear_tv(&tv); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1725 } |
|
24234
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1726 else if (tv.v_type == VAR_STRING) |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1727 { |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1728 fi->fi_byte_idx = 0; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1729 fi->fi_string = tv.vval.v_string; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1730 tv.vval.v_string = NULL; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1731 if (fi->fi_string == NULL) |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1732 fi->fi_string = vim_strsave((char_u *)""); |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1733 } |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1734 else |
| 359 | 1735 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1736 emsg(_(e_listreq)); |
| 359 | 1737 clear_tv(&tv); |
| 1738 } | |
| 76 | 1739 } |
| 1740 } | |
| 1741 if (skip) | |
| 1742 --emsg_skip; | |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1743 fi->fi_break_count = evalarg->eval_break_count; |
| 76 | 1744 |
| 1745 return fi; | |
| 1746 } | |
| 1747 | |
| 1748 /* | |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1749 * Used when looping over a :for line, skip the "in expr" part. |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1750 */ |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1751 void |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1752 skip_for_lines(void *fi_void, evalarg_T *evalarg) |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1753 { |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1754 forinfo_T *fi = (forinfo_T *)fi_void; |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1755 int i; |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1756 |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1757 for (i = 0; i < fi->fi_break_count; ++i) |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1758 eval_next_line(evalarg); |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1759 } |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1760 |
|
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
1761 /* |
| 76 | 1762 * Use the first item in a ":for" list. Advance to the next. |
| 1763 * Assign the values to the variable (list). "arg" points to the first one. | |
| 1764 * Return TRUE when a valid item was found, FALSE when at end of list or | |
| 1765 * something wrong. | |
| 1766 */ | |
| 1767 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1768 next_for_item(void *fi_void, char_u *arg) |
| 76 | 1769 { |
|
4974
a594ce86b5ea
updated for version 7.3.1232
Bram Moolenaar <bram@vim.org>
parents:
4936
diff
changeset
|
1770 forinfo_T *fi = (forinfo_T *)fi_void; |
| 76 | 1771 int result; |
|
24440
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1772 int flag = ASSIGN_FOR_LOOP | (in_vim9script() |
|
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1773 ? (ASSIGN_FINAL | ASSIGN_DECL | ASSIGN_NO_MEMBER_TYPE) |
|
d2f9bdd938fa
patch 8.2.2760: Vim9: no error for changing a for loop variable
Bram Moolenaar <Bram@vim.org>
parents:
24434
diff
changeset
|
1774 : 0); |
| 137 | 1775 listitem_T *item; |
| 76 | 1776 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1777 if (fi->fi_blob != NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1778 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1779 typval_T tv; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1780 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1781 if (fi->fi_bi >= blob_len(fi->fi_blob)) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1782 return FALSE; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1783 tv.v_type = VAR_NUMBER; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1784 tv.v_lock = VAR_FIXED; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1785 tv.vval.v_number = blob_get(fi->fi_blob, fi->fi_bi); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1786 ++fi->fi_bi; |
|
17079
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1787 return ex_let_vars(arg, &tv, TRUE, fi->fi_semicolon, |
|
24234
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1788 fi->fi_varcount, flag, NULL) == OK; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1789 } |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1790 |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1791 if (fi->fi_string != NULL) |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1792 { |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1793 typval_T tv; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1794 int len; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1795 |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1796 len = mb_ptr2len(fi->fi_string + fi->fi_byte_idx); |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1797 if (len == 0) |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1798 return FALSE; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1799 tv.v_type = VAR_STRING; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1800 tv.v_lock = VAR_FIXED; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1801 tv.vval.v_string = vim_strnsave(fi->fi_string + fi->fi_byte_idx, len); |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1802 fi->fi_byte_idx += len; |
|
24240
2194227d034a
patch 8.2.2661: leaking memory when looping over a string
Bram Moolenaar <Bram@vim.org>
parents:
24234
diff
changeset
|
1803 result = ex_let_vars(arg, &tv, TRUE, fi->fi_semicolon, |
|
24234
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1804 fi->fi_varcount, flag, NULL) == OK; |
|
24240
2194227d034a
patch 8.2.2661: leaking memory when looping over a string
Bram Moolenaar <Bram@vim.org>
parents:
24234
diff
changeset
|
1805 vim_free(tv.vval.v_string); |
|
2194227d034a
patch 8.2.2661: leaking memory when looping over a string
Bram Moolenaar <Bram@vim.org>
parents:
24234
diff
changeset
|
1806 return result; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1807 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1808 |
| 76 | 1809 item = fi->fi_lw.lw_item; |
| 1810 if (item == NULL) | |
| 1811 result = FALSE; | |
| 1812 else | |
| 1813 { | |
| 1814 fi->fi_lw.lw_item = item->li_next; | |
|
17079
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1815 result = (ex_let_vars(arg, &item->li_tv, TRUE, fi->fi_semicolon, |
|
24234
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1816 fi->fi_varcount, flag, NULL) == OK); |
| 76 | 1817 } |
| 1818 return result; | |
| 1819 } | |
| 1820 | |
| 1821 /* | |
| 1822 * Free the structure used to store info used by ":for". | |
| 1823 */ | |
| 1824 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1825 free_for_info(void *fi_void) |
| 76 | 1826 { |
| 137 | 1827 forinfo_T *fi = (forinfo_T *)fi_void; |
| 76 | 1828 |
|
24234
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1829 if (fi == NULL) |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1830 return; |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1831 if (fi->fi_list != NULL) |
| 359 | 1832 { |
| 76 | 1833 list_rem_watch(fi->fi_list, &fi->fi_lw); |
| 359 | 1834 list_unref(fi->fi_list); |
| 1835 } | |
|
24234
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1836 else if (fi->fi_blob != NULL) |
|
15460
543cff56dd3f
patch 8.1.0738: using freed memory, for loop over blob leaks memory
Bram Moolenaar <Bram@vim.org>
parents:
15458
diff
changeset
|
1837 blob_unref(fi->fi_blob); |
|
24234
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1838 else |
|
7ffc795288dd
patch 8.2.2658: :for cannot loop over a string
Bram Moolenaar <Bram@vim.org>
parents:
24194
diff
changeset
|
1839 vim_free(fi->fi_string); |
| 76 | 1840 vim_free(fi); |
| 1841 } | |
| 1842 | |
| 7 | 1843 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1844 set_context_for_expression( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1845 expand_T *xp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1846 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1847 cmdidx_T cmdidx) |
| 7 | 1848 { |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22365
diff
changeset
|
1849 int has_expr = cmdidx != CMD_let && cmdidx != CMD_var; |
| 7 | 1850 int c; |
| 76 | 1851 char_u *p; |
| 1852 | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22365
diff
changeset
|
1853 if (cmdidx == CMD_let || cmdidx == CMD_var |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22365
diff
changeset
|
1854 || cmdidx == CMD_const || cmdidx == CMD_final) |
| 76 | 1855 { |
| 1856 xp->xp_context = EXPAND_USER_VARS; | |
| 159 | 1857 if (vim_strpbrk(arg, (char_u *)"\"'+-*/%.=!?~|&$([<>,#") == NULL) |
| 76 | 1858 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1859 // ":let var1 var2 ...": find last space. |
| 159 | 1860 for (p = arg + STRLEN(arg); p >= arg; ) |
| 76 | 1861 { |
| 1862 xp->xp_pattern = p; | |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10964
diff
changeset
|
1863 MB_PTR_BACK(arg, p); |
|
11129
f4ea50924c6d
patch 8.0.0452: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11127
diff
changeset
|
1864 if (VIM_ISWHITE(*p)) |
| 76 | 1865 break; |
| 1866 } | |
| 1867 return; | |
| 1868 } | |
| 1869 } | |
| 1870 else | |
| 1871 xp->xp_context = cmdidx == CMD_call ? EXPAND_FUNCTIONS | |
| 1872 : EXPAND_EXPRESSION; | |
| 7 | 1873 while ((xp->xp_pattern = vim_strpbrk(arg, |
| 1874 (char_u *)"\"'+-*/%.=!?~|&$([<>,#")) != NULL) | |
| 1875 { | |
| 1876 c = *xp->xp_pattern; | |
| 1877 if (c == '&') | |
| 1878 { | |
| 1879 c = xp->xp_pattern[1]; | |
| 1880 if (c == '&') | |
| 1881 { | |
| 1882 ++xp->xp_pattern; | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22365
diff
changeset
|
1883 xp->xp_context = has_expr ? EXPAND_EXPRESSION : EXPAND_NOTHING; |
| 7 | 1884 } |
| 1885 else if (c != ' ') | |
| 201 | 1886 { |
| 7 | 1887 xp->xp_context = EXPAND_SETTINGS; |
| 201 | 1888 if ((c == 'l' || c == 'g') && xp->xp_pattern[2] == ':') |
| 1889 xp->xp_pattern += 2; | |
| 1890 | |
| 1891 } | |
| 7 | 1892 } |
| 1893 else if (c == '$') | |
| 1894 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1895 // environment variable |
| 7 | 1896 xp->xp_context = EXPAND_ENV_VARS; |
| 1897 } | |
| 1898 else if (c == '=') | |
| 1899 { | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22365
diff
changeset
|
1900 has_expr = TRUE; |
| 7 | 1901 xp->xp_context = EXPAND_EXPRESSION; |
| 1902 } | |
|
8763
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1903 else if (c == '#' |
|
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1904 && xp->xp_context == EXPAND_EXPRESSION) |
|
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1905 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1906 // Autoload function/variable contains '#'. |
|
8763
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1907 break; |
|
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1908 } |
| 6367 | 1909 else if ((c == '<' || c == '#') |
| 7 | 1910 && xp->xp_context == EXPAND_FUNCTIONS |
| 1911 && vim_strchr(xp->xp_pattern, '(') == NULL) | |
| 1912 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1913 // Function name can start with "<SNR>" and contain '#'. |
| 7 | 1914 break; |
| 1915 } | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22365
diff
changeset
|
1916 else if (has_expr) |
| 7 | 1917 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1918 if (c == '"') // string |
| 7 | 1919 { |
| 1920 while ((c = *++xp->xp_pattern) != NUL && c != '"') | |
| 1921 if (c == '\\' && xp->xp_pattern[1] != NUL) | |
| 1922 ++xp->xp_pattern; | |
| 1923 xp->xp_context = EXPAND_NOTHING; | |
| 1924 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1925 else if (c == '\'') // literal string |
| 7 | 1926 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1927 // Trick: '' is like stopping and starting a literal string. |
| 7 | 1928 while ((c = *++xp->xp_pattern) != NUL && c != '\'') |
| 1929 /* skip */ ; | |
| 1930 xp->xp_context = EXPAND_NOTHING; | |
| 1931 } | |
| 1932 else if (c == '|') | |
| 1933 { | |
| 1934 if (xp->xp_pattern[1] == '|') | |
| 1935 { | |
| 1936 ++xp->xp_pattern; | |
| 1937 xp->xp_context = EXPAND_EXPRESSION; | |
| 1938 } | |
| 1939 else | |
| 1940 xp->xp_context = EXPAND_COMMANDS; | |
| 1941 } | |
| 1942 else | |
| 1943 xp->xp_context = EXPAND_EXPRESSION; | |
| 1944 } | |
| 1945 else | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1946 // Doesn't look like something valid, expand as an expression |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1947 // anyway. |
| 76 | 1948 xp->xp_context = EXPAND_EXPRESSION; |
| 7 | 1949 arg = xp->xp_pattern; |
| 1950 if (*arg != NUL) | |
| 1951 while ((c = *++arg) != NUL && (c == ' ' || c == '\t')) | |
| 1952 /* skip */ ; | |
| 1953 } | |
|
23322
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1954 |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1955 // ":exe one two" completes "two" |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1956 if ((cmdidx == CMD_execute |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1957 || cmdidx == CMD_echo |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1958 || cmdidx == CMD_echon |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1959 || cmdidx == CMD_echomsg) |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1960 && xp->xp_context == EXPAND_EXPRESSION) |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1961 { |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1962 for (;;) |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1963 { |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1964 char_u *n = skiptowhite(arg); |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1965 |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1966 if (n == arg || IS_WHITE_OR_NUL(*skipwhite(n))) |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1967 break; |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1968 arg = skipwhite(n); |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1969 } |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1970 } |
|
68df9697667a
patch 8.2.2206: :exe command line completion only works for first argument
Bram Moolenaar <Bram@vim.org>
parents:
23299
diff
changeset
|
1971 |
| 7 | 1972 xp->xp_pattern = arg; |
| 1973 } | |
| 1974 | |
| 1975 /* | |
|
8749
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1976 * Return TRUE if "pat" matches "text". |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1977 * Does not use 'cpo' and always uses 'magic'. |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1978 */ |
|
17377
cb008de2a6ec
patch 8.1.1687: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17375
diff
changeset
|
1979 int |
|
8749
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1980 pattern_match(char_u *pat, char_u *text, int ic) |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1981 { |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1982 int matches = FALSE; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1983 char_u *save_cpo; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1984 regmatch_T regmatch; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1985 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1986 // avoid 'l' flag in 'cpoptions' |
|
8749
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1987 save_cpo = p_cpo; |
|
23493
f8382c4e6551
patch 8.2.2289: Vim9: 'cpo' can become empty
Bram Moolenaar <Bram@vim.org>
parents:
23450
diff
changeset
|
1988 p_cpo = empty_option; |
|
8749
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1989 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1990 if (regmatch.regprog != NULL) |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1991 { |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1992 regmatch.rm_ic = ic; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1993 matches = vim_regexec_nl(®match, text, (colnr_T)0); |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1994 vim_regfree(regmatch.regprog); |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1995 } |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1996 p_cpo = save_cpo; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1997 return matches; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1998 } |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1999 |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
2000 /* |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2001 * Handle a name followed by "(". Both for just "name(arg)" and for |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2002 * "expr->name(arg)". |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2003 * Returns OK or FAIL. |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2004 */ |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2005 static int |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2006 eval_func( |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2007 char_u **arg, // points to "(", will be advanced |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
2008 evalarg_T *evalarg, |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2009 char_u *name, |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2010 int name_len, |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2011 typval_T *rettv, |
|
20397
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
2012 int flags, |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2013 typval_T *basetv) // "expr" for "expr->name(arg)" |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2014 { |
|
20397
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
2015 int evaluate = flags & EVAL_EVALUATE; |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2016 char_u *s = name; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2017 int len = name_len; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2018 partial_T *partial; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2019 int ret = OK; |
|
23527
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
2020 type_T *type = NULL; |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2021 |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2022 if (!evaluate) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2023 check_vars(s, len); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2024 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2025 // If "s" is the name of a variable of type VAR_FUNC |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2026 // use its contents. |
|
23527
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
2027 s = deref_func_name(s, &len, &partial, |
|
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
2028 in_vim9script() ? &type : NULL, !evaluate); |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2029 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2030 // Need to make a copy, in case evaluating the arguments makes |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2031 // the name invalid. |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2032 s = vim_strsave(s); |
|
20397
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
2033 if (s == NULL || (flags & EVAL_CONSTANT)) |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2034 ret = FAIL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2035 else |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2036 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2037 funcexe_T funcexe; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2038 |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2039 // Invoke the function. |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
2040 CLEAR_FIELD(funcexe); |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2041 funcexe.firstline = curwin->w_cursor.lnum; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2042 funcexe.lastline = curwin->w_cursor.lnum; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2043 funcexe.evaluate = evaluate; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2044 funcexe.partial = partial; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2045 funcexe.basetv = basetv; |
|
23527
27ca5534a408
patch 8.2.2306: Vim9: when using function reference type is not checked
Bram Moolenaar <Bram@vim.org>
parents:
23525
diff
changeset
|
2046 funcexe.check_type = type; |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
2047 ret = get_func_tv(s, len, rettv, arg, evalarg, &funcexe); |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2048 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2049 vim_free(s); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2050 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2051 // If evaluate is FALSE rettv->v_type was not set in |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2052 // get_func_tv, but it's needed in handle_subscript() to parse |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2053 // what follows. So set it here. |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2054 if (rettv->v_type == VAR_UNKNOWN && !evaluate && **arg == '(') |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2055 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2056 rettv->vval.v_string = NULL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2057 rettv->v_type = VAR_FUNC; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2058 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2059 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2060 // Stop the expression evaluation when immediately |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2061 // aborting on error, or when an interrupt occurred or |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2062 // an exception was thrown but not caught. |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2063 if (evaluate && aborting()) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2064 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2065 if (ret == OK) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2066 clear_tv(rettv); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2067 ret = FAIL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2068 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2069 return ret; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2070 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2071 |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2072 /* |
|
22580
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2073 * Get the next line source line without advancing. But do skip over comment |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2074 * lines. |
|
24553
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2075 * Only called for Vim9 script. |
|
22580
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2076 */ |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2077 static char_u * |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2078 getline_peek_skip_comments(evalarg_T *evalarg) |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2079 { |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2080 for (;;) |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2081 { |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2082 char_u *next = getline_peek(evalarg->eval_getline, |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2083 evalarg->eval_cookie); |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2084 char_u *p; |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2085 |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2086 if (next == NULL) |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2087 break; |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2088 p = skipwhite(next); |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2089 if (*p != NUL && !vim9_comment_start(p)) |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2090 return next; |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2091 (void)eval_next_line(evalarg); |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2092 } |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2093 return NULL; |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2094 } |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2095 |
|
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2096 /* |
|
21148
667192c5938b
patch 8.2.1125: Vim9: double quote can be a string or a comment
Bram Moolenaar <Bram@vim.org>
parents:
21142
diff
changeset
|
2097 * If inside Vim9 script, "arg" points to the end of a line (ignoring a # |
|
667192c5938b
patch 8.2.1125: Vim9: double quote can be a string or a comment
Bram Moolenaar <Bram@vim.org>
parents:
21142
diff
changeset
|
2098 * comment) and there is a next line, return the next line (skipping blanks) |
|
667192c5938b
patch 8.2.1125: Vim9: double quote can be a string or a comment
Bram Moolenaar <Bram@vim.org>
parents:
21142
diff
changeset
|
2099 * and set "getnext". |
|
24525
887121a6d7cf
patch 8.2.2802: Vim9: illegal memory access
Bram Moolenaar <Bram@vim.org>
parents:
24518
diff
changeset
|
2100 * Otherwise return the next non-white at or after "arg" and set "getnext" to |
|
887121a6d7cf
patch 8.2.2802: Vim9: illegal memory access
Bram Moolenaar <Bram@vim.org>
parents:
24518
diff
changeset
|
2101 * FALSE. |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2102 * "arg" must point somewhere inside a line, not at the start. |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2103 */ |
|
21028
7acceb76669f
patch 8.2.1065: Vim9: no line break allowed inside a list
Bram Moolenaar <Bram@vim.org>
parents:
21026
diff
changeset
|
2104 char_u * |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2105 eval_next_non_blank(char_u *arg, evalarg_T *evalarg, int *getnext) |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2106 { |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2107 char_u *p = skipwhite(arg); |
|
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2108 |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2109 *getnext = FALSE; |
|
21279
8d1d11afd8c8
patch 8.2.1190: Vim9: checking for Vim9 syntax is spread out
Bram Moolenaar <Bram@vim.org>
parents:
21277
diff
changeset
|
2110 if (in_vim9script() |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2111 && evalarg != NULL |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
2112 && (evalarg->eval_cookie != NULL || evalarg->eval_cctx != NULL) |
|
24525
887121a6d7cf
patch 8.2.2802: Vim9: illegal memory access
Bram Moolenaar <Bram@vim.org>
parents:
24518
diff
changeset
|
2113 && (*p == NUL || (vim9_comment_start(p) && VIM_ISWHITE(p[-1])))) |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2114 { |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2115 char_u *next; |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
2116 |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
2117 if (evalarg->eval_cookie != NULL) |
|
22580
eb54d34ecd27
patch 8.2.1838: Vim9: cannot insert a comment line in an expression
Bram Moolenaar <Bram@vim.org>
parents:
22541
diff
changeset
|
2118 next = getline_peek_skip_comments(evalarg); |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
2119 else |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2120 next = peek_next_line_from_context(evalarg->eval_cctx); |
|
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2121 |
|
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2122 if (next != NULL) |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2123 { |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2124 *getnext = TRUE; |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2125 return skipwhite(next); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2126 } |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2127 } |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2128 return p; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2129 } |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2130 |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2131 /* |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2132 * To be called after eval_next_non_blank() sets "getnext" to TRUE. |
|
24553
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2133 * Only called for Vim9 script. |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2134 */ |
|
21028
7acceb76669f
patch 8.2.1065: Vim9: no line break allowed inside a list
Bram Moolenaar <Bram@vim.org>
parents:
21026
diff
changeset
|
2135 char_u * |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2136 eval_next_line(evalarg_T *evalarg) |
|
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2137 { |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2138 garray_T *gap = &evalarg->eval_ga; |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2139 char_u *line; |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2140 |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
2141 if (evalarg->eval_cookie != NULL) |
|
21889
e7e485a60caf
patch 8.2.1494: missing change to calling eval_getline()
Bram Moolenaar <Bram@vim.org>
parents:
21865
diff
changeset
|
2142 line = evalarg->eval_getline(0, evalarg->eval_cookie, 0, |
|
e7e485a60caf
patch 8.2.1494: missing change to calling eval_getline()
Bram Moolenaar <Bram@vim.org>
parents:
21865
diff
changeset
|
2143 GETLINE_CONCAT_ALL); |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
2144 else |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
2145 line = next_line_from_context(evalarg->eval_cctx, TRUE); |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
2146 ++evalarg->eval_break_count; |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2147 if (gap->ga_itemsize > 0 && ga_grow(gap, 1) == OK) |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2148 { |
|
24553
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2149 char_u *p = skipwhite(line); |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2150 |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2151 // Going to concatenate the lines after parsing. For an empty or |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2152 // comment line use an empty string. |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2153 if (*p == NUL || vim9_comment_start(p)) |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2154 { |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2155 vim_free(line); |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2156 line = vim_strsave((char_u *)""); |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2157 } |
|
cb0d344bd381
patch 8.2.2816: Vim9: comment below expression in lambda causes problems
Bram Moolenaar <Bram@vim.org>
parents:
24533
diff
changeset
|
2158 |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2159 ((char_u **)gap->ga_data)[gap->ga_len] = line; |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2160 ++gap->ga_len; |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2161 } |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2162 else if (evalarg->eval_cookie != NULL) |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2163 { |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2164 vim_free(evalarg->eval_tofree); |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2165 evalarg->eval_tofree = line; |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2166 } |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
2167 return skipwhite(line); |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2168 } |
|
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2169 |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
2170 /* |
|
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
2171 * Call eval_next_non_blank() and get the next line if needed. |
|
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
2172 */ |
|
21046
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2173 char_u * |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2174 skipwhite_and_linebreak(char_u *arg, evalarg_T *evalarg) |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2175 { |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2176 int getnext; |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2177 char_u *p = skipwhite(arg); |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2178 |
|
21148
667192c5938b
patch 8.2.1125: Vim9: double quote can be a string or a comment
Bram Moolenaar <Bram@vim.org>
parents:
21142
diff
changeset
|
2179 if (evalarg == NULL) |
|
667192c5938b
patch 8.2.1125: Vim9: double quote can be a string or a comment
Bram Moolenaar <Bram@vim.org>
parents:
21142
diff
changeset
|
2180 return skipwhite(arg); |
|
21046
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2181 eval_next_non_blank(p, evalarg, &getnext); |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2182 if (getnext) |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2183 return eval_next_line(evalarg); |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2184 return p; |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2185 } |
|
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2186 |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2187 /* |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2188 * After using "evalarg" filled from "eap": free the memory. |
|
21050
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2189 */ |
|
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2190 void |
|
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2191 clear_evalarg(evalarg_T *evalarg, exarg_T *eap) |
|
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2192 { |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2193 if (evalarg != NULL) |
|
21050
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2194 { |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2195 if (evalarg->eval_tofree != NULL) |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
2196 { |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2197 if (eap != NULL) |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2198 { |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2199 // We may need to keep the original command line, e.g. for |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2200 // ":let" it has the variable names. But we may also need the |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2201 // new one, "nextcmd" points into it. Keep both. |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2202 vim_free(eap->cmdline_tofree); |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2203 eap->cmdline_tofree = *eap->cmdlinep; |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2204 *eap->cmdlinep = evalarg->eval_tofree; |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2205 } |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2206 else |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2207 vim_free(evalarg->eval_tofree); |
|
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2208 evalarg->eval_tofree = NULL; |
|
21058
111f877e63d9
patch 8.2.1080: Vim9: no line break allowed in a for loop
Bram Moolenaar <Bram@vim.org>
parents:
21056
diff
changeset
|
2209 } |
|
21220
ad13736a1783
patch 8.2.1161: Vim9: using freed memory
Bram Moolenaar <Bram@vim.org>
parents:
21208
diff
changeset
|
2210 |
|
24190
5f3a2d31c48d
patch 8.2.2636: memory leak when compiling inline function
Bram Moolenaar <Bram@vim.org>
parents:
24174
diff
changeset
|
2211 VIM_CLEAR(evalarg->eval_tofree_cmdline); |
|
5f3a2d31c48d
patch 8.2.2636: memory leak when compiling inline function
Bram Moolenaar <Bram@vim.org>
parents:
24174
diff
changeset
|
2212 VIM_CLEAR(evalarg->eval_tofree_lambda); |
|
21050
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2213 } |
|
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2214 } |
|
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2215 |
|
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
2216 /* |
| 7 | 2217 * The "evaluate" argument: When FALSE, the argument is only parsed but not |
| 71 | 2218 * executed. The function may return OK, but the rettv will be of type |
| 7 | 2219 * VAR_UNKNOWN. The function still returns FAIL for a syntax error. |
| 2220 */ | |
| 2221 | |
| 2222 /* | |
| 2223 * Handle zero level expression. | |
| 2224 * This calls eval1() and handles error message and nextcmd. | |
| 71 | 2225 * Put the result in "rettv" when returning OK and "evaluate" is TRUE. |
| 533 | 2226 * Note: "rettv.v_lock" is not set. |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2227 * "evalarg" can be NULL, EVALARG_EVALUATE or a pointer. |
| 7 | 2228 * Return OK or FAIL. |
| 2229 */ | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
2230 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2231 eval0( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2232 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2233 typval_T *rettv, |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2234 exarg_T *eap, |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2235 evalarg_T *evalarg) |
| 7 | 2236 { |
| 2237 int ret; | |
| 2238 char_u *p; | |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
2239 int did_emsg_before = did_emsg; |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
2240 int called_emsg_before = called_emsg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2241 int flags = evalarg == NULL ? 0 : evalarg->eval_flags; |
| 7 | 2242 |
| 2243 p = skipwhite(arg); | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2244 ret = eval1(&p, rettv, evalarg); |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2245 p = skipwhite(p); |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2246 |
|
20111
f40231487a49
patch 8.2.0611: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20091
diff
changeset
|
2247 if (ret == FAIL || !ends_excmd2(arg, p)) |
| 7 | 2248 { |
| 2249 if (ret != FAIL) | |
| 71 | 2250 clear_tv(rettv); |
| 7 | 2251 /* |
| 2252 * Report the invalid expression unless the expression evaluation has | |
| 2253 * been cancelled due to an aborting error, an interrupt, or an | |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
2254 * exception, or we already gave a more specific error. |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
2255 * Also check called_emsg for when using assert_fails(). |
| 7 | 2256 */ |
|
20397
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
2257 if (!aborting() |
|
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
2258 && did_emsg == did_emsg_before |
|
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
2259 && called_emsg == called_emsg_before |
|
24174
99bfaa4693db
patch 8.2.2628: Vim9: #{ can still be used at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24112
diff
changeset
|
2260 && (flags & EVAL_CONSTANT) == 0 |
|
99bfaa4693db
patch 8.2.2628: Vim9: #{ can still be used at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24112
diff
changeset
|
2261 && (!in_vim9script() || !vim9_bad_comment(p))) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
2262 semsg(_(e_invexpr2), arg); |
|
23096
b6aadb0b3a56
patch 8.2.2094: when an expression fails getting next command may be wrong
Bram Moolenaar <Bram@vim.org>
parents:
23072
diff
changeset
|
2263 |
|
b6aadb0b3a56
patch 8.2.2094: when an expression fails getting next command may be wrong
Bram Moolenaar <Bram@vim.org>
parents:
23072
diff
changeset
|
2264 // Some of the expression may not have been consumed. Do not check for |
|
23191
3e7723bab4e5
patch 8.2.2141: a user command with try/catch may not catch an expression error
Bram Moolenaar <Bram@vim.org>
parents:
23096
diff
changeset
|
2265 // a next command to avoid more errors, unless "|" is following, which |
|
3e7723bab4e5
patch 8.2.2141: a user command with try/catch may not catch an expression error
Bram Moolenaar <Bram@vim.org>
parents:
23096
diff
changeset
|
2266 // could only be a command separator. |
|
3e7723bab4e5
patch 8.2.2141: a user command with try/catch may not catch an expression error
Bram Moolenaar <Bram@vim.org>
parents:
23096
diff
changeset
|
2267 if (eap != NULL && skipwhite(p)[0] == '|' && skipwhite(p)[1] != '|') |
|
3e7723bab4e5
patch 8.2.2141: a user command with try/catch may not catch an expression error
Bram Moolenaar <Bram@vim.org>
parents:
23096
diff
changeset
|
2268 eap->nextcmd = check_nextcmd(p); |
|
23096
b6aadb0b3a56
patch 8.2.2094: when an expression fails getting next command may be wrong
Bram Moolenaar <Bram@vim.org>
parents:
23072
diff
changeset
|
2269 return FAIL; |
| 7 | 2270 } |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2271 |
|
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2272 if (eap != NULL) |
|
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2273 eap->nextcmd = check_nextcmd(p); |
|
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2274 |
| 7 | 2275 return ret; |
| 2276 } | |
| 2277 | |
| 2278 /* | |
| 2279 * Handle top level expression: | |
| 1800 | 2280 * expr2 ? expr1 : expr1 |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2281 * expr2 ?? expr1 |
| 7 | 2282 * |
| 2283 * "arg" must point to the first non-white of the expression. | |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2284 * "arg" is advanced to just after the recognized expression. |
| 7 | 2285 * |
| 533 | 2286 * Note: "rettv.v_lock" is not set. |
| 2287 * | |
| 7 | 2288 * Return OK or FAIL. |
| 2289 */ | |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
2290 int |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2291 eval1(char_u **arg, typval_T *rettv, evalarg_T *evalarg) |
| 7 | 2292 { |
|
21022
9d8634e91d1b
patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2"
Bram Moolenaar <Bram@vim.org>
parents:
21002
diff
changeset
|
2293 char_u *p; |
|
9d8634e91d1b
patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2"
Bram Moolenaar <Bram@vim.org>
parents:
21002
diff
changeset
|
2294 int getnext; |
|
9d8634e91d1b
patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2"
Bram Moolenaar <Bram@vim.org>
parents:
21002
diff
changeset
|
2295 |
|
22246
6f83d2adee74
patch 8.2.1672: v_lock is used when it is not initialized
Bram Moolenaar <Bram@vim.org>
parents:
22244
diff
changeset
|
2296 CLEAR_POINTER(rettv); |
|
6f83d2adee74
patch 8.2.1672: v_lock is used when it is not initialized
Bram Moolenaar <Bram@vim.org>
parents:
22244
diff
changeset
|
2297 |
| 7 | 2298 /* |
| 2299 * Get the first variable. | |
| 2300 */ | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2301 if (eval2(arg, rettv, evalarg) == FAIL) |
| 7 | 2302 return FAIL; |
| 2303 | |
|
21022
9d8634e91d1b
patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2"
Bram Moolenaar <Bram@vim.org>
parents:
21002
diff
changeset
|
2304 p = eval_next_non_blank(*arg, evalarg, &getnext); |
|
9d8634e91d1b
patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2"
Bram Moolenaar <Bram@vim.org>
parents:
21002
diff
changeset
|
2305 if (*p == '?') |
| 7 | 2306 { |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2307 int op_falsy = p[1] == '?'; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2308 int result; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2309 typval_T var2; |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2310 evalarg_T *evalarg_used = evalarg; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2311 evalarg_T local_evalarg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2312 int orig_flags; |
|
21002
4852db420162
patch 8.2.1052: build failure with older compilers
Bram Moolenaar <Bram@vim.org>
parents:
20996
diff
changeset
|
2313 int evaluate; |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
2314 int vim9script = in_vim9script(); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2315 |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2316 if (evalarg == NULL) |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2317 { |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2318 CLEAR_FIELD(local_evalarg); |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2319 evalarg_used = &local_evalarg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2320 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2321 orig_flags = evalarg_used->eval_flags; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2322 evaluate = evalarg_used->eval_flags & EVAL_EVALUATE; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2323 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2324 if (getnext) |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2325 *arg = eval_next_line(evalarg_used); |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2326 else |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2327 { |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
2328 if (evaluate && vim9script && !VIM_ISWHITE(p[-1])) |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2329 { |
|
24339
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
2330 error_white_both(p, op_falsy ? 2 : 1); |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2331 clear_tv(rettv); |
|
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2332 return FAIL; |
|
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2333 } |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2334 *arg = p; |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2335 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2336 |
| 7 | 2337 result = FALSE; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2338 if (evaluate) |
| 7 | 2339 { |
| 323 | 2340 int error = FALSE; |
| 2341 | |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
2342 if (op_falsy) |
|
21831
d8422de73113
patch 8.2.1465: Vim9: subscript not handled properly
Bram Moolenaar <Bram@vim.org>
parents:
21828
diff
changeset
|
2343 result = tv2bool(rettv); |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
2344 else if (vim9script) |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
2345 result = tv_get_bool_chk(rettv, &error); |
|
21831
d8422de73113
patch 8.2.1465: Vim9: subscript not handled properly
Bram Moolenaar <Bram@vim.org>
parents:
21828
diff
changeset
|
2346 else if (tv_get_number_chk(rettv, &error) != 0) |
| 7 | 2347 result = TRUE; |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2348 if (error || !op_falsy || !result) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2349 clear_tv(rettv); |
| 323 | 2350 if (error) |
| 2351 return FAIL; | |
| 7 | 2352 } |
| 2353 | |
| 2354 /* | |
|
20397
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
2355 * Get the second variable. Recursive! |
| 7 | 2356 */ |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2357 if (op_falsy) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2358 ++*arg; |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
2359 if (evaluate && vim9script && !IS_WHITE_OR_NUL((*arg)[1])) |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2360 { |
|
24339
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
2361 error_white_both(p, op_falsy ? 2 : 1); |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2362 clear_tv(rettv); |
|
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2363 return FAIL; |
|
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2364 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2365 *arg = skipwhite_and_linebreak(*arg + 1, evalarg_used); |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2366 evalarg_used->eval_flags = (op_falsy ? !result : result) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2367 ? orig_flags : orig_flags & ~EVAL_EVALUATE; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2368 if (eval1(arg, &var2, evalarg_used) == FAIL) |
|
21925
51d591dbb8df
patch 8.2.1512: failure after trinary expression fails
Bram Moolenaar <Bram@vim.org>
parents:
21915
diff
changeset
|
2369 { |
|
51d591dbb8df
patch 8.2.1512: failure after trinary expression fails
Bram Moolenaar <Bram@vim.org>
parents:
21915
diff
changeset
|
2370 evalarg_used->eval_flags = orig_flags; |
| 7 | 2371 return FAIL; |
|
21925
51d591dbb8df
patch 8.2.1512: failure after trinary expression fails
Bram Moolenaar <Bram@vim.org>
parents:
21915
diff
changeset
|
2372 } |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2373 if (!op_falsy || !result) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2374 *rettv = var2; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2375 |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2376 if (!op_falsy) |
| 7 | 2377 { |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2378 /* |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2379 * Check for the ":". |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2380 */ |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2381 p = eval_next_non_blank(*arg, evalarg_used, &getnext); |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2382 if (*p != ':') |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2383 { |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2384 emsg(_(e_missing_colon)); |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2385 if (evaluate && result) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2386 clear_tv(rettv); |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2387 evalarg_used->eval_flags = orig_flags; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2388 return FAIL; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2389 } |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2390 if (getnext) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2391 *arg = eval_next_line(evalarg_used); |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2392 else |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2393 { |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
2394 if (evaluate && vim9script && !VIM_ISWHITE(p[-1])) |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2395 { |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2396 error_white_both(p, 1); |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2397 clear_tv(rettv); |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2398 evalarg_used->eval_flags = orig_flags; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2399 return FAIL; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2400 } |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2401 *arg = p; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2402 } |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2403 |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2404 /* |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2405 * Get the third variable. Recursive! |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2406 */ |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
2407 if (evaluate && vim9script && !IS_WHITE_OR_NUL((*arg)[1])) |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2408 { |
|
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2409 error_white_both(p, 1); |
|
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2410 clear_tv(rettv); |
|
21925
51d591dbb8df
patch 8.2.1512: failure after trinary expression fails
Bram Moolenaar <Bram@vim.org>
parents:
21915
diff
changeset
|
2411 evalarg_used->eval_flags = orig_flags; |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2412 return FAIL; |
|
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2413 } |
|
22492
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2414 *arg = skipwhite_and_linebreak(*arg + 1, evalarg_used); |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2415 evalarg_used->eval_flags = !result ? orig_flags |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2416 : orig_flags & ~EVAL_EVALUATE; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2417 if (eval1(arg, &var2, evalarg_used) == FAIL) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2418 { |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2419 if (evaluate && result) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2420 clear_tv(rettv); |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2421 evalarg_used->eval_flags = orig_flags; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2422 return FAIL; |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2423 } |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2424 if (evaluate && !result) |
|
0e03ef68e738
patch 8.2.1794: no falsy Coalescing operator
Bram Moolenaar <Bram@vim.org>
parents:
22391
diff
changeset
|
2425 *rettv = var2; |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2426 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2427 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2428 if (evalarg == NULL) |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2429 clear_evalarg(&local_evalarg, NULL); |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2430 else |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2431 evalarg->eval_flags = orig_flags; |
| 7 | 2432 } |
| 2433 | |
| 2434 return OK; | |
| 2435 } | |
| 2436 | |
| 2437 /* | |
| 2438 * Handle first level expression: | |
| 2439 * expr2 || expr2 || expr2 logical OR | |
| 2440 * | |
| 2441 * "arg" must point to the first non-white of the expression. | |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2442 * "arg" is advanced to just after the recognized expression. |
| 7 | 2443 * |
| 2444 * Return OK or FAIL. | |
| 2445 */ | |
| 2446 static int | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2447 eval2(char_u **arg, typval_T *rettv, evalarg_T *evalarg) |
| 7 | 2448 { |
|
21024
02b03915855d
patch 8.2.1063: Vim9: no line break allowed before || or &&
Bram Moolenaar <Bram@vim.org>
parents:
21022
diff
changeset
|
2449 char_u *p; |
|
02b03915855d
patch 8.2.1063: Vim9: no line break allowed before || or &&
Bram Moolenaar <Bram@vim.org>
parents:
21022
diff
changeset
|
2450 int getnext; |
| 7 | 2451 |
| 2452 /* | |
| 2453 * Get the first variable. | |
| 2454 */ | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2455 if (eval3(arg, rettv, evalarg) == FAIL) |
| 7 | 2456 return FAIL; |
| 2457 | |
| 2458 /* | |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2459 * Handle the "||" operator. |
| 7 | 2460 */ |
|
21024
02b03915855d
patch 8.2.1063: Vim9: no line break allowed before || or &&
Bram Moolenaar <Bram@vim.org>
parents:
21022
diff
changeset
|
2461 p = eval_next_non_blank(*arg, evalarg, &getnext); |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2462 if (p[0] == '|' && p[1] == '|') |
| 7 | 2463 { |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2464 evalarg_T *evalarg_used = evalarg; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2465 evalarg_T local_evalarg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2466 int evaluate; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2467 int orig_flags; |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2468 long result = FALSE; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2469 typval_T var2; |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2470 int error = FALSE; |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2471 int vim9script = in_vim9script(); |
|
21024
02b03915855d
patch 8.2.1063: Vim9: no line break allowed before || or &&
Bram Moolenaar <Bram@vim.org>
parents:
21022
diff
changeset
|
2472 |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2473 if (evalarg == NULL) |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2474 { |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2475 CLEAR_FIELD(local_evalarg); |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2476 evalarg_used = &local_evalarg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2477 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2478 orig_flags = evalarg_used->eval_flags; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2479 evaluate = orig_flags & EVAL_EVALUATE; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2480 if (evaluate) |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2481 { |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2482 if (vim9script) |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2483 result = tv_get_bool_chk(rettv, &error); |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2484 else if (tv_get_number_chk(rettv, &error) != 0) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2485 result = TRUE; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2486 clear_tv(rettv); |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2487 if (error) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2488 return FAIL; |
| 7 | 2489 } |
| 2490 | |
| 2491 /* | |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2492 * Repeat until there is no following "||". |
| 7 | 2493 */ |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2494 while (p[0] == '|' && p[1] == '|') |
| 7 | 2495 { |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2496 if (getnext) |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2497 *arg = eval_next_line(evalarg_used); |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2498 else |
|
21642
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2499 { |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2500 if (evaluate && in_vim9script() && !VIM_ISWHITE(p[-1])) |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2501 { |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2502 error_white_both(p, 2); |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2503 clear_tv(rettv); |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2504 return FAIL; |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2505 } |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2506 *arg = p; |
|
21642
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2507 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2508 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2509 /* |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2510 * Get the second variable. |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2511 */ |
|
21642
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2512 if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[2])) |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2513 { |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2514 error_white_both(p, 2); |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2515 clear_tv(rettv); |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2516 return FAIL; |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2517 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2518 *arg = skipwhite_and_linebreak(*arg + 2, evalarg_used); |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2519 evalarg_used->eval_flags = !result ? orig_flags |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2520 : orig_flags & ~EVAL_EVALUATE; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2521 if (eval3(arg, &var2, evalarg_used) == FAIL) |
| 323 | 2522 return FAIL; |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2523 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2524 /* |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2525 * Compute the result. |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2526 */ |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2527 if (evaluate && !result) |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2528 { |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2529 if (vim9script) |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2530 result = tv_get_bool_chk(&var2, &error); |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2531 else if (tv_get_number_chk(&var2, &error) != 0) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2532 result = TRUE; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2533 clear_tv(&var2); |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2534 if (error) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2535 return FAIL; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2536 } |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2537 if (evaluate) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2538 { |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2539 if (vim9script) |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2540 { |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2541 rettv->v_type = VAR_BOOL; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2542 rettv->vval.v_number = result ? VVAL_TRUE : VVAL_FALSE; |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2543 } |
|
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2544 else |
|
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2545 { |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2546 rettv->v_type = VAR_NUMBER; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2547 rettv->vval.v_number = result; |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2548 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2549 } |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2550 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2551 p = eval_next_non_blank(*arg, evalarg_used, &getnext); |
| 7 | 2552 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2553 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2554 if (evalarg == NULL) |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2555 clear_evalarg(&local_evalarg, NULL); |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2556 else |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2557 evalarg->eval_flags = orig_flags; |
| 7 | 2558 } |
| 2559 | |
| 2560 return OK; | |
| 2561 } | |
| 2562 | |
| 2563 /* | |
| 2564 * Handle second level expression: | |
| 2565 * expr3 && expr3 && expr3 logical AND | |
| 2566 * | |
| 2567 * "arg" must point to the first non-white of the expression. | |
|
21644
7d3ba70a03f1
patch 8.2.1372: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21642
diff
changeset
|
2568 * "arg" is advanced to just after the recognized expression. |
| 7 | 2569 * |
| 2570 * Return OK or FAIL. | |
| 2571 */ | |
| 2572 static int | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2573 eval3(char_u **arg, typval_T *rettv, evalarg_T *evalarg) |
| 7 | 2574 { |
|
21024
02b03915855d
patch 8.2.1063: Vim9: no line break allowed before || or &&
Bram Moolenaar <Bram@vim.org>
parents:
21022
diff
changeset
|
2575 char_u *p; |
|
02b03915855d
patch 8.2.1063: Vim9: no line break allowed before || or &&
Bram Moolenaar <Bram@vim.org>
parents:
21022
diff
changeset
|
2576 int getnext; |
| 7 | 2577 |
| 2578 /* | |
| 2579 * Get the first variable. | |
| 2580 */ | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2581 if (eval4(arg, rettv, evalarg) == FAIL) |
| 7 | 2582 return FAIL; |
| 2583 | |
| 2584 /* | |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2585 * Handle the "&&" operator. |
| 7 | 2586 */ |
|
21024
02b03915855d
patch 8.2.1063: Vim9: no line break allowed before || or &&
Bram Moolenaar <Bram@vim.org>
parents:
21022
diff
changeset
|
2587 p = eval_next_non_blank(*arg, evalarg, &getnext); |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2588 if (p[0] == '&' && p[1] == '&') |
| 7 | 2589 { |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2590 evalarg_T *evalarg_used = evalarg; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2591 evalarg_T local_evalarg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2592 int orig_flags; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2593 int evaluate; |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2594 long result = TRUE; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2595 typval_T var2; |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2596 int error = FALSE; |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2597 int vim9script = in_vim9script(); |
|
21024
02b03915855d
patch 8.2.1063: Vim9: no line break allowed before || or &&
Bram Moolenaar <Bram@vim.org>
parents:
21022
diff
changeset
|
2598 |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2599 if (evalarg == NULL) |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2600 { |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2601 CLEAR_FIELD(local_evalarg); |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2602 evalarg_used = &local_evalarg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2603 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2604 orig_flags = evalarg_used->eval_flags; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2605 evaluate = orig_flags & EVAL_EVALUATE; |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2606 if (evaluate) |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2607 { |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2608 if (vim9script) |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2609 result = tv_get_bool_chk(rettv, &error); |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2610 else if (tv_get_number_chk(rettv, &error) == 0) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2611 result = FALSE; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2612 clear_tv(rettv); |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2613 if (error) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2614 return FAIL; |
| 7 | 2615 } |
| 2616 | |
| 2617 /* | |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2618 * Repeat until there is no following "&&". |
| 7 | 2619 */ |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2620 while (p[0] == '&' && p[1] == '&') |
| 7 | 2621 { |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2622 if (getnext) |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2623 *arg = eval_next_line(evalarg_used); |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2624 else |
|
21642
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2625 { |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2626 if (evaluate && vim9script && !VIM_ISWHITE(p[-1])) |
|
21642
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2627 { |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2628 error_white_both(p, 2); |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2629 clear_tv(rettv); |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2630 return FAIL; |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2631 } |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2632 *arg = p; |
|
21642
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2633 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2634 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2635 /* |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2636 * Get the second variable. |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2637 */ |
|
21642
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2638 if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[2])) |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2639 { |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2640 error_white_both(p, 2); |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2641 clear_tv(rettv); |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2642 return FAIL; |
|
5ae89c8633ae
patch 8.2.1371: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21636
diff
changeset
|
2643 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2644 *arg = skipwhite_and_linebreak(*arg + 2, evalarg_used); |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2645 evalarg_used->eval_flags = result ? orig_flags |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2646 : orig_flags & ~EVAL_EVALUATE; |
|
22202
7899b4e2880c
patch 8.2.1650: Vim9: result of && and || expression is not bool in script
Bram Moolenaar <Bram@vim.org>
parents:
22021
diff
changeset
|
2647 CLEAR_FIELD(var2); |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2648 if (eval4(arg, &var2, evalarg_used) == FAIL) |
| 323 | 2649 return FAIL; |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2650 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2651 /* |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2652 * Compute the result. |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2653 */ |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2654 if (evaluate && result) |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2655 { |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2656 if (vim9script) |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2657 result = tv_get_bool_chk(&var2, &error); |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2658 else if (tv_get_number_chk(&var2, &error) == 0) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2659 result = FALSE; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2660 clear_tv(&var2); |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2661 if (error) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2662 return FAIL; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2663 } |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2664 if (evaluate) |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2665 { |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2666 if (vim9script) |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2667 { |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2668 rettv->v_type = VAR_BOOL; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2669 rettv->vval.v_number = result ? VVAL_TRUE : VVAL_FALSE; |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2670 } |
|
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2671 else |
|
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2672 { |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2673 rettv->v_type = VAR_NUMBER; |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22492
diff
changeset
|
2674 rettv->vval.v_number = result; |
|
21309
31a3f4d408b9
patch 8.2.1205: Vim9: && and || work different when not compiled
Bram Moolenaar <Bram@vim.org>
parents:
21307
diff
changeset
|
2675 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2676 } |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2677 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2678 p = eval_next_non_blank(*arg, evalarg_used, &getnext); |
| 7 | 2679 } |
|
21277
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2680 |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2681 if (evalarg == NULL) |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2682 clear_evalarg(&local_evalarg, NULL); |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2683 else |
|
1e5c29d4e5b3
patch 8.2.1189: Vim9: line continuation in lambda doesn't always work
Bram Moolenaar <Bram@vim.org>
parents:
21251
diff
changeset
|
2684 evalarg->eval_flags = orig_flags; |
| 7 | 2685 } |
| 2686 | |
| 2687 return OK; | |
| 2688 } | |
| 2689 | |
| 2690 /* | |
| 2691 * Handle third level expression: | |
| 2692 * var1 == var2 | |
| 2693 * var1 =~ var2 | |
| 2694 * var1 != var2 | |
| 2695 * var1 !~ var2 | |
| 2696 * var1 > var2 | |
| 2697 * var1 >= var2 | |
| 2698 * var1 < var2 | |
| 2699 * var1 <= var2 | |
| 80 | 2700 * var1 is var2 |
| 2701 * var1 isnot var2 | |
| 7 | 2702 * |
| 2703 * "arg" must point to the first non-white of the expression. | |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2704 * "arg" is advanced to just after the recognized expression. |
| 7 | 2705 * |
| 2706 * Return OK or FAIL. | |
| 2707 */ | |
| 2708 static int | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2709 eval4(char_u **arg, typval_T *rettv, evalarg_T *evalarg) |
| 7 | 2710 { |
| 2711 char_u *p; | |
|
21026
fe2ed85db946
patch 8.2.1064: Vim9: no line break allowed before comperators
Bram Moolenaar <Bram@vim.org>
parents:
21024
diff
changeset
|
2712 int getnext; |
|
23553
5c094273c015
patch 8.2.2319: "exptype_T" can be read as "expected type"
Bram Moolenaar <Bram@vim.org>
parents:
23551
diff
changeset
|
2713 exprtype_T type = EXPR_UNKNOWN; |
| 7 | 2714 int len = 2; |
|
21546
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2715 int type_is = FALSE; |
| 7 | 2716 |
| 2717 /* | |
| 2718 * Get the first variable. | |
| 2719 */ | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2720 if (eval5(arg, rettv, evalarg) == FAIL) |
| 7 | 2721 return FAIL; |
| 2722 | |
|
21026
fe2ed85db946
patch 8.2.1064: Vim9: no line break allowed before comperators
Bram Moolenaar <Bram@vim.org>
parents:
21024
diff
changeset
|
2723 p = eval_next_non_blank(*arg, evalarg, &getnext); |
|
21546
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2724 type = get_compare_type(p, &len, &type_is); |
| 7 | 2725 |
| 2726 /* | |
| 1624 | 2727 * If there is a comparative operator, use it. |
| 7 | 2728 */ |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2729 if (type != EXPR_UNKNOWN) |
| 7 | 2730 { |
|
21425
a6c316ef161a
patch 8.2.1263: Vim9: comperators use 'ignorecase' in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21385
diff
changeset
|
2731 typval_T var2; |
|
a6c316ef161a
patch 8.2.1263: Vim9: comperators use 'ignorecase' in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21385
diff
changeset
|
2732 int ic; |
|
a6c316ef161a
patch 8.2.1263: Vim9: comperators use 'ignorecase' in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21385
diff
changeset
|
2733 int vim9script = in_vim9script(); |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2734 int evaluate = evalarg == NULL |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2735 ? 0 : (evalarg->eval_flags & EVAL_EVALUATE); |
|
21425
a6c316ef161a
patch 8.2.1263: Vim9: comperators use 'ignorecase' in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21385
diff
changeset
|
2736 |
|
21026
fe2ed85db946
patch 8.2.1064: Vim9: no line break allowed before comperators
Bram Moolenaar <Bram@vim.org>
parents:
21024
diff
changeset
|
2737 if (getnext) |
|
fe2ed85db946
patch 8.2.1064: Vim9: no line break allowed before comperators
Bram Moolenaar <Bram@vim.org>
parents:
21024
diff
changeset
|
2738 *arg = eval_next_line(evalarg); |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2739 else if (evaluate && vim9script && !VIM_ISWHITE(**arg)) |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2740 { |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2741 error_white_both(p, len); |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2742 clear_tv(rettv); |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2743 return FAIL; |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2744 } |
|
21026
fe2ed85db946
patch 8.2.1064: Vim9: no line break allowed before comperators
Bram Moolenaar <Bram@vim.org>
parents:
21024
diff
changeset
|
2745 |
|
21546
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2746 if (vim9script && type_is && (p[len] == '?' || p[len] == '#')) |
|
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2747 { |
|
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2748 semsg(_(e_invexpr2), p); |
|
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2749 clear_tv(rettv); |
|
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2750 return FAIL; |
|
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2751 } |
|
4d3e983313dc
patch 8.2.1323: Vim9: invalid operators only rejected in :def function
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
2752 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2753 // extra question mark appended: ignore case |
| 7 | 2754 if (p[len] == '?') |
| 2755 { | |
| 2756 ic = TRUE; | |
| 2757 ++len; | |
| 2758 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2759 // extra '#' appended: match case |
| 7 | 2760 else if (p[len] == '#') |
| 2761 { | |
| 2762 ic = FALSE; | |
| 2763 ++len; | |
| 2764 } | |
|
21425
a6c316ef161a
patch 8.2.1263: Vim9: comperators use 'ignorecase' in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21385
diff
changeset
|
2765 // nothing appended: use 'ignorecase' if not in Vim script |
| 7 | 2766 else |
|
21425
a6c316ef161a
patch 8.2.1263: Vim9: comperators use 'ignorecase' in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21385
diff
changeset
|
2767 ic = vim9script ? FALSE : p_ic; |
| 7 | 2768 |
| 2769 /* | |
| 2770 * Get the second variable. | |
| 2771 */ | |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2772 if (evaluate && vim9script && !IS_WHITE_OR_NUL(p[len])) |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2773 { |
|
24339
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
2774 error_white_both(p, len); |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2775 clear_tv(rettv); |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2776 return FAIL; |
|
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2777 } |
|
21046
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
2778 *arg = skipwhite_and_linebreak(p + len, evalarg); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2779 if (eval5(arg, &var2, evalarg) == FAIL) |
| 7 | 2780 { |
| 71 | 2781 clear_tv(rettv); |
| 7 | 2782 return FAIL; |
| 2783 } | |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2784 if (evaluate) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
2785 { |
|
21251
d1215fcdbca8
patch 8.2.1176: Vim9: not enough type checking in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21220
diff
changeset
|
2786 int ret; |
|
d1215fcdbca8
patch 8.2.1176: Vim9: not enough type checking in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21220
diff
changeset
|
2787 |
|
21425
a6c316ef161a
patch 8.2.1263: Vim9: comperators use 'ignorecase' in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21385
diff
changeset
|
2788 if (vim9script && check_compare_types(type, rettv, &var2) == FAIL) |
|
21251
d1215fcdbca8
patch 8.2.1176: Vim9: not enough type checking in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21220
diff
changeset
|
2789 { |
|
d1215fcdbca8
patch 8.2.1176: Vim9: not enough type checking in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21220
diff
changeset
|
2790 ret = FAIL; |
|
d1215fcdbca8
patch 8.2.1176: Vim9: not enough type checking in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21220
diff
changeset
|
2791 clear_tv(rettv); |
|
d1215fcdbca8
patch 8.2.1176: Vim9: not enough type checking in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21220
diff
changeset
|
2792 } |
|
d1215fcdbca8
patch 8.2.1176: Vim9: not enough type checking in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21220
diff
changeset
|
2793 else |
|
d1215fcdbca8
patch 8.2.1176: Vim9: not enough type checking in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21220
diff
changeset
|
2794 ret = typval_compare(rettv, &var2, type, ic); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
2795 clear_tv(&var2); |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
2796 return ret; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
2797 } |
| 7 | 2798 } |
| 2799 | |
| 2800 return OK; | |
| 2801 } | |
| 2802 | |
|
22683
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2803 /* |
|
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2804 * Make a copy of blob "tv1" and append blob "tv2". |
|
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2805 */ |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2806 void |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2807 eval_addblob(typval_T *tv1, typval_T *tv2) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2808 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2809 blob_T *b1 = tv1->vval.v_blob; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2810 blob_T *b2 = tv2->vval.v_blob; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2811 blob_T *b = blob_alloc(); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2812 int i; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2813 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2814 if (b != NULL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2815 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2816 for (i = 0; i < blob_len(b1); i++) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2817 ga_append(&b->bv_ga, blob_get(b1, i)); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2818 for (i = 0; i < blob_len(b2); i++) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2819 ga_append(&b->bv_ga, blob_get(b2, i)); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2820 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2821 clear_tv(tv1); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2822 rettv_blob_set(tv1, b); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2823 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2824 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2825 |
|
22683
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2826 /* |
|
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2827 * Make a copy of list "tv1" and append list "tv2". |
|
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2828 */ |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2829 int |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2830 eval_addlist(typval_T *tv1, typval_T *tv2) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2831 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2832 typval_T var3; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2833 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2834 // concatenate Lists |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2835 if (list_concat(tv1->vval.v_list, tv2->vval.v_list, &var3) == FAIL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2836 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2837 clear_tv(tv1); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2838 clear_tv(tv2); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2839 return FAIL; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2840 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2841 clear_tv(tv1); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2842 *tv1 = var3; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2843 return OK; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2844 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2845 |
| 7 | 2846 /* |
| 2847 * Handle fourth level expression: | |
| 2848 * + number addition | |
| 2849 * - number subtraction | |
|
16223
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2850 * . string concatenation (if script version is 1) |
|
16219
bd49e1656c72
patch 8.1.1114: confusing overloaded operator "." for string concatenation
Bram Moolenaar <Bram@vim.org>
parents:
16170
diff
changeset
|
2851 * .. string concatenation |
| 7 | 2852 * |
| 2853 * "arg" must point to the first non-white of the expression. | |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
2854 * "arg" is advanced to just after the recognized expression. |
| 7 | 2855 * |
| 2856 * Return OK or FAIL. | |
| 2857 */ | |
| 2858 static int | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2859 eval5(char_u **arg, typval_T *rettv, evalarg_T *evalarg) |
| 7 | 2860 { |
| 2861 /* | |
| 2862 * Get the first variable. | |
| 2863 */ | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2864 if (eval6(arg, rettv, evalarg, FALSE) == FAIL) |
| 7 | 2865 return FAIL; |
| 2866 | |
| 2867 /* | |
| 2868 * Repeat computing, until no '+', '-' or '.' is following. | |
| 2869 */ | |
| 2870 for (;;) | |
| 2871 { | |
|
21305
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
2872 int evaluate; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2873 int getnext; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2874 char_u *p; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2875 int op; |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2876 int oplen; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2877 int concat; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2878 typval_T var2; |
|
21949
e6608764248a
patch 8.2.1524: no longer get an error for string concatenation with float
Bram Moolenaar <Bram@vim.org>
parents:
21925
diff
changeset
|
2879 int vim9script = in_vim9script(); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2880 |
|
16223
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2881 // "." is only string concatenation when scriptversion is 1 |
|
24047
b535ab17d160
patch 8.2.2565: Vim9: "..=" not always recognized
Bram Moolenaar <Bram@vim.org>
parents:
23982
diff
changeset
|
2882 // "+=", "-=" and "..=" are assignments |
|
24533
9c404d78d767
patch 8.2.2806: Vim9: using "++nr" as a command might not work
Bram Moolenaar <Bram@vim.org>
parents:
24525
diff
changeset
|
2883 // "++" and "--" on the next line are a separate command. |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2884 p = eval_next_non_blank(*arg, evalarg, &getnext); |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2885 op = *p; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2886 concat = op == '.' && (*(p + 1) == '.' || current_sctx.sc_version < 2); |
|
24047
b535ab17d160
patch 8.2.2565: Vim9: "..=" not always recognized
Bram Moolenaar <Bram@vim.org>
parents:
23982
diff
changeset
|
2887 if ((op != '+' && op != '-' && !concat) || p[1] == '=' |
|
b535ab17d160
patch 8.2.2565: Vim9: "..=" not always recognized
Bram Moolenaar <Bram@vim.org>
parents:
23982
diff
changeset
|
2888 || (p[1] == '.' && p[2] == '=')) |
| 7 | 2889 break; |
|
24533
9c404d78d767
patch 8.2.2806: Vim9: using "++nr" as a command might not work
Bram Moolenaar <Bram@vim.org>
parents:
24525
diff
changeset
|
2890 if (getnext && (op == '+' || op == '-') && p[0] == p[1]) |
|
9c404d78d767
patch 8.2.2806: Vim9: using "++nr" as a command might not work
Bram Moolenaar <Bram@vim.org>
parents:
24525
diff
changeset
|
2891 break; |
|
21305
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
2892 |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2893 evaluate = evalarg == NULL ? 0 : (evalarg->eval_flags & EVAL_EVALUATE); |
|
21634
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
2894 oplen = (concat && p[1] == '.') ? 2 : 1; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2895 if (getnext) |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
2896 *arg = eval_next_line(evalarg); |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2897 else |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2898 { |
|
21949
e6608764248a
patch 8.2.1524: no longer get an error for string concatenation with float
Bram Moolenaar <Bram@vim.org>
parents:
21925
diff
changeset
|
2899 if (evaluate && vim9script && !VIM_ISWHITE(**arg)) |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2900 { |
|
21634
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
2901 error_white_both(p, oplen); |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2902 clear_tv(rettv); |
|
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2903 return FAIL; |
|
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2904 } |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
2905 *arg = p; |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2906 } |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2907 if ((op != '+' || (rettv->v_type != VAR_LIST |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2908 && rettv->v_type != VAR_BLOB)) |
| 1624 | 2909 #ifdef FEAT_FLOAT |
| 2910 && (op == '.' || rettv->v_type != VAR_FLOAT) | |
| 2911 #endif | |
|
22683
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2912 && evaluate) |
| 323 | 2913 { |
|
22683
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2914 int error = FALSE; |
|
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2915 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2916 // For "list + ...", an illegal use of the first operand as |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2917 // a number cannot be determined before evaluating the 2nd |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2918 // operand: if this is also a list, all is ok. |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2919 // For "something . ...", "something - ..." or "non-list + ...", |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2920 // we know that the first operand needs to be a string or number |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2921 // without evaluating the 2nd operand. So check before to avoid |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2922 // side effects after an error. |
|
22683
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2923 if (op != '.') |
|
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2924 tv_get_number_chk(rettv, &error); |
|
5cbcd3768125
patch 8.2.1890: Vim9: strange error for subtracting from a list
Bram Moolenaar <Bram@vim.org>
parents:
22606
diff
changeset
|
2925 if ((op == '.' && tv_get_string_chk(rettv) == NULL) || error) |
| 323 | 2926 { |
| 2927 clear_tv(rettv); | |
| 2928 return FAIL; | |
| 2929 } | |
| 2930 } | |
| 2931 | |
| 7 | 2932 /* |
| 2933 * Get the second variable. | |
| 2934 */ | |
|
21949
e6608764248a
patch 8.2.1524: no longer get an error for string concatenation with float
Bram Moolenaar <Bram@vim.org>
parents:
21925
diff
changeset
|
2935 if (evaluate && vim9script && !IS_WHITE_OR_NUL((*arg)[oplen])) |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2936 { |
|
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2937 error_white_both(p, oplen); |
|
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2938 clear_tv(rettv); |
|
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2939 return FAIL; |
|
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2940 } |
|
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
2941 *arg = skipwhite_and_linebreak(*arg + oplen, evalarg); |
|
21949
e6608764248a
patch 8.2.1524: no longer get an error for string concatenation with float
Bram Moolenaar <Bram@vim.org>
parents:
21925
diff
changeset
|
2942 if (eval6(arg, &var2, evalarg, !vim9script && op == '.') == FAIL) |
| 7 | 2943 { |
| 71 | 2944 clear_tv(rettv); |
| 7 | 2945 return FAIL; |
| 2946 } | |
| 2947 | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2948 if (evaluate) |
| 7 | 2949 { |
| 2950 /* | |
| 2951 * Compute the result. | |
| 2952 */ | |
| 2953 if (op == '.') | |
| 2954 { | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2955 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2956 char_u *s1 = tv_get_string_buf(rettv, buf1); |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2957 char_u *s2 = NULL; |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2958 |
|
21949
e6608764248a
patch 8.2.1524: no longer get an error for string concatenation with float
Bram Moolenaar <Bram@vim.org>
parents:
21925
diff
changeset
|
2959 if (vim9script && (var2.v_type == VAR_VOID |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2960 || var2.v_type == VAR_CHANNEL |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2961 || var2.v_type == VAR_JOB)) |
|
24614
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
2962 semsg(_(e_using_invalid_value_as_string_str), |
|
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
2963 vartype_name(var2.v_type)); |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2964 #ifdef FEAT_FLOAT |
|
21949
e6608764248a
patch 8.2.1524: no longer get an error for string concatenation with float
Bram Moolenaar <Bram@vim.org>
parents:
21925
diff
changeset
|
2965 else if (vim9script && var2.v_type == VAR_FLOAT) |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2966 { |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2967 vim_snprintf((char *)buf2, NUMBUFLEN, "%g", |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2968 var2.vval.v_float); |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2969 s2 = buf2; |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2970 } |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2971 #endif |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2972 else |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21733
diff
changeset
|
2973 s2 = tv_get_string_buf_chk(&var2, buf2); |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2974 if (s2 == NULL) // type error ? |
| 323 | 2975 { |
| 2976 clear_tv(rettv); | |
| 2977 clear_tv(&var2); | |
| 2978 return FAIL; | |
| 2979 } | |
| 117 | 2980 p = concat_str(s1, s2); |
| 71 | 2981 clear_tv(rettv); |
| 2982 rettv->v_type = VAR_STRING; | |
| 2983 rettv->vval.v_string = p; | |
| 7 | 2984 } |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2985 else if (op == '+' && rettv->v_type == VAR_BLOB |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2986 && var2.v_type == VAR_BLOB) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2987 eval_addblob(rettv, &var2); |
| 104 | 2988 else if (op == '+' && rettv->v_type == VAR_LIST |
| 2989 && var2.v_type == VAR_LIST) | |
| 80 | 2990 { |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2991 if (eval_addlist(rettv, &var2) == FAIL) |
| 80 | 2992 return FAIL; |
| 2993 } | |
| 7 | 2994 else |
| 2995 { | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2996 int error = FALSE; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2997 varnumber_T n1, n2; |
| 1624 | 2998 #ifdef FEAT_FLOAT |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
2999 float_T f1 = 0, f2 = 0; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3000 |
| 1624 | 3001 if (rettv->v_type == VAR_FLOAT) |
| 3002 { | |
| 3003 f1 = rettv->vval.v_float; | |
| 3004 n1 = 0; | |
| 3005 } | |
| 3006 else | |
| 3007 #endif | |
| 3008 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3009 n1 = tv_get_number_chk(rettv, &error); |
| 1624 | 3010 if (error) |
| 3011 { | |
|
24343
7735cbff607d
patch 8.2.2712: memory leak when adding to a blob fails
Bram Moolenaar <Bram@vim.org>
parents:
24339
diff
changeset
|
3012 // This can only happen for "list + non-list" or |
|
7735cbff607d
patch 8.2.2712: memory leak when adding to a blob fails
Bram Moolenaar <Bram@vim.org>
parents:
24339
diff
changeset
|
3013 // "blob + non-blob". For "non-list + ..." or |
|
7735cbff607d
patch 8.2.2712: memory leak when adding to a blob fails
Bram Moolenaar <Bram@vim.org>
parents:
24339
diff
changeset
|
3014 // "something - ...", we returned before evaluating the |
|
7735cbff607d
patch 8.2.2712: memory leak when adding to a blob fails
Bram Moolenaar <Bram@vim.org>
parents:
24339
diff
changeset
|
3015 // 2nd operand. |
| 1624 | 3016 clear_tv(rettv); |
|
24343
7735cbff607d
patch 8.2.2712: memory leak when adding to a blob fails
Bram Moolenaar <Bram@vim.org>
parents:
24339
diff
changeset
|
3017 clear_tv(&var2); |
| 1624 | 3018 return FAIL; |
| 3019 } | |
| 3020 #ifdef FEAT_FLOAT | |
| 3021 if (var2.v_type == VAR_FLOAT) | |
| 3022 f1 = n1; | |
| 3023 #endif | |
| 3024 } | |
| 3025 #ifdef FEAT_FLOAT | |
| 3026 if (var2.v_type == VAR_FLOAT) | |
| 3027 { | |
| 3028 f2 = var2.vval.v_float; | |
| 3029 n2 = 0; | |
| 3030 } | |
| 3031 else | |
| 3032 #endif | |
| 3033 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3034 n2 = tv_get_number_chk(&var2, &error); |
| 1624 | 3035 if (error) |
| 3036 { | |
| 3037 clear_tv(rettv); | |
| 3038 clear_tv(&var2); | |
| 3039 return FAIL; | |
| 3040 } | |
| 3041 #ifdef FEAT_FLOAT | |
| 3042 if (rettv->v_type == VAR_FLOAT) | |
| 3043 f2 = n2; | |
| 3044 #endif | |
| 323 | 3045 } |
| 71 | 3046 clear_tv(rettv); |
| 1624 | 3047 |
| 3048 #ifdef FEAT_FLOAT | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3049 // If there is a float on either side the result is a float. |
| 1624 | 3050 if (rettv->v_type == VAR_FLOAT || var2.v_type == VAR_FLOAT) |
| 3051 { | |
| 3052 if (op == '+') | |
| 3053 f1 = f1 + f2; | |
| 3054 else | |
| 3055 f1 = f1 - f2; | |
| 3056 rettv->v_type = VAR_FLOAT; | |
| 3057 rettv->vval.v_float = f1; | |
| 3058 } | |
| 3059 else | |
| 3060 #endif | |
| 3061 { | |
| 3062 if (op == '+') | |
| 3063 n1 = n1 + n2; | |
| 3064 else | |
| 3065 n1 = n1 - n2; | |
| 3066 rettv->v_type = VAR_NUMBER; | |
| 3067 rettv->vval.v_number = n1; | |
| 3068 } | |
| 71 | 3069 } |
| 3070 clear_tv(&var2); | |
| 7 | 3071 } |
| 3072 } | |
| 3073 return OK; | |
| 3074 } | |
| 3075 | |
| 3076 /* | |
| 3077 * Handle fifth level expression: | |
| 3078 * * number multiplication | |
| 3079 * / number division | |
| 3080 * % number modulo | |
| 3081 * | |
| 3082 * "arg" must point to the first non-white of the expression. | |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
3083 * "arg" is advanced to just after the recognized expression. |
| 7 | 3084 * |
| 3085 * Return OK or FAIL. | |
| 3086 */ | |
| 3087 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3088 eval6( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3089 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3090 typval_T *rettv, |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3091 evalarg_T *evalarg, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3092 int want_string) // after "." operator |
| 7 | 3093 { |
| 1624 | 3094 #ifdef FEAT_FLOAT |
|
21305
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3095 int use_float = FALSE; |
| 1624 | 3096 #endif |
| 7 | 3097 |
| 3098 /* | |
| 3099 * Get the first variable. | |
| 3100 */ | |
|
24518
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3101 if (eval7t(arg, rettv, evalarg, want_string) == FAIL) |
| 7 | 3102 return FAIL; |
| 3103 | |
| 3104 /* | |
| 3105 * Repeat computing, until no '*', '/' or '%' is following. | |
| 3106 */ | |
| 3107 for (;;) | |
| 3108 { | |
|
21305
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3109 int evaluate; |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3110 int getnext; |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3111 typval_T var2; |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
3112 char_u *p; |
|
21305
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3113 int op; |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3114 varnumber_T n1, n2; |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3115 #ifdef FEAT_FLOAT |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3116 float_T f1, f2; |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3117 #endif |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3118 int error; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3119 |
|
24047
b535ab17d160
patch 8.2.2565: Vim9: "..=" not always recognized
Bram Moolenaar <Bram@vim.org>
parents:
23982
diff
changeset
|
3120 // "*=", "/=" and "%=" are assignments |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
3121 p = eval_next_non_blank(*arg, evalarg, &getnext); |
|
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
3122 op = *p; |
|
24047
b535ab17d160
patch 8.2.2565: Vim9: "..=" not always recognized
Bram Moolenaar <Bram@vim.org>
parents:
23982
diff
changeset
|
3123 if ((op != '*' && op != '/' && op != '%') || p[1] == '=') |
| 7 | 3124 break; |
|
21305
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3125 |
|
21634
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3126 evaluate = evalarg == NULL ? 0 : (evalarg->eval_flags & EVAL_EVALUATE); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3127 if (getnext) |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
3128 *arg = eval_next_line(evalarg); |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
3129 else |
|
21634
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3130 { |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3131 if (evaluate && in_vim9script() && !VIM_ISWHITE(**arg)) |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3132 { |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3133 error_white_both(p, 1); |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3134 clear_tv(rettv); |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3135 return FAIL; |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3136 } |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
3137 *arg = p; |
|
21634
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3138 } |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3139 |
|
21305
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3140 #ifdef FEAT_FLOAT |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3141 f1 = 0; |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3142 f2 = 0; |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3143 #endif |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3144 error = FALSE; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3145 if (evaluate) |
| 7 | 3146 { |
| 1624 | 3147 #ifdef FEAT_FLOAT |
| 3148 if (rettv->v_type == VAR_FLOAT) | |
| 3149 { | |
| 3150 f1 = rettv->vval.v_float; | |
| 3151 use_float = TRUE; | |
| 3152 n1 = 0; | |
| 3153 } | |
| 3154 else | |
| 3155 #endif | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3156 n1 = tv_get_number_chk(rettv, &error); |
| 71 | 3157 clear_tv(rettv); |
| 323 | 3158 if (error) |
| 3159 return FAIL; | |
| 7 | 3160 } |
| 3161 else | |
| 3162 n1 = 0; | |
| 3163 | |
| 3164 /* | |
| 3165 * Get the second variable. | |
| 3166 */ | |
|
21634
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3167 if (evaluate && in_vim9script() && !IS_WHITE_OR_NUL((*arg)[1])) |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3168 { |
|
24063
d8f3a993dc9a
patch 8.2.2573: Vim9: using inalid pointer for error message
Bram Moolenaar <Bram@vim.org>
parents:
24047
diff
changeset
|
3169 error_white_both(*arg, 1); |
|
21634
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3170 clear_tv(rettv); |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3171 return FAIL; |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3172 } |
|
3a86e41fdffd
patch 8.2.1367: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21630
diff
changeset
|
3173 *arg = skipwhite_and_linebreak(*arg + 1, evalarg); |
|
24518
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3174 if (eval7t(arg, &var2, evalarg, FALSE) == FAIL) |
| 7 | 3175 return FAIL; |
| 3176 | |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3177 if (evaluate) |
| 7 | 3178 { |
| 1624 | 3179 #ifdef FEAT_FLOAT |
| 3180 if (var2.v_type == VAR_FLOAT) | |
| 3181 { | |
| 3182 if (!use_float) | |
| 3183 { | |
| 3184 f1 = n1; | |
| 3185 use_float = TRUE; | |
| 3186 } | |
| 3187 f2 = var2.vval.v_float; | |
| 3188 n2 = 0; | |
| 3189 } | |
| 3190 else | |
| 3191 #endif | |
| 3192 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3193 n2 = tv_get_number_chk(&var2, &error); |
| 1624 | 3194 clear_tv(&var2); |
| 3195 if (error) | |
| 3196 return FAIL; | |
| 3197 #ifdef FEAT_FLOAT | |
| 3198 if (use_float) | |
| 3199 f2 = n2; | |
| 3200 #endif | |
| 3201 } | |
| 7 | 3202 |
| 3203 /* | |
| 3204 * Compute the result. | |
| 1624 | 3205 * When either side is a float the result is a float. |
| 7 | 3206 */ |
| 1624 | 3207 #ifdef FEAT_FLOAT |
| 3208 if (use_float) | |
| 3209 { | |
| 3210 if (op == '*') | |
| 3211 f1 = f1 * f2; | |
| 3212 else if (op == '/') | |
| 3213 { | |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3214 # ifdef VMS |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3215 // VMS crashes on divide by zero, work around it |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3216 if (f2 == 0.0) |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3217 { |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3218 if (f1 == 0) |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3219 f1 = -1 * __F_FLT_MAX - 1L; // similar to NaN |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3220 else if (f1 < 0) |
|
2529
2aaa88366cbb
Fix for float values on VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2513
diff
changeset
|
3221 f1 = -1 * __F_FLT_MAX; |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3222 else |
|
2529
2aaa88366cbb
Fix for float values on VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2513
diff
changeset
|
3223 f1 = __F_FLT_MAX; |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3224 } |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3225 else |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3226 f1 = f1 / f2; |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3227 # else |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3228 // We rely on the floating point library to handle divide |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3229 // by zero to result in "inf" and not a crash. |
| 1624 | 3230 f1 = f1 / f2; |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
3231 # endif |
| 1624 | 3232 } |
| 3233 else | |
| 3234 { | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3235 emsg(_(e_modulus)); |
| 1624 | 3236 return FAIL; |
| 3237 } | |
| 3238 rettv->v_type = VAR_FLOAT; | |
| 3239 rettv->vval.v_float = f1; | |
| 3240 } | |
| 3241 else | |
| 3242 #endif | |
| 3243 { | |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
3244 int failed = FALSE; |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
3245 |
| 1624 | 3246 if (op == '*') |
| 3247 n1 = n1 * n2; | |
| 3248 else if (op == '/') | |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
3249 n1 = num_divide(n1, n2, &failed); |
| 1624 | 3250 else |
|
23679
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
3251 n1 = num_modulus(n1, n2, &failed); |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
3252 if (failed) |
|
e8c379b20765
patch 8.2.2381: Vim9: divide by zero does not abort expression execution
Bram Moolenaar <Bram@vim.org>
parents:
23673
diff
changeset
|
3253 return FAIL; |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
3254 |
| 1624 | 3255 rettv->v_type = VAR_NUMBER; |
| 3256 rettv->vval.v_number = n1; | |
| 3257 } | |
| 7 | 3258 } |
| 3259 } | |
| 3260 | |
| 3261 return OK; | |
| 3262 } | |
| 3263 | |
|
24518
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3264 /* |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3265 * Handle a type cast before a base level expression. |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3266 * "arg" must point to the first non-white of the expression. |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3267 * "arg" is advanced to just after the recognized expression. |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3268 * Return OK or FAIL. |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3269 */ |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3270 static int |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3271 eval7t( |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3272 char_u **arg, |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3273 typval_T *rettv, |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3274 evalarg_T *evalarg, |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3275 int want_string) // after "." operator |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3276 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3277 type_T *want_type = NULL; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3278 garray_T type_list; // list of pointers to allocated types |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3279 int res; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3280 int evaluate = evalarg == NULL ? 0 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3281 : (evalarg->eval_flags & EVAL_EVALUATE); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3282 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3283 // Recognize <type> in Vim9 script only. |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3284 if (in_vim9script() && **arg == '<' && eval_isnamec1((*arg)[1])) |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3285 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3286 ++*arg; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3287 ga_init2(&type_list, sizeof(type_T *), 10); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3288 want_type = parse_type(arg, &type_list, TRUE); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3289 if (want_type == NULL && (evaluate || **arg != '>')) |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3290 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3291 clear_type_list(&type_list); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3292 return FAIL; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3293 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3294 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3295 if (**arg != '>') |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3296 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3297 if (*skipwhite(*arg) == '>') |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3298 semsg(_(e_no_white_space_allowed_before_str_str), ">", *arg); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3299 else |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3300 emsg(_(e_missing_gt)); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3301 clear_type_list(&type_list); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3302 return FAIL; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3303 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3304 ++*arg; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3305 *arg = skipwhite_and_linebreak(*arg, evalarg); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3306 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3307 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3308 res = eval7(arg, rettv, evalarg, want_string); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3309 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3310 if (want_type != NULL && evaluate) |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3311 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3312 if (res == OK) |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3313 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3314 type_T *actual = typval2type(rettv, get_copyID(), &type_list, TRUE); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3315 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3316 if (!equal_type(want_type, actual)) |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3317 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3318 if (want_type == &t_bool && actual != &t_bool |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3319 && (actual->tt_flags & TTFLAG_BOOL_OK)) |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3320 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3321 int n = tv2bool(rettv); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3322 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3323 // can use "0" and "1" for boolean in some places |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3324 clear_tv(rettv); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3325 rettv->v_type = VAR_BOOL; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3326 rettv->vval.v_number = n ? VVAL_TRUE : VVAL_FALSE; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3327 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3328 else |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3329 { |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3330 where_T where; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3331 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3332 where.wt_index = 0; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3333 where.wt_variable = TRUE; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3334 res = check_type(want_type, actual, TRUE, where); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3335 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3336 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3337 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3338 clear_type_list(&type_list); |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3339 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3340 |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3341 return res; |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3342 } |
|
cf334a353c30
patch 8.2.2799: Vim9: type casts don't fully work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24486
diff
changeset
|
3343 |
|
23525
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3344 int |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3345 eval_leader(char_u **arg, int vim9) |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3346 { |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3347 char_u *s = *arg; |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3348 char_u *p = *arg; |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3349 |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3350 while (*p == '!' || *p == '-' || *p == '+') |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3351 { |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3352 char_u *n = skipwhite(p + 1); |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3353 |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3354 // ++, --, -+ and +- are not accepted in Vim9 script |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3355 if (vim9 && (*p == '-' || *p == '+') && (*n == '-' || *n == '+')) |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3356 { |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3357 semsg(_(e_invexpr2), s); |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3358 return FAIL; |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3359 } |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3360 p = n; |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3361 } |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3362 *arg = p; |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3363 return OK; |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3364 } |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3365 |
| 7 | 3366 /* |
| 3367 * Handle sixth level expression: | |
| 3368 * number number constant | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3369 * 0zFFFFFFFF Blob constant |
| 1228 | 3370 * "string" string constant |
| 3371 * 'string' literal string constant | |
| 7 | 3372 * &option-name option value |
| 3373 * @r register contents | |
| 3374 * identifier variable value | |
| 3375 * function() function call | |
| 3376 * $VAR environment variable | |
| 3377 * (expression) nested expression | |
| 151 | 3378 * [expr, expr] List |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3379 * {arg, arg -> expr} Lambda |
|
17368
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3380 * {key: val, key: val} Dictionary |
|
17413
40417757dffd
patch 8.1.1705: using ~{} for a literal dict is not nice
Bram Moolenaar <Bram@vim.org>
parents:
17387
diff
changeset
|
3381 * #{key: val, key: val} Dictionary with literal keys |
| 7 | 3382 * |
| 3383 * Also handle: | |
| 3384 * ! in front logical NOT | |
| 3385 * - in front unary minus | |
| 3386 * + in front unary plus (ignored) | |
| 100 | 3387 * trailing [] subscript in String or List |
| 3388 * trailing .name entry in Dictionary | |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3389 * trailing ->name() method call |
| 7 | 3390 * |
| 3391 * "arg" must point to the first non-white of the expression. | |
|
21636
dcfcb6163f3d
patch 8.2.1368: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21634
diff
changeset
|
3392 * "arg" is advanced to just after the recognized expression. |
| 7 | 3393 * |
| 3394 * Return OK or FAIL. | |
| 3395 */ | |
| 3396 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3397 eval7( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3398 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3399 typval_T *rettv, |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3400 evalarg_T *evalarg, |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3401 int want_string) // after "." operator |
| 7 | 3402 { |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3403 int evaluate = evalarg != NULL |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3404 && (evalarg->eval_flags & EVAL_EVALUATE); |
| 7 | 3405 int len; |
| 3406 char_u *s; | |
| 3407 char_u *start_leader, *end_leader; | |
| 3408 int ret = OK; | |
| 3409 char_u *alias; | |
| 3410 | |
| 3411 /* | |
| 71 | 3412 * Initialise variable so that clear_tv() can't mistake this for a |
| 56 | 3413 * string and free a string that isn't there. |
| 7 | 3414 */ |
| 71 | 3415 rettv->v_type = VAR_UNKNOWN; |
| 7 | 3416 |
| 3417 /* | |
|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
10000
diff
changeset
|
3418 * Skip '!', '-' and '+' characters. They are handled later. |
| 7 | 3419 */ |
| 3420 start_leader = *arg; | |
|
23525
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3421 if (eval_leader(arg, in_vim9script()) == FAIL) |
|
54ec7c8b7459
patch 8.2.2305: Vim9: "++var" and "--var" are silently accepted
Bram Moolenaar <Bram@vim.org>
parents:
23499
diff
changeset
|
3422 return FAIL; |
| 7 | 3423 end_leader = *arg; |
| 3424 | |
|
16223
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3425 if (**arg == '.' && (!isdigit(*(*arg + 1)) |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3426 #ifdef FEAT_FLOAT |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3427 || current_sctx.sc_version < 2 |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3428 #endif |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3429 )) |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3430 { |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3431 semsg(_(e_invexpr2), *arg); |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3432 ++*arg; |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3433 return FAIL; |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3434 } |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
3435 |
| 7 | 3436 switch (**arg) |
| 3437 { | |
| 3438 /* | |
| 3439 * Number constant. | |
| 3440 */ | |
| 3441 case '0': | |
| 3442 case '1': | |
| 3443 case '2': | |
| 3444 case '3': | |
| 3445 case '4': | |
| 3446 case '5': | |
| 3447 case '6': | |
| 3448 case '7': | |
| 3449 case '8': | |
| 3450 case '9': | |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
3451 case '.': ret = eval_number(arg, rettv, evaluate, want_string); |
|
21032
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3452 |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3453 // Apply prefixed "-" and "+" now. Matters especially when |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3454 // "->" follows. |
|
21733
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
3455 if (ret == OK && evaluate && end_leader > start_leader |
|
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
3456 && rettv->v_type != VAR_BLOB) |
|
21032
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3457 ret = eval7_leader(rettv, TRUE, start_leader, &end_leader); |
| 1624 | 3458 break; |
| 7 | 3459 |
| 3460 /* | |
| 3461 * String constant: "string". | |
| 3462 */ | |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
3463 case '"': ret = eval_string(arg, rettv, evaluate); |
| 7 | 3464 break; |
| 3465 | |
| 3466 /* | |
| 100 | 3467 * Literal string constant: 'str''ing'. |
| 7 | 3468 */ |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
3469 case '\'': ret = eval_lit_string(arg, rettv, evaluate); |
| 56 | 3470 break; |
| 3471 | |
| 3472 /* | |
| 3473 * List: [expr, expr] | |
| 3474 */ | |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
3475 case '[': ret = eval_list(arg, rettv, evalarg, TRUE); |
| 7 | 3476 break; |
| 3477 | |
| 3478 /* | |
|
17413
40417757dffd
patch 8.1.1705: using ~{} for a literal dict is not nice
Bram Moolenaar <Bram@vim.org>
parents:
17387
diff
changeset
|
3479 * Dictionary: #{key: val, key: val} |
|
17368
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3480 */ |
|
24174
99bfaa4693db
patch 8.2.2628: Vim9: #{ can still be used at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24112
diff
changeset
|
3481 case '#': if (in_vim9script()) |
|
99bfaa4693db
patch 8.2.2628: Vim9: #{ can still be used at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24112
diff
changeset
|
3482 { |
|
99bfaa4693db
patch 8.2.2628: Vim9: #{ can still be used at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24112
diff
changeset
|
3483 ret = vim9_bad_comment(*arg) ? FAIL : NOTDONE; |
|
99bfaa4693db
patch 8.2.2628: Vim9: #{ can still be used at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24112
diff
changeset
|
3484 } |
|
99bfaa4693db
patch 8.2.2628: Vim9: #{ can still be used at the script level
Bram Moolenaar <Bram@vim.org>
parents:
24112
diff
changeset
|
3485 else if ((*arg)[1] == '{') |
|
17368
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3486 { |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3487 ++*arg; |
|
21034
2f8b0812819f
patch 8.2.1068: Vim9: no line break allowed inside a dict
Bram Moolenaar <Bram@vim.org>
parents:
21032
diff
changeset
|
3488 ret = eval_dict(arg, rettv, evalarg, TRUE); |
|
17368
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3489 } |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3490 else |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3491 ret = NOTDONE; |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3492 break; |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3493 |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3494 /* |
|
9527
e8b3db8e2d30
commit https://github.com/vim/vim/commit/069c1e7fa9f45a665064f7f2c17da84d6a48f544
Christian Brabandt <cb@256bit.org>
parents:
9525
diff
changeset
|
3495 * Lambda: {arg, arg -> expr} |
|
17368
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
3496 * Dictionary: {'key': val, 'key': val} |
| 100 | 3497 */ |
|
23428
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3498 case '{': if (in_vim9script()) |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3499 ret = NOTDONE; |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3500 else |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3501 ret = get_lambda_tv(arg, rettv, in_vim9script(), evalarg); |
|
9527
e8b3db8e2d30
commit https://github.com/vim/vim/commit/069c1e7fa9f45a665064f7f2c17da84d6a48f544
Christian Brabandt <cb@256bit.org>
parents:
9525
diff
changeset
|
3502 if (ret == NOTDONE) |
|
21034
2f8b0812819f
patch 8.2.1068: Vim9: no line break allowed inside a dict
Bram Moolenaar <Bram@vim.org>
parents:
21032
diff
changeset
|
3503 ret = eval_dict(arg, rettv, evalarg, FALSE); |
| 100 | 3504 break; |
| 3505 | |
| 3506 /* | |
| 104 | 3507 * Option value: &name |
| 7 | 3508 */ |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
3509 case '&': ret = eval_option(arg, rettv, evaluate); |
| 7 | 3510 break; |
| 3511 | |
| 3512 /* | |
| 3513 * Environment variable: $VAR. | |
| 3514 */ | |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
3515 case '$': ret = eval_env_var(arg, rettv, evaluate); |
| 7 | 3516 break; |
| 3517 | |
| 3518 /* | |
| 3519 * Register contents: @r. | |
| 3520 */ | |
| 3521 case '@': ++*arg; | |
| 3522 if (evaluate) | |
| 3523 { | |
|
24339
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3524 if (in_vim9script() && IS_WHITE_OR_NUL(**arg)) |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3525 semsg(_(e_syntax_error_at_str), *arg); |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3526 else if (in_vim9script() && !valid_yank_reg(**arg, FALSE)) |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3527 emsg_invreg(**arg); |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3528 else |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3529 { |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3530 rettv->v_type = VAR_STRING; |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3531 rettv->vval.v_string = get_reg_contents(**arg, |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3532 GREG_EXPR_SRC); |
|
236e9ebdb30e
patch 8.2.2710: Vim9: not all tests cover script and :def function
Bram Moolenaar <Bram@vim.org>
parents:
24250
diff
changeset
|
3533 } |
| 7 | 3534 } |
| 3535 if (**arg != NUL) | |
| 3536 ++*arg; | |
| 3537 break; | |
| 3538 | |
| 3539 /* | |
| 3540 * nested expression: (expression). | |
|
24655
3876d9629ebd
patch 8.2.2866: Vim9: memory leak when using inline function
Bram Moolenaar <Bram@vim.org>
parents:
24632
diff
changeset
|
3541 * or lambda: (arg) => expr |
| 7 | 3542 */ |
|
23338
9c5275b1c763
patch 8.2.2212: Vim9: lambda with => does not work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
23332
diff
changeset
|
3543 case '(': ret = NOTDONE; |
|
9c5275b1c763
patch 8.2.2212: Vim9: lambda with => does not work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
23332
diff
changeset
|
3544 if (in_vim9script()) |
|
23970
ba79ceac82ec
patch 8.2.2527: Vim9: lambda return type is not determined at script level
Bram Moolenaar <Bram@vim.org>
parents:
23917
diff
changeset
|
3545 { |
|
23338
9c5275b1c763
patch 8.2.2212: Vim9: lambda with => does not work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
23332
diff
changeset
|
3546 ret = get_lambda_tv(arg, rettv, TRUE, evalarg); |
|
23970
ba79ceac82ec
patch 8.2.2527: Vim9: lambda return type is not determined at script level
Bram Moolenaar <Bram@vim.org>
parents:
23917
diff
changeset
|
3547 if (ret == OK && evaluate) |
|
ba79ceac82ec
patch 8.2.2527: Vim9: lambda return type is not determined at script level
Bram Moolenaar <Bram@vim.org>
parents:
23917
diff
changeset
|
3548 { |
|
ba79ceac82ec
patch 8.2.2527: Vim9: lambda return type is not determined at script level
Bram Moolenaar <Bram@vim.org>
parents:
23917
diff
changeset
|
3549 ufunc_T *ufunc = rettv->vval.v_partial->pt_func; |
|
ba79ceac82ec
patch 8.2.2527: Vim9: lambda return type is not determined at script level
Bram Moolenaar <Bram@vim.org>
parents:
23917
diff
changeset
|
3550 |
|
ba79ceac82ec
patch 8.2.2527: Vim9: lambda return type is not determined at script level
Bram Moolenaar <Bram@vim.org>
parents:
23917
diff
changeset
|
3551 // compile it here to get the return type |
|
23972
a620df0ebbe5
patch 8.2.2528: Vim9: crash when compiling lambda fails
Bram Moolenaar <Bram@vim.org>
parents:
23970
diff
changeset
|
3552 if (compile_def_function(ufunc, |
|
a620df0ebbe5
patch 8.2.2528: Vim9: crash when compiling lambda fails
Bram Moolenaar <Bram@vim.org>
parents:
23970
diff
changeset
|
3553 TRUE, PROFILING(ufunc), NULL) == FAIL) |
|
a620df0ebbe5
patch 8.2.2528: Vim9: crash when compiling lambda fails
Bram Moolenaar <Bram@vim.org>
parents:
23970
diff
changeset
|
3554 { |
|
a620df0ebbe5
patch 8.2.2528: Vim9: crash when compiling lambda fails
Bram Moolenaar <Bram@vim.org>
parents:
23970
diff
changeset
|
3555 clear_tv(rettv); |
|
a620df0ebbe5
patch 8.2.2528: Vim9: crash when compiling lambda fails
Bram Moolenaar <Bram@vim.org>
parents:
23970
diff
changeset
|
3556 ret = FAIL; |
|
a620df0ebbe5
patch 8.2.2528: Vim9: crash when compiling lambda fails
Bram Moolenaar <Bram@vim.org>
parents:
23970
diff
changeset
|
3557 } |
|
23970
ba79ceac82ec
patch 8.2.2527: Vim9: lambda return type is not determined at script level
Bram Moolenaar <Bram@vim.org>
parents:
23917
diff
changeset
|
3558 } |
|
ba79ceac82ec
patch 8.2.2527: Vim9: lambda return type is not determined at script level
Bram Moolenaar <Bram@vim.org>
parents:
23917
diff
changeset
|
3559 } |
|
23338
9c5275b1c763
patch 8.2.2212: Vim9: lambda with => does not work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
23332
diff
changeset
|
3560 if (ret == NOTDONE) |
|
9c5275b1c763
patch 8.2.2212: Vim9: lambda with => does not work at the script level
Bram Moolenaar <Bram@vim.org>
parents:
23332
diff
changeset
|
3561 { |
|
21046
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
3562 *arg = skipwhite_and_linebreak(*arg + 1, evalarg); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3563 ret = eval1(arg, rettv, evalarg); // recursive! |
|
21044
dc2ca403a217
patch 8.2.1073: Vim9: no line break allowed in () expression
Bram Moolenaar <Bram@vim.org>
parents:
21040
diff
changeset
|
3564 |
|
21046
0ca7e04d39e3
patch 8.2.1074: Vim9: no line break allowed after some operators
Bram Moolenaar <Bram@vim.org>
parents:
21044
diff
changeset
|
3565 *arg = skipwhite_and_linebreak(*arg, evalarg); |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3566 if (**arg == ')') |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3567 ++*arg; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3568 else if (ret == OK) |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3569 { |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3570 emsg(_(e_missing_close)); |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3571 clear_tv(rettv); |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3572 ret = FAIL; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
3573 } |
| 7 | 3574 } |
| 3575 break; | |
| 3576 | |
| 100 | 3577 default: ret = NOTDONE; |
| 3578 break; | |
| 3579 } | |
| 3580 | |
| 3581 if (ret == NOTDONE) | |
| 3582 { | |
| 3583 /* | |
| 3584 * Must be a variable or function name. | |
| 3585 * Can also be a curly-braces kind of name: {expr}. | |
| 3586 */ | |
| 3587 s = *arg; | |
| 159 | 3588 len = get_name_len(arg, &alias, evaluate, TRUE); |
| 100 | 3589 if (alias != NULL) |
| 3590 s = alias; | |
| 3591 | |
| 159 | 3592 if (len <= 0) |
| 100 | 3593 ret = FAIL; |
| 3594 else | |
| 3595 { | |
|
21305
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3596 int flags = evalarg == NULL ? 0 : evalarg->eval_flags; |
|
91d4af3309e7
patch 8.2.1203: unused assignments in expression evaluation
Bram Moolenaar <Bram@vim.org>
parents:
21279
diff
changeset
|
3597 |
|
24426
78343859f42d
patch 8.2.2753: Vim9: cannot ignore an item in assignment unpack
Bram Moolenaar <Bram@vim.org>
parents:
24408
diff
changeset
|
3598 if (evaluate && in_vim9script() && len == 1 && *s == '_') |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24363
diff
changeset
|
3599 { |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24363
diff
changeset
|
3600 emsg(_(e_cannot_use_underscore_here)); |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24363
diff
changeset
|
3601 ret = FAIL; |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24363
diff
changeset
|
3602 } |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24363
diff
changeset
|
3603 else if ((in_vim9script() ? **arg : *skipwhite(*arg)) == '(') |
|
21656
c3f6006bf0ba
patch 8.2.1378: cannot put space between function name and paren
Bram Moolenaar <Bram@vim.org>
parents:
21644
diff
changeset
|
3604 { |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
3605 // "name(..." recursive! |
|
21656
c3f6006bf0ba
patch 8.2.1378: cannot put space between function name and paren
Bram Moolenaar <Bram@vim.org>
parents:
21644
diff
changeset
|
3606 *arg = skipwhite(*arg); |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
3607 ret = eval_func(arg, evalarg, s, len, rettv, flags, NULL); |
|
21656
c3f6006bf0ba
patch 8.2.1378: cannot put space between function name and paren
Bram Moolenaar <Bram@vim.org>
parents:
21644
diff
changeset
|
3608 } |
|
20401
918b9a05cf35
patch 8.2.0755: Vim9: No error when variable initializer is not a constant
Bram Moolenaar <Bram@vim.org>
parents:
20397
diff
changeset
|
3609 else if (flags & EVAL_CONSTANT) |
|
918b9a05cf35
patch 8.2.0755: Vim9: No error when variable initializer is not a constant
Bram Moolenaar <Bram@vim.org>
parents:
20397
diff
changeset
|
3610 ret = FAIL; |
| 100 | 3611 else if (evaluate) |
|
21307
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3612 { |
|
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3613 // get the value of "true", "false" or a variable |
|
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3614 if (len == 4 && in_vim9script() && STRNCMP(s, "true", 4) == 0) |
|
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3615 { |
|
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3616 rettv->v_type = VAR_BOOL; |
|
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3617 rettv->vval.v_number = VVAL_TRUE; |
|
21725
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3618 ret = OK; |
|
21307
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3619 } |
|
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3620 else if (len == 5 && in_vim9script() |
|
23499
fe868a6d2e0a
patch 8.2.2292: Vim: expr test fails
Bram Moolenaar <Bram@vim.org>
parents:
23495
diff
changeset
|
3621 && STRNCMP(s, "false", 5) == 0) |
|
21307
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3622 { |
|
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3623 rettv->v_type = VAR_BOOL; |
|
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3624 rettv->vval.v_number = VVAL_FALSE; |
|
21725
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3625 ret = OK; |
|
21307
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3626 } |
|
23499
fe868a6d2e0a
patch 8.2.2292: Vim: expr test fails
Bram Moolenaar <Bram@vim.org>
parents:
23495
diff
changeset
|
3627 else if (len == 4 && in_vim9script() |
|
fe868a6d2e0a
patch 8.2.2292: Vim: expr test fails
Bram Moolenaar <Bram@vim.org>
parents:
23495
diff
changeset
|
3628 && STRNCMP(s, "null", 4) == 0) |
|
fe868a6d2e0a
patch 8.2.2292: Vim: expr test fails
Bram Moolenaar <Bram@vim.org>
parents:
23495
diff
changeset
|
3629 { |
|
fe868a6d2e0a
patch 8.2.2292: Vim: expr test fails
Bram Moolenaar <Bram@vim.org>
parents:
23495
diff
changeset
|
3630 rettv->v_type = VAR_SPECIAL; |
|
fe868a6d2e0a
patch 8.2.2292: Vim: expr test fails
Bram Moolenaar <Bram@vim.org>
parents:
23495
diff
changeset
|
3631 rettv->vval.v_number = VVAL_NULL; |
|
fe868a6d2e0a
patch 8.2.2292: Vim: expr test fails
Bram Moolenaar <Bram@vim.org>
parents:
23495
diff
changeset
|
3632 ret = OK; |
|
fe868a6d2e0a
patch 8.2.2292: Vim: expr test fails
Bram Moolenaar <Bram@vim.org>
parents:
23495
diff
changeset
|
3633 } |
|
21307
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3634 else |
|
24112
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
3635 ret = eval_variable(s, len, rettv, NULL, |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
3636 EVAL_VAR_VERBOSE + EVAL_VAR_IMPORT); |
|
21307
b991565745fb
patch 8.2.1204: Vim9: true and false not recognized in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
21305
diff
changeset
|
3637 } |
| 117 | 3638 else |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
3639 { |
|
21120
4d844a65183d
patch 8.2.1111: inconsistent naming of get_list_tv() and eval_dict()
Bram Moolenaar <Bram@vim.org>
parents:
21118
diff
changeset
|
3640 // skip the name |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
3641 check_vars(s, len); |
| 117 | 3642 ret = OK; |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
3643 } |
| 100 | 3644 } |
| 2690 | 3645 vim_free(alias); |
| 100 | 3646 } |
| 3647 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3648 // Handle following '[', '(' and '.' for expr[expr], expr.name, |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3649 // expr(expr), expr->name(expr) |
| 159 | 3650 if (ret == OK) |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
3651 ret = handle_subscript(arg, rettv, evalarg, TRUE); |
| 7 | 3652 |
| 3653 /* | |
| 3654 * Apply logical NOT and unary '-', from right to left, ignore '+'. | |
| 3655 */ | |
| 3656 if (ret == OK && evaluate && end_leader > start_leader) | |
|
21032
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3657 ret = eval7_leader(rettv, FALSE, start_leader, &end_leader); |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3658 return ret; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3659 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3660 |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3661 /* |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3662 * Apply the leading "!" and "-" before an eval7 expression to "rettv". |
|
21032
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3663 * When "numeric_only" is TRUE only handle "+" and "-". |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3664 * Adjusts "end_leaderp" until it is at "start_leader". |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3665 */ |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3666 static int |
|
21032
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3667 eval7_leader( |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3668 typval_T *rettv, |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3669 int numeric_only, |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3670 char_u *start_leader, |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3671 char_u **end_leaderp) |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3672 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3673 char_u *end_leader = *end_leaderp; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3674 int ret = OK; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3675 int error = FALSE; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3676 varnumber_T val = 0; |
|
21725
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3677 vartype_T type = rettv->v_type; |
| 1624 | 3678 #ifdef FEAT_FLOAT |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3679 float_T f = 0.0; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3680 |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3681 if (rettv->v_type == VAR_FLOAT) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3682 f = rettv->vval.v_float; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3683 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3684 #endif |
|
22606
336ac63fb987
patch 8.2.1851: Vim9: "!" followed by space incorrectly used
Bram Moolenaar <Bram@vim.org>
parents:
22580
diff
changeset
|
3685 { |
|
336ac63fb987
patch 8.2.1851: Vim9: "!" followed by space incorrectly used
Bram Moolenaar <Bram@vim.org>
parents:
22580
diff
changeset
|
3686 while (VIM_ISWHITE(end_leader[-1])) |
|
336ac63fb987
patch 8.2.1851: Vim9: "!" followed by space incorrectly used
Bram Moolenaar <Bram@vim.org>
parents:
22580
diff
changeset
|
3687 --end_leader; |
|
21733
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
3688 if (in_vim9script() && end_leader[-1] == '!') |
|
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
3689 val = tv2bool(rettv); |
|
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
3690 else |
|
1bb5adfe5966
patch 8.2.1416: Vim9: boolean evaluation does not work as intended
Bram Moolenaar <Bram@vim.org>
parents:
21725
diff
changeset
|
3691 val = tv_get_number_chk(rettv, &error); |
|
22606
336ac63fb987
patch 8.2.1851: Vim9: "!" followed by space incorrectly used
Bram Moolenaar <Bram@vim.org>
parents:
22580
diff
changeset
|
3692 } |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3693 if (error) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3694 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3695 clear_tv(rettv); |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3696 ret = FAIL; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3697 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3698 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3699 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3700 while (end_leader > start_leader) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3701 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3702 --end_leader; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3703 if (*end_leader == '!') |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3704 { |
|
21032
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3705 if (numeric_only) |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3706 { |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3707 ++end_leader; |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3708 break; |
|
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
3709 } |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3710 #ifdef FEAT_FLOAT |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3711 if (rettv->v_type == VAR_FLOAT) |
|
22866
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3712 { |
|
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3713 if (in_vim9script()) |
|
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3714 { |
|
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3715 rettv->v_type = VAR_BOOL; |
|
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3716 val = f == 0.0 ? VVAL_TRUE : VVAL_FALSE; |
|
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3717 } |
|
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3718 else |
|
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3719 f = !f; |
|
52e64d340a98
patch 8.2.1980: Vim9: some tests are not done at the script level
Bram Moolenaar <Bram@vim.org>
parents:
22816
diff
changeset
|
3720 } |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3721 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3722 #endif |
|
21725
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3723 { |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3724 val = !val; |
|
21725
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3725 type = VAR_BOOL; |
|
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3726 } |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3727 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3728 else if (*end_leader == '-') |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3729 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3730 #ifdef FEAT_FLOAT |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3731 if (rettv->v_type == VAR_FLOAT) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3732 f = -f; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3733 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3734 #endif |
|
21725
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3735 { |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3736 val = -val; |
|
21725
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3737 type = VAR_NUMBER; |
|
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3738 } |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3739 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3740 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3741 #ifdef FEAT_FLOAT |
| 1624 | 3742 if (rettv->v_type == VAR_FLOAT) |
| 323 | 3743 { |
| 3744 clear_tv(rettv); | |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3745 rettv->vval.v_float = f; |
| 323 | 3746 } |
| 3747 else | |
| 1624 | 3748 #endif |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3749 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3750 clear_tv(rettv); |
|
21725
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3751 if (in_vim9script()) |
|
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3752 rettv->v_type = type; |
|
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3753 else |
|
741c1d58d50f
patch 8.2.1412: Vim: not operator does not result in boolean
Bram Moolenaar <Bram@vim.org>
parents:
21691
diff
changeset
|
3754 rettv->v_type = VAR_NUMBER; |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3755 rettv->vval.v_number = val; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3756 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3757 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
3758 *end_leaderp = end_leader; |
| 7 | 3759 return ret; |
| 3760 } | |
| 3761 | |
| 3762 /* | |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3763 * Call the function referred to in "rettv". |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3764 */ |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3765 static int |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3766 call_func_rettv( |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3767 char_u **arg, |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
3768 evalarg_T *evalarg, |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3769 typval_T *rettv, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3770 int evaluate, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3771 dict_T *selfdict, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3772 typval_T *basetv) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3773 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3774 partial_T *pt = NULL; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3775 funcexe_T funcexe; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3776 typval_T functv; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3777 char_u *s; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3778 int ret; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3779 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3780 // need to copy the funcref so that we can clear rettv |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3781 if (evaluate) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3782 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3783 functv = *rettv; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3784 rettv->v_type = VAR_UNKNOWN; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3785 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3786 // Invoke the function. Recursive! |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3787 if (functv.v_type == VAR_PARTIAL) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3788 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3789 pt = functv.vval.v_partial; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3790 s = partial_name(pt); |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3791 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3792 else |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3793 s = functv.vval.v_string; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3794 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3795 else |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3796 s = (char_u *)""; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3797 |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
3798 CLEAR_FIELD(funcexe); |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3799 funcexe.firstline = curwin->w_cursor.lnum; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3800 funcexe.lastline = curwin->w_cursor.lnum; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3801 funcexe.evaluate = evaluate; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3802 funcexe.partial = pt; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3803 funcexe.selfdict = selfdict; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3804 funcexe.basetv = basetv; |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
3805 ret = get_func_tv(s, -1, rettv, arg, evalarg, &funcexe); |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3806 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3807 // Clear the funcref afterwards, so that deleting it while |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3808 // evaluating the arguments is possible (see test55). |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3809 if (evaluate) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3810 clear_tv(&functv); |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3811 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3812 return ret; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3813 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3814 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3815 /* |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3816 * Evaluate "->method()". |
|
23709
a0c4d04a58c4
patch 8.2.2396: Vim9: no white space allowed before "->"
Bram Moolenaar <Bram@vim.org>
parents:
23679
diff
changeset
|
3817 * "*arg" points to "method". |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3818 * Returns FAIL or OK. "*arg" is advanced to after the ')'. |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3819 */ |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3820 static int |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3821 eval_lambda( |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3822 char_u **arg, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3823 typval_T *rettv, |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
3824 evalarg_T *evalarg, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3825 int verbose) // give error messages |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3826 { |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
3827 int evaluate = evalarg != NULL |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
3828 && (evalarg->eval_flags & EVAL_EVALUATE); |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3829 typval_T base = *rettv; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3830 int ret; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3831 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3832 rettv->v_type = VAR_UNKNOWN; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3833 |
|
23428
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3834 if (**arg == '{') |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3835 { |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3836 // ->{lambda}() |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3837 ret = get_lambda_tv(arg, rettv, FALSE, evalarg); |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3838 } |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3839 else |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3840 { |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3841 // ->(lambda)() |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3842 ++*arg; |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3843 ret = eval1(arg, rettv, evalarg); |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3844 *arg = skipwhite_and_linebreak(*arg, evalarg); |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3845 if (**arg != ')') |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3846 { |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3847 emsg(_(e_missing_close)); |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3848 ret = FAIL; |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3849 } |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3850 ++*arg; |
|
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
3851 } |
|
18851
3cf9529b3a4a
patch 8.1.2412: crash when evaluating expression with error
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
3852 if (ret != OK) |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3853 return FAIL; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3854 else if (**arg != '(') |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3855 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3856 if (verbose) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3857 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3858 if (*skipwhite(*arg) == '(') |
|
19760
9daed26b788b
patch 8.2.0436: no warnings for incorrect printf arguments
Bram Moolenaar <Bram@vim.org>
parents:
19568
diff
changeset
|
3859 emsg(_(e_nowhitespace)); |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3860 else |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3861 semsg(_(e_missing_paren), "lambda"); |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3862 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3863 clear_tv(rettv); |
|
18225
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3864 ret = FAIL; |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3865 } |
|
18225
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3866 else |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
3867 ret = call_func_rettv(arg, evalarg, rettv, evaluate, NULL, &base); |
|
18225
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3868 |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3869 // Clear the funcref afterwards, so that deleting it while |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3870 // evaluating the arguments is possible (see test55). |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3871 if (evaluate) |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3872 clear_tv(&base); |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3873 |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
3874 return ret; |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3875 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3876 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3877 /* |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3878 * Evaluate "->method()". |
|
23709
a0c4d04a58c4
patch 8.2.2396: Vim9: no white space allowed before "->"
Bram Moolenaar <Bram@vim.org>
parents:
23679
diff
changeset
|
3879 * "*arg" points to "method". |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3880 * Returns FAIL or OK. "*arg" is advanced to after the ')'. |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3881 */ |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3882 static int |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3883 eval_method( |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3884 char_u **arg, |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3885 typval_T *rettv, |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
3886 evalarg_T *evalarg, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3887 int verbose) // give error messages |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3888 { |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3889 char_u *name; |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3890 long len; |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3891 char_u *alias; |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3892 typval_T base = *rettv; |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3893 int ret; |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
3894 int evaluate = evalarg != NULL |
|
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
3895 && (evalarg->eval_flags & EVAL_EVALUATE); |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3896 |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3897 rettv->v_type = VAR_UNKNOWN; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3898 |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3899 name = *arg; |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3900 len = get_name_len(arg, &alias, evaluate, TRUE); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3901 if (alias != NULL) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3902 name = alias; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3903 |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3904 if (len <= 0) |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3905 { |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3906 if (verbose) |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3907 emsg(_("E260: Missing name after ->")); |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3908 ret = FAIL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3909 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3910 else |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3911 { |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
3912 *arg = skipwhite(*arg); |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3913 if (**arg != '(') |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3914 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3915 if (verbose) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3916 semsg(_(e_missing_paren), name); |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3917 ret = FAIL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3918 } |
|
17661
da7890e3359b
patch 8.1.1828: not strict enough checking syntax of method invocation
Bram Moolenaar <Bram@vim.org>
parents:
17646
diff
changeset
|
3919 else if (VIM_ISWHITE((*arg)[-1])) |
|
da7890e3359b
patch 8.1.1828: not strict enough checking syntax of method invocation
Bram Moolenaar <Bram@vim.org>
parents:
17646
diff
changeset
|
3920 { |
|
da7890e3359b
patch 8.1.1828: not strict enough checking syntax of method invocation
Bram Moolenaar <Bram@vim.org>
parents:
17646
diff
changeset
|
3921 if (verbose) |
|
19760
9daed26b788b
patch 8.2.0436: no warnings for incorrect printf arguments
Bram Moolenaar <Bram@vim.org>
parents:
19568
diff
changeset
|
3922 emsg(_(e_nowhitespace)); |
|
17661
da7890e3359b
patch 8.1.1828: not strict enough checking syntax of method invocation
Bram Moolenaar <Bram@vim.org>
parents:
17646
diff
changeset
|
3923 ret = FAIL; |
|
da7890e3359b
patch 8.1.1828: not strict enough checking syntax of method invocation
Bram Moolenaar <Bram@vim.org>
parents:
17646
diff
changeset
|
3924 } |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3925 else |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
3926 ret = eval_func(arg, evalarg, name, len, rettv, |
|
20397
c225be44692a
patch 8.2.0753: Vim9: expressions are evaluated in the discovery phase
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
3927 evaluate ? EVAL_EVALUATE : 0, &base); |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
3928 } |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3929 |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3930 // Clear the funcref afterwards, so that deleting it while |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
3931 // evaluating the arguments is possible (see test55). |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3932 if (evaluate) |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3933 clear_tv(&base); |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3934 |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3935 return ret; |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3936 } |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3937 |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
3938 /* |
| 829 | 3939 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key". |
| 3940 * "*arg" points to the '[' or '.'. | |
| 56 | 3941 * Returns FAIL or OK. "*arg" is advanced to after the ']'. |
| 3942 */ | |
| 3943 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3944 eval_index( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3945 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3946 typval_T *rettv, |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
3947 evalarg_T *evalarg, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3948 int verbose) // give error messages |
| 56 | 3949 { |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
3950 int evaluate = evalarg != NULL |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
3951 && (evalarg->eval_flags & EVAL_EVALUATE); |
| 56 | 3952 int empty1 = FALSE, empty2 = FALSE; |
| 137 | 3953 typval_T var1, var2; |
| 100 | 3954 int range = FALSE; |
| 3955 char_u *key = NULL; | |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
3956 int keylen = -1; |
|
23414
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
3957 int vim9 = in_vim9script(); |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
3958 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
3959 if (check_can_index(rettv, evaluate, verbose) == FAIL) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
3960 return FAIL; |
| 56 | 3961 |
|
7046
fd409a0800fd
commit https://github.com/vim/vim/commit/0a38dd29d6f65aa601162542a5ab0ba7f308fc8e
Christian Brabandt <cb@256bit.org>
parents:
7042
diff
changeset
|
3962 init_tv(&var1); |
|
fd409a0800fd
commit https://github.com/vim/vim/commit/0a38dd29d6f65aa601162542a5ab0ba7f308fc8e
Christian Brabandt <cb@256bit.org>
parents:
7042
diff
changeset
|
3963 init_tv(&var2); |
| 100 | 3964 if (**arg == '.') |
| 3965 { | |
| 3966 /* | |
| 3967 * dict.name | |
| 3968 */ | |
| 3969 key = *arg + 1; | |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
3970 for (keylen = 0; eval_isdictc(key[keylen]); ++keylen) |
| 100 | 3971 ; |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
3972 if (keylen == 0) |
| 100 | 3973 return FAIL; |
|
22244
9f6b8fdea159
patch 8.2.1671: Vim9: stray error for missing white space
Bram Moolenaar <Bram@vim.org>
parents:
22202
diff
changeset
|
3974 *arg = key + keylen; |
| 100 | 3975 } |
| 3976 else | |
| 3977 { | |
| 3978 /* | |
| 3979 * something[idx] | |
| 3980 * | |
| 3981 * Get the (first) variable from inside the []. | |
| 3982 */ | |
|
21142
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
3983 *arg = skipwhite_and_linebreak(*arg + 1, evalarg); |
| 100 | 3984 if (**arg == ':') |
| 3985 empty1 = TRUE; | |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
3986 else if (eval1(arg, &var1, evalarg) == FAIL) // recursive! |
| 56 | 3987 return FAIL; |
|
23414
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
3988 else if (vim9 && **arg == ':') |
|
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
3989 { |
|
23446
b1dbbc81a011
patch 8.2.2266: Vim9: it can be hard to see where white space is missing
Bram Moolenaar <Bram@vim.org>
parents:
23428
diff
changeset
|
3990 semsg(_(e_white_space_required_before_and_after_str_at_str), |
|
b1dbbc81a011
patch 8.2.2266: Vim9: it can be hard to see where white space is missing
Bram Moolenaar <Bram@vim.org>
parents:
23428
diff
changeset
|
3991 ":", *arg); |
|
23414
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
3992 clear_tv(&var1); |
|
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
3993 return FAIL; |
|
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
3994 } |
|
23827
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
3995 else if (evaluate) |
| 323 | 3996 { |
|
23827
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
3997 #ifdef FEAT_FLOAT |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
3998 // allow for indexing with float |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
3999 if (vim9 && rettv->v_type == VAR_DICT |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4000 && var1.v_type == VAR_FLOAT) |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4001 { |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4002 var1.vval.v_string = typval_tostring(&var1, TRUE); |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4003 var1.v_type = VAR_STRING; |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4004 } |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4005 #endif |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4006 if (tv_get_string_chk(&var1) == NULL) |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4007 { |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4008 // not a number or string |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4009 clear_tv(&var1); |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4010 return FAIL; |
|
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23709
diff
changeset
|
4011 } |
| 323 | 4012 } |
| 100 | 4013 |
| 4014 /* | |
| 4015 * Get the second variable from inside the [:]. | |
| 4016 */ | |
|
21142
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
4017 *arg = skipwhite_and_linebreak(*arg, evalarg); |
| 100 | 4018 if (**arg == ':') |
| 4019 { | |
| 4020 range = TRUE; | |
|
23414
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
4021 ++*arg; |
|
23416
108039938e3c
patch 8.2.2251: test failures in legacy script
Bram Moolenaar <Bram@vim.org>
parents:
23414
diff
changeset
|
4022 if (vim9 && !IS_WHITE_OR_NUL(**arg) && **arg != ']') |
|
23414
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
4023 { |
|
23446
b1dbbc81a011
patch 8.2.2266: Vim9: it can be hard to see where white space is missing
Bram Moolenaar <Bram@vim.org>
parents:
23428
diff
changeset
|
4024 semsg(_(e_white_space_required_before_and_after_str_at_str), |
|
b1dbbc81a011
patch 8.2.2266: Vim9: it can be hard to see where white space is missing
Bram Moolenaar <Bram@vim.org>
parents:
23428
diff
changeset
|
4025 ":", *arg - 1); |
|
23414
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
4026 if (!empty1) |
|
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
4027 clear_tv(&var1); |
|
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
4028 return FAIL; |
|
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
4029 } |
|
9bd3873b13e2
patch 8.2.2250: Vim9: sublist is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23338
diff
changeset
|
4030 *arg = skipwhite_and_linebreak(*arg, evalarg); |
| 100 | 4031 if (**arg == ']') |
| 4032 empty2 = TRUE; | |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
4033 else if (eval1(arg, &var2, evalarg) == FAIL) // recursive! |
| 100 | 4034 { |
| 323 | 4035 if (!empty1) |
| 4036 clear_tv(&var1); | |
| 4037 return FAIL; | |
| 4038 } | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
4039 else if (evaluate && tv_get_string_chk(&var2) == NULL) |
| 323 | 4040 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4041 // not a number or string |
| 323 | 4042 if (!empty1) |
| 4043 clear_tv(&var1); | |
| 4044 clear_tv(&var2); | |
| 100 | 4045 return FAIL; |
| 4046 } | |
| 4047 } | |
| 4048 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4049 // Check for the ']'. |
|
21142
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
4050 *arg = skipwhite_and_linebreak(*arg, evalarg); |
| 100 | 4051 if (**arg != ']') |
| 4052 { | |
| 159 | 4053 if (verbose) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
4054 emsg(_(e_missbrac)); |
| 100 | 4055 clear_tv(&var1); |
| 4056 if (range) | |
| 4057 clear_tv(&var2); | |
| 4058 return FAIL; | |
| 4059 } | |
|
21837
2b941fbab4d9
patch 8.2.1468: Vim9: invalid error for missing white space
Bram Moolenaar <Bram@vim.org>
parents:
21833
diff
changeset
|
4060 *arg = *arg + 1; // skip over the ']' |
| 56 | 4061 } |
| 4062 | |
| 4063 if (evaluate) | |
| 4064 { | |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4065 int res = eval_index_inner(rettv, range, |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4066 empty1 ? NULL : &var1, empty2 ? NULL : &var2, FALSE, |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4067 key, keylen, verbose); |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4068 |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4069 if (!empty1) |
| 71 | 4070 clear_tv(&var1); |
| 56 | 4071 if (range) |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4072 clear_tv(&var2); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4073 return res; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4074 } |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4075 return OK; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4076 } |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4077 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4078 /* |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4079 * Check if "rettv" can have an [index] or [sli:ce] |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4080 */ |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4081 int |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4082 check_can_index(typval_T *rettv, int evaluate, int verbose) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4083 { |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4084 switch (rettv->v_type) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4085 { |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4086 case VAR_FUNC: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4087 case VAR_PARTIAL: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4088 if (verbose) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4089 emsg(_("E695: Cannot index a Funcref")); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4090 return FAIL; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4091 case VAR_FLOAT: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4092 #ifdef FEAT_FLOAT |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4093 if (verbose) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4094 emsg(_(e_float_as_string)); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4095 return FAIL; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4096 #endif |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4097 case VAR_BOOL: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4098 case VAR_SPECIAL: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4099 case VAR_JOB: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4100 case VAR_CHANNEL: |
|
24606
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
4101 case VAR_INSTR: |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4102 if (verbose) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4103 emsg(_(e_cannot_index_special_variable)); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4104 return FAIL; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4105 case VAR_UNKNOWN: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4106 case VAR_ANY: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4107 case VAR_VOID: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4108 if (evaluate) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4109 { |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4110 emsg(_(e_cannot_index_special_variable)); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4111 return FAIL; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4112 } |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4113 // FALLTHROUGH |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4114 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4115 case VAR_STRING: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4116 case VAR_LIST: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4117 case VAR_DICT: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4118 case VAR_BLOB: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4119 break; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4120 case VAR_NUMBER: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4121 if (in_vim9script()) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4122 emsg(_(e_cannot_index_number)); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4123 break; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4124 } |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4125 return OK; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4126 } |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4127 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4128 /* |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4129 * slice() function |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4130 */ |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4131 void |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4132 f_slice(typval_T *argvars, typval_T *rettv) |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4133 { |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4134 if (check_can_index(argvars, TRUE, FALSE) == OK) |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4135 { |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4136 copy_tv(argvars, rettv); |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4137 eval_index_inner(rettv, TRUE, argvars + 1, |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4138 argvars[2].v_type == VAR_UNKNOWN ? NULL : argvars + 2, |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4139 TRUE, NULL, 0, FALSE); |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4140 } |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4141 } |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4142 |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4143 /* |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4144 * Apply index or range to "rettv". |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4145 * "var1" is the first index, NULL for [:expr]. |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4146 * "var2" is the second index, NULL for [expr] and [expr: ] |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4147 * "exclusive" is TRUE for slice(): second index is exclusive, use character |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4148 * index for string. |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4149 * Alternatively, "key" is not NULL, then key[keylen] is the dict index. |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4150 */ |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4151 int |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4152 eval_index_inner( |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4153 typval_T *rettv, |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4154 int is_range, |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4155 typval_T *var1, |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4156 typval_T *var2, |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4157 int exclusive, |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4158 char_u *key, |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4159 int keylen, |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4160 int verbose) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4161 { |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4162 varnumber_T n1, n2 = 0; |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4163 long len; |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4164 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4165 n1 = 0; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4166 if (var1 != NULL && rettv->v_type != VAR_DICT) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4167 n1 = tv_get_number(var1); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4168 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4169 if (is_range) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4170 { |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4171 if (rettv->v_type == VAR_DICT) |
| 56 | 4172 { |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4173 if (verbose) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4174 emsg(_(e_cannot_slice_dictionary)); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4175 return FAIL; |
| 71 | 4176 } |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4177 if (var2 != NULL) |
|
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4178 n2 = tv_get_number(var2); |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4179 else |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4180 n2 = VARNUM_MAX; |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4181 } |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4182 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4183 switch (rettv->v_type) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4184 { |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4185 case VAR_UNKNOWN: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4186 case VAR_ANY: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4187 case VAR_VOID: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4188 case VAR_FUNC: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4189 case VAR_PARTIAL: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4190 case VAR_FLOAT: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4191 case VAR_BOOL: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4192 case VAR_SPECIAL: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4193 case VAR_JOB: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4194 case VAR_CHANNEL: |
|
24606
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
4195 case VAR_INSTR: |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4196 break; // not evaluating, skipping over subscript |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4197 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4198 case VAR_NUMBER: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4199 case VAR_STRING: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4200 { |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4201 char_u *s = tv_get_string(rettv); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4202 |
| 56 | 4203 len = (long)STRLEN(s); |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4204 if (in_vim9script() || exclusive) |
|
21826
ccad66ac6c3e
patch 8.2.1462: Vim9: string slice not supported yet
Bram Moolenaar <Bram@vim.org>
parents:
21823
diff
changeset
|
4205 { |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4206 if (is_range) |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4207 s = string_slice(s, n1, n2, exclusive); |
|
21826
ccad66ac6c3e
patch 8.2.1462: Vim9: string slice not supported yet
Bram Moolenaar <Bram@vim.org>
parents:
21823
diff
changeset
|
4208 else |
|
ccad66ac6c3e
patch 8.2.1462: Vim9: string slice not supported yet
Bram Moolenaar <Bram@vim.org>
parents:
21823
diff
changeset
|
4209 s = char_from_string(s, n1); |
|
ccad66ac6c3e
patch 8.2.1462: Vim9: string slice not supported yet
Bram Moolenaar <Bram@vim.org>
parents:
21823
diff
changeset
|
4210 } |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4211 else if (is_range) |
| 56 | 4212 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4213 // The resulting variable is a substring. If the indexes |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4214 // are out of range the result is empty. |
| 56 | 4215 if (n1 < 0) |
| 4216 { | |
| 4217 n1 = len + n1; | |
| 4218 if (n1 < 0) | |
| 4219 n1 = 0; | |
| 4220 } | |
| 4221 if (n2 < 0) | |
| 4222 n2 = len + n2; | |
| 4223 else if (n2 >= len) | |
| 4224 n2 = len; | |
| 4225 if (n1 >= len || n2 < 0 || n1 > n2) | |
| 4226 s = NULL; | |
| 4227 else | |
|
20751
d9a2e5dcfd9f
patch 8.2.0928: many type casts are used for vim_strnsave()
Bram Moolenaar <Bram@vim.org>
parents:
20731
diff
changeset
|
4228 s = vim_strnsave(s + n1, n2 - n1 + 1); |
| 56 | 4229 } |
| 4230 else | |
| 4231 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4232 // The resulting variable is a string of a single |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4233 // character. If the index is too big or negative the |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4234 // result is empty. |
| 56 | 4235 if (n1 >= len || n1 < 0) |
| 4236 s = NULL; | |
| 4237 else | |
| 4238 s = vim_strnsave(s + n1, 1); | |
| 4239 } | |
| 71 | 4240 clear_tv(rettv); |
| 4241 rettv->v_type = VAR_STRING; | |
| 4242 rettv->vval.v_string = s; | |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4243 } |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4244 break; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4245 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4246 case VAR_BLOB: |
|
24432
aa150abca273
patch 8.2.2756: Vim9: blob index and slice not implemented yet
Bram Moolenaar <Bram@vim.org>
parents:
24426
diff
changeset
|
4247 blob_slice_or_index(rettv->vval.v_blob, is_range, n1, n2, |
|
aa150abca273
patch 8.2.2756: Vim9: blob index and slice not implemented yet
Bram Moolenaar <Bram@vim.org>
parents:
24426
diff
changeset
|
4248 exclusive, rettv); |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4249 break; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4250 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4251 case VAR_LIST: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4252 if (var1 == NULL) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4253 n1 = 0; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4254 if (var2 == NULL) |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4255 n2 = VARNUM_MAX; |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4256 if (list_slice_or_index(rettv->vval.v_list, |
|
23604
1816ea68c022
patch 8.2.2344: using inclusive index for slice is not always desired
Bram Moolenaar <Bram@vim.org>
parents:
23600
diff
changeset
|
4257 is_range, n1, n2, exclusive, rettv, verbose) == FAIL) |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4258 return FAIL; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4259 break; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4260 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4261 case VAR_DICT: |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4262 { |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4263 dictitem_T *item; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4264 typval_T tmp; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4265 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4266 if (key == NULL) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4267 { |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4268 key = tv_get_string_chk(var1); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4269 if (key == NULL) |
| 100 | 4270 return FAIL; |
| 4271 } | |
|
21833
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4272 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4273 item = dict_find(rettv->vval.v_dict, key, (int)keylen); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4274 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4275 if (item == NULL && verbose) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4276 semsg(_(e_dictkey), key); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4277 if (item == NULL) |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4278 return FAIL; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4279 |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4280 copy_tv(&item->di_tv, &tmp); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4281 clear_tv(rettv); |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4282 *rettv = tmp; |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4283 } |
|
e3f9528bddda
patch 8.2.1466: Vim9: cannot index or slice a variable with type "any"
Bram Moolenaar <Bram@vim.org>
parents:
21831
diff
changeset
|
4284 break; |
| 100 | 4285 } |
| 56 | 4286 return OK; |
| 4287 } | |
| 4288 | |
| 4289 /* | |
|
19922
1f42c49c3d29
patch 8.2.0517: Vim9: cannot separate "func" and "func(): void"
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
4290 * Return the function name of partial "pt". |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4291 */ |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4292 char_u * |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4293 partial_name(partial_T *pt) |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4294 { |
|
24618
4aebea72c397
patch 8.2.2848: crash whn calling partial
Bram Moolenaar <Bram@vim.org>
parents:
24614
diff
changeset
|
4295 if (pt != NULL) |
|
4aebea72c397
patch 8.2.2848: crash whn calling partial
Bram Moolenaar <Bram@vim.org>
parents:
24614
diff
changeset
|
4296 { |
|
4aebea72c397
patch 8.2.2848: crash whn calling partial
Bram Moolenaar <Bram@vim.org>
parents:
24614
diff
changeset
|
4297 if (pt->pt_name != NULL) |
|
4aebea72c397
patch 8.2.2848: crash whn calling partial
Bram Moolenaar <Bram@vim.org>
parents:
24614
diff
changeset
|
4298 return pt->pt_name; |
|
4aebea72c397
patch 8.2.2848: crash whn calling partial
Bram Moolenaar <Bram@vim.org>
parents:
24614
diff
changeset
|
4299 if (pt->pt_func != NULL) |
|
4aebea72c397
patch 8.2.2848: crash whn calling partial
Bram Moolenaar <Bram@vim.org>
parents:
24614
diff
changeset
|
4300 return pt->pt_func->uf_name; |
|
4aebea72c397
patch 8.2.2848: crash whn calling partial
Bram Moolenaar <Bram@vim.org>
parents:
24614
diff
changeset
|
4301 } |
|
20158
94f05de75e9f
patch 8.2.0634: crash with null partial and blob
Bram Moolenaar <Bram@vim.org>
parents:
20156
diff
changeset
|
4302 return (char_u *)""; |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4303 } |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4304 |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4305 static void |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4306 partial_free(partial_T *pt) |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4307 { |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4308 int i; |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4309 |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4310 for (i = 0; i < pt->pt_argc; ++i) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4311 clear_tv(&pt->pt_argv[i]); |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4312 vim_free(pt->pt_argv); |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4313 dict_unref(pt->pt_dict); |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4314 if (pt->pt_name != NULL) |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4315 { |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4316 func_unref(pt->pt_name); |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4317 vim_free(pt->pt_name); |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4318 } |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4319 else |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4320 func_ptr_unref(pt->pt_func); |
|
20257
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4321 |
|
22541
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4322 // Decrease the reference count for the context of a closure. If down |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4323 // to the minimum it may be time to free it. |
|
20257
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4324 if (pt->pt_funcstack != NULL) |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4325 { |
|
22541
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4326 --pt->pt_funcstack->fs_refcount; |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4327 funcstack_check_refcount(pt->pt_funcstack); |
|
20257
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4328 } |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4329 |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4330 vim_free(pt); |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4331 } |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4332 |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4333 /* |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4334 * Unreference a closure: decrement the reference count and free it when it |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4335 * becomes zero. |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4336 */ |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4337 void |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4338 partial_unref(partial_T *pt) |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4339 { |
|
22541
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4340 if (pt != NULL) |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4341 { |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4342 if (--pt->pt_refcount <= 0) |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4343 partial_free(pt); |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4344 |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4345 // If the reference count goes down to one, the funcstack may be the |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4346 // only reference and can be freed if no other partials reference it. |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4347 else if (pt->pt_refcount == 1 && pt->pt_funcstack != NULL) |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4348 funcstack_check_refcount(pt->pt_funcstack); |
|
7d6ba4204f66
patch 8.2.1819: Vim9: Memory leak when using a closure
Bram Moolenaar <Bram@vim.org>
parents:
22529
diff
changeset
|
4349 } |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4350 } |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
4351 |
| 80 | 4352 /* |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4353 * Return the next (unique) copy ID. |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4354 * Used for serializing nested structures. |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4355 */ |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4356 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4357 get_copyID(void) |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4358 { |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4359 current_copyID += COPYID_INC; |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4360 return current_copyID; |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4361 } |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4362 |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4363 /* |
| 371 | 4364 * Garbage collection for lists and dictionaries. |
| 4365 * | |
| 4366 * We use reference counts to be able to free most items right away when they | |
| 4367 * are no longer used. But for composite items it's possible that it becomes | |
| 4368 * unused while the reference count is > 0: When there is a recursive | |
| 4369 * reference. Example: | |
| 4370 * :let l = [1, 2, 3] | |
| 4371 * :let d = {9: l} | |
| 4372 * :let l[1] = d | |
| 4373 * | |
| 4374 * Since this is quite unusual we handle this with garbage collection: every | |
| 4375 * once in a while find out which lists and dicts are not referenced from any | |
| 4376 * variable. | |
| 4377 * | |
| 4378 * Here is a good reference text about garbage collection (refers to Python | |
| 4379 * but it applies to all reference-counting mechanisms): | |
| 4380 * http://python.ca/nas/python/gc/ | |
| 4381 */ | |
| 4382 | |
| 4383 /* | |
| 4384 * Do garbage collection for lists and dicts. | |
|
9108
d319453f62b3
commit https://github.com/vim/vim/commit/574860b5ee9da281c875dad07a607454e135eaee
Christian Brabandt <cb@256bit.org>
parents:
9104
diff
changeset
|
4385 * When "testing" is TRUE this is called from test_garbagecollect_now(). |
| 371 | 4386 * Return TRUE if some memory was freed. |
| 4387 */ | |
| 4388 int | |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
4389 garbage_collect(int testing) |
| 371 | 4390 { |
| 1891 | 4391 int copyID; |
| 6565 | 4392 int abort = FALSE; |
| 371 | 4393 buf_T *buf; |
| 4394 win_T *wp; | |
| 6588 | 4395 int did_free = FALSE; |
| 819 | 4396 tabpage_T *tp; |
| 371 | 4397 |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
4398 if (!testing) |
|
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
4399 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4400 // Only do this once. |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
4401 want_garbage_collect = FALSE; |
|
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
4402 may_garbage_collect = FALSE; |
|
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
4403 garbage_collect_at_exit = FALSE; |
|
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
4404 } |
| 958 | 4405 |
|
19001
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4406 // The execution stack can grow big, limit the size. |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4407 if (exestack.ga_maxlen - exestack.ga_len > 500) |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4408 { |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4409 size_t new_len; |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4410 char_u *pp; |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4411 int n; |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4412 |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4413 // Keep 150% of the current size, with a minimum of the growth size. |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4414 n = exestack.ga_len / 2; |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4415 if (n < exestack.ga_growsize) |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4416 n = exestack.ga_growsize; |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4417 |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4418 // Don't make it bigger though. |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4419 if (exestack.ga_len + n < exestack.ga_maxlen) |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4420 { |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4421 new_len = exestack.ga_itemsize * (exestack.ga_len + n); |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4422 pp = vim_realloc(exestack.ga_data, new_len); |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4423 if (pp == NULL) |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4424 return FAIL; |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4425 exestack.ga_maxlen = exestack.ga_len + n; |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4426 exestack.ga_data = pp; |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4427 } |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4428 } |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
4429 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4430 // We advance by two because we add one for items referenced through |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4431 // previous_funccal. |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4432 copyID = get_copyID(); |
| 1891 | 4433 |
| 371 | 4434 /* |
| 4435 * 1. Go through all accessible variables and mark all lists and dicts | |
| 4436 * with copyID. | |
| 4437 */ | |
| 1891 | 4438 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4439 // Don't free variables in the previous_funccal list unless they are only |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4440 // referenced through previous_funccal. This must be first, because if |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4441 // the item is referenced elsewhere the funccal must not be freed. |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4442 abort = abort || set_ref_in_previous_funccal(copyID); |
| 1891 | 4443 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4444 // script-local variables |
|
17885
5e2d8840da11
patch 8.1.1939: code for handling v: variables in generic eval file
Bram Moolenaar <Bram@vim.org>
parents:
17873
diff
changeset
|
4445 abort = abort || garbage_collect_scriptvars(copyID); |
| 371 | 4446 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4447 // buffer-local variables |
|
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9636
diff
changeset
|
4448 FOR_ALL_BUFFERS(buf) |
| 6565 | 4449 abort = abort || set_ref_in_item(&buf->b_bufvar.di_tv, copyID, |
| 4450 NULL, NULL); | |
| 371 | 4451 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4452 // window-local variables |
| 819 | 4453 FOR_ALL_TAB_WINDOWS(tp, wp) |
| 6565 | 4454 abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID, |
| 4455 NULL, NULL); | |
| 4309 | 4456 if (aucmd_win != NULL) |
| 6565 | 4457 abort = abort || set_ref_in_item(&aucmd_win->w_winvar.di_tv, copyID, |
| 4458 NULL, NULL); | |
|
18763
49b78d6465e5
patch 8.1.2371: FEAT_TEXT_PROP is a confusing name
Bram Moolenaar <Bram@vim.org>
parents:
18713
diff
changeset
|
4459 #ifdef FEAT_PROP_POPUP |
|
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
19874
diff
changeset
|
4460 FOR_ALL_POPUPWINS(wp) |
|
16778
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
4461 abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID, |
|
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
4462 NULL, NULL); |
|
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
4463 FOR_ALL_TABPAGES(tp) |
|
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
19874
diff
changeset
|
4464 FOR_ALL_POPUPWINS_IN_TAB(tp, wp) |
|
16778
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
4465 abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID, |
|
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
4466 NULL, NULL); |
|
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
4467 #endif |
| 371 | 4468 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4469 // tabpage-local variables |
|
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9636
diff
changeset
|
4470 FOR_ALL_TABPAGES(tp) |
| 6565 | 4471 abort = abort || set_ref_in_item(&tp->tp_winvar.di_tv, copyID, |
| 4472 NULL, NULL); | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4473 // global variables |
|
17922
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
4474 abort = abort || garbage_collect_globvars(copyID); |
| 371 | 4475 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4476 // function-local variables |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4477 abort = abort || set_ref_in_call_stack(copyID); |
| 371 | 4478 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4479 // named functions (matters for closures) |
|
9735
8037eb704e93
commit https://github.com/vim/vim/commit/bc7ce675b2d1c9fb58c067eff3edd59abc30aba4
Christian Brabandt <cb@256bit.org>
parents:
9731
diff
changeset
|
4480 abort = abort || set_ref_in_functions(copyID); |
|
8037eb704e93
commit https://github.com/vim/vim/commit/bc7ce675b2d1c9fb58c067eff3edd59abc30aba4
Christian Brabandt <cb@256bit.org>
parents:
9731
diff
changeset
|
4481 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4482 // function call arguments, if v:testing is set. |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4483 abort = abort || set_ref_in_func_args(copyID); |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
4484 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4485 // v: vars |
|
17885
5e2d8840da11
patch 8.1.1939: code for handling v: variables in generic eval file
Bram Moolenaar <Bram@vim.org>
parents:
17873
diff
changeset
|
4486 abort = abort || garbage_collect_vimvars(copyID); |
| 1733 | 4487 |
|
17151
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4488 // callbacks in buffers |
|
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4489 abort = abort || set_ref_in_buffers(copyID); |
|
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4490 |
| 3450 | 4491 #ifdef FEAT_LUA |
| 6565 | 4492 abort = abort || set_ref_in_lua(copyID); |
| 3450 | 4493 #endif |
| 4494 | |
| 3618 | 4495 #ifdef FEAT_PYTHON |
| 6565 | 4496 abort = abort || set_ref_in_python(copyID); |
| 3618 | 4497 #endif |
| 4498 | |
| 4499 #ifdef FEAT_PYTHON3 | |
| 6565 | 4500 abort = abort || set_ref_in_python3(copyID); |
| 4501 #endif | |
| 4502 | |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
4503 #ifdef FEAT_JOB_CHANNEL |
|
8877
50e40f322e78
commit https://github.com/vim/vim/commit/3780bb923a688e0051a9a23474eeb38a8acb695a
Christian Brabandt <cb@256bit.org>
parents:
8870
diff
changeset
|
4504 abort = abort || set_ref_in_channel(copyID); |
|
9058
87c2e43a4a12
commit https://github.com/vim/vim/commit/b8d4905592fc26fcd09180d7d6bfefd899f2f6c6
Christian Brabandt <cb@256bit.org>
parents:
9052
diff
changeset
|
4505 abort = abort || set_ref_in_job(copyID); |
|
7931
2679e636e862
commit https://github.com/vim/vim/commit/4b6a6dcbe7bd13170c4884cc17acb1eac2c633d1
Christian Brabandt <cb@256bit.org>
parents:
7895
diff
changeset
|
4506 #endif |
|
9052
3a6b66c02d6d
commit https://github.com/vim/vim/commit/3266c85a44a637862b0ed6e531680c6ab2897ab5
Christian Brabandt <cb@256bit.org>
parents:
9027
diff
changeset
|
4507 #ifdef FEAT_NETBEANS_INTG |
|
3a6b66c02d6d
commit https://github.com/vim/vim/commit/3266c85a44a637862b0ed6e531680c6ab2897ab5
Christian Brabandt <cb@256bit.org>
parents:
9027
diff
changeset
|
4508 abort = abort || set_ref_in_nb_channel(copyID); |
|
3a6b66c02d6d
commit https://github.com/vim/vim/commit/3266c85a44a637862b0ed6e531680c6ab2897ab5
Christian Brabandt <cb@256bit.org>
parents:
9027
diff
changeset
|
4509 #endif |
|
7931
2679e636e862
commit https://github.com/vim/vim/commit/4b6a6dcbe7bd13170c4884cc17acb1eac2c633d1
Christian Brabandt <cb@256bit.org>
parents:
7895
diff
changeset
|
4510 |
|
9153
c2fe86f2bda1
commit https://github.com/vim/vim/commit/e3188e261569ae512fb1ae2653b57fdd9e259ca3
Christian Brabandt <cb@256bit.org>
parents:
9127
diff
changeset
|
4511 #ifdef FEAT_TIMERS |
|
c2fe86f2bda1
commit https://github.com/vim/vim/commit/e3188e261569ae512fb1ae2653b57fdd9e259ca3
Christian Brabandt <cb@256bit.org>
parents:
9127
diff
changeset
|
4512 abort = abort || set_ref_in_timer(copyID); |
|
c2fe86f2bda1
commit https://github.com/vim/vim/commit/e3188e261569ae512fb1ae2653b57fdd9e259ca3
Christian Brabandt <cb@256bit.org>
parents:
9127
diff
changeset
|
4513 #endif |
|
c2fe86f2bda1
commit https://github.com/vim/vim/commit/e3188e261569ae512fb1ae2653b57fdd9e259ca3
Christian Brabandt <cb@256bit.org>
parents:
9127
diff
changeset
|
4514 |
|
11412
84baca75b7f2
patch 8.0.0590: cannot add a context to locations
Christian Brabandt <cb@256bit.org>
parents:
11323
diff
changeset
|
4515 #ifdef FEAT_QUICKFIX |
|
84baca75b7f2
patch 8.0.0590: cannot add a context to locations
Christian Brabandt <cb@256bit.org>
parents:
11323
diff
changeset
|
4516 abort = abort || set_ref_in_quickfix(copyID); |
|
84baca75b7f2
patch 8.0.0590: cannot add a context to locations
Christian Brabandt <cb@256bit.org>
parents:
11323
diff
changeset
|
4517 #endif |
|
84baca75b7f2
patch 8.0.0590: cannot add a context to locations
Christian Brabandt <cb@256bit.org>
parents:
11323
diff
changeset
|
4518 |
|
11804
5630978ae089
patch 8.0.0784: job of terminal may be garbage collected
Christian Brabandt <cb@256bit.org>
parents:
11418
diff
changeset
|
4519 #ifdef FEAT_TERMINAL |
|
5630978ae089
patch 8.0.0784: job of terminal may be garbage collected
Christian Brabandt <cb@256bit.org>
parents:
11418
diff
changeset
|
4520 abort = abort || set_ref_in_term(copyID); |
|
5630978ae089
patch 8.0.0784: job of terminal may be garbage collected
Christian Brabandt <cb@256bit.org>
parents:
11418
diff
changeset
|
4521 #endif |
|
5630978ae089
patch 8.0.0784: job of terminal may be garbage collected
Christian Brabandt <cb@256bit.org>
parents:
11418
diff
changeset
|
4522 |
|
18763
49b78d6465e5
patch 8.1.2371: FEAT_TEXT_PROP is a confusing name
Bram Moolenaar <Bram@vim.org>
parents:
18713
diff
changeset
|
4523 #ifdef FEAT_PROP_POPUP |
|
17151
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4524 abort = abort || set_ref_in_popups(copyID); |
|
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4525 #endif |
|
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4526 |
| 6565 | 4527 if (!abort) |
| 4528 { | |
| 4529 /* | |
| 4530 * 2. Free lists and dictionaries that are not referenced. | |
| 4531 */ | |
| 4532 did_free = free_unref_items(copyID); | |
| 4533 | |
| 4534 /* | |
| 4535 * 3. Check if any funccal can be freed now. | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4536 * This may call us back recursively. |
| 6565 | 4537 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4538 free_unref_funccal(copyID, testing); |
| 6565 | 4539 } |
| 4540 else if (p_verbose > 0) | |
| 4541 { | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15517
diff
changeset
|
4542 verb_msg(_("Not enough memory to set references, garbage collection aborted!")); |
| 6565 | 4543 } |
| 1891 | 4544 |
| 4545 return did_free; | |
| 4546 } | |
| 4547 | |
| 4548 /* | |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4549 * Free lists, dictionaries, channels and jobs that are no longer referenced. |
| 1891 | 4550 */ |
| 4551 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4552 free_unref_items(int copyID) |
| 1891 | 4553 { |
| 4554 int did_free = FALSE; | |
| 4555 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4556 // Let all "free" functions know that we are here. This means no |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4557 // dictionaries, lists, channels or jobs are to be freed, because we will |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4558 // do that here. |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4559 in_free_unref_items = TRUE; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4560 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4561 /* |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4562 * PASS 1: free the contents of the items. We don't free the items |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4563 * themselves yet, so that it is possible to decrement refcount counters |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4564 */ |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4565 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4566 // Go through the list of dicts and free items without the copyID. |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
4567 did_free |= dict_free_nonref(copyID); |
| 371 | 4568 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4569 // Go through the list of lists and free items without the copyID. |
|
9560
1e68dfd7931b
commit https://github.com/vim/vim/commit/da861d631d7e22654faee2789286c685ad548911
Christian Brabandt <cb@256bit.org>
parents:
9556
diff
changeset
|
4570 did_free |= list_free_nonref(copyID); |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4571 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4572 #ifdef FEAT_JOB_CHANNEL |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4573 // Go through the list of jobs and free items without the copyID. This |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4574 // must happen before doing channels, because jobs refer to channels, but |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4575 // the reference from the channel to the job isn't tracked. |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4576 did_free |= free_unused_jobs_contents(copyID, COPYID_MASK); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4577 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4578 // Go through the list of channels and free items without the copyID. |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4579 did_free |= free_unused_channels_contents(copyID, COPYID_MASK); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4580 #endif |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4581 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4582 /* |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4583 * PASS 2: free the items themselves. |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4584 */ |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
4585 dict_free_items(copyID); |
|
9560
1e68dfd7931b
commit https://github.com/vim/vim/commit/da861d631d7e22654faee2789286c685ad548911
Christian Brabandt <cb@256bit.org>
parents:
9556
diff
changeset
|
4586 list_free_items(copyID); |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4587 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4588 #ifdef FEAT_JOB_CHANNEL |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4589 // Go through the list of jobs and free items without the copyID. This |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4590 // must happen before doing channels, because jobs refer to channels, but |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4591 // the reference from the channel to the job isn't tracked. |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4592 free_unused_jobs(copyID, COPYID_MASK); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4593 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4594 // Go through the list of channels and free items without the copyID. |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4595 free_unused_channels(copyID, COPYID_MASK); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4596 #endif |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4597 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4598 in_free_unref_items = FALSE; |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
4599 |
| 371 | 4600 return did_free; |
| 4601 } | |
| 4602 | |
| 4603 /* | |
| 4604 * Mark all lists and dicts referenced through hashtab "ht" with "copyID". | |
| 6565 | 4605 * "list_stack" is used to add lists to be marked. Can be NULL. |
| 4606 * | |
| 4607 * Returns TRUE if setting references failed somehow. | |
| 4608 */ | |
| 4609 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4610 set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack) |
| 364 | 4611 { |
| 4612 int todo; | |
| 6565 | 4613 int abort = FALSE; |
| 364 | 4614 hashitem_T *hi; |
| 6565 | 4615 hashtab_T *cur_ht; |
| 4616 ht_stack_T *ht_stack = NULL; | |
| 4617 ht_stack_T *tempitem; | |
| 4618 | |
| 4619 cur_ht = ht; | |
| 4620 for (;;) | |
| 4621 { | |
| 4622 if (!abort) | |
| 4623 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4624 // Mark each item in the hashtab. If the item contains a hashtab |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4625 // it is added to ht_stack, if it contains a list it is added to |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4626 // list_stack. |
| 6565 | 4627 todo = (int)cur_ht->ht_used; |
| 4628 for (hi = cur_ht->ht_array; todo > 0; ++hi) | |
| 4629 if (!HASHITEM_EMPTY(hi)) | |
| 4630 { | |
| 4631 --todo; | |
| 4632 abort = abort || set_ref_in_item(&HI2DI(hi)->di_tv, copyID, | |
| 4633 &ht_stack, list_stack); | |
| 4634 } | |
| 4635 } | |
| 4636 | |
| 4637 if (ht_stack == NULL) | |
| 4638 break; | |
| 4639 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4640 // take an item from the stack |
| 6565 | 4641 cur_ht = ht_stack->ht; |
| 4642 tempitem = ht_stack; | |
| 4643 ht_stack = ht_stack->prev; | |
| 4644 free(tempitem); | |
| 4645 } | |
| 4646 | |
| 4647 return abort; | |
| 371 | 4648 } |
| 4649 | |
| 4650 /* | |
|
17168
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4651 * Mark a dict and its items with "copyID". |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4652 * Returns TRUE if setting references failed somehow. |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4653 */ |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4654 int |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4655 set_ref_in_dict(dict_T *d, int copyID) |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4656 { |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4657 if (d != NULL && d->dv_copyID != copyID) |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4658 { |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4659 d->dv_copyID = copyID; |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4660 return set_ref_in_ht(&d->dv_hashtab, copyID, NULL); |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4661 } |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4662 return FALSE; |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4663 } |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4664 |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4665 /* |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4666 * Mark a list and its items with "copyID". |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4667 * Returns TRUE if setting references failed somehow. |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4668 */ |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4669 int |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4670 set_ref_in_list(list_T *ll, int copyID) |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4671 { |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4672 if (ll != NULL && ll->lv_copyID != copyID) |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4673 { |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4674 ll->lv_copyID = copyID; |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4675 return set_ref_in_list_items(ll, copyID, NULL); |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4676 } |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4677 return FALSE; |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4678 } |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4679 |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4680 /* |
| 371 | 4681 * Mark all lists and dicts referenced through list "l" with "copyID". |
| 6565 | 4682 * "ht_stack" is used to add hashtabs to be marked. Can be NULL. |
| 4683 * | |
| 4684 * Returns TRUE if setting references failed somehow. | |
| 4685 */ | |
| 4686 int | |
|
17168
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4687 set_ref_in_list_items(list_T *l, int copyID, ht_stack_T **ht_stack) |
| 6565 | 4688 { |
| 4689 listitem_T *li; | |
| 4690 int abort = FALSE; | |
| 4691 list_T *cur_l; | |
| 4692 list_stack_T *list_stack = NULL; | |
| 4693 list_stack_T *tempitem; | |
| 4694 | |
| 4695 cur_l = l; | |
| 4696 for (;;) | |
| 4697 { | |
|
19201
e7b4fff348dd
patch 8.2.0159: non-materialized range() list causes problems
Bram Moolenaar <Bram@vim.org>
parents:
19191
diff
changeset
|
4698 if (!abort && cur_l->lv_first != &range_list_item) |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4699 // Mark each item in the list. If the item contains a hashtab |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4700 // it is added to ht_stack, if it contains a list it is added to |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4701 // list_stack. |
| 6565 | 4702 for (li = cur_l->lv_first; !abort && li != NULL; li = li->li_next) |
| 4703 abort = abort || set_ref_in_item(&li->li_tv, copyID, | |
| 4704 ht_stack, &list_stack); | |
| 4705 if (list_stack == NULL) | |
| 4706 break; | |
| 4707 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4708 // take an item from the stack |
| 6565 | 4709 cur_l = list_stack->list; |
| 4710 tempitem = list_stack; | |
| 4711 list_stack = list_stack->prev; | |
| 4712 free(tempitem); | |
| 4713 } | |
| 4714 | |
| 4715 return abort; | |
| 371 | 4716 } |
| 4717 | |
| 4718 /* | |
| 4719 * Mark all lists and dicts referenced through typval "tv" with "copyID". | |
| 6565 | 4720 * "list_stack" is used to add lists to be marked. Can be NULL. |
| 4721 * "ht_stack" is used to add hashtabs to be marked. Can be NULL. | |
| 4722 * | |
| 4723 * Returns TRUE if setting references failed somehow. | |
| 4724 */ | |
| 4725 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4726 set_ref_in_item( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4727 typval_T *tv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4728 int copyID, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4729 ht_stack_T **ht_stack, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4730 list_stack_T **list_stack) |
| 364 | 4731 { |
| 6565 | 4732 int abort = FALSE; |
| 364 | 4733 |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4734 if (tv->v_type == VAR_DICT) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4735 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4736 dict_T *dd = tv->vval.v_dict; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4737 |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4738 if (dd != NULL && dd->dv_copyID != copyID) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4739 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4740 // Didn't see this dict yet. |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4741 dd->dv_copyID = copyID; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4742 if (ht_stack == NULL) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4743 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4744 abort = set_ref_in_ht(&dd->dv_hashtab, copyID, list_stack); |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4745 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4746 else |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4747 { |
|
21915
2559dc02bd64
patch 8.2.1507: using malloc() directly
Bram Moolenaar <Bram@vim.org>
parents:
21899
diff
changeset
|
4748 ht_stack_T *newitem = ALLOC_ONE(ht_stack_T); |
|
2559dc02bd64
patch 8.2.1507: using malloc() directly
Bram Moolenaar <Bram@vim.org>
parents:
21899
diff
changeset
|
4749 |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4750 if (newitem == NULL) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4751 abort = TRUE; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4752 else |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4753 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4754 newitem->ht = &dd->dv_hashtab; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4755 newitem->prev = *ht_stack; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4756 *ht_stack = newitem; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4757 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4758 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4759 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4760 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4761 else if (tv->v_type == VAR_LIST) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4762 { |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4763 list_T *ll = tv->vval.v_list; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4764 |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4765 if (ll != NULL && ll->lv_copyID != copyID) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4766 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4767 // Didn't see this list yet. |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4768 ll->lv_copyID = copyID; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4769 if (list_stack == NULL) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4770 { |
|
17168
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4771 abort = set_ref_in_list_items(ll, copyID, ht_stack); |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4772 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4773 else |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4774 { |
|
21915
2559dc02bd64
patch 8.2.1507: using malloc() directly
Bram Moolenaar <Bram@vim.org>
parents:
21899
diff
changeset
|
4775 list_stack_T *newitem = ALLOC_ONE(list_stack_T); |
|
2559dc02bd64
patch 8.2.1507: using malloc() directly
Bram Moolenaar <Bram@vim.org>
parents:
21899
diff
changeset
|
4776 |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4777 if (newitem == NULL) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4778 abort = TRUE; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4779 else |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4780 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4781 newitem->list = ll; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4782 newitem->prev = *list_stack; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4783 *list_stack = newitem; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4784 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4785 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4786 } |
| 6565 | 4787 } |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
4788 else if (tv->v_type == VAR_FUNC) |
|
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
4789 { |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4790 abort = set_ref_in_func(tv->vval.v_string, NULL, copyID); |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
4791 } |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4792 else if (tv->v_type == VAR_PARTIAL) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4793 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4794 partial_T *pt = tv->vval.v_partial; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4795 int i; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4796 |
|
20295
bc2c9ea94ec1
patch 8.2.0703: Vim9: closure cannot store value in outer context
Bram Moolenaar <Bram@vim.org>
parents:
20257
diff
changeset
|
4797 if (pt != NULL && pt->pt_copyID != copyID) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4798 { |
|
20295
bc2c9ea94ec1
patch 8.2.0703: Vim9: closure cannot store value in outer context
Bram Moolenaar <Bram@vim.org>
parents:
20257
diff
changeset
|
4799 // Didn't see this partial yet. |
|
bc2c9ea94ec1
patch 8.2.0703: Vim9: closure cannot store value in outer context
Bram Moolenaar <Bram@vim.org>
parents:
20257
diff
changeset
|
4800 pt->pt_copyID = copyID; |
|
bc2c9ea94ec1
patch 8.2.0703: Vim9: closure cannot store value in outer context
Bram Moolenaar <Bram@vim.org>
parents:
20257
diff
changeset
|
4801 |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4802 abort = set_ref_in_func(pt->pt_name, pt->pt_func, copyID); |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
4803 |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4804 if (pt->pt_dict != NULL) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4805 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4806 typval_T dtv; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4807 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4808 dtv.v_type = VAR_DICT; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4809 dtv.vval.v_dict = pt->pt_dict; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4810 set_ref_in_item(&dtv, copyID, ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4811 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4812 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4813 for (i = 0; i < pt->pt_argc; ++i) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4814 abort = abort || set_ref_in_item(&pt->pt_argv[i], copyID, |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4815 ht_stack, list_stack); |
|
20257
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4816 if (pt->pt_funcstack != NULL) |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4817 { |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4818 typval_T *stack = pt->pt_funcstack->fs_ga.ga_data; |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4819 |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4820 for (i = 0; i < pt->pt_funcstack->fs_ga.ga_len; ++i) |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4821 abort = abort || set_ref_in_item(stack + i, copyID, |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4822 ht_stack, list_stack); |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4823 } |
|
683c2da4982b
patch 8.2.0684: Vim9: memory leak when using lambda
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
4824 |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4825 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4826 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4827 #ifdef FEAT_JOB_CHANNEL |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4828 else if (tv->v_type == VAR_JOB) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4829 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4830 job_T *job = tv->vval.v_job; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4831 typval_T dtv; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4832 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4833 if (job != NULL && job->jv_copyID != copyID) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4834 { |
|
8870
30988ffb7498
commit https://github.com/vim/vim/commit/0239acb11fe4bfe9b525ea90b782759da5eb7704
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
4835 job->jv_copyID = copyID; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4836 if (job->jv_channel != NULL) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4837 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4838 dtv.v_type = VAR_CHANNEL; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4839 dtv.vval.v_channel = job->jv_channel; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4840 set_ref_in_item(&dtv, copyID, ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4841 } |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4842 if (job->jv_exit_cb.cb_partial != NULL) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4843 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4844 dtv.v_type = VAR_PARTIAL; |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4845 dtv.vval.v_partial = job->jv_exit_cb.cb_partial; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4846 set_ref_in_item(&dtv, copyID, ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4847 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4848 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4849 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4850 else if (tv->v_type == VAR_CHANNEL) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4851 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4852 channel_T *ch =tv->vval.v_channel; |
|
10259
a09db7a4afe0
commit https://github.com/vim/vim/commit/dc0ccaee68ca24d10050117fbec757ad33590a17
Christian Brabandt <cb@256bit.org>
parents:
10235
diff
changeset
|
4853 ch_part_T part; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4854 typval_T dtv; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4855 jsonq_T *jq; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4856 cbq_T *cq; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4857 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4858 if (ch != NULL && ch->ch_copyID != copyID) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4859 { |
|
8870
30988ffb7498
commit https://github.com/vim/vim/commit/0239acb11fe4bfe9b525ea90b782759da5eb7704
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
4860 ch->ch_copyID = copyID; |
|
10259
a09db7a4afe0
commit https://github.com/vim/vim/commit/dc0ccaee68ca24d10050117fbec757ad33590a17
Christian Brabandt <cb@256bit.org>
parents:
10235
diff
changeset
|
4861 for (part = PART_SOCK; part < PART_COUNT; ++part) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4862 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4863 for (jq = ch->ch_part[part].ch_json_head.jq_next; jq != NULL; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4864 jq = jq->jq_next) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4865 set_ref_in_item(jq->jq_value, copyID, ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4866 for (cq = ch->ch_part[part].ch_cb_head.cq_next; cq != NULL; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4867 cq = cq->cq_next) |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4868 if (cq->cq_callback.cb_partial != NULL) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4869 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4870 dtv.v_type = VAR_PARTIAL; |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4871 dtv.vval.v_partial = cq->cq_callback.cb_partial; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4872 set_ref_in_item(&dtv, copyID, ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4873 } |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4874 if (ch->ch_part[part].ch_callback.cb_partial != NULL) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4875 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4876 dtv.v_type = VAR_PARTIAL; |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4877 dtv.vval.v_partial = |
|
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4878 ch->ch_part[part].ch_callback.cb_partial; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4879 set_ref_in_item(&dtv, copyID, ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4880 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4881 } |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4882 if (ch->ch_callback.cb_partial != NULL) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4883 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4884 dtv.v_type = VAR_PARTIAL; |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4885 dtv.vval.v_partial = ch->ch_callback.cb_partial; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4886 set_ref_in_item(&dtv, copyID, ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4887 } |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4888 if (ch->ch_close_cb.cb_partial != NULL) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4889 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4890 dtv.v_type = VAR_PARTIAL; |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4891 dtv.vval.v_partial = ch->ch_close_cb.cb_partial; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4892 set_ref_in_item(&dtv, copyID, ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4893 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4894 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4895 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4896 #endif |
| 6565 | 4897 return abort; |
| 364 | 4898 } |
| 4899 | |
| 100 | 4900 /* |
| 56 | 4901 * Return a string with the string representation of a variable. |
| 4902 * If the memory is allocated "tofree" is set to it, otherwise NULL. | |
| 80 | 4903 * "numbuf" is used for a number. |
| 634 | 4904 * When "copyID" is not NULL replace recursive lists and dicts with "...". |
|
11973
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4905 * When both "echo_style" and "composite_val" are FALSE, put quotes around |
|
23229
b545334ae654
patch 8.2.2160: various typos
Bram Moolenaar <Bram@vim.org>
parents:
23191
diff
changeset
|
4906 * strings as "string()", otherwise does not put quotes around strings, as |
|
11973
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4907 * ":echo" displays values. |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4908 * When "restore_copyID" is FALSE, repeated items in dictionaries and lists |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4909 * are replaced with "...". |
| 1360 | 4910 * May return NULL. |
| 56 | 4911 */ |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
4912 char_u * |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4913 echo_string_core( |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4914 typval_T *tv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4915 char_u **tofree, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4916 char_u *numbuf, |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4917 int copyID, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4918 int echo_style, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4919 int restore_copyID, |
|
11973
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4920 int composite_val) |
| 56 | 4921 { |
| 104 | 4922 static int recurse = 0; |
| 4923 char_u *r = NULL; | |
| 4924 | |
| 137 | 4925 if (recurse >= DICT_MAXNEST) |
| 104 | 4926 { |
| 5973 | 4927 if (!did_echo_string_emsg) |
| 4928 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4929 // Only give this message once for a recursive call to avoid |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4930 // flooding the user with errors. And stop iterating over lists |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4931 // and dicts. |
| 5973 | 4932 did_echo_string_emsg = TRUE; |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
4933 emsg(_("E724: variable nested too deep for displaying")); |
| 5973 | 4934 } |
| 104 | 4935 *tofree = NULL; |
| 5973 | 4936 return (char_u *)"{E724}"; |
| 104 | 4937 } |
| 4938 ++recurse; | |
| 4939 | |
| 56 | 4940 switch (tv->v_type) |
| 4941 { | |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4942 case VAR_STRING: |
|
11973
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4943 if (echo_style && !composite_val) |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4944 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4945 *tofree = NULL; |
|
11973
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4946 r = tv->vval.v_string; |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4947 if (r == NULL) |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4948 r = (char_u *)""; |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4949 } |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4950 else |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4951 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4952 *tofree = string_quote(tv->vval.v_string, FALSE); |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4953 r = *tofree; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4954 } |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4955 break; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4956 |
| 56 | 4957 case VAR_FUNC: |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4958 if (echo_style) |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4959 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4960 *tofree = NULL; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4961 r = tv->vval.v_string; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4962 } |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4963 else |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4964 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4965 *tofree = string_quote(tv->vval.v_string, TRUE); |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4966 r = *tofree; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4967 } |
| 104 | 4968 break; |
| 634 | 4969 |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
4970 case VAR_PARTIAL: |
|
8710
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4971 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4972 partial_T *pt = tv->vval.v_partial; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4973 char_u *fname = string_quote(pt == NULL ? NULL |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4974 : partial_name(pt), FALSE); |
|
8710
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4975 garray_T ga; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4976 int i; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4977 char_u *tf; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4978 |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4979 ga_init2(&ga, 1, 100); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4980 ga_concat(&ga, (char_u *)"function("); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4981 if (fname != NULL) |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4982 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4983 ga_concat(&ga, fname); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4984 vim_free(fname); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4985 } |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4986 if (pt != NULL && pt->pt_argc > 0) |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4987 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4988 ga_concat(&ga, (char_u *)", ["); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4989 for (i = 0; i < pt->pt_argc; ++i) |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4990 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4991 if (i > 0) |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4992 ga_concat(&ga, (char_u *)", "); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4993 ga_concat(&ga, |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4994 tv2string(&pt->pt_argv[i], &tf, numbuf, copyID)); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4995 vim_free(tf); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4996 } |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4997 ga_concat(&ga, (char_u *)"]"); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4998 } |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4999 if (pt != NULL && pt->pt_dict != NULL) |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5000 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5001 typval_T dtv; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5002 |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5003 ga_concat(&ga, (char_u *)", "); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5004 dtv.v_type = VAR_DICT; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5005 dtv.vval.v_dict = pt->pt_dict; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5006 ga_concat(&ga, tv2string(&dtv, &tf, numbuf, copyID)); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5007 vim_free(tf); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5008 } |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5009 ga_concat(&ga, (char_u *)")"); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5010 |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5011 *tofree = ga.ga_data; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5012 r = *tofree; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5013 break; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
5014 } |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5015 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5016 case VAR_BLOB: |
|
15466
435fcefd2c8e
patch 8.1.0741: viminfo with Blob is not tested
Bram Moolenaar <Bram@vim.org>
parents:
15464
diff
changeset
|
5017 r = blob2string(tv->vval.v_blob, tofree, numbuf); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5018 break; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5019 |
| 56 | 5020 case VAR_LIST: |
| 634 | 5021 if (tv->vval.v_list == NULL) |
| 5022 { | |
|
20126
831b1ea43020
patch 8.2.0618: echoing a null list results in no output
Bram Moolenaar <Bram@vim.org>
parents:
20111
diff
changeset
|
5023 // NULL list is equivalent to empty list. |
| 634 | 5024 *tofree = NULL; |
|
20126
831b1ea43020
patch 8.2.0618: echoing a null list results in no output
Bram Moolenaar <Bram@vim.org>
parents:
20111
diff
changeset
|
5025 r = (char_u *)"[]"; |
| 634 | 5026 } |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5027 else if (copyID != 0 && tv->vval.v_list->lv_copyID == copyID |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5028 && tv->vval.v_list->lv_len > 0) |
| 634 | 5029 { |
| 5030 *tofree = NULL; | |
| 5031 r = (char_u *)"[...]"; | |
| 5032 } | |
| 5033 else | |
| 5034 { | |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5035 int old_copyID = tv->vval.v_list->lv_copyID; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5036 |
| 634 | 5037 tv->vval.v_list->lv_copyID = copyID; |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5038 *tofree = list2string(tv, copyID, restore_copyID); |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5039 if (restore_copyID) |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5040 tv->vval.v_list->lv_copyID = old_copyID; |
| 634 | 5041 r = *tofree; |
| 5042 } | |
| 5043 break; | |
| 5044 | |
| 100 | 5045 case VAR_DICT: |
| 634 | 5046 if (tv->vval.v_dict == NULL) |
| 5047 { | |
|
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20126
diff
changeset
|
5048 // NULL dict is equivalent to empty dict. |
| 634 | 5049 *tofree = NULL; |
|
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20126
diff
changeset
|
5050 r = (char_u *)"{}"; |
| 634 | 5051 } |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5052 else if (copyID != 0 && tv->vval.v_dict->dv_copyID == copyID |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5053 && tv->vval.v_dict->dv_hashtab.ht_used != 0) |
| 634 | 5054 { |
| 5055 *tofree = NULL; | |
| 5056 r = (char_u *)"{...}"; | |
| 5057 } | |
| 5058 else | |
| 5059 { | |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5060 int old_copyID = tv->vval.v_dict->dv_copyID; |
|
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20126
diff
changeset
|
5061 |
| 634 | 5062 tv->vval.v_dict->dv_copyID = copyID; |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5063 *tofree = dict2string(tv, copyID, restore_copyID); |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5064 if (restore_copyID) |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5065 tv->vval.v_dict->dv_copyID = old_copyID; |
| 634 | 5066 r = *tofree; |
| 5067 } | |
| 5068 break; | |
| 5069 | |
| 71 | 5070 case VAR_NUMBER: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
5071 case VAR_UNKNOWN: |
|
19922
1f42c49c3d29
patch 8.2.0517: Vim9: cannot separate "func" and "func(): void"
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
5072 case VAR_ANY: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
5073 case VAR_VOID: |
|
11973
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
5074 *tofree = NULL; |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5075 r = tv_get_string_buf(tv, numbuf); |
|
11973
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
5076 break; |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
5077 |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5078 case VAR_JOB: |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5079 case VAR_CHANNEL: |
| 104 | 5080 *tofree = NULL; |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5081 r = tv_get_string_buf(tv, numbuf); |
|
11973
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
5082 if (composite_val) |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
5083 { |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
5084 *tofree = string_quote(r, FALSE); |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
5085 r = *tofree; |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
5086 } |
| 71 | 5087 break; |
| 634 | 5088 |
|
24606
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
5089 case VAR_INSTR: |
|
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
5090 *tofree = NULL; |
|
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
5091 r = (char_u *)"instructions"; |
|
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
5092 break; |
|
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
5093 |
| 1624 | 5094 case VAR_FLOAT: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5095 #ifdef FEAT_FLOAT |
| 1624 | 5096 *tofree = NULL; |
| 5097 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv->vval.v_float); | |
| 5098 r = numbuf; | |
| 5099 break; | |
| 5100 #endif | |
| 5101 | |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5102 case VAR_BOOL: |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
5103 case VAR_SPECIAL: |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
5104 *tofree = NULL; |
|
7730
80ce794827c4
commit https://github.com/vim/vim/commit/17a13437c9414a8693369a97f3be2fc8ad48c12e
Christian Brabandt <cb@256bit.org>
parents:
7720
diff
changeset
|
5105 r = (char_u *)get_var_special_name(tv->vval.v_number); |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
5106 break; |
| 104 | 5107 } |
| 5108 | |
| 5973 | 5109 if (--recurse == 0) |
| 5110 did_echo_string_emsg = FALSE; | |
| 104 | 5111 return r; |
| 97 | 5112 } |
| 5113 | |
| 5114 /* | |
| 5115 * Return a string with the string representation of a variable. | |
| 5116 * If the memory is allocated "tofree" is set to it, otherwise NULL. | |
| 5117 * "numbuf" is used for a number. | |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5118 * Does not put quotes around strings, as ":echo" displays values. |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5119 * When "copyID" is not NULL replace recursive lists and dicts with "...". |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5120 * May return NULL. |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5121 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5122 char_u * |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5123 echo_string( |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5124 typval_T *tv, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5125 char_u **tofree, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5126 char_u *numbuf, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5127 int copyID) |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5128 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5129 return echo_string_core(tv, tofree, numbuf, copyID, TRUE, FALSE, FALSE); |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5130 } |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5131 |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
5132 /* |
| 137 | 5133 * Return string "str" in ' quotes, doubling ' characters. |
| 5134 * If "str" is NULL an empty string is assumed. | |
| 100 | 5135 * If "function" is TRUE make it function('string'). |
| 97 | 5136 */ |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
5137 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5138 string_quote(char_u *str, int function) |
| 97 | 5139 { |
| 137 | 5140 unsigned len; |
| 97 | 5141 char_u *p, *r, *s; |
| 5142 | |
| 137 | 5143 len = (function ? 13 : 3); |
| 5144 if (str != NULL) | |
| 5145 { | |
| 835 | 5146 len += (unsigned)STRLEN(str); |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10964
diff
changeset
|
5147 for (p = str; *p != NUL; MB_PTR_ADV(p)) |
| 137 | 5148 if (*p == '\'') |
| 5149 ++len; | |
| 5150 } | |
| 97 | 5151 s = r = alloc(len); |
| 5152 if (r != NULL) | |
| 5153 { | |
| 5154 if (function) | |
| 5155 { | |
| 100 | 5156 STRCPY(r, "function('"); |
| 97 | 5157 r += 10; |
| 5158 } | |
| 5159 else | |
| 100 | 5160 *r++ = '\''; |
| 137 | 5161 if (str != NULL) |
| 5162 for (p = str; *p != NUL; ) | |
| 5163 { | |
| 5164 if (*p == '\'') | |
| 5165 *r++ = '\''; | |
| 5166 MB_COPY_CHAR(p, r); | |
| 5167 } | |
| 100 | 5168 *r++ = '\''; |
| 97 | 5169 if (function) |
| 5170 *r++ = ')'; | |
| 5171 *r++ = NUL; | |
| 5172 } | |
| 5173 return s; | |
| 5174 } | |
| 5175 | |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
5176 #if defined(FEAT_FLOAT) || defined(PROTO) |
| 1624 | 5177 /* |
| 5178 * Convert the string "text" to a floating point number. | |
| 5179 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure | |
| 5180 * this always uses a decimal point. | |
| 5181 * Returns the length of the text that was consumed. | |
| 5182 */ | |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
5183 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5184 string2float( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5185 char_u *text, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5186 float_T *value) // result stored here |
| 1624 | 5187 { |
| 5188 char *s = (char *)text; | |
| 5189 float_T f; | |
| 5190 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5191 // MS-Windows does not deal with "inf" and "nan" properly. |
|
10536
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5192 if (STRNICMP(text, "inf", 3) == 0) |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5193 { |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5194 *value = INFINITY; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5195 return 3; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5196 } |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5197 if (STRNICMP(text, "-inf", 3) == 0) |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5198 { |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5199 *value = -INFINITY; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5200 return 4; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5201 } |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5202 if (STRNICMP(text, "nan", 3) == 0) |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5203 { |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5204 *value = NAN; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5205 return 3; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
5206 } |
| 1624 | 5207 f = strtod(s, &s); |
| 5208 *value = f; | |
| 5209 return (int)((char_u *)s - text); | |
| 5210 } | |
| 5211 #endif | |
| 5212 | |
| 97 | 5213 /* |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5214 * Convert the specified byte index of line 'lnum' in buffer 'buf' to a |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5215 * character index. Works only for loaded buffers. Returns -1 on failure. |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5216 * The index of the first byte and the first character is zero. |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5217 */ |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5218 int |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5219 buf_byteidx_to_charidx(buf_T *buf, int lnum, int byteidx) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5220 { |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5221 char_u *str; |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5222 char_u *t; |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5223 int count; |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5224 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5225 if (buf == NULL || buf->b_ml.ml_mfp == NULL) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5226 return -1; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5227 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5228 if (lnum > buf->b_ml.ml_line_count) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5229 lnum = buf->b_ml.ml_line_count; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5230 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5231 str = ml_get_buf(buf, lnum, FALSE); |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5232 if (str == NULL) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5233 return -1; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5234 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5235 if (*str == NUL) |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5236 return 0; |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5237 |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5238 // count the number of characters |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5239 t = str; |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5240 for (count = 0; *t != NUL && t <= str + byteidx; count++) |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5241 t += mb_ptr2len(t); |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5242 |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5243 // In insert mode, when the cursor is at the end of a non-empty line, |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5244 // byteidx points to the NUL character immediately past the end of the |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5245 // string. In this case, add one to the character count. |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5246 if (*t == NUL && byteidx != 0 && t == str + byteidx) |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5247 count++; |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5248 |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5249 return count - 1; |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5250 } |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5251 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5252 /* |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5253 * Convert the specified character index of line 'lnum' in buffer 'buf' to a |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5254 * byte index. Works only for loaded buffers. Returns -1 on failure. |
|
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5255 * The index of the first byte and the first character is zero. |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5256 */ |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5257 int |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5258 buf_charidx_to_byteidx(buf_T *buf, int lnum, int charidx) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5259 { |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5260 char_u *str; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5261 char_u *t; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5262 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5263 if (buf == NULL || buf->b_ml.ml_mfp == NULL) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5264 return -1; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5265 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5266 if (lnum > buf->b_ml.ml_line_count) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5267 lnum = buf->b_ml.ml_line_count; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5268 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5269 str = ml_get_buf(buf, lnum, FALSE); |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5270 if (str == NULL) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5271 return -1; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5272 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5273 // Convert the character offset to a byte offset |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5274 t = str; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5275 while (*t != NUL && --charidx > 0) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5276 t += mb_ptr2len(t); |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5277 |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5278 return t - str; |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5279 } |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5280 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5281 /* |
| 7 | 5282 * Translate a String variable into a position. |
| 685 | 5283 * Returns NULL when there is an error. |
| 7 | 5284 */ |
|
9571
5eaa708ab50d
commit https://github.com/vim/vim/commit/73dad1e64cb42842d8259cb1a255a6fa59822f76
Christian Brabandt <cb@256bit.org>
parents:
9562
diff
changeset
|
5285 pos_T * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5286 var2fpos( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5287 typval_T *varp, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5288 int dollar_lnum, // TRUE when $ is last line |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5289 int *fnum, // set to fnum for '0, 'A, etc. |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5290 int charcol) // return character column |
| 7 | 5291 { |
| 700 | 5292 char_u *name; |
| 7 | 5293 static pos_T pos; |
| 700 | 5294 pos_T *pp; |
| 7 | 5295 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5296 // Argument can be [lnum, col, coladd]. |
| 685 | 5297 if (varp->v_type == VAR_LIST) |
| 5298 { | |
| 5299 list_T *l; | |
| 5300 int len; | |
| 705 | 5301 int error = FALSE; |
| 1317 | 5302 listitem_T *li; |
| 685 | 5303 |
| 5304 l = varp->vval.v_list; | |
| 5305 if (l == NULL) | |
| 5306 return NULL; | |
| 5307 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5308 // Get the line number |
| 705 | 5309 pos.lnum = list_find_nr(l, 0L, &error); |
| 5310 if (error || pos.lnum <= 0 || pos.lnum > curbuf->b_ml.ml_line_count) | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5311 return NULL; // invalid line number |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5312 if (charcol) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5313 len = (long)mb_charlen(ml_get(pos.lnum)); |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5314 else |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5315 len = (long)STRLEN(ml_get(pos.lnum)); |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5316 |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5317 // Get the column number |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5318 // We accept "$" for the column number: last column. |
| 1317 | 5319 li = list_find(l, 1L); |
| 5320 if (li != NULL && li->li_tv.v_type == VAR_STRING | |
| 5321 && li->li_tv.vval.v_string != NULL | |
| 5322 && STRCMP(li->li_tv.vval.v_string, "$") == 0) | |
|
21899
8fe86125dcba
patch 8.2.1499: Vim9: error when using "$" with col()
Bram Moolenaar <Bram@vim.org>
parents:
21889
diff
changeset
|
5323 { |
| 1317 | 5324 pos.col = len + 1; |
|
21899
8fe86125dcba
patch 8.2.1499: Vim9: error when using "$" with col()
Bram Moolenaar <Bram@vim.org>
parents:
21889
diff
changeset
|
5325 } |
|
8fe86125dcba
patch 8.2.1499: Vim9: error when using "$" with col()
Bram Moolenaar <Bram@vim.org>
parents:
21889
diff
changeset
|
5326 else |
|
8fe86125dcba
patch 8.2.1499: Vim9: error when using "$" with col()
Bram Moolenaar <Bram@vim.org>
parents:
21889
diff
changeset
|
5327 { |
|
8fe86125dcba
patch 8.2.1499: Vim9: error when using "$" with col()
Bram Moolenaar <Bram@vim.org>
parents:
21889
diff
changeset
|
5328 pos.col = list_find_nr(l, 1L, &error); |
|
8fe86125dcba
patch 8.2.1499: Vim9: error when using "$" with col()
Bram Moolenaar <Bram@vim.org>
parents:
21889
diff
changeset
|
5329 if (error) |
|
8fe86125dcba
patch 8.2.1499: Vim9: error when using "$" with col()
Bram Moolenaar <Bram@vim.org>
parents:
21889
diff
changeset
|
5330 return NULL; |
|
8fe86125dcba
patch 8.2.1499: Vim9: error when using "$" with col()
Bram Moolenaar <Bram@vim.org>
parents:
21889
diff
changeset
|
5331 } |
| 1317 | 5332 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5333 // Accept a position up to the NUL after the line. |
| 826 | 5334 if (pos.col == 0 || (int)pos.col > len + 1) |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5335 return NULL; // invalid column number |
| 705 | 5336 --pos.col; |
| 5337 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5338 // Get the virtual offset. Defaults to zero. |
| 705 | 5339 pos.coladd = list_find_nr(l, 2L, &error); |
| 5340 if (error) | |
| 5341 pos.coladd = 0; | |
| 5342 | |
| 685 | 5343 return &pos; |
| 5344 } | |
| 5345 | |
|
24250
01b274c3f69b
patch 8.2.2666: Vim9: not enough function arguments checked for string
Bram Moolenaar <Bram@vim.org>
parents:
24240
diff
changeset
|
5346 if (in_vim9script() && check_for_string_arg(varp, 0) == FAIL) |
|
01b274c3f69b
patch 8.2.2666: Vim9: not enough function arguments checked for string
Bram Moolenaar <Bram@vim.org>
parents:
24240
diff
changeset
|
5347 return NULL; |
|
01b274c3f69b
patch 8.2.2666: Vim9: not enough function arguments checked for string
Bram Moolenaar <Bram@vim.org>
parents:
24240
diff
changeset
|
5348 |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5349 name = tv_get_string_chk(varp); |
| 323 | 5350 if (name == NULL) |
| 5351 return NULL; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5352 if (name[0] == '.') // cursor |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5353 { |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5354 pos = curwin->w_cursor; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5355 if (charcol) |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5356 pos.col = buf_byteidx_to_charidx(curbuf, pos.lnum, pos.col); |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5357 return &pos; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5358 } |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5359 if (name[0] == 'v' && name[1] == NUL) // Visual start |
| 1609 | 5360 { |
| 5361 if (VIsual_active) | |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5362 pos = VIsual; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5363 else |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5364 pos = curwin->w_cursor; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5365 if (charcol) |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5366 pos.col = buf_byteidx_to_charidx(curbuf, pos.lnum, pos.col); |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5367 return &pos; |
| 1609 | 5368 } |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5369 if (name[0] == '\'') // mark |
| 7 | 5370 { |
| 4043 | 5371 pp = getmark_buf_fnum(curbuf, name[1], FALSE, fnum); |
| 7 | 5372 if (pp == NULL || pp == (pos_T *)-1 || pp->lnum <= 0) |
| 5373 return NULL; | |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5374 if (charcol) |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5375 pp->col = buf_byteidx_to_charidx(curbuf, pp->lnum, pp->col); |
| 7 | 5376 return pp; |
| 5377 } | |
| 705 | 5378 |
| 5379 pos.coladd = 0; | |
| 5380 | |
| 1317 | 5381 if (name[0] == 'w' && dollar_lnum) |
| 666 | 5382 { |
| 5383 pos.col = 0; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5384 if (name[1] == '0') // "w0": first visible line |
| 666 | 5385 { |
| 671 | 5386 update_topline(); |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5387 // In silent Ex mode topline is zero, but that's not a valid line |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5388 // number; use one instead. |
|
11313
327a04a762f6
patch 8.0.0542: getpos() can return a negative line number
Christian Brabandt <cb@256bit.org>
parents:
11181
diff
changeset
|
5389 pos.lnum = curwin->w_topline > 0 ? curwin->w_topline : 1; |
| 666 | 5390 return &pos; |
| 5391 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5392 else if (name[1] == '$') // "w$": last visible line |
| 666 | 5393 { |
| 671 | 5394 validate_botline(); |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5395 // In silent Ex mode botline is zero, return zero then. |
|
11313
327a04a762f6
patch 8.0.0542: getpos() can return a negative line number
Christian Brabandt <cb@256bit.org>
parents:
11181
diff
changeset
|
5396 pos.lnum = curwin->w_botline > 0 ? curwin->w_botline - 1 : 0; |
| 666 | 5397 return &pos; |
| 5398 } | |
| 5399 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5400 else if (name[0] == '$') // last column or line |
| 7 | 5401 { |
| 1317 | 5402 if (dollar_lnum) |
| 7 | 5403 { |
| 5404 pos.lnum = curbuf->b_ml.ml_line_count; | |
| 5405 pos.col = 0; | |
| 5406 } | |
| 5407 else | |
| 5408 { | |
| 5409 pos.lnum = curwin->w_cursor.lnum; | |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5410 if (charcol) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5411 pos.col = (colnr_T)mb_charlen(ml_get_curline()); |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5412 else |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5413 pos.col = (colnr_T)STRLEN(ml_get_curline()); |
| 7 | 5414 } |
| 5415 return &pos; | |
| 5416 } | |
| 5417 return NULL; | |
| 5418 } | |
| 5419 | |
| 5420 /* | |
| 709 | 5421 * Convert list in "arg" into a position and optional file number. |
| 5422 * When "fnump" is NULL there is no file number, only 3 items. | |
| 5423 * Note that the column is passed on as-is, the caller may want to decrement | |
| 5424 * it to use 1 for the first column. | |
| 5425 * Return FAIL when conversion is not possible, doesn't check the position for | |
| 5426 * validity. | |
| 5427 */ | |
|
9571
5eaa708ab50d
commit https://github.com/vim/vim/commit/73dad1e64cb42842d8259cb1a255a6fa59822f76
Christian Brabandt <cb@256bit.org>
parents:
9562
diff
changeset
|
5428 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5429 list2fpos( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5430 typval_T *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5431 pos_T *posp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5432 int *fnump, |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5433 colnr_T *curswantp, |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5434 int charcol) |
| 709 | 5435 { |
| 5436 list_T *l = arg->vval.v_list; | |
| 5437 long i = 0; | |
| 5438 long n; | |
| 5439 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5440 // List must be: [fnum, lnum, col, coladd, curswant], where "fnum" is only |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5441 // there when "fnump" isn't NULL; "coladd" and "curswant" are optional. |
| 915 | 5442 if (arg->v_type != VAR_LIST |
| 5443 || l == NULL | |
| 5444 || l->lv_len < (fnump == NULL ? 2 : 3) | |
| 5938 | 5445 || l->lv_len > (fnump == NULL ? 4 : 5)) |
| 709 | 5446 return FAIL; |
| 5447 | |
| 5448 if (fnump != NULL) | |
| 5449 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5450 n = list_find_nr(l, i++, NULL); // fnum |
| 709 | 5451 if (n < 0) |
| 5452 return FAIL; | |
| 5453 if (n == 0) | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5454 n = curbuf->b_fnum; // current buffer |
| 709 | 5455 *fnump = n; |
| 5456 } | |
| 5457 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5458 n = list_find_nr(l, i++, NULL); // lnum |
| 709 | 5459 if (n < 0) |
| 5460 return FAIL; | |
| 5461 posp->lnum = n; | |
| 5462 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5463 n = list_find_nr(l, i++, NULL); // col |
| 709 | 5464 if (n < 0) |
| 5465 return FAIL; | |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5466 // If character position is specified, then convert to byte position |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5467 if (charcol) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5468 { |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5469 buf_T *buf; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5470 |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5471 // Get the text for the specified line in a loaded buffer |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5472 buf = buflist_findnr(fnump == NULL ? curbuf->b_fnum : *fnump); |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5473 if (buf == NULL || buf->b_ml.ml_mfp == NULL) |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5474 return FAIL; |
|
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5475 |
|
23600
f4347a61ed38
patch 8.2.2342: "char" functions may return wrong column in Insert mode
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
5476 n = buf_charidx_to_byteidx(buf, posp->lnum, n) + 1; |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23553
diff
changeset
|
5477 } |
| 709 | 5478 posp->col = n; |
| 5479 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5480 n = list_find_nr(l, i, NULL); // off |
| 709 | 5481 if (n < 0) |
| 915 | 5482 posp->coladd = 0; |
| 5483 else | |
| 5484 posp->coladd = n; | |
| 709 | 5485 |
| 5938 | 5486 if (curswantp != NULL) |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5487 *curswantp = list_find_nr(l, i + 1, NULL); // curswant |
| 5938 | 5488 |
| 709 | 5489 return OK; |
| 5490 } | |
| 5491 | |
| 5492 /* | |
| 7 | 5493 * Get the length of an environment variable name. |
| 5494 * Advance "arg" to the first character after the name. | |
| 5495 * Return 0 for error. | |
| 5496 */ | |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
5497 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5498 get_env_len(char_u **arg) |
| 7 | 5499 { |
| 5500 char_u *p; | |
| 5501 int len; | |
| 5502 | |
| 5503 for (p = *arg; vim_isIDc(*p); ++p) | |
| 5504 ; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5505 if (p == *arg) // no name found |
| 7 | 5506 return 0; |
| 5507 | |
| 5508 len = (int)(p - *arg); | |
| 5509 *arg = p; | |
| 5510 return len; | |
| 5511 } | |
| 5512 | |
| 5513 /* | |
| 5514 * Get the length of the name of a function or internal variable. | |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
5515 * "arg" is advanced to after the name. |
| 7 | 5516 * Return 0 if something is wrong. |
| 5517 */ | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5518 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5519 get_id_len(char_u **arg) |
| 7 | 5520 { |
| 5521 char_u *p; | |
| 5522 int len; | |
| 5523 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5524 // Find the end of the name. |
| 7 | 5525 for (p = *arg; eval_isnamec(*p); ++p) |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5526 { |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5527 if (*p == ':') |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5528 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5529 // "s:" is start of "s:var", but "n:" is not and can be used in |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5530 // slice "[n:]". Also "xx:" is not a namespace. |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5531 len = (int)(p - *arg); |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5532 if ((len == 1 && vim_strchr(NAMESPACE_CHAR, **arg) == NULL) |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5533 || len > 1) |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5534 break; |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5535 } |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5536 } |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5537 if (p == *arg) // no name found |
| 7 | 5538 return 0; |
| 5539 | |
| 5540 len = (int)(p - *arg); | |
|
21630
3c6c52fbc8ea
patch 8.2.1365: Vim9: no error for missing white space around operator
Bram Moolenaar <Bram@vim.org>
parents:
21622
diff
changeset
|
5541 *arg = p; |
| 7 | 5542 |
| 5543 return len; | |
| 5544 } | |
| 5545 | |
| 5546 /* | |
| 124 | 5547 * Get the length of the name of a variable or function. |
| 5548 * Only the name is recognized, does not handle ".key" or "[idx]". | |
| 7 | 5549 * "arg" is advanced to the first non-white character after the name. |
| 159 | 5550 * Return -1 if curly braces expansion failed. |
| 5551 * Return 0 if something else is wrong. | |
| 7 | 5552 * If the name contains 'magic' {}'s, expand them and return the |
| 5553 * expanded name in an allocated string via 'alias' - caller must free. | |
| 5554 */ | |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
5555 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5556 get_name_len( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5557 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5558 char_u **alias, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5559 int evaluate, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5560 int verbose) |
| 7 | 5561 { |
| 5562 int len; | |
| 5563 char_u *p; | |
| 5564 char_u *expr_start; | |
| 5565 char_u *expr_end; | |
| 5566 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5567 *alias = NULL; // default to no alias |
| 7 | 5568 |
| 5569 if ((*arg)[0] == K_SPECIAL && (*arg)[1] == KS_EXTRA | |
| 5570 && (*arg)[2] == (int)KE_SNR) | |
| 5571 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5572 // hard coded <SNR>, already translated |
| 7 | 5573 *arg += 3; |
| 5574 return get_id_len(arg) + 3; | |
| 5575 } | |
| 5576 len = eval_fname_script(*arg); | |
| 5577 if (len > 0) | |
| 5578 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5579 // literal "<SID>", "s:" or "<SNR>" |
| 7 | 5580 *arg += len; |
| 5581 } | |
| 5582 | |
| 5583 /* | |
| 71 | 5584 * Find the end of the name; check for {} construction. |
| 7 | 5585 */ |
| 271 | 5586 p = find_name_end(*arg, &expr_start, &expr_end, |
| 5587 len > 0 ? 0 : FNE_CHECK_START); | |
| 7 | 5588 if (expr_start != NULL) |
| 5589 { | |
| 5590 char_u *temp_string; | |
| 5591 | |
| 5592 if (!evaluate) | |
| 5593 { | |
| 5594 len += (int)(p - *arg); | |
| 5595 *arg = skipwhite(p); | |
| 5596 return len; | |
| 5597 } | |
| 5598 | |
| 5599 /* | |
| 5600 * Include any <SID> etc in the expanded string: | |
| 5601 * Thus the -len here. | |
| 5602 */ | |
| 5603 temp_string = make_expanded_name(*arg - len, expr_start, expr_end, p); | |
| 5604 if (temp_string == NULL) | |
| 159 | 5605 return -1; |
| 7 | 5606 *alias = temp_string; |
| 5607 *arg = skipwhite(p); | |
| 5608 return (int)STRLEN(temp_string); | |
| 5609 } | |
| 5610 | |
| 5611 len += get_id_len(arg); | |
|
15464
3faa7cc8207c
patch 8.1.0740: Tcl test fails
Bram Moolenaar <Bram@vim.org>
parents:
15460
diff
changeset
|
5612 // Only give an error when there is something, otherwise it will be |
|
3faa7cc8207c
patch 8.1.0740: Tcl test fails
Bram Moolenaar <Bram@vim.org>
parents:
15460
diff
changeset
|
5613 // reported at a higher level. |
|
3faa7cc8207c
patch 8.1.0740: Tcl test fails
Bram Moolenaar <Bram@vim.org>
parents:
15460
diff
changeset
|
5614 if (len == 0 && verbose && **arg != NUL) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5615 semsg(_(e_invexpr2), *arg); |
| 7 | 5616 |
| 5617 return len; | |
| 5618 } | |
| 5619 | |
| 71 | 5620 /* |
| 5621 * Find the end of a variable or function name, taking care of magic braces. | |
| 5622 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the | |
| 5623 * start and end of the first magic braces item. | |
| 271 | 5624 * "flags" can have FNE_INCL_BR and FNE_CHECK_START. |
| 71 | 5625 * Return a pointer to just after the name. Equal to "arg" if there is no |
| 5626 * valid name. | |
| 5627 */ | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5628 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5629 find_name_end( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5630 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5631 char_u **expr_start, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5632 char_u **expr_end, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5633 int flags) |
| 71 | 5634 { |
| 5635 int mb_nest = 0; | |
| 5636 int br_nest = 0; | |
| 7 | 5637 char_u *p; |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5638 int len; |
|
21279
8d1d11afd8c8
patch 8.2.1190: Vim9: checking for Vim9 syntax is spread out
Bram Moolenaar <Bram@vim.org>
parents:
21277
diff
changeset
|
5639 int vim9script = in_vim9script(); |
| 7 | 5640 |
| 71 | 5641 if (expr_start != NULL) |
| 5642 { | |
| 5643 *expr_start = NULL; | |
| 5644 *expr_end = NULL; | |
| 5645 } | |
| 5646 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5647 // Quick check for valid starting character. |
|
20091
a64c16ff98b8
patch 8.2.0601: Vim9: :unlet is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
20061
diff
changeset
|
5648 if ((flags & FNE_CHECK_START) && !eval_isnamec1(*arg) |
|
a64c16ff98b8
patch 8.2.0601: Vim9: :unlet is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
20061
diff
changeset
|
5649 && (*arg != '{' || vim9script)) |
| 271 | 5650 return arg; |
| 5651 | |
| 71 | 5652 for (p = arg; *p != NUL |
| 5653 && (eval_isnamec(*p) | |
|
20091
a64c16ff98b8
patch 8.2.0601: Vim9: :unlet is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
20061
diff
changeset
|
5654 || (*p == '{' && !vim9script) |
|
21447
369cde0d5771
patch 8.2.1274: Vim9: no error for missing white space at script level
Bram Moolenaar <Bram@vim.org>
parents:
21443
diff
changeset
|
5655 || ((flags & FNE_INCL_BR) && (*p == '[' |
|
21512
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5656 || (*p == '.' && eval_isdictc(p[1])))) |
| 71 | 5657 || mb_nest != 0 |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10964
diff
changeset
|
5658 || br_nest != 0); MB_PTR_ADV(p)) |
| 468 | 5659 { |
| 5660 if (*p == '\'') | |
| 5661 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5662 // skip over 'string' to avoid counting [ and ] inside it. |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10964
diff
changeset
|
5663 for (p = p + 1; *p != NUL && *p != '\''; MB_PTR_ADV(p)) |
| 468 | 5664 ; |
| 5665 if (*p == NUL) | |
| 5666 break; | |
| 5667 } | |
| 5668 else if (*p == '"') | |
| 5669 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5670 // skip over "str\"ing" to avoid counting [ and ] inside it. |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10964
diff
changeset
|
5671 for (p = p + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p)) |
| 468 | 5672 if (*p == '\\' && p[1] != NUL) |
| 5673 ++p; | |
| 5674 if (*p == NUL) | |
| 5675 break; | |
| 5676 } | |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5677 else if (br_nest == 0 && mb_nest == 0 && *p == ':') |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5678 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5679 // "s:" is start of "s:var", but "n:" is not and can be used in |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5680 // slice "[n:]". Also "xx:" is not a namespace. But {ns}: is. |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5681 len = (int)(p - arg); |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5682 if ((len == 1 && vim_strchr(NAMESPACE_CHAR, *arg) == NULL) |
|
7627
d9ec7d22494d
commit https://github.com/vim/vim/commit/4119cf80e1e534057680f9543e73edf7967c2440
Christian Brabandt <cb@256bit.org>
parents:
7615
diff
changeset
|
5683 || (len > 1 && p[-1] != '}')) |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5684 break; |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5685 } |
| 468 | 5686 |
| 71 | 5687 if (mb_nest == 0) |
| 5688 { | |
| 5689 if (*p == '[') | |
| 5690 ++br_nest; | |
| 5691 else if (*p == ']') | |
| 5692 --br_nest; | |
| 5693 } | |
| 468 | 5694 |
|
20091
a64c16ff98b8
patch 8.2.0601: Vim9: :unlet is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
20061
diff
changeset
|
5695 if (br_nest == 0 && !vim9script) |
| 71 | 5696 { |
| 5697 if (*p == '{') | |
| 5698 { | |
| 5699 mb_nest++; | |
| 5700 if (expr_start != NULL && *expr_start == NULL) | |
| 5701 *expr_start = p; | |
| 5702 } | |
| 5703 else if (*p == '}') | |
| 5704 { | |
| 5705 mb_nest--; | |
| 5706 if (expr_start != NULL && mb_nest == 0 && *expr_end == NULL) | |
| 5707 *expr_end = p; | |
| 5708 } | |
| 5709 } | |
| 7 | 5710 } |
| 5711 | |
| 5712 return p; | |
| 5713 } | |
| 5714 | |
| 5715 /* | |
| 159 | 5716 * Expands out the 'magic' {}'s in a variable/function name. |
| 5717 * Note that this can call itself recursively, to deal with | |
| 5718 * constructs like foo{bar}{baz}{bam} | |
| 5719 * The four pointer arguments point to "foo{expre}ss{ion}bar" | |
| 5720 * "in_start" ^ | |
| 5721 * "expr_start" ^ | |
| 5722 * "expr_end" ^ | |
| 5723 * "in_end" ^ | |
| 5724 * | |
| 5725 * Returns a new allocated string, which the caller must free. | |
| 5726 * Returns NULL for failure. | |
| 5727 */ | |
| 5728 static char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5729 make_expanded_name( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5730 char_u *in_start, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5731 char_u *expr_start, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5732 char_u *expr_end, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5733 char_u *in_end) |
| 159 | 5734 { |
| 5735 char_u c1; | |
| 5736 char_u *retval = NULL; | |
| 5737 char_u *temp_result; | |
| 5738 | |
| 5739 if (expr_end == NULL || in_end == NULL) | |
| 5740 return NULL; | |
| 5741 *expr_start = NUL; | |
| 5742 *expr_end = NUL; | |
| 5743 c1 = *in_end; | |
| 5744 *in_end = NUL; | |
| 5745 | |
|
20996
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
5746 temp_result = eval_to_string(expr_start + 1, FALSE); |
|
3af71cbcfdbe
patch 8.2.1049: Vim9: leaking memory when using continuation line
Bram Moolenaar <Bram@vim.org>
parents:
20992
diff
changeset
|
5747 if (temp_result != NULL) |
| 159 | 5748 { |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16706
diff
changeset
|
5749 retval = alloc(STRLEN(temp_result) + (expr_start - in_start) |
|
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16706
diff
changeset
|
5750 + (in_end - expr_end) + 1); |
| 159 | 5751 if (retval != NULL) |
| 5752 { | |
| 5753 STRCPY(retval, in_start); | |
| 5754 STRCAT(retval, temp_result); | |
| 5755 STRCAT(retval, expr_end + 1); | |
| 5756 } | |
| 5757 } | |
| 5758 vim_free(temp_result); | |
| 5759 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5760 *in_end = c1; // put char back for error messages |
| 159 | 5761 *expr_start = '{'; |
| 5762 *expr_end = '}'; | |
| 5763 | |
| 5764 if (retval != NULL) | |
| 5765 { | |
| 271 | 5766 temp_result = find_name_end(retval, &expr_start, &expr_end, 0); |
| 159 | 5767 if (expr_start != NULL) |
| 5768 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5769 // Further expansion! |
| 159 | 5770 temp_result = make_expanded_name(retval, expr_start, |
| 5771 expr_end, temp_result); | |
| 5772 vim_free(retval); | |
| 5773 retval = temp_result; | |
| 5774 } | |
| 5775 } | |
| 5776 | |
| 5777 return retval; | |
| 5778 } | |
| 5779 | |
| 5780 /* | |
| 7 | 5781 * Return TRUE if character "c" can be used in a variable or function name. |
| 104 | 5782 * Does not include '{' or '}' for magic braces. |
| 7 | 5783 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5784 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5785 eval_isnamec(int c) |
| 7 | 5786 { |
|
21512
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5787 return ASCII_ISALNUM(c) || c == '_' || c == ':' || c == AUTOLOAD_CHAR; |
| 271 | 5788 } |
| 5789 | |
| 5790 /* | |
| 5791 * Return TRUE if character "c" can be used as the first character in a | |
| 5792 * variable or function name (excluding '{' and '}'). | |
| 5793 */ | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5794 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5795 eval_isnamec1(int c) |
| 271 | 5796 { |
|
21512
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5797 return ASCII_ISALPHA(c) || c == '_'; |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5798 } |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5799 |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5800 /* |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5801 * Return TRUE if character "c" can be used as the first character of a |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5802 * dictionary key. |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5803 */ |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5804 int |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5805 eval_isdictc(int c) |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5806 { |
|
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5807 return ASCII_ISALNUM(c) || c == '_'; |
| 7 | 5808 } |
| 5809 | |
| 5810 /* | |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5811 * Handle: |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5812 * - expr[expr], expr[expr:expr] subscript |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5813 * - ".name" lookup |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5814 * - function call with Funcref variable: func(expr) |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5815 * - method call: var->method() |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5816 * |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5817 * Can all be combined in any order: dict.func(expr)[idx]['func'](expr)->len() |
| 159 | 5818 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5819 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5820 handle_subscript( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5821 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5822 typval_T *rettv, |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
5823 evalarg_T *evalarg, |
|
21032
f80e822a310d
patch 8.2.1067: expression "!expr->func()" does not work
Bram Moolenaar <Bram@vim.org>
parents:
21028
diff
changeset
|
5824 int verbose) // give error messages |
| 159 | 5825 { |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
5826 int evaluate = evalarg != NULL |
|
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
5827 && (evalarg->eval_flags & EVAL_EVALUATE); |
| 159 | 5828 int ret = OK; |
| 5829 dict_T *selfdict = NULL; | |
|
21142
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
5830 int check_white = TRUE; |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5831 int getnext; |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5832 char_u *p; |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5833 |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5834 while (ret == OK) |
|
21142
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
5835 { |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5836 // When at the end of the line and ".name" or "->{" or "->X" follows in |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5837 // the next line then consume the line break. |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5838 p = eval_next_non_blank(*arg, evalarg, &getnext); |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5839 if (getnext |
|
21512
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21461
diff
changeset
|
5840 && ((rettv->v_type == VAR_DICT && *p == '.' && eval_isdictc(p[1])) |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
5841 || (p[0] == '-' && p[1] == '>' |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5842 && (p[2] == '{' || ASCII_ISALPHA(p[2]))))) |
|
21142
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
5843 { |
|
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
5844 *arg = eval_next_line(evalarg); |
|
21865
c16af87df654
patch 8.2.1482: Vim9: crash when using a nested lambda
Bram Moolenaar <Bram@vim.org>
parents:
21861
diff
changeset
|
5845 p = *arg; |
|
21142
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
5846 check_white = FALSE; |
|
165cea61e974
patch 8.2.1122: Vim9: line continuation in dict member not recognized
Bram Moolenaar <Bram@vim.org>
parents:
21120
diff
changeset
|
5847 } |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5848 |
|
24112
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5849 if (rettv->v_type == VAR_ANY) |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5850 { |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5851 char_u *exp_name; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5852 int cc; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5853 int idx; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5854 ufunc_T *ufunc; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5855 type_T *type; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5856 |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5857 // Found script from "import * as {name}", script item name must |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5858 // follow. |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5859 if (**arg != '.') |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5860 { |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5861 if (verbose) |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5862 semsg(_(e_expected_str_but_got_str), "'.'", *arg); |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5863 ret = FAIL; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5864 break; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5865 } |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5866 ++*arg; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5867 if (IS_WHITE_OR_NUL(**arg)) |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5868 { |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5869 if (verbose) |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5870 emsg(_(e_no_white_space_allowed_after_dot)); |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5871 ret = FAIL; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5872 break; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5873 } |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5874 |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5875 // isolate the name |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5876 exp_name = *arg; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5877 while (eval_isnamec(**arg)) |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5878 ++*arg; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5879 cc = **arg; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5880 **arg = NUL; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5881 |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5882 idx = find_exported(rettv->vval.v_number, exp_name, &ufunc, &type, |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5883 evalarg->eval_cctx, verbose); |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5884 **arg = cc; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5885 *arg = skipwhite(*arg); |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5886 |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5887 if (idx < 0 && ufunc == NULL) |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5888 { |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5889 ret = FAIL; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5890 break; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5891 } |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5892 if (idx >= 0) |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5893 { |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5894 scriptitem_T *si = SCRIPT_ITEM(rettv->vval.v_number); |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5895 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5896 |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5897 copy_tv(sv->sv_tv, rettv); |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5898 } |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5899 else |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5900 { |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5901 rettv->v_type = VAR_FUNC; |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5902 rettv->vval.v_string = vim_strsave(ufunc->uf_name); |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5903 } |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5904 } |
|
0346a59ed5bf
patch 8.2.2597: Vim9: "import * as" does not work at script level
Bram Moolenaar <Bram@vim.org>
parents:
24063
diff
changeset
|
5905 |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5906 if ((**arg == '(' && (!evaluate || rettv->v_type == VAR_FUNC |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5907 || rettv->v_type == VAR_PARTIAL)) |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5908 && (!check_white || !VIM_ISWHITE(*(*arg - 1)))) |
| 159 | 5909 { |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
5910 ret = call_func_rettv(arg, evalarg, rettv, evaluate, |
|
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
5911 selfdict, NULL); |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
5912 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
5913 // Stop the expression evaluation when immediately aborting on |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
5914 // error, or when an interrupt occurred or an exception was thrown |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
5915 // but not caught. |
| 159 | 5916 if (aborting()) |
| 5917 { | |
| 5918 if (ret == OK) | |
| 5919 clear_tv(rettv); | |
| 5920 ret = FAIL; | |
| 5921 } | |
| 5922 dict_unref(selfdict); | |
| 5923 selfdict = NULL; | |
| 5924 } | |
|
21552
cbc570e66d11
patch 8.2.1326: Vim9: skipping over white space after list
Bram Moolenaar <Bram@vim.org>
parents:
21546
diff
changeset
|
5925 else if (p[0] == '-' && p[1] == '>') |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5926 { |
|
24632
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5927 if (in_vim9script()) |
|
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5928 *arg = skipwhite(p + 2); |
|
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5929 else |
|
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5930 *arg = p + 2; |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5931 if (ret == OK) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5932 { |
|
24632
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5933 if (VIM_ISWHITE(**arg)) |
|
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5934 { |
|
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5935 emsg(_(e_nowhitespace)); |
|
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5936 ret = FAIL; |
|
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5937 } |
|
9e72076e31f8
patch 8.2.2855: white space after "->" does not give E274
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
5938 else if ((**arg == '{' && !in_vim9script()) || **arg == '(') |
|
23428
5807e3958e38
patch 8.2.2257: Vim9: using -> for lambda is ambiguous
Bram Moolenaar <Bram@vim.org>
parents:
23416
diff
changeset
|
5939 // expr->{lambda}() or expr->(lambda)() |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
5940 ret = eval_lambda(arg, rettv, evalarg, verbose); |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5941 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5942 // expr->name() |
|
21118
b0baa80cb53f
patch 8.2.1110: Vim9: line continuation does not work in function arguments
Bram Moolenaar <Bram@vim.org>
parents:
21104
diff
changeset
|
5943 ret = eval_method(arg, rettv, evalarg, verbose); |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5944 } |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5945 } |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5946 // "." is ".name" lookup when we found a dict or when evaluating and |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5947 // scriptversion is at least 2, where string concatenation is "..". |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5948 else if (**arg == '[' |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5949 || (**arg == '.' && (rettv->v_type == VAR_DICT |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5950 || (!evaluate |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5951 && (*arg)[1] != '.' |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5952 && current_sctx.sc_version >= 2)))) |
| 159 | 5953 { |
| 5954 dict_unref(selfdict); | |
| 5955 if (rettv->v_type == VAR_DICT) | |
| 5956 { | |
| 5957 selfdict = rettv->vval.v_dict; | |
| 5958 if (selfdict != NULL) | |
| 5959 ++selfdict->dv_refcount; | |
| 5960 } | |
| 5961 else | |
| 5962 selfdict = NULL; | |
|
21040
d9e0db9b2b99
patch 8.2.1071: Vim9: no line break allowed inside a lambda
Bram Moolenaar <Bram@vim.org>
parents:
21034
diff
changeset
|
5963 if (eval_index(arg, rettv, evalarg, verbose) == FAIL) |
| 159 | 5964 { |
| 5965 clear_tv(rettv); | |
| 5966 ret = FAIL; | |
| 5967 } | |
| 5968 } | |
|
21208
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5969 else |
|
09377fd59b2e
patch 8.2.1155: Vim9: cannot handle line break inside lambda
Bram Moolenaar <Bram@vim.org>
parents:
21148
diff
changeset
|
5970 break; |
| 159 | 5971 } |
|
8575
b5209a4e5baf
commit https://github.com/vim/vim/commit/ab1fa3955f25dfdb7e329c3bd76e175c93c8cb5e
Christian Brabandt <cb@256bit.org>
parents:
8554
diff
changeset
|
5972 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5973 // Turn "dict.Func" into a partial for "Func" bound to "dict". |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5974 // Don't do this when "Func" is already a partial that was bound |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5975 // explicitly (pt_auto is FALSE). |
|
9104
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5976 if (selfdict != NULL |
|
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5977 && (rettv->v_type == VAR_FUNC |
|
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5978 || (rettv->v_type == VAR_PARTIAL |
|
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5979 && (rettv->vval.v_partial->pt_auto |
|
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5980 || rettv->vval.v_partial->pt_dict == NULL)))) |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5981 selfdict = make_partial(selfdict, rettv); |
|
8575
b5209a4e5baf
commit https://github.com/vim/vim/commit/ab1fa3955f25dfdb7e329c3bd76e175c93c8cb5e
Christian Brabandt <cb@256bit.org>
parents:
8554
diff
changeset
|
5982 |
| 159 | 5983 dict_unref(selfdict); |
| 5984 return ret; | |
| 5985 } | |
| 5986 | |
| 5987 /* | |
| 104 | 5988 * Make a copy of an item. |
| 5989 * Lists and Dictionaries are also copied. A deep copy if "deep" is set. | |
| 165 | 5990 * For deepcopy() "copyID" is zero for a full copy or the ID for when a |
| 5991 * reference to an already copied list/dict can be used. | |
| 5992 * Returns FAIL or OK. | |
| 5993 */ | |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
5994 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5995 item_copy( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5996 typval_T *from, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5997 typval_T *to, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5998 int deep, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5999 int copyID) |
| 104 | 6000 { |
| 6001 static int recurse = 0; | |
| 165 | 6002 int ret = OK; |
| 104 | 6003 |
| 137 | 6004 if (recurse >= DICT_MAXNEST) |
| 104 | 6005 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6006 emsg(_("E698: variable nested too deep for making a copy")); |
| 165 | 6007 return FAIL; |
| 104 | 6008 } |
| 6009 ++recurse; | |
| 6010 | |
| 6011 switch (from->v_type) | |
| 6012 { | |
| 6013 case VAR_NUMBER: | |
| 1624 | 6014 case VAR_FLOAT: |
| 104 | 6015 case VAR_STRING: |
| 6016 case VAR_FUNC: | |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
6017 case VAR_PARTIAL: |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
6018 case VAR_BOOL: |
|
7862
d4fec9208e7e
commit https://github.com/vim/vim/commit/155500077c80cdb5d9c63996000c011b66a676bf
Christian Brabandt <cb@256bit.org>
parents:
7856
diff
changeset
|
6019 case VAR_SPECIAL: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
6020 case VAR_JOB: |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
6021 case VAR_CHANNEL: |
|
24606
a4fda40e0bb9
patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
24553
diff
changeset
|
6022 case VAR_INSTR: |
| 104 | 6023 copy_tv(from, to); |
| 6024 break; | |
| 6025 case VAR_LIST: | |
| 6026 to->v_type = VAR_LIST; | |
| 151 | 6027 to->v_lock = 0; |
| 165 | 6028 if (from->vval.v_list == NULL) |
| 6029 to->vval.v_list = NULL; | |
| 6030 else if (copyID != 0 && from->vval.v_list->lv_copyID == copyID) | |
| 6031 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6032 // use the copy made earlier |
| 165 | 6033 to->vval.v_list = from->vval.v_list->lv_copylist; |
| 6034 ++to->vval.v_list->lv_refcount; | |
| 6035 } | |
| 6036 else | |
| 6037 to->vval.v_list = list_copy(from->vval.v_list, deep, copyID); | |
| 6038 if (to->vval.v_list == NULL) | |
| 6039 ret = FAIL; | |
| 104 | 6040 break; |
|
15496
f1c33409e908
patch 8.1.0756: copy() does not make a copy of a Blob
Bram Moolenaar <Bram@vim.org>
parents:
15490
diff
changeset
|
6041 case VAR_BLOB: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6042 ret = blob_copy(from->vval.v_blob, to); |
|
15496
f1c33409e908
patch 8.1.0756: copy() does not make a copy of a Blob
Bram Moolenaar <Bram@vim.org>
parents:
15490
diff
changeset
|
6043 break; |
| 104 | 6044 case VAR_DICT: |
| 6045 to->v_type = VAR_DICT; | |
| 151 | 6046 to->v_lock = 0; |
| 165 | 6047 if (from->vval.v_dict == NULL) |
| 6048 to->vval.v_dict = NULL; | |
| 6049 else if (copyID != 0 && from->vval.v_dict->dv_copyID == copyID) | |
| 6050 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6051 // use the copy made earlier |
| 165 | 6052 to->vval.v_dict = from->vval.v_dict->dv_copydict; |
| 6053 ++to->vval.v_dict->dv_refcount; | |
| 6054 } | |
| 6055 else | |
| 6056 to->vval.v_dict = dict_copy(from->vval.v_dict, deep, copyID); | |
| 6057 if (to->vval.v_dict == NULL) | |
| 6058 ret = FAIL; | |
| 104 | 6059 break; |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
6060 case VAR_UNKNOWN: |
|
19922
1f42c49c3d29
patch 8.2.0517: Vim9: cannot separate "func" and "func(): void"
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
6061 case VAR_ANY: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6062 case VAR_VOID: |
|
19554
b38d73f36467
patch 8.2.0334: abort called when using test_void()
Bram Moolenaar <Bram@vim.org>
parents:
19477
diff
changeset
|
6063 internal_error_no_abort("item_copy(UNKNOWN)"); |
| 165 | 6064 ret = FAIL; |
| 104 | 6065 } |
| 6066 --recurse; | |
| 165 | 6067 return ret; |
| 104 | 6068 } |
| 6069 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6070 void |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6071 echo_one(typval_T *rettv, int with_space, int *atstart, int *needclr) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6072 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6073 char_u *tofree; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6074 char_u numbuf[NUMBUFLEN]; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6075 char_u *p = echo_string(rettv, &tofree, numbuf, get_copyID()); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6076 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6077 if (*atstart) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6078 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6079 *atstart = FALSE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6080 // Call msg_start() after eval1(), evaluating the expression |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6081 // may cause a message to appear. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6082 if (with_space) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6083 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6084 // Mark the saved text as finishing the line, so that what |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6085 // follows is displayed on a new line when scrolling back |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6086 // at the more prompt. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6087 msg_sb_eol(); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6088 msg_start(); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6089 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6090 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6091 else if (with_space) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6092 msg_puts_attr(" ", echo_attr); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6093 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6094 if (p != NULL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6095 for ( ; *p != NUL && !got_int; ++p) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6096 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6097 if (*p == '\n' || *p == '\r' || *p == TAB) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6098 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6099 if (*p != TAB && *needclr) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6100 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6101 // remove any text still there from the command |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6102 msg_clr_eos(); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6103 *needclr = FALSE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6104 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6105 msg_putchar_attr(*p, echo_attr); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6106 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6107 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6108 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6109 if (has_mbyte) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6110 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6111 int i = (*mb_ptr2len)(p); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6112 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6113 (void)msg_outtrans_len_attr(p, i, echo_attr); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6114 p += i - 1; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6115 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6116 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6117 (void)msg_outtrans_len_attr(p, 1, echo_attr); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6118 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6119 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6120 vim_free(tofree); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6121 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6122 |
| 104 | 6123 /* |
| 7 | 6124 * ":echo expr1 ..." print each argument separated with a space, add a |
| 6125 * newline at the end. | |
| 6126 * ":echon expr1 ..." print each argument plain. | |
| 6127 */ | |
| 6128 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6129 ex_echo(exarg_T *eap) |
| 7 | 6130 { |
| 6131 char_u *arg = eap->arg; | |
| 137 | 6132 typval_T rettv; |
|
24614
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6133 char_u *arg_start; |
| 7 | 6134 int needclr = TRUE; |
| 6135 int atstart = TRUE; | |
|
15079
a527110d5f56
patch 8.1.0550: expression evaluation may repeat an error message
Bram Moolenaar <Bram@vim.org>
parents:
14968
diff
changeset
|
6136 int did_emsg_before = did_emsg; |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
6137 int called_emsg_before = called_emsg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
6138 evalarg_T evalarg; |
|
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
6139 |
|
21104
f8ec5a7a9cf6
patch 8.2.1103: Coverity reports an unnecessary NULL check
Bram Moolenaar <Bram@vim.org>
parents:
21098
diff
changeset
|
6140 fill_evalarg_from_eap(&evalarg, eap, eap->skip); |
| 7 | 6141 |
| 6142 if (eap->skip) | |
| 6143 ++emsg_skip; | |
|
20059
de756b3f4dee
patch 8.2.0585: Vim9: # comment not recognized after :vim9script
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
6144 while ((!ends_excmd2(eap->cmd, arg) || *arg == '"') && !got_int) |
| 7 | 6145 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6146 // If eval1() causes an error message the text from the command may |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6147 // still need to be cleared. E.g., "echo 22,44". |
| 1624 | 6148 need_clr_eos = needclr; |
| 6149 | |
|
24614
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6150 arg_start = arg; |
|
20992
7ee565134d4a
patch 8.2.1047: Vim9: script cannot use line continuation like :def function
Bram Moolenaar <Bram@vim.org>
parents:
20943
diff
changeset
|
6151 if (eval1(&arg, &rettv, &evalarg) == FAIL) |
| 7 | 6152 { |
| 6153 /* | |
| 6154 * Report the invalid expression unless the expression evaluation | |
| 6155 * has been cancelled due to an aborting error, an interrupt, or an | |
| 6156 * exception. | |
| 6157 */ | |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
6158 if (!aborting() && did_emsg == did_emsg_before |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
6159 && called_emsg == called_emsg_before) |
|
24614
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6160 semsg(_(e_invexpr2), arg_start); |
| 1624 | 6161 need_clr_eos = FALSE; |
| 6162 break; | |
| 6163 } | |
| 6164 need_clr_eos = FALSE; | |
| 6165 | |
| 7 | 6166 if (!eap->skip) |
|
24614
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6167 { |
|
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6168 if (rettv.v_type == VAR_VOID) |
|
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6169 { |
|
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6170 semsg(_(e_expression_does_not_result_in_value_str), arg_start); |
|
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6171 break; |
|
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6172 } |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6173 echo_one(&rettv, eap->cmdidx == CMD_echo, &atstart, &needclr); |
|
24614
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6174 } |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6175 |
| 71 | 6176 clear_tv(&rettv); |
| 7 | 6177 arg = skipwhite(arg); |
| 6178 } | |
| 6179 eap->nextcmd = check_nextcmd(arg); | |
|
21050
7a9daf73a724
patch 8.2.1076: Vim9: no line break allowed in :if expression
Bram Moolenaar <Bram@vim.org>
parents:
21048
diff
changeset
|
6180 clear_evalarg(&evalarg, eap); |
| 7 | 6181 |
| 6182 if (eap->skip) | |
| 6183 --emsg_skip; | |
| 6184 else | |
| 6185 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6186 // remove text that may still be there from the command |
| 7 | 6187 if (needclr) |
| 6188 msg_clr_eos(); | |
| 6189 if (eap->cmdidx == CMD_echo) | |
| 6190 msg_end(); | |
| 6191 } | |
| 6192 } | |
| 6193 | |
| 6194 /* | |
| 6195 * ":echohl {name}". | |
| 6196 */ | |
| 6197 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6198 ex_echohl(exarg_T *eap) |
| 7 | 6199 { |
|
12487
3f16cf18386c
patch 8.0.1123: cannot define a toolbar for a window
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
6200 echo_attr = syn_name2attr(eap->arg); |
| 7 | 6201 } |
| 6202 | |
| 6203 /* | |
|
17922
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6204 * Returns the :echo attribute |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6205 */ |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6206 int |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6207 get_echo_attr(void) |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6208 { |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6209 return echo_attr; |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6210 } |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6211 |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6212 /* |
| 7 | 6213 * ":execute expr1 ..." execute the result of an expression. |
| 6214 * ":echomsg expr1 ..." Print a message | |
| 6215 * ":echoerr expr1 ..." Print an error | |
|
24194
9f64c420f280
patch 8.2.2638: cannot write a message to the terminal from the GUI
Bram Moolenaar <Bram@vim.org>
parents:
24190
diff
changeset
|
6216 * ":echoconsole expr1 ..." Print a message on stdout |
| 7 | 6217 * Each gets spaces around each argument and a newline at the end for |
| 6218 * echo commands | |
| 6219 */ | |
| 6220 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6221 ex_execute(exarg_T *eap) |
| 7 | 6222 { |
| 6223 char_u *arg = eap->arg; | |
| 137 | 6224 typval_T rettv; |
| 7 | 6225 int ret = OK; |
| 6226 char_u *p; | |
| 6227 garray_T ga; | |
| 6228 int len; | |
| 6229 | |
| 6230 ga_init2(&ga, 1, 80); | |
| 6231 | |
| 6232 if (eap->skip) | |
| 6233 ++emsg_skip; | |
|
20061
6e6a75800884
patch 8.2.0586: Vim9: # comment not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
20059
diff
changeset
|
6234 while (!ends_excmd2(eap->cmd, arg) || *arg == '"') |
| 7 | 6235 { |
|
21098
e88b0daa2fcb
patch 8.2.1100: Vim9: cannot use line break in :execute argument
Bram Moolenaar <Bram@vim.org>
parents:
21096
diff
changeset
|
6236 ret = eval1_emsg(&arg, &rettv, eap); |
|
15478
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
6237 if (ret == FAIL) |
| 7 | 6238 break; |
| 6239 | |
| 6240 if (!eap->skip) | |
| 6241 { | |
|
15219
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6242 char_u buf[NUMBUFLEN]; |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6243 |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6244 if (eap->cmdidx == CMD_execute) |
|
19087
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6245 { |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6246 if (rettv.v_type == VAR_CHANNEL || rettv.v_type == VAR_JOB) |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6247 { |
|
24614
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6248 semsg(_(e_using_invalid_value_as_string_str), |
|
07b3d21a8b4b
patch 8.2.2846: Vim9: "echo Func()" does not give an error for using void
Bram Moolenaar <Bram@vim.org>
parents:
24606
diff
changeset
|
6249 vartype_name(rettv.v_type)); |
|
19087
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6250 p = NULL; |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6251 } |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6252 else |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6253 p = tv_get_string_buf(&rettv, buf); |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6254 } |
|
15219
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6255 else |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6256 p = tv_stringify(&rettv, buf); |
|
19081
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6257 if (p == NULL) |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6258 { |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6259 clear_tv(&rettv); |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6260 ret = FAIL; |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6261 break; |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6262 } |
| 7 | 6263 len = (int)STRLEN(p); |
| 6264 if (ga_grow(&ga, len + 2) == FAIL) | |
| 6265 { | |
| 71 | 6266 clear_tv(&rettv); |
| 7 | 6267 ret = FAIL; |
| 6268 break; | |
| 6269 } | |
| 6270 if (ga.ga_len) | |
| 6271 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' '; | |
| 6272 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p); | |
| 6273 ga.ga_len += len; | |
| 6274 } | |
| 6275 | |
| 71 | 6276 clear_tv(&rettv); |
| 7 | 6277 arg = skipwhite(arg); |
| 6278 } | |
| 6279 | |
| 6280 if (ret != FAIL && ga.ga_data != NULL) | |
| 6281 { | |
|
11161
404e98047f0b
patch 8.0.0467: using g< after :for does not show the right output
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
6282 if (eap->cmdidx == CMD_echomsg || eap->cmdidx == CMD_echoerr) |
|
404e98047f0b
patch 8.0.0467: using g< after :for does not show the right output
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
6283 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6284 // Mark the already saved text as finishing the line, so that what |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6285 // follows is displayed on a new line when scrolling back at the |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6286 // more prompt. |
|
11161
404e98047f0b
patch 8.0.0467: using g< after :for does not show the right output
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
6287 msg_sb_eol(); |
|
404e98047f0b
patch 8.0.0467: using g< after :for does not show the right output
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
6288 } |
|
404e98047f0b
patch 8.0.0467: using g< after :for does not show the right output
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
6289 |
| 7 | 6290 if (eap->cmdidx == CMD_echomsg) |
| 625 | 6291 { |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15517
diff
changeset
|
6292 msg_attr(ga.ga_data, echo_attr); |
| 625 | 6293 out_flush(); |
| 6294 } | |
|
24194
9f64c420f280
patch 8.2.2638: cannot write a message to the terminal from the GUI
Bram Moolenaar <Bram@vim.org>
parents:
24190
diff
changeset
|
6295 else if (eap->cmdidx == CMD_echoconsole) |
|
9f64c420f280
patch 8.2.2638: cannot write a message to the terminal from the GUI
Bram Moolenaar <Bram@vim.org>
parents:
24190
diff
changeset
|
6296 { |
|
9f64c420f280
patch 8.2.2638: cannot write a message to the terminal from the GUI
Bram Moolenaar <Bram@vim.org>
parents:
24190
diff
changeset
|
6297 ui_write(ga.ga_data, (int)STRLEN(ga.ga_data), TRUE); |
|
9f64c420f280
patch 8.2.2638: cannot write a message to the terminal from the GUI
Bram Moolenaar <Bram@vim.org>
parents:
24190
diff
changeset
|
6298 ui_write((char_u *)"\r\n", 2, TRUE); |
|
9f64c420f280
patch 8.2.2638: cannot write a message to the terminal from the GUI
Bram Moolenaar <Bram@vim.org>
parents:
24190
diff
changeset
|
6299 } |
| 7 | 6300 else if (eap->cmdidx == CMD_echoerr) |
| 6301 { | |
|
20142
fe8d0a4344df
patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
20128
diff
changeset
|
6302 int save_did_emsg = did_emsg; |
|
fe8d0a4344df
patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
20128
diff
changeset
|
6303 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6304 // We don't want to abort following commands, restore did_emsg. |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6305 emsg(ga.ga_data); |
| 7 | 6306 if (!force_abort) |
| 6307 did_emsg = save_did_emsg; | |
| 6308 } | |
| 6309 else if (eap->cmdidx == CMD_execute) | |
| 6310 do_cmdline((char_u *)ga.ga_data, | |
| 6311 eap->getline, eap->cookie, DOCMD_NOWAIT|DOCMD_VERBOSE); | |
| 6312 } | |
| 6313 | |
| 6314 ga_clear(&ga); | |
| 6315 | |
| 6316 if (eap->skip) | |
| 6317 --emsg_skip; | |
| 6318 | |
| 6319 eap->nextcmd = check_nextcmd(arg); | |
| 6320 } | |
| 6321 | |
| 6322 /* | |
| 6323 * Skip over the name of an option: "&option", "&g:option" or "&l:option". | |
| 6324 * "arg" points to the "&" or '+' when called, to "option" when returning. | |
| 6325 * Returns NULL when no option name found. Otherwise pointer to the char | |
| 6326 * after the option name. | |
| 6327 */ | |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
6328 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6329 find_option_end(char_u **arg, int *opt_flags) |
| 7 | 6330 { |
| 6331 char_u *p = *arg; | |
| 6332 | |
| 6333 ++p; | |
| 6334 if (*p == 'g' && p[1] == ':') | |
| 6335 { | |
| 6336 *opt_flags = OPT_GLOBAL; | |
| 6337 p += 2; | |
| 6338 } | |
| 6339 else if (*p == 'l' && p[1] == ':') | |
| 6340 { | |
| 6341 *opt_flags = OPT_LOCAL; | |
| 6342 p += 2; | |
| 6343 } | |
| 6344 else | |
| 6345 *opt_flags = 0; | |
| 6346 | |
| 6347 if (!ASCII_ISALPHA(*p)) | |
| 6348 return NULL; | |
| 6349 *arg = p; | |
| 6350 | |
| 6351 if (p[0] == 't' && p[1] == '_' && p[2] != NUL && p[3] != NUL) | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6352 p += 4; // termcap option |
| 7 | 6353 else |
| 6354 while (ASCII_ISALPHA(*p)) | |
| 6355 ++p; | |
| 6356 return p; | |
| 6357 } | |
| 6358 | |
| 6359 /* | |
| 448 | 6360 * Display script name where an item was last set. |
| 6361 * Should only be invoked when 'verbose' is non-zero. | |
| 6362 */ | |
| 6363 void | |
|
14700
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6364 last_set_msg(sctx_T script_ctx) |
| 448 | 6365 { |
| 507 | 6366 char_u *p; |
| 6367 | |
|
14700
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6368 if (script_ctx.sc_sid != 0) |
|
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6369 { |
|
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6370 p = home_replace_save(NULL, get_scriptname(script_ctx.sc_sid)); |
| 507 | 6371 if (p != NULL) |
| 6372 { | |
| 6373 verbose_enter(); | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15517
diff
changeset
|
6374 msg_puts(_("\n\tLast set from ")); |
|
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15517
diff
changeset
|
6375 msg_puts((char *)p); |
|
14700
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6376 if (script_ctx.sc_lnum > 0) |
|
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6377 { |
|
18939
25ebc35e104f
patch 8.2.0030: "gF" does not work on output of "verbose command"
Bram Moolenaar <Bram@vim.org>
parents:
18851
diff
changeset
|
6378 msg_puts(_(line_msg)); |
|
14700
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6379 msg_outnum((long)script_ctx.sc_lnum); |
|
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6380 } |
|
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6381 verbose_leave(); |
| 507 | 6382 vim_free(p); |
| 6383 } | |
| 448 | 6384 } |
| 6385 } | |
| 6386 | |
|
17966
46f95606b9ec
patch 8.1.1979: code for handling file names is spread out
Bram Moolenaar <Bram@vim.org>
parents:
17964
diff
changeset
|
6387 #endif // FEAT_EVAL |
| 7 | 6388 |
| 6389 /* | |
| 6390 * Perform a substitution on "str" with pattern "pat" and substitute "sub". | |
|
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9587
diff
changeset
|
6391 * When "sub" is NULL "expr" is used, must be a VAR_FUNC or VAR_PARTIAL. |
| 7 | 6392 * "flags" can be "g" to do a global substitute. |
| 6393 * Returns an allocated string, NULL for error. | |
| 6394 */ | |
| 6395 char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6396 do_string_sub( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6397 char_u *str, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6398 char_u *pat, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6399 char_u *sub, |
|
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9587
diff
changeset
|
6400 typval_T *expr, |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6401 char_u *flags) |
| 7 | 6402 { |
| 6403 int sublen; | |
| 6404 regmatch_T regmatch; | |
| 6405 int i; | |
| 6406 int do_all; | |
| 6407 char_u *tail; | |
| 6332 | 6408 char_u *end; |
| 7 | 6409 garray_T ga; |
| 6410 char_u *ret; | |
| 6411 char_u *save_cpo; | |
| 5623 | 6412 char_u *zero_width = NULL; |
| 7 | 6413 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6414 // Make 'cpoptions' empty, so that the 'l' flag doesn't work here |
| 7 | 6415 save_cpo = p_cpo; |
| 1672 | 6416 p_cpo = empty_option; |
| 7 | 6417 |
| 6418 ga_init2(&ga, 1, 200); | |
| 6419 | |
| 6420 do_all = (flags[0] == 'g'); | |
| 6421 | |
| 6422 regmatch.rm_ic = p_ic; | |
| 6423 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); | |
| 6424 if (regmatch.regprog != NULL) | |
| 6425 { | |
| 6426 tail = str; | |
| 6332 | 6427 end = str + STRLEN(str); |
| 7 | 6428 while (vim_regexec_nl(®match, str, (colnr_T)(tail - str))) |
| 6429 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6430 // Skip empty match except for first match. |
| 5623 | 6431 if (regmatch.startp[0] == regmatch.endp[0]) |
| 6432 { | |
| 6433 if (zero_width == regmatch.startp[0]) | |
| 6434 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6435 // avoid getting stuck on a match with an empty string |
|
18251
c8a53c0daeed
patch 8.1.2120: some MB_ macros are more complicated than necessary
Bram Moolenaar <Bram@vim.org>
parents:
18225
diff
changeset
|
6436 i = mb_ptr2len(tail); |
| 5964 | 6437 mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail, |
| 6438 (size_t)i); | |
| 6439 ga.ga_len += i; | |
| 6440 tail += i; | |
| 5623 | 6441 continue; |
| 6442 } | |
| 6443 zero_width = regmatch.startp[0]; | |
| 6444 } | |
| 6445 | |
| 7 | 6446 /* |
| 6447 * Get some space for a temporary buffer to do the substitution | |
| 6448 * into. It will contain: | |
| 6449 * - The text up to where the match is. | |
| 6450 * - The substituted text. | |
| 6451 * - The text after the match. | |
| 6452 */ | |
|
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9587
diff
changeset
|
6453 sublen = vim_regsub(®match, sub, expr, tail, FALSE, TRUE, FALSE); |
| 6332 | 6454 if (ga_grow(&ga, (int)((end - tail) + sublen - |
| 7 | 6455 (regmatch.endp[0] - regmatch.startp[0]))) == FAIL) |
| 6456 { | |
| 6457 ga_clear(&ga); | |
| 6458 break; | |
| 6459 } | |
| 6460 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6461 // copy the text up to where the match is |
| 7 | 6462 i = (int)(regmatch.startp[0] - tail); |
| 6463 mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail, (size_t)i); | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6464 // add the substituted text |
|
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9587
diff
changeset
|
6465 (void)vim_regsub(®match, sub, expr, (char_u *)ga.ga_data |
| 7 | 6466 + ga.ga_len + i, TRUE, TRUE, FALSE); |
| 6467 ga.ga_len += i + sublen - 1; | |
| 5388 | 6468 tail = regmatch.endp[0]; |
| 6469 if (*tail == NUL) | |
| 6470 break; | |
| 7 | 6471 if (!do_all) |
| 6472 break; | |
| 6473 } | |
| 6474 | |
| 6475 if (ga.ga_data != NULL) | |
| 6476 STRCPY((char *)ga.ga_data + ga.ga_len, tail); | |
| 6477 | |
|
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4778
diff
changeset
|
6478 vim_regfree(regmatch.regprog); |
| 7 | 6479 } |
| 6480 | |
| 6481 ret = vim_strsave(ga.ga_data == NULL ? str : (char_u *)ga.ga_data); | |
| 6482 ga_clear(&ga); | |
| 1672 | 6483 if (p_cpo == empty_option) |
| 6484 p_cpo = save_cpo; | |
| 6485 else | |
|
23493
f8382c4e6551
patch 8.2.2289: Vim9: 'cpo' can become empty
Bram Moolenaar <Bram@vim.org>
parents:
23450
diff
changeset
|
6486 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6487 // Darn, evaluating {sub} expression or {expr} changed the value. |
|
23493
f8382c4e6551
patch 8.2.2289: Vim9: 'cpo' can become empty
Bram Moolenaar <Bram@vim.org>
parents:
23450
diff
changeset
|
6488 // If it's still empty it was changed and restored, need to restore in |
|
f8382c4e6551
patch 8.2.2289: Vim9: 'cpo' can become empty
Bram Moolenaar <Bram@vim.org>
parents:
23450
diff
changeset
|
6489 // the complicated way. |
|
f8382c4e6551
patch 8.2.2289: Vim9: 'cpo' can become empty
Bram Moolenaar <Bram@vim.org>
parents:
23450
diff
changeset
|
6490 if (*p_cpo == NUL) |
|
f8382c4e6551
patch 8.2.2289: Vim9: 'cpo' can become empty
Bram Moolenaar <Bram@vim.org>
parents:
23450
diff
changeset
|
6491 set_option_value((char_u *)"cpo", 0L, save_cpo, 0); |
| 1672 | 6492 free_string_option(save_cpo); |
|
23493
f8382c4e6551
patch 8.2.2289: Vim9: 'cpo' can become empty
Bram Moolenaar <Bram@vim.org>
parents:
23450
diff
changeset
|
6493 } |
| 7 | 6494 |
| 6495 return ret; | |
| 6496 } |