718 lines
15 KiB
C
718 lines
15 KiB
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)); }
|
|||
|
|
|
|||
|
|
/* 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));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* 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 */
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
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);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* 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 */
|
|||
|
|
|
|||
|
|
/* 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);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* 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 */
|
|||
|
|
}
|