pci: don't do sanity check for missing pci bus, the check can misfire.

[minix.git] / commands / elle / eefd.c

/* ELLE - Copyright 1982, 1987 by Ken Harrenstien, SRI International
 *      This software is quasi-public; it may be used freely with
 *      like software, but may NOT be sold or made part of licensed
 *      products without permission of the author.
 */

/* EEFD         Display control functions
 */

#include "elle.h"


#if FX_NEWWIN
/* EFUN: "New Window" */
/*      Clear current window and set as requested.
 *              ^L - clear current window and redisplay it (default top)
 *              <arg>^L - select new window so that current line is
 *                      the <arg>'th from top of window (0 = top line)
 *              ^U^L - clear current line and redisplay.
 */
f_newwin()
{       register int i, n;
        register struct window *w;

        d_fixcur();             /* Ensure screen vars correct */
        w = cur_win;
        if (exp_p)
          {     if((n = exp) == 4 && exp_p == 4         /* CTRL-U? */
                  && (i = d_line(cur_dot)) >= 0)        /* On valid line? */
                  {     d_lupd(w, i);                   /* Update it */
                        return;
                  }
          }
        else                    /* No argument given */
          {     redp(RD_SCREEN);        /* Clear whole screen (later just window? */
#if IMAGEN
                return;
#else
                n = (ev_nwpct*w->w_ht)/100;     /* Set new window using % */
#endif /*-IMAGEN*/
          }
        if (n < 0) n = 0;               /* Ensure # is reasonable */
        else if (n >= w->w_ht)
                n = w->w_ht - 1;
        d_fgoloff(-n);                  /* Go up given # of lines */
        w->w_topldot = e_dot();         /* Set new top-line dot */
        e_gocur();                      /* Move back to cur_dot */
        redp(RD_FIXWIN);                /* Say to re-hack window */
}
#endif /*FX_NEWWIN*/

#if FX_NSCREEN
/* EFUN: "Next Screen" */
f_nscreen()
{       d_screen( exp);
}
#endif /*FX_NSCREEN*/

#if FX_PSCREEN
/* EFUN: "Previous Screen" */
f_pscreen()
{       d_screen(-exp);
}
#endif /*FX_PSCREEN*/

#if FX_OTHNSCREEN
/* EFUN: "Other New Screen" (not EMACS) - from IMAGEN config */
f_othnscreen()
{
        if (! oth_win)
                return;
        f_othwind();
        if (exp_p)                      /* With arg, back up */
                d_screen(-1);
        else
                d_screen(1);
        f_othwind();
        redp(RD_WINDS);                 /* Look at all windows */
}
#endif /*FX_OTHNSCREEN*/


#if FX_LWINDBORD
/* EFUN: "Line to Window Border" (not EMACS) - from IMAGEN config */
f_lwindbord()
{
        if (exp_p)
                /* With arg, means "to bottom" */
                exp = cur_win->w_ht - 1;
        else
                /* Else, to top */
                exp = 0;

        /* Just a "front end" for ^L */
        exp_p = 1;
        f_newwin();
}
#endif /*FX_LWINDBORD*/

#if FX_SCUPWIND
/* EFUN: "Scroll Window Up" (not EMACS) - from IMAGEN config */
f_scupwind()
{
        scroll_win(exp);
}
#endif /*FX_SCUPWIND*/

#if FX_SCDNWIND
/* EFUN: "Scroll Window Down" (not EMACS) - from IMAGEN config */
f_scdnwind()
{
        scroll_win(-exp);
}
#endif /*FX_SCDNWIND*/


#if FX_MVWTOP
/* EFUN: "Move to Window Top" (not EMACS) - from IMAGEN config */
f_mvwtop()
{
        extern moveborder();
        moveborder(1);
}
#endif /*FX_MVWTOP*/

#if FX_MVWBOT
/* EFUN: "Move to Window Bottom" (not EMACS) - from IMAGEN config */
f_mvwbot()
{
        extern moveborder();
        moveborder(0);
}
#endif /*FX_MVWBOT*/


\f
#if FX_NSCREEN || FX_PSCREEN || FX_OTHNSCREEN
/* Move to new loc by N screenfuls.
 * If moving downward, keep bottom 2 lines of current screen on top of next.
 * If moving up, keep top 2 lines of current screen on bottom of next.
 */
d_screen(rep)
int rep;
{
        register int i;
        register struct window *w;
        chroff newdot;

        w = cur_win;
        if((i = w->w_ht - 2) <= 0)      /* Just-in-case check */
                i = 1;
        if((i *= rep) == 0)
                return;
        d_fixcur();                     /* Ensure window fixed up */
        e_go(w->w_topldot);             /* Start at top of screen */
        d_fgoloff(i);

        /* Find where we are now, and make that the new top of window. */
        if((newdot = e_dot()) != e_blen())      /* If not at EOF, */
                w->w_topldot = newdot;  /* set new top of window! */
        else w->w_topldot = 0;          /* Else let fix_wind select top. */

        e_setcur();                     /* Ensure cur_dot set to real loc */
#if IMAGEN
        redp(RD_WINRES|RD_REDO);        /* HINT: just repaint screen */
#else
        redp(RD_FIXWIN|RD_MOVE);
#endif /*-IMAGEN*/
}
#endif /*FX_NSCREEN || FX_PSCREEN || FX_OTHNSCREEN*/
\f
#if FX_SCUPWIND || FX_SCDNWIND  /* If want scroll-window function */
scroll_win(n)
register int n;
{       register struct window *w = cur_win;
        chroff savdot;

        if (n == 0) return;
        d_fixcur();             /* Ensure screen vars for win all set up */
        e_go(w->w_topldot);     /* Go to top of current window */
        d_fgoloff(n);           /* Move given # of display lines */
        w->w_topldot = e_dot(); /* Set new top of window */
        redp(RD_FIXWIN);        /* Say new window needs fixing up */

        /* Now adjust position of current dot so it is still within window */
        if (n > 0)
          {     /* Moving screen text "up" (win down) */
                if (cur_dot < w->w_topldot)     /* See if scrolled off top */
                        e_setcur();             /* yes, make dot be win top */
          }
        else {  /* Moving screen text "down" (win up) */
                savdot = cur_dot;       /* Save since must temporarily */
                e_setcur();             /* set current dot within window, */
                d_fixcur();             /* so screen can be fixed up. */
                if (inwinp(w, savdot))  /* Now see if old dot in new win */
                        cur_dot = savdot;       /* Yes, just restore it! */
                else                    /* No, make it beg of bottom line. */
                        cur_dot = scr[w->w_pos + w->w_ht - 1]->sl_boff;
          }
        e_gocur();              /* Make current pos be cur_dot */
}
#endif /* FX_SC%%WIND */

#if FX_MVWTOP || FX_MVWBOT      /* Guts for above two functions */
static
moveborder(top)
int top;
{
        d_fixcur();             /* Ensure current win screen image fixed up */
        e_gosetcur(top ? cur_win->w_topldot
                        : scr[cur_win->w_pos + cur_win->w_ht - 1]->sl_boff);

        redp(RD_MOVE);          /* Should only be cursor adjustment */
}
#endif /*FX_MVW%%%*/
\f
/* Given a line and a position in that line, return the xpos.
 * NOTE CAREFULLY that when line extends over several screen lines,
 * the value returned is the screen X position even though it
 * may be some lines down from the start of the logical line!
 * Also note this won't work very well if tabs exist on the extra
 * lines.  This rtn should not be used for cursor positioning.
 * Also note: d_ncols() will never return -1 meaning EOL because the
 * setup guarantees there is no EOL within the range checked.
 */
d_curind()      /* Find current indentation */
{       indtion(e_dot());
}
indtion(lin)
chroff lin;
{       register int i, col;
        chroff savdot;
        chroff nchars;

        savdot = e_dot();               /* Save current position */
        e_go(lin);                      /* Go to line caller wants */
        e_gobol();                      /* Go to its beginning */
        col = 0;                        /* Start at left margin */
        if((nchars = lin - e_dot()) > 0)
            do {
                if(nchars < (i = scr_wd0))
                        i = nchars;
                if((col = d_ncols(i, col)) < 0) /* Hit edge of screen? */
                        col = 0;                /* Reset to left margin */
            } while((nchars -= i) > 0);
        e_go(savdot);                   /* Restore current position */
        return(col);
}

/* ININDEX - How many positions in lin must we go to get to xpos?
 * Returns -1 if can't be done.  Assumes "lin" is at beginning of a line!
 */

inindex (lin, xpos)
chroff lin;
int   xpos;
{       register int col, x;
        chroff savdot;
        char tmp[MAXLINE+MAXCHAR];
        extern int sctreol;             /* From EEDISP */

        if((x = xpos) <= 0) return(0);
        if(x >= MAXLINE) return(-1);    /* ?!? */
        col = 0;
        savdot = e_dot();
        e_go(lin);                      /* Assumes this is start of line */
        col = sctrin(tmp, x, 0);        /* Translate from sb_getc input */
        if((col - x) >= 0)              /* Exact count-out or past it? */
          {     x = e_dot() - lin;      /* Yup, win. */
                if (sctreol > 0)        /* Did we hit (and include) EOL? */
#if FX_EOLMODE                  /* If so, back up over the EOL. */
                        x -= eolcrlf(cur_buf) ? 2 : 1;
#else
                        --x;
#endif
          }
        else x = -1;                    /* Nope, EOL or EOF hit too soon. */
        e_go(savdot);
        return(x);
}
\f
/*
 * D_ ROUTINES - display-relative functions.  Similar to E_, but
 *      a "line" is defined as one line of the screen rather than
 *      as a logical text line.  Also, for efficiency reasons
 *      arguments are given saying how many lines to hack.
 */

d_gopl() { return(d_goloff(-1)); }
d_gonl() { return(d_goloff( 1)); }

/* D_GOLOFF(i) - Go to beginning of a display line
 * D_FGOLOFF(i) - ditto, but assumes screen image of window already fixed up.
 *      i - # of lines offset.  Negative moves up, positive down.
 *              Zero arg goes to beginning of current display line.
 *      Side effects: screen image of window is fixed up at
 *      start of routine, but is NOT updated by the move to new location.
 */
d_goloff(cnt)
int cnt;
{       d_fixcur();
        d_fgoloff(cnt);         /* Now can invoke fixed-up fast version */
}
d_fgoloff(cnt)
register int cnt;
{       register int y;
        struct scr_line l;
        char line[MAXLINE+MAXCHAR];
        int top, bot;

        /* Find current position in window, since can save time
         * by using stuff already in fixed-up screen image.
         */
        if((y = d_line(e_dot())) < 0)           /* Get current Y position */
          {
                errbarf("Dot out of window");
                y = 0;
          }
        top = cur_win->w_pos;           /* 1st line of window */
        bot = top + cur_win->w_ht;      /* 1st line not in window */
        l.sl_boff = scr[y]->sl_boff;
        l.sl_nlin = &line[0];
        l.sl_cont = 0;

        if(cnt > 0) goto down;
        
        /* Go upwards.  This is hairy because we want to be clever about
         * huge logical lines -- avoid going all the way back to BOL.
         */
        if((y+cnt) >= top)      /* Fits? */
                goto onscr;     /* Hurray, hack it! */
        cnt += y - top;         /* Sigh, find # lines to skip */
        y = top;
        l.sl_boff = scr[y]->sl_boff;
        e_go(l.sl_boff);

        /* Okay, here's the hairy part.  Must go backwards from top
         * line; if no EOL within scr_wid*cnt chars, then simply assume one is
         * seen.
         */
        cnt = -cnt;
        d_backup(cnt);
        return;         /* Really should re-adjust stuff, but... */

        /* Go downwards.  Not too bad... */
down:
        if((y+cnt) <= bot)      /* Fits? */
                goto onscr;     /* Hurray, hack it! */
        cnt -= bot - y;         /* Sigh, find # lines can skip */
        y = bot - 1;
        l.sl_boff = scr[y]->sl_boff + scr[y]->sl_len;
        if(y > top
          && (l.sl_cont = scr[y-1]->sl_cont))
                l.sl_line = scr[y-1]->sl_line;
        e_go(l.sl_boff);

        do {
                fix_line(&l,&l);
          } while(--cnt > 0 && l.sl_len);
        return;

onscr:  if((y += cnt) >= bot)
          {     --y;
                e_go(scr[y]->sl_boff + scr[y]->sl_len);
          }
        else e_go(scr[y]->sl_boff);
}

/* D_FIXCUR() - Ensure current window is fixed up, with
 *      current location (not necessarily cur_dot)!
 * Ensure cur_dot reflects real loc so that fix_wind will work,
 * and always call fix_wind to ensure that screen image vars
 * are set properly.  Note any active redisplay flags must be carried
 * on into window redisplay flags, so fix_wind will notice them.
 */
d_fixcur()
{       register struct window *w;
        chroff savedot;

        w = cur_win;
        savedot = cur_dot;
        e_setcur();
        w->w_redp |= rd_type&RDS_WINFLGS;
        fix_wind(w);            /* Always ensure window is set up! */
        redp(w->w_redp);        /* Add back new flags */
        rd_type &= ~RDS_DOFIX;  /* and flush fix-invoking ones */
        cur_dot = savedot;      /* Restore cur_dot, no longer hacked. */
}
\f
d_backup(nlin)          /* Try to back up by nlin screen lines */
int nlin;
{       register int cnt, n, c;
        int eolstop;

        if((cnt = nlin+1) <= 0) return;
        c = 0;
        do
          {     n = scr_wid;
                eolstop = 0;            /* Not yet stopped at EOL */
                do {    if((c = e_rgetc()) == EOF)
                                return;
                        if(c == LF)
                          {
#if FX_EOLMODE
                                if(eolcrlf(cur_buf))
                                  {     if((c = e_rgetc()) == CR)
                                          {     eolstop++;
                                                break;
                                          }
                                        if(c != EOF)
                                                e_getc();
                                  }
                                else
#endif
                                  {     eolstop++;
                                        break;
                                  }
                          }
                  } while(--n);
          } while(--cnt);
        if(eolstop)
          {
#if FX_EOLMODE
                if(eolcrlf(cur_buf)) e_getc();  /* Skip back over CR */
#endif
                e_getc();               /* Skip back over LF */
          }

        /* At this point, dot is guaranteed to be less than goal,
         * which is the important thing for fix_wind, which can handle
         * things okay if dot is off bottom of window.
         */
        return(1);              /* Say always test result */
}