home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Spezial / SPEZIAL2_97.zip / SPEZIAL2_97.iso / ANWEND / EDITOR / NVI179B / NVI179B.ZIP / vi / vs_smap.c < prev    next >
C/C++ Source or Header  |  1996-07-12  |  28KB  |  1,261 lines
  1. /*-
  2.  * Copyright (c) 1993, 1994
  3.  *    The Regents of the University of California.  All rights reserved.
  4.  * Copyright (c) 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[] = "@(#)vs_smap.c    10.25 (Berkeley) 7/12/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 <limits.h>
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <string.h>
  25.  
  26. #include "../common/common.h"
  27. #include "vi.h"
  28.  
  29. static int    vs_deleteln __P((SCR *, int));
  30. static int    vs_insertln __P((SCR *, int));
  31. static int    vs_sm_delete __P((SCR *, recno_t));
  32. static int    vs_sm_down __P((SCR *, MARK *, recno_t, scroll_t, SMAP *));
  33. static int    vs_sm_erase __P((SCR *));
  34. static int    vs_sm_insert __P((SCR *, recno_t));
  35. static int    vs_sm_reset __P((SCR *, recno_t));
  36. static int    vs_sm_up __P((SCR *, MARK *, recno_t, scroll_t, SMAP *));
  37.  
  38. /*
  39.  * vs_change --
  40.  *    Make a change to the screen.
  41.  *
  42.  * PUBLIC: int vs_change __P((SCR *, recno_t, lnop_t));
  43.  */
  44. int
  45. vs_change(sp, lno, op)
  46.     SCR *sp;
  47.     recno_t lno;
  48.     lnop_t op;
  49. {
  50.     VI_PRIVATE *vip;
  51.     SMAP *p;
  52.     size_t cnt, oldy, oldx;
  53.  
  54.     vip = VIP(sp);
  55.  
  56.     /*
  57.      * XXX
  58.      * Very nasty special case.  The historic vi code displays a single
  59.      * space (or a '$' if the list option is set) for the first line in
  60.      * an "empty" file.  If we "insert" a line, that line gets scrolled
  61.      * down, not repainted, so it's incorrect when we refresh the screen.
  62.      * The vi text input functions detect it explicitly and don't insert
  63.      * a new line.
  64.      *
  65.      * Check for line #2 before going to the end of the file.
  66.      */
  67.     if ((op == LINE_APPEND && lno == 0 || op == LINE_INSERT && lno == 1) &&
  68.         !db_exist(sp, 2)) {
  69.         lno = 1;
  70.         op = LINE_RESET;
  71.     }
  72.  
  73.     /* Appending is the same as inserting, if the line is incremented. */
  74.     if (op == LINE_APPEND) {
  75.         ++lno;
  76.         op = LINE_INSERT;
  77.     }
  78.  
  79.     /* Ignore the change if the line is after the map. */
  80.     if (lno > TMAP->lno)
  81.         return (0);
  82.  
  83.     /*
  84.      * If the line is before the map, and it's a decrement, decrement
  85.      * the map.  If it's an increment, increment the map.  Otherwise,
  86.      * ignore it.
  87.      */
  88.     if (lno < HMAP->lno) {
  89.         switch (op) {
  90.         case LINE_APPEND:
  91.             abort();
  92.             /* NOTREACHED */
  93.         case LINE_DELETE:
  94.             for (p = HMAP, cnt = sp->t_rows; cnt--; ++p)
  95.                 --p->lno;
  96.             if (sp->lno >= lno)
  97.                 --sp->lno;
  98.             F_SET(vip, VIP_N_RENUMBER);
  99.             break;
  100.         case LINE_INSERT:
  101.             for (p = HMAP, cnt = sp->t_rows; cnt--; ++p)
  102.                 ++p->lno;
  103.             if (sp->lno >= lno)
  104.                 ++sp->lno;
  105.             F_SET(vip, VIP_N_RENUMBER);
  106.             break;
  107.         case LINE_RESET:
  108.             break;
  109.         }
  110.         return (0);
  111.     }
  112.  
  113.     F_SET(vip, VIP_N_REFRESH);
  114.  
  115.     /*
  116.      * Invalidate the line size cache, and invalidate the cursor if it's
  117.      * on this line,
  118.      */
  119.     VI_SCR_CFLUSH(vip);
  120.     if (sp->lno == lno)
  121.         F_SET(vip, VIP_CUR_INVALID);
  122.  
  123.     /*
  124.      * If ex modifies the screen after ex output is already on the screen
  125.      * or if we've switched into ex canonical mode, don't touch it -- we'll
  126.      * get scrolling wrong, at best.
  127.      */
  128.     if (!F_ISSET(sp, SC_TINPUT_INFO) &&
  129.         (F_ISSET(sp, SC_SCR_EXWROTE) || VIP(sp)->totalcount > 1)) {
  130.         F_SET(vip, VIP_N_EX_REDRAW);
  131.         return (0);
  132.     }
  133.  
  134.     /* Save and restore the cursor for these routines. */
  135.     (void)sp->gp->scr_cursor(sp, &oldy, &oldx);
  136.  
  137.     switch (op) {
  138.     case LINE_DELETE:
  139.         if (vs_sm_delete(sp, lno))
  140.             return (1);
  141.         F_SET(vip, VIP_N_RENUMBER);
  142.         break;
  143.     case LINE_INSERT:
  144.         if (vs_sm_insert(sp, lno))
  145.             return (1);
  146.         F_SET(vip, VIP_N_RENUMBER);
  147.         break;
  148.     case LINE_RESET:
  149.         if (vs_sm_reset(sp, lno))
  150.             return (1);
  151.         break;
  152.     default:
  153.         abort();
  154.     }
  155.  
  156.     (void)sp->gp->scr_move(sp, oldy, oldx);
  157.     return (0);
  158. }
  159.  
  160. /*
  161.  * vs_sm_fill --
  162.  *    Fill in the screen map, placing the specified line at the
  163.  *    right position.  There isn't any way to tell if an SMAP
  164.  *    entry has been filled in, so this routine had better be
  165.  *    called with P_FILL set before anything else is done.
  166.  *
  167.  * !!!
  168.  * Unexported interface: if lno is OOBLNO, P_TOP means that the HMAP
  169.  * slot is already filled in, P_BOTTOM means that the TMAP slot is
  170.  * already filled in, and we just finish up the job.
  171.  *
  172.  * PUBLIC: int vs_sm_fill __P((SCR *, recno_t, pos_t));
  173.  */
  174. int
  175. vs_sm_fill(sp, lno, pos)
  176.     SCR *sp;
  177.     recno_t lno;
  178.     pos_t pos;
  179. {
  180.     SMAP *p, tmp;
  181.     size_t cnt;
  182.  
  183.     /* Flush all cached information from the SMAP. */
  184.     for (p = HMAP, cnt = sp->t_rows; cnt--; ++p)
  185.         SMAP_FLUSH(p);
  186.  
  187.     /*
  188.      * If the map is filled, the screen must be redrawn.
  189.      *
  190.      * XXX
  191.      * This is a bug.  We should try and figure out if the desired line
  192.      * is already in the map or close by -- scrolling the screen would
  193.      * be a lot better than redrawing.
  194.      */
  195.     F_SET(sp, SC_SCR_REDRAW);
  196.  
  197.     switch (pos) {
  198.     case P_FILL:
  199.         tmp.lno = 1;
  200.         tmp.coff = 0;
  201.         tmp.soff = 1;
  202.  
  203.         /* See if less than half a screen from the top. */
  204.         if (vs_sm_nlines(sp,
  205.             &tmp, lno, HALFTEXT(sp)) <= HALFTEXT(sp)) {
  206.             lno = 1;
  207.             goto top;
  208.         }
  209.  
  210.         /* See if less than half a screen from the bottom. */
  211.         if (db_last(sp, &tmp.lno))
  212.             return (1);
  213.         tmp.coff = 0;
  214.         tmp.soff = vs_screens(sp, tmp.lno, NULL);
  215.         if (vs_sm_nlines(sp,
  216.             &tmp, lno, HALFTEXT(sp)) <= HALFTEXT(sp)) {
  217.             TMAP->lno = tmp.lno;
  218.             TMAP->coff = tmp.coff;
  219.             TMAP->soff = tmp.soff;
  220.             goto bottom;
  221.         }
  222.         goto middle;
  223.     case P_TOP:
  224.         if (lno != OOBLNO) {
  225. top:            HMAP->lno = lno;
  226.             HMAP->coff = 0;
  227.             HMAP->soff = 1;
  228.         }
  229.         /* If we fail, just punt. */
  230.         for (p = HMAP, cnt = sp->t_rows; --cnt; ++p)
  231.             if (vs_sm_next(sp, p, p + 1))
  232.                 goto err;
  233.         break;
  234.     case P_MIDDLE:
  235.         /* If we fail, guess that the file is too small. */
  236. middle:        p = HMAP + sp->t_rows / 2;
  237.         p->lno = lno;
  238.         p->coff = 0;
  239.         p->soff = 1;
  240.         for (; p > HMAP; --p)
  241.             if (vs_sm_prev(sp, p, p - 1)) {
  242.                 lno = 1;
  243.                 goto top;
  244.             }
  245.  
  246.         /* If we fail, just punt. */
  247.         p = HMAP + sp->t_rows / 2;
  248.         for (; p < TMAP; ++p)
  249.             if (vs_sm_next(sp, p, p + 1))
  250.                 goto err;
  251.         break;
  252.     case P_BOTTOM:
  253.         if (lno != OOBLNO) {
  254.             TMAP->lno = lno;
  255.             TMAP->coff = 0;
  256.             TMAP->soff = vs_screens(sp, lno, NULL);
  257.         }
  258.         /* If we fail, guess that the file is too small. */
  259. bottom:        for (p = TMAP; p > HMAP; --p)
  260.             if (vs_sm_prev(sp, p, p - 1)) {
  261.                 lno = 1;
  262.                 goto top;
  263.             }
  264.         break;
  265.     default:
  266.         abort();
  267.     }
  268.     return (0);
  269.  
  270.     /*
  271.      * Try and put *something* on the screen.  If this fails, we have a
  272.      * serious hard error.
  273.      */
  274. err:    HMAP->lno = 1;
  275.     HMAP->coff = 0;
  276.     HMAP->soff = 1;
  277.     for (p = HMAP; p < TMAP; ++p)
  278.         if (vs_sm_next(sp, p, p + 1))
  279.             return (1);
  280.     return (0);
  281. }
  282.  
  283. /*
  284.  * For the routines vs_sm_reset, vs_sm_delete and vs_sm_insert: if the
  285.  * screen contains only a single line (whether because the screen is small
  286.  * or the line large), it gets fairly exciting.  Skip the fun, set a flag
  287.  * so the screen map is refilled and the screen redrawn, and return.  This
  288.  * is amazingly slow, but it's not clear that anyone will care.
  289.  */
  290. #define    HANDLE_WEIRDNESS(cnt) {                        \
  291.     if (cnt >= sp->t_rows) {                    \
  292.         F_SET(sp, SC_SCR_REFORMAT);                \
  293.         return (0);                        \
  294.     }                                \
  295. }
  296.  
  297. /*
  298.  * vs_sm_delete --
  299.  *    Delete a line out of the SMAP.
  300.  */
  301. static int
  302. vs_sm_delete(sp, lno)
  303.     SCR *sp;
  304.     recno_t lno;
  305. {
  306.     SMAP *p, *t;
  307.     size_t cnt_orig;
  308.  
  309.     /*
  310.      * Find the line in the map, and count the number of screen lines
  311.      * which display any part of the deleted line.
  312.      */
  313.     for (p = HMAP; p->lno != lno; ++p);
  314.     if (O_ISSET(sp, O_LEFTRIGHT))
  315.         cnt_orig = 1;
  316.     else
  317.         for (cnt_orig = 1, t = p + 1;
  318.             t <= TMAP && t->lno == lno; ++cnt_orig, ++t);
  319.  
  320.     HANDLE_WEIRDNESS(cnt_orig);
  321.  
  322.     /* Delete that many lines from the screen. */
  323.     (void)sp->gp->scr_move(sp, p - HMAP, 0);
  324.     if (vs_deleteln(sp, cnt_orig))
  325.         return (1);
  326.  
  327.     /* Shift the screen map up. */
  328.     memmove(p, p + cnt_orig, (((TMAP - p) - cnt_orig) + 1) * sizeof(SMAP));
  329.  
  330.     /* Decrement the line numbers for the rest of the map. */
  331.     for (t = TMAP - cnt_orig; p <= t; ++p)
  332.         --p->lno;
  333.  
  334.     /* Display the new lines. */
  335.     for (p = TMAP - cnt_orig;;) {
  336.         if (p < TMAP && vs_sm_next(sp, p, p + 1))
  337.             return (1);
  338.         /* vs_sm_next() flushed the cache. */
  339.         if (vs_line(sp, ++p, NULL, NULL))
  340.             return (1);
  341.         if (p == TMAP)
  342.             break;
  343.     }
  344.     return (0);
  345. }
  346.  
  347. /*
  348.  * vs_sm_insert --
  349.  *    Insert a line into the SMAP.
  350.  */
  351. static int
  352. vs_sm_insert(sp, lno)
  353.     SCR *sp;
  354.     recno_t lno;
  355. {
  356.     SMAP *p, *t;
  357.     size_t cnt_orig, cnt, coff;
  358.  
  359.     /* Save the offset. */
  360.     coff = HMAP->coff;
  361.  
  362.     /*
  363.      * Find the line in the map, find out how many screen lines
  364.      * needed to display the line.
  365.      */
  366.     for (p = HMAP; p->lno != lno; ++p);
  367.  
  368.     cnt_orig = vs_screens(sp, lno, NULL);
  369.     HANDLE_WEIRDNESS(cnt_orig);
  370.  
  371.     /*
  372.      * The lines left in the screen override the number of screen
  373.      * lines in the inserted line.
  374.      */
  375.     cnt = (TMAP - p) + 1;
  376.     if (cnt_orig > cnt)
  377.         cnt_orig = cnt;
  378.  
  379.     /* Push down that many lines. */
  380.     (void)sp->gp->scr_move(sp, p - HMAP, 0);
  381.     if (vs_insertln(sp, cnt_orig))
  382.         return (1);
  383.  
  384.     /* Shift the screen map down. */
  385.     memmove(p + cnt_orig, p, (((TMAP - p) - cnt_orig) + 1) * sizeof(SMAP));
  386.  
  387.     /* Increment the line numbers for the rest of the map. */
  388.     for (t = p + cnt_orig; t <= TMAP; ++t)
  389.         ++t->lno;
  390.  
  391.     /* Fill in the SMAP for the new lines, and display. */
  392.     for (cnt = 1, t = p; cnt <= cnt_orig; ++t, ++cnt) {
  393.         t->lno = lno;
  394.         t->coff = coff;
  395.         t->soff = cnt;
  396.         SMAP_FLUSH(t);
  397.         if (vs_line(sp, t, NULL, NULL))
  398.             return (1);
  399.     }
  400.     return (0);
  401. }
  402.  
  403. /*
  404.  * vs_sm_reset --
  405.  *    Reset a line in the SMAP.
  406.  */
  407. static int
  408. vs_sm_reset(sp, lno)
  409.     SCR *sp;
  410.     recno_t lno;
  411. {
  412.     SMAP *p, *t;
  413.     size_t cnt_orig, cnt_new, cnt, diff;
  414.  
  415.     /*
  416.      * See if the number of on-screen rows taken up by the old display
  417.      * for the line is the same as the number needed for the new one.
  418.      * If so, repaint, otherwise do it the hard way.
  419.      */
  420.     for (p = HMAP; p->lno != lno; ++p);
  421.     if (O_ISSET(sp, O_LEFTRIGHT)) {
  422.         t = p;
  423.         cnt_orig = cnt_new = 1;
  424.     } else {
  425.         for (cnt_orig = 0,
  426.             t = p; t <= TMAP && t->lno == lno; ++cnt_orig, ++t);
  427.         cnt_new = vs_screens(sp, lno, NULL);
  428.     }
  429.  
  430.     HANDLE_WEIRDNESS(cnt_orig);
  431.  
  432.     if (cnt_orig == cnt_new) {
  433.         do {
  434.             SMAP_FLUSH(p);
  435.             if (vs_line(sp, p, NULL, NULL))
  436.                 return (1);
  437.         } while (++p < t);
  438.         return (0);
  439.     }
  440.  
  441.     if (cnt_orig < cnt_new) {
  442.         /* Get the difference. */
  443.         diff = cnt_new - cnt_orig;
  444.  
  445.         /*
  446.          * The lines left in the screen override the number of screen
  447.          * lines in the inserted line.
  448.          */
  449.         cnt = (TMAP - p) + 1;
  450.         if (diff > cnt)
  451.             diff = cnt;
  452.  
  453.         /* If there are any following lines, push them down. */
  454.         if (cnt > 1) {
  455.             (void)sp->gp->scr_move(sp, p - HMAP, 0);
  456.             if (vs_insertln(sp, diff))
  457.                 return (1);
  458.  
  459.             /* Shift the screen map down. */
  460.             memmove(p + diff, p,
  461.                 (((TMAP - p) - diff) + 1) * sizeof(SMAP));
  462.         }
  463.  
  464.         /* Fill in the SMAP for the replaced line, and display. */
  465.         for (cnt = 1, t = p; cnt_new-- && t <= TMAP; ++t, ++cnt) {
  466.             t->lno = lno;
  467.             t->soff = cnt;
  468.             SMAP_FLUSH(t);
  469.             if (vs_line(sp, t, NULL, NULL))
  470.                 return (1);
  471.         }
  472.     } else {
  473.         /* Get the difference. */
  474.         diff = cnt_orig - cnt_new;
  475.  
  476.         /* Delete that many lines from the screen. */
  477.         (void)sp->gp->scr_move(sp, p - HMAP, 0);
  478.         if (vs_deleteln(sp, diff))
  479.             return (1);
  480.  
  481.         /* Shift the screen map up. */
  482.         memmove(p, p + diff, (((TMAP - p) - diff) + 1) * sizeof(SMAP));
  483.  
  484.         /* Fill in the SMAP for the replaced line, and display. */
  485.         for (cnt = 1, t = p; cnt_new--; ++t, ++cnt) {
  486.             t->lno = lno;
  487.             t->soff = cnt;
  488.             SMAP_FLUSH(t);
  489.             if (vs_line(sp, t, NULL, NULL))
  490.                 return (1);
  491.         }
  492.  
  493.         /* Display the new lines at the bottom of the screen. */
  494.         for (t = TMAP - diff;;) {
  495.             if (t < TMAP && vs_sm_next(sp, t, t + 1))
  496.                 return (1);
  497.             /* vs_sm_next() flushed the cache. */
  498.             if (vs_line(sp, ++t, NULL, NULL))
  499.                 return (1);
  500.             if (t == TMAP)
  501.                 break;
  502.         }
  503.     }
  504.     return (0);
  505. }
  506.  
  507. /*
  508.  * vs_sm_scroll
  509.  *    Scroll the SMAP up/down count logical lines.  Different
  510.  *    semantics based on the vi command, *sigh*.
  511.  *
  512.  * PUBLIC: int vs_sm_scroll __P((SCR *, MARK *, recno_t, scroll_t));
  513.  */
  514. int
  515. vs_sm_scroll(sp, rp, count, scmd)
  516.     SCR *sp;
  517.     MARK *rp;
  518.     recno_t count;
  519.     scroll_t scmd;
  520. {
  521.     SMAP *smp;
  522.  
  523.     /*
  524.      * Invalidate the cursor.  The line is probably going to change,
  525.      * (although for ^E and ^Y it may not).  In any case, the scroll
  526.      * routines move the cursor to draw things.
  527.      */
  528.     F_SET(VIP(sp), VIP_CUR_INVALID);
  529.  
  530.     /* Find the cursor in the screen. */
  531.     if (vs_sm_cursor(sp, &smp))
  532.         return (1);
  533.  
  534.     switch (scmd) {
  535.     case CNTRL_B:
  536.     case CNTRL_U:
  537.     case CNTRL_Y:
  538.     case Z_CARAT:
  539.         if (vs_sm_down(sp, rp, count, scmd, smp))
  540.             return (1);
  541.         break;
  542.     case CNTRL_D:
  543.     case CNTRL_E:
  544.     case CNTRL_F:
  545.     case Z_PLUS:
  546.         if (vs_sm_up(sp, rp, count, scmd, smp))
  547.             return (1);
  548.         break;
  549.     default:
  550.         abort();
  551.     }
  552.  
  553.     /*
  554.      * !!!
  555.      * If we're at the start of a line, go for the first non-blank.
  556.      * This makes it look like the old vi, even though we're moving
  557.      * around by logical lines, not physical ones.
  558.      *
  559.      * XXX
  560.      * In the presence of a long line, which has more than a screen
  561.      * width of leading spaces, this code can cause a cursor warp.
  562.      * Live with it.
  563.      */
  564.     if (scmd != CNTRL_E && scmd != CNTRL_Y &&
  565.         rp->cno == 0 && nonblank(sp, rp->lno, &rp->cno))
  566.         return (1);
  567.  
  568.     return (0);
  569. }
  570.  
  571. /*
  572.  * vs_sm_up --
  573.  *    Scroll the SMAP up count logical lines.
  574.  */
  575. static int
  576. vs_sm_up(sp, rp, count, scmd, smp)
  577.     SCR *sp;
  578.     MARK *rp;
  579.     scroll_t scmd;
  580.     recno_t count;
  581.     SMAP *smp;
  582. {
  583.     int cursor_set, echanged, zset;
  584.     SMAP *ssmp, s1, s2;
  585.  
  586.     /*
  587.      * Check to see if movement is possible.
  588.      *
  589.      * Get the line after the map.  If that line is a new one (and if
  590.      * O_LEFTRIGHT option is set, this has to be true), and the next
  591.      * line doesn't exist, and the cursor doesn't move, or the cursor
  592.      * isn't even on the screen, or the cursor is already at the last
  593.      * line in the map, it's an error.  If that test succeeded because
  594.      * the cursor wasn't at the end of the map, test to see if the map
  595.      * is mostly empty.
  596.      */
  597.     if (vs_sm_next(sp, TMAP, &s1))
  598.         return (1);
  599.     if (s1.lno > TMAP->lno && !db_exist(sp, s1.lno)) {
  600.         if (scmd == CNTRL_E || scmd == Z_PLUS || smp == TMAP) {
  601.             v_eof(sp, NULL);
  602.             return (1);
  603.         }
  604.         if (vs_sm_next(sp, smp, &s1))
  605.             return (1);
  606.         if (s1.lno > smp->lno && !db_exist(sp, s1.lno)) {
  607.             v_eof(sp, NULL);
  608.             return (1);
  609.         }
  610.     }
  611.  
  612.     /*
  613.      * Small screens: see vs_refresh.c section 6a.
  614.      *
  615.      * If it's a small screen, and the movement isn't larger than a
  616.      * screen, i.e some context will remain, open up the screen and
  617.      * display by scrolling.  In this case, the cursor moves down one
  618.      * line for each line displayed.  Otherwise, erase/compress and
  619.      * repaint, and move the cursor to the first line in the screen.
  620.      * Note, the ^F command is always in the latter case, for historical
  621.      * reasons.
  622.      */
  623.     cursor_set = 0;
  624.     if (IS_SMALL(sp)) {
  625.         if (count >= sp->t_maxrows || scmd == CNTRL_F) {
  626.             s1 = TMAP[0];
  627.             if (vs_sm_erase(sp))
  628.                 return (1);
  629.             for (; count--; s1 = s2) {
  630.                 if (vs_sm_next(sp, &s1, &s2))
  631.                     return (1);
  632.                 if (s2.lno != s1.lno && !db_exist(sp, s2.lno))
  633.                     break;
  634.             }
  635.             TMAP[0] = s2;
  636.             if (vs_sm_fill(sp, OOBLNO, P_BOTTOM))
  637.                 return (1);
  638.             return (vs_sm_position(sp, rp, 0, P_TOP));
  639.         }
  640.         cursor_set = scmd == CNTRL_E || vs_sm_cursor(sp, &ssmp);
  641.         for (; count &&
  642.             sp->t_rows != sp->t_maxrows; --count, ++sp->t_rows) {
  643.             if (vs_sm_next(sp, TMAP, &s1))
  644.                 return (1);
  645.             if (TMAP->lno != s1.lno && !db_exist(sp, s1.lno))
  646.                 break;
  647.             *++TMAP = s1;
  648.             /* vs_sm_next() flushed the cache. */
  649.             if (vs_line(sp, TMAP, NULL, NULL))
  650.                 return (1);
  651.  
  652.             if (!cursor_set)
  653.                 ++ssmp;
  654.         }
  655.         if (!cursor_set) {
  656.             rp->lno = ssmp->lno;
  657.             rp->cno = ssmp->c_sboff;
  658.         }
  659.         if (count == 0)
  660.             return (0);
  661.     }
  662.  
  663.     for (echanged = zset = 0; count; --count) {
  664.         /* Decide what would show up on the screen. */
  665.         if (vs_sm_next(sp, TMAP, &s1))
  666.             return (1);
  667.  
  668.         /* If the line doesn't exist, we're done. */
  669.         if (TMAP->lno != s1.lno && !db_exist(sp, s1.lno))
  670.             break;
  671.  
  672.         /* Scroll the screen cursor up one logical line. */
  673.         if (vs_sm_1up(sp))
  674.             return (1);
  675.         switch (scmd) {
  676.         case CNTRL_E:
  677.             if (smp > HMAP)
  678.                 --smp;
  679.             else
  680.                 echanged = 1;
  681.             break;
  682.         case Z_PLUS:
  683.             if (zset) {
  684.                 if (smp > HMAP)
  685.                     --smp;
  686.             } else {
  687.                 smp = TMAP;
  688.                 zset = 1;
  689.             }
  690.             /* FALLTHROUGH */
  691.         default:
  692.             break;
  693.         }
  694.     }
  695.  
  696.     if (cursor_set)
  697.         return(0);
  698.  
  699.     switch (scmd) {
  700.     case CNTRL_E:
  701.         /*
  702.          * On a ^E that was forced to change lines, try and keep the
  703.          * cursor as close as possible to the last position, but also
  704.          * set it up so that the next "real" movement will return the
  705.          * cursor to the closest position to the last real movement.
  706.          */
  707.         if (echanged) {
  708.             rp->lno = smp->lno;
  709.             rp->cno = vs_colpos(sp, smp->lno,
  710.                 (O_ISSET(sp, O_LEFTRIGHT) ? 
  711.                 smp->coff : (smp->soff - 1) * sp->cols) +
  712.                 sp->rcm % sp->cols);
  713.         }
  714.         return (0);
  715.     case CNTRL_F:
  716.         /*
  717.          * If there are more lines, the ^F command is positioned at
  718.          * the first line of the screen.
  719.          */
  720.         if (!count) {
  721.             smp = HMAP;
  722.             break;
  723.         }
  724.         /* FALLTHROUGH */
  725.     case CNTRL_D:
  726.         /*
  727.          * The ^D and ^F commands move the cursor towards EOF
  728.          * if there are more lines to move.  Check to be sure
  729.          * the lines actually exist.  (They may not if the
  730.          * file is smaller than the screen.)
  731.          */
  732.         for (; count; --count, ++smp)
  733.             if (smp == TMAP || !db_exist(sp, smp[1].lno))
  734.                 break;
  735.         break;
  736.     case Z_PLUS:
  737.          /* The z+ command moves the cursor to the first new line. */
  738.         break;
  739.     default:
  740.         abort();
  741.     }
  742.  
  743.     if (!SMAP_CACHE(smp) && vs_line(sp, smp, NULL, NULL))
  744.         return (1);
  745.     rp->lno = smp->lno;
  746.     rp->cno = smp->c_sboff;
  747.     return (0);
  748. }
  749.  
  750. /*
  751.  * vs_sm_1up --
  752.  *    Scroll the SMAP up one.
  753.  *
  754.  * PUBLIC: int vs_sm_1up __P((SCR *));
  755.  */
  756. int
  757. vs_sm_1up(sp)
  758.     SCR *sp;
  759. {
  760.     /*
  761.      * Delete the top line of the screen.  Shift the screen map
  762.      * up and display a new line at the bottom of the screen.
  763.      */
  764.     (void)sp->gp->scr_move(sp, 0, 0);
  765.     if (vs_deleteln(sp, 1))
  766.         return (1);
  767.  
  768.     /* One-line screens can fail. */
  769.     if (IS_ONELINE(sp)) {
  770.         if (vs_sm_next(sp, TMAP, TMAP))
  771.             return (1);
  772.     } else {
  773.         memmove(HMAP, HMAP + 1, (sp->rows - 1) * sizeof(SMAP));
  774.         if (vs_sm_next(sp, TMAP - 1, TMAP))
  775.             return (1);
  776.     }
  777.     /* vs_sm_next() flushed the cache. */
  778.     return (vs_line(sp, TMAP, NULL, NULL));
  779. }
  780.  
  781. /*
  782.  * vs_deleteln --
  783.  *    Delete a line a la curses, make sure to put the information
  784.  *    line and other screens back.
  785.  */
  786. static int
  787. vs_deleteln(sp, cnt)
  788.     SCR *sp;
  789.     int cnt;
  790. {
  791.     GS *gp;
  792.     size_t oldy, oldx;
  793.  
  794.     gp = sp->gp;
  795.     if (IS_ONELINE(sp))
  796.         (void)gp->scr_clrtoeol(sp);
  797.     else {
  798.         (void)gp->scr_cursor(sp, &oldy, &oldx);
  799.         while (cnt--) {
  800.             (void)gp->scr_deleteln(sp);
  801.             (void)gp->scr_move(sp, LASTLINE(sp), 0);
  802.             (void)gp->scr_insertln(sp);
  803.             (void)gp->scr_move(sp, oldy, oldx);
  804.         }
  805.     }
  806.     return (0);
  807. }
  808.  
  809. /*
  810.  * vs_sm_down --
  811.  *    Scroll the SMAP down count logical lines.
  812.  */
  813. static int
  814. vs_sm_down(sp, rp, count, scmd, smp)
  815.     SCR *sp;
  816.     MARK *rp;
  817.     recno_t count;
  818.     SMAP *smp;
  819.     scroll_t scmd;
  820. {
  821.     SMAP *ssmp, s1, s2;
  822.     int cursor_set, ychanged, zset;
  823.  
  824.     /* Check to see if movement is possible. */
  825.     if (HMAP->lno == 1 &&
  826.         (O_ISSET(sp, O_LEFTRIGHT) || HMAP->soff == 1) &&
  827.         (scmd == CNTRL_Y || scmd == Z_CARAT || smp == HMAP)) {
  828.         v_sof(sp, NULL);
  829.         return (1);
  830.     }
  831.  
  832.     /*
  833.      * Small screens: see vs_refresh.c section 6a.
  834.      *
  835.      * If it's a small screen, and the movement isn't larger than a
  836.      * screen, i.e some context will remain, open up the screen and
  837.      * display by scrolling.  In this case, the cursor moves up one
  838.      * line for each line displayed.  Otherwise, erase/compress and
  839.      * repaint, and move the cursor to the first line in the screen.
  840.      * Note, the ^B command is always in the latter case, for historical
  841.      * reasons.
  842.      */
  843.     cursor_set = scmd == CNTRL_Y;
  844.     if (IS_SMALL(sp)) {
  845.         if (count >= sp->t_maxrows || scmd == CNTRL_B) {
  846.             s1 = HMAP[0];
  847.             if (vs_sm_erase(sp))
  848.                 return (1);
  849.             for (; count--; s1 = s2) {
  850.                 if (vs_sm_prev(sp, &s1, &s2))
  851.                     return (1);
  852.                 if (s2.lno == 1 &&
  853.                     (O_ISSET(sp, O_LEFTRIGHT) || s2.soff == 1))
  854.                     break;
  855.             }
  856.             HMAP[0] = s2;
  857.             if (vs_sm_fill(sp, OOBLNO, P_TOP))
  858.                 return (1);
  859.             return (vs_sm_position(sp, rp, 0, P_BOTTOM));
  860.         }
  861.         cursor_set = scmd == CNTRL_Y || vs_sm_cursor(sp, &ssmp);
  862.         for (; count &&
  863.             sp->t_rows != sp->t_maxrows; --count, ++sp->t_rows) {
  864.             if (HMAP->lno == 1 &&
  865.                 (O_ISSET(sp, O_LEFTRIGHT) || HMAP->soff == 1))
  866.                 break;
  867.             ++TMAP;
  868.             if (vs_sm_1down(sp))
  869.                 return (1);
  870.         }
  871.         if (!cursor_set) {
  872.             rp->lno = ssmp->lno;
  873.             rp->cno = ssmp->c_sboff;
  874.         }
  875.         if (count == 0)
  876.             return (0);
  877.     }
  878.  
  879.     for (ychanged = zset = 0; count; --count) {
  880.         /* If the line doesn't exist, we're done. */
  881.         if (HMAP->lno == 1 &&
  882.             (O_ISSET(sp, O_LEFTRIGHT) || HMAP->soff == 1))
  883.             break;
  884.  
  885.         /* Scroll the screen and cursor down one logical line. */
  886.         if (vs_sm_1down(sp))
  887.             return (1);
  888.         switch (scmd) {
  889.         case CNTRL_Y:
  890.             if (smp < TMAP)
  891.                 ++smp;
  892.             else
  893.                 ychanged = 1;
  894.             break;
  895.         case Z_CARAT:
  896.             if (zset) {
  897.                 if (smp < TMAP)
  898.                     ++smp;
  899.             } else {
  900.                 smp = HMAP;
  901.                 zset = 1;
  902.             }
  903.             /* FALLTHROUGH */
  904.         default:
  905.             break;
  906.         }
  907.     }
  908.  
  909.     if (scmd != CNTRL_Y && cursor_set)
  910.         return(0);
  911.  
  912.     switch (scmd) {
  913.     case CNTRL_B:
  914.         /*
  915.          * If there are more lines, the ^B command is positioned at
  916.          * the last line of the screen.  However, the line may not
  917.          * exist.
  918.          */
  919.         if (!count) {
  920.             for (smp = TMAP; smp > HMAP; --smp)
  921.                 if (db_exist(sp, smp->lno))
  922.                     break;
  923.             break;
  924.         }
  925.         /* FALLTHROUGH */
  926.     case CNTRL_U:
  927.         /*
  928.          * The ^B and ^U commands move the cursor towards SOF
  929.          * if there are more lines to move.
  930.          */
  931.         if (count < smp - HMAP)
  932.             smp -= count;
  933.         else
  934.             smp = HMAP;
  935.         break;
  936.     case CNTRL_Y:
  937.         /*
  938.          * On a ^Y that was forced to change lines, try and keep the
  939.          * cursor as close as possible to the last position, but also
  940.          * set it up so that the next "real" movement will return the
  941.          * cursor to the closest position to the last real movement.
  942.          */
  943.         if (ychanged) {
  944.             rp->lno = smp->lno;
  945.             rp->cno = vs_colpos(sp, smp->lno,
  946.                 (O_ISSET(sp, O_LEFTRIGHT) ? 
  947.                 smp->coff : (smp->soff - 1) * sp->cols) +
  948.                 sp->rcm % sp->cols);
  949.         }
  950.         return (0);
  951.     case Z_CARAT:
  952.          /* The z^ command moves the cursor to the first new line. */
  953.         break;
  954.     default:
  955.         abort();
  956.     }
  957.  
  958.     if (!SMAP_CACHE(smp) && vs_line(sp, smp, NULL, NULL))
  959.         return (1);
  960.     rp->lno = smp->lno;
  961.     rp->cno = smp->c_sboff;
  962.     return (0);
  963. }
  964.  
  965. /*
  966.  * vs_sm_erase --
  967.  *    Erase the small screen area for the scrolling functions.
  968.  */
  969. static int
  970. vs_sm_erase(sp)
  971.     SCR *sp;
  972. {
  973.     GS *gp;
  974.  
  975.     gp = sp->gp;
  976.     (void)gp->scr_move(sp, LASTLINE(sp), 0);
  977.     (void)gp->scr_clrtoeol(sp);
  978.     for (; sp->t_rows > sp->t_minrows; --sp->t_rows, --TMAP) {
  979.         (void)gp->scr_move(sp, TMAP - HMAP, 0);
  980.         (void)gp->scr_clrtoeol(sp);
  981.     }
  982.     return (0);
  983. }
  984.  
  985. /*
  986.  * vs_sm_1down --
  987.  *    Scroll the SMAP down one.
  988.  *
  989.  * PUBLIC: int vs_sm_1down __P((SCR *));
  990.  */
  991. int
  992. vs_sm_1down(sp)
  993.     SCR *sp;
  994. {
  995.     /*
  996.      * Insert a line at the top of the screen.  Shift the screen map
  997.      * down and display a new line at the top of the screen.
  998.      */
  999.     (void)sp->gp->scr_move(sp, 0, 0);
  1000.     if (vs_insertln(sp, 1))
  1001.         return (1);
  1002.  
  1003.     /* One-line screens can fail. */
  1004.     if (IS_ONELINE(sp)) {
  1005.         if (vs_sm_prev(sp, HMAP, HMAP))
  1006.             return (1);
  1007.     } else {
  1008.         memmove(HMAP + 1, HMAP, (sp->rows - 1) * sizeof(SMAP));
  1009.         if (vs_sm_prev(sp, HMAP + 1, HMAP))
  1010.             return (1);
  1011.     }
  1012.     /* vs_sm_prev() flushed the cache. */
  1013.     return (vs_line(sp, HMAP, NULL, NULL));
  1014. }
  1015.  
  1016. /*
  1017.  * vs_insertln --
  1018.  *    Insert a line a la curses, make sure to put the information
  1019.  *    line and other screens back.
  1020.  */
  1021. static int
  1022. vs_insertln(sp, cnt)
  1023.     SCR *sp;
  1024.     int cnt;
  1025. {
  1026.     GS *gp;
  1027.     size_t oldy, oldx;
  1028.  
  1029.     gp = sp->gp;
  1030.     if (IS_ONELINE(sp)) {
  1031.         (void)gp->scr_move(sp, LASTLINE(sp), 0);
  1032.         (void)gp->scr_clrtoeol(sp);
  1033.     } else {
  1034.         (void)gp->scr_cursor(sp, &oldy, &oldx);
  1035.         while (cnt--) {
  1036.             (void)gp->scr_move(sp, LASTLINE(sp) - 1, 0);
  1037.             (void)gp->scr_deleteln(sp);
  1038.             (void)gp->scr_move(sp, oldy, oldx);
  1039.             (void)gp->scr_insertln(sp);
  1040.         }
  1041.     }
  1042.     return (0);
  1043. }
  1044.  
  1045. /*
  1046.  * vs_sm_next --
  1047.  *    Fill in the next entry in the SMAP.
  1048.  *
  1049.  * PUBLIC: int vs_sm_next __P((SCR *, SMAP *, SMAP *));
  1050.  */
  1051. int
  1052. vs_sm_next(sp, p, t)
  1053.     SCR *sp;
  1054.     SMAP *p, *t;
  1055. {
  1056.     size_t lcnt;
  1057.  
  1058.     SMAP_FLUSH(t);
  1059.     if (O_ISSET(sp, O_LEFTRIGHT)) {
  1060.         t->lno = p->lno + 1;
  1061.         t->coff = p->coff;
  1062.     } else {
  1063.         lcnt = vs_screens(sp, p->lno, NULL);
  1064.         if (lcnt == p->soff) {
  1065.             t->lno = p->lno + 1;
  1066.             t->soff = 1;
  1067.         } else {
  1068.             t->lno = p->lno;
  1069.             t->soff = p->soff + 1;
  1070.         }
  1071.     }
  1072.     return (0);
  1073. }
  1074.  
  1075. /*
  1076.  * vs_sm_prev --
  1077.  *    Fill in the previous entry in the SMAP.
  1078.  *
  1079.  * PUBLIC: int vs_sm_prev __P((SCR *, SMAP *, SMAP *));
  1080.  */
  1081. int
  1082. vs_sm_prev(sp, p, t)
  1083.     SCR *sp;
  1084.     SMAP *p, *t;
  1085. {
  1086.     SMAP_FLUSH(t);
  1087.     if (O_ISSET(sp, O_LEFTRIGHT)) {
  1088.         t->lno = p->lno - 1;
  1089.         t->coff = p->coff;
  1090.     } else {
  1091.         if (p->soff != 1) {
  1092.             t->lno = p->lno;
  1093.             t->soff = p->soff - 1;
  1094.         } else {
  1095.             t->lno = p->lno - 1;
  1096.             t->soff = vs_screens(sp, t->lno, NULL);
  1097.         }
  1098.     }
  1099.     return (t->lno == 0);
  1100. }
  1101.  
  1102. /*
  1103.  * vs_sm_cursor --
  1104.  *    Return the SMAP entry referenced by the cursor.
  1105.  *
  1106.  * PUBLIC: int vs_sm_cursor __P((SCR *, SMAP **));
  1107.  */
  1108. int
  1109. vs_sm_cursor(sp, smpp)
  1110.     SCR *sp;
  1111.     SMAP **smpp;
  1112. {
  1113.     SMAP *p;
  1114.  
  1115.     /* See if the cursor is not in the map. */
  1116.     if (sp->lno < HMAP->lno || sp->lno > TMAP->lno)
  1117.         return (1);
  1118.  
  1119.     /* Find the first occurence of the line. */
  1120.     for (p = HMAP; p->lno != sp->lno; ++p);
  1121.  
  1122.     /* Fill in the map information until we find the right line. */
  1123.     for (; p <= TMAP; ++p) {
  1124.         /* Short lines are common and easy to detect. */
  1125.         if (p != TMAP && (p + 1)->lno != p->lno) {
  1126.             *smpp = p;
  1127.             return (0);
  1128.         }
  1129.         if (!SMAP_CACHE(p) && vs_line(sp, p, NULL, NULL))
  1130.             return (1);
  1131.         if (p->c_eboff >= sp->cno) {
  1132.             *smpp = p;
  1133.             return (0);
  1134.         }
  1135.     }
  1136.  
  1137.     /* It was past the end of the map after all. */
  1138.     return (1);
  1139. }
  1140.  
  1141. /*
  1142.  * vs_sm_position --
  1143.  *    Return the line/column of the top, middle or last line on the screen.
  1144.  *    (The vi H, M and L commands.)  Here because only the screen routines
  1145.  *    know what's really out there.
  1146.  *
  1147.  * PUBLIC: int vs_sm_position __P((SCR *, MARK *, u_long, pos_t));
  1148.  */
  1149. int
  1150. vs_sm_position(sp, rp, cnt, pos)
  1151.     SCR *sp;
  1152.     MARK *rp;
  1153.     u_long cnt;
  1154.     pos_t pos;
  1155. {
  1156.     SMAP *smp;
  1157.     recno_t last;
  1158.  
  1159.     switch (pos) {
  1160.     case P_TOP:
  1161.         /*
  1162.          * !!!
  1163.          * Historically, an invalid count to the H command failed.
  1164.          * We do nothing special here, just making sure that H in
  1165.          * an empty screen works.
  1166.          */
  1167.         if (cnt > TMAP - HMAP)
  1168.             goto sof;
  1169.         smp = HMAP + cnt;
  1170.         if (cnt && !db_exist(sp, smp->lno)) {
  1171. sof:            msgq(sp, M_BERR, "220|Movement past the end-of-screen");
  1172.             return (1);
  1173.         }
  1174.         break;
  1175.     case P_MIDDLE:
  1176.         /*
  1177.          * !!!
  1178.          * Historically, a count to the M command was ignored.
  1179.          * If the screen isn't filled, find the middle of what's
  1180.          * real and move there.
  1181.          */
  1182.         if (!db_exist(sp, TMAP->lno)) {
  1183.             if (db_last(sp, &last))
  1184.                 return (1);
  1185.             for (smp = TMAP; smp->lno > last && smp > HMAP; --smp);
  1186.             if (smp > HMAP)
  1187.                 smp -= (smp - HMAP) / 2;
  1188.         } else
  1189.             smp = (HMAP + (TMAP - HMAP) / 2) + cnt;
  1190.         break;
  1191.     case P_BOTTOM:
  1192.         /*
  1193.          * !!!
  1194.          * Historically, an invalid count to the L command failed.
  1195.          * If the screen isn't filled, find the bottom of what's
  1196.          * real and try to offset from there.
  1197.          */
  1198.         if (cnt > TMAP - HMAP)
  1199.             goto eof;
  1200.         smp = TMAP - cnt;
  1201.         if (!db_exist(sp, smp->lno)) {
  1202.             if (db_last(sp, &last))
  1203.                 return (1);
  1204.             for (; smp->lno > last && smp > HMAP; --smp);
  1205.             if (cnt > smp - HMAP) {
  1206. eof:                msgq(sp, M_BERR,
  1207.                 "221|Movement past the beginning-of-screen");
  1208.                 return (1);
  1209.             }
  1210.             smp -= cnt;
  1211.         }
  1212.         break;
  1213.     default:
  1214.         abort();
  1215.     }
  1216.  
  1217.     /* Make sure that the cached information is valid. */
  1218.     if (!SMAP_CACHE(smp) && vs_line(sp, smp, NULL, NULL))
  1219.         return (1);
  1220.     rp->lno = smp->lno;
  1221.     rp->cno = smp->c_sboff;
  1222.  
  1223.     return (0);
  1224. }
  1225.  
  1226. /*
  1227.  * vs_sm_nlines --
  1228.  *    Return the number of screen lines from an SMAP entry to the
  1229.  *    start of some file line, less than a maximum value.
  1230.  *
  1231.  * PUBLIC: recno_t vs_sm_nlines __P((SCR *, SMAP *, recno_t, size_t));
  1232.  */
  1233. recno_t
  1234. vs_sm_nlines(sp, from_sp, to_lno, max)
  1235.     SCR *sp;
  1236.     SMAP *from_sp;
  1237.     recno_t to_lno;
  1238.     size_t max;
  1239. {
  1240.     recno_t lno, lcnt;
  1241.  
  1242.     if (O_ISSET(sp, O_LEFTRIGHT))
  1243.         return (from_sp->lno > to_lno ?
  1244.             from_sp->lno - to_lno : to_lno - from_sp->lno);
  1245.  
  1246.     if (from_sp->lno == to_lno)
  1247.         return (from_sp->soff - 1);
  1248.  
  1249.     if (from_sp->lno > to_lno) {
  1250.         lcnt = from_sp->soff - 1;    /* Correct for off-by-one. */
  1251.         for (lno = from_sp->lno; --lno >= to_lno && lcnt <= max;)
  1252.             lcnt += vs_screens(sp, lno, NULL);
  1253.     } else {
  1254.         lno = from_sp->lno;
  1255.         lcnt = (vs_screens(sp, lno, NULL) - from_sp->soff) + 1;
  1256.         for (; ++lno < to_lno && lcnt <= max;)
  1257.             lcnt += vs_screens(sp, lno, NULL);
  1258.     }
  1259.     return (lcnt);
  1260. }
  1261.