Mercurial > vim
annotate src/eval.c @ 20156:49694eceaa55 v8.2.0633
patch 8.2.0633: crash when using null partial in filter()
Commit: https://github.com/vim/vim/commit/9d8d0b5c644ea53364d04403740b3f23e57c1497
Author: Bram Moolenaar <Bram@vim.org>
Date: Fri Apr 24 22:47:31 2020 +0200
patch 8.2.0633: crash when using null partial in filter()
Problem: Crash when using null partial in filter().
Solution: Fix crash. Add more tests. (Yegappan Lakshmanan, closes https://github.com/vim/vim/issues/5976)
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Fri, 24 Apr 2020 23:00:04 +0200 |
| parents | fe8d0a4344df |
| children | 94f05de75e9f |
| 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 |
| 117 | 23 static char *e_dictrange = N_("E719: Cannot use [:] with a Dictionary"); |
|
4936
ae05437a744a
updated for version 7.3.1213
Bram Moolenaar <bram@vim.org>
parents:
4918
diff
changeset
|
24 #ifdef FEAT_FLOAT |
|
4870
b7bb20390111
updated for version 7.3.1181
Bram Moolenaar <bram@vim.org>
parents:
4859
diff
changeset
|
25 static char *e_float_as_string = N_("E806: using Float as a String"); |
|
4936
ae05437a744a
updated for version 7.3.1213
Bram Moolenaar <bram@vim.org>
parents:
4918
diff
changeset
|
26 #endif |
| 1624 | 27 |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
28 #define NAMESPACE_CHAR (char_u *)"abglstvw" |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
29 |
| 142 | 30 /* |
| 364 | 31 * When recursively copying lists and dicts we need to remember which ones we |
| 32 * have done to avoid endless recursiveness. This unique ID is used for that. | |
| 1891 | 33 * The last bit is used for previous_funccal, ignored when comparing. |
| 364 | 34 */ |
| 35 static int current_copyID = 0; | |
| 5973 | 36 |
| 7 | 37 /* |
| 76 | 38 * Info used by a ":for" loop. |
| 39 */ | |
| 137 | 40 typedef struct |
| 76 | 41 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
42 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
|
43 int fi_varcount; // nr of variables in the list |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
44 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
|
45 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
|
46 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
|
47 blob_T *fi_blob; // blob being used |
| 137 | 48 } forinfo_T; |
| 76 | 49 |
|
7720
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
50 static int tv_op(typval_T *tv1, typval_T *tv2, char_u *op); |
|
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
51 static int eval2(char_u **arg, typval_T *rettv, int evaluate); |
|
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
52 static int eval3(char_u **arg, typval_T *rettv, int evaluate); |
|
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
53 static int eval4(char_u **arg, typval_T *rettv, int evaluate); |
|
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
54 static int eval5(char_u **arg, typval_T *rettv, int evaluate); |
|
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
55 static int eval6(char_u **arg, typval_T *rettv, int evaluate, int want_string); |
|
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
56 static int eval7(char_u **arg, typval_T *rettv, int evaluate, int want_string); |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
57 static int eval7_leader(typval_T *rettv, 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
|
58 |
|
7c52f11e6df3
commit https://github.com/vim/vim/commit/48e697e4b6b6b490c58ec9393da9b2d2ea47c6d8
Christian Brabandt <cb@256bit.org>
parents:
7718
diff
changeset
|
59 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
|
60 static char_u *make_expanded_name(char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end); |
|
15780
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
61 static int tv_check_lock(typval_T *tv, char_u *name, int use_gettext); |
|
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
62 |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
63 /* |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
64 * Return "n1" divided by "n2", taking care of dividing by zero. |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
65 */ |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
66 varnumber_T |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
67 num_divide(varnumber_T n1, varnumber_T n2) |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
68 { |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
69 varnumber_T result; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
70 |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
71 if (n2 == 0) // give an error message? |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
72 { |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
73 if (n1 == 0) |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
74 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
|
75 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
|
76 result = -VARNUM_MAX; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
77 else |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
78 result = VARNUM_MAX; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
79 } |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
80 else |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
81 result = n1 / n2; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
82 |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
83 return result; |
|
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 |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
86 /* |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
87 * Return "n1" modulus "n2", taking care of dividing by zero. |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
88 */ |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
89 varnumber_T |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
90 num_modulus(varnumber_T n1, varnumber_T n2) |
|
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 // Give an error when n2 is 0? |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
93 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
|
94 } |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
95 |
|
10567
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
96 #if defined(EBCDIC) || defined(PROTO) |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
97 /* |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
98 * 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
|
99 */ |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
100 static int |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
101 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
|
102 { |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
103 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
|
104 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
|
105 |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
106 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
|
107 } |
|
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 /* |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
110 * 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
|
111 * 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
|
112 * 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
|
113 */ |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
114 static void |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
115 sortFunctions(void) |
|
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 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
|
118 |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
119 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
|
120 } |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
121 #endif |
|
82c2c450dad0
patch 8.0.0173: build fails with EBCDIC defined
Christian Brabandt <cb@256bit.org>
parents:
10540
diff
changeset
|
122 |
| 137 | 123 /* |
| 124 * Initialize the global and v: variables. | |
| 125 */ | |
| 126 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
127 eval_init(void) |
| 137 | 128 { |
|
17885
5e2d8840da11
patch 8.1.1939: code for handling v: variables in generic eval file
Bram Moolenaar <Bram@vim.org>
parents:
17873
diff
changeset
|
129 evalvars_init(); |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
130 func_init(); |
| 137 | 131 |
|
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
132 #ifdef EBCDIC |
|
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
133 /* |
| 3178 | 134 * 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
|
135 */ |
|
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
136 sortFunctions(); |
|
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
137 #endif |
| 137 | 138 } |
| 139 | |
| 357 | 140 #if defined(EXITFREE) || defined(PROTO) |
| 141 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
142 eval_clear(void) |
| 357 | 143 { |
|
17885
5e2d8840da11
patch 8.1.1939: code for handling v: variables in generic eval file
Bram Moolenaar <Bram@vim.org>
parents:
17873
diff
changeset
|
144 evalvars_clear(); |
|
19108
44c6498535c9
patch 8.2.0114: info about sourced scripts is scattered
Bram Moolenaar <Bram@vim.org>
parents:
19102
diff
changeset
|
145 free_scriptnames(); // must come after evalvars_clear(). |
| 2849 | 146 free_locales(); |
| 357 | 147 |
|
17922
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
148 // 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
|
149 free_autoload_scriptnames(); |
| 855 | 150 |
|
16967
586d625e21b4
patch 8.1.1484: some tests are slow
Bram Moolenaar <Bram@vim.org>
parents:
16872
diff
changeset
|
151 // unreferenced lists and dicts |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
152 (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
|
153 |
|
8c794a694d66
patch 8.1.1485: double free when garbage_collect() is used in autocommand
Bram Moolenaar <Bram@vim.org>
parents:
16967
diff
changeset
|
154 // 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
|
155 free_all_functions(); |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
156 } |
|
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
157 #endif |
| 137 | 158 |
| 7 | 159 /* |
| 160 * Top level evaluation function, returning a boolean. | |
| 161 * Sets "error" to TRUE if there was an error. | |
| 162 * Return TRUE or FALSE. | |
| 163 */ | |
| 164 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
165 eval_to_bool( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
166 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
167 int *error, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
168 char_u **nextcmd, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
169 int skip) // only parse, don't execute |
| 7 | 170 { |
| 137 | 171 typval_T tv; |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
172 varnumber_T retval = FALSE; |
| 7 | 173 |
| 174 if (skip) | |
| 175 ++emsg_skip; | |
| 71 | 176 if (eval0(arg, &tv, nextcmd, !skip) == FAIL) |
| 7 | 177 *error = TRUE; |
| 178 else | |
| 179 { | |
| 180 *error = FALSE; | |
| 181 if (!skip) | |
| 182 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
183 retval = (tv_get_number_chk(&tv, error) != 0); |
| 71 | 184 clear_tv(&tv); |
| 7 | 185 } |
| 186 } | |
| 187 if (skip) | |
| 188 --emsg_skip; | |
| 189 | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
190 return (int)retval; |
| 7 | 191 } |
| 192 | |
|
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
|
193 /* |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
194 * 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
|
195 */ |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
196 static int |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
197 eval1_emsg(char_u **arg, typval_T *rettv, int evaluate) |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
198 { |
|
15482
18dd04f7c4a1
patch 8.1.0749: error message contains garbage
Bram Moolenaar <Bram@vim.org>
parents:
15478
diff
changeset
|
199 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
|
200 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
|
201 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
|
202 int called_emsg_before = called_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
|
203 |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
204 ret = eval1(arg, rettv, evaluate); |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
205 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
|
206 { |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
207 // 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
|
208 // 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
|
209 // 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
|
210 // 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
|
211 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
|
212 && called_emsg == called_emsg_before) |
|
15482
18dd04f7c4a1
patch 8.1.0749: error message contains garbage
Bram Moolenaar <Bram@vim.org>
parents:
15478
diff
changeset
|
213 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
|
214 } |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
215 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
|
216 } |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
217 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
218 /* |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
219 * 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
|
220 * 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
|
221 * 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
|
222 */ |
|
16231
0761a4c111a7
patch 8.1.1120: cannot easily get directory entry matches
Bram Moolenaar <Bram@vim.org>
parents:
16223
diff
changeset
|
223 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
|
224 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
|
225 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
226 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
|
227 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
|
228 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
|
229 |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
230 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
|
231 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
232 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
|
233 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
|
234 return FAIL; |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
235 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
|
236 funcexe.evaluate = TRUE; |
|
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
237 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
|
238 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
|
239 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
240 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
|
241 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
242 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
|
243 |
|
20156
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
244 if (partial == NULL) |
|
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
245 return FAIL; |
|
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
246 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
247 if (partial->pt_func != NULL && partial->pt_func->uf_dfunc_idx >= 0) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
248 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
249 if (call_def_function(partial->pt_func, argc, argv, rettv) == FAIL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
250 return FAIL; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
251 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
252 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
253 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
254 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
|
255 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
|
256 return FAIL; |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
257 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
|
258 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
|
259 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
|
260 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
|
261 return FAIL; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
262 } |
|
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
|
263 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
264 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
|
265 { |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
266 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
|
267 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
|
268 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
|
269 s = skipwhite(s); |
|
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
|
270 if (eval1_emsg(&s, rettv, TRUE) == 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
|
271 return FAIL; |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
272 if (*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
|
273 { |
|
14331
f8280e1bfc84
patch 8.1.0181: memory leak with trailing characters in skip expression
Christian Brabandt <cb@256bit.org>
parents:
14071
diff
changeset
|
274 clear_tv(rettv); |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
275 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
|
276 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
|
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 } |
|
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 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
|
280 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
281 |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
282 /* |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
283 * 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
|
284 * 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
|
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 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
|
287 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
|
288 { |
|
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 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
|
290 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
|
291 |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
292 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
|
293 { |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
294 *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
|
295 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
|
296 } |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
297 res = (tv_get_number_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
|
298 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
|
299 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
|
300 } |
|
7749260f261c
patch 8.0.1239: cannot use a lambda for the skip argument to searchpair()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
301 |
| 7 | 302 /* |
| 303 * Top level evaluation function, returning a string. If "skip" is TRUE, | |
| 304 * only parsing to "nextcmd" is done, without reporting errors. Return | |
| 305 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE. | |
| 306 */ | |
| 307 char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
308 eval_to_string_skip( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
309 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
310 char_u **nextcmd, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
311 int skip) // only parse, don't execute |
| 7 | 312 { |
| 137 | 313 typval_T tv; |
| 7 | 314 char_u *retval; |
| 315 | |
| 316 if (skip) | |
| 317 ++emsg_skip; | |
| 71 | 318 if (eval0(arg, &tv, nextcmd, !skip) == FAIL || skip) |
| 7 | 319 retval = NULL; |
| 320 else | |
| 321 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
322 retval = vim_strsave(tv_get_string(&tv)); |
| 71 | 323 clear_tv(&tv); |
| 7 | 324 } |
| 325 if (skip) | |
| 326 --emsg_skip; | |
| 327 | |
| 328 return retval; | |
| 329 } | |
| 330 | |
| 331 /* | |
| 9 | 332 * Skip over an expression at "*pp". |
| 333 * Return FAIL for an error, OK otherwise. | |
| 334 */ | |
| 335 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
336 skip_expr(char_u **pp) |
| 9 | 337 { |
| 137 | 338 typval_T rettv; |
| 9 | 339 |
| 340 *pp = skipwhite(*pp); | |
| 71 | 341 return eval1(pp, &rettv, FALSE); |
| 9 | 342 } |
| 343 | |
| 344 /* | |
| 7 | 345 * Top level evaluation function, returning a string. |
| 1713 | 346 * When "convert" is TRUE convert a List into a sequence of lines and convert |
| 347 * a Float to a String. | |
| 7 | 348 * Return pointer to allocated memory, or NULL for failure. |
| 349 */ | |
| 350 char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
351 eval_to_string( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
352 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
353 char_u **nextcmd, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
354 int convert) |
| 7 | 355 { |
| 137 | 356 typval_T tv; |
| 7 | 357 char_u *retval; |
| 714 | 358 garray_T ga; |
| 1851 | 359 #ifdef FEAT_FLOAT |
| 1713 | 360 char_u numbuf[NUMBUFLEN]; |
| 1851 | 361 #endif |
| 7 | 362 |
| 71 | 363 if (eval0(arg, &tv, nextcmd, TRUE) == FAIL) |
| 7 | 364 retval = NULL; |
| 365 else | |
| 366 { | |
| 1713 | 367 if (convert && tv.v_type == VAR_LIST) |
| 714 | 368 { |
| 369 ga_init2(&ga, (int)sizeof(char), 80); | |
| 1690 | 370 if (tv.vval.v_list != NULL) |
| 3000 | 371 { |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
372 list_join(&ga, tv.vval.v_list, (char_u *)"\n", TRUE, FALSE, 0); |
| 3000 | 373 if (tv.vval.v_list->lv_len > 0) |
| 374 ga_append(&ga, NL); | |
| 375 } | |
| 714 | 376 ga_append(&ga, NUL); |
| 377 retval = (char_u *)ga.ga_data; | |
| 378 } | |
| 1713 | 379 #ifdef FEAT_FLOAT |
| 380 else if (convert && tv.v_type == VAR_FLOAT) | |
| 381 { | |
| 382 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv.vval.v_float); | |
| 383 retval = vim_strsave(numbuf); | |
| 384 } | |
| 385 #endif | |
| 714 | 386 else |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
387 retval = vim_strsave(tv_get_string(&tv)); |
| 71 | 388 clear_tv(&tv); |
| 7 | 389 } |
| 390 | |
| 391 return retval; | |
| 392 } | |
| 393 | |
| 394 /* | |
| 634 | 395 * Call eval_to_string() without using current local variables and using |
| 396 * textlock. When "use_sandbox" is TRUE use the sandbox. | |
| 7 | 397 */ |
| 398 char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
399 eval_to_string_safe( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
400 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
401 char_u **nextcmd, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
402 int use_sandbox) |
| 7 | 403 { |
| 404 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
|
405 funccal_entry_T funccal_entry; |
|
162d79d273e6
patch 8.1.0475: memory not freed on exit when quit in autocmd
Bram Moolenaar <Bram@vim.org>
parents:
14897
diff
changeset
|
406 |
|
162d79d273e6
patch 8.1.0475: memory not freed on exit when quit in autocmd
Bram Moolenaar <Bram@vim.org>
parents:
14897
diff
changeset
|
407 save_funccal(&funccal_entry); |
| 634 | 408 if (use_sandbox) |
| 409 ++sandbox; | |
| 410 ++textlock; | |
| 714 | 411 retval = eval_to_string(arg, nextcmd, FALSE); |
| 634 | 412 if (use_sandbox) |
| 413 --sandbox; | |
| 414 --textlock; | |
|
14927
162d79d273e6
patch 8.1.0475: memory not freed on exit when quit in autocmd
Bram Moolenaar <Bram@vim.org>
parents:
14897
diff
changeset
|
415 restore_funccal(); |
| 7 | 416 return retval; |
| 417 } | |
| 418 | |
| 419 /* | |
| 420 * Top level evaluation function, returning a number. | |
| 421 * Evaluates "expr" silently. | |
| 422 * Returns -1 for an error. | |
| 423 */ | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
424 varnumber_T |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
425 eval_to_number(char_u *expr) |
| 7 | 426 { |
| 137 | 427 typval_T rettv; |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
428 varnumber_T retval; |
| 97 | 429 char_u *p = skipwhite(expr); |
| 7 | 430 |
| 431 ++emsg_off; | |
| 432 | |
| 71 | 433 if (eval1(&p, &rettv, TRUE) == FAIL) |
| 7 | 434 retval = -1; |
| 435 else | |
| 436 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
437 retval = tv_get_number_chk(&rettv, NULL); |
| 71 | 438 clear_tv(&rettv); |
| 7 | 439 } |
| 440 --emsg_off; | |
| 441 | |
| 442 return retval; | |
| 443 } | |
| 444 | |
| 446 | 445 /* |
| 625 | 446 * Top level evaluation function. |
| 447 * Returns an allocated typval_T with the result. | |
| 448 * Returns NULL when there is an error. | |
| 446 | 449 */ |
| 450 typval_T * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
451 eval_expr(char_u *arg, char_u **nextcmd) |
| 446 | 452 { |
| 453 typval_T *tv; | |
| 454 | |
|
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
|
455 tv = ALLOC_ONE(typval_T); |
| 625 | 456 if (tv != NULL && eval0(arg, tv, nextcmd, TRUE) == FAIL) |
|
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
13037
diff
changeset
|
457 VIM_CLEAR(tv); |
| 446 | 458 |
| 459 return tv; | |
| 460 } | |
| 461 | |
| 7 | 462 /* |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10926
diff
changeset
|
463 * 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
|
464 * 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
|
465 * should have type VAR_UNKNOWN. |
| 408 | 466 * Returns OK or FAIL. |
| 467 */ | |
| 3078 | 468 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
469 call_vim_function( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
470 char_u *func, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
471 int argc, |
|
14071
c1fcfafa8d1a
patch 8.1.0053: first argument of 'completefunc' has inconsistent type
Christian Brabandt <cb@256bit.org>
parents:
13923
diff
changeset
|
472 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
|
473 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
|
474 { |
| 408 | 475 int ret; |
|
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
476 funcexe_T funcexe; |
| 7 | 477 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
478 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
|
479 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
|
480 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
|
481 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
|
482 funcexe.evaluate = TRUE; |
|
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17536
diff
changeset
|
483 ret = call_func(func, -1, rettv, argc, argv, &funcexe); |
| 408 | 484 if (ret == FAIL) |
| 485 clear_tv(rettv); | |
| 486 | |
| 487 return ret; | |
| 488 } | |
| 489 | |
| 4133 | 490 /* |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10926
diff
changeset
|
491 * Call Vim script function "func" and return the result as a number. |
| 4133 | 492 * 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
|
493 * 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
|
494 * have type VAR_UNKNOWN. |
| 4133 | 495 */ |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
496 varnumber_T |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
497 call_func_retnr( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
498 char_u *func, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
499 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
|
500 typval_T *argv) |
| 4133 | 501 { |
| 502 typval_T rettv; | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
503 varnumber_T retval; |
| 4133 | 504 |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
505 if (call_vim_function(func, argc, argv, &rettv) == FAIL) |
| 4133 | 506 return -1; |
| 507 | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
508 retval = tv_get_number_chk(&rettv, NULL); |
| 4133 | 509 clear_tv(&rettv); |
| 510 return retval; | |
| 511 } | |
| 512 | |
| 408 | 513 /* |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10926
diff
changeset
|
514 * Call Vim script function "func" and return the result as a string. |
| 453 | 515 * Returns NULL 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
|
516 * 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
|
517 * have type VAR_UNKNOWN. |
| 408 | 518 */ |
| 519 void * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
520 call_func_retstr( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
521 char_u *func, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
522 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
|
523 typval_T *argv) |
| 408 | 524 { |
| 525 typval_T rettv; | |
| 453 | 526 char_u *retval; |
| 408 | 527 |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
528 if (call_vim_function(func, argc, argv, &rettv) == FAIL) |
| 408 | 529 return NULL; |
| 530 | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
531 retval = vim_strsave(tv_get_string(&rettv)); |
| 408 | 532 clear_tv(&rettv); |
| 7 | 533 return retval; |
| 534 } | |
| 1322 | 535 |
| 453 | 536 /* |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10926
diff
changeset
|
537 * Call Vim script function "func" and return the result as a List. |
|
14071
c1fcfafa8d1a
patch 8.1.0053: first argument of 'completefunc' has inconsistent type
Christian Brabandt <cb@256bit.org>
parents:
13923
diff
changeset
|
538 * 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
|
539 * have type VAR_UNKNOWN. |
| 1690 | 540 * Returns NULL when there is something wrong. |
| 408 | 541 */ |
| 542 void * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
543 call_func_retlist( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
544 char_u *func, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
545 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
|
546 typval_T *argv) |
| 408 | 547 { |
| 548 typval_T rettv; | |
| 549 | |
|
14439
e4c553e9132b
patch 8.1.0233: "safe" argument of call_vim_function() is always FALSE
Christian Brabandt <cb@256bit.org>
parents:
14393
diff
changeset
|
550 if (call_vim_function(func, argc, argv, &rettv) == FAIL) |
| 408 | 551 return NULL; |
| 552 | |
| 553 if (rettv.v_type != VAR_LIST) | |
| 554 { | |
| 555 clear_tv(&rettv); | |
| 556 return NULL; | |
| 557 } | |
| 558 | |
| 559 return rettv.vval.v_list; | |
| 560 } | |
| 1322 | 561 |
| 7 | 562 #ifdef FEAT_FOLDING |
| 563 /* | |
| 564 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding | |
| 565 * it in "*cp". Doesn't give error messages. | |
| 566 */ | |
| 567 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
568 eval_foldexpr(char_u *arg, int *cp) |
| 7 | 569 { |
| 137 | 570 typval_T tv; |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
571 varnumber_T retval; |
| 7 | 572 char_u *s; |
| 681 | 573 int use_sandbox = was_set_insecurely((char_u *)"foldexpr", |
| 574 OPT_LOCAL); | |
| 7 | 575 |
| 576 ++emsg_off; | |
| 634 | 577 if (use_sandbox) |
| 578 ++sandbox; | |
| 579 ++textlock; | |
| 7 | 580 *cp = NUL; |
| 71 | 581 if (eval0(arg, &tv, NULL, TRUE) == FAIL) |
| 7 | 582 retval = 0; |
| 583 else | |
| 584 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
585 // If the result is a number, just return the number. |
| 71 | 586 if (tv.v_type == VAR_NUMBER) |
| 587 retval = tv.vval.v_number; | |
| 156 | 588 else if (tv.v_type != VAR_STRING || tv.vval.v_string == NULL) |
| 7 | 589 retval = 0; |
| 590 else | |
| 591 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
592 // 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
|
593 // the number. |
| 71 | 594 s = tv.vval.v_string; |
| 7 | 595 if (!VIM_ISDIGIT(*s) && *s != '-') |
| 596 *cp = *s++; | |
| 597 retval = atol((char *)s); | |
| 598 } | |
| 71 | 599 clear_tv(&tv); |
| 7 | 600 } |
| 601 --emsg_off; | |
| 634 | 602 if (use_sandbox) |
| 603 --sandbox; | |
| 604 --textlock; | |
| 7 | 605 |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
606 return (int)retval; |
| 7 | 607 } |
| 608 #endif | |
| 609 | |
| 610 /* | |
| 110 | 611 * Get an lval: variable, Dict item or List item that can be assigned a value |
| 612 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]", | |
| 613 * "name.key", "name.key[expr]" etc. | |
| 614 * Indexing only works if "name" is an existing List or Dictionary. | |
| 615 * "name" points to the start of the name. | |
| 616 * If "rettv" is not NULL it points to the value to be assigned. | |
| 617 * "unlet" is TRUE for ":unlet": slightly different behavior when something is | |
| 618 * wrong; must end in space or cmd separator. | |
| 619 * | |
| 5604 | 620 * flags: |
| 621 * 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
|
622 * GLV_READ_ONLY: will not change the variable |
| 5604 | 623 * GLV_NO_AUTOLOAD: do not use script autoloading |
| 624 * | |
| 110 | 625 * Returns a pointer to just after the name, including indexes. |
| 124 | 626 * When an evaluation error occurs "lp->ll_name" is NULL; |
| 110 | 627 * Returns NULL for a parsing error. Still need to free items in "lp"! |
| 71 | 628 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
629 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
630 get_lval( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
631 char_u *name, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
632 typval_T *rettv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
633 lval_T *lp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
634 int unlet, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
635 int skip, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
636 int flags, // GLV_ values |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
637 int fne_flags) // flags for find_name_end() |
| 110 | 638 { |
| 639 char_u *p; | |
| 640 char_u *expr_start, *expr_end; | |
| 641 int cc; | |
| 137 | 642 dictitem_T *v; |
| 643 typval_T var1; | |
| 644 typval_T var2; | |
| 110 | 645 int empty1 = FALSE; |
| 137 | 646 listitem_T *ni; |
| 100 | 647 char_u *key = NULL; |
| 648 int len; | |
| 137 | 649 hashtab_T *ht; |
| 5604 | 650 int quiet = flags & GLV_QUIET; |
| 71 | 651 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
652 // Clear everything in "lp". |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
653 CLEAR_POINTER(lp); |
| 110 | 654 |
| 655 if (skip) | |
| 656 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
657 // When skipping just find the end of the name. |
| 110 | 658 lp->ll_name = name; |
| 271 | 659 return find_name_end(name, NULL, NULL, FNE_INCL_BR | fne_flags); |
| 110 | 660 } |
| 661 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
662 // Find the end of the name. |
| 271 | 663 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
|
664 lp->ll_name_end = p; |
| 110 | 665 if (expr_start != NULL) |
| 666 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
667 // 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
|
668 if (unlet && !VIM_ISWHITE(*p) && !ends_excmd(*p) |
| 110 | 669 && *p != '[' && *p != '.') |
| 670 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
671 emsg(_(e_trailing)); |
| 110 | 672 return NULL; |
| 673 } | |
| 674 | |
| 675 lp->ll_exp_name = make_expanded_name(name, expr_start, expr_end, p); | |
| 676 if (lp->ll_exp_name == NULL) | |
| 677 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
678 // 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
|
679 // 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
|
680 // aborting error, an interrupt, or an exception. |
| 110 | 681 if (!aborting() && !quiet) |
| 682 { | |
| 121 | 683 emsg_severe = TRUE; |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
684 semsg(_(e_invarg2), name); |
| 110 | 685 return NULL; |
| 686 } | |
| 687 } | |
| 688 lp->ll_name = lp->ll_exp_name; | |
| 689 } | |
| 690 else | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
691 { |
| 110 | 692 lp->ll_name = name; |
| 693 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
694 if (current_sctx.sc_version == SCRIPT_VERSION_VIM9 && *p == ':') |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
695 { |
|
19191
133ef7ba4e4e
patch 8.2.0154: reallocating the list of scripts is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
19181
diff
changeset
|
696 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid); |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
697 char_u *tp = skipwhite(p + 1); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
698 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
699 // parse the type after the name |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
700 lp->ll_type = parse_type(&tp, &si->sn_type_list); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
701 lp->ll_name_end = tp; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
702 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
703 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
704 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
705 // Without [idx] or .key we are done. |
| 110 | 706 if ((*p != '[' && *p != '.') || lp->ll_name == NULL) |
| 707 return p; | |
| 708 | |
| 709 cc = *p; | |
| 710 *p = NUL; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
711 // Only pass &ht when we would write to the variable, it prevents autoload |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
712 // as well. |
|
13002
f7b2ecaeb79c
patch 8.0.1377: cannot call a dict function in autoloaded dict
Christian Brabandt <cb@256bit.org>
parents:
12728
diff
changeset
|
713 v = find_var(lp->ll_name, (flags & GLV_READ_ONLY) ? NULL : &ht, |
|
f7b2ecaeb79c
patch 8.0.1377: cannot call a dict function in autoloaded dict
Christian Brabandt <cb@256bit.org>
parents:
12728
diff
changeset
|
714 flags & GLV_NO_AUTOLOAD); |
| 110 | 715 if (v == NULL && !quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
716 semsg(_(e_undefvar), lp->ll_name); |
| 110 | 717 *p = cc; |
| 71 | 718 if (v == NULL) |
| 719 return NULL; | |
| 720 | |
| 110 | 721 /* |
| 722 * Loop until no more [idx] or .key is following. | |
| 723 */ | |
| 137 | 724 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
|
725 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
|
726 var2.v_type = VAR_UNKNOWN; |
| 110 | 727 while (*p == '[' || (*p == '.' && lp->ll_tv->v_type == VAR_DICT)) |
| 728 { | |
| 729 if (!(lp->ll_tv->v_type == VAR_LIST && lp->ll_tv->vval.v_list != NULL) | |
| 730 && !(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
|
731 && lp->ll_tv->vval.v_dict != NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
732 && !(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
|
733 && lp->ll_tv->vval.v_blob != NULL)) |
| 110 | 734 { |
| 735 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
736 emsg(_("E689: Can only index a List, Dictionary or Blob")); |
| 110 | 737 return NULL; |
| 738 } | |
| 739 if (lp->ll_range) | |
| 740 { | |
| 741 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
742 emsg(_("E708: [:] must come last")); |
| 110 | 743 return NULL; |
| 71 | 744 } |
| 88 | 745 |
| 100 | 746 len = -1; |
| 747 if (*p == '.') | |
| 748 { | |
| 749 key = p + 1; | |
| 750 for (len = 0; ASCII_ISALNUM(key[len]) || key[len] == '_'; ++len) | |
| 751 ; | |
| 752 if (len == 0) | |
| 753 { | |
| 110 | 754 if (!quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
755 emsg(_(e_emptykey)); |
| 110 | 756 return NULL; |
| 88 | 757 } |
| 100 | 758 p = key + len; |
| 759 } | |
| 760 else | |
| 761 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
762 // Get the index [expr] or the first index [expr: ]. |
| 88 | 763 p = skipwhite(p + 1); |
| 100 | 764 if (*p == ':') |
| 765 empty1 = TRUE; | |
| 88 | 766 else |
| 767 { | |
| 100 | 768 empty1 = FALSE; |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
769 if (eval1(&p, &var1, TRUE) == FAIL) // recursive! |
| 110 | 770 return NULL; |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
771 if (tv_get_string_chk(&var1) == NULL) |
| 323 | 772 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
773 // not a number or string |
| 323 | 774 clear_tv(&var1); |
| 775 return NULL; | |
| 776 } | |
| 100 | 777 } |
| 778 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
779 // Optionally get the second index [ :expr]. |
| 100 | 780 if (*p == ':') |
| 781 { | |
| 110 | 782 if (lp->ll_tv->v_type == VAR_DICT) |
| 783 { | |
| 784 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
785 emsg(_(e_dictrange)); |
|
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
|
786 clear_tv(&var1); |
| 110 | 787 return NULL; |
| 788 } | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
789 if (rettv != NULL |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
790 && !(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
|
791 && rettv->vval.v_list != NULL) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
792 && !(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
|
793 && rettv->vval.v_blob != NULL)) |
| 110 | 794 { |
| 795 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
796 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
|
797 clear_tv(&var1); |
| 110 | 798 return NULL; |
| 88 | 799 } |
| 100 | 800 p = skipwhite(p + 1); |
| 801 if (*p == ']') | |
| 110 | 802 lp->ll_empty2 = TRUE; |
| 100 | 803 else |
| 804 { | |
| 110 | 805 lp->ll_empty2 = FALSE; |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
806 if (eval1(&p, &var2, TRUE) == FAIL) // recursive! |
| 100 | 807 { |
|
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
|
808 clear_tv(&var1); |
| 110 | 809 return NULL; |
| 100 | 810 } |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
811 if (tv_get_string_chk(&var2) == NULL) |
| 323 | 812 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
813 // 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
|
814 clear_tv(&var1); |
| 323 | 815 clear_tv(&var2); |
| 816 return NULL; | |
| 817 } | |
| 100 | 818 } |
| 110 | 819 lp->ll_range = TRUE; |
| 100 | 820 } |
| 821 else | |
| 110 | 822 lp->ll_range = FALSE; |
| 100 | 823 |
| 824 if (*p != ']') | |
| 825 { | |
| 110 | 826 if (!quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
827 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
|
828 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
|
829 clear_tv(&var2); |
| 110 | 830 return NULL; |
| 100 | 831 } |
| 832 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
833 // Skip to past ']'. |
| 100 | 834 ++p; |
| 835 } | |
| 836 | |
| 110 | 837 if (lp->ll_tv->v_type == VAR_DICT) |
| 100 | 838 { |
| 839 if (len == -1) | |
| 840 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
841 // "[key]": get key from "var1" |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
842 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
|
843 if (key == NULL) |
|
9fa567d13551
commit https://github.com/vim/vim/commit/0921ecff1c5a74541bad6c073e8ade32247403d8
Christian Brabandt <cb@256bit.org>
parents:
8831
diff
changeset
|
844 { |
| 100 | 845 clear_tv(&var1); |
| 110 | 846 return NULL; |
| 847 } | |
| 848 } | |
| 117 | 849 lp->ll_list = NULL; |
| 850 lp->ll_dict = lp->ll_tv->vval.v_dict; | |
| 121 | 851 lp->ll_di = dict_find(lp->ll_dict, key, len); |
| 2739 | 852 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
853 // 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
|
854 // 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
|
855 // g: dictionary). Disallow overwriting a builtin function. |
| 3687 | 856 if (rettv != NULL && lp->ll_dict->dv_scope != 0) |
| 857 { | |
| 858 int prevval; | |
| 859 int wrong; | |
| 860 | |
| 861 if (len != -1) | |
| 862 { | |
| 863 prevval = key[len]; | |
| 864 key[len] = NUL; | |
| 865 } | |
|
4819
8c4324e6f477
updated for version 7.3.1156
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
866 else |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
867 prevval = 0; // avoid compiler warning |
| 3687 | 868 wrong = (lp->ll_dict->dv_scope == VAR_DEF_SCOPE |
| 869 && rettv->v_type == VAR_FUNC | |
| 2739 | 870 && var_check_func_name(key, lp->ll_di == NULL)) |
| 3687 | 871 || !valid_varname(key); |
| 872 if (len != -1) | |
| 873 key[len] = prevval; | |
| 874 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
|
875 { |
|
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20126
diff
changeset
|
876 clear_tv(&var1); |
| 2739 | 877 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
|
878 } |
| 2739 | 879 } |
| 880 | |
| 110 | 881 if (lp->ll_di == NULL) |
| 100 | 882 { |
|
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
883 // 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
|
884 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
|
885 || &lp->ll_dict->dv_hashtab == get_funccal_args_ht()) |
| 2739 | 886 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
887 semsg(_(e_illvar), name); |
|
16013
93b08b92a049
patch 8.1.1012: memory leak with E461
Bram Moolenaar <Bram@vim.org>
parents:
15969
diff
changeset
|
888 clear_tv(&var1); |
| 2739 | 889 return NULL; |
| 890 } | |
| 891 | |
|
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
892 // Key does not exist in dict: may need to add it. |
| 110 | 893 if (*p == '[' || *p == '.' || unlet) |
| 894 { | |
| 895 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
896 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
|
897 clear_tv(&var1); |
| 110 | 898 return NULL; |
| 100 | 899 } |
| 900 if (len == -1) | |
| 110 | 901 lp->ll_newkey = vim_strsave(key); |
| 100 | 902 else |
| 110 | 903 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
|
904 clear_tv(&var1); |
| 110 | 905 if (lp->ll_newkey == NULL) |
| 100 | 906 p = NULL; |
| 907 break; | |
| 908 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
909 // 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
|
910 else if ((flags & GLV_READ_ONLY) == 0 |
|
fd1760f8c215
patch 8.0.0345: islocked('d.changedtick') does not work
Christian Brabandt <cb@256bit.org>
parents:
10910
diff
changeset
|
911 && var_check_ro(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
|
912 { |
|
8bff367672a4
patch 8.0.0344: unlet command leaks memory
Christian Brabandt <cb@256bit.org>
parents:
10908
diff
changeset
|
913 clear_tv(&var1); |
| 2739 | 914 return NULL; |
|
10910
8bff367672a4
patch 8.0.0344: unlet command leaks memory
Christian Brabandt <cb@256bit.org>
parents:
10908
diff
changeset
|
915 } |
| 2739 | 916 |
|
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
|
917 clear_tv(&var1); |
| 110 | 918 lp->ll_tv = &lp->ll_di->di_tv; |
| 100 | 919 } |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
920 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
|
921 { |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
922 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
|
923 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
924 /* |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
925 * 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
|
926 */ |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
927 if (empty1) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
928 lp->ll_n1 = 0; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
929 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
930 // is number or string |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
931 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
|
932 clear_tv(&var1); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
933 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
934 if (lp->ll_n1 < 0 |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
935 || lp->ll_n1 > bloblen |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
936 || (lp->ll_range && lp->ll_n1 == bloblen)) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
937 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
938 if (!quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
939 semsg(_(e_blobidx), lp->ll_n1); |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
940 clear_tv(&var2); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
941 return NULL; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
942 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
943 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
|
944 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
945 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
|
946 clear_tv(&var2); |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
947 if (lp->ll_n2 < 0 |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
948 || lp->ll_n2 >= bloblen |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
949 || lp->ll_n2 < lp->ll_n1) |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
950 { |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
951 if (!quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
952 semsg(_(e_blobidx), lp->ll_n2); |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
953 return NULL; |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
954 } |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
955 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
956 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
|
957 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
|
958 break; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
959 } |
| 100 | 960 else |
| 961 { | |
| 962 /* | |
| 963 * Get the number and item for the only or first index of the List. | |
| 964 */ | |
| 965 if (empty1) | |
| 110 | 966 lp->ll_n1 = 0; |
| 100 | 967 else |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
968 // 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
|
969 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
|
970 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
|
971 |
| 117 | 972 lp->ll_dict = NULL; |
| 110 | 973 lp->ll_list = lp->ll_tv->vval.v_list; |
| 974 lp->ll_li = list_find(lp->ll_list, lp->ll_n1); | |
| 975 if (lp->ll_li == NULL) | |
| 976 { | |
| 842 | 977 if (lp->ll_n1 < 0) |
| 978 { | |
| 979 lp->ll_n1 = 0; | |
| 980 lp->ll_li = list_find(lp->ll_list, lp->ll_n1); | |
| 981 } | |
| 982 } | |
| 983 if (lp->ll_li == NULL) | |
| 984 { | |
|
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
|
985 clear_tv(&var2); |
| 2772 | 986 if (!quiet) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
987 semsg(_(e_listidx), lp->ll_n1); |
| 110 | 988 return NULL; |
| 100 | 989 } |
| 990 | |
| 991 /* | |
| 992 * May need to find the item or absolute index for the second | |
| 993 * index of a range. | |
| 110 | 994 * When no index given: "lp->ll_empty2" is TRUE. |
| 995 * Otherwise "lp->ll_n2" is set to the second index. | |
| 100 | 996 */ |
| 110 | 997 if (lp->ll_range && !lp->ll_empty2) |
| 998 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
999 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
|
1000 // is number or string |
| 88 | 1001 clear_tv(&var2); |
| 110 | 1002 if (lp->ll_n2 < 0) |
| 1003 { | |
| 1004 ni = list_find(lp->ll_list, lp->ll_n2); | |
| 100 | 1005 if (ni == NULL) |
| 2772 | 1006 { |
| 1007 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1008 semsg(_(e_listidx), lp->ll_n2); |
| 110 | 1009 return NULL; |
| 2772 | 1010 } |
| 110 | 1011 lp->ll_n2 = list_idx_of_item(lp->ll_list, ni); |
| 1012 } | |
| 1013 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1014 // Check that lp->ll_n2 isn't before lp->ll_n1. |
| 110 | 1015 if (lp->ll_n1 < 0) |
| 1016 lp->ll_n1 = list_idx_of_item(lp->ll_list, lp->ll_li); | |
| 1017 if (lp->ll_n2 < lp->ll_n1) | |
| 2772 | 1018 { |
| 1019 if (!quiet) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1020 semsg(_(e_listidx), lp->ll_n2); |
| 110 | 1021 return NULL; |
| 2772 | 1022 } |
| 110 | 1023 } |
| 1024 | |
| 1025 lp->ll_tv = &lp->ll_li->li_tv; | |
| 1026 } | |
| 1027 } | |
| 1028 | |
|
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
|
1029 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
|
1030 lp->ll_name_end = p; |
| 110 | 1031 return p; |
| 1032 } | |
| 1033 | |
| 1034 /* | |
| 137 | 1035 * Clear lval "lp" that was filled by get_lval(). |
| 110 | 1036 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
1037 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1038 clear_lval(lval_T *lp) |
| 110 | 1039 { |
| 1040 vim_free(lp->ll_exp_name); | |
| 1041 vim_free(lp->ll_newkey); | |
| 1042 } | |
| 1043 | |
| 1044 /* | |
| 151 | 1045 * Set a variable that was parsed by get_lval() to "rettv". |
| 110 | 1046 * "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
|
1047 * "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
|
1048 * "%" for "%=", "." for ".=" or "=" for "=". |
| 117 | 1049 */ |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
1050 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1051 set_var_lval( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1052 lval_T *lp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1053 char_u *endp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1054 typval_T *rettv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1055 int copy, |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1056 int flags, // LET_IS_CONST and/or LET_NO_COMMAND |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1057 char_u *op) |
| 110 | 1058 { |
| 1059 int cc; | |
| 137 | 1060 listitem_T *ri; |
| 1061 dictitem_T *di; | |
| 110 | 1062 |
| 1063 if (lp->ll_tv == NULL) | |
| 1064 { | |
|
10889
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1065 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
|
1066 *endp = NUL; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1067 if (lp->ll_blob != NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1068 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1069 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
|
1070 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1071 if (op != NULL && *op != '=') |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1072 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1073 semsg(_(e_letwrong), op); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1074 return; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1075 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1076 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1077 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
|
1078 { |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1079 int il, ir; |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1080 |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1081 if (lp->ll_empty2) |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1082 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
|
1083 |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1084 if (lp->ll_n2 - lp->ll_n1 + 1 != blob_len(rettv->vval.v_blob)) |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1085 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1086 emsg(_("E972: Blob value does not have the right number of bytes")); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1087 return; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1088 } |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1089 if (lp->ll_empty2) |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1090 lp->ll_n2 = blob_len(lp->ll_blob); |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1091 |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1092 ir = 0; |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1093 for (il = lp->ll_n1; il <= lp->ll_n2; il++) |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1094 blob_set(lp->ll_blob, il, |
|
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1095 blob_get(rettv->vval.v_blob, ir++)); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1096 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1097 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1098 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1099 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
|
1100 if (!error) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1101 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1102 garray_T *gap = &lp->ll_blob->bv_ga; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1103 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1104 // Allow for appending a byte. Setting a byte beyond |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1105 // the end is an error otherwise. |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1106 if (lp->ll_n1 < gap->ga_len |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1107 || (lp->ll_n1 == gap->ga_len |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1108 && ga_grow(&lp->ll_blob->bv_ga, 1) == OK)) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1109 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1110 blob_set(lp->ll_blob, lp->ll_n1, val); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1111 if (lp->ll_n1 == gap->ga_len) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1112 ++gap->ga_len; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1113 } |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1114 // error for invalid range was already given in get_lval() |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1115 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1116 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1117 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1118 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
|
1119 { |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1120 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
|
1121 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1122 if (flags & LET_IS_CONST) |
|
17079
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1123 { |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1124 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
|
1125 *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
|
1126 return; |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1127 } |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1128 |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1129 // 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
|
1130 di = NULL; |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1131 if (get_var_tv(lp->ll_name, (int)STRLEN(lp->ll_name), |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1132 &tv, &di, TRUE, FALSE) == OK) |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1133 { |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1134 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
|
1135 || (!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
|
1136 && !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
|
1137 && 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
|
1138 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
|
1139 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
|
1140 } |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1141 } |
|
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1142 else |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1143 set_var_const(lp->ll_name, lp->ll_type, rettv, copy, flags); |
|
10889
5780bd3a5a7e
patch 8.0.0334: can't access b:changedtick from a dict reference
Christian Brabandt <cb@256bit.org>
parents:
10728
diff
changeset
|
1144 *endp = cc; |
| 110 | 1145 } |
|
15780
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
1146 else if (var_check_lock(lp->ll_newkey == NULL |
| 151 | 1147 ? lp->ll_tv->v_lock |
| 6773 | 1148 : lp->ll_tv->vval.v_dict->dv_lock, lp->ll_name, FALSE)) |
| 151 | 1149 ; |
| 110 | 1150 else if (lp->ll_range) |
| 1151 { | |
| 6166 | 1152 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
|
1153 int ll_n1 = lp->ll_n1; |
| 6166 | 1154 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1155 if (flags & LET_IS_CONST) |
|
17079
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1156 { |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1157 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
|
1158 return; |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1159 } |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1160 |
| 6166 | 1161 /* |
| 1162 * Check whether any of the list items is locked | |
| 1163 */ | |
| 6422 | 1164 for (ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; ) |
| 6166 | 1165 { |
|
15780
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
1166 if (var_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE)) |
| 6166 | 1167 return; |
| 1168 ri = ri->li_next; | |
| 1169 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == ll_n1)) | |
| 1170 break; | |
| 1171 ll_li = ll_li->li_next; | |
| 1172 ++ll_n1; | |
| 1173 } | |
| 1174 | |
| 110 | 1175 /* |
| 1176 * Assign the List values to the list items. | |
| 1177 */ | |
| 1178 for (ri = rettv->vval.v_list->lv_first; ri != NULL; ) | |
| 1179 { | |
| 117 | 1180 if (op != NULL && *op != '=') |
| 1181 tv_op(&lp->ll_li->li_tv, &ri->li_tv, op); | |
| 1182 else | |
| 1183 { | |
| 1184 clear_tv(&lp->ll_li->li_tv); | |
| 1185 copy_tv(&ri->li_tv, &lp->ll_li->li_tv); | |
| 1186 } | |
| 110 | 1187 ri = ri->li_next; |
| 1188 if (ri == NULL || (!lp->ll_empty2 && lp->ll_n2 == lp->ll_n1)) | |
| 1189 break; | |
| 1190 if (lp->ll_li->li_next == NULL) | |
| 1191 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1192 // Need to add an empty item. |
| 533 | 1193 if (list_append_number(lp->ll_list, 0) == FAIL) |
| 110 | 1194 { |
| 1195 ri = NULL; | |
| 88 | 1196 break; |
| 110 | 1197 } |
| 1198 } | |
| 1199 lp->ll_li = lp->ll_li->li_next; | |
| 1200 ++lp->ll_n1; | |
| 1201 } | |
| 1202 if (ri != NULL) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1203 emsg(_("E710: List value has more items than target")); |
| 117 | 1204 else if (lp->ll_empty2 |
| 1205 ? (lp->ll_li != NULL && lp->ll_li->li_next != NULL) | |
| 110 | 1206 : lp->ll_n1 != lp->ll_n2) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1207 emsg(_("E711: List value has not enough items")); |
| 110 | 1208 } |
| 1209 else | |
| 1210 { | |
| 1211 /* | |
| 1212 * Assign to a List or Dictionary item. | |
| 1213 */ | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1214 if (flags & LET_IS_CONST) |
|
17079
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1215 { |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1216 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
|
1217 return; |
|
00ffed9bbb65
patch 8.1.1539: not easy to define a variable and lock it
Bram Moolenaar <Bram@vim.org>
parents:
17053
diff
changeset
|
1218 } |
| 110 | 1219 if (lp->ll_newkey != NULL) |
| 1220 { | |
| 117 | 1221 if (op != NULL && *op != '=') |
| 1222 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1223 semsg(_(e_letwrong), op); |
| 117 | 1224 return; |
| 1225 } | |
| 1226 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1227 // Need to add an item to the Dictionary. |
| 121 | 1228 di = dictitem_alloc(lp->ll_newkey); |
| 110 | 1229 if (di == NULL) |
| 1230 return; | |
| 121 | 1231 if (dict_add(lp->ll_tv->vval.v_dict, di) == FAIL) |
| 1232 { | |
| 1233 vim_free(di); | |
| 1234 return; | |
| 1235 } | |
| 110 | 1236 lp->ll_tv = &di->di_tv; |
| 1237 } | |
| 117 | 1238 else if (op != NULL && *op != '=') |
| 1239 { | |
| 1240 tv_op(lp->ll_tv, rettv, op); | |
| 1241 return; | |
| 1242 } | |
| 110 | 1243 else |
| 1244 clear_tv(lp->ll_tv); | |
| 1245 | |
| 1246 /* | |
| 1247 * Assign the value to the variable or list item. | |
| 1248 */ | |
| 1249 if (copy) | |
| 1250 copy_tv(rettv, lp->ll_tv); | |
| 1251 else | |
| 1252 { | |
| 1253 *lp->ll_tv = *rettv; | |
| 156 | 1254 lp->ll_tv->v_lock = 0; |
| 110 | 1255 init_tv(rettv); |
| 1256 } | |
| 1257 } | |
| 7 | 1258 } |
| 1259 | |
| 76 | 1260 /* |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1261 * 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
|
1262 * and "tv1 .= tv2" |
| 117 | 1263 * Returns OK or FAIL. |
| 1264 */ | |
| 1265 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1266 tv_op(typval_T *tv1, typval_T *tv2, char_u *op) |
| 117 | 1267 { |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
1268 varnumber_T n; |
| 117 | 1269 char_u numbuf[NUMBUFLEN]; |
| 1270 char_u *s; | |
| 1271 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1272 // 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
|
1273 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
|
1274 && tv2->v_type != VAR_BOOL && tv2->v_type != VAR_SPECIAL) |
| 117 | 1275 { |
| 1276 switch (tv1->v_type) | |
| 1277 { | |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
1278 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
|
1279 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
|
1280 case VAR_VOID: |
| 117 | 1281 case VAR_DICT: |
| 1282 case VAR_FUNC: | |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
1283 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
|
1284 case VAR_BOOL: |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
1285 case VAR_SPECIAL: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
1286 case VAR_JOB: |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
1287 case VAR_CHANNEL: |
| 117 | 1288 break; |
| 1289 | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1290 case VAR_BLOB: |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1291 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
|
1292 break; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1293 // BLOB += BLOB |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1294 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
|
1295 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1296 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
|
1297 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
|
1298 int i, len = blob_len(b2); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1299 for (i = 0; i < len; i++) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1300 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
|
1301 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1302 return OK; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1303 |
| 117 | 1304 case VAR_LIST: |
| 1305 if (*op != '+' || tv2->v_type != VAR_LIST) | |
| 1306 break; | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1307 // List += List |
| 117 | 1308 if (tv1->vval.v_list != NULL && tv2->vval.v_list != NULL) |
| 1309 list_extend(tv1->vval.v_list, tv2->vval.v_list, NULL); | |
| 1310 return OK; | |
| 1311 | |
| 1312 case VAR_NUMBER: | |
| 1313 case VAR_STRING: | |
| 1314 if (tv2->v_type == VAR_LIST) | |
| 1315 break; | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1316 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
|
1317 { |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1318 // 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
|
1319 n = tv_get_number(tv1); |
| 1624 | 1320 #ifdef FEAT_FLOAT |
| 1321 if (tv2->v_type == VAR_FLOAT) | |
| 1322 { | |
| 1323 float_T f = n; | |
| 1324 | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1325 if (*op == '%') |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1326 break; |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1327 switch (*op) |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1328 { |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1329 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
|
1330 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
|
1331 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
|
1332 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
|
1333 } |
| 1624 | 1334 clear_tv(tv1); |
| 1335 tv1->v_type = VAR_FLOAT; | |
| 1336 tv1->vval.v_float = f; | |
| 1337 } | |
| 117 | 1338 else |
| 1624 | 1339 #endif |
| 1340 { | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1341 switch (*op) |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1342 { |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1343 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
|
1344 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
|
1345 case '*': n *= tv_get_number(tv2); break; |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
1346 case '/': n = num_divide(n, tv_get_number(tv2)); break; |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
1347 case '%': n = num_modulus(n, tv_get_number(tv2)); break; |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1348 } |
| 1624 | 1349 clear_tv(tv1); |
| 1350 tv1->v_type = VAR_NUMBER; | |
| 1351 tv1->vval.v_number = n; | |
| 1352 } | |
| 1353 } | |
| 1354 else | |
| 1355 { | |
| 1356 if (tv2->v_type == VAR_FLOAT) | |
| 1357 break; | |
| 1358 | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1359 // str .= str |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1360 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
|
1361 s = concat_str(s, tv_get_string_buf(tv2, numbuf)); |
| 117 | 1362 clear_tv(tv1); |
| 1363 tv1->v_type = VAR_STRING; | |
| 1364 tv1->vval.v_string = s; | |
| 1365 } | |
| 1366 return OK; | |
| 1624 | 1367 |
| 1368 case VAR_FLOAT: | |
|
8364
991d8fd4d841
commit https://github.com/vim/vim/commit/5fac467474376a844407cecc0ff481510ead221c
Christian Brabandt <cb@256bit.org>
parents:
8350
diff
changeset
|
1369 #ifdef FEAT_FLOAT |
| 1624 | 1370 { |
| 1371 float_T f; | |
| 1372 | |
|
15790
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1373 if (*op == '%' || *op == '.' |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1374 || (tv2->v_type != VAR_FLOAT |
| 1624 | 1375 && tv2->v_type != VAR_NUMBER |
| 1376 && tv2->v_type != VAR_STRING)) | |
| 1377 break; | |
| 1378 if (tv2->v_type == VAR_FLOAT) | |
| 1379 f = tv2->vval.v_float; | |
| 1380 else | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1381 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
|
1382 switch (*op) |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1383 { |
|
05d836c8f1c4
patch 8.1.0902: incomplete set of assignment operators
Bram Moolenaar <Bram@vim.org>
parents:
15784
diff
changeset
|
1384 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
|
1385 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
|
1386 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
|
1387 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
|
1388 } |
| 1624 | 1389 } |
|
8364
991d8fd4d841
commit https://github.com/vim/vim/commit/5fac467474376a844407cecc0ff481510ead221c
Christian Brabandt <cb@256bit.org>
parents:
8350
diff
changeset
|
1390 #endif |
| 1624 | 1391 return OK; |
| 117 | 1392 } |
| 1393 } | |
| 1394 | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1395 semsg(_(e_letwrong), op); |
| 117 | 1396 return FAIL; |
| 1397 } | |
| 1398 | |
| 1399 /* | |
| 76 | 1400 * Evaluate the expression used in a ":for var in expr" command. |
| 1401 * "arg" points to "var". | |
| 1402 * Set "*errp" to TRUE for an error, FALSE otherwise; | |
| 1403 * Return a pointer that holds the info. Null when there is an error. | |
| 1404 */ | |
| 1405 void * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1406 eval_for_line( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1407 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1408 int *errp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1409 char_u **nextcmdp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1410 int skip) |
| 76 | 1411 { |
| 137 | 1412 forinfo_T *fi; |
| 76 | 1413 char_u *expr; |
| 137 | 1414 typval_T tv; |
| 1415 list_T *l; | |
| 76 | 1416 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1417 *errp = TRUE; // default: there is an error |
| 76 | 1418 |
|
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
|
1419 fi = ALLOC_CLEAR_ONE(forinfo_T); |
| 76 | 1420 if (fi == NULL) |
| 1421 return NULL; | |
| 1422 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1423 expr = skip_var_list(arg, TRUE, &fi->fi_varcount, &fi->fi_semicolon); |
| 76 | 1424 if (expr == NULL) |
| 1425 return fi; | |
| 1426 | |
| 1427 expr = skipwhite(expr); | |
|
11129
f4ea50924c6d
patch 8.0.0452: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11127
diff
changeset
|
1428 if (expr[0] != 'i' || expr[1] != 'n' || !VIM_ISWHITE(expr[2])) |
| 76 | 1429 { |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1430 emsg(_(e_missing_in)); |
| 76 | 1431 return fi; |
| 1432 } | |
| 1433 | |
| 1434 if (skip) | |
| 1435 ++emsg_skip; | |
| 1436 if (eval0(skipwhite(expr + 2), &tv, nextcmdp, !skip) == OK) | |
| 1437 { | |
| 1438 *errp = FALSE; | |
| 1439 if (!skip) | |
| 1440 { | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1441 if (tv.v_type == VAR_LIST) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1442 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1443 l = tv.vval.v_list; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1444 if (l == NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1445 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1446 // 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
|
1447 clear_tv(&tv); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1448 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1449 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1450 { |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1451 // Need a real list here. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1452 range_list_materialize(l); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1453 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1454 // 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
|
1455 // the list being used in "tv". |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1456 fi->fi_list = l; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1457 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
|
1458 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
|
1459 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1460 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1461 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
|
1462 { |
|
15581
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1463 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
|
1464 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
|
1465 { |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1466 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
|
1467 |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1468 // 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
|
1469 // 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
|
1470 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
|
1471 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
|
1472 } |
|
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
1473 clear_tv(&tv); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1474 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1475 else |
| 359 | 1476 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1477 emsg(_(e_listreq)); |
| 359 | 1478 clear_tv(&tv); |
| 1479 } | |
| 76 | 1480 } |
| 1481 } | |
| 1482 if (skip) | |
| 1483 --emsg_skip; | |
| 1484 | |
| 1485 return fi; | |
| 1486 } | |
| 1487 | |
| 1488 /* | |
| 1489 * Use the first item in a ":for" list. Advance to the next. | |
| 1490 * Assign the values to the variable (list). "arg" points to the first one. | |
| 1491 * Return TRUE when a valid item was found, FALSE when at end of list or | |
| 1492 * something wrong. | |
| 1493 */ | |
| 1494 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1495 next_for_item(void *fi_void, char_u *arg) |
| 76 | 1496 { |
|
4974
a594ce86b5ea
updated for version 7.3.1232
Bram Moolenaar <bram@vim.org>
parents:
4936
diff
changeset
|
1497 forinfo_T *fi = (forinfo_T *)fi_void; |
| 76 | 1498 int result; |
|
19568
c0749ad6c699
patch 8.2.0341: using ":for" in Vim9 script gives an error
Bram Moolenaar <Bram@vim.org>
parents:
19554
diff
changeset
|
1499 int flag = current_sctx.sc_version == SCRIPT_VERSION_VIM9 ? |
|
c0749ad6c699
patch 8.2.0341: using ":for" in Vim9 script gives an error
Bram Moolenaar <Bram@vim.org>
parents:
19554
diff
changeset
|
1500 LET_NO_COMMAND : 0; |
| 137 | 1501 listitem_T *item; |
| 76 | 1502 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1503 if (fi->fi_blob != NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1504 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1505 typval_T tv; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1506 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1507 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
|
1508 return FALSE; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1509 tv.v_type = VAR_NUMBER; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1510 tv.v_lock = VAR_FIXED; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1511 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
|
1512 ++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
|
1513 return ex_let_vars(arg, &tv, TRUE, fi->fi_semicolon, |
|
19568
c0749ad6c699
patch 8.2.0341: using ":for" in Vim9 script gives an error
Bram Moolenaar <Bram@vim.org>
parents:
19554
diff
changeset
|
1514 fi->fi_varcount, flag, NULL) == OK; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1515 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
1516 |
| 76 | 1517 item = fi->fi_lw.lw_item; |
| 1518 if (item == NULL) | |
| 1519 result = FALSE; | |
| 1520 else | |
| 1521 { | |
| 1522 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
|
1523 result = (ex_let_vars(arg, &item->li_tv, TRUE, fi->fi_semicolon, |
|
19568
c0749ad6c699
patch 8.2.0341: using ":for" in Vim9 script gives an error
Bram Moolenaar <Bram@vim.org>
parents:
19554
diff
changeset
|
1524 fi->fi_varcount, flag, NULL) == OK); |
| 76 | 1525 } |
| 1526 return result; | |
| 1527 } | |
| 1528 | |
| 1529 /* | |
| 1530 * Free the structure used to store info used by ":for". | |
| 1531 */ | |
| 1532 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1533 free_for_info(void *fi_void) |
| 76 | 1534 { |
| 137 | 1535 forinfo_T *fi = (forinfo_T *)fi_void; |
| 76 | 1536 |
| 92 | 1537 if (fi != NULL && fi->fi_list != NULL) |
| 359 | 1538 { |
| 76 | 1539 list_rem_watch(fi->fi_list, &fi->fi_lw); |
| 359 | 1540 list_unref(fi->fi_list); |
| 1541 } | |
|
15460
543cff56dd3f
patch 8.1.0738: using freed memory, for loop over blob leaks memory
Bram Moolenaar <Bram@vim.org>
parents:
15458
diff
changeset
|
1542 if (fi != NULL && fi->fi_blob != NULL) |
|
543cff56dd3f
patch 8.1.0738: using freed memory, for loop over blob leaks memory
Bram Moolenaar <Bram@vim.org>
parents:
15458
diff
changeset
|
1543 blob_unref(fi->fi_blob); |
| 76 | 1544 vim_free(fi); |
| 1545 } | |
| 1546 | |
| 7 | 1547 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1548 set_context_for_expression( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1549 expand_T *xp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1550 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1551 cmdidx_T cmdidx) |
| 7 | 1552 { |
| 1553 int got_eq = FALSE; | |
| 1554 int c; | |
| 76 | 1555 char_u *p; |
| 1556 | |
|
18713
baf890fa1621
patch 8.1.2348: :const cannot be followed by "| endif"
Bram Moolenaar <Bram@vim.org>
parents:
18301
diff
changeset
|
1557 if (cmdidx == CMD_let || cmdidx == CMD_const) |
| 76 | 1558 { |
| 1559 xp->xp_context = EXPAND_USER_VARS; | |
| 159 | 1560 if (vim_strpbrk(arg, (char_u *)"\"'+-*/%.=!?~|&$([<>,#") == NULL) |
| 76 | 1561 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1562 // ":let var1 var2 ...": find last space. |
| 159 | 1563 for (p = arg + STRLEN(arg); p >= arg; ) |
| 76 | 1564 { |
| 1565 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
|
1566 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
|
1567 if (VIM_ISWHITE(*p)) |
| 76 | 1568 break; |
| 1569 } | |
| 1570 return; | |
| 1571 } | |
| 1572 } | |
| 1573 else | |
| 1574 xp->xp_context = cmdidx == CMD_call ? EXPAND_FUNCTIONS | |
| 1575 : EXPAND_EXPRESSION; | |
| 7 | 1576 while ((xp->xp_pattern = vim_strpbrk(arg, |
| 1577 (char_u *)"\"'+-*/%.=!?~|&$([<>,#")) != NULL) | |
| 1578 { | |
| 1579 c = *xp->xp_pattern; | |
| 1580 if (c == '&') | |
| 1581 { | |
| 1582 c = xp->xp_pattern[1]; | |
| 1583 if (c == '&') | |
| 1584 { | |
| 1585 ++xp->xp_pattern; | |
| 1586 xp->xp_context = cmdidx != CMD_let || got_eq | |
| 1587 ? EXPAND_EXPRESSION : EXPAND_NOTHING; | |
| 1588 } | |
| 1589 else if (c != ' ') | |
| 201 | 1590 { |
| 7 | 1591 xp->xp_context = EXPAND_SETTINGS; |
| 201 | 1592 if ((c == 'l' || c == 'g') && xp->xp_pattern[2] == ':') |
| 1593 xp->xp_pattern += 2; | |
| 1594 | |
| 1595 } | |
| 7 | 1596 } |
| 1597 else if (c == '$') | |
| 1598 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1599 // environment variable |
| 7 | 1600 xp->xp_context = EXPAND_ENV_VARS; |
| 1601 } | |
| 1602 else if (c == '=') | |
| 1603 { | |
| 1604 got_eq = TRUE; | |
| 1605 xp->xp_context = EXPAND_EXPRESSION; | |
| 1606 } | |
|
8763
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1607 else if (c == '#' |
|
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1608 && xp->xp_context == EXPAND_EXPRESSION) |
|
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1609 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1610 // Autoload function/variable contains '#'. |
|
8763
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1611 break; |
|
4b83af41f5db
commit https://github.com/vim/vim/commit/a32095fc8fdf5fe3d487c86d9cc54adb1236731e
Christian Brabandt <cb@256bit.org>
parents:
8749
diff
changeset
|
1612 } |
| 6367 | 1613 else if ((c == '<' || c == '#') |
| 7 | 1614 && xp->xp_context == EXPAND_FUNCTIONS |
| 1615 && vim_strchr(xp->xp_pattern, '(') == NULL) | |
| 1616 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1617 // Function name can start with "<SNR>" and contain '#'. |
| 7 | 1618 break; |
| 1619 } | |
| 1620 else if (cmdidx != CMD_let || got_eq) | |
| 1621 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1622 if (c == '"') // string |
| 7 | 1623 { |
| 1624 while ((c = *++xp->xp_pattern) != NUL && c != '"') | |
| 1625 if (c == '\\' && xp->xp_pattern[1] != NUL) | |
| 1626 ++xp->xp_pattern; | |
| 1627 xp->xp_context = EXPAND_NOTHING; | |
| 1628 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1629 else if (c == '\'') // literal string |
| 7 | 1630 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1631 // Trick: '' is like stopping and starting a literal string. |
| 7 | 1632 while ((c = *++xp->xp_pattern) != NUL && c != '\'') |
| 1633 /* skip */ ; | |
| 1634 xp->xp_context = EXPAND_NOTHING; | |
| 1635 } | |
| 1636 else if (c == '|') | |
| 1637 { | |
| 1638 if (xp->xp_pattern[1] == '|') | |
| 1639 { | |
| 1640 ++xp->xp_pattern; | |
| 1641 xp->xp_context = EXPAND_EXPRESSION; | |
| 1642 } | |
| 1643 else | |
| 1644 xp->xp_context = EXPAND_COMMANDS; | |
| 1645 } | |
| 1646 else | |
| 1647 xp->xp_context = EXPAND_EXPRESSION; | |
| 1648 } | |
| 1649 else | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1650 // 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
|
1651 // anyway. |
| 76 | 1652 xp->xp_context = EXPAND_EXPRESSION; |
| 7 | 1653 arg = xp->xp_pattern; |
| 1654 if (*arg != NUL) | |
| 1655 while ((c = *++arg) != NUL && (c == ' ' || c == '\t')) | |
| 1656 /* skip */ ; | |
| 1657 } | |
| 1658 xp->xp_pattern = arg; | |
| 1659 } | |
| 1660 | |
| 1661 /* | |
|
8749
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1662 * Return TRUE if "pat" matches "text". |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1663 * 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
|
1664 */ |
|
17377
cb008de2a6ec
patch 8.1.1687: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17375
diff
changeset
|
1665 int |
|
8749
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1666 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
|
1667 { |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1668 int matches = FALSE; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1669 char_u *save_cpo; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1670 regmatch_T regmatch; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1671 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1672 // avoid 'l' flag in 'cpoptions' |
|
8749
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1673 save_cpo = p_cpo; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1674 p_cpo = (char_u *)""; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1675 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
|
1676 if (regmatch.regprog != NULL) |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1677 { |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1678 regmatch.rm_ic = ic; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1679 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
|
1680 vim_regfree(regmatch.regprog); |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1681 } |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1682 p_cpo = save_cpo; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1683 return matches; |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1684 } |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1685 |
|
65a5a18d3acf
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2
Christian Brabandt <cb@256bit.org>
parents:
8742
diff
changeset
|
1686 /* |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1687 * 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
|
1688 * "expr->name(arg)". |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1689 * Returns OK or FAIL. |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1690 */ |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1691 static int |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1692 eval_func( |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1693 char_u **arg, // points to "(", will be advanced |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1694 char_u *name, |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1695 int name_len, |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1696 typval_T *rettv, |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1697 int evaluate, |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1698 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
|
1699 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1700 char_u *s = name; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1701 int len = name_len; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1702 partial_T *partial; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1703 int ret = OK; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1704 |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1705 if (!evaluate) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1706 check_vars(s, len); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1707 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1708 // 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
|
1709 // use its contents. |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1710 s = deref_func_name(s, &len, &partial, !evaluate); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1711 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1712 // 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
|
1713 // the name invalid. |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1714 s = vim_strsave(s); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1715 if (s == NULL) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1716 ret = FAIL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1717 else |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1718 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1719 funcexe_T funcexe; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1720 |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1721 // Invoke the function. |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
1722 CLEAR_FIELD(funcexe); |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1723 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
|
1724 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
|
1725 funcexe.evaluate = evaluate; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1726 funcexe.partial = partial; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1727 funcexe.basetv = basetv; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1728 ret = get_func_tv(s, len, rettv, arg, &funcexe); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1729 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1730 vim_free(s); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1731 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1732 // 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
|
1733 // 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
|
1734 // 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
|
1735 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
|
1736 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1737 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
|
1738 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
|
1739 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1740 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1741 // 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
|
1742 // 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
|
1743 // 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
|
1744 if (evaluate && aborting()) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1745 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1746 if (ret == OK) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1747 clear_tv(rettv); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1748 ret = FAIL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1749 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1750 return ret; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1751 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1752 |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
1753 /* |
| 7 | 1754 * The "evaluate" argument: When FALSE, the argument is only parsed but not |
| 71 | 1755 * executed. The function may return OK, but the rettv will be of type |
| 7 | 1756 * VAR_UNKNOWN. The function still returns FAIL for a syntax error. |
| 1757 */ | |
| 1758 | |
| 1759 /* | |
| 1760 * Handle zero level expression. | |
| 1761 * This calls eval1() and handles error message and nextcmd. | |
| 71 | 1762 * Put the result in "rettv" when returning OK and "evaluate" is TRUE. |
| 533 | 1763 * Note: "rettv.v_lock" is not set. |
| 7 | 1764 * Return OK or FAIL. |
| 1765 */ | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
1766 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1767 eval0( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1768 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1769 typval_T *rettv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1770 char_u **nextcmd, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1771 int evaluate) |
| 7 | 1772 { |
| 1773 int ret; | |
| 1774 char_u *p; | |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1775 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
|
1776 int called_emsg_before = called_emsg; |
| 7 | 1777 |
| 1778 p = skipwhite(arg); | |
| 71 | 1779 ret = eval1(&p, rettv, evaluate); |
|
20111
f40231487a49
patch 8.2.0611: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20091
diff
changeset
|
1780 if (ret == FAIL || !ends_excmd2(arg, p)) |
| 7 | 1781 { |
| 1782 if (ret != FAIL) | |
| 71 | 1783 clear_tv(rettv); |
| 7 | 1784 /* |
| 1785 * Report the invalid expression unless the expression evaluation has | |
| 1786 * 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
|
1787 * 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
|
1788 * Also check called_emsg for when using assert_fails(). |
| 7 | 1789 */ |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
1790 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
|
1791 && called_emsg == called_emsg_before) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
1792 semsg(_(e_invexpr2), arg); |
| 7 | 1793 ret = FAIL; |
| 1794 } | |
| 1795 if (nextcmd != NULL) | |
| 1796 *nextcmd = check_nextcmd(p); | |
| 1797 | |
| 1798 return ret; | |
| 1799 } | |
| 1800 | |
| 1801 /* | |
| 1802 * Handle top level expression: | |
| 1800 | 1803 * expr2 ? expr1 : expr1 |
| 7 | 1804 * |
| 1805 * "arg" must point to the first non-white of the expression. | |
| 1806 * "arg" is advanced to the next non-white after the recognized expression. | |
| 1807 * | |
| 533 | 1808 * Note: "rettv.v_lock" is not set. |
| 1809 * | |
| 7 | 1810 * Return OK or FAIL. |
| 1811 */ | |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
1812 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1813 eval1(char_u **arg, typval_T *rettv, int evaluate) |
| 7 | 1814 { |
| 1815 int result; | |
| 137 | 1816 typval_T var2; |
| 7 | 1817 |
| 1818 /* | |
| 1819 * Get the first variable. | |
| 1820 */ | |
| 71 | 1821 if (eval2(arg, rettv, evaluate) == FAIL) |
| 7 | 1822 return FAIL; |
| 1823 | |
| 1824 if ((*arg)[0] == '?') | |
| 1825 { | |
| 1826 result = FALSE; | |
| 1827 if (evaluate) | |
| 1828 { | |
| 323 | 1829 int error = FALSE; |
| 1830 | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1831 if (tv_get_number_chk(rettv, &error) != 0) |
| 7 | 1832 result = TRUE; |
| 71 | 1833 clear_tv(rettv); |
| 323 | 1834 if (error) |
| 1835 return FAIL; | |
| 7 | 1836 } |
| 1837 | |
| 1838 /* | |
| 1839 * Get the second variable. | |
| 1840 */ | |
| 1841 *arg = skipwhite(*arg + 1); | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1842 if (eval1(arg, rettv, evaluate && result) == FAIL) // recursive! |
| 7 | 1843 return FAIL; |
| 1844 | |
| 1845 /* | |
| 1846 * Check for the ":". | |
| 1847 */ | |
| 1848 if ((*arg)[0] != ':') | |
| 1849 { | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
1850 emsg(_(e_missing_colon)); |
| 7 | 1851 if (evaluate && result) |
| 71 | 1852 clear_tv(rettv); |
| 7 | 1853 return FAIL; |
| 1854 } | |
| 1855 | |
| 1856 /* | |
| 1857 * Get the third variable. | |
| 1858 */ | |
| 1859 *arg = skipwhite(*arg + 1); | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1860 if (eval1(arg, &var2, evaluate && !result) == FAIL) // recursive! |
| 7 | 1861 { |
| 1862 if (evaluate && result) | |
| 71 | 1863 clear_tv(rettv); |
| 7 | 1864 return FAIL; |
| 1865 } | |
| 1866 if (evaluate && !result) | |
| 71 | 1867 *rettv = var2; |
| 7 | 1868 } |
| 1869 | |
| 1870 return OK; | |
| 1871 } | |
| 1872 | |
| 1873 /* | |
| 1874 * Handle first level expression: | |
| 1875 * expr2 || expr2 || expr2 logical OR | |
| 1876 * | |
| 1877 * "arg" must point to the first non-white of the expression. | |
| 1878 * "arg" is advanced to the next non-white after the recognized expression. | |
| 1879 * | |
| 1880 * Return OK or FAIL. | |
| 1881 */ | |
| 1882 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1883 eval2(char_u **arg, typval_T *rettv, int evaluate) |
| 7 | 1884 { |
| 137 | 1885 typval_T var2; |
| 7 | 1886 long result; |
| 1887 int first; | |
| 323 | 1888 int error = FALSE; |
| 7 | 1889 |
| 1890 /* | |
| 1891 * Get the first variable. | |
| 1892 */ | |
| 71 | 1893 if (eval3(arg, rettv, evaluate) == FAIL) |
| 7 | 1894 return FAIL; |
| 1895 | |
| 1896 /* | |
| 1897 * Repeat until there is no following "||". | |
| 1898 */ | |
| 1899 first = TRUE; | |
| 1900 result = FALSE; | |
| 1901 while ((*arg)[0] == '|' && (*arg)[1] == '|') | |
| 1902 { | |
| 1903 if (evaluate && first) | |
| 1904 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1905 if (tv_get_number_chk(rettv, &error) != 0) |
| 7 | 1906 result = TRUE; |
| 71 | 1907 clear_tv(rettv); |
| 323 | 1908 if (error) |
| 1909 return FAIL; | |
| 7 | 1910 first = FALSE; |
| 1911 } | |
| 1912 | |
| 1913 /* | |
| 1914 * Get the second variable. | |
| 1915 */ | |
| 1916 *arg = skipwhite(*arg + 2); | |
| 1917 if (eval3(arg, &var2, evaluate && !result) == FAIL) | |
| 1918 return FAIL; | |
| 1919 | |
| 1920 /* | |
| 1921 * Compute the result. | |
| 1922 */ | |
| 1923 if (evaluate && !result) | |
| 1924 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1925 if (tv_get_number_chk(&var2, &error) != 0) |
| 7 | 1926 result = TRUE; |
| 71 | 1927 clear_tv(&var2); |
| 323 | 1928 if (error) |
| 1929 return FAIL; | |
| 7 | 1930 } |
| 1931 if (evaluate) | |
| 1932 { | |
| 71 | 1933 rettv->v_type = VAR_NUMBER; |
| 1934 rettv->vval.v_number = result; | |
| 7 | 1935 } |
| 1936 } | |
| 1937 | |
| 1938 return OK; | |
| 1939 } | |
| 1940 | |
| 1941 /* | |
| 1942 * Handle second level expression: | |
| 1943 * expr3 && expr3 && expr3 logical AND | |
| 1944 * | |
| 1945 * "arg" must point to the first non-white of the expression. | |
| 1946 * "arg" is advanced to the next non-white after the recognized expression. | |
| 1947 * | |
| 1948 * Return OK or FAIL. | |
| 1949 */ | |
| 1950 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
1951 eval3(char_u **arg, typval_T *rettv, int evaluate) |
| 7 | 1952 { |
| 137 | 1953 typval_T var2; |
| 7 | 1954 long result; |
| 1955 int first; | |
| 323 | 1956 int error = FALSE; |
| 7 | 1957 |
| 1958 /* | |
| 1959 * Get the first variable. | |
| 1960 */ | |
| 71 | 1961 if (eval4(arg, rettv, evaluate) == FAIL) |
| 7 | 1962 return FAIL; |
| 1963 | |
| 1964 /* | |
| 1965 * Repeat until there is no following "&&". | |
| 1966 */ | |
| 1967 first = TRUE; | |
| 1968 result = TRUE; | |
| 1969 while ((*arg)[0] == '&' && (*arg)[1] == '&') | |
| 1970 { | |
| 1971 if (evaluate && first) | |
| 1972 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1973 if (tv_get_number_chk(rettv, &error) == 0) |
| 7 | 1974 result = FALSE; |
| 71 | 1975 clear_tv(rettv); |
| 323 | 1976 if (error) |
| 1977 return FAIL; | |
| 7 | 1978 first = FALSE; |
| 1979 } | |
| 1980 | |
| 1981 /* | |
| 1982 * Get the second variable. | |
| 1983 */ | |
| 1984 *arg = skipwhite(*arg + 2); | |
| 1985 if (eval4(arg, &var2, evaluate && result) == FAIL) | |
| 1986 return FAIL; | |
| 1987 | |
| 1988 /* | |
| 1989 * Compute the result. | |
| 1990 */ | |
| 1991 if (evaluate && result) | |
| 1992 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
1993 if (tv_get_number_chk(&var2, &error) == 0) |
| 7 | 1994 result = FALSE; |
| 71 | 1995 clear_tv(&var2); |
| 323 | 1996 if (error) |
| 1997 return FAIL; | |
| 7 | 1998 } |
| 1999 if (evaluate) | |
| 2000 { | |
| 71 | 2001 rettv->v_type = VAR_NUMBER; |
| 2002 rettv->vval.v_number = result; | |
| 7 | 2003 } |
| 2004 } | |
| 2005 | |
| 2006 return OK; | |
| 2007 } | |
| 2008 | |
| 2009 /* | |
| 2010 * Handle third level expression: | |
| 2011 * var1 == var2 | |
| 2012 * var1 =~ var2 | |
| 2013 * var1 != var2 | |
| 2014 * var1 !~ var2 | |
| 2015 * var1 > var2 | |
| 2016 * var1 >= var2 | |
| 2017 * var1 < var2 | |
| 2018 * var1 <= var2 | |
| 80 | 2019 * var1 is var2 |
| 2020 * var1 isnot var2 | |
| 7 | 2021 * |
| 2022 * "arg" must point to the first non-white of the expression. | |
| 2023 * "arg" is advanced to the next non-white after the recognized expression. | |
| 2024 * | |
| 2025 * Return OK or FAIL. | |
| 2026 */ | |
| 2027 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2028 eval4(char_u **arg, typval_T *rettv, int evaluate) |
| 7 | 2029 { |
| 137 | 2030 typval_T var2; |
| 7 | 2031 char_u *p; |
| 2032 int i; | |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2033 exptype_T type = EXPR_UNKNOWN; |
| 7 | 2034 int len = 2; |
| 2035 int ic; | |
| 2036 | |
| 2037 /* | |
| 2038 * Get the first variable. | |
| 2039 */ | |
| 71 | 2040 if (eval5(arg, rettv, evaluate) == FAIL) |
| 7 | 2041 return FAIL; |
| 2042 | |
| 2043 p = *arg; | |
| 2044 switch (p[0]) | |
| 2045 { | |
| 2046 case '=': if (p[1] == '=') | |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2047 type = EXPR_EQUAL; |
| 7 | 2048 else if (p[1] == '~') |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2049 type = EXPR_MATCH; |
| 7 | 2050 break; |
| 2051 case '!': if (p[1] == '=') | |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2052 type = EXPR_NEQUAL; |
| 7 | 2053 else if (p[1] == '~') |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2054 type = EXPR_NOMATCH; |
| 7 | 2055 break; |
| 2056 case '>': if (p[1] != '=') | |
| 2057 { | |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2058 type = EXPR_GREATER; |
| 7 | 2059 len = 1; |
| 2060 } | |
| 2061 else | |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2062 type = EXPR_GEQUAL; |
| 7 | 2063 break; |
| 2064 case '<': if (p[1] != '=') | |
| 2065 { | |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2066 type = EXPR_SMALLER; |
| 7 | 2067 len = 1; |
| 2068 } | |
| 2069 else | |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2070 type = EXPR_SEQUAL; |
| 7 | 2071 break; |
| 80 | 2072 case 'i': if (p[1] == 's') |
| 2073 { | |
| 2074 if (p[2] == 'n' && p[3] == 'o' && p[4] == 't') | |
| 2075 len = 5; | |
|
7064
5fc5c5bf2233
commit https://github.com/vim/vim/commit/37a8de17d4dfd3d463960c38a204ce399c8e19d4
Christian Brabandt <cb@256bit.org>
parents:
7046
diff
changeset
|
2076 i = p[len]; |
|
5fc5c5bf2233
commit https://github.com/vim/vim/commit/37a8de17d4dfd3d463960c38a204ce399c8e19d4
Christian Brabandt <cb@256bit.org>
parents:
7046
diff
changeset
|
2077 if (!isalnum(i) && i != '_') |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2078 type = len == 2 ? EXPR_IS : EXPR_ISNOT; |
| 80 | 2079 } |
| 2080 break; | |
| 7 | 2081 } |
| 2082 | |
| 2083 /* | |
| 1624 | 2084 * If there is a comparative operator, use it. |
| 7 | 2085 */ |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
2086 if (type != EXPR_UNKNOWN) |
| 7 | 2087 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2088 // extra question mark appended: ignore case |
| 7 | 2089 if (p[len] == '?') |
| 2090 { | |
| 2091 ic = TRUE; | |
| 2092 ++len; | |
| 2093 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2094 // extra '#' appended: match case |
| 7 | 2095 else if (p[len] == '#') |
| 2096 { | |
| 2097 ic = FALSE; | |
| 2098 ++len; | |
| 2099 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2100 // nothing appended: use 'ignorecase' |
| 7 | 2101 else |
| 2102 ic = p_ic; | |
| 2103 | |
| 2104 /* | |
| 2105 * Get the second variable. | |
| 2106 */ | |
| 2107 *arg = skipwhite(p + len); | |
| 2108 if (eval5(arg, &var2, evaluate) == FAIL) | |
| 2109 { | |
| 71 | 2110 clear_tv(rettv); |
| 7 | 2111 return FAIL; |
| 2112 } | |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
2113 if (evaluate) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
2114 { |
|
18966
6bd715870e32
patch 8.2.0044: expression type is used inconsistently
Bram Moolenaar <Bram@vim.org>
parents:
18939
diff
changeset
|
2115 int 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
|
2116 |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
2117 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
|
2118 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
|
2119 } |
| 7 | 2120 } |
| 2121 | |
| 2122 return OK; | |
| 2123 } | |
| 2124 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2125 void |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2126 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
|
2127 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2128 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
|
2129 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
|
2130 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
|
2131 int i; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2132 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2133 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
|
2134 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2135 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
|
2136 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
|
2137 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
|
2138 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
|
2139 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2140 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
|
2141 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
|
2142 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2143 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2144 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2145 int |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2146 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
|
2147 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2148 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
|
2149 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2150 // concatenate Lists |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2151 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
|
2152 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2153 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
|
2154 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
|
2155 return FAIL; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2156 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2157 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
|
2158 *tv1 = var3; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2159 return OK; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2160 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2161 |
| 7 | 2162 /* |
| 2163 * Handle fourth level expression: | |
| 2164 * + number addition | |
| 2165 * - number subtraction | |
|
16223
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2166 * . 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
|
2167 * .. string concatenation |
| 7 | 2168 * |
| 2169 * "arg" must point to the first non-white of the expression. | |
| 2170 * "arg" is advanced to the next non-white after the recognized expression. | |
| 2171 * | |
| 2172 * Return OK or FAIL. | |
| 2173 */ | |
| 2174 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2175 eval5(char_u **arg, typval_T *rettv, int evaluate) |
| 7 | 2176 { |
| 137 | 2177 typval_T var2; |
| 7 | 2178 int op; |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
2179 varnumber_T n1, n2; |
| 1624 | 2180 #ifdef FEAT_FLOAT |
| 2181 float_T f1 = 0, f2 = 0; | |
| 2182 #endif | |
| 7 | 2183 char_u *s1, *s2; |
| 2184 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; | |
| 2185 char_u *p; | |
|
16223
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2186 int concat; |
| 7 | 2187 |
| 2188 /* | |
| 2189 * Get the first variable. | |
| 2190 */ | |
| 1655 | 2191 if (eval6(arg, rettv, evaluate, FALSE) == FAIL) |
| 7 | 2192 return FAIL; |
| 2193 | |
| 2194 /* | |
| 2195 * Repeat computing, until no '+', '-' or '.' is following. | |
| 2196 */ | |
| 2197 for (;;) | |
| 2198 { | |
|
16223
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2199 // "." is only string concatenation when scriptversion is 1 |
| 7 | 2200 op = **arg; |
|
16223
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2201 concat = op == '.' |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2202 && (*(*arg + 1) == '.' || 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
|
2203 if (op != '+' && op != '-' && !concat) |
| 7 | 2204 break; |
| 2205 | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2206 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
|
2207 && rettv->v_type != VAR_BLOB)) |
| 1624 | 2208 #ifdef FEAT_FLOAT |
| 2209 && (op == '.' || rettv->v_type != VAR_FLOAT) | |
| 2210 #endif | |
| 2211 ) | |
| 323 | 2212 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2213 // 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
|
2214 // 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
|
2215 // 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
|
2216 // 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
|
2217 // 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
|
2218 // 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
|
2219 // side effects after an error. |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
2220 if (evaluate && tv_get_string_chk(rettv) == NULL) |
| 323 | 2221 { |
| 2222 clear_tv(rettv); | |
| 2223 return FAIL; | |
| 2224 } | |
| 2225 } | |
| 2226 | |
| 7 | 2227 /* |
| 2228 * Get the second variable. | |
| 2229 */ | |
|
16219
bd49e1656c72
patch 8.1.1114: confusing overloaded operator "." for string concatenation
Bram Moolenaar <Bram@vim.org>
parents:
16170
diff
changeset
|
2230 if (op == '.' && *(*arg + 1) == '.') // .. string concatenation |
|
bd49e1656c72
patch 8.1.1114: confusing overloaded operator "." for string concatenation
Bram Moolenaar <Bram@vim.org>
parents:
16170
diff
changeset
|
2231 ++*arg; |
| 7 | 2232 *arg = skipwhite(*arg + 1); |
| 1655 | 2233 if (eval6(arg, &var2, evaluate, op == '.') == FAIL) |
| 7 | 2234 { |
| 71 | 2235 clear_tv(rettv); |
| 7 | 2236 return FAIL; |
| 2237 } | |
| 2238 | |
| 2239 if (evaluate) | |
| 2240 { | |
| 2241 /* | |
| 2242 * Compute the result. | |
| 2243 */ | |
| 2244 if (op == '.') | |
| 2245 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2246 s1 = tv_get_string_buf(rettv, buf1); // already checked |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
2247 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
|
2248 if (s2 == NULL) // type error ? |
| 323 | 2249 { |
| 2250 clear_tv(rettv); | |
| 2251 clear_tv(&var2); | |
| 2252 return FAIL; | |
| 2253 } | |
| 117 | 2254 p = concat_str(s1, s2); |
| 71 | 2255 clear_tv(rettv); |
| 2256 rettv->v_type = VAR_STRING; | |
| 2257 rettv->vval.v_string = p; | |
| 7 | 2258 } |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2259 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
|
2260 && 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
|
2261 eval_addblob(rettv, &var2); |
| 104 | 2262 else if (op == '+' && rettv->v_type == VAR_LIST |
| 2263 && var2.v_type == VAR_LIST) | |
| 80 | 2264 { |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2265 if (eval_addlist(rettv, &var2) == FAIL) |
| 80 | 2266 return FAIL; |
| 2267 } | |
| 7 | 2268 else |
| 2269 { | |
| 323 | 2270 int error = FALSE; |
| 2271 | |
| 1624 | 2272 #ifdef FEAT_FLOAT |
| 2273 if (rettv->v_type == VAR_FLOAT) | |
| 2274 { | |
| 2275 f1 = rettv->vval.v_float; | |
| 2276 n1 = 0; | |
| 2277 } | |
| 2278 else | |
| 2279 #endif | |
| 2280 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
2281 n1 = tv_get_number_chk(rettv, &error); |
| 1624 | 2282 if (error) |
| 2283 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2284 // This can only happen for "list + non-list". For |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2285 // "non-list + ..." or "something - ...", we returned |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2286 // before evaluating the 2nd operand. |
| 1624 | 2287 clear_tv(rettv); |
| 2288 return FAIL; | |
| 2289 } | |
| 2290 #ifdef FEAT_FLOAT | |
| 2291 if (var2.v_type == VAR_FLOAT) | |
| 2292 f1 = n1; | |
| 2293 #endif | |
| 2294 } | |
| 2295 #ifdef FEAT_FLOAT | |
| 2296 if (var2.v_type == VAR_FLOAT) | |
| 2297 { | |
| 2298 f2 = var2.vval.v_float; | |
| 2299 n2 = 0; | |
| 2300 } | |
| 2301 else | |
| 2302 #endif | |
| 2303 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
2304 n2 = tv_get_number_chk(&var2, &error); |
| 1624 | 2305 if (error) |
| 2306 { | |
| 2307 clear_tv(rettv); | |
| 2308 clear_tv(&var2); | |
| 2309 return FAIL; | |
| 2310 } | |
| 2311 #ifdef FEAT_FLOAT | |
| 2312 if (rettv->v_type == VAR_FLOAT) | |
| 2313 f2 = n2; | |
| 2314 #endif | |
| 323 | 2315 } |
| 71 | 2316 clear_tv(rettv); |
| 1624 | 2317 |
| 2318 #ifdef FEAT_FLOAT | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2319 // If there is a float on either side the result is a float. |
| 1624 | 2320 if (rettv->v_type == VAR_FLOAT || var2.v_type == VAR_FLOAT) |
| 2321 { | |
| 2322 if (op == '+') | |
| 2323 f1 = f1 + f2; | |
| 2324 else | |
| 2325 f1 = f1 - f2; | |
| 2326 rettv->v_type = VAR_FLOAT; | |
| 2327 rettv->vval.v_float = f1; | |
| 2328 } | |
| 2329 else | |
| 2330 #endif | |
| 2331 { | |
| 2332 if (op == '+') | |
| 2333 n1 = n1 + n2; | |
| 2334 else | |
| 2335 n1 = n1 - n2; | |
| 2336 rettv->v_type = VAR_NUMBER; | |
| 2337 rettv->vval.v_number = n1; | |
| 2338 } | |
| 71 | 2339 } |
| 2340 clear_tv(&var2); | |
| 7 | 2341 } |
| 2342 } | |
| 2343 return OK; | |
| 2344 } | |
| 2345 | |
| 2346 /* | |
| 2347 * Handle fifth level expression: | |
| 2348 * * number multiplication | |
| 2349 * / number division | |
| 2350 * % number modulo | |
| 2351 * | |
| 2352 * "arg" must point to the first non-white of the expression. | |
| 2353 * "arg" is advanced to the next non-white after the recognized expression. | |
| 2354 * | |
| 2355 * Return OK or FAIL. | |
| 2356 */ | |
| 2357 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2358 eval6( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2359 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2360 typval_T *rettv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2361 int evaluate, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2362 int want_string) // after "." operator |
| 7 | 2363 { |
| 137 | 2364 typval_T var2; |
| 7 | 2365 int op; |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
2366 varnumber_T n1, n2; |
| 1624 | 2367 #ifdef FEAT_FLOAT |
| 2368 int use_float = FALSE; | |
|
16405
840fa633ad64
patch 8.1.1207: some compilers give warning messages
Bram Moolenaar <Bram@vim.org>
parents:
16366
diff
changeset
|
2369 float_T f1 = 0, f2 = 0; |
| 1624 | 2370 #endif |
| 323 | 2371 int error = FALSE; |
| 7 | 2372 |
| 2373 /* | |
| 2374 * Get the first variable. | |
| 2375 */ | |
| 1655 | 2376 if (eval7(arg, rettv, evaluate, want_string) == FAIL) |
| 7 | 2377 return FAIL; |
| 2378 | |
| 2379 /* | |
| 2380 * Repeat computing, until no '*', '/' or '%' is following. | |
| 2381 */ | |
| 2382 for (;;) | |
| 2383 { | |
| 2384 op = **arg; | |
|
17387
2558f90045e5
patch 8.1.1692: using *{} for literal dict is not backwards compatible
Bram Moolenaar <Bram@vim.org>
parents:
17377
diff
changeset
|
2385 if (op != '*' && op != '/' && op != '%') |
| 7 | 2386 break; |
| 2387 | |
| 2388 if (evaluate) | |
| 2389 { | |
| 1624 | 2390 #ifdef FEAT_FLOAT |
| 2391 if (rettv->v_type == VAR_FLOAT) | |
| 2392 { | |
| 2393 f1 = rettv->vval.v_float; | |
| 2394 use_float = TRUE; | |
| 2395 n1 = 0; | |
| 2396 } | |
| 2397 else | |
| 2398 #endif | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
2399 n1 = tv_get_number_chk(rettv, &error); |
| 71 | 2400 clear_tv(rettv); |
| 323 | 2401 if (error) |
| 2402 return FAIL; | |
| 7 | 2403 } |
| 2404 else | |
| 2405 n1 = 0; | |
| 2406 | |
| 2407 /* | |
| 2408 * Get the second variable. | |
| 2409 */ | |
| 2410 *arg = skipwhite(*arg + 1); | |
| 1655 | 2411 if (eval7(arg, &var2, evaluate, FALSE) == FAIL) |
| 7 | 2412 return FAIL; |
| 2413 | |
| 2414 if (evaluate) | |
| 2415 { | |
| 1624 | 2416 #ifdef FEAT_FLOAT |
| 2417 if (var2.v_type == VAR_FLOAT) | |
| 2418 { | |
| 2419 if (!use_float) | |
| 2420 { | |
| 2421 f1 = n1; | |
| 2422 use_float = TRUE; | |
| 2423 } | |
| 2424 f2 = var2.vval.v_float; | |
| 2425 n2 = 0; | |
| 2426 } | |
| 2427 else | |
| 2428 #endif | |
| 2429 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
2430 n2 = tv_get_number_chk(&var2, &error); |
| 1624 | 2431 clear_tv(&var2); |
| 2432 if (error) | |
| 2433 return FAIL; | |
| 2434 #ifdef FEAT_FLOAT | |
| 2435 if (use_float) | |
| 2436 f2 = n2; | |
| 2437 #endif | |
| 2438 } | |
| 7 | 2439 |
| 2440 /* | |
| 2441 * Compute the result. | |
| 1624 | 2442 * When either side is a float the result is a float. |
| 7 | 2443 */ |
| 1624 | 2444 #ifdef FEAT_FLOAT |
| 2445 if (use_float) | |
| 2446 { | |
| 2447 if (op == '*') | |
| 2448 f1 = f1 * f2; | |
| 2449 else if (op == '/') | |
| 2450 { | |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2451 # ifdef VMS |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2452 // 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
|
2453 if (f2 == 0.0) |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2454 { |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2455 if (f1 == 0) |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2456 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
|
2457 else if (f1 < 0) |
|
2529
2aaa88366cbb
Fix for float values on VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2513
diff
changeset
|
2458 f1 = -1 * __F_FLT_MAX; |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2459 else |
|
2529
2aaa88366cbb
Fix for float values on VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2513
diff
changeset
|
2460 f1 = __F_FLT_MAX; |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2461 } |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2462 else |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2463 f1 = f1 / f2; |
|
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2464 # else |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2465 // 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
|
2466 // by zero to result in "inf" and not a crash. |
| 1624 | 2467 f1 = f1 / f2; |
|
2441
620a42739426
Improvements for VMS. (Zoltan Arpadffy)
Bram Moolenaar <bram@vim.org>
parents:
2427
diff
changeset
|
2468 # endif |
| 1624 | 2469 } |
| 2470 else | |
| 2471 { | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2472 emsg(_(e_modulus)); |
| 1624 | 2473 return FAIL; |
| 2474 } | |
| 2475 rettv->v_type = VAR_FLOAT; | |
| 2476 rettv->vval.v_float = f1; | |
| 2477 } | |
| 2478 else | |
| 2479 #endif | |
| 2480 { | |
| 2481 if (op == '*') | |
| 2482 n1 = n1 * n2; | |
| 2483 else if (op == '/') | |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
2484 n1 = num_divide(n1, n2); |
| 1624 | 2485 else |
|
15969
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
2486 n1 = num_modulus(n1, n2); |
|
9cc42db77a54
patch 8.1.0990: floating point exception with "%= 0" and "/= 0"
Bram Moolenaar <Bram@vim.org>
parents:
15904
diff
changeset
|
2487 |
| 1624 | 2488 rettv->v_type = VAR_NUMBER; |
| 2489 rettv->vval.v_number = n1; | |
| 2490 } | |
| 7 | 2491 } |
| 2492 } | |
| 2493 | |
| 2494 return OK; | |
| 2495 } | |
| 2496 | |
| 2497 /* | |
| 2498 * Handle sixth level expression: | |
| 2499 * number number constant | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2500 * 0zFFFFFFFF Blob constant |
| 1228 | 2501 * "string" string constant |
| 2502 * 'string' literal string constant | |
| 7 | 2503 * &option-name option value |
| 2504 * @r register contents | |
| 2505 * identifier variable value | |
| 2506 * function() function call | |
| 2507 * $VAR environment variable | |
| 2508 * (expression) nested expression | |
| 151 | 2509 * [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
|
2510 * {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
|
2511 * {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
|
2512 * #{key: val, key: val} Dictionary with literal keys |
| 7 | 2513 * |
| 2514 * Also handle: | |
| 2515 * ! in front logical NOT | |
| 2516 * - in front unary minus | |
| 2517 * + in front unary plus (ignored) | |
| 100 | 2518 * trailing [] subscript in String or List |
| 2519 * 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
|
2520 * trailing ->name() method call |
| 7 | 2521 * |
| 2522 * "arg" must point to the first non-white of the expression. | |
| 2523 * "arg" is advanced to the next non-white after the recognized expression. | |
| 2524 * | |
| 2525 * Return OK or FAIL. | |
| 2526 */ | |
| 2527 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2528 eval7( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2529 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2530 typval_T *rettv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2531 int evaluate, |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2532 int want_string) // after "." operator |
| 7 | 2533 { |
| 2534 int len; | |
| 2535 char_u *s; | |
| 2536 char_u *start_leader, *end_leader; | |
| 2537 int ret = OK; | |
| 2538 char_u *alias; | |
| 2539 | |
| 2540 /* | |
| 71 | 2541 * Initialise variable so that clear_tv() can't mistake this for a |
| 56 | 2542 * string and free a string that isn't there. |
| 7 | 2543 */ |
| 71 | 2544 rettv->v_type = VAR_UNKNOWN; |
| 7 | 2545 |
| 2546 /* | |
|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
10000
diff
changeset
|
2547 * Skip '!', '-' and '+' characters. They are handled later. |
| 7 | 2548 */ |
| 2549 start_leader = *arg; | |
| 2550 while (**arg == '!' || **arg == '-' || **arg == '+') | |
| 2551 *arg = skipwhite(*arg + 1); | |
| 2552 end_leader = *arg; | |
| 2553 | |
|
16223
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2554 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
|
2555 #ifdef FEAT_FLOAT |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2556 || 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
|
2557 #endif |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2558 )) |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2559 { |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2560 semsg(_(e_invexpr2), *arg); |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2561 ++*arg; |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2562 return FAIL; |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2563 } |
|
abb67309c1ca
patch 8.1.1116: cannot enforce a Vim script style
Bram Moolenaar <Bram@vim.org>
parents:
16219
diff
changeset
|
2564 |
| 7 | 2565 switch (**arg) |
| 2566 { | |
| 2567 /* | |
| 2568 * Number constant. | |
| 2569 */ | |
| 2570 case '0': | |
| 2571 case '1': | |
| 2572 case '2': | |
| 2573 case '3': | |
| 2574 case '4': | |
| 2575 case '5': | |
| 2576 case '6': | |
| 2577 case '7': | |
| 2578 case '8': | |
| 2579 case '9': | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2580 case '.': ret = get_number_tv(arg, rettv, evaluate, want_string); |
| 1624 | 2581 break; |
| 7 | 2582 |
| 2583 /* | |
| 2584 * String constant: "string". | |
| 2585 */ | |
| 71 | 2586 case '"': ret = get_string_tv(arg, rettv, evaluate); |
| 7 | 2587 break; |
| 2588 | |
| 2589 /* | |
| 100 | 2590 * Literal string constant: 'str''ing'. |
| 7 | 2591 */ |
| 71 | 2592 case '\'': ret = get_lit_string_tv(arg, rettv, evaluate); |
| 56 | 2593 break; |
| 2594 | |
| 2595 /* | |
| 2596 * List: [expr, expr] | |
| 2597 */ | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2598 case '[': ret = get_list_tv(arg, rettv, evaluate, TRUE); |
| 7 | 2599 break; |
| 2600 | |
| 2601 /* | |
|
17413
40417757dffd
patch 8.1.1705: using ~{} for a literal dict is not nice
Bram Moolenaar <Bram@vim.org>
parents:
17387
diff
changeset
|
2602 * 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
|
2603 */ |
|
17413
40417757dffd
patch 8.1.1705: using ~{} for a literal dict is not nice
Bram Moolenaar <Bram@vim.org>
parents:
17387
diff
changeset
|
2604 case '#': 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
|
2605 { |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
2606 ++*arg; |
|
19047
a3fce2763e83
patch 8.2.0084: complete item "user_data" can only be a string
Bram Moolenaar <Bram@vim.org>
parents:
19017
diff
changeset
|
2607 ret = eval_dict(arg, rettv, evaluate, TRUE); |
|
17368
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
2608 } |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
2609 else |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
2610 ret = NOTDONE; |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
2611 break; |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
2612 |
|
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
17322
diff
changeset
|
2613 /* |
|
9527
e8b3db8e2d30
commit https://github.com/vim/vim/commit/069c1e7fa9f45a665064f7f2c17da84d6a48f544
Christian Brabandt <cb@256bit.org>
parents:
9525
diff
changeset
|
2614 * 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
|
2615 * Dictionary: {'key': val, 'key': val} |
| 100 | 2616 */ |
|
9527
e8b3db8e2d30
commit https://github.com/vim/vim/commit/069c1e7fa9f45a665064f7f2c17da84d6a48f544
Christian Brabandt <cb@256bit.org>
parents:
9525
diff
changeset
|
2617 case '{': ret = get_lambda_tv(arg, rettv, evaluate); |
|
e8b3db8e2d30
commit https://github.com/vim/vim/commit/069c1e7fa9f45a665064f7f2c17da84d6a48f544
Christian Brabandt <cb@256bit.org>
parents:
9525
diff
changeset
|
2618 if (ret == NOTDONE) |
|
19047
a3fce2763e83
patch 8.2.0084: complete item "user_data" can only be a string
Bram Moolenaar <Bram@vim.org>
parents:
19017
diff
changeset
|
2619 ret = eval_dict(arg, rettv, evaluate, FALSE); |
| 100 | 2620 break; |
| 2621 | |
| 2622 /* | |
| 104 | 2623 * Option value: &name |
| 7 | 2624 */ |
| 104 | 2625 case '&': ret = get_option_tv(arg, rettv, evaluate); |
| 7 | 2626 break; |
| 2627 | |
| 2628 /* | |
| 2629 * Environment variable: $VAR. | |
| 2630 */ | |
| 71 | 2631 case '$': ret = get_env_tv(arg, rettv, evaluate); |
| 7 | 2632 break; |
| 2633 | |
| 2634 /* | |
| 2635 * Register contents: @r. | |
| 2636 */ | |
| 2637 case '@': ++*arg; | |
| 2638 if (evaluate) | |
| 2639 { | |
| 71 | 2640 rettv->v_type = VAR_STRING; |
| 5796 | 2641 rettv->vval.v_string = get_reg_contents(**arg, |
| 2642 GREG_EXPR_SRC); | |
| 7 | 2643 } |
| 2644 if (**arg != NUL) | |
| 2645 ++*arg; | |
| 2646 break; | |
| 2647 | |
| 2648 /* | |
| 2649 * nested expression: (expression). | |
| 2650 */ | |
| 2651 case '(': *arg = skipwhite(*arg + 1); | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2652 ret = eval1(arg, rettv, evaluate); // recursive! |
| 7 | 2653 if (**arg == ')') |
| 2654 ++*arg; | |
| 2655 else if (ret == OK) | |
| 2656 { | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2657 emsg(_(e_missing_close)); |
| 71 | 2658 clear_tv(rettv); |
| 7 | 2659 ret = FAIL; |
| 2660 } | |
| 2661 break; | |
| 2662 | |
| 100 | 2663 default: ret = NOTDONE; |
| 2664 break; | |
| 2665 } | |
| 2666 | |
| 2667 if (ret == NOTDONE) | |
| 2668 { | |
| 2669 /* | |
| 2670 * Must be a variable or function name. | |
| 2671 * Can also be a curly-braces kind of name: {expr}. | |
| 2672 */ | |
| 2673 s = *arg; | |
| 159 | 2674 len = get_name_len(arg, &alias, evaluate, TRUE); |
| 100 | 2675 if (alias != NULL) |
| 2676 s = alias; | |
| 2677 | |
| 159 | 2678 if (len <= 0) |
| 100 | 2679 ret = FAIL; |
| 2680 else | |
| 2681 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2682 if (**arg == '(') // recursive! |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2683 ret = eval_func(arg, s, len, rettv, evaluate, NULL); |
| 100 | 2684 else if (evaluate) |
| 6791 | 2685 ret = get_var_tv(s, len, rettv, NULL, TRUE, FALSE); |
| 117 | 2686 else |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
2687 { |
|
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
2688 check_vars(s, len); |
| 117 | 2689 ret = OK; |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
2690 } |
| 100 | 2691 } |
| 2690 | 2692 vim_free(alias); |
| 100 | 2693 } |
| 2694 | |
| 7 | 2695 *arg = skipwhite(*arg); |
| 2696 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2697 // 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
|
2698 // expr(expr), expr->name(expr) |
| 159 | 2699 if (ret == OK) |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2700 ret = handle_subscript(arg, rettv, evaluate, TRUE, |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2701 start_leader, &end_leader); |
| 7 | 2702 |
| 2703 /* | |
| 2704 * Apply logical NOT and unary '-', from right to left, ignore '+'. | |
| 2705 */ | |
| 2706 if (ret == OK && evaluate && end_leader > start_leader) | |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2707 ret = eval7_leader(rettv, start_leader, &end_leader); |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2708 return ret; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2709 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2710 |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2711 /* |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2712 * Apply the leading "!" and "-" before an eval7 expression to "rettv". |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2713 * 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
|
2714 */ |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2715 static int |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2716 eval7_leader(typval_T *rettv, char_u *start_leader, char_u **end_leaderp) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2717 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2718 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
|
2719 int ret = OK; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2720 int error = FALSE; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2721 varnumber_T val = 0; |
| 1624 | 2722 #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
|
2723 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
|
2724 |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2725 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
|
2726 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
|
2727 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2728 #endif |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2729 val = tv_get_number_chk(rettv, &error); |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2730 if (error) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2731 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2732 clear_tv(rettv); |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2733 ret = FAIL; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2734 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2735 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2736 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2737 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
|
2738 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2739 --end_leader; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2740 if (*end_leader == '!') |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2741 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2742 #ifdef FEAT_FLOAT |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2743 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
|
2744 f = !f; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2745 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2746 #endif |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2747 val = !val; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2748 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2749 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
|
2750 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2751 #ifdef FEAT_FLOAT |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2752 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
|
2753 f = -f; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2754 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2755 #endif |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2756 val = -val; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2757 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2758 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2759 #ifdef FEAT_FLOAT |
| 1624 | 2760 if (rettv->v_type == VAR_FLOAT) |
| 323 | 2761 { |
| 2762 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
|
2763 rettv->vval.v_float = f; |
| 323 | 2764 } |
| 2765 else | |
| 1624 | 2766 #endif |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2767 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2768 clear_tv(rettv); |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2769 rettv->v_type = VAR_NUMBER; |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2770 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
|
2771 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2772 } |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
2773 *end_leaderp = end_leader; |
| 7 | 2774 return ret; |
| 2775 } | |
| 2776 | |
| 2777 /* | |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2778 * 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
|
2779 */ |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2780 static int |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2781 call_func_rettv( |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2782 char_u **arg, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2783 typval_T *rettv, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2784 int evaluate, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2785 dict_T *selfdict, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2786 typval_T *basetv) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2787 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2788 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
|
2789 funcexe_T funcexe; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2790 typval_T functv; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2791 char_u *s; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2792 int ret; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2793 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2794 // 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
|
2795 if (evaluate) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2796 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2797 functv = *rettv; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2798 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
|
2799 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2800 // 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
|
2801 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
|
2802 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2803 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
|
2804 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
|
2805 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2806 else |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2807 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
|
2808 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2809 else |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2810 s = (char_u *)""; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2811 |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
2812 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
|
2813 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
|
2814 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
|
2815 funcexe.evaluate = evaluate; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2816 funcexe.partial = pt; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2817 funcexe.selfdict = selfdict; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2818 funcexe.basetv = basetv; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2819 ret = get_func_tv(s, -1, rettv, arg, &funcexe); |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2820 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2821 // 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
|
2822 // 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
|
2823 if (evaluate) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2824 clear_tv(&functv); |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2825 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2826 return ret; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2827 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2828 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2829 /* |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2830 * Evaluate "->method()". |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2831 * "*arg" points to the '-'. |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2832 * 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
|
2833 */ |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2834 static int |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2835 eval_lambda( |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2836 char_u **arg, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2837 typval_T *rettv, |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2838 int evaluate, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2839 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
|
2840 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2841 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
|
2842 int ret; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2843 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2844 // Skip over the ->. |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2845 *arg += 2; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2846 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
|
2847 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2848 ret = get_lambda_tv(arg, rettv, evaluate); |
|
18851
3cf9529b3a4a
patch 8.1.2412: crash when evaluating expression with error
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
2849 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
|
2850 return FAIL; |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2851 else if (**arg != '(') |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2852 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2853 if (verbose) |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2854 { |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2855 if (*skipwhite(*arg) == '(') |
|
19760
9daed26b788b
patch 8.2.0436: no warnings for incorrect printf arguments
Bram Moolenaar <Bram@vim.org>
parents:
19568
diff
changeset
|
2856 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
|
2857 else |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
2858 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
|
2859 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2860 clear_tv(rettv); |
|
18225
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
2861 ret = FAIL; |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2862 } |
|
18225
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
2863 else |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
2864 ret = call_func_rettv(arg, rettv, evaluate, NULL, &base); |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
2865 |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
2866 // 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
|
2867 // 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
|
2868 if (evaluate) |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
2869 clear_tv(&base); |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
2870 |
|
6c3a8312486d
patch 8.1.2107: various memory leaks reported by asan
Bram Moolenaar <Bram@vim.org>
parents:
18080
diff
changeset
|
2871 return ret; |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2872 } |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2873 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2874 /* |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2875 * Evaluate "->method()". |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2876 * "*arg" points to the '-'. |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2877 * 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
|
2878 */ |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2879 static int |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2880 eval_method( |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2881 char_u **arg, |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2882 typval_T *rettv, |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2883 int evaluate, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2884 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
|
2885 { |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2886 char_u *name; |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2887 long len; |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2888 char_u *alias; |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2889 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
|
2890 int ret; |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2891 |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2892 // Skip over the ->. |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2893 *arg += 2; |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2894 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
|
2895 |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2896 name = *arg; |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2897 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
|
2898 if (alias != NULL) |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2899 name = alias; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2900 |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2901 if (len <= 0) |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2902 { |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2903 if (verbose) |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2904 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
|
2905 ret = FAIL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2906 } |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2907 else |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2908 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2909 if (**arg != '(') |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2910 { |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2911 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
|
2912 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
|
2913 ret = FAIL; |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2914 } |
|
17661
da7890e3359b
patch 8.1.1828: not strict enough checking syntax of method invocation
Bram Moolenaar <Bram@vim.org>
parents:
17646
diff
changeset
|
2915 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
|
2916 { |
|
da7890e3359b
patch 8.1.1828: not strict enough checking syntax of method invocation
Bram Moolenaar <Bram@vim.org>
parents:
17646
diff
changeset
|
2917 if (verbose) |
|
19760
9daed26b788b
patch 8.2.0436: no warnings for incorrect printf arguments
Bram Moolenaar <Bram@vim.org>
parents:
19568
diff
changeset
|
2918 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
|
2919 ret = FAIL; |
|
da7890e3359b
patch 8.1.1828: not strict enough checking syntax of method invocation
Bram Moolenaar <Bram@vim.org>
parents:
17646
diff
changeset
|
2920 } |
|
17646
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2921 else |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2922 ret = eval_func(arg, name, len, rettv, evaluate, &base); |
|
e5397617d6ca
patch 8.1.1820: using expr->FuncRef() does not work
Bram Moolenaar <Bram@vim.org>
parents:
17638
diff
changeset
|
2923 } |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2924 |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
2925 // 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
|
2926 // 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
|
2927 if (evaluate) |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2928 clear_tv(&base); |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2929 |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2930 return ret; |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2931 } |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2932 |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
2933 /* |
| 829 | 2934 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key". |
| 2935 * "*arg" points to the '[' or '.'. | |
| 56 | 2936 * Returns FAIL or OK. "*arg" is advanced to after the ']'. |
| 2937 */ | |
| 2938 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2939 eval_index( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2940 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2941 typval_T *rettv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
2942 int evaluate, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2943 int verbose) // give error messages |
| 56 | 2944 { |
| 2945 int empty1 = FALSE, empty2 = FALSE; | |
| 137 | 2946 typval_T var1, var2; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2947 long i; |
| 56 | 2948 long n1, n2 = 0; |
| 100 | 2949 long len = -1; |
| 2950 int range = FALSE; | |
| 56 | 2951 char_u *s; |
| 100 | 2952 char_u *key = NULL; |
| 56 | 2953 |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2954 switch (rettv->v_type) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2955 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2956 case VAR_FUNC: |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
2957 case VAR_PARTIAL: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2958 if (verbose) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
2959 emsg(_("E695: Cannot index a Funcref")); |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2960 return FAIL; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2961 case VAR_FLOAT: |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2962 #ifdef FEAT_FLOAT |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2963 if (verbose) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
2964 emsg(_(e_float_as_string)); |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2965 return FAIL; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2966 #endif |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
2967 case VAR_BOOL: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2968 case VAR_SPECIAL: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
2969 case VAR_JOB: |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
2970 case VAR_CHANNEL: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2971 if (verbose) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
2972 emsg(_("E909: Cannot index a special variable")); |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2973 return FAIL; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2974 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
|
2975 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
|
2976 case VAR_VOID: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2977 if (evaluate) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2978 return FAIL; |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2979 // FALLTHROUGH |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2980 |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2981 case VAR_STRING: |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2982 case VAR_NUMBER: |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2983 case VAR_LIST: |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2984 case VAR_DICT: |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
2985 case VAR_BLOB: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
2986 break; |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
2987 } |
| 56 | 2988 |
|
7046
fd409a0800fd
commit https://github.com/vim/vim/commit/0a38dd29d6f65aa601162542a5ab0ba7f308fc8e
Christian Brabandt <cb@256bit.org>
parents:
7042
diff
changeset
|
2989 init_tv(&var1); |
|
fd409a0800fd
commit https://github.com/vim/vim/commit/0a38dd29d6f65aa601162542a5ab0ba7f308fc8e
Christian Brabandt <cb@256bit.org>
parents:
7042
diff
changeset
|
2990 init_tv(&var2); |
| 100 | 2991 if (**arg == '.') |
| 2992 { | |
| 2993 /* | |
| 2994 * dict.name | |
| 2995 */ | |
| 2996 key = *arg + 1; | |
| 2997 for (len = 0; ASCII_ISALNUM(key[len]) || key[len] == '_'; ++len) | |
| 2998 ; | |
| 2999 if (len == 0) | |
| 3000 return FAIL; | |
| 3001 *arg = skipwhite(key + len); | |
| 3002 } | |
| 3003 else | |
| 3004 { | |
| 3005 /* | |
| 3006 * something[idx] | |
| 3007 * | |
| 3008 * Get the (first) variable from inside the []. | |
| 3009 */ | |
| 56 | 3010 *arg = skipwhite(*arg + 1); |
| 100 | 3011 if (**arg == ':') |
| 3012 empty1 = TRUE; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3013 else if (eval1(arg, &var1, evaluate) == FAIL) // recursive! |
| 56 | 3014 return FAIL; |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3015 else if (evaluate && tv_get_string_chk(&var1) == NULL) |
| 323 | 3016 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3017 // not a number or string |
| 323 | 3018 clear_tv(&var1); |
| 3019 return FAIL; | |
| 3020 } | |
| 100 | 3021 |
| 3022 /* | |
| 3023 * Get the second variable from inside the [:]. | |
| 3024 */ | |
| 3025 if (**arg == ':') | |
| 3026 { | |
| 3027 range = TRUE; | |
| 3028 *arg = skipwhite(*arg + 1); | |
| 3029 if (**arg == ']') | |
| 3030 empty2 = TRUE; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3031 else if (eval1(arg, &var2, evaluate) == FAIL) // recursive! |
| 100 | 3032 { |
| 323 | 3033 if (!empty1) |
| 3034 clear_tv(&var1); | |
| 3035 return FAIL; | |
| 3036 } | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3037 else if (evaluate && tv_get_string_chk(&var2) == NULL) |
| 323 | 3038 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3039 // not a number or string |
| 323 | 3040 if (!empty1) |
| 3041 clear_tv(&var1); | |
| 3042 clear_tv(&var2); | |
| 100 | 3043 return FAIL; |
| 3044 } | |
| 3045 } | |
| 3046 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3047 // Check for the ']'. |
| 100 | 3048 if (**arg != ']') |
| 3049 { | |
| 159 | 3050 if (verbose) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
3051 emsg(_(e_missbrac)); |
| 100 | 3052 clear_tv(&var1); |
| 3053 if (range) | |
| 3054 clear_tv(&var2); | |
| 3055 return FAIL; | |
| 3056 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3057 *arg = skipwhite(*arg + 1); // skip the ']' |
| 56 | 3058 } |
| 3059 | |
| 3060 if (evaluate) | |
| 3061 { | |
| 100 | 3062 n1 = 0; |
| 3063 if (!empty1 && rettv->v_type != VAR_DICT) | |
| 56 | 3064 { |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3065 n1 = tv_get_number(&var1); |
| 71 | 3066 clear_tv(&var1); |
| 56 | 3067 } |
| 3068 if (range) | |
| 3069 { | |
| 3070 if (empty2) | |
| 3071 n2 = -1; | |
| 3072 else | |
| 3073 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3074 n2 = tv_get_number(&var2); |
| 71 | 3075 clear_tv(&var2); |
| 3076 } | |
| 3077 } | |
| 3078 | |
| 3079 switch (rettv->v_type) | |
| 56 | 3080 { |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3081 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
|
3082 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
|
3083 case VAR_VOID: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
3084 case VAR_FUNC: |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
3085 case VAR_PARTIAL: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
3086 case VAR_FLOAT: |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
3087 case VAR_BOOL: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3088 case VAR_SPECIAL: |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3089 case VAR_JOB: |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
3090 case VAR_CHANNEL: |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3091 break; // not evaluating, skipping over subscript |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
3092 |
| 56 | 3093 case VAR_NUMBER: |
| 3094 case VAR_STRING: | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3095 s = tv_get_string(rettv); |
| 56 | 3096 len = (long)STRLEN(s); |
| 3097 if (range) | |
| 3098 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3099 // 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
|
3100 // are out of range the result is empty. |
| 56 | 3101 if (n1 < 0) |
| 3102 { | |
| 3103 n1 = len + n1; | |
| 3104 if (n1 < 0) | |
| 3105 n1 = 0; | |
| 3106 } | |
| 3107 if (n2 < 0) | |
| 3108 n2 = len + n2; | |
| 3109 else if (n2 >= len) | |
| 3110 n2 = len; | |
| 3111 if (n1 >= len || n2 < 0 || n1 > n2) | |
| 3112 s = NULL; | |
| 3113 else | |
| 3114 s = vim_strnsave(s + n1, (int)(n2 - n1 + 1)); | |
| 3115 } | |
| 3116 else | |
| 3117 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3118 // 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
|
3119 // 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
|
3120 // result is empty. |
| 56 | 3121 if (n1 >= len || n1 < 0) |
| 3122 s = NULL; | |
| 3123 else | |
| 3124 s = vim_strnsave(s + n1, 1); | |
| 3125 } | |
| 71 | 3126 clear_tv(rettv); |
| 3127 rettv->v_type = VAR_STRING; | |
| 3128 rettv->vval.v_string = s; | |
| 56 | 3129 break; |
| 3130 | |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3131 case VAR_BLOB: |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3132 len = blob_len(rettv->vval.v_blob); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3133 if (range) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3134 { |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
3135 // The resulting variable is a sub-blob. If the indexes |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3136 // are out of range the result is empty. |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3137 if (n1 < 0) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3138 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3139 n1 = len + n1; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3140 if (n1 < 0) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3141 n1 = 0; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3142 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3143 if (n2 < 0) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3144 n2 = len + n2; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3145 else if (n2 >= len) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3146 n2 = len - 1; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3147 if (n1 >= len || n2 < 0 || n1 > n2) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3148 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3149 clear_tv(rettv); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3150 rettv->v_type = VAR_BLOB; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3151 rettv->vval.v_blob = NULL; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3152 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3153 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3154 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3155 blob_T *blob = blob_alloc(); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3156 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3157 if (blob != NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3158 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3159 if (ga_grow(&blob->bv_ga, n2 - n1 + 1) == FAIL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3160 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3161 blob_free(blob); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3162 return FAIL; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3163 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3164 blob->bv_ga.ga_len = n2 - n1 + 1; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3165 for (i = n1; i <= n2; i++) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3166 blob_set(blob, i - n1, |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3167 blob_get(rettv->vval.v_blob, i)); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3168 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3169 clear_tv(rettv); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3170 rettv_blob_set(rettv, blob); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3171 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3172 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3173 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3174 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3175 { |
|
15589
44ea60ca593b
patch 8.1.0802: negative index doesn't work for Blob
Bram Moolenaar <Bram@vim.org>
parents:
15581
diff
changeset
|
3176 // The resulting variable is a byte value. |
|
44ea60ca593b
patch 8.1.0802: negative index doesn't work for Blob
Bram Moolenaar <Bram@vim.org>
parents:
15581
diff
changeset
|
3177 // If the index is too big or negative that is an error. |
|
44ea60ca593b
patch 8.1.0802: negative index doesn't work for Blob
Bram Moolenaar <Bram@vim.org>
parents:
15581
diff
changeset
|
3178 if (n1 < 0) |
|
44ea60ca593b
patch 8.1.0802: negative index doesn't work for Blob
Bram Moolenaar <Bram@vim.org>
parents:
15581
diff
changeset
|
3179 n1 = len + n1; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3180 if (n1 < len && n1 >= 0) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3181 { |
|
15589
44ea60ca593b
patch 8.1.0802: negative index doesn't work for Blob
Bram Moolenaar <Bram@vim.org>
parents:
15581
diff
changeset
|
3182 int v = blob_get(rettv->vval.v_blob, n1); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3183 |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3184 clear_tv(rettv); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3185 rettv->v_type = VAR_NUMBER; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3186 rettv->vval.v_number = v; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3187 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3188 else |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
3189 semsg(_(e_blobidx), n1); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3190 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3191 break; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3192 |
| 56 | 3193 case VAR_LIST: |
| 71 | 3194 len = list_len(rettv->vval.v_list); |
| 56 | 3195 if (n1 < 0) |
| 3196 n1 = len + n1; | |
| 3197 if (!empty1 && (n1 < 0 || n1 >= len)) | |
| 3198 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3199 // For a range we allow invalid values and return an empty |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3200 // list. A list index out of range is an error. |
| 842 | 3201 if (!range) |
| 3202 { | |
| 3203 if (verbose) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
3204 semsg(_(e_listidx), n1); |
| 842 | 3205 return FAIL; |
| 3206 } | |
| 3207 n1 = len; | |
| 56 | 3208 } |
| 3209 if (range) | |
| 3210 { | |
| 137 | 3211 list_T *l; |
| 3212 listitem_T *item; | |
| 56 | 3213 |
| 3214 if (n2 < 0) | |
| 3215 n2 = len + n2; | |
| 829 | 3216 else if (n2 >= len) |
| 3217 n2 = len - 1; | |
| 3218 if (!empty2 && (n2 < 0 || n2 + 1 < n1)) | |
| 842 | 3219 n2 = -1; |
| 56 | 3220 l = list_alloc(); |
| 3221 if (l == NULL) | |
| 3222 return FAIL; | |
| 71 | 3223 for (item = list_find(rettv->vval.v_list, n1); |
| 56 | 3224 n1 <= n2; ++n1) |
| 3225 { | |
| 3226 if (list_append_tv(l, &item->li_tv) == FAIL) | |
| 3227 { | |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
3228 list_free(l); |
| 56 | 3229 return FAIL; |
| 3230 } | |
| 3231 item = item->li_next; | |
| 3232 } | |
| 71 | 3233 clear_tv(rettv); |
|
11418
162bcd0debd7
patch 8.0.0593: duplication of code for adding a list or dict return value
Christian Brabandt <cb@256bit.org>
parents:
11412
diff
changeset
|
3234 rettv_list_set(rettv, l); |
| 56 | 3235 } |
| 3236 else | |
| 3237 { | |
| 842 | 3238 copy_tv(&list_find(rettv->vval.v_list, n1)->li_tv, &var1); |
| 71 | 3239 clear_tv(rettv); |
| 3240 *rettv = var1; | |
| 56 | 3241 } |
| 3242 break; | |
| 100 | 3243 |
| 3244 case VAR_DICT: | |
| 3245 if (range) | |
| 3246 { | |
| 159 | 3247 if (verbose) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
3248 emsg(_(e_dictrange)); |
| 100 | 3249 if (len == -1) |
| 3250 clear_tv(&var1); | |
| 3251 return FAIL; | |
| 3252 } | |
| 3253 { | |
| 137 | 3254 dictitem_T *item; |
| 100 | 3255 |
| 3256 if (len == -1) | |
| 3257 { | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3258 key = tv_get_string_chk(&var1); |
|
8839
9fa567d13551
commit https://github.com/vim/vim/commit/0921ecff1c5a74541bad6c073e8ade32247403d8
Christian Brabandt <cb@256bit.org>
parents:
8831
diff
changeset
|
3259 if (key == NULL) |
| 100 | 3260 { |
| 3261 clear_tv(&var1); | |
| 3262 return FAIL; | |
| 3263 } | |
| 3264 } | |
| 3265 | |
| 121 | 3266 item = dict_find(rettv->vval.v_dict, key, (int)len); |
| 100 | 3267 |
| 159 | 3268 if (item == NULL && verbose) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
3269 semsg(_(e_dictkey), key); |
| 100 | 3270 if (len == -1) |
| 3271 clear_tv(&var1); | |
| 3272 if (item == NULL) | |
| 3273 return FAIL; | |
| 3274 | |
| 3275 copy_tv(&item->di_tv, &var1); | |
| 3276 clear_tv(rettv); | |
| 3277 *rettv = var1; | |
| 3278 } | |
| 3279 break; | |
| 3280 } | |
| 3281 } | |
| 3282 | |
| 56 | 3283 return OK; |
| 3284 } | |
| 3285 | |
| 3286 /* | |
| 7 | 3287 * Get an option value. |
| 3288 * "arg" points to the '&' or '+' before the option name. | |
| 3289 * "arg" is advanced to character after the option name. | |
| 3290 * Return OK or FAIL. | |
| 3291 */ | |
|
9571
5eaa708ab50d
commit https://github.com/vim/vim/commit/73dad1e64cb42842d8259cb1a255a6fa59822f76
Christian Brabandt <cb@256bit.org>
parents:
9562
diff
changeset
|
3292 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3293 get_option_tv( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3294 char_u **arg, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3295 typval_T *rettv, // when NULL, only check if option exists |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3296 int evaluate) |
| 7 | 3297 { |
| 3298 char_u *option_end; | |
| 3299 long numval; | |
| 3300 char_u *stringval; | |
| 3301 int opt_type; | |
| 3302 int c; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3303 int working = (**arg == '+'); // has("+option") |
| 7 | 3304 int ret = OK; |
| 3305 int opt_flags; | |
| 3306 | |
| 3307 /* | |
| 3308 * Isolate the option name and find its value. | |
| 3309 */ | |
| 3310 option_end = find_option_end(arg, &opt_flags); | |
| 3311 if (option_end == NULL) | |
| 3312 { | |
| 71 | 3313 if (rettv != NULL) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
3314 semsg(_("E112: Option name missing: %s"), *arg); |
| 7 | 3315 return FAIL; |
| 3316 } | |
| 3317 | |
| 3318 if (!evaluate) | |
| 3319 { | |
| 3320 *arg = option_end; | |
| 3321 return OK; | |
| 3322 } | |
| 3323 | |
| 3324 c = *option_end; | |
| 3325 *option_end = NUL; | |
| 3326 opt_type = get_option_value(*arg, &numval, | |
| 71 | 3327 rettv == NULL ? NULL : &stringval, opt_flags); |
| 7 | 3328 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3329 if (opt_type == -3) // invalid name |
| 7 | 3330 { |
| 71 | 3331 if (rettv != NULL) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3332 semsg(_(e_unknown_option), *arg); |
| 7 | 3333 ret = FAIL; |
| 3334 } | |
| 71 | 3335 else if (rettv != NULL) |
| 7 | 3336 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3337 if (opt_type == -2) // hidden string option |
| 7 | 3338 { |
| 71 | 3339 rettv->v_type = VAR_STRING; |
| 3340 rettv->vval.v_string = NULL; | |
| 7 | 3341 } |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3342 else if (opt_type == -1) // hidden number option |
| 7 | 3343 { |
| 71 | 3344 rettv->v_type = VAR_NUMBER; |
| 3345 rettv->vval.v_number = 0; | |
| 7 | 3346 } |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3347 else if (opt_type == 1) // number option |
| 7 | 3348 { |
| 71 | 3349 rettv->v_type = VAR_NUMBER; |
| 3350 rettv->vval.v_number = numval; | |
| 7 | 3351 } |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3352 else // string option |
| 7 | 3353 { |
| 71 | 3354 rettv->v_type = VAR_STRING; |
| 3355 rettv->vval.v_string = stringval; | |
| 7 | 3356 } |
| 3357 } | |
| 3358 else if (working && (opt_type == -2 || opt_type == -1)) | |
| 3359 ret = FAIL; | |
| 3360 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3361 *option_end = c; // put back for error messages |
| 7 | 3362 *arg = option_end; |
| 3363 | |
| 3364 return ret; | |
| 3365 } | |
| 3366 | |
| 3367 /* | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3368 * Allocate a variable for a number constant. Also deals with "0z" for blob. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3369 * Return 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
|
3370 */ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3371 int |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3372 get_number_tv( |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3373 char_u **arg, |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3374 typval_T *rettv, |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3375 int evaluate, |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3376 int want_string UNUSED) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3377 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3378 int len; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3379 #ifdef FEAT_FLOAT |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3380 char_u *p; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3381 int get_float = FALSE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3382 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3383 // We accept a float when the format matches |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3384 // "[0-9]\+\.[0-9]\+\([eE][+-]\?[0-9]\+\)\?". This is very |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3385 // strict to avoid backwards compatibility problems. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3386 // With script version 2 and later the leading digit can be |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3387 // omitted. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3388 // Don't look for a float after the "." operator, so that |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3389 // ":let vers = 1.2.3" doesn't fail. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3390 if (**arg == '.') |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3391 p = *arg; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3392 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3393 p = skipdigits(*arg + 1); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3394 if (!want_string && p[0] == '.' && vim_isdigit(p[1])) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3395 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3396 get_float = TRUE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3397 p = skipdigits(p + 2); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3398 if (*p == 'e' || *p == 'E') |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3399 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3400 ++p; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3401 if (*p == '-' || *p == '+') |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3402 ++p; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3403 if (!vim_isdigit(*p)) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3404 get_float = FALSE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3405 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3406 p = skipdigits(p + 1); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3407 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3408 if (ASCII_ISALPHA(*p) || *p == '.') |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3409 get_float = FALSE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3410 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3411 if (get_float) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3412 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3413 float_T f; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3414 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3415 *arg += string2float(*arg, &f); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3416 if (evaluate) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3417 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3418 rettv->v_type = VAR_FLOAT; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3419 rettv->vval.v_float = f; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3420 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3421 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3422 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3423 #endif |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3424 if (**arg == '0' && ((*arg)[1] == 'z' || (*arg)[1] == 'Z')) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3425 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3426 char_u *bp; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3427 blob_T *blob = NULL; // init for gcc |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3428 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3429 // Blob constant: 0z0123456789abcdef |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3430 if (evaluate) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3431 blob = blob_alloc(); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3432 for (bp = *arg + 2; vim_isxdigit(bp[0]); bp += 2) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3433 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3434 if (!vim_isxdigit(bp[1])) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3435 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3436 if (blob != NULL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3437 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3438 emsg(_("E973: Blob literal should have an even number of hex characters")); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3439 ga_clear(&blob->bv_ga); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3440 VIM_CLEAR(blob); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3441 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3442 return FAIL; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3443 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3444 if (blob != NULL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3445 ga_append(&blob->bv_ga, |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3446 (hex2nr(*bp) << 4) + hex2nr(*(bp+1))); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3447 if (bp[2] == '.' && vim_isxdigit(bp[3])) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3448 ++bp; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3449 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3450 if (blob != NULL) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3451 rettv_blob_set(rettv, blob); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3452 *arg = bp; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3453 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3454 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3455 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3456 varnumber_T n; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3457 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3458 // decimal, hex or octal number |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3459 vim_str2nr(*arg, NULL, &len, current_sctx.sc_version >= 4 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3460 ? STR2NR_NO_OCT + STR2NR_QUOTE |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3461 : STR2NR_ALL, &n, NULL, 0, TRUE); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3462 if (len == 0) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3463 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3464 semsg(_(e_invexpr2), *arg); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3465 return FAIL; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3466 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3467 *arg += len; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3468 if (evaluate) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3469 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3470 rettv->v_type = VAR_NUMBER; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3471 rettv->vval.v_number = n; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3472 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3473 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3474 return OK; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3475 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3476 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3477 /* |
| 7 | 3478 * Allocate a variable for a string constant. |
| 3479 * Return OK or FAIL. | |
| 3480 */ | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3481 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3482 get_string_tv(char_u **arg, typval_T *rettv, int evaluate) |
| 7 | 3483 { |
| 3484 char_u *p; | |
| 3485 char_u *name; | |
| 3486 int extra = 0; | |
| 3487 | |
| 3488 /* | |
| 3489 * Find the end of the string, skipping backslashed characters. | |
| 3490 */ | |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10964
diff
changeset
|
3491 for (p = *arg + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p)) |
| 7 | 3492 { |
| 3493 if (*p == '\\' && p[1] != NUL) | |
| 3494 { | |
| 3495 ++p; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3496 // A "\<x>" form occupies at least 4 characters, and produces up |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3497 // to 6 characters: reserve space for 2 extra |
| 7 | 3498 if (*p == '<') |
| 3499 extra += 2; | |
| 3500 } | |
| 3501 } | |
| 3502 | |
| 3503 if (*p != '"') | |
| 3504 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
3505 semsg(_("E114: Missing quote: %s"), *arg); |
| 7 | 3506 return FAIL; |
| 3507 } | |
| 3508 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3509 // If only parsing, set *arg and return here |
| 7 | 3510 if (!evaluate) |
| 3511 { | |
| 3512 *arg = p + 1; | |
| 3513 return OK; | |
| 3514 } | |
| 3515 | |
| 3516 /* | |
| 3517 * Copy the string into allocated memory, handling backslashed | |
| 3518 * characters. | |
| 3519 */ | |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16706
diff
changeset
|
3520 name = alloc(p - *arg + extra); |
| 7 | 3521 if (name == NULL) |
| 3522 return FAIL; | |
| 100 | 3523 rettv->v_type = VAR_STRING; |
| 3524 rettv->vval.v_string = name; | |
| 3525 | |
| 3526 for (p = *arg + 1; *p != NUL && *p != '"'; ) | |
| 7 | 3527 { |
| 3528 if (*p == '\\') | |
| 3529 { | |
| 3530 switch (*++p) | |
| 3531 { | |
| 100 | 3532 case 'b': *name++ = BS; ++p; break; |
| 3533 case 'e': *name++ = ESC; ++p; break; | |
| 3534 case 'f': *name++ = FF; ++p; break; | |
| 3535 case 'n': *name++ = NL; ++p; break; | |
| 3536 case 'r': *name++ = CAR; ++p; break; | |
| 3537 case 't': *name++ = TAB; ++p; break; | |
| 7 | 3538 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3539 case 'X': // hex: "\x1", "\x12" |
| 7 | 3540 case 'x': |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3541 case 'u': // Unicode: "\u0023" |
| 7 | 3542 case 'U': |
| 3543 if (vim_isxdigit(p[1])) | |
| 3544 { | |
| 3545 int n, nr; | |
| 3546 int c = toupper(*p); | |
| 3547 | |
| 3548 if (c == 'X') | |
| 3549 n = 2; | |
| 6836 | 3550 else if (*p == 'u') |
| 3551 n = 4; | |
| 7 | 3552 else |
| 6836 | 3553 n = 8; |
| 7 | 3554 nr = 0; |
| 3555 while (--n >= 0 && vim_isxdigit(p[1])) | |
| 3556 { | |
| 3557 ++p; | |
| 3558 nr = (nr << 4) + hex2nr(*p); | |
| 3559 } | |
| 100 | 3560 ++p; |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3561 // For "\u" store the number according to |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3562 // 'encoding'. |
| 7 | 3563 if (c != 'X') |
| 100 | 3564 name += (*mb_char2bytes)(nr, name); |
| 7 | 3565 else |
| 100 | 3566 *name++ = nr; |
| 7 | 3567 } |
| 3568 break; | |
| 3569 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3570 // octal: "\1", "\12", "\123" |
| 7 | 3571 case '0': |
| 3572 case '1': | |
| 3573 case '2': | |
| 3574 case '3': | |
| 3575 case '4': | |
| 3576 case '5': | |
| 3577 case '6': | |
| 100 | 3578 case '7': *name = *p++ - '0'; |
| 3579 if (*p >= '0' && *p <= '7') | |
| 7 | 3580 { |
| 100 | 3581 *name = (*name << 3) + *p++ - '0'; |
| 3582 if (*p >= '0' && *p <= '7') | |
| 3583 *name = (*name << 3) + *p++ - '0'; | |
| 7 | 3584 } |
| 100 | 3585 ++name; |
| 7 | 3586 break; |
| 3587 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3588 // Special key, e.g.: "\<C-W>" |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18251
diff
changeset
|
3589 case '<': extra = trans_special(&p, name, TRUE, TRUE, |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18251
diff
changeset
|
3590 TRUE, NULL); |
| 7 | 3591 if (extra != 0) |
| 3592 { | |
| 100 | 3593 name += extra; |
| 7 | 3594 break; |
| 3595 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3596 // FALLTHROUGH |
| 7 | 3597 |
| 100 | 3598 default: MB_COPY_CHAR(p, name); |
| 7 | 3599 break; |
| 3600 } | |
| 3601 } | |
| 3602 else | |
| 100 | 3603 MB_COPY_CHAR(p, name); |
| 3604 | |
| 3605 } | |
| 3606 *name = NUL; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3607 if (*p != NUL) // just in case |
|
9965
b329e3ca0dcb
commit https://github.com/vim/vim/commit/db249f26edf7a5f88d1f4468d08ec5b84f5ab7ad
Christian Brabandt <cb@256bit.org>
parents:
9915
diff
changeset
|
3608 ++p; |
|
b329e3ca0dcb
commit https://github.com/vim/vim/commit/db249f26edf7a5f88d1f4468d08ec5b84f5ab7ad
Christian Brabandt <cb@256bit.org>
parents:
9915
diff
changeset
|
3609 *arg = p; |
| 7 | 3610 |
| 3611 return OK; | |
| 3612 } | |
| 3613 | |
| 3614 /* | |
| 100 | 3615 * Allocate a variable for a 'str''ing' constant. |
| 7 | 3616 * Return OK or FAIL. |
| 3617 */ | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3618 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3619 get_lit_string_tv(char_u **arg, typval_T *rettv, int evaluate) |
| 7 | 3620 { |
| 3621 char_u *p; | |
| 100 | 3622 char_u *str; |
| 3623 int reduce = 0; | |
| 7 | 3624 |
| 3625 /* | |
| 100 | 3626 * Find the end of the string, skipping ''. |
| 7 | 3627 */ |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10964
diff
changeset
|
3628 for (p = *arg + 1; *p != NUL; MB_PTR_ADV(p)) |
| 100 | 3629 { |
| 3630 if (*p == '\'') | |
| 3631 { | |
| 3632 if (p[1] != '\'') | |
| 3633 break; | |
| 3634 ++reduce; | |
| 3635 ++p; | |
| 3636 } | |
| 3637 } | |
| 3638 | |
| 3639 if (*p != '\'') | |
| 7 | 3640 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
3641 semsg(_("E115: Missing quote: %s"), *arg); |
| 7 | 3642 return FAIL; |
| 3643 } | |
| 3644 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3645 // If only parsing return after setting "*arg" |
| 97 | 3646 if (!evaluate) |
| 3647 { | |
| 3648 *arg = p + 1; | |
| 3649 return OK; | |
| 3650 } | |
| 3651 | |
| 3652 /* | |
| 100 | 3653 * Copy the string into allocated memory, handling '' to ' reduction. |
| 97 | 3654 */ |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16706
diff
changeset
|
3655 str = alloc((p - *arg) - reduce); |
| 97 | 3656 if (str == NULL) |
| 3657 return FAIL; | |
| 100 | 3658 rettv->v_type = VAR_STRING; |
| 3659 rettv->vval.v_string = str; | |
| 3660 | |
| 3661 for (p = *arg + 1; *p != NUL; ) | |
| 3662 { | |
| 3663 if (*p == '\'') | |
| 3664 { | |
| 3665 if (p[1] != '\'') | |
| 97 | 3666 break; |
| 3667 ++p; | |
| 3668 } | |
| 100 | 3669 MB_COPY_CHAR(p, str); |
| 3670 } | |
| 3671 *str = NUL; | |
| 97 | 3672 *arg = p + 1; |
| 3673 | |
| 3674 return OK; | |
| 3675 } | |
| 3676 | |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3677 /* |
|
19922
1f42c49c3d29
patch 8.2.0517: Vim9: cannot separate "func" and "func(): void"
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
3678 * 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
|
3679 */ |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3680 char_u * |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3681 partial_name(partial_T *pt) |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3682 { |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3683 if (pt->pt_name != NULL) |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3684 return pt->pt_name; |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3685 return pt->pt_func->uf_name; |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3686 } |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3687 |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3688 static void |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
3689 partial_free(partial_T *pt) |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3690 { |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3691 int i; |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3692 |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3693 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
|
3694 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
|
3695 vim_free(pt->pt_argv); |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
3696 dict_unref(pt->pt_dict); |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3697 if (pt->pt_name != NULL) |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3698 { |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3699 func_unref(pt->pt_name); |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3700 vim_free(pt->pt_name); |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3701 } |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3702 else |
|
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3703 func_ptr_unref(pt->pt_func); |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3704 vim_free(pt); |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3705 } |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3706 |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3707 /* |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3708 * 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
|
3709 * becomes zero. |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3710 */ |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3711 void |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3712 partial_unref(partial_T *pt) |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3713 { |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3714 if (pt != NULL && --pt->pt_refcount <= 0) |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
3715 partial_free(pt); |
|
8855
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3716 } |
|
b76195a1e38e
commit https://github.com/vim/vim/commit/ddecc25947dbdd689d5bcaed32f298a08abdd497
Christian Brabandt <cb@256bit.org>
parents:
8839
diff
changeset
|
3717 |
| 2634 | 3718 static int tv_equal_recurse_limit; |
| 3719 | |
|
9183
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3720 static int |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3721 func_equal( |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3722 typval_T *tv1, |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3723 typval_T *tv2, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3724 int ic) // ignore case |
|
9183
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3725 { |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3726 char_u *s1, *s2; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3727 dict_T *d1, *d2; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3728 int a1, a2; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3729 int i; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3730 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3731 // empty and NULL function name considered the same |
|
9183
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3732 s1 = tv1->v_type == VAR_FUNC ? tv1->vval.v_string |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3733 : partial_name(tv1->vval.v_partial); |
|
9183
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3734 if (s1 != NULL && *s1 == NUL) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3735 s1 = NULL; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3736 s2 = tv2->v_type == VAR_FUNC ? tv2->vval.v_string |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
3737 : partial_name(tv2->vval.v_partial); |
|
9183
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3738 if (s2 != NULL && *s2 == NUL) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3739 s2 = NULL; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3740 if (s1 == NULL || s2 == NULL) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3741 { |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3742 if (s1 != s2) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3743 return FALSE; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3744 } |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3745 else if (STRCMP(s1, s2) != 0) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3746 return FALSE; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3747 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3748 // empty dict and NULL dict is different |
|
9183
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3749 d1 = tv1->v_type == VAR_FUNC ? NULL : tv1->vval.v_partial->pt_dict; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3750 d2 = tv2->v_type == VAR_FUNC ? NULL : tv2->vval.v_partial->pt_dict; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3751 if (d1 == NULL || d2 == NULL) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3752 { |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3753 if (d1 != d2) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3754 return FALSE; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3755 } |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3756 else if (!dict_equal(d1, d2, ic, TRUE)) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3757 return FALSE; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3758 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3759 // empty list and no list considered the same |
|
9183
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3760 a1 = tv1->v_type == VAR_FUNC ? 0 : tv1->vval.v_partial->pt_argc; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3761 a2 = tv2->v_type == VAR_FUNC ? 0 : tv2->vval.v_partial->pt_argc; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3762 if (a1 != a2) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3763 return FALSE; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3764 for (i = 0; i < a1; ++i) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3765 if (!tv_equal(tv1->vval.v_partial->pt_argv + i, |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3766 tv2->vval.v_partial->pt_argv + i, ic, TRUE)) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3767 return FALSE; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3768 |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3769 return TRUE; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3770 } |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3771 |
| 117 | 3772 /* |
| 80 | 3773 * Return TRUE if "tv1" and "tv2" have the same value. |
| 388 | 3774 * Compares the items just like "==" would compare them, but strings and |
| 1624 | 3775 * numbers are different. Floats and numbers are also different. |
| 80 | 3776 */ |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
3777 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3778 tv_equal( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3779 typval_T *tv1, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3780 typval_T *tv2, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3781 int ic, // ignore case |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3782 int recursive) // TRUE when used recursively |
| 80 | 3783 { |
| 3784 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; | |
| 323 | 3785 char_u *s1, *s2; |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3786 static int recursive_cnt = 0; // catch recursive loops |
| 1008 | 3787 int r; |
| 3788 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3789 // Catch lists and dicts that have an endless loop by limiting |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3790 // recursiveness to a limit. We guess they are equal then. |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3791 // A fixed limit has the problem of still taking an awful long time. |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3792 // Reduce the limit every time running into it. That should work fine for |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3793 // deeply linked structures that are not recursively linked and catch |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3794 // recursiveness quickly. |
| 2634 | 3795 if (!recursive) |
| 3796 tv_equal_recurse_limit = 1000; | |
| 3797 if (recursive_cnt >= tv_equal_recurse_limit) | |
| 3798 { | |
| 3799 --tv_equal_recurse_limit; | |
| 1014 | 3800 return TRUE; |
| 2634 | 3801 } |
| 388 | 3802 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3803 // For VAR_FUNC and VAR_PARTIAL compare the function name, bound dict and |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3804 // arguments. |
|
9183
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3805 if ((tv1->v_type == VAR_FUNC |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3806 || (tv1->v_type == VAR_PARTIAL && tv1->vval.v_partial != NULL)) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3807 && (tv2->v_type == VAR_FUNC |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3808 || (tv2->v_type == VAR_PARTIAL && tv2->vval.v_partial != NULL))) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3809 { |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3810 ++recursive_cnt; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3811 r = func_equal(tv1, tv2, ic); |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3812 --recursive_cnt; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3813 return r; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3814 } |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3815 |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3816 if (tv1->v_type != tv2->v_type) |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3817 return FALSE; |
|
988c8ab557bf
commit https://github.com/vim/vim/commit/8e759ba8651428995b338b66c615367259f79766
Christian Brabandt <cb@256bit.org>
parents:
9169
diff
changeset
|
3818 |
| 388 | 3819 switch (tv1->v_type) |
| 3820 { | |
| 3821 case VAR_LIST: | |
| 2634 | 3822 ++recursive_cnt; |
| 3823 r = list_equal(tv1->vval.v_list, tv2->vval.v_list, ic, TRUE); | |
| 3824 --recursive_cnt; | |
| 1008 | 3825 return r; |
| 388 | 3826 |
| 3827 case VAR_DICT: | |
| 2634 | 3828 ++recursive_cnt; |
| 3829 r = dict_equal(tv1->vval.v_dict, tv2->vval.v_dict, ic, TRUE); | |
| 3830 --recursive_cnt; | |
| 1008 | 3831 return r; |
| 388 | 3832 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3833 case VAR_BLOB: |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3834 return blob_equal(tv1->vval.v_blob, tv2->vval.v_blob); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
3835 |
| 388 | 3836 case VAR_NUMBER: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3837 case VAR_BOOL: |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3838 case VAR_SPECIAL: |
| 388 | 3839 return tv1->vval.v_number == tv2->vval.v_number; |
| 3840 | |
| 3841 case VAR_STRING: | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3842 s1 = tv_get_string_buf(tv1, buf1); |
|
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
3843 s2 = tv_get_string_buf(tv2, buf2); |
| 388 | 3844 return ((ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2)) == 0); |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3845 |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3846 case VAR_FLOAT: |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3847 #ifdef FEAT_FLOAT |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3848 return tv1->vval.v_float == tv2->vval.v_float; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3849 #endif |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3850 case VAR_JOB: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
3851 #ifdef FEAT_JOB_CHANNEL |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3852 return tv1->vval.v_job == tv2->vval.v_job; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3853 #endif |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
3854 case VAR_CHANNEL: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
3855 #ifdef FEAT_JOB_CHANNEL |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
3856 return tv1->vval.v_channel == tv2->vval.v_channel; |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
3857 #endif |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
3858 |
|
19874
f92435f0f449
patch 8.2.0493: Vim9: some error messages not tested
Bram Moolenaar <Bram@vim.org>
parents:
19760
diff
changeset
|
3859 case VAR_PARTIAL: |
|
f92435f0f449
patch 8.2.0493: Vim9: some error messages not tested
Bram Moolenaar <Bram@vim.org>
parents:
19760
diff
changeset
|
3860 return tv1->vval.v_partial == tv2->vval.v_partial; |
|
f92435f0f449
patch 8.2.0493: Vim9: some error messages not tested
Bram Moolenaar <Bram@vim.org>
parents:
19760
diff
changeset
|
3861 |
|
8635
3a38d465f731
commit https://github.com/vim/vim/commit/f0e86a0dbddc18568910e9e4aaae0cd88ca8087a
Christian Brabandt <cb@256bit.org>
parents:
8633
diff
changeset
|
3862 case VAR_FUNC: |
|
19874
f92435f0f449
patch 8.2.0493: Vim9: some error messages not tested
Bram Moolenaar <Bram@vim.org>
parents:
19760
diff
changeset
|
3863 return tv1->vval.v_string == tv2->vval.v_string; |
|
f92435f0f449
patch 8.2.0493: Vim9: some error messages not tested
Bram Moolenaar <Bram@vim.org>
parents:
19760
diff
changeset
|
3864 |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3865 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
|
3866 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
|
3867 case VAR_VOID: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
3868 break; |
| 388 | 3869 } |
| 3870 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3871 // VAR_UNKNOWN can be the result of a invalid expression, let's say it |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3872 // does not equal anything, not even itself. |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
3873 return FALSE; |
| 80 | 3874 } |
| 3875 | |
| 3876 /* | |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3877 * Return the next (unique) copy ID. |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3878 * Used for serializing nested structures. |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3879 */ |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3880 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
3881 get_copyID(void) |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3882 { |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3883 current_copyID += COPYID_INC; |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3884 return current_copyID; |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3885 } |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3886 |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3887 /* |
| 371 | 3888 * Garbage collection for lists and dictionaries. |
| 3889 * | |
| 3890 * We use reference counts to be able to free most items right away when they | |
| 3891 * are no longer used. But for composite items it's possible that it becomes | |
| 3892 * unused while the reference count is > 0: When there is a recursive | |
| 3893 * reference. Example: | |
| 3894 * :let l = [1, 2, 3] | |
| 3895 * :let d = {9: l} | |
| 3896 * :let l[1] = d | |
| 3897 * | |
| 3898 * Since this is quite unusual we handle this with garbage collection: every | |
| 3899 * once in a while find out which lists and dicts are not referenced from any | |
| 3900 * variable. | |
| 3901 * | |
| 3902 * Here is a good reference text about garbage collection (refers to Python | |
| 3903 * but it applies to all reference-counting mechanisms): | |
| 3904 * http://python.ca/nas/python/gc/ | |
| 3905 */ | |
| 3906 | |
| 3907 /* | |
| 3908 * 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
|
3909 * When "testing" is TRUE this is called from test_garbagecollect_now(). |
| 371 | 3910 * Return TRUE if some memory was freed. |
| 3911 */ | |
| 3912 int | |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
3913 garbage_collect(int testing) |
| 371 | 3914 { |
| 1891 | 3915 int copyID; |
| 6565 | 3916 int abort = FALSE; |
| 371 | 3917 buf_T *buf; |
| 3918 win_T *wp; | |
| 6588 | 3919 int did_free = FALSE; |
| 819 | 3920 tabpage_T *tp; |
| 371 | 3921 |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
3922 if (!testing) |
|
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
3923 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3924 // Only do this once. |
|
8881
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
3925 want_garbage_collect = FALSE; |
|
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
3926 may_garbage_collect = FALSE; |
|
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
3927 garbage_collect_at_exit = FALSE; |
|
ed0b39dd7fd6
commit https://github.com/vim/vim/commit/ebf7dfa6f121c82f97d2adca3d45fbaba9ad8f7e
Christian Brabandt <cb@256bit.org>
parents:
8877
diff
changeset
|
3928 } |
| 958 | 3929 |
|
19001
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
3930 // 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
|
3931 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
|
3932 { |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
3933 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
|
3934 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
|
3935 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
|
3936 |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
3937 // 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
|
3938 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
|
3939 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
|
3940 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
|
3941 |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
3942 // 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
|
3943 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
|
3944 { |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
3945 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
|
3946 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
|
3947 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
|
3948 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
|
3949 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
|
3950 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
|
3951 } |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
3952 } |
|
1ebfb46710cd
patch 8.2.0061: the execute stack can grow big and never shrinks
Bram Moolenaar <Bram@vim.org>
parents:
18968
diff
changeset
|
3953 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3954 // 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
|
3955 // previous_funccal. |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
3956 copyID = get_copyID(); |
| 1891 | 3957 |
| 371 | 3958 /* |
| 3959 * 1. Go through all accessible variables and mark all lists and dicts | |
| 3960 * with copyID. | |
| 3961 */ | |
| 1891 | 3962 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3963 // 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
|
3964 // 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
|
3965 // 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
|
3966 abort = abort || set_ref_in_previous_funccal(copyID); |
| 1891 | 3967 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3968 // 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
|
3969 abort = abort || garbage_collect_scriptvars(copyID); |
| 371 | 3970 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3971 // buffer-local variables |
|
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9636
diff
changeset
|
3972 FOR_ALL_BUFFERS(buf) |
| 6565 | 3973 abort = abort || set_ref_in_item(&buf->b_bufvar.di_tv, copyID, |
| 3974 NULL, NULL); | |
| 371 | 3975 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3976 // window-local variables |
| 819 | 3977 FOR_ALL_TAB_WINDOWS(tp, wp) |
| 6565 | 3978 abort = abort || set_ref_in_item(&wp->w_winvar.di_tv, copyID, |
| 3979 NULL, NULL); | |
| 4309 | 3980 if (aucmd_win != NULL) |
| 6565 | 3981 abort = abort || set_ref_in_item(&aucmd_win->w_winvar.di_tv, copyID, |
| 3982 NULL, NULL); | |
|
18763
49b78d6465e5
patch 8.1.2371: FEAT_TEXT_PROP is a confusing name
Bram Moolenaar <Bram@vim.org>
parents:
18713
diff
changeset
|
3983 #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
|
3984 FOR_ALL_POPUPWINS(wp) |
|
16778
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
3985 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
|
3986 NULL, NULL); |
|
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
3987 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
|
3988 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
|
3989 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
|
3990 NULL, NULL); |
|
eda4d65f232c
patch 8.1.1391: no popup window support
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
3991 #endif |
| 371 | 3992 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3993 // tabpage-local variables |
|
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9636
diff
changeset
|
3994 FOR_ALL_TABPAGES(tp) |
| 6565 | 3995 abort = abort || set_ref_in_item(&tp->tp_winvar.di_tv, copyID, |
| 3996 NULL, NULL); | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3997 // 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
|
3998 abort = abort || garbage_collect_globvars(copyID); |
| 371 | 3999 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4000 // function-local variables |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4001 abort = abort || set_ref_in_call_stack(copyID); |
| 371 | 4002 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4003 // named functions (matters for closures) |
|
9735
8037eb704e93
commit https://github.com/vim/vim/commit/bc7ce675b2d1c9fb58c067eff3edd59abc30aba4
Christian Brabandt <cb@256bit.org>
parents:
9731
diff
changeset
|
4004 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
|
4005 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4006 // 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
|
4007 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
|
4008 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4009 // 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
|
4010 abort = abort || garbage_collect_vimvars(copyID); |
| 1733 | 4011 |
|
17151
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4012 // callbacks in buffers |
|
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4013 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
|
4014 |
| 3450 | 4015 #ifdef FEAT_LUA |
| 6565 | 4016 abort = abort || set_ref_in_lua(copyID); |
| 3450 | 4017 #endif |
| 4018 | |
| 3618 | 4019 #ifdef FEAT_PYTHON |
| 6565 | 4020 abort = abort || set_ref_in_python(copyID); |
| 3618 | 4021 #endif |
| 4022 | |
| 4023 #ifdef FEAT_PYTHON3 | |
| 6565 | 4024 abort = abort || set_ref_in_python3(copyID); |
| 4025 #endif | |
| 4026 | |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
4027 #ifdef FEAT_JOB_CHANNEL |
|
8877
50e40f322e78
commit https://github.com/vim/vim/commit/3780bb923a688e0051a9a23474eeb38a8acb695a
Christian Brabandt <cb@256bit.org>
parents:
8870
diff
changeset
|
4028 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
|
4029 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
|
4030 #endif |
|
9052
3a6b66c02d6d
commit https://github.com/vim/vim/commit/3266c85a44a637862b0ed6e531680c6ab2897ab5
Christian Brabandt <cb@256bit.org>
parents:
9027
diff
changeset
|
4031 #ifdef FEAT_NETBEANS_INTG |
|
3a6b66c02d6d
commit https://github.com/vim/vim/commit/3266c85a44a637862b0ed6e531680c6ab2897ab5
Christian Brabandt <cb@256bit.org>
parents:
9027
diff
changeset
|
4032 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
|
4033 #endif |
|
7931
2679e636e862
commit https://github.com/vim/vim/commit/4b6a6dcbe7bd13170c4884cc17acb1eac2c633d1
Christian Brabandt <cb@256bit.org>
parents:
7895
diff
changeset
|
4034 |
|
9153
c2fe86f2bda1
commit https://github.com/vim/vim/commit/e3188e261569ae512fb1ae2653b57fdd9e259ca3
Christian Brabandt <cb@256bit.org>
parents:
9127
diff
changeset
|
4035 #ifdef FEAT_TIMERS |
|
c2fe86f2bda1
commit https://github.com/vim/vim/commit/e3188e261569ae512fb1ae2653b57fdd9e259ca3
Christian Brabandt <cb@256bit.org>
parents:
9127
diff
changeset
|
4036 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
|
4037 #endif |
|
c2fe86f2bda1
commit https://github.com/vim/vim/commit/e3188e261569ae512fb1ae2653b57fdd9e259ca3
Christian Brabandt <cb@256bit.org>
parents:
9127
diff
changeset
|
4038 |
|
11412
84baca75b7f2
patch 8.0.0590: cannot add a context to locations
Christian Brabandt <cb@256bit.org>
parents:
11323
diff
changeset
|
4039 #ifdef FEAT_QUICKFIX |
|
84baca75b7f2
patch 8.0.0590: cannot add a context to locations
Christian Brabandt <cb@256bit.org>
parents:
11323
diff
changeset
|
4040 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
|
4041 #endif |
|
84baca75b7f2
patch 8.0.0590: cannot add a context to locations
Christian Brabandt <cb@256bit.org>
parents:
11323
diff
changeset
|
4042 |
|
11804
5630978ae089
patch 8.0.0784: job of terminal may be garbage collected
Christian Brabandt <cb@256bit.org>
parents:
11418
diff
changeset
|
4043 #ifdef FEAT_TERMINAL |
|
5630978ae089
patch 8.0.0784: job of terminal may be garbage collected
Christian Brabandt <cb@256bit.org>
parents:
11418
diff
changeset
|
4044 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
|
4045 #endif |
|
5630978ae089
patch 8.0.0784: job of terminal may be garbage collected
Christian Brabandt <cb@256bit.org>
parents:
11418
diff
changeset
|
4046 |
|
18763
49b78d6465e5
patch 8.1.2371: FEAT_TEXT_PROP is a confusing name
Bram Moolenaar <Bram@vim.org>
parents:
18713
diff
changeset
|
4047 #ifdef FEAT_PROP_POPUP |
|
17151
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4048 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
|
4049 #endif |
|
ebe9aab81898
patch 8.1.1575: callbacks may be garbage collected
Bram Moolenaar <Bram@vim.org>
parents:
17085
diff
changeset
|
4050 |
| 6565 | 4051 if (!abort) |
| 4052 { | |
| 4053 /* | |
| 4054 * 2. Free lists and dictionaries that are not referenced. | |
| 4055 */ | |
| 4056 did_free = free_unref_items(copyID); | |
| 4057 | |
| 4058 /* | |
| 4059 * 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
|
4060 * This may call us back recursively. |
| 6565 | 4061 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4062 free_unref_funccal(copyID, testing); |
| 6565 | 4063 } |
| 4064 else if (p_verbose > 0) | |
| 4065 { | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15517
diff
changeset
|
4066 verb_msg(_("Not enough memory to set references, garbage collection aborted!")); |
| 6565 | 4067 } |
| 1891 | 4068 |
| 4069 return did_free; | |
| 4070 } | |
| 4071 | |
| 4072 /* | |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4073 * Free lists, dictionaries, channels and jobs that are no longer referenced. |
| 1891 | 4074 */ |
| 4075 static int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4076 free_unref_items(int copyID) |
| 1891 | 4077 { |
| 4078 int did_free = FALSE; | |
| 4079 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4080 // 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
|
4081 // 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
|
4082 // do that here. |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4083 in_free_unref_items = TRUE; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4084 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4085 /* |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4086 * 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
|
4087 * 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
|
4088 */ |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4089 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4090 // 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
|
4091 did_free |= dict_free_nonref(copyID); |
| 371 | 4092 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4093 // 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
|
4094 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
|
4095 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4096 #ifdef FEAT_JOB_CHANNEL |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4097 // 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
|
4098 // 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
|
4099 // 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
|
4100 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
|
4101 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4102 // 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
|
4103 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
|
4104 #endif |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4105 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4106 /* |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4107 * PASS 2: free the items themselves. |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4108 */ |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
4109 dict_free_items(copyID); |
|
9560
1e68dfd7931b
commit https://github.com/vim/vim/commit/da861d631d7e22654faee2789286c685ad548911
Christian Brabandt <cb@256bit.org>
parents:
9556
diff
changeset
|
4110 list_free_items(copyID); |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4111 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4112 #ifdef FEAT_JOB_CHANNEL |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4113 // 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
|
4114 // 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
|
4115 // 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
|
4116 free_unused_jobs(copyID, COPYID_MASK); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4117 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4118 // 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
|
4119 free_unused_channels(copyID, COPYID_MASK); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4120 #endif |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4121 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4122 in_free_unref_items = FALSE; |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
4123 |
| 371 | 4124 return did_free; |
| 4125 } | |
| 4126 | |
| 4127 /* | |
| 4128 * Mark all lists and dicts referenced through hashtab "ht" with "copyID". | |
| 6565 | 4129 * "list_stack" is used to add lists to be marked. Can be NULL. |
| 4130 * | |
| 4131 * Returns TRUE if setting references failed somehow. | |
| 4132 */ | |
| 4133 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4134 set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack) |
| 364 | 4135 { |
| 4136 int todo; | |
| 6565 | 4137 int abort = FALSE; |
| 364 | 4138 hashitem_T *hi; |
| 6565 | 4139 hashtab_T *cur_ht; |
| 4140 ht_stack_T *ht_stack = NULL; | |
| 4141 ht_stack_T *tempitem; | |
| 4142 | |
| 4143 cur_ht = ht; | |
| 4144 for (;;) | |
| 4145 { | |
| 4146 if (!abort) | |
| 4147 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4148 // 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
|
4149 // 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
|
4150 // list_stack. |
| 6565 | 4151 todo = (int)cur_ht->ht_used; |
| 4152 for (hi = cur_ht->ht_array; todo > 0; ++hi) | |
| 4153 if (!HASHITEM_EMPTY(hi)) | |
| 4154 { | |
| 4155 --todo; | |
| 4156 abort = abort || set_ref_in_item(&HI2DI(hi)->di_tv, copyID, | |
| 4157 &ht_stack, list_stack); | |
| 4158 } | |
| 4159 } | |
| 4160 | |
| 4161 if (ht_stack == NULL) | |
| 4162 break; | |
| 4163 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4164 // take an item from the stack |
| 6565 | 4165 cur_ht = ht_stack->ht; |
| 4166 tempitem = ht_stack; | |
| 4167 ht_stack = ht_stack->prev; | |
| 4168 free(tempitem); | |
| 4169 } | |
| 4170 | |
| 4171 return abort; | |
| 371 | 4172 } |
| 4173 | |
| 4174 /* | |
|
17168
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4175 * 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
|
4176 * 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
|
4177 */ |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4178 int |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4179 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
|
4180 { |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4181 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
|
4182 { |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4183 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
|
4184 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
|
4185 } |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4186 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
|
4187 } |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4188 |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4189 /* |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4190 * 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
|
4191 * 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
|
4192 */ |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4193 int |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4194 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
|
4195 { |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4196 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
|
4197 { |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4198 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
|
4199 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
|
4200 } |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4201 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
|
4202 } |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4203 |
|
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4204 /* |
| 371 | 4205 * Mark all lists and dicts referenced through list "l" with "copyID". |
| 6565 | 4206 * "ht_stack" is used to add hashtabs to be marked. Can be NULL. |
| 4207 * | |
| 4208 * Returns TRUE if setting references failed somehow. | |
| 4209 */ | |
| 4210 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
|
4211 set_ref_in_list_items(list_T *l, int copyID, ht_stack_T **ht_stack) |
| 6565 | 4212 { |
| 4213 listitem_T *li; | |
| 4214 int abort = FALSE; | |
| 4215 list_T *cur_l; | |
| 4216 list_stack_T *list_stack = NULL; | |
| 4217 list_stack_T *tempitem; | |
| 4218 | |
| 4219 cur_l = l; | |
| 4220 for (;;) | |
| 4221 { | |
|
19201
e7b4fff348dd
patch 8.2.0159: non-materialized range() list causes problems
Bram Moolenaar <Bram@vim.org>
parents:
19191
diff
changeset
|
4222 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
|
4223 // 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
|
4224 // 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
|
4225 // list_stack. |
| 6565 | 4226 for (li = cur_l->lv_first; !abort && li != NULL; li = li->li_next) |
| 4227 abort = abort || set_ref_in_item(&li->li_tv, copyID, | |
| 4228 ht_stack, &list_stack); | |
| 4229 if (list_stack == NULL) | |
| 4230 break; | |
| 4231 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4232 // take an item from the stack |
| 6565 | 4233 cur_l = list_stack->list; |
| 4234 tempitem = list_stack; | |
| 4235 list_stack = list_stack->prev; | |
| 4236 free(tempitem); | |
| 4237 } | |
| 4238 | |
| 4239 return abort; | |
| 371 | 4240 } |
| 4241 | |
| 4242 /* | |
| 4243 * Mark all lists and dicts referenced through typval "tv" with "copyID". | |
| 6565 | 4244 * "list_stack" is used to add lists to be marked. Can be NULL. |
| 4245 * "ht_stack" is used to add hashtabs to be marked. Can be NULL. | |
| 4246 * | |
| 4247 * Returns TRUE if setting references failed somehow. | |
| 4248 */ | |
| 4249 int | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4250 set_ref_in_item( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4251 typval_T *tv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4252 int copyID, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4253 ht_stack_T **ht_stack, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4254 list_stack_T **list_stack) |
| 364 | 4255 { |
| 6565 | 4256 int abort = FALSE; |
| 364 | 4257 |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4258 if (tv->v_type == VAR_DICT) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4259 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4260 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
|
4261 |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4262 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
|
4263 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4264 // 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
|
4265 dd->dv_copyID = copyID; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4266 if (ht_stack == NULL) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4267 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4268 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
|
4269 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4270 else |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4271 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4272 ht_stack_T *newitem = (ht_stack_T*)malloc(sizeof(ht_stack_T)); |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4273 if (newitem == NULL) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4274 abort = TRUE; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4275 else |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4276 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4277 newitem->ht = &dd->dv_hashtab; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4278 newitem->prev = *ht_stack; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4279 *ht_stack = newitem; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4280 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4281 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4282 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4283 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4284 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
|
4285 { |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4286 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
|
4287 |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4288 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
|
4289 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4290 // 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
|
4291 ll->lv_copyID = copyID; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4292 if (list_stack == NULL) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4293 { |
|
17168
1d30eb64a7a2
patch 8.1.1583: set_ref_in_list() only sets ref in items
Bram Moolenaar <Bram@vim.org>
parents:
17151
diff
changeset
|
4294 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
|
4295 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4296 else |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4297 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4298 list_stack_T *newitem = (list_stack_T*)malloc( |
| 6565 | 4299 sizeof(list_stack_T)); |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4300 if (newitem == NULL) |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4301 abort = TRUE; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4302 else |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4303 { |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4304 newitem->list = ll; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4305 newitem->prev = *list_stack; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4306 *list_stack = newitem; |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4307 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4308 } |
|
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4309 } |
| 6565 | 4310 } |
|
9686
8c2553beff0f
commit https://github.com/vim/vim/commit/1e96d9bf98f9ab84d5af7f98d6a961d91b17364f
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
4311 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
|
4312 { |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4313 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
|
4314 } |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4315 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
|
4316 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4317 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
|
4318 int i; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4319 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4320 // A partial does not have a copyID, because it cannot contain itself. |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4321 if (pt != NULL) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4322 { |
|
9723
80ac9cf77c9b
commit https://github.com/vim/vim/commit/437bafe4c8a83ed71ee006eda7f54b65a90f0d4c
Christian Brabandt <cb@256bit.org>
parents:
9717
diff
changeset
|
4323 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
|
4324 |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4325 if (pt->pt_dict != NULL) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4326 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4327 typval_T dtv; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4328 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4329 dtv.v_type = VAR_DICT; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4330 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
|
4331 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
|
4332 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4333 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4334 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
|
4335 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
|
4336 ht_stack, list_stack); |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4337 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4338 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4339 #ifdef FEAT_JOB_CHANNEL |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4340 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
|
4341 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4342 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
|
4343 typval_T dtv; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4344 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4345 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
|
4346 { |
|
8870
30988ffb7498
commit https://github.com/vim/vim/commit/0239acb11fe4bfe9b525ea90b782759da5eb7704
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
4347 job->jv_copyID = copyID; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4348 if (job->jv_channel != NULL) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4349 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4350 dtv.v_type = VAR_CHANNEL; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4351 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
|
4352 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
|
4353 } |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4354 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
|
4355 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4356 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
|
4357 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
|
4358 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
|
4359 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4360 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4361 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4362 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
|
4363 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4364 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
|
4365 ch_part_T part; |
|
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4366 typval_T dtv; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4367 jsonq_T *jq; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4368 cbq_T *cq; |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4369 |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4370 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
|
4371 { |
|
8870
30988ffb7498
commit https://github.com/vim/vim/commit/0239acb11fe4bfe9b525ea90b782759da5eb7704
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
4372 ch->ch_copyID = copyID; |
|
10259
a09db7a4afe0
commit https://github.com/vim/vim/commit/dc0ccaee68ca24d10050117fbec757ad33590a17
Christian Brabandt <cb@256bit.org>
parents:
10235
diff
changeset
|
4373 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
|
4374 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4375 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
|
4376 jq = jq->jq_next) |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4377 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
|
4378 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
|
4379 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
|
4380 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
|
4381 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4382 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
|
4383 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
|
4384 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
|
4385 } |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4386 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
|
4387 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4388 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
|
4389 dtv.vval.v_partial = |
|
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4390 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
|
4391 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
|
4392 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4393 } |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4394 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
|
4395 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4396 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
|
4397 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
|
4398 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
|
4399 } |
|
16872
a836d122231a
patch 8.1.1437: code to handle callbacks is duplicated
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
4400 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
|
4401 { |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4402 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
|
4403 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
|
4404 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
|
4405 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4406 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4407 } |
|
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8861
diff
changeset
|
4408 #endif |
| 6565 | 4409 return abort; |
| 364 | 4410 } |
| 4411 | |
| 100 | 4412 /* |
| 56 | 4413 * Return a string with the string representation of a variable. |
| 4414 * If the memory is allocated "tofree" is set to it, otherwise NULL. | |
| 80 | 4415 * "numbuf" is used for a number. |
| 634 | 4416 * 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
|
4417 * When both "echo_style" and "composite_val" are FALSE, put quotes around |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4418 * stings as "string()", otherwise does not put quotes around strings, as |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4419 * ":echo" displays values. |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4420 * 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
|
4421 * are replaced with "...". |
| 1360 | 4422 * May return NULL. |
| 56 | 4423 */ |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
4424 char_u * |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4425 echo_string_core( |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4426 typval_T *tv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4427 char_u **tofree, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4428 char_u *numbuf, |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4429 int copyID, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4430 int echo_style, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4431 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
|
4432 int composite_val) |
| 56 | 4433 { |
| 104 | 4434 static int recurse = 0; |
| 4435 char_u *r = NULL; | |
| 4436 | |
| 137 | 4437 if (recurse >= DICT_MAXNEST) |
| 104 | 4438 { |
| 5973 | 4439 if (!did_echo_string_emsg) |
| 4440 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4441 // 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
|
4442 // 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
|
4443 // and dicts. |
| 5973 | 4444 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
|
4445 emsg(_("E724: variable nested too deep for displaying")); |
| 5973 | 4446 } |
| 104 | 4447 *tofree = NULL; |
| 5973 | 4448 return (char_u *)"{E724}"; |
| 104 | 4449 } |
| 4450 ++recurse; | |
| 4451 | |
| 56 | 4452 switch (tv->v_type) |
| 4453 { | |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4454 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
|
4455 if (echo_style && !composite_val) |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4456 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4457 *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
|
4458 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
|
4459 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
|
4460 r = (char_u *)""; |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4461 } |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4462 else |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4463 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4464 *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
|
4465 r = *tofree; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4466 } |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4467 break; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4468 |
| 56 | 4469 case VAR_FUNC: |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4470 if (echo_style) |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4471 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4472 *tofree = NULL; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4473 r = tv->vval.v_string; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4474 } |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4475 else |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4476 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4477 *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
|
4478 r = *tofree; |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4479 } |
| 104 | 4480 break; |
| 634 | 4481 |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
4482 case VAR_PARTIAL: |
|
8710
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4483 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4484 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
|
4485 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
|
4486 : partial_name(pt), FALSE); |
|
8710
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4487 garray_T ga; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4488 int i; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4489 char_u *tf; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4490 |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4491 ga_init2(&ga, 1, 100); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4492 ga_concat(&ga, (char_u *)"function("); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4493 if (fname != NULL) |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4494 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4495 ga_concat(&ga, fname); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4496 vim_free(fname); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4497 } |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4498 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
|
4499 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4500 ga_concat(&ga, (char_u *)", ["); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4501 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
|
4502 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4503 if (i > 0) |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4504 ga_concat(&ga, (char_u *)", "); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4505 ga_concat(&ga, |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4506 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
|
4507 vim_free(tf); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4508 } |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4509 ga_concat(&ga, (char_u *)"]"); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4510 } |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4511 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
|
4512 { |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4513 typval_T dtv; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4514 |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4515 ga_concat(&ga, (char_u *)", "); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4516 dtv.v_type = VAR_DICT; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4517 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
|
4518 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
|
4519 vim_free(tf); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4520 } |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4521 ga_concat(&ga, (char_u *)")"); |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4522 |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4523 *tofree = ga.ga_data; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4524 r = *tofree; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4525 break; |
|
af3cb5c068fd
commit https://github.com/vim/vim/commit/24c77a1e3a2ad510582116229462b482d69b4b8e
Christian Brabandt <cb@256bit.org>
parents:
8708
diff
changeset
|
4526 } |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
4527 |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
4528 case VAR_BLOB: |
|
15466
435fcefd2c8e
patch 8.1.0741: viminfo with Blob is not tested
Bram Moolenaar <Bram@vim.org>
parents:
15464
diff
changeset
|
4529 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
|
4530 break; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
4531 |
| 56 | 4532 case VAR_LIST: |
| 634 | 4533 if (tv->vval.v_list == NULL) |
| 4534 { | |
|
20126
831b1ea43020
patch 8.2.0618: echoing a null list results in no output
Bram Moolenaar <Bram@vim.org>
parents:
20111
diff
changeset
|
4535 // NULL list is equivalent to empty list. |
| 634 | 4536 *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
|
4537 r = (char_u *)"[]"; |
| 634 | 4538 } |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4539 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
|
4540 && tv->vval.v_list->lv_len > 0) |
| 634 | 4541 { |
| 4542 *tofree = NULL; | |
| 4543 r = (char_u *)"[...]"; | |
| 4544 } | |
| 4545 else | |
| 4546 { | |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4547 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
|
4548 |
| 634 | 4549 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
|
4550 *tofree = list2string(tv, copyID, restore_copyID); |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4551 if (restore_copyID) |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4552 tv->vval.v_list->lv_copyID = old_copyID; |
| 634 | 4553 r = *tofree; |
| 4554 } | |
| 4555 break; | |
| 4556 | |
| 100 | 4557 case VAR_DICT: |
| 634 | 4558 if (tv->vval.v_dict == NULL) |
| 4559 { | |
|
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20126
diff
changeset
|
4560 // NULL dict is equivalent to empty dict. |
| 634 | 4561 *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
|
4562 r = (char_u *)"{}"; |
| 634 | 4563 } |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4564 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
|
4565 && tv->vval.v_dict->dv_hashtab.ht_used != 0) |
| 634 | 4566 { |
| 4567 *tofree = NULL; | |
| 4568 r = (char_u *)"{...}"; | |
| 4569 } | |
| 4570 else | |
| 4571 { | |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4572 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
|
4573 |
| 634 | 4574 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
|
4575 *tofree = dict2string(tv, copyID, restore_copyID); |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4576 if (restore_copyID) |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4577 tv->vval.v_dict->dv_copyID = old_copyID; |
| 634 | 4578 r = *tofree; |
| 4579 } | |
| 4580 break; | |
| 4581 | |
| 71 | 4582 case VAR_NUMBER: |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
4583 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
|
4584 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
|
4585 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
|
4586 *tofree = NULL; |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
4587 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
|
4588 break; |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4589 |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
4590 case VAR_JOB: |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
4591 case VAR_CHANNEL: |
| 104 | 4592 *tofree = NULL; |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
4593 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
|
4594 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
|
4595 { |
|
aec3df2af27c
patch 8.0.0867: job and channel in a dict value not quoted
Christian Brabandt <cb@256bit.org>
parents:
11848
diff
changeset
|
4596 *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
|
4597 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
|
4598 } |
| 71 | 4599 break; |
| 634 | 4600 |
| 1624 | 4601 case VAR_FLOAT: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
4602 #ifdef FEAT_FLOAT |
| 1624 | 4603 *tofree = NULL; |
| 4604 vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv->vval.v_float); | |
| 4605 r = numbuf; | |
| 4606 break; | |
| 4607 #endif | |
| 4608 | |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
4609 case VAR_BOOL: |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4610 case VAR_SPECIAL: |
|
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4611 *tofree = NULL; |
|
7730
80ce794827c4
commit https://github.com/vim/vim/commit/17a13437c9414a8693369a97f3be2fc8ad48c12e
Christian Brabandt <cb@256bit.org>
parents:
7720
diff
changeset
|
4612 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
|
4613 break; |
| 104 | 4614 } |
| 4615 | |
| 5973 | 4616 if (--recurse == 0) |
| 4617 did_echo_string_emsg = FALSE; | |
| 104 | 4618 return r; |
| 97 | 4619 } |
| 4620 | |
| 4621 /* | |
| 4622 * Return a string with the string representation of a variable. | |
| 4623 * If the memory is allocated "tofree" is set to it, otherwise NULL. | |
| 4624 * "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
|
4625 * 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
|
4626 * 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
|
4627 * May return NULL. |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4628 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4629 char_u * |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4630 echo_string( |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4631 typval_T *tv, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4632 char_u **tofree, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4633 char_u *numbuf, |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4634 int copyID) |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4635 { |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4636 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
|
4637 } |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4638 |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4639 /* |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4640 * Return a string with the string representation of a variable. |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4641 * If the memory is allocated "tofree" is set to it, otherwise NULL. |
|
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4642 * "numbuf" is used for a number. |
| 97 | 4643 * Puts quotes around strings, so that they can be parsed back by eval(). |
| 1360 | 4644 * May return NULL. |
| 97 | 4645 */ |
|
8889
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8887
diff
changeset
|
4646 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4647 tv2string( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4648 typval_T *tv, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4649 char_u **tofree, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4650 char_u *numbuf, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4651 int copyID) |
| 97 | 4652 { |
|
9157
e316b83892c1
commit https://github.com/vim/vim/commit/18dfb4404a618c52ee7138630a2381aed4d66eaf
Christian Brabandt <cb@256bit.org>
parents:
9153
diff
changeset
|
4653 return echo_string_core(tv, tofree, numbuf, copyID, FALSE, TRUE, FALSE); |
| 56 | 4654 } |
| 4655 | |
| 4656 /* | |
| 137 | 4657 * Return string "str" in ' quotes, doubling ' characters. |
| 4658 * If "str" is NULL an empty string is assumed. | |
| 100 | 4659 * If "function" is TRUE make it function('string'). |
| 97 | 4660 */ |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
4661 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4662 string_quote(char_u *str, int function) |
| 97 | 4663 { |
| 137 | 4664 unsigned len; |
| 97 | 4665 char_u *p, *r, *s; |
| 4666 | |
| 137 | 4667 len = (function ? 13 : 3); |
| 4668 if (str != NULL) | |
| 4669 { | |
| 835 | 4670 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
|
4671 for (p = str; *p != NUL; MB_PTR_ADV(p)) |
| 137 | 4672 if (*p == '\'') |
| 4673 ++len; | |
| 4674 } | |
| 97 | 4675 s = r = alloc(len); |
| 4676 if (r != NULL) | |
| 4677 { | |
| 4678 if (function) | |
| 4679 { | |
| 100 | 4680 STRCPY(r, "function('"); |
| 97 | 4681 r += 10; |
| 4682 } | |
| 4683 else | |
| 100 | 4684 *r++ = '\''; |
| 137 | 4685 if (str != NULL) |
| 4686 for (p = str; *p != NUL; ) | |
| 4687 { | |
| 4688 if (*p == '\'') | |
| 4689 *r++ = '\''; | |
| 4690 MB_COPY_CHAR(p, r); | |
| 4691 } | |
| 100 | 4692 *r++ = '\''; |
| 97 | 4693 if (function) |
| 4694 *r++ = ')'; | |
| 4695 *r++ = NUL; | |
| 4696 } | |
| 4697 return s; | |
| 4698 } | |
| 4699 | |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4700 #if defined(FEAT_FLOAT) || defined(PROTO) |
| 1624 | 4701 /* |
| 4702 * Convert the string "text" to a floating point number. | |
| 4703 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure | |
| 4704 * this always uses a decimal point. | |
| 4705 * Returns the length of the text that was consumed. | |
| 4706 */ | |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
4707 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4708 string2float( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4709 char_u *text, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4710 float_T *value) // result stored here |
| 1624 | 4711 { |
| 4712 char *s = (char *)text; | |
| 4713 float_T f; | |
| 4714 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4715 // 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
|
4716 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
|
4717 { |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4718 *value = INFINITY; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4719 return 3; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4720 } |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4721 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
|
4722 { |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4723 *value = -INFINITY; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4724 return 4; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4725 } |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4726 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
|
4727 { |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4728 *value = NAN; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4729 return 3; |
|
6ddf322ff7cf
patch 8.0.0158: float funcion test fails on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
10386
diff
changeset
|
4730 } |
| 1624 | 4731 f = strtod(s, &s); |
| 4732 *value = f; | |
| 4733 return (int)((char_u *)s - text); | |
| 4734 } | |
| 4735 #endif | |
| 4736 | |
| 97 | 4737 /* |
| 7 | 4738 * Get the value of an environment variable. |
| 4739 * "arg" is pointing to the '$'. It is advanced to after the name. | |
| 4740 * If the environment variable was not set, silently assume it is empty. | |
| 5858 | 4741 * Return FAIL if the name is invalid. |
| 7 | 4742 */ |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
4743 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4744 get_env_tv(char_u **arg, typval_T *rettv, int evaluate) |
| 7 | 4745 { |
| 4746 char_u *string = NULL; | |
| 4747 int len; | |
| 4748 int cc; | |
| 4749 char_u *name; | |
| 170 | 4750 int mustfree = FALSE; |
| 7 | 4751 |
| 4752 ++*arg; | |
| 4753 name = *arg; | |
| 4754 len = get_env_len(arg); | |
| 4755 if (evaluate) | |
| 4756 { | |
| 5858 | 4757 if (len == 0) |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4758 return FAIL; // invalid empty name |
| 5858 | 4759 |
| 4760 cc = name[len]; | |
| 4761 name[len] = NUL; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4762 // first try vim_getenv(), fast for normal environment vars |
| 5858 | 4763 string = vim_getenv(name, &mustfree); |
| 4764 if (string != NULL && *string != NUL) | |
| 4765 { | |
| 4766 if (!mustfree) | |
| 4767 string = vim_strsave(string); | |
| 4768 } | |
| 4769 else | |
| 4770 { | |
| 4771 if (mustfree) | |
| 4772 vim_free(string); | |
| 4773 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4774 // next try expanding things like $VIM and ${HOME} |
| 5858 | 4775 string = expand_env_save(name - 1); |
| 4776 if (string != NULL && *string == '$') | |
|
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
13037
diff
changeset
|
4777 VIM_CLEAR(string); |
| 5858 | 4778 } |
| 4779 name[len] = cc; | |
| 4780 | |
| 71 | 4781 rettv->v_type = VAR_STRING; |
| 4782 rettv->vval.v_string = string; | |
| 7 | 4783 } |
| 4784 | |
| 4785 return OK; | |
| 4786 } | |
| 4787 | |
| 3214 | 4788 /* |
| 7 | 4789 * Translate a String variable into a position. |
| 685 | 4790 * Returns NULL when there is an error. |
| 7 | 4791 */ |
|
9571
5eaa708ab50d
commit https://github.com/vim/vim/commit/73dad1e64cb42842d8259cb1a255a6fa59822f76
Christian Brabandt <cb@256bit.org>
parents:
9562
diff
changeset
|
4792 pos_T * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4793 var2fpos( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4794 typval_T *varp, |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4795 int dollar_lnum, // TRUE when $ is last line |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4796 int *fnum) // set to fnum for '0, 'A, etc. |
| 7 | 4797 { |
| 700 | 4798 char_u *name; |
| 7 | 4799 static pos_T pos; |
| 700 | 4800 pos_T *pp; |
| 7 | 4801 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4802 // Argument can be [lnum, col, coladd]. |
| 685 | 4803 if (varp->v_type == VAR_LIST) |
| 4804 { | |
| 4805 list_T *l; | |
| 4806 int len; | |
| 705 | 4807 int error = FALSE; |
| 1317 | 4808 listitem_T *li; |
| 685 | 4809 |
| 4810 l = varp->vval.v_list; | |
| 4811 if (l == NULL) | |
| 4812 return NULL; | |
| 4813 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4814 // Get the line number |
| 705 | 4815 pos.lnum = list_find_nr(l, 0L, &error); |
| 4816 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
|
4817 return NULL; // invalid line number |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4818 |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4819 // Get the column number |
| 705 | 4820 pos.col = list_find_nr(l, 1L, &error); |
| 4821 if (error) | |
| 685 | 4822 return NULL; |
| 4823 len = (long)STRLEN(ml_get(pos.lnum)); | |
| 1317 | 4824 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4825 // We accept "$" for the column number: last column. |
| 1317 | 4826 li = list_find(l, 1L); |
| 4827 if (li != NULL && li->li_tv.v_type == VAR_STRING | |
| 4828 && li->li_tv.vval.v_string != NULL | |
| 4829 && STRCMP(li->li_tv.vval.v_string, "$") == 0) | |
| 4830 pos.col = len + 1; | |
| 4831 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4832 // Accept a position up to the NUL after the line. |
| 826 | 4833 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
|
4834 return NULL; // invalid column number |
| 705 | 4835 --pos.col; |
| 4836 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4837 // Get the virtual offset. Defaults to zero. |
| 705 | 4838 pos.coladd = list_find_nr(l, 2L, &error); |
| 4839 if (error) | |
| 4840 pos.coladd = 0; | |
| 4841 | |
| 685 | 4842 return &pos; |
| 4843 } | |
| 4844 | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
4845 name = tv_get_string_chk(varp); |
| 323 | 4846 if (name == NULL) |
| 4847 return NULL; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4848 if (name[0] == '.') // cursor |
| 7 | 4849 return &curwin->w_cursor; |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4850 if (name[0] == 'v' && name[1] == NUL) // Visual start |
| 1609 | 4851 { |
| 4852 if (VIsual_active) | |
| 4853 return &VIsual; | |
| 4854 return &curwin->w_cursor; | |
| 4855 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4856 if (name[0] == '\'') // mark |
| 7 | 4857 { |
| 4043 | 4858 pp = getmark_buf_fnum(curbuf, name[1], FALSE, fnum); |
| 7 | 4859 if (pp == NULL || pp == (pos_T *)-1 || pp->lnum <= 0) |
| 4860 return NULL; | |
| 4861 return pp; | |
| 4862 } | |
| 705 | 4863 |
| 4864 pos.coladd = 0; | |
| 4865 | |
| 1317 | 4866 if (name[0] == 'w' && dollar_lnum) |
| 666 | 4867 { |
| 4868 pos.col = 0; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4869 if (name[1] == '0') // "w0": first visible line |
| 666 | 4870 { |
| 671 | 4871 update_topline(); |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4872 // 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
|
4873 // 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
|
4874 pos.lnum = curwin->w_topline > 0 ? curwin->w_topline : 1; |
| 666 | 4875 return &pos; |
| 4876 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4877 else if (name[1] == '$') // "w$": last visible line |
| 666 | 4878 { |
| 671 | 4879 validate_botline(); |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4880 // 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
|
4881 pos.lnum = curwin->w_botline > 0 ? curwin->w_botline - 1 : 0; |
| 666 | 4882 return &pos; |
| 4883 } | |
| 4884 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4885 else if (name[0] == '$') // last column or line |
| 7 | 4886 { |
| 1317 | 4887 if (dollar_lnum) |
| 7 | 4888 { |
| 4889 pos.lnum = curbuf->b_ml.ml_line_count; | |
| 4890 pos.col = 0; | |
| 4891 } | |
| 4892 else | |
| 4893 { | |
| 4894 pos.lnum = curwin->w_cursor.lnum; | |
| 4895 pos.col = (colnr_T)STRLEN(ml_get_curline()); | |
| 4896 } | |
| 4897 return &pos; | |
| 4898 } | |
| 4899 return NULL; | |
| 4900 } | |
| 4901 | |
| 4902 /* | |
| 709 | 4903 * Convert list in "arg" into a position and optional file number. |
| 4904 * When "fnump" is NULL there is no file number, only 3 items. | |
| 4905 * Note that the column is passed on as-is, the caller may want to decrement | |
| 4906 * it to use 1 for the first column. | |
| 4907 * Return FAIL when conversion is not possible, doesn't check the position for | |
| 4908 * validity. | |
| 4909 */ | |
|
9571
5eaa708ab50d
commit https://github.com/vim/vim/commit/73dad1e64cb42842d8259cb1a255a6fa59822f76
Christian Brabandt <cb@256bit.org>
parents:
9562
diff
changeset
|
4910 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4911 list2fpos( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4912 typval_T *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4913 pos_T *posp, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4914 int *fnump, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4915 colnr_T *curswantp) |
| 709 | 4916 { |
| 4917 list_T *l = arg->vval.v_list; | |
| 4918 long i = 0; | |
| 4919 long n; | |
| 4920 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4921 // 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
|
4922 // there when "fnump" isn't NULL; "coladd" and "curswant" are optional. |
| 915 | 4923 if (arg->v_type != VAR_LIST |
| 4924 || l == NULL | |
| 4925 || l->lv_len < (fnump == NULL ? 2 : 3) | |
| 5938 | 4926 || l->lv_len > (fnump == NULL ? 4 : 5)) |
| 709 | 4927 return FAIL; |
| 4928 | |
| 4929 if (fnump != NULL) | |
| 4930 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4931 n = list_find_nr(l, i++, NULL); // fnum |
| 709 | 4932 if (n < 0) |
| 4933 return FAIL; | |
| 4934 if (n == 0) | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4935 n = curbuf->b_fnum; // current buffer |
| 709 | 4936 *fnump = n; |
| 4937 } | |
| 4938 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4939 n = list_find_nr(l, i++, NULL); // lnum |
| 709 | 4940 if (n < 0) |
| 4941 return FAIL; | |
| 4942 posp->lnum = n; | |
| 4943 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4944 n = list_find_nr(l, i++, NULL); // col |
| 709 | 4945 if (n < 0) |
| 4946 return FAIL; | |
| 4947 posp->col = n; | |
| 4948 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4949 n = list_find_nr(l, i, NULL); // off |
| 709 | 4950 if (n < 0) |
| 915 | 4951 posp->coladd = 0; |
| 4952 else | |
| 4953 posp->coladd = n; | |
| 709 | 4954 |
| 5938 | 4955 if (curswantp != NULL) |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4956 *curswantp = list_find_nr(l, i + 1, NULL); // curswant |
| 5938 | 4957 |
| 709 | 4958 return OK; |
| 4959 } | |
| 4960 | |
| 4961 /* | |
| 7 | 4962 * Get the length of an environment variable name. |
| 4963 * Advance "arg" to the first character after the name. | |
| 4964 * Return 0 for error. | |
| 4965 */ | |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
4966 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4967 get_env_len(char_u **arg) |
| 7 | 4968 { |
| 4969 char_u *p; | |
| 4970 int len; | |
| 4971 | |
| 4972 for (p = *arg; vim_isIDc(*p); ++p) | |
| 4973 ; | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4974 if (p == *arg) // no name found |
| 7 | 4975 return 0; |
| 4976 | |
| 4977 len = (int)(p - *arg); | |
| 4978 *arg = p; | |
| 4979 return len; | |
| 4980 } | |
| 4981 | |
| 4982 /* | |
| 4983 * Get the length of the name of a function or internal variable. | |
| 4984 * "arg" is advanced to the first non-white character after the name. | |
| 4985 * Return 0 if something is wrong. | |
| 4986 */ | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
4987 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
4988 get_id_len(char_u **arg) |
| 7 | 4989 { |
| 4990 char_u *p; | |
| 4991 int len; | |
| 4992 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4993 // Find the end of the name. |
| 7 | 4994 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
|
4995 { |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
4996 if (*p == ':') |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
4997 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4998 // "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
|
4999 // 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
|
5000 len = (int)(p - *arg); |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5001 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
|
5002 || len > 1) |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5003 break; |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5004 } |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5005 } |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5006 if (p == *arg) // no name found |
| 7 | 5007 return 0; |
| 5008 | |
| 5009 len = (int)(p - *arg); | |
| 5010 *arg = skipwhite(p); | |
| 5011 | |
| 5012 return len; | |
| 5013 } | |
| 5014 | |
| 5015 /* | |
| 124 | 5016 * Get the length of the name of a variable or function. |
| 5017 * Only the name is recognized, does not handle ".key" or "[idx]". | |
| 7 | 5018 * "arg" is advanced to the first non-white character after the name. |
| 159 | 5019 * Return -1 if curly braces expansion failed. |
| 5020 * Return 0 if something else is wrong. | |
| 7 | 5021 * If the name contains 'magic' {}'s, expand them and return the |
| 5022 * expanded name in an allocated string via 'alias' - caller must free. | |
| 5023 */ | |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
5024 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5025 get_name_len( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5026 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5027 char_u **alias, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5028 int evaluate, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5029 int verbose) |
| 7 | 5030 { |
| 5031 int len; | |
| 5032 char_u *p; | |
| 5033 char_u *expr_start; | |
| 5034 char_u *expr_end; | |
| 5035 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5036 *alias = NULL; // default to no alias |
| 7 | 5037 |
| 5038 if ((*arg)[0] == K_SPECIAL && (*arg)[1] == KS_EXTRA | |
| 5039 && (*arg)[2] == (int)KE_SNR) | |
| 5040 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5041 // hard coded <SNR>, already translated |
| 7 | 5042 *arg += 3; |
| 5043 return get_id_len(arg) + 3; | |
| 5044 } | |
| 5045 len = eval_fname_script(*arg); | |
| 5046 if (len > 0) | |
| 5047 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5048 // literal "<SID>", "s:" or "<SNR>" |
| 7 | 5049 *arg += len; |
| 5050 } | |
| 5051 | |
| 5052 /* | |
| 71 | 5053 * Find the end of the name; check for {} construction. |
| 7 | 5054 */ |
| 271 | 5055 p = find_name_end(*arg, &expr_start, &expr_end, |
| 5056 len > 0 ? 0 : FNE_CHECK_START); | |
| 7 | 5057 if (expr_start != NULL) |
| 5058 { | |
| 5059 char_u *temp_string; | |
| 5060 | |
| 5061 if (!evaluate) | |
| 5062 { | |
| 5063 len += (int)(p - *arg); | |
| 5064 *arg = skipwhite(p); | |
| 5065 return len; | |
| 5066 } | |
| 5067 | |
| 5068 /* | |
| 5069 * Include any <SID> etc in the expanded string: | |
| 5070 * Thus the -len here. | |
| 5071 */ | |
| 5072 temp_string = make_expanded_name(*arg - len, expr_start, expr_end, p); | |
| 5073 if (temp_string == NULL) | |
| 159 | 5074 return -1; |
| 7 | 5075 *alias = temp_string; |
| 5076 *arg = skipwhite(p); | |
| 5077 return (int)STRLEN(temp_string); | |
| 5078 } | |
| 5079 | |
| 5080 len += get_id_len(arg); | |
|
15464
3faa7cc8207c
patch 8.1.0740: Tcl test fails
Bram Moolenaar <Bram@vim.org>
parents:
15460
diff
changeset
|
5081 // 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
|
5082 // reported at a higher level. |
|
3faa7cc8207c
patch 8.1.0740: Tcl test fails
Bram Moolenaar <Bram@vim.org>
parents:
15460
diff
changeset
|
5083 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
|
5084 semsg(_(e_invexpr2), *arg); |
| 7 | 5085 |
| 5086 return len; | |
| 5087 } | |
| 5088 | |
| 71 | 5089 /* |
| 5090 * Find the end of a variable or function name, taking care of magic braces. | |
| 5091 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the | |
| 5092 * start and end of the first magic braces item. | |
| 271 | 5093 * "flags" can have FNE_INCL_BR and FNE_CHECK_START. |
| 71 | 5094 * Return a pointer to just after the name. Equal to "arg" if there is no |
| 5095 * valid name. | |
| 5096 */ | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5097 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5098 find_name_end( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5099 char_u *arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5100 char_u **expr_start, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5101 char_u **expr_end, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5102 int flags) |
| 71 | 5103 { |
| 5104 int mb_nest = 0; | |
| 5105 int br_nest = 0; | |
| 7 | 5106 char_u *p; |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5107 int len; |
|
20091
a64c16ff98b8
patch 8.2.0601: Vim9: :unlet is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
20061
diff
changeset
|
5108 int vim9script = current_sctx.sc_version == SCRIPT_VERSION_VIM9; |
| 7 | 5109 |
| 71 | 5110 if (expr_start != NULL) |
| 5111 { | |
| 5112 *expr_start = NULL; | |
| 5113 *expr_end = NULL; | |
| 5114 } | |
| 5115 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5116 // 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
|
5117 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
|
5118 && (*arg != '{' || vim9script)) |
| 271 | 5119 return arg; |
| 5120 | |
| 71 | 5121 for (p = arg; *p != NUL |
| 5122 && (eval_isnamec(*p) | |
|
20091
a64c16ff98b8
patch 8.2.0601: Vim9: :unlet is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
20061
diff
changeset
|
5123 || (*p == '{' && !vim9script) |
| 271 | 5124 || ((flags & FNE_INCL_BR) && (*p == '[' || *p == '.')) |
| 71 | 5125 || mb_nest != 0 |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10964
diff
changeset
|
5126 || br_nest != 0); MB_PTR_ADV(p)) |
| 468 | 5127 { |
| 5128 if (*p == '\'') | |
| 5129 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5130 // 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
|
5131 for (p = p + 1; *p != NUL && *p != '\''; MB_PTR_ADV(p)) |
| 468 | 5132 ; |
| 5133 if (*p == NUL) | |
| 5134 break; | |
| 5135 } | |
| 5136 else if (*p == '"') | |
| 5137 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5138 // 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
|
5139 for (p = p + 1; *p != NUL && *p != '"'; MB_PTR_ADV(p)) |
| 468 | 5140 if (*p == '\\' && p[1] != NUL) |
| 5141 ++p; | |
| 5142 if (*p == NUL) | |
| 5143 break; | |
| 5144 } | |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5145 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
|
5146 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5147 // "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
|
5148 // 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
|
5149 len = (int)(p - arg); |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5150 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
|
5151 || (len > 1 && p[-1] != '}')) |
|
7611
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5152 break; |
|
9c420b8db435
commit https://github.com/vim/vim/commit/9bbf63dbf8286fadc0cd6b3428010abb67b1b64d
Christian Brabandt <cb@256bit.org>
parents:
7605
diff
changeset
|
5153 } |
| 468 | 5154 |
| 71 | 5155 if (mb_nest == 0) |
| 5156 { | |
| 5157 if (*p == '[') | |
| 5158 ++br_nest; | |
| 5159 else if (*p == ']') | |
| 5160 --br_nest; | |
| 5161 } | |
| 468 | 5162 |
|
20091
a64c16ff98b8
patch 8.2.0601: Vim9: :unlet is not compiled
Bram Moolenaar <Bram@vim.org>
parents:
20061
diff
changeset
|
5163 if (br_nest == 0 && !vim9script) |
| 71 | 5164 { |
| 5165 if (*p == '{') | |
| 5166 { | |
| 5167 mb_nest++; | |
| 5168 if (expr_start != NULL && *expr_start == NULL) | |
| 5169 *expr_start = p; | |
| 5170 } | |
| 5171 else if (*p == '}') | |
| 5172 { | |
| 5173 mb_nest--; | |
| 5174 if (expr_start != NULL && mb_nest == 0 && *expr_end == NULL) | |
| 5175 *expr_end = p; | |
| 5176 } | |
| 5177 } | |
| 7 | 5178 } |
| 5179 | |
| 5180 return p; | |
| 5181 } | |
| 5182 | |
| 5183 /* | |
| 159 | 5184 * Expands out the 'magic' {}'s in a variable/function name. |
| 5185 * Note that this can call itself recursively, to deal with | |
| 5186 * constructs like foo{bar}{baz}{bam} | |
| 5187 * The four pointer arguments point to "foo{expre}ss{ion}bar" | |
| 5188 * "in_start" ^ | |
| 5189 * "expr_start" ^ | |
| 5190 * "expr_end" ^ | |
| 5191 * "in_end" ^ | |
| 5192 * | |
| 5193 * Returns a new allocated string, which the caller must free. | |
| 5194 * Returns NULL for failure. | |
| 5195 */ | |
| 5196 static char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5197 make_expanded_name( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5198 char_u *in_start, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5199 char_u *expr_start, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5200 char_u *expr_end, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5201 char_u *in_end) |
| 159 | 5202 { |
| 5203 char_u c1; | |
| 5204 char_u *retval = NULL; | |
| 5205 char_u *temp_result; | |
| 5206 char_u *nextcmd = NULL; | |
| 5207 | |
| 5208 if (expr_end == NULL || in_end == NULL) | |
| 5209 return NULL; | |
| 5210 *expr_start = NUL; | |
| 5211 *expr_end = NUL; | |
| 5212 c1 = *in_end; | |
| 5213 *in_end = NUL; | |
| 5214 | |
| 714 | 5215 temp_result = eval_to_string(expr_start + 1, &nextcmd, FALSE); |
| 159 | 5216 if (temp_result != NULL && nextcmd == NULL) |
| 5217 { | |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16706
diff
changeset
|
5218 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
|
5219 + (in_end - expr_end) + 1); |
| 159 | 5220 if (retval != NULL) |
| 5221 { | |
| 5222 STRCPY(retval, in_start); | |
| 5223 STRCAT(retval, temp_result); | |
| 5224 STRCAT(retval, expr_end + 1); | |
| 5225 } | |
| 5226 } | |
| 5227 vim_free(temp_result); | |
| 5228 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5229 *in_end = c1; // put char back for error messages |
| 159 | 5230 *expr_start = '{'; |
| 5231 *expr_end = '}'; | |
| 5232 | |
| 5233 if (retval != NULL) | |
| 5234 { | |
| 271 | 5235 temp_result = find_name_end(retval, &expr_start, &expr_end, 0); |
| 159 | 5236 if (expr_start != NULL) |
| 5237 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5238 // Further expansion! |
| 159 | 5239 temp_result = make_expanded_name(retval, expr_start, |
| 5240 expr_end, temp_result); | |
| 5241 vim_free(retval); | |
| 5242 retval = temp_result; | |
| 5243 } | |
| 5244 } | |
| 5245 | |
| 5246 return retval; | |
| 5247 } | |
| 5248 | |
| 5249 /* | |
| 7 | 5250 * Return TRUE if character "c" can be used in a variable or function name. |
| 104 | 5251 * Does not include '{' or '}' for magic braces. |
| 7 | 5252 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5253 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5254 eval_isnamec(int c) |
| 7 | 5255 { |
| 271 | 5256 return (ASCII_ISALNUM(c) || c == '_' || c == ':' || c == AUTOLOAD_CHAR); |
| 5257 } | |
| 5258 | |
| 5259 /* | |
| 5260 * Return TRUE if character "c" can be used as the first character in a | |
| 5261 * variable or function name (excluding '{' and '}'). | |
| 5262 */ | |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5263 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5264 eval_isnamec1(int c) |
| 271 | 5265 { |
| 5266 return (ASCII_ISALPHA(c) || c == '_'); | |
| 7 | 5267 } |
| 5268 | |
| 5269 /* | |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5270 * Handle: |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5271 * - 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
|
5272 * - ".name" lookup |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5273 * - 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
|
5274 * - method call: var->method() |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5275 * |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5276 * Can all be combined in any order: dict.func(expr)[idx]['func'](expr)->len() |
| 159 | 5277 */ |
|
9562
86af4a48c00a
commit https://github.com/vim/vim/commit/a9b579f3d7463720a316e11e77a7a9fbb9267986
Christian Brabandt <cb@256bit.org>
parents:
9560
diff
changeset
|
5278 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5279 handle_subscript( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5280 char_u **arg, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5281 typval_T *rettv, |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5282 int evaluate, // do more than finding the end |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5283 int verbose, // give error messages |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5284 char_u *start_leader, // start of '!' and '-' prefixes |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5285 char_u **end_leaderp) // end of '!' and '-' prefixes |
| 159 | 5286 { |
| 5287 int ret = OK; | |
| 5288 dict_T *selfdict = NULL; | |
| 5289 | |
|
17448
f8cd16838434
patch 8.1.1722: error when scriptversion is 2 a making a dictionary access
Bram Moolenaar <Bram@vim.org>
parents:
17413
diff
changeset
|
5290 // "." is ".name" lookup when we found a dict or when evaluating and |
|
f8cd16838434
patch 8.1.1722: error when scriptversion is 2 a making a dictionary access
Bram Moolenaar <Bram@vim.org>
parents:
17413
diff
changeset
|
5291 // scriptversion is at least 2, where string concatenation is "..". |
| 159 | 5292 while (ret == OK |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5293 && (((**arg == '[' |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5294 || (**arg == '.' && (rettv->v_type == VAR_DICT |
|
17448
f8cd16838434
patch 8.1.1722: error when scriptversion is 2 a making a dictionary access
Bram Moolenaar <Bram@vim.org>
parents:
17413
diff
changeset
|
5295 || (!evaluate |
|
f8cd16838434
patch 8.1.1722: error when scriptversion is 2 a making a dictionary access
Bram Moolenaar <Bram@vim.org>
parents:
17413
diff
changeset
|
5296 && (*arg)[1] != '.' |
|
f8cd16838434
patch 8.1.1722: error when scriptversion is 2 a making a dictionary access
Bram Moolenaar <Bram@vim.org>
parents:
17413
diff
changeset
|
5297 && current_sctx.sc_version >= 2))) |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5298 || (**arg == '(' && (!evaluate || rettv->v_type == VAR_FUNC |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5299 || rettv->v_type == VAR_PARTIAL))) |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5300 && !VIM_ISWHITE(*(*arg - 1))) |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5301 || (**arg == '-' && (*arg)[1] == '>'))) |
| 159 | 5302 { |
| 5303 if (**arg == '(') | |
| 5304 { | |
|
17674
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
5305 ret = call_func_rettv(arg, rettv, evaluate, selfdict, NULL); |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
5306 |
|
06c3e15ad84d
patch 8.1.1834: cannot use a lambda as a method
Bram Moolenaar <Bram@vim.org>
parents:
17661
diff
changeset
|
5307 // 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
|
5308 // 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
|
5309 // but not caught. |
| 159 | 5310 if (aborting()) |
| 5311 { | |
| 5312 if (ret == OK) | |
| 5313 clear_tv(rettv); | |
| 5314 ret = FAIL; | |
| 5315 } | |
| 5316 dict_unref(selfdict); | |
| 5317 selfdict = NULL; | |
| 5318 } | |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5319 else if (**arg == '-') |
|
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5320 { |
|
17763
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5321 // Expression "-1.0->method()" applies the leader "-" before |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5322 // applying ->. |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5323 if (evaluate && *end_leaderp > start_leader) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5324 ret = eval7_leader(rettv, start_leader, end_leaderp); |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5325 if (ret == OK) |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5326 { |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5327 if ((*arg)[2] == '{') |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5328 // expr->{lambda}() |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5329 ret = eval_lambda(arg, rettv, evaluate, verbose); |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5330 else |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5331 // expr->name() |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5332 ret = eval_method(arg, rettv, evaluate, verbose); |
|
117c7795a979
patch 8.1.1878: negative float before method not parsed correctly
Bram Moolenaar <Bram@vim.org>
parents:
17674
diff
changeset
|
5333 } |
|
17612
e259d11e2900
patch 8.1.1803: all builtin functions are global
Bram Moolenaar <Bram@vim.org>
parents:
17606
diff
changeset
|
5334 } |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5335 else // **arg == '[' || **arg == '.' |
| 159 | 5336 { |
| 5337 dict_unref(selfdict); | |
| 5338 if (rettv->v_type == VAR_DICT) | |
| 5339 { | |
| 5340 selfdict = rettv->vval.v_dict; | |
| 5341 if (selfdict != NULL) | |
| 5342 ++selfdict->dv_refcount; | |
| 5343 } | |
| 5344 else | |
| 5345 selfdict = NULL; | |
| 5346 if (eval_index(arg, rettv, evaluate, verbose) == FAIL) | |
| 5347 { | |
| 5348 clear_tv(rettv); | |
| 5349 ret = FAIL; | |
| 5350 } | |
| 5351 } | |
| 5352 } | |
|
8575
b5209a4e5baf
commit https://github.com/vim/vim/commit/ab1fa3955f25dfdb7e329c3bd76e175c93c8cb5e
Christian Brabandt <cb@256bit.org>
parents:
8554
diff
changeset
|
5353 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5354 // 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
|
5355 // 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
|
5356 // explicitly (pt_auto is FALSE). |
|
9104
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5357 if (selfdict != NULL |
|
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5358 && (rettv->v_type == VAR_FUNC |
|
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5359 || (rettv->v_type == VAR_PARTIAL |
|
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5360 && (rettv->vval.v_partial->pt_auto |
|
2242a5766417
commit https://github.com/vim/vim/commit/1d429610bf9e99a6252be8abbc910d6667e4d1da
Christian Brabandt <cb@256bit.org>
parents:
9093
diff
changeset
|
5361 || 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
|
5362 selfdict = make_partial(selfdict, rettv); |
|
8575
b5209a4e5baf
commit https://github.com/vim/vim/commit/ab1fa3955f25dfdb7e329c3bd76e175c93c8cb5e
Christian Brabandt <cb@256bit.org>
parents:
8554
diff
changeset
|
5363 |
| 159 | 5364 dict_unref(selfdict); |
| 5365 return ret; | |
| 5366 } | |
| 5367 | |
| 5368 /* | |
| 1624 | 5369 * Allocate memory for a variable type-value, and make it empty (0 or NULL |
| 56 | 5370 * value). |
| 5371 */ | |
|
7877
7fbd2de703a9
commit https://github.com/vim/vim/commit/11e0afa00a8e6c0aa1d50f760b5d5cb62dade038
Christian Brabandt <cb@256bit.org>
parents:
7864
diff
changeset
|
5372 typval_T * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5373 alloc_tv(void) |
| 56 | 5374 { |
|
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
|
5375 return ALLOC_CLEAR_ONE(typval_T); |
| 56 | 5376 } |
| 5377 | |
| 5378 /* | |
| 5379 * Allocate memory for a variable type-value, and assign a string to it. | |
| 7 | 5380 * The string "s" must have been allocated, it is consumed. |
| 5381 * Return NULL for out of memory, the variable otherwise. | |
| 5382 */ | |
|
17885
5e2d8840da11
patch 8.1.1939: code for handling v: variables in generic eval file
Bram Moolenaar <Bram@vim.org>
parents:
17873
diff
changeset
|
5383 typval_T * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5384 alloc_string_tv(char_u *s) |
| 7 | 5385 { |
| 137 | 5386 typval_T *rettv; |
| 71 | 5387 |
| 5388 rettv = alloc_tv(); | |
| 5389 if (rettv != NULL) | |
| 5390 { | |
| 5391 rettv->v_type = VAR_STRING; | |
| 5392 rettv->vval.v_string = s; | |
| 7 | 5393 } |
| 5394 else | |
| 5395 vim_free(s); | |
| 71 | 5396 return rettv; |
| 7 | 5397 } |
| 5398 | |
| 5399 /* | |
| 56 | 5400 * Free the memory for a variable type-value. |
| 5401 */ | |
| 625 | 5402 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5403 free_tv(typval_T *varp) |
| 7 | 5404 { |
| 5405 if (varp != NULL) | |
| 5406 { | |
| 56 | 5407 switch (varp->v_type) |
| 5408 { | |
| 117 | 5409 case VAR_FUNC: |
| 5410 func_unref(varp->vval.v_string); | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5411 // FALLTHROUGH |
| 56 | 5412 case VAR_STRING: |
| 5413 vim_free(varp->vval.v_string); | |
| 5414 break; | |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5415 case VAR_PARTIAL: |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5416 partial_unref(varp->vval.v_partial); |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5417 break; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5418 case VAR_BLOB: |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5419 blob_unref(varp->vval.v_blob); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5420 break; |
| 56 | 5421 case VAR_LIST: |
| 5422 list_unref(varp->vval.v_list); | |
| 5423 break; | |
| 117 | 5424 case VAR_DICT: |
| 5425 dict_unref(varp->vval.v_dict); | |
| 5426 break; | |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5427 case VAR_JOB: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5428 #ifdef FEAT_JOB_CHANNEL |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5429 job_unref(varp->vval.v_job); |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5430 break; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5431 #endif |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5432 case VAR_CHANNEL: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5433 #ifdef FEAT_JOB_CHANNEL |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5434 channel_unref(varp->vval.v_channel); |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5435 break; |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5436 #endif |
| 156 | 5437 case VAR_NUMBER: |
| 1624 | 5438 case VAR_FLOAT: |
|
19922
1f42c49c3d29
patch 8.2.0517: Vim9: cannot separate "func" and "func(): void"
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
5439 case VAR_ANY: |
| 156 | 5440 case VAR_UNKNOWN: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
5441 case VAR_VOID: |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5442 case VAR_BOOL: |
|
7768
3d8e4e0d7127
commit https://github.com/vim/vim/commit/6650a694547eb744afa060ec62dd8270e99db9f2
Christian Brabandt <cb@256bit.org>
parents:
7765
diff
changeset
|
5443 case VAR_SPECIAL: |
| 156 | 5444 break; |
| 56 | 5445 } |
| 7 | 5446 vim_free(varp); |
| 5447 } | |
| 5448 } | |
| 5449 | |
| 5450 /* | |
| 5451 * Free the memory for a variable value and set the value to NULL or 0. | |
| 5452 */ | |
| 446 | 5453 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5454 clear_tv(typval_T *varp) |
| 7 | 5455 { |
| 5456 if (varp != NULL) | |
| 5457 { | |
| 56 | 5458 switch (varp->v_type) |
| 5459 { | |
| 117 | 5460 case VAR_FUNC: |
| 5461 func_unref(varp->vval.v_string); | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5462 // FALLTHROUGH |
| 56 | 5463 case VAR_STRING: |
|
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
13037
diff
changeset
|
5464 VIM_CLEAR(varp->vval.v_string); |
| 56 | 5465 break; |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5466 case VAR_PARTIAL: |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5467 partial_unref(varp->vval.v_partial); |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5468 varp->vval.v_partial = NULL; |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5469 break; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5470 case VAR_BLOB: |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5471 blob_unref(varp->vval.v_blob); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5472 varp->vval.v_blob = NULL; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5473 break; |
| 56 | 5474 case VAR_LIST: |
| 5475 list_unref(varp->vval.v_list); | |
| 121 | 5476 varp->vval.v_list = NULL; |
| 56 | 5477 break; |
| 100 | 5478 case VAR_DICT: |
| 5479 dict_unref(varp->vval.v_dict); | |
| 121 | 5480 varp->vval.v_dict = NULL; |
| 100 | 5481 break; |
| 71 | 5482 case VAR_NUMBER: |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5483 case VAR_BOOL: |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
5484 case VAR_SPECIAL: |
| 56 | 5485 varp->vval.v_number = 0; |
| 5486 break; | |
| 1624 | 5487 case VAR_FLOAT: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5488 #ifdef FEAT_FLOAT |
| 1624 | 5489 varp->vval.v_float = 0.0; |
| 5490 break; | |
| 5491 #endif | |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5492 case VAR_JOB: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5493 #ifdef FEAT_JOB_CHANNEL |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5494 job_unref(varp->vval.v_job); |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5495 varp->vval.v_job = NULL; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5496 #endif |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5497 break; |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5498 case VAR_CHANNEL: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5499 #ifdef FEAT_JOB_CHANNEL |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5500 channel_unref(varp->vval.v_channel); |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5501 varp->vval.v_channel = NULL; |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5502 #endif |
| 71 | 5503 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
|
5504 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
|
5505 case VAR_VOID: |
| 71 | 5506 break; |
| 5507 } | |
| 151 | 5508 varp->v_lock = 0; |
| 71 | 5509 } |
| 5510 } | |
| 5511 | |
| 5512 /* | |
| 5513 * Set the value of a variable to NULL without freeing items. | |
| 5514 */ | |
|
9571
5eaa708ab50d
commit https://github.com/vim/vim/commit/73dad1e64cb42842d8259cb1a255a6fa59822f76
Christian Brabandt <cb@256bit.org>
parents:
9562
diff
changeset
|
5515 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5516 init_tv(typval_T *varp) |
| 71 | 5517 { |
| 5518 if (varp != NULL) | |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19922
diff
changeset
|
5519 CLEAR_POINTER(varp); |
| 7 | 5520 } |
| 5521 | |
| 5522 /* | |
| 5523 * Get the number value of a variable. | |
| 5524 * If it is a String variable, uses vim_str2nr(). | |
| 323 | 5525 * For incompatible types, return 0. |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5526 * tv_get_number_chk() is similar to tv_get_number(), but informs the |
| 323 | 5527 * caller of incompatible types: it sets *denote to TRUE if "denote" |
| 5528 * is not NULL or returns -1 otherwise. | |
| 7 | 5529 */ |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
5530 varnumber_T |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5531 tv_get_number(typval_T *varp) |
| 56 | 5532 { |
| 323 | 5533 int error = FALSE; |
| 5534 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5535 return tv_get_number_chk(varp, &error); // return 0L on error |
| 323 | 5536 } |
| 5537 | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
5538 varnumber_T |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5539 tv_get_number_chk(typval_T *varp, int *denote) |
| 323 | 5540 { |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
5541 varnumber_T n = 0L; |
| 56 | 5542 |
| 5543 switch (varp->v_type) | |
| 5544 { | |
| 5545 case VAR_NUMBER: | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
5546 return varp->vval.v_number; |
| 1624 | 5547 case VAR_FLOAT: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5548 #ifdef FEAT_FLOAT |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5549 emsg(_("E805: Using a Float as a Number")); |
| 1624 | 5550 break; |
| 5551 #endif | |
| 56 | 5552 case VAR_FUNC: |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5553 case VAR_PARTIAL: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5554 emsg(_("E703: Using a Funcref as a Number")); |
| 56 | 5555 break; |
| 5556 case VAR_STRING: | |
| 5557 if (varp->vval.v_string != NULL) | |
| 5558 vim_str2nr(varp->vval.v_string, NULL, NULL, | |
|
16706
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16704
diff
changeset
|
5559 STR2NR_ALL, &n, NULL, 0, FALSE); |
| 323 | 5560 return n; |
| 97 | 5561 case VAR_LIST: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5562 emsg(_("E745: Using a List as a Number")); |
| 97 | 5563 break; |
| 117 | 5564 case VAR_DICT: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5565 emsg(_("E728: Using a Dictionary as a Number")); |
| 117 | 5566 break; |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5567 case VAR_BOOL: |
|
7730
80ce794827c4
commit https://github.com/vim/vim/commit/17a13437c9414a8693369a97f3be2fc8ad48c12e
Christian Brabandt <cb@256bit.org>
parents:
7720
diff
changeset
|
5568 case VAR_SPECIAL: |
|
80ce794827c4
commit https://github.com/vim/vim/commit/17a13437c9414a8693369a97f3be2fc8ad48c12e
Christian Brabandt <cb@256bit.org>
parents:
7720
diff
changeset
|
5569 return varp->vval.v_number == VVAL_TRUE ? 1 : 0; |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5570 case VAR_JOB: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5571 #ifdef FEAT_JOB_CHANNEL |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5572 emsg(_("E910: Using a Job as a Number")); |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5573 break; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5574 #endif |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5575 case VAR_CHANNEL: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5576 #ifdef FEAT_JOB_CHANNEL |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5577 emsg(_("E913: Using a Channel as a Number")); |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5578 break; |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5579 #endif |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5580 case VAR_BLOB: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5581 emsg(_("E974: Using a Blob as a Number")); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5582 break; |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
5583 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
|
5584 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
|
5585 case VAR_VOID: |
|
19554
b38d73f36467
patch 8.2.0334: abort called when using test_void()
Bram Moolenaar <Bram@vim.org>
parents:
19477
diff
changeset
|
5586 internal_error_no_abort("tv_get_number(UNKNOWN)"); |
| 56 | 5587 break; |
| 5588 } | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5589 if (denote == NULL) // useful for values that must be unsigned |
| 323 | 5590 n = -1; |
| 5591 else | |
| 5592 *denote = TRUE; | |
| 56 | 5593 return n; |
| 7 | 5594 } |
| 5595 | |
|
7689
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5596 #ifdef FEAT_FLOAT |
|
9571
5eaa708ab50d
commit https://github.com/vim/vim/commit/73dad1e64cb42842d8259cb1a255a6fa59822f76
Christian Brabandt <cb@256bit.org>
parents:
9562
diff
changeset
|
5597 float_T |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5598 tv_get_float(typval_T *varp) |
|
7689
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5599 { |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5600 switch (varp->v_type) |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5601 { |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5602 case VAR_NUMBER: |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5603 return (float_T)(varp->vval.v_number); |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5604 case VAR_FLOAT: |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5605 return varp->vval.v_float; |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5606 case VAR_FUNC: |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5607 case VAR_PARTIAL: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5608 emsg(_("E891: Using a Funcref as a Float")); |
|
7689
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5609 break; |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5610 case VAR_STRING: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5611 emsg(_("E892: Using a String as a Float")); |
|
7689
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5612 break; |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5613 case VAR_LIST: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5614 emsg(_("E893: Using a List as a Float")); |
|
7689
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5615 break; |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5616 case VAR_DICT: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5617 emsg(_("E894: Using a Dictionary as a Float")); |
|
7689
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5618 break; |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5619 case VAR_BOOL: |
|
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5620 emsg(_("E362: Using a boolean value as a Float")); |
|
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5621 break; |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
5622 case VAR_SPECIAL: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5623 emsg(_("E907: Using a special value as a Float")); |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
5624 break; |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5625 case VAR_JOB: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5626 # ifdef FEAT_JOB_CHANNEL |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5627 emsg(_("E911: Using a Job as a Float")); |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5628 break; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5629 # endif |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5630 case VAR_CHANNEL: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5631 # ifdef FEAT_JOB_CHANNEL |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5632 emsg(_("E914: Using a Channel as a Float")); |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5633 break; |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5634 # endif |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5635 case VAR_BLOB: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5636 emsg(_("E975: Using a Blob as a Float")); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5637 break; |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
5638 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
|
5639 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
|
5640 case VAR_VOID: |
|
19554
b38d73f36467
patch 8.2.0334: abort called when using test_void()
Bram Moolenaar <Bram@vim.org>
parents:
19477
diff
changeset
|
5641 internal_error_no_abort("tv_get_float(UNKNOWN)"); |
|
7689
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5642 break; |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5643 } |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5644 return 0; |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5645 } |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5646 #endif |
|
20dc2763a3b9
commit https://github.com/vim/vim/commit/f7edf40448a09e04eec3bd05e043f7fea93b07c9
Christian Brabandt <cb@256bit.org>
parents:
7683
diff
changeset
|
5647 |
| 7 | 5648 /* |
| 5649 * Get the string value of a variable. | |
| 5650 * If it is a Number variable, the number is converted into a string. | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5651 * tv_get_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE! |
|
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5652 * tv_get_string_buf() uses a given buffer. |
| 7 | 5653 * If the String variable has never been set, return an empty string. |
| 5654 * Never returns NULL; | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5655 * tv_get_string_chk() and tv_get_string_buf_chk() are similar, but return |
| 323 | 5656 * NULL on error. |
| 7 | 5657 */ |
|
8498
42277980a76d
commit https://github.com/vim/vim/commit/8e2c942ce49f2555d7dc2088cf3aa856820c5e32
Christian Brabandt <cb@256bit.org>
parents:
8493
diff
changeset
|
5658 char_u * |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5659 tv_get_string(typval_T *varp) |
| 7 | 5660 { |
| 5661 static char_u mybuf[NUMBUFLEN]; | |
| 5662 | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5663 return tv_get_string_buf(varp, mybuf); |
| 7 | 5664 } |
| 5665 | |
|
8498
42277980a76d
commit https://github.com/vim/vim/commit/8e2c942ce49f2555d7dc2088cf3aa856820c5e32
Christian Brabandt <cb@256bit.org>
parents:
8493
diff
changeset
|
5666 char_u * |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5667 tv_get_string_buf(typval_T *varp, char_u *buf) |
|
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5668 { |
|
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5669 char_u *res = tv_get_string_buf_chk(varp, buf); |
| 323 | 5670 |
| 5671 return res != NULL ? res : (char_u *)""; | |
| 5672 } | |
| 5673 | |
| 5810 | 5674 /* |
| 5675 * Careful: This uses a single, static buffer. YOU CAN ONLY USE IT ONCE! | |
| 5676 */ | |
| 449 | 5677 char_u * |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5678 tv_get_string_chk(typval_T *varp) |
| 323 | 5679 { |
| 5680 static char_u mybuf[NUMBUFLEN]; | |
| 5681 | |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5682 return tv_get_string_buf_chk(varp, mybuf); |
| 323 | 5683 } |
| 5684 | |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
5685 char_u * |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
5686 tv_get_string_buf_chk(typval_T *varp, char_u *buf) |
| 323 | 5687 { |
| 56 | 5688 switch (varp->v_type) |
| 5689 { | |
| 5690 case VAR_NUMBER: | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
5691 vim_snprintf((char *)buf, NUMBUFLEN, "%lld", |
|
19477
2bb0e80fcd32
patch 8.2.0296: mixing up "long long" and __int64 may cause problems
Bram Moolenaar <Bram@vim.org>
parents:
19201
diff
changeset
|
5692 (varnumber_T)varp->vval.v_number); |
| 56 | 5693 return buf; |
| 5694 case VAR_FUNC: | |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5695 case VAR_PARTIAL: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5696 emsg(_("E729: using Funcref as a String")); |
| 56 | 5697 break; |
| 5698 case VAR_LIST: | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5699 emsg(_("E730: using List as a String")); |
| 100 | 5700 break; |
| 5701 case VAR_DICT: | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5702 emsg(_("E731: using Dictionary as a String")); |
| 56 | 5703 break; |
| 1624 | 5704 case VAR_FLOAT: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5705 #ifdef FEAT_FLOAT |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5706 emsg(_(e_float_as_string)); |
| 1624 | 5707 break; |
| 5708 #endif | |
| 56 | 5709 case VAR_STRING: |
| 5710 if (varp->vval.v_string != NULL) | |
| 5711 return varp->vval.v_string; | |
| 323 | 5712 return (char_u *)""; |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5713 case VAR_BOOL: |
|
7730
80ce794827c4
commit https://github.com/vim/vim/commit/17a13437c9414a8693369a97f3be2fc8ad48c12e
Christian Brabandt <cb@256bit.org>
parents:
7720
diff
changeset
|
5714 case VAR_SPECIAL: |
|
80ce794827c4
commit https://github.com/vim/vim/commit/17a13437c9414a8693369a97f3be2fc8ad48c12e
Christian Brabandt <cb@256bit.org>
parents:
7720
diff
changeset
|
5715 STRCPY(buf, get_var_special_name(varp->vval.v_number)); |
|
80ce794827c4
commit https://github.com/vim/vim/commit/17a13437c9414a8693369a97f3be2fc8ad48c12e
Christian Brabandt <cb@256bit.org>
parents:
7720
diff
changeset
|
5716 return buf; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5717 case VAR_BLOB: |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5718 emsg(_("E976: using Blob as a String")); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5719 break; |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5720 case VAR_JOB: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5721 #ifdef FEAT_JOB_CHANNEL |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5722 { |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5723 job_T *job = varp->vval.v_job; |
|
8424
be45d4921f1f
commit https://github.com/vim/vim/commit/839fd11d7ed1a96bace3159c4d1861658864aae3
Christian Brabandt <cb@256bit.org>
parents:
8386
diff
changeset
|
5724 char *status; |
|
be45d4921f1f
commit https://github.com/vim/vim/commit/839fd11d7ed1a96bace3159c4d1861658864aae3
Christian Brabandt <cb@256bit.org>
parents:
8386
diff
changeset
|
5725 |
|
be45d4921f1f
commit https://github.com/vim/vim/commit/839fd11d7ed1a96bace3159c4d1861658864aae3
Christian Brabandt <cb@256bit.org>
parents:
8386
diff
changeset
|
5726 if (job == NULL) |
|
be45d4921f1f
commit https://github.com/vim/vim/commit/839fd11d7ed1a96bace3159c4d1861658864aae3
Christian Brabandt <cb@256bit.org>
parents:
8386
diff
changeset
|
5727 return (char_u *)"no process"; |
|
be45d4921f1f
commit https://github.com/vim/vim/commit/839fd11d7ed1a96bace3159c4d1861658864aae3
Christian Brabandt <cb@256bit.org>
parents:
8386
diff
changeset
|
5728 status = job->jv_status == JOB_FAILED ? "fail" |
|
10386
d3f0946b4a80
commit https://github.com/vim/vim/commit/7df915d113ac1981792c50e8b000c9f5f784b78b
Christian Brabandt <cb@256bit.org>
parents:
10381
diff
changeset
|
5729 : job->jv_status >= JOB_ENDED ? "dead" |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5730 : "run"; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5731 # ifdef UNIX |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5732 vim_snprintf((char *)buf, NUMBUFLEN, |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5733 "process %ld %s", (long)job->jv_pid, status); |
|
15868
7fad90423bd2
patch 8.1.0941: macros for MS-Windows are inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15790
diff
changeset
|
5734 # elif defined(MSWIN) |
|
8001
e5dbeb923ce6
commit https://github.com/vim/vim/commit/4d8747cdfc13843a5680dc8340fbeb6d32e7b626
Christian Brabandt <cb@256bit.org>
parents:
7995
diff
changeset
|
5735 vim_snprintf((char *)buf, NUMBUFLEN, |
|
8023
75e0831549f1
commit https://github.com/vim/vim/commit/76467dfcafcf295fd987f712730774c6f55317d3
Christian Brabandt <cb@256bit.org>
parents:
8019
diff
changeset
|
5736 "process %ld %s", |
|
75e0831549f1
commit https://github.com/vim/vim/commit/76467dfcafcf295fd987f712730774c6f55317d3
Christian Brabandt <cb@256bit.org>
parents:
8019
diff
changeset
|
5737 (long)job->jv_proc_info.dwProcessId, |
|
8001
e5dbeb923ce6
commit https://github.com/vim/vim/commit/4d8747cdfc13843a5680dc8340fbeb6d32e7b626
Christian Brabandt <cb@256bit.org>
parents:
7995
diff
changeset
|
5738 status); |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5739 # else |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5740 // fall-back |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5741 vim_snprintf((char *)buf, NUMBUFLEN, "process ? %s", status); |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5742 # endif |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5743 return buf; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5744 } |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5745 #endif |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5746 break; |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5747 case VAR_CHANNEL: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5748 #ifdef FEAT_JOB_CHANNEL |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5749 { |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5750 channel_T *channel = varp->vval.v_channel; |
|
10235
ad6851687158
commit https://github.com/vim/vim/commit/0e77b7691ee7c477facb4c9d9162c8603ada2d84
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
5751 char *status = channel_status(channel, -1); |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5752 |
|
8070
e4c3f6720b03
commit https://github.com/vim/vim/commit/5cefd4098204b4677387511b586673649f2fab48
Christian Brabandt <cb@256bit.org>
parents:
8062
diff
changeset
|
5753 if (channel == NULL) |
|
e4c3f6720b03
commit https://github.com/vim/vim/commit/5cefd4098204b4677387511b586673649f2fab48
Christian Brabandt <cb@256bit.org>
parents:
8062
diff
changeset
|
5754 vim_snprintf((char *)buf, NUMBUFLEN, "channel %s", status); |
|
e4c3f6720b03
commit https://github.com/vim/vim/commit/5cefd4098204b4677387511b586673649f2fab48
Christian Brabandt <cb@256bit.org>
parents:
8062
diff
changeset
|
5755 else |
|
e4c3f6720b03
commit https://github.com/vim/vim/commit/5cefd4098204b4677387511b586673649f2fab48
Christian Brabandt <cb@256bit.org>
parents:
8062
diff
changeset
|
5756 vim_snprintf((char *)buf, NUMBUFLEN, |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5757 "channel %d %s", channel->ch_id, status); |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5758 return buf; |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5759 } |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5760 #endif |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5761 break; |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
5762 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
|
5763 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
|
5764 case VAR_VOID: |
|
19085
fd1070ff696b
patch 8.2.0103: using null object with execute() has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19081
diff
changeset
|
5765 emsg(_(e_inval_string)); |
| 56 | 5766 break; |
| 5767 } | |
| 323 | 5768 return NULL; |
| 7 | 5769 } |
| 5770 | |
| 5771 /* | |
|
15219
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5772 * Turn a typeval into a string. Similar to tv_get_string_buf() but uses |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5773 * string() on Dict, List, etc. |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5774 */ |
|
17789
0f7ae8010787
patch 8.1.1891: functions used in one file are global
Bram Moolenaar <Bram@vim.org>
parents:
17781
diff
changeset
|
5775 static char_u * |
|
15219
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5776 tv_stringify(typval_T *varp, char_u *buf) |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5777 { |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5778 if (varp->v_type == VAR_LIST |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5779 || varp->v_type == VAR_DICT |
|
19081
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
5780 || varp->v_type == VAR_BLOB |
|
15219
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5781 || varp->v_type == VAR_FUNC |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5782 || varp->v_type == VAR_PARTIAL |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5783 || varp->v_type == VAR_FLOAT) |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5784 { |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5785 typval_T tmp; |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5786 |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5787 f_string(varp, &tmp); |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5788 tv_get_string_buf(&tmp, buf); |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5789 clear_tv(varp); |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5790 *varp = tmp; |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5791 return tmp.vval.v_string; |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5792 } |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5793 return tv_get_string_buf(varp, buf); |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5794 } |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5795 |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
5796 /* |
|
15780
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5797 * Return TRUE if typeval "tv" and its value are set to be locked (immutable). |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5798 * Also give an error message, using "name" or _("name") when use_gettext is |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5799 * TRUE. |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5800 */ |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5801 static int |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5802 tv_check_lock(typval_T *tv, char_u *name, int use_gettext) |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5803 { |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5804 int lock = 0; |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5805 |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5806 switch (tv->v_type) |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5807 { |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5808 case VAR_BLOB: |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5809 if (tv->vval.v_blob != NULL) |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5810 lock = tv->vval.v_blob->bv_lock; |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5811 break; |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5812 case VAR_LIST: |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5813 if (tv->vval.v_list != NULL) |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5814 lock = tv->vval.v_list->lv_lock; |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5815 break; |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5816 case VAR_DICT: |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5817 if (tv->vval.v_dict != NULL) |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5818 lock = tv->vval.v_dict->dv_lock; |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5819 break; |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5820 default: |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5821 break; |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5822 } |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5823 return var_check_lock(tv->v_lock, name, use_gettext) |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5824 || (lock != 0 && var_check_lock(lock, name, use_gettext)); |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5825 } |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5826 |
|
5b6c3c7feba8
patch 8.1.0897: can modify a:000 when using a reference
Bram Moolenaar <Bram@vim.org>
parents:
15770
diff
changeset
|
5827 /* |
| 137 | 5828 * Copy the values from typval_T "from" to typval_T "to". |
| 56 | 5829 * When needed allocates string or increases reference count. |
|
15581
c2382f0d1279
patch 8.1.0798: changing a blob while iterating over it works strangely
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
5830 * Does not make a copy of a list, blob or dict but copies the reference! |
| 1772 | 5831 * It is OK for "from" and "to" to point to the same item. This is used to |
| 5832 * make a copy later. | |
| 56 | 5833 */ |
|
2050
afcf9db31561
updated for version 7.2.336
Bram Moolenaar <bram@zimbu.org>
parents:
2045
diff
changeset
|
5834 void |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5835 copy_tv(typval_T *from, typval_T *to) |
| 56 | 5836 { |
| 5837 to->v_type = from->v_type; | |
| 151 | 5838 to->v_lock = 0; |
| 56 | 5839 switch (from->v_type) |
| 5840 { | |
| 5841 case VAR_NUMBER: | |
|
19102
ba9f50bfda83
patch 8.2.0111: VAR_SPECIAL is also used for booleans
Bram Moolenaar <Bram@vim.org>
parents:
19087
diff
changeset
|
5842 case VAR_BOOL: |
|
7712
bce3b5ddb393
commit https://github.com/vim/vim/commit/520e1e41f35b063ede63b41738c82d6636e78c34
Christian Brabandt <cb@256bit.org>
parents:
7705
diff
changeset
|
5843 case VAR_SPECIAL: |
| 56 | 5844 to->vval.v_number = from->vval.v_number; |
| 5845 break; | |
| 1624 | 5846 case VAR_FLOAT: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5847 #ifdef FEAT_FLOAT |
| 1624 | 5848 to->vval.v_float = from->vval.v_float; |
| 5849 break; | |
| 5850 #endif | |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5851 case VAR_JOB: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5852 #ifdef FEAT_JOB_CHANNEL |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5853 to->vval.v_job = from->vval.v_job; |
|
8174
f2286ff0c102
commit https://github.com/vim/vim/commit/ee1cffc07a42441924c5353af7fd7ab6e97e5aae
Christian Brabandt <cb@256bit.org>
parents:
8170
diff
changeset
|
5854 if (to->vval.v_job != NULL) |
|
f2286ff0c102
commit https://github.com/vim/vim/commit/ee1cffc07a42441924c5353af7fd7ab6e97e5aae
Christian Brabandt <cb@256bit.org>
parents:
8170
diff
changeset
|
5855 ++to->vval.v_job->jv_refcount; |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5856 break; |
|
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5857 #endif |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5858 case VAR_CHANNEL: |
|
8493
caed4b2d305f
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821
Christian Brabandt <cb@256bit.org>
parents:
8491
diff
changeset
|
5859 #ifdef FEAT_JOB_CHANNEL |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5860 to->vval.v_channel = from->vval.v_channel; |
|
8070
e4c3f6720b03
commit https://github.com/vim/vim/commit/5cefd4098204b4677387511b586673649f2fab48
Christian Brabandt <cb@256bit.org>
parents:
8062
diff
changeset
|
5861 if (to->vval.v_channel != NULL) |
|
e4c3f6720b03
commit https://github.com/vim/vim/commit/5cefd4098204b4677387511b586673649f2fab48
Christian Brabandt <cb@256bit.org>
parents:
8062
diff
changeset
|
5862 ++to->vval.v_channel->ch_refcount; |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5863 break; |
|
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5864 #endif |
| 56 | 5865 case VAR_STRING: |
| 5866 case VAR_FUNC: | |
| 5867 if (from->vval.v_string == NULL) | |
| 5868 to->vval.v_string = NULL; | |
| 5869 else | |
| 117 | 5870 { |
| 56 | 5871 to->vval.v_string = vim_strsave(from->vval.v_string); |
| 117 | 5872 if (from->v_type == VAR_FUNC) |
| 5873 func_ref(to->vval.v_string); | |
| 5874 } | |
| 56 | 5875 break; |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5876 case VAR_PARTIAL: |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5877 if (from->vval.v_partial == NULL) |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5878 to->vval.v_partial = NULL; |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5879 else |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5880 { |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5881 to->vval.v_partial = from->vval.v_partial; |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5882 ++to->vval.v_partial->pt_refcount; |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5883 } |
|
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5884 break; |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5885 case VAR_BLOB: |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5886 if (from->vval.v_blob == NULL) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5887 to->vval.v_blob = NULL; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5888 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5889 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5890 to->vval.v_blob = from->vval.v_blob; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5891 ++to->vval.v_blob->bv_refcount; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5892 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
5893 break; |
| 56 | 5894 case VAR_LIST: |
| 5895 if (from->vval.v_list == NULL) | |
| 5896 to->vval.v_list = NULL; | |
| 5897 else | |
| 5898 { | |
| 5899 to->vval.v_list = from->vval.v_list; | |
| 5900 ++to->vval.v_list->lv_refcount; | |
| 5901 } | |
| 5902 break; | |
| 100 | 5903 case VAR_DICT: |
| 5904 if (from->vval.v_dict == NULL) | |
| 5905 to->vval.v_dict = NULL; | |
| 5906 else | |
| 5907 { | |
| 5908 to->vval.v_dict = from->vval.v_dict; | |
| 5909 ++to->vval.v_dict->dv_refcount; | |
| 5910 } | |
| 5911 break; | |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
5912 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
|
5913 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
|
5914 case VAR_VOID: |
|
19554
b38d73f36467
patch 8.2.0334: abort called when using test_void()
Bram Moolenaar <Bram@vim.org>
parents:
19477
diff
changeset
|
5915 internal_error_no_abort("copy_tv(UNKNOWN)"); |
| 56 | 5916 break; |
| 5917 } | |
| 7 | 5918 } |
| 5919 | |
| 5920 /* | |
| 104 | 5921 * Make a copy of an item. |
| 5922 * Lists and Dictionaries are also copied. A deep copy if "deep" is set. | |
| 165 | 5923 * For deepcopy() "copyID" is zero for a full copy or the ID for when a |
| 5924 * reference to an already copied list/dict can be used. | |
| 5925 * Returns FAIL or OK. | |
| 5926 */ | |
|
9556
afaff1d283d3
commit https://github.com/vim/vim/commit/cd52459c387785796713826c63174cdeed295dd4
Christian Brabandt <cb@256bit.org>
parents:
9527
diff
changeset
|
5927 int |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5928 item_copy( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5929 typval_T *from, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5930 typval_T *to, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5931 int deep, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
5932 int copyID) |
| 104 | 5933 { |
| 5934 static int recurse = 0; | |
| 165 | 5935 int ret = OK; |
| 104 | 5936 |
| 137 | 5937 if (recurse >= DICT_MAXNEST) |
| 104 | 5938 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
5939 emsg(_("E698: variable nested too deep for making a copy")); |
| 165 | 5940 return FAIL; |
| 104 | 5941 } |
| 5942 ++recurse; | |
| 5943 | |
| 5944 switch (from->v_type) | |
| 5945 { | |
| 5946 case VAR_NUMBER: | |
| 1624 | 5947 case VAR_FLOAT: |
| 104 | 5948 case VAR_STRING: |
| 5949 case VAR_FUNC: | |
|
8538
c337c813c64d
commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710
Christian Brabandt <cb@256bit.org>
parents:
8536
diff
changeset
|
5950 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
|
5951 case VAR_BOOL: |
|
7862
d4fec9208e7e
commit https://github.com/vim/vim/commit/155500077c80cdb5d9c63996000c011b66a676bf
Christian Brabandt <cb@256bit.org>
parents:
7856
diff
changeset
|
5952 case VAR_SPECIAL: |
|
7957
b74549818500
commit https://github.com/vim/vim/commit/835dc636a5350f610b62f110227d2363b5b2880a
Christian Brabandt <cb@256bit.org>
parents:
7955
diff
changeset
|
5953 case VAR_JOB: |
|
8041
c6443e78cf2d
commit https://github.com/vim/vim/commit/7707344ddec9069b495b2a5ed41f2104466fc88b
Christian Brabandt <cb@256bit.org>
parents:
8031
diff
changeset
|
5954 case VAR_CHANNEL: |
| 104 | 5955 copy_tv(from, to); |
| 5956 break; | |
| 5957 case VAR_LIST: | |
| 5958 to->v_type = VAR_LIST; | |
| 151 | 5959 to->v_lock = 0; |
| 165 | 5960 if (from->vval.v_list == NULL) |
| 5961 to->vval.v_list = NULL; | |
| 5962 else if (copyID != 0 && from->vval.v_list->lv_copyID == copyID) | |
| 5963 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5964 // use the copy made earlier |
| 165 | 5965 to->vval.v_list = from->vval.v_list->lv_copylist; |
| 5966 ++to->vval.v_list->lv_refcount; | |
| 5967 } | |
| 5968 else | |
| 5969 to->vval.v_list = list_copy(from->vval.v_list, deep, copyID); | |
| 5970 if (to->vval.v_list == NULL) | |
| 5971 ret = FAIL; | |
| 104 | 5972 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
|
5973 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
|
5974 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
|
5975 break; |
| 104 | 5976 case VAR_DICT: |
| 5977 to->v_type = VAR_DICT; | |
| 151 | 5978 to->v_lock = 0; |
| 165 | 5979 if (from->vval.v_dict == NULL) |
| 5980 to->vval.v_dict = NULL; | |
| 5981 else if (copyID != 0 && from->vval.v_dict->dv_copyID == copyID) | |
| 5982 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
5983 // use the copy made earlier |
| 165 | 5984 to->vval.v_dict = from->vval.v_dict->dv_copydict; |
| 5985 ++to->vval.v_dict->dv_refcount; | |
| 5986 } | |
| 5987 else | |
| 5988 to->vval.v_dict = dict_copy(from->vval.v_dict, deep, copyID); | |
| 5989 if (to->vval.v_dict == NULL) | |
| 5990 ret = FAIL; | |
| 104 | 5991 break; |
|
7943
e875f0fbd9c0
commit https://github.com/vim/vim/commit/a03f23351588f04276469cd7742b7ec655bb604b
Christian Brabandt <cb@256bit.org>
parents:
7937
diff
changeset
|
5992 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
|
5993 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
|
5994 case VAR_VOID: |
|
19554
b38d73f36467
patch 8.2.0334: abort called when using test_void()
Bram Moolenaar <Bram@vim.org>
parents:
19477
diff
changeset
|
5995 internal_error_no_abort("item_copy(UNKNOWN)"); |
| 165 | 5996 ret = FAIL; |
| 104 | 5997 } |
| 5998 --recurse; | |
| 165 | 5999 return ret; |
| 104 | 6000 } |
| 6001 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6002 void |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6003 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
|
6004 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6005 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
|
6006 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
|
6007 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
|
6008 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6009 if (*atstart) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6010 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6011 *atstart = FALSE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6012 // 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
|
6013 // 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
|
6014 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
|
6015 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6016 // 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
|
6017 // 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
|
6018 // 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
|
6019 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
|
6020 msg_start(); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6021 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6022 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6023 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
|
6024 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
|
6025 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6026 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
|
6027 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
|
6028 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6029 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
|
6030 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6031 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
|
6032 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6033 // 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
|
6034 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
|
6035 *needclr = FALSE; |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6036 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6037 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
|
6038 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6039 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6040 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6041 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
|
6042 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6043 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
|
6044 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6045 (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
|
6046 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
|
6047 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6048 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6049 (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
|
6050 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6051 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6052 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
|
6053 } |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6054 |
| 104 | 6055 /* |
| 7 | 6056 * ":echo expr1 ..." print each argument separated with a space, add a |
| 6057 * newline at the end. | |
| 6058 * ":echon expr1 ..." print each argument plain. | |
| 6059 */ | |
| 6060 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6061 ex_echo(exarg_T *eap) |
| 7 | 6062 { |
| 6063 char_u *arg = eap->arg; | |
| 137 | 6064 typval_T rettv; |
| 7 | 6065 char_u *p; |
| 6066 int needclr = TRUE; | |
| 6067 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
|
6068 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
|
6069 int called_emsg_before = called_emsg; |
| 7 | 6070 |
| 6071 if (eap->skip) | |
| 6072 ++emsg_skip; | |
|
20059
de756b3f4dee
patch 8.2.0585: Vim9: # comment not recognized after :vim9script
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
6073 while ((!ends_excmd2(eap->cmd, arg) || *arg == '"') && !got_int) |
| 7 | 6074 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6075 // 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
|
6076 // still need to be cleared. E.g., "echo 22,44". |
| 1624 | 6077 need_clr_eos = needclr; |
| 6078 | |
| 7 | 6079 p = arg; |
| 71 | 6080 if (eval1(&arg, &rettv, !eap->skip) == FAIL) |
| 7 | 6081 { |
| 6082 /* | |
| 6083 * Report the invalid expression unless the expression evaluation | |
| 6084 * has been cancelled due to an aborting error, an interrupt, or an | |
| 6085 * exception. | |
| 6086 */ | |
|
15456
f01eb1aed348
patch 8.1.0736: code for Blob not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15454
diff
changeset
|
6087 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
|
6088 && called_emsg == called_emsg_before) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6089 semsg(_(e_invexpr2), p); |
| 1624 | 6090 need_clr_eos = FALSE; |
| 6091 break; | |
| 6092 } | |
| 6093 need_clr_eos = FALSE; | |
| 6094 | |
| 7 | 6095 if (!eap->skip) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6096 echo_one(&rettv, eap->cmdidx == CMD_echo, &atstart, &needclr); |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6097 |
| 71 | 6098 clear_tv(&rettv); |
| 7 | 6099 arg = skipwhite(arg); |
| 6100 } | |
| 6101 eap->nextcmd = check_nextcmd(arg); | |
| 6102 | |
| 6103 if (eap->skip) | |
| 6104 --emsg_skip; | |
| 6105 else | |
| 6106 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6107 // remove text that may still be there from the command |
| 7 | 6108 if (needclr) |
| 6109 msg_clr_eos(); | |
| 6110 if (eap->cmdidx == CMD_echo) | |
| 6111 msg_end(); | |
| 6112 } | |
| 6113 } | |
| 6114 | |
| 6115 /* | |
| 6116 * ":echohl {name}". | |
| 6117 */ | |
| 6118 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6119 ex_echohl(exarg_T *eap) |
| 7 | 6120 { |
|
12487
3f16cf18386c
patch 8.0.1123: cannot define a toolbar for a window
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
6121 echo_attr = syn_name2attr(eap->arg); |
| 7 | 6122 } |
| 6123 | |
| 6124 /* | |
|
17922
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6125 * 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
|
6126 */ |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6127 int |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6128 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
|
6129 { |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6130 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
|
6131 } |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6132 |
|
4d63d47d87ef
patch 8.1.1957: more code can be moved to evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
17893
diff
changeset
|
6133 /* |
| 7 | 6134 * ":execute expr1 ..." execute the result of an expression. |
| 6135 * ":echomsg expr1 ..." Print a message | |
| 6136 * ":echoerr expr1 ..." Print an error | |
| 6137 * Each gets spaces around each argument and a newline at the end for | |
| 6138 * echo commands | |
| 6139 */ | |
| 6140 void | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6141 ex_execute(exarg_T *eap) |
| 7 | 6142 { |
| 6143 char_u *arg = eap->arg; | |
| 137 | 6144 typval_T rettv; |
| 7 | 6145 int ret = OK; |
| 6146 char_u *p; | |
| 6147 garray_T ga; | |
| 6148 int len; | |
| 6149 | |
| 6150 ga_init2(&ga, 1, 80); | |
| 6151 | |
| 6152 if (eap->skip) | |
| 6153 ++emsg_skip; | |
|
20061
6e6a75800884
patch 8.2.0586: Vim9: # comment not sufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
20059
diff
changeset
|
6154 while (!ends_excmd2(eap->cmd, arg) || *arg == '"') |
| 7 | 6155 { |
|
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
|
6156 ret = eval1_emsg(&arg, &rettv, !eap->skip); |
|
051937ebaf22
patch 8.1.0747: map() with a bad expression doesn't give an error
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
6157 if (ret == FAIL) |
| 7 | 6158 break; |
| 6159 | |
| 6160 if (!eap->skip) | |
| 6161 { | |
|
15219
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6162 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
|
6163 |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6164 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
|
6165 { |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6166 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
|
6167 { |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6168 emsg(_(e_inval_string)); |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6169 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
|
6170 } |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6171 else |
|
e3848b251a01
patch 8.2.0104: using channel or job with ":execute" has strange effects
Bram Moolenaar <Bram@vim.org>
parents:
19085
diff
changeset
|
6172 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
|
6173 } |
|
15219
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6174 else |
|
dada0b389d4f
patch 8.1.0619: :echomsg and :echoerr do not handle List and Dict
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
6175 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
|
6176 if (p == NULL) |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6177 { |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6178 clear_tv(&rettv); |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6179 ret = FAIL; |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6180 break; |
|
3b1f83fdaabc
patch 8.2.0101: crash when passing null object to ":echomsg"
Bram Moolenaar <Bram@vim.org>
parents:
19047
diff
changeset
|
6181 } |
| 7 | 6182 len = (int)STRLEN(p); |
| 6183 if (ga_grow(&ga, len + 2) == FAIL) | |
| 6184 { | |
| 71 | 6185 clear_tv(&rettv); |
| 7 | 6186 ret = FAIL; |
| 6187 break; | |
| 6188 } | |
| 6189 if (ga.ga_len) | |
| 6190 ((char_u *)(ga.ga_data))[ga.ga_len++] = ' '; | |
| 6191 STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p); | |
| 6192 ga.ga_len += len; | |
| 6193 } | |
| 6194 | |
| 71 | 6195 clear_tv(&rettv); |
| 7 | 6196 arg = skipwhite(arg); |
| 6197 } | |
| 6198 | |
| 6199 if (ret != FAIL && ga.ga_data != NULL) | |
| 6200 { | |
|
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
|
6201 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
|
6202 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6203 // 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
|
6204 // 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
|
6205 // 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
|
6206 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
|
6207 } |
|
404e98047f0b
patch 8.0.0467: using g< after :for does not show the right output
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
6208 |
| 7 | 6209 if (eap->cmdidx == CMD_echomsg) |
| 625 | 6210 { |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15517
diff
changeset
|
6211 msg_attr(ga.ga_data, echo_attr); |
| 625 | 6212 out_flush(); |
| 6213 } | |
| 7 | 6214 else if (eap->cmdidx == CMD_echoerr) |
| 6215 { | |
|
20142
fe8d0a4344df
patch 8.2.0626: Vim9: wrong syntax of function in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
20128
diff
changeset
|
6216 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
|
6217 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6218 // 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
|
6219 emsg(ga.ga_data); |
| 7 | 6220 if (!force_abort) |
| 6221 did_emsg = save_did_emsg; | |
| 6222 } | |
| 6223 else if (eap->cmdidx == CMD_execute) | |
| 6224 do_cmdline((char_u *)ga.ga_data, | |
| 6225 eap->getline, eap->cookie, DOCMD_NOWAIT|DOCMD_VERBOSE); | |
| 6226 } | |
| 6227 | |
| 6228 ga_clear(&ga); | |
| 6229 | |
| 6230 if (eap->skip) | |
| 6231 --emsg_skip; | |
| 6232 | |
| 6233 eap->nextcmd = check_nextcmd(arg); | |
| 6234 } | |
| 6235 | |
| 6236 /* | |
| 6237 * Skip over the name of an option: "&option", "&g:option" or "&l:option". | |
| 6238 * "arg" points to the "&" or '+' when called, to "option" when returning. | |
| 6239 * Returns NULL when no option name found. Otherwise pointer to the char | |
| 6240 * after the option name. | |
| 6241 */ | |
|
17873
d50a5faa75bd
patch 8.1.1933: the eval.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17833
diff
changeset
|
6242 char_u * |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6243 find_option_end(char_u **arg, int *opt_flags) |
| 7 | 6244 { |
| 6245 char_u *p = *arg; | |
| 6246 | |
| 6247 ++p; | |
| 6248 if (*p == 'g' && p[1] == ':') | |
| 6249 { | |
| 6250 *opt_flags = OPT_GLOBAL; | |
| 6251 p += 2; | |
| 6252 } | |
| 6253 else if (*p == 'l' && p[1] == ':') | |
| 6254 { | |
| 6255 *opt_flags = OPT_LOCAL; | |
| 6256 p += 2; | |
| 6257 } | |
| 6258 else | |
| 6259 *opt_flags = 0; | |
| 6260 | |
| 6261 if (!ASCII_ISALPHA(*p)) | |
| 6262 return NULL; | |
| 6263 *arg = p; | |
| 6264 | |
| 6265 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
|
6266 p += 4; // termcap option |
| 7 | 6267 else |
| 6268 while (ASCII_ISALPHA(*p)) | |
| 6269 ++p; | |
| 6270 return p; | |
| 6271 } | |
| 6272 | |
| 6273 /* | |
| 448 | 6274 * Display script name where an item was last set. |
| 6275 * Should only be invoked when 'verbose' is non-zero. | |
| 6276 */ | |
| 6277 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
|
6278 last_set_msg(sctx_T script_ctx) |
| 448 | 6279 { |
| 507 | 6280 char_u *p; |
| 6281 | |
|
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
|
6282 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
|
6283 { |
|
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6284 p = home_replace_save(NULL, get_scriptname(script_ctx.sc_sid)); |
| 507 | 6285 if (p != NULL) |
| 6286 { | |
| 6287 verbose_enter(); | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15517
diff
changeset
|
6288 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
|
6289 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
|
6290 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
|
6291 { |
|
18939
25ebc35e104f
patch 8.2.0030: "gF" does not work on output of "verbose command"
Bram Moolenaar <Bram@vim.org>
parents:
18851
diff
changeset
|
6292 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
|
6293 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
|
6294 } |
|
0a3b9ecf7cb8
patch 8.1.0362: cannot get the script line number when executing a function
Christian Brabandt <cb@256bit.org>
parents:
14439
diff
changeset
|
6295 verbose_leave(); |
| 507 | 6296 vim_free(p); |
| 6297 } | |
| 448 | 6298 } |
| 6299 } | |
| 6300 | |
|
16036
89fb86821b4a
patch 8.1.1023: may use NULL pointer when indexing a blob
Bram Moolenaar <Bram@vim.org>
parents:
16013
diff
changeset
|
6301 /* |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6302 * Compare "typ1" and "typ2". Put the result in "typ1". |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6303 */ |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6304 int |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6305 typval_compare( |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6306 typval_T *typ1, // first operand |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6307 typval_T *typ2, // second operand |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6308 exptype_T type, // operator |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6309 int ic) // ignore case |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6310 { |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6311 int i; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6312 varnumber_T n1, n2; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6313 char_u *s1, *s2; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6314 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6315 int type_is = type == EXPR_IS || type == EXPR_ISNOT; |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6316 |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6317 if (type_is && typ1->v_type != typ2->v_type) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6318 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6319 // For "is" a different type always means FALSE, for "notis" |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6320 // it means TRUE. |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6321 n1 = (type == EXPR_ISNOT); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6322 } |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6323 else if (typ1->v_type == VAR_BLOB || typ2->v_type == VAR_BLOB) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6324 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6325 if (type_is) |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6326 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6327 n1 = (typ1->v_type == typ2->v_type |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6328 && typ1->vval.v_blob == typ2->vval.v_blob); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6329 if (type == EXPR_ISNOT) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6330 n1 = !n1; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6331 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6332 else if (typ1->v_type != typ2->v_type |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6333 || (type != EXPR_EQUAL && type != EXPR_NEQUAL)) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6334 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6335 if (typ1->v_type != typ2->v_type) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6336 emsg(_("E977: Can only compare Blob with Blob")); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6337 else |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6338 emsg(_(e_invalblob)); |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6339 clear_tv(typ1); |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6340 return FAIL; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6341 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6342 else |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6343 { |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6344 // Compare two Blobs for being equal or unequal. |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6345 n1 = blob_equal(typ1->vval.v_blob, typ2->vval.v_blob); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6346 if (type == EXPR_NEQUAL) |
|
15454
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6347 n1 = !n1; |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6348 } |
|
1d2b5c016f17
patch 8.1.0735: cannot handle binary data
Bram Moolenaar <Bram@vim.org>
parents:
15219
diff
changeset
|
6349 } |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6350 else if (typ1->v_type == VAR_LIST || typ2->v_type == VAR_LIST) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6351 { |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6352 if (type_is) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6353 { |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6354 n1 = (typ1->v_type == typ2->v_type |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6355 && typ1->vval.v_list == typ2->vval.v_list); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6356 if (type == EXPR_ISNOT) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6357 n1 = !n1; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6358 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6359 else if (typ1->v_type != typ2->v_type |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6360 || (type != EXPR_EQUAL && type != EXPR_NEQUAL)) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6361 { |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6362 if (typ1->v_type != typ2->v_type) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6363 emsg(_("E691: Can only compare List with List")); |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6364 else |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6365 emsg(_("E692: Invalid operation for List")); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6366 clear_tv(typ1); |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6367 return FAIL; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6368 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6369 else |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6370 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6371 // Compare two Lists for being equal or unequal. |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6372 n1 = list_equal(typ1->vval.v_list, typ2->vval.v_list, |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6373 ic, FALSE); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6374 if (type == EXPR_NEQUAL) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6375 n1 = !n1; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6376 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6377 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6378 |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6379 else if (typ1->v_type == VAR_DICT || typ2->v_type == VAR_DICT) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6380 { |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6381 if (type_is) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6382 { |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6383 n1 = (typ1->v_type == typ2->v_type |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6384 && typ1->vval.v_dict == typ2->vval.v_dict); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6385 if (type == EXPR_ISNOT) |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6386 n1 = !n1; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6387 } |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6388 else if (typ1->v_type != typ2->v_type |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6389 || (type != EXPR_EQUAL && type != EXPR_NEQUAL)) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6390 { |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6391 if (typ1->v_type != typ2->v_type) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6392 emsg(_("E735: Can only compare Dictionary with Dictionary")); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6393 else |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6394 emsg(_("E736: Invalid operation for Dictionary")); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6395 clear_tv(typ1); |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6396 return FAIL; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6397 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6398 else |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6399 { |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6400 // Compare two Dictionaries for being equal or unequal. |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6401 n1 = dict_equal(typ1->vval.v_dict, typ2->vval.v_dict, |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6402 ic, FALSE); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6403 if (type == EXPR_NEQUAL) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6404 n1 = !n1; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6405 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6406 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6407 |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6408 else if (typ1->v_type == VAR_FUNC || typ2->v_type == VAR_FUNC |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6409 || typ1->v_type == VAR_PARTIAL || typ2->v_type == VAR_PARTIAL) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6410 { |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6411 if (type != EXPR_EQUAL && type != EXPR_NEQUAL |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6412 && type != EXPR_IS && type != EXPR_ISNOT) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6413 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15466
diff
changeset
|
6414 emsg(_("E694: Invalid operation for Funcrefs")); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6415 clear_tv(typ1); |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6416 return FAIL; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6417 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6418 if ((typ1->v_type == VAR_PARTIAL |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6419 && typ1->vval.v_partial == NULL) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6420 || (typ2->v_type == VAR_PARTIAL |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6421 && typ2->vval.v_partial == NULL)) |
|
20156
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
6422 // When both partials are NULL, then they are equal. |
|
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
6423 // Otherwise they are not equal. |
|
49694eceaa55
patch 8.2.0633: crash when using null partial in filter()
Bram Moolenaar <Bram@vim.org>
parents:
20142
diff
changeset
|
6424 n1 = (typ1->vval.v_partial == typ2->vval.v_partial); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6425 else if (type_is) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6426 { |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6427 if (typ1->v_type == VAR_FUNC && typ2->v_type == VAR_FUNC) |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6428 // strings are considered the same if their value is |
|
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6429 // the same |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6430 n1 = tv_equal(typ1, typ2, ic, FALSE); |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6431 else if (typ1->v_type == VAR_PARTIAL |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6432 && typ2->v_type == VAR_PARTIAL) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6433 n1 = (typ1->vval.v_partial == typ2->vval.v_partial); |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6434 else |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6435 n1 = FALSE; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6436 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6437 else |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6438 n1 = tv_equal(typ1, typ2, ic, FALSE); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6439 if (type == EXPR_NEQUAL || type == EXPR_ISNOT) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6440 n1 = !n1; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6441 } |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6442 |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6443 #ifdef FEAT_FLOAT |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6444 /* |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6445 * If one of the two variables is a float, compare as a float. |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6446 * When using "=~" or "!~", always compare as string. |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6447 */ |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6448 else if ((typ1->v_type == VAR_FLOAT || typ2->v_type == VAR_FLOAT) |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6449 && type != EXPR_MATCH && type != EXPR_NOMATCH) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6450 { |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6451 float_T f1, f2; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6452 |
|
15904
fec4416adb80
patch 8.1.0958: compiling weird regexp pattern is very slow
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
6453 f1 = tv_get_float(typ1); |
|
fec4416adb80
patch 8.1.0958: compiling weird regexp pattern is very slow
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
6454 f2 = tv_get_float(typ2); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6455 n1 = FALSE; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6456 switch (type) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6457 { |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6458 case EXPR_IS: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6459 case EXPR_EQUAL: n1 = (f1 == f2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6460 case EXPR_ISNOT: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6461 case EXPR_NEQUAL: n1 = (f1 != f2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6462 case EXPR_GREATER: n1 = (f1 > f2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6463 case EXPR_GEQUAL: n1 = (f1 >= f2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6464 case EXPR_SMALLER: n1 = (f1 < f2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6465 case EXPR_SEQUAL: n1 = (f1 <= f2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6466 case EXPR_UNKNOWN: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6467 case EXPR_MATCH: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6468 default: break; // avoid gcc warning |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6469 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6470 } |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6471 #endif |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6472 |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6473 /* |
|
18968
24941a950cc7
patch 8.2.0045: script test fails
Bram Moolenaar <Bram@vim.org>
parents:
18966
diff
changeset
|
6474 * If one of the two variables is a number, compare as a number. |
|
24941a950cc7
patch 8.2.0045: script test fails
Bram Moolenaar <Bram@vim.org>
parents:
18966
diff
changeset
|
6475 * When using "=~" or "!~", always compare as string. |
|
24941a950cc7
patch 8.2.0045: script test fails
Bram Moolenaar <Bram@vim.org>
parents:
18966
diff
changeset
|
6476 */ |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6477 else if ((typ1->v_type == VAR_NUMBER || typ2->v_type == VAR_NUMBER) |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6478 && type != EXPR_MATCH && type != EXPR_NOMATCH) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6479 { |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
6480 n1 = tv_get_number(typ1); |
|
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
6481 n2 = tv_get_number(typ2); |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6482 switch (type) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6483 { |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6484 case EXPR_IS: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6485 case EXPR_EQUAL: n1 = (n1 == n2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6486 case EXPR_ISNOT: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6487 case EXPR_NEQUAL: n1 = (n1 != n2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6488 case EXPR_GREATER: n1 = (n1 > n2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6489 case EXPR_GEQUAL: n1 = (n1 >= n2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6490 case EXPR_SMALLER: n1 = (n1 < n2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6491 case EXPR_SEQUAL: n1 = (n1 <= n2); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6492 case EXPR_UNKNOWN: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6493 case EXPR_MATCH: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6494 default: break; // avoid gcc warning |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6495 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6496 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6497 else |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6498 { |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
6499 s1 = tv_get_string_buf(typ1, buf1); |
|
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
6500 s2 = tv_get_string_buf(typ2, buf2); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6501 if (type != EXPR_MATCH && type != EXPR_NOMATCH) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6502 i = ic ? MB_STRICMP(s1, s2) : STRCMP(s1, s2); |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6503 else |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6504 i = 0; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6505 n1 = FALSE; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6506 switch (type) |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6507 { |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6508 case EXPR_IS: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6509 case EXPR_EQUAL: n1 = (i == 0); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6510 case EXPR_ISNOT: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6511 case EXPR_NEQUAL: n1 = (i != 0); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6512 case EXPR_GREATER: n1 = (i > 0); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6513 case EXPR_GEQUAL: n1 = (i >= 0); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6514 case EXPR_SMALLER: n1 = (i < 0); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6515 case EXPR_SEQUAL: n1 = (i <= 0); break; |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6516 |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6517 case EXPR_MATCH: |
|
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6518 case EXPR_NOMATCH: |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6519 n1 = pattern_match(s2, s1, ic); |
|
19017
d9ea4f0bfd34
patch 8.2.0069: ETYPE_ is used for two different enums
Bram Moolenaar <Bram@vim.org>
parents:
19001
diff
changeset
|
6520 if (type == EXPR_NOMATCH) |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6521 n1 = !n1; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6522 break; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6523 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
19108
diff
changeset
|
6524 default: break; // avoid gcc warning |
|
13274
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6525 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6526 } |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6527 clear_tv(typ1); |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6528 typ1->v_type = VAR_NUMBER; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6529 typ1->vval.v_number = n1; |
|
f4b4162264b1
patch 8.0.1511: some code for the debugger watch expression is clumsy
Christian Brabandt <cb@256bit.org>
parents:
13272
diff
changeset
|
6530 |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6531 return OK; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6532 } |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6533 |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6534 char_u * |
|
14391
46f14852a919
patch 8.1.0210: still a few K&R function declarations
Christian Brabandt <cb@256bit.org>
parents:
14331
diff
changeset
|
6535 typval_tostring(typval_T *arg) |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6536 { |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6537 char_u *tofree; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6538 char_u numbuf[NUMBUFLEN]; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6539 char_u *ret = NULL; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6540 |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6541 if (arg == NULL) |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6542 return vim_strsave((char_u *)"(does not exist)"); |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6543 ret = tv2string(arg, &tofree, numbuf, 0); |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6544 // Make a copy if we have a value but it's not in allocated memory. |
|
13262
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6545 if (ret != NULL && tofree == NULL) |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6546 ret = vim_strsave(ret); |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6547 return ret; |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6548 } |
|
69278c25429d
patch 8.0.1505: debugger can't break on a condition
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
6549 |
|
17966
46f95606b9ec
patch 8.1.1979: code for handling file names is spread out
Bram Moolenaar <Bram@vim.org>
parents:
17964
diff
changeset
|
6550 #endif // FEAT_EVAL |
| 7 | 6551 |
| 6552 /* | |
| 6553 * 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
|
6554 * When "sub" is NULL "expr" is used, must be a VAR_FUNC or VAR_PARTIAL. |
| 7 | 6555 * "flags" can be "g" to do a global substitute. |
| 6556 * Returns an allocated string, NULL for error. | |
| 6557 */ | |
| 6558 char_u * | |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6559 do_string_sub( |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6560 char_u *str, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6561 char_u *pat, |
|
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6562 char_u *sub, |
|
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9587
diff
changeset
|
6563 typval_T *expr, |
|
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7788
diff
changeset
|
6564 char_u *flags) |
| 7 | 6565 { |
| 6566 int sublen; | |
| 6567 regmatch_T regmatch; | |
| 6568 int i; | |
| 6569 int do_all; | |
| 6570 char_u *tail; | |
| 6332 | 6571 char_u *end; |
| 7 | 6572 garray_T ga; |
| 6573 char_u *ret; | |
| 6574 char_u *save_cpo; | |
| 5623 | 6575 char_u *zero_width = NULL; |
| 7 | 6576 |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6577 // Make 'cpoptions' empty, so that the 'l' flag doesn't work here |
| 7 | 6578 save_cpo = p_cpo; |
| 1672 | 6579 p_cpo = empty_option; |
| 7 | 6580 |
| 6581 ga_init2(&ga, 1, 200); | |
| 6582 | |
| 6583 do_all = (flags[0] == 'g'); | |
| 6584 | |
| 6585 regmatch.rm_ic = p_ic; | |
| 6586 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); | |
| 6587 if (regmatch.regprog != NULL) | |
| 6588 { | |
| 6589 tail = str; | |
| 6332 | 6590 end = str + STRLEN(str); |
| 7 | 6591 while (vim_regexec_nl(®match, str, (colnr_T)(tail - str))) |
| 6592 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6593 // Skip empty match except for first match. |
| 5623 | 6594 if (regmatch.startp[0] == regmatch.endp[0]) |
| 6595 { | |
| 6596 if (zero_width == regmatch.startp[0]) | |
| 6597 { | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6598 // 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
|
6599 i = mb_ptr2len(tail); |
| 5964 | 6600 mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail, |
| 6601 (size_t)i); | |
| 6602 ga.ga_len += i; | |
| 6603 tail += i; | |
| 5623 | 6604 continue; |
| 6605 } | |
| 6606 zero_width = regmatch.startp[0]; | |
| 6607 } | |
| 6608 | |
| 7 | 6609 /* |
| 6610 * Get some space for a temporary buffer to do the substitution | |
| 6611 * into. It will contain: | |
| 6612 * - The text up to where the match is. | |
| 6613 * - The substituted text. | |
| 6614 * - The text after the match. | |
| 6615 */ | |
|
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9587
diff
changeset
|
6616 sublen = vim_regsub(®match, sub, expr, tail, FALSE, TRUE, FALSE); |
| 6332 | 6617 if (ga_grow(&ga, (int)((end - tail) + sublen - |
| 7 | 6618 (regmatch.endp[0] - regmatch.startp[0]))) == FAIL) |
| 6619 { | |
| 6620 ga_clear(&ga); | |
| 6621 break; | |
| 6622 } | |
| 6623 | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6624 // copy the text up to where the match is |
| 7 | 6625 i = (int)(regmatch.startp[0] - tail); |
| 6626 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
|
6627 // add the substituted text |
|
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9587
diff
changeset
|
6628 (void)vim_regsub(®match, sub, expr, (char_u *)ga.ga_data |
| 7 | 6629 + ga.ga_len + i, TRUE, TRUE, FALSE); |
| 6630 ga.ga_len += i + sublen - 1; | |
| 5388 | 6631 tail = regmatch.endp[0]; |
| 6632 if (*tail == NUL) | |
| 6633 break; | |
| 7 | 6634 if (!do_all) |
| 6635 break; | |
| 6636 } | |
| 6637 | |
| 6638 if (ga.ga_data != NULL) | |
| 6639 STRCPY((char *)ga.ga_data + ga.ga_len, tail); | |
| 6640 | |
|
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4778
diff
changeset
|
6641 vim_regfree(regmatch.regprog); |
| 7 | 6642 } |
| 6643 | |
| 6644 ret = vim_strsave(ga.ga_data == NULL ? str : (char_u *)ga.ga_data); | |
| 6645 ga_clear(&ga); | |
| 1672 | 6646 if (p_cpo == empty_option) |
| 6647 p_cpo = save_cpo; | |
| 6648 else | |
|
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
6649 // Darn, evaluating {sub} expression or {expr} changed the value. |
| 1672 | 6650 free_string_option(save_cpo); |
| 7 | 6651 |
| 6652 return ret; | |
| 6653 } |