Mercurial > vim
annotate src/misc2.c @ 33004:50e7d33c40f9 v9.0.1794
patch 9.0.1794: autoconf: not correctly detecing include dirs
Commit: https://github.com/vim/vim/commit/74e1dada4199b2d9e68ccaafdb7895c85b4b08f1
Author: Illia Bobyr <illia.bobyr@gmail.com>
Date: Sun Aug 27 18:26:54 2023 +0200
patch 9.0.1794: autoconf: not correctly detecing include dirs
Problem: autoconf: not correctly detecing include dirs
Solution: make use of python3 to generate includedirs
configure: Python3: Use sysconfig for -I
It seems better to use tools provided by Python for determining the
include directories, rather than construct them "manually".
Current system is broken when using virtual environments for python
3.11.4. It used to work before, but now it detects a incorrect value
for `-I`.
It would probably make sense to switch to a similar logic for lib
folders, that is for the `-l` switch. There are also
`sysconfig.get_config_h_filename()` and
`sysconfig.get_makefile_filename()`, that could replace more Python
specific logic in the current `configure{.ac,}`.
sysconfig provides the necessary tools since Python 2.7.
closes: #12889
Signed-off-by: Christian Brabandt <cb@256bit.org>
Co-authored-by: Illia Bobyr <illia.bobyr@gmail.com>
| author | Christian Brabandt <cb@256bit.org> |
|---|---|
| date | Sun, 27 Aug 2023 18:45:03 +0200 |
| parents | bc3b293a965c |
| children | a0a4a774117b |
| rev | line source |
|---|---|
|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
9869
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 * misc2.c: Various functions. | |
| 12 */ | |
| 13 #include "vim.h" | |
| 14 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
15 static char_u *username = NULL; // cached result of mch_get_user_name() |
| 359 | 16 |
|
7803
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7664
diff
changeset
|
17 static int coladvance2(pos_T *pos, int addspaces, int finetune, colnr_T wcol); |
| 7 | 18 |
| 19 /* | |
| 20 * Return TRUE if in the current mode we need to use virtual. | |
| 21 */ | |
| 22 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
23 virtual_active(void) |
| 7 | 24 { |
|
25380
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
25 unsigned int cur_ve_flags = get_ve_flags(); |
|
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
26 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
27 // While an operator is being executed we return "virtual_op", because |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
28 // VIsual_active has already been reset, thus we can't check for "block" |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
29 // being used. |
| 7 | 30 if (virtual_op != MAYBE) |
| 31 return virtual_op; | |
|
25380
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
32 return (cur_ve_flags == VE_ALL |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
33 || ((cur_ve_flags & VE_BLOCK) && VIsual_active |
|
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
34 && VIsual_mode == Ctrl_V) |
|
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
35 || ((cur_ve_flags & VE_INSERT) && (State & MODE_INSERT))); |
| 7 | 36 } |
| 37 | |
| 38 /* | |
| 39 * Get the screen position of the cursor. | |
| 40 */ | |
| 41 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
42 getviscol(void) |
| 7 | 43 { |
| 44 colnr_T x; | |
| 45 | |
| 46 getvvcol(curwin, &curwin->w_cursor, &x, NULL, NULL); | |
| 47 return (int)x; | |
| 48 } | |
| 49 | |
| 50 /* | |
| 1209 | 51 * Go to column "wcol", and add/insert white space as necessary to get the |
| 7 | 52 * cursor in that column. |
| 53 * The caller must have saved the cursor line for undo! | |
| 54 */ | |
| 55 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
56 coladvance_force(colnr_T wcol) |
| 7 | 57 { |
| 58 int rc = coladvance2(&curwin->w_cursor, TRUE, FALSE, wcol); | |
| 59 | |
| 60 if (wcol == MAXCOL) | |
| 61 curwin->w_valid &= ~VALID_VIRTCOL; | |
| 62 else | |
| 63 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
64 // Virtcol is valid |
| 7 | 65 curwin->w_valid |= VALID_VIRTCOL; |
| 66 curwin->w_virtcol = wcol; | |
| 67 } | |
| 68 return rc; | |
| 69 } | |
| 70 | |
| 71 /* | |
|
15428
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
72 * Get the screen position of character col with a coladd in the cursor line. |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
73 */ |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
74 int |
|
15597
536dd2bc5ac9
patch 8.1.0806: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
75 getviscol2(colnr_T col, colnr_T coladd UNUSED) |
|
15428
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
76 { |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
77 colnr_T x; |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
78 pos_T pos; |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
79 |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
80 pos.lnum = curwin->w_cursor.lnum; |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
81 pos.col = col; |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
82 pos.coladd = coladd; |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
83 getvvcol(curwin, &pos, &x, NULL, NULL); |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
84 return (int)x; |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
85 } |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
86 |
|
eae582bfb293
patch 8.1.0722: cannot build without the virtualedit feature
Bram Moolenaar <Bram@vim.org>
parents:
15292
diff
changeset
|
87 /* |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
88 * Try to advance the Cursor to the specified screen column "wantcol". |
| 7 | 89 * If virtual editing: fine tune the cursor position. |
| 90 * Note that all virtual positions off the end of a line should share | |
| 91 * a curwin->w_cursor.col value (n.b. this is equal to STRLEN(line)), | |
| 92 * beginning at coladd 0. | |
| 93 * | |
| 94 * return OK if desired column is reached, FAIL if not | |
| 95 */ | |
| 96 int | |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
97 coladvance(colnr_T wantcol) |
| 7 | 98 { |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
99 int rc = getvpos(&curwin->w_cursor, wantcol); |
| 7 | 100 |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
101 if (wantcol == MAXCOL || rc == FAIL) |
| 7 | 102 curwin->w_valid &= ~VALID_VIRTCOL; |
| 44 | 103 else if (*ml_get_cursor() != TAB) |
| 7 | 104 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
105 // Virtcol is valid when not on a TAB |
| 7 | 106 curwin->w_valid |= VALID_VIRTCOL; |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
107 curwin->w_virtcol = wantcol; |
| 7 | 108 } |
| 109 return rc; | |
| 110 } | |
| 111 | |
| 112 /* | |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
113 * Return in "pos" the position of the cursor advanced to screen column |
|
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
114 * "wantcol". |
| 7 | 115 * return OK if desired column is reached, FAIL if not |
| 116 */ | |
| 117 int | |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
118 getvpos(pos_T *pos, colnr_T wantcol) |
| 7 | 119 { |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
120 return coladvance2(pos, FALSE, virtual_active(), wantcol); |
| 7 | 121 } |
| 122 | |
| 123 static int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
124 coladvance2( |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
125 pos_T *pos, |
|
18291
11f68eb58fda
patch 8.1.2140: "gk" and "gj" do not work correctly in number column
Bram Moolenaar <Bram@vim.org>
parents:
18195
diff
changeset
|
126 int addspaces, // change the text to achieve our goal? |
|
11f68eb58fda
patch 8.1.2140: "gk" and "gj" do not work correctly in number column
Bram Moolenaar <Bram@vim.org>
parents:
18195
diff
changeset
|
127 int finetune, // change char offset for the exact column |
|
11f68eb58fda
patch 8.1.2140: "gk" and "gj" do not work correctly in number column
Bram Moolenaar <Bram@vim.org>
parents:
18195
diff
changeset
|
128 colnr_T wcol_arg) // column to move to (can be negative) |
| 7 | 129 { |
|
18291
11f68eb58fda
patch 8.1.2140: "gk" and "gj" do not work correctly in number column
Bram Moolenaar <Bram@vim.org>
parents:
18195
diff
changeset
|
130 colnr_T wcol = wcol_arg; |
| 7 | 131 int idx; |
| 132 char_u *line; | |
| 133 colnr_T col = 0; | |
| 134 int csize = 0; | |
| 135 int one_more; | |
| 136 #ifdef FEAT_LINEBREAK | |
| 137 int head = 0; | |
| 138 #endif | |
| 139 | |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
140 one_more = (State & MODE_INSERT) |
| 772 | 141 || restart_edit != NUL |
| 142 || (VIsual_active && *p_sel != 'o') | |
|
25380
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
143 || ((get_ve_flags() & VE_ONEMORE) && wcol < MAXCOL); |
| 1982 | 144 line = ml_get_buf(curbuf, pos->lnum, FALSE); |
| 7 | 145 |
| 146 if (wcol >= MAXCOL) | |
| 147 { | |
| 148 idx = (int)STRLEN(line) - 1 + one_more; | |
| 149 col = wcol; | |
| 150 | |
| 151 if ((addspaces || finetune) && !VIsual_active) | |
| 152 { | |
|
33000
bc3b293a965c
patch 9.0.1792: problem with gj/gk/gM and virtual text
Christian Brabandt <cb@256bit.org>
parents:
32138
diff
changeset
|
153 curwin->w_curswant = linetabsize(curwin, pos->lnum) + one_more; |
| 7 | 154 if (curwin->w_curswant > 0) |
| 155 --curwin->w_curswant; | |
| 156 } | |
| 157 } | |
| 158 else | |
| 159 { | |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
160 int width = curwin->w_width - win_col_off(curwin); |
|
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
161 chartabsize_T cts; |
| 7 | 162 |
| 620 | 163 if (finetune |
| 7 | 164 && curwin->w_p_wrap |
| 165 && curwin->w_width != 0 | |
|
25642
b46214b82d6e
patch 8.2.3357: crash when 'virtualedit' is set and window is narrow
Bram Moolenaar <Bram@vim.org>
parents:
25529
diff
changeset
|
166 && wcol >= (colnr_T)width |
|
b46214b82d6e
patch 8.2.3357: crash when 'virtualedit' is set and window is narrow
Bram Moolenaar <Bram@vim.org>
parents:
25529
diff
changeset
|
167 && width > 0) |
| 7 | 168 { |
|
33000
bc3b293a965c
patch 9.0.1792: problem with gj/gk/gM and virtual text
Christian Brabandt <cb@256bit.org>
parents:
32138
diff
changeset
|
169 csize = linetabsize(curwin, pos->lnum); |
| 7 | 170 if (csize > 0) |
| 171 csize--; | |
| 172 | |
| 620 | 173 if (wcol / width > (colnr_T)csize / width |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
174 && ((State & MODE_INSERT) == 0 || (int)wcol > csize + 1)) |
| 7 | 175 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
176 // In case of line wrapping don't move the cursor beyond the |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
177 // right screen edge. In Insert mode allow going just beyond |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
178 // the last character (like what happens when typing and |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
179 // reaching the right window edge). |
| 7 | 180 wcol = (csize / width + 1) * width - 1; |
| 181 } | |
| 182 } | |
| 183 | |
|
29451
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
184 init_chartabsize_arg(&cts, curwin, pos->lnum, 0, line, line); |
|
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
185 while (cts.cts_vcol <= wcol && *cts.cts_ptr != NUL) |
| 7 | 186 { |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
187 #ifdef FEAT_PROP_POPUP |
|
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
188 int at_start = cts.cts_ptr == cts.cts_line; |
|
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
189 #endif |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
190 // Count a tab for what it's worth (if list mode not on) |
| 7 | 191 #ifdef FEAT_LINEBREAK |
|
29451
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
192 csize = win_lbr_chartabsize(&cts, &head); |
|
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
193 MB_PTR_ADV(cts.cts_ptr); |
| 7 | 194 #else |
|
29451
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
195 csize = lbr_chartabsize_adv(&cts); |
| 7 | 196 #endif |
|
29451
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
197 cts.cts_vcol += csize; |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
198 #ifdef FEAT_PROP_POPUP |
|
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
199 if (at_start) |
|
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
200 // do not count the columns for virtual text above |
|
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
201 cts.cts_vcol -= cts.cts_first_char; |
|
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
202 #endif |
| 7 | 203 } |
|
29451
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
204 col = cts.cts_vcol; |
|
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
205 idx = (int)(cts.cts_ptr - line); |
|
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
206 clear_chartabsize_arg(&cts); |
|
057c26b5c33a
patch 9.0.0067: cannot show virtual text
Bram Moolenaar <Bram@vim.org>
parents:
28893
diff
changeset
|
207 |
| 7 | 208 /* |
| 209 * Handle all the special cases. The virtual_active() check | |
| 210 * is needed to ensure that a virtual position off the end of | |
| 211 * a line has the correct indexing. The one_more comparison | |
| 212 * replaces an explicit add of one_more later on. | |
| 213 */ | |
| 214 if (col > wcol || (!virtual_active() && one_more == 0)) | |
| 215 { | |
| 216 idx -= 1; | |
| 217 # ifdef FEAT_LINEBREAK | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
218 // Don't count the chars from 'showbreak'. |
| 7 | 219 csize -= head; |
| 220 # endif | |
| 221 col -= csize; | |
| 222 } | |
| 223 | |
| 224 if (virtual_active() | |
| 225 && addspaces | |
|
18291
11f68eb58fda
patch 8.1.2140: "gk" and "gj" do not work correctly in number column
Bram Moolenaar <Bram@vim.org>
parents:
18195
diff
changeset
|
226 && wcol >= 0 |
| 7 | 227 && ((col != wcol && col != wcol + 1) || csize > 1)) |
| 228 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
229 // 'virtualedit' is set: The difference between wcol and col is |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
230 // filled with spaces. |
| 7 | 231 |
| 232 if (line[idx] == NUL) | |
| 233 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
234 // Append spaces |
| 7 | 235 int correct = wcol - col; |
| 236 char_u *newline = alloc(idx + correct + 1); | |
| 237 int t; | |
| 238 | |
| 239 if (newline == NULL) | |
| 240 return FAIL; | |
| 241 | |
| 242 for (t = 0; t < idx; ++t) | |
| 243 newline[t] = line[t]; | |
| 244 | |
| 245 for (t = 0; t < correct; ++t) | |
| 246 newline[t + idx] = ' '; | |
| 247 | |
| 248 newline[idx + correct] = NUL; | |
| 249 | |
| 250 ml_replace(pos->lnum, newline, FALSE); | |
| 251 changed_bytes(pos->lnum, (colnr_T)idx); | |
| 252 idx += correct; | |
| 253 col = wcol; | |
| 254 } | |
| 255 else | |
| 256 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
257 // Break a tab |
| 7 | 258 int linelen = (int)STRLEN(line); |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
259 int correct = wcol - col - csize + 1; // negative!! |
| 840 | 260 char_u *newline; |
| 7 | 261 int t, s = 0; |
| 262 int v; | |
| 263 | |
| 840 | 264 if (-correct > csize) |
| 265 return FAIL; | |
| 266 | |
| 267 newline = alloc(linelen + csize); | |
| 268 if (newline == NULL) | |
| 7 | 269 return FAIL; |
| 270 | |
| 271 for (t = 0; t < linelen; t++) | |
| 272 { | |
| 273 if (t != idx) | |
| 274 newline[s++] = line[t]; | |
| 275 else | |
| 276 for (v = 0; v < csize; v++) | |
| 277 newline[s++] = ' '; | |
| 278 } | |
| 279 | |
| 280 newline[linelen + csize - 1] = NUL; | |
| 281 | |
| 282 ml_replace(pos->lnum, newline, FALSE); | |
| 283 changed_bytes(pos->lnum, idx); | |
| 284 idx += (csize - 1 + correct); | |
| 285 col += correct; | |
| 286 } | |
| 287 } | |
| 288 } | |
| 289 | |
| 290 if (idx < 0) | |
| 291 pos->col = 0; | |
| 292 else | |
| 293 pos->col = idx; | |
| 294 | |
| 295 pos->coladd = 0; | |
| 296 | |
| 297 if (finetune) | |
| 298 { | |
| 299 if (wcol == MAXCOL) | |
| 300 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
301 // The width of the last character is used to set coladd. |
| 7 | 302 if (!one_more) |
| 303 { | |
| 304 colnr_T scol, ecol; | |
| 305 | |
| 306 getvcol(curwin, pos, &scol, NULL, &ecol); | |
| 307 pos->coladd = ecol - scol; | |
| 308 } | |
| 309 } | |
| 310 else | |
| 311 { | |
| 312 int b = (int)wcol - (int)col; | |
| 313 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
314 // The difference between wcol and col is used to set coladd. |
|
12515
972ea22c946f
patch 8.0.1136: W_WIDTH() is always the same
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
315 if (b > 0 && b < (MAXCOL - 2 * curwin->w_width)) |
| 7 | 316 pos->coladd = b; |
| 317 | |
| 318 col += b; | |
| 319 } | |
| 320 } | |
| 321 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
322 // prevent from moving onto a trail byte |
| 7 | 323 if (has_mbyte) |
| 2933 | 324 mb_adjustpos(curbuf, pos); |
| 7 | 325 |
|
18291
11f68eb58fda
patch 8.1.2140: "gk" and "gj" do not work correctly in number column
Bram Moolenaar <Bram@vim.org>
parents:
18195
diff
changeset
|
326 if (wcol < 0 || col < wcol) |
| 7 | 327 return FAIL; |
| 328 return OK; | |
| 329 } | |
| 330 | |
| 331 /* | |
| 1621 | 332 * Increment the cursor position. See inc() for return values. |
| 7 | 333 */ |
| 334 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
335 inc_cursor(void) |
| 7 | 336 { |
| 337 return inc(&curwin->w_cursor); | |
| 338 } | |
| 339 | |
| 1621 | 340 /* |
| 341 * Increment the line pointer "lp" crossing line boundaries as necessary. | |
| 342 * Return 1 when going to the next line. | |
| 343 * Return 2 when moving forward onto a NUL at the end of the line). | |
| 344 * Return -1 when at the end of file. | |
| 345 * Return 0 otherwise. | |
| 346 */ | |
| 7 | 347 int |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
348 inc(pos_T *lp) |
| 7 | 349 { |
|
13082
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
350 char_u *p; |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
351 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
352 // when searching position may be set to end of a line |
|
13082
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
353 if (lp->col != MAXCOL) |
| 7 | 354 { |
|
13082
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
355 p = ml_get_pos(lp); |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
356 if (*p != NUL) // still within line, move to next char (may be NUL) |
| 7 | 357 { |
|
13082
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
358 if (has_mbyte) |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
359 { |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
360 int l = (*mb_ptr2len)(p); |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
361 |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
362 lp->col += l; |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
363 return ((p[l] != NUL) ? 0 : 2); |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
364 } |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
365 lp->col++; |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
366 lp->coladd = 0; |
|
a80082fd1a1d
patch 8.0.1416: crash when searching for a sentence
Christian Brabandt <cb@256bit.org>
parents:
12865
diff
changeset
|
367 return ((p[1] != NUL) ? 0 : 2); |
| 7 | 368 } |
| 369 } | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
370 if (lp->lnum != curbuf->b_ml.ml_line_count) // there is a next line |
| 7 | 371 { |
| 372 lp->col = 0; | |
| 373 lp->lnum++; | |
| 374 lp->coladd = 0; | |
| 375 return 1; | |
| 376 } | |
| 377 return -1; | |
| 378 } | |
| 379 | |
| 380 /* | |
| 381 * incl(lp): same as inc(), but skip the NUL at the end of non-empty lines | |
| 382 */ | |
| 383 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
384 incl(pos_T *lp) |
| 7 | 385 { |
| 386 int r; | |
| 387 | |
| 388 if ((r = inc(lp)) >= 1 && lp->col) | |
| 389 r = inc(lp); | |
| 390 return r; | |
| 391 } | |
| 392 | |
| 393 /* | |
| 394 * dec(p) | |
| 395 * | |
| 396 * Decrement the line pointer 'p' crossing line boundaries as necessary. | |
| 397 * Return 1 when crossing a line, -1 when at start of file, 0 otherwise. | |
| 398 */ | |
| 399 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
400 dec_cursor(void) |
| 7 | 401 { |
|
10549
055b1633aed7
patch 8.0.0164: outdated and misplaced comments
Christian Brabandt <cb@256bit.org>
parents:
10449
diff
changeset
|
402 return dec(&curwin->w_cursor); |
| 7 | 403 } |
| 404 | |
| 405 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
406 dec(pos_T *lp) |
| 7 | 407 { |
| 408 char_u *p; | |
| 409 | |
| 410 lp->coladd = 0; | |
|
13084
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
411 if (lp->col == MAXCOL) |
| 7 | 412 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
413 // past end of line |
|
13084
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
414 p = ml_get(lp->lnum); |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
415 lp->col = (colnr_T)STRLEN(p); |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
416 if (has_mbyte) |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
417 lp->col -= (*mb_head_off)(p, p + lp->col); |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
418 return 0; |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
419 } |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
420 |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
421 if (lp->col > 0) |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
422 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
423 // still within line |
| 7 | 424 lp->col--; |
| 425 if (has_mbyte) | |
| 426 { | |
| 427 p = ml_get(lp->lnum); | |
| 428 lp->col -= (*mb_head_off)(p, p + lp->col); | |
| 429 } | |
| 430 return 0; | |
| 431 } | |
|
13084
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
432 |
|
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
433 if (lp->lnum > 1) |
| 7 | 434 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
435 // there is a prior line |
| 7 | 436 lp->lnum--; |
| 437 p = ml_get(lp->lnum); | |
| 438 lp->col = (colnr_T)STRLEN(p); | |
| 439 if (has_mbyte) | |
| 440 lp->col -= (*mb_head_off)(p, p + lp->col); | |
| 441 return 1; | |
| 442 } | |
|
13084
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
443 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
444 // at start of file |
|
13084
25ab78f14c8b
patch 8.0.1417: test doesn't search for a sentence
Christian Brabandt <cb@256bit.org>
parents:
13082
diff
changeset
|
445 return -1; |
| 7 | 446 } |
| 447 | |
| 448 /* | |
| 449 * decl(lp): same as dec(), but skip the NUL at the end of non-empty lines | |
| 450 */ | |
| 451 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
452 decl(pos_T *lp) |
| 7 | 453 { |
| 454 int r; | |
| 455 | |
| 456 if ((r = dec(lp)) == 1 && lp->col) | |
| 457 r = dec(lp); | |
| 458 return r; | |
| 459 } | |
| 460 | |
| 461 /* | |
|
2178
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
462 * Get the line number relative to the current cursor position, i.e. the |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
463 * difference between line number and cursor position. Only look for lines that |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
464 * can be visible, folded lines don't count. |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
465 */ |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
466 linenr_T |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
467 get_cursor_rel_lnum( |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
468 win_T *wp, |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
469 linenr_T lnum) // line number to get the result for |
|
2178
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
470 { |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
471 linenr_T cursor = wp->w_cursor.lnum; |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
472 linenr_T retval = 0; |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
473 |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
474 #ifdef FEAT_FOLDING |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
475 if (hasAnyFolding(wp)) |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
476 { |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
477 if (lnum > cursor) |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
478 { |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
479 while (lnum > cursor) |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
480 { |
| 5564 | 481 (void)hasFoldingWin(wp, lnum, &lnum, NULL, TRUE, NULL); |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
482 // if lnum and cursor are in the same fold, |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
483 // now lnum <= cursor |
|
2178
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
484 if (lnum > cursor) |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
485 retval++; |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
486 lnum--; |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
487 } |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
488 } |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
489 else if (lnum < cursor) |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
490 { |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
491 while (lnum < cursor) |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
492 { |
| 5564 | 493 (void)hasFoldingWin(wp, lnum, NULL, &lnum, TRUE, NULL); |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
494 // if lnum and cursor are in the same fold, |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
495 // now lnum >= cursor |
|
2178
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
496 if (lnum < cursor) |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
497 retval--; |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
498 lnum++; |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
499 } |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
500 } |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
501 // else if (lnum == cursor) |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
502 // retval = 0; |
|
2178
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
503 } |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
504 else |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
505 #endif |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
506 retval = lnum - cursor; |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
507 |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
508 return retval; |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
509 } |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
510 |
|
c6f1aa1e9f32
Add 'relativenumber' patch from Markus Heidelberg.
Bram Moolenaar <bram@vim.org>
parents:
2027
diff
changeset
|
511 /* |
|
10110
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
512 * Make sure "pos.lnum" and "pos.col" are valid in "buf". |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
513 * This allows for the col to be on the NUL byte. |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
514 */ |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
515 void |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
516 check_pos(buf_T *buf, pos_T *pos) |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
517 { |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
518 char_u *line; |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
519 colnr_T len; |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
520 |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
521 if (pos->lnum > buf->b_ml.ml_line_count) |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
522 pos->lnum = buf->b_ml.ml_line_count; |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
523 |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
524 if (pos->col > 0) |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
525 { |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
526 line = ml_get_buf(buf, pos->lnum, FALSE); |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
527 len = (colnr_T)STRLEN(line); |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
528 if (pos->col > len) |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
529 pos->col = len; |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
530 } |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
531 } |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
532 |
|
cfb38b57d407
commit https://github.com/vim/vim/commit/d5824ce1b5491df7d2eb0b66189d366fa67b4585
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
533 /* |
| 7 | 534 * Make sure curwin->w_cursor.lnum is valid. |
| 535 */ | |
| 536 void | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
537 check_cursor_lnum(void) |
| 7 | 538 { |
| 539 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) | |
| 540 { | |
| 541 #ifdef FEAT_FOLDING | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
542 // If there is a closed fold at the end of the file, put the cursor in |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
543 // its first line. Otherwise in the last line. |
| 7 | 544 if (!hasFolding(curbuf->b_ml.ml_line_count, |
| 545 &curwin->w_cursor.lnum, NULL)) | |
| 546 #endif | |
| 547 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; | |
| 548 } | |
| 549 if (curwin->w_cursor.lnum <= 0) | |
| 550 curwin->w_cursor.lnum = 1; | |
| 551 } | |
| 552 | |
| 553 /* | |
| 554 * Make sure curwin->w_cursor.col is valid. | |
| 555 */ | |
| 556 void | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
557 check_cursor_col(void) |
| 7 | 558 { |
| 2933 | 559 check_cursor_col_win(curwin); |
| 560 } | |
| 561 | |
| 562 /* | |
| 563 * Make sure win->w_cursor.col is valid. | |
| 564 */ | |
| 565 void | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
566 check_cursor_col_win(win_T *win) |
| 2933 | 567 { |
|
25380
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
568 colnr_T len; |
|
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
569 colnr_T oldcol = win->w_cursor.col; |
|
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
570 colnr_T oldcoladd = win->w_cursor.col + win->w_cursor.coladd; |
|
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
571 unsigned int cur_ve_flags = get_ve_flags(); |
| 2933 | 572 |
| 573 len = (colnr_T)STRLEN(ml_get_buf(win->w_buffer, win->w_cursor.lnum, FALSE)); | |
| 7 | 574 if (len == 0) |
| 2933 | 575 win->w_cursor.col = 0; |
| 576 else if (win->w_cursor.col >= len) | |
| 7 | 577 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
578 // Allow cursor past end-of-line when: |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
579 // - in Insert mode or restarting Insert mode |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
580 // - in Visual mode and 'selection' isn't "old" |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
581 // - 'virtualedit' is set |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
582 if ((State & MODE_INSERT) || restart_edit |
| 7 | 583 || (VIsual_active && *p_sel != 'o') |
|
25380
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
584 || (cur_ve_flags & VE_ONEMORE) |
| 7 | 585 || virtual_active()) |
| 2933 | 586 win->w_cursor.col = len; |
| 7 | 587 else |
| 1099 | 588 { |
| 2933 | 589 win->w_cursor.col = len - 1; |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
590 // Move the cursor to the head byte. |
| 1099 | 591 if (has_mbyte) |
| 2933 | 592 mb_adjustpos(win->w_buffer, &win->w_cursor); |
| 1099 | 593 } |
| 7 | 594 } |
| 2933 | 595 else if (win->w_cursor.col < 0) |
| 596 win->w_cursor.col = 0; | |
| 7 | 597 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
598 // If virtual editing is on, we can leave the cursor on the old position, |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
599 // only we must set it to virtual. But don't do it when at the end of the |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
600 // line. |
| 7 | 601 if (oldcol == MAXCOL) |
| 2933 | 602 win->w_cursor.coladd = 0; |
|
25380
ac88cd21ae88
patch 8.2.3227: 'virtualedit' can only be set globally
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
603 else if (cur_ve_flags == VE_ALL) |
| 1841 | 604 { |
| 2933 | 605 if (oldcoladd > win->w_cursor.col) |
|
12164
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
606 { |
| 2933 | 607 win->w_cursor.coladd = oldcoladd - win->w_cursor.col; |
|
12279
57e0b701611e
patch 8.0.1019: pasting in virtual edit happens in the wrong place
Christian Brabandt <cb@256bit.org>
parents:
12240
diff
changeset
|
608 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
609 // Make sure that coladd is not more than the char width. |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
610 // Not for the last character, coladd is then used when the cursor |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
611 // is actually after the last character. |
|
28169
bef82285dda0
patch 8.2.4610: some conditions are always true
Bram Moolenaar <Bram@vim.org>
parents:
27617
diff
changeset
|
612 if (win->w_cursor.col + 1 < len) |
|
12164
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
613 { |
|
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
614 int cs, ce; |
|
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
615 |
|
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
616 getvcol(win, &win->w_cursor, &cs, NULL, &ce); |
|
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
617 if (win->w_cursor.coladd > ce - cs) |
|
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
618 win->w_cursor.coladd = ce - cs; |
|
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
619 } |
|
5d82470552ce
patch 8.0.0962: crash with virtualedit and joining lines
Christian Brabandt <cb@256bit.org>
parents:
11737
diff
changeset
|
620 } |
| 1841 | 621 else |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
622 // avoid weird number when there is a miscalculation or overflow |
| 2933 | 623 win->w_cursor.coladd = 0; |
| 1841 | 624 } |
| 7 | 625 } |
| 626 | |
| 627 /* | |
| 628 * make sure curwin->w_cursor in on a valid character | |
| 629 */ | |
| 630 void | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
631 check_cursor(void) |
| 7 | 632 { |
| 633 check_cursor_lnum(); | |
| 634 check_cursor_col(); | |
| 635 } | |
| 636 | |
|
28893
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
637 /* |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
638 * Check if VIsual position is valid, correct it if not. |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
639 * Can be called when in Visual mode and a change has been made. |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
640 */ |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
641 void |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
642 check_visual_pos(void) |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
643 { |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
644 if (VIsual.lnum > curbuf->b_ml.ml_line_count) |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
645 { |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
646 VIsual.lnum = curbuf->b_ml.ml_line_count; |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
647 VIsual.col = 0; |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
648 VIsual.coladd = 0; |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
649 } |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
650 else |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
651 { |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
652 int len = (int)STRLEN(ml_get(VIsual.lnum)); |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
653 |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
654 if (VIsual.col > len) |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
655 { |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
656 VIsual.col = len; |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
657 VIsual.coladd = 0; |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
658 } |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
659 } |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
660 } |
|
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
661 |
| 7 | 662 /* |
| 663 * Make sure curwin->w_cursor is not on the NUL at the end of the line. | |
| 664 * Allow it when in Visual mode and 'selection' is not "old". | |
| 665 */ | |
| 666 void | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
667 adjust_cursor_col(void) |
| 7 | 668 { |
| 669 if (curwin->w_cursor.col > 0 | |
| 670 && (!VIsual_active || *p_sel == 'o') | |
| 671 && gchar_cursor() == NUL) | |
| 672 --curwin->w_cursor.col; | |
| 673 } | |
| 674 | |
| 675 /* | |
|
31133
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
676 * Set "curwin->w_leftcol" to "leftcol". |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
677 * Adjust the cursor position if needed. |
| 7 | 678 * Return TRUE if the cursor was moved. |
| 679 */ | |
| 680 int | |
|
31133
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
681 set_leftcol(colnr_T leftcol) |
| 7 | 682 { |
| 683 int retval = FALSE; | |
|
31133
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
684 |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
685 // Return quickly when there is no change. |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
686 if (curwin->w_leftcol == leftcol) |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
687 return FALSE; |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
688 curwin->w_leftcol = leftcol; |
| 7 | 689 |
| 690 changed_cline_bef_curs(); | |
|
31133
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
691 long lastcol = curwin->w_leftcol + curwin->w_width - curwin_col_off() - 1; |
| 7 | 692 validate_virtcol(); |
| 693 | |
|
31133
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
694 // If the cursor is right or left of the screen, move it to last or first |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
695 // visible character. |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
696 long siso = get_sidescrolloff_value(); |
|
15713
ad8b2c109b22
patch 8.1.0864: cannot have a local value for 'scrolloff' and 'sidescrolloff'
Bram Moolenaar <Bram@vim.org>
parents:
15675
diff
changeset
|
697 if (curwin->w_virtcol > (colnr_T)(lastcol - siso)) |
| 7 | 698 { |
| 699 retval = TRUE; | |
|
15713
ad8b2c109b22
patch 8.1.0864: cannot have a local value for 'scrolloff' and 'sidescrolloff'
Bram Moolenaar <Bram@vim.org>
parents:
15675
diff
changeset
|
700 coladvance((colnr_T)(lastcol - siso)); |
| 7 | 701 } |
|
15713
ad8b2c109b22
patch 8.1.0864: cannot have a local value for 'scrolloff' and 'sidescrolloff'
Bram Moolenaar <Bram@vim.org>
parents:
15675
diff
changeset
|
702 else if (curwin->w_virtcol < curwin->w_leftcol + siso) |
| 7 | 703 { |
| 704 retval = TRUE; | |
|
15713
ad8b2c109b22
patch 8.1.0864: cannot have a local value for 'scrolloff' and 'sidescrolloff'
Bram Moolenaar <Bram@vim.org>
parents:
15675
diff
changeset
|
705 (void)coladvance((colnr_T)(curwin->w_leftcol + siso)); |
| 7 | 706 } |
| 707 | |
|
31133
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
708 // If the start of the character under the cursor is not on the screen, |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
709 // advance the cursor one more char. If this fails (last char of the |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
710 // line) adjust the scrolling. |
|
cc0c4141fb73
patch 9.0.0901: setting w_leftcol and handling side effects is confusing
Bram Moolenaar <Bram@vim.org>
parents:
31093
diff
changeset
|
711 colnr_T s, e; |
| 7 | 712 getvvcol(curwin, &curwin->w_cursor, &s, NULL, &e); |
| 713 if (e > (colnr_T)lastcol) | |
| 714 { | |
| 715 retval = TRUE; | |
| 716 coladvance(s - 1); | |
| 717 } | |
| 718 else if (s < curwin->w_leftcol) | |
| 719 { | |
| 720 retval = TRUE; | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
721 if (coladvance(e + 1) == FAIL) // there isn't another character |
| 7 | 722 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
723 curwin->w_leftcol = s; // adjust w_leftcol instead |
| 7 | 724 changed_cline_bef_curs(); |
| 725 } | |
| 726 } | |
| 727 | |
| 728 if (retval) | |
| 729 curwin->w_set_curswant = TRUE; | |
|
29732
89e1d67814a9
patch 9.0.0206: redraw flags are not named specifically
Bram Moolenaar <Bram@vim.org>
parents:
29451
diff
changeset
|
730 redraw_later(UPD_NOT_VALID); |
| 7 | 731 return retval; |
| 732 } | |
| 733 | |
|
15292
ba6f0f1bb9d0
patch 8.1.0654: when deleting a line text property flags are not adjusted
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
734 /* |
| 7 | 735 * Isolate one part of a string option where parts are separated with |
| 736 * "sep_chars". | |
| 459 | 737 * The part is copied into "buf[maxlen]". |
| 7 | 738 * "*option" is advanced to the next part. |
| 739 * The length is returned. | |
| 740 */ | |
| 741 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
742 copy_option_part( |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
743 char_u **option, |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
744 char_u *buf, |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
745 int maxlen, |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
746 char *sep_chars) |
| 7 | 747 { |
| 748 int len = 0; | |
| 749 char_u *p = *option; | |
| 750 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
751 // skip '.' at start of option part, for 'suffixes' |
| 7 | 752 if (*p == '.') |
| 753 buf[len++] = *p++; | |
| 754 while (*p != NUL && vim_strchr((char_u *)sep_chars, *p) == NULL) | |
| 755 { | |
| 756 /* | |
| 757 * Skip backslash before a separator character and space. | |
| 758 */ | |
| 759 if (p[0] == '\\' && vim_strchr((char_u *)sep_chars, p[1]) != NULL) | |
| 760 ++p; | |
| 761 if (len < maxlen - 1) | |
| 762 buf[len++] = *p; | |
| 763 ++p; | |
| 764 } | |
| 765 buf[len] = NUL; | |
| 766 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
767 if (*p != NUL && *p != ',') // skip non-standard separator |
| 7 | 768 ++p; |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
769 p = skip_to_option_part(p); // p points to next file name |
| 7 | 770 |
| 771 *option = p; | |
| 772 return len; | |
| 773 } | |
| 774 | |
| 775 #ifndef HAVE_MEMSET | |
| 776 void * | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
777 vim_memset(void *ptr, int c, size_t size) |
| 7 | 778 { |
| 779 char *p = ptr; | |
| 780 | |
| 781 while (size-- > 0) | |
| 782 *p++ = c; | |
| 783 return ptr; | |
| 784 } | |
| 785 #endif | |
| 786 | |
| 787 /* | |
| 788 * Vim has its own isspace() function, because on some machines isspace() | |
| 789 * can't handle characters above 128. | |
| 790 */ | |
| 791 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
792 vim_isspace(int x) |
| 7 | 793 { |
| 794 return ((x >= 9 && x <= 13) || x == ' '); | |
| 795 } | |
| 796 | |
| 797 /************************************************************************ | |
| 798 * functions that use lookup tables for various things, generally to do with | |
| 799 * special key codes. | |
| 800 */ | |
| 801 | |
| 802 /* | |
| 803 * Some useful tables. | |
| 804 */ | |
| 805 | |
| 806 static struct modmasktable | |
| 807 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
808 short mod_mask; // Bit-mask for particular key modifier |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
809 short mod_flag; // Bit(s) for particular key modifier |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
810 char_u name; // Single letter name of modifier |
| 7 | 811 } mod_mask_table[] = |
| 812 { | |
| 813 {MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'M'}, | |
| 179 | 814 {MOD_MASK_META, MOD_MASK_META, (char_u)'T'}, |
| 7 | 815 {MOD_MASK_CTRL, MOD_MASK_CTRL, (char_u)'C'}, |
| 816 {MOD_MASK_SHIFT, MOD_MASK_SHIFT, (char_u)'S'}, | |
| 817 {MOD_MASK_MULTI_CLICK, MOD_MASK_2CLICK, (char_u)'2'}, | |
| 818 {MOD_MASK_MULTI_CLICK, MOD_MASK_3CLICK, (char_u)'3'}, | |
| 819 {MOD_MASK_MULTI_CLICK, MOD_MASK_4CLICK, (char_u)'4'}, | |
|
12716
351cf7c67bbe
patch 8.0.1236: Mac features are confusing
Christian Brabandt <cb@256bit.org>
parents:
12672
diff
changeset
|
820 #ifdef MACOS_X |
| 7 | 821 {MOD_MASK_CMD, MOD_MASK_CMD, (char_u)'D'}, |
| 822 #endif | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
823 // 'A' must be the last one |
| 7 | 824 {MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'A'}, |
| 825 {0, 0, NUL} | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
826 // NOTE: when adding an entry, update MAX_KEY_NAME_LEN! |
| 7 | 827 }; |
| 828 | |
| 829 /* | |
| 830 * Shifted key terminal codes and their unshifted equivalent. | |
| 1209 | 831 * Don't add mouse codes here, they are handled separately! |
| 7 | 832 */ |
| 833 #define MOD_KEYS_ENTRY_SIZE 5 | |
| 834 | |
| 835 static char_u modifier_keys_table[] = | |
| 836 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
837 // mod mask with modifier without modifier |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
838 MOD_MASK_SHIFT, '&', '9', '@', '1', // begin |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
839 MOD_MASK_SHIFT, '&', '0', '@', '2', // cancel |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
840 MOD_MASK_SHIFT, '*', '1', '@', '4', // command |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
841 MOD_MASK_SHIFT, '*', '2', '@', '5', // copy |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
842 MOD_MASK_SHIFT, '*', '3', '@', '6', // create |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
843 MOD_MASK_SHIFT, '*', '4', 'k', 'D', // delete char |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
844 MOD_MASK_SHIFT, '*', '5', 'k', 'L', // delete line |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
845 MOD_MASK_SHIFT, '*', '7', '@', '7', // end |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
846 MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_END, '@', '7', // end |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
847 MOD_MASK_SHIFT, '*', '9', '@', '9', // exit |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
848 MOD_MASK_SHIFT, '*', '0', '@', '0', // find |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
849 MOD_MASK_SHIFT, '#', '1', '%', '1', // help |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
850 MOD_MASK_SHIFT, '#', '2', 'k', 'h', // home |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
851 MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_HOME, 'k', 'h', // home |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
852 MOD_MASK_SHIFT, '#', '3', 'k', 'I', // insert |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
853 MOD_MASK_SHIFT, '#', '4', 'k', 'l', // left arrow |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
854 MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_LEFT, 'k', 'l', // left arrow |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
855 MOD_MASK_SHIFT, '%', 'a', '%', '3', // message |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
856 MOD_MASK_SHIFT, '%', 'b', '%', '4', // move |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
857 MOD_MASK_SHIFT, '%', 'c', '%', '5', // next |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
858 MOD_MASK_SHIFT, '%', 'd', '%', '7', // options |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
859 MOD_MASK_SHIFT, '%', 'e', '%', '8', // previous |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
860 MOD_MASK_SHIFT, '%', 'f', '%', '9', // print |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
861 MOD_MASK_SHIFT, '%', 'g', '%', '0', // redo |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
862 MOD_MASK_SHIFT, '%', 'h', '&', '3', // replace |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
863 MOD_MASK_SHIFT, '%', 'i', 'k', 'r', // right arr. |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
864 MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_RIGHT, 'k', 'r', // right arr. |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
865 MOD_MASK_SHIFT, '%', 'j', '&', '5', // resume |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
866 MOD_MASK_SHIFT, '!', '1', '&', '6', // save |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
867 MOD_MASK_SHIFT, '!', '2', '&', '7', // suspend |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
868 MOD_MASK_SHIFT, '!', '3', '&', '8', // undo |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
869 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP, 'k', 'u', // up arrow |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
870 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN, 'k', 'd', // down arrow |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
871 |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
872 // vt100 F1 |
| 7 | 873 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF1, KS_EXTRA, (int)KE_XF1, |
| 874 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF2, KS_EXTRA, (int)KE_XF2, | |
| 875 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF3, KS_EXTRA, (int)KE_XF3, | |
| 876 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF4, KS_EXTRA, (int)KE_XF4, | |
| 877 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
878 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F1, 'k', '1', // F1 |
| 7 | 879 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F2, 'k', '2', |
| 880 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F3, 'k', '3', | |
| 881 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F4, 'k', '4', | |
| 882 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F5, 'k', '5', | |
| 883 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F6, 'k', '6', | |
| 884 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F7, 'k', '7', | |
| 885 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F8, 'k', '8', | |
| 886 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F9, 'k', '9', | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
887 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F10, 'k', ';', // F10 |
| 7 | 888 |
| 889 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F11, 'F', '1', | |
| 890 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F12, 'F', '2', | |
| 891 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F13, 'F', '3', | |
| 892 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F14, 'F', '4', | |
| 893 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F15, 'F', '5', | |
| 894 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F16, 'F', '6', | |
| 895 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F17, 'F', '7', | |
| 896 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F18, 'F', '8', | |
| 897 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F19, 'F', '9', | |
| 898 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F20, 'F', 'A', | |
| 899 | |
| 900 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F21, 'F', 'B', | |
| 901 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F22, 'F', 'C', | |
| 902 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F23, 'F', 'D', | |
| 903 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F24, 'F', 'E', | |
| 904 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F25, 'F', 'F', | |
| 905 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F26, 'F', 'G', | |
| 906 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F27, 'F', 'H', | |
| 907 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F28, 'F', 'I', | |
| 908 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F29, 'F', 'J', | |
| 909 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F30, 'F', 'K', | |
| 910 | |
| 911 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F31, 'F', 'L', | |
| 912 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F32, 'F', 'M', | |
| 913 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F33, 'F', 'N', | |
| 914 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F34, 'F', 'O', | |
| 915 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F35, 'F', 'P', | |
| 916 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F36, 'F', 'Q', | |
| 917 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F37, 'F', 'R', | |
| 918 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
919 // TAB pseudo code |
| 7 | 920 MOD_MASK_SHIFT, 'k', 'B', KS_EXTRA, (int)KE_TAB, |
| 921 | |
| 922 NUL | |
| 923 }; | |
| 924 | |
| 925 static struct key_name_entry | |
| 926 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
927 int key; // Special key code or ascii value |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
928 char_u *name; // Name of key |
| 7 | 929 } key_names_table[] = |
| 930 { | |
| 931 {' ', (char_u *)"Space"}, | |
| 932 {TAB, (char_u *)"Tab"}, | |
| 933 {K_TAB, (char_u *)"Tab"}, | |
| 934 {NL, (char_u *)"NL"}, | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
935 {NL, (char_u *)"NewLine"}, // Alternative name |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
936 {NL, (char_u *)"LineFeed"}, // Alternative name |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
937 {NL, (char_u *)"LF"}, // Alternative name |
| 7 | 938 {CAR, (char_u *)"CR"}, |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
939 {CAR, (char_u *)"Return"}, // Alternative name |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
940 {CAR, (char_u *)"Enter"}, // Alternative name |
| 7 | 941 {K_BS, (char_u *)"BS"}, |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
942 {K_BS, (char_u *)"BackSpace"}, // Alternative name |
| 7 | 943 {ESC, (char_u *)"Esc"}, |
| 944 {CSI, (char_u *)"CSI"}, | |
| 945 {K_CSI, (char_u *)"xCSI"}, | |
| 946 {'|', (char_u *)"Bar"}, | |
| 947 {'\\', (char_u *)"Bslash"}, | |
| 948 {K_DEL, (char_u *)"Del"}, | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
949 {K_DEL, (char_u *)"Delete"}, // Alternative name |
| 7 | 950 {K_KDEL, (char_u *)"kDel"}, |
| 951 {K_UP, (char_u *)"Up"}, | |
| 952 {K_DOWN, (char_u *)"Down"}, | |
| 953 {K_LEFT, (char_u *)"Left"}, | |
| 954 {K_RIGHT, (char_u *)"Right"}, | |
| 180 | 955 {K_XUP, (char_u *)"xUp"}, |
| 956 {K_XDOWN, (char_u *)"xDown"}, | |
| 957 {K_XLEFT, (char_u *)"xLeft"}, | |
| 958 {K_XRIGHT, (char_u *)"xRight"}, | |
|
10640
27be410d6d29
patch 8.0.0210: no support for bracketed paste
Christian Brabandt <cb@256bit.org>
parents:
10549
diff
changeset
|
959 {K_PS, (char_u *)"PasteStart"}, |
|
27be410d6d29
patch 8.0.0210: no support for bracketed paste
Christian Brabandt <cb@256bit.org>
parents:
10549
diff
changeset
|
960 {K_PE, (char_u *)"PasteEnd"}, |
| 7 | 961 |
| 962 {K_F1, (char_u *)"F1"}, | |
| 963 {K_F2, (char_u *)"F2"}, | |
| 964 {K_F3, (char_u *)"F3"}, | |
| 965 {K_F4, (char_u *)"F4"}, | |
| 966 {K_F5, (char_u *)"F5"}, | |
| 967 {K_F6, (char_u *)"F6"}, | |
| 968 {K_F7, (char_u *)"F7"}, | |
| 969 {K_F8, (char_u *)"F8"}, | |
| 970 {K_F9, (char_u *)"F9"}, | |
| 971 {K_F10, (char_u *)"F10"}, | |
| 972 | |
| 973 {K_F11, (char_u *)"F11"}, | |
| 974 {K_F12, (char_u *)"F12"}, | |
| 975 {K_F13, (char_u *)"F13"}, | |
| 976 {K_F14, (char_u *)"F14"}, | |
| 977 {K_F15, (char_u *)"F15"}, | |
| 978 {K_F16, (char_u *)"F16"}, | |
| 979 {K_F17, (char_u *)"F17"}, | |
| 980 {K_F18, (char_u *)"F18"}, | |
| 981 {K_F19, (char_u *)"F19"}, | |
| 982 {K_F20, (char_u *)"F20"}, | |
| 983 | |
| 984 {K_F21, (char_u *)"F21"}, | |
| 985 {K_F22, (char_u *)"F22"}, | |
| 986 {K_F23, (char_u *)"F23"}, | |
| 987 {K_F24, (char_u *)"F24"}, | |
| 988 {K_F25, (char_u *)"F25"}, | |
| 989 {K_F26, (char_u *)"F26"}, | |
| 990 {K_F27, (char_u *)"F27"}, | |
| 991 {K_F28, (char_u *)"F28"}, | |
| 992 {K_F29, (char_u *)"F29"}, | |
| 993 {K_F30, (char_u *)"F30"}, | |
| 994 | |
| 995 {K_F31, (char_u *)"F31"}, | |
| 996 {K_F32, (char_u *)"F32"}, | |
| 997 {K_F33, (char_u *)"F33"}, | |
| 998 {K_F34, (char_u *)"F34"}, | |
| 999 {K_F35, (char_u *)"F35"}, | |
| 1000 {K_F36, (char_u *)"F36"}, | |
| 1001 {K_F37, (char_u *)"F37"}, | |
| 1002 | |
| 1003 {K_XF1, (char_u *)"xF1"}, | |
| 1004 {K_XF2, (char_u *)"xF2"}, | |
| 1005 {K_XF3, (char_u *)"xF3"}, | |
| 1006 {K_XF4, (char_u *)"xF4"}, | |
| 1007 | |
| 1008 {K_HELP, (char_u *)"Help"}, | |
| 1009 {K_UNDO, (char_u *)"Undo"}, | |
| 1010 {K_INS, (char_u *)"Insert"}, | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1011 {K_INS, (char_u *)"Ins"}, // Alternative name |
| 7 | 1012 {K_KINS, (char_u *)"kInsert"}, |
| 1013 {K_HOME, (char_u *)"Home"}, | |
| 1014 {K_KHOME, (char_u *)"kHome"}, | |
| 1015 {K_XHOME, (char_u *)"xHome"}, | |
| 230 | 1016 {K_ZHOME, (char_u *)"zHome"}, |
| 7 | 1017 {K_END, (char_u *)"End"}, |
| 1018 {K_KEND, (char_u *)"kEnd"}, | |
| 1019 {K_XEND, (char_u *)"xEnd"}, | |
| 230 | 1020 {K_ZEND, (char_u *)"zEnd"}, |
| 7 | 1021 {K_PAGEUP, (char_u *)"PageUp"}, |
| 1022 {K_PAGEDOWN, (char_u *)"PageDown"}, | |
| 1023 {K_KPAGEUP, (char_u *)"kPageUp"}, | |
| 1024 {K_KPAGEDOWN, (char_u *)"kPageDown"}, | |
| 1025 | |
| 1026 {K_KPLUS, (char_u *)"kPlus"}, | |
| 1027 {K_KMINUS, (char_u *)"kMinus"}, | |
| 1028 {K_KDIVIDE, (char_u *)"kDivide"}, | |
| 1029 {K_KMULTIPLY, (char_u *)"kMultiply"}, | |
| 1030 {K_KENTER, (char_u *)"kEnter"}, | |
| 1031 {K_KPOINT, (char_u *)"kPoint"}, | |
| 1032 | |
| 1033 {K_K0, (char_u *)"k0"}, | |
| 1034 {K_K1, (char_u *)"k1"}, | |
| 1035 {K_K2, (char_u *)"k2"}, | |
| 1036 {K_K3, (char_u *)"k3"}, | |
| 1037 {K_K4, (char_u *)"k4"}, | |
| 1038 {K_K5, (char_u *)"k5"}, | |
| 1039 {K_K6, (char_u *)"k6"}, | |
| 1040 {K_K7, (char_u *)"k7"}, | |
| 1041 {K_K8, (char_u *)"k8"}, | |
| 1042 {K_K9, (char_u *)"k9"}, | |
| 1043 | |
| 1044 {'<', (char_u *)"lt"}, | |
| 1045 | |
| 1046 {K_MOUSE, (char_u *)"Mouse"}, | |
| 3273 | 1047 #ifdef FEAT_MOUSE_NET |
| 7 | 1048 {K_NETTERM_MOUSE, (char_u *)"NetMouse"}, |
| 3273 | 1049 #endif |
| 1050 #ifdef FEAT_MOUSE_DEC | |
| 7 | 1051 {K_DEC_MOUSE, (char_u *)"DecMouse"}, |
| 3273 | 1052 #endif |
| 1053 #ifdef FEAT_MOUSE_JSB | |
| 7 | 1054 {K_JSBTERM_MOUSE, (char_u *)"JsbMouse"}, |
| 3273 | 1055 #endif |
| 1056 #ifdef FEAT_MOUSE_PTERM | |
| 7 | 1057 {K_PTERM_MOUSE, (char_u *)"PtermMouse"}, |
| 3273 | 1058 #endif |
| 1059 #ifdef FEAT_MOUSE_URXVT | |
| 1060 {K_URXVT_MOUSE, (char_u *)"UrxvtMouse"}, | |
| 1061 #endif | |
| 3746 | 1062 {K_SGR_MOUSE, (char_u *)"SgrMouse"}, |
|
24008
51cccde1b1aa
patch 8.2.2546: typo in mouse key name
Bram Moolenaar <Bram@vim.org>
parents:
23683
diff
changeset
|
1063 {K_SGR_MOUSERELEASE, (char_u *)"SgrMouseRelease"}, |
| 7 | 1064 {K_LEFTMOUSE, (char_u *)"LeftMouse"}, |
| 1065 {K_LEFTMOUSE_NM, (char_u *)"LeftMouseNM"}, | |
| 1066 {K_LEFTDRAG, (char_u *)"LeftDrag"}, | |
| 1067 {K_LEFTRELEASE, (char_u *)"LeftRelease"}, | |
| 1068 {K_LEFTRELEASE_NM, (char_u *)"LeftReleaseNM"}, | |
|
12865
ebb4f6c93598
patch 8.0.1309: cannot use 'balloonexpr' in a terminal
Christian Brabandt <cb@256bit.org>
parents:
12798
diff
changeset
|
1069 {K_MOUSEMOVE, (char_u *)"MouseMove"}, |
| 7 | 1070 {K_MIDDLEMOUSE, (char_u *)"MiddleMouse"}, |
| 1071 {K_MIDDLEDRAG, (char_u *)"MiddleDrag"}, | |
| 1072 {K_MIDDLERELEASE, (char_u *)"MiddleRelease"}, | |
| 1073 {K_RIGHTMOUSE, (char_u *)"RightMouse"}, | |
| 1074 {K_RIGHTDRAG, (char_u *)"RightDrag"}, | |
| 1075 {K_RIGHTRELEASE, (char_u *)"RightRelease"}, | |
|
2409
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2363
diff
changeset
|
1076 {K_MOUSEDOWN, (char_u *)"ScrollWheelUp"}, |
|
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2363
diff
changeset
|
1077 {K_MOUSEUP, (char_u *)"ScrollWheelDown"}, |
|
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2363
diff
changeset
|
1078 {K_MOUSELEFT, (char_u *)"ScrollWheelRight"}, |
|
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2363
diff
changeset
|
1079 {K_MOUSERIGHT, (char_u *)"ScrollWheelLeft"}, |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1080 {K_MOUSEDOWN, (char_u *)"MouseDown"}, // OBSOLETE: Use |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1081 {K_MOUSEUP, (char_u *)"MouseUp"}, // ScrollWheelXXX instead |
| 7 | 1082 {K_X1MOUSE, (char_u *)"X1Mouse"}, |
| 1083 {K_X1DRAG, (char_u *)"X1Drag"}, | |
| 1084 {K_X1RELEASE, (char_u *)"X1Release"}, | |
| 1085 {K_X2MOUSE, (char_u *)"X2Mouse"}, | |
| 1086 {K_X2DRAG, (char_u *)"X2Drag"}, | |
| 1087 {K_X2RELEASE, (char_u *)"X2Release"}, | |
| 1088 {K_DROP, (char_u *)"Drop"}, | |
| 1089 {K_ZERO, (char_u *)"Nul"}, | |
| 1090 #ifdef FEAT_EVAL | |
| 1091 {K_SNR, (char_u *)"SNR"}, | |
| 1092 #endif | |
| 1093 {K_PLUG, (char_u *)"Plug"}, | |
| 6245 | 1094 {K_CURSORHOLD, (char_u *)"CursorHold"}, |
|
16594
6f52e82d9d4e
patch 8.1.1300: in a terminal 'ballooneval' does not work right away
Bram Moolenaar <Bram@vim.org>
parents:
16511
diff
changeset
|
1095 {K_IGNORE, (char_u *)"Ignore"}, |
|
22862
6d50182e7e24
patch 8.2.1978: making a mapping work in all modes is complicated
Bram Moolenaar <Bram@vim.org>
parents:
22732
diff
changeset
|
1096 {K_COMMAND, (char_u *)"Cmd"}, |
|
27140
a9eeb18e749c
patch 8.2.4099: Vim9: cannot use Vim9 syntax in mapping
Bram Moolenaar <Bram@vim.org>
parents:
27018
diff
changeset
|
1097 {K_SCRIPT_COMMAND, (char_u *)"ScriptCmd"}, |
|
23683
c6b9df4c442d
patch 8.2.2383: focus escape sequences are not named
Bram Moolenaar <Bram@vim.org>
parents:
22862
diff
changeset
|
1098 {K_FOCUSGAINED, (char_u *)"FocusGained"}, |
|
c6b9df4c442d
patch 8.2.2383: focus escape sequences are not named
Bram Moolenaar <Bram@vim.org>
parents:
22862
diff
changeset
|
1099 {K_FOCUSLOST, (char_u *)"FocusLost"}, |
| 7 | 1100 {0, NULL} |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1101 // NOTE: When adding a long name update MAX_KEY_NAME_LEN. |
| 7 | 1102 }; |
| 1103 | |
|
24768
7334bf933510
patch 8.2.2922: computing array length is done in various ways
Bram Moolenaar <Bram@vim.org>
parents:
24375
diff
changeset
|
1104 #define KEY_NAMES_TABLE_LEN ARRAY_LENGTH(key_names_table) |
| 7 | 1105 |
| 1106 /* | |
| 1107 * Return the modifier mask bit (MOD_MASK_*) which corresponds to the given | |
| 1108 * modifier name ('S' for Shift, 'C' for Ctrl etc). | |
| 1109 */ | |
|
17789
0f7ae8010787
patch 8.1.1891: functions used in one file are global
Bram Moolenaar <Bram@vim.org>
parents:
17781
diff
changeset
|
1110 static int |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1111 name_to_mod_mask(int c) |
| 7 | 1112 { |
| 1113 int i; | |
| 1114 | |
| 1115 c = TOUPPER_ASC(c); | |
| 1116 for (i = 0; mod_mask_table[i].mod_mask != 0; i++) | |
| 1117 if (c == mod_mask_table[i].name) | |
| 1118 return mod_mask_table[i].mod_flag; | |
| 1119 return 0; | |
| 1120 } | |
| 1121 | |
| 1122 /* | |
| 1123 * Check if if there is a special key code for "key" that includes the | |
| 1124 * modifiers specified. | |
| 1125 */ | |
| 1126 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1127 simplify_key(int key, int *modifiers) |
| 7 | 1128 { |
| 1129 int i; | |
| 1130 int key0; | |
| 1131 int key1; | |
| 1132 | |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1133 if (!(*modifiers & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT))) |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1134 return key; |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1135 |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1136 // TAB is a special case |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1137 if (key == TAB && (*modifiers & MOD_MASK_SHIFT)) |
| 7 | 1138 { |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1139 *modifiers &= ~MOD_MASK_SHIFT; |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1140 return K_S_TAB; |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1141 } |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1142 key0 = KEY2TERMCAP0(key); |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1143 key1 = KEY2TERMCAP1(key); |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1144 for (i = 0; modifier_keys_table[i] != NUL; i += MOD_KEYS_ENTRY_SIZE) |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1145 { |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1146 if (key0 == modifier_keys_table[i + 3] |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1147 && key1 == modifier_keys_table[i + 4] |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1148 && (*modifiers & modifier_keys_table[i])) |
| 7 | 1149 { |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1150 *modifiers &= ~modifier_keys_table[i]; |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1151 return TERMCAP2KEY(modifier_keys_table[i + 1], |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1152 modifier_keys_table[i + 2]); |
| 7 | 1153 } |
| 1154 } | |
| 1155 return key; | |
| 1156 } | |
| 1157 | |
| 1158 /* | |
| 180 | 1159 * Change <xHome> to <Home>, <xUp> to <Up>, etc. |
| 1160 */ | |
| 1161 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1162 handle_x_keys(int key) |
| 180 | 1163 { |
| 1164 switch (key) | |
| 1165 { | |
| 1166 case K_XUP: return K_UP; | |
| 1167 case K_XDOWN: return K_DOWN; | |
| 1168 case K_XLEFT: return K_LEFT; | |
| 1169 case K_XRIGHT: return K_RIGHT; | |
| 1170 case K_XHOME: return K_HOME; | |
| 230 | 1171 case K_ZHOME: return K_HOME; |
| 180 | 1172 case K_XEND: return K_END; |
| 230 | 1173 case K_ZEND: return K_END; |
| 180 | 1174 case K_XF1: return K_F1; |
| 1175 case K_XF2: return K_F2; | |
| 1176 case K_XF3: return K_F3; | |
| 1177 case K_XF4: return K_F4; | |
| 1178 case K_S_XF1: return K_S_F1; | |
| 1179 case K_S_XF2: return K_S_F2; | |
| 1180 case K_S_XF3: return K_S_F3; | |
| 1181 case K_S_XF4: return K_S_F4; | |
| 1182 } | |
| 1183 return key; | |
| 1184 } | |
| 1185 | |
| 1186 /* | |
| 7 | 1187 * Return a string which contains the name of the given key when the given |
| 1188 * modifiers are down. | |
| 1189 */ | |
| 1190 char_u * | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1191 get_special_key_name(int c, int modifiers) |
| 7 | 1192 { |
| 1193 static char_u string[MAX_KEY_NAME_LEN + 1]; | |
| 1194 | |
| 1195 int i, idx; | |
| 1196 int table_idx; | |
| 1197 char_u *s; | |
| 1198 | |
| 1199 string[0] = '<'; | |
| 1200 idx = 1; | |
| 1201 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1202 // Key that stands for a normal character. |
| 7 | 1203 if (IS_SPECIAL(c) && KEY2TERMCAP0(c) == KS_KEY) |
| 1204 c = KEY2TERMCAP1(c); | |
| 1205 | |
| 1206 /* | |
| 1207 * Translate shifted special keys into unshifted keys and set modifier. | |
| 1208 * Same for CTRL and ALT modifiers. | |
| 1209 */ | |
| 1210 if (IS_SPECIAL(c)) | |
| 1211 { | |
| 1212 for (i = 0; modifier_keys_table[i] != 0; i += MOD_KEYS_ENTRY_SIZE) | |
| 1213 if ( KEY2TERMCAP0(c) == (int)modifier_keys_table[i + 1] | |
| 1214 && (int)KEY2TERMCAP1(c) == (int)modifier_keys_table[i + 2]) | |
| 1215 { | |
| 1216 modifiers |= modifier_keys_table[i]; | |
| 1217 c = TERMCAP2KEY(modifier_keys_table[i + 3], | |
| 1218 modifier_keys_table[i + 4]); | |
| 1219 break; | |
| 1220 } | |
| 1221 } | |
| 1222 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1223 // try to find the key in the special key table |
| 7 | 1224 table_idx = find_special_key_in_table(c); |
| 1225 | |
| 1226 /* | |
| 1227 * When not a known special key, and not a printable character, try to | |
| 1228 * extract modifiers. | |
| 1229 */ | |
|
15597
536dd2bc5ac9
patch 8.1.0806: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
1230 if (c > 0 && (*mb_char2len)(c) == 1) |
| 7 | 1231 { |
| 1232 if (table_idx < 0 | |
| 1233 && (!vim_isprintc(c) || (c & 0x7f) == ' ') | |
| 1234 && (c & 0x80)) | |
| 1235 { | |
| 1236 c &= 0x7f; | |
| 1237 modifiers |= MOD_MASK_ALT; | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1238 // try again, to find the un-alted key in the special key table |
| 7 | 1239 table_idx = find_special_key_in_table(c); |
| 1240 } | |
| 1241 if (table_idx < 0 && !vim_isprintc(c) && c < ' ') | |
| 1242 { | |
| 1243 c += '@'; | |
| 1244 modifiers |= MOD_MASK_CTRL; | |
| 1245 } | |
| 1246 } | |
| 1247 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1248 // translate the modifier into a string |
| 7 | 1249 for (i = 0; mod_mask_table[i].name != 'A'; i++) |
| 1250 if ((modifiers & mod_mask_table[i].mod_mask) | |
| 1251 == mod_mask_table[i].mod_flag) | |
| 1252 { | |
| 1253 string[idx++] = mod_mask_table[i].name; | |
| 1254 string[idx++] = (char_u)'-'; | |
| 1255 } | |
| 1256 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1257 if (table_idx < 0) // unknown special key, may output t_xx |
| 7 | 1258 { |
| 1259 if (IS_SPECIAL(c)) | |
| 1260 { | |
| 1261 string[idx++] = 't'; | |
| 1262 string[idx++] = '_'; | |
| 1263 string[idx++] = KEY2TERMCAP0(c); | |
| 1264 string[idx++] = KEY2TERMCAP1(c); | |
| 1265 } | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1266 // Not a special key, only modifiers, output directly |
| 7 | 1267 else |
| 1268 { | |
| 1269 if (has_mbyte && (*mb_char2len)(c) > 1) | |
| 1270 idx += (*mb_char2bytes)(c, string + idx); | |
|
15597
536dd2bc5ac9
patch 8.1.0806: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
1271 else if (vim_isprintc(c)) |
| 7 | 1272 string[idx++] = c; |
| 1273 else | |
| 1274 { | |
| 1275 s = transchar(c); | |
| 1276 while (*s) | |
| 1277 string[idx++] = *s++; | |
| 1278 } | |
| 1279 } | |
| 1280 } | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1281 else // use name of special key |
| 7 | 1282 { |
|
10644
2025bec9175f
patch 8.0.0212: buffer for key name may be too small
Christian Brabandt <cb@256bit.org>
parents:
10640
diff
changeset
|
1283 size_t len = STRLEN(key_names_table[table_idx].name); |
|
2025bec9175f
patch 8.0.0212: buffer for key name may be too small
Christian Brabandt <cb@256bit.org>
parents:
10640
diff
changeset
|
1284 |
|
2025bec9175f
patch 8.0.0212: buffer for key name may be too small
Christian Brabandt <cb@256bit.org>
parents:
10640
diff
changeset
|
1285 if (len + idx + 2 <= MAX_KEY_NAME_LEN) |
|
2025bec9175f
patch 8.0.0212: buffer for key name may be too small
Christian Brabandt <cb@256bit.org>
parents:
10640
diff
changeset
|
1286 { |
|
2025bec9175f
patch 8.0.0212: buffer for key name may be too small
Christian Brabandt <cb@256bit.org>
parents:
10640
diff
changeset
|
1287 STRCPY(string + idx, key_names_table[table_idx].name); |
|
2025bec9175f
patch 8.0.0212: buffer for key name may be too small
Christian Brabandt <cb@256bit.org>
parents:
10640
diff
changeset
|
1288 idx += (int)len; |
|
2025bec9175f
patch 8.0.0212: buffer for key name may be too small
Christian Brabandt <cb@256bit.org>
parents:
10640
diff
changeset
|
1289 } |
| 7 | 1290 } |
| 1291 string[idx++] = '>'; | |
| 1292 string[idx] = NUL; | |
| 1293 return string; | |
| 1294 } | |
| 1295 | |
| 1296 /* | |
|
31722
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1297 * Try translating a <> name at "(*srcp)[]" to "dst[]". |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1298 * Return the number of characters added to "dst[]", zero for no match. |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1299 * If there is a match, "srcp" is advanced to after the <> name. |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1300 * "dst[]" must be big enough to hold the result (up to six characters)! |
| 7 | 1301 */ |
| 1302 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1303 trans_special( |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1304 char_u **srcp, |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1305 char_u *dst, |
|
20603
c2570baa2e4c
patch 8.2.0855: GUI tests fail because the test doesn't use a modifier
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
1306 int flags, // FSK_ values |
|
28668
53c608c7ea9e
patch 8.2.4858: K_SPECIAL may be escaped twice
Bram Moolenaar <Bram@vim.org>
parents:
28610
diff
changeset
|
1307 int escape_ks, // escape K_SPECIAL bytes in the character |
|
20603
c2570baa2e4c
patch 8.2.0855: GUI tests fail because the test doesn't use a modifier
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
1308 int *did_simplify) // FSK_SIMPLIFY and found <C-H> or <A-x> |
| 7 | 1309 { |
| 1310 int modifiers = 0; | |
| 1311 int key; | |
| 1312 | |
|
20603
c2570baa2e4c
patch 8.2.0855: GUI tests fail because the test doesn't use a modifier
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
1313 key = find_special_key(srcp, &modifiers, flags, did_simplify); |
| 7 | 1314 if (key == 0) |
| 1315 return 0; | |
| 1316 | |
|
28668
53c608c7ea9e
patch 8.2.4858: K_SPECIAL may be escaped twice
Bram Moolenaar <Bram@vim.org>
parents:
28610
diff
changeset
|
1317 return special_to_buf(key, modifiers, escape_ks, dst); |
|
16880
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1318 } |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1319 |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1320 /* |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1321 * Put the character sequence for "key" with "modifiers" into "dst" and return |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1322 * the resulting length. |
|
28668
53c608c7ea9e
patch 8.2.4858: K_SPECIAL may be escaped twice
Bram Moolenaar <Bram@vim.org>
parents:
28610
diff
changeset
|
1323 * When "escape_ks" is TRUE escape K_SPECIAL bytes in the character. |
|
16880
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1324 * The sequence is not NUL terminated. |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1325 * This is how characters in a string are encoded. |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1326 */ |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1327 int |
|
28668
53c608c7ea9e
patch 8.2.4858: K_SPECIAL may be escaped twice
Bram Moolenaar <Bram@vim.org>
parents:
28610
diff
changeset
|
1328 special_to_buf(int key, int modifiers, int escape_ks, char_u *dst) |
|
16880
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1329 { |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1330 int dlen = 0; |
|
998603a243d7
patch 8.1.1441: popup window filter not yet implemented
Bram Moolenaar <Bram@vim.org>
parents:
16876
diff
changeset
|
1331 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1332 // Put the appropriate modifier in a string |
| 7 | 1333 if (modifiers != 0) |
| 1334 { | |
| 1335 dst[dlen++] = K_SPECIAL; | |
| 1336 dst[dlen++] = KS_MODIFIER; | |
| 1337 dst[dlen++] = modifiers; | |
| 1338 } | |
| 1339 | |
| 1340 if (IS_SPECIAL(key)) | |
| 1341 { | |
| 1342 dst[dlen++] = K_SPECIAL; | |
| 1343 dst[dlen++] = KEY2TERMCAP0(key); | |
| 1344 dst[dlen++] = KEY2TERMCAP1(key); | |
| 1345 } | |
|
28668
53c608c7ea9e
patch 8.2.4858: K_SPECIAL may be escaped twice
Bram Moolenaar <Bram@vim.org>
parents:
28610
diff
changeset
|
1346 else if (escape_ks) |
|
53c608c7ea9e
patch 8.2.4858: K_SPECIAL may be escaped twice
Bram Moolenaar <Bram@vim.org>
parents:
28610
diff
changeset
|
1347 dlen = (int)(add_char2buf(key, dst + dlen) - dst); |
|
53c608c7ea9e
patch 8.2.4858: K_SPECIAL may be escaped twice
Bram Moolenaar <Bram@vim.org>
parents:
28610
diff
changeset
|
1348 else if (has_mbyte) |
| 7 | 1349 dlen += (*mb_char2bytes)(key, dst + dlen); |
| 1350 else | |
| 1351 dst[dlen++] = key; | |
| 1352 | |
| 1353 return dlen; | |
| 1354 } | |
| 1355 | |
| 1356 /* | |
|
31722
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1357 * Try translating a <> name at "(*srcp)[]", return the key and put modifiers |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1358 * in "modp". |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1359 * "srcp" is advanced to after the <> name. |
| 7 | 1360 * returns 0 if there is no match. |
| 1361 */ | |
| 1362 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1363 find_special_key( |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1364 char_u **srcp, |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1365 int *modp, |
|
20603
c2570baa2e4c
patch 8.2.0855: GUI tests fail because the test doesn't use a modifier
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
1366 int flags, // FSK_ values |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1367 int *did_simplify) // found <C-H> or <A-x> |
| 7 | 1368 { |
| 1369 char_u *last_dash; | |
| 1370 char_u *end_of_name; | |
| 1371 char_u *src; | |
| 1372 char_u *bp; | |
|
20603
c2570baa2e4c
patch 8.2.0855: GUI tests fail because the test doesn't use a modifier
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
1373 int in_string = flags & FSK_IN_STRING; |
| 7 | 1374 int modifiers; |
| 1375 int bit; | |
| 1376 int key; | |
|
9389
32e34e574716
commit https://github.com/vim/vim/commit/22fcfad29276bd5f317faf516637dcd491b96a12
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
1377 uvarnumber_T n; |
| 3024 | 1378 int l; |
| 7 | 1379 |
| 1380 src = *srcp; | |
|
20627
8bce783af0cb
patch 8.2.0867: using {xxx} for encoding a modifier is not nice
Bram Moolenaar <Bram@vim.org>
parents:
20603
diff
changeset
|
1381 if (src[0] != '<') |
| 7 | 1382 return 0; |
|
20627
8bce783af0cb
patch 8.2.0867: using {xxx} for encoding a modifier is not nice
Bram Moolenaar <Bram@vim.org>
parents:
20603
diff
changeset
|
1383 if (src[1] == '*') // <*xxx>: do not simplify |
|
8bce783af0cb
patch 8.2.0867: using {xxx} for encoding a modifier is not nice
Bram Moolenaar <Bram@vim.org>
parents:
20603
diff
changeset
|
1384 ++src; |
| 7 | 1385 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1386 // Find end of modifier list |
| 7 | 1387 last_dash = src; |
|
24375
fe4b6fc7149c
patch 8.2.2728: special key names don't work if 'isident' is cleared
Bram Moolenaar <Bram@vim.org>
parents:
24188
diff
changeset
|
1388 for (bp = src + 1; *bp == '-' || vim_isNormalIDc(*bp); bp++) |
| 7 | 1389 { |
| 1390 if (*bp == '-') | |
| 1391 { | |
| 1392 last_dash = bp; | |
| 3024 | 1393 if (bp[1] != NUL) |
| 1394 { | |
| 1395 if (has_mbyte) | |
| 1396 l = mb_ptr2len(bp + 1); | |
| 1397 else | |
| 1398 l = 1; | |
|
17720
844f470532b6
patch 8.1.1857: cannot use modifier with multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
17708
diff
changeset
|
1399 // Anything accepted, like <C-?>. |
|
844f470532b6
patch 8.1.1857: cannot use modifier with multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
17708
diff
changeset
|
1400 // <C-"> or <M-"> are not special in strings as " is |
|
844f470532b6
patch 8.1.1857: cannot use modifier with multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
17708
diff
changeset
|
1401 // the string delimiter. With a backslash it works: <M-\"> |
|
20627
8bce783af0cb
patch 8.2.0867: using {xxx} for encoding a modifier is not nice
Bram Moolenaar <Bram@vim.org>
parents:
20603
diff
changeset
|
1402 if (!(in_string && bp[1] == '"') && bp[l + 1] == '>') |
|
9373
b88c573d8aa4
commit https://github.com/vim/vim/commit/1d90a5a5af84250e226f8a9121e771f7b72aa894
Christian Brabandt <cb@256bit.org>
parents:
9347
diff
changeset
|
1403 bp += l; |
|
9869
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1404 else if (in_string && bp[1] == '\\' && bp[2] == '"' |
|
20627
8bce783af0cb
patch 8.2.0867: using {xxx} for encoding a modifier is not nice
Bram Moolenaar <Bram@vim.org>
parents:
20603
diff
changeset
|
1405 && bp[3] == '>') |
|
9869
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1406 bp += 2; |
| 3024 | 1407 } |
| 7 | 1408 } |
| 1409 if (bp[0] == 't' && bp[1] == '_' && bp[2] && bp[3]) | |
|
20627
8bce783af0cb
patch 8.2.0867: using {xxx} for encoding a modifier is not nice
Bram Moolenaar <Bram@vim.org>
parents:
20603
diff
changeset
|
1410 bp += 3; // skip t_xx, xx may be '-' or '>' |
| 3026 | 1411 else if (STRNICMP(bp, "char-", 5) == 0) |
| 1412 { | |
|
32098
39f4126d2a0d
patch 9.0.1380: CTRL-X on 2**64 subtracts two
Bram Moolenaar <Bram@vim.org>
parents:
31940
diff
changeset
|
1413 vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0, TRUE, NULL); |
|
16706
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16606
diff
changeset
|
1414 if (l == 0) |
|
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16606
diff
changeset
|
1415 { |
|
26865
bce848ec8b1b
patch 8.2.3961: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26602
diff
changeset
|
1416 emsg(_(e_invalid_argument)); |
|
16706
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16606
diff
changeset
|
1417 return 0; |
|
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16606
diff
changeset
|
1418 } |
| 3026 | 1419 bp += l + 5; |
| 1420 break; | |
| 1421 } | |
| 7 | 1422 } |
| 1423 | |
|
20627
8bce783af0cb
patch 8.2.0867: using {xxx} for encoding a modifier is not nice
Bram Moolenaar <Bram@vim.org>
parents:
20603
diff
changeset
|
1424 if (*bp == '>') // found matching '>' |
| 7 | 1425 { |
| 1426 end_of_name = bp + 1; | |
| 1427 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1428 // Which modifiers are given? |
| 7 | 1429 modifiers = 0x0; |
| 1430 for (bp = src + 1; bp < last_dash; bp++) | |
| 1431 { | |
| 1432 if (*bp != '-') | |
| 1433 { | |
| 1434 bit = name_to_mod_mask(*bp); | |
| 1435 if (bit == 0x0) | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1436 break; // Illegal modifier name |
| 7 | 1437 modifiers |= bit; |
| 1438 } | |
| 1439 } | |
| 1440 | |
| 1441 /* | |
| 1442 * Legal modifier name. | |
| 1443 */ | |
| 1444 if (bp >= last_dash) | |
| 1445 { | |
| 3024 | 1446 if (STRNICMP(last_dash + 1, "char-", 5) == 0 |
| 1447 && VIM_ISDIGIT(last_dash[6])) | |
| 1448 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1449 // <Char-123> or <Char-033> or <Char-0x33> |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1450 vim_str2nr(last_dash + 6, NULL, &l, STR2NR_ALL, NULL, |
|
32098
39f4126d2a0d
patch 9.0.1380: CTRL-X on 2**64 subtracts two
Bram Moolenaar <Bram@vim.org>
parents:
31940
diff
changeset
|
1451 &n, 0, TRUE, NULL); |
|
16706
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16606
diff
changeset
|
1452 if (l == 0) |
|
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16606
diff
changeset
|
1453 { |
|
26865
bce848ec8b1b
patch 8.2.3961: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26602
diff
changeset
|
1454 emsg(_(e_invalid_argument)); |
|
16706
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16606
diff
changeset
|
1455 return 0; |
|
77bcb5055fec
patch 8.1.1355: obvious mistakes are accepted as valid expressions
Bram Moolenaar <Bram@vim.org>
parents:
16606
diff
changeset
|
1456 } |
| 3026 | 1457 key = (int)n; |
| 3024 | 1458 } |
| 7 | 1459 else |
| 180 | 1460 { |
|
9869
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1461 int off = 1; |
|
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1462 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1463 // Modifier with single letter, or special key name. |
|
9869
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1464 if (in_string && last_dash[1] == '\\' && last_dash[2] == '"') |
|
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1465 off = 2; |
| 3026 | 1466 if (has_mbyte) |
|
9869
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1467 l = mb_ptr2len(last_dash + off); |
| 3026 | 1468 else |
| 1469 l = 1; | |
|
20627
8bce783af0cb
patch 8.2.0867: using {xxx} for encoding a modifier is not nice
Bram Moolenaar <Bram@vim.org>
parents:
20603
diff
changeset
|
1470 if (modifiers != 0 && last_dash[l + off] == '>') |
|
9869
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1471 key = PTR2CHAR(last_dash + off); |
| 3026 | 1472 else |
| 1473 { | |
|
9869
989d44d35a66
commit https://github.com/vim/vim/commit/35a4cfa200917dd171b1fff3cd5b6cee9add673d
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1474 key = get_special_key_code(last_dash + off); |
|
20603
c2570baa2e4c
patch 8.2.0855: GUI tests fail because the test doesn't use a modifier
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
1475 if (!(flags & FSK_KEEP_X_KEY)) |
| 3026 | 1476 key = handle_x_keys(key); |
| 1477 } | |
| 180 | 1478 } |
| 7 | 1479 |
| 1480 /* | |
| 1481 * get_special_key_code() may return NUL for invalid | |
| 1482 * special key name. | |
| 1483 */ | |
| 1484 if (key != NUL) | |
| 1485 { | |
| 1486 /* | |
| 1487 * Only use a modifier when there is no special key code that | |
| 1488 * includes the modifier. | |
| 1489 */ | |
| 1490 key = simplify_key(key, &modifiers); | |
| 1491 | |
|
31722
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1492 if ((flags & FSK_KEYCODE) == 0) |
| 7 | 1493 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1494 // don't want keycode, use single byte code |
| 7 | 1495 if (key == K_BS) |
| 1496 key = BS; | |
| 1497 else if (key == K_DEL || key == K_KDEL) | |
| 1498 key = DEL; | |
| 1499 } | |
|
31722
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1500 else if (key == 27 |
|
31734
59c474f6715d
patch 9.0.1199: crash when using kitty and using a mapping with <Esc>
Bram Moolenaar <Bram@vim.org>
parents:
31728
diff
changeset
|
1501 && (flags & FSK_FROM_PART) != 0 |
|
31722
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1502 && (kitty_protocol_state == KKPS_ENABLED |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1503 || kitty_protocol_state == KKPS_DISABLED)) |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1504 { |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1505 // Using the Kitty key protocol, which uses K_ESC for an |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1506 // Esc character. For the simplified keys use the Esc |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1507 // character and set did_simplify, then in the |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1508 // non-simplified keys use K_ESC. |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1509 if ((flags & FSK_SIMPLIFY) != 0) |
|
31734
59c474f6715d
patch 9.0.1199: crash when using kitty and using a mapping with <Esc>
Bram Moolenaar <Bram@vim.org>
parents:
31728
diff
changeset
|
1510 { |
|
59c474f6715d
patch 9.0.1199: crash when using kitty and using a mapping with <Esc>
Bram Moolenaar <Bram@vim.org>
parents:
31728
diff
changeset
|
1511 if (did_simplify != NULL) |
|
59c474f6715d
patch 9.0.1199: crash when using kitty and using a mapping with <Esc>
Bram Moolenaar <Bram@vim.org>
parents:
31728
diff
changeset
|
1512 *did_simplify = TRUE; |
|
59c474f6715d
patch 9.0.1199: crash when using kitty and using a mapping with <Esc>
Bram Moolenaar <Bram@vim.org>
parents:
31728
diff
changeset
|
1513 } |
|
31722
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1514 else |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1515 key = K_ESC; |
|
6fa4f94aca5a
patch 9.0.1193: cannot map <Esc> when using the Kitty key protocol
Bram Moolenaar <Bram@vim.org>
parents:
31156
diff
changeset
|
1516 } |
| 7 | 1517 |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1518 // Normal Key with modifier: Try to make a single byte code. |
| 7 | 1519 if (!IS_SPECIAL(key)) |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1520 key = extract_modifiers(key, &modifiers, |
|
20603
c2570baa2e4c
patch 8.2.0855: GUI tests fail because the test doesn't use a modifier
Bram Moolenaar <Bram@vim.org>
parents:
20392
diff
changeset
|
1521 flags & FSK_SIMPLIFY, did_simplify); |
| 7 | 1522 |
| 1523 *modp = modifiers; | |
| 1524 *srcp = end_of_name; | |
| 1525 return key; | |
| 1526 } | |
| 1527 } | |
| 1528 } | |
| 1529 return 0; | |
| 1530 } | |
| 1531 | |
|
20935
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1532 |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1533 /* |
|
22522
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1534 * Some keys are used with Ctrl without Shift and are still expected to be |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1535 * mapped as if Shift was pressed: |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1536 * CTRL-2 is CTRL-@ |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1537 * CTRL-6 is CTRL-^ |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1538 * CTRL-- is CTRL-_ |
|
31156
0ecb16d5f86f
patch 9.0.0912: libvterm with modifyOtherKeys level 2 does not match xterm
Bram Moolenaar <Bram@vim.org>
parents:
31133
diff
changeset
|
1539 * Also, unless no_reduce_keys is set then <C-H> and <C-h> mean the same thing, |
|
0ecb16d5f86f
patch 9.0.0912: libvterm with modifyOtherKeys level 2 does not match xterm
Bram Moolenaar <Bram@vim.org>
parents:
31133
diff
changeset
|
1540 * use "H". |
|
22522
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1541 * Returns the possibly adjusted key. |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1542 */ |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1543 int |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1544 may_adjust_key_for_ctrl(int modifiers, int key) |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1545 { |
|
31940
03188d05289a
patch 9.0.1302: on a Belgian keyboard CTRL-] does not work
Bram Moolenaar <Bram@vim.org>
parents:
31734
diff
changeset
|
1546 if ((modifiers & MOD_MASK_CTRL) == 0) |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1547 return key; |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1548 |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1549 if (ASCII_ISALPHA(key)) |
|
22522
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1550 { |
|
31156
0ecb16d5f86f
patch 9.0.0912: libvterm with modifyOtherKeys level 2 does not match xterm
Bram Moolenaar <Bram@vim.org>
parents:
31133
diff
changeset
|
1551 #ifdef FEAT_TERMINAL |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1552 check_no_reduce_keys(); // may update the no_reduce_keys flag |
|
31156
0ecb16d5f86f
patch 9.0.0912: libvterm with modifyOtherKeys level 2 does not match xterm
Bram Moolenaar <Bram@vim.org>
parents:
31133
diff
changeset
|
1553 #endif |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1554 return no_reduce_keys == 0 ? TOUPPER_ASC(key) : key; |
|
22522
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1555 } |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1556 if (key == '2') |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1557 return '@'; |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1558 if (key == '6') |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1559 return '^'; |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1560 if (key == '-') |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
1561 return '_'; |
|
31940
03188d05289a
patch 9.0.1302: on a Belgian keyboard CTRL-] does not work
Bram Moolenaar <Bram@vim.org>
parents:
31734
diff
changeset
|
1562 |
|
03188d05289a
patch 9.0.1302: on a Belgian keyboard CTRL-] does not work
Bram Moolenaar <Bram@vim.org>
parents:
31734
diff
changeset
|
1563 // On a Belgian keyboard AltGr $ is ']', on other keyboards '$' can only be |
|
03188d05289a
patch 9.0.1302: on a Belgian keyboard CTRL-] does not work
Bram Moolenaar <Bram@vim.org>
parents:
31734
diff
changeset
|
1564 // obtained with Shift. Assume that '$' without shift implies a Belgian |
|
03188d05289a
patch 9.0.1302: on a Belgian keyboard CTRL-] does not work
Bram Moolenaar <Bram@vim.org>
parents:
31734
diff
changeset
|
1565 // keyboard, where CTRL-$ means CTRL-]. |
|
03188d05289a
patch 9.0.1302: on a Belgian keyboard CTRL-] does not work
Bram Moolenaar <Bram@vim.org>
parents:
31734
diff
changeset
|
1566 if (key == '$' && (modifiers & MOD_MASK_SHIFT) == 0) |
|
03188d05289a
patch 9.0.1302: on a Belgian keyboard CTRL-] does not work
Bram Moolenaar <Bram@vim.org>
parents:
31734
diff
changeset
|
1567 return ']'; |
|
03188d05289a
patch 9.0.1302: on a Belgian keyboard CTRL-] does not work
Bram Moolenaar <Bram@vim.org>
parents:
31734
diff
changeset
|
1568 |
|
22522
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1569 return key; |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1570 } |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1571 |
|
6c7e4db139a3
patch 8.2.1809: mapping some keys with Ctrl does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
22407
diff
changeset
|
1572 /* |
|
20935
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1573 * Some keys already have Shift included, pass them as normal keys. |
|
22526
6325ef9143bc
patch 8.2.1811: mapping Ctrl-key does not work for '{', '}' and '|'
Bram Moolenaar <Bram@vim.org>
parents:
22522
diff
changeset
|
1574 * When Ctrl is also used <C-H> and <C-S-H> are different, but <C-S-{> should |
|
6325ef9143bc
patch 8.2.1811: mapping Ctrl-key does not work for '{', '}' and '|'
Bram Moolenaar <Bram@vim.org>
parents:
22522
diff
changeset
|
1575 * be <C-{>. Same for <C-S-}> and <C-S-|>. |
|
20935
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1576 * Also for <A-S-a> and <M-S-a>. |
|
30235
2403a1b53826
patch 9.0.0453: on an AZERTY keyboard digit keys get the shift modifier
Bram Moolenaar <Bram@vim.org>
parents:
30205
diff
changeset
|
1577 * This includes all printable ASCII characters except a-z. |
|
2403a1b53826
patch 9.0.0453: on an AZERTY keyboard digit keys get the shift modifier
Bram Moolenaar <Bram@vim.org>
parents:
30205
diff
changeset
|
1578 * Digits are included because with AZERTY the Shift key is used to get them. |
|
20935
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1579 */ |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1580 int |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1581 may_remove_shift_modifier(int modifiers, int key) |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1582 { |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1583 if ((modifiers == MOD_MASK_SHIFT |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1584 || modifiers == (MOD_MASK_SHIFT | MOD_MASK_ALT) |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1585 || modifiers == (MOD_MASK_SHIFT | MOD_MASK_META)) |
|
22407
c19acd92ee83
patch 8.2.1752: GTK GUI: cannot map alt-? with <A-?>
Bram Moolenaar <Bram@vim.org>
parents:
21745
diff
changeset
|
1586 && ((key >= '!' && key <= '/') |
|
c19acd92ee83
patch 8.2.1752: GTK GUI: cannot map alt-? with <A-?>
Bram Moolenaar <Bram@vim.org>
parents:
21745
diff
changeset
|
1587 || (key >= ':' && key <= 'Z') |
|
30235
2403a1b53826
patch 9.0.0453: on an AZERTY keyboard digit keys get the shift modifier
Bram Moolenaar <Bram@vim.org>
parents:
30205
diff
changeset
|
1588 || vim_isdigit(key) |
|
22407
c19acd92ee83
patch 8.2.1752: GTK GUI: cannot map alt-? with <A-?>
Bram Moolenaar <Bram@vim.org>
parents:
21745
diff
changeset
|
1589 || (key >= '[' && key <= '`') |
|
20935
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1590 || (key >= '{' && key <= '~'))) |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1591 return modifiers & ~MOD_MASK_SHIFT; |
|
22526
6325ef9143bc
patch 8.2.1811: mapping Ctrl-key does not work for '{', '}' and '|'
Bram Moolenaar <Bram@vim.org>
parents:
22522
diff
changeset
|
1592 |
|
6325ef9143bc
patch 8.2.1811: mapping Ctrl-key does not work for '{', '}' and '|'
Bram Moolenaar <Bram@vim.org>
parents:
22522
diff
changeset
|
1593 if (modifiers == (MOD_MASK_SHIFT | MOD_MASK_CTRL) |
|
6325ef9143bc
patch 8.2.1811: mapping Ctrl-key does not work for '{', '}' and '|'
Bram Moolenaar <Bram@vim.org>
parents:
22522
diff
changeset
|
1594 && (key == '{' || key == '}' || key == '|')) |
|
6325ef9143bc
patch 8.2.1811: mapping Ctrl-key does not work for '{', '}' and '|'
Bram Moolenaar <Bram@vim.org>
parents:
22522
diff
changeset
|
1595 return modifiers & ~MOD_MASK_SHIFT; |
|
6325ef9143bc
patch 8.2.1811: mapping Ctrl-key does not work for '{', '}' and '|'
Bram Moolenaar <Bram@vim.org>
parents:
22522
diff
changeset
|
1596 |
|
20935
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1597 return modifiers; |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1598 } |
|
d64520bfafa0
patch 8.2.1019: mapping <M-S-a> does not work in the GUI
Bram Moolenaar <Bram@vim.org>
parents:
20927
diff
changeset
|
1599 |
| 7 | 1600 /* |
| 1601 * Try to include modifiers in the key. | |
| 1602 * Changes "Shift-a" to 'A', "Alt-A" to 0xc0, etc. | |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1603 * When "simplify" is FALSE don't do Ctrl and Alt. |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1604 * When "simplify" is TRUE and Ctrl or Alt is removed from modifiers set |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1605 * "did_simplify" when it's not NULL. |
| 7 | 1606 */ |
| 1607 int | |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1608 extract_modifiers(int key, int *modp, int simplify, int *did_simplify) |
| 7 | 1609 { |
| 1610 int modifiers = *modp; | |
| 1611 | |
|
12716
351cf7c67bbe
patch 8.0.1236: Mac features are confusing
Christian Brabandt <cb@256bit.org>
parents:
12672
diff
changeset
|
1612 #ifdef MACOS_X |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1613 // Command-key really special, no fancynest |
| 7 | 1614 if (!(modifiers & MOD_MASK_CMD)) |
| 1615 #endif | |
| 1616 if ((modifiers & MOD_MASK_SHIFT) && ASCII_ISALPHA(key)) | |
| 1617 { | |
| 1618 key = TOUPPER_ASC(key); | |
|
20927
9328feafbbf5
patch 8.2.1015: popup filter gets key with modifier prepended
Bram Moolenaar <Bram@vim.org>
parents:
20751
diff
changeset
|
1619 // With <C-S-a> we keep the shift modifier. |
|
9328feafbbf5
patch 8.2.1015: popup filter gets key with modifier prepended
Bram Moolenaar <Bram@vim.org>
parents:
20751
diff
changeset
|
1620 // With <S-a>, <A-S-a> and <S-A> we don't keep the shift modifier. |
|
9328feafbbf5
patch 8.2.1015: popup filter gets key with modifier prepended
Bram Moolenaar <Bram@vim.org>
parents:
20751
diff
changeset
|
1621 if (simplify || modifiers == MOD_MASK_SHIFT |
|
9328feafbbf5
patch 8.2.1015: popup filter gets key with modifier prepended
Bram Moolenaar <Bram@vim.org>
parents:
20751
diff
changeset
|
1622 || modifiers == (MOD_MASK_SHIFT | MOD_MASK_ALT) |
|
9328feafbbf5
patch 8.2.1015: popup filter gets key with modifier prepended
Bram Moolenaar <Bram@vim.org>
parents:
20751
diff
changeset
|
1623 || modifiers == (MOD_MASK_SHIFT | MOD_MASK_META)) |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1624 modifiers &= ~MOD_MASK_SHIFT; |
| 7 | 1625 } |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1626 |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1627 // <C-H> and <C-h> mean the same thing, always use "H" |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1628 if ((modifiers & MOD_MASK_CTRL) && ASCII_ISALPHA(key)) |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1629 key = TOUPPER_ASC(key); |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1630 |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1631 if (simplify && (modifiers & MOD_MASK_CTRL) |
|
27490
fb4c30606b4a
patch 8.2.4273: the EBCDIC support is outdated
Bram Moolenaar <Bram@vim.org>
parents:
27181
diff
changeset
|
1632 && ((key >= '?' && key <= '_') || ASCII_ISALPHA(key))) |
| 7 | 1633 { |
| 1634 key = Ctrl_chr(key); | |
| 1635 modifiers &= ~MOD_MASK_CTRL; | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1636 // <C-@> is <Nul> |
|
28610
ce202d2984a0
patch 8.2.4829: a key may be simplified to NUL
Bram Moolenaar <Bram@vim.org>
parents:
28169
diff
changeset
|
1637 if (key == NUL) |
| 7 | 1638 key = K_ZERO; |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1639 if (did_simplify != NULL) |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1640 *did_simplify = TRUE; |
| 7 | 1641 } |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1642 |
|
12716
351cf7c67bbe
patch 8.0.1236: Mac features are confusing
Christian Brabandt <cb@256bit.org>
parents:
12672
diff
changeset
|
1643 #ifdef MACOS_X |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1644 // Command-key really special, no fancynest |
| 7 | 1645 if (!(modifiers & MOD_MASK_CMD)) |
| 1646 #endif | |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1647 if (simplify && (modifiers & MOD_MASK_ALT) && key < 0x80 |
|
15597
536dd2bc5ac9
patch 8.1.0806: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
1648 && !enc_dbcs) // avoid creating a lead byte |
| 7 | 1649 { |
| 1650 key |= 0x80; | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1651 modifiers &= ~MOD_MASK_ALT; // remove the META modifier |
|
18301
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1652 if (did_simplify != NULL) |
|
506bf60a30a0
patch 8.1.2145: cannot map <C-H> when modifyOtherKeys is enabled
Bram Moolenaar <Bram@vim.org>
parents:
18291
diff
changeset
|
1653 *did_simplify = TRUE; |
| 7 | 1654 } |
| 1655 | |
| 1656 *modp = modifiers; | |
| 1657 return key; | |
| 1658 } | |
| 1659 | |
| 1660 /* | |
| 1661 * Try to find key "c" in the special key table. | |
| 1662 * Return the index when found, -1 when not found. | |
| 1663 */ | |
| 1664 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1665 find_special_key_in_table(int c) |
| 7 | 1666 { |
| 1667 int i; | |
| 1668 | |
| 1669 for (i = 0; key_names_table[i].name != NULL; i++) | |
| 1670 if (c == key_names_table[i].key) | |
| 1671 break; | |
| 1672 if (key_names_table[i].name == NULL) | |
| 1673 i = -1; | |
| 1674 return i; | |
| 1675 } | |
| 1676 | |
| 1677 /* | |
| 1678 * Find the special key with the given name (the given string does not have to | |
| 1679 * end with NUL, the name is assumed to end before the first non-idchar). | |
| 1680 * If the name starts with "t_" the next two characters are interpreted as a | |
| 1681 * termcap name. | |
| 1682 * Return the key code, or 0 if not found. | |
| 1683 */ | |
| 1684 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1685 get_special_key_code(char_u *name) |
| 7 | 1686 { |
| 1687 char_u *table_name; | |
| 1688 char_u string[3]; | |
| 1689 int i, j; | |
| 1690 | |
| 1691 /* | |
| 1692 * If it's <t_xx> we get the code for xx from the termcap | |
| 1693 */ | |
| 1694 if (name[0] == 't' && name[1] == '_' && name[2] != NUL && name[3] != NUL) | |
| 1695 { | |
| 1696 string[0] = name[2]; | |
| 1697 string[1] = name[3]; | |
| 1698 string[2] = NUL; | |
| 1699 if (add_termcap_entry(string, FALSE) == OK) | |
| 1700 return TERMCAP2KEY(name[2], name[3]); | |
| 1701 } | |
| 1702 else | |
| 1703 for (i = 0; key_names_table[i].name != NULL; i++) | |
| 1704 { | |
| 1705 table_name = key_names_table[i].name; | |
|
24375
fe4b6fc7149c
patch 8.2.2728: special key names don't work if 'isident' is cleared
Bram Moolenaar <Bram@vim.org>
parents:
24188
diff
changeset
|
1706 for (j = 0; vim_isNormalIDc(name[j]) && table_name[j] != NUL; j++) |
| 7 | 1707 if (TOLOWER_ASC(table_name[j]) != TOLOWER_ASC(name[j])) |
| 1708 break; | |
|
24375
fe4b6fc7149c
patch 8.2.2728: special key names don't work if 'isident' is cleared
Bram Moolenaar <Bram@vim.org>
parents:
24188
diff
changeset
|
1709 if (!vim_isNormalIDc(name[j]) && table_name[j] == NUL) |
| 7 | 1710 return key_names_table[i].key; |
| 1711 } | |
| 1712 return 0; | |
| 1713 } | |
| 1714 | |
| 1715 char_u * | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1716 get_key_name(int i) |
| 7 | 1717 { |
| 1881 | 1718 if (i >= (int)KEY_NAMES_TABLE_LEN) |
| 7 | 1719 return NULL; |
| 1720 return key_names_table[i].name; | |
| 1721 } | |
| 1722 | |
| 1723 /* | |
| 1724 * Return the current end-of-line type: EOL_DOS, EOL_UNIX or EOL_MAC. | |
| 1725 */ | |
| 1726 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1727 get_fileformat(buf_T *buf) |
| 7 | 1728 { |
| 1729 int c = *buf->b_p_ff; | |
| 1730 | |
| 1731 if (buf->b_p_bin || c == 'u') | |
| 1732 return EOL_UNIX; | |
| 1733 if (c == 'm') | |
| 1734 return EOL_MAC; | |
| 1735 return EOL_DOS; | |
| 1736 } | |
| 1737 | |
| 1738 /* | |
| 1739 * Like get_fileformat(), but override 'fileformat' with "p" for "++opt=val" | |
| 1740 * argument. | |
| 1741 */ | |
| 1742 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1743 get_fileformat_force( |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1744 buf_T *buf, |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1745 exarg_T *eap) // can be NULL! |
| 7 | 1746 { |
| 1747 int c; | |
| 1748 | |
| 1749 if (eap != NULL && eap->force_ff != 0) | |
|
13575
4df23d9bad47
patch 8.0.1660: the terminal API "drop" command doesn't support options
Christian Brabandt <cb@256bit.org>
parents:
13493
diff
changeset
|
1750 c = eap->force_ff; |
| 7 | 1751 else |
| 1752 { | |
| 1753 if ((eap != NULL && eap->force_bin != 0) | |
| 1754 ? (eap->force_bin == FORCE_BIN) : buf->b_p_bin) | |
| 1755 return EOL_UNIX; | |
| 1756 c = *buf->b_p_ff; | |
| 1757 } | |
| 1758 if (c == 'u') | |
| 1759 return EOL_UNIX; | |
| 1760 if (c == 'm') | |
| 1761 return EOL_MAC; | |
| 1762 return EOL_DOS; | |
| 1763 } | |
| 1764 | |
| 1765 /* | |
| 1766 * Set the current end-of-line type to EOL_DOS, EOL_UNIX or EOL_MAC. | |
| 1767 * Sets both 'textmode' and 'fileformat'. | |
| 1768 * Note: Does _not_ set global value of 'textmode'! | |
| 1769 */ | |
| 1770 void | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1771 set_fileformat( |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1772 int t, |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1773 int opt_flags) // OPT_LOCAL and/or OPT_GLOBAL |
| 7 | 1774 { |
| 1775 char *p = NULL; | |
| 1776 | |
| 1777 switch (t) | |
| 1778 { | |
| 1779 case EOL_DOS: | |
| 1780 p = FF_DOS; | |
| 1781 curbuf->b_p_tx = TRUE; | |
| 1782 break; | |
| 1783 case EOL_UNIX: | |
| 1784 p = FF_UNIX; | |
| 1785 curbuf->b_p_tx = FALSE; | |
| 1786 break; | |
| 1787 case EOL_MAC: | |
| 1788 p = FF_MAC; | |
| 1789 curbuf->b_p_tx = FALSE; | |
| 1790 break; | |
| 1791 } | |
| 1792 if (p != NULL) | |
| 1793 set_string_option_direct((char_u *)"ff", -1, (char_u *)p, | |
| 694 | 1794 OPT_FREE | opt_flags, 0); |
| 1795 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1796 // This may cause the buffer to become (un)modified. |
| 7 | 1797 check_status(curbuf); |
| 673 | 1798 redraw_tabline = TRUE; |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1799 need_maketitle = TRUE; // set window title later |
| 7 | 1800 } |
| 1801 | |
| 1802 /* | |
| 1803 * Return the default fileformat from 'fileformats'. | |
| 1804 */ | |
| 1805 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1806 default_fileformat(void) |
| 7 | 1807 { |
| 1808 switch (*p_ffs) | |
| 1809 { | |
| 1810 case 'm': return EOL_MAC; | |
| 1811 case 'd': return EOL_DOS; | |
| 1812 } | |
| 1813 return EOL_UNIX; | |
| 1814 } | |
| 1815 | |
| 1816 /* | |
| 1817 * Call shell. Calls mch_call_shell, with 'shellxquote' added. | |
| 1818 */ | |
| 1819 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1820 call_shell(char_u *cmd, int opt) |
| 7 | 1821 { |
| 1822 char_u *ncmd; | |
| 1823 int retval; | |
| 170 | 1824 #ifdef FEAT_PROFILE |
| 1825 proftime_T wait_time; | |
| 1826 #endif | |
| 7 | 1827 |
| 1828 if (p_verbose > 3) | |
| 1829 { | |
| 293 | 1830 verbose_enter(); |
|
20380
79c870b68cf3
patch 8.2.0745: crash on exit when not all popups are closed
Bram Moolenaar <Bram@vim.org>
parents:
20033
diff
changeset
|
1831 smsg(_("Calling shell to execute: \"%s\""), cmd == NULL ? p_sh : cmd); |
|
30519
4a88061200c2
patch 9.0.0595: extra newline in messages after a verbose shell message
Bram Moolenaar <Bram@vim.org>
parents:
30235
diff
changeset
|
1832 msg_putchar_attr('\n', 0); |
| 7 | 1833 cursor_on(); |
| 293 | 1834 verbose_leave(); |
| 7 | 1835 } |
| 1836 | |
| 170 | 1837 #ifdef FEAT_PROFILE |
| 789 | 1838 if (do_profiling == PROF_YES) |
| 170 | 1839 prof_child_enter(&wait_time); |
| 1840 #endif | |
| 1841 | |
| 7 | 1842 if (*p_sh == NUL) |
| 1843 { | |
|
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26336
diff
changeset
|
1844 emsg(_(e_shell_option_is_empty)); |
| 7 | 1845 retval = -1; |
| 1846 } | |
| 1847 else | |
| 1848 { | |
| 1849 #ifdef FEAT_GUI_MSWIN | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1850 // Don't hide the pointer while executing a shell command. |
| 7 | 1851 gui_mch_mousehide(FALSE); |
| 1852 #endif | |
| 1853 #ifdef FEAT_GUI | |
| 1854 ++hold_gui_events; | |
| 1855 #endif | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1856 // The external command may update a tags file, clear cached tags. |
| 7 | 1857 tag_freematch(); |
| 1858 | |
|
17028
70933f7b5de4
patch 8.1.1514: MS-Windows: wrong shell command with ! in 'guioptions'
Bram Moolenaar <Bram@vim.org>
parents:
17000
diff
changeset
|
1859 if (cmd == NULL || *p_sxq == NUL) |
| 7 | 1860 retval = mch_call_shell(cmd, opt); |
| 1861 else | |
| 1862 { | |
| 3359 | 1863 char_u *ecmd = cmd; |
| 1864 | |
|
18195
a81f0c936112
patch 8.1.2092: MS-Windows: redirect in system() does not work
Bram Moolenaar <Bram@vim.org>
parents:
18135
diff
changeset
|
1865 if (*p_sxe != NUL && *p_sxq == '(') |
| 3359 | 1866 { |
| 1867 ecmd = vim_strsave_escaped_ext(cmd, p_sxe, '^', FALSE); | |
| 1868 if (ecmd == NULL) | |
| 1869 ecmd = cmd; | |
| 1870 } | |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16706
diff
changeset
|
1871 ncmd = alloc(STRLEN(ecmd) + STRLEN(p_sxq) * 2 + 1); |
| 7 | 1872 if (ncmd != NULL) |
| 1873 { | |
| 1874 STRCPY(ncmd, p_sxq); | |
| 3359 | 1875 STRCAT(ncmd, ecmd); |
|
18195
a81f0c936112
patch 8.1.2092: MS-Windows: redirect in system() does not work
Bram Moolenaar <Bram@vim.org>
parents:
18135
diff
changeset
|
1876 // When 'shellxquote' is ( append ). |
|
a81f0c936112
patch 8.1.2092: MS-Windows: redirect in system() does not work
Bram Moolenaar <Bram@vim.org>
parents:
18135
diff
changeset
|
1877 // When 'shellxquote' is "( append )". |
|
a81f0c936112
patch 8.1.2092: MS-Windows: redirect in system() does not work
Bram Moolenaar <Bram@vim.org>
parents:
18135
diff
changeset
|
1878 STRCAT(ncmd, *p_sxq == '(' ? (char_u *)")" |
|
a81f0c936112
patch 8.1.2092: MS-Windows: redirect in system() does not work
Bram Moolenaar <Bram@vim.org>
parents:
18135
diff
changeset
|
1879 : *p_sxq == '"' && *(p_sxq+1) == '(' ? (char_u *)")\"" |
|
a81f0c936112
patch 8.1.2092: MS-Windows: redirect in system() does not work
Bram Moolenaar <Bram@vim.org>
parents:
18135
diff
changeset
|
1880 : p_sxq); |
| 7 | 1881 retval = mch_call_shell(ncmd, opt); |
| 1882 vim_free(ncmd); | |
| 1883 } | |
| 1884 else | |
| 1885 retval = -1; | |
| 3359 | 1886 if (ecmd != cmd) |
| 1887 vim_free(ecmd); | |
| 7 | 1888 } |
| 1889 #ifdef FEAT_GUI | |
| 1890 --hold_gui_events; | |
| 1891 #endif | |
| 1892 /* | |
| 1893 * Check the window size, in case it changed while executing the | |
| 1894 * external command. | |
| 1895 */ | |
| 1896 shell_resized_check(); | |
| 1897 } | |
| 1898 | |
| 1899 #ifdef FEAT_EVAL | |
| 1900 set_vim_var_nr(VV_SHELL_ERROR, (long)retval); | |
| 170 | 1901 # ifdef FEAT_PROFILE |
| 789 | 1902 if (do_profiling == PROF_YES) |
| 170 | 1903 prof_child_exit(&wait_time); |
| 1904 # endif | |
| 7 | 1905 #endif |
| 1906 | |
| 1907 return retval; | |
| 1908 } | |
| 1909 | |
| 1910 /* | |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
1911 * MODE_VISUAL, MODE_SELECT and MODE_OP_PENDING State are never set, they are |
|
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
1912 * equal to MODE_NORMAL State with a condition. This function returns the real |
|
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
1913 * State. |
| 7 | 1914 */ |
| 1915 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1916 get_real_state(void) |
| 7 | 1917 { |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
1918 if (State & MODE_NORMAL) |
| 7 | 1919 { |
| 1920 if (VIsual_active) | |
| 789 | 1921 { |
| 1922 if (VIsual_select) | |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
1923 return MODE_SELECT; |
|
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
1924 return MODE_VISUAL; |
| 789 | 1925 } |
| 5735 | 1926 else if (finish_op) |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
1927 return MODE_OP_PENDING; |
| 7 | 1928 } |
| 1929 return State; | |
| 1930 } | |
| 1931 | |
| 39 | 1932 /* |
| 1933 * Return TRUE if "p" points to just after a path separator. | |
| 2939 | 1934 * Takes care of multi-byte characters. |
| 39 | 1935 * "b" must point to the start of the file name |
| 1936 */ | |
| 1937 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1938 after_pathsep(char_u *b, char_u *p) |
| 39 | 1939 { |
| 2939 | 1940 return p > b && vim_ispathsep(p[-1]) |
| 39 | 1941 && (!has_mbyte || (*mb_head_off)(b, p - 1) == 0); |
| 1942 } | |
| 1943 | |
| 1944 /* | |
| 1945 * Return TRUE if file names "f1" and "f2" are in the same directory. | |
| 1946 * "f1" may be a short name, "f2" must be a full path. | |
| 1947 */ | |
| 1948 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1949 same_directory(char_u *f1, char_u *f2) |
| 39 | 1950 { |
| 1951 char_u ffname[MAXPATHL]; | |
| 1952 char_u *t1; | |
| 1953 char_u *t2; | |
| 1954 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
1955 // safety check |
| 39 | 1956 if (f1 == NULL || f2 == NULL) |
| 1957 return FALSE; | |
| 1958 | |
| 1959 (void)vim_FullName(f1, ffname, MAXPATHL, FALSE); | |
| 1960 t1 = gettail_sep(ffname); | |
| 1961 t2 = gettail_sep(f2); | |
| 1962 return (t1 - ffname == t2 - f2 | |
| 1963 && pathcmp((char *)ffname, (char *)f2, (int)(t1 - ffname)) == 0); | |
| 1964 } | |
| 1965 | |
|
14220
96e4c6b26998
patch 8.1.0127: build failure when disabling the session feature
Christian Brabandt <cb@256bit.org>
parents:
13750
diff
changeset
|
1966 #if defined(FEAT_SESSION) || defined(FEAT_AUTOCHDIR) \ |
|
21745
35921b7fc07a
patch 8.2.1422: the Mac GUI implementation is outdated
Bram Moolenaar <Bram@vim.org>
parents:
21558
diff
changeset
|
1967 || defined(MSWIN) || defined(FEAT_GUI_GTK) \ |
|
15510
41fbbcea0f1b
patch 8.1.0763: nobody is using the Sun Workshop support
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1968 || defined(FEAT_NETBEANS_INTG) \ |
| 7 | 1969 || defined(PROTO) |
| 1970 /* | |
| 1971 * Change to a file's directory. | |
| 1972 * Caller must call shorten_fnames()! | |
| 1973 * Return OK or FAIL. | |
| 1974 */ | |
| 1975 int | |
|
15184
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1976 vim_chdirfile(char_u *fname, char *trigger_autocmd) |
|
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1977 { |
|
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1978 char_u old_dir[MAXPATHL]; |
|
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1979 char_u new_dir[MAXPATHL]; |
| 39 | 1980 |
|
15184
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1981 if (mch_dirname(old_dir, MAXPATHL) != OK) |
|
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1982 *old_dir = NUL; |
|
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1983 |
|
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1984 vim_strncpy(new_dir, fname, MAXPATHL - 1); |
|
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1985 *gettail_sep(new_dir) = NUL; |
|
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1986 |
|
15188
2d8c31ae1e24
patch 8.1.0604: autocommand test fails on MS-Windows
Bram Moolenaar <Bram@vim.org>
parents:
15184
diff
changeset
|
1987 if (pathcmp((char *)old_dir, (char *)new_dir, -1) == 0) |
|
15184
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1988 // nothing to do |
|
27511
9986f96fb1bd
patch 8.2.4283: using a variable for the return value is not needed
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
1989 return OK; |
|
9986f96fb1bd
patch 8.2.4283: using a variable for the return value is not needed
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
1990 |
|
27617
269f89efb06a
patch 8.2.4335: no autocommand event triggered before changing directory
Bram Moolenaar <Bram@vim.org>
parents:
27511
diff
changeset
|
1991 if (trigger_autocmd != NULL) |
|
269f89efb06a
patch 8.2.4335: no autocommand event triggered before changing directory
Bram Moolenaar <Bram@vim.org>
parents:
27511
diff
changeset
|
1992 trigger_DirChangedPre((char_u *)trigger_autocmd, new_dir); |
|
269f89efb06a
patch 8.2.4335: no autocommand event triggered before changing directory
Bram Moolenaar <Bram@vim.org>
parents:
27511
diff
changeset
|
1993 |
|
27511
9986f96fb1bd
patch 8.2.4283: using a variable for the return value is not needed
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
1994 if (mch_chdir((char *)new_dir) != 0) |
|
9986f96fb1bd
patch 8.2.4283: using a variable for the return value is not needed
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
1995 return FAIL; |
|
15184
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1996 |
|
27511
9986f96fb1bd
patch 8.2.4283: using a variable for the return value is not needed
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
1997 if (trigger_autocmd != NULL) |
|
9986f96fb1bd
patch 8.2.4283: using a variable for the return value is not needed
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
1998 apply_autocmds(EVENT_DIRCHANGED, (char_u *)trigger_autocmd, |
|
15184
90ab2d3ce11d
patch 8.1.0602: DirChanged is also triggered when directory didn't change
Bram Moolenaar <Bram@vim.org>
parents:
15160
diff
changeset
|
1999 new_dir, FALSE, curbuf); |
|
27511
9986f96fb1bd
patch 8.2.4283: using a variable for the return value is not needed
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
2000 return OK; |
| 7 | 2001 } |
| 2002 #endif | |
| 2003 | |
| 2004 #if defined(STAT_IGNORES_SLASH) || defined(PROTO) | |
| 2005 /* | |
| 2006 * Check if "name" ends in a slash and is not a directory. | |
| 2007 * Used for systems where stat() ignores a trailing slash on a file name. | |
| 2008 * The Vim code assumes a trailing slash is only ignored for a directory. | |
| 2009 */ | |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2010 static int |
|
11146
6ce90f33373f
patch 8.0.0460: can't build on HPUX
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
2011 illegal_slash(const char *name) |
| 7 | 2012 { |
| 2013 if (name[0] == NUL) | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2014 return FALSE; // no file name is not illegal |
| 7 | 2015 if (name[strlen(name) - 1] != '/') |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2016 return FALSE; // no trailing slash |
| 7 | 2017 if (mch_isdir((char_u *)name)) |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2018 return FALSE; // trailing slash for a directory |
| 7 | 2019 return TRUE; |
| 2020 } | |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2021 |
|
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2022 /* |
|
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2023 * Special implementation of mch_stat() for Solaris. |
|
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2024 */ |
|
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2025 int |
|
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2026 vim_stat(const char *name, stat_T *stp) |
|
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2027 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2028 // On Solaris stat() accepts "file/" as if it was "file". Return -1 if |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2029 // the name ends in "/" and it's not a directory. |
|
11146
6ce90f33373f
patch 8.0.0460: can't build on HPUX
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
2030 return illegal_slash(name) ? -1 : stat(name, stp); |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11016
diff
changeset
|
2031 } |
| 7 | 2032 #endif |
| 2033 | |
| 2034 #if defined(CURSOR_SHAPE) || defined(PROTO) | |
| 2035 | |
| 2036 /* | |
| 2037 * Handling of cursor and mouse pointer shapes in various modes. | |
| 2038 */ | |
| 2039 | |
| 2040 cursorentry_T shape_table[SHAPE_IDX_COUNT] = | |
| 2041 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2042 // The values will be filled in from the 'guicursor' and 'mouseshape' |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2043 // defaults when Vim starts. |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2044 // Adjust the SHAPE_IDX_ defines when making changes! |
| 7 | 2045 {0, 0, 0, 700L, 400L, 250L, 0, 0, "n", SHAPE_CURSOR+SHAPE_MOUSE}, |
| 2046 {0, 0, 0, 700L, 400L, 250L, 0, 0, "v", SHAPE_CURSOR+SHAPE_MOUSE}, | |
| 2047 {0, 0, 0, 700L, 400L, 250L, 0, 0, "i", SHAPE_CURSOR+SHAPE_MOUSE}, | |
| 2048 {0, 0, 0, 700L, 400L, 250L, 0, 0, "r", SHAPE_CURSOR+SHAPE_MOUSE}, | |
| 2049 {0, 0, 0, 700L, 400L, 250L, 0, 0, "c", SHAPE_CURSOR+SHAPE_MOUSE}, | |
| 2050 {0, 0, 0, 700L, 400L, 250L, 0, 0, "ci", SHAPE_CURSOR+SHAPE_MOUSE}, | |
| 2051 {0, 0, 0, 700L, 400L, 250L, 0, 0, "cr", SHAPE_CURSOR+SHAPE_MOUSE}, | |
| 2052 {0, 0, 0, 700L, 400L, 250L, 0, 0, "o", SHAPE_CURSOR+SHAPE_MOUSE}, | |
| 2053 {0, 0, 0, 700L, 400L, 250L, 0, 0, "ve", SHAPE_CURSOR+SHAPE_MOUSE}, | |
| 2054 {0, 0, 0, 0L, 0L, 0L, 0, 0, "e", SHAPE_MOUSE}, | |
| 2055 {0, 0, 0, 0L, 0L, 0L, 0, 0, "s", SHAPE_MOUSE}, | |
| 2056 {0, 0, 0, 0L, 0L, 0L, 0, 0, "sd", SHAPE_MOUSE}, | |
| 2057 {0, 0, 0, 0L, 0L, 0L, 0, 0, "vs", SHAPE_MOUSE}, | |
| 2058 {0, 0, 0, 0L, 0L, 0L, 0, 0, "vd", SHAPE_MOUSE}, | |
| 2059 {0, 0, 0, 0L, 0L, 0L, 0, 0, "m", SHAPE_MOUSE}, | |
| 2060 {0, 0, 0, 0L, 0L, 0L, 0, 0, "ml", SHAPE_MOUSE}, | |
| 2061 {0, 0, 0, 100L, 100L, 100L, 0, 0, "sm", SHAPE_CURSOR}, | |
| 2062 }; | |
| 2063 | |
|
31093
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2064 # ifdef FEAT_MOUSESHAPE |
| 7 | 2065 /* |
| 2066 * Table with names for mouse shapes. Keep in sync with all the tables for | |
| 2067 * mch_set_mouse_shape()!. | |
| 2068 */ | |
|
31093
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2069 static char *mshape_names[] = |
| 7 | 2070 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2071 "arrow", // default, must be the first one |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2072 "blank", // hidden |
| 7 | 2073 "beam", |
| 2074 "updown", | |
| 2075 "udsizing", | |
| 2076 "leftright", | |
| 2077 "lrsizing", | |
| 2078 "busy", | |
| 2079 "no", | |
| 2080 "crosshair", | |
| 2081 "hand1", | |
| 2082 "hand2", | |
| 2083 "pencil", | |
| 2084 "question", | |
| 2085 "rightup-arrow", | |
| 2086 "up-arrow", | |
| 2087 NULL | |
| 2088 }; | |
|
31093
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2089 |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2090 # define MSHAPE_NAMES_COUNT (ARRAY_LENGTH(mshape_names) - 1) |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2091 # endif |
| 7 | 2092 |
| 2093 /* | |
| 2094 * Parse the 'guicursor' option ("what" is SHAPE_CURSOR) or 'mouseshape' | |
| 2095 * ("what" is SHAPE_MOUSE). | |
| 2096 * Returns error message for an illegal option, NULL otherwise. | |
| 2097 */ | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15428
diff
changeset
|
2098 char * |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2099 parse_shape_opt(int what) |
| 7 | 2100 { |
| 2101 char_u *modep; | |
| 2102 char_u *colonp; | |
| 2103 char_u *commap; | |
| 2104 char_u *slashp; | |
| 2105 char_u *p, *endp; | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2106 int idx = 0; // init for GCC |
| 7 | 2107 int all_idx; |
| 2108 int len; | |
| 2109 int i; | |
| 2110 long n; | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2111 int found_ve = FALSE; // found "ve" flag |
| 7 | 2112 int round; |
| 2113 | |
| 2114 /* | |
| 2115 * First round: check for errors; second round: do it for real. | |
| 2116 */ | |
| 2117 for (round = 1; round <= 2; ++round) | |
| 2118 { | |
| 2119 /* | |
| 2120 * Repeat for all comma separated parts. | |
| 2121 */ | |
| 2122 #ifdef FEAT_MOUSESHAPE | |
| 2123 if (what == SHAPE_MOUSE) | |
| 2124 modep = p_mouseshape; | |
| 2125 else | |
| 2126 #endif | |
| 2127 modep = p_guicursor; | |
| 2128 while (*modep != NUL) | |
| 2129 { | |
| 2130 colonp = vim_strchr(modep, ':'); | |
|
10936
a516b6c279d9
patch 8.0.0357: crash when setting 'guicursor' to weird value
Christian Brabandt <cb@256bit.org>
parents:
10716
diff
changeset
|
2131 commap = vim_strchr(modep, ','); |
|
a516b6c279d9
patch 8.0.0357: crash when setting 'guicursor' to weird value
Christian Brabandt <cb@256bit.org>
parents:
10716
diff
changeset
|
2132 |
|
a516b6c279d9
patch 8.0.0357: crash when setting 'guicursor' to weird value
Christian Brabandt <cb@256bit.org>
parents:
10716
diff
changeset
|
2133 if (colonp == NULL || (commap != NULL && commap < colonp)) |
|
26917
d91aea2a612c
patch 8.2.3987: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
2134 return e_missing_colon_2; |
| 7 | 2135 if (colonp == modep) |
|
26917
d91aea2a612c
patch 8.2.3987: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
2136 return e_illegal_mode; |
| 7 | 2137 |
| 2138 /* | |
| 2139 * Repeat for all mode's before the colon. | |
| 2140 * For the 'a' mode, we loop to handle all the modes. | |
| 2141 */ | |
| 2142 all_idx = -1; | |
| 2143 while (modep < colonp || all_idx >= 0) | |
| 2144 { | |
| 2145 if (all_idx < 0) | |
| 2146 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2147 // Find the mode. |
| 7 | 2148 if (modep[1] == '-' || modep[1] == ':') |
| 2149 len = 1; | |
| 2150 else | |
| 2151 len = 2; | |
| 2152 if (len == 1 && TOLOWER_ASC(modep[0]) == 'a') | |
| 2153 all_idx = SHAPE_IDX_COUNT - 1; | |
| 2154 else | |
| 2155 { | |
| 2156 for (idx = 0; idx < SHAPE_IDX_COUNT; ++idx) | |
| 2157 if (STRNICMP(modep, shape_table[idx].name, len) | |
| 2158 == 0) | |
| 2159 break; | |
| 2160 if (idx == SHAPE_IDX_COUNT | |
| 2161 || (shape_table[idx].used_for & what) == 0) | |
|
26917
d91aea2a612c
patch 8.2.3987: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
2162 return e_illegal_mode; |
| 7 | 2163 if (len == 2 && modep[0] == 'v' && modep[1] == 'e') |
| 2164 found_ve = TRUE; | |
| 2165 } | |
| 2166 modep += len + 1; | |
| 2167 } | |
| 2168 | |
| 2169 if (all_idx >= 0) | |
| 2170 idx = all_idx--; | |
| 2171 else if (round == 2) | |
| 2172 { | |
| 2173 #ifdef FEAT_MOUSESHAPE | |
| 2174 if (what == SHAPE_MOUSE) | |
| 2175 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2176 // Set the default, for the missing parts |
| 7 | 2177 shape_table[idx].mshape = 0; |
| 2178 } | |
| 2179 else | |
| 2180 #endif | |
| 2181 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2182 // Set the defaults, for the missing parts |
| 7 | 2183 shape_table[idx].shape = SHAPE_BLOCK; |
| 2184 shape_table[idx].blinkwait = 700L; | |
| 2185 shape_table[idx].blinkon = 400L; | |
| 2186 shape_table[idx].blinkoff = 250L; | |
| 2187 } | |
| 2188 } | |
| 2189 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2190 // Parse the part after the colon |
| 7 | 2191 for (p = colonp + 1; *p && *p != ','; ) |
| 2192 { | |
| 2193 #ifdef FEAT_MOUSESHAPE | |
| 2194 if (what == SHAPE_MOUSE) | |
| 2195 { | |
| 2196 for (i = 0; ; ++i) | |
| 2197 { | |
| 2198 if (mshape_names[i] == NULL) | |
| 2199 { | |
| 2200 if (!VIM_ISDIGIT(*p)) | |
|
26917
d91aea2a612c
patch 8.2.3987: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
2201 return e_illegal_mouseshape; |
| 7 | 2202 if (round == 2) |
| 2203 shape_table[idx].mshape = | |
| 2204 getdigits(&p) + MSHAPE_NUMBERED; | |
| 2205 else | |
| 2206 (void)getdigits(&p); | |
| 2207 break; | |
| 2208 } | |
| 2209 len = (int)STRLEN(mshape_names[i]); | |
| 2210 if (STRNICMP(p, mshape_names[i], len) == 0) | |
| 2211 { | |
| 2212 if (round == 2) | |
| 2213 shape_table[idx].mshape = i; | |
| 2214 p += len; | |
| 2215 break; | |
| 2216 } | |
| 2217 } | |
| 2218 } | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2219 else // if (what == SHAPE_MOUSE) |
| 7 | 2220 #endif |
| 2221 { | |
| 2222 /* | |
| 2223 * First handle the ones with a number argument. | |
| 2224 */ | |
| 2225 i = *p; | |
| 2226 len = 0; | |
| 2227 if (STRNICMP(p, "ver", 3) == 0) | |
| 2228 len = 3; | |
| 2229 else if (STRNICMP(p, "hor", 3) == 0) | |
| 2230 len = 3; | |
| 2231 else if (STRNICMP(p, "blinkwait", 9) == 0) | |
| 2232 len = 9; | |
| 2233 else if (STRNICMP(p, "blinkon", 7) == 0) | |
| 2234 len = 7; | |
| 2235 else if (STRNICMP(p, "blinkoff", 8) == 0) | |
| 2236 len = 8; | |
| 2237 if (len != 0) | |
| 2238 { | |
| 2239 p += len; | |
| 2240 if (!VIM_ISDIGIT(*p)) | |
|
26917
d91aea2a612c
patch 8.2.3987: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
2241 return e_digit_expected; |
| 7 | 2242 n = getdigits(&p); |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2243 if (len == 3) // "ver" or "hor" |
| 7 | 2244 { |
| 2245 if (n == 0) | |
|
26917
d91aea2a612c
patch 8.2.3987: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
2246 return e_illegal_percentage; |
| 7 | 2247 if (round == 2) |
| 2248 { | |
| 2249 if (TOLOWER_ASC(i) == 'v') | |
| 2250 shape_table[idx].shape = SHAPE_VER; | |
| 2251 else | |
| 2252 shape_table[idx].shape = SHAPE_HOR; | |
| 2253 shape_table[idx].percentage = n; | |
| 2254 } | |
| 2255 } | |
| 2256 else if (round == 2) | |
| 2257 { | |
| 2258 if (len == 9) | |
| 2259 shape_table[idx].blinkwait = n; | |
| 2260 else if (len == 7) | |
| 2261 shape_table[idx].blinkon = n; | |
| 2262 else | |
| 2263 shape_table[idx].blinkoff = n; | |
| 2264 } | |
| 2265 } | |
| 2266 else if (STRNICMP(p, "block", 5) == 0) | |
| 2267 { | |
| 2268 if (round == 2) | |
| 2269 shape_table[idx].shape = SHAPE_BLOCK; | |
| 2270 p += 5; | |
| 2271 } | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2272 else // must be a highlight group name then |
| 7 | 2273 { |
| 2274 endp = vim_strchr(p, '-'); | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2275 if (commap == NULL) // last part |
| 7 | 2276 { |
| 2277 if (endp == NULL) | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2278 endp = p + STRLEN(p); // find end of part |
| 7 | 2279 } |
| 2280 else if (endp > commap || endp == NULL) | |
| 2281 endp = commap; | |
| 2282 slashp = vim_strchr(p, '/'); | |
| 2283 if (slashp != NULL && slashp < endp) | |
| 2284 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2285 // "group/langmap_group" |
| 7 | 2286 i = syn_check_group(p, (int)(slashp - p)); |
| 2287 p = slashp + 1; | |
| 2288 } | |
| 2289 if (round == 2) | |
| 2290 { | |
| 2291 shape_table[idx].id = syn_check_group(p, | |
| 2292 (int)(endp - p)); | |
| 2293 shape_table[idx].id_lm = shape_table[idx].id; | |
| 2294 if (slashp != NULL && slashp < endp) | |
| 2295 shape_table[idx].id = i; | |
| 2296 } | |
| 2297 p = endp; | |
| 2298 } | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2299 } // if (what != SHAPE_MOUSE) |
| 7 | 2300 |
| 2301 if (*p == '-') | |
| 2302 ++p; | |
| 2303 } | |
| 2304 } | |
| 2305 modep = p; | |
| 2306 if (*modep == ',') | |
| 2307 ++modep; | |
| 2308 } | |
| 2309 } | |
| 2310 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2311 // If the 's' flag is not given, use the 'v' cursor for 's' |
| 7 | 2312 if (!found_ve) |
| 2313 { | |
| 2314 #ifdef FEAT_MOUSESHAPE | |
| 2315 if (what == SHAPE_MOUSE) | |
| 2316 { | |
| 2317 shape_table[SHAPE_IDX_VE].mshape = shape_table[SHAPE_IDX_V].mshape; | |
| 2318 } | |
| 2319 else | |
| 2320 #endif | |
| 2321 { | |
| 2322 shape_table[SHAPE_IDX_VE].shape = shape_table[SHAPE_IDX_V].shape; | |
| 2323 shape_table[SHAPE_IDX_VE].percentage = | |
| 2324 shape_table[SHAPE_IDX_V].percentage; | |
| 2325 shape_table[SHAPE_IDX_VE].blinkwait = | |
| 2326 shape_table[SHAPE_IDX_V].blinkwait; | |
| 2327 shape_table[SHAPE_IDX_VE].blinkon = | |
| 2328 shape_table[SHAPE_IDX_V].blinkon; | |
| 2329 shape_table[SHAPE_IDX_VE].blinkoff = | |
| 2330 shape_table[SHAPE_IDX_V].blinkoff; | |
| 2331 shape_table[SHAPE_IDX_VE].id = shape_table[SHAPE_IDX_V].id; | |
| 2332 shape_table[SHAPE_IDX_VE].id_lm = shape_table[SHAPE_IDX_V].id_lm; | |
| 2333 } | |
| 2334 } | |
| 2335 | |
| 2336 return NULL; | |
| 2337 } | |
| 2338 | |
| 500 | 2339 # if defined(MCH_CURSOR_SHAPE) || defined(FEAT_GUI) \ |
| 2340 || defined(FEAT_MOUSESHAPE) || defined(PROTO) | |
| 7 | 2341 /* |
| 2342 * Return the index into shape_table[] for the current mode. | |
| 2343 * When "mouse" is TRUE, consider indexes valid for the mouse pointer. | |
| 2344 */ | |
| 2345 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2346 get_shape_idx(int mouse) |
| 7 | 2347 { |
| 2348 #ifdef FEAT_MOUSESHAPE | |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
2349 if (mouse && (State == MODE_HITRETURN || State == MODE_ASKMORE)) |
| 7 | 2350 { |
| 2351 # ifdef FEAT_GUI | |
| 87 | 2352 int x, y; |
| 2353 gui_mch_getmouse(&x, &y); | |
| 2354 if (Y_2_ROW(y) == Rows - 1) | |
| 7 | 2355 return SHAPE_IDX_MOREL; |
| 2356 # endif | |
| 2357 return SHAPE_IDX_MORE; | |
| 2358 } | |
| 2359 if (mouse && drag_status_line) | |
| 2360 return SHAPE_IDX_SDRAG; | |
| 2361 if (mouse && drag_sep_line) | |
| 2362 return SHAPE_IDX_VDRAG; | |
| 2363 #endif | |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
2364 if (!mouse && State == MODE_SHOWMATCH) |
| 7 | 2365 return SHAPE_IDX_SM; |
| 2366 if (State & VREPLACE_FLAG) | |
| 2367 return SHAPE_IDX_R; | |
| 2368 if (State & REPLACE_FLAG) | |
| 2369 return SHAPE_IDX_R; | |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
2370 if (State & MODE_INSERT) |
| 7 | 2371 return SHAPE_IDX_I; |
|
28773
d770568e6c98
patch 8.2.4911: the mode #defines are not clearly named
Bram Moolenaar <Bram@vim.org>
parents:
28668
diff
changeset
|
2372 if (State & MODE_CMDLINE) |
| 7 | 2373 { |
| 2374 if (cmdline_at_end()) | |
| 2375 return SHAPE_IDX_C; | |
| 2376 if (cmdline_overstrike()) | |
| 2377 return SHAPE_IDX_CR; | |
| 2378 return SHAPE_IDX_CI; | |
| 2379 } | |
| 2380 if (finish_op) | |
| 2381 return SHAPE_IDX_O; | |
| 2382 if (VIsual_active) | |
| 2383 { | |
| 2384 if (*p_sel == 'e') | |
| 2385 return SHAPE_IDX_VE; | |
| 2386 else | |
| 2387 return SHAPE_IDX_V; | |
| 2388 } | |
| 2389 return SHAPE_IDX_N; | |
| 2390 } | |
| 500 | 2391 #endif |
| 7 | 2392 |
| 2393 # if defined(FEAT_MOUSESHAPE) || defined(PROTO) | |
|
31093
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2394 static int current_mouse_shape = 0; |
| 7 | 2395 |
| 2396 /* | |
| 2397 * Set the mouse shape: | |
| 2398 * If "shape" is -1, use shape depending on the current mode, | |
| 2399 * depending on the current state. | |
| 2400 * If "shape" is -2, only update the shape when it's CLINE or STATUS (used | |
| 2401 * when the mouse moves off the status or command line). | |
| 2402 */ | |
| 2403 void | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2404 update_mouseshape(int shape_idx) |
| 7 | 2405 { |
| 2406 int new_mouse_shape; | |
| 2407 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2408 // Only works in GUI mode. |
| 227 | 2409 if (!gui.in_use || gui.starting) |
| 7 | 2410 return; |
| 2411 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2412 // Postpone the updating when more is to come. Speeds up executing of |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2413 // mappings. |
| 7 | 2414 if (shape_idx == -1 && char_avail()) |
| 2415 { | |
| 2416 postponed_mouseshape = TRUE; | |
| 2417 return; | |
| 2418 } | |
| 2419 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2420 // When ignoring the mouse don't change shape on the statusline. |
| 864 | 2421 if (*p_mouse == NUL |
| 2422 && (shape_idx == SHAPE_IDX_CLINE | |
| 2423 || shape_idx == SHAPE_IDX_STATUS | |
| 2424 || shape_idx == SHAPE_IDX_VSEP)) | |
| 2425 shape_idx = -2; | |
| 2426 | |
| 7 | 2427 if (shape_idx == -2 |
|
31093
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2428 && current_mouse_shape != shape_table[SHAPE_IDX_CLINE].mshape |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2429 && current_mouse_shape != shape_table[SHAPE_IDX_STATUS].mshape |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2430 && current_mouse_shape != shape_table[SHAPE_IDX_VSEP].mshape) |
| 7 | 2431 return; |
| 2432 if (shape_idx < 0) | |
| 2433 new_mouse_shape = shape_table[get_shape_idx(TRUE)].mshape; | |
| 2434 else | |
| 2435 new_mouse_shape = shape_table[shape_idx].mshape; | |
|
31093
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2436 if (new_mouse_shape != current_mouse_shape) |
| 7 | 2437 { |
| 2438 mch_set_mouse_shape(new_mouse_shape); | |
|
31093
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2439 current_mouse_shape = new_mouse_shape; |
| 7 | 2440 } |
| 2441 postponed_mouseshape = FALSE; | |
| 2442 } | |
| 2443 # endif | |
| 2444 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2445 #endif // CURSOR_SHAPE |
| 7 | 2446 |
|
31093
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2447 #if defined(FEAT_EVAL) || defined(PROTO) |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2448 /* |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2449 * Mainly for tests: get the name of the current mouse shape. |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2450 */ |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2451 void |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2452 f_getmouseshape(typval_T *argvars UNUSED, typval_T *rettv) |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2453 { |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2454 rettv->v_type = VAR_STRING; |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2455 rettv->vval.v_string = NULL; |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2456 # if defined(FEAT_MOUSESHAPE) || defined(PROTO) |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2457 if (current_mouse_shape >= 0 |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2458 && current_mouse_shape < (int)MSHAPE_NAMES_COUNT) |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2459 rettv->vval.v_string = vim_strsave( |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2460 (char_u *)mshape_names[current_mouse_shape]); |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2461 # endif |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2462 } |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2463 #endif |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2464 |
|
004aee2845d2
patch 9.0.0881: cannot get the currently showing mouse shape
Bram Moolenaar <Bram@vim.org>
parents:
30833
diff
changeset
|
2465 |
| 7 | 2466 |
| 2467 /* | |
|
29853
31c598083364
patch 9.0.0265: no good reason why the "gf" command isn't in the tiny version
Bram Moolenaar <Bram@vim.org>
parents:
29765
diff
changeset
|
2468 * Change directory to "new_dir". Search 'cdpath' for relative directory |
|
30205
ed6f3d2593df
patch 9.0.0438: cannot put virtual text above a line
Bram Moolenaar <Bram@vim.org>
parents:
29853
diff
changeset
|
2469 * names. |
| 7 | 2470 */ |
| 2471 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2472 vim_chdir(char_u *new_dir) |
| 7 | 2473 { |
| 2474 char_u *dir_name; | |
| 2475 int r; | |
|
32138
2c09e40ce3da
patch 9.0.1400: find_file_in_path() is not reentrant
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
2476 char_u *file_to_find = NULL; |
|
2c09e40ce3da
patch 9.0.1400: find_file_in_path() is not reentrant
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
2477 char *search_ctx = NULL; |
| 7 | 2478 |
| 2479 dir_name = find_directory_in_path(new_dir, (int)STRLEN(new_dir), | |
|
32138
2c09e40ce3da
patch 9.0.1400: find_file_in_path() is not reentrant
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
2480 FNAME_MESS, curbuf->b_ffname, &file_to_find, &search_ctx); |
|
2c09e40ce3da
patch 9.0.1400: find_file_in_path() is not reentrant
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
2481 vim_free(file_to_find); |
|
2c09e40ce3da
patch 9.0.1400: find_file_in_path() is not reentrant
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
2482 vim_findfile_cleanup(search_ctx); |
| 7 | 2483 if (dir_name == NULL) |
| 2484 return -1; | |
| 2485 r = mch_chdir((char *)dir_name); | |
| 2486 vim_free(dir_name); | |
| 2487 return r; | |
| 2488 } | |
| 2489 | |
| 2490 /* | |
| 418 | 2491 * Get user name from machine-specific function. |
| 7 | 2492 * Returns the user name in "buf[len]". |
| 418 | 2493 * Some systems are quite slow in obtaining the user name (Windows NT), thus |
| 2494 * cache the result. | |
| 7 | 2495 * Returns OK or FAIL. |
| 2496 */ | |
| 2497 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2498 get_user_name(char_u *buf, int len) |
| 7 | 2499 { |
| 359 | 2500 if (username == NULL) |
| 7 | 2501 { |
| 2502 if (mch_get_user_name(buf, len) == FAIL) | |
| 2503 return FAIL; | |
| 359 | 2504 username = vim_strsave(buf); |
| 7 | 2505 } |
| 2506 else | |
| 418 | 2507 vim_strncpy(buf, username, len - 1); |
| 7 | 2508 return OK; |
| 2509 } | |
| 2510 | |
|
28893
aa44d5842d6c
patch 8.2.4969: changing text in Visual mode may cause invalid memory access
Bram Moolenaar <Bram@vim.org>
parents:
28809
diff
changeset
|
2511 #if defined(EXITFREE) || defined(PROTO) |
|
25529
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2512 /* |
|
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2513 * Free the memory allocated by get_user_name() |
|
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2514 */ |
|
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2515 void |
|
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2516 free_username(void) |
|
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2517 { |
|
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2518 vim_free(username); |
|
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2519 } |
|
27018
268f6a3511df
patch 8.2.4038: various code not used when features are disabled
Bram Moolenaar <Bram@vim.org>
parents:
26917
diff
changeset
|
2520 #endif |
|
25529
bb1097899693
patch 8.2.3301: memory allocation functions don't have their own place
Bram Moolenaar <Bram@vim.org>
parents:
25435
diff
changeset
|
2521 |
| 7 | 2522 #ifndef HAVE_QSORT |
| 2523 /* | |
| 2524 * Our own qsort(), for systems that don't have it. | |
| 2525 * It's simple and slow. From the K&R C book. | |
| 2526 */ | |
| 2527 void | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2528 qsort( |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2529 void *base, |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2530 size_t elm_count, |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2531 size_t elm_size, |
|
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2532 int (*cmp)(const void *, const void *)) |
| 7 | 2533 { |
| 2534 char_u *buf; | |
| 2535 char_u *p1; | |
| 2536 char_u *p2; | |
| 2537 int i, j; | |
| 2538 int gap; | |
| 2539 | |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16706
diff
changeset
|
2540 buf = alloc(elm_size); |
| 7 | 2541 if (buf == NULL) |
| 2542 return; | |
| 2543 | |
| 2544 for (gap = elm_count / 2; gap > 0; gap /= 2) | |
| 2545 for (i = gap; i < elm_count; ++i) | |
| 2546 for (j = i - gap; j >= 0; j -= gap) | |
| 2547 { | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2548 // Compare the elements. |
| 7 | 2549 p1 = (char_u *)base + j * elm_size; |
| 2550 p2 = (char_u *)base + (j + gap) * elm_size; | |
| 2551 if ((*cmp)((void *)p1, (void *)p2) <= 0) | |
| 2552 break; | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2553 // Exchange the elements. |
| 7 | 2554 mch_memmove(buf, p1, elm_size); |
| 2555 mch_memmove(p1, p2, elm_size); | |
| 2556 mch_memmove(p2, buf, elm_size); | |
| 2557 } | |
| 2558 | |
| 2559 vim_free(buf); | |
| 2560 } | |
| 2561 #endif | |
| 2562 | |
| 2563 /* | |
| 2564 * The putenv() implementation below comes from the "screen" program. | |
| 2565 * Included with permission from Juergen Weigert. | |
| 2566 * See pty.c for the copyright notice. | |
| 2567 */ | |
| 2568 | |
| 2569 /* | |
| 2570 * putenv -- put value into environment | |
| 2571 * | |
| 2572 * Usage: i = putenv (string) | |
| 2573 * int i; | |
| 2574 * char *string; | |
| 2575 * | |
| 2576 * where string is of the form <name>=<value>. | |
| 2577 * Putenv returns 0 normally, -1 on error (not enough core for malloc). | |
| 2578 * | |
| 2579 * Putenv may need to add a new name into the environment, or to | |
| 2580 * associate a value longer than the current value with a particular | |
| 2581 * name. So, to make life simpler, putenv() copies your entire | |
| 2582 * environment into the heap (i.e. malloc()) from the stack | |
| 2583 * (i.e. where it resides when your process is initiated) the first | |
| 2584 * time you call it. | |
| 2585 * | |
| 2586 * (history removed, not very interesting. See the "screen" sources.) | |
| 2587 */ | |
| 2588 | |
| 2589 #if !defined(HAVE_SETENV) && !defined(HAVE_PUTENV) | |
| 2590 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2591 #define EXTRASIZE 5 // increment to add to env. size |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2592 |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2593 static int envsize = -1; // current size of environment |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2594 extern char **environ; // the global which is your env. |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2595 |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2596 static int findenv(char *name); // look for a name in the env. |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2597 static int newenv(void); // copy env. from stack to heap |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2598 static int moreenv(void); // incr. size of env. |
| 7 | 2599 |
| 2600 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2601 putenv(const char *string) |
| 7 | 2602 { |
| 2603 int i; | |
| 2604 char *p; | |
| 2605 | |
| 2606 if (envsize < 0) | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2607 { // first time putenv called |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2608 if (newenv() < 0) // copy env. to heap |
| 7 | 2609 return -1; |
| 2610 } | |
| 2611 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2612 i = findenv((char *)string); // look for name in environment |
| 7 | 2613 |
| 2614 if (i < 0) | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2615 { // name must be added |
| 7 | 2616 for (i = 0; environ[i]; i++); |
| 2617 if (i >= (envsize - 1)) | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2618 { // need new slot |
| 7 | 2619 if (moreenv() < 0) |
| 2620 return -1; | |
| 2621 } | |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2622 p = alloc(strlen(string) + 1); |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2623 if (p == NULL) // not enough core |
| 7 | 2624 return -1; |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2625 environ[i + 1] = 0; // new end of env. |
| 7 | 2626 } |
| 2627 else | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2628 { // name already in env. |
| 7 | 2629 p = vim_realloc(environ[i], strlen(string) + 1); |
| 2630 if (p == NULL) | |
| 2631 return -1; | |
| 2632 } | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2633 sprintf(p, "%s", string); // copy into env. |
| 7 | 2634 environ[i] = p; |
| 2635 | |
| 2636 return 0; | |
| 2637 } | |
| 2638 | |
| 2639 static int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2640 findenv(char *name) |
| 7 | 2641 { |
| 2642 char *namechar, *envchar; | |
| 2643 int i, found; | |
| 2644 | |
| 2645 found = 0; | |
| 2646 for (i = 0; environ[i] && !found; i++) | |
| 2647 { | |
| 2648 envchar = environ[i]; | |
| 2649 namechar = name; | |
| 2650 while (*namechar && *namechar != '=' && (*namechar == *envchar)) | |
| 2651 { | |
| 2652 namechar++; | |
| 2653 envchar++; | |
| 2654 } | |
| 2655 found = ((*namechar == '\0' || *namechar == '=') && *envchar == '='); | |
| 2656 } | |
| 2657 return found ? i - 1 : -1; | |
| 2658 } | |
| 2659 | |
| 2660 static int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2661 newenv(void) |
| 7 | 2662 { |
| 2663 char **env, *elem; | |
| 2664 int i, esize; | |
| 2665 | |
| 2666 for (i = 0; environ[i]; i++) | |
| 2667 ; | |
|
12716
351cf7c67bbe
patch 8.0.1236: Mac features are confusing
Christian Brabandt <cb@256bit.org>
parents:
12672
diff
changeset
|
2668 |
| 7 | 2669 esize = i + EXTRASIZE + 1; |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2670 env = ALLOC_MULT(char *, esize); |
| 7 | 2671 if (env == NULL) |
| 2672 return -1; | |
| 2673 | |
| 2674 for (i = 0; environ[i]; i++) | |
| 2675 { | |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2676 elem = alloc(strlen(environ[i]) + 1); |
| 7 | 2677 if (elem == NULL) |
| 2678 return -1; | |
| 2679 env[i] = elem; | |
| 2680 strcpy(elem, environ[i]); | |
| 2681 } | |
| 2682 | |
| 2683 env[i] = 0; | |
| 2684 environ = env; | |
| 2685 envsize = esize; | |
| 2686 return 0; | |
| 2687 } | |
| 2688 | |
| 2689 static int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2690 moreenv(void) |
| 7 | 2691 { |
| 2692 int esize; | |
| 2693 char **env; | |
| 2694 | |
| 2695 esize = envsize + EXTRASIZE; | |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2696 env = vim_realloc((char *)environ, esize * sizeof (*env)); |
| 7 | 2697 if (env == 0) |
| 2698 return -1; | |
| 2699 environ = env; | |
| 2700 envsize = esize; | |
| 2701 return 0; | |
| 2702 } | |
| 2703 | |
| 2704 # ifdef USE_VIMPTY_GETENV | |
|
11737
7791a15353dc
patch 8.0.0751: OpenPTY missing with some combination of features
Christian Brabandt <cb@256bit.org>
parents:
11557
diff
changeset
|
2705 /* |
|
7791a15353dc
patch 8.0.0751: OpenPTY missing with some combination of features
Christian Brabandt <cb@256bit.org>
parents:
11557
diff
changeset
|
2706 * Used for mch_getenv() for Mac. |
|
7791a15353dc
patch 8.0.0751: OpenPTY missing with some combination of features
Christian Brabandt <cb@256bit.org>
parents:
11557
diff
changeset
|
2707 */ |
| 7 | 2708 char_u * |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2709 vimpty_getenv(const char_u *string) |
| 7 | 2710 { |
| 2711 int i; | |
| 2712 char_u *p; | |
| 2713 | |
| 2714 if (envsize < 0) | |
| 2715 return NULL; | |
| 2716 | |
| 2717 i = findenv((char *)string); | |
| 2718 | |
| 2719 if (i < 0) | |
| 2720 return NULL; | |
| 2721 | |
| 2722 p = vim_strchr((char_u *)environ[i], '='); | |
| 2723 return (p + 1); | |
| 2724 } | |
| 2725 # endif | |
| 2726 | |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2727 #endif // !defined(HAVE_SETENV) && !defined(HAVE_PUTENV) |
| 313 | 2728 |
| 741 | 2729 #if defined(FEAT_EVAL) || defined(FEAT_SPELL) || defined(PROTO) |
| 313 | 2730 /* |
| 2731 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have | |
| 2732 * rights to write into. | |
| 2733 */ | |
| 2734 int | |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2735 filewritable(char_u *fname) |
| 313 | 2736 { |
| 2737 int retval = 0; | |
| 2738 #if defined(UNIX) || defined(VMS) | |
| 2739 int perm = 0; | |
| 2740 #endif | |
| 2741 | |
| 2742 #if defined(UNIX) || defined(VMS) | |
| 2743 perm = mch_getperm(fname); | |
| 2744 #endif | |
| 2745 if ( | |
|
15868
7fad90423bd2
patch 8.1.0941: macros for MS-Windows are inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15814
diff
changeset
|
2746 # ifdef MSWIN |
| 313 | 2747 mch_writable(fname) && |
| 2748 # else | |
| 2749 # if defined(UNIX) || defined(VMS) | |
| 2750 (perm & 0222) && | |
| 2751 # endif | |
| 2752 # endif | |
| 2753 mch_access((char *)fname, W_OK) == 0 | |
| 2754 ) | |
| 2755 { | |
| 2756 ++retval; | |
| 2757 if (mch_isdir(fname)) | |
| 2758 ++retval; | |
| 2759 } | |
| 2760 return retval; | |
| 2761 } | |
| 2762 #endif | |
| 332 | 2763 |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2764 #if defined(FEAT_SPELL) || defined(FEAT_PERSISTENT_UNDO) || defined(PROTO) |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2765 /* |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2766 * Read 2 bytes from "fd" and turn them into an int, MSB first. |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2767 * Returns -1 when encountering EOF. |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2768 */ |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2769 int |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2770 get2c(FILE *fd) |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2771 { |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2772 int c, n; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2773 |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2774 n = getc(fd); |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2775 if (n == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2776 c = getc(fd); |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2777 if (c == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2778 return (n << 8) + c; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2779 } |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2780 |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2781 /* |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2782 * Read 3 bytes from "fd" and turn them into an int, MSB first. |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2783 * Returns -1 when encountering EOF. |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2784 */ |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2785 int |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2786 get3c(FILE *fd) |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2787 { |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2788 int c, n; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2789 |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2790 n = getc(fd); |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2791 if (n == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2792 c = getc(fd); |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2793 if (c == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2794 n = (n << 8) + c; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2795 c = getc(fd); |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2796 if (c == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2797 return (n << 8) + c; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2798 } |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2799 |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2800 /* |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2801 * Read 4 bytes from "fd" and turn them into an int, MSB first. |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2802 * Returns -1 when encountering EOF. |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2803 */ |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2804 int |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2805 get4c(FILE *fd) |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2806 { |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2807 int c; |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2808 // Use unsigned rather than int otherwise result is undefined |
|
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2809 // when left-shift sets the MSB. |
| 5347 | 2810 unsigned n; |
| 2811 | |
|
13493
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2812 c = getc(fd); |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2813 if (c == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2814 n = (unsigned)c; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2815 c = getc(fd); |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2816 if (c == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2817 n = (n << 8) + (unsigned)c; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2818 c = getc(fd); |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2819 if (c == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2820 n = (n << 8) + (unsigned)c; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2821 c = getc(fd); |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2822 if (c == EOF) return -1; |
|
96de13023cad
patch 8.0.1620: reading spell file has no good EOF detection
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
2823 n = (n << 8) + (unsigned)c; |
| 5347 | 2824 return (int)n; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2825 } |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2826 |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2827 /* |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2828 * Read a string of length "cnt" from "fd" into allocated memory. |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2829 * Returns NULL when out of memory or unable to read that many bytes. |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2830 */ |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2831 char_u * |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2832 read_string(FILE *fd, int cnt) |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2833 { |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2834 char_u *str; |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2835 int i; |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2836 int c; |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2837 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2838 // allocate memory |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16706
diff
changeset
|
2839 str = alloc(cnt + 1); |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2840 if (str == NULL) |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2841 return NULL; |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2842 |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2843 // Read the string. Quit when running into the EOF. |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2844 for (i = 0; i < cnt; ++i) |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2845 { |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2846 c = getc(fd); |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2847 if (c == EOF) |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2848 { |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2849 vim_free(str); |
|
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2850 return NULL; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2851 } |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2852 str[i] = c; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2853 } |
|
31728
238ca27dbfd2
patch 9.0.1196: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31722
diff
changeset
|
2854 str[i] = NUL; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2855 return str; |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2856 } |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2857 |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2858 /* |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2859 * Write a number to file "fd", MSB first, in "len" bytes. |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2860 */ |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2861 int |
|
7829
2a8d6b2dd925
commit https://github.com/vim/vim/commit/9b57814db13c29ecb08260b36923c0e1c8a373a9
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
2862 put_bytes(FILE *fd, long_u nr, int len) |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2863 { |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2864 int i; |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2865 |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2866 for (i = len - 1; i >= 0; --i) |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2867 if (putc((int)(nr >> (i * 8)), fd) == EOF) |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2868 return FAIL; |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2869 return OK; |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2870 } |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2871 |
|
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
2872 #endif |
| 3257 | 2873 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2874 #ifndef PROTO // proto is defined in vim.h |
|
10449
222b1432814e
commit https://github.com/vim/vim/commit/5162822914372fc916a93f85848c0c82209e7cec
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
2875 # ifdef ELAPSED_TIMEVAL |
|
10406
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2876 /* |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2877 * Return time in msec since "start_tv". |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2878 */ |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2879 long |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2880 elapsed(struct timeval *start_tv) |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2881 { |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2882 struct timeval now_tv; |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2883 |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2884 gettimeofday(&now_tv, NULL); |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2885 return (now_tv.tv_sec - start_tv->tv_sec) * 1000L |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2886 + (now_tv.tv_usec - start_tv->tv_usec) / 1000L; |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2887 } |
|
10449
222b1432814e
commit https://github.com/vim/vim/commit/5162822914372fc916a93f85848c0c82209e7cec
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
2888 # endif |
|
222b1432814e
commit https://github.com/vim/vim/commit/5162822914372fc916a93f85848c0c82209e7cec
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
2889 |
|
222b1432814e
commit https://github.com/vim/vim/commit/5162822914372fc916a93f85848c0c82209e7cec
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
2890 # ifdef ELAPSED_TICKCOUNT |
|
10406
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2891 /* |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2892 * Return time in msec since "start_tick". |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2893 */ |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2894 long |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2895 elapsed(DWORD start_tick) |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2896 { |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2897 DWORD now = GetTickCount(); |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2898 |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2899 return (long)now - (long)start_tick; |
|
42911b233245
commit https://github.com/vim/vim/commit/833eb1d752426689051bf2001083359899536939
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2900 } |
|
10449
222b1432814e
commit https://github.com/vim/vim/commit/5162822914372fc916a93f85848c0c82209e7cec
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
2901 # endif |
|
222b1432814e
commit https://github.com/vim/vim/commit/5162822914372fc916a93f85848c0c82209e7cec
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
2902 #endif |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2903 |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2904 #if defined(FEAT_JOB_CHANNEL) \ |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2905 || (defined(UNIX) && (!defined(USE_SYSTEM) \ |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2906 || (defined(FEAT_GUI) && defined(FEAT_TERMINAL)))) \ |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2907 || defined(PROTO) |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2908 /* |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2909 * Parse "cmd" and put the white-separated parts in "argv". |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2910 * "argv" is an allocated array with "argc" entries and room for 4 more. |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2911 * Returns FAIL when out of memory. |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2912 */ |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2913 int |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2914 mch_parse_cmd(char_u *cmd, int use_shcf, char ***argv, int *argc) |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2915 { |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2916 int i; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2917 char_u *p, *d; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2918 int inquote; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2919 |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2920 /* |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2921 * Do this loop twice: |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2922 * 1: find number of arguments |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2923 * 2: separate them and build argv[] |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2924 */ |
|
19793
607e5d7968b9
patch 8.2.0453: trailing space in job_start() command causes empty argument
Bram Moolenaar <Bram@vim.org>
parents:
19396
diff
changeset
|
2925 for (i = 1; i <= 2; ++i) |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2926 { |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2927 p = skipwhite(cmd); |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2928 inquote = FALSE; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2929 *argc = 0; |
|
19793
607e5d7968b9
patch 8.2.0453: trailing space in job_start() command causes empty argument
Bram Moolenaar <Bram@vim.org>
parents:
19396
diff
changeset
|
2930 while (*p != NUL) |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2931 { |
|
19793
607e5d7968b9
patch 8.2.0453: trailing space in job_start() command causes empty argument
Bram Moolenaar <Bram@vim.org>
parents:
19396
diff
changeset
|
2932 if (i == 2) |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2933 (*argv)[*argc] = (char *)p; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2934 ++*argc; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2935 d = p; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2936 while (*p != NUL && (inquote || (*p != ' ' && *p != TAB))) |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2937 { |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2938 if (p[0] == '"') |
|
14905
c1e94bb0f004
patch 8.1.0464: MS-Windows: job_info() has cmd without backslashes
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2939 // quotes surrounding an argument and are dropped |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2940 inquote = !inquote; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2941 else |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2942 { |
|
14905
c1e94bb0f004
patch 8.1.0464: MS-Windows: job_info() has cmd without backslashes
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2943 if (rem_backslash(p)) |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2944 { |
|
14905
c1e94bb0f004
patch 8.1.0464: MS-Windows: job_info() has cmd without backslashes
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2945 // First pass: skip over "\ " and "\"". |
|
c1e94bb0f004
patch 8.1.0464: MS-Windows: job_info() has cmd without backslashes
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2946 // Second pass: Remove the backslash. |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2947 ++p; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2948 } |
|
19793
607e5d7968b9
patch 8.2.0453: trailing space in job_start() command causes empty argument
Bram Moolenaar <Bram@vim.org>
parents:
19396
diff
changeset
|
2949 if (i == 2) |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2950 *d++ = *p; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2951 } |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2952 ++p; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2953 } |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2954 if (*p == NUL) |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2955 { |
|
19793
607e5d7968b9
patch 8.2.0453: trailing space in job_start() command causes empty argument
Bram Moolenaar <Bram@vim.org>
parents:
19396
diff
changeset
|
2956 if (i == 2) |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2957 *d++ = NUL; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2958 break; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2959 } |
|
19793
607e5d7968b9
patch 8.2.0453: trailing space in job_start() command causes empty argument
Bram Moolenaar <Bram@vim.org>
parents:
19396
diff
changeset
|
2960 if (i == 2) |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2961 *d++ = NUL; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2962 p = skipwhite(p + 1); |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2963 } |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2964 if (*argv == NULL) |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2965 { |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2966 if (use_shcf) |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2967 { |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2968 // Account for possible multiple args in p_shcf. |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2969 p = p_shcf; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2970 for (;;) |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2971 { |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2972 p = skiptowhite(p); |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2973 if (*p == NUL) |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2974 break; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2975 ++*argc; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2976 p = skipwhite(p); |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2977 } |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2978 } |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2979 |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2980 *argv = ALLOC_MULT(char *, *argc + 4); |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2981 if (*argv == NULL) // out of memory |
|
13746
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2982 return FAIL; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2983 } |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2984 } |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2985 return OK; |
|
260256caac38
patch 8.0.1745: build failure on MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
13575
diff
changeset
|
2986 } |
|
13750
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2987 |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2988 /* |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2989 * Build "argv[argc]" from the string "cmd". |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2990 * "argv[argc]" is set to NULL; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2991 * Return FAIL when out of memory. |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2992 */ |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2993 int |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2994 build_argv_from_string(char_u *cmd, char ***argv, int *argc) |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2995 { |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2996 char_u *cmd_copy; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2997 int i; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
2998 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
2999 // Make a copy, parsing will modify "cmd". |
|
13750
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3000 cmd_copy = vim_strsave(cmd); |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3001 if (cmd_copy == NULL |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3002 || mch_parse_cmd(cmd_copy, FALSE, argv, argc) == FAIL) |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3003 { |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3004 vim_free(cmd_copy); |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3005 return FAIL; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3006 } |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3007 for (i = 0; i < *argc; i++) |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3008 (*argv)[i] = (char *)vim_strsave((char_u *)(*argv)[i]); |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3009 (*argv)[*argc] = NULL; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3010 vim_free(cmd_copy); |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3011 return OK; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3012 } |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3013 |
|
27181
f9f1e76957a6
patch 8.2.4119: build failure when disabling the channel feature
Bram Moolenaar <Bram@vim.org>
parents:
27140
diff
changeset
|
3014 # if defined(FEAT_JOB_CHANNEL) || defined(PROTO) |
|
13750
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3015 /* |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3016 * Build "argv[argc]" from the list "l". |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3017 * "argv[argc]" is set to NULL; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3018 * Return FAIL when out of memory. |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3019 */ |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3020 int |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3021 build_argv_from_list(list_T *l, char ***argv, int *argc) |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3022 { |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3023 listitem_T *li; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3024 char_u *s; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3025 |
|
18931
80b40bd5ec1a
patch 8.2.0026: still some /* */ comments
Bram Moolenaar <Bram@vim.org>
parents:
18886
diff
changeset
|
3026 // Pass argv[] to mch_call_shell(). |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
3027 *argv = ALLOC_MULT(char *, l->lv_len + 1); |
|
13750
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3028 if (*argv == NULL) |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3029 return FAIL; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3030 *argc = 0; |
|
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
19793
diff
changeset
|
3031 FOR_ALL_LIST_ITEMS(l, li) |
|
13750
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3032 { |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15209
diff
changeset
|
3033 s = tv_get_string_chk(&li->li_tv); |
|
13750
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3034 if (s == NULL) |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3035 { |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3036 int i; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3037 |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3038 for (i = 0; i < *argc; ++i) |
|
20033
2e5e86ff7596
patch 8.2.0572: using two lines for free and reset
Bram Moolenaar <Bram@vim.org>
parents:
20031
diff
changeset
|
3039 VIM_CLEAR((*argv)[i]); |
|
25891
58b1c9d96ec6
patch 8.2.3479: crash when calling job_start with an invalid argument
Bram Moolenaar <Bram@vim.org>
parents:
25642
diff
changeset
|
3040 (*argv)[0] = NULL; |
|
13750
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3041 return FAIL; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3042 } |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3043 (*argv)[*argc] = (char *)vim_strsave(s); |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3044 *argc += 1; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3045 } |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3046 (*argv)[*argc] = NULL; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3047 return OK; |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3048 } |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3049 # endif |
|
3ab6198c1f9a
patch 8.0.1747: MS-Windows: term_start() does not set job_info() cmd
Christian Brabandt <cb@256bit.org>
parents:
13746
diff
changeset
|
3050 #endif |
|
18064
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3051 |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3052 /* |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3053 * Change the behavior of vterm. |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3054 * 0: As usual. |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3055 * 1: Windows 10 version 1809 |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3056 * The bug causes unstable handling of ambiguous width character. |
|
18611
6a7ebc2ee528
patch 8.1.2299: ConPTY in MS-Windows 1909 is still wrong
Bram Moolenaar <Bram@vim.org>
parents:
18301
diff
changeset
|
3057 * 2: Windows 10 version 1903 & 1909 |
|
18064
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3058 * Use the wrong result because each result is different. |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3059 * 3: Windows 10 insider preview (current latest logic) |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3060 */ |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3061 int |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3062 get_special_pty_type(void) |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3063 { |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3064 #ifdef MSWIN |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3065 return get_conpty_type(); |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3066 #else |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3067 return 0; |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3068 #endif |
|
8b4f9be5db73
patch 8.1.2027: MS-Windows: problem with ambiwidth characters
Bram Moolenaar <Bram@vim.org>
parents:
17978
diff
changeset
|
3069 } |