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