re-enable munmap().

[minix.git] / commands / elle / eeedit.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.
 */
/*      EEEDIT - E-type routines */

#include "elle.h"

/* E_   - Operate on cur_buf.  Do not change value of cur_dot unless
 *              unavoidable side effect (also e_setcur).
 * EX_  - Like E_ but take SB ptr value.  Never touch cur_dot.
 * ED_  - Like E_, operate on cur_buf, update cur_dot and display stuff.
 * D_   - Perform necessary display update for given operations.
 *
 * Note that "dot" refers to the current read/write pointer for a sbbuffer.
 * The name comes from EMACS/TECO where "." represents this value.
 */

#define CURSBB (SBBUF *)cur_buf         /* Shorthand for current SB buffer */

e_reset()       /* Reset current buffer */
{       ex_reset(CURSBB);
        cur_dot = 0;
}

/* Basic functions - apply SB routines to current buffer.
 * There is some optimization here which knows that certain SB functions
 * are macros.
 */
e_rgetc()       /* Read/move 1 char backward */
{       return(sb_rgetc((CURSBB)));
}
e_rdelc()       /* Delete 1 char backward */
{       return(sb_rdelc((CURSBB)));
}
e_delc()        /* Delete 1 char forward */
{       return(sb_deln(CURSBB,(chroff)1));
}
e_getc()        /* Read/move 1 char forward */
{       register SBBUF *sb;
        sb = CURSBB;            /* Macro: use reg */
        return(sb_getc(sb));
}
e_backc()       /* Move 1 char backward */
{       register SBBUF *sb;
        sb = CURSBB;            /* Macro: use reg */
        sb_backc(sb);                   /* No value returned */
}
e_putc(c)       /* Insert/write 1 char forward */
char c;
{       register SBBUF *sb;
        sb = CURSBB;            /* Macro: use reg */
        return(sb_putc(sb, c));
}
e_peekc()       /* Read 1 char forward (no move) */
{       register SBBUF *sb;
        sb = CURSBB;            /* Macro: use reg */
        return(sb_peekc(sb));
}
e_ovwc(ch)      /* Overwrite 1 char forward */
char ch;
{
        sb_setovw(CURSBB);      /* Turn on overwrite mode */
        e_putc(ch);
        sb_clrovw(CURSBB);      /* Turn off overwrite mode */
}

SBSTR *
e_copyn(off)    /* Copy N chars forward/backward, return SD to sbstring */
chroff off;
{       return(sb_cpyn(CURSBB,off));
}
e_deln(off)     /* Delete N chars forward/backward */
chroff off;
{       return(sb_deln(CURSBB, off));
}

/* E_SETCUR() - set cur_dot to current position (dot).  This is the only
 *      E_ routine that mungs cur_dot except for e_reset.
 */
e_setcur()
{       cur_dot = e_dot();
}
e_gosetcur(dot)         /* Go to specified dot and set cur_dot as well */
chroff dot;
{       sb_seek(CURSBB,dot,0);
        e_setcur();     /* Not cur_dot = dot since want canonicalization */
}

/* E_GO(dot) - Move to specified location. */
/* These "GO" routines all move to the location specified, returning
 *      0 if successful and -1 on error.  "cur_dot" is never changed,
 *      with the exception of e_gosetcur.
 * Note that other "GO" routines (eg E_GONL) will return 1 if successful
 *      and 0 if stopped by EOF.
 */

e_gocur() { return(e_go(cur_dot)); }            /* Move to cur_dot */
e_gobob() { return(e_go((chroff) 0)); }         /* Move to Beg Of Buffer */
e_goeob() { return(sb_seek(CURSBB,(chroff)0,2)); } /* Move to End Of Buffer */
e_go(dot)       /* Move to specified location. */
chroff dot;
{       return(sb_seek(CURSBB,dot,0));
}
e_igoff(ioff)   /* Move (int) N chars forward/backward */
int ioff;
{       return(sb_seek(CURSBB,(chroff)ioff,1));
}

e_goff(off)     /* Move (full) N chars forward/backward */
chroff off;
{       return(sb_seek(CURSBB,off,1));
}

int ex_gonl(), ex_gopl(), ex_gobol(), ex_goeol();

e_gobol() { return(ex_gobol(CURSBB)); } /* Move to beg of this line */
e_goeol() { return(ex_goeol(CURSBB)); } /* Move to end of this line */
e_gonl()  { return(ex_gonl(CURSBB)); }  /* Move to beg of next line */
e_gopl()  { return(ex_gopl(CURSBB)); }  /* Move to beg of prev line */


/* E_DOT() - Return current value of dot. */
chroff e_dot()   { return(sb_tell(CURSBB)); }           /* Current pos */
chroff e_nldot() { return(e_alldot(CURSBB,ex_gonl)); }  /* Beg of next line */
chroff e_pldot() { return(e_alldot(CURSBB,ex_gopl)); }  /* Beg of prev line */
chroff e_boldot(){ return(e_alldot(CURSBB,ex_gobol));}  /* Beg of this line */
chroff e_eoldot(){ return(e_alldot(CURSBB,ex_goeol));}  /* End of this line */

chroff
e_alldot(sbp,rtn)       /* Auxiliary for above stuff */
SBBUF *sbp;
int (*rtn)();
{       return(ex_alldot(sbp,rtn,e_dot()));
}

/* E_BLEN - Return length of current buffer */
chroff
e_blen() { return(ex_blen(CURSBB)); }
\f
/* EX_ routines - similar to E_ but take a buffer/sbbuf argument
 *      instead of assuming current buffer.
 */

/* EX_RESET - Reset a given buffer */
ex_reset(b)
struct buffer *b;
{       sbs_del(sb_close((SBBUF *)b));
        sb_open((SBBUF *)b,(SBSTR *)0);
}

ex_go(sbp,loc)          /* Move to given dot in specified sbbuf */
chroff loc;
SBBUF *sbp;
{       return(sb_seek(sbp,loc,0));
}

chroff
ex_dot(sbp)     /* Return current position in specified sbbuf */
SBBUF *sbp;
{
        return(sb_tell(sbp));
}


chroff
ex_boldot(sbp,dot)      /* Return dot for BOL of specified sbbuf */
SBBUF *sbp;
chroff dot;
{       return(ex_alldot(sbp,ex_gobol,dot));
}

chroff
ex_alldot(sbp,rtn,dot)  /* Auxiliary for some e_ stuff */
SBBUF *sbp;
int (*rtn)();
chroff dot;
{       register SBBUF *sb;
        chroff savloc, retloc;

        savloc = sb_tell(sb = sbp);
        sb_seek(sb,dot,0);
        (*rtn)(sb);
        retloc = sb_tell(sb);
        sb_seek(sb,savloc,0);
        return(retloc);
}

/* GO (forward) to Next Line of specified sbbuf - returns 0 if stopped at EOF
 * before an EOL is seen. */
ex_gonl(sbp)
SBBUF *sbp;
{       register SBBUF *sb;
        register int c;
        sb = sbp;
#if FX_EOLMODE
        if(eolcrlf(sb))
                while((c = sb_getc(sb)) != EOF)
                  {     if(c == LF)             /* Possible EOL? */
                          {     sb_backc(sb);   /* See if prev char was CR */
                                if((c = sb_rgetc(sb)) != EOF)
                                        sb_getc(sb);
                                sb_getc(sb);    /* Must restore position */
                                if(c == CR)     /* Now test for CR */
                                        return(1);      /* Won, CR-LF! */
                          }
                  }
        else
#endif
        while((c = sb_getc(sb)) != EOF)
                if(c == LF)
                        return(1);
        return(0);
}

/* GO (forward) to End Of Line of specified sbbuf - returns 0 if stopped at
 * EOF before an EOL is seen. */
ex_goeol(sbp)
SBBUF *sbp;
{       register SBBUF *sb;
        register int c;
        sb = sbp;
#if FX_EOLMODE
        if(eolcrlf(sb))
                while((c = sb_getc(sb)) != EOF)
                  {     if(c == LF)             /* Possible EOL? */
                          {     sb_backc(sb);   /* See if prev char was CR */
                                if((c = sb_rgetc(sb)) == CR)
                                        return(1);      /* Won, CR-LF! */
                                if(c != EOF)    /* No, must restore position */
                                        sb_getc(sb);    /* Skip over */
                                sb_getc(sb);            /* Skip over LF */
                          }
                  }
        else
#endif
        while((c = sb_getc(sb)) != EOF)
                if(c == LF)
                  {     sb_backc(sb);
                        return(1);
                  }
        return(0);
}

/* GO (backward) to Beg Of Line of specified sbbuf - returns 0 if stopped
 * at EOF
 */
ex_gobol(sbp)
SBBUF *sbp;
{       register SBBUF *sb;
        register int c;
        sb = sbp;
#if FX_EOLMODE
        if(eolcrlf(sb))
                while((c = sb_rgetc(sb)) != EOF)
                  {     if(c == LF)             /* Possible EOL? */
                          {     if((c = sb_rgetc(sb)) == CR)
                                  {     sb_getc(sb);    /* Won, CR-LF! */
                                        sb_getc(sb);    /* Move back */
                                        return(1);
                                  }
                                if(c != EOF)    /* No, must restore position */
                                        sb_getc(sb);    /* Undo the rgetc */
                          }
                  }
        else
#endif
        while((c = sb_rgetc(sb)) != EOF)
                if(c == LF)
                  {     sb_getc(sb);
                        return(1);
                  }
        return(0);
}

/* GO (backward) to Previous Line of specified sbbuf - returns 0 if stopped
 * at EOF before an EOL is seen (i.e. if already on 1st line of buffer)
 */
ex_gopl(sbp)
SBBUF *sbp;
{       register SBBUF *sb;
        register int c;
        sb = sbp;
#if FX_EOLMODE
        if(eolcrlf(sb))
                while((c = sb_rgetc(sb)) != EOF)
                  {     if(c == LF)             /* Possible EOL? */
                          {     if((c = sb_rgetc(sb)) == CR)
                                  {     ex_gobol(sb);
                                        return(1);              /* Won! */
                                  }
                                if(c != EOF)    /* No, must restore position */
                                        sb_getc(sb);    /* Undo the rgetc */
                          }
                  }
        else
#endif
        while((c = sb_rgetc(sb)) != EOF)
                if(c == LF)
                  {     ex_gobol(sb);
                        return(1);      /* Won! */
                  }
        return(0);
}


chroff
ex_blen(sbp)            /* Return length of specified sbbuf */
SBBUF *sbp;
{
        return(sb_tell(sbp)+sb_ztell(sbp));
}
\f
/* Miscellaneous stuff */

/* E_GOFWSP() - Forward over whitespace */
e_gofwsp()
{       register int c;
        while((c = e_getc()) == SP || c == TAB);
        if(c != EOF) e_backc();
}

/* E_GOBWSP() - Backward over whitespace */
e_gobwsp()
{       register int c;
        while((c = e_rgetc()) == SP || c == TAB);
        if(c != EOF) e_getc();
}


/* E_GOLINE(n) - Goes N lines forward (or backward).
**      If N == 0, goes to beginning of current line.
**      Returns 0 if hit EOF.
*/
e_goline(i)
register int i;
{
        if(i > 0)
          {     do { if(!e_gonl()) return(0); }
                while(--i);
          }
        else if(i < 0)
          {     i = -i;
                do { if(!e_gopl()) return(0); }
                while(--i);
          }
        else e_gobol();         /* arg of 0 */
        return 1;
}

/* E_LBLANKP() - Returns true if all characters in rest of line are blank.
 *      Moves to beginning of next line as side effect, unless fails.
 */
e_lblankp()
{       register int c;
        for(;;) switch(e_getc())
          {
                case SP:
                case TAB:
                        continue;
                case LF:        /* Normally drop thru to return 1 as for EOF */
#if FX_EOLMODE
                        if(eolcrlf(cur_buf))
                          {     e_rgetc();
                                if((c = e_rgetc()) != EOF) /* Get prev char */
                                        e_getc();
                                e_getc();
                                if(c != CR)             /* Now examine */
                                        continue;       /* Not CR-LF, go on */
                          }     /* Else drop thru to return win */
#endif
                case EOF:
                        return(1);
                default:
                        return(0);
          }
        /* Never drops out */
}
\f

e_insn(ch, cnt)
int ch;
int cnt;
{       register int i;
        if((i = cnt) > 0)
                do { e_putc(ch);
                  } while(--i);
}

e_sputz(acp)
char *acp;
{       register SBBUF *sb;
        register char *cp;
        register int c;
        if(cp = acp)
          {     sb = CURSBB;
                while(c = *cp++)
                        sb_putc(sb,c);
          }
}

/* BOLEQ - Returns TRUE if 2 dots are on the same line
 *      (i.e. have the same Beg-Of-Line)
 */
boleq(dot1,dot2)
chroff dot1,dot2;
{       return( (ex_boldot(CURSBB,dot1) == ex_boldot(CURSBB,dot2)));
}


char *
dottoa(str,val)
char *str;
chroff val;
{       register char *s;

        s = str;
        if(val < 0)
          {     *s++ = '-';
                val = -val;
          }
        if(val >= 10)
                s = dottoa(s, val/10);
        *s++ = '0' + (int)(val%10);
        *s = 0;
        return(s);
}

\f
/* Paragraph utilities */

#if FX_FPARA || FX_BPARA || FX_MRKPARA || FX_FILLPARA

#if FX_SFPREF
extern char *fill_prefix;       /* Defined in eefill.c for now */
extern int fill_plen;           /* Ditto */
#endif /*FX_SFPREF*/

#if ICONOGRAPHICS
int para_mode = PARABLOCK;      /* eexcmd.c only other file that refs this */
#endif /*ICONOGRAPHICS*/


/* Go to beginning of paragraph */
e_gobpa()
{       register int c;
        chroff savdot;

        savdot = e_dot();
        e_bwsp();
        while((c = e_rgetc()) != EOF)
                if(c == LF)             /* Went past line? */
                  {     e_getc();               /* Back up and check */
#if FX_SFPREF
                        if(fill_plen)
                                if(tstfillp(fill_plen))
                                  {     e_igoff(-(fill_plen+1));
                                        continue;
                                  }
                                else break;
#endif /*FX_SFPREF*/
#if ICONOGRAPHICS
                        c = e_peekc ();

                        if (para_mode == PARABLOCK)
                            if (c == LF)
                                break;

                        if (para_mode == PARALINE)
                            if (c_wsp (c))
                                break;
#else
                        if(c_pwsp(e_peekc()))   /* Check 1st chr for wsp */
                                break;          /* If wsp, done */
#endif /*ICONOGRAPHICS*/
                        e_rgetc();              /* Nope, continue */
                  }
        if((c = e_peekc()) == '.' || c == '-')
          {     e_gonl();
                if(e_dot() >= savdot)
                        e_gopl();
          }
}

/* Go to end of paragraph */
e_goepa()
{       register int c;

        e_gobol();                      /* First go to beg of cur line */
        e_fwsp();
        while((c = e_getc()) != EOF)
                if (c == LF)
                  {
#if FX_SFPREF
                if(fill_plen)           /* If Fill Prefix is defined */
                        if(tstfillp(fill_plen)) /* then must start with it */
                                continue;
                        else break;             /* or else we're done */
#endif /*FX_SFPREF*/
#if ICONOGRAPHICS
                if (para_mode == PARABLOCK)
                    if (e_peekc () == LF)
                        break;

                if (para_mode == PARALINE)
                    if (c_wsp (e_peekc ()))
                        break;
#else
                if(c_pwsp(e_peekc()))
                        break;
#endif /*-ICONOGRAPHICS*/
                  }
}

exp_do(rpos, rneg)
int (*rpos)(), (*rneg)();
{       register int e;
        register int (*rtn)();

        if((e = exp) == 0)
                return;
        rtn = rpos;
        if(e < 0)
          {     rtn = rneg;
                e = -e;
          }
        do { (*rtn)();
          } while(--e);
}


e_fwsp()
{       register int c;
        while(c_wsp(c = e_getc()));
        if(c != EOF) e_backc();
}
e_bwsp()
{       register int c;
        while(c_wsp(c = e_rgetc()));
        if(c != EOF) e_getc();
}


c_wsp(ch)
int ch;
{       register int c;
        c = ch;
        if(c == SP || c == TAB || c == LF || c == FF)
                return(1);
        return(0);
}
c_pwsp(ch)
int ch;
{       register int c;
        c = ch;
        if(c == '.' || c == '-')
                return(1);
        return(c_wsp(c));
}

#endif /* FX_FPARA || FX_BPARA || FX_MRKPARA || FX_FILLPARA */
\f
/* Word function auxiliaries */

/* Returns true if this character is a delimiter. */
delimp(c)
int  c;
{       static int  delim_tab[] =
          {
            0177777, 0177777,           /* All controls */
            0177777, 0176000,           /* All punct but 0-9 */
            0000001, 0074000,           /* All punct but A-Z and _ */
            0000001, 0174000            /* All punct but a-z */
          };
        return (delim_tab[c >> 4] & (1 << (c & 017)));
}

e_wding(adot,n)
register chroff *adot;
int n;
{       chroff savdot;
        savdot = e_dot();
        e_gowd(n);
        *adot = e_dot();
        e_go(savdot);
        if(*adot == savdot)
          {     ring_bell();
                return(0);
          }
        return(1);
}
chroff
e_wdot(dot,n)
chroff dot;
int n;
{       chroff savdot, retdot;
        savdot = e_dot();
        e_go(dot);
        e_gowd(n);
        retdot = e_dot();
        e_go(savdot);
        return(retdot);
}
e_gowd(n)
int n;
{       register int (*gch)(), c, cnt;
        int e_getc(), e_rgetc();
        chroff ret_dot;

        if((cnt = n) == 0)
                return;
        if(cnt > 0)
                gch = e_getc;           /* Forward routine */
        else
          {     gch = e_rgetc;          /* Backward routine */
                cnt = -cnt;
          }
        do
          {     ret_dot = e_dot();      /* Remember dot for last word found */
                while((c = (*gch)()) != EOF && delimp(c));
                if(c == EOF)
                  {     e_go(ret_dot);          /* Use last word found */
                        break;
                  }
                while((c = (*gch)()) != EOF && !delimp(c));
                if(c == EOF)
                        break;
                if(n < 0) e_getc(); else e_backc();
          } while(--cnt);
}
\f
/* Searching */

e_search(mstr,mlen,backwards)
char *mstr;
int mlen;
int backwards;
{       register SBBUF *sb;
        register char *cp;
        register int c;
        char *savcp;
        int cnt, scnt;
#if IMAGEN
        register int c1;
        register int caseless = (cur_buf->b_flags & B_TEXTMODE);
#endif /*IMAGEN*/

        sb = (SBBUF *) cur_buf;
        if (!backwards)
          {             /* Search forwards */
        sfwd:   cp = mstr;
                while((c = sb_getc(sb)) != EOF)
                  {
#if IMAGEN
                        if((!caseless && c != *cp) || 
                            (caseless && upcase(c) != upcase(*cp))) continue;
#else
                        if(c != *cp) continue;
#endif /*-IMAGEN*/
                        cp++;
                        cnt = mlen;
                        while(--cnt > 0)
                          {
#if IMAGEN
                                c1 = *cp++;
                                c = e_getc();
                                if ((!caseless && c1 != c) ||
                                     (caseless && upcase(c1) != upcase(c)))
#else
                                if(*cp++ != (c = e_getc()))
#endif /*-IMAGEN*/
                                  {     if(c == EOF) return(0);
                                        sb_seek(sb,(chroff)(cnt-mlen),1);
                                        goto sfwd;
                                  }
                          }
                        return(1);
                  }
          }
        else
          {             /* Search backwards */
                scnt = mlen - 1;
                savcp = mstr + scnt;            /* Point to end of string */

        sbck:   cp = savcp;
                while((c = sb_rgetc(sb)) != EOF)
                  {
#if IMAGEN
                        if((!caseless && c != *cp) || 
                            (caseless && upcase(c) != upcase(*cp))) continue;
#else
                        if(c != *cp) continue;
#endif /*-IMAGEN*/
                        cp--;
                        if((cnt = scnt) == 0) return(1);
                        do
                          {
#if IMAGEN
                                c1 = *cp--;
                                c = e_rgetc();
                                if ((!caseless && c1 != c) ||
                                     (caseless && upcase(c1) != upcase(c)))
#else
                                if(*cp-- != (c = e_rgetc()))
#endif /*-IMAGEN*/
                                  {     if(c == EOF) return(0);
                                        sb_seek(sb,(chroff)(mlen-cnt),1);
                                        goto sbck;
                                  }
                          }
                        while(--cnt);
                        return(1);
                  }
          }
        return(0);              /* Failed */
}