contrib/nvi/vi/v_scroll.c

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