1 /*-
2 * Copyright (c) 1992, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 */
9
10 #include "config.h"
11
12 #include <sys/types.h>
13 #include <sys/queue.h>
14 #include <sys/time.h>
15
16 #include <bitstring.h>
17 #include <errno.h>
18 #include <limits.h>
19 #include <stdio.h>
20
21 #include "../common/common.h"
22 #include "vi.h"
23
24 static void goto_adjust(VICMD *);
25
26 /*
27 * The historic vi had a problem in that all movements were by physical
28 * lines, not by logical, or screen lines. Arguments can be made that this
29 * is the right thing to do. For example, single line movements, such as
30 * 'j' or 'k', should probably work on physical lines. Commands like "dj",
31 * or "j.", where '.' is a change command, make more sense for physical lines
32 * than they do for logical lines.
33 *
34 * These arguments, however, don't apply to scrolling commands like ^D and
35 * ^F -- if the window is fairly small, using physical lines can result in
36 * a half-page scroll repainting the entire screen, which is not what the
37 * user wanted. Second, if the line is larger than the screen, using physical
38 * lines can make it impossible to display parts of the line -- there aren't
39 * any commands that don't display the beginning of the line in historic vi,
40 * and if both the beginning and end of the line can't be on the screen at
41 * the same time, you lose. This is even worse in the case of the H, L, and
42 * M commands -- for large lines, they may all refer to the same line and
43 * will result in no movement at all.
44 *
45 * Another issue is that page and half-page scrolling commands historically
46 * moved to the first non-blank character in the new line. If the line is
47 * approximately the same size as the screen, this loses because the cursor
48 * before and after a ^D, may refer to the same location on the screen. In
49 * this implementation, scrolling commands set the cursor to the first non-
50 * blank character if the line changes because of the scroll. Otherwise,
51 * the cursor is left alone.
52 *
53 * This implementation does the scrolling (^B, ^D, ^F, ^U, ^Y, ^E), and the
54 * cursor positioning commands (H, L, M) commands using logical lines, not
55 * physical.
56 */
57
58 /*
59 * v_lgoto -- [count]G
60 * Go to first non-blank character of the line count, the last line
61 * of the file by default.
62 *
63 * PUBLIC: int v_lgoto(SCR *, VICMD *);
64 */
65 int
v_lgoto(SCR * sp,VICMD * vp)66 v_lgoto(SCR *sp, VICMD *vp)
67 {
68 recno_t nlines;
69
70 if (F_ISSET(vp, VC_C1SET)) {
71 if (!db_exist(sp, vp->count)) {
72 /*
73 * !!!
74 * Historically, 1G was legal in an empty file.
75 */
76 if (vp->count == 1) {
77 if (db_last(sp, &nlines))
78 return (1);
79 if (nlines == 0)
80 return (0);
81 }
82 v_eof(sp, &vp->m_start);
83 return (1);
84 }
85 vp->m_stop.lno = vp->count;
86 } else {
87 if (db_last(sp, &nlines))
88 return (1);
89 vp->m_stop.lno = nlines ? nlines : 1;
90 }
91 goto_adjust(vp);
92 return (0);
93 }
94
95 /*
96 * v_home -- [count]H
97 * Move to the first non-blank character of the logical line
98 * count - 1 from the top of the screen, 0 by default.
99 *
100 * PUBLIC: int v_home(SCR *, VICMD *);
101 */
102 int
v_home(SCR * sp,VICMD * vp)103 v_home(SCR *sp, VICMD *vp)
104 {
105 if (vs_sm_position(sp, &vp->m_stop,
106 F_ISSET(vp, VC_C1SET) ? vp->count - 1 : 0, P_TOP))
107 return (1);
108 goto_adjust(vp);
109 return (0);
110 }
111
112 /*
113 * v_middle -- M
114 * Move to the first non-blank character of the logical line
115 * in the middle of the screen.
116 *
117 * PUBLIC: int v_middle(SCR *, VICMD *);
118 */
119 int
v_middle(SCR * sp,VICMD * vp)120 v_middle(SCR *sp, VICMD *vp)
121 {
122 /*
123 * Yielding to none in our quest for compatibility with every
124 * historical blemish of vi, no matter how strange it might be,
125 * we permit the user to enter a count and then ignore it.
126 */
127 if (vs_sm_position(sp, &vp->m_stop, 0, P_MIDDLE))
128 return (1);
129 goto_adjust(vp);
130 return (0);
131 }
132
133 /*
134 * v_bottom -- [count]L
135 * Move to the first non-blank character of the logical line
136 * count - 1 from the bottom of the screen, 0 by default.
137 *
138 * PUBLIC: int v_bottom(SCR *, VICMD *);
139 */
140 int
v_bottom(SCR * sp,VICMD * vp)141 v_bottom(SCR *sp, VICMD *vp)
142 {
143 if (vs_sm_position(sp, &vp->m_stop,
144 F_ISSET(vp, VC_C1SET) ? vp->count - 1 : 0, P_BOTTOM))
145 return (1);
146 goto_adjust(vp);
147 return (0);
148 }
149
150 static void
goto_adjust(VICMD * vp)151 goto_adjust(VICMD *vp)
152 {
153 /* Guess that it's the end of the range. */
154 vp->m_final = vp->m_stop;
155
156 /*
157 * Non-motion commands move the cursor to the end of the range, and
158 * then to the NEXT nonblank of the line. Historic vi always moved
159 * to the first nonblank in the line; since the H, M, and L commands
160 * are logical motions in this implementation, we do the next nonblank
161 * so that it looks approximately the same to the user. To make this
162 * happen, the VM_RCM_SETNNB flag is set in the vcmd.c command table.
163 *
164 * If it's a motion, it's more complicated. The best possible solution
165 * is probably to display the first nonblank of the line the cursor
166 * will eventually rest on. This is tricky, particularly given that if
167 * the associated command is a delete, we don't yet know what line that
168 * will be. So, we clear the VM_RCM_SETNNB flag, and set the first
169 * nonblank flag (VM_RCM_SETFNB). Note, if the lines are sufficiently
170 * long, this can cause the cursor to warp out of the screen. It's too
171 * hard to fix.
172 *
173 * XXX
174 * The G command is always first nonblank, so it's okay to reset it.
175 */
176 if (ISMOTION(vp)) {
177 F_CLR(vp, VM_RCM_MASK);
178 F_SET(vp, VM_RCM_SETFNB);
179 } else
180 return;
181
182 /*
183 * If moving backward in the file, delete and yank move to the end
184 * of the range, unless the line didn't change, in which case yank
185 * doesn't move. If moving forward in the file, delete and yank
186 * stay at the start of the range. Ignore others.
187 */
188 if (vp->m_stop.lno < vp->m_start.lno ||
189 (vp->m_stop.lno == vp->m_start.lno &&
190 vp->m_stop.cno < vp->m_start.cno)) {
191 if (ISCMD(vp->rkp, 'y') && vp->m_stop.lno == vp->m_start.lno)
192 vp->m_final = vp->m_start;
193 } else
194 vp->m_final = vp->m_start;
195 }
196
197 /*
198 * v_up -- [count]^P, [count]k, [count]-
199 * Move up by lines.
200 *
201 * PUBLIC: int v_up(SCR *, VICMD *);
202 */
203 int
v_up(SCR * sp,VICMD * vp)204 v_up(SCR *sp, VICMD *vp)
205 {
206 recno_t lno;
207
208 lno = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
209 if (vp->m_start.lno <= lno) {
210 v_sof(sp, &vp->m_start);
211 return (1);
212 }
213 vp->m_stop.lno = vp->m_start.lno - lno;
214 vp->m_final = vp->m_stop;
215 return (0);
216 }
217
218 /*
219 * v_cr -- [count]^M
220 * In a script window, send the line to the shell.
221 * In a regular window, move down by lines.
222 *
223 * PUBLIC: int v_cr(SCR *, VICMD *);
224 */
225 int
v_cr(SCR * sp,VICMD * vp)226 v_cr(SCR *sp, VICMD *vp)
227 {
228 /* If it's a colon command-line edit window, it's an ex command. */
229 if (F_ISSET(sp, SC_COMEDIT))
230 return (v_ecl_exec(sp));
231
232 /* If it's a script window, exec the line. */
233 if (F_ISSET(sp, SC_SCRIPT))
234 return (sscr_exec(sp, vp->m_start.lno));
235
236 /* Otherwise, it's the same as v_down(). */
237 return (v_down(sp, vp));
238 }
239
240 /*
241 * v_down -- [count]^J, [count]^N, [count]j, [count]^M, [count]+
242 * Move down by lines.
243 *
244 * PUBLIC: int v_down(SCR *, VICMD *);
245 */
246 int
v_down(SCR * sp,VICMD * vp)247 v_down(SCR *sp, VICMD *vp)
248 {
249 recno_t lno;
250
251 lno = vp->m_start.lno + (F_ISSET(vp, VC_C1SET) ? vp->count : 1);
252 if (!db_exist(sp, lno)) {
253 v_eof(sp, &vp->m_start);
254 return (1);
255 }
256 vp->m_stop.lno = lno;
257 vp->m_final = ISMOTION(vp) ? vp->m_start : vp->m_stop;
258 return (0);
259 }
260
261 /*
262 * v_hpageup -- [count]^U
263 * Page up half screens.
264 *
265 * PUBLIC: int v_hpageup(SCR *, VICMD *);
266 */
267 int
v_hpageup(SCR * sp,VICMD * vp)268 v_hpageup(SCR *sp, VICMD *vp)
269 {
270 /*
271 * Half screens always succeed unless already at SOF.
272 *
273 * !!!
274 * Half screens set the scroll value, even if the command
275 * ultimately failed, in historic vi. Probably a don't care.
276 */
277 if (F_ISSET(vp, VC_C1SET))
278 sp->defscroll = vp->count;
279 if (vs_sm_scroll(sp, &vp->m_stop, sp->defscroll, CNTRL_U))
280 return (1);
281 vp->m_final = vp->m_stop;
282 return (0);
283 }
284
285 /*
286 * v_hpagedown -- [count]^D
287 * Page down half screens.
288 *
289 * PUBLIC: int v_hpagedown(SCR *, VICMD *);
290 */
291 int
v_hpagedown(SCR * sp,VICMD * vp)292 v_hpagedown(SCR *sp, VICMD *vp)
293 {
294 /*
295 * Half screens always succeed unless already at EOF.
296 *
297 * !!!
298 * Half screens set the scroll value, even if the command
299 * ultimately failed, in historic vi. Probably a don't care.
300 */
301 if (F_ISSET(vp, VC_C1SET))
302 sp->defscroll = vp->count;
303 if (vs_sm_scroll(sp, &vp->m_stop, sp->defscroll, CNTRL_D))
304 return (1);
305 vp->m_final = vp->m_stop;
306 return (0);
307 }
308
309 /*
310 * v_pagedown -- [count]^F
311 * Page down full screens.
312 * !!!
313 * Historic vi did not move to the EOF if the screen couldn't move, i.e.
314 * if EOF was already displayed on the screen. This implementation does
315 * move to EOF in that case, making ^F more like the historic ^D.
316 *
317 * PUBLIC: int v_pagedown(SCR *, VICMD *);
318 */
319 int
v_pagedown(SCR * sp,VICMD * vp)320 v_pagedown(SCR *sp, VICMD *vp)
321 {
322 recno_t offset;
323
324 /*
325 * !!!
326 * The calculation in IEEE Std 1003.2-1992 (POSIX) is:
327 *
328 * top_line = top_line + count * (window - 2);
329 *
330 * which was historically wrong. The correct one is:
331 *
332 * top_line = top_line + count * window - 2;
333 *
334 * i.e. the two line "overlap" was only subtracted once. Which
335 * makes no sense, but then again, an overlap makes no sense for
336 * any screen but the "next" one anyway. We do it the historical
337 * way as there's no good reason to change it.
338 *
339 * If the screen has been split horizontally, use the smaller of
340 * the current window size and the window option value.
341 *
342 * It possible for this calculation to be less than 1; move at
343 * least one line.
344 */
345 offset = (F_ISSET(vp, VC_C1SET) ? vp->count : 1) * (IS_SPLIT(sp) ?
346 MIN(sp->t_maxrows, O_VAL(sp, O_WINDOW)) : O_VAL(sp, O_WINDOW));
347 offset = offset <= 2 ? 1 : offset - 2;
348 if (vs_sm_scroll(sp, &vp->m_stop, offset, CNTRL_F))
349 return (1);
350 vp->m_final = vp->m_stop;
351 return (0);
352 }
353
354 /*
355 * v_pageup -- [count]^B
356 * Page up full screens.
357 *
358 * !!!
359 * Historic vi did not move to the SOF if the screen couldn't move, i.e.
360 * if SOF was already displayed on the screen. This implementation does
361 * move to SOF in that case, making ^B more like the historic ^U.
362 *
363 * PUBLIC: int v_pageup(SCR *, VICMD *);
364 */
365 int
v_pageup(SCR * sp,VICMD * vp)366 v_pageup(SCR *sp, VICMD *vp)
367 {
368 recno_t offset;
369
370 /*
371 * !!!
372 * The calculation in IEEE Std 1003.2-1992 (POSIX) is:
373 *
374 * top_line = top_line - count * (window - 2);
375 *
376 * which was historically wrong. The correct one is:
377 *
378 * top_line = (top_line - count * window) + 2;
379 *
380 * A simpler expression is that, as with ^F, we scroll exactly:
381 *
382 * count * window - 2
383 *
384 * lines.
385 *
386 * Bizarre. As with ^F, an overlap makes no sense for anything
387 * but the first screen. We do it the historical way as there's
388 * no good reason to change it.
389 *
390 * If the screen has been split horizontally, use the smaller of
391 * the current window size and the window option value.
392 *
393 * It possible for this calculation to be less than 1; move at
394 * least one line.
395 */
396 offset = (F_ISSET(vp, VC_C1SET) ? vp->count : 1) * (IS_SPLIT(sp) ?
397 MIN(sp->t_maxrows, O_VAL(sp, O_WINDOW)) : O_VAL(sp, O_WINDOW));
398 offset = offset <= 2 ? 1 : offset - 2;
399 if (vs_sm_scroll(sp, &vp->m_stop, offset, CNTRL_B))
400 return (1);
401 vp->m_final = vp->m_stop;
402 return (0);
403 }
404
405 /*
406 * v_lineup -- [count]^Y
407 * Page up by lines.
408 *
409 * PUBLIC: int v_lineup(SCR *, VICMD *);
410 */
411 int
v_lineup(SCR * sp,VICMD * vp)412 v_lineup(SCR *sp, VICMD *vp)
413 {
414 /*
415 * The cursor moves down, staying with its original line, unless it
416 * reaches the bottom of the screen.
417 */
418 if (vs_sm_scroll(sp,
419 &vp->m_stop, F_ISSET(vp, VC_C1SET) ? vp->count : 1, CNTRL_Y))
420 return (1);
421 vp->m_final = vp->m_stop;
422 return (0);
423 }
424
425 /*
426 * v_linedown -- [count]^E
427 * Page down by lines.
428 *
429 * PUBLIC: int v_linedown(SCR *, VICMD *);
430 */
431 int
v_linedown(SCR * sp,VICMD * vp)432 v_linedown(SCR *sp, VICMD *vp)
433 {
434 /*
435 * The cursor moves up, staying with its original line, unless it
436 * reaches the top of the screen.
437 */
438 if (vs_sm_scroll(sp,
439 &vp->m_stop, F_ISSET(vp, VC_C1SET) ? vp->count : 1, CNTRL_E))
440 return (1);
441 vp->m_final = vp->m_stop;
442 return (0);
443 }
444