From 731317961dd78a8a6a84be2b662b9691fcf40d5a Mon Sep 17 00:00:00 2001 From: "Todd C. Miller" Date: Thu, 13 Apr 2000 06:12:19 +0000 Subject: The start of KNF + -Wall. The code has been run through indent but needs hand fixup. I stopped at keymap.c... --- usr.bin/mg/README | 13 +- usr.bin/mg/basic.c | 265 ++++---- usr.bin/mg/buffer.c | 537 ++++++++-------- usr.bin/mg/chrdef.h | 88 +-- usr.bin/mg/cinfo.c | 217 +++---- usr.bin/mg/def.h | 454 +++++++++----- usr.bin/mg/dir.c | 28 +- usr.bin/mg/dired.c | 320 +++++----- usr.bin/mg/display.c | 756 ++++++++++++----------- usr.bin/mg/echo.c | 847 ++++++++++++++------------ usr.bin/mg/extend.c | 1063 +++++++++++++++++--------------- usr.bin/mg/file.c | 405 +++++++------ usr.bin/mg/fileio.c | 731 +++++++++++----------- usr.bin/mg/help.c | 450 ++++++++------ usr.bin/mg/kbd.c | 541 +++++++++-------- usr.bin/mg/kbd.h | 81 ++- usr.bin/mg/key.h | 8 +- usr.bin/mg/keymap.c | 1581 ++++++++++++++++++++++++------------------------ usr.bin/mg/line.c | 328 +++++----- usr.bin/mg/macro.c | 106 ++-- usr.bin/mg/macro.h | 16 +- usr.bin/mg/main.c | 126 ++-- usr.bin/mg/match.c | 141 +++-- usr.bin/mg/modes.c | 202 ++++--- usr.bin/mg/paragraph.c | 170 +++--- usr.bin/mg/random.c | 247 ++++---- usr.bin/mg/re_search.c | 838 ++++++++++++------------- usr.bin/mg/region.c | 139 +++-- usr.bin/mg/search.c | 294 +++++---- usr.bin/mg/spawn.c | 1 + usr.bin/mg/sysdef.h | 26 +- usr.bin/mg/tty.c | 221 ++++--- usr.bin/mg/ttydef.h | 17 +- usr.bin/mg/ttyio.c | 18 +- usr.bin/mg/ttykbd.c | 16 +- usr.bin/mg/version.c | 9 +- usr.bin/mg/window.c | 173 +++--- usr.bin/mg/word.c | 73 +-- 38 files changed, 6221 insertions(+), 5325 deletions(-) (limited to 'usr.bin/mg') diff --git a/usr.bin/mg/README b/usr.bin/mg/README index e37a3c26b06..3b6f8d4f1d6 100644 --- a/usr.bin/mg/README +++ b/usr.bin/mg/README @@ -18,18 +18,15 @@ copyright restrictions.) The Mg authors individually may or may not agree with the opinions expressed by Richard Stallman in "The GNU Manifesto". -To avoid GNU copyright restrictions, replace the re_search.c, regex.h -and regex.c files with empty files. - Documentation of Mg is in the TeX file mg.tex. This should be -formatted with the TeX text formatter and printed. A start twords a mg -programmers guied in in mgprog.doc, and some of the changes from 1b +formatted with the TeX text formatter and printed. A start twords a +mg programmers guide is in mgprog.doc, and some of the changes from 1b are mentioned briefly in mg2a.change. This program is intended to be a small, fast, and portable editor for -people who can't (or don't want to) run real Emacs thing for one -reason or another. It is compatible with GNU because there shouldn't -be any reason to learn more than one Emacs flavor. We have excised +people who can't (or don't want to) run real Emacs for one reason +or another. It is compatible with GNU because there shouldn't be +any reason to learn more than one Emacs flavor. We have excised most MicroEMACS features that were incompatible with the big brother, and added missing features that seemed essential. diff --git a/usr.bin/mg/basic.c b/usr.bin/mg/basic.c index c4095800c0d..990f395a616 100644 --- a/usr.bin/mg/basic.c +++ b/usr.bin/mg/basic.c @@ -7,17 +7,19 @@ * mark. Only moves between lines, which might make the * current buffer framing bad, are hard. */ -#include "def.h" +#include "def.h" -VOID setgoal(); +VOID setgoal __P((void)); /* * Go to beginning of line. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int gotobol(f, n) + int f, n; { - curwp->w_doto = 0; + curwp->w_doto = 0; return (TRUE); } @@ -27,22 +29,24 @@ gotobol(f, n) * 0. Error if you try to move back from * the beginning of the buffer. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int backchar(f, n) -register int n; + int n; { - register LINE *lp; + LINE *lp; - if (n < 0) return forwchar(f, -n); + if (n < 0) + return forwchar(f, -n); while (n--) { if (curwp->w_doto == 0) { - if ((lp=lback(curwp->w_dotp)) == curbp->b_linep) { + if ((lp = lback(curwp->w_dotp)) == curbp->b_linep) { if (!(f & FFRAND)) ewprintf("Beginning of buffer"); return (FALSE); } - curwp->w_dotp = lp; - curwp->w_doto = llength(lp); + curwp->w_dotp = lp; + curwp->w_doto = llength(lp); curwp->w_flag |= WFMOVE; } else curwp->w_doto--; @@ -53,10 +57,12 @@ register int n; /* * Go to end of line. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int gotoeol(f, n) + int f, n; { - curwp->w_doto = llength(curwp->w_dotp); + curwp->w_doto = llength(curwp->w_dotp); return (TRUE); } @@ -66,21 +72,24 @@ gotoeol(f, n) * 0. Error if you try to move forward * from the end of the buffer. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int forwchar(f, n) -register int n; + int f, n; { - if (n < 0) return backchar(f, -n); + + if (n < 0) + return backchar(f, -n); while (n--) { if (curwp->w_doto == llength(curwp->w_dotp)) { - curwp->w_dotp = lforw(curwp->w_dotp); + curwp->w_dotp = lforw(curwp->w_dotp); if (curwp->w_dotp == curbp->b_linep) { curwp->w_dotp = lback(curwp->w_dotp); if (!(f & FFRAND)) ewprintf("End of buffer"); return FALSE; } - curwp->w_doto = 0; + curwp->w_doto = 0; curwp->w_flag |= WFMOVE; } else curwp->w_doto++; @@ -93,11 +102,14 @@ register int n; * buffer. Setting WFHARD is conservative, * but almost always the case. */ +int gotobob(f, n) + int f, n; { - (VOID) setmark(f, n) ; - curwp->w_dotp = lforw(curbp->b_linep); - curwp->w_doto = 0; + + (VOID) setmark(f, n); + curwp->w_dotp = lforw(curbp->b_linep); + curwp->w_doto = 0; curwp->w_flag |= WFHARD; return TRUE; } @@ -107,11 +119,14 @@ gotobob(f, n) * Setting WFHARD is conservative, but * almost always the case. */ +int gotoeob(f, n) + int f, n; { - (VOID) setmark(f, n) ; - curwp->w_dotp = lback(curbp->b_linep); - curwp->w_doto = llength(curwp->w_dotp); + + (VOID) setmark(f, n); + curwp->w_dotp = lback(curbp->b_linep); + curwp->w_doto = llength(curwp->w_dotp); curwp->w_flag |= WFHARD; return TRUE; } @@ -123,37 +138,42 @@ gotoeob(f, n) * actually do it. The last command controls how * the goal column is set. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int forwline(f, n) + int f, n; { - register LINE *dlp; + LINE *dlp; if (n < 0) - return backline(f|FFRAND, -n); - if ((lastflag&CFCPCN) == 0) /* Fix goal. */ + return backline(f | FFRAND, -n); + if ((lastflag & CFCPCN) == 0) /* Fix goal. */ setgoal(); thisflag |= CFCPCN; - if (n == 0) return TRUE; + if (n == 0) + return TRUE; dlp = curwp->w_dotp; - while (dlp!=curbp->b_linep && n--) + while (dlp != curbp->b_linep && n--) dlp = lforw(dlp); curwp->w_flag |= WFMOVE; - if(dlp==curbp->b_linep) { /* ^N at end of buffer creates lines (like gnu) */ - if(!(curbp->b_flag&BFCHG)) { /* first change */ + if (dlp == curbp->b_linep) { /* ^N at end of buffer creates lines + * (like gnu) */ + if (!(curbp->b_flag & BFCHG)) { /* first change */ curbp->b_flag |= BFCHG; curwp->w_flag |= WFMODE; } curwp->w_doto = 0; - while(n-- >= 0) { - if((dlp = lallocx(0)) == NULL) return FALSE; + while (n-- >= 0) { + if ((dlp = lallocx(0)) == NULL) + return FALSE; dlp->l_fp = curbp->b_linep; dlp->l_bp = lback(dlp->l_fp); dlp->l_bp->l_fp = dlp->l_fp->l_bp = dlp; } curwp->w_dotp = lback(curbp->b_linep); } else { - curwp->w_dotp = dlp; - curwp->w_doto = getgoal(dlp); + curwp->w_dotp = dlp; + curwp->w_doto = getgoal(dlp); } return TRUE; } @@ -165,36 +185,38 @@ forwline(f, n) * call your alternate. Figure out the new line and * call "movedot" to perform the motion. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int backline(f, n) + int f, n; { - register LINE *dlp; + LINE *dlp; - if (n < 0) return forwline(f|FFRAND, -n); - if ((lastflag&CFCPCN) == 0) /* Fix goal. */ + if (n < 0) + return forwline(f | FFRAND, -n); + if ((lastflag & CFCPCN) == 0) /* Fix goal. */ setgoal(); thisflag |= CFCPCN; dlp = curwp->w_dotp; - while (n-- && lback(dlp)!=curbp->b_linep) + while (n-- && lback(dlp) != curbp->b_linep) dlp = lback(dlp); - curwp->w_dotp = dlp; - curwp->w_doto = getgoal(dlp); + curwp->w_dotp = dlp; + curwp->w_doto = getgoal(dlp); curwp->w_flag |= WFMOVE; return TRUE; } /* - * Set the current goal column, - * which is saved in the external variable "curgoal", - * to the current cursor column. The column is never off - * the edge of the screen; it's more like display then - * show position. + * Set the current goal column, which is saved in the external variable + * "curgoal", to the current cursor column. The column is never off + * the edge of the screen; it's more like display then show position. */ VOID -setgoal() { +setgoal() +{ - curgoal = getcolpos() - 1; /* Get the position. */ -/* we can now display past end of display, don't chop! */ + curgoal = getcolpos() - 1; /* Get the position. */ + /* we can now display past end of display, don't chop! */ } /* @@ -204,11 +226,14 @@ setgoal() { * routine above) and returns the best offset to use * when a vertical motion is made into the line. */ -getgoal(dlp) register LINE *dlp; { - register int c; - register int col; - register int newcol; - register int dbo; +int +getgoal(dlp) + LINE *dlp; +{ + int c; + int col; + int newcol; + int dbo; col = 0; dbo = 0; @@ -217,10 +242,10 @@ getgoal(dlp) register LINE *dlp; { newcol = col; if (c == '\t' #ifdef NOTAB - && !(curbp->b_flag & BFNOTAB) + && !(curbp->b_flag & BFNOTAB) #endif ) - newcol |= 0x07; + newcol |= 0x07; else if (ISCTRL(c) != FALSE) ++newcol; ++newcol; @@ -240,32 +265,34 @@ getgoal(dlp) register LINE *dlp; { * the window is zapped, we have to do a hard * update and get it back. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int forwpage(f, n) -register int n; + int f, n; { - register LINE *lp; + LINE *lp; if (!(f & FFARG)) { - n = curwp->w_ntrows - 2; /* Default scroll. */ - if (n <= 0) /* Forget the overlap */ - n = 1; /* if tiny window. */ + n = curwp->w_ntrows - 2; /* Default scroll. */ + if (n <= 0) /* Forget the overlap */ + n = 1; /* if tiny window. */ } else if (n < 0) - return backpage(f|FFRAND, -n); + return backpage(f | FFRAND, -n); #ifdef CVMVAS - else /* Convert from pages */ - n *= curwp->w_ntrows; /* to lines. */ + else /* Convert from pages */ + n *= curwp->w_ntrows; /* to lines. */ #endif lp = curwp->w_linep; - while (n-- && lforw(lp)!=curbp->b_linep) + while (n-- && lforw(lp) != curbp->b_linep) lp = lforw(lp); curwp->w_linep = lp; curwp->w_flag |= WFHARD; /* if in current window, don't move dot */ - for(n = curwp->w_ntrows; n-- && lp!=curbp->b_linep; lp = lforw(lp)) - if(lp==curwp->w_dotp) return TRUE; - curwp->w_dotp = curwp->w_linep; - curwp->w_doto = 0; + for (n = curwp->w_ntrows; n-- && lp != curbp->b_linep; lp = lforw(lp)) + if (lp == curwp->w_dotp) + return TRUE; + curwp->w_dotp = curwp->w_linep; + curwp->w_doto = 0; return TRUE; } @@ -277,58 +304,64 @@ register int n; * hard update is done because the top line in * the window is zapped. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int backpage(f, n) -register int n; + int f, n; { - register LINE *lp; + LINE *lp; if (!(f & FFARG)) { - n = curwp->w_ntrows - 2; /* Default scroll. */ - if (n <= 0) /* Don't blow up if the */ - n = 1; /* window is tiny. */ + n = curwp->w_ntrows - 2; /* Default scroll. */ + if (n <= 0) /* Don't blow up if the */ + n = 1; /* window is tiny. */ } else if (n < 0) - return forwpage(f|FFRAND, -n); + return forwpage(f | FFRAND, -n); #ifdef CVMVAS - else /* Convert from pages */ - n *= curwp->w_ntrows; /* to lines. */ + else /* Convert from pages */ + n *= curwp->w_ntrows; /* to lines. */ #endif lp = curwp->w_linep; - while (n-- && lback(lp)!=curbp->b_linep) + while (n-- && lback(lp) != curbp->b_linep) lp = lback(lp); curwp->w_linep = lp; curwp->w_flag |= WFHARD; /* if in current window, don't move dot */ - for(n = curwp->w_ntrows; n-- && lp!=curbp->b_linep; lp = lforw(lp)) - if(lp==curwp->w_dotp) return TRUE; + for (n = curwp->w_ntrows; n-- && lp != curbp->b_linep; lp = lforw(lp)) + if (lp == curwp->w_dotp) + return TRUE; curwp->w_dotp = curwp->w_linep; curwp->w_doto = 0; return TRUE; } -/* These functions are provided for compatibility with Gosling's Emacs. - * They are used to scroll the display up (or down) one line at a time. +/* + * These functions are provided for compatibility with Gosling's Emacs. They + * are used to scroll the display up (or down) one line at a time. */ - #ifdef GOSMACS +VOID forw1page(f, n) -int f, n; + int f, n; { - if (!(f & FFARG)) { - n = 1; + + if (!(f & FFARG)) { + n = 1; f = FFUNIV; } - forwpage(f|FFRAND, n); + forwpage(f | FFRAND, n); } +VOID back1page(f, n) -int f, n; + int f, n; { + if (!(f & FFARG)) { - n = 1; + n = 1; f = FFUNIV; } - backpage(f|FFRAND, n); + backpage(f | FFRAND, n); } #endif @@ -336,9 +369,11 @@ int f, n; * Page the other window. Check to make sure it exists, then * nextwind, forwpage and restore window pointers. */ +int pagenext(f, n) + int f, n; { - register MGWIN *wp; + MGWIN *wp; if (wheadp->w_wndp == NULL) { ewprintf("No other window"); @@ -358,6 +393,7 @@ pagenext(f, n) VOID isetmark() { + curwp->w_markp = curwp->w_dotp; curwp->w_marko = curwp->w_doto; } @@ -367,9 +403,12 @@ isetmark() * to the value of dot. A message is written to * the echo line. (ewprintf knows about macros) */ -/*ARGSUSED*/ +/* ARGSUSED */ +int setmark(f, n) + int f, n; { + isetmark(); ewprintf("Mark set"); return TRUE; @@ -382,11 +421,13 @@ setmark(f, n) * that moves the mark about. The only possible * error is "no mark". */ -/*ARGSUSED*/ +/* ARGSUSED */ +int swapmark(f, n) + int f, n; { - register LINE *odotp; - register int odoto; + LINE *odotp; + int odoto; if (curwp->w_markp == NULL) { ewprintf("No mark in this window"); @@ -394,8 +435,8 @@ swapmark(f, n) } odotp = curwp->w_dotp; odoto = curwp->w_doto; - curwp->w_dotp = curwp->w_markp; - curwp->w_doto = curwp->w_marko; + curwp->w_dotp = curwp->w_markp; + curwp->w_doto = curwp->w_marko; curwp->w_markp = odotp; curwp->w_marko = odoto; curwp->w_flag |= WFMOVE; @@ -409,30 +450,32 @@ swapmark(f, n) * it is the line number, else prompt for a line number * to use. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int gotoline(f, n) -register int n; + int f, n; { - register LINE *clp; - register int s; - char buf[32]; + LINE *clp; + int s; + char buf[32]; if (!(f & FFARG)) { - if ((s=ereply("Goto line: ", buf, sizeof(buf))) != TRUE) + if ((s = ereply("Goto line: ", buf, sizeof(buf))) != TRUE) return s; n = atoi(buf); } - if (n > 0) { - clp = lforw(curbp->b_linep); /* "clp" is first line */ + clp = lforw(curbp->b_linep); /* "clp" is first line */ while (--n > 0) { - if (lforw(clp) == curbp->b_linep) break; + if (lforw(clp) == curbp->b_linep) + break; clp = lforw(clp); } } else { clp = lback(curbp->b_linep); /* clp is last line */ while (n < 0) { - if (lback(clp) == curbp->b_linep) break; + if (lback(clp) == curbp->b_linep) + break; clp = lback(clp); n++; } diff --git a/usr.bin/mg/buffer.c b/usr.bin/mg/buffer.c index 6f0f920fee2..a795506369b 100644 --- a/usr.bin/mg/buffer.c +++ b/usr.bin/mg/buffer.c @@ -2,9 +2,10 @@ * Buffer handling. */ #include "def.h" -#include "kbd.h" /* needed for modes */ +#include "kbd.h" /* needed for modes */ -static RSIZE itor(); +static RSIZE itor __P((char *, int, RSIZE)); +static BUFFER *makelist __P((void)); /* * Attach a buffer to a window. The values of dot and mark come @@ -12,56 +13,67 @@ static RSIZE itor(); * from some other window. *scratch* is the default alternate * buffer. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int usebuffer(f, n) + int f, n; { - register BUFFER *bp; - register int s; - char bufn[NBUFN]; + BUFFER *bp; + int s; + char bufn[NBUFN]; /* Get buffer to use from user */ if ((curbp->b_altb == NULL) && ((curbp->b_altb = bfind("*scratch*", TRUE)) == NULL)) - s=eread("Switch to buffer: ", bufn, NBUFN, EFNEW|EFBUF); + s = eread("Switch to buffer: ", bufn, NBUFN, EFNEW | EFBUF); else - s=eread("Switch to buffer: (default %s) ", bufn, NBUFN, - EFNEW|EFBUF, curbp->b_altb->b_bname); - - if (s == ABORT) return s; - if (s == FALSE && curbp->b_altb != NULL) bp = curbp->b_altb ; - else if ((bp=bfind(bufn, TRUE)) == NULL) return FALSE; + s = eread("Switch to buffer: (default %s) ", bufn, NBUFN, + EFNEW | EFBUF, curbp->b_altb->b_bname); + + if (s == ABORT) + return s; + if (s == FALSE && curbp->b_altb != NULL) + bp = curbp->b_altb; + else if ((bp = bfind(bufn, TRUE)) == NULL) + return FALSE; /* and put it in current window */ curbp = bp; - return showbuffer(bp, curwp, WFFORCE|WFHARD); + return showbuffer(bp, curwp, WFFORCE | WFHARD); } /* * pop to buffer asked for by the user. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int poptobuffer(f, n) + int f, n; { - register BUFFER *bp; - register MGWIN *wp; - register int s; - char bufn[NBUFN]; - MGWIN *popbuf(); + BUFFER *bp; + MGWIN *wp; + int s; + char bufn[NBUFN]; + MGWIN *popbuf(); /* Get buffer to use from user */ if ((curbp->b_altb == NULL) && ((curbp->b_altb = bfind("*scratch*", TRUE)) == NULL)) - s=eread("Switch to buffer in other window: ", bufn, NBUFN, - EFNEW|EFBUF); + s = eread("Switch to buffer in other window: ", bufn, NBUFN, + EFNEW | EFBUF); else - s=eread("Switch to buffer in other window: (default %s) ", - bufn, NBUFN, EFNEW|EFBUF, curbp->b_altb->b_bname); - if (s == ABORT) return s; - if (s == FALSE && curbp->b_altb != NULL) bp = curbp->b_altb ; - else if ((bp=bfind(bufn, TRUE)) == NULL) return FALSE; + s = eread("Switch to buffer in other window: (default %s) ", + bufn, NBUFN, EFNEW | EFBUF, curbp->b_altb->b_bname); + if (s == ABORT) + return s; + if (s == FALSE && curbp->b_altb != NULL) + bp = curbp->b_altb; + else if ((bp = bfind(bufn, TRUE)) == NULL) + return FALSE; /* and put it in a new window */ - if ((wp = popbuf(bp)) == NULL) return FALSE; + if ((wp = popbuf(bp)) == NULL) + return FALSE; curbp = bp; curwp = wp; return TRUE; @@ -74,49 +86,58 @@ poptobuffer(f, n) * if the buffer has been changed). Then free the header * line and the buffer header. Bound to "C-X K". */ -/*ARGSUSED*/ +/* ARGSUSED */ +int killbuffer(f, n) + int f, n; { - register BUFFER *bp; - register BUFFER *bp1; - register BUFFER *bp2; - MGWIN *wp; - register int s; - char bufn[NBUFN]; - - if ((s=eread("Kill buffer: (default %s) ", bufn, NBUFN, EFNEW|EFBUF, - curbp->b_bname)) == ABORT) return (s); - else if (s == FALSE) bp = curbp; - else if ((bp=bfind(bufn, FALSE)) == NULL) return FALSE; - - /* find some other buffer to display. try the alternate buffer, - * then the first different buffer in the buffer list. if - * there's only one buffer, create buffer *scratch* and make - * it the alternate buffer. return if *scratch* is only buffer + BUFFER *bp; + BUFFER *bp1; + BUFFER *bp2; + MGWIN *wp; + int s; + char bufn[NBUFN]; + + if ((s = eread("Kill buffer: (default %s) ", bufn, NBUFN, EFNEW | EFBUF, + curbp->b_bname)) == ABORT) + return (s); + else if (s == FALSE) + bp = curbp; + else if ((bp = bfind(bufn, FALSE)) == NULL) + return FALSE; + + /* + * Find some other buffer to display. try the alternate buffer, + * then the first different buffer in the buffer list. If there's + * only one buffer, create buffer *scratch* and make it the alternate + * buffer. Return if *scratch* is only buffer... */ if ((bp1 = bp->b_altb) == NULL) { bp1 = (bp == bheadp) ? bp->b_bufp : bheadp; if (bp1 == NULL) { /* only one buffer. see if it's *scratch* */ - if (bp == bfind("*scratch*",FALSE)) + if (bp == bfind("*scratch*", FALSE)) return FALSE; /* create *scratch* for alternate buffer */ - if ((bp1 = bfind("*scratch*",TRUE)) == NULL) + if ((bp1 = bfind("*scratch*", TRUE)) == NULL) return FALSE; } } - if (bclear(bp) != TRUE) return TRUE; + if (bclear(bp) != TRUE) + return TRUE; for (wp = wheadp; bp->b_nwnd > 0; wp = wp->w_wndp) { - if (wp->w_bufp == bp) { - bp2 = bp1->b_altb; /* save alternate buffer */ - if(showbuffer(bp1, wp, WFMODE|WFFORCE|WFHARD) != NULL) - bp1->b_altb = bp2; - else bp1 = bp2; - } + if (wp->w_bufp == bp) { + bp2 = bp1->b_altb; /* save alternate buffer */ + if (showbuffer(bp1, wp, WFMODE | WFFORCE | WFHARD)) + bp1->b_altb = bp2; + else + bp1 = bp2; + } } - if (bp == curbp) curbp = bp1; - free((char *) bp->b_linep); /* Release header line. */ - bp2 = NULL; /* Find the header. */ + if (bp == curbp) + curbp = bp1; + free(bp->b_linep); /* Release header line. */ + bp2 = NULL; /* Find the header. */ bp1 = bheadp; while (bp1 != bp) { if (bp1->b_altb == bp) @@ -124,28 +145,32 @@ killbuffer(f, n) bp2 = bp1; bp1 = bp1->b_bufp; } - bp1 = bp1->b_bufp; /* Next one in chain. */ - if (bp2 == NULL) /* Unlink it. */ + bp1 = bp1->b_bufp; /* Next one in chain. */ + if (bp2 == NULL) /* Unlink it. */ bheadp = bp1; else bp2->b_bufp = bp1; - while (bp1 != NULL) { /* Finish with altb's */ + while (bp1 != NULL) { /* Finish with altb's */ if (bp1->b_altb == bp) bp1->b_altb = (bp->b_altb == bp1) ? NULL : bp->b_altb; bp1 = bp1->b_bufp; } - free(bp->b_bname); /* Release name block */ - free((char *) bp); /* Release buffer block */ + free(bp->b_bname); /* Release name block */ + free(bp); /* Release buffer block */ return TRUE; } /* * Save some buffers - just call anycb with the arg flag. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int savebuffers(f, n) + int f, n; { - if (anycb(f) == ABORT) return ABORT; + + if (anycb(f) == ABORT) + return ABORT; return TRUE; } @@ -156,17 +181,17 @@ savebuffers(f, n) * then pops the data onto the screen. Bound to * "C-X C-B". */ -/*ARGSUSED*/ +/* ARGSUSED */ +int listbuffers(f, n) + int f, n; { - register BUFFER *bp; - register MGWIN *wp; - BUFFER *makelist(); - MGWIN *popbuf(); + BUFFER *bp; + MGWIN *wp; - if ((bp=makelist()) == NULL || (wp=popbuf(bp)) == NULL) + if ((bp = makelist()) == NULL || (wp = popbuf(bp)) == NULL) return FALSE; - wp->w_dotp = bp->b_dotp; /* fix up if window already on screen */ + wp->w_dotp = bp->b_dotp;/* fix up if window already on screen */ wp->w_doto = bp->b_doto; return TRUE; } @@ -177,150 +202,167 @@ listbuffers(f, n) * everything works. Return FALSE if there * is an error (if there is no memory). */ -BUFFER * -makelist() { - register char *cp1; - register char *cp2; - register int c; - register BUFFER *bp; - LINE *lp; - register RSIZE nbytes; - BUFFER *blp; - char b[6+1]; - char line[128]; - - if ((blp = bfind("*Buffer List*", TRUE)) == NULL) return NULL; - if (bclear(blp) != TRUE) return NULL; - blp->b_flag &= ~BFCHG; /* Blow away old. */ +static BUFFER * +makelist() +{ + char *cp1; + char *cp2; + int c; + BUFFER *bp; + LINE *lp; + RSIZE nbytes; + BUFFER *blp; + char b[6 + 1]; + char line[128]; + + if ((blp = bfind("*Buffer List*", TRUE)) == NULL) + return NULL; + if (bclear(blp) != TRUE) + return NULL; + blp->b_flag &= ~BFCHG; /* Blow away old. */ (VOID) strcpy(line, " MR Buffer"); cp1 = line + 10; - while(cp1 < line + 4 + NBUFN + 1) *cp1++ = ' '; + while (cp1 < line + 4 + NBUFN + 1) + *cp1++ = ' '; (VOID) strcpy(cp1, "Size File"); - if (addline(blp, line) == FALSE) return NULL; + if (addline(blp, line) == FALSE) + return NULL; (VOID) strcpy(line, " -- ------"); cp1 = line + 10; - while(cp1 < line + 4 + NBUFN + 1) *cp1++ = ' '; + while (cp1 < line + 4 + NBUFN + 1) + *cp1++ = ' '; (VOID) strcpy(cp1, "---- ----"); - if (addline(blp, line) == FALSE) return NULL; - bp = bheadp; /* For all buffers */ + if (addline(blp, line) == FALSE) + return NULL; + bp = bheadp; /* For all buffers */ while (bp != NULL) { - cp1 = &line[0]; /* Start at left edge */ + cp1 = &line[0]; /* Start at left edge */ *cp1++ = (bp == curbp) ? '.' : ' '; - *cp1++ = ((bp->b_flag&BFCHG) != 0) ? '*' : ' '; - *cp1++ = ' '; /* Gap. */ + *cp1++ = ((bp->b_flag & BFCHG) != 0) ? '*' : ' '; + *cp1++ = ' '; /* Gap. */ *cp1++ = ' '; - cp2 = &bp->b_bname[0]; /* Buffer name */ + cp2 = &bp->b_bname[0]; /* Buffer name */ while ((c = *cp2++) != 0) *cp1++ = c; - while (cp1 < &line[4+NBUFN+1]) + while (cp1 < &line[4 + NBUFN + 1]) *cp1++ = ' '; - nbytes = 0; /* Count bytes in buf. */ + nbytes = 0; /* Count bytes in buf. */ if (bp != blp) { lp = lforw(bp->b_linep); while (lp != bp->b_linep) { - nbytes += llength(lp)+1; + nbytes += llength(lp) + 1; lp = lforw(lp); } - if(nbytes) nbytes--; /* no bonus newline */ + if (nbytes) + nbytes--; /* no bonus newline */ } (VOID) itor(b, 6, nbytes); /* 6 digit buffer size. */ cp2 = &b[0]; while ((c = *cp2++) != 0) *cp1++ = c; - *cp1++ = ' '; /* Gap.. */ - cp2 = &bp->b_fname[0]; /* File name */ + *cp1++ = ' '; /* Gap.. */ + cp2 = &bp->b_fname[0]; /* File name */ if (*cp2 != 0) { while ((c = *cp2++) != 0) { - if (cp1 < &line[128-1]) + if (cp1 < &line[128 - 1]) *cp1++ = c; } } - *cp1 = 0; /* Add to the buffer. */ + *cp1 = 0; /* Add to the buffer. */ if (addline(blp, line) == FALSE) return NULL; bp = bp->b_bufp; } - blp->b_dotp = lforw(blp->b_linep); /* put dot at beginning of buffer */ + blp->b_dotp = lforw(blp->b_linep); /* put dot at beginning of + * buffer */ blp->b_doto = 0; - return blp; /* All done */ + return blp; /* All done */ } /* * Used above. */ -static RSIZE itor(buf, width, num) -register char buf[]; register int width; register RSIZE num; { - register RSIZE r; +static RSIZE +itor(buf, width, num) + char *buf; + int width; + RSIZE num; +{ + RSIZE r; if (num / 10 == 0) { buf[0] = (num % 10) + '0'; - for (r = 1; r < width; buf[r++] = ' ') - ; + for (r = 1; r < width; buf[r++] = ' '); buf[width] = '\0'; return 1; } else { - buf[r = itor(buf, width, num / (RSIZE)10)] = - (num % (RSIZE)10) + '0'; + buf[r = itor(buf, width, num / (RSIZE) 10)] = + (num % (RSIZE) 10) + '0'; return r + 1; } - /*NOTREACHED*/ + /* NOTREACHED */ } /* - * The argument "text" points to - * a string. Append this line to the - * buffer. Handcraft the EOL - * on the end. Return TRUE if it worked and + * The argument "text" points to a string. Append this line to the + * buffer. Handcraft the EOL on the end. Return TRUE if it worked and * FALSE if you ran out of room. */ -addline(bp, text) register BUFFER *bp; char *text; { - register LINE *lp; - register int i; - register int ntext; +int +addline(bp, text) + BUFFER *bp; + char *text; +{ + LINE *lp; + int i; + int ntext; ntext = strlen(text); - if ((lp=lalloc(ntext)) == NULL) + if ((lp = lalloc(ntext)) == NULL) return FALSE; - for (i=0; ib_linep->l_bp->l_fp = lp; /* Hook onto the end */ + bp->b_linep->l_bp->l_fp = lp; /* Hook onto the end */ lp->l_bp = bp->b_linep->l_bp; bp->b_linep->l_bp = lp; lp->l_fp = bp->b_linep; #ifdef CANTHAPPEN - if (bp->b_dotp == bp->b_linep) /* If "." is at the end */ - bp->b_dotp = lp; /* move it to new line */ - if (bp->b_markp == bp->b_linep) /* ditto for mark */ + if (bp->b_dotp == bp->b_linep) /* If "." is at the end */ + bp->b_dotp = lp; /* move it to new line */ + if (bp->b_markp == bp->b_linep) /* ditto for mark */ bp->b_markp = lp; #endif return TRUE; } /* - * Look through the list of buffers, giving the user - * a chance to save them. Return TRUE if there are - * any changed buffers afterwards. Buffers that don't - * have an associated file don't count. Return FALSE - * if there are no changed buffers. + * Look through the list of buffers, giving the user a chance to save them. + * Return TRUE if there are any changed buffers afterwards. Buffers that + * don't have an associated file don't count. Return FALSE if there are + * no changed buffers. */ -anycb(f) { - register BUFFER *bp; - register int s = FALSE, save = FALSE; - char prompt[NFILEN + 11]; - VOID upmodes(); +int +anycb(f) + int f; +{ + BUFFER *bp; + int s = FALSE, save = FALSE; + char prompt[NFILEN + 11]; for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { if (*(bp->b_fname) != '\0' - && (bp->b_flag&BFCHG) != 0) { + && (bp->b_flag & BFCHG) != 0) { (VOID) strcpy(prompt, "Save file "); (VOID) strcpy(prompt + 10, bp->b_fname); if ((f == TRUE || (save = eyorn(prompt)) == TRUE) - && buffsave(bp) == TRUE) { + && buffsave(bp) == TRUE) { bp->b_flag &= ~BFCHG; upmodes(bp); - } else s = TRUE; - if (save == ABORT) return (save); + } else + s = TRUE; + if (save == ABORT) + return (save); save = TRUE; } } @@ -336,15 +378,17 @@ anycb(f) { * all buffers. Return pointer to the BUFFER * block for the buffer. */ -BUFFER * -bfind(bname, cflag) register char *bname; { - register BUFFER *bp; - char *malloc(); - register LINE *lp; - int i; - extern int defb_nmodes; - extern MAPS *defb_modes[PBMODES]; - extern int defb_flag; +BUFFER * +bfind(bname, cflag) + char *bname; + int cflag; +{ + BUFFER *bp; + LINE *lp; + int i; + extern int defb_nmodes; + extern MAPS *defb_modes[PBMODES]; + extern int defb_flag; bp = bheadp; while (bp != NULL) { @@ -352,14 +396,15 @@ bfind(bname, cflag) register char *bname; { return bp; bp = bp->b_bufp; } - if (cflag!=TRUE) return NULL; - /*NOSTRICT*/ - if ((bp=(BUFFER *)malloc(sizeof(BUFFER))) == NULL) { + if (cflag != TRUE) + return NULL; + /* NOSTRICT */ + if ((bp = (BUFFER *) malloc(sizeof(BUFFER))) == NULL) { ewprintf("Can't get %d bytes", sizeof(BUFFER)); return NULL; } - if ((bp->b_bname=malloc((unsigned)(strlen(bname)+1))) == NULL) { - ewprintf("Can't get %d bytes", strlen(bname)+1); + if ((bp->b_bname = malloc((strlen(bname) + 1))) == NULL) { + ewprintf("Can't get %d bytes", strlen(bname) + 1); free((char *) bp); return NULL; } @@ -368,19 +413,19 @@ bfind(bname, cflag) register char *bname; { free((char *) bp); return NULL; } - bp->b_altb = bp->b_bufp = NULL; - bp->b_dotp = lp; - bp->b_doto = 0; + bp->b_altb = bp->b_bufp = NULL; + bp->b_dotp = lp; + bp->b_doto = 0; bp->b_markp = NULL; bp->b_marko = 0; - bp->b_flag = defb_flag; - bp->b_nwnd = 0; + bp->b_flag = defb_flag; + bp->b_nwnd = 0; bp->b_linep = lp; bp->b_nmodes = defb_nmodes; i = 0; do { - bp->b_modes[i] = defb_modes[i]; - } while(i++ < defb_nmodes); + bp->b_modes[i] = defb_modes[i]; + } while (i++ < defb_nmodes); bp->b_fname[0] = '\0'; bzero(&bp->b_fi, sizeof(bp->b_fi)); (VOID) strcpy(bp->b_bname, bname); @@ -401,20 +446,22 @@ bfind(bname, cflag) register char *bname; { * that are required. Return TRUE if everything * looks good. */ -bclear(bp) register BUFFER *bp; { - register LINE *lp; - register int s; - VOID lfree(); +int +bclear(bp) + BUFFER *bp; +{ + LINE *lp; + int s; - if ((bp->b_flag&BFCHG) != 0 /* Changed. */ - && (s=eyesno("Buffer modified; kill anyway")) != TRUE) + if ((bp->b_flag & BFCHG) != 0 /* Changed. */ + && (s = eyesno("Buffer modified; kill anyway")) != TRUE) return (s); - bp->b_flag &= ~BFCHG; /* Not changed */ - while ((lp=lforw(bp->b_linep)) != bp->b_linep) + bp->b_flag &= ~BFCHG; /* Not changed */ + while ((lp = lforw(bp->b_linep)) != bp->b_linep) lfree(lp); - bp->b_dotp = bp->b_linep; /* Fix "." */ - bp->b_doto = 0; - bp->b_markp = NULL; /* Invalidate "mark" */ + bp->b_dotp = bp->b_linep; /* Fix "." */ + bp->b_doto = 0; + bp->b_markp = NULL; /* Invalidate "mark" */ bp->b_marko = 0; return TRUE; } @@ -423,44 +470,47 @@ bclear(bp) register BUFFER *bp; { * Display the given buffer in the given window. Flags indicated * action on redisplay. */ -showbuffer(bp, wp, flags) register BUFFER *bp; register MGWIN *wp; { - register BUFFER *obp; - MGWIN *owp; +int +showbuffer(bp, wp, flags) + BUFFER *bp; + MGWIN *wp; + int flags; +{ + BUFFER *obp; + MGWIN *owp; - if (wp->w_bufp == bp) { /* Easy case! */ + if (wp->w_bufp == bp) { /* Easy case! */ wp->w_flag |= flags; return TRUE; } - /* First, dettach the old buffer from the window */ if ((bp->b_altb = obp = wp->w_bufp) != NULL) { if (--obp->b_nwnd == 0) { - obp->b_dotp = wp->w_dotp; - obp->b_doto = wp->w_doto; + obp->b_dotp = wp->w_dotp; + obp->b_doto = wp->w_doto; obp->b_markp = wp->w_markp; obp->b_marko = wp->w_marko; } } - /* Now, attach the new buffer to the window */ wp->w_bufp = bp; - if (bp->b_nwnd++ == 0) { /* First use. */ - wp->w_dotp = bp->b_dotp; - wp->w_doto = bp->b_doto; + if (bp->b_nwnd++ == 0) { /* First use. */ + wp->w_dotp = bp->b_dotp; + wp->w_doto = bp->b_doto; wp->w_markp = bp->b_markp; wp->w_marko = bp->b_marko; } else - /* already on screen, steal values from other window */ + /* already on screen, steal values from other window */ for (owp = wheadp; owp != NULL; owp = wp->w_wndp) if (wp->w_bufp == bp && owp != wp) { - wp->w_dotp = owp->w_dotp; - wp->w_doto = owp->w_doto; + wp->w_dotp = owp->w_dotp; + wp->w_doto = owp->w_doto; wp->w_markp = owp->w_markp; wp->w_marko = owp->w_marko; break; } - wp->w_flag |= WFMODE|flags; + wp->w_flag |= WFMODE | flags; return TRUE; } @@ -469,71 +519,81 @@ showbuffer(bp, wp, flags) register BUFFER *bp; register MGWIN *wp; { * Returns a status. */ MGWIN * -popbuf(bp) register BUFFER *bp; { - register MGWIN *wp; +popbuf(bp) + BUFFER *bp; +{ + MGWIN *wp; - if (bp->b_nwnd == 0) { /* Not on screen yet. */ - if ((wp=wpopup()) == NULL) return NULL; + if (bp->b_nwnd == 0) { /* Not on screen yet. */ + if ((wp = wpopup()) == NULL) + return NULL; } else for (wp = wheadp; wp != NULL; wp = wp->w_wndp) if (wp->w_bufp == bp) { - wp->w_flag |= WFHARD|WFFORCE; - return wp ; + wp->w_flag |= WFHARD | WFFORCE; + return wp; } - if (showbuffer(bp, wp, WFHARD) != TRUE) return NULL; + if (showbuffer(bp, wp, WFHARD) != TRUE) + return NULL; return wp; } /* * Insert another buffer at dot. Very useful. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int bufferinsert(f, n) { - register BUFFER *bp; - register LINE *clp; - register int clo; - register int nline; - int s; - char bufn[NBUFN]; + BUFFER *bp; + LINE *clp; + int clo; + int nline; + int s; + char bufn[NBUFN]; /* Get buffer to use from user */ if (curbp->b_altb != NULL) - s=eread("Insert buffer: (default %s) ", bufn, NBUFN, - EFNEW|EFBUF, &(curbp->b_altb->b_bname), - (char *) NULL) ; + s = eread("Insert buffer: (default %s) ", bufn, NBUFN, + EFNEW | EFBUF, &(curbp->b_altb->b_bname), + (char *) NULL); else - s=eread("Insert buffer: ", bufn, NBUFN, EFNEW|EFBUF, - (char *) NULL) ; - if (s == ABORT) return (s); - if (s == FALSE && curbp->b_altb != NULL) bp = curbp->b_altb; - else if ((bp=bfind(bufn, FALSE)) == NULL) return FALSE; + s = eread("Insert buffer: ", bufn, NBUFN, EFNEW | EFBUF, + (char *) NULL); + if (s == ABORT) + return (s); + if (s == FALSE && curbp->b_altb != NULL) + bp = curbp->b_altb; + else if ((bp = bfind(bufn, FALSE)) == NULL) + return FALSE; - if (bp==curbp) { + if (bp == curbp) { ewprintf("Cannot insert buffer into self"); return FALSE; } - /* insert the buffer */ nline = 0; clp = lforw(bp->b_linep); - for(;;) { + for (;;) { for (clo = 0; clo < llength(clp); clo++) if (linsert(1, lgetc(clp, clo)) == FALSE) return FALSE; - if((clp = lforw(clp)) == bp->b_linep) break; - if (newline(FFRAND, 1) == FALSE) /* fake newline */ + if ((clp = lforw(clp)) == bp->b_linep) + break; + if (newline(FFRAND, 1) == FALSE) /* fake newline */ return FALSE; nline++; } - if (nline == 1) ewprintf("[Inserted 1 line]"); - else ewprintf("[Inserted %d lines]", nline); + if (nline == 1) + ewprintf("[Inserted 1 line]"); + else + ewprintf("[Inserted %d lines]", nline); - clp = curwp->w_linep; /* cosmetic adjustment */ - if (curwp->w_dotp == clp) { /* for offscreen insert */ - while (nline-- && lback(clp)!=curbp->b_linep) + clp = curwp->w_linep; /* cosmetic adjustment */ + if (curwp->w_dotp == clp) { /* for offscreen insert */ + while (nline-- && lback(clp) != curbp->b_linep) clp = lback(clp); - curwp->w_linep = clp; /* adjust framing. */ + curwp->w_linep = clp; /* adjust framing. */ curwp->w_flag |= WFHARD; } return (TRUE); @@ -542,13 +602,14 @@ bufferinsert(f, n) /* * Turn off the dirty bit on this buffer. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int notmodified(f, n) { - register MGWIN *wp; + MGWIN *wp; curbp->b_flag &= ~BFCHG; - wp = wheadp; /* Update mode lines. */ + wp = wheadp; /* Update mode lines. */ while (wp != NULL) { if (wp->w_bufp == curbp) wp->w_flag |= WFMODE; @@ -563,22 +624,22 @@ notmodified(f, n) * Popbuf and set all windows to top of buffer. Currently only used by * help functions. */ - +int popbuftop(bp) -register BUFFER *bp; + BUFFER *bp; { - register MGWIN *wp; + MGWIN *wp; - bp->b_dotp = lforw(bp->b_linep); - bp->b_doto = 0; - if(bp->b_nwnd != 0) { - for(wp = wheadp; wp!=NULL; wp = wp->w_wndp) - if(wp->w_bufp == bp) { - wp->w_dotp = bp->b_dotp; - wp->w_doto = 0; - wp->w_flag |= WFHARD; - } - } - return popbuf(bp) != NULL; + bp->b_dotp = lforw(bp->b_linep); + bp->b_doto = 0; + if (bp->b_nwnd != 0) { + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) + if (wp->w_bufp == bp) { + wp->w_dotp = bp->b_dotp; + wp->w_doto = 0; + wp->w_flag |= WFHARD; + } + } + return popbuf(bp) != NULL; } #endif diff --git a/usr.bin/mg/chrdef.h b/usr.bin/mg/chrdef.h index 6c2f2f3180f..4b4c386f0ec 100644 --- a/usr.bin/mg/chrdef.h +++ b/usr.bin/mg/chrdef.h @@ -1,14 +1,14 @@ /* - * sys/default/chardef.h: character set specific #defines for mg 2a + * sys/default/chardef.h: character set specific #defines for Mg 2a * Warning: System specific ones exist */ -#ifndef CHARMASK /* - * casting should be at least as efficent as anding with 0xff, + * Casting should be at least as efficent as anding with 0xff, * and won't have the size problems. Override in sysdef.h if no * unsigned char type. */ +#ifndef CHARMASK #define CHARMASK(c) ((unsigned char) (c)) #endif @@ -18,12 +18,12 @@ * understand the DEC multinational set, and let me ask * a slightly different set of questions. */ -#define _W 0x01 /* Word. */ -#define _U 0x02 /* Upper case letter. */ -#define _L 0x04 /* Lower case letter. */ -#define _C 0x08 /* Control. */ -#define _P 0x10 /* end of sentence punctuation */ -#define _D 0x20 /* is decimal digit */ +#define _W 0x01 /* Word. */ +#define _U 0x02 /* Upper case letter. */ +#define _L 0x04 /* Lower case letter. */ +#define _C 0x08 /* Control. */ +#define _P 0x10 /* end of sentence punctuation */ +#define _D 0x20 /* is decimal digit */ #define ISWORD(c) ((cinfo[CHARMASK(c)]&_W)!=0) #define ISCTRL(c) ((cinfo[CHARMASK(c)]&_C)!=0) @@ -35,45 +35,45 @@ #define TOLOWER(c) ((c)+0x20) /* - * generally useful thing for chars + * Generally useful thing for chars */ #define CCHR(x) ((x) ^ 0x40) /* CCHR('?') == DEL */ #ifndef METACH -#define METACH CCHR('[') +#define METACH CCHR('[') #endif -#ifdef XKEYS -#define K00 256 -#define K01 257 -#define K02 258 -#define K03 259 -#define K04 260 -#define K05 261 -#define K06 262 -#define K07 263 -#define K08 264 -#define K09 265 -#define K0A 266 -#define K0B 267 -#define K0C 268 -#define K0D 269 -#define K0E 270 -#define K0F 271 -#define K10 272 -#define K11 273 -#define K12 274 -#define K13 275 -#define K14 276 -#define K15 277 -#define K16 278 -#define K17 279 -#define K18 280 -#define K19 281 -#define K1A 282 -#define K1B 283 -#define K1C 284 -#define K1D 285 -#define K1E 286 -#define K1F 287 +#ifdef XKEYS +#define K00 256 +#define K01 257 +#define K02 258 +#define K03 259 +#define K04 260 +#define K05 261 +#define K06 262 +#define K07 263 +#define K08 264 +#define K09 265 +#define K0A 266 +#define K0B 267 +#define K0C 268 +#define K0D 269 +#define K0E 270 +#define K0F 271 +#define K10 272 +#define K11 273 +#define K12 274 +#define K13 275 +#define K14 276 +#define K15 277 +#define K16 278 +#define K17 279 +#define K18 280 +#define K19 281 +#define K1A 282 +#define K1B 283 +#define K1C 284 +#define K1D 285 +#define K1E 286 +#define K1F 287 #endif diff --git a/usr.bin/mg/cinfo.c b/usr.bin/mg/cinfo.c index 163017e0e07..8b342f915bf 100644 --- a/usr.bin/mg/cinfo.c +++ b/usr.bin/mg/cinfo.c @@ -15,71 +15,71 @@ * character set, and lets me ask some questions that the * standard "ctype" macros cannot ask. */ -char cinfo[256] = { - _C, _C, _C, _C, /* 0x0X */ - _C, _C, _C, _C, - _C, _C, _C, _C, - _C, _C, _C, _C, - _C, _C, _C, _C, /* 0x1X */ - _C, _C, _C, _C, - _C, _C, _C, _C, - _C, _C, _C, _C, - 0, _P, 0, 0, /* 0x2X */ - _W, _W, 0, _W, - 0, 0, 0, 0, - 0, 0, _P, 0, - _D|_W, _D|_W, _D|_W, _D|_W, /* 0x3X */ - _D|_W, _D|_W, _D|_W, _D|_W, - _D|_W, _D|_W, 0, 0, - 0, 0, 0, _P, - 0, _U|_W, _U|_W, _U|_W, /* 0x4X */ - _U|_W, _U|_W, _U|_W, _U|_W, - _U|_W, _U|_W, _U|_W, _U|_W, - _U|_W, _U|_W, _U|_W, _U|_W, - _U|_W, _U|_W, _U|_W, _U|_W, /* 0x5X */ - _U|_W, _U|_W, _U|_W, _U|_W, - _U|_W, _U|_W, _U|_W, 0, - 0, 0, 0, 0, - 0, _L|_W, _L|_W, _L|_W, /* 0x6X */ - _L|_W, _L|_W, _L|_W, _L|_W, - _L|_W, _L|_W, _L|_W, _L|_W, - _L|_W, _L|_W, _L|_W, _L|_W, - _L|_W, _L|_W, _L|_W, _L|_W, /* 0x7X */ - _L|_W, _L|_W, _L|_W, _L|_W, - _L|_W, _L|_W, _L|_W, 0, - 0, 0, 0, _C, - 0, 0, 0, 0, /* 0x8X */ - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, /* 0x9X */ - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, /* 0xAX */ - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, /* 0xBX */ - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, - _U|_W, _U|_W, _U|_W, _U|_W, /* 0xCX */ - _U|_W, _U|_W, _U|_W, _U|_W, - _U|_W, _U|_W, _U|_W, _U|_W, - _U|_W, _U|_W, _U|_W, _U|_W, - 0, _U|_W, _U|_W, _U|_W, /* 0xDX */ - _U|_W, _U|_W, _U|_W, _U|_W, - _U|_W, _U|_W, _U|_W, _U|_W, - _U|_W, _U|_W, 0, _W, - _L|_W, _L|_W, _L|_W, _L|_W, /* 0xEX */ - _L|_W, _L|_W, _L|_W, _L|_W, - _L|_W, _L|_W, _L|_W, _L|_W, - _L|_W, _L|_W, _L|_W, _L|_W, - 0, _L|_W, _L|_W, _L|_W, /* 0xFX */ - _L|_W, _L|_W, _L|_W, _L|_W, - _L|_W, _L|_W, _L|_W, _L|_W, - _L|_W, _L|_W, 0, 0 +char cinfo[256] = { + _C, _C, _C, _C, /* 0x0X */ + _C, _C, _C, _C, + _C, _C, _C, _C, + _C, _C, _C, _C, + _C, _C, _C, _C, /* 0x1X */ + _C, _C, _C, _C, + _C, _C, _C, _C, + _C, _C, _C, _C, + 0, _P, 0, 0, /* 0x2X */ + _W, _W, 0, _W, + 0, 0, 0, 0, + 0, 0, _P, 0, + _D | _W, _D | _W, _D | _W, _D | _W, /* 0x3X */ + _D | _W, _D | _W, _D | _W, _D | _W, + _D | _W, _D | _W, 0, 0, + 0, 0, 0, _P, + 0, _U | _W, _U | _W, _U | _W, /* 0x4X */ + _U | _W, _U | _W, _U | _W, _U | _W, + _U | _W, _U | _W, _U | _W, _U | _W, + _U | _W, _U | _W, _U | _W, _U | _W, + _U | _W, _U | _W, _U | _W, _U | _W, /* 0x5X */ + _U | _W, _U | _W, _U | _W, _U | _W, + _U | _W, _U | _W, _U | _W, 0, + 0, 0, 0, 0, + 0, _L | _W, _L | _W, _L | _W, /* 0x6X */ + _L | _W, _L | _W, _L | _W, _L | _W, + _L | _W, _L | _W, _L | _W, _L | _W, + _L | _W, _L | _W, _L | _W, _L | _W, + _L | _W, _L | _W, _L | _W, _L | _W, /* 0x7X */ + _L | _W, _L | _W, _L | _W, _L | _W, + _L | _W, _L | _W, _L | _W, 0, + 0, 0, 0, _C, + 0, 0, 0, 0, /* 0x8X */ + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, /* 0x9X */ + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, /* 0xAX */ + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, /* 0xBX */ + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + _U | _W, _U | _W, _U | _W, _U | _W, /* 0xCX */ + _U | _W, _U | _W, _U | _W, _U | _W, + _U | _W, _U | _W, _U | _W, _U | _W, + _U | _W, _U | _W, _U | _W, _U | _W, + 0, _U | _W, _U | _W, _U | _W, /* 0xDX */ + _U | _W, _U | _W, _U | _W, _U | _W, + _U | _W, _U | _W, _U | _W, _U | _W, + _U | _W, _U | _W, 0, _W, + _L | _W, _L | _W, _L | _W, _L | _W, /* 0xEX */ + _L | _W, _L | _W, _L | _W, _L | _W, + _L | _W, _L | _W, _L | _W, _L | _W, + _L | _W, _L | _W, _L | _W, _L | _W, + 0, _L | _W, _L | _W, _L | _W, /* 0xFX */ + _L | _W, _L | _W, _L | _W, _L | _W, + _L | _W, _L | _W, _L | _W, _L | _W, + _L | _W, _L | _W, 0, 0 }; /* @@ -87,49 +87,62 @@ char cinfo[256] = { * characters and function keys better. Returns a pointer to the terminating * '\0'. */ - -char *keyname(cp, k) -register char *cp; -register int k; +char * +keyname(cp, k) + char *cp; + int k; { - register char *np; -#ifdef FKEYS - extern char *keystrings[]; -#endif + char *np; - if(k < 0) k = CHARMASK(k); /* sign extended char */ - switch(k) { - case CCHR('@'): np = "NUL"; break; - case CCHR('I'): np = "TAB"; break; - case CCHR('J'): np = "LFD"; break; /* yuck, but that's what GNU calls it */ - case CCHR('M'): np = "RET"; break; - case CCHR('['): np = "ESC"; break; - case ' ': np = "SPC"; break; /* yuck again */ - case CCHR('?'): np = "DEL"; break; + if (k < 0) + k = CHARMASK(k);/* sign extended char */ + switch (k) { + case CCHR('@'): + np = "NUL"; + break; + case CCHR('I'): + np = "TAB"; + break; + case CCHR('J'): + np = "LFD"; + break; /* yuck, but that's what GNU calls it */ + case CCHR('M'): + np = "RET"; + break; + case CCHR('['): + np = "ESC"; + break; + case ' ': + np = "SPC"; + break; /* yuck again */ + case CCHR('?'): + np = "DEL"; + break; default: #ifdef FKEYS - if(k >= KFIRST && k <= KLAST && + if (k >= KFIRST && k <= KLAST && (np = keystrings[k - KFIRST]) != NULL) - break; + break; #endif - if(k > CCHR('?')) { - *cp++ = '0'; - *cp++ = ((k>>6)&7) + '0'; - *cp++ = ((k>>3)&7) + '0'; - *cp++ = (k&7) + '0'; + if (k > CCHR('?')) { + *cp++ = '0'; + *cp++ = ((k >> 6) & 7) + '0'; + *cp++ = ((k >> 3) & 7) + '0'; + *cp++ = (k & 7) + '0'; + *cp = '\0'; + return cp; + } + if (k < ' ') { + *cp++ = 'C'; + *cp++ = '-'; + k = CCHR(k); + if (ISUPPER(k)) + k = TOLOWER(k); + } + *cp++ = k; *cp = '\0'; return cp; - } - if(k < ' ') { - *cp++ = 'C'; - *cp++ = '-'; - k = CCHR(k); - if(ISUPPER(k)) k = TOLOWER(k); - } - *cp++ = k; - *cp = '\0'; - return cp; - } - (VOID) strcpy(cp, np); - return cp + strlen(cp); + } + (VOID) strcpy(cp, np); + return cp + strlen(cp); } diff --git a/usr.bin/mg/def.h b/usr.bin/mg/def.h index bf8acb24b8b..57ce809edb9 100644 --- a/usr.bin/mg/def.h +++ b/usr.bin/mg/def.h @@ -1,13 +1,13 @@ /* * This file is the general header file for all parts - * of the MicroEMACS display editor. It contains all of the + * of the Mg display editor. It contains all of the * general definitions and macros. It also contains some * conditional compilation flags. All of the per-system and * per-terminal definitions are in special header files. * The most common reason to edit this file would be to zap * the definition of CVMVAS or BACKUP. */ -#include "sysdef.h" /* Order is critical. */ +#include "sysdef.h" /* Order is critical. */ #include "ttydef.h" #include "chrdef.h" @@ -22,43 +22,43 @@ */ #ifdef NO_VOID_TYPE -# undef VOID -# define VOID int /* Default for no void is int */ +#undef VOID +#define VOID int /* Default for no void is int */ #else #ifndef VOID -# define VOID void /* Just use normal void */ -#endif /* VOID */ -#endif /* NO_VOID_TYPE */ +#define VOID void /* Just use normal void */ +#endif /* VOID */ +#endif /* NO_VOID_TYPE */ #ifdef NO_MACRO #ifndef NO_STARTUP -#define NO_STARTUP /* NO_MACRO implies NO_STARTUP */ +#define NO_STARTUP /* NO_MACRO implies NO_STARTUP */ #endif #endif -typedef int (*PF)(); /* generaly useful type */ +typedef int (*PF) (); /* generaly useful type */ /* * Table sizes, etc. */ -#define NFILEN 80 /* Length, file name. */ -#define NBUFN 24 /* Length, buffer name. */ -#define NLINE 256 /* Length, line. */ -#define PBMODES 4 /* modes per buffer */ -#define NKBDM 256 /* Length, keyboard macro. */ -#define NPAT 80 /* Length, pattern. */ -#define HUGE 1000 /* A rather large number. */ -#define NSRCH 128 /* Undoable search commands. */ -#define NXNAME 64 /* Length, extended command. */ -#define NKNAME 20 /* Length, key names */ +#define NFILEN 80 /* Length, file name. */ +#define NBUFN 24 /* Length, buffer name. */ +#define NLINE 256 /* Length, line. */ +#define PBMODES 4 /* modes per buffer */ +#define NKBDM 256 /* Length, keyboard macro. */ +#define NPAT 80 /* Length, pattern. */ +#define HUGE 1000 /* A rather large number. */ +#define NSRCH 128 /* Undoable search commands. */ +#define NXNAME 64 /* Length, extended command. */ +#define NKNAME 20 /* Length, key names */ /* * Universal. */ -#define FALSE 0 /* False, no, bad, etc. */ -#define TRUE 1 /* True, yes, good, etc. */ -#define ABORT 2 /* Death, ^G, abort, etc. */ +#define FALSE 0 /* False, no, bad, etc. */ +#define TRUE 1 /* True, yes, good, etc. */ +#define ABORT 2 /* Death, ^G, abort, etc. */ -#define KPROMPT 2 /* keyboard prompt */ +#define KPROMPT 2 /* keyboard prompt */ /* * These flag bits keep track of @@ -67,55 +67,55 @@ typedef int (*PF)(); /* generaly useful type */ * flag controls the clearing versus appending * of data in the kill buffer. */ -#define CFCPCN 0x0001 /* Last command was C-P, C-N */ -#define CFKILL 0x0002 /* Last command was a kill */ -#define CFINS 0x0004 /* Last command was self-insert */ +#define CFCPCN 0x0001 /* Last command was C-P, C-N */ +#define CFKILL 0x0002 /* Last command was a kill */ +#define CFINS 0x0004 /* Last command was self-insert */ /* * File I/O. */ -#define FIOSUC 0 /* Success. */ -#define FIOFNF 1 /* File not found. */ -#define FIOEOF 2 /* End of file. */ -#define FIOERR 3 /* Error. */ -#define FIOLONG 4 /* long line partially read */ +#define FIOSUC 0 /* Success. */ +#define FIOFNF 1 /* File not found. */ +#define FIOEOF 2 /* End of file. */ +#define FIOERR 3 /* Error. */ +#define FIOLONG 4 /* long line partially read */ /* * Directory I/O. */ -#define DIOSUC 0 /* Success. */ -#define DIOEOF 1 /* End of file. */ -#define DIOERR 2 /* Error. */ +#define DIOSUC 0 /* Success. */ +#define DIOEOF 1 /* End of file. */ +#define DIOERR 2 /* Error. */ /* * Display colors. */ -#define CNONE 0 /* Unknown color. */ -#define CTEXT 1 /* Text color. */ -#define CMODE 2 /* Mode line color. */ +#define CNONE 0 /* Unknown color. */ +#define CTEXT 1 /* Text color. */ +#define CMODE 2 /* Mode line color. */ -/* Flags for keyboard involked functions */ - -#define FFUNIV 1 /* universal argument */ -#define FFNEGARG 2 /* negitive only argument */ -#define FFOTHARG 4 /* other argument */ -#define FFARG 7 /* any argument */ -#define FFRAND 8 /* Called by other function */ +/* + * Flags for keyboard involked functions. + */ +#define FFUNIV 1 /* universal argument */ +#define FFNEGARG 2 /* negitive only argument */ +#define FFOTHARG 4 /* other argument */ +#define FFARG 7 /* any argument */ +#define FFRAND 8 /* Called by other function */ /* * Flags for "eread". */ -#define EFFUNC 0x0001 /* Autocomplete functions. */ -#define EFBUF 0x0002 /* Autocomplete buffers. */ -#define EFFILE 0x0004 /* " files (maybe someday) */ -#define EFAUTO 0x0007 /* Some autocompleteion on */ -#define EFNEW 0x0008 /* New prompt. */ -#define EFCR 0x0010 /* Echo CR at end; last read. */ +#define EFFUNC 0x0001 /* Autocomplete functions. */ +#define EFBUF 0x0002 /* Autocomplete buffers. */ +#define EFFILE 0x0004 /* " files (maybe someday) */ +#define EFAUTO 0x0007 /* Some autocompleteion on */ +#define EFNEW 0x0008 /* New prompt. */ +#define EFCR 0x0010 /* Echo CR at end; last read. */ /* * Flags for "ldelete"/"kinsert" */ - #define KNONE 0 #define KFORW 1 #define KBACK 2 @@ -132,17 +132,17 @@ typedef int (*PF)(); /* generaly useful type */ * additions will include update hints, and a * list of marks into the line. */ -typedef struct LINE { - struct LINE *l_fp; /* Link to the next line */ - struct LINE *l_bp; /* Link to the previous line */ - int l_size; /* Allocated size */ - int l_used; /* Used size */ +typedef struct LINE { + struct LINE *l_fp; /* Link to the next line */ + struct LINE *l_bp; /* Link to the previous line */ + int l_size; /* Allocated size */ + int l_used; /* Used size */ #ifndef ZEROARRAY - char l_text[1]; /* A bunch of characters. */ + char l_text[1]; /* A bunch of chars. */ #else - char l_text[]; /* A bunch of characters. */ + char l_text[]; /* A bunch of chars. */ #endif -} LINE; +} LINE; /* * The rationale behind these macros is that you @@ -170,12 +170,13 @@ typedef struct LINE { */ typedef struct LIST { union { - struct MGWIN *l_wp; - struct BUFFER *x_bp; /* l_bp is used by LINE */ - struct LIST *l_nxt; + struct MGWIN *l_wp; + struct BUFFER *x_bp; /* l_bp is used by LINE */ + struct LIST *l_nxt; } l_p; - char *l_name; + char *l_name; } LIST; + /* * Usual hack - to keep from uglifying the code with lotsa * references through the union, we #define something for it. @@ -192,19 +193,19 @@ typedef struct LIST { * terms of decoupling, the full blown redisplay is just too * expensive to run for every input character. */ -typedef struct MGWIN { - LIST w_list; /* List header */ - struct BUFFER *w_bufp; /* Buffer displayed in window */ - struct LINE *w_linep; /* Top line in the window */ - struct LINE *w_dotp; /* Line containing "." */ - struct LINE *w_markp; /* Line containing "mark" */ - int w_doto; /* Byte offset for "." */ - int w_marko; /* Byte offset for "mark" */ - char w_toprow; /* Origin 0 top row of window */ - char w_ntrows; /* # of rows of text in window */ - char w_force; /* If NZ, forcing row. */ - char w_flag; /* Flags. */ -} MGWIN; +typedef struct MGWIN { + LIST w_list; /* List header */ + struct BUFFER *w_bufp; /* Buffer displayed in window */ + struct LINE *w_linep; /* Top line in the window */ + struct LINE *w_dotp; /* Line containing "." */ + struct LINE *w_markp; /* Line containing "mark" */ + int w_doto; /* Byte offset for "." */ + int w_marko; /* Byte offset for "mark" */ + char w_toprow; /* Origin 0 top row of window */ + char w_ntrows; /* # of rows of text in window */ + char w_force; /* If NZ, forcing row. */ + char w_flag; /* Flags. */ +} MGWIN; #define w_wndp w_list.l_p.l_wp #define w_name w_list.l_name @@ -217,11 +218,11 @@ typedef struct MGWIN { * Because commands set bits in the "w_flag", update will see * all change flags, and do the most general one. */ -#define WFFORCE 0x01 /* Force reframe. */ -#define WFMOVE 0x02 /* Movement from line to line. */ -#define WFEDIT 0x04 /* Editing within a line. */ -#define WFHARD 0x08 /* Better to a full display. */ -#define WFMODE 0x10 /* Update mode line. */ +#define WFFORCE 0x01 /* Force reframe. */ +#define WFMOVE 0x02 /* Movement from line to line. */ +#define WFEDIT 0x04 /* Editing within a line. */ +#define WFHARD 0x08 /* Better to a full display. */ +#define WFMODE 0x10 /* Update mode line. */ /* * Text is kept in buffers. A buffer header, described @@ -233,30 +234,30 @@ typedef struct MGWIN { * the buffer is kept in a circularly linked list of lines, with * a pointer to the header line in "b_linep". */ -typedef struct BUFFER { - LIST b_list; /* buffer list pointer */ - struct BUFFER *b_altb; /* Link to alternate buffer */ - struct LINE *b_dotp; /* Link to "." LINE structure */ - struct LINE *b_markp; /* ditto for mark */ - struct LINE *b_linep; /* Link to the header LINE */ - struct MAPS_S *b_modes[PBMODES]; /* buffer modes */ - int b_doto; /* Offset of "." in above LINE */ - int b_marko; /* ditto for the "mark" */ - short b_nmodes; /* number of non-fundamental modes */ - char b_nwnd; /* Count of windows on buffer */ - char b_flag; /* Flags */ - char b_fname[NFILEN]; /* File name */ - struct fileinfo b_fi; /* File attributes */ -} BUFFER; +typedef struct BUFFER { + LIST b_list; /* buffer list pointer */ + struct BUFFER *b_altb; /* Link to alternate buffer */ + struct LINE *b_dotp; /* Link to "." LINE structure */ + struct LINE *b_markp; /* ditto for mark */ + struct LINE *b_linep; /* Link to the header LINE */ + struct MAPS_S *b_modes[PBMODES]; /* buffer modes */ + int b_doto; /* Offset of "." in above LINE */ + int b_marko; /* ditto for the "mark" */ + short b_nmodes; /* number of non-fundamental modes */ + char b_nwnd; /* Count of windows on buffer */ + char b_flag; /* Flags */ + char b_fname[NFILEN];/* File name */ + struct fileinfo b_fi; /* File attributes */ +} BUFFER; #define b_bufp b_list.l_p.x_bp #define b_bname b_list.l_name -#define BFCHG 0x01 /* Changed. */ -#define BFBAK 0x02 /* Need to make a backup. */ +#define BFCHG 0x01 /* Changed. */ +#define BFBAK 0x02 /* Need to make a backup. */ #ifdef NOTAB -#define BFNOTAB 0x04 /* no tab mode */ +#define BFNOTAB 0x04 /* no tab mode */ #endif -#define BFOVERWRITE 0x08 /* overwrite mode */ +#define BFOVERWRITE 0x08 /* overwrite mode */ /* * This structure holds the starting position @@ -264,43 +265,224 @@ typedef struct BUFFER { * region of a buffer. This makes passing the specification * of a region around a little bit easier. */ -typedef struct { - struct LINE *r_linep; /* Origin LINE address. */ - int r_offset; /* Origin LINE offset. */ - RSIZE r_size; /* Length in characters. */ -} REGION; +typedef struct { + struct LINE *r_linep; /* Origin LINE address. */ + int r_offset; /* Origin LINE offset. */ + RSIZE r_size; /* Length in characters. */ +} REGION; + +/* + * Prototypes. + */ + +/* tty.c */ +VOID ttinit __P((void)); +VOID ttreinit __P((void)); +VOID tttidy __P((void)); +VOID ttmove __P((int, int)); +VOID tteeol __P((void)); +VOID tteeop __P((void)); +VOID ttbeep __P((void)); +VOID ttinsl __P((int, int, int)); +VOID ttdell __P((int, int, int)); +VOID ttwindow __P((int, int)); +VOID ttnowindow __P((void)); +VOID ttcolor __P((int)); +VOID ttresize __P((void)); + +/* ttyio.c */ +VOID ttopen __P((void)); +int ttraw __P((void)); +VOID ttclose __P((void)); +int ttcooked __P((void)); +int ttputc __P((int)); +VOID ttflush __P((void)); +int ttgetc __P((void)); +int ttwait __P((void)); +VOID setttysize __P((void)); +int typeahead __P((void)); + +/* dir.c */ +VOID dirinit __P((VOID)); +int changedir __P((int, int)); +int showcwdir __P((int, int)); + +/* dired.c */ +int dired __P((int, int)); +int d_otherwindow __P((int, int)); +int d_undel __P((int, int)); +int d_undelbak __P((int, int)); +int d_findfile __P((int, int)); +int d_ffotherwindow __P((int, int)); +int d_expunge __P((int, int)); +int d_copy __P((int, int)); +int d_del __P((int, int)); +int d_rename __P((int, int)); + +/* file.c */ +int fileinsert __P((int, int)); +int filevisit __P((int, int)); +int poptofile __P((int, int)); +BUFFER *findbuffer __P((char *)); +int readin __P((char *)); +int insertfile __P((char *, char *, int)); +VOID makename __P((char *, char *)); +int filewrite __P((int, int)); +int filesave __P((int, int)); +int buffsave __P((BUFFER *)); +int makebkfile __P((int, int)); +int writeout __P((BUFFER *, char *)); +VOID upmodes __P((BUFFER *)); + +/* line.c */ +LINE *lalloc __P((int)); +LINE *lallocx __P((int)); +int lnewline __P((void)); +VOID lfree __P((LINE *)); +VOID lchange __P((int)); +VOID kdelete __P((void)); +int ldelnewline __P((void)); +int linsert __P((int, int)); + +/* window.c */ +MGWIN *wpopup __P((void)); +int nextwind __P((int, int)); + +/* buffer.c */ +BUFFER *bfind __P((char *, int)); +int poptobuffer __P((int, int)); +int killbuffer __P((int, int)); +int savebuffers __P((int, int)); +int listbuffers __P((int, int)); +int addline __P((BUFFER *, char *)); +int anycb __P((int)); +int bclear __P((BUFFER *)); +int showbuffer __P((BUFFER *, MGWIN *, int)); +MGWIN *popbuf __P((BUFFER *)); +int bufferinsert __P((int, int)); +int usebuffer __P((int, int)); +int notmodified __P((int, int)); +int popbuftop __P((BUFFER *)); + +/* display.c */ +VOID vtinit __P((void)); +VOID vttidy __P((void)); +VOID update __P((void)); + +/* echo.c */ +int eyorn __P((char *)); +int eyesno __P((char *)); +VOID ewprintf __P((const char *fmt, ...)); +int ereply __P((const char *, char *, int, ...)); +int eread __P((const char *, char *, int, int, ...)); +int getxtra __P((LIST *, LIST *, int, int)); + +/* fileio.c */ +int ffropen __P((char *, BUFFER *)); +int ffwopen __P((char *, BUFFER *)); +int ffclose __P((BUFFER *)); +int ffputbuf __P((BUFFER *)); +int ffgetline __P((char *, int, int *)); +int fbackupfile __P((char *)); +char *adjustname __P((char *)); +char *startupfile __P((char *)); +int copy __P((char *, char *)); +BUFFER *dired_ __P((char *)); +int d_makename __P((LINE *, char *)); +LIST *make_file_list __P((char *, int)); + +/* keymap.c */ +LIST *complete_function_list __P((char *, int)); +int complete_function __P((char *, int)); + +/* kbd.c */ +int do_meta __P((int, int)); +int bsmap __P((int, int)); +VOID ungetkey __P((int)); +int getkey __P((int)); +int doin __P((void)); +int rescan __P((int, int)); +int universal_argument __P((int, int)); +int digit_argument __P((int, int)); +int negative_argument __P((int, int)); +int selfinsert __P((int, int)); +int quote __P((int, int)); + +/* main.c */ +int ctrlg __P((int, int)); + +/* ttyio.c */ +VOID panic __P((char *)); + +/* cinfo.c */ +char *keyname __P((char *, int)); + +/* basic.c */ +int gotobol __P((int, int)); +int backchar __P((int, int)); +int gotoeol __P((int, int)); +int forwchar __P((int, int)); +int gotobob __P((int, int)); +int gotoeob __P((int, int)); +int forwline __P((int, int)); +int backline __P((int, int)); +VOID setgoal __P((void)); +int getgoal __P((LINE *)); +int forwpage __P((int, int)); +int backpage __P((int, int)); +int forw1page __P((int, int)); +int back1page __P((int, int)); +int pagenext __P((int, int)); +VOID isetmark __P((VOID)); +int setmark __P((int, int)); +int swapmark __P((int, int)); +int gotoline __P((int, int)); + +/* random.c */ +int getcolpos __P((void)); +int newline __P((int, int)); + +/* extend.c */ +int insert __P((int, int)); +int bindtokey __P((int, int)); +int localbind __P((int, int)); +int define_key __P((int, int)); +int unbindtokey __P((int, int)); +int localunbind __P((int, int)); +int extend __P((int, int)); +int evalexpr __P((int, int)); +int evalbuffer __P((int, int)); +int evalfile __P((int, int)); +int load __P((char *)); +int excline __P((char *)); + +/* help.c */ +int desckey __P((int, int)); +int wallchart __P((int, int)); +int help_help __P((int, int)); +int apropos_command __P((int, int)); /* * Externals. */ -extern int thisflag; -extern int lastflag; -extern int curgoal; -extern int epresf; -extern int sgarbf; -extern int mode; -extern MGWIN *curwp; -extern BUFFER *curbp; -extern MGWIN *wheadp; -extern BUFFER *bheadp; -extern char pat[]; -extern BUFFER *bfind(); -extern MGWIN *popbuf(); -extern MGWIN *wpopup(); -extern LINE *lalloc(); -extern LINE *lallocx(); -extern VOID ewprintf(); -extern int nrow; -extern int ncol; -extern int ttrow; -extern int ttcol; -extern int tceeol; -extern int tcinsl; -extern int tcdell; -extern char cinfo[]; -extern char *keystrings[]; -extern VOID update(); -extern char *keyname(); -extern char *adjustname(); -extern VOID kdelete(); -extern VOID lchange(); +extern int thisflag; +extern int lastflag; +extern int curgoal; +extern int epresf; +extern int sgarbf; +extern int mode; +extern MGWIN *curwp; +extern BUFFER *curbp; +extern MGWIN *wheadp; +extern BUFFER *bheadp; +extern char pat[]; +extern int nrow; +extern int ncol; +extern int ttrow; +extern int ttcol; +extern int tthue; +extern int tceeol; +extern int tcinsl; +extern int tcdell; +extern char cinfo[]; +extern char *keystrings[]; diff --git a/usr.bin/mg/dir.c b/usr.bin/mg/dir.c index d96e6552473..b667c862b6e 100644 --- a/usr.bin/mg/dir.c +++ b/usr.bin/mg/dir.c @@ -8,14 +8,16 @@ #include "def.h" #ifndef NO_DIR -char *wdir; -static char cwd[NFILEN]; +char *wdir; +static char cwd[NFILEN]; /* * Initialize anything the directory management routines need */ +VOID dirinit() { + if (!(wdir = getcwd(cwd, sizeof(cwd)))) panic("Can't get current directory!"); } @@ -23,34 +25,38 @@ dirinit() /* * Change current working directory */ -/*ARGSUSED*/ +/* ARGSUSED */ +int changedir(f, n) + int f, n; { - register int s; - char bufc[NPAT]; + int s; + char bufc[NPAT]; - if ((s=ereply("Change default directory: ", bufc, NPAT)) != TRUE) - return(s); + if ((s = ereply("Change default directory: ", bufc, NPAT)) != TRUE) + return (s); if (bufc[0] == '\0') (VOID) strcpy(bufc, wdir); if (chdir(bufc) == -1) { ewprintf("Can't change dir to %s", bufc); - return(FALSE); + return (FALSE); } else { if (!(wdir = getcwd(cwd, sizeof(cwd)))) panic("Can't get current directory!"); ewprintf("Current directory is now %s", wdir); - return(TRUE); + return (TRUE); } } /* * Show current directory */ -/*ARGSUSED*/ +/* ARGSUSED */ +int showcwdir(f, n) { + ewprintf("Current directory: %s", wdir); - return(TRUE); + return (TRUE); } #endif diff --git a/usr.bin/mg/dired.c b/usr.bin/mg/dired.c index aad6763fc79..bf231c85060 100644 --- a/usr.bin/mg/dired.c +++ b/usr.bin/mg/dired.c @@ -1,195 +1,217 @@ -/* dired module for mg 2a */ -/* by Robert A. Larson */ +/* dired module for mg 2a */ +/* by Robert A. Larson */ #include "def.h" #ifndef NO_DIRED -BUFFER *dired_(); - -/*ARGSUSED*/ +/* ARGSUSED */ +int dired(f, n) -int f, n; + int f, n; { - char dirname[NFILEN]; - BUFFER *bp; - - dirname[0] = '\0'; - if(eread("Dired: ", dirname, NFILEN, EFNEW | EFCR) == ABORT) - return ABORT; - if((bp = dired_(dirname)) == NULL) return FALSE; - curbp = bp; - return showbuffer(bp, curwp, WFHARD | WFMODE); + char dirname[NFILEN]; + BUFFER *bp; + + dirname[0] = '\0'; + if (eread("Dired: ", dirname, NFILEN, EFNEW | EFCR) == ABORT) + return ABORT; + if ((bp = dired_(dirname)) == NULL) + return FALSE; + curbp = bp; + return showbuffer(bp, curwp, WFHARD | WFMODE); } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_otherwindow(f, n) -int f, n; + int f, n; { - char dirname[NFILEN]; - BUFFER *bp; - MGWIN *wp; - - dirname[0] = '\0'; - if(eread("Dired other window: ", dirname, NFILEN, EFNEW | EFCR) == ABORT) - return ABORT; - if((bp = dired_(dirname)) == NULL) return FALSE; - if((wp = popbuf(bp)) == NULL) return FALSE; - curbp = bp; - curwp = wp; - return TRUE; + char dirname[NFILEN]; + BUFFER *bp; + MGWIN *wp; + + dirname[0] = '\0'; + if (eread("Dired other window: ", dirname, NFILEN, EFNEW | EFCR) == ABORT) + return ABORT; + if ((bp = dired_(dirname)) == NULL) + return FALSE; + if ((wp = popbuf(bp)) == NULL) + return FALSE; + curbp = bp; + curwp = wp; + return TRUE; } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_del(f, n) -int f, n; + int f, n; { - if(n < 0) return FALSE; - while(n--) { - if(llength(curwp->w_dotp) > 0) - lputc(curwp->w_dotp, 0, 'D'); - if(lforw(curwp->w_dotp) != curbp->b_linep) - curwp->w_dotp = lforw(curwp->w_dotp); - } - curwp->w_flag |= WFEDIT | WFMOVE; - curwp->w_doto = 0; - return TRUE; + + if (n < 0) + return FALSE; + while (n--) { + if (llength(curwp->w_dotp) > 0) + lputc(curwp->w_dotp, 0, 'D'); + if (lforw(curwp->w_dotp) != curbp->b_linep) + curwp->w_dotp = lforw(curwp->w_dotp); + } + curwp->w_flag |= WFEDIT | WFMOVE; + curwp->w_doto = 0; + return TRUE; } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_undel(f, n) -int f, n; + int f, n; { - if(n < 0) return d_undelbak(f, -n); - while(n--) { - if(llength(curwp->w_dotp) > 0) - lputc(curwp->w_dotp, 0, ' '); - if(lforw(curwp->w_dotp) != curbp->b_linep) - curwp->w_dotp = lforw(curwp->w_dotp); - } - curwp->w_flag |= WFEDIT | WFMOVE; - curwp->w_doto = 0; - return TRUE; + if (n < 0) + return d_undelbak(f, -n); + while (n--) { + if (llength(curwp->w_dotp) > 0) + lputc(curwp->w_dotp, 0, ' '); + if (lforw(curwp->w_dotp) != curbp->b_linep) + curwp->w_dotp = lforw(curwp->w_dotp); + } + curwp->w_flag |= WFEDIT | WFMOVE; + curwp->w_doto = 0; + return TRUE; } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_undelbak(f, n) -int f, n; + int f, n; { - if(n < 0) return d_undel(f, -n); - while(n--) { - if(llength(curwp->w_dotp) > 0) - lputc(curwp->w_dotp, 0, ' '); - if(lback(curwp->w_dotp) != curbp->b_linep) - curwp->w_dotp = lback(curwp->w_dotp); - } - curwp->w_doto = 0; - curwp->w_flag |= WFEDIT | WFMOVE; - return TRUE; + + if (n < 0) + return d_undel(f, -n); + while (n--) { + if (llength(curwp->w_dotp) > 0) + lputc(curwp->w_dotp, 0, ' '); + if (lback(curwp->w_dotp) != curbp->b_linep) + curwp->w_dotp = lback(curwp->w_dotp); + } + curwp->w_doto = 0; + curwp->w_flag |= WFEDIT | WFMOVE; + return TRUE; } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_findfile(f, n) -int f, n; + int f, n; { - char fname[NFILEN]; - register BUFFER *bp; - register int s; - BUFFER *findbuffer(); - - if((s = d_makename(curwp->w_dotp, fname)) == ABORT) return FALSE; - if ((bp = (s ? dired_(fname) : findbuffer(fname))) == NULL) return FALSE; - curbp = bp; - if (showbuffer(bp, curwp, WFHARD) != TRUE) return FALSE; - if (bp->b_fname[0] != 0) return TRUE; - return readin(fname); + BUFFER *bp; + int s; + char fname[NFILEN]; + + if ((s = d_makename(curwp->w_dotp, fname)) == ABORT) + return FALSE; + if ((bp = (s ? dired_(fname) : findbuffer(fname))) == NULL) + return FALSE; + curbp = bp; + if (showbuffer(bp, curwp, WFHARD) != TRUE) + return FALSE; + if (bp->b_fname[0] != 0) + return TRUE; + return readin(fname); } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_ffotherwindow(f, n) -int f, n; + int f, n; { - char fname[NFILEN]; - register BUFFER *bp; - register int s; - register MGWIN *wp; - BUFFER *findbuffer(); - - if((s = d_makename(curwp->w_dotp, fname)) == ABORT) return FALSE; - if ((bp = (s ? dired_(fname) : findbuffer(fname))) == NULL) return FALSE; - if ((wp = popbuf(bp)) == NULL) return FALSE; - curbp = bp; - curwp = wp; - if (bp->b_fname[0] != 0) return TRUE; /* never true for dired buffers */ - return readin(fname); + char fname[NFILEN]; + int s; + BUFFER *bp; + MGWIN *wp; + + if ((s = d_makename(curwp->w_dotp, fname)) == ABORT) + return FALSE; + if ((bp = (s ? dired_(fname) : findbuffer(fname))) == NULL) + return FALSE; + if ((wp = popbuf(bp)) == NULL) + return FALSE; + curbp = bp; + curwp = wp; + if (bp->b_fname[0] != 0) + return TRUE; /* never true for dired buffers */ + return readin(fname); } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_expunge(f, n) -int f, n; + int f, n; { - register LINE *lp, *nlp; - char fname[NFILEN]; - VOID lfree(); - - for(lp = lforw(curbp->b_linep); lp != curbp->b_linep; lp = nlp) { - nlp = lforw(lp); - if(llength(lp) && lgetc(lp, 0) == 'D') { - switch(d_makename(lp, fname)) { - case ABORT: - ewprintf("Bad line in dired buffer"); - return FALSE; - case FALSE: - if(unlink(fname) < 0) { - ewprintf("Could not delete '%s'", fname); - return FALSE; - } - break; - case TRUE: - if(rmdir(fname) < 0) { - ewprintf("Could not delete directory '%s'", fname); - return FALSE; - } - break; - } - lfree(lp); - curwp->w_flag |= WFHARD; + LINE *lp, *nlp; + char fname[NFILEN]; + + for (lp = lforw(curbp->b_linep); lp != curbp->b_linep; lp = nlp) { + nlp = lforw(lp); + if (llength(lp) && lgetc(lp, 0) == 'D') { + switch (d_makename(lp, fname)) { + case ABORT: + ewprintf("Bad line in dired buffer"); + return FALSE; + case FALSE: + if (unlink(fname) < 0) { + ewprintf("Could not delete '%s'", fname); + return FALSE; + } + break; + case TRUE: + if (rmdir(fname) < 0) { + ewprintf("Could not delete directory '%s'", + fname); + return FALSE; + } + break; + } + lfree(lp); + curwp->w_flag |= WFHARD; + } } - } - return TRUE; + return TRUE; } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_copy(f, n) -int f, n; + int f, n; { - char frname[NFILEN], toname[NFILEN]; - int stat; - - if(d_makename(curwp->w_dotp, frname) != FALSE) { - ewprintf("Not a file"); - return FALSE; - } - if((stat = eread("Copy %s to: ", toname, NFILEN, EFNEW | EFCR, frname)) - != TRUE) return stat; - return copy(frname, toname) >= 0; + char frname[NFILEN], toname[NFILEN]; + int stat; + + if (d_makename(curwp->w_dotp, frname) != FALSE) { + ewprintf("Not a file"); + return FALSE; + } + if ((stat = eread("Copy %s to: ", toname, NFILEN, EFNEW | EFCR, frname)) + != TRUE) + return stat; + return copy(frname, toname) >= 0; } -/*ARGSUSED*/ +/* ARGSUSED */ +int d_rename(f, n) -int f, n; + int f, n; { - char frname[NFILEN], toname[NFILEN]; - int stat; - - if(d_makename(curwp->w_dotp, frname) != FALSE) { - ewprintf("Not a file"); - return FALSE; - } - if((stat = eread("Rename %s to: ", toname, NFILEN, EFNEW | EFCR, frname)) - != TRUE) return stat; - return rename(frname, toname) >= 0; + char frname[NFILEN], toname[NFILEN]; + int stat; + + if (d_makename(curwp->w_dotp, frname) != FALSE) { + ewprintf("Not a file"); + return FALSE; + } + if ((stat = eread("Rename %s to: ", toname, NFILEN, EFNEW | EFCR, + frname)) != TRUE) + return stat; + return rename(frname, toname) >= 0; } #endif - - diff --git a/usr.bin/mg/display.c b/usr.bin/mg/display.c index 24341c28579..321d02e6c4d 100644 --- a/usr.bin/mg/display.c +++ b/usr.bin/mg/display.c @@ -23,8 +23,8 @@ */ /* These defines really belong in sysdef.h */ #ifndef XCHAR -# define XCHAR int -# define XSHORT int +#define XCHAR int +#define XSHORT int #endif #ifdef STANDOUT_GLITCH @@ -37,17 +37,17 @@ * the longest line possible. Only some of this is * used if "ncol" isn't the same as "NCOL". */ -typedef struct { - short v_hash; /* Hash code, for compares. */ - short v_flag; /* Flag word. */ - short v_color; /* Color of the line. */ - XSHORT v_cost; /* Cost of display. */ - char v_text[NCOL]; /* The actual characters. */ -} VIDEO; - -#define VFCHG 0x0001 /* Changed. */ -#define VFHBAD 0x0002 /* Hash and cost are bad. */ -#define VFEXT 0x0004 /* extended line (beond ncol) */ +typedef struct { + short v_hash; /* Hash code, for compares. */ + short v_flag; /* Flag word. */ + short v_color; /* Color of the line. */ + XSHORT v_cost; /* Cost of display. */ + char v_text[NCOL]; /* The actual characters. */ +} VIDEO; + +#define VFCHG 0x0001 /* Changed. */ +#define VFHBAD 0x0002 /* Hash and cost are bad. */ +#define VFEXT 0x0004 /* extended line (beond ncol) */ /* * SCORE structures hold the optimal @@ -57,45 +57,42 @@ typedef struct { * fields can be "char", and the score a "short", but * this makes the code worse on the VAX. */ -typedef struct { - XCHAR s_itrace; /* "i" index for track back. */ - XCHAR s_jtrace; /* "j" index for trace back. */ - XSHORT s_cost; /* Display cost. */ -} SCORE; - -int sgarbf = TRUE; /* TRUE if screen is garbage. */ -int vtrow = 0; /* Virtual cursor row. */ -int vtcol = 0; /* Virtual cursor column. */ -int tthue = CNONE; /* Current color. */ -int ttrow = HUGE; /* Physical cursor row. */ -int ttcol = HUGE; /* Physical cursor column. */ -int tttop = HUGE; /* Top of scroll region. */ -int ttbot = HUGE; /* Bottom of scroll region. */ -int lbound = 0; /* leftmost bound of the current line */ - /* being displayed */ - -VIDEO *vscreen[NROW-1]; /* Edge vector, virtual. */ -VIDEO *pscreen[NROW-1]; /* Edge vector, physical. */ -VIDEO video[2*(NROW-1)]; /* Actual screen data. */ -VIDEO blanks; /* Blank line image. */ - -/* - * Some predeclerations to make ANSI compilers happy - */ -VOID vtinit(); -VOID vttidy(); -VOID vtmove(); -VOID vtputc(); -VOID vtpute(); -VOID vteeol(); -VOID update(); -VOID updext(); -VOID ucopy(); -VOID uline(); -VOID modeline(); -VOID hash(); -VOID setscores(); -VOID traceback(); +typedef struct { + XCHAR s_itrace; /* "i" index for track back. */ + XCHAR s_jtrace; /* "j" index for trace back. */ + XSHORT s_cost; /* Display cost. */ +} SCORE; + + +VOID vtmove __P((int, int)); +VOID vtputc __P((int)); +VOID vtpute __P((int)); +int vtputs __P((char *)); +VOID vteeol __P((void)); +VOID updext __P((int, int)); +VOID modeline __P((MGWIN *)); +VOID setscores __P((int, int)); +VOID traceback __P((int, int, int, int)); +VOID ucopy __P((VIDEO *, VIDEO *)); +VOID uline __P((int, VIDEO *, VIDEO *)); +VOID hash __P((VIDEO *)); + + +int sgarbf = TRUE; /* TRUE if screen is garbage. */ +int vtrow = 0; /* Virtual cursor row. */ +int vtcol = 0; /* Virtual cursor column. */ +int tthue = CNONE; /* Current color. */ +int ttrow = HUGE; /* Physical cursor row. */ +int ttcol = HUGE; /* Physical cursor column. */ +int tttop = HUGE; /* Top of scroll region. */ +int ttbot = HUGE; /* Bottom of scroll region. */ +int lbound = 0; /* leftmost bound of the current line */ + /* being displayed */ + +VIDEO *vscreen[NROW - 1]; /* Edge vector, virtual. */ +VIDEO *pscreen[NROW - 1]; /* Edge vector, physical. */ +VIDEO video[2 * (NROW - 1)]; /* Actual screen data. */ +VIDEO blanks; /* Blank line image. */ #ifdef GOSLING /* @@ -105,7 +102,7 @@ VOID traceback(); * It would be "SCORE score[NROW][NROW]" in old speak. * Look at "setscores" to understand what is up. */ -SCORE score[NROW*NROW]; +SCORE score[NROW * NROW]; #endif /* @@ -120,21 +117,22 @@ SCORE score[NROW*NROW]; * on the first call to redisplay. */ VOID -vtinit() { - register VIDEO *vp; - register int i; +vtinit() +{ + VIDEO *vp; + int i; ttopen(); ttinit(); vp = &video[0]; - for (i=0; i= ncol) - vp->v_text[ncol-1] = '$'; + vp->v_text[ncol - 1] = '$'; else if (c == '\t' #ifdef NOTAB - && !(curbp->b_flag & BFNOTAB) + && !(curbp->b_flag & BFNOTAB) #endif - ) { + ) { do { vtputc(' '); - } while (vtcolv_text[vtcol++] = c; } -/* Put a character to the virtual screen in an extended line. If we are - * not yet on left edge, don't print it yet. Check for overflow on - * the right margin. +/* + * Put a character to the virtual screen in an extended line. If we are not + * yet on left edge, don't print it yet. Check for overflow on the right + * margin. */ VOID vtpute(c) -int c; + int c; { - register VIDEO *vp; + VIDEO *vp; - vp = vscreen[vtrow]; + vp = vscreen[vtrow]; - if (vtcol >= ncol) vp->v_text[ncol - 1] = '$'; - else if (c == '\t' + if (vtcol >= ncol) + vp->v_text[ncol - 1] = '$'; + else if (c == '\t' #ifdef NOTAB - && !(curbp->b_flag & BFNOTAB) + && !(curbp->b_flag & BFNOTAB) #endif - ) { - do { - vtpute(' '); + ) { + do { + vtpute(' '); + } + while (((vtcol + lbound) & 0x07) != 0 && vtcol < ncol); + } else if (ISCTRL(c) != FALSE) { + vtpute('^'); + vtpute(CCHR(c)); + } else { + if (vtcol >= 0) + vp->v_text[vtcol] = c; + ++vtcol; } - while (((vtcol + lbound)&0x07) != 0 && vtcol < ncol); - } else if (ISCTRL(c) != FALSE) { - vtpute('^'); - vtpute(CCHR(c)); - } else { - if (vtcol >= 0) vp->v_text[vtcol] = c; - ++vtcol; - } } -/* Erase from the end of the - * software cursor to the end of the - * line on which the software cursor is - * located. The display routines will decide - * if a hardware erase to end of line command - * should be used to display this. +/* + * Erase from the end of the software cursor to the end of the line on which + * the software cursor is located. The display routines will decide if a + * hardware erase to end of line command should be used to display this. */ VOID -vteeol() { - register VIDEO *vp; +vteeol() +{ + VIDEO *vp; vp = vscreen[vtrow]; while (vtcol < ncol) @@ -260,37 +267,37 @@ vteeol() { * virtual and physical screens the same. */ VOID -update() { - register LINE *lp; - register MGWIN *wp; - register VIDEO *vp1; - VIDEO *vp2; - register int i; - register int j; - register int c; - register int hflag; - register int currow; - register int curcol; - register int offs; - register int size; - VOID traceback (); - VOID uline (); - - if (typeahead()) return; - if (sgarbf) { /* must update everything */ +update() +{ + LINE *lp; + MGWIN *wp; + VIDEO *vp1; + VIDEO *vp2; + int i; + int j; + int c; + int hflag; + int currow; + int curcol; + int offs; + int size; + + if (typeahead()) + return; + if (sgarbf) { /* must update everything */ wp = wheadp; - while(wp != NULL) { + while (wp != NULL) { wp->w_flag |= WFMODE | WFHARD; wp = wp->w_wndp; } } - hflag = FALSE; /* Not hard. */ + hflag = FALSE; /* Not hard. */ wp = wheadp; while (wp != NULL) { - if (wp->w_flag != 0) { /* Need update. */ - if ((wp->w_flag&WFFORCE) == 0) { + if (wp->w_flag != 0) { /* Need update. */ + if ((wp->w_flag & WFFORCE) == 0) { lp = wp->w_linep; - for (i=0; iw_ntrows; ++i) { + for (i = 0; i < wp->w_ntrows; ++i) { if (lp == wp->w_dotp) goto out; if (lp == wp->w_bufp->b_linep) @@ -298,46 +305,46 @@ update() { lp = lforw(lp); } } - i = wp->w_force; /* Reframe this one. */ + i = wp->w_force; /* Reframe this one. */ if (i > 0) { --i; if (i >= wp->w_ntrows) - i = wp->w_ntrows-1; + i = wp->w_ntrows - 1; } else if (i < 0) { i += wp->w_ntrows; if (i < 0) i = 0; } else - i = wp->w_ntrows/2; + i = wp->w_ntrows / 2; lp = wp->w_dotp; - while (i!=0 && lback(lp)!=wp->w_bufp->b_linep) { + while (i != 0 && lback(lp) != wp->w_bufp->b_linep) { --i; lp = lback(lp); } wp->w_linep = lp; - wp->w_flag |= WFHARD; /* Force full. */ - out: - lp = wp->w_linep; /* Try reduced update. */ - i = wp->w_toprow; - if ((wp->w_flag&~WFMODE) == WFEDIT) { + wp->w_flag |= WFHARD; /* Force full. */ + out: + lp = wp->w_linep; /* Try reduced update. */ + i = wp->w_toprow; + if ((wp->w_flag & ~WFMODE) == WFEDIT) { while (lp != wp->w_dotp) { ++i; lp = lforw(lp); } vscreen[i]->v_color = CTEXT; - vscreen[i]->v_flag |= (VFCHG|VFHBAD); + vscreen[i]->v_flag |= (VFCHG | VFHBAD); vtmove(i, 0); - for (j=0; jw_flag&(WFEDIT|WFHARD)) != 0) { + } else if ((wp->w_flag & (WFEDIT | WFHARD)) != 0) { hflag = TRUE; - while (i < wp->w_toprow+wp->w_ntrows) { + while (i < wp->w_toprow + wp->w_ntrows) { vscreen[i]->v_color = CTEXT; - vscreen[i]->v_flag |= (VFCHG|VFHBAD); + vscreen[i]->v_flag |= (VFCHG | VFHBAD); vtmove(i, 0); if (lp != wp->w_bufp->b_linep) { - for (j=0; jw_flag&WFMODE) != 0) + if ((wp->w_flag & WFMODE) != 0) modeline(wp); - wp->w_flag = 0; + wp->w_flag = 0; wp->w_force = 0; } wp = wp->w_wndp; } - lp = curwp->w_linep; /* Cursor location. */ + lp = curwp->w_linep; /* Cursor location. */ currow = curwp->w_toprow; while (lp != curwp->w_dotp) { ++currow; @@ -364,59 +371,62 @@ update() { c = lgetc(lp, i++); if (c == '\t' #ifdef NOTAB - && !(curbp->b_flag & BFNOTAB) + && !(curbp->b_flag & BFNOTAB) #endif - ) curcol |= 0x07; + ) + curcol |= 0x07; else if (ISCTRL(c) != FALSE) ++curcol; ++curcol; } - if (curcol >= ncol - 1) { /* extended line. */ - /* flag we are extended and changed */ + if (curcol >= ncol - 1) { /* extended line. */ + /* flag we are extended and changed */ vscreen[currow]->v_flag |= VFEXT | VFCHG; - updext(currow, curcol); /* and output extended line */ - } else lbound = 0; /* not extended line */ - - /* make sure no lines need to be de-extended because the cursor is - no longer on them */ + updext(currow, curcol); /* and output extended line */ + } else + lbound = 0; /* not extended line */ + /* + * make sure no lines need to be de-extended because the cursor is no + * longer on them + */ wp = wheadp; - while (wp != NULL) { - lp = wp->w_linep; - i = wp->w_toprow; - while (i < wp->w_toprow + wp->w_ntrows) { - if (vscreen[i]->v_flag & VFEXT) { - /* always flag extended lines as changed */ - vscreen[i]->v_flag |= VFCHG; - if ((wp != curwp) || (lp != wp->w_dotp) || - (curcol < ncol - 1)) { - vtmove(i, 0); - for (j = 0; j < llength(lp); ++j) - vtputc(lgetc(lp, j)); - vteeol(); - /* this line no longer is extended */ - vscreen[i]->v_flag &= ~VFEXT; - } + lp = wp->w_linep; + i = wp->w_toprow; + while (i < wp->w_toprow + wp->w_ntrows) { + if (vscreen[i]->v_flag & VFEXT) { + /* always flag extended lines as changed */ + vscreen[i]->v_flag |= VFCHG; + if ((wp != curwp) || (lp != wp->w_dotp) || + (curcol < ncol - 1)) { + vtmove(i, 0); + for (j = 0; j < llength(lp); ++j) + vtputc(lgetc(lp, j)); + vteeol(); + /* this line no longer is extended */ + vscreen[i]->v_flag &= ~VFEXT; + } + } + lp = lforw(lp); + ++i; } - lp = lforw(lp); - ++i; - } - /* if garbaged then fix up mode lines */ - if (sgarbf != FALSE) vscreen[i]->v_flag |= VFCHG; - /* and onward to the next window */ - wp = wp->w_wndp; + /* if garbaged then fix up mode lines */ + if (sgarbf != FALSE) + vscreen[i]->v_flag |= VFCHG; + /* and onward to the next window */ + wp = wp->w_wndp; } - if (sgarbf != FALSE) { /* Screen is garbage. */ - sgarbf = FALSE; /* Erase-page clears */ - epresf = FALSE; /* the message area. */ - tttop = HUGE; /* Forget where you set */ - ttbot = HUGE; /* scroll region. */ - tthue = CNONE; /* Color unknown. */ + if (sgarbf != FALSE) { /* Screen is garbage. */ + sgarbf = FALSE; /* Erase-page clears */ + epresf = FALSE; /* the message area. */ + tttop = HUGE; /* Forget where you set */ + ttbot = HUGE; /* scroll region. */ + tthue = CNONE; /* Color unknown. */ ttmove(0, 0); tteeop(); - for (i=0; iv_color != vp2->v_color - || vp1->v_hash != vp2->v_hash) + || vp1->v_hash != vp2->v_hash) break; uline(offs, vp1, vp2); ucopy(vp1, vp2); ++offs; } - if (offs == nrow-1) { /* Might get it all. */ + if (offs == nrow - 1) { /* Might get it all. */ ttmove(currow, curcol - lbound); ttflush(); return; } - size = nrow-1; /* Get bottom match. */ + size = nrow - 1; /* Get bottom match. */ while (size != offs) { - vp1 = vscreen[size-1]; - vp2 = pscreen[size-1]; + vp1 = vscreen[size - 1]; + vp2 = pscreen[size - 1]; if (vp1->v_color != vp2->v_color - || vp1->v_hash != vp2->v_hash) + || vp1->v_hash != vp2->v_hash) break; - uline(size-1, vp1, vp2); + uline(size - 1, vp1, vp2); ucopy(vp1, vp2); --size; } @@ -461,17 +471,17 @@ update() { panic("Illegal screen size in update"); setscores(offs, size); /* Do hard update. */ traceback(offs, size, size, size); - for (i=0; iv_flag&VFCHG) != 0) { + if ((vp1->v_flag & VFCHG) != 0) { uline(i, vp1, vp2); ucopy(vp1, vp2); } @@ -489,39 +499,46 @@ update() { * display has done an update. */ VOID -ucopy(vvp, pvp) register VIDEO *vvp; register VIDEO *pvp; { +ucopy(vvp, pvp) + VIDEO *vvp; + VIDEO *pvp; +{ - vvp->v_flag &= ~VFCHG; /* Changes done. */ - pvp->v_flag = vvp->v_flag; /* Update model. */ - pvp->v_hash = vvp->v_hash; - pvp->v_cost = vvp->v_cost; + vvp->v_flag &= ~VFCHG; /* Changes done. */ + pvp->v_flag = vvp->v_flag; /* Update model. */ + pvp->v_hash = vvp->v_hash; + pvp->v_cost = vvp->v_cost; pvp->v_color = vvp->v_color; bcopy(vvp->v_text, pvp->v_text, ncol); } -/* updext: update the extended line which the cursor is currently - * on at a column greater than the terminal width. The line - * will be scrolled right or left to let the user see where - * the cursor is +/* + * updext: update the extended line which the cursor is currently on at a + * column greater than the terminal width. The line will be scrolled right or + * left to let the user see where the cursor is */ VOID updext(currow, curcol) -int currow, curcol; + int currow, curcol; { - register LINE *lp; /* pointer to current line */ - register int j; /* index into line */ - - /* calculate what column the left bound should be */ - /* (force cursor into middle half of screen) */ - lbound = curcol - (curcol % (ncol>>1)) - (ncol>>2); - /* scan through the line outputing characters to the virtual screen */ - /* once we reach the left edge */ - vtmove(currow, -lbound); /* start scanning offscreen */ - lp = curwp->w_dotp; /* line to output */ - for (j=0; jv_text[0] = '$'; /* and put a '$' in column 1 */ + LINE *lp; /* pointer to current line */ + int j; /* index into line */ + + /* + * calculate what column the left bound should be + * (force cursor into middle half of screen) + */ + lbound = curcol - (curcol % (ncol >> 1)) - (ncol >> 2); + /* + * scan through the line outputing characters to the virtual screen + * once we reach the left edge + */ + vtmove(currow, -lbound); /* start scanning offscreen */ + lp = curwp->w_dotp; /* line to output */ + for (j = 0; j < llength(lp); ++j) /* until the end-of-line */ + vtpute(lgetc(lp, j)); + vteeol(); /* truncate the virtual line */ + vscreen[currow]->v_text[0] = '$'; /* and put a '$' in column 1 */ } /* @@ -533,19 +550,24 @@ int currow, curcol; * line when updating CMODE color lines, because of the way that * reverse video works on most terminals. */ -VOID uline(row, vvp, pvp) VIDEO *vvp; VIDEO *pvp; { +VOID +uline(row, vvp, pvp) + int row; + VIDEO *vvp; + VIDEO *pvp; +{ #ifdef MEMMAP - putline(row+1, 1, &vvp->v_text[0]); + putline(row + 1, 1, &vvp->v_text[0]); #else - register char *cp1; - register char *cp2; - register char *cp3; - char *cp4; - char *cp5; - register int nbflag; - - if (vvp->v_color != pvp->v_color) { /* Wrong color, do a */ - ttmove(row, 0); /* full redraw. */ + char *cp1; + char *cp2; + char *cp3; + char *cp4; + char *cp5; + int nbflag; + + if (vvp->v_color != pvp->v_color) { /* Wrong color, do a */ + ttmove(row, 0); /* full redraw. */ #ifdef STANDOUT_GLITCH if (pvp->v_color != CTEXT && magic_cookie_glitch >= 0) tteeol(); @@ -553,12 +575,12 @@ VOID uline(row, vvp, pvp) VIDEO *vvp; VIDEO *pvp; { ttcolor(vvp->v_color); #ifdef STANDOUT_GLITCH cp1 = &vvp->v_text[magic_cookie_glitch > 0 ? magic_cookie_glitch : 0]; - /* the odd code for magic_cookie_glitch==0 - * is to avoid putting the invisable - * glitch character on the next line. + /* + * the odd code for magic_cookie_glitch==0 is to avoid + * putting the invisable glitch character on the next line. * (Hazeltine executive 80 model 30) */ - cp2 = &vvp->v_text[ncol - (magic_cookie_glitch >= 0 ? (magic_cookie_glitch!=0 ? magic_cookie_glitch : 1) : 0)]; + cp2 = &vvp->v_text[ncol - (magic_cookie_glitch >= 0 ? (magic_cookie_glitch != 0 ? magic_cookie_glitch : 1) : 0)]; #else cp1 = &vvp->v_text[0]; cp2 = &vvp->v_text[ncol]; @@ -572,37 +594,39 @@ VOID uline(row, vvp, pvp) VIDEO *vvp; VIDEO *pvp; { #endif return; } - cp1 = &vvp->v_text[0]; /* Compute left match. */ + cp1 = &vvp->v_text[0]; /* Compute left match. */ cp2 = &pvp->v_text[0]; - while (cp1!=&vvp->v_text[ncol] && cp1[0]==cp2[0]) { + while (cp1 != &vvp->v_text[ncol] && cp1[0] == cp2[0]) { ++cp1; ++cp2; } - if (cp1 == &vvp->v_text[ncol]) /* All equal. */ + if (cp1 == &vvp->v_text[ncol]) /* All equal. */ return; nbflag = FALSE; - cp3 = &vvp->v_text[ncol]; /* Compute right match. */ + cp3 = &vvp->v_text[ncol]; /* Compute right match. */ cp4 = &pvp->v_text[ncol]; while (cp3[-1] == cp4[-1]) { --cp3; --cp4; - if (cp3[0] != ' ') /* Note non-blanks in */ - nbflag = TRUE; /* the right match. */ + if (cp3[0] != ' ') /* Note non-blanks in */ + nbflag = TRUE; /* the right match. */ } - cp5 = cp3; /* Is erase good? */ - if (nbflag==FALSE && vvp->v_color==CTEXT) { - while (cp5!=cp1 && cp5[-1]==' ') + cp5 = cp3; /* Is erase good? */ + if (nbflag == FALSE && vvp->v_color == CTEXT) { + while (cp5 != cp1 && cp5[-1] == ' ') --cp5; /* Alcyon hack */ - if ((int)(cp3-cp5) <= tceeol) + if ((int) (cp3 - cp5) <= tceeol) cp5 = cp3; } /* Alcyon hack */ - ttmove(row, (int)(cp1-&vvp->v_text[0])); + ttmove(row, (int) (cp1 - &vvp->v_text[0])); #ifdef STANDOUT_GLITCH if (vvp->v_color != CTEXT && magic_cookie_glitch > 0) { - if(cp1 < &vvp->v_text[magic_cookie_glitch]) cp1 = &vvp->v_text[magic_cookie_glitch]; - if(cp5 > &vvp->v_text[ncol-magic_cookie_glitch]) cp5 = &vvp->v_text[ncol-magic_cookie_glitch]; + if (cp1 < &vvp->v_text[magic_cookie_glitch]) + cp1 = &vvp->v_text[magic_cookie_glitch]; + if (cp5 > &vvp->v_text[ncol - magic_cookie_glitch]) + cp5 = &vvp->v_text[ncol - magic_cookie_glitch]; } else if (magic_cookie_glitch < 0) #endif ttcolor(vvp->v_color); @@ -610,59 +634,62 @@ VOID uline(row, vvp, pvp) VIDEO *vvp; VIDEO *pvp; { ttputc(*cp1++); ++ttcol; } - if (cp5 != cp3) /* Do erase. */ + if (cp5 != cp3) /* Do erase. */ tteeol(); #endif } /* - * Redisplay the mode line for - * the window pointed to by the "wp". - * This is the only routine that has any idea - * of how the modeline is formatted. You can - * change the modeline format by hacking at - * this routine. Called by "update" any time - * there is a dirty window. - * Note that if STANDOUT_GLITCH is defined, first and last - * magic_cookie_glitch characters may never be seen. + * Redisplay the mode line for the window pointed to by the "wp". + * This is the only routine that has any idea of how the modeline is + * formatted. You can change the modeline format by hacking at this + * routine. Called by "update" any time there is a dirty window. Note + * that if STANDOUT_GLITCH is defined, first and last magic_cookie_glitch + * characters may never be seen. */ VOID -modeline(wp) register MGWIN *wp; { - register int n; - register BUFFER *bp; - int mode; - - n = wp->w_toprow+wp->w_ntrows; /* Location. */ - vscreen[n]->v_color = CMODE; /* Mode line color. */ - vscreen[n]->v_flag |= (VFCHG|VFHBAD); /* Recompute, display. */ - vtmove(n, 0); /* Seek to right line. */ +modeline(wp) + MGWIN *wp; +{ + int n; + BUFFER *bp; + int mode; + + n = wp->w_toprow + wp->w_ntrows; /* Location. */ + vscreen[n]->v_color = CMODE; /* Mode line color. */ + vscreen[n]->v_flag |= (VFCHG | VFHBAD); /* Recompute, display. */ + vtmove(n, 0); /* Seek to right line. */ bp = wp->w_bufp; - vtputc('-'); vtputc('-'); - if ((bp->b_flag&BFCHG) != 0) { /* "*" if changed. */ - vtputc('*'); vtputc('*'); + vtputc('-'); + vtputc('-'); + if ((bp->b_flag & BFCHG) != 0) { /* "*" if changed. */ + vtputc('*'); + vtputc('*'); } else { - vtputc('-'); vtputc('-'); + vtputc('-'); + vtputc('-'); } vtputc('-'); - n = 5; + n = 5; n += vtputs("Mg: "); if (bp->b_bname[0] != '\0') n += vtputs(&(bp->b_bname[0])); - while (n < 42) { /* Pad out with blanks */ + while (n < 42) { /* Pad out with blanks */ vtputc(' '); ++n; } vtputc('('); ++n; - for(mode=0;;) { - n += vtputs(bp->b_modes[mode]->p_name); - if(++mode > bp->b_nmodes) break; - vtputc('-'); - ++n; + for (mode = 0;;) { + n += vtputs(bp->b_modes[mode]->p_name); + if (++mode > bp->b_nmodes) + break; + vtputc('-'); + ++n; } vtputc(')'); ++n; - while (n < ncol) { /* Pad out. */ + while (n < ncol) { /* Pad out. */ vtputc('-'); ++n; } @@ -670,8 +697,11 @@ modeline(wp) register MGWIN *wp; { /* * output a string to the mode line, report how long it was. */ -vtputs(s) register char *s; { - register int n = 0; +int +vtputs(s) + char *s; +{ + int n = 0; while (*s != '\0') { vtputc(*s++); @@ -679,36 +709,37 @@ vtputs(s) register char *s; { } return n; } + #ifdef GOSLING /* - * Compute the hash code for - * the line pointed to by the "vp". Recompute - * it if necessary. Also set the approximate redisplay - * cost. The validity of the hash code is marked by - * a flag bit. The cost understand the advantages - * of erase to end of line. Tuned for the VAX - * by Bob McNamara; better than it used to be on + * Compute the hash code for the line pointed to by the "vp". + * Recompute it if necessary. Also set the approximate redisplay + * cost. The validity of the hash code is marked by a flag bit. + * The cost understand the advantages of erase to end of line. + * Tuned for the VAX by Bob McNamara; better than it used to be on * just about any machine. */ VOID -hash(vp) register VIDEO *vp; { - register int i; - register int n; - register char *s; - - if ((vp->v_flag&VFHBAD) != 0) { /* Hash bad. */ - s = &vp->v_text[ncol-1]; - for (i=ncol; i!=0; --i, --s) +hash(vp) + VIDEO *vp; +{ + int i; + int n; + char *s; + + if ((vp->v_flag & VFHBAD) != 0) { /* Hash bad. */ + s = &vp->v_text[ncol - 1]; + for (i = ncol; i != 0; --i, --s) if (*s != ' ') break; - n = ncol-i; /* Erase cheaper? */ + n = ncol - i; /* Erase cheaper? */ if (n > tceeol) n = tceeol; - vp->v_cost = i+n; /* Bytes + blanks. */ - for (n=0; i!=0; --i, --s) - n = (n<<5) + n + *s; - vp->v_hash = n; /* Hash code. */ - vp->v_flag &= ~VFHBAD; /* Flag as all done. */ + vp->v_cost = i + n; /* Bytes + blanks. */ + for (n = 0; i != 0; --i, --s) + n = (n << 5) + n + *s; + vp->v_hash = n; /* Hash code. */ + vp->v_flag &= ~VFHBAD; /* Flag as all done. */ } } @@ -739,77 +770,80 @@ hash(vp) register VIDEO *vp; { * bit better; but it looks ugly. */ VOID -setscores(offs, size) { - register SCORE *sp; - SCORE *sp1; - register int tempcost; - register int bestcost; - register int j; - register int i; - register VIDEO **vp; - VIDEO **pp, **vbase, **pbase; - - vbase = &vscreen[offs-1]; /* By hand CSE's. */ - pbase = &pscreen[offs-1]; - score[0].s_itrace = 0; /* [0, 0] */ +setscores(offs, size) + int offs; + int size; +{ + SCORE *sp; + SCORE *sp1; + int tempcost; + int bestcost; + int j; + int i; + VIDEO **vp, **pp; + VIDEO **vbase, **pbase; + + vbase = &vscreen[offs - 1]; /* By hand CSE's. */ + pbase = &pscreen[offs - 1]; + score[0].s_itrace = 0; /* [0, 0] */ score[0].s_jtrace = 0; - score[0].s_cost = 0; - sp = &score[1]; /* Row 0, inserts. */ + score[0].s_cost = 0; + sp = &score[1]; /* Row 0, inserts. */ tempcost = 0; vp = &vbase[1]; - for (j=1; j<=size; ++j) { + for (j = 1; j <= size; ++j) { sp->s_itrace = 0; - sp->s_jtrace = j-1; + sp->s_jtrace = j - 1; tempcost += tcinsl; tempcost += (*vp)->v_cost; sp->s_cost = tempcost; ++vp; ++sp; } - sp = &score[NROW]; /* Column 0, deletes. */ + sp = &score[NROW]; /* Column 0, deletes. */ tempcost = 0; - for (i=1; i<=size; ++i) { - sp->s_itrace = i-1; + for (i = 1; i <= size; ++i) { + sp->s_itrace = i - 1; sp->s_jtrace = 0; - tempcost += tcdell; + tempcost += tcdell; sp->s_cost = tempcost; sp += NROW; } - sp1 = &score[NROW+1]; /* [1, 1]. */ + sp1 = &score[NROW + 1]; /* [1, 1]. */ pp = &pbase[1]; - for (i=1; i<=size; ++i) { + for (i = 1; i <= size; ++i) { sp = sp1; vp = &vbase[1]; - for (j=1; j<=size; ++j) { - sp->s_itrace = i-1; + for (j = 1; j <= size; ++j) { + sp->s_itrace = i - 1; sp->s_jtrace = j; - bestcost = (sp-NROW)->s_cost; - if (j != size) /* Cd(A[i])=0 @ Dis. */ + bestcost = (sp - NROW)->s_cost; + if (j != size) /* Cd(A[i])=0 @ Dis. */ bestcost += tcdell; - tempcost = (sp-1)->s_cost; + tempcost = (sp - 1)->s_cost; tempcost += (*vp)->v_cost; - if (i != size) /* Ci(B[j])=0 @ Dsj. */ + if (i != size) /* Ci(B[j])=0 @ Dsj. */ tempcost += tcinsl; if (tempcost < bestcost) { sp->s_itrace = i; - sp->s_jtrace = j-1; + sp->s_jtrace = j - 1; bestcost = tempcost; } - tempcost = (sp-NROW-1)->s_cost; + tempcost = (sp - NROW - 1)->s_cost; if ((*pp)->v_color != (*vp)->v_color - || (*pp)->v_hash != (*vp)->v_hash) + || (*pp)->v_hash != (*vp)->v_hash) tempcost += (*vp)->v_cost; if (tempcost < bestcost) { - sp->s_itrace = i-1; - sp->s_jtrace = j-1; + sp->s_itrace = i - 1; + sp->s_jtrace = j - 1; bestcost = tempcost; } sp->s_cost = bestcost; - ++sp; /* Next column. */ + ++sp; /* Next column. */ ++vp; } ++pp; - sp1 += NROW; /* Next row. */ + sp1 += NROW; /* Next row. */ } } @@ -825,27 +859,33 @@ setscores(offs, size) { * which is acceptable because this routine is much less compute * intensive then the code that builds the score matrix! */ -VOID traceback(offs, size, i, j) { - register int itrace; - register int jtrace; - register int k; - register int ninsl; - register int ndraw; - register int ndell; - - if (i==0 && j==0) /* End of update. */ +VOID +traceback(offs, size, i, j) + int offs; + int size; + int i; + int j; +{ + int itrace; + int jtrace; + int k; + int ninsl; + int ndraw; + int ndell; + + if (i == 0 && j == 0) /* End of update. */ return; - itrace = score[(NROW*i) + j].s_itrace; - jtrace = score[(NROW*i) + j].s_jtrace; - if (itrace == i) { /* [i, j-1] */ - ninsl = 0; /* Collect inserts. */ + itrace = score[(NROW * i) + j].s_itrace; + jtrace = score[(NROW * i) + j].s_jtrace; + if (itrace == i) { /* [i, j-1] */ + ninsl = 0; /* Collect inserts. */ if (i != size) ninsl = 1; ndraw = 1; - while (itrace!=0 || jtrace!=0) { - if (score[(NROW*itrace) + jtrace].s_itrace != itrace) + while (itrace != 0 || jtrace != 0) { + if (score[(NROW * itrace) + jtrace].s_itrace != itrace) break; - jtrace = score[(NROW*itrace) + jtrace].s_jtrace; + jtrace = score[(NROW * itrace) + jtrace].s_jtrace; if (i != size) ++ninsl; ++ndraw; @@ -853,34 +893,34 @@ VOID traceback(offs, size, i, j) { traceback(offs, size, itrace, jtrace); if (ninsl != 0) { ttcolor(CTEXT); - ttinsl(offs+j-ninsl, offs+size-1, ninsl); + ttinsl(offs + j - ninsl, offs + size - 1, ninsl); } - do { /* B[j], A[j] blank. */ - k = offs+j-ndraw; + do { /* B[j], A[j] blank. */ + k = offs + j - ndraw; uline(k, vscreen[k], &blanks); } while (--ndraw); return; } - if (jtrace == j) { /* [i-1, j] */ - ndell = 0; /* Collect deletes. */ + if (jtrace == j) { /* [i-1, j] */ + ndell = 0; /* Collect deletes. */ if (j != size) ndell = 1; - while (itrace!=0 || jtrace!=0) { - if (score[(NROW*itrace) + jtrace].s_jtrace != jtrace) + while (itrace != 0 || jtrace != 0) { + if (score[(NROW * itrace) + jtrace].s_jtrace != jtrace) break; - itrace = score[(NROW*itrace) + jtrace].s_itrace; + itrace = score[(NROW * itrace) + jtrace].s_itrace; if (j != size) ++ndell; } if (ndell != 0) { ttcolor(CTEXT); - ttdell(offs+i-ndell, offs+size-1, ndell); + ttdell(offs + i - ndell, offs + size - 1, ndell); } traceback(offs, size, itrace, jtrace); return; } traceback(offs, size, itrace, jtrace); - k = offs+j-1; - uline(k, vscreen[k], pscreen[offs+i-1]); + k = offs + j - 1; + uline(k, vscreen[k], pscreen[offs + i - 1]); } #endif diff --git a/usr.bin/mg/echo.c b/usr.bin/mg/echo.c index 3663cda638c..775be72fa7e 100644 --- a/usr.bin/mg/echo.c +++ b/usr.bin/mg/echo.c @@ -6,46 +6,39 @@ * of the display screen. Used by the entire * known universe. */ -/* - * The varargs lint directive comments are 0 an attempt to get lint to shup - * up about CORRECT usage of varargs.h. It won't. - */ #include "def.h" #include "key.h" -#ifdef LOCAL_VARARGS -#include "varargs.h" +#ifdef __STDC__ +#include #else #include #endif #ifndef NO_MACRO -# include "macro.h" +#include "macro.h" #endif -static int veread(); -VOID ewprintf(); -static VOID eformat(); -static VOID eputi(); -static VOID eputl(); -static VOID eputs(); -static VOID eputc(); -static int complt(); -static int complt_list(); -LIST * make_file_list(); -LIST * copy_list(); -char * strrchr(); -extern LIST * complete_function_list(); - -int epresf = FALSE; /* Stuff in echo line flag. */ +static VOID eformat __P((const char *, va_list)); +static int veread __P((const char *, char *buf, int, int, va_list)); +static VOID eputi __P((int, int)); +static VOID eputl __P((long, int)); +static VOID eputs __P((char *)); +static VOID eputc __P((char)); +static int complt __P((int, int, char *, int)); +static int complt_list __P((int, int, char *, int)); +static LIST *copy_list __P((LIST *)); +static VOID free_file_list __P((LIST *)); -extern int tthue; +int epresf = FALSE; /* Stuff in echo line flag. */ /* * Erase the echo line. */ VOID -eerase() { +eerase() +{ + ttcolor(CTEXT); - ttmove(nrow-1, 0); + ttmove(nrow - 1, 0); tteeol(); ttflush(); epresf = FALSE; @@ -58,60 +51,75 @@ eerase() { * for "no" and TRUE for "yes". No formatting * services are available. No newline required. */ -eyorn(sp) char *sp; { - register int s; +int +eyorn(sp) + char *sp; +{ + int s; #ifndef NO_MACRO - if(inmacro) return TRUE; + if (inmacro) + return TRUE; #endif ewprintf("%s? (y or n) ", sp); for (;;) { s = getkey(FALSE); - if (s == 'y' || s == 'Y') return TRUE; - if (s == 'n' || s == 'N') return FALSE; - if (s == CCHR('G')) return ctrlg(FFRAND, 1); + if (s == 'y' || s == 'Y') + return TRUE; + if (s == 'n' || s == 'N') + return FALSE; + if (s == CCHR('G')) + return ctrlg(FFRAND, 1); ewprintf("Please answer y or n. %s? (y or n) ", sp); } - /*NOTREACHED*/ + /* NOTREACHED */ } /* * Like eyorn, but for more important question. User must type either all of * "yes" or "no", and the trainling newline. */ -eyesno(sp) char *sp; { - register int s; - char buf[64]; +int +eyesno(sp) + char *sp; +{ + int s; + char buf[64]; #ifndef NO_MACRO - if(inmacro) return TRUE; + if (inmacro) + return TRUE; #endif s = ereply("%s? (yes or no) ", buf, sizeof(buf), sp); for (;;) { - if (s == ABORT) return ABORT; + if (s == ABORT) + return ABORT; if (s != FALSE) { #ifndef NO_MACRO if (macrodef) { - LINE *lp = maclcur; + LINE *lp = maclcur; - maclcur = lp->l_bp; - maclcur->l_fp = lp->l_fp; - free((char *)lp); + maclcur = lp->l_bp; + maclcur->l_fp = lp->l_fp; + free((char *) lp); } #endif if ((buf[0] == 'y' || buf[0] == 'Y') - && (buf[1] == 'e' || buf[1] == 'E') - && (buf[2] == 's' || buf[2] == 'S') - && (buf[3] == '\0')) return TRUE; + && (buf[1] == 'e' || buf[1] == 'E') + && (buf[2] == 's' || buf[2] == 'S') + && (buf[3] == '\0')) + return TRUE; if ((buf[0] == 'n' || buf[0] == 'N') - && (buf[1] == 'o' || buf[0] == 'O') - && (buf[2] == '\0')) return FALSE; + && (buf[1] == 'o' || buf[0] == 'O') + && (buf[2] == '\0')) + return FALSE; } s = ereply("Please answer yes or no. %s? (yes or no) ", buf, sizeof(buf), sp); } - /*NOTREACHED*/ + /* NOTREACHED */ } + /* * Write out a prompt, and read back a * reply. The prompt is now written out with full "ewprintf" @@ -119,21 +127,30 @@ eyesno(sp) char *sp; { * place. This is always a new message, there is no auto * completion, and the return is echoed as such. */ -/*VARARGS 0*/ +/* VARARGS */ +int +#ifdef __STDC__ +ereply(const char *fmt, char *buf, int nbuf, ...) +#else ereply(va_alist) -va_dcl + va_dcl +#endif { - va_list pvar; - register char *fp, *buf; - register int nbuf; - register int i; - - va_start(pvar); - fp = va_arg(pvar, char *); - buf = va_arg(pvar, char *); - nbuf = va_arg(pvar, int); - i = veread(fp, buf, nbuf, EFNEW|EFCR, &pvar); - va_end(pvar); + va_list ap; + int i; +#ifdef __STDC__ + va_start(ap, nbuf); +#else + char *fmt, *buf; + int nbuf; + + va_start(ap); + fmt = va_arg(ap, char *); + buf = va_arg(ap, char *); + nbuf = va_arg(ap, int); +#endif + i = veread(fmt, buf, nbuf, EFNEW | EFCR, ap); + va_end(ap); return i; } @@ -146,40 +163,62 @@ va_dcl * new prompt), an EFFUNC (autocomplete), or EFCR (echo * the carriage return as CR). */ -/* VARARGS 0 */ +/* VARARGS */ +int +#ifdef __STDC__ +eread(const char *fmt, char *buf, int nbuf, int flag, ...) +#else eread(va_alist) -va_dcl + char *fmt; + char *buf; + int nbuf; + int flag; + va_dcl +#endif { - va_list pvar; - char *fp, *buf; - int nbuf, flag, i; - va_start(pvar); - fp = va_arg(pvar, char *); - buf = va_arg(pvar, char *); - nbuf = va_arg(pvar, int); - flag = va_arg(pvar, int); - i = veread(fp, buf, nbuf, flag, &pvar); - va_end(pvar); + int i; + va_list ap; +#ifdef __STDC__ + va_start(ap, flag); +#else + char *fmt, *buf; + int nbuf; + + va_start(ap); + fmt = va_arg(ap, char *); + buf = va_arg(ap, char *); + nbuf = va_arg(ap, int); + flag = va_arg(ap, int); +#endif + i = veread(fmt, buf, nbuf, flag, ap); + va_end(ap); return i; } -static veread(fp, buf, nbuf, flag, ap) char *fp; char *buf; va_list *ap; { - register int cpos; - register int i; - register int c; +static int +veread(fp, buf, nbuf, flag, ap) + const char *fp; + char *buf; + int nbuf; + int flag; + va_list ap; +{ + int cpos; + int i; + int c; #ifndef NO_MACRO - if(inmacro) { - bcopy(maclcur->l_text, buf, maclcur->l_used); - buf[maclcur->l_used] = '\0'; - maclcur = maclcur->l_fp; - return TRUE; + if (inmacro) { + bcopy(maclcur->l_text, buf, maclcur->l_used); + buf[maclcur->l_used] = '\0'; + maclcur = maclcur->l_fp; + return TRUE; } #endif cpos = 0; - if ((flag&EFNEW)!=0 || ttrow!=nrow-1) { + if ((flag & EFNEW) != 0 || ttrow != nrow - 1) { ttcolor(CTEXT); - ttmove(nrow-1, 0); + ttmove(nrow - 1, 0); epresf = TRUE; } else eputc(' '); @@ -188,50 +227,52 @@ static veread(fp, buf, nbuf, flag, ap) char *fp; char *buf; va_list *ap; { ttflush(); for (;;) { c = getkey(FALSE); - if ((flag&EFAUTO) != 0 && (c == ' ' || c == CCHR('I'))) { + if ((flag & EFAUTO) != 0 && (c == ' ' || c == CCHR('I'))) { cpos += complt(flag, c, buf, cpos); continue; } - if ((flag&EFAUTO) != 0 && c == '?') { + if ((flag & EFAUTO) != 0 && c == '?') { complt_list(flag, c, buf, cpos); continue; } switch (c) { - case CCHR('J'): - c = CCHR('M'); /* and continue */ - case CCHR('M'): /* Return, done. */ - if ((flag&EFFUNC) != 0) { + case CCHR('J'): + c = CCHR('M'); /* and continue */ + case CCHR('M'):/* Return, done. */ + if ((flag & EFFUNC) != 0) { if ((i = complt(flag, c, buf, cpos)) == 0) continue; - if (i > 0) cpos += i; + if (i > 0) + cpos += i; } buf[cpos] = '\0'; - if ((flag&EFCR) != 0) { + if ((flag & EFCR) != 0) { ttputc(CCHR('M')); ttflush(); } #ifndef NO_MACRO - if(macrodef) { - LINE *lp; - - if((lp = lalloc(cpos)) == NULL) return FALSE; - lp->l_fp = maclcur->l_fp; - maclcur->l_fp = lp; - lp->l_bp = maclcur; - maclcur = lp; - bcopy(buf, lp->l_text, cpos); + if (macrodef) { + LINE *lp; + + if ((lp = lalloc(cpos)) == NULL) + return FALSE; + lp->l_fp = maclcur->l_fp; + maclcur->l_fp = lp; + lp->l_bp = maclcur; + maclcur = lp; + bcopy(buf, lp->l_text, cpos); } #endif goto done; - case CCHR('G'): /* Bell, abort. */ + case CCHR('G'): /* Bell, abort. */ eputc(CCHR('G')); (VOID) ctrlg(FFRAND, 0); ttflush(); return ABORT; - case CCHR('H'): - case CCHR('?'): /* Rubout, erase. */ + case CCHR('H'): + case CCHR('?'): /* Rubout, erase. */ if (cpos != 0) { ttputc('\b'); ttputc(' '); @@ -247,8 +288,8 @@ static veread(fp, buf, nbuf, flag, ap) char *fp; char *buf; va_list *ap; { } break; - case CCHR('X'): /* C-X */ - case CCHR('U'): /* C-U, kill line. */ + case CCHR('X'): /* C-X */ + case CCHR('U'): /* C-U, kill line. */ while (cpos != 0) { ttputc('\b'); ttputc(' '); @@ -264,8 +305,8 @@ static veread(fp, buf, nbuf, flag, ap) char *fp; char *buf; va_list *ap; { ttflush(); break; - case CCHR('W'): /* C-W, kill to beginning of */ - /* previous word */ + case CCHR('W'): /* C-W, kill to beginning of */ + /* previous word */ /* back up to first word character or beginning */ while ((cpos > 0) && !ISWORD(buf[cpos - 1])) { ttputc('\b'); @@ -294,11 +335,11 @@ static veread(fp, buf, nbuf, flag, ap) char *fp; char *buf; va_list *ap; { ttflush(); break; - case CCHR('\\'): - case CCHR('Q'): /* C-Q, quote next */ - c = getkey(FALSE); /* and continue */ - default: /* All the rest. */ - if (cpos < nbuf-1) { + case CCHR('\\'): + case CCHR('Q'): /* C-Q, quote next */ + c = getkey(FALSE); /* and continue */ + default: /* All the rest. */ + if (cpos < nbuf - 1) { buf[cpos++] = (char) c; eputc((char) c); ttflush(); @@ -311,254 +352,270 @@ done: return buf[0] != '\0'; /* * do completion on a list of objects. */ -static int complt(flags, c, buf, cpos) -register char *buf; -register int cpos; +static int +complt(flags, c, buf, cpos) + int flags; + int c; + char *buf; + int cpos; { - register LIST *lh, *lh2; - LIST *wholelist = NULL; - int i, nxtra; - int nhits, bxtra; - int wflag = FALSE; - int msglen, nshown; - char *msg; - - if ((flags&EFFUNC) != 0) { - buf[cpos] = '\0'; - i = complete_function(buf, c); - if(i>0) { - eputs(&buf[cpos]); - ttflush(); - return i; - } - switch(i) { + LIST *lh, *lh2; + LIST *wholelist = NULL; + int i, nxtra; + int nhits, bxtra; + int wflag = FALSE; + int msglen, nshown; + char *msg; + + if ((flags & EFFUNC) != 0) { + buf[cpos] = '\0'; + i = complete_function(buf, c); + if (i > 0) { + eputs(&buf[cpos]); + ttflush(); + return i; + } + switch (i) { case -3: - msg = " [Ambiguous]"; - break; + msg = " [Ambiguous]"; + break; case -2: - i=0; - msg = " [No match]"; - break; + i = 0; + msg = " [No match]"; + break; case -1: case 0: - return i; + return i; default: - msg = " [Internal error]"; - break; - } + msg = " [Internal error]"; + break; + } } else { - if ((flags&EFBUF) != 0) lh = &(bheadp->b_list); - else if ((flags&EFFILE) != 0) { - buf[cpos] = '\0'; - wholelist = lh = make_file_list(buf,0); - } - else panic("broken complt call: flags"); + if ((flags & EFBUF) != 0) + lh = &(bheadp->b_list); + else if ((flags & EFFILE) != 0) { + buf[cpos] = '\0'; + wholelist = lh = make_file_list(buf, 0); + } else + panic("broken complt call: flags"); - if (c == ' ') wflag = TRUE; - else if (c != '\t' && c != CCHR('M')) panic("broken complt call: c"); + if (c == ' ') + wflag = TRUE; + else if (c != '\t' && c != CCHR('M')) + panic("broken complt call: c"); - nhits = 0; - nxtra = HUGE; + nhits = 0; + nxtra = HUGE; - while (lh != NULL) { - for (i=0; il_name[i]) - break; - } - if (i == cpos) { - if (nhits == 0) - lh2 = lh; - ++nhits; - if (lh->l_name[i] == '\0') nxtra = -1; - else { - bxtra = getxtra(lh, lh2, cpos, wflag); - if (bxtra < nxtra) nxtra = bxtra; - lh2 = lh; + while (lh != NULL) { + for (i = 0; i < cpos; ++i) { + if (buf[i] != lh->l_name[i]) + break; + } + if (i == cpos) { + if (nhits == 0) + lh2 = lh; + ++nhits; + if (lh->l_name[i] == '\0') + nxtra = -1; + else { + bxtra = getxtra(lh, lh2, cpos, wflag); + if (bxtra < nxtra) + nxtra = bxtra; + lh2 = lh; + } } + lh = lh->l_next; } - lh = lh->l_next; - } - if (nhits == 0) - msg = " [No match]"; - else if (nhits > 1 && nxtra == 0) - msg = " [Ambiguous]"; - else { /* Got a match, do it to it */ - /* - * Being lazy - ought to check length, but all things - * autocompleted have known types/lengths. - */ - if (nxtra < 0 && nhits > 1 && c == ' ') nxtra = 1; - for (i = 0; i < nxtra; ++i) { - buf[cpos] = lh2->l_name[cpos]; - eputc(buf[cpos++]); + if (nhits == 0) + msg = " [No match]"; + else if (nhits > 1 && nxtra == 0) + msg = " [Ambiguous]"; + else { /* Got a match, do it to it */ + /* + * Being lazy - ought to check length, but all things + * autocompleted have known types/lengths. + */ + if (nxtra < 0 && nhits > 1 && c == ' ') + nxtra = 1; + for (i = 0; i < nxtra; ++i) { + buf[cpos] = lh2->l_name[cpos]; + eputc(buf[cpos++]); + } + ttflush(); + free_file_list(wholelist); + if (nxtra < 0 && c != CCHR('M')) + return 0; + return nxtra; } - ttflush(); - free_file_list(wholelist); - if (nxtra < 0 && c != CCHR('M')) return 0; - return nxtra; - } } - /* wholelist is null if we are doing buffers. want to free - * lists that were created for us, but not the buffer list! */ + /* + * wholelist is null if we are doing buffers. want to free lists + * that were created for us, but not the buffer list! + */ free_file_list(wholelist); /* Set up backspaces, etc., being mindful of echo line limit */ msglen = strlen(msg); nshown = (ttcol + msglen + 2 > ncol) ? - ncol - ttcol - 2 : msglen; + ncol - ttcol - 2 : msglen; eputs(msg); - ttcol -= (i = nshown); /* update ttcol! */ - while (i--) /* move back before msg */ + ttcol -= (i = nshown); /* update ttcol! */ + while (i--) /* move back before msg */ ttputc('\b'); - ttflush(); /* display to user */ + ttflush(); /* display to user */ i = nshown; - while (i--) /* blank out on next flush */ + while (i--) /* blank out on next flush */ eputc(' '); - ttcol -= (i = nshown); /* update ttcol on BS's */ + ttcol -= (i = nshown); /* update ttcol on BS's */ while (i--) - ttputc('\b'); /* update ttcol again! */ + ttputc('\b'); /* update ttcol again! */ return 0; } /* * do completion on a list of objects, listing instead of completing */ -static int complt_list(flags, c, buf, cpos) -register char *buf; -register int cpos; +static int +complt_list(flags, c, buf, cpos) + int flags; + int c; + char *buf; + int cpos; { - register LIST *lh, *lh2, *lh3; - LIST *wholelist = NULL; - int i,maxwidth,width; - int preflen = 0; - BUFFER *bp; - static VOID findbind(); - int oldrow = ttrow; - int oldcol = ttcol; - int oldhue = tthue; - char linebuf[NCOL+1]; - char *cp; + LIST *lh, *lh2, *lh3; + LIST *wholelist = NULL; + int i, maxwidth, width; + int preflen = 0; + BUFFER *bp; + int oldrow = ttrow; + int oldcol = ttcol; + int oldhue = tthue; + char linebuf[NCOL + 1]; + char *cp; ttflush(); /* the results are put into a help buffer */ - bp = bfind("*help*", TRUE); - if(bclear(bp) == FALSE) return FALSE; + if (bclear(bp) == FALSE) + return FALSE; - { /* this {} present for historical reasons */ + { /* this {} present for historical reasons */ -/* - * first get the list of objects. This list may contain only the - * ones that complete what has been typed, or may be the whole list - * of all objects of this type. They are filtered later in any case. - * set wholelist if the list has been cons'ed up just for us, so we - * can free it later. We have to copy the buffer list for this - * function even though we didn't for complt. The sorting code - * does destructive changes to the list, which we don't want to - * happen to the main buffer list! - */ - if ((flags&EFBUF) != 0) - wholelist = lh = copy_list (&(bheadp->b_list)); - else if ((flags&EFFUNC) != 0) { - buf[cpos] = '\0'; - wholelist = lh = complete_function_list(buf, c); - } - else if ((flags&EFFILE) != 0) { - buf[cpos] = '\0'; - wholelist = lh = make_file_list(buf,1); /* - * we don't want to display stuff up to the / for file names - * preflen is the list of a prefix of what the user typed - * that should not be displayed. + * first get the list of objects. This list may contain only + * the ones that complete what has been typed, or may be the + * whole list of all objects of this type. They are filtered + * later in any case. Set wholelist if the list has been + * cons'ed up just for us, so we can free it later. We have + * to copy the buffer list for this function even though we + * didn't for complt. The sorting code does destructive + * changes to the list, which we don't want to happen to the + * main buffer list! */ - cp = strrchr(buf,'/'); - if (cp) - preflen = cp - buf + 1; - } - else panic("broken complt call: flags"); - - -/* sort the list, since users expect to see it in alphabetic order */ - - lh2 = lh; - while (lh2) { - lh3 = lh2->l_next; - while (lh3) { - if (strcmp(lh2->l_name, lh3->l_name) > 0) { - cp = lh2->l_name; - lh2->l_name = lh3->l_name; - lh3->l_name = cp; - } - lh3 = lh3->l_next; - } - lh2 = lh2->l_next; - } + if ((flags & EFBUF) != 0) + wholelist = lh = copy_list(&(bheadp->b_list)); + else if ((flags & EFFUNC) != 0) { + buf[cpos] = '\0'; + wholelist = lh = complete_function_list(buf, c); + } else if ((flags & EFFILE) != 0) { + buf[cpos] = '\0'; + wholelist = lh = make_file_list(buf, 1); + /* + * We don't want to display stuff up to the / for file + * names preflen is the list of a prefix of what the + * user typed that should not be displayed. + */ + cp = strrchr(buf, '/'); + if (cp) + preflen = cp - buf + 1; + } else + panic("broken complt call: flags"); -/* - * first find max width of object to be displayed, so we can - * put several on a line - */ - maxwidth = 0; - lh2 = lh; - while (lh2 != NULL) { - for (i=0; il_name[i]) - break; - } - if (i == cpos) { - width = strlen(lh2->l_name); - if (width > maxwidth) - maxwidth = width; + /* + * Sort the list, since users expect to see it in alphabetic + * order. + */ + lh2 = lh; + while (lh2) { + lh3 = lh2->l_next; + while (lh3) { + if (strcmp(lh2->l_name, lh3->l_name) > 0) { + cp = lh2->l_name; + lh2->l_name = lh3->l_name; + lh3->l_name = cp; + } + lh3 = lh3->l_next; + } + lh2 = lh2->l_next; } - lh2 = lh2->l_next; - } - maxwidth += 1 - preflen; -/* - * now do the display. objects are written into linebuf until it - * fills, and then put into the help buffer. - */ - cp = linebuf; - width = 0; - lh2 = lh; - while (lh2 != NULL) { - for (i=0; il_name[i]) - break; + /* + * First find max width of object to be displayed, so we can + * put several on a line. + */ + maxwidth = 0; + lh2 = lh; + while (lh2 != NULL) { + for (i = 0; i < cpos; ++i) { + if (buf[i] != lh2->l_name[i]) + break; + } + if (i == cpos) { + width = strlen(lh2->l_name); + if (width > maxwidth) + maxwidth = width; + } + lh2 = lh2->l_next; } - if (i == cpos) { - if ((width + maxwidth) > ncol) { - *cp = 0; - addline(bp,linebuf); - cp = linebuf; - width = 0; + maxwidth += 1 - preflen; + + /* + * Now do the display. objects are written into linebuf until + * it fills, and then put into the help buffer. + */ + cp = linebuf; + width = 0; + lh2 = lh; + while (lh2 != NULL) { + for (i = 0; i < cpos; ++i) { + if (buf[i] != lh2->l_name[i]) + break; } - strcpy(cp,lh2->l_name+preflen); - i = strlen(lh2->l_name+preflen); - cp += i; - for (; i < maxwidth; i++) - *cp++ = ' '; - width += maxwidth; + if (i == cpos) { + if ((width + maxwidth) > ncol) { + *cp = 0; + addline(bp, linebuf); + cp = linebuf; + width = 0; + } + strcpy(cp, lh2->l_name + preflen); + i = strlen(lh2->l_name + preflen); + cp += i; + for (; i < maxwidth; i++) + *cp++ = ' '; + width += maxwidth; + } + lh2 = lh2->l_next; + } + if (width > 0) { + *cp = 0; + addline(bp, linebuf); } - lh2 = lh2->l_next; - } - if (width > 0) { - *cp = 0; - addline(bp,linebuf); - } - } - /* - * note that we free lists only if they are put in wholelist - * lists that were built just for us should be freed. However - * when we use the buffer list, obviously we don't want it - * freed. + } + /* + * Note that we free lists only if they are put in wholelist lists + * that were built just for us should be freed. However when we use + * the buffer list, obviously we don't want it freed. */ free_file_list(wholelist); - popbuftop(bp); /* split the screen and put up the help buffer */ - update(); /* needed to make the new stuff actually appear */ - ttmove(oldrow,oldcol); /* update leaves cursor in arbitrary place */ - ttcolor(oldhue); /* with arbitrary color */ + popbuftop(bp); /* split the screen and put up the help + * buffer */ + update(); /* needed to make the new stuff actually + * appear */ + ttmove(oldrow, oldcol); /* update leaves cursor in arbitrary place */ + ttcolor(oldhue); /* with arbitrary color */ ttflush(); return 0; } @@ -569,16 +626,24 @@ register int cpos; * Return the longest block of characters that can be * autocompleted at this point. Sometimes the two * symbols are the same, but this is normal. - */ -getxtra(lp1, lp2, cpos, wflag) register LIST *lp1, *lp2; register int wflag; { - register int i; + */ +int +getxtra(lp1, lp2, cpos, wflag) + LIST *lp1, *lp2; + int cpos; + int wflag; +{ + int i; i = cpos; for (;;) { - if (lp1->l_name[i] != lp2->l_name[i]) break; - if (lp1->l_name[i] == '\0') break; + if (lp1->l_name[i] != lp2->l_name[i]) + break; + if (lp1->l_name[i] == '\0') + break; ++i; - if (wflag && !ISWORD(lp1->l_name[i-1])) break; + if (wflag && !ISWORD(lp1->l_name[i - 1])) + break; } return (i - cpos); } @@ -590,23 +655,34 @@ getxtra(lp1, lp2, cpos, wflag) register LIST *lp1, *lp2; register int wflag; { * echo line. The formatting is done by a call * to the standard formatting routine. */ -/*VARARGS 0 */ +/* VARARGS */ VOID +#ifdef __STDC__ +ewprintf(const char *fmt, ...) +#else ewprintf(va_alist) -va_dcl + va_dcl +#endif { - va_list pvar; - register char *fp; + va_list ap; +#ifndef __STDC__ + char *fmt; +#endif #ifndef NO_MACRO - if(inmacro) return; + if (inmacro) + return; +#endif +#ifdef __STDC__ + va_start(ap, fmt); +#else + va_start(ap); + fmt = va_arg(ap, char *); #endif - va_start(pvar); - fp = va_arg(pvar, char *); ttcolor(CTEXT); - ttmove(nrow-1, 0); - eformat(fp, &pvar); - va_end(pvar); + ttmove(nrow - 1, 0); + eformat(fmt, ap); + va_end(ap); tteeol(); ttflush(); epresf = TRUE; @@ -623,13 +699,12 @@ va_dcl */ static VOID eformat(fp, ap) -register char *fp; -register va_list *ap; + const char *fp; + va_list ap; { - register int c; - char kname[NKNAME]; - char *keyname(); - char *cp; + int c; + char kname[NKNAME]; + char *cp; while ((c = *fp++) != '\0') { if (c != '%') @@ -638,37 +713,37 @@ register va_list *ap; c = *fp++; switch (c) { case 'c': - (VOID) keyname(kname, va_arg(*ap, int)); + (VOID) keyname(kname, va_arg(ap, int)); eputs(kname); break; case 'k': cp = kname; - for(c=0; c < key.k_count; c++) { - cp = keyname(cp, key.k_chars[c]); - *cp++ = ' '; + for (c = 0; c < key.k_count; c++) { + cp = keyname(cp, key.k_chars[c]); + *cp++ = ' '; } *--cp = '\0'; eputs(kname); break; case 'd': - eputi(va_arg(*ap, int), 10); + eputi(va_arg(ap, int), 10); break; case 'o': - eputi(va_arg(*ap, int), 8); + eputi(va_arg(ap, int), 8); break; case 's': - eputs(va_arg(*ap, char *)); + eputs(va_arg(ap, char *)); break; - case 'l':/* explicit longword */ + case 'l': /* explicit longword */ c = *fp++; - switch(c) { + switch (c) { case 'd': - eputl((long)va_arg(*ap, long), 10); + eputl((long) va_arg(ap, long), 10); break; default: eputc(c); @@ -688,18 +763,18 @@ register va_list *ap; */ static VOID eputi(i, r) -register int i; -register int r; + int i; + int r; { - register int q; + int q; - if(i<0) { - eputc('-'); - i = -i; + if (i < 0) { + eputc('-'); + i = -i; } - if ((q=i/r) != 0) + if ((q = i / r) != 0) eputi(q, r); - eputc(i%r+'0'); + eputc(i % r + '0'); } /* @@ -707,18 +782,18 @@ register int r; */ static VOID eputl(l, r) -register long l; -register int r; + long l; + int r; { - register long q; + long q; - if(l < 0) { - eputc('-'); - l = -l; + if (l < 0) { + eputc('-'); + l = -l; } - if ((q=l/r) != 0) + if ((q = l / r) != 0) eputl(q, r); - eputc((int)(l%r)+'0'); + eputc((int) (l % r) + '0'); } /* @@ -726,9 +801,9 @@ register int r; */ static VOID eputs(s) -register char *s; + char *s; { - register int c; + int c; while ((c = *s++) != '\0') eputc(c); @@ -741,9 +816,10 @@ register char *s; */ static VOID eputc(c) -register char c; + char c; { - if (ttcol+2 < ncol) { + + if (ttcol + 2 < ncol) { if (ISCTRL(c)) { eputc('^'); c = CCHR(c); @@ -753,29 +829,32 @@ register char c; } } +static VOID free_file_list(lp) - LIST *lp; + LIST *lp; { -LIST *next; -while (lp) { - next = lp->l_next; - free(lp); - lp = next; -} + LIST *next; + + while (lp) { + next = lp->l_next; + free(lp); + lp = next; + } } -LIST *copy_list(lp) - LIST *lp; +static LIST * +copy_list(lp) + LIST *lp; { -LIST *current,*last; - -last = NULL; -while(lp) { - current = (LIST *)malloc(sizeof(LIST)); - current->l_next = last; - current->l_name = lp->l_name; - last = (LIST *)current; - lp = lp->l_next; -} -return(last); + LIST *current, *last; + + last = NULL; + while (lp) { + current = (LIST *) malloc(sizeof(LIST)); + current->l_next = last; + current->l_name = lp->l_name; + last = (LIST *) current; + lp = lp->l_next; + } + return (last); } diff --git a/usr.bin/mg/extend.c b/usr.bin/mg/extend.c index f9f0ba95061..774dbbfc06b 100644 --- a/usr.bin/mg/extend.c +++ b/usr.bin/mg/extend.c @@ -1,5 +1,5 @@ /* - * Extended (M-X) commands, rebinding, and + * Extended (M-X) commands, rebinding, and * startup file processing. */ #include "def.h" @@ -13,46 +13,57 @@ #include "key.h" #ifndef NO_STARTUP #ifndef BINDKEY -#define BINDKEY /* bindkey is used by FKEYS startup code */ +#define BINDKEY /* bindkey is used by FKEYS startup code */ #endif #endif #endif -extern int rescan(); +static KEYMAP *realocmap __P((KEYMAP *)); +static VOID fixmap __P((KEYMAP *, KEYMAP*, KEYMAP*)); +static char *skipwhite __P((char *)); +static char *parsetoken __P((char *)); +int load __P((char *)); +int excline __P((char *)); /* insert a string, mainly for use from macros (created by selfinsert) */ -/*ARGSUSED*/ +/* ARGSUSED */ +int insert(f, n) -int f, n; + int f, n; { - register char *cp; - char buf[128]; + char *cp; + char buf[128]; #ifndef NO_MACRO - register int count; - int c; - - if(inmacro) { - while(--n >= 0) { - for(count = 0; count < maclcur->l_used; count++) { - if((((c=maclcur->l_text[count]) == '\n') ? lnewline() - : linsert(1, c)) != TRUE) return FALSE; - } + int count; + int c; + + if (inmacro) { + while (--n >= 0) { + for (count = 0; count < maclcur->l_used; count++) { + if ((((c = maclcur->l_text[count]) == '\n') + ? lnewline() : linsert(1, c)) != TRUE) + return FALSE; + } + } + maclcur = maclcur->l_fp; + return TRUE; } - maclcur = maclcur->l_fp; - return TRUE; - } - if(n==1) thisflag |= CFINS; /* CFINS means selfinsert can tack on end */ + if (n == 1) + thisflag |= CFINS; /* CFINS means selfinsert can tack on + * end */ #endif - if(eread("Insert: ", buf, sizeof(buf), EFNEW) == FALSE) return FALSE; - while(--n >= 0) { - cp = buf; - while(*cp) { - if(((*cp == '\n') ? lnewline() : linsert(1, *cp)) != TRUE) + if (eread("Insert: ", buf, sizeof(buf), EFNEW) == FALSE) return FALSE; - cp++; + while (--n >= 0) { + cp = buf; + while (*cp) { + if (((*cp == '\n') ? lnewline() : linsert(1, *cp)) + != TRUE) + return FALSE; + cp++; + } } - } - return TRUE; + return TRUE; } /* @@ -67,273 +78,301 @@ int f, n; * don't have them. Care is taken so running out of memory will leave * the keymap in a usable state. */ -static int remap(curmap, c, funct, pref_map) -register KEYMAP *curmap;/* pointer to the map being changed */ -int c; /* character being changed */ -PF funct; /* function being changed to */ -KEYMAP *pref_map; /* if funct==prefix, map to bind to or NULL for new */ +static int +remap(curmap, c, funct, pref_map) + KEYMAP *curmap; /* pointer to the map being changed */ + int c; /* character being changed */ + PF funct; /* function being changed to */ + KEYMAP *pref_map; /* if funct==prefix, map to bind to or + NULL for new */ /* extern MAP_ELEMENT *ele; must be set before calling */ { - register int i; - int n1, n2, nold; - KEYMAP *mp; - PF *pfp; - MAP_ELEMENT *mep; - static KEYMAP *realocmap(); - - if(ele >= &curmap->map_element[curmap->map_num] || c < ele->k_base) { - if(ele > &curmap->map_element[0] && (funct!=prefix || - (ele-1)->k_prefmap==NULL)) { - n1 = c - (ele-1)->k_num; - } else n1 = HUGE; - if(ele < &curmap->map_element[curmap->map_num] && (funct!=prefix || - ele->k_prefmap==NULL)) { - n2 = ele->k_base - c; - } else n2 = HUGE; - if(n1 <= MAPELEDEF && n1 <= n2) { - ele--; - if((pfp = (PF *)malloc((unsigned)(c - ele->k_base+1) - * sizeof(PF))) == NULL) { - ewprintf("Out of memory"); - return FALSE; - } - nold = ele->k_num - ele->k_base + 1; - for(i=0; i < nold; i++) - pfp[i] = ele->k_funcp[i]; - while(--n1) pfp[i++] = curmap->map_default; - pfp[i] = funct; - ele->k_num = c; - ele->k_funcp = pfp; - } else if(n2 <= MAPELEDEF) { - if((pfp = (PF *)malloc((unsigned)(ele->k_num - c + 1) - * sizeof(PF))) == NULL) { - ewprintf("Out of memory"); - return FALSE; - } - nold = ele->k_num - ele->k_base + 1; - for(i=0; i < nold; i++) - pfp[i+n2] = ele->k_funcp[i]; - while(--n2) pfp[n2] = curmap->map_default; - pfp[0] = funct; - ele->k_base = c; - ele->k_funcp = pfp; - } else { - if(curmap->map_num >= curmap->map_max && - (curmap = realocmap(curmap)) == NULL) return FALSE; - if((pfp = (PF *)malloc(sizeof(PF))) == NULL) { - ewprintf("Out of memory"); - return FALSE; - } - pfp[0] = funct; - for(mep = &curmap->map_element[curmap->map_num]; mep > ele; mep--) { - mep->k_base = (mep-1)->k_base; - mep->k_num = (mep-1)->k_num; - mep->k_funcp = (mep-1)->k_funcp; - mep->k_prefmap = (mep-1)->k_prefmap; - } - ele->k_base = c; - ele->k_num = c; - ele->k_funcp = pfp; - ele->k_prefmap = NULL; - curmap->map_num++; - } - if(funct == prefix) { - if(pref_map != NULL) { - ele->k_prefmap = pref_map; + int i; + int n1, n2, nold; + KEYMAP *mp; + PF *pfp; + MAP_ELEMENT *mep; + + if (ele >= &curmap->map_element[curmap->map_num] || c < ele->k_base) { + if (ele > &curmap->map_element[0] && (funct != prefix || + (ele - 1)->k_prefmap == NULL)) { + n1 = c - (ele - 1)->k_num; + } else + n1 = HUGE; + if (ele < &curmap->map_element[curmap->map_num] && + (funct != prefix || ele->k_prefmap == NULL)) { + n2 = ele->k_base - c; + } else + n2 = HUGE; + if (n1 <= MAPELEDEF && n1 <= n2) { + ele--; + if ((pfp = (PF *) malloc((c - ele->k_base + 1) * + sizeof(PF))) == NULL) { + ewprintf("Out of memory"); + return FALSE; + } + nold = ele->k_num - ele->k_base + 1; + for (i = 0; i < nold; i++) + pfp[i] = ele->k_funcp[i]; + while (--n1) + pfp[i++] = curmap->map_default; + pfp[i] = funct; + ele->k_num = c; + ele->k_funcp = pfp; + } else if (n2 <= MAPELEDEF) { + if ((pfp = (PF *) malloc((ele->k_num - c + 1) + * sizeof(PF))) == NULL) { + ewprintf("Out of memory"); + return FALSE; + } + nold = ele->k_num - ele->k_base + 1; + for (i = 0; i < nold; i++) + pfp[i + n2] = ele->k_funcp[i]; + while (--n2) + pfp[n2] = curmap->map_default; + pfp[0] = funct; + ele->k_base = c; + ele->k_funcp = pfp; } else { - if((mp = (KEYMAP *)malloc(sizeof(KEYMAP) + - (MAPINIT-1)*sizeof(MAP_ELEMENT))) == NULL) { - ewprintf("Out of memory"); - ele->k_funcp[c - ele->k_base] = curmap->map_default; - return FALSE; - } - mp->map_num = 0; - mp->map_max = MAPINIT; - mp->map_default = rescan; - ele->k_prefmap = mp; - } - } - } else { - n1 = c - ele->k_base; - if(ele->k_funcp[n1] == funct && (funct!=prefix || pref_map==NULL || - pref_map==ele->k_prefmap)) - return TRUE; /* no change */ - if(funct!=prefix || ele->k_prefmap==NULL) { - if(ele->k_funcp[n1] == prefix) - ele->k_prefmap = (KEYMAP *)NULL; - ele->k_funcp[n1] = funct; /* easy case */ - if(funct==prefix) { - if(pref_map!=NULL) - ele->k_prefmap = pref_map; - else { - if((mp = (KEYMAP *)malloc(sizeof(KEYMAP) + - (MAPINIT-1)*sizeof(MAP_ELEMENT))) == NULL) { - ewprintf("Out of memory"); - ele->k_funcp[c - ele->k_base] = curmap->map_default; - return FALSE; + if (curmap->map_num >= curmap->map_max && + (curmap = realocmap(curmap)) == NULL) + return FALSE; + if ((pfp = (PF *) malloc(sizeof(PF))) == NULL) { + ewprintf("Out of memory"); + return FALSE; + } + pfp[0] = funct; + for (mep = &curmap->map_element[curmap->map_num]; + mep > ele; mep--) { + mep->k_base = (mep - 1)->k_base; + mep->k_num = (mep - 1)->k_num; + mep->k_funcp = (mep - 1)->k_funcp; + mep->k_prefmap = (mep - 1)->k_prefmap; } - mp->map_num = 0; - mp->map_max = MAPINIT; - mp->map_default = rescan; - ele->k_prefmap = mp; - } + ele->k_base = c; + ele->k_num = c; + ele->k_funcp = pfp; + ele->k_prefmap = NULL; + curmap->map_num++; } - } else { - /* this case is the splits */ - /* determine which side of the break c goes on */ - /* 0 = after break; 1 = before break */ - n2 = 1; - for(i=0; n2 && i < n1; i++) - n2 &= ele->k_funcp[i] != prefix; - if(curmap->map_num >= curmap->map_max && - (curmap = realocmap(curmap)) == NULL) return FALSE; - if((pfp = (PF *)malloc((unsigned)(ele->k_num - c + !n2) - * sizeof(PF))) == NULL) { - ewprintf("Out of memory"); - return FALSE; + if (funct == prefix) { + if (pref_map != NULL) { + ele->k_prefmap = pref_map; + } else { + if (!(mp = (KEYMAP *) malloc(sizeof(KEYMAP) + + (MAPINIT - 1) * sizeof(MAP_ELEMENT)))) { + ewprintf("Out of memory"); + ele->k_funcp[c - ele->k_base] = + curmap->map_default; + return FALSE; + } + mp->map_num = 0; + mp->map_max = MAPINIT; + mp->map_default = rescan; + ele->k_prefmap = mp; + } } - ele->k_funcp[n1] = prefix; - for(i=n1+n2; i <= ele->k_num - ele->k_base; i++) - pfp[i-n1-n2] = ele->k_funcp[i]; - for(mep = &curmap->map_element[curmap->map_num]; mep > ele; mep--) { - mep->k_base = (mep-1)->k_base; - mep->k_num = (mep-1)->k_num; - mep->k_funcp = (mep-1)->k_funcp; - mep->k_prefmap = (mep-1)->k_prefmap; + } else { + n1 = c - ele->k_base; + if (ele->k_funcp[n1] == funct && (funct != prefix || + pref_map == NULL || pref_map == ele->k_prefmap)) + return TRUE; /* no change */ + if (funct != prefix || ele->k_prefmap == NULL) { + if (ele->k_funcp[n1] == prefix) + ele->k_prefmap = (KEYMAP *) NULL; + ele->k_funcp[n1] = funct; /* easy case */ + if (funct == prefix) { + if (pref_map != NULL) + ele->k_prefmap = pref_map; + else { + if (!(mp = malloc(sizeof(KEYMAP) + + (MAPINIT - 1) * sizeof(MAP_ELEMENT)))) { + ewprintf("Out of memory"); + ele->k_funcp[c - ele->k_base] = + curmap->map_default; + return FALSE; + } + mp->map_num = 0; + mp->map_max = MAPINIT; + mp->map_default = rescan; + ele->k_prefmap = mp; + } + } + } else { + /* + * This case is the splits + * determine which side of the break c goes on + * 0 = after break; 1 = before break + */ + n2 = 1; + for (i = 0; n2 && i < n1; i++) + n2 &= ele->k_funcp[i] != prefix; + if (curmap->map_num >= curmap->map_max && + (curmap = realocmap(curmap)) == NULL) + return FALSE; + if (!(pfp = malloc((ele->k_num - c + !n2) * sizeof(PF)))) { + ewprintf("Out of memory"); + return FALSE; + } + ele->k_funcp[n1] = prefix; + for (i = n1 + n2; i <= ele->k_num - ele->k_base; i++) + pfp[i - n1 - n2] = ele->k_funcp[i]; + for (mep = &curmap->map_element[curmap->map_num]; + mep > ele; mep--) { + mep->k_base = (mep - 1)->k_base; + mep->k_num = (mep - 1)->k_num; + mep->k_funcp = (mep - 1)->k_funcp; + mep->k_prefmap = (mep - 1)->k_prefmap; + } + ele->k_num = c - !n2; + (ele + 1)->k_base = c + n2; + (ele + 1)->k_funcp = pfp; + ele += !n2; + ele->k_prefmap = NULL; + curmap->map_num++; + if (pref_map == NULL) { + if ((mp = malloc(sizeof(KEYMAP) + (MAPINIT - 1) + * sizeof(MAP_ELEMENT))) == NULL) { + ewprintf("Out of memory"); + ele->k_funcp[c - ele->k_base] = + curmap->map_default; + return FALSE; + } + mp->map_num = 0; + mp->map_max = MAPINIT; + mp->map_default = rescan; + ele->k_prefmap = mp; + } else + ele->k_prefmap = pref_map; } - ele->k_num = c - !n2; - (ele+1)->k_base = c + n2; - (ele+1)->k_funcp = pfp; - ele += !n2; - ele->k_prefmap = NULL; - curmap->map_num++; - if(pref_map == NULL) { - if((mp = (KEYMAP *)malloc(sizeof(KEYMAP) + - (MAPINIT-1)*sizeof(MAP_ELEMENT))) == NULL) { - ewprintf("Out of memory"); - ele->k_funcp[c - ele->k_base] = curmap->map_default; - return FALSE; - } - mp->map_num = 0; - mp->map_max = MAPINIT; - mp->map_default = rescan; - ele->k_prefmap = mp; - } else ele->k_prefmap = pref_map; - } } return TRUE; } -/* reallocate a keymap, used above */ -static KEYMAP *realocmap(curmap) -register KEYMAP *curmap; +/* + * Reallocate a keymap, used above. + */ +static KEYMAP * +realocmap(curmap) + KEYMAP *curmap; { - register KEYMAP *mp; - register int i; - static VOID fixmap(); - extern int nmaps; - - if((mp = (KEYMAP *)malloc((unsigned)(sizeof(KEYMAP)+ - (curmap->map_max+(MAPGROW-1))*sizeof(MAP_ELEMENT)))) == NULL) { - ewprintf("Out of memory"); - return NULL; - } - mp->map_num = curmap->map_num; - mp->map_max = curmap->map_max + MAPGROW; - mp->map_default = curmap->map_default; - for(i=curmap->map_num; i--; ) { - mp->map_element[i].k_base = curmap->map_element[i].k_base; - mp->map_element[i].k_num = curmap->map_element[i].k_num; - mp->map_element[i].k_funcp = curmap->map_element[i].k_funcp; - mp->map_element[i].k_prefmap = curmap->map_element[i].k_prefmap; - } - for(i=nmaps; i--; ) { - if(map_table[i].p_map == curmap) map_table[i].p_map = mp; - else fixmap(curmap, mp, map_table[i].p_map); - } - ele = &mp->map_element[ele - &curmap->map_element[0]]; - return mp; + KEYMAP *mp; + int i; + extern int nmaps; + + if ((mp = (KEYMAP *) malloc((unsigned) (sizeof(KEYMAP) + + (curmap->map_max + (MAPGROW - 1)) * sizeof(MAP_ELEMENT)))) == NULL) { + ewprintf("Out of memory"); + return NULL; + } + mp->map_num = curmap->map_num; + mp->map_max = curmap->map_max + MAPGROW; + mp->map_default = curmap->map_default; + for (i = curmap->map_num; i--;) { + mp->map_element[i].k_base = curmap->map_element[i].k_base; + mp->map_element[i].k_num = curmap->map_element[i].k_num; + mp->map_element[i].k_funcp = curmap->map_element[i].k_funcp; + mp->map_element[i].k_prefmap = curmap->map_element[i].k_prefmap; + } + for (i = nmaps; i--;) { + if (map_table[i].p_map == curmap) + map_table[i].p_map = mp; + else + fixmap(curmap, mp, map_table[i].p_map); + } + ele = &mp->map_element[ele - &curmap->map_element[0]]; + return mp; } -/* fix references to a reallocated keymap (recursive) */ -static VOID fixmap(curmap, mp, mt) -register KEYMAP *mt; -register KEYMAP *curmap; -KEYMAP *mp; +/* + * Fix references to a reallocated keymap (recursive). + */ +static VOID +fixmap(curmap, mp, mt) + KEYMAP *mt; + KEYMAP *curmap; + KEYMAP *mp; { - register int i; + int i; - for(i = mt->map_num; i--; ) { - if(mt->map_element[i].k_prefmap != NULL) { - if(mt->map_element[i].k_prefmap == curmap) - mt->map_element[i].k_prefmap = mp; - else fixmap(curmap, mp, mt->map_element[i].k_prefmap); + for (i = mt->map_num; i--;) { + if (mt->map_element[i].k_prefmap != NULL) { + if (mt->map_element[i].k_prefmap == curmap) + mt->map_element[i].k_prefmap = mp; + else + fixmap(curmap, mp, mt->map_element[i].k_prefmap); + } } - } } /* * do the input for local-set-key, global-set-key and define-key * then call remap to do the work. */ - -static int dobind(curmap, p, unbind) -register KEYMAP *curmap; -char *p; -int unbind; +static int +dobind(curmap, p, unbind) + KEYMAP *curmap; + char *p; + int unbind; { - PF funct; - char prompt[80]; - char *pep; - int c; - int s; - KEYMAP *pref_map = NULL; + PF funct; + char prompt[80]; + char *pep; + int c; + int s; + KEYMAP *pref_map = NULL; #ifndef NO_MACRO - if(macrodef) { - /* keystrokes arn't collected. Not hard, but pretty useless */ - /* would not work for function keys in any case */ - ewprintf("Can't rebind key in macro"); - return FALSE; + if (macrodef) { + /* + * Keystrokes aren't collected. Not hard, but pretty useless. + * Would not work for function keys in any case. + */ + ewprintf("Can't rebind key in macro"); + return FALSE; } #ifndef NO_STARTUP - if(inmacro) { - for(s=0; s < maclcur->l_used - 1; s++) { - if(doscan(curmap, c=CHARMASK(maclcur->l_text[s])) != prefix) { - if(remap(curmap, c, prefix, (KEYMAP *)NULL) != TRUE) { - return FALSE; - } + if (inmacro) { + for (s = 0; s < maclcur->l_used - 1; s++) { + if (doscan(curmap, c = CHARMASK(maclcur->l_text[s])) + != prefix) { + if (remap(curmap, c, prefix, (KEYMAP *) NULL) + != TRUE) + return FALSE; + } + curmap = ele->k_prefmap; } - curmap = ele->k_prefmap; - } - (VOID) doscan(curmap, c=maclcur->l_text[s]); - maclcur = maclcur->l_fp; + (VOID) doscan(curmap, c = maclcur->l_text[s]); + maclcur = maclcur->l_fp; } else { #endif #endif - (VOID) strcpy(prompt, p); - pep = prompt + strlen(prompt); - for(;;) { - ewprintf("%s", prompt); - pep[-1] = ' '; - pep = keyname(pep, c = getkey(FALSE)); - if(doscan(curmap,c) != prefix) break; - *pep++ = '-'; - *pep = '\0'; - curmap = ele->k_prefmap; - } + (VOID) strcpy(prompt, p); + pep = prompt + strlen(prompt); + for (;;) { + ewprintf("%s", prompt); + pep[-1] = ' '; + pep = keyname(pep, c = getkey(FALSE)); + if (doscan(curmap, c) != prefix) + break; + *pep++ = '-'; + *pep = '\0'; + curmap = ele->k_prefmap; + } #ifndef NO_STARTUP } #endif - if(unbind) funct = rescan; + if (unbind) + funct = rescan; else { - if ((s=eread("%s to command: ", prompt, 80, EFFUNC|EFNEW, prompt)) - != TRUE) return s; - if (((funct = name_function(prompt)) == prefix) ? - (pref_map = name_map(prompt)) == NULL : funct==NULL) { - ewprintf("[No match]"); - return FALSE; - } + if ((s = eread("%s to command: ", prompt, 80, EFFUNC | EFNEW, + prompt)) != TRUE) + return s; + if (((funct = name_function(prompt)) == prefix) ? + (pref_map = name_map(prompt)) == NULL : funct == NULL) { + ewprintf("[No match]"); + return FALSE; + } } return remap(curmap, c, funct, pref_map); } @@ -345,29 +384,31 @@ int unbind; * KEYMAP *curmap rather than KEYMAP **mapp. */ #ifdef BINDKEY +int bindkey(mapp, fname, keys, kcount) -KEYMAP **mapp; -char *fname; -KCHAR *keys; -int kcount; + KEYMAP **mapp; + char *fname; + KCHAR *keys; + int kcount; { - KEYMAP *curmap = *mapp; - PF funct; - int c; - KEYMAP *pref_map = NULL; + KEYMAP *curmap = *mapp; + PF funct; + int c; + KEYMAP *pref_map = NULL; - if(fname == NULL) funct = rescan; + if (fname == NULL) + funct = rescan; else if (((funct = name_function(fname)) == prefix) ? - (pref_map = name_map(fname)) == NULL : funct==NULL) { - ewprintf("[No match: %s]", fname); - return FALSE; + (pref_map = name_map(fname)) == NULL : funct == NULL) { + ewprintf("[No match: %s]", fname); + return FALSE; } - while(--kcount) { - if(doscan(curmap, c = *keys++) != prefix) { - if(remap(curmap, c, prefix, (KEYMAP *)NULL) != TRUE) - return FALSE; - } - curmap = ele->k_prefmap; + while (--kcount) { + if (doscan(curmap, c = *keys++) != prefix) { + if (remap(curmap, c, prefix, (KEYMAP *) NULL) != TRUE) + return FALSE; + } + curmap = ele->k_prefmap; } (VOID) doscan(curmap, c = *keys); return remap(curmap, c, funct, pref_map); @@ -380,27 +421,31 @@ int kcount; int dobindkey(map, func, str) KEYMAP *map; - char *func; - char *str; + char *func; + char *str; { - int i; + int i; for (i = 0; *str && i < MAXKEY; i++) { /* XXX - convert numbers w/ strol()? */ if (*str != '\\') key.k_chars[i] = *str; else { - switch(*++str) { - case 't': case 'T': + switch (*++str) { + case 't': + case 'T': key.k_chars[i] = '\t'; break; - case 'n': case 'N': + case 'n': + case 'N': key.k_chars[i] = '\n'; break; - case 'r': case 'R': + case 'r': + case 'R': key.k_chars[i] = '\r'; break; - case 'e': case 'E': + case 'e': + case 'E': key.k_chars[i] = CCHR('['); break; } @@ -408,7 +453,7 @@ dobindkey(map, func, str) str++; } key.k_count = i; - return(bindkey(&map, func, key.k_chars, key.k_count)); + return (bindkey(&map, func, key.k_chars, key.k_count)); } #endif #endif @@ -416,53 +461,65 @@ dobindkey(map, func, str) /* * This function modifies the fundamental keyboard map. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int bindtokey(f, n) + int f, n; { - return dobind(map_table[0].p_map, "Global set key: ", FALSE); + return dobind(map_table[0].p_map, "Global set key: ", FALSE); } /* * This function modifies the current mode's keyboard map. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int localbind(f, n) + int f, n; { - return dobind(curbp->b_modes[curbp->b_nmodes]->p_map, "Local set key: ", - FALSE); + + return dobind(curbp->b_modes[curbp->b_nmodes]->p_map, "Local set key: ", + FALSE); } /* * This function redefines a key in any keymap. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int define_key(f, n) + int f, n; { - static char buf[48] = "Define key map: "; - MAPS *mp; - char *strncat(); - - buf[16] = '\0'; - if(eread(buf, &buf[16], 48 - 16, EFNEW) != TRUE) return FALSE; - if((mp = name_mode(&buf[16])) == NULL) { - ewprintf("Unknown map %s", &buf[16]); - return FALSE; - } - (VOID) strncat(&buf[16], " key: ", 48-16-1); - return dobind(mp->p_map, buf, FALSE); + static char buf[48] = "Define key map: "; + MAPS *mp; + char *strncat(); + + buf[16] = '\0'; + if (eread(buf, &buf[16], 48 - 16, EFNEW) != TRUE) + return FALSE; + if ((mp = name_mode(&buf[16])) == NULL) { + ewprintf("Unknown map %s", &buf[16]); + return FALSE; + } + (VOID) strncat(&buf[16], " key: ", 48 - 16 - 1); + return dobind(mp->p_map, buf, FALSE); } +int unbindtokey(f, n) -int f, n; + int f, n; { - return dobind(map_table[0].p_map, "Global unset key: ", TRUE); + + return dobind(map_table[0].p_map, "Global unset key: ", TRUE); } +int localunbind(f, n) -int f, n; + int f, n; { - return dobind(curbp->b_modes[curbp->b_nmodes]->p_map, "Local unset key: ", - TRUE); + + return dobind(curbp->b_modes[curbp->b_nmodes]->p_map, + "Local unset key: ", TRUE); } /* @@ -472,26 +529,31 @@ int f, n; * and run the command if it is found. * Print an error if there is anything wrong. */ +int extend(f, n) + int f, n; { - PF funct; - int s; - char xname[NXNAME]; - - if(!(f & FFARG)) s = eread("M-x ", xname, NXNAME, EFNEW|EFFUNC); - else s = eread("%d M-x ", xname, NXNAME, EFNEW|EFFUNC, n); - if(s != TRUE) return s; - if((funct = name_function(xname)) != NULL) { + PF funct; + int s; + char xname[NXNAME]; + + if (!(f & FFARG)) + s = eread("M-x ", xname, NXNAME, EFNEW | EFFUNC); + else + s = eread("%d M-x ", xname, NXNAME, EFNEW | EFFUNC, n); + if (s != TRUE) + return s; + if ((funct = name_function(xname)) != NULL) { #ifndef NO_MACRO - if(macrodef) { - LINE *lp = maclcur; - macro[macrocount-1].m_funct = funct; - maclcur = lp->l_bp; - maclcur->l_fp = lp->l_fp; - free((char *)lp); - } + if (macrodef) { + LINE *lp = maclcur; + macro[macrocount - 1].m_funct = funct; + maclcur = lp->l_bp; + maclcur->l_fp = lp->l_fp; + free((char *) lp); + } #endif - return (*funct)(f, n); + return (*funct) (f, n); } ewprintf("[No match]"); return FALSE; @@ -516,45 +578,55 @@ extend(f, n) /* * evalexpr - get one line from the user, and run it. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int evalexpr(f, n) + int f, n; { - int s; - char exbuf[128]; + int s; + char exbuf[128]; if ((s = ereply("Eval: ", exbuf, 128)) != TRUE) return s; return excline(exbuf); } + /* * evalbuffer - evaluate the current buffer as line commands. Useful * for testing startup files. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int evalbuffer(f, n) + int f, n; { - register LINE *lp; - register BUFFER *bp = curbp; - register int s; - static char excbuf[128]; + LINE *lp; + BUFFER *bp = curbp; + int s; + static char excbuf[128]; for (lp = lforw(bp->b_linep); lp != bp->b_linep; lp = lforw(lp)) { - if (llength(lp) >= 128) return FALSE; + if (llength(lp) >= 128) + return FALSE; (VOID) strncpy(excbuf, ltext(lp), llength(lp)); excbuf[llength(lp)] = '\0'; /* make sure it's terminated */ - if ((s = excline(excbuf)) != TRUE) return s; + if ((s = excline(excbuf)) != TRUE) + return s; } return TRUE; } + /* * evalfile - go get a file and evaluate it as line commands. You can * go get your own startup file if need be. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int evalfile(f, n) + int f, n; { - register int s; - char fname[NFILEN]; + int s; + char fname[NFILEN]; if ((s = ereply("Load file: ", fname, NFILEN)) != TRUE) return s; @@ -564,16 +636,20 @@ evalfile(f, n) /* * load - go load the file name we got passed. */ -load(fname) char *fname; { - int s = TRUE; - int nbytes; - char excbuf[128]; +int +load(fname) + char *fname; +{ + int s = TRUE; + int nbytes; + char excbuf[128]; if ((fname = adjustname(fname)) == NULL) return FALSE; /* just to be careful */ - if (ffropen(fname, (BUFFER *) NULL) != FIOSUC) return FALSE; - while ((s = ffgetline(excbuf, sizeof(excbuf)-1, &nbytes)) == FIOSUC) { + if (ffropen(fname, (BUFFER *) NULL) != FIOSUC) + return FALSE; + while ((s = ffgetline(excbuf, sizeof(excbuf) - 1, &nbytes)) == FIOSUC) { excbuf[nbytes] = '\0'; if (excline(excbuf) != TRUE) { s = FIOERR; @@ -583,7 +659,7 @@ load(fname) char *fname; { } (VOID) ffclose((BUFFER *) NULL); excbuf[nbytes] = '\0'; - if(s!=FIOEOF || (nbytes && excline(excbuf)!=TRUE)) + if (s != FIOEOF || (nbytes && excline(excbuf) != TRUE)) return FALSE; return TRUE; } @@ -593,20 +669,22 @@ load(fname) char *fname; { * if FKEYS is defined, duplicate functionallity of dobind so function * key values don't have to fit in type char. */ +int excline(line) -register char *line; + char *line; { - register char *funcp, *argp = NULL; - register int c; - int status; - int f, n; - LINE *lp, *np; - PF fp; + char *funcp, *argp = NULL; + int c; + int status; + int f, n; + LINE *lp, *np; + PF fp; #ifdef FKEYS - int bind; - KEYMAP *curmap; - MAPS *mp; -#define BINDARG 0 /* this arg is key to bind (local/global set key) */ + int bind; + KEYMAP *curmap; + MAPS *mp; +#define BINDARG 0 /* this arg is key to bind (local/global set + * key) */ #define BINDNO 1 /* not binding or non-quoted BINDARG */ #define BINDNEXT 2 /* next arg " (define-key) */ #define BINDDO 3 /* already found key to bind */ @@ -614,19 +692,16 @@ register char *line; #else #define BINDEXT 0 #endif - PF name_function(); - LINE *lalloc(); - static char *skipwhite(), *parsetoken(); - if(macrodef || inmacro) { + if (macrodef || inmacro) { ewprintf("Not now!"); return FALSE; } - f = 0; n = 1; funcp = skipwhite(line); - if (*funcp == '\0') return TRUE; /* No error on blank lines */ + if (*funcp == '\0') + return TRUE; /* No error on blank lines */ line = parsetoken(funcp); if (*line != '\0') { *line++ = '\0'; @@ -636,135 +711,159 @@ register char *line; line = parsetoken(line); } } - if (argp != NULL) { f = FFARG; n = atoi(argp); } - if((fp = name_function(funcp)) == NULL) { - ewprintf("Unknown function: %s", funcp); - return FALSE; + if ((fp = name_function(funcp)) == NULL) { + ewprintf("Unknown function: %s", funcp); + return FALSE; } #ifdef FKEYS - if(fp == bindtokey || fp == unbindtokey) { + if (fp == bindtokey || fp == unbindtokey) { bind = BINDARG; curmap = map_table[0].p_map; - } else if(fp == localbind || fp == localunbind) { + } else if (fp == localbind || fp == localunbind) { bind = BINDARG; curmap = curbp->b_modes[curbp->b_nmodes]->p_map; - } else if(fp == define_key) bind = BINDNEXT; - else bind = BINDNO; + } else if (fp == define_key) + bind = BINDNEXT; + else + bind = BINDNO; #endif - /* Pack away all the args now... */ - if((np = lalloc(0))==FALSE) return FALSE; + /* Pack away all the args now... */ + if ((np = lalloc(0)) == FALSE) + return FALSE; np->l_fp = np->l_bp = maclcur = np; while (*line != '\0') { argp = skipwhite(line); - if (*argp == '\0') break; + if (*argp == '\0') + break; line = parsetoken(argp); if (*argp != '"') { - if (*argp == '\'') ++argp; - if((lp = lalloc((int)(line-argp)+BINDEXT))==NULL) { - status = FALSE; - goto cleanup; - } - bcopy(argp, ltext(lp), (int)(line-argp)); + if (*argp == '\'') + ++argp; + if (!(lp = lalloc((int) (line - argp) + BINDEXT))) { + status = FALSE; + goto cleanup; + } + bcopy(argp, ltext(lp), (int) (line - argp)); #ifdef FKEYS - lp->l_used--; /* don't count BINDEXT! */ - if(bind == BINDARG) bind = BINDNO; + lp->l_used--; /* don't count BINDEXT! */ + if (bind == BINDARG) + bind = BINDNO; #endif } else { /* Quoted strings special */ - ++argp; + ++argp; #ifdef FKEYS - if(bind != BINDARG) { + if (bind != BINDARG) { #endif - if((lp = lalloc((int)(line-argp)+BINDEXT))==NULL) { - status = FALSE; - goto cleanup; + lp = lalloc((int) (line - argp) + BINDEXT); + if (lp == NULL) { + status = FALSE; + goto cleanup; + } + lp->l_used = 0; +#ifdef FKEYS + } else { + key.k_count = 0; } - lp->l_used = 0; +#endif + while (*argp != '"' && *argp != '\0') { + if (*argp != '\\') + c = *argp++; + else { + switch (*++argp) { + case 't': + case 'T': + c = CCHR('I'); + break; + case 'n': + case 'N': + c = CCHR('J'); + break; + case 'r': + case 'R': + c = CCHR('M'); + break; + case 'e': + case 'E': + c = CCHR('['); + break; + case '^': + /* + * split into two statements + * due to bug in OSK cpp + */ + c = CHARMASK(*++argp); + c = ISLOWER(c) ? + CCHR(TOUPPER(c)) : CCHR(c); + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + c = *argp - '0'; + if (argp[1] <= '7' && argp[1] >= '0') { + c <<= 3; + c += *++argp - '0'; + if (argp[1] <= '7' && + argp[1] >= '0') { + c <<= 3; + c += *++argp + - '0'; + } + } + break; #ifdef FKEYS - } else { - key.k_count = 0; - } + case 'f': + case 'F': + c = *++argp - '0'; + if (ISDIGIT(argp[1])) { + c *= 10; + c += *++argp - '0'; + } + c += KFIRST; + break; #endif - while (*argp != '"' && *argp != '\0') { - if (*argp != '\\') c = *argp++; - else { - switch(*++argp) { - case 't': case 'T': - c = CCHR('I'); - break; - case 'n': case 'N': - c = CCHR('J'); - break; - case 'r': case 'R': - c = CCHR('M'); - break; - case 'e': case 'E': - c = CCHR('['); - break; - case '^': -/* split into two statements due to bug in OSK cpp */ - c = CHARMASK(*++argp); - c = ISLOWER(c) ? - CCHR(TOUPPER(c)) : CCHR(c); - break; - case '0': case '1': case '2': case '3': - case '4': case '5': case '6': case '7': - c = *argp - '0'; - if(argp[1] <= '7' && argp[1] >= '0') { - c <<= 3; - c += *++argp - '0'; - if(argp[1] <= '7' && argp[1] >= '0') { - c <<= 3; - c += *++argp - '0'; + default: + c = CHARMASK(*argp); + break; } - } - break; + argp++; + } #ifdef FKEYS - case 'f': case 'F': - c = *++argp - '0'; - if(ISDIGIT(argp[1])) { - c *= 10; - c += *++argp - '0'; - } - c += KFIRST; - break; + if (bind == BINDARG) + key.k_chars[key.k_count++] = c; + else #endif - default: - c = CHARMASK(*argp); - break; - } - argp++; + lp->l_text[lp->l_used++] = c; } -#ifdef FKEYS - if(bind == BINDARG) - key.k_chars[key.k_count++] = c; - else -#endif - lp->l_text[lp->l_used++] = c; - } - if(*line) line++; + if (*line) + line++; } #ifdef FKEYS - switch(bind) { - case BINDARG: + switch (bind) { + case BINDARG: bind = BINDDO; break; - case BINDNEXT: + case BINDNEXT: lp->l_text[lp->l_used] = '\0'; - if((mp = name_mode(lp->l_text)) == NULL) { - ewprintf("No such mode: %s", lp->l_text); - status = FALSE; - free((char *)lp); - goto cleanup; + if ((mp = name_mode(lp->l_text)) == NULL) { + ewprintf("No such mode: %s", lp->l_text); + status = FALSE; + free((char *) lp); + goto cleanup; } curmap = mp->p_map; - free((char *)lp); + free((char *) lp); bind = BINDARG; break; - default: + default: #endif lp->l_fp = np->l_fp; lp->l_bp = np; @@ -775,34 +874,37 @@ register char *line; #endif } #ifdef FKEYS - switch(bind) { - default: + switch (bind) { + default: ewprintf("Bad args to set key"); status = FALSE; break; - case BINDDO: - if(fp != unbindtokey && fp != localunbind) { - lp->l_text[lp->l_used] = '\0'; - status = bindkey(&curmap, lp->l_text, key.k_chars, key.k_count); - } else status = bindkey(&curmap, (char *)NULL, key.k_chars, key.k_count); + case BINDDO: + if (fp != unbindtokey && fp != localunbind) { + lp->l_text[lp->l_used] = '\0'; + status = bindkey(&curmap, lp->l_text, key.k_chars, + key.k_count); + } else + status = bindkey(&curmap, (char *) NULL, key.k_chars, + key.k_count); break; - case BINDNO: + case BINDNO: #endif inmacro = TRUE; maclcur = maclcur->l_fp; - status = (*fp)(f, n); + status = (*fp) (f, n); inmacro = FALSE; #ifdef FKEYS } #endif cleanup: lp = maclcur->l_fp; - while(lp!=maclcur) { - np = lp->l_fp; - free((char *)lp); - lp = np; + while (lp != maclcur) { + np = lp->l_fp; + free((char *) lp); + lp = np; } - free((char *)lp); + free((char *) lp); return status; } @@ -811,25 +913,32 @@ cleanup: */ static char * skipwhite(s) -register char *s; + char *s; { - while(*s == ' ' || *s == '\t' || *s == ')' || *s == '(') s++; - if (*s == ';') *s = '\0' ; + + while (*s == ' ' || *s == '\t' || *s == ')' || *s == '(') + s++; + if (*s == ';') + *s = '\0'; return s; } static char * parsetoken(s) -register char *s; + char *s; { + if (*s != '"') { - while(*s && *s!=' ' && *s!='\t' && *s!=')' && *s!='(') s++; - if(*s==';') *s='\0'; + while (*s && *s != ' ' && *s != '\t' && *s != ')' && *s != '(') + s++; + if (*s == ';') + *s = '\0'; } else - do { /* Strings get special treatment */ + do { /* Strings get special treatment */ /* Beware: You can \ out the end of the string! */ - if (*s == '\\') ++s; - } while (*++s != '"' && *s != '\0'); + if (*s == '\\') + ++s; + } while (*++s != '"' && *s != '\0'); return s; } #endif diff --git a/usr.bin/mg/file.c b/usr.bin/mg/file.c index 508b4727d25..966982f295f 100644 --- a/usr.bin/mg/file.c +++ b/usr.bin/mg/file.c @@ -3,25 +3,25 @@ */ #include "def.h" -BUFFER *findbuffer(); -VOID makename(); -VOID upmodes(); -static char *itos(); +static char *itos __P((char *, unsigned int)); /* * insert a file into the current buffer. Real easy - just call the * insertfile routine with the file name. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int fileinsert(f, n) + int f, n; { - register int s; - char fname[NFILEN]; + int s; + char fname[NFILEN]; - if ((s=eread("Insert file: ", fname, NFILEN, EFNEW|EFCR|EFFILE)) != TRUE) + s = eread("Insert file: ", fname, NFILEN, EFNEW | EFCR | EFFILE); + if (s != TRUE) return (s); return insertfile(adjustname(fname), (char *) NULL, FALSE); - /* don't set buffer name */ + /* don't set buffer name */ } /* @@ -32,22 +32,27 @@ fileinsert(f, n) * the file, create a new buffer, read in the * text, and switch to the new buffer. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int filevisit(f, n) + int f, n; { - register BUFFER *bp; - int s; - char fname[NFILEN]; - char *adjf; + BUFFER *bp; + int s; + char fname[NFILEN]; + char *adjf; - if ((s=eread("Find file: ", fname, NFILEN, EFNEW|EFCR|EFFILE)) != TRUE) + s = eread("Find file: ", fname, NFILEN, EFNEW | EFCR | EFFILE); + if (s != TRUE) return s; adjf = adjustname(fname); - if ((bp = findbuffer(adjf)) == NULL) return FALSE; + if ((bp = findbuffer(adjf)) == NULL) + return FALSE; curbp = bp; - if (showbuffer(bp, curwp, WFHARD) != TRUE) return FALSE; + if (showbuffer(bp, curwp, WFHARD) != TRUE) + return FALSE; if (bp->b_fname[0] == 0) - return readin(adjf); /* Read it in. */ + return readin(adjf); /* Read it in. */ return TRUE; } @@ -55,25 +60,29 @@ filevisit(f, n) * Pop to a file in the other window. Same as last function, just * popbuf instead of showbuffer. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int poptofile(f, n) + int f, n; { - register BUFFER *bp; - register MGWIN *wp; - int s; - char fname[NFILEN]; - char *adjf; - - if ((s=eread("Find file in other window: ", fname, NFILEN, - EFNEW|EFCR|EFFILE)) != TRUE) + BUFFER *bp; + MGWIN *wp; + int s; + char fname[NFILEN]; + char *adjf; + + if ((s = eread("Find file in other window: ", fname, NFILEN, + EFNEW | EFCR | EFFILE)) != TRUE) return s; adjf = adjustname(fname); - if ((bp = findbuffer(adjf)) == NULL) return FALSE; - if ((wp = popbuf(bp)) == NULL) return FALSE; + if ((bp = findbuffer(adjf)) == NULL) + return FALSE; + if ((wp = popbuf(bp)) == NULL) + return FALSE; curbp = bp; curwp = wp; if (bp->b_fname[0] == 0) - return readin(adjf); /* Read it in. */ + return readin(adjf); /* Read it in. */ return TRUE; } @@ -83,21 +92,21 @@ poptofile(f, n) */ BUFFER * findbuffer(fname) -char *fname; + char *fname; { - register BUFFER *bp; - char bname[NBUFN], *cp; - unsigned count = 1; + BUFFER *bp; + char bname[NBUFN], *cp; + unsigned int count = 1; - for (bp=bheadp; bp!=NULL; bp=bp->b_bufp) { + for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { if (fncmp(bp->b_fname, fname) == 0) return bp; } - makename(bname, fname); /* New buffer name. */ + makename(bname, fname); /* New buffer name. */ cp = bname + strlen(bname); - while(bfind(bname, FALSE) != NULL) { - *cp = '<'; /* add "" to then name */ - (VOID) strcpy(itos(cp, ++count)+1, ">"); + while (bfind(bname, FALSE) != NULL) { + *cp = '<'; /* add "" to then name */ + (VOID) strcpy(itos(cp, ++count) + 1, ">"); } return bfind(bname, TRUE); } @@ -106,12 +115,14 @@ char *fname; * Put the decimal representation of num into a buffer. Hacked to be * faster, smaller, and less general. */ -static char *itos(bufp, num) -char *bufp; -unsigned num; +static char * +itos(bufp, num) + char *bufp; + unsigned int num; { + if (num >= 10) { - bufp = itos(bufp, num/10); + bufp = itos(bufp, num / 10); num %= 10; } *++bufp = '0' + num; @@ -124,18 +135,21 @@ unsigned num; * for unsaved changes. This is called by the "read" command, the * "visit" command, and the mainline (for "uemacs file"). */ -readin(fname) char *fname; { - register int status; - register MGWIN *wp; +int +readin(fname) + char *fname; +{ + int status; + MGWIN *wp; - if (bclear(curbp) != TRUE) /* Might be old. */ + if (bclear(curbp) != TRUE) /* Might be old. */ return TRUE; - status = insertfile(fname, fname, TRUE) ; - curbp->b_flag &= ~BFCHG; /* No change. */ - for (wp=wheadp; wp!=NULL; wp=wp->w_wndp) { + status = insertfile(fname, fname, TRUE); + curbp->b_flag &= ~BFCHG;/* No change. */ + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == curbp) { - wp->w_dotp = wp->w_linep = lforw(curbp->b_linep); - wp->w_doto = 0; + wp->w_dotp = wp->w_linep = lforw(curbp->b_linep); + wp->w_doto = 0; wp->w_markp = NULL; wp->w_marko = 0; } @@ -160,97 +174,105 @@ readin(fname) char *fname; { * read in, but not on a new file (you don't need to make a backup * copy of nothing). */ -static char *line = NULL; -static int linesize = 0; - -insertfile(fname, newname, needinfo) char fname[], newname[]; { - register LINE *lp1; - register LINE *lp2; - register MGWIN *wp; - int nbytes; - LINE *olp; /* Line we started at */ - int opos; /* and offset into it */ - int s, nline; - BUFFER *bp; +static char *line = NULL; +static int linesize = 0; + +int +insertfile(fname, newname, needinfo) + char *fname, *newname; + int needinfo; +{ + LINE *lp1; + LINE *lp2; + MGWIN *wp; + int nbytes; + LINE *olp; /* Line we started at */ + int opos; /* and offset into it */ + int s, nline; + BUFFER *bp; if (line == NULL) { line = malloc(NLINE); linesize = NLINE; } - bp = curbp; /* Cheap. */ + bp = curbp; /* Cheap. */ if (newname != (char *) NULL) (VOID) strcpy(bp->b_fname, newname); - /* Hard file open. */ - if ((s=ffropen(fname, needinfo ? bp : (BUFFER *) NULL)) == FIOERR) + /* Hard file open. */ + if ((s = ffropen(fname, needinfo ? bp : (BUFFER *) NULL)) == FIOERR) goto out; - if (s == FIOFNF) { /* File not found. */ + if (s == FIOFNF) { /* File not found. */ if (newname != NULL) ewprintf("(New file)"); - else ewprintf("(File not found)"); + else + ewprintf("(File not found)"); goto out; } opos = curwp->w_doto; /* Open a new line, at point, and start inserting after it */ (VOID) lnewline(); olp = lback(curwp->w_dotp); - if(olp == curbp->b_linep) { + if (olp == curbp->b_linep) { /* if at end of buffer, create a line to insert before */ (VOID) lnewline(); curwp->w_dotp = lback(curwp->w_dotp); } - nline = 0; /* Don't count fake line at end */ - while ((s=ffgetline(line, linesize, &nbytes)) != FIOERR) { + nline = 0; /* Don't count fake line at end */ + while ((s = ffgetline(line, linesize, &nbytes)) != FIOERR) { doneread: - switch(s) { - case FIOSUC: - ++nline; - /* and continue */ - case FIOEOF: /* the last line of the file */ - if ((lp1=lalloc(nbytes)) == NULL) { - s = FIOERR; /* Keep message on the */ - goto endoffile; /* display. */ - } - bcopy(line, <ext(lp1)[0], nbytes); - lp2 = lback(curwp->w_dotp); - lp2->l_fp = lp1; - lp1->l_fp = curwp->w_dotp; - lp1->l_bp = lp2; - curwp->w_dotp->l_bp = lp1; - if(s==FIOEOF) goto endoffile; - break; - case FIOLONG: { /* a line to long to fit in our buffer */ - char *cp; - int newsize; - - newsize = linesize * 2; - if(newsize < 0 || - (cp = malloc((unsigned)newsize)) == NULL) { - ewprintf("Could not allocate %d bytes", - newsize); - s = FIOERR; - goto endoffile; - } - bcopy(line, cp, linesize); - free(line); - line = cp; - s=ffgetline(line+linesize, linesize, &nbytes); - nbytes += linesize; - linesize = newsize; - if (s == FIOERR) - goto endoffile; - goto doneread; + switch (s) { + case FIOSUC: + ++nline; + /* and continue */ + case FIOEOF: /* the last line of the file */ + if ((lp1 = lalloc(nbytes)) == NULL) { + s = FIOERR; /* Keep message on the */ + goto endoffile; /* display. */ + } + bcopy(line, <ext(lp1)[0], nbytes); + lp2 = lback(curwp->w_dotp); + lp2->l_fp = lp1; + lp1->l_fp = curwp->w_dotp; + lp1->l_bp = lp2; + curwp->w_dotp->l_bp = lp1; + if (s == FIOEOF) + goto endoffile; + break; + case FIOLONG:{ /* a line too long to fit in our buffer */ + char *cp; + int newsize; + + newsize = linesize * 2; + if (newsize < 0 || + (cp = malloc((unsigned) newsize)) == NULL) { + ewprintf("Could not allocate %d bytes", + newsize); + s = FIOERR; + goto endoffile; + } + bcopy(line, cp, linesize); + free(line); + line = cp; + s = ffgetline(line + linesize, linesize, &nbytes); + nbytes += linesize; + linesize = newsize; + if (s == FIOERR) + goto endoffile; + goto doneread; + } + default: + ewprintf("Unknown code %d reading file", s); + s = FIOERR; + break; } - default: - ewprintf("Unknown code %d reading file", s); - s = FIOERR; - break; - } } endoffile: - (VOID) ffclose((BUFFER *) NULL); /* Ignore errors. */ - if (s==FIOEOF) { /* Don't zap an error. */ - if (nline == 1) ewprintf("(Read 1 line)"); - else ewprintf("(Read %d lines)", nline); + (VOID) ffclose((BUFFER *) NULL); /* Ignore errors. */ + if (s == FIOEOF) { /* Don't zap an error. */ + if (nline == 1) + ewprintf("(Read 1 line)"); + else + ewprintf("(Read %d lines)", nline); } /* Set mark at the end of the text */ curwp->w_dotp = curwp->w_markp = lback(curwp->w_dotp); @@ -258,38 +280,44 @@ endoffile: (VOID) ldelnewline(); curwp->w_dotp = olp; curwp->w_doto = opos; - if(olp == curbp->b_linep) curwp->w_dotp = lforw(olp); + if (olp == curbp->b_linep) + curwp->w_dotp = lforw(olp); #ifndef NO_BACKUP if (newname != NULL) - bp->b_flag |= BFCHG | BFBAK; /* Need a backup. */ - else bp->b_flag |= BFCHG; + bp->b_flag |= BFCHG | BFBAK; /* Need a backup. */ + else + bp->b_flag |= BFCHG; #else bp->b_flag |= BFCHG; #endif - /* if the insert was at the end of buffer, set lp1 to the end of - * buffer line, and lp2 to the beginning of the newly inserted - * text. (Otherwise lp2 is set to NULL.) This is - * used below to set pointers in other windows correctly if they - * are also at the end of buffer. + /* + * if the insert was at the end of buffer, set lp1 to the end of + * buffer line, and lp2 to the beginning of the newly inserted text. + * (Otherwise lp2 is set to NULL.) This is used below to set + * pointers in other windows correctly if they are also at the end of + * buffer. */ lp1 = bp->b_linep; if (curwp->w_markp == lp1) { lp2 = curwp->w_dotp; } else { - (VOID) ldelnewline(); /* delete extranious newline */ + (VOID) ldelnewline(); /* delete extranious newline */ out: lp2 = NULL; } - for (wp=wheadp; wp!=NULL; wp=wp->w_wndp) { + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == curbp) { - wp->w_flag |= WFMODE|WFEDIT; + wp->w_flag |= WFMODE | WFEDIT; if (wp != curwp && lp2 != NULL) { - if (wp->w_dotp == lp1) wp->w_dotp = lp2; - if (wp->w_markp == lp1) wp->w_markp = lp2; - if (wp->w_linep == lp1) wp->w_linep = lp2; + if (wp->w_dotp == lp1) + wp->w_dotp = lp2; + if (wp->w_markp == lp1) + wp->w_markp = lp2; + if (wp->w_linep == lp1) + wp->w_linep = lp2; } } } - return s != FIOERR; /* False if error. */ + return s != FIOERR; /* False if error. */ } /* @@ -301,27 +329,30 @@ out: lp2 = NULL; * BDC3 optional right scan delimiter. */ VOID -makename(bname, fname) char bname[]; char fname[]; { - register char *cp1; - register char *cp2; +makename(bname, fname) + char *bname; + char *fname; +{ + char *cp1; + char *cp2; cp1 = &fname[0]; while (*cp1 != 0) ++cp1; --cp1; /* insure at least 1 character ! */ #ifdef BDC2 - while (cp1!=&fname[0] && cp1[-1]!=BDC1 && cp1[-1]!=BDC2) + while (cp1 != &fname[0] && cp1[-1] != BDC1 && cp1[-1] != BDC2) --cp1; #else - while (cp1!=&fname[0] && cp1[-1]!=BDC1) + while (cp1 != &fname[0] && cp1[-1] != BDC1) --cp1; #endif cp2 = &bname[0]; #ifdef BDC3 - while (cp2!=&bname[NBUFN-1] && *cp1!=0 && *cp1!=BDC3) + while (cp2 != &bname[NBUFN - 1] && *cp1 != 0 && *cp1 != BDC3) *cp2++ = *cp1++; #else - while (cp2!=&bname[NBUFN-1] && *cp1!=0) + while (cp2 != &bname[NBUFN - 1] && *cp1 != 0) *cp2++ = *cp1++; #endif *cp2 = 0; @@ -336,20 +367,22 @@ makename(bname, fname) char bname[]; char fname[]; { * is more compatable with Gosling EMACS than * with ITS EMACS. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int filewrite(f, n) + int f, n; { - register int s; - char fname[NFILEN]; - char *adjfname; + int s; + char fname[NFILEN]; + char *adjfname; - if ((s=eread("Write file: ", fname, NFILEN, - EFNEW|EFCR|EFFILE)) != TRUE) + if ((s = eread("Write file: ", fname, NFILEN, + EFNEW | EFCR | EFFILE)) != TRUE) return (s); adjfname = adjustname(fname); /* old attributes are no longer current */ bzero(&curbp->b_fi, sizeof(curbp->b_fi)); - if ((s=writeout(curbp, adjfname)) == TRUE) { + if ((s = writeout(curbp, adjfname)) == TRUE) { (VOID) strcpy(curbp->b_fname, adjfname); #ifndef NO_BACKUP curbp->b_flag &= ~(BFBAK | BFCHG); @@ -369,10 +402,11 @@ filewrite(f, n) #ifndef MAKEBACKUP #define MAKEBACKUP TRUE #endif -static int makebackup = MAKEBACKUP; +static int makebackup = MAKEBACKUP; #endif -/*ARGSUSED*/ +/* ARGSUSED */ +int filesave(f, n) { return buffsave(curbp); @@ -387,28 +421,31 @@ filesave(f, n) * Allow user to select whether or not to make backup files * by looking at the value of makebackup. */ -buffsave(bp) BUFFER *bp; { - register int s; +int +buffsave(bp) + BUFFER *bp; +{ + int s; - if ((bp->b_flag&BFCHG) == 0) { /* Return, no changes. */ + if ((bp->b_flag & BFCHG) == 0) { /* Return, no changes. */ ewprintf("(No changes need to be saved)"); return TRUE; } - if (bp->b_fname[0] == '\0') { /* Must have a name. */ + if (bp->b_fname[0] == '\0') { /* Must have a name. */ ewprintf("No file name"); return (FALSE); } #ifndef NO_BACKUP - if (makebackup && (bp->b_flag&BFBAK)) { + if (makebackup && (bp->b_flag & BFBAK)) { s = fbackupfile(bp->b_fname); - if (s == ABORT) /* Hard error. */ + if (s == ABORT) /* Hard error. */ return FALSE; - if (s == FALSE /* Softer error. */ - && (s=eyesno("Backup error, save anyway")) != TRUE) + if (s == FALSE /* Softer error. */ + && (s = eyesno("Backup error, save anyway")) != TRUE) return s; } #endif - if ((s=writeout(bp, bp->b_fname)) == TRUE) { + if ((s = writeout(bp, bp->b_fname)) == TRUE) { #ifndef NO_BACKUP bp->b_flag &= ~(BFCHG | BFBAK); #else @@ -420,19 +457,22 @@ buffsave(bp) BUFFER *bp; { } #ifndef NO_BACKUP -/* Since we don't have variables (we probably should) - * this is a command processor for changing the value of - * the make backup flag. If no argument is given, - * sets makebackup to true, so backups are made. If - * an argument is given, no backup files are made when - * saving a new version of a file. Only used when BACKUP - * is #defined. +/* + * Since we don't have variables (we probably should) this is a command + * processor for changing the value of the make backup flag. If no argument + * is given, sets makebackup to true, so backups are made. If an argument is + * given, no backup files are made when saving a new version of a file. Only + * used when BACKUP is #defined. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int makebkfile(f, n) { - if(f & FFARG) makebackup = n > 0; - else makebackup = !makebackup; + + if (f & FFARG) + makebackup = n > 0; + else + makebackup = !makebackup; ewprintf("Backup files %sabled", makebackup ? "en" : "dis"); return TRUE; } @@ -454,18 +494,22 @@ makebkfile(f, n) * in the "fileio.c" package. Most of the grief * is checking of some sort. */ -writeout(bp, fn) register BUFFER *bp; char *fn; { - register int s; +int +writeout(bp, fn) + BUFFER *bp; + char *fn; +{ + int s; - if ((s=ffwopen(fn,bp)) != FIOSUC) /* Open writes message. */ + if ((s = ffwopen(fn, bp)) != FIOSUC) /* Open writes message. */ return (FALSE); s = ffputbuf(bp); - if (s == FIOSUC) { /* No write error. */ + if (s == FIOSUC) { /* No write error. */ s = ffclose(bp); - if (s==FIOSUC) + if (s == FIOSUC) ewprintf("Wrote %s", fn); - } else /* Ignore close error */ - (VOID) ffclose(bp); /* if a write error. */ + } else /* Ignore close error */ + (VOID) ffclose(bp); /* if a write error. */ return s == FIOSUC; } @@ -474,9 +518,12 @@ writeout(bp, fn) register BUFFER *bp; char *fn; { * mode line updated. */ VOID -upmodes(bp) register BUFFER *bp; { - register MGWIN *wp; +upmodes(bp) + BUFFER *bp; +{ + MGWIN *wp; for (wp = wheadp; wp != NULL; wp = wp->w_wndp) - if (bp == NULL || curwp->w_bufp == bp) wp->w_flag |= WFMODE; + if (bp == NULL || curwp->w_bufp == bp) + wp->w_flag |= WFMODE; } diff --git a/usr.bin/mg/fileio.c b/usr.bin/mg/fileio.c index b50758d817c..8fb3b049a43 100644 --- a/usr.bin/mg/fileio.c +++ b/usr.bin/mg/fileio.c @@ -1,10 +1,9 @@ /* - * POSIX fileio.c + * POSIX fileio.c */ #include "def.h" -static FILE *ffp; -char *adjustname(); +static FILE *ffp; #include #include @@ -13,13 +12,17 @@ char *adjustname(); /* * Open a file for reading. */ -ffropen(fn, bp) char *fn; BUFFER *bp; { - struct stat statbuf; - - if ((ffp=fopen(fn, "r")) == NULL) +int +ffropen(fn, bp) + char *fn; + BUFFER *bp; +{ + struct stat statbuf; + + if ((ffp = fopen(fn, "r")) == NULL) return (FIOFNF); if (bp && fstat(fileno(ffp), &statbuf) == 0) { -/* set highorder bit to make sure this isn't all zero */ + /* set highorder bit to make sure this isn't all zero */ bp->b_fi.fi_mode = statbuf.st_mode | 0x8000; bp->b_fi.fi_uid = statbuf.st_uid; bp->b_fi.fi_gid = statbuf.st_gid; @@ -32,18 +35,23 @@ ffropen(fn, bp) char *fn; BUFFER *bp; { * Return TRUE if all is well, and * FALSE on error (cannot create). */ -ffwopen(fn, bp) char *fn; BUFFER *bp; { - if ((ffp=fopen(fn, "w")) == NULL) { +int +ffwopen(fn, bp) + char *fn; + BUFFER *bp; +{ + + if ((ffp = fopen(fn, "w")) == NULL) { ewprintf("Cannot open file for writing"); return (FIOERR); } - /* - * If we have file information, use it. We don't bother - * to check for errors, because there's no a lot we can do - * about it. Certainly trying to change ownership will fail - * if we aren' root. That's probably OK. If we don't have - * info, no need to get it, since any future writes will do - * the same thing. + + /* + * If we have file information, use it. We don't bother to check for + * errors, because there's no a lot we can do about it. Certainly + * trying to change ownership will fail if we aren' root. That's + * probably OK. If we don't have info, no need to get it, since any + * future writes will do the same thing. */ if (bp && bp->b_fi.fi_mode) { chmod(fn, bp->b_fi.fi_mode & 07777); @@ -54,9 +62,14 @@ ffwopen(fn, bp) char *fn; BUFFER *bp; { /* * Close a file. - * Should look at the status. + * XXX - Should look at the status. */ -ffclose() { +/* ARGSUSED */ +int +ffclose(bp) + BUFFER *bp; +{ + (VOID) fclose(ffp); return (FIOSUC); } @@ -68,32 +81,35 @@ ffclose() { * Check only at the newline and * end of buffer. */ +int ffputbuf(bp) -BUFFER *bp; + BUFFER *bp; { - register char *cp; - register char *cpend; - register LINE *lp; - register LINE *lpend; - - lpend = bp->b_linep; - lp = lforw(lpend); - do { - cp = <ext(lp)[0]; /* begining of line */ - cpend = &cp[llength(lp)]; /* end of line */ - while(cp != cpend) { - putc(*cp, ffp); - cp++; /* putc may evalualte arguments more than once */ + char *cp; + char *cpend; + LINE *lp; + LINE *lpend; + + lpend = bp->b_linep; + lp = lforw(lpend); + do { + cp = <ext(lp)[0]; /* begining of line */ + cpend = &cp[llength(lp)]; /* end of line */ + while (cp != cpend) { + putc(*cp, ffp); + cp++; /* putc may evaluate arguments + more than once */ + } + lp = lforw(lp); + if (lp == lpend) + break; /* no implied \n on last line */ + putc('\n', ffp); + } while (!ferror(ffp)); + if (ferror(ffp)) { + ewprintf("Write I/O error"); + return FIOERR; } - lp = lforw(lp); - if(lp == lpend) break; /* no implied newline on last line */ - putc('\n', ffp); - } while(!ferror(ffp)); - if(ferror(ffp)) { - ewprintf("Write I/O error"); - return FIOERR; - } - return FIOSUC; + return (FIOSUC); } /* @@ -102,25 +118,27 @@ BUFFER *bp; * line. When FIOEOF is returned, there is a valid line * of data without the normally implied \n. */ +int ffgetline(buf, nbuf, nbytes) -register char *buf; -register int nbuf; -register int *nbytes; + char *buf; + int nbuf; + int *nbytes; { - register int c; - register int i; + int c; + int i; i = 0; - while((c = getc(ffp))!=EOF && c!='\n') { + while ((c = getc(ffp)) != EOF && c != '\n') { buf[i++] = c; - if (i >= nbuf) return FIOLONG; + if (i >= nbuf) + return FIOLONG; } - if (c == EOF && ferror(ffp) != FALSE) { + if (c == EOF && ferror(ffp) != FALSE) { ewprintf("File read error"); return FIOERR; } *nbytes = i; - return c==EOF ? FIOEOF : FIOSUC; + return c == EOF ? FIOEOF : FIOSUC; } #ifndef NO_BACKUP @@ -133,13 +151,13 @@ register int *nbytes; * right thing here; I don't care that much as * I don't enable backups myself. */ -fbackupfile(fn) char *fn; { - register char *nname; - char *malloc(), *strrchr(); - int i; - char *lastpart; +int +fbackupfile(fn) + char *fn; +{ + char *nname; - if ((nname=malloc((unsigned)(strlen(fn)+1+1))) == NULL) { + if ((nname = malloc((unsigned) (strlen(fn) + 1 + 1))) == NULL) { ewprintf("Can't get %d bytes", strlen(fn) + 1); return (ABORT); } @@ -169,116 +187,125 @@ fbackupfile(fn) char *fn; { #endif #include #ifndef NO_DIR -extern char *wdir; +extern char *wdir; #endif -char *adjustname(fn) -register char *fn; +char * +adjustname(fn) + char *fn; { - register char *cp; - static char fnb[NFILEN]; - struct passwd *pwent; + char *cp; + static char fnb[NFILEN]; + struct passwd *pwent; #ifdef SYMBLINK - struct stat statbuf; - int i, j; - char linkbuf[NFILEN]; + struct stat statbuf; + int i, j; + char linkbuf[NFILEN]; #endif - switch(*fn) { - case '/': - cp = fnb; - *cp++ = *fn++; - break; - case '~': - fn++; - if(*fn == '/' || *fn == '\0') { - (VOID) strcpy(fnb, getenv("HOME")); - cp = fnb + strlen(fnb); - if(*fn) fn++; - break; - } else { + switch (*fn) { + case '/': cp = fnb; - while(*fn && *fn != '/') *cp++ = *fn++; - *cp = '\0'; - if((pwent = getpwnam(fnb)) != NULL) { - (VOID) strcpy(fnb, pwent->pw_dir); - cp = fnb + strlen(fnb); - break; + *cp++ = *fn++; + break; + case '~': + fn++; + if (*fn == '/' || *fn == '\0') { + (VOID) strcpy(fnb, getenv("HOME")); + cp = fnb + strlen(fnb); + if (*fn) + fn++; + break; } else { - fn -= strlen(fnb) + 1; - /* can't find ~user, continue to default case */ + cp = fnb; + while (*fn && *fn != '/') + *cp++ = *fn++; + *cp = '\0'; + if ((pwent = getpwnam(fnb)) != NULL) { + (VOID) strcpy(fnb, pwent->pw_dir); + cp = fnb + strlen(fnb); + break; + } else { + fn -= strlen(fnb) + 1; + /* can't find ~user, continue to default case */ + } } - } default: #ifndef NODIR - strcpy(fnb, wdir); - cp = fnb + strlen(fnb); - break; + strcpy(fnb, wdir); + cp = fnb + strlen(fnb); + break; #else - return fn; /* punt */ + return fn; /* punt */ #endif - } - if(cp != fnb && cp[-1] != '/') *cp++ = '/'; - while(*fn) { - switch(*fn) { - case '.': - switch(fn[1]) { - case '\0': - *--cp = '\0'; - return fnb; - case '/': - fn += 2; - continue; - case '.': - if(fn[2]=='/' || fn[2] == '\0') { + } + if (cp != fnb && cp[-1] != '/') + *cp++ = '/'; + while (*fn) { + switch (*fn) { + case '.': + switch (fn[1]) { + case '\0': + *--cp = '\0'; + return fnb; + case '/': + fn += 2; + continue; + case '.': + if (fn[2] != '/' && fn[2] != '\0') + break; #ifdef SYMBLINK - cp[-1] = '\0'; - for(j = MAXLINK; j-- && - lstat(fnb, &statbuf) != -1 && - (statbuf.st_mode&S_IFMT) == S_IFLNK && - (i = readlink(fnb, linkbuf, sizeof linkbuf)) - != -1 ;) { - if(linkbuf[0] != '/') { - --cp; - while(cp > fnb && *--cp != '/') {} - ++cp; - (VOID) strncpy(cp, linkbuf, i); - cp += i; - } else { - (VOID) strncpy(fnb, linkbuf, i); - cp = fnb + i; + cp[-1] = '\0'; + for (j = MAXLINK; j-- && + lstat(fnb, &statbuf) != -1 && + (statbuf.st_mode & S_IFMT) == S_IFLNK && + (i = readlink(fnb, linkbuf, sizeof linkbuf)) + != -1;) { + if (linkbuf[0] != '/') { + --cp; + while (cp > fnb && *--cp != '/') { + } + ++cp; + (VOID) strncpy(cp, linkbuf, i); + cp += i; + } else { + (VOID) strncpy(fnb, linkbuf, i); + cp = fnb + i; + } + if (cp[-1] != '/') + *cp++ = '\0'; + else + cp[-1] = '\0'; } - if(cp[-1]!='/') *cp++ = '\0'; - else cp[-1] = '\0'; - } - cp[-1] = '/'; + cp[-1] = '/'; #endif - --cp; - while(cp > fnb && *--cp != '/') {} - ++cp; - if(fn[2]=='\0') { - *--cp = '\0'; - return fnb; - } - fn += 3; - continue; - } - break; - default: - break; - } - break; - case '/': - fn++; - continue; - default: - break; + --cp; + while (cp > fnb && *--cp != '/') { + } + ++cp; + if (fn[2] == '\0') { + *--cp = '\0'; + return fnb; + } + fn += 3; + continue; + default: + break; + } + break; + case '/': + fn++; + continue; + default: + break; + } + while (*fn && (*cp++ = *fn++) != '/') { + } } - while(*fn && (*cp++ = *fn++) != '/') {} - } - if(cp[-1]=='/') --cp; - *cp = '\0'; - return fnb; + if (cp[-1] == '/') + --cp; + *cp = '\0'; + return fnb; } #ifndef NO_STARTUP @@ -292,20 +319,23 @@ register char *fn; */ char * startupfile(suffix) -char *suffix; + char *suffix; { - register char *file; - static char home[NFILEN]; + char *file; + static char home[NFILEN]; - if ((file = getenv("HOME")) == NULL) goto notfound; - if (strlen(file)+7 >= NFILEN - 1) goto notfound; + if ((file = getenv("HOME")) == NULL) + goto notfound; + if (strlen(file) + 7 >= NFILEN - 1) + goto notfound; (VOID) strcpy(home, file); (VOID) strcat(home, "/.mg"); if (suffix != NULL) { (VOID) strcat(home, "-"); (VOID) strcat(home, suffix); } - if (access(home, F_OK) == 0) return home; + if (access(home, F_OK) == 0) + return home; notfound: #ifdef STARTUPFILE @@ -316,7 +346,8 @@ notfound: (VOID) strcat(home, suffix); file = home; } - if (access(file, F_OK ) == 0) return file; + if (access(file, F_OK) == 0) + return file; #endif return NULL; @@ -327,92 +358,98 @@ notfound: #include #include "kbd.h" +int copy(frname, toname) -char *frname, *toname; + char *frname; + char *toname; { - pid_t pid; - int status; - - if(pid = vfork()) { - if(pid == -1) return -1; - execl("/bin/cp", "cp", frname, toname, (char *)NULL); - _exit(1); /* shouldn't happen */ - } - while(wait(&status) != pid) - ; - return status == 0; + pid_t pid; + int status; + + if ((pid = vfork())) { + if (pid == -1) + return -1; + execl("/bin/cp", "cp", frname, toname, (char *) NULL); + _exit(1); /* shouldn't happen */ + } + while (wait(&status) != pid); + return status == 0; } -BUFFER *dired_(dirname) -char *dirname; +BUFFER * +dired_(dirname) + char *dirname; { - register BUFFER *bp; - char line[256]; - BUFFER *findbuffer(); - FILE *dirpipe; - FILE *popen(); - char *strncpy(); - - if((dirname = adjustname(dirname)) == NULL) { - ewprintf("Bad directory name"); - return NULL; - } - if(dirname[strlen(dirname)-1] != '/') (VOID) strcat(dirname, "/"); - if((bp = findbuffer(dirname)) == NULL) { - ewprintf("Could not create buffer"); - return NULL; - } - if(bclear(bp) != TRUE) return FALSE; - (VOID) strcpy(line, "ls -al "); - (VOID) strcpy(&line[7], dirname); - if((dirpipe = popen(line, "r")) == NULL) { - ewprintf("Problem opening pipe to ls"); - return NULL; - } - line[0] = line[1] = ' '; - while(fgets(&line[2], 254, dirpipe) != NULL) { - line[strlen(line) - 1] = '\0'; /* remove ^J */ - (VOID) addline(bp, line); - } - if(pclose(dirpipe) == -1) { - ewprintf("Problem closing pipe to ls"); - return NULL; - } - bp->b_dotp = lforw(bp->b_linep); /* go to first line */ - (VOID) strncpy(bp->b_fname, dirname, NFILEN); - if((bp->b_modes[0] = name_mode("dired")) == NULL) { - bp->b_modes[0] = &map_table[0]; - ewprintf("Could not find mode dired"); - return NULL; - } - bp->b_nmodes = 0; - return bp; + BUFFER *bp; + FILE *dirpipe; + char line[256]; + + if ((dirname = adjustname(dirname)) == NULL) { + ewprintf("Bad directory name"); + return NULL; + } + if (dirname[strlen(dirname) - 1] != '/') + (VOID) strcat(dirname, "/"); + if ((bp = findbuffer(dirname)) == NULL) { + ewprintf("Could not create buffer"); + return NULL; + } + if (bclear(bp) != TRUE) + return FALSE; + (VOID) strcpy(line, "ls -al "); + (VOID) strcpy(&line[7], dirname); + if ((dirpipe = popen(line, "r")) == NULL) { + ewprintf("Problem opening pipe to ls"); + return NULL; + } + line[0] = line[1] = ' '; + while (fgets(&line[2], 254, dirpipe) != NULL) { + line[strlen(line) - 1] = '\0'; /* remove ^J */ + (VOID) addline(bp, line); + } + if (pclose(dirpipe) == -1) { + ewprintf("Problem closing pipe to ls"); + return NULL; + } + bp->b_dotp = lforw(bp->b_linep); /* go to first line */ + (VOID) strncpy(bp->b_fname, dirname, NFILEN); + if ((bp->b_modes[0] = name_mode("dired")) == NULL) { + bp->b_modes[0] = &map_table[0]; + ewprintf("Could not find mode dired"); + return NULL; + } + bp->b_nmodes = 0; + return bp; } +int d_makename(lp, fn) -register LINE *lp; -register char *fn; + LINE *lp; + char *fn; { - register char *cp; - - if(llength(lp) <= 56) return ABORT; - (VOID) strcpy(fn, curbp->b_fname); - cp = fn + strlen(fn); - bcopy(&lp->l_text[56], cp, llength(lp) - 56); - cp[llength(lp) - 56] = '\0'; - return lgetc(lp, 2) == 'd'; + char *cp; + + if (llength(lp) <= 56) + return ABORT; + (VOID) strcpy(fn, curbp->b_fname); + cp = fn + strlen(fn); + bcopy(&lp->l_text[56], cp, llength(lp) - 56); + cp[llength(lp) - 56] = '\0'; + return lgetc(lp, 2) == 'd'; } -#endif NO_DIRED +#endif /* NO_DIRED */ struct filelist { - LIST fl_l; - char fl_name[NFILEN+2]; + LIST fl_l; + char fl_name[NFILEN + 2]; }; -/* these things had better be contiguous, because we're going - * to refer to the end of dirbuf + 1 byte */ -struct direct dirbuf; -char dirdummy; +/* + * these things had better be contiguous, because we're going to refer to the + * end of dirbuf + 1 byte + */ +struct dirent dirbuf; +char dirdummy; /* * return list of file names that match the name in buf. @@ -422,133 +459,127 @@ char dirdummy; * for executables and directories. The list is not sorted. */ -LIST *make_file_list(buf,listing) - char *buf; - int listing; +LIST * +make_file_list(buf, listing) + char *buf; + int listing; { -char *dir,*file,*cp; -int len,i,preflen; -int fp; -LIST *last,*l1,*l2; -struct filelist *current; -char prefixx[NFILEN+1]; -extern int errno; -struct stat statbuf; -char statname[NFILEN+2]; - -/* We need three different strings: - * dir - the name of the directory containing what the user typed. - * Must be a real unix file name, e.g. no ~user, etc.. Must - * not end in /. - * prefix - the portion of what the user typed that is before - * the names we are going to find in the directory. Must have - * a trailing / if the user typed it. - * names from the directory. - * we open dir, and return prefix concatenated with names. - */ + char *dir, *file, *cp; + int len, i, preflen; + int fp; + LIST *last; + struct filelist *current; + char prefixx[NFILEN + 1]; + struct stat statbuf; + char statname[NFILEN + 2]; + + /* + * We need three different strings: dir - the name of the directory + * containing what the user typed. Must be a real unix file name, + * e.g. no ~user, etc.. Must not end in /. prefix - the portion of + * what the user typed that is before the names we are going to find + * in the directory. Must have a trailing / if the user typed it. + * names from the directory. we open dir, and return prefix + * concatenated with names. + */ -/* first we get a directory name we can look up */ -/* names ending in . are potentially odd, because adjustname - * will treat foo/.. as a reference to another directory, - * whereas we are interested in names starting with .. - */ -len = strlen(buf); -if (buf[len-1] == '.') { - buf[len-1] = 'x'; - dir = adjustname(buf); - buf[len-1] = '.'; -} -else - dir = adjustname(buf); -/* - * if the user typed a trailing / or the empty string - * he wants us to use his file spec as a directory name - */ -if (buf[0] && buf[strlen(buf)-1] != '/') { - file = strrchr(dir, '/'); - if (file) { - *file = 0; - if (*dir == 0) - dir = "/"; - } - else { - return(NULL); + /* first we get a directory name we can look up */ + /* + * Names ending in . are potentially odd, because adjustname will + * treat foo/.. as a reference to another directory, whereas we are + * interested in names starting with .. + */ + len = strlen(buf); + if (buf[len - 1] == '.') { + buf[len - 1] = 'x'; + dir = adjustname(buf); + buf[len - 1] = '.'; + } else + dir = adjustname(buf); + /* + * If the user typed a trailing / or the empty string + * he wants us to use his file spec as a directory name. + */ + if (buf[0] && buf[strlen(buf) - 1] != '/') { + file = strrchr(dir, '/'); + if (file) { + *file = 0; + if (*dir == 0) + dir = "/"; + } else { + return (NULL); + } } -} - -/* now we get the prefix of the name the user typed */ -strcpy(prefixx,buf); -cp = strrchr(prefixx, '/'); -if (cp == NULL) - prefixx[0] = 0; -else - cp[1] = 0; - -preflen = strlen(prefixx); -/* cp is the tail of buf that really needs to be compared */ -cp = buf + preflen; -len = strlen(cp); - -/* - * Now make sure that file names will fit in the buffers allocated. - * SV files are fairly short. For BSD, something more general - * would be required. - */ -if ((preflen + MAXNAMLEN) > NFILEN) - return(NULL); -if ((strlen(dir) + MAXNAMLEN) > NFILEN) - listing = 0; - -/* loop over the specified directory, making up the list of files */ - -/* - * Note that it is worth our time to filter out names that don't - * match, even though our caller is going to do so again, and to - * avoid doing the stat if completion is being done, because stat'ing - * every file in the directory is relatively expensive. - */ - -fp = open(dir,0); -if (fp < 0) { - return(NULL); -} + /* Now we get the prefix of the name the user typed. */ + strcpy(prefixx, buf); + cp = strrchr(prefixx, '/'); + if (cp == NULL) + prefixx[0] = 0; + else + cp[1] = 0; + + preflen = strlen(prefixx); + /* cp is the tail of buf that really needs to be compared */ + cp = buf + preflen; + len = strlen(cp); + + /* + * Now make sure that file names will fit in the buffers allocated. + * SV files are fairly short. For BSD, something more general would + * be required. + */ + if ((preflen + MAXNAMLEN) > NFILEN) + return (NULL); + if ((strlen(dir) + MAXNAMLEN) > NFILEN) + listing = 0; + + /* loop over the specified directory, making up the list of files */ + + /* + * Note that it is worth our time to filter out names that don't + * match, even though our caller is going to do so again, and to + * avoid doing the stat if completion is being done, because stat'ing + * every file in the directory is relatively expensive. + */ -last = NULL; -/* clear entry after last so we can treat d_name as ASCIZ */ -dirbuf.d_name[MAXNAMLEN] = 0; -while (1) { - if (read(fp, &dirbuf, sizeof(struct direct)) <= 0) { - break; + fp = open(dir, 0); + if (fp < 0) { + return (NULL); } - if (dirbuf.d_ino == 0) /* entry not allocated */ - continue; - for (i=0; ifl_l.l_next = last; + current->fl_l.l_name = current->fl_name; + last = (LIST *) current; + strcpy(current->fl_name, prefixx); + strcat(current->fl_name, dirbuf.d_name); + if (listing) { + statbuf.st_mode = 0; + strcpy(statname, dir); + strcat(statname, "/"); + strcat(statname, dirbuf.d_name); + stat(statname, &statbuf); + if (statbuf.st_mode & 040000) + strcat(current->fl_name, "/"); + else if (statbuf.st_mode & 0100) + strcat(current->fl_name, "*"); + } } - if (i < len) - continue; - current = (struct filelist *)malloc(sizeof(struct filelist)); - current->fl_l.l_next = last; - current->fl_l.l_name = current->fl_name; - last = (LIST *)current; - strcpy(current->fl_name,prefixx); - strcat(current->fl_name,dirbuf.d_name); - if (listing) { - statbuf.st_mode = 0; - strcpy(statname,dir); - strcat(statname,"/"); - strcat(statname,dirbuf.d_name); - stat(statname,&statbuf); - if (statbuf.st_mode & 040000) - strcat(current->fl_name,"/"); - else if (statbuf.st_mode & 0100) - strcat(current->fl_name,"*"); - } - -} -close(fp); - -return (last); + close(fp); + return (last); } diff --git a/usr.bin/mg/help.c b/usr.bin/mg/help.c index ae9268aa85a..4f70c009d86 100644 --- a/usr.bin/mg/help.c +++ b/usr.bin/mg/help.c @@ -1,4 +1,4 @@ -/* Help functions for MicroGnuEmacs 2 */ +/* Help functions for Mg 2 */ #include "def.h" @@ -8,263 +8,311 @@ #ifndef NO_MACRO #include "macro.h" #endif -extern int rescan(); + +static int showall __P((char *ind, KEYMAP *map)); +static VOID findbind __P((PF, char *, KEYMAP *)); +static VOID bindfound __P((void)); /* - * Read a key from the keyboard, and look it - * up in the keymap. Display the name of the function - * currently bound to the key. + * Read a key from the keyboard, and look it up in the keymap. + * Display the name of the function currently bound to the key. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int desckey(f, n) + int f, n; { - register KEYMAP *curmap; - register PF funct; - register char *pep; - char prompt[80]; - int c; - int m; - int i; + KEYMAP *curmap; + PF funct; + char *pep; + char prompt[80]; + int c; + int m; + int i; #ifndef NO_MACRO - if(inmacro) return TRUE; /* ignore inside keyboard macro */ + if (inmacro) + return TRUE; /* ignore inside keyboard macro */ #endif - (VOID) strcpy(prompt, "Describe key briefly: "); - pep = prompt + strlen(prompt); - key.k_count = 0; - m = curbp->b_nmodes; - curmap = curbp->b_modes[m]->p_map; - for(;;) { - for(;;) { - ewprintf("%s", prompt); - pep[-1] = ' '; - pep = keyname(pep, key.k_chars[key.k_count++] = c = getkey(FALSE)); - if((funct = doscan(curmap, c)) != prefix) break; - *pep++ = '-'; - *pep = '\0'; - curmap = ele->k_prefmap; - } - if(funct != rescan) break; - if(ISUPPER(key.k_chars[key.k_count-1])) { - funct = doscan(curmap, TOLOWER(key.k_chars[key.k_count-1])); - if(funct == prefix) { + (VOID) strcpy(prompt, "Describe key briefly: "); + pep = prompt + strlen(prompt); + key.k_count = 0; + m = curbp->b_nmodes; + curmap = curbp->b_modes[m]->p_map; + for (;;) { + for (;;) { + ewprintf("%s", prompt); + pep[-1] = ' '; + pep = keyname(pep, key.k_chars[key.k_count++] = + c = getkey(FALSE)); + if ((funct = doscan(curmap, c)) != prefix) + break; + *pep++ = '-'; + *pep = '\0'; + curmap = ele->k_prefmap; + } + if (funct != rescan) + break; + if (ISUPPER(key.k_chars[key.k_count - 1])) { + funct = doscan(curmap, + TOLOWER(key.k_chars[key.k_count - 1])); + if (funct == prefix) { + *pep++ = '-'; + *pep = '\0'; + curmap = ele->k_prefmap; + continue; + } + if (funct != rescan) + break; + } +nextmode: + if (--m < 0) + break; + curmap = curbp->b_modes[m]->p_map; + for (i = 0; i < key.k_count; i++) { + funct = doscan(curmap, key.k_chars[i]); + if (funct != prefix) { + if (i == key.k_count - 1 && funct != rescan) + goto found; + funct = rescan; + goto nextmode; + } + curmap = ele->k_prefmap; + } *pep++ = '-'; *pep = '\0'; - curmap = ele->k_prefmap; - continue; - } - if(funct != rescan) break; } -nextmode: - if(--m < 0) break; - curmap = curbp->b_modes[m]->p_map; - for(i=0; i < key.k_count; i++) { - funct = doscan(curmap, key.k_chars[i]); - if(funct != prefix) { - if(i == key.k_count - 1 && funct != rescan) goto found; - funct = rescan; - goto nextmode; - } - curmap = ele->k_prefmap; - } - *pep++ = '-'; - *pep = '\0'; - } found: - if(funct == rescan) ewprintf("%k is not bound to any function"); - else if((pep = function_name(funct)) != NULL) - ewprintf("%k runs the command %s", pep); - else ewprintf("%k is bound to an unnamed function"); - return TRUE; + if (funct == rescan) + ewprintf("%k is not bound to any function"); + else if ((pep = function_name(funct)) != NULL) + ewprintf("%k runs the command %s", pep); + else + ewprintf("%k is bound to an unnamed function"); + return TRUE; } /* - * This function creates a table, listing all - * of the command keys and their current bindings, and stores - * the table in the *help* pop-up buffer. This - * lets MicroGnuEMACS produce it's own wall chart. + * This function creates a table, listing all of the command + * keys and their current bindings, and stores the table in the + * *help* pop-up buffer. This lets Mg produce it's own wall chart. */ -static BUFFER *bp; -static char buf[80]; /* used by showall and findbind */ +static BUFFER *bp; +static char buf[80]; /* used by showall and findbind */ -/*ARGSUSED*/ +/* ARGSUSED */ +int wallchart(f, n) { - int m; - static char locbind[80] = "Local keybindings for mode "; - static int showall(); + int m; + static char locbind[80] = "Local keybindings for mode "; bp = bfind("*help*", TRUE); - if (bclear(bp) != TRUE) return FALSE; /* Clear it out. */ - for(m=curbp->b_nmodes; m > 0; m--) { - (VOID) strcpy(&locbind[27], curbp->b_modes[m]->p_name); - (VOID) strcat(&locbind[27], ":"); - if((addline(bp, locbind) == FALSE) || - (showall(buf, curbp->b_modes[m]->p_map) == FALSE) || - (addline(bp, "") == FALSE)) return FALSE; + if (bclear(bp) != TRUE) + return FALSE; /* Clear it out. */ + for (m = curbp->b_nmodes; m > 0; m--) { + (VOID) strcpy(&locbind[27], curbp->b_modes[m]->p_name); + (VOID) strcat(&locbind[27], ":"); + if ((addline(bp, locbind) == FALSE) || + (showall(buf, curbp->b_modes[m]->p_map) == FALSE) || + (addline(bp, "") == FALSE)) + return FALSE; } - if((addline(bp, "Global bindings:") == FALSE) || - (showall(buf, map_table[0].p_map) == FALSE)) return FALSE; + if ((addline(bp, "Global bindings:") == FALSE) || + (showall(buf, map_table[0].p_map) == FALSE)) + return FALSE; return popbuftop(bp); } -static int showall(ind, map) -char *ind; -KEYMAP *map; +static int +showall(ind, map) + char *ind; + KEYMAP *map; { - register MAP_ELEMENT *ele; - register int i; - PF functp; - char *cp; - char *cp2; - int last; + MAP_ELEMENT *ele; + int i; + PF functp; + char *cp; + char *cp2; + int last; - if(addline(bp, "") == FALSE) return FALSE; + if (addline(bp, "") == FALSE) + return FALSE; last = -1; - for(ele = &map->map_element[0]; ele < &map->map_element[map->map_num] ; ele++) { - if(map->map_default != rescan && ++last < ele->k_base) { - cp = keyname(ind, last); - if(last < ele->k_base - 1) { - (VOID) strcpy(cp, " .. "); - cp = keyname(cp + 4, ele->k_base - 1); + for (ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; + ele++) { + if (map->map_default != rescan && ++last < ele->k_base) { + cp = keyname(ind, last); + if (last < ele->k_base - 1) { + (VOID) strcpy(cp, " .. "); + cp = keyname(cp + 4, ele->k_base - 1); + } + do { + *cp++ = ' '; + } while (cp < &buf[16]); + (VOID) strcpy(cp, function_name(map->map_default)); + if (addline(bp, buf) == FALSE) + return FALSE; } - do { *cp++ = ' '; } while(cp < &buf[16]); - (VOID) strcpy(cp, function_name(map->map_default)); - if(addline(bp, buf) == FALSE) return FALSE; - } - last = ele->k_num; - for(i=ele->k_base; i <= last; i++) { - functp = ele->k_funcp[i - ele->k_base]; - if(functp != rescan) { - if(functp != prefix) cp2 = function_name(functp); - else cp2 = map_name(ele->k_prefmap); - if(cp2 != NULL) { - cp = keyname(ind, i); - do { *cp++ = ' '; } while(cp < &buf[16]); - (VOID) strcpy(cp, cp2); - if (addline(bp, buf) == FALSE) return FALSE; - } + last = ele->k_num; + for (i = ele->k_base; i <= last; i++) { + functp = ele->k_funcp[i - ele->k_base]; + if (functp != rescan) { + if (functp != prefix) + cp2 = function_name(functp); + else + cp2 = map_name(ele->k_prefmap); + if (cp2 != NULL) { + cp = keyname(ind, i); + do { + *cp++ = ' '; + } while (cp < &buf[16]); + (VOID) strcpy(cp, cp2); + if (addline(bp, buf) == FALSE) + return FALSE; + } + } } - } } - for(ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; ele++) { - if(ele->k_prefmap != NULL) { - for(i = ele->k_base; ele->k_funcp[i - ele->k_base] != prefix; i++) { - if(i >= ele->k_num) /* damaged map */ - return FALSE; + for (ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; + ele++) { + if (ele->k_prefmap != NULL) { + for (i = ele->k_base; + ele->k_funcp[i - ele->k_base] != prefix; i++) { + if (i >= ele->k_num) /* damaged map */ + return FALSE; + } + cp = keyname(ind, i); + *cp++ = ' '; + if (showall(cp, ele->k_prefmap) == FALSE) + return FALSE; } - cp = keyname(ind, i); - *cp++ = ' '; - if(showall(cp, ele->k_prefmap) == FALSE) return FALSE; - } } return TRUE; } +int help_help(f, n) -int f, n; + int f, n; { - KEYMAP *kp; - PF funct; + KEYMAP *kp; + PF funct; - if((kp = name_map("help")) == NULL) return FALSE; - ewprintf("a b c: "); - do { - funct = doscan(kp, getkey(FALSE)); - } while(funct==NULL || funct==help_help); + if ((kp = name_map("help")) == NULL) + return FALSE; + ewprintf("a b c: "); + do { + funct = doscan(kp, getkey(FALSE)); + } while (funct == NULL || funct == help_help); #ifndef NO_MACRO - if(macrodef && macrocount < MAXMACRO) macro[macrocount-1].m_funct = funct; + if (macrodef && macrocount < MAXMACRO) + macro[macrocount - 1].m_funct = funct; #endif - return (*funct)(f, n); + return (*funct) (f, n); } -static char buf2[128]; -static char *buf2p; +static char buf2[128]; +static char *buf2p; -/*ARGSUSED*/ +/* ARGSUSED */ +int apropos_command(f, n) -int f, n; + int f, n; { - register char *cp1, *cp2; - char string[32]; - FUNCTNAMES *fnp; - BUFFER *bp; - static VOID findbind(); + char *cp1, *cp2; + char string[32]; + FUNCTNAMES *fnp; + BUFFER *bp; - if(eread("apropos: ", string, sizeof(string), EFNEW) == ABORT) return ABORT; + if (eread("apropos: ", string, sizeof(string), EFNEW) == ABORT) + return ABORT; /* FALSE means we got a 0 character string, which is fine */ - bp = bfind("*help*", TRUE); - if(bclear(bp) == FALSE) return FALSE; - for(fnp = &functnames[0]; fnp < &functnames[nfunct]; fnp++) { - for(cp1 = fnp->n_name; *cp1; cp1++) { - cp2 = string; - while(*cp2 && *cp1 == *cp2) - cp1++, cp2++; - if(!*cp2) { - (VOID) strcpy(buf2, fnp->n_name); - buf2p = &buf2[strlen(buf2)]; - findbind(fnp->n_funct, buf, map_table[0].p_map); - if(addline(bp, buf2) == FALSE) return FALSE; - break; - } else cp1 -= cp2 - string; + bp = bfind("*help*", TRUE); + if (bclear(bp) == FALSE) + return FALSE; + for (fnp = &functnames[0]; fnp < &functnames[nfunct]; fnp++) { + for (cp1 = fnp->n_name; *cp1; cp1++) { + cp2 = string; + while (*cp2 && *cp1 == *cp2) + cp1++, cp2++; + if (!*cp2) { + (VOID) strcpy(buf2, fnp->n_name); + buf2p = &buf2[strlen(buf2)]; + findbind(fnp->n_funct, buf, map_table[0].p_map); + if (addline(bp, buf2) == FALSE) + return FALSE; + break; + } else + cp1 -= cp2 - string; + } } - } - return popbuftop(bp); + return popbuftop(bp); } -static VOID findbind(funct, ind, map) -PF funct; -char *ind; -KEYMAP *map; +static VOID +findbind(funct, ind, map) + PF funct; + char *ind; + KEYMAP *map; { - register MAP_ELEMENT *ele; - register int i; - char *cp; - int last; - static VOID bindfound(); + MAP_ELEMENT *ele; + int i; + char *cp; + int last; - last = -1; - for(ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; ele++) { - if(map->map_default == funct && ++last < ele->k_base) { - cp = keyname(ind, last); - if(last < ele->k_base - 1) { - (VOID) strcpy(cp, " .. "); - (VOID) keyname(cp + 4, ele->k_base - 1); - } - bindfound(); - } - last = ele->k_num; - for(i=ele->k_base; i <= last; i++) { - if(funct == ele->k_funcp[i - ele->k_base]) { - if(funct == prefix) { - cp = map_name(ele->k_prefmap); - if(!cp || strncmp(cp, buf2, strlen(cp)) != 0) continue; + last = -1; + for (ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; + ele++) { + if (map->map_default == funct && ++last < ele->k_base) { + cp = keyname(ind, last); + if (last < ele->k_base - 1) { + (VOID) strcpy(cp, " .. "); + (VOID) keyname(cp + 4, ele->k_base - 1); + } + bindfound(); + } + last = ele->k_num; + for (i = ele->k_base; i <= last; i++) { + if (funct == ele->k_funcp[i - ele->k_base]) { + if (funct == prefix) { + cp = map_name(ele->k_prefmap); + if (!cp || + strncmp(cp, buf2, strlen(cp)) != 0) + continue; + } + (VOID) keyname(ind, i); + bindfound(); + } } - (VOID) keyname(ind, i); - bindfound(); - } } - } - for(ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; ele++) { - if(ele->k_prefmap != NULL) { - for(i = ele->k_base; ele->k_funcp[i - ele->k_base] != prefix; i++) { - if(i >= ele->k_num) return; /* damaged */ - } - cp = keyname(ind, i); - *cp++ = ' '; - findbind(funct, cp, ele->k_prefmap); + for (ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; + ele++) { + if (ele->k_prefmap != NULL) { + for (i = ele->k_base; + ele->k_funcp[i - ele->k_base] != prefix; i++) { + if (i >= ele->k_num) + return; /* damaged */ + } + cp = keyname(ind, i); + *cp++ = ' '; + findbind(funct, cp, ele->k_prefmap); + } } - } } -static VOID bindfound() { - if(buf2p < &buf2[32]) { - do { *buf2p++ = ' '; } while(buf2p < &buf2[32]); - } else { - *buf2p++ = ','; - *buf2p++ = ' '; - } - (VOID) strcpy(buf2p, buf); - buf2p += strlen(buf); +static VOID +bindfound() +{ + + if (buf2p < &buf2[32]) { + do { + *buf2p++ = ' '; + } while (buf2p < &buf2[32]); + } else { + *buf2p++ = ','; + *buf2p++ = ' '; + } + (VOID) strcpy(buf2p, buf); + buf2p += strlen(buf); } #endif diff --git a/usr.bin/mg/kbd.c b/usr.bin/mg/kbd.c index 3c2dd86da0c..72be336b622 100644 --- a/usr.bin/mg/kbd.c +++ b/usr.bin/mg/kbd.c @@ -16,29 +16,39 @@ #define METABIT 0x80 #endif -int use_metakey = TRUE; +int use_metakey = TRUE; /* * Toggle the value of use_metakey */ +int do_meta(f, n) + int f, n; { - if(f & FFARG) use_metakey = n > 0; - else use_metakey = !use_metakey; + + if (f & FFARG) + use_metakey = n > 0; + else + use_metakey = !use_metakey; ewprintf("Meta keys %sabled", use_metakey ? "en" : "dis"); return TRUE; } #endif #ifdef BSMAP -static int bs_map = BSMAP; +static int bs_map = BSMAP; /* * Toggle backspace mapping */ +int bsmap(f, n) + int f, n; { - if(f & FFARG) bs_map = n > 0; - else bs_map = ! bs_map; + + if (f & FFARG) + bs_map = n > 0; + else + bs_map = !bs_map; ewprintf("Backspace mapping %sabled", bs_map ? "en" : "dis"); return TRUE; } @@ -46,60 +56,67 @@ bsmap(f, n) #ifndef NO_DPROMPT #define PROMPTL 80 - char prompt[PROMPTL], *promptp; +char prompt[PROMPTL], *promptp; #endif -static int pushed = FALSE; -static int pushedc; +static int pushed = FALSE; +static int pushedc; -VOID ungetkey(c) -int c; +VOID +ungetkey(c) + int c; { + #ifdef DO_METAKEY - if(use_metakey && pushed && c==CCHR('[')) pushedc |= METABIT; + if (use_metakey && pushed && c == CCHR('[')) + pushedc |= METABIT; else #endif pushedc = c; pushed = TRUE; } -int getkey(flag) -int flag; +int +getkey(flag) + int flag; { - int c; - char *keyname(); + int c; #ifndef NO_DPROMPT - if(flag && !pushed) { - if(prompt[0]!='\0' && ttwait()) { + if (flag && !pushed) { + if (prompt[0] != '\0' && ttwait()) { ewprintf("%s", prompt); /* avoid problems with % */ - update(); /* put the cursor back */ + update(); /* put the cursor back */ epresf = KPROMPT; } - if(promptp > prompt) *(promptp-1) = ' '; + if (promptp > prompt) + *(promptp - 1) = ' '; } #endif - if(pushed) { + if (pushed) { c = pushedc; pushed = FALSE; - } else c = getkbd(); + } else + c = getkbd(); #ifdef BSMAP - if(bs_map) - if(c==CCHR('H')) c=CCHR('?'); - else if(c==CCHR('?')) c=CCHR('H'); -#endif + if (bs_map) + if (c == CCHR('H')) + c = CCHR('?'); + else if (c == CCHR('?')) + c = CCHR('H'); +#endif #ifdef DO_METAKEY - if(use_metakey && (c&METABIT)) { + if (use_metakey && (c & METABIT)) { pushedc = c & ~METABIT; pushed = TRUE; c = CCHR('['); } #endif #ifndef NO_DPROMPT - if(flag && promptp < &prompt[PROMPTL - 5]) { - promptp = keyname(promptp, c); - *promptp++ = '-'; - *promptp = '\0'; + if (flag && promptp < &prompt[PROMPTL - 5]) { + promptp = keyname(promptp, c); + *promptp++ = '-'; + *promptp = '\0'; } #endif return c; @@ -111,281 +128,313 @@ int flag; * keymap element the keyboard was found in as a side effect. */ -MAP_ELEMENT *ele; +MAP_ELEMENT *ele; -PF doscan(map, c) -register KEYMAP *map; -register int c; +PF +doscan(map, c) + KEYMAP *map; + int c; { - register MAP_ELEMENT *elec = &map->map_element[0]; /* local register copy for faster access */ - register MAP_ELEMENT *last = &map->map_element[map->map_num]; - - while(elec < last && c > elec->k_num) elec++; - ele = elec; /* used by prefix and binding code */ - if(elec >= last || c < elec->k_base) - return map->map_default; - return elec->k_funcp[c - elec->k_base]; + MAP_ELEMENT *elec = &map->map_element[0]; + MAP_ELEMENT *last = &map->map_element[map->map_num]; + + while (elec < last && c > elec->k_num) + elec++; + ele = elec; /* used by prefix and binding code */ + if (elec >= last || c < elec->k_base) + return map->map_default; + return elec->k_funcp[c - elec->k_base]; } +int doin() { - KEYMAP *curmap; - PF funct; + KEYMAP *curmap; + PF funct; #ifndef NO_DPROMPT - *(promptp = prompt) = '\0'; + *(promptp = prompt) = '\0'; #endif - curmap = curbp->b_modes[curbp->b_nmodes]->p_map; - key.k_count = 0; - while((funct=doscan(curmap,(key.k_chars[key.k_count++]=getkey(TRUE)))) - == prefix) - curmap = ele->k_prefmap; + curmap = curbp->b_modes[curbp->b_nmodes]->p_map; + key.k_count = 0; + while ((funct = doscan(curmap, (key.k_chars[key.k_count++] = + getkey(TRUE)))) == prefix) + curmap = ele->k_prefmap; #ifndef NO_MACRO - if(macrodef && macrocount < MAXMACRO) - macro[macrocount++].m_funct = funct; + if (macrodef && macrocount < MAXMACRO) + macro[macrocount++].m_funct = funct; #endif - return (*funct)(0, 1); + return (*funct) (0, 1); } +int rescan(f, n) -int f, n; + int f, n; { - int c; - register KEYMAP *curmap; - int i; - PF fp; - int mode = curbp->b_nmodes; - - for(;;) { - if(ISUPPER(key.k_chars[key.k_count-1])) { - c = TOLOWER(key.k_chars[key.k_count-1]); - curmap = curbp->b_modes[mode]->p_map; - for(i=0; i < key.k_count-1; i++) { - if((fp=doscan(curmap,(key.k_chars[i]))) != prefix) break; - curmap = ele->k_prefmap; - } - if(fp==prefix) { - if((fp = doscan(curmap, c)) == prefix) - while((fp=doscan(curmap,key.k_chars[key.k_count++] = - getkey(TRUE))) == prefix) - curmap = ele->k_prefmap; - if(fp!=rescan) { + int c; + KEYMAP *curmap; + int i; + PF fp; + int mode = curbp->b_nmodes; + + for (;;) { + if (ISUPPER(key.k_chars[key.k_count - 1])) { + c = TOLOWER(key.k_chars[key.k_count - 1]); + curmap = curbp->b_modes[mode]->p_map; + for (i = 0; i < key.k_count - 1; i++) { + if ((fp = doscan(curmap, (key.k_chars[i]))) != prefix) + break; + curmap = ele->k_prefmap; + } + if (fp == prefix) { + if ((fp = doscan(curmap, c)) == prefix) + while ((fp = doscan(curmap, + key.k_chars[key.k_count++] = + getkey(TRUE))) == prefix) + curmap = ele->k_prefmap; + if (fp != rescan) { #ifndef NO_MACRO - if(macrodef && macrocount <= MAXMACRO) - macro[macrocount-1].m_funct = fp; + if (macrodef && macrocount <= MAXMACRO) + macro[macrocount - 1].m_funct = fp; #endif - return (*fp)(f, n); + return (*fp) (f, n); + } + } } - } - } - /* try previous mode */ - if(--mode < 0) return ABORT; - curmap = curbp->b_modes[mode]->p_map; - for(i=0; i < key.k_count; i++) { - if((fp=doscan(curmap,(key.k_chars[i]))) != prefix) break; - curmap = ele->k_prefmap; - } - if(fp==prefix) { - while((fp=doscan(curmap,key.k_chars[i++]=getkey(TRUE))) - == prefix) - curmap = ele->k_prefmap; - key.k_count = i; - } - if(fp!=rescan && i>=key.k_count-1) { + /* try previous mode */ + if (--mode < 0) + return ABORT; + curmap = curbp->b_modes[mode]->p_map; + for (i = 0; i < key.k_count; i++) { + if ((fp = doscan(curmap, (key.k_chars[i]))) != prefix) + break; + curmap = ele->k_prefmap; + } + if (fp == prefix) { + while ((fp = doscan(curmap, key.k_chars[i++] = getkey(TRUE))) + == prefix) + curmap = ele->k_prefmap; + key.k_count = i; + } + if (fp != rescan && i >= key.k_count - 1) { #ifndef NO_MACRO - if(macrodef && macrocount <= MAXMACRO) - macro[macrocount-1].m_funct = fp; + if (macrodef && macrocount <= MAXMACRO) + macro[macrocount - 1].m_funct = fp; #endif - return (*fp)(f, n); + return (*fp) (f, n); + } } - } } +int universal_argument(f, n) -int f, n; + int f, n; { - int c, nn=4; - KEYMAP *curmap; - PF funct; + int c, nn = 4; + KEYMAP *curmap; + PF funct; - if(f&FFUNIV) nn *= n; - for(;;) { - key.k_chars[0] = c = getkey(TRUE); - key.k_count = 1; - if(c == '-') return negative_argument(f, nn); - if(c >= '0' && c <= '9') return digit_argument(f, nn); - curmap = curbp->b_modes[curbp->b_nmodes]->p_map; - while((funct=doscan(curmap,c)) == prefix) { - curmap = ele->k_prefmap; - key.k_chars[key.k_count++] = c = getkey(TRUE); - } - if(funct != universal_argument) { + if (f & FFUNIV) + nn *= n; + for (;;) { + key.k_chars[0] = c = getkey(TRUE); + key.k_count = 1; + if (c == '-') + return negative_argument(f, nn); + if (c >= '0' && c <= '9') + return digit_argument(f, nn); + curmap = curbp->b_modes[curbp->b_nmodes]->p_map; + while ((funct = doscan(curmap, c)) == prefix) { + curmap = ele->k_prefmap; + key.k_chars[key.k_count++] = c = getkey(TRUE); + } + if (funct != universal_argument) { #ifndef NO_MACRO - if(macrodef && macrocount < MAXMACRO-1) { - if(f&FFARG) macrocount--; - macro[macrocount++].m_count = nn; - macro[macrocount++].m_funct = funct; - } + if (macrodef && macrocount < MAXMACRO - 1) { + if (f & FFARG) + macrocount--; + macro[macrocount++].m_count = nn; + macro[macrocount++].m_funct = funct; + } #endif - return (*funct)(FFUNIV, nn); + return (*funct) (FFUNIV, nn); + } + nn <<= 2; } - nn <<= 2; - } } -/*ARGSUSED*/ +/* ARGSUSED */ +int digit_argument(f, n) -int f, n; + int f, n; { - int nn, c; - KEYMAP *curmap; - PF funct; - - nn = key.k_chars[key.k_count-1] - '0'; - for(;;) { - c = getkey(TRUE); - if(c < '0' || c > '9') break; - nn *= 10; - nn += c - '0'; - } - key.k_chars[0] = c; - key.k_count = 1; - curmap = curbp->b_modes[curbp->b_nmodes]->p_map; - while((funct=doscan(curmap,c)) == prefix) { - curmap = ele->k_prefmap; - key.k_chars[key.k_count++] = c = getkey(TRUE); - } + int nn, c; + KEYMAP *curmap; + PF funct; + + nn = key.k_chars[key.k_count - 1] - '0'; + for (;;) { + c = getkey(TRUE); + if (c < '0' || c > '9') + break; + nn *= 10; + nn += c - '0'; + } + key.k_chars[0] = c; + key.k_count = 1; + curmap = curbp->b_modes[curbp->b_nmodes]->p_map; + while ((funct = doscan(curmap, c)) == prefix) { + curmap = ele->k_prefmap; + key.k_chars[key.k_count++] = c = getkey(TRUE); + } #ifndef NO_MACRO - if(macrodef && macrocount < MAXMACRO-1) { - if(f&FFARG) macrocount--; - else macro[macrocount-1].m_funct = universal_argument; - macro[macrocount++].m_count = nn; - macro[macrocount++].m_funct = funct; - } + if (macrodef && macrocount < MAXMACRO - 1) { + if (f & FFARG) + macrocount--; + else + macro[macrocount - 1].m_funct = universal_argument; + macro[macrocount++].m_count = nn; + macro[macrocount++].m_funct = funct; + } #endif - return (*funct)(FFOTHARG, nn); + return (*funct) (FFOTHARG, nn); } +int negative_argument(f, n) -int f, n; + int f, n; { - int nn = 0, c; - KEYMAP *curmap; - PF funct; - - for(;;) { - c = getkey(TRUE); - if(c < '0' || c > '9') break; - nn *= 10; - nn += c - '0'; - } - if(nn) nn = -nn; - else nn = -n; - key.k_chars[0] = c; - key.k_count = 1; - curmap = curbp->b_modes[curbp->b_nmodes]->p_map; - while((funct=doscan(curmap,c)) == prefix) { - curmap = ele->k_prefmap; - key.k_chars[key.k_count++] = c = getkey(TRUE); - } + int nn = 0, c; + KEYMAP *curmap; + PF funct; + + for (;;) { + c = getkey(TRUE); + if (c < '0' || c > '9') + break; + nn *= 10; + nn += c - '0'; + } + if (nn) + nn = -nn; + else + nn = -n; + key.k_chars[0] = c; + key.k_count = 1; + curmap = curbp->b_modes[curbp->b_nmodes]->p_map; + while ((funct = doscan(curmap, c)) == prefix) { + curmap = ele->k_prefmap; + key.k_chars[key.k_count++] = c = getkey(TRUE); + } #ifndef NO_MACRO - if(macrodef && macrocount < MAXMACRO-1) { - if(f&FFARG) macrocount--; - else macro[macrocount-1].m_funct = universal_argument; - macro[macrocount++].m_count = nn; - macro[macrocount++].m_funct = funct; - } + if (macrodef && macrocount < MAXMACRO - 1) { + if (f & FFARG) + macrocount--; + else + macro[macrocount - 1].m_funct = universal_argument; + macro[macrocount++].m_count = nn; + macro[macrocount++].m_funct = funct; + } #endif - return (*funct)(FFNEGARG, nn); + return (*funct) (FFNEGARG, nn); } /* * Insert a character. While defining a macro, create a "LINE" containing * all inserted characters. */ - +int selfinsert(f, n) -int f, n; + int f, n; { - register int c; - int count; - VOID lchange(); + int c; + int count; #ifndef NO_MACRO - LINE *lp; - int insert(); + LINE *lp; #endif - if (n < 0) return FALSE; - if (n == 0) return TRUE; - c = key.k_chars[key.k_count-1]; + if (n < 0) + return FALSE; + if (n == 0) + return TRUE; + c = key.k_chars[key.k_count - 1]; #ifndef NO_MACRO - if(macrodef && macrocount < MAXMACRO) { - if(f & FFARG) macrocount -= 2; - if(lastflag & CFINS) { /* last command was insert -- tack on end */ - macrocount--; - if(maclcur->l_size < maclcur->l_used + n) { - if((lp = lallocx(maclcur->l_used + n)) == NULL) - return FALSE; - lp->l_fp = maclcur->l_fp; - lp->l_bp = maclcur->l_bp; - lp->l_fp->l_bp = lp->l_bp->l_fp = lp; - bcopy(maclcur->l_text, lp->l_text, maclcur->l_used); - for(count = maclcur->l_used; count < lp->l_used; count++) - lp->l_text[count] = c; - free((char *)maclcur); - maclcur = lp; - } else { - maclcur->l_used += n; - for(count = maclcur->l_used-n; count < maclcur->l_used; count++) - maclcur->l_text[count] = c; - } - } else { - macro[macrocount-1].m_funct = insert; - if((lp = lallocx(n)) == NULL) return FALSE; - lp->l_bp = maclcur; - lp->l_fp = maclcur->l_fp; - maclcur->l_fp = lp; - maclcur = lp; - for(count = 0; count < n; count++) - lp->l_text[count] = c; + if (macrodef && macrocount < MAXMACRO) { + if (f & FFARG) + macrocount -= 2; + if (lastflag & CFINS) { /* last command was insert -- tack on + * end */ + macrocount--; + if (maclcur->l_size < maclcur->l_used + n) { + if ((lp = lallocx(maclcur->l_used + n)) == NULL) + return FALSE; + lp->l_fp = maclcur->l_fp; + lp->l_bp = maclcur->l_bp; + lp->l_fp->l_bp = lp->l_bp->l_fp = lp; + bcopy(maclcur->l_text, lp->l_text, maclcur->l_used); + for (count = maclcur->l_used; count < lp->l_used; count++) + lp->l_text[count] = c; + free((char *) maclcur); + maclcur = lp; + } else { + maclcur->l_used += n; + for (count = maclcur->l_used - n; + count < maclcur->l_used; count++) + maclcur->l_text[count] = c; + } + } else { + macro[macrocount - 1].m_funct = insert; + if ((lp = lallocx(n)) == NULL) + return FALSE; + lp->l_bp = maclcur; + lp->l_fp = maclcur->l_fp; + maclcur->l_fp = lp; + maclcur = lp; + for (count = 0; count < n; count++) + lp->l_text[count] = c; + } + thisflag |= CFINS; } - thisflag |= CFINS; - } #endif - if(c == '\n') { - do { - count = lnewline(); - } while (--n && count==TRUE); - return count; - } - if(curbp->b_flag & BFOVERWRITE) { /* Overwrite mode */ - lchange(WFEDIT); - while(curwp->w_doto < llength(curwp->w_dotp) && n--) - lputc(curwp->w_dotp, curwp->w_doto++, c); - if(n<=0) return TRUE; - } - return linsert(n, c); + if (c == '\n') { + do { + count = lnewline(); + } while (--n && count == TRUE); + return count; + } + if (curbp->b_flag & BFOVERWRITE) { /* Overwrite mode */ + lchange(WFEDIT); + while (curwp->w_doto < llength(curwp->w_dotp) && n--) + lputc(curwp->w_dotp, curwp->w_doto++, c); + if (n <= 0) + return TRUE; + } + return linsert(n, c); } /* - * this could be implemented as a keymap with everthing defined + * This could be implemented as a keymap with everthing defined * as self-insert. */ +int quote(f, n) + int f, n; { - register int c; - - key.k_count = 1; - if((key.k_chars[0] = getkey(TRUE)) >= '0' && key.k_chars[0] <= '7') { - key.k_chars[0] -= '0'; - if((c = getkey(TRUE)) >= '0' && c <= '7') { - key.k_chars[0] <<= 3; - key.k_chars[0] += c - '0'; - if((c = getkey(TRUE)) >= '0' && c <= '7') { - key.k_chars[0] <<= 3; - key.k_chars[0] += c - '0'; - } else ungetkey(c); - } else ungetkey(c); - } - return selfinsert(f, n); + int c; + + key.k_count = 1; + if ((key.k_chars[0] = getkey(TRUE)) >= '0' && key.k_chars[0] <= '7') { + key.k_chars[0] -= '0'; + if ((c = getkey(TRUE)) >= '0' && c <= '7') { + key.k_chars[0] <<= 3; + key.k_chars[0] += c - '0'; + if ((c = getkey(TRUE)) >= '0' && c <= '7') { + key.k_chars[0] <<= 3; + key.k_chars[0] += c - '0'; + } else + ungetkey(c); + } else + ungetkey(c); + } + return selfinsert(f, n); } diff --git a/usr.bin/mg/kbd.h b/usr.bin/mg/kbd.h index 1816fc6462c..b121f0e19a3 100644 --- a/usr.bin/mg/kbd.h +++ b/usr.bin/mg/kbd.h @@ -2,62 +2,59 @@ * kbd.h: type definitions for symbol.c and kbd.c for mg experimental */ -typedef struct { - KCHAR k_base; /* first key in element */ - KCHAR k_num; /* last key in element */ - PF *k_funcp; /* pointer to array of pointers to functions */ - struct keymap_s *k_prefmap; /* keymap of ONLY prefix key in element */ -} MAP_ELEMENT; - -/* predefined keymaps are NOT type KEYMAP because final array needs - * dimension. If any changes are made to this struct, they must be - * reflected in all keymap declarations. +typedef struct { + KCHAR k_base; /* first key in element */ + KCHAR k_num; /* last key in element */ + PF *k_funcp; /* pointer to array of pointers + * to functions */ + struct keymap_s *k_prefmap; /* keymap of ONLY prefix key in + * element */ +} MAP_ELEMENT; + +/* + * predefined keymaps are NOT type KEYMAP because final array needs + * dimension. If any changes are made to this struct, they must be reflected + * in all keymap declarations. */ -#define KEYMAPE(NUM) {\ - short map_num;\ - short map_max;\ - PF map_default;\ - MAP_ELEMENT map_element[NUM];\ +#define KEYMAPE(NUM) { \ + short map_num; /* elements used */ \ + short map_max; /* elements allocated */ \ + PF map_default; /* default function */ \ + MAP_ELEMENT map_element[NUM]; /* really [e_max] */ \ } - /* elements used */ - /* elements allocated */ - /* default function */ - /* realy [e_max] */ -typedef struct keymap_s KEYMAPE(1) KEYMAP; +typedef struct keymap_s KEYMAPE(1) KEYMAP; #define none ctrlg #define prefix (PF)NULL -/* number of map_elements to grow an overflowed keymap by */ +/* Number of map_elements to grow an overflowed keymap by */ #define IMAPEXT 0 #define MAPGROW 3 #define MAPINIT (MAPGROW+1) -/* max number of default bindings added to avoid creating new element */ +/* Max number of default bindings added to avoid creating new element */ #define MAPELEDEF 4 typedef struct MAPS_S { - KEYMAP *p_map; - char *p_name; -} MAPS; + KEYMAP *p_map; + char *p_name; +} MAPS; -extern MAPS map_table[]; +extern MAPS map_table[]; typedef struct { - PF n_funct; - char *n_name; -} FUNCTNAMES; - -extern FUNCTNAMES functnames[]; -extern int nfunct; - -extern PF doscan(); -extern PF name_function(); -extern char *function_name(); -extern int complete_function(); -extern KEYMAP *name_map(); -extern char *map_name(); -extern MAPS *name_mode(); - -extern MAP_ELEMENT *ele; + PF n_funct; + char *n_name; +} FUNCTNAMES; + +PF doscan __P((KEYMAP *, int)); +PF name_function __P((char *)); +char *function_name __P((PF)); +KEYMAP *name_map __P((char *)); +char *map_name __P((KEYMAP *)); +MAPS *name_mode __P((char *)); + +extern FUNCTNAMES functnames[]; +extern int nfunct; +extern MAP_ELEMENT *ele; diff --git a/usr.bin/mg/key.h b/usr.bin/mg/key.h index 88e8bc1f1c7..b60c36f0b35 100644 --- a/usr.bin/mg/key.h +++ b/usr.bin/mg/key.h @@ -6,8 +6,8 @@ #define MAXKEY 8 /* maximum number of prefix chars */ -EXTERN struct { /* the chacter sequence in a key */ - int k_count; /* number of chars */ - KCHAR k_chars[MAXKEY]; /* chars */ -} key; +EXTERN struct { /* the chacter sequence in a key */ + int k_count; /* number of chars */ + KCHAR k_chars[MAXKEY]; /* chars */ +} key; #undef EXTERN diff --git a/usr.bin/mg/keymap.c b/usr.bin/mg/keymap.c index 69c34e300e3..da5a1ec2724 100644 --- a/usr.bin/mg/keymap.c +++ b/usr.bin/mg/keymap.c @@ -6,293 +6,183 @@ #include "def.h" #include "kbd.h" -/* - * Defined by "basic.c". - */ -extern int gotobol(); /* Move to start of line */ -extern int backchar(); /* Move backward by characters */ -extern int gotoeol(); /* Move to end of line */ -extern int forwchar(); /* Move forward by characters */ -extern int gotobob(); /* Move to start of buffer */ -extern int gotoeob(); /* Move to end of buffer */ -extern int forwline(); /* Move forward by lines */ -extern int backline(); /* Move backward by lines */ -extern int forwpage(); /* Move forward by pages */ -extern int backpage(); /* Move backward by pages */ -extern int pagenext(); /* Page forward next window */ -extern int setmark(); /* Set mark */ -extern int swapmark(); /* Swap "." and mark */ -extern int gotoline(); /* Go to a specified line. */ -#ifdef GOSMACS -extern int forw1page(); /* move forward by lines */ -extern int back1page(); /* move back by lines */ -#endif - -/* - * Defined by "buffer.c". - */ -extern int listbuffers(); /* Display list of buffers */ -extern int usebuffer(); /* Switch a window to a buffer */ -extern int poptobuffer(); /* Other window to a buffer */ -extern int killbuffer(); /* Make a buffer go away. */ -extern int savebuffers(); /* Save unmodified buffers */ -extern int bufferinsert(); /* Insert buffer into another */ -extern int notmodified(); /* Reset modification flag */ - -#ifndef NO_DIR -/* - * Defined by "dir.c" - */ -extern int changedir(); /* change current directory */ -extern int showcwdir(); /* show current directory */ - -#ifndef NO_DIRED -/* - * defined by "dired.c" - */ -extern int dired(); /* dired */ -extern int d_findfile(); /* dired find file */ -extern int d_del(); /* dired mark for deletion */ -extern int d_undel(); /* dired unmark */ -extern int d_undelbak(); /* dired unmark backwards */ -extern int d_expunge(); /* dired expunge */ -extern int d_copy(); /* dired copy */ -extern int d_rename(); /* dired rename */ -extern int d_otherwindow(); /* dired other window */ -extern int d_ffotherwindow(); /* dired find file other window */ -#endif -#endif - -/* - * Defined by "extend.c". - */ -extern int extend(); /* Extended commands. */ -extern int bindtokey(); /* Modify global key bindings. */ -extern int localbind(); /* Modify mode key bindings. */ -extern int define_key(); /* modify any key map */ -extern int unbindtokey(); /* delete global binding */ -extern int localunbind(); /* delete local binding */ -extern int insert(); /* insert string */ -#ifndef NO_STARTUP -extern int evalexpr(); /* Extended commands (again) */ -extern int evalbuffer(); /* Evaluate current buffer */ -extern int evalfile(); /* Evaluate a file */ -#endif - -/* - * Defined by "file.c". - */ -extern int filevisit(); /* Get a file, read write */ -extern int poptofile(); /* Get a file, other window */ -extern int filewrite(); /* Write a file */ -extern int filesave(); /* Save current file */ -extern int fileinsert(); /* Insert file into buffer */ -#ifndef NO_BACKUP -extern int makebkfile(); /* Control backups on saves */ -#endif - -/* - * defined by help.c - */ -#ifndef NO_HELP -extern int desckey(); /* describe key */ -extern int wallchart(); /* Make wall chart. */ -extern int help_help(); /* help help */ -extern int apropos_command(); /* apropos */ -#endif - -/* - * defined by "kbd.c" - */ -#ifdef DO_METAKEY -extern int do_meta(); /* interpret meta keys */ -#endif -#ifdef BSMAP -extern int bsmap(); /* backspace mapping */ -#endif -extern int universal_argument(); /* Ctrl-U */ -extern int digit_argument(); /* M-1, etc. */ -extern int negative_argument(); /* M-- */ -extern int selfinsert(); /* Insert character */ -extern int rescan(); /* internal try again function */ - /* * defined by "macro.c" */ #ifndef NO_MACRO -extern int definemacro(); /* Begin macro */ -extern int finishmacro(); /* End macro */ -extern int executemacro(); /* Execute macro */ +extern int definemacro(); /* Begin macro */ +extern int finishmacro(); /* End macro */ +extern int executemacro(); /* Execute macro */ #endif /* * Defined by "main.c". */ -extern int ctrlg(); /* Abort out of things */ -extern int quit(); /* Quit */ +extern int ctrlg(); /* Abort out of things */ +extern int quit(); /* Quit */ /* * Defined by "match.c" */ -extern int showmatch(); /* Hack to show matching paren */ +extern int showmatch(); /* Hack to show matching paren */ /* defined by "modes.c" */ -extern int indentmode(); /* set auto-indent mode */ -extern int fillmode(); /* set word-wrap mode */ -extern int blinkparen(); /* Fake blink-matching-paren var */ +extern int indentmode(); /* set auto-indent mode */ +extern int fillmode(); /* set word-wrap mode */ +extern int blinkparen(); /* Fake blink-matching-paren var */ #ifdef NOTAB -extern int notabmode(); /* no tab mode */ +extern int notabmode(); /* no tab mode */ #endif -extern int overwrite(); /* overwrite mode */ -extern int set_default_mode(); /* set default modes */ +extern int overwrite(); /* overwrite mode */ +extern int set_default_mode(); /* set default modes */ /* * defined by "paragraph.c" - the paragraph justification code. */ -extern int gotobop(); /* Move to start of paragraph. */ -extern int gotoeop(); /* Move to end of paragraph. */ -extern int fillpara(); /* Justify a paragraph. */ -extern int killpara(); /* Delete a paragraph. */ -extern int setfillcol(); /* Set fill column for justify. */ -extern int fillword(); /* Insert char with word wrap. */ +extern int gotobop(); /* Move to start of paragraph. */ +extern int gotoeop(); /* Move to end of paragraph. */ +extern int fillpara(); /* Justify a paragraph. */ +extern int killpara(); /* Delete a paragraph. */ +extern int setfillcol(); /* Set fill column for justify. */ +extern int fillword(); /* Insert char with word wrap. */ /* * Defined by "random.c". */ -extern int showcpos(); /* Show the cursor position */ -extern int twiddle(); /* Twiddle characters */ -extern int quote(); /* Insert literal */ -extern int openline(); /* Open up a blank line */ -extern int newline(); /* Insert newline */ -extern int deblank(); /* Delete blank lines */ -extern int justone(); /* Delete extra whitespace */ -extern int delwhite(); /* Delete all whitespace */ -extern int indent(); /* Insert newline, then indent */ -extern int forwdel(); /* Forward delete */ -extern int backdel(); /* Backward delete in */ -extern int killline(); /* Kill forward */ -extern int yank(); /* Yank back from killbuffer. */ +extern int showcpos(); /* Show the cursor position */ +extern int twiddle(); /* Twiddle characters */ +extern int quote(); /* Insert literal */ +extern int openline(); /* Open up a blank line */ +extern int newline(); /* Insert newline */ +extern int deblank(); /* Delete blank lines */ +extern int justone(); /* Delete extra whitespace */ +extern int delwhite(); /* Delete all whitespace */ +extern int indent(); /* Insert newline, then indent */ +extern int forwdel(); /* Forward delete */ +extern int backdel(); /* Backward delete in */ +extern int killline(); /* Kill forward */ +extern int yank(); /* Yank back from killbuffer. */ #ifdef NOTAB -extern int space_to_tabstop(); +extern int space_to_tabstop(); #endif #ifdef REGEX /* * Defined by "re_search.c" */ -extern int re_forwsearch(); /* Regex search forward */ -extern int re_backsearch(); /* Regex search backwards */ -extern int re_searchagain(); /* Repeat regex search command */ -extern int re_queryrepl(); /* Regex query replace */ -extern int setcasefold(); /* Set case fold in searches */ -extern int delmatchlines(); /* Delete all lines matching */ -extern int delnonmatchlines(); /* Delete all lines not matching */ -extern int cntmatchlines(); /* Count matching lines */ -extern int cntnonmatchlines(); /* Count nonmatching lines */ +extern int re_forwsearch();/* Regex search forward */ +extern int re_backsearch();/* Regex search backwards */ +extern int re_searchagain(); /* Repeat regex search command */ +extern int re_queryrepl(); /* Regex query replace */ +extern int setcasefold(); /* Set case fold in searches */ +extern int delmatchlines();/* Delete all lines matching */ +extern int delnonmatchlines(); /* Delete all lines not matching */ +extern int cntmatchlines();/* Count matching lines */ +extern int cntnonmatchlines(); /* Count nonmatching lines */ #endif /* * Defined by "region.c". */ -extern int killregion(); /* Kill region. */ -extern int copyregion(); /* Copy region to kill buffer. */ -extern int lowerregion(); /* Lower case region. */ -extern int upperregion(); /* Upper case region. */ +extern int killregion(); /* Kill region. */ +extern int copyregion(); /* Copy region to kill buffer. */ +extern int lowerregion(); /* Lower case region. */ +extern int upperregion(); /* Upper case region. */ #ifdef PREFIXREGION -extern int prefixregion(); /* Prefix all lines in region */ -extern int setprefix(); /* Set line prefix string */ +extern int prefixregion(); /* Prefix all lines in region */ +extern int setprefix(); /* Set line prefix string */ #endif /* * Defined by "search.c". */ -extern int forwsearch(); /* Search forward */ -extern int backsearch(); /* Search backwards */ -extern int searchagain(); /* Repeat last search command */ -extern int forwisearch(); /* Incremental search forward */ -extern int backisearch(); /* Incremental search backwards */ -extern int queryrepl(); /* Query replace */ +extern int forwsearch(); /* Search forward */ +extern int backsearch(); /* Search backwards */ +extern int searchagain(); /* Repeat last search command */ +extern int forwisearch(); /* Incremental search forward */ +extern int backisearch(); /* Incremental search backwards */ +extern int queryrepl(); /* Query replace */ /* * Defined by "spawn.c". */ -extern int spawncli(); /* Run CLI in a subjob. */ +extern int spawncli(); /* Run CLI in a subjob. */ #ifdef VMS -extern int attachtoparent(); /* Attach to parent process */ +extern int attachtoparent(); /* Attach to parent process */ #endif /* defined by "version.c" */ -extern int showversion(); /* Show version numbers, etc. */ +extern int showversion(); /* Show version numbers, etc. */ /* * Defined by "window.c". */ -extern int reposition(); /* Reposition window */ -extern int refresh(); /* Refresh the screen */ -extern int nextwind(); /* Move to the next window */ +extern int reposition(); /* Reposition window */ +extern int refresh(); /* Refresh the screen */ +extern int nextwind(); /* Move to the next window */ #ifdef GOSMACS -extern int prevwind(); /* Move to the previous window */ +extern int prevwind(); /* Move to the previous window */ #endif -extern int onlywind(); /* Make current window only one */ -extern int splitwind(); /* Split current window */ -extern int delwind(); /* Delete current window */ -extern int enlargewind(); /* Enlarge display window. */ -extern int shrinkwind(); /* Shrink window. */ +extern int onlywind(); /* Make current window only one */ +extern int splitwind(); /* Split current window */ +extern int delwind(); /* Delete current window */ +extern int enlargewind(); /* Enlarge display window. */ +extern int shrinkwind(); /* Shrink window. */ /* * Defined by "word.c". */ -extern int backword(); /* Backup by words */ -extern int forwword(); /* Advance by words */ -extern int upperword(); /* Upper case word. */ -extern int lowerword(); /* Lower case word. */ -extern int capword(); /* Initial capitalize word. */ -extern int delfword(); /* Delete forward word. */ -extern int delbword(); /* Delete backward word. */ +extern int backword(); /* Backup by words */ +extern int forwword(); /* Advance by words */ +extern int upperword(); /* Upper case word. */ +extern int lowerword(); /* Lower case word. */ +extern int capword(); /* Initial capitalize word. */ +extern int delfword(); /* Delete forward word. */ +extern int delbword(); /* Delete backward word. */ #ifdef AMIGA #ifdef DO_ICONIFY -extern int tticon(); +extern int tticon(); #endif #ifdef DO_MENU -extern int amigamenu(); /* Menu function */ +extern int amigamenu(); /* Menu function */ #endif #ifdef MOUSE -extern int amigamouse(); /* Amiga mouse functions */ -extern int mgotobob(); -extern int mforwdel(); -extern int mdelwhite(); -extern int mdelwind(); -extern int mgotoeob(); -extern int menlargewind(); -extern int mkillline(); -extern int mkillregion(); -extern int mdelfword(); -extern int mreposition(); -extern int mbackpage(); -extern int mforwpage(); -extern int mshrinkwind(); -extern int msplitwind(); -extern int myank(); -#endif MOUSE - -extern int togglewindow(); /* Defined by "ttyio.c" */ -extern int togglezooms(); /* "" "" */ +extern int amigamouse(); /* Amiga mouse functions */ +extern int mgotobob(); +extern int mforwdel(); +extern int mdelwhite(); +extern int mdelwind(); +extern int mgotoeob(); +extern int menlargewind(); +extern int mkillline(); +extern int mkillregion(); +extern int mdelfword(); +extern int mreposition(); +extern int mbackpage(); +extern int mforwpage(); +extern int mshrinkwind(); +extern int msplitwind(); +extern int myank(); +#endif /* MOUSE */ + +extern int togglewindow(); /* Defined by "ttyio.c" */ +extern int togglezooms(); /* "" "" */ #ifdef CHANGE_FONT -extern int setfont(); /* Defined by "ttyio.c" */ +extern int setfont(); /* Defined by "ttyio.c" */ #endif #ifdef CHANGE_COLOR - /* functions to mess with the mode line rendition, window colors*/ -extern int ttmode(); /* Defined by "tty.c" */ -extern int tttext(); /* "" */ -extern int textforeground(); /* "" */ -extern int textbackground(); /* "" */ -extern int modeforeground(); /* "" */ -extern int modebackground(); /* "" */ +/* functions to mess with the mode line rendition, window colors */ +extern int ttmode(); /* Defined by "tty.c" */ +extern int tttext(); /* "" */ +extern int textforeground(); /* "" */ +extern int textbackground(); /* "" */ +extern int modeforeground(); /* "" */ +extern int modebackground(); /* "" */ #endif /* @@ -303,803 +193,880 @@ extern int modebackground(); /* "" */ */ #include "amiga_maps.c" -#endif /* AMIGA */ +#endif /* AMIGA */ /* initial keymap declarations, deepest first */ #ifndef NO_HELP -static PF cHcG[] = { - ctrlg, /* ^G */ - help_help, /* ^H */ +static PF cHcG[] = { + ctrlg, /* ^G */ + help_help, /* ^H */ }; -static PF cHa[] = { - apropos_command,/* a */ - wallchart, /* b */ - desckey, /* c */ +static PF cHa[] = { + apropos_command, /* a */ + wallchart, /* b */ + desckey, /* c */ }; -static struct KEYMAPE(2+IMAPEXT) helpmap = { +static struct KEYMAPE (2 + IMAPEXT) helpmap = { 2, - 2+IMAPEXT, + 2 + IMAPEXT, rescan, { - {CCHR('G'),CCHR('H'), cHcG, (KEYMAP *)NULL}, - {'a', 'c', cHa, (KEYMAP *)NULL}, + { + CCHR('G'), CCHR('H'), cHcG, (KEYMAP *) NULL + }, + { + 'a', 'c', cHa, (KEYMAP *) NULL + }, } }; #endif -static struct KEYMAPE(1+IMAPEXT) extramap1 = { +static struct KEYMAPE (1 + IMAPEXT) extramap1 = { 0, - 1+IMAPEXT, + 1 + IMAPEXT, rescan }; -static struct KEYMAPE(1+IMAPEXT) extramap2 = { +static struct KEYMAPE (1 + IMAPEXT) extramap2 = { 0, - 1+IMAPEXT, + 1 + IMAPEXT, rescan }; -static struct KEYMAPE(1+IMAPEXT) extramap3 = { +static struct KEYMAPE (1 + IMAPEXT) extramap3 = { 0, - 1+IMAPEXT, + 1 + IMAPEXT, rescan }; -static struct KEYMAPE(1+IMAPEXT) extramap4 = { +static struct KEYMAPE (1 + IMAPEXT) extramap4 = { 0, - 1+IMAPEXT, + 1 + IMAPEXT, rescan }; -static struct KEYMAPE(1+IMAPEXT) extramap5 = { +static struct KEYMAPE (1 + IMAPEXT) extramap5 = { 0, - 1+IMAPEXT, + 1 + IMAPEXT, rescan }; -static PF cX4cF[] = { - poptofile, /* ^f */ - ctrlg, /* ^g */ +static PF cX4cF[] = { + poptofile, /* ^f */ + ctrlg, /* ^g */ }; -static PF cX4b[] = { - poptobuffer, /* b */ - rescan, /* c */ - rescan, /* d */ - rescan, /* e */ - poptofile, /* f */ +static PF cX4b[] = { + poptobuffer, /* b */ + rescan, /* c */ + rescan, /* d */ + rescan, /* e */ + poptofile, /* f */ }; -static struct KEYMAPE(2+IMAPEXT) cX4map = { +static struct KEYMAPE (2 + IMAPEXT) cX4map = { 2, - 2+IMAPEXT, + 2 + IMAPEXT, rescan, { - {CCHR('F'),CCHR('G'), cX4cF, (KEYMAP *)NULL}, - {'b', 'f', cX4b, (KEYMAP *)NULL}, + { + CCHR('F'), CCHR('G'), cX4cF, (KEYMAP *) NULL + }, + { + 'b', 'f', cX4b, (KEYMAP *) NULL + }, } }; -static PF cXcB[] = { - listbuffers, /* ^B */ - quit, /* ^C */ - rescan, /* ^D */ - rescan, /* ^E */ - filevisit, /* ^F */ - ctrlg, /* ^G */ +static PF cXcB[] = { + listbuffers, /* ^B */ + quit, /* ^C */ + rescan, /* ^D */ + rescan, /* ^E */ + filevisit, /* ^F */ + ctrlg, /* ^G */ }; -static PF cXcL[] = { - lowerregion, /* ^L */ - rescan, /* ^M */ - rescan, /* ^N */ - deblank, /* ^O */ - rescan, /* ^P */ - rescan, /* ^Q */ - rescan, /* ^R */ - filesave, /* ^S */ - rescan, /* ^T */ - upperregion, /* ^U */ - rescan, /* ^V */ - filewrite, /* ^W */ - swapmark, /* ^X */ +static PF cXcL[] = { + lowerregion, /* ^L */ + rescan, /* ^M */ + rescan, /* ^N */ + deblank, /* ^O */ + rescan, /* ^P */ + rescan, /* ^Q */ + rescan, /* ^R */ + filesave, /* ^S */ + rescan, /* ^T */ + upperregion, /* ^U */ + rescan, /* ^V */ + filewrite, /* ^W */ + swapmark, /* ^X */ }; #ifndef NO_MACRO -static PF cXlp[] = { - definemacro, /* ( */ - finishmacro, /* ) */ +static PF cXlp[] = { + definemacro, /* ( */ + finishmacro, /* ) */ }; #endif -static PF cX0[] = { - delwind, /* 0 */ - onlywind, /* 1 */ - splitwind, /* 2 */ - rescan, /* 3 */ - prefix, /* 4 */ +static PF cX0[] = { + delwind, /* 0 */ + onlywind, /* 1 */ + splitwind, /* 2 */ + rescan, /* 3 */ + prefix, /* 4 */ }; -static PF cXeq[] = { - showcpos, /* = */ +static PF cXeq[] = { + showcpos, /* = */ }; -static PF cXcar[] = { - enlargewind, /* ^ */ - rescan, /* _ */ - rescan, /* ` */ - rescan, /* a */ - usebuffer, /* b */ - rescan, /* c */ +static PF cXcar[] = { + enlargewind, /* ^ */ + rescan, /* _ */ + rescan, /* ` */ + rescan, /* a */ + usebuffer, /* b */ + rescan, /* c */ #ifndef NO_DIRED - dired, /* d */ + dired, /* d */ #else - rescan, /* d */ + rescan, /* d */ #endif #ifndef NO_MACRO - executemacro, /* e */ + executemacro, /* e */ #else - rescan, /* e */ -#endif - setfillcol, /* f */ - rescan, /* g */ - rescan, /* h */ - fileinsert, /* i */ - rescan, /* j */ - killbuffer, /* k */ - rescan, /* l */ - rescan, /* m */ - rescan, /* n */ - nextwind, /* o */ - rescan, /* p */ - rescan, /* q */ - rescan, /* r */ - savebuffers, /* s */ + rescan, /* e */ +#endif + setfillcol, /* f */ + rescan, /* g */ + rescan, /* h */ + fileinsert, /* i */ + rescan, /* j */ + killbuffer, /* k */ + rescan, /* l */ + rescan, /* m */ + rescan, /* n */ + nextwind, /* o */ + rescan, /* p */ + rescan, /* q */ + rescan, /* r */ + savebuffers, /* s */ }; #ifndef NO_MACRO -static struct KEYMAPE(6+IMAPEXT) cXmap = { +static struct KEYMAPE (6 + IMAPEXT) cXmap = { 6, - 6+IMAPEXT, + 6 + IMAPEXT, #else -static struct KEYMAPE(5+IMAPEXT) cXmap = { +static struct KEYMAPE (5 + IMAPEXT) cXmap = { 5, - 5+IMAPEXT, + 5 + IMAPEXT, #endif rescan, { - {CCHR('B'),CCHR('G'), cXcB, (KEYMAP *)NULL}, - {CCHR('L'),CCHR('X'), cXcL, (KEYMAP *)NULL}, + { + CCHR('B'), CCHR('G'), cXcB, (KEYMAP *) NULL + }, + { + CCHR('L'), CCHR('X'), cXcL, (KEYMAP *) NULL + }, #ifndef NO_MACRO - {'(', ')', cXlp, (KEYMAP *)NULL}, -#endif - {'0', '4', cX0, (KEYMAP *)&cX4map}, - {'=', '=', cXeq, (KEYMAP *)NULL}, - {'^', 's', cXcar, (KEYMAP *)NULL}, + { + '(', ')', cXlp, (KEYMAP *) NULL + }, +#endif + { + '0', '4', cX0, (KEYMAP *) & cX4map + }, + { + '=', '=', cXeq, (KEYMAP *) NULL + }, + { + '^', 's', cXcar, (KEYMAP *) NULL + }, } }; -static PF metacG[] = { - ctrlg, /* ^G */ +static PF metacG[] = { + ctrlg, /* ^G */ }; -static PF metacV[] = { - pagenext, /* ^V */ +static PF metacV[] = { + pagenext, /* ^V */ }; -static PF metasp[] = { - justone, /* space */ +static PF metasp[] = { + justone, /* space */ }; -static PF metapct[] = { - queryrepl, /* % */ +static PF metapct[] = { + queryrepl, /* % */ }; -static PF metami[] = { +static PF metami[] = { negative_argument, /* - */ - rescan, /* . */ - rescan, /* / */ - digit_argument, /* 0 */ - digit_argument, /* 1 */ - digit_argument, /* 2 */ - digit_argument, /* 3 */ - digit_argument, /* 4 */ - digit_argument, /* 5 */ - digit_argument, /* 6 */ - digit_argument, /* 7 */ - digit_argument, /* 8 */ - digit_argument, /* 9 */ - rescan, /* : */ - rescan, /* ; */ - gotobob, /* < */ - rescan, /* = */ - gotoeob, /* > */ + rescan, /* . */ + rescan, /* / */ + digit_argument, /* 0 */ + digit_argument, /* 1 */ + digit_argument, /* 2 */ + digit_argument, /* 3 */ + digit_argument, /* 4 */ + digit_argument, /* 5 */ + digit_argument, /* 6 */ + digit_argument, /* 7 */ + digit_argument, /* 8 */ + digit_argument, /* 9 */ + rescan, /* : */ + rescan, /* ; */ + gotobob, /* < */ + rescan, /* = */ + gotoeob, /* > */ }; -static PF metalb[] = { - gotobop, /* [ */ - delwhite, /* \ */ - gotoeop, /* ] */ - rescan, /* ^ */ - rescan, /* _ */ - rescan, /* ` */ - rescan, /* a */ - backword, /* b */ - capword, /* c */ - delfword, /* d */ - rescan, /* e */ - forwword, /* f */ +static PF metalb[] = { + gotobop, /* [ */ + delwhite, /* \ */ + gotoeop, /* ] */ + rescan, /* ^ */ + rescan, /* _ */ + rescan, /* ` */ + rescan, /* a */ + backword, /* b */ + capword, /* c */ + delfword, /* d */ + rescan, /* e */ + forwword, /* f */ }; -static PF metal[] = { - lowerword, /* l */ - rescan, /* m */ - rescan, /* n */ - rescan, /* o */ - rescan, /* p */ - fillpara, /* q */ - backsearch, /* r */ - forwsearch, /* s */ - rescan, /* t */ - upperword, /* u */ - backpage, /* v */ - copyregion, /* w */ - extend, /* x */ +static PF metal[] = { + lowerword, /* l */ + rescan, /* m */ + rescan, /* n */ + rescan, /* o */ + rescan, /* p */ + fillpara, /* q */ + backsearch, /* r */ + forwsearch, /* s */ + rescan, /* t */ + upperword, /* u */ + backpage, /* v */ + copyregion, /* w */ + extend, /* x */ }; -static PF metatilde[] = { - notmodified, /* ~ */ - delbword, /* DEL */ +static PF metatilde[] = { + notmodified, /* ~ */ + delbword, /* DEL */ }; -static struct KEYMAPE(8+IMAPEXT) metamap = { +static struct KEYMAPE (8 + IMAPEXT) metamap = { 8, - 8+IMAPEXT, + 8 + IMAPEXT, rescan, { - {CCHR('G'),CCHR('G'), metacG, (KEYMAP *)NULL}, - {CCHR('V'),CCHR('V'), metacV, (KEYMAP *)NULL}, - {' ', ' ', metasp, (KEYMAP *)NULL}, - {'%', '%', metapct,(KEYMAP *)NULL}, - {'-', '>', metami, (KEYMAP *)NULL}, - {'[', 'f', metalb, (KEYMAP *)NULL}, - {'l', 'x', metal, (KEYMAP *)NULL}, - {'~', CCHR('?'), metatilde,(KEYMAP *)NULL}, + { + CCHR('G'), CCHR('G'), metacG, (KEYMAP *) NULL + }, + { + CCHR('V'), CCHR('V'), metacV, (KEYMAP *) NULL + }, + { + ' ', ' ', metasp, (KEYMAP *) NULL + }, + { + '%', '%', metapct, (KEYMAP *) NULL + }, + { + '-', '>', metami, (KEYMAP *) NULL + }, + { + '[', 'f', metalb, (KEYMAP *) NULL + }, + { + 'l', 'x', metal, (KEYMAP *) NULL + }, + { + '~', CCHR('?'), metatilde, (KEYMAP *) NULL + }, } }; -static PF fund_at[] = { - setmark, /* ^@ */ - gotobol, /* ^A */ - backchar, /* ^B */ - rescan, /* ^C */ - forwdel, /* ^D */ - gotoeol, /* ^E */ - forwchar, /* ^F */ - ctrlg, /* ^G */ +static PF fund_at[] = { + setmark, /* ^@ */ + gotobol, /* ^A */ + backchar, /* ^B */ + rescan, /* ^C */ + forwdel, /* ^D */ + gotoeol, /* ^E */ + forwchar, /* ^F */ + ctrlg, /* ^G */ #ifndef NO_HELP - prefix, /* ^H */ + prefix, /* ^H */ #else - rescan, /* ^H */ + rescan, /* ^H */ #endif }; /* ^I is selfinsert */ -static PF fund_CJ[] = { - indent, /* ^J */ - killline, /* ^K */ - reposition, /* ^L */ - newline, /* ^M */ - forwline, /* ^N */ - openline, /* ^O */ - backline, /* ^P */ - quote, /* ^Q */ - backisearch, /* ^R */ - forwisearch, /* ^S */ - twiddle, /* ^T */ +static PF fund_CJ[] = { + indent, /* ^J */ + killline, /* ^K */ + reposition, /* ^L */ + newline, /* ^M */ + forwline, /* ^N */ + openline, /* ^O */ + backline, /* ^P */ + quote, /* ^Q */ + backisearch, /* ^R */ + forwisearch, /* ^S */ + twiddle, /* ^T */ universal_argument, /* ^U */ - forwpage, /* ^V */ - killregion, /* ^W */ - prefix, /* ^X */ - yank, /* ^Y */ + forwpage, /* ^V */ + killregion, /* ^W */ + prefix, /* ^X */ + yank, /* ^Y */ #ifndef VMS - spawncli, /* ^Z */ + spawncli, /* ^Z */ #else - attachtoparent, /* ^Z */ + attachtoparent, /* ^Z */ #endif }; -static PF fund_esc[] = { - prefix, /* esc */ - rescan, /* ^\ */ /* selfinsert is default on fundamental */ - rescan, /* ^] */ - rescan, /* ^^ */ - rescan, /* ^_ */ +static PF fund_esc[] = { + prefix, /* esc */ + rescan, /* ^\ *//* selfinsert is default on + * fundamental */ + rescan, /* ^] */ + rescan, /* ^^ */ + rescan, /* ^_ */ }; -static PF fund_del[] = { - backdel, /* DEL */ +static PF fund_del[] = { + backdel, /* DEL */ }; #ifndef FUND_XMAPS #define NFUND_XMAPS 0 /* extra map sections after normal ones */ #endif -static struct KEYMAPE(4+NFUND_XMAPS+IMAPEXT) fundmap = { +static struct KEYMAPE (4 + NFUND_XMAPS + IMAPEXT) fundmap = { 4 + NFUND_XMAPS, 4 + NFUND_XMAPS + IMAPEXT, selfinsert, { #ifndef NO_HELP - {CCHR('@'),CCHR('H'), fund_at, (KEYMAP *)&helpmap}, + { + CCHR('@'), CCHR('H'), fund_at, (KEYMAP *) & helpmap + }, #else - {CCHR('@'),CCHR('H'), fund_at, (KEYMAP *)NULL}, -#endif - {CCHR('J'),CCHR('Z'), fund_CJ, (KEYMAP *)&cXmap}, - {CCHR('['),CCHR('_'), fund_esc,(KEYMAP *)&metamap}, - {CCHR('?'),CCHR('?'), fund_del,(KEYMAP *)NULL}, + { + CCHR('@'), CCHR('H'), fund_at, (KEYMAP *) NULL + }, +#endif + { + CCHR('J'), CCHR('Z'), fund_CJ, (KEYMAP *) & cXmap + }, + { + CCHR('['), CCHR('_'), fund_esc, (KEYMAP *) & metamap + }, + { + CCHR('?'), CCHR('?'), fund_del, (KEYMAP *) NULL + }, #ifdef FUND_XMAPS FUND_XMAPS, #endif } }; -static PF fill_sp[] = { - fillword, /* ' ' */ +static PF fill_sp[] = { + fillword, /* ' ' */ }; -static struct KEYMAPE(1+IMAPEXT) fillmap = { +static struct KEYMAPE (1 + IMAPEXT) fillmap = { 1, - 1+IMAPEXT, + 1 + IMAPEXT, rescan, { - {' ', ' ', fill_sp, (KEYMAP *)NULL}, + { + ' ', ' ', fill_sp, (KEYMAP *) NULL + }, } }; -static PF indent_lf[] = { - newline, /* ^J */ - rescan, /* ^K */ - rescan, /* ^L */ - indent, /* ^M */ +static PF indent_lf[] = { + newline, /* ^J */ + rescan, /* ^K */ + rescan, /* ^L */ + indent, /* ^M */ }; -static struct KEYMAPE(1+IMAPEXT) indntmap = { +static struct KEYMAPE (1 + IMAPEXT) indntmap = { 1, - 1+IMAPEXT, + 1 + IMAPEXT, rescan, { - {CCHR('J'), CCHR('M'), indent_lf, (KEYMAP *)NULL}, + { + CCHR('J'), CCHR('M'), indent_lf, (KEYMAP *) NULL + }, } }; -static PF blink_rp[] = { - showmatch, /* ) */ +static PF blink_rp[] = { + showmatch, /* ) */ }; -static struct KEYMAPE(1+IMAPEXT) blinkmap = { +static struct KEYMAPE (1 + IMAPEXT) blinkmap = { 1, - 1+IMAPEXT, + 1 + IMAPEXT, rescan, { - {')', ')', blink_rp, (KEYMAP *)NULL}, + { + ')', ')', blink_rp, (KEYMAP *) NULL + }, } }; #ifdef NOTAB -static PF notab_tab[] = { +static PF notab_tab[] = { space_to_tabstop, /* ^I */ }; -static struct KEYMAPE(1+IMAPEXT) notabmap = { +static struct KEYMAPE (1 + IMAPEXT) notabmap = { 1, - 1+IMAPEXT, + 1 + IMAPEXT, rescan, { - {CCHR('I'),CCHR('I'), notab_tab, (KEYMAP *)NULL}, + { + CCHR('I'), CCHR('I'), notab_tab, (KEYMAP *) NULL + }, } }; #endif -static struct KEYMAPE(1+IMAPEXT) overwmap = { +static struct KEYMAPE (1 + IMAPEXT) overwmap = { 0, - 1+IMAPEXT, /* 1 to avoid 0 sized array */ + 1 + IMAPEXT, /* 1 to avoid 0 sized array */ rescan, { /* unused dummy entry for VMS C */ - {(KCHAR)0, (KCHAR)0, (PF *)NULL, (KEYMAP *)NULL}, + { + (KCHAR) 0, (KCHAR) 0, (PF *) NULL, (KEYMAP *) NULL + }, } }; #ifndef NO_DIRED -static PF dirednul[] = { - setmark, /* ^@ */ - gotobol, /* ^A */ - backchar, /* ^B */ - rescan, /* ^C */ - d_del, /* ^D */ - gotoeol, /* ^E */ - forwchar, /* ^F */ - ctrlg, /* ^G */ +static PF dirednul[] = { + setmark, /* ^@ */ + gotobol, /* ^A */ + backchar, /* ^B */ + rescan, /* ^C */ + d_del, /* ^D */ + gotoeol, /* ^E */ + forwchar, /* ^F */ + ctrlg, /* ^G */ #ifndef NO_HELP - prefix, /* ^H */ + prefix, /* ^H */ #endif }; -static PF diredcl[] = { - reposition, /* ^L */ - forwline, /* ^M */ - forwline, /* ^N */ - rescan, /* ^O */ - backline, /* ^P */ - rescan, /* ^Q */ - backisearch, /* ^R */ - forwisearch, /* ^S */ - rescan, /* ^T */ - universal_argument, /* ^U */ - forwpage, /* ^V */ - rescan, /* ^W */ - prefix, /* ^X */ +static PF diredcl[] = { + reposition, /* ^L */ + forwline, /* ^M */ + forwline, /* ^N */ + rescan, /* ^O */ + backline, /* ^P */ + rescan, /* ^Q */ + backisearch, /* ^R */ + forwisearch, /* ^S */ + rescan, /* ^T */ + universal_argument, /* ^U */ + forwpage, /* ^V */ + rescan, /* ^W */ + prefix, /* ^X */ }; -static PF diredcz[] = { +static PF diredcz[] = { #ifndef VMS - spawncli, /* ^Z */ + spawncli, /* ^Z */ #else - attachtoparent, /* ^Z */ -#endif - prefix, /* esc */ - rescan, /* ^\ */ - rescan, /* ^] */ - rescan, /* ^^ */ - rescan, /* ^_ */ - forwline, /* SP */ + attachtoparent, /* ^Z */ +#endif + prefix, /* esc */ + rescan, /* ^\ */ + rescan, /* ^] */ + rescan, /* ^^ */ + rescan, /* ^_ */ + forwline, /* SP */ }; -static PF diredc[] = { - d_copy, /* c */ - d_del, /* d */ - d_findfile, /* e */ - d_findfile, /* f */ +static PF diredc[] = { + d_copy, /* c */ + d_del, /* d */ + d_findfile, /* e */ + d_findfile, /* f */ }; -static PF diredn[] = { - forwline, /* n */ - d_ffotherwindow,/* o */ - backline, /* p */ - rescan, /* q */ - d_rename, /* r */ - rescan, /* s */ - rescan, /* t */ - d_undel, /* u */ - rescan, /* v */ - rescan, /* w */ - d_expunge, /* x */ +static PF diredn[] = { + forwline, /* n */ + d_ffotherwindow, /* o */ + backline, /* p */ + rescan, /* q */ + d_rename, /* r */ + rescan, /* s */ + rescan, /* t */ + d_undel, /* u */ + rescan, /* v */ + rescan, /* w */ + d_expunge, /* x */ }; -static PF direddl[] = { - d_undelbak, /* del */ +static PF direddl[] = { + d_undelbak, /* del */ }; #ifndef DIRED_XMAPS #define NDIRED_XMAPS 0 /* number of extra map sections */ #endif -static struct KEYMAPE(6 + NDIRED_XMAPS + IMAPEXT) diredmap = { +static struct KEYMAPE (6 + NDIRED_XMAPS + IMAPEXT) diredmap = { 6 + NDIRED_XMAPS, 6 + NDIRED_XMAPS + IMAPEXT, rescan, { #ifndef NO_HELP - {CCHR('@'), CCHR('H'), dirednul, (KEYMAP *)&helpmap}, + { + CCHR('@'), CCHR('H'), dirednul, (KEYMAP *) & helpmap + }, #else - {CCHR('@'), CCHR('G'), dirednul, (KEYMAP *)NULL}, -#endif - {CCHR('L'), CCHR('X'), diredcl, (KEYMAP *)&cXmap}, - {CCHR('Z'), ' ', diredcz, (KEYMAP *)&metamap}, - {'c', 'f', diredc, (KEYMAP *)NULL}, - {'n', 'x', diredn, (KEYMAP *)NULL}, - {CCHR('?'), CCHR('?'), direddl, (KEYMAP *)NULL}, + { + CCHR('@'), CCHR('G'), dirednul, (KEYMAP *) NULL + }, +#endif + { + CCHR('L'), CCHR('X'), diredcl, (KEYMAP *) & cXmap + }, + { + CCHR('Z'), ' ', diredcz, (KEYMAP *) & metamap + }, + { + 'c', 'f', diredc, (KEYMAP *) NULL + }, + { + 'n', 'x', diredn, (KEYMAP *) NULL + }, + { + CCHR('?'), CCHR('?'), direddl, (KEYMAP *) NULL + }, #ifdef DIRED_XMAPS - DIRED_XMAPS, /* map sections for dired mode keys */ + DIRED_XMAPS, /* map sections for dired mode keys */ #endif } }; #endif -/* give names to the maps, for use by help etc. - * If the map is to be bindable, it must also be listed in the - * function name table below with the same name. - * Maps created dynamicly currently don't get added here, thus are unnamed. - * Modes are just named keymaps with functions to add/subtract them from - * a buffer's list of modes. If you change a mode name, change it in +/* + * give names to the maps, for use by help etc. If the map is to be bindable, + * it must also be listed in the function name table below with the same + * name. Maps created dynamicly currently don't get added here, thus are + * unnamed. Modes are just named keymaps with functions to add/subtract them + * from a buffer's list of modes. If you change a mode name, change it in * modes.c also. */ -MAPS map_table[] = { +MAPS map_table[] = { /* fundamental map MUST be first entry */ - {(KEYMAP *)&fundmap, "fundamental"}, - {(KEYMAP *)&fillmap, "fill"}, - {(KEYMAP *)&indntmap, "indent"}, - {(KEYMAP *)&blinkmap, "blink"}, + {(KEYMAP *) & fundmap, "fundamental"}, + {(KEYMAP *) & fillmap, "fill"}, + {(KEYMAP *) & indntmap, "indent"}, + {(KEYMAP *) & blinkmap, "blink"}, #ifdef NOTAB - {(KEYMAP *)¬abmap, "notab"}, -#endif - {(KEYMAP *)&overwmap, "overwrite"}, - {(KEYMAP *)&metamap, "esc prefix"}, - {(KEYMAP *)&cXmap, "c-x prefix"}, - {(KEYMAP *)&cX4map, "c-x 4 prefix"}, - {(KEYMAP *)&extramap1, "extra prefix 1"}, - {(KEYMAP *)&extramap2, "extra prefix 2"}, - {(KEYMAP *)&extramap3, "extra prefix 3"}, - {(KEYMAP *)&extramap4, "extra prefix 4"}, - {(KEYMAP *)&extramap5, "extra prefix 5"}, + {(KEYMAP *) & notabmap, "notab"}, +#endif + {(KEYMAP *) & overwmap, "overwrite"}, + {(KEYMAP *) & metamap, "esc prefix"}, + {(KEYMAP *) & cXmap, "c-x prefix"}, + {(KEYMAP *) & cX4map, "c-x 4 prefix"}, + {(KEYMAP *) & extramap1, "extra prefix 1"}, + {(KEYMAP *) & extramap2, "extra prefix 2"}, + {(KEYMAP *) & extramap3, "extra prefix 3"}, + {(KEYMAP *) & extramap4, "extra prefix 4"}, + {(KEYMAP *) & extramap5, "extra prefix 5"}, #ifndef NO_HELP - {(KEYMAP *)&helpmap, "help"}, + {(KEYMAP *) & helpmap, "help"}, #endif #ifndef NO_DIRED - {(KEYMAP *)&diredmap, "dired"}, + {(KEYMAP *) & diredmap, "dired"}, #endif }; #define NMAPS (sizeof map_table/sizeof(MAPS)) -int nmaps = NMAPS; /* for use by rebind in extend.c */ +int nmaps = NMAPS; /* for use by rebind in extend.c */ -char *map_name(map) -KEYMAP *map; +char * +map_name(map) + KEYMAP *map; { - MAPS *mp = &map_table[0]; + MAPS *mp = &map_table[0]; do { - if(mp->p_map == map) return mp->p_name; - } while(++mp < &map_table[NMAPS]); - return (char *)NULL; + if (mp->p_map == map) + return mp->p_name; + } while (++mp < &map_table[NMAPS]); + return (char *) NULL; } -MAPS *name_mode(name) -char *name; +MAPS * +name_mode(name) + char *name; { - MAPS *mp = &map_table[0]; + MAPS *mp = &map_table[0]; do { - if(strcmp(mp->p_name,name)==0) return mp; - } while(++mp < &map_table[NMAPS]); - return (MAPS *)NULL; + if (strcmp(mp->p_name, name) == 0) + return mp; + } while (++mp < &map_table[NMAPS]); + return (MAPS *) NULL; } -KEYMAP *name_map(name) -char *name; +KEYMAP * +name_map(name) + char *name; { - MAPS *mp; - return (mp=name_mode(name))==NULL ? (KEYMAP *)NULL : mp->p_map; + MAPS *mp; + return (mp = name_mode(name)) == NULL ? (KEYMAP *) NULL : mp->p_map; } -/* Warning: functnames MUST be in alphabetical order! (due to binary - * search in name_function.) If the function is prefix, it must be listed - * with the same name in the map_table above. +/* + * Warning: functnames MUST be in alphabetical order! (due to binary search + * in name_function.) If the function is prefix, it must be listed with the + * same name in the map_table above. */ -FUNCTNAMES functnames[] = { +FUNCTNAMES functnames[] = { #ifdef AMIGA #ifdef DO_ICONIFY - {tticon, "amiga-iconify"}, + {tticon, "amiga-iconify"}, #endif #ifdef DO_MENU - {amigamenu, "amiga-menu"}, + {amigamenu, "amiga-menu"}, #endif #ifdef CHANGE_COLOR - {modebackground,"amiga-mode-background"}, - {modeforeground,"amiga-mode-foreground"}, - {ttmode, "amiga-mode-rendition"}, + {modebackground, "amiga-mode-background"}, + {modeforeground, "amiga-mode-foreground"}, + {ttmode, "amiga-mode-rendition"}, #endif #ifdef CHANGE_FONT - {setfont, "amiga-set-font"}, + {setfont, "amiga-set-font"}, #endif #ifdef CHANGE_COLOR - {textbackground,"amiga-text-background"}, - {textforeground,"amiga-text-foreground"}, - {tttext, "amiga-text-rendition"}, + {textbackground, "amiga-text-background"}, + {textforeground, "amiga-text-foreground"}, + {tttext, "amiga-text-rendition"}, #endif - {togglewindow, "amiga-toggle-border"}, - {togglezooms, "amiga-zoom-mode"}, -#endif /* AMIGA */ + {togglewindow, "amiga-toggle-border"}, + {togglezooms, "amiga-zoom-mode"}, +#endif /* AMIGA */ #ifndef NO_HELP {apropos_command, "apropos"}, #endif - {fillmode, "auto-fill-mode"}, - {indentmode, "auto-indent-mode"}, - {backchar, "backward-char"}, - {delbword, "backward-kill-word"}, - {gotobop, "backward-paragraph"}, - {backword, "backward-word"}, - {gotobob, "beginning-of-buffer"}, - {gotobol, "beginning-of-line"}, - {blinkparen, "blink-matching-paren"}, - {showmatch, "blink-matching-paren-hack"}, + {fillmode, "auto-fill-mode"}, + {indentmode, "auto-indent-mode"}, + {backchar, "backward-char"}, + {delbword, "backward-kill-word"}, + {gotobop, "backward-paragraph"}, + {backword, "backward-word"}, + {gotobob, "beginning-of-buffer"}, + {gotobol, "beginning-of-line"}, + {blinkparen, "blink-matching-paren"}, + {showmatch, "blink-matching-paren-hack"}, #ifdef BSMAP - {bsmap, "bsmap-mode"}, + {bsmap, "bsmap-mode"}, #endif - {prefix, "c-x 4 prefix"}, - {prefix, "c-x prefix"}, + {prefix, "c-x 4 prefix"}, + {prefix, "c-x prefix"}, #ifndef NO_MACRO - {executemacro, "call-last-kbd-macro"}, + {executemacro, "call-last-kbd-macro"}, #endif - {capword, "capitalize-word"}, + {capword, "capitalize-word"}, #ifndef NO_DIR - {changedir, "cd"}, + {changedir, "cd"}, #endif - {copyregion, "copy-region-as-kill"}, + {copyregion, "copy-region-as-kill"}, #ifdef REGEX {cntmatchlines, "count-matches"}, - {cntnonmatchlines,"count-non-matches"}, + {cntnonmatchlines, "count-non-matches"}, #endif - {define_key, "define-key"}, - {backdel, "delete-backward-char"}, - {deblank, "delete-blank-lines"}, - {forwdel, "delete-char"}, - {delwhite, "delete-horizontal-space"}, + {define_key, "define-key"}, + {backdel, "delete-backward-char"}, + {deblank, "delete-blank-lines"}, + {forwdel, "delete-char"}, + {delwhite, "delete-horizontal-space"}, #ifdef REGEX {delmatchlines, "delete-matching-lines"}, - {delnonmatchlines,"delete-non-matching-lines"}, + {delnonmatchlines, "delete-non-matching-lines"}, #endif - {onlywind, "delete-other-windows"}, - {delwind, "delete-window"}, + {onlywind, "delete-other-windows"}, + {delwind, "delete-window"}, #ifndef NO_HELP - {wallchart, "describe-bindings"}, - {desckey, "describe-key-briefly"}, + {wallchart, "describe-bindings"}, + {desckey, "describe-key-briefly"}, #endif - {digit_argument,"digit-argument"}, + {digit_argument, "digit-argument"}, #ifndef NO_DIRED - {dired, "dired"}, - {d_undelbak, "dired-backup-unflag"}, - {d_copy, "dired-copy-file"}, - {d_expunge, "dired-do-deletions"}, - {d_findfile, "dired-find-file"}, + {dired, "dired"}, + {d_undelbak, "dired-backup-unflag"}, + {d_copy, "dired-copy-file"}, + {d_expunge, "dired-do-deletions"}, + {d_findfile, "dired-find-file"}, {d_ffotherwindow, "dired-find-file-other-window"}, - {d_del, "dired-flag-file-deleted"}, + {d_del, "dired-flag-file-deleted"}, {d_otherwindow, "dired-other-window"}, - {d_rename, "dired-rename-file"}, - {d_undel, "dired-unflag"}, + {d_rename, "dired-rename-file"}, + {d_undel, "dired-unflag"}, #endif - {lowerregion, "downcase-region"}, - {lowerword, "downcase-word"}, - {showversion, "emacs-version"}, + {lowerregion, "downcase-region"}, + {lowerword, "downcase-word"}, + {showversion, "emacs-version"}, #ifndef NO_MACRO - {finishmacro, "end-kbd-macro"}, + {finishmacro, "end-kbd-macro"}, #endif - {gotoeob, "end-of-buffer"}, - {gotoeol, "end-of-line"}, - {enlargewind, "enlarge-window"}, - {prefix, "esc prefix"}, + {gotoeob, "end-of-buffer"}, + {gotoeol, "end-of-line"}, + {enlargewind, "enlarge-window"}, + {prefix, "esc prefix"}, #ifndef NO_STARTUP - {evalbuffer, "eval-current-buffer"}, - {evalexpr, "eval-expression"}, -#endif - {swapmark, "exchange-point-and-mark"}, - {extend, "execute-extended-command"}, - {prefix, "extra prefix 1"}, - {prefix, "extra prefix 2"}, - {prefix, "extra prefix 3"}, - {prefix, "extra prefix 4"}, - {prefix, "extra prefix 5"}, - {fillpara, "fill-paragraph"}, - {filevisit, "find-file"}, - {poptofile, "find-file-other-window"}, - {forwchar, "forward-char"}, - {gotoeop, "forward-paragraph"}, - {forwword, "forward-word"}, - {bindtokey, "global-set-key"}, - {unbindtokey, "global-unset-key"}, - {gotoline, "goto-line"}, + {evalbuffer, "eval-current-buffer"}, + {evalexpr, "eval-expression"}, +#endif + {swapmark, "exchange-point-and-mark"}, + {extend, "execute-extended-command"}, + {prefix, "extra prefix 1"}, + {prefix, "extra prefix 2"}, + {prefix, "extra prefix 3"}, + {prefix, "extra prefix 4"}, + {prefix, "extra prefix 5"}, + {fillpara, "fill-paragraph"}, + {filevisit, "find-file"}, + {poptofile, "find-file-other-window"}, + {forwchar, "forward-char"}, + {gotoeop, "forward-paragraph"}, + {forwword, "forward-word"}, + {bindtokey, "global-set-key"}, + {unbindtokey, "global-unset-key"}, + {gotoline, "goto-line"}, #ifndef NO_HELP - {prefix, "help"}, - {help_help, "help-help"}, -#endif - {insert, "insert"}, - {bufferinsert, "insert-buffer"}, - {fileinsert, "insert-file"}, - {fillword, "insert-with-wrap"}, - {backisearch, "isearch-backward"}, - {forwisearch, "isearch-forward"}, - {justone, "just-one-space"}, - {ctrlg, "keyboard-quit"}, - {killbuffer, "kill-buffer"}, - {killline, "kill-line"}, - {killpara, "kill-paragraph"}, - {killregion, "kill-region"}, - {delfword, "kill-word"}, - {listbuffers, "list-buffers"}, + {prefix, "help"}, + {help_help, "help-help"}, +#endif + {insert, "insert"}, + {bufferinsert, "insert-buffer"}, + {fileinsert, "insert-file"}, + {fillword, "insert-with-wrap"}, + {backisearch, "isearch-backward"}, + {forwisearch, "isearch-forward"}, + {justone, "just-one-space"}, + {ctrlg, "keyboard-quit"}, + {killbuffer, "kill-buffer"}, + {killline, "kill-line"}, + {killpara, "kill-paragraph"}, + {killregion, "kill-region"}, + {delfword, "kill-word"}, + {listbuffers, "list-buffers"}, #ifndef NO_STARTUP - {evalfile, "load"}, + {evalfile, "load"}, #endif - {localbind, "local-set-key"}, - {localunbind, "local-unset-key"}, + {localbind, "local-set-key"}, + {localunbind, "local-unset-key"}, #ifndef NO_BACKUP - {makebkfile, "make-backup-files"}, + {makebkfile, "make-backup-files"}, #endif #ifdef DO_METAKEY - {do_meta, "meta-key-mode"}, /* better name, anyone? */ + {do_meta, "meta-key-mode"}, /* better name, anyone? */ #endif #ifdef AMIGA #ifdef MOUSE - {mgotobob, "mouse-beginning-of-buffer"}, - {mforwdel, "mouse-delete-char"}, - {mdelwhite, "mouse-delete-horizontal-space"}, - {mdelwind, "mouse-delete-window"}, - {mgotoeob, "mouse-end-of-buffer"}, - {menlargewind, "mouse-enlarge-window"}, - {mkillline, "mouse-kill-line"}, - {mkillregion, "mouse-kill-region"}, - {mdelfword, "mouse-kill-word"}, - {mreposition, "mouse-recenter"}, - {mbackpage, "mouse-scroll-down"}, - {mforwpage, "mouse-scroll-up"}, - {amigamouse, "mouse-set-point"}, - {mshrinkwind, "mouse-shrink-window"}, - {msplitwind, "mouse-split-window-vertically"}, - {myank, "mouse-yank"}, + {mgotobob, "mouse-beginning-of-buffer"}, + {mforwdel, "mouse-delete-char"}, + {mdelwhite, "mouse-delete-horizontal-space"}, + {mdelwind, "mouse-delete-window"}, + {mgotoeob, "mouse-end-of-buffer"}, + {menlargewind, "mouse-enlarge-window"}, + {mkillline, "mouse-kill-line"}, + {mkillregion, "mouse-kill-region"}, + {mdelfword, "mouse-kill-word"}, + {mreposition, "mouse-recenter"}, + {mbackpage, "mouse-scroll-down"}, + {mforwpage, "mouse-scroll-up"}, + {amigamouse, "mouse-set-point"}, + {mshrinkwind, "mouse-shrink-window"}, + {msplitwind, "mouse-split-window-vertically"}, + {myank, "mouse-yank"}, #endif #endif {negative_argument, "negative-argument"}, - {newline, "newline"}, - {indent, "newline-and-indent"}, - {forwline, "next-line"}, + {newline, "newline"}, + {indent, "newline-and-indent"}, + {forwline, "next-line"}, #ifdef NOTAB - {notabmode, "no-tab-mode"}, + {notabmode, "no-tab-mode"}, #endif - {notmodified, "not-modified"}, - {openline, "open-line"}, - {nextwind, "other-window"}, - {overwrite, "overwrite-mode"}, + {notmodified, "not-modified"}, + {openline, "open-line"}, + {nextwind, "other-window"}, + {overwrite, "overwrite-mode"}, #ifdef PREFIXREGION - {prefixregion, "prefix-region"}, + {prefixregion, "prefix-region"}, #endif - {backline, "previous-line"}, + {backline, "previous-line"}, #ifdef GOSMACS - {prevwind, "previous-window"}, + {prevwind, "previous-window"}, #endif #ifdef VMS - {spawncli, "push-to-dcl"}, + {spawncli, "push-to-dcl"}, #else - {spawncli, "push-shell"}, + {spawncli, "push-shell"}, #endif #ifndef NO_DIR - {showcwdir, "pwd"}, + {showcwdir, "pwd"}, #endif - {queryrepl, "query-replace"}, + {queryrepl, "query-replace"}, #ifdef REGEX - {re_queryrepl, "query-replace-regexp"}, + {re_queryrepl, "query-replace-regexp"}, #endif - {quote, "quoted-insert"}, + {quote, "quoted-insert"}, #ifdef REGEX - {re_searchagain,"re-search-again"}, + {re_searchagain, "re-search-again"}, {re_backsearch, "re-search-backward"}, {re_forwsearch, "re-search-forward"}, #endif - {reposition, "recenter"}, - {refresh, "redraw-display"}, - {filesave, "save-buffer"}, - {quit, "save-buffers-kill-emacs"}, - {savebuffers, "save-some-buffers"}, - {backpage, "scroll-down"}, + {reposition, "recenter"}, + {refresh, "redraw-display"}, + {filesave, "save-buffer"}, + {quit, "save-buffers-kill-emacs"}, + {savebuffers, "save-some-buffers"}, + {backpage, "scroll-down"}, #ifdef GOSMACS - {back1page, "scroll-one-line-down"}, - {forw1page, "scroll-one-line-up"}, -#endif - {pagenext, "scroll-other-window"}, - {forwpage, "scroll-up"}, - {searchagain, "search-again"}, - {backsearch, "search-backward"}, - {forwsearch, "search-forward"}, - {selfinsert, "self-insert-command"}, + {back1page, "scroll-one-line-down"}, + {forw1page, "scroll-one-line-up"}, +#endif + {pagenext, "scroll-other-window"}, + {forwpage, "scroll-up"}, + {searchagain, "search-again"}, + {backsearch, "search-backward"}, + {forwsearch, "search-forward"}, + {selfinsert, "self-insert-command"}, #ifdef REGEX - {setcasefold, "set-case-fold-search"}, + {setcasefold, "set-case-fold-search"}, #endif {set_default_mode, "set-default-mode"}, - {setfillcol, "set-fill-column"}, - {setmark, "set-mark-command"}, + {setfillcol, "set-fill-column"}, + {setmark, "set-mark-command"}, #ifdef PREFIXREGION - {setprefix, "set-prefix-string"}, + {setprefix, "set-prefix-string"}, #endif - {shrinkwind, "shrink-window"}, + {shrinkwind, "shrink-window"}, #ifdef NOTAB {space_to_tabstop, "space-to-tabstop"}, #endif - {splitwind, "split-window-vertically"}, + {splitwind, "split-window-vertically"}, #ifndef NO_MACRO - {definemacro, "start-kbd-macro"}, + {definemacro, "start-kbd-macro"}, #endif #ifdef VMS - {attachtoparent,"suspend-emacs"}, + {attachtoparent, "suspend-emacs"}, #else - {spawncli, "suspend-emacs"}, + {spawncli, "suspend-emacs"}, #endif - {usebuffer, "switch-to-buffer"}, - {poptobuffer, "switch-to-buffer-other-window"}, - {twiddle, "transpose-chars"}, + {usebuffer, "switch-to-buffer"}, + {poptobuffer, "switch-to-buffer-other-window"}, + {twiddle, "transpose-chars"}, {universal_argument, "universal-argument"}, - {upperregion, "upcase-region"}, - {upperword, "upcase-word"}, - {showcpos, "what-cursor-position"}, - {filewrite, "write-file"}, - {yank, "yank"}, + {upperregion, "upcase-region"}, + {upperword, "upcase-word"}, + {showcpos, "what-cursor-position"}, + {filewrite, "write-file"}, + {yank, "yank"}, }; #define NFUNCT (sizeof(functnames)/sizeof(FUNCTNAMES)) -int nfunct = NFUNCT; /* used by help.c */ +int nfunct = NFUNCT;/* used by help.c */ /* * The general-purpose version of ROUND2 blows osk C (2.0) out of the water. @@ -1111,24 +1078,26 @@ int nfunct = NFUNCT; /* used by help.c */ */ #define ROUND2(x) (x<128?(x<64?32:64):(x<256?128:256)) -static name_fent(fname, flag) -register char *fname; -int flag; +static +name_fent(fname, flag) + register char *fname; + int flag; { - register int try; - register int x = ROUND2(NFUNCT); - register int base = 0; - register int notit; + register int try; + register int x = ROUND2(NFUNCT); + register int base = 0; + register int notit; do { - /* + can be used instead of | here if more efficent. */ - if((try = base | x) < NFUNCT) { - if((notit = strcmp(fname, functnames[try].n_name)) >= 0) { - if(!notit) return try; - base = try; + /* + can be used instead of | here if more efficent. */ + if ((try = base | x) < NFUNCT) { + if ((notit = strcmp(fname, functnames[try].n_name)) >= 0) { + if (!notit) + return try; + base = try; + } } - } - } while((x>>=1) || (try==1 && base==0)); /* try 0 once if needed */ + } while ((x >>= 1) || (try == 1 && base == 0)); /* try 0 once if needed */ return flag ? base : -1; } @@ -1136,47 +1105,61 @@ int flag; * Translate from function name to function pointer, using binary search. */ -PF name_function(fname) -char *fname; +PF +name_function(fname) + char *fname; { - int i; - if((i = name_fent(fname, FALSE)) >= 0) return functnames[i].n_funct; - return (PF)NULL; + int i; + if ((i = name_fent(fname, FALSE)) >= 0) + return functnames[i].n_funct; + return (PF) NULL; } /* complete function name */ +int complete_function(fname, c) -register char *fname; + register char *fname; + int c; { - register int i, j, k, l; - int oj; + register int i, j, k, l; + int oj; i = name_fent(fname, TRUE); - for(j=0; (l=fname[j]) && functnames[i].n_name[j]==l; j++) {} - if(fname[j]!='\0') { - if(++i >= NFUNCT) return -2; /* no match */ - for(j=0; (l=fname[j]) && functnames[i].n_name[j]==l; j++) {} - if(fname[j]!='\0') return -2; /* no match */ + for (j = 0; (l = fname[j]) && functnames[i].n_name[j] == l; j++) { } - if(c==CCHR('M') && functnames[i].n_name[j]=='\0') return -1; - for(k=i+1; k= NFUNCT) + return -2; /* no match */ + for (j = 0; (l = fname[j]) && functnames[i].n_name[j] == l; j++) { + } + if (fname[j] != '\0') + return -2; /* no match */ + } + if (c == CCHR('M') && functnames[i].n_name[j] == '\0') + return -1; + for (k = i + 1; k < NFUNCT; k++) { /* find last match */ + for (l = 0; functnames[k].n_name[l] == fname[l]; l++) { + } + if (l < j) + break; } k--; oj = j; - if(k>i) { /* multiple matches */ - while((l = functnames[i].n_name[j]) == functnames[k].n_name[j]) { - fname[j++] = l; - if(l=='-' && c==' ') break; - } - if(j==oj) return -3; /* ambiguous */ - } else { /* single match */ - while(l = functnames[i].n_name[j]) { - fname[j++] = l; - if(l=='-' && c==' ') break; - } + if (k > i) { /* multiple matches */ + while ((l = functnames[i].n_name[j]) == functnames[k].n_name[j]) { + fname[j++] = l; + if (l == '-' && c == ' ') + break; + } + if (j == oj) + return -3; /* ambiguous */ + } else { /* single match */ + while (l = functnames[i].n_name[j]) { + fname[j++] = l; + if (l == '-' && c == ' ') + break; + } } fname[j] = '\0'; return j - oj; @@ -1184,48 +1167,58 @@ register char *fname; /* list possible function name completions */ -LIST *complete_function_list(fname, c) -register char *fname; +LIST * +complete_function_list(fname, c) + register char *fname; { - register int i, j, k, l; - int oj; - LIST *current,*last; + register int i, j, k, l; + int oj; + LIST *current, *last; i = name_fent(fname, TRUE); - for(j=0; (l=fname[j]) && functnames[i].n_name[j]==l; j++) {} - if(fname[j]!='\0') { - if(++i >= NFUNCT) return NULL; /* no match */ - for(j=0; (l=fname[j]) && functnames[i].n_name[j]==l; j++) {} - if(fname[j]!='\0') return NULL; /* no match */ + for (j = 0; (l = fname[j]) && functnames[i].n_name[j] == l; j++) { } -/* - * if(c==CCHR('M') && functnames[i].n_name[j]=='\0') return -1; - */ - for(k=i+1; k= NFUNCT) + return NULL; /* no match */ + for (j = 0; (l = fname[j]) && functnames[i].n_name[j] == l; j++) { + } + if (fname[j] != '\0') + return NULL; /* no match */ + } + /* + * if(c==CCHR('M') && functnames[i].n_name[j]=='\0') return -1; + */ + for (k = i + 1; k < NFUNCT; k++) { /* find last match */ + for (l = 0; functnames[k].n_name[l] == fname[l]; l++) { + } + if (l < j) + break; } k--; last = NULL; for (; k >= i; k--) { - current = (LIST *)malloc(sizeof(LIST)); - current->l_next = last; - current->l_name = functnames[k].n_name; - last = current; + current = (LIST *) malloc(sizeof(LIST)); + current->l_next = last; + current->l_name = functnames[k].n_name; + last = current; } - return(last); + return (last); } /* translate from function pointer to function name. */ -char *function_name(fpoint) -register PF fpoint; +char * +function_name(fpoint) + register PF fpoint; { - register FUNCTNAMES *fnp = &functnames[0]; + register FUNCTNAMES *fnp = &functnames[0]; - if(fpoint == prefix) return (char *)NULL; /* ambiguous */ + if (fpoint == prefix) + return (char *) NULL; /* ambiguous */ do { - if(fnp->n_funct == fpoint) return fnp->n_name; - } while(++fnp < &functnames[NFUNCT]); - return (char *)NULL; + if (fnp->n_funct == fpoint) + return fnp->n_name; + } while (++fnp < &functnames[NFUNCT]); + return (char *) NULL; } diff --git a/usr.bin/mg/line.c b/usr.bin/mg/line.c index c0cad9fbda1..0c653291fee 100644 --- a/usr.bin/mg/line.c +++ b/usr.bin/mg/line.c @@ -19,25 +19,25 @@ */ #include "def.h" -/* number of bytes member is from start of structure type */ -/* should be computed at compile time */ +/* number of bytes member is from start of structure type */ +/* should be computed at compile time */ #ifndef OFFSET #define OFFSET(type,member) ((char *)&(((type *)0)->member)-(char *)((type *)0)) #endif #ifndef NBLOCK -#define NBLOCK 16 /* Line block chunk size */ +#define NBLOCK 16 /* Line block chunk size */ #endif #ifndef KBLOCK -#define KBLOCK 256 /* Kill buffer block size. */ +#define KBLOCK 256 /* Kill buffer block size. */ #endif -static char *kbufp = NULL; /* Kill buffer data. */ -static RSIZE kused = 0; /* # of bytes used in KB. */ -static RSIZE ksize = 0; /* # of bytes allocated in KB. */ -static RSIZE kstart = 0; /* # of first used byte in KB. */ +static char *kbufp = NULL; /* Kill buffer data. */ +static RSIZE kused = 0; /* # of bytes used in KB. */ +static RSIZE ksize = 0; /* # of bytes allocated in KB. */ +static RSIZE kstart = 0; /* # of first used byte in KB. */ /* * This routine allocates a block of memory large enough to hold a LINE @@ -47,19 +47,21 @@ static RSIZE kstart = 0; /* # of first used byte in KB. */ * any memory left. Print a message in the message line if no space. */ LINE * -lalloc(used) register int used; { - register LINE *lp; - register int size; +lalloc(used) + int used; +{ + LINE *lp; + int size; /* any padding at the end of the structure is used */ - if((size = used + OFFSET(LINE, l_text[0])) < sizeof(LINE)) + if ((size = used + OFFSET(LINE, l_text[0])) < sizeof(LINE)) size = sizeof(LINE); #ifdef MALLOCROUND - MALLOCROUND(size); /* round up to a size optimal to malloc */ + MALLOCROUND(size); /* round up to a size optimal to malloc */ #endif - if((lp = (LINE *)malloc((unsigned)size)) == NULL) { + if ((lp = (LINE *) malloc((unsigned) size)) == NULL) { ewprintf("Can't get %d bytes", size); - return (LINE *)NULL; + return (LINE *) NULL; } lp->l_size = size - OFFSET(LINE, l_text[0]); lp->l_used = used; @@ -73,13 +75,14 @@ lalloc(used) register int used; { */ LINE * lallocx(used) -int used; + int used; { - register int size; - register LINE *lp; + int size; + LINE *lp; - size = (NBLOCK+used) & ~(NBLOCK-1); - if((lp = lalloc(size)) != NULL) lp->l_used = used; + size = (NBLOCK + used) & ~(NBLOCK - 1); + if ((lp = lalloc(size)) != NULL) + lp->l_used = used; return lp; } @@ -94,25 +97,27 @@ int used; * here. */ VOID -lfree(lp) register LINE *lp; { +lfree(lp) + register LINE *lp; +{ register BUFFER *bp; register MGWIN *wp; - for(wp = wheadp; wp != NULL; wp = wp->w_wndp) { + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp) wp->w_linep = lp->l_fp; - if (wp->w_dotp == lp) { - wp->w_dotp = lp->l_fp; - wp->w_doto = 0; + if (wp->w_dotp == lp) { + wp->w_dotp = lp->l_fp; + wp->w_doto = 0; } if (wp->w_markp == lp) { wp->w_markp = lp->l_fp; wp->w_marko = 0; } } - for(bp = bheadp; bp != NULL; bp = bp->b_bufp) { + for (bp = bheadp; bp != NULL; bp = bp->b_bufp) { if (bp->b_nwnd == 0) { - if (bp->b_dotp == lp) { + if (bp->b_dotp == lp) { bp->b_dotp = lp->l_fp; bp->b_doto = 0; } @@ -138,17 +143,20 @@ lfree(lp) register LINE *lp; { * updated (the "*" has to be set). */ VOID -lchange(flag) register int flag; { +lchange(flag) + register int flag; +{ register MGWIN *wp; - if ((curbp->b_flag&BFCHG) == 0) { /* First change, so */ - flag |= WFMODE; /* update mode lines. */ + if ((curbp->b_flag & BFCHG) == 0) { /* First change, so */ + flag |= WFMODE; /* update mode lines. */ curbp->b_flag |= BFCHG; } - for(wp = wheadp; wp != NULL; wp = wp->w_wndp) { + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_bufp == curbp) { wp->w_flag |= flag; - if(wp != curwp) wp->w_flag |= WFHARD; + if (wp != curwp) + wp->w_flag |= WFHARD; } } } @@ -166,35 +174,35 @@ lchange(flag) register int flag; { * if all is well, and FALSE on errors. */ linsert(n, c) -int n; + int n; { - register char *cp1; - register char *cp2; - register LINE *lp1; - LINE *lp2; - LINE *lp3; - register int doto; - register RSIZE i; - MGWIN *wp; + register char *cp1; + register char *cp2; + register LINE *lp1; + LINE *lp2; + LINE *lp3; + register int doto; + register RSIZE i; + MGWIN *wp; lchange(WFEDIT); - lp1 = curwp->w_dotp; /* Current line */ - if (lp1 == curbp->b_linep) { /* At the end: special */ - /* (now should only happen in empty buffer */ + lp1 = curwp->w_dotp; /* Current line */ + if (lp1 == curbp->b_linep) { /* At the end: special */ + /* (now should only happen in empty buffer */ if (curwp->w_doto != 0) { ewprintf("bug: linsert"); return FALSE; } - if ((lp2=lallocx(n)) == NULL) /* Allocate new line */ + if ((lp2 = lallocx(n)) == NULL) /* Allocate new line */ return FALSE; - lp3 = lp1->l_bp; /* Previous line */ - lp3->l_fp = lp2; /* Link in */ + lp3 = lp1->l_bp;/* Previous line */ + lp3->l_fp = lp2;/* Link in */ lp2->l_fp = lp1; lp1->l_bp = lp2; lp2->l_bp = lp3; - for (i=0; il_text[i] = c; - for(wp = wheadp; wp != NULL; wp = wp->w_wndp) { + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp1) wp->w_linep = lp2; if (wp->w_dotp == lp1) @@ -202,20 +210,20 @@ int n; if (wp->w_markp == lp1) wp->w_markp = lp2; } - /*NOSTRICT*/ + /* NOSTRICT */ curwp->w_doto = n; return TRUE; } - doto = curwp->w_doto; /* Save for later. */ - /*NOSTRICT (2) */ - if (lp1->l_used+n > lp1->l_size) { /* Hard: reallocate */ - if ((lp2=lallocx(lp1->l_used+n)) == NULL) + doto = curwp->w_doto; /* Save for later. */ + /* NOSTRICT (2) */ + if (lp1->l_used + n > lp1->l_size) { /* Hard: reallocate */ + if ((lp2 = lallocx(lp1->l_used + n)) == NULL) return FALSE; cp1 = &lp1->l_text[0]; cp2 = &lp2->l_text[0]; while (cp1 != &lp1->l_text[doto]) *cp2++ = *cp1++; - /*NOSTRICT*/ + /* NOSTRICT */ cp2 += n; while (cp1 != &lp1->l_text[lp1->l_used]) *cp2++ = *cp1++; @@ -224,32 +232,32 @@ int n; lp1->l_fp->l_bp = lp2; lp2->l_bp = lp1->l_bp; free((char *) lp1); - } else { /* Easy: in place */ - lp2 = lp1; /* Pretend new line */ - /*NOSTRICT*/ + } else { /* Easy: in place */ + lp2 = lp1; /* Pretend new line */ + /* NOSTRICT */ lp2->l_used += n; cp2 = &lp1->l_text[lp1->l_used]; - cp1 = cp2-n; + cp1 = cp2 - n; while (cp1 != &lp1->l_text[doto]) *--cp2 = *--cp1; } - for (i=0; il_text[doto+i] = c; + for (i = 0; i < n; ++i) /* Add the characters */ + lp2->l_text[doto + i] = c; - for(wp = wheadp; wp != NULL; wp = wp->w_wndp) { + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp1) wp->w_linep = lp2; if (wp->w_dotp == lp1) { wp->w_dotp = lp2; - if (wp==curwp || wp->w_doto>doto) - /*NOSTRICT*/ + if (wp == curwp || wp->w_doto > doto) + /* NOSTRICT */ wp->w_doto += n; } if (wp->w_markp == lp1) { wp->w_markp = lp2; if (wp->w_marko > doto) - /*NOSTRICT*/ + /* NOSTRICT */ wp->w_marko += n; } } @@ -263,36 +271,38 @@ int n; */ lnewline() { - register LINE *lp1; - register LINE *lp2; - register int doto; - register int nlen; - MGWIN *wp; + register LINE *lp1; + register LINE *lp2; + register int doto; + register int nlen; + MGWIN *wp; lchange(WFHARD); - lp1 = curwp->w_dotp; /* Get the address and */ - doto = curwp->w_doto; /* offset of "." */ - if(doto == 0) { /* avoid unnessisary copying */ - if((lp2 = lallocx(0)) == NULL) /* new first part */ + lp1 = curwp->w_dotp; /* Get the address and */ + doto = curwp->w_doto; /* offset of "." */ + if (doto == 0) { /* avoid unnessisary copying */ + if ((lp2 = lallocx(0)) == NULL) /* new first part */ return FALSE; lp2->l_bp = lp1->l_bp; lp1->l_bp->l_fp = lp2; lp2->l_fp = lp1; lp1->l_bp = lp2; - for(wp = wheadp; wp!=NULL; wp = wp->w_wndp) - if(wp->w_linep == lp1) wp->w_linep = lp2; - return TRUE; + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) + if (wp->w_linep == lp1) + wp->w_linep = lp2; + return TRUE; } - nlen = llength(lp1) - doto; /* length of new part */ - if((lp2=lallocx(nlen)) == NULL) /* New second half line */ + nlen = llength(lp1) - doto; /* length of new part */ + if ((lp2 = lallocx(nlen)) == NULL) /* New second half line */ return FALSE; - if(nlen!=0) bcopy(&lp1->l_text[doto], &lp2->l_text[0], nlen); + if (nlen != 0) + bcopy(&lp1->l_text[doto], &lp2->l_text[0], nlen); lp1->l_used = doto; lp2->l_bp = lp1; lp2->l_fp = lp1->l_fp; lp1->l_fp = lp2; lp2->l_fp->l_bp = lp2; - for(wp = wheadp; wp != NULL; wp = wp->w_wndp) { /* Windows */ + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { /* Windows */ if (wp->w_dotp == lp1 && wp->w_doto >= doto) { wp->w_dotp = lp2; wp->w_doto -= doto; @@ -314,64 +324,70 @@ lnewline() * the buffer. The "kflag" indicates either no insertion, * or direction of insertion into the kill buffer. */ -ldelete(n, kflag) RSIZE n; { - register char *cp1; - register char *cp2; - register LINE *dotp; - register int doto; - register RSIZE chunk; - MGWIN *wp; +ldelete(n, kflag) + RSIZE n; +{ + register char *cp1; + register char *cp2; + register LINE *dotp; + register int doto; + register RSIZE chunk; + MGWIN *wp; /* * HACK - doesn't matter, and fixes back-over-nl bug for empty * kill buffers. */ - if (kused == kstart) kflag = KFORW; + if (kused == kstart) + kflag = KFORW; while (n != 0) { dotp = curwp->w_dotp; doto = curwp->w_doto; - if (dotp == curbp->b_linep) /* Hit end of buffer. */ + if (dotp == curbp->b_linep) /* Hit end of buffer. */ return FALSE; - chunk = dotp->l_used-doto; /* Size of chunk. */ + chunk = dotp->l_used - doto; /* Size of chunk. */ if (chunk > n) chunk = n; - if (chunk == 0) { /* End of line, merge. */ - if(dotp == lback(curbp->b_linep)) - return FALSE; /* End of buffer. */ + if (chunk == 0) { /* End of line, merge. */ + if (dotp == lback(curbp->b_linep)) + return FALSE; /* End of buffer. */ lchange(WFHARD); if (ldelnewline() == FALSE - || (kflag!=KNONE && kinsert('\n', kflag)==FALSE)) + || (kflag != KNONE && kinsert('\n', kflag) == FALSE)) return FALSE; --n; continue; } lchange(WFEDIT); - cp1 = &dotp->l_text[doto]; /* Scrunch text. */ + cp1 = &dotp->l_text[doto]; /* Scrunch text. */ cp2 = cp1 + chunk; if (kflag == KFORW) { while (ksize - kused < chunk) - if (kgrow(FALSE) == FALSE) return FALSE; + if (kgrow(FALSE) == FALSE) + return FALSE; bcopy(cp1, &(kbufp[kused]), (int) chunk); kused += chunk; } else if (kflag == KBACK) { while (kstart < chunk) - if (kgrow(TRUE) == FALSE) return FALSE; - bcopy(cp1, &(kbufp[kstart-chunk]), (int) chunk); + if (kgrow(TRUE) == FALSE) + return FALSE; + bcopy(cp1, &(kbufp[kstart - chunk]), (int) chunk); kstart -= chunk; - } else if (kflag != KNONE) panic("broken ldelete call"); + } else if (kflag != KNONE) + panic("broken ldelete call"); while (cp2 != &dotp->l_text[dotp->l_used]) *cp1++ = *cp2++; dotp->l_used -= (int) chunk; - for(wp = wheadp; wp != NULL; wp = wp->w_wndp ) { - if (wp->w_dotp==dotp && wp->w_doto>=doto) { - /*NOSTRICT*/ + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { + if (wp->w_dotp == dotp && wp->w_doto >= doto) { + /* NOSTRICT */ wp->w_doto -= chunk; if (wp->w_doto < doto) wp->w_doto = doto; } - if (wp->w_markp==dotp && wp->w_marko>=doto) { - /*NOSTRICT*/ + if (wp->w_markp == dotp && wp->w_marko >= doto) { + /* NOSTRICT */ wp->w_marko -= chunk; if (wp->w_marko < doto) wp->w_marko = doto; @@ -393,27 +409,28 @@ ldelete(n, kflag) RSIZE n; { * about in memory. Return FALSE on error and TRUE if all * looks ok. */ -ldelnewline() { - register LINE *lp1; - register LINE *lp2; +ldelnewline() +{ + register LINE *lp1; + register LINE *lp2; register MGWIN *wp; - LINE *lp3; + LINE *lp3; lp1 = curwp->w_dotp; lp2 = lp1->l_fp; - if (lp2 == curbp->b_linep) /* At the buffer end. */ + if (lp2 == curbp->b_linep) /* At the buffer end. */ return TRUE; if (lp2->l_used <= lp1->l_size - lp1->l_used) { bcopy(&lp2->l_text[0], &lp1->l_text[lp1->l_used], lp2->l_used); - for(wp = wheadp; wp != NULL; wp = wp->w_wndp) { + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { if (wp->w_linep == lp2) wp->w_linep = lp1; if (wp->w_dotp == lp2) { - wp->w_dotp = lp1; + wp->w_dotp = lp1; wp->w_doto += lp1->l_used; } if (wp->w_markp == lp2) { - wp->w_markp = lp1; + wp->w_markp = lp1; wp->w_marko += lp1->l_used; } } @@ -423,7 +440,7 @@ ldelnewline() { free((char *) lp2); return TRUE; } - if ((lp3=lalloc(lp1->l_used + lp2->l_used)) == NULL) + if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL) return FALSE; bcopy(&lp1->l_text[0], &lp3->l_text[0], lp1->l_used); bcopy(&lp2->l_text[0], &lp3->l_text[lp1->l_used], lp2->l_used); @@ -431,19 +448,19 @@ ldelnewline() { lp3->l_fp = lp2->l_fp; lp2->l_fp->l_bp = lp3; lp3->l_bp = lp1->l_bp; - for(wp = wheadp; wp != NULL; wp = wp->w_wndp) { - if (wp->w_linep==lp1 || wp->w_linep==lp2) + for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { + if (wp->w_linep == lp1 || wp->w_linep == lp2) wp->w_linep = lp3; if (wp->w_dotp == lp1) - wp->w_dotp = lp3; + wp->w_dotp = lp3; else if (wp->w_dotp == lp2) { - wp->w_dotp = lp3; + wp->w_dotp = lp3; wp->w_doto += lp1->l_used; } if (wp->w_markp == lp1) - wp->w_markp = lp3; + wp->w_markp = lp3; else if (wp->w_markp == lp2) { - wp->w_markp = lp3; + wp->w_markp = lp3; wp->w_marko += lp1->l_used; } } @@ -459,34 +476,33 @@ ldelnewline() { * case of replacement to what was there). */ lreplace(plen, st, f) -register RSIZE plen; /* length to remove */ -char *st; /* replacement string */ -int f; /* case hack disable */ + register RSIZE plen; /* length to remove */ + char *st; /* replacement string */ + int f; /* case hack disable */ { - register RSIZE rlen; /* replacement length */ - register int rtype; /* capitalization */ - register int c; /* used for random characters */ - register int doto; /* offset into line */ + register RSIZE rlen; /* replacement length */ + register int rtype; /* capitalization */ + register int c; /* used for random characters */ + register int doto; /* offset into line */ /* * Find the capitalization of the word that was found. * f says use exact case of replacement string (same thing that * happens with lowercase found), so bypass check. */ - /*NOSTRICT*/ + /* NOSTRICT */ (VOID) backchar(FFARG | FFRAND, (int) plen); rtype = _L; c = lgetc(curwp->w_dotp, curwp->w_doto); - if (ISUPPER(c)!=FALSE && f==FALSE) { - rtype = _U|_L; - if (curwp->w_doto+1 < llength(curwp->w_dotp)) { - c = lgetc(curwp->w_dotp, curwp->w_doto+1); + if (ISUPPER(c) != FALSE && f == FALSE) { + rtype = _U | _L; + if (curwp->w_doto + 1 < llength(curwp->w_dotp)) { + c = lgetc(curwp->w_dotp, curwp->w_doto + 1); if (ISUPPER(c) != FALSE) { rtype = _U; } } } - /* * make the string lengths match (either pad the line * so that it will fit, or scrunch out the excess). @@ -495,9 +511,9 @@ int f; /* case hack disable */ rlen = strlen(st); doto = curwp->w_doto; if (plen > rlen) - (VOID) ldelete((RSIZE) (plen-rlen), KNONE); + (VOID) ldelete((RSIZE) (plen - rlen), KNONE); else if (plen < rlen) { - if (linsert((int)(rlen-plen), ' ') == FALSE) + if (linsert((int) (rlen - plen), ' ') == FALSE) return FALSE; } curwp->w_doto = doto; @@ -508,9 +524,9 @@ int f; /* case hack disable */ * If inserting upper, check replacement for case. */ while ((c = CHARMASK(*st++)) != '\0') { - if ((rtype&_U)!=0 && ISLOWER(c)!=0) + if ((rtype & _U) != 0 && ISLOWER(c) != 0) c = TOUPPER(c); - if (rtype == (_U|_L)) + if (rtype == (_U | _L)) rtype = _L; if (c == CCHR('J')) { if (curwp->w_doto == llength(curwp->w_dotp)) @@ -539,7 +555,9 @@ int f; /* case hack disable */ * grown to immense size. No errors. */ VOID -kdelete() { +kdelete() +{ + if (kbufp != NULL) { free((char *) kbufp); kbufp = NULL; @@ -556,15 +574,19 @@ kdelete() { * well, and FALSE on errors. Print a message on * errors. Dir says whether to put it at back or front. */ -kinsert(c, dir) { +kinsert(c, dir) +{ if (kused == ksize && dir == KFORW && kgrow(FALSE) == FALSE) return FALSE; if (kstart == 0 && dir == KBACK && kgrow(TRUE) == FALSE) return FALSE; - if (dir == KFORW) kbufp[kused++] = c; - else if (dir == KBACK) kbufp[--kstart] = c; - else panic("broken kinsert call"); /* Oh shit! */ + if (dir == KFORW) + kbufp[kused++] = c; + else if (dir == KBACK) + kbufp[--kstart] = c; + else + panic("broken kinsert call"); /* Oh shit! */ return (TRUE); } @@ -572,24 +594,25 @@ kinsert(c, dir) { * kgrow - just get more kill buffer for the callee. back is true if * we are trying to get space at the beginning of the kill buffer. */ -kgrow(back) { - register int nstart; - register char *nbufp; +kgrow(back) +{ + register int nstart; + register char *nbufp; - if ((unsigned)(ksize+KBLOCK) <= (unsigned)ksize) { + if ((unsigned) (ksize + KBLOCK) <= (unsigned) ksize) { /* probably 16 bit unsigned */ ewprintf("Kill buffer size at maximum"); return FALSE; } - if ((nbufp=malloc((unsigned)(ksize+KBLOCK))) == NULL) { - ewprintf("Can't get %ld bytes", (long)(ksize+KBLOCK)); + if ((nbufp = malloc((unsigned) (ksize + KBLOCK))) == NULL) { + ewprintf("Can't get %ld bytes", (long) (ksize + KBLOCK)); return FALSE; } - nstart = (back == TRUE) ? (kstart + KBLOCK) : (KBLOCK / 4) ; - bcopy(&(kbufp[kstart]), &(nbufp[nstart]), (int) (kused-kstart)); + nstart = (back == TRUE) ? (kstart + KBLOCK) : (KBLOCK / 4); + bcopy(&(kbufp[kstart]), &(nbufp[nstart]), (int) (kused - kstart)); if (kbufp != NULL) free((char *) kbufp); - kbufp = nbufp; + kbufp = nbufp; ksize += KBLOCK; kused = kused - kstart + nstart; kstart = nstart; @@ -602,7 +625,8 @@ kgrow(back) { * off the end, it returns "-1". This lets the caller * just scan along until it gets a "-1" back. */ -kremove(n) { +kremove(n) +{ if (n < 0 || n + kstart >= kused) return -1; return CHARMASK(kbufp[n + kstart]); diff --git a/usr.bin/mg/macro.c b/usr.bin/mg/macro.c index 94d14e28dc8..6b4396bf78a 100644 --- a/usr.bin/mg/macro.c +++ b/usr.bin/mg/macro.c @@ -1,4 +1,4 @@ -/* keyboard macros for MicroGnuEmacs 1x */ +/* keyboard macros for Mg 2 */ #ifndef NO_MACRO #include "def.h" @@ -7,77 +7,79 @@ #define INIT(i) = (i) #include "macro.h" -/*ARGSUSED*/ +/* ARGSUSED */ definemacro(f, n) -int f, n; + int f, n; { - register LINE *lp1; - LINE *lp2; + register LINE *lp1; + LINE *lp2; macrocount = 0; - if(macrodef) { - ewprintf("already defining macro"); - return macrodef = FALSE; + if (macrodef) { + ewprintf("already defining macro"); + return macrodef = FALSE; } /* free lines allocated for string arguments */ - if(maclhead != NULL) { - for(lp1 = maclhead->l_fp; lp1 != maclhead; lp1 = lp2) { - lp2 = lp1->l_fp; - free((char *)lp1); - } - free((char *)lp1); + if (maclhead != NULL) { + for (lp1 = maclhead->l_fp; lp1 != maclhead; lp1 = lp2) { + lp2 = lp1->l_fp; + free((char *) lp1); + } + free((char *) lp1); } - if((maclhead = lp1 = lalloc(0)) == NULL) return FALSE; + if ((maclhead = lp1 = lalloc(0)) == NULL) + return FALSE; ewprintf("Defining Keyboard Macro..."); maclcur = lp1->l_fp = lp1->l_bp = lp1; return macrodef = TRUE; } -/*ARGSUSED*/ +/* ARGSUSED */ finishmacro(f, n) -int f, n; + int f, n; { - macrodef = FALSE; - ewprintf("End Keyboard Macro Definition"); - return TRUE; + macrodef = FALSE; + ewprintf("End Keyboard Macro Definition"); + return TRUE; } -/*ARGSUSED*/ +/* ARGSUSED */ executemacro(f, n) -int f, n; + int f, n; { - int i, j; - PF funct; - int universal_argument(); - int flag, num; + int i, j; + PF funct; + int universal_argument(); + int flag, num; - if(macrodef || - (macrocount >= MAXMACRO && macro[MAXMACRO].m_funct != finishmacro)) - return FALSE; - if(macrocount == 0) return TRUE; - inmacro = TRUE; - for(i = n; i > 0; i--) { - maclcur = maclhead->l_fp; - flag = 0; - num = 1; - for(j = 0; j < macrocount-1; j++) { - funct = macro[j].m_funct; - if(funct == universal_argument) { - flag = FFARG; - num = macro[++j].m_count; - continue; - } - if((*funct)(flag, num) != TRUE) { - inmacro = FALSE; + if (macrodef || + (macrocount >= MAXMACRO && macro[MAXMACRO].m_funct != finishmacro)) return FALSE; - } - lastflag = thisflag; - thisflag = 0; - flag = 0; - num = 1; + if (macrocount == 0) + return TRUE; + inmacro = TRUE; + for (i = n; i > 0; i--) { + maclcur = maclhead->l_fp; + flag = 0; + num = 1; + for (j = 0; j < macrocount - 1; j++) { + funct = macro[j].m_funct; + if (funct == universal_argument) { + flag = FFARG; + num = macro[++j].m_count; + continue; + } + if ((*funct) (flag, num) != TRUE) { + inmacro = FALSE; + return FALSE; + } + lastflag = thisflag; + thisflag = 0; + flag = 0; + num = 1; + } } - } - inmacro = FALSE; - return TRUE; + inmacro = FALSE; + return TRUE; } #endif diff --git a/usr.bin/mg/macro.h b/usr.bin/mg/macro.h index 9ce7f892f67..287c949900b 100644 --- a/usr.bin/mg/macro.h +++ b/usr.bin/mg/macro.h @@ -7,17 +7,17 @@ #define MAXMACRO 256 /* maximum functs in a macro */ -EXTERN int inmacro INIT(FALSE); -EXTERN int macrodef INIT(FALSE); -EXTERN int macrocount INIT(0); +EXTERN int inmacro INIT(FALSE); +EXTERN int macrodef INIT(FALSE); +EXTERN int macrocount INIT(0); -EXTERN union { +EXTERN union { PF m_funct; - int m_count; /* for count-prefix */ -} macro[MAXMACRO]; + int m_count; /* for count-prefix */ +} macro[MAXMACRO]; -EXTERN LINE *maclhead INIT(NULL); -EXTERN LINE *maclcur; +EXTERN LINE *maclhead INIT(NULL); +EXTERN LINE *maclcur; #undef EXTERN #undef INIT diff --git a/usr.bin/mg/main.c b/usr.bin/mg/main.c index 73271ce9b6e..cb84ca4ddbf 100644 --- a/usr.bin/mg/main.c +++ b/usr.bin/mg/main.c @@ -6,48 +6,49 @@ #include "macro.h" #endif -int thisflag; /* Flags, this command */ -int lastflag; /* Flags, last command */ -int curgoal; /* Goal column */ -BUFFER *curbp; /* Current buffer */ -MGWIN *curwp; /* Current window */ -BUFFER *bheadp; /* BUFFER listhead */ -MGWIN *wheadp = (MGWIN *)NULL; /* MGWIN listhead */ -char pat[NPAT]; /* Pattern */ +int thisflag; /* Flags, this command */ +int lastflag; /* Flags, last command */ +int curgoal; /* Goal column */ +BUFFER *curbp; /* Current buffer */ +MGWIN *curwp; /* Current window */ +BUFFER *bheadp; /* BUFFER listhead */ +MGWIN *wheadp = (MGWIN *) NULL; /* MGWIN listhead */ +char pat[NPAT]; /* Pattern */ #ifndef NO_DPROMPT -extern char prompt[], *promptp; /* delayed prompting */ +extern char prompt[], *promptp; /* delayed prompting */ #endif -static VOID edinit(); +static VOID edinit(); int main(argc, argv) -int argc; -char **argv; + int argc; + char **argv; { #ifndef NO_STARTUP - char *startupfile(); + char *startupfile(); #endif - char *cp; - VOID vtinit(), makename(), eerase(); - BUFFER *findbuffer(); + char *cp; + VOID vtinit(), makename(), eerase(); + BUFFER *findbuffer(); #ifdef SYSINIT - SYSINIT; /* system dependent. */ + SYSINIT; /* system dependent. */ #endif - vtinit(); /* Virtual terminal. */ + vtinit(); /* Virtual terminal. */ #ifndef NO_DIR - dirinit(); /* Get current directory */ + dirinit(); /* Get current directory */ #endif - edinit(); /* Buffers, windows. */ - ttykeymapinit(); /* Symbols, bindings. */ - /* doing update() before reading files causes the error messages from - * the file I/O show up on the screen. (and also an extra display - * of the mode line if there are files specified on the command line.) + edinit(); /* Buffers, windows. */ + ttykeymapinit(); /* Symbols, bindings. */ + /* + * doing update() before reading files causes the error messages from + * the file I/O show up on the screen. (and also an extra display of + * the mode line if there are files specified on the command line.) */ update(); -#ifndef NO_STARTUP /* User startup file. */ - if ((cp = startupfile((char *)NULL)) != NULL) +#ifndef NO_STARTUP /* User startup file. */ + if ((cp = startupfile((char *) NULL)) != NULL) (VOID) load(cp); #endif while (--argc > 0) { @@ -56,55 +57,59 @@ char **argv; (VOID) showbuffer(curbp, curwp, 0); (VOID) readin(cp); } - thisflag = 0; /* Fake last flags. */ - for(;;) { + thisflag = 0; /* Fake last flags. */ + for (;;) { #ifndef NO_DPROMPT - *(promptp = prompt) = '\0'; - if(epresf == KPROMPT) eerase(); + *(promptp = prompt) = '\0'; + if (epresf == KPROMPT) + eerase(); #endif - update(); - lastflag = thisflag; - thisflag = 0; - switch(doin()) { - case TRUE: break; + update(); + lastflag = thisflag; + thisflag = 0; + switch (doin()) { + case TRUE: + break; case ABORT: - ewprintf("Quit"); /* and fall through */ + ewprintf("Quit"); /* and fall through */ case FALSE: default: - ttbeep(); + ttbeep(); #ifndef NO_MACRO - macrodef = FALSE; + macrodef = FALSE; #endif - } + } } } /* * Initialize default buffer and window. */ -static VOID -edinit() { +static VOID +edinit() +{ register BUFFER *bp; register MGWIN *wp; bheadp = NULL; - bp = bfind("*scratch*", TRUE); /* Text buffer. */ - wp = (MGWIN *)malloc(sizeof(MGWIN)); /* Initial window. */ - if (bp==NULL || wp==NULL) panic("edinit"); - curbp = bp; /* Current ones. */ + bp = bfind("*scratch*", TRUE); /* Text buffer. */ + wp = (MGWIN *) malloc(sizeof(MGWIN)); /* Initial window. */ + if (bp == NULL || wp == NULL) + panic("edinit"); + curbp = bp; /* Current ones. */ wheadp = wp; - curwp = wp; - wp->w_wndp = NULL; /* Initialize window. */ - wp->w_bufp = bp; - bp->b_nwnd = 1; /* Displayed. */ + curwp = wp; + wp->w_wndp = NULL; /* Initialize window. */ + wp->w_bufp = bp; + bp->b_nwnd = 1; /* Displayed. */ wp->w_linep = wp->w_dotp = bp->b_linep; - wp->w_doto = 0; + wp->w_doto = 0; wp->w_markp = NULL; wp->w_marko = 0; wp->w_toprow = 0; - wp->w_ntrows = nrow-2; /* 2 = mode, echo. */ + wp->w_ntrows = nrow - 2;/* 2 = mode, echo. */ wp->w_force = 0; - wp->w_flag = WFMODE|WFHARD; /* Full. */ + wp->w_flag = WFMODE | WFHARD; /* Full. */ } /* @@ -113,18 +118,19 @@ edinit() { * changed and not written out. Normally bound * to "C-X C-C". */ -/*ARGSUSED*/ +/* ARGSUSED */ quit(f, n) { - register int s; - VOID vttidy(); + register int s; + VOID vttidy(); - if ((s = anycb(FALSE)) == ABORT) return ABORT; + if ((s = anycb(FALSE)) == ABORT) + return ABORT; if (s == FALSE - || eyesno("Some modified buffers exist, really exit") == TRUE) { + || eyesno("Some modified buffers exist, really exit") == TRUE) { vttidy(); #ifdef SYSCLEANUP - SYSCLEANUP; + SYSCLEANUP; #endif exit(GOOD); } @@ -136,8 +142,10 @@ quit(f, n) * to abort whatever C-g is aborting these days. Currently does * nothing. */ -/*ARGSUSED*/ +/* ARGSUSED */ +int ctrlg(f, n) + int f, n; { return ABORT; } diff --git a/usr.bin/mg/match.c b/usr.bin/mg/match.c index e49268b9b54..e5eacf2465f 100644 --- a/usr.bin/mg/match.c +++ b/usr.bin/mg/match.c @@ -14,24 +14,34 @@ #include "def.h" #include "key.h" -static int balance(); -static VOID displaymatch(); +static int balance(); +static VOID displaymatch(); -/* Balance table. When balance() encounters a character - * that is to be matched, it first searches this table - * for a balancing left-side character. If the character - * is not in the table, the character is balanced by itself. +/* + * Balance table. When balance() encounters a character that is to be + * matched, it first searches this table for a balancing left-side character. + * f the character is not in the table, the character is balanced by itself. * This is to allow delimiters in Scribe documents to be matched. */ static struct balance { - char left, right; -} bal[] = { - { '(', ')' }, - { '[', ']' }, - { '{', '}' }, - { '<', '>' }, - { '\0','\0'} + char left, right; +} bal[] = { + { + '(', ')' + }, + { + '[', ']' + }, + { + '{', '}' + }, + { + '<', '>' + }, + { + '\0', '\0' + } }; /* @@ -41,13 +51,14 @@ static struct balance { showmatch(f, n) { - register int i, s; + register int i, s; - if (f & FFRAND) return FALSE; + if (f & FFRAND) + return FALSE; for (i = 0; i < n; i++) { if ((s = selfinsert(FFRAND, 1)) != TRUE) return s; - if (balance() != TRUE) /* unbalanced -- warn user */ + if (balance() != TRUE) /* unbalanced -- warn user */ ttbeep(); } return TRUE; @@ -61,16 +72,17 @@ showmatch(f, n) * is found, it uses displaymatch() to display the match. */ -static balance() +static +balance() { - register LINE *clp; - register int cbo; - int c; - int i; - int rbal, lbal; - int depth; + register LINE *clp; + register int cbo; + int c; + int i; + int rbal, lbal; + int depth; - rbal = key.k_chars[key.k_count-1]; + rbal = key.k_chars[key.k_count - 1]; /* See if there is a matching character -- default to the same */ @@ -80,7 +92,6 @@ static balance() lbal = bal[i].left; break; } - /* Move behind the inserted character. We are always guaranteed */ /* that there is at least one character on the line, since one was */ /* just self-inserted by blinkparen. */ @@ -88,19 +99,19 @@ static balance() clp = curwp->w_dotp; cbo = curwp->w_doto - 1; - depth = 0; /* init nesting depth */ + depth = 0; /* init nesting depth */ for (;;) { - if (cbo == 0) { /* beginning of line */ + if (cbo == 0) { /* beginning of line */ clp = lback(clp); if (clp == curbp->b_linep) return (FALSE); - cbo = llength(clp)+1; + cbo = llength(clp) + 1; } - if (--cbo == llength(clp)) /* end of line */ + if (--cbo == llength(clp)) /* end of line */ c = '\n'; else - c = lgetc(clp,cbo); /* somewhere in middle */ + c = lgetc(clp, cbo); /* somewhere in middle */ /* Check for a matching character. If still in a nested */ /* level, pop out of it and continue search. This check */ @@ -108,17 +119,16 @@ static balance() /* matches will work too. */ if (c == lbal) { if (depth == 0) { - displaymatch(clp,cbo); + displaymatch(clp, cbo); return (TRUE); - } - else + } else depth--; } - /* Check for another level of nesting. */ + /* Check for another level of nesting. */ if (c == rbal) depth++; } - /*NOTREACHED*/ + /* NOTREACHED */ } @@ -130,20 +140,21 @@ static balance() * sit there a while, then move back. */ -static VOID displaymatch(clp, cbo) -register LINE *clp; -register int cbo; +static VOID +displaymatch(clp, cbo) + register LINE *clp; + register int cbo; { - register LINE *tlp; - register int tbo; - register int cp; - register int bufo; - register int c; - int inwindow; - char buf[NLINE]; + register LINE *tlp; + register int tbo; + register int cp; + register int bufo; + register int c; + int inwindow; + char buf[NLINE]; - /* Figure out if matching char is in current window by */ - /* searching from the top of the window to dot. */ + /* Figure out if matching char is in current window by */ + /* searching from the top of the window to dot. */ inwindow = FALSE; for (tlp = curwp->w_linep; tlp != lforw(curwp->w_dotp); tlp = lforw(tlp)) @@ -154,36 +165,38 @@ register int cbo; tlp = curwp->w_dotp; /* save current position */ tbo = curwp->w_doto; - curwp->w_dotp = clp; /* move to new position */ - curwp->w_doto = cbo; + curwp->w_dotp = clp; /* move to new position */ + curwp->w_doto = cbo; curwp->w_flag |= WFMOVE; - update(); /* show match */ - sleep(1); /* wait a bit */ + update(); /* show match */ + sleep(1); /* wait a bit */ - curwp->w_dotp = tlp; /* return to old position */ - curwp->w_doto = tbo; - curwp->w_flag |= WFMOVE; + curwp->w_dotp = tlp; /* return to old position */ + curwp->w_doto = tbo; + curwp->w_flag |= WFMOVE; update(); - } - else { /* match not in this window so display line in echo area */ + } else { /* match not in this window so display line + * in echo area */ bufo = 0; - for (cp = 0; cp < llength(clp); cp++) { /* expand tabs */ - c = lgetc(clp,cp); + for (cp = 0; cp < llength(clp); cp++) { /* expand tabs */ + c = lgetc(clp, cp); if (c != '\t' #ifdef NOTAB - || (curbp->b_flag & BFNOTAB) + || (curbp->b_flag & BFNOTAB) #endif - ) if(ISCTRL(c)) { - buf[bufo++] = '^'; - buf[bufo++] = CCHR(c); - } else buf[bufo++] = c; + ) + if (ISCTRL(c)) { + buf[bufo++] = '^'; + buf[bufo++] = CCHR(c); + } else + buf[bufo++] = c; else do { buf[bufo++] = ' '; } while (bufo & 7); } buf[bufo++] = '\0'; - ewprintf("Matches %s",buf); + ewprintf("Matches %s", buf); } } diff --git a/usr.bin/mg/modes.c b/usr.bin/mg/modes.c index 49144f2fd6f..856bcc9d517 100644 --- a/usr.bin/mg/modes.c +++ b/usr.bin/mg/modes.c @@ -6,57 +6,60 @@ #include "def.h" #include "kbd.h" -int defb_nmodes = 0; -MAPS *defb_modes[PBMODES] = {&map_table[0]}; -int defb_flag = 0; +int defb_nmodes = 0; +MAPS *defb_modes[PBMODES] = {&map_table[0]}; +int defb_flag = 0; -static int changemode(f, n, mode) -int f, n; -char *mode; +static int +changemode(f, n, mode) + int f, n; + char *mode; { - register int i; - MAPS *m; - VOID upmodes(); + register int i; + MAPS *m; - if((m = name_mode(mode)) == NULL) { - ewprintf("Can't find mode %s", mode); - return FALSE; - } - if(!(f & FFARG)) { - for(i=0; i <= curbp->b_nmodes; i++) - if(curbp->b_modes[i] == m) { - n = 0; /* mode already set */ - break; - } - } - if(n > 0) { - for(i=0; i <= curbp->b_nmodes; i++) - if(curbp->b_modes[i] == m) return TRUE; /* mode already set */ - if(curbp->b_nmodes >= PBMODES-1) { - ewprintf("Too many modes"); - return FALSE; + if ((m = name_mode(mode)) == NULL) { + ewprintf("Can't find mode %s", mode); + return FALSE; } - curbp->b_modes[++(curbp->b_nmodes)] = m; - } else { - /* fundamental is b_modes[0] and can't be unset */ - for(i=1; i <= curbp->b_nmodes && m != curbp->b_modes[i]; i++) {} - if(i > curbp->b_nmodes) return TRUE; /* mode wasn't set */ - for(; i < curbp->b_nmodes; i++) - curbp->b_modes[i] = curbp->b_modes[i+1]; - curbp->b_nmodes--; - } - upmodes(curbp); - return TRUE; + if (!(f & FFARG)) { + for (i = 0; i <= curbp->b_nmodes; i++) + if (curbp->b_modes[i] == m) { + n = 0; /* mode already set */ + break; + } + } + if (n > 0) { + for (i = 0; i <= curbp->b_nmodes; i++) + if (curbp->b_modes[i] == m) + return TRUE; /* mode already set */ + if (curbp->b_nmodes >= PBMODES - 1) { + ewprintf("Too many modes"); + return FALSE; + } + curbp->b_modes[++(curbp->b_nmodes)] = m; + } else { + /* fundamental is b_modes[0] and can't be unset */ + for (i = 1; i <= curbp->b_nmodes && m != curbp->b_modes[i]; i++) { + } + if (i > curbp->b_nmodes) + return TRUE; /* mode wasn't set */ + for (; i < curbp->b_nmodes; i++) + curbp->b_modes[i] = curbp->b_modes[i + 1]; + curbp->b_nmodes--; + } + upmodes(curbp); + return TRUE; } indentmode(f, n) { - return changemode(f, n, "indent"); + return changemode(f, n, "indent"); } fillmode(f, n) { - return changemode(f, n, "fill"); + return changemode(f, n, "fill"); } /* @@ -64,75 +67,90 @@ fillmode(f, n) */ blinkparen(f, n) { - return changemode(f, n, "blink"); + return changemode(f, n, "blink"); } #ifdef NOTAB notabmode(f, n) { - if(changemode(f, n, "notab") == FALSE) return FALSE; - if(f & FFARG) { - if(n <= 0) curbp->b_flag &= ~BFNOTAB; - else curbp->b_flag |= BFNOTAB; - } else curbp->b_flag ^= BFNOTAB; - return TRUE; + if (changemode(f, n, "notab") == FALSE) + return FALSE; + if (f & FFARG) { + if (n <= 0) + curbp->b_flag &= ~BFNOTAB; + else + curbp->b_flag |= BFNOTAB; + } else + curbp->b_flag ^= BFNOTAB; + return TRUE; } #endif overwrite(f, n) -int f, n; + int f, n; { - if(changemode(f, n, "overwrite") == FALSE) return FALSE; - if(f & FFARG) { - if(n <= 0) curbp->b_flag &= ~BFOVERWRITE; - else curbp->b_flag |= BFOVERWRITE; - } else curbp->b_flag ^= BFOVERWRITE; - return TRUE; + if (changemode(f, n, "overwrite") == FALSE) + return FALSE; + if (f & FFARG) { + if (n <= 0) + curbp->b_flag &= ~BFOVERWRITE; + else + curbp->b_flag |= BFOVERWRITE; + } else + curbp->b_flag ^= BFOVERWRITE; + return TRUE; } set_default_mode(f, n) -int f, n; + int f, n; { - register int i; - register MAPS *m; - char mode[32]; + register int i; + register MAPS *m; + char mode[32]; - if(eread("Set Default Mode: ", mode, 32, EFNEW) != TRUE) - return ABORT; - if((m = name_mode(mode)) == NULL) { - ewprintf("can't find mode %s", mode); - return FALSE; - } - if(!(f & FFARG)) { - for(i=0; i <= defb_nmodes; i++) - if(defb_modes[i] == m) { - n = 0; /* mode already set */ - break; - } - } - if(n > 0) { - for(i=0; i <= defb_nmodes; i++) - if(defb_modes[i] == m) return TRUE; /* mode already set */ - if(defb_nmodes >= PBMODES-1) { - ewprintf("Too many modes"); - return FALSE; + if (eread("Set Default Mode: ", mode, 32, EFNEW) != TRUE) + return ABORT; + if ((m = name_mode(mode)) == NULL) { + ewprintf("can't find mode %s", mode); + return FALSE; + } + if (!(f & FFARG)) { + for (i = 0; i <= defb_nmodes; i++) + if (defb_modes[i] == m) { + n = 0; /* mode already set */ + break; + } + } + if (n > 0) { + for (i = 0; i <= defb_nmodes; i++) + if (defb_modes[i] == m) + return TRUE; /* mode already set */ + if (defb_nmodes >= PBMODES - 1) { + ewprintf("Too many modes"); + return FALSE; + } + defb_modes[++defb_nmodes] = m; + } else { + /* fundamental is defb_modes[0] and can't be unset */ + for (i = 1; i <= defb_nmodes && m != defb_modes[i]; i++) { + } + if (i > defb_nmodes) + return TRUE; /* mode wasn't set */ + for (; i < defb_nmodes; i++) + defb_modes[i] = defb_modes[i + 1]; + defb_nmodes--; } - defb_modes[++defb_nmodes] = m; - } else { - /* fundamental is defb_modes[0] and can't be unset */ - for(i=1; i <= defb_nmodes && m != defb_modes[i]; i++) {} - if(i > defb_nmodes) return TRUE; /* mode wasn't set */ - for(; i < defb_nmodes; i++) - defb_modes[i] = defb_modes[i+1]; - defb_nmodes--; - } - if(strcmp(mode, "overwrite")==0) - if(n<=0) defb_flag &= ~BFOVERWRITE; - else defb_flag |= BFOVERWRITE; + if (strcmp(mode, "overwrite") == 0) + if (n <= 0) + defb_flag &= ~BFOVERWRITE; + else + defb_flag |= BFOVERWRITE; #ifdef NOTAB - if(strcmp(mode, "notab")==0) - if(n<=0) defb_flag &= ~BFNOTAB; - else defb_flag |= BFNOTAB; + if (strcmp(mode, "notab") == 0) + if (n <= 0) + defb_flag &= ~BFNOTAB; + else + defb_flag |= BFNOTAB; #endif - return TRUE; + return TRUE; } diff --git a/usr.bin/mg/paragraph.c b/usr.bin/mg/paragraph.c index b09aa7810f3..8e1536dfe0d 100644 --- a/usr.bin/mg/paragraph.c +++ b/usr.bin/mg/paragraph.c @@ -4,7 +4,7 @@ */ #include "def.h" -static int fillcol = 70 ; +static int fillcol = 70; #define MAXWORD 256 /* @@ -12,40 +12,47 @@ static int fillcol = 70 ; * here we look for a or or * combination to delimit the begining of a paragraph */ -/*ARGSUSED*/ +/* ARGSUSED */ gotobop(f, n) { - if (n < 0) /* the other way...*/ + if (n < 0) /* the other way... */ return gotoeop(f, -n); while (n-- > 0) { /* for each one asked for */ /* first scan back until we are in a word */ - - while (backchar(FFRAND, 1) && !inword()) {} + + while (backchar(FFRAND, 1) && !inword()) { + } curwp->w_doto = 0; /* and go to the B-O-Line */ - /* and scan back until we hit a or */ + /* + * and scan back until we hit a or + * + */ while (lback(curwp->w_dotp) != curbp->b_linep) if (llength(lback(curwp->w_dotp)) - && lgetc(curwp->w_dotp,0) != ' ' - && lgetc(curwp->w_dotp,0) != '.' - && lgetc(curwp->w_dotp,0) != '\t') + && lgetc(curwp->w_dotp, 0) != ' ' + && lgetc(curwp->w_dotp, 0) != '.' + && lgetc(curwp->w_dotp, 0) != '\t') curwp->w_dotp = lback(curwp->w_dotp); else { - if (llength(lback(curwp->w_dotp)) - && lgetc(curwp->w_dotp,0) == '.') { - curwp->w_dotp = lforw(curwp->w_dotp); - if(curwp->w_dotp == curbp->b_linep) { - /* beond end of buffer, cleanup time */ - curwp->w_dotp = lback(curwp->w_dotp); - curwp->w_doto = llength(curwp->w_dotp); - } - } - break; - } + if (llength(lback(curwp->w_dotp)) + && lgetc(curwp->w_dotp, 0) == '.') { + curwp->w_dotp = lforw(curwp->w_dotp); + if (curwp->w_dotp == curbp->b_linep) { + /* + * beond end of buffer, + * cleanup time + */ + curwp->w_dotp = lback(curwp->w_dotp); + curwp->w_doto = llength(curwp->w_dotp); + } + } + break; + } } - curwp->w_flag |= WFMOVE; /* force screen update */ + curwp->w_flag |= WFMOVE;/* force screen update */ return TRUE; } @@ -54,37 +61,38 @@ gotobop(f, n) * here we look for a or or * combination to delimit the begining of a paragraph */ -/*ARGSUSED*/ +/* ARGSUSED */ gotoeop(f, n) { - if (n < 0) /* the other way...*/ + if (n < 0) /* the other way... */ return gotobop(f, -n); while (n-- > 0) { /* for each one asked for */ /* Find the first word on/after the current line */ curwp->w_doto = 0; - while(forwchar(FFRAND, 1) && !inword()) {} + while (forwchar(FFRAND, 1) && !inword()) { + } curwp->w_doto = 0; curwp->w_dotp = lforw(curwp->w_dotp); /* and scan forword until we hit a or ... */ while (curwp->w_dotp != curbp->b_linep) { if (llength(curwp->w_dotp) - && lgetc(curwp->w_dotp,0) != ' ' - && lgetc(curwp->w_dotp,0) != '.' - && lgetc(curwp->w_dotp,0) != '\t') + && lgetc(curwp->w_dotp, 0) != ' ' + && lgetc(curwp->w_dotp, 0) != '.' + && lgetc(curwp->w_dotp, 0) != '\t') curwp->w_dotp = lforw(curwp->w_dotp); else break; } - if(curwp->w_dotp == curbp->b_linep) { + if (curwp->w_dotp == curbp->b_linep) { /* beond end of buffer, cleanup time */ curwp->w_dotp = lback(curwp->w_dotp); curwp->w_doto = llength(curwp->w_dotp); - break; + break; } } - curwp->w_flag |= WFMOVE; /* force screen update */ + curwp->w_flag |= WFMOVE;/* force screen update */ return TRUE; } @@ -92,33 +100,35 @@ gotoeop(f, n) * Fill the current paragraph according to the current * fill column */ -/*ARGSUSED*/ +/* ARGSUSED */ fillpara(f, n) { - register int c; /* current char durring scan */ - register int wordlen; /* length of current word */ - register int clength; /* position on line during fill */ - register int i; /* index during word copy */ - register int eopflag; /* Are we at the End-Of-Paragraph? */ - int firstflag; /* first word? (needs no space) */ - int newlength; /* tentative new line length */ - int eolflag; /* was at end of line */ - LINE *eopline; /* pointer to line just past EOP */ - char wbuf[MAXWORD]; /* buffer for current word */ + register int c; /* current char durring scan */ + register int wordlen;/* length of current word */ + register int clength;/* position on line during fill */ + register int i; /* index during word copy */ + register int eopflag;/* Are we at the End-Of-Paragraph? */ + int firstflag; /* first word? (needs no space) */ + int newlength; /* tentative new line length */ + int eolflag;/* was at end of line */ + LINE *eopline;/* pointer to line just past EOP */ + char wbuf[MAXWORD]; /* buffer for current word */ /* record the pointer to the line just past the EOP */ (VOID) gotoeop(FFRAND, 1); - if(curwp->w_doto != 0) { + if (curwp->w_doto != 0) { /* paragraph ends at end of buffer */ (VOID) lnewline(); eopline = lforw(curwp->w_dotp); - } else eopline = curwp->w_dotp; + } else + eopline = curwp->w_dotp; /* and back top the begining of the paragraph */ (VOID) gotobop(FFRAND, 1); /* initialize various info */ - while (!inword() && forwchar(FFRAND, 1)) {} + while (!inword() && forwchar(FFRAND, 1)) { + } clength = curwp->w_doto; wordlen = 0; @@ -127,7 +137,7 @@ fillpara(f, n) eopflag = FALSE; while (!eopflag) { /* get the next character in the paragraph */ - if (eolflag=(curwp->w_doto == llength(curwp->w_dotp))) { + if (eolflag = (curwp->w_doto == llength(curwp->w_dotp))) { c = ' '; if (lforw(curwp->w_dotp) == eopline) eopflag = TRUE; @@ -143,24 +153,26 @@ fillpara(f, n) if (wordlen < MAXWORD - 1) wbuf[wordlen++] = c; else { - /* You loose chars beyond MAXWORD if the word + /* + * You loose chars beyond MAXWORD if the word * is to long. I'm to lazy to fix it now; it - * just silently truncated the word before, so - * I get to feel smug. + * just silently truncated the word before, + * so I get to feel smug. */ ewprintf("Word too long!"); } } else if (wordlen) { /* calculate tenatitive new length with word added */ newlength = clength + 1 + wordlen; - /* if at end of line or at doublespace and previous + /* + * if at end of line or at doublespace and previous * character was one of '.','?','!' doublespace here. */ - if((eolflag || curwp->w_doto==llength(curwp->w_dotp) - || (c=lgetc(curwp->w_dotp,curwp->w_doto))==' ' - || c=='\t') - && ISEOSP(wbuf[wordlen-1]) - && wordlenw_doto == llength(curwp->w_dotp) + || (c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ' + || c == '\t') + && ISEOSP(wbuf[wordlen - 1]) + && wordlen < MAXWORD - 1) wbuf[wordlen++] = ' '; /* at a word break with a word waiting */ if (newlength <= fillcol) { @@ -171,8 +183,8 @@ fillpara(f, n) } firstflag = FALSE; } else { - if(curwp->w_doto > 0 && - lgetc(curwp->w_dotp,curwp->w_doto-1)==' ') { + if (curwp->w_doto > 0 && + lgetc(curwp->w_dotp, curwp->w_doto - 1) == ' ') { curwp->w_doto -= 1; (VOID) ldelete((RSIZE) 1, KNONE); } @@ -182,7 +194,7 @@ fillpara(f, n) } /* and add the word in in either case */ - for (i=0; iw_doto) return selfinsert(f, n) ; + if (i == curwp->w_doto) + return selfinsert(f, n); c = lgetc(curwp->w_dotp, i); if (c == '\t' #ifdef NOTAB - && !(curbp->b_flag & BFNOTAB) + && !(curbp->b_flag & BFNOTAB) #endif - ) col |= 0x07; - else if (ISCTRL(c) != FALSE) ++col; + ) + col |= 0x07; + else if (ISCTRL(c) != FALSE) + ++col; } if (curwp->w_doto != llength(curwp->w_dotp)) { (VOID) selfinsert(f, n); nce = llength(curwp->w_dotp) - curwp->w_doto; - } else nce = 0; + } else + nce = 0; curwp->w_doto = i; if ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' && c != '\t') do { (VOID) backchar(FFRAND, 1); } while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' - && c != '\t' && curwp->w_doto > 0); + && c != '\t' && curwp->w_doto > 0); if (curwp->w_doto == 0) do { (VOID) forwchar(FFRAND, 1); } while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' - && c != '\t' && curwp->w_doto < llength(curwp->w_dotp)); + && c != '\t' && curwp->w_doto < llength(curwp->w_dotp)); (VOID) delwhite(FFRAND, 1); (VOID) lnewline(); i = llength(curwp->w_dotp) - nce; - curwp->w_doto = i>0 ? i : 0; + curwp->w_doto = i > 0 ? i : 0; curwp->w_flag |= WFMOVE; - if (nce == 0 && curwp->w_doto != 0) return fillword(f, n); + if (nce == 0 && curwp->w_doto != 0) + return fillword(f, n); return TRUE; } /* Set fill column to n. */ -setfillcol(f, n) { - extern int getcolpos() ; +setfillcol(f, n) +{ + extern int getcolpos(); fillcol = ((f & FFARG) ? n : getcolpos()); ewprintf("Fill column set to %d", fillcol); diff --git a/usr.bin/mg/random.c b/usr.bin/mg/random.c index 297de45eba5..c10aa2d5127 100644 --- a/usr.bin/mg/random.c +++ b/usr.bin/mg/random.c @@ -16,60 +16,62 @@ * display; it does not truncate just because the screen does. * This is normally bound to "C-X =". */ -/*ARGSUSED*/ +/* ARGSUSED */ showcpos(f, n) { - register LINE *clp; - register long nchar; - long cchar; - register int nline, row; - int cline, cbyte; /* Current line/char/byte */ - int ratio; + register LINE *clp; + register long nchar; + long cchar; + register int nline, row; + int cline, cbyte; /* Current line/char/byte */ + int ratio; - clp = lforw(curbp->b_linep); /* Collect the data. */ + clp = lforw(curbp->b_linep); /* Collect the data. */ nchar = 0; nline = 0; for (;;) { - ++nline; /* Count this line */ + ++nline; /* Count this line */ if (clp == curwp->w_dotp) { - cline = nline; /* Mark line */ + cline = nline; /* Mark line */ cchar = nchar + curwp->w_doto; if (curwp->w_doto == llength(clp)) cbyte = '\n'; else cbyte = lgetc(clp, curwp->w_doto); } - nchar += llength(clp); /* Now count the chars */ + nchar += llength(clp); /* Now count the chars */ clp = lforw(clp); - if (clp == curbp->b_linep) break; - nchar++; /* count the newline */ + if (clp == curbp->b_linep) + break; + nchar++; /* count the newline */ } - row = curwp->w_toprow + 1; /* Determine row. */ + row = curwp->w_toprow + 1; /* Determine row. */ clp = curwp->w_linep; - while (clp!=curbp->b_linep && clp!=curwp->w_dotp) { + while (clp != curbp->b_linep && clp != curwp->w_dotp) { ++row; clp = lforw(clp); } - /*NOSTRICT*/ - ratio = nchar ? (100L*cchar) / nchar : 100; + /* NOSTRICT */ + ratio = nchar ? (100L * cchar) / nchar : 100; ewprintf("Char: %c (0%o) point=%ld(%d%%) line=%d row=%d col=%d", - cbyte, cbyte, cchar, ratio, cline, row, getcolpos()); + cbyte, cbyte, cchar, ratio, cline, row, getcolpos()); return TRUE; } -getcolpos() { - register int col, i, c; +getcolpos() +{ + register int col, i, c; - col = 1; /* Determine column. */ - for (i=0; iw_doto; ++i) { + col = 1; /* Determine column. */ + for (i = 0; i < curwp->w_doto; ++i) { c = lgetc(curwp->w_dotp, i); if (c == '\t' #ifdef NOTAB - && !(curbp->b_flag & BFNOTAB) + && !(curbp->b_flag & BFNOTAB) #endif ) { - col |= 0x07; - ++col; + col |= 0x07; + ++col; } else if (ISCTRL(c) != FALSE) ++col; ++col; @@ -86,24 +88,26 @@ getcolpos() { * to "C-T". This always works within a line, so * "WFEDIT" is good enough. */ -/*ARGSUSED*/ +/* ARGSUSED */ twiddle(f, n) { - register LINE *dotp; - register int doto; - register int cr; - VOID lchange(); + register LINE *dotp; + register int doto; + register int cr; + VOID lchange(); dotp = curwp->w_dotp; doto = curwp->w_doto; - if(doto==llength(dotp)) { - if(--doto<=0) return FALSE; + if (doto == llength(dotp)) { + if (--doto <= 0) + return FALSE; } else { - if(doto==0) return FALSE; + if (doto == 0) + return FALSE; ++curwp->w_doto; } cr = lgetc(dotp, doto--); - lputc(dotp, doto+1, lgetc(dotp, doto)); + lputc(dotp, doto + 1, lgetc(dotp, doto)); lputc(dotp, doto, cr); lchange(WFEDIT); return TRUE; @@ -116,22 +120,22 @@ twiddle(f, n) * procerssors. They even handle the looping. Normally * this is bound to "C-O". */ -/*ARGSUSED*/ +/* ARGSUSED */ openline(f, n) { - register int i; - register int s; + register int i; + register int s; if (n < 0) return FALSE; if (n == 0) return TRUE; - i = n; /* Insert newlines. */ + i = n; /* Insert newlines. */ do { s = lnewline(); - } while (s==TRUE && --i); - if (s == TRUE) /* Then back up overtop */ - s = backchar(f | FFRAND, n); /* of them all. */ + } while (s == TRUE && --i); + if (s == TRUE) /* Then back up overtop */ + s = backchar(f | FFRAND, n); /* of them all. */ return s; } @@ -147,25 +151,26 @@ openline(f, n) * as critical if screen update were a lot * more efficient. */ -/*ARGSUSED*/ +/* ARGSUSED */ newline(f, n) { - register LINE *lp; - register int s; + register LINE *lp; + register int s; - if (n < 0) return FALSE; + if (n < 0) + return FALSE; while (n--) { lp = curwp->w_dotp; #ifdef undef if (llength(lp) == curwp->w_doto - && lforw(lp) != curbp->b_linep - && llength(lforw(lp)) == 0) { - if ((s=forwchar(FFRAND, 1)) != TRUE) + && lforw(lp) != curbp->b_linep + && llength(lforw(lp)) == 0) { + if ((s = forwchar(FFRAND, 1)) != TRUE) return s; } else #endif - if ((s=lnewline()) != TRUE) - return s; + if ((s = lnewline()) != TRUE) + return s; } return TRUE; } @@ -180,56 +185,59 @@ newline(f, n) * blank lines after the line. Normally this command * is bound to "C-X C-O". Any argument is ignored. */ -/*ARGSUSED*/ +/* ARGSUSED */ deblank(f, n) { - register LINE *lp1; - register LINE *lp2; - register RSIZE nld; + register LINE *lp1; + register LINE *lp2; + register RSIZE nld; lp1 = curwp->w_dotp; - while (llength(lp1)==0 && (lp2=lback(lp1))!=curbp->b_linep) + while (llength(lp1) == 0 && (lp2 = lback(lp1)) != curbp->b_linep) lp1 = lp2; lp2 = lp1; nld = (RSIZE) 0; - while ((lp2=lforw(lp2))!=curbp->b_linep && llength(lp2)==0) + while ((lp2 = lforw(lp2)) != curbp->b_linep && llength(lp2) == 0) ++nld; if (nld == 0) return (TRUE); curwp->w_dotp = lforw(lp1); curwp->w_doto = 0; - return ldelete((RSIZE)nld, KNONE); + return ldelete((RSIZE) nld, KNONE); } /* * Delete any whitespace around dot, then insert a space. */ -justone(f, n) { +justone(f, n) +{ (VOID) delwhite(f, n); return linsert(1, ' '); } /* * Delete any whitespace around dot. */ -/*ARGSUSED*/ +/* ARGSUSED */ delwhite(f, n) { - register int col, c, s; + register int col, c, s; col = curwp->w_doto; while (((c = lgetc(curwp->w_dotp, col)) == ' ' || c == '\t') - && col < llength(curwp->w_dotp)) + && col < llength(curwp->w_dotp)) ++col; do { if (curwp->w_doto == 0) { s = FALSE; break; } - if ((s = backchar(FFRAND, 1)) != TRUE) break; + if ((s = backchar(FFRAND, 1)) != TRUE) + break; } while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ' || c == '\t'); - if (s == TRUE) (VOID) forwchar(FFRAND, 1); - (VOID) ldelete((RSIZE)(col - curwp->w_doto), KNONE); + if (s == TRUE) + (VOID) forwchar(FFRAND, 1); + (VOID) ldelete((RSIZE) (col - curwp->w_doto), KNONE); return TRUE; } /* @@ -244,19 +252,20 @@ delwhite(f, n) * of the subcomands failed. Normally bound * to "C-J". */ -/*ARGSUSED*/ +/* ARGSUSED */ indent(f, n) { - register int nicol; - register int c; - register int i; + register int nicol; + register int c; + register int i; - if (n < 0) return (FALSE); + if (n < 0) + return (FALSE); while (n--) { nicol = 0; - for (i=0; iw_dotp); ++i) { + for (i = 0; i < llength(curwp->w_dotp); ++i) { c = lgetc(curwp->w_dotp, i); - if (c!=' ' && c!='\t') + if (c != ' ' && c != '\t') break; if (c == '\t') nicol |= 0x07; @@ -264,11 +273,11 @@ indent(f, n) } if (lnewline() == FALSE || (( #ifdef NOTAB - curbp->b_flag&BFNOTAB) ? - linsert(nicol, ' ') == FALSE : ( + curbp->b_flag & BFNOTAB) ? + linsert(nicol, ' ') == FALSE : ( #endif - ((i=nicol/8)!=0 && linsert(i, '\t')==FALSE) || - ((i=nicol%8)!=0 && linsert(i, ' ')==FALSE)))) + ((i = nicol / 8) != 0 && linsert(i, '\t') == FALSE) || + ((i = nicol % 8) != 0 && linsert(i, ' ') == FALSE)))) return FALSE; } return TRUE; @@ -283,13 +292,13 @@ indent(f, n) * loss of text if typed with a big argument. * Normally bound to "C-D". */ -/*ARGSUSED*/ +/* ARGSUSED */ forwdel(f, n) { if (n < 0) return backdel(f | FFRAND, -n); - if (f & FFARG) { /* Really a kill. */ - if ((lastflag&CFKILL) == 0) + if (f & FFARG) { /* Really a kill. */ + if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; } @@ -303,19 +312,19 @@ forwdel(f, n) * Like delete forward, this actually does a kill * if presented with an argument. */ -/*ARGSUSED*/ +/* ARGSUSED */ backdel(f, n) { - register int s; + register int s; if (n < 0) return forwdel(f | FFRAND, -n); - if (f & FFARG) { /* Really a kill. */ - if ((lastflag&CFKILL) == 0) + if (f & FFARG) { /* Really a kill. */ + if ((lastflag & CFKILL) == 0) kdelete(); thisflag |= CFKILL; } - if ((s=backchar(f | FFRAND, n)) == TRUE) + if ((s = backchar(f | FFRAND, n)) == TRUE) s = ldelete((RSIZE) n, (f & FFARG) ? KFORW : KNONE); return s; } @@ -331,38 +340,39 @@ backdel(f, n) * kills any text before dot on the current line, * then it kills back abs(arg) lines. */ -/*ARGSUSED*/ -killline(f, n) { - register RSIZE chunk; - register LINE *nextp; - register int i, c; - VOID kdelete(); +/* ARGSUSED */ +killline(f, n) +{ + register RSIZE chunk; + register LINE *nextp; + register int i, c; + VOID kdelete(); - if ((lastflag&CFKILL) == 0) /* Clear kill buffer if */ - kdelete(); /* last wasn't a kill. */ + if ((lastflag & CFKILL) == 0) /* Clear kill buffer if */ + kdelete(); /* last wasn't a kill. */ thisflag |= CFKILL; if (!(f & FFARG)) { for (i = curwp->w_doto; i < llength(curwp->w_dotp); ++i) if ((c = lgetc(curwp->w_dotp, i)) != ' ' && c != '\t') break; if (i == llength(curwp->w_dotp)) - chunk = llength(curwp->w_dotp)-curwp->w_doto + 1; + chunk = llength(curwp->w_dotp) - curwp->w_doto + 1; else { - chunk = llength(curwp->w_dotp)-curwp->w_doto; + chunk = llength(curwp->w_dotp) - curwp->w_doto; if (chunk == 0) chunk = 1; } } else if (n > 0) { - chunk = llength(curwp->w_dotp)-curwp->w_doto+1; + chunk = llength(curwp->w_dotp) - curwp->w_doto + 1; nextp = lforw(curwp->w_dotp); i = n; while (--i) { if (nextp == curbp->b_linep) break; - chunk += llength(nextp)+1; + chunk += llength(nextp) + 1; nextp = lforw(nextp); } - } else { /* n <= 0 */ + } else { /* n <= 0 */ chunk = curwp->w_doto; curwp->w_doto = 0; i = n; @@ -371,14 +381,14 @@ killline(f, n) { break; curwp->w_dotp = lback(curwp->w_dotp); curwp->w_flag |= WFMOVE; - chunk += llength(curwp->w_dotp)+1; + chunk += llength(curwp->w_dotp) + 1; } } /* * KFORW here is a bug. Should be KBACK/KFORW, but we need to * rewrite the ldelete code (later)? */ - return (ldelete(chunk, KFORW)); + return (ldelete(chunk, KFORW)); } /* @@ -396,21 +406,22 @@ killline(f, n) { * the window (nothing moves, because all of the new * text landed off screen). */ -/*ARGSUSED*/ +/* ARGSUSED */ yank(f, n) { - register int c; - register int i; - register LINE *lp; - register int nline; - VOID isetmark(); + register int c; + register int i; + register LINE *lp; + register int nline; + VOID isetmark(); - if (n < 0) return FALSE; - nline = 0; /* Newline counting. */ + if (n < 0) + return FALSE; + nline = 0; /* Newline counting. */ while (n--) { - isetmark(); /* mark around last yank */ + isetmark(); /* mark around last yank */ i = 0; - while ((c=kremove(i)) >= 0) { + while ((c = kremove(i)) >= 0) { if (c == '\n') { if (newline(FFRAND, 1) == FALSE) return FALSE; @@ -422,23 +433,25 @@ yank(f, n) ++i; } } - lp = curwp->w_linep; /* Cosmetic adjustment */ - if (curwp->w_dotp == lp) { /* if offscreen insert. */ - while (nline-- && lback(lp)!=curbp->b_linep) + lp = curwp->w_linep; /* Cosmetic adjustment */ + if (curwp->w_dotp == lp) { /* if offscreen insert. */ + while (nline-- && lback(lp) != curbp->b_linep) lp = lback(lp); - curwp->w_linep = lp; /* Adjust framing. */ + curwp->w_linep = lp; /* Adjust framing. */ curwp->w_flag |= WFHARD; } return TRUE; } #ifdef NOTAB -/*ARGSUSED*/ +/* ARGSUSED */ space_to_tabstop(f, n) -int f, n; + int f, n; { - if(n<0) return FALSE; - if(n==0) return TRUE; - return linsert((n<<3) - (curwp->w_doto & 7), ' '); + if (n < 0) + return FALSE; + if (n == 0) + return TRUE; + return linsert((n << 3) - (curwp->w_doto & 7), ' '); } #endif diff --git a/usr.bin/mg/re_search.c b/usr.bin/mg/re_search.c index 4be7c271c82..bfd1b8f1864 100644 --- a/usr.bin/mg/re_search.c +++ b/usr.bin/mg/re_search.c @@ -1,12 +1,11 @@ /* - * regular expression search commands for - * MicroGnuEmacs + * regular expression search commands for Mg * * This file contains functions to implement several of gnuemacs' - * regular expression functions for MicroGnuEmacs. Several of - * the routines below are just minor rearrangements of the MicroGnuEmacs - * non-regular expression search functions. Hence some of them date back - * in essential structure to the original MicroEMACS; others are modifications + * regular expression functions for Mg. Several of the routines + * below are just minor rearrangements of the Mg non-regular + * expression search functions. Hence some of them date back in + * essential structure to the original MicroEMACS; others are modifications * of Rich Ellison's code. I, Peter Newton, wrote about half from scratch. */ @@ -18,55 +17,55 @@ #include "def.h" #include "macro.h" -#define SRCH_BEGIN (0) /* Search sub-codes. */ +#define SRCH_BEGIN (0) /* Search sub-codes. */ #define SRCH_FORW (-1) #define SRCH_BACK (-2) #define SRCH_NOPR (-3) #define SRCH_ACCM (-4) #define SRCH_MARK (-5) -#define RE_NMATCH 10 /* max number of matches */ +#define RE_NMATCH 10 /* max number of matches */ -char re_pat[NPAT]; /* Regex pattern */ -int re_srch_lastdir = SRCH_NOPR; /* Last search flags. */ -int casefoldsearch = TRUE; /* Does search ignore case ? */ +char re_pat[NPAT]; /* Regex pattern */ +int re_srch_lastdir = SRCH_NOPR; /* Last search flags. */ +int casefoldsearch = TRUE; /* Does search ignore case ? */ /* Indexed by a character, gives the upper case equivalent of the character */ -static char upcase[0400] = - { 000, 001, 002, 003, 004, 005, 006, 007, - 010, 011, 012, 013, 014, 015, 016, 017, - 020, 021, 022, 023, 024, 025, 026, 027, - 030, 031, 032, 033, 034, 035, 036, 037, - 040, 041, 042, 043, 044, 045, 046, 047, - 050, 051, 052, 053, 054, 055, 056, 057, - 060, 061, 062, 063, 064, 065, 066, 067, - 070, 071, 072, 073, 074, 075, 076, 077, - 0100, 0101, 0102, 0103, 0104, 0105, 0106, 0107, - 0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117, - 0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127, - 0130, 0131, 0132, 0133, 0134, 0135, 0136, 0137, - 0140, 0101, 0102, 0103, 0104, 0105, 0106, 0107, - 0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117, - 0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127, - 0130, 0131, 0132, 0173, 0174, 0175, 0176, 0177, - 0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207, - 0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217, - 0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227, - 0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237, - 0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247, - 0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257, - 0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267, - 0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277, - 0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307, - 0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317, - 0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327, - 0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337, - 0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347, - 0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357, - 0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367, - 0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377 - }; +static char upcase[0400] = +{000, 001, 002, 003, 004, 005, 006, 007, + 010, 011, 012, 013, 014, 015, 016, 017, + 020, 021, 022, 023, 024, 025, 026, 027, + 030, 031, 032, 033, 034, 035, 036, 037, + 040, 041, 042, 043, 044, 045, 046, 047, + 050, 051, 052, 053, 054, 055, 056, 057, + 060, 061, 062, 063, 064, 065, 066, 067, + 070, 071, 072, 073, 074, 075, 076, 077, + 0100, 0101, 0102, 0103, 0104, 0105, 0106, 0107, + 0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117, + 0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127, + 0130, 0131, 0132, 0133, 0134, 0135, 0136, 0137, + 0140, 0101, 0102, 0103, 0104, 0105, 0106, 0107, + 0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117, + 0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127, + 0130, 0131, 0132, 0173, 0174, 0175, 0176, 0177, + 0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207, + 0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217, + 0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227, + 0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237, + 0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247, + 0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257, + 0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267, + 0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277, + 0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307, + 0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317, + 0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327, + 0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337, + 0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347, + 0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357, + 0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367, + 0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377 +}; /* * Search forward. @@ -75,11 +74,12 @@ static char upcase[0400] = * matched characters, and display does all the hard stuff. * If not found, it just prints a message. */ -/*ARGSUSED*/ -re_forwsearch(f, n) { - register int s; +/* ARGSUSED */ +re_forwsearch(f, n) +{ + register int s; - if ((s=re_readpattern("RE Search")) != TRUE) + if ((s = re_readpattern("RE Search")) != TRUE) return (s); if (re_forwsrch() == FALSE) { ewprintf("Search failed: \"%s\"", re_pat); @@ -96,11 +96,12 @@ re_forwsearch(f, n) { * pointing at the first character of the pattern [the last character that * was matched]. */ -/*ARGSUSED*/ -re_backsearch(f, n) { - register int s; +/* ARGSUSED */ +re_backsearch(f, n) +{ + register int s; - if ((s=re_readpattern("RE Search backward")) != TRUE) + if ((s = re_readpattern("RE Search backward")) != TRUE) return (s); if (re_backsrch() == FALSE) { ewprintf("Search failed: \"%s\"", re_pat); @@ -118,55 +119,58 @@ re_backsearch(f, n) { * has been saved in "srch_lastdir", so you know which way * to go. */ -/*ARGSUSED*/ -/* This code has problems-- some incompatibility(?) with - extend.c causes match to fail when it should not. +/* ARGSUSED */ +/* + * This code has problems-- some incompatibility(?) with extend.c causes + * match to fail when it should not. */ -re_searchagain(f, n) { - - if (re_srch_lastdir == SRCH_NOPR) { - ewprintf("No last search"); - return (FALSE); - } - - if (re_srch_lastdir == SRCH_FORW) { - if (re_forwsrch() == FALSE) { - ewprintf("Search failed: \"%s\"", re_pat); - return (FALSE); - } - return (TRUE); - } - if (re_srch_lastdir == SRCH_BACK) { - if (re_backsrch() == FALSE) { - ewprintf("Search failed: \"%s\"", re_pat); - return (FALSE); - } - return (TRUE); - } +re_searchagain(f, n) +{ + + if (re_srch_lastdir == SRCH_NOPR) { + ewprintf("No last search"); + return (FALSE); + } + if (re_srch_lastdir == SRCH_FORW) { + if (re_forwsrch() == FALSE) { + ewprintf("Search failed: \"%s\"", re_pat); + return (FALSE); + } + return (TRUE); + } + if (re_srch_lastdir == SRCH_BACK) { + if (re_backsrch() == FALSE) { + ewprintf("Search failed: \"%s\"", re_pat); + return (FALSE); + } + return (TRUE); + } } /* Compiled regex goes here-- changed only when new pattern read */ -static regex_t re_buff; +static regex_t re_buff; static regmatch_t re_match[RE_NMATCH]; /* * Re-Query Replace. * Replace strings selectively. Does a search and replace operation. */ -/*ARGSUSED*/ -re_queryrepl(f, n) { - register int s; - register int rcnt = 0; /* Replacements made so far */ - register int plen; /* length of found string */ - char news[NPAT]; /* replacement string */ +/* ARGSUSED */ +re_queryrepl(f, n) +{ + register int s; + register int rcnt = 0; /* Replacements made so far */ + register int plen; /* length of found string */ + char news[NPAT]; /* replacement string */ /* Casefold check */ - if (!casefoldsearch) f = TRUE; + if (!casefoldsearch) + f = TRUE; - if ((s=re_readpattern("RE Query replace")) != TRUE) + if ((s = re_readpattern("RE Query replace")) != TRUE) return (s); - if ((s=ereply("Query replace %s with: ",news, NPAT, re_pat)) == ABORT) + if ((s = ereply("Query replace %s with: ", news, NPAT, re_pat)) == ABORT) return (s); if (s == FALSE) news[0] = '\0'; @@ -179,7 +183,7 @@ re_queryrepl(f, n) { */ while (re_forwsrch() == TRUE) { - retry: +retry: update(); switch (getkey(FALSE)) { case ' ': @@ -196,9 +200,9 @@ re_queryrepl(f, n) { rcnt++; goto stopsearch; - case CCHR('G'): /* ^G */ + case CCHR('G'):/* ^G */ (VOID) ctrlg(FFRAND, 0); - case CCHR('['): /* ESC */ + case CCHR('['):/* ESC */ case '`': goto stopsearch; @@ -211,11 +215,11 @@ re_queryrepl(f, n) { } while (re_forwsrch() == TRUE); goto stopsearch; - case CCHR('?'): /* To not replace */ + case CCHR('?'):/* To not replace */ break; default: -ewprintf(" replace, [.] rep-end, don't, [!] repl rest quit"); + ewprintf(" replace, [.] rep-end, don't, [!] repl rest quit"); goto retry; } } @@ -235,93 +239,100 @@ stopsearch: -/* Routine re_doreplace calls lreplace to make replacements needed by - * re_query replace. Its reason for existence is to deal with \1, - * \2. etc. +/* + * Routine re_doreplace calls lreplace to make replacements needed by + * re_query replace. Its reason for existence is to deal with \1, \2. etc. */ /* Maximum length of replacement string */ #define REPLEN 256 re_doreplace(plen, st, f) - register RSIZE plen; /* length to remove */ - char *st; /* replacement string */ - int f; /* case hack disable */ + register RSIZE plen; /* length to remove */ + char *st; /* replacement string */ + int f; /* case hack disable */ { - int s; - int num, k; - register int j; - int more, state; - LINE *clp; - char repstr[REPLEN]; - - clp = curwp->w_dotp; - more = TRUE; - j = 0; - state = 0; - - /* The following FSA parses the replacement string */ - while (more) { - switch (state) { - - case 0: if (*st == '\\') { - st++; - state = 1; - } - else if (*st == '\0') - more = FALSE; - else { - repstr[j] = *st; - j++; if (j >= REPLEN) return(FALSE); - st++; - } - break; - case 1: if (*st >= '0' && *st <= '9') { - num = *st - '0'; - st++; - state = 2; - } - else if (*st == '\0') - more = FALSE; - else { - repstr[j] = *st; - j++; if (j >= REPLEN) return(FALSE); - st++; - state = 0; - } - break; - case 2: if (*st >= '0' && *st <= '9') { - num = 10*num + *st - '0'; - st++; - } - else { - if (num >= RE_NMATCH) return(FALSE); - k = re_match[num].rm_eo - re_match[num].rm_so; - if (j+k >= REPLEN) return(FALSE); - bcopy(&(clp->l_text[re_match[num].rm_so]), &repstr[j], k); - j += k; - if (*st == '\0') - more = FALSE; - if (*st == '\\') { - st++; - state = 1; - } - else { - repstr[j] = *st; - j++; if (j >= REPLEN) return(FALSE); - st++; - state = 0; - } - } - break; - } /* end case */ - } /* end while */ - - repstr[j] = '\0'; - - s = lreplace(plen, repstr, f); - - return(s); + int s; + int num, k; + register int j; + int more, state; + LINE *clp; + char repstr[REPLEN]; + + clp = curwp->w_dotp; + more = TRUE; + j = 0; + state = 0; + + /* The following FSA parses the replacement string */ + while (more) { + switch (state) { + + case 0: + if (*st == '\\') { + st++; + state = 1; + } else if (*st == '\0') + more = FALSE; + else { + repstr[j] = *st; + j++; + if (j >= REPLEN) + return (FALSE); + st++; + } + break; + case 1: + if (*st >= '0' && *st <= '9') { + num = *st - '0'; + st++; + state = 2; + } else if (*st == '\0') + more = FALSE; + else { + repstr[j] = *st; + j++; + if (j >= REPLEN) + return (FALSE); + st++; + state = 0; + } + break; + case 2: + if (*st >= '0' && *st <= '9') { + num = 10 * num + *st - '0'; + st++; + } else { + if (num >= RE_NMATCH) + return (FALSE); + k = re_match[num].rm_eo - re_match[num].rm_so; + if (j + k >= REPLEN) + return (FALSE); + bcopy(&(clp->l_text[re_match[num].rm_so]), &repstr[j], k); + j += k; + if (*st == '\0') + more = FALSE; + if (*st == '\\') { + st++; + state = 1; + } else { + repstr[j] = *st; + j++; + if (j >= REPLEN) + return (FALSE); + st++; + state = 0; + } + } + break; + } /* end case */ + } /* end while */ + + repstr[j] = '\0'; + + s = lreplace(plen, repstr, f); + + return (s); } @@ -333,48 +344,49 @@ re_doreplace(plen, st, f) * is notified of the change, and TRUE is returned. If the * string isn't found, FALSE is returned. */ -re_forwsrch() { - - register LINE *clp; - register int tbo; - int error, plen; - - clp = curwp->w_dotp; - tbo = curwp->w_doto; - - if (tbo == clp->l_used) - /* Don't start matching off end of line-- must - * move to beginning of next line, unless at end - */ - if (clp != curbp->b_linep) { - clp = lforw(clp); - tbo = 0; - } - +re_forwsrch() +{ - /* Note this loop does not process the last line, but this editor - always makes the last line empty so this is good. - */ + register LINE *clp; + register int tbo; + int error, plen; + + clp = curwp->w_dotp; + tbo = curwp->w_doto; + + if (tbo == clp->l_used) + /* + * Don't start matching off end of line-- must move to + * beginning of next line, unless at end + */ + if (clp != curbp->b_linep) { + clp = lforw(clp); + tbo = 0; + } + /* + * Note this loop does not process the last line, but this editor + * always makes the last line empty so this is good. + */ - while (clp != (curbp->b_linep)) { + while (clp != (curbp->b_linep)) { - re_match[0].rm_so = tbo; - re_match[0].rm_eo = llength(clp); - error = regexec(&re_buff, ltext(clp), RE_NMATCH, re_match, REG_STARTEND); + re_match[0].rm_so = tbo; + re_match[0].rm_eo = llength(clp); + error = regexec(&re_buff, ltext(clp), RE_NMATCH, re_match, REG_STARTEND); - if (error) { - clp = lforw(clp); - tbo = 0; - } else { - curwp->w_doto = re_match[0].rm_eo; - curwp->w_dotp = clp; - curwp->w_flag |= WFMOVE; - return (TRUE); - } + if (error) { + clp = lforw(clp); + tbo = 0; + } else { + curwp->w_doto = re_match[0].rm_eo; + curwp->w_dotp = clp; + curwp->w_flag |= WFMOVE; + return (TRUE); + } - } + } - return(FALSE); + return (FALSE); } @@ -386,59 +398,61 @@ re_forwsrch() { * is notified of the change, and TRUE is returned. If the * string isn't found, FALSE is returned. */ -re_backsrch() { - - register LINE *clp; - register int tbo; - regmatch_t lastmatch; - char m[1]; - - clp = curwp->w_dotp; - tbo = curwp->w_doto; - - /* Start search one position to the left of dot */ - tbo = tbo - 1; - if (tbo < 0) { - /* must move up one line */ - clp = lback(clp); - tbo = llength(clp); - } - - /* Note this loop does not process the last line, but this editor - always makes the last line empty so this is good. - */ - - while (clp != (curbp->b_linep)) { - - re_match[0].rm_so = 0; - re_match[0].rm_eo = llength(clp); - lastmatch.rm_so = -1; - /* Keep searching until we don't match any longer. Assumes a non-match - does not modify the re_match array. We have to do this - character-by-character after the first match since POSIX regexps don't - give you a way to do reverse matches. - */ - while (!regexec(&re_buff, ltext(clp), RE_NMATCH, re_match, REG_STARTEND) && - re_match[0].rm_so < tbo) { - memcpy(&lastmatch, &re_match[0], sizeof(regmatch_t)); - re_match[0].rm_so++; - re_match[0].rm_eo = llength(clp); - } - - if (lastmatch.rm_so == -1) { - clp = lback(clp); - tbo = llength(clp); - } else { - memcpy(&re_match[0], &lastmatch, sizeof(regmatch_t)); - curwp->w_doto = re_match[0].rm_so; - curwp->w_dotp = clp; - curwp->w_flag |= WFMOVE; - return (TRUE); - } - - } - - return(FALSE); +re_backsrch() +{ + + register LINE *clp; + register int tbo; + regmatch_t lastmatch; + char m[1]; + + clp = curwp->w_dotp; + tbo = curwp->w_doto; + + /* Start search one position to the left of dot */ + tbo = tbo - 1; + if (tbo < 0) { + /* must move up one line */ + clp = lback(clp); + tbo = llength(clp); + } + /* + * Note this loop does not process the last line, but this editor + * always makes the last line empty so this is good. + */ + + while (clp != (curbp->b_linep)) { + + re_match[0].rm_so = 0; + re_match[0].rm_eo = llength(clp); + lastmatch.rm_so = -1; + /* + * Keep searching until we don't match any longer. Assumes a + * non-match does not modify the re_match array. We have to + * do this character-by-character after the first match since + * POSIX regexps don't give you a way to do reverse matches. + */ + while (!regexec(&re_buff, ltext(clp), RE_NMATCH, re_match, + REG_STARTEND) && re_match[0].rm_so < tbo) { + memcpy(&lastmatch, &re_match[0], sizeof(regmatch_t)); + re_match[0].rm_so++; + re_match[0].rm_eo = llength(clp); + } + + if (lastmatch.rm_so == -1) { + clp = lback(clp); + tbo = llength(clp); + } else { + memcpy(&re_match[0], &lastmatch, sizeof(regmatch_t)); + curwp->w_doto = re_match[0].rm_so; + curwp->w_dotp = clp; + curwp->w_flag |= WFMOVE; + return (TRUE); + } + + } + + return (FALSE); } @@ -451,215 +465,231 @@ re_backsrch() { * Display the old pattern, in the style of Jeff Lomicka. There is * some do-it-yourself control expansion. */ -re_readpattern(prompt) char *prompt; { - int s; - int flags; - int error; - char tpat[NPAT]; - static int dofree = 0; +re_readpattern(prompt) + char *prompt; +{ + int s; + int flags; + int error; + char tpat[NPAT]; + static int dofree = 0; - if (re_pat[0] == '\0') s = ereply("%s: ", tpat, NPAT, prompt); - else s = ereply("%s: (default %s) ", tpat, NPAT, prompt, re_pat); + if (re_pat[0] == '\0') + s = ereply("%s: ", tpat, NPAT, prompt); + else + s = ereply("%s: (default %s) ", tpat, NPAT, prompt, re_pat); if (s == TRUE) { - /* New pattern given */ - (VOID) strcpy(re_pat, tpat); - if (casefoldsearch) - flags = REG_EXTENDED|REG_ICASE; - else - flags = REG_EXTENDED; - if (dofree) - regfree(&re_buff); - error = regcomp(&re_buff, re_pat, flags); - if (error) { - char message[256]; - regerror(error, &re_buff, message, sizeof(message)); - ewprintf("Regex Error: %s", message); - re_pat[0] = '\0'; - return(FALSE); - } - dofree = 1; - } - else if (s==FALSE && re_pat[0]!='\0') - /* Just using old pattern */ - s = TRUE; + /* New pattern given */ + (VOID) strcpy(re_pat, tpat); + if (casefoldsearch) + flags = REG_EXTENDED | REG_ICASE; + else + flags = REG_EXTENDED; + if (dofree) + regfree(&re_buff); + error = regcomp(&re_buff, re_pat, flags); + if (error) { + char message[256]; + regerror(error, &re_buff, message, sizeof(message)); + ewprintf("Regex Error: %s", message); + re_pat[0] = '\0'; + return (FALSE); + } + dofree = 1; + } else if (s == FALSE && re_pat[0] != '\0') + /* Just using old pattern */ + s = TRUE; return (s); } -/* Cause case to not matter in searches. This is the default. If - * called with argument cause case to matter. +/* + * Cause case to not matter in searches. This is the default. If called + * with argument cause case to matter. */ -setcasefold(f, n) { +setcasefold(f, n) +{ - if (f & FFARG) { - casefoldsearch = FALSE; - ewprintf("Case-fold-search unset"); - } - else { - casefoldsearch = TRUE; - ewprintf("Case-fold-search set"); - } + if (f & FFARG) { + casefoldsearch = FALSE; + ewprintf("Case-fold-search unset"); + } else { + casefoldsearch = TRUE; + ewprintf("Case-fold-search set"); + } - /* Invalidate the regular expression pattern since I'm too lazy - * to recompile it. - */ + /* + * Invalidate the regular expression pattern since I'm too lazy to + * recompile it. + */ - re_pat[0] = '\0'; + re_pat[0] = '\0'; - return(TRUE); + return (TRUE); -} /* end setcasefold */ +} /* end setcasefold */ -/* Delete all lines after dot that contain a string matching regex +/* + * Delete all lines after dot that contain a string matching regex */ -delmatchlines(f, n) { - int s; +delmatchlines(f, n) +{ + int s; - if ((s=re_readpattern("Flush lines (containing match for regexp)")) != TRUE) - return (s); + if ((s = re_readpattern("Flush lines (containing match for regexp)")) != TRUE) + return (s); - s = killmatches(TRUE); + s = killmatches(TRUE); - return(s); + return (s); } -/* Delete all lines after dot that don't contain a string matching regex +/* + * Delete all lines after dot that don't contain a string matching regex */ -delnonmatchlines(f, n) { - int s; +delnonmatchlines(f, n) +{ + int s; - if ((s=re_readpattern("Keep lines (containing match for regexp)")) != TRUE) - return (s); + if ((s = re_readpattern("Keep lines (containing match for regexp)")) != TRUE) + return (s); - s = killmatches(FALSE); + s = killmatches(FALSE); - return(s); + return (s); } /* This function does the work of deleting matching lines */ killmatches(cond) - int cond; + int cond; { - int s, error; - int count = 0; - LINE *clp; - - clp = curwp->w_dotp; - if (curwp->w_doto == llength(clp)) - /* Consider dot on next line */ - clp = lforw(clp); - - while (clp != (curbp->b_linep)) { - - /* see if line matches */ - re_match[0].rm_so = 0; - re_match[0].rm_eo = llength(clp); - error = regexec(&re_buff, ltext(clp), RE_NMATCH, re_match, REG_STARTEND); - - /* Delete line when appropriate */ - if ((cond == FALSE && error) || (cond == TRUE && !error)) { - curwp->w_doto = 0; - curwp->w_dotp = clp; - count++; - s = ldelete(llength(clp)+1, KNONE); - clp = curwp->w_dotp; - curwp->w_flag |= WFMOVE; - if (s == FALSE) return(FALSE); - } - else - clp = lforw(clp); - } - - ewprintf("%d line(s) deleted", count); - if (count > 0) curwp->w_flag |= WFMOVE; - - return(TRUE); + int s, error; + int count = 0; + LINE *clp; + + clp = curwp->w_dotp; + if (curwp->w_doto == llength(clp)) + /* Consider dot on next line */ + clp = lforw(clp); + + while (clp != (curbp->b_linep)) { + + /* see if line matches */ + re_match[0].rm_so = 0; + re_match[0].rm_eo = llength(clp); + error = regexec(&re_buff, ltext(clp), RE_NMATCH, re_match, REG_STARTEND); + + /* Delete line when appropriate */ + if ((cond == FALSE && error) || (cond == TRUE && !error)) { + curwp->w_doto = 0; + curwp->w_dotp = clp; + count++; + s = ldelete(llength(clp) + 1, KNONE); + clp = curwp->w_dotp; + curwp->w_flag |= WFMOVE; + if (s == FALSE) + return (FALSE); + } else + clp = lforw(clp); + } + + ewprintf("%d line(s) deleted", count); + if (count > 0) + curwp->w_flag |= WFMOVE; + + return (TRUE); } -petersfunc(f, n) { +petersfunc(f, n) +{ - int s; - LINE *clp; - char c; + int s; + LINE *clp; + char c; - curwp->w_doto = 0; - s = ldelete(llength(curwp->w_dotp)+1, KNONE); - curwp->w_flag |= WFMOVE; - return(s); + curwp->w_doto = 0; + s = ldelete(llength(curwp->w_dotp) + 1, KNONE); + curwp->w_flag |= WFMOVE; + return (s); } -/* Count lines matching regex +/* + * Count lines matching regex */ -cntmatchlines(f, n) { - int s; +cntmatchlines(f, n) +{ + int s; - if ((s=re_readpattern("Count lines (matching regexp)")) != TRUE) - return (s); + if ((s = re_readpattern("Count lines (matching regexp)")) != TRUE) + return (s); - s = countmatches(TRUE); + s = countmatches(TRUE); - return(s); + return (s); } -/* Count lines that fail to match regex +/* + * Count lines that fail to match regex */ -cntnonmatchlines(f, n) { - int s; +cntnonmatchlines(f, n) +{ + int s; - if ((s=re_readpattern("Count lines (not matching regexp)")) != TRUE) - return (s); + if ((s = re_readpattern("Count lines (not matching regexp)")) != TRUE) + return (s); - s = countmatches(FALSE); + s = countmatches(FALSE); - return(s); + return (s); } /* This function does the work of counting matching lines */ countmatches(cond) - int cond; + int cond; { - int s, error; - int count = 0; - LINE *clp; - - clp = curwp->w_dotp; - if (curwp->w_doto == llength(clp)) - /* Consider dot on next line */ - clp = lforw(clp); - - while (clp != (curbp->b_linep)) { - - /* see if line matches */ - re_match[0].rm_so = 0; - re_match[0].rm_eo = llength(clp); - error = regexec(&re_buff, ltext(clp), RE_NMATCH, re_match, REG_STARTEND); - - /* Count line when appropriate */ - if ((cond == FALSE && error) || (cond == TRUE && !error)) count++; - clp = lforw(clp); - } + int s, error; + int count = 0; + LINE *clp; + + clp = curwp->w_dotp; + if (curwp->w_doto == llength(clp)) + /* Consider dot on next line */ + clp = lforw(clp); + + while (clp != (curbp->b_linep)) { + + /* see if line matches */ + re_match[0].rm_so = 0; + re_match[0].rm_eo = llength(clp); + error = regexec(&re_buff, ltext(clp), RE_NMATCH, re_match, REG_STARTEND); + + /* Count line when appropriate */ + if ((cond == FALSE && error) || (cond == TRUE && !error)) + count++; + clp = lforw(clp); + } - if (cond) - ewprintf("Number of lines matching: %d", count); - else - ewprintf("Number of lines not matching: %d", count); + if (cond) + ewprintf("Number of lines matching: %d", count); + else + ewprintf("Number of lines not matching: %d", count); - return(TRUE); + return (TRUE); } #endif diff --git a/usr.bin/mg/region.c b/usr.bin/mg/region.c index 8112296f81a..0c3395150c0 100644 --- a/usr.bin/mg/region.c +++ b/usr.bin/mg/region.c @@ -13,17 +13,17 @@ * to figure out the bounds of the region. * Move "." to the start, and kill the characters. */ -/*ARGSUSED*/ +/* ARGSUSED */ killregion(f, n) { - register int s; - REGION region; + register int s; + REGION region; - if ((s=getregion(®ion)) != TRUE) + if ((s = getregion(®ion)) != TRUE) return (s); - if ((lastflag&CFKILL) == 0) /* This is a kill type */ - kdelete(); /* command, so do magic */ - thisflag |= CFKILL; /* kill buffer stuff. */ + if ((lastflag & CFKILL) == 0) /* This is a kill type */ + kdelete(); /* command, so do magic */ + thisflag |= CFKILL; /* kill buffer stuff. */ curwp->w_dotp = region.r_linep; curwp->w_doto = region.r_offset; return (ldelete(region.r_size, KFORW)); @@ -35,30 +35,30 @@ killregion(f, n) * at all. This is a bit like a kill region followed * by a yank. */ -/*ARGSUSED*/ +/* ARGSUSED */ copyregion(f, n) { - register LINE *linep; - register int loffs; - register int s; - REGION region; - VOID kdelete(); + register LINE *linep; + register int loffs; + register int s; + REGION region; + VOID kdelete(); - if ((s=getregion(®ion)) != TRUE) + if ((s = getregion(®ion)) != TRUE) return s; - if ((lastflag&CFKILL) == 0) /* Kill type command. */ + if ((lastflag & CFKILL) == 0) /* Kill type command. */ kdelete(); thisflag |= CFKILL; - linep = region.r_linep; /* Current line. */ - loffs = region.r_offset; /* Current offset. */ + linep = region.r_linep; /* Current line. */ + loffs = region.r_offset;/* Current offset. */ while (region.r_size--) { - if (loffs == llength(linep)) { /* End of line. */ - if ((s=kinsert('\n', KFORW)) != TRUE) + if (loffs == llength(linep)) { /* End of line. */ + if ((s = kinsert('\n', KFORW)) != TRUE) return (s); linep = lforw(linep); loffs = 0; - } else { /* Middle of line. */ - if ((s=kinsert(lgetc(linep, loffs), KFORW)) != TRUE) + } else { /* Middle of line. */ + if ((s = kinsert(lgetc(linep, loffs), KFORW)) != TRUE) return s; ++loffs; } @@ -73,16 +73,16 @@ copyregion(f, n) * doing the changes. Call "lchange" to ensure that * redisplay is done in all buffers. */ -/*ARGSUSED*/ +/* ARGSUSED */ lowerregion(f, n) { - register LINE *linep; - register int loffs; - register int c; - register int s; - REGION region; + register LINE *linep; + register int loffs; + register int c; + register int s; + REGION region; - if ((s=getregion(®ion)) != TRUE) + if ((s = getregion(®ion)) != TRUE) return s; lchange(WFHARD); linep = region.r_linep; @@ -108,17 +108,17 @@ lowerregion(f, n) * doing the changes. Call "lchange" to ensure that * redisplay is done in all buffers. */ -/*ARGSUSED*/ +/* ARGSUSED */ upperregion(f, n) { - register LINE *linep; - register int loffs; - register int c; - register int s; - REGION region; - VOID lchange(); + register LINE *linep; + register int loffs; + register int c; + register int s; + REGION region; + VOID lchange(); - if ((s=getregion(®ion)) != TRUE) + if ((s = getregion(®ion)) != TRUE) return s; lchange(WFHARD); linep = region.r_linep; @@ -150,60 +150,65 @@ upperregion(f, n) * get an ABORT status, because I might add a "if regions is big, * ask before clobberring" flag. */ -getregion(rp) register REGION *rp; { - register LINE *flp; - register LINE *blp; - register long fsize; /* Long now. */ - register long bsize; +getregion(rp) + register REGION *rp; +{ + register LINE *flp; + register LINE *blp; + register long fsize; /* Long now. */ + register long bsize; if (curwp->w_markp == NULL) { ewprintf("No mark set in this window"); return (FALSE); } - if (curwp->w_dotp == curwp->w_markp) { /* "r_size" always ok. */ + if (curwp->w_dotp == curwp->w_markp) { /* "r_size" always ok. */ rp->r_linep = curwp->w_dotp; if (curwp->w_doto < curwp->w_marko) { rp->r_offset = curwp->w_doto; - rp->r_size = (RSIZE) (curwp->w_marko-curwp->w_doto); + rp->r_size = (RSIZE) (curwp->w_marko - curwp->w_doto); } else { rp->r_offset = curwp->w_marko; - rp->r_size = (RSIZE) (curwp->w_doto-curwp->w_marko); + rp->r_size = (RSIZE) (curwp->w_doto - curwp->w_marko); } return TRUE; } - flp = blp = curwp->w_dotp; /* Get region size. */ + flp = blp = curwp->w_dotp; /* Get region size. */ bsize = curwp->w_doto; - fsize = llength(flp)-curwp->w_doto+1; - while (lforw(flp)!=curbp->b_linep || lback(blp)!=curbp->b_linep) { + fsize = llength(flp) - curwp->w_doto + 1; + while (lforw(flp) != curbp->b_linep || lback(blp) != curbp->b_linep) { if (lforw(flp) != curbp->b_linep) { flp = lforw(flp); if (flp == curwp->w_markp) { rp->r_linep = curwp->w_dotp; rp->r_offset = curwp->w_doto; return (setsize(rp, - (RSIZE) (fsize+curwp->w_marko))); + (RSIZE) (fsize + curwp->w_marko))); } - fsize += llength(flp)+1; + fsize += llength(flp) + 1; } if (lback(blp) != curbp->b_linep) { blp = lback(blp); - bsize += llength(blp)+1; + bsize += llength(blp) + 1; if (blp == curwp->w_markp) { rp->r_linep = blp; rp->r_offset = curwp->w_marko; return (setsize(rp, - (RSIZE) (bsize-curwp->w_marko))); + (RSIZE) (bsize - curwp->w_marko))); } } } - ewprintf("Bug: lost mark"); /* Gak! */ + ewprintf("Bug: lost mark"); /* Gak! */ return FALSE; } /* * Set size, and check for overflow. */ -setsize(rp, size) register REGION *rp; register RSIZE size; { +setsize(rp, size) + register REGION *rp; + register RSIZE size; +{ rp->r_size = size; if (rp->r_size != size) { @@ -223,7 +228,7 @@ setsize(rp, size) register REGION *rp; register RSIZE size; { */ #define PREFIXLENGTH 40 -static char prefix_string[PREFIXLENGTH] = { '>', '\0' }; +static char prefix_string[PREFIXLENGTH] = {'>', '\0'}; /* * Prefix the region with whatever is in prefix_string. @@ -232,14 +237,14 @@ static char prefix_string[PREFIXLENGTH] = { '>', '\0' }; * line prefix string. */ -/*ARGSUSED*/ +/* ARGSUSED */ prefixregion(f, n) { - register int s; - register LINE *first, *last; - register int nline; - REGION region; - char *prefix = prefix_string; + register int s; + register LINE *first, *last; + register int nline; + REGION region; + char *prefix = prefix_string; if ((f == TRUE) && ((s = setprefix(FFRAND, 1)) != TRUE)) return s; @@ -252,7 +257,7 @@ prefixregion(f, n) for (nline = 1; first != last; nline++) first = lforw(first); - /*move to beginning of region */ + /* move to beginning of region */ curwp->w_dotp = region.r_linep; curwp->w_doto = region.r_offset; @@ -271,20 +276,20 @@ prefixregion(f, n) * Set prefix string. */ -/*ARGSUSED*/ +/* ARGSUSED */ setprefix(f, n) { - char buf[PREFIXLENGTH]; - register int s; + char buf[PREFIXLENGTH]; + register int s; if (prefix_string[0] == '\0') - s = ereply("Prefix string: ",buf,sizeof buf); + s = ereply("Prefix string: ", buf, sizeof buf); else s = ereply("Prefix string (default %s): ", - buf,sizeof buf,prefix_string); + buf, sizeof buf, prefix_string); if (s == TRUE) (VOID) strcpy(prefix_string, buf); - if ((s == FALSE) && (prefix_string[0] != '\0')) /* CR -- use old one */ + if ((s == FALSE) && (prefix_string[0] != '\0')) /* CR -- use old one */ s = TRUE; return s; } diff --git a/usr.bin/mg/search.c b/usr.bin/mg/search.c index 3d127ce1f02..ac384539222 100644 --- a/usr.bin/mg/search.c +++ b/usr.bin/mg/search.c @@ -13,33 +13,33 @@ #include "macro.h" #endif -#define SRCH_BEGIN (0) /* Search sub-codes. */ +#define SRCH_BEGIN (0) /* Search sub-codes. */ #define SRCH_FORW (-1) #define SRCH_BACK (-2) #define SRCH_NOPR (-3) #define SRCH_ACCM (-4) #define SRCH_MARK (-5) -typedef struct { - int s_code; - LINE *s_dotp; - int s_doto; -} SRCHCOM; +typedef struct { + int s_code; + LINE *s_dotp; + int s_doto; +} SRCHCOM; -static SRCHCOM cmds[NSRCH]; -static int cip; +static SRCHCOM cmds[NSRCH]; +static int cip; -int srch_lastdir = SRCH_NOPR; /* Last search flags. */ +int srch_lastdir = SRCH_NOPR; /* Last search flags. */ -static VOID is_cpush(); -static VOID is_lpush(); -static VOID is_pop(); -static int is_peek(); -static VOID is_undo(); -static int is_find(); -static VOID is_prompt(); -static VOID is_dspl(); -static int eq(); +static VOID is_cpush(); +static VOID is_lpush(); +static VOID is_pop(); +static int is_peek(); +static VOID is_undo(); +static int is_find(); +static VOID is_prompt(); +static VOID is_dspl(); +static int eq(); /* * Search forward. @@ -48,12 +48,12 @@ static int eq(); * matched characters, and display does all the hard stuff. * If not found, it just prints a message. */ -/*ARGSUSED*/ +/* ARGSUSED */ forwsearch(f, n) { - register int s; + register int s; - if ((s=readpattern("Search")) != TRUE) + if ((s = readpattern("Search")) != TRUE) return s; if (forwsrch() == FALSE) { ewprintf("Search failed: \"%s\"", pat); @@ -70,12 +70,12 @@ forwsearch(f, n) * pointing at the first character of the pattern [the last character that * was matched]. */ -/*ARGSUSED*/ +/* ARGSUSED */ backsearch(f, n) { - register int s; + register int s; - if ((s=readpattern("Search backward")) != TRUE) + if ((s = readpattern("Search backward")) != TRUE) return (s); if (backsrch() == FALSE) { ewprintf("Search failed: \"%s\"", pat); @@ -91,7 +91,7 @@ backsearch(f, n) * has been saved in "srch_lastdir", so you know which way * to go. */ -/*ARGSUSED*/ +/* ARGSUSED */ searchagain(f, n) { if (srch_lastdir == SRCH_FORW) { @@ -116,7 +116,7 @@ searchagain(f, n) * Use incremental searching, initially in the forward direction. * isearch ignores any explicit arguments. */ -/*ARGSUSED*/ +/* ARGSUSED */ forwisearch(f, n) { return isearch(SRCH_FORW); @@ -126,7 +126,7 @@ forwisearch(f, n) * Use incremental searching, initially in the reverse direction. * isearch ignores any explicit arguments. */ -/*ARGSUSED*/ +/* ARGSUSED */ backisearch(f, n) { return isearch(SRCH_BACK); @@ -143,22 +143,23 @@ backisearch(f, n) * other ^ exit search, don't set mark * else accumulate into search string */ -isearch(dir) { - register int c; - register LINE *clp; - register int cbo; - register int success; - int pptr; - char opat[NPAT]; - VOID ungetkey(); +isearch(dir) +{ + register int c; + register LINE *clp; + register int cbo; + register int success; + int pptr; + char opat[NPAT]; + VOID ungetkey(); #ifndef NO_MACRO - if(macrodef) { - ewprintf("Can't isearch in macro"); - return FALSE; + if (macrodef) { + ewprintf("Can't isearch in macro"); + return FALSE; } #endif - for (cip=0; cipw_marko = cbo; ewprintf("Mark set"); curwp->w_flag |= WFMOVE; - return TRUE; + return TRUE; } /* and continue */ case CCHR('I'): case CCHR('J'): - addchar: + addchar: if (pptr == -1) pptr = 0; if (pptr == 0) @@ -289,21 +293,24 @@ isearch(dir) { is_prompt(dir, FALSE, success); } } - /*NOTREACHED*/ + /* NOTREACHED */ } -static VOID -is_cpush(cmd) register int cmd; { +static VOID +is_cpush(cmd) + register int cmd; +{ if (++cip >= NSRCH) cip = 0; cmds[cip].s_code = cmd; } -static VOID -is_lpush() { - register int ctp; +static VOID +is_lpush() +{ + register int ctp; - ctp = cip+1; + ctp = cip + 1; if (ctp >= NSRCH) ctp = 0; cmds[ctp].s_code = SRCH_NOPR; @@ -311,27 +318,32 @@ is_lpush() { cmds[ctp].s_dotp = curwp->w_dotp; } -static VOID -is_pop() { +static VOID +is_pop() +{ if (cmds[cip].s_code != SRCH_NOPR) { - curwp->w_doto = cmds[cip].s_doto; - curwp->w_dotp = cmds[cip].s_dotp; + curwp->w_doto = cmds[cip].s_doto; + curwp->w_dotp = cmds[cip].s_dotp; curwp->w_flag |= WFMOVE; cmds[cip].s_code = SRCH_NOPR; } if (--cip <= 0) - cip = NSRCH-1; + cip = NSRCH - 1; } static int -is_peek() { +is_peek() +{ return cmds[cip].s_code; } /* this used to always return TRUE (the return value was checked) */ -static VOID -is_undo(pptr, dir) register int *pptr; register int *dir; { - register int redo = FALSE ; +static VOID +is_undo(pptr, dir) + register int *pptr; + register int *dir; +{ + register int redo = FALSE; switch (cmds[cip].s_code) { case SRCH_BEGIN: case SRCH_NOPR: @@ -358,19 +370,22 @@ is_undo(pptr, dir) register int *pptr; register int *dir; { break; } is_pop(); - if (redo) is_undo(pptr, dir); + if (redo) + is_undo(pptr, dir); } static int -is_find(dir) register int dir; { - register int plen, odoto; - register LINE *odotp ; +is_find(dir) + register int dir; +{ + register int plen, odoto; + register LINE *odotp; odoto = curwp->w_doto; odotp = curwp->w_dotp; plen = strlen(pat); if (plen != 0) { - if (dir==SRCH_FORW) { + if (dir == SRCH_FORW) { (VOID) backchar(FFARG | FFRAND, plen); if (forwsrch() == FALSE) { curwp->w_doto = odoto; @@ -379,7 +394,7 @@ is_find(dir) register int dir; { } return TRUE; } - if (dir==SRCH_BACK) { + if (dir == SRCH_BACK) { (VOID) forwchar(FFARG | FFRAND, plen); if (backsrch() == FALSE) { curwp->w_doto = odoto; @@ -402,8 +417,9 @@ is_find(dir) register int dir; { * of the callers looked at the status, so I just * made the checking vanish. */ -static VOID -is_prompt(dir, flag, success) { +static VOID +is_prompt(dir, flag, success) +{ if (dir == SRCH_FORW) { if (success != FALSE) is_dspl("I-search", flag); @@ -414,7 +430,8 @@ is_prompt(dir, flag, success) { is_dspl("I-search backward", flag); else is_dspl("Failing I-search backward", flag); - } else ewprintf("Broken call to is_prompt"); + } else + ewprintf("Broken call to is_prompt"); } /* @@ -422,8 +439,10 @@ is_prompt(dir, flag, success) { * The "prompt" is just a string. The "flag" determines * whether pat should be printed. */ -static VOID -is_dspl(prompt, flag) char *prompt; { +static VOID +is_dspl(prompt, flag) + char *prompt; +{ if (flag != FALSE) ewprintf("%s: ", prompt); @@ -435,23 +454,23 @@ is_dspl(prompt, flag) char *prompt; { * Query Replace. * Replace strings selectively. Does a search and replace operation. */ -/*ARGSUSED*/ +/* ARGSUSED */ queryrepl(f, n) { - register int s; - register int rcnt = 0; /* Replacements made so far */ - register int plen; /* length of found string */ - char news[NPAT]; /* replacement string */ + register int s; + register int rcnt = 0; /* Replacements made so far */ + register int plen; /* length of found string */ + char news[NPAT]; /* replacement string */ #ifndef NO_MACRO - if(macrodef) { - ewprintf("Can't query replace in macro"); - return FALSE; + if (macrodef) { + ewprintf("Can't query replace in macro"); + return FALSE; } #endif - if ((s=readpattern("Query replace")) != TRUE) + if ((s = readpattern("Query replace")) != TRUE) return (s); - if ((s=ereply("Query replace %s with: ",news, NPAT, pat)) == ABORT) + if ((s = ereply("Query replace %s with: ", news, NPAT, pat)) == ABORT) return (s); if (s == FALSE) news[0] = '\0'; @@ -465,7 +484,7 @@ queryrepl(f, n) */ while (forwsrch() == TRUE) { - retry: +retry: update(); switch (getkey(FALSE)) { case ' ': @@ -480,7 +499,7 @@ queryrepl(f, n) rcnt++; goto stopsearch; - case CCHR('G'): /* ^G or ESC */ + case CCHR('G'):/* ^G or ESC */ (VOID) ctrlg(FFRAND, 0); case CCHR('['): goto stopsearch; @@ -494,11 +513,11 @@ queryrepl(f, n) goto stopsearch; case CCHR('H'): - case CCHR('?'): /* To not replace */ + case CCHR('?'):/* To not replace */ break; default: -ewprintf(" replace, [.] rep-end, don't, [!] repl rest quit"); + ewprintf(" replace, [.] rep-end, don't, [!] repl rest quit"); goto retry; } } @@ -521,19 +540,21 @@ stopsearch: * is notified of the change, and TRUE is returned. If the * string isn't found, FALSE is returned. */ -forwsrch() { - register LINE *clp; - register int cbo; - register LINE *tlp; - register int tbo; - char *pp; - register int c; +forwsrch() +{ + register LINE *clp; + register int cbo; + register LINE *tlp; + register int tbo; + char *pp; + register int c; clp = curwp->w_dotp; cbo = curwp->w_doto; - for(;;) { + for (;;) { if (cbo == llength(clp)) { - if((clp = lforw(clp)) == curbp->b_linep) break; + if ((clp = lforw(clp)) == curbp->b_linep) + break; cbo = 0; c = CCHR('J'); } else @@ -541,7 +562,7 @@ forwsrch() { if (eq(c, pat[0]) != FALSE) { tlp = clp; tbo = cbo; - pp = &pat[1]; + pp = &pat[1]; while (*pp != 0) { if (tbo == llength(tlp)) { tlp = lforw(tlp); @@ -554,12 +575,12 @@ forwsrch() { if (eq(c, *pp++) == FALSE) goto fail; } - curwp->w_dotp = tlp; - curwp->w_doto = tbo; + curwp->w_dotp = tlp; + curwp->w_doto = tbo; curwp->w_flag |= WFMOVE; return TRUE; } - fail: ; +fail: ; } return FALSE; } @@ -571,17 +592,17 @@ forwsrch() { * is notified of the change, and TRUE is returned. If the * string isn't found, FALSE is returned. */ -backsrch() { - register LINE *clp; - register int cbo; - register LINE *tlp; - register int tbo; - register int c; - register char *epp; - register char *pp; - - for (epp = &pat[0]; epp[1] != 0; ++epp) - ; +backsrch() +{ + register LINE *clp; + register int cbo; + register LINE *tlp; + register int tbo; + register int c; + register char *epp; + register char *pp; + + for (epp = &pat[0]; epp[1] != 0; ++epp); clp = curwp->w_dotp; cbo = curwp->w_doto; for (;;) { @@ -589,38 +610,38 @@ backsrch() { clp = lback(clp); if (clp == curbp->b_linep) return FALSE; - cbo = llength(clp)+1; + cbo = llength(clp) + 1; } if (--cbo == llength(clp)) c = CCHR('J'); else - c = lgetc(clp,cbo); + c = lgetc(clp, cbo); if (eq(c, *epp) != FALSE) { tlp = clp; tbo = cbo; - pp = epp; + pp = epp; while (pp != &pat[0]) { if (tbo == 0) { tlp = lback(tlp); if (tlp == curbp->b_linep) goto fail; - tbo = llength(tlp)+1; + tbo = llength(tlp) + 1; } if (--tbo == llength(tlp)) c = CCHR('J'); else - c = lgetc(tlp,tbo); + c = lgetc(tlp, tbo); if (eq(c, *--pp) == FALSE) goto fail; } - curwp->w_dotp = tlp; - curwp->w_doto = tbo; + curwp->w_dotp = tlp; + curwp->w_doto = tbo; curwp->w_flag |= WFMOVE; return TRUE; } - fail: ; +fail: ; } - /*NOTREACHED*/ + /* NOTREACHED */ } /* @@ -631,13 +652,16 @@ backsrch() { */ static int eq(bc, pc) -register int bc, pc; + register int bc, pc; { bc = CHARMASK(bc); pc = CHARMASK(pc); - if (bc == pc) return TRUE; - if (ISUPPER(bc)) return TOLOWER(bc) == pc; - if (ISUPPER(pc)) return bc == TOLOWER(pc); + if (bc == pc) + return TRUE; + if (ISUPPER(bc)) + return TOLOWER(bc) == pc; + if (ISUPPER(pc)) + return bc == TOLOWER(pc); return FALSE; } @@ -649,16 +673,20 @@ register int bc, pc; * Display the old pattern, in the style of Jeff Lomicka. There is * some do-it-yourself control expansion. */ -readpattern(prompt) char *prompt; { - register int s; - char tpat[NPAT]; +readpattern(prompt) + char *prompt; +{ + register int s; + char tpat[NPAT]; - if (tpat[0] == '\0') s = ereply("%s: ", tpat, NPAT, prompt); - else s = ereply("%s: (default %s) ", tpat, NPAT, prompt, pat); + if (tpat[0] == '\0') + s = ereply("%s: ", tpat, NPAT, prompt); + else + s = ereply("%s: (default %s) ", tpat, NPAT, prompt, pat); - if (s == TRUE) /* Specified */ + if (s == TRUE) /* Specified */ (VOID) strcpy(pat, tpat); - else if (s==FALSE && pat[0]!=0) /* CR, but old one */ + else if (s == FALSE && pat[0] != 0) /* CR, but old one */ s = TRUE; return s; } diff --git a/usr.bin/mg/spawn.c b/usr.bin/mg/spawn.c index 800592d68bc..e8708064522 100644 --- a/usr.bin/mg/spawn.c +++ b/usr.bin/mg/spawn.c @@ -6,6 +6,7 @@ #include #include +#include /* * This causes mg to send itself a stop signal. diff --git a/usr.bin/mg/sysdef.h b/usr.bin/mg/sysdef.h index b2964fbc179..794d15d1d41 100644 --- a/usr.bin/mg/sysdef.h +++ b/usr.bin/mg/sysdef.h @@ -6,13 +6,13 @@ #include #include -#define KBLOCK 8192 /* Kill grow. */ -#define GOOD 0 /* Good exit status. */ -#define SYMBLINK 1 /* Handle symbolic links */ -#define MAXPATH PATH_MAX /* Maximum length of path for chdir */ +#define KBLOCK 8192 /* Kill grow. */ +#define GOOD 0 /* Good exit status. */ +#define SYMBLINK 1 /* Handle symbolic links */ +#define MAXPATH PATH_MAX /* Maximum length of path for chdir */ -typedef int RSIZE; /* Type for file/region sizes */ -typedef short KCHAR; /* Type for internal keystrokes */ +typedef int RSIZE; /* Type for file/region sizes */ +typedef short KCHAR; /* Type for internal keystrokes */ /* * Macros used by the buffer name making code. @@ -22,15 +22,15 @@ typedef short KCHAR; /* Type for internal keystrokes */ * stops at end of string (or at the next BDC3 character, * if defined). BDC2 and BDC3 are mainly for VMS. */ -#define BDC1 '/' /* Buffer names. */ +#define BDC1 '/' /* Buffer names. */ -#define MALLOCROUND(m) (m+=7,m&=~7) /* round up to 8 byte boundry */ +#define MALLOCROUND(m) (m+=7,m&=~7) /* round up to 8 byte boundry */ -#define fncmp strcmp /* file name comparison */ -#define gettermtype() getenv("TERM") /* determine terminal type */ +#define fncmp strcmp /* file name comparison */ +#define gettermtype() getenv("TERM") /* determine terminal type */ struct fileinfo { - mode_t fi_mode; - uid_t fi_uid; - gid_t short fi_gid; + mode_t fi_mode; + uid_t fi_uid; + gid_t short fi_gid; }; diff --git a/usr.bin/mg/tty.c b/usr.bin/mg/tty.c index 7cf082667bc..e976f608ca7 100644 --- a/usr.bin/mg/tty.c +++ b/usr.bin/mg/tty.c @@ -6,66 +6,65 @@ * this as a reasonable way to allow for widly varying and ever changing * varieties of terminal types. This should be used where practical. */ -/* Known problems: - * If you have a terminal with no clear to end of screen and - * memory of lines below the ones visible on the screen, display - * will be wrong in some cases. I doubt that any such terminal - * was ever made, but I thought everyone with delete line would - * have clear to end of screen too... +/* + * Known problems: If you have a terminal with no clear to end of screen and + * memory of lines below the ones visible on the screen, display will be + * wrong in some cases. I doubt that any such terminal was ever made, but I + * thought everyone with delete line would have clear to end of screen too... * - * Code for terminals without clear to end of screen and/or clear - * to end of line has not been extensivly tested. + * Code for terminals without clear to end of screen and/or clear to end of line + * has not been extensivly tested. * - * Cost calculations are very rough. Costs of insert/delete line - * may be far from the truth. This is accentuated by display.c - * not knowing about multi-line insert/delete. + * Cost calculations are very rough. Costs of insert/delete line may be far + * from the truth. This is accentuated by display.c not knowing about + * multi-line insert/delete. * - * Using scrolling region vs insert/delete line should probably - * be based on cost rather than the assuption that scrolling - * region operations look better. + * Using scrolling region vs insert/delete line should probably be based on cost + * rather than the assuption that scrolling region operations look better. */ #include "def.h" -#include #include -extern int ttrow; -extern int ttcol; -extern int tttop; -extern int ttbot; -extern int tthue; +extern int ttrow; +extern int ttcol; +extern int tttop; +extern int ttbot; +extern int tthue; -extern int ttputc(); +extern int ttputc(); -int tceeol; /* Costs are set later */ -int tcinsl; -int tcdell; +int tceeol; /* Costs are set later */ +int tcinsl; +int tcdell; -static int insdel; /* Do we have both insert & delete line? */ -static char * scroll_fwd; /* How to scroll forward. */ +static int insdel; /* Do we have both insert & delete line? */ +static char *scroll_fwd; /* How to scroll forward. */ #ifdef NO_RESIZE -static setttysize(); +static setttysize(); #endif /* * Initialize the terminal when the editor * gets started up. */ -ttinit() { - char *tv_stype; - char *t, *p; +VOID +ttinit() +{ + char *tv_stype; + char *t, *p; #ifndef gettermtype /* (avoid declaration if #define) */ - char *gettermtype(); /* system dependent function to determin terminal type */ + char *gettermtype(); /* system dependent function to + * determin terminal type */ #endif if ((tv_stype = gettermtype()) == NULL) panic("Could not determine terminal type"); - if (setupterm(tv_stype, 1, NULL) == ERR) { + if (setupterm(tv_stype, 1, NULL)) { (void) asprintf(&p, "Unknown terminal type: %s", tv_stype); panic(p); } - scroll_fwd = scroll_forward; if (!scroll_fwd || !*scroll_fwd) { /* this is what GNU Emacs does */ @@ -73,10 +72,9 @@ ttinit() { if (!scroll_fwd || !*scroll_fwd) scroll_fwd = "\n"; } - if (!cursor_address || !cursor_up) panic("This terminal is to stupid to run mg"); - ttresize(); /* set nrow & ncol */ + ttresize(); /* set nrow & ncol */ if (!clr_eol) tceeol = ncol; @@ -85,8 +83,8 @@ ttinit() { /* Estimate cost of inserting a line */ if (change_scroll_region && scroll_reverse) - tcinsl = charcost(change_scroll_region)*2 + - charcost(scroll_reverse); + tcinsl = charcost(change_scroll_region) * 2 + + charcost(scroll_reverse); else if (parm_insert_line) tcinsl = charcost(parm_insert_line); else if (insert_line) @@ -96,20 +94,20 @@ ttinit() { /* Estimate cost of deleting a line */ if (change_scroll_region) - tcdell = charcost(change_scroll_region)*2 + - charcost(scroll_fwd); + tcdell = charcost(change_scroll_region) * 2 + + charcost(scroll_fwd); else if (parm_delete_line) tcdell = charcost(parm_delete_line); else if (delete_line) tcdell = charcost(delete_line); - else + else tcdell = NROW * NCOL; /* make this cost high enough */ /* Flag to indicate that we can both insert and delete lines */ insdel = (insert_line || parm_insert_line) && (delete_line || parm_delete_line); if (enter_ca_mode) - putpad(enter_ca_mode, 1); /* init the term */ + putpad(enter_ca_mode, 1); /* enter application mode */ setttysize(); } @@ -118,7 +116,9 @@ ttinit() { * Re-initialize the terminal when the editor is resumed. * The keypad_xmit doesn't really belong here but... */ -ttreinit() { +VOID +ttreinit() +{ if (enter_ca_mode) putpad(enter_ca_mode, 1); /* enter application mode */ if (keypad_xmit) @@ -135,14 +135,16 @@ ttreinit() { * query the display for the increment, and put it * back to what it was. */ -tttidy() { +VOID +tttidy() +{ - /* set the term back to normal mode */ - if (exit_ca_mode) - putpad(exit_ca_mode, 1); #ifdef XKEYS ttykeymaptidy(); #endif + /* set the term back to normal mode */ + if (exit_ca_mode) + putpad(exit_ca_mode, 1); } /* @@ -152,25 +154,29 @@ tttidy() { * have left the cursor in the right * location last time! */ -ttmove(row, col) { - char *tgoto(); - - if (ttrow != row || ttcol !=col) { - putpad(tgoto(cursor_address, col, row), 1); - ttrow = row; - ttcol = col; - } +VOID +ttmove(row, col) +{ + char *tgoto(); + + if (ttrow != row || ttcol != col) { + putpad(tgoto(cursor_address, col, row), 1); + ttrow = row; + ttcol = col; + } } /* * Erase to end of line. */ -tteeol() { +VOID +tteeol() +{ if (clr_eol) putpad(clr_eol, 1); else { - int i = ncol - ttcol; + int i = ncol - ttcol; while (i--) ttputc(' '); ttrow = ttcol = HUGE; @@ -180,8 +186,10 @@ tteeol() { /* * Erase to end of page. */ -tteeop() { - int line; +VOID +tteeop() +{ + int line; if (clr_eos) putpad(clr_eos, nrow - ttrow); @@ -202,7 +210,9 @@ tteeop() { /* * Make a noise. */ -ttbeep() { +VOID +ttbeep() +{ putpad(bell, 1); ttflush(); } @@ -215,31 +225,33 @@ ttbeep() { * If no scrolling region, use a set * of insert and delete line sequences */ -ttinsl(row, bot, nchunk) { - int i, nl; +VOID +ttinsl(row, bot, nchunk) +{ + int i, nl; - if (row == bot) { /* Case of one line insert is */ - ttmove(row, 0); /* special */ + if (row == bot) { /* Case of one line insert is */ + ttmove(row, 0); /* special */ tteeol(); return; } if (change_scroll_region && scroll_reverse) { - /* Use scroll region and back index */ + /* Use scroll region and back index */ nl = bot - row; - ttwindow(row,bot); + ttwindow(row, bot); ttmove(row, 0); while (nchunk--) putpad(scroll_reverse, nl); ttnowindow(); return; } else if (insdel) { - ttmove(1+bot-nchunk, 0); + ttmove(1 + bot - nchunk, 0); nl = nrow - ttrow; if (parm_delete_line) putpad(tgoto(parm_delete_line, 0, nchunk), nl); else - /* For all lines in the chunk */ - for (i=0; i lines ? nrow : lines) - 1, 0), nrow - ttrow); - ttrow = HUGE; /* Unknown. */ + (nrow > lines ? nrow : lines) - 1, 0), nrow - ttrow); + ttrow = HUGE; /* Unknown. */ ttcol = HUGE; - tttop = HUGE; /* No scroll region. */ + tttop = HUGE; /* No scroll region. */ ttbot = HUGE; } } @@ -357,16 +371,17 @@ ttnowindow() * line by line basis, so don't bother sending * out the color shift. */ +VOID ttcolor(color) - int color; + int color; { if (color != tthue) { - if (color == CTEXT) /* Normal video. */ - putpad(exit_standout_mode, 1); - else if (color == CMODE) /* Reverse video. */ - putpad(enter_standout_mode, 1); - tthue = color; /* Save the color. */ + if (color == CTEXT) /* Normal video. */ + putpad(exit_standout_mode, 1); + else if (color == CMODE) /* Reverse video. */ + putpad(enter_standout_mode, 1); + tthue = color; /* Save the color. */ } } @@ -379,11 +394,13 @@ ttcolor(color) * with a screen NROW by NCOL. Look in "window.c" to * see how the caller deals with a change. */ -ttresize() { +VOID +ttresize() +{ - setttysize(); /* found in "ttyio.c", */ - /* ask OS for tty size */ - if (nrow < 1) /* Check limits. */ + setttysize(); /* found in "ttyio.c", */ + /* ask OS for tty size */ + if (nrow < 1) /* Check limits. */ nrow = 1; else if (nrow > NROW) nrow = NROW; @@ -394,24 +411,28 @@ ttresize() { } #ifdef NO_RESIZE -static setttysize() { +static +setttysize() +{ nrow = lines; ncol = columns; } #endif -static int cci; +static int cci; -/*ARGSUSED*/ -static int /* fake char output for charcost() */ +/* ARGSUSED */ +static int /* fake char output for charcost() */ fakec(c) -char c; + char c; { cci++; } /* calculate the cost of doing string s */ -charcost (s) char *s; { +charcost(s) + char *s; +{ cci = 0; tputs(s, nrow, fakec); diff --git a/usr.bin/mg/ttydef.h b/usr.bin/mg/ttydef.h index fbbec4ca70e..848fff2f7f4 100644 --- a/usr.bin/mg/ttydef.h +++ b/usr.bin/mg/ttydef.h @@ -1,16 +1,16 @@ /* - * Termcap terminal file, nothing special, just make it big + * Terminfo terminal file, nothing special, just make it big * enough for windowing systems. */ -#define GOSLING /* Compile in fancy display. */ -/* #define MEMMAP */ /* Not memory mapped video. */ +#define GOSLING /* Compile in fancy display. */ +/* #define MEMMAP *//* Not memory mapped video. */ -#define NROW 66 /* (maximum) Rows. */ -#define NCOL 132 /* (maximum) Columns. */ -/* #define MOVE_STANDOUT */ /* don't move in standout mode */ -#define STANDOUT_GLITCH /* possible standout glitch */ -#define TERMCAP /* for possible use in ttyio.c */ +#define NROW 66 /* (maximum) Rows. */ +#define NCOL 132 /* (maximum) Columns. */ +/* #define MOVE_STANDOUT *//* don't move in standout mode */ +#define STANDOUT_GLITCH /* possible standout glitch */ +#define TERMCAP /* for possible use in ttyio.c */ #define getkbd() (ttgetc()) @@ -18,7 +18,6 @@ #define ttykeymapinit() {} #endif -extern int tputs(); #define putpad(str, num) tputs(str, num, ttputc) #define KFIRST K00 diff --git a/usr.bin/mg/ttyio.c b/usr.bin/mg/ttyio.c index 40136b48ab8..8df4fe0dc0e 100644 --- a/usr.bin/mg/ttyio.c +++ b/usr.bin/mg/ttyio.c @@ -28,19 +28,6 @@ struct termios newtty; int nrow; /* Terminal size, rows. */ int ncol; /* Terminal size, columns. */ -/* XXX - move most of these to def.h? */ -void ttopen __P((void)); -int ttraw __P((void)); -void ttclose __P((void)); -int ttcooked __P((void)); -void ttputc __P((int)); -void ttflush __P((void)); -int ttgetc __P((void)); -void setttysize __P((void)); -int typeahead __P((void)); -void panic __P((char *)); -int ttwait __P((void)); - /* * This function gets called once, to set up the terminal. * On systems w/o TCSASOFT we turn off off flow control, @@ -128,7 +115,7 @@ ttcooked() * Write character to the display. Characters are buffered up, * to make things a little bit more efficient. */ -void +int ttputc(c) int c; { @@ -136,6 +123,7 @@ ttputc(c) if (nobuf >= NOBUF) ttflush(); obuf[nobuf++] = c; + return(c); } /* @@ -209,7 +197,7 @@ typeahead() /* * panic - just exit, as quickly as we can. */ -void +VOID panic(s) char *s; { diff --git a/usr.bin/mg/ttykbd.c b/usr.bin/mg/ttykbd.c index f4a16799a34..b10712f5c46 100644 --- a/usr.bin/mg/ttykbd.c +++ b/usr.bin/mg/ttykbd.c @@ -17,7 +17,7 @@ * extend.c. */ -char *keystrings[] = { NULL } ; +char *keystrings[] = {NULL}; #endif /* @@ -25,12 +25,12 @@ char *keystrings[] = { NULL } ; * available. The keys file is located in the same manner as the startup * file is, depending on what startupfile() does on your system. */ -extern int ttputc(); +extern int ttputc(); ttykeymapinit() { - extern int dobindkey(); /* XXX */ - char *cp; + extern int dobindkey(); /* XXX */ + char *cp; #ifdef FKEYS /* Bind keypad function keys. */ if (key_left) @@ -54,13 +54,13 @@ ttykeymapinit() #endif #ifndef NO_STARTUP if (cp = gettermtype()) { - extern char *startupfile(); + extern char *startupfile(); if (((cp = startupfile(cp)) != NULL) - && (load(cp) != TRUE)) + && (load(cp) != TRUE)) ewprintf("Error reading key initialization file"); } #endif - if (keypad_xmit) /* turn on keypad */ + if (keypad_xmit) /* turn on keypad */ putpad(keypad_xmit, 1); } @@ -71,7 +71,7 @@ ttykeymaptidy() { if (keypad_local) - putpad(keypad_local, 1); /* turn off keypad */ + putpad(keypad_local, 1); /* turn off keypad */ } #endif diff --git a/usr.bin/mg/version.c b/usr.bin/mg/version.c index 0f3a9e7562f..846c873e87f 100644 --- a/usr.bin/mg/version.c +++ b/usr.bin/mg/version.c @@ -3,17 +3,18 @@ * out by the emacs-version command. */ -#define TRUE 1 /* include "def.h" when things get more complicated */ +#define TRUE 1 /* include "def.h" when things get more + * complicated */ -char version[] = "Mg 2a (formerly MicroGnuEmacs)"; +char version[] = "Mg 2a"; /* * Display the version. All this does * is copy the version string onto the echo line. */ -/*ARGSUSED*/ +/* ARGSUSED */ showversion(f, n) -int f, n; + int f, n; { ewprintf(version); return TRUE; diff --git a/usr.bin/mg/window.c b/usr.bin/mg/window.c index 18e944fcd0c..e9a9c17f1db 100644 --- a/usr.bin/mg/window.c +++ b/usr.bin/mg/window.c @@ -13,11 +13,11 @@ * If GOSREC is defined, with no argument it defaults to 1 * and works like in Gosling. */ -/*ARGSUSED*/ +/* ARGSUSED */ reposition(f, n) { #ifndef GOSREC - curwp->w_force = (f & FFARG) ? (n>=0 ? n+1 : n) : 0; + curwp->w_force = (f & FFARG) ? (n >= 0 ? n + 1 : n) : 0; #else curwp->w_force = n; #endif @@ -41,25 +41,25 @@ reposition(f, n) * the window bigger again, and send another command, * everything will get fixed! */ -/*ARGSUSED*/ +/* ARGSUSED */ refresh(f, n) { register MGWIN *wp; - register int oldnrow; - register int oldncol; + register int oldnrow; + register int oldncol; oldnrow = nrow; oldncol = ncol; ttresize(); - if (nrow!=oldnrow || ncol!=oldncol) { - wp = wheadp; /* Find last. */ + if (nrow != oldnrow || ncol != oldncol) { + wp = wheadp; /* Find last. */ while (wp->w_wndp != NULL) wp = wp->w_wndp; - if (nrow < wp->w_toprow+3) { /* Check if too small. */ + if (nrow < wp->w_toprow + 3) { /* Check if too small. */ ewprintf("Display unusable"); return (FALSE); } - wp->w_ntrows = nrow-wp->w_toprow-2; + wp->w_ntrows = nrow - wp->w_toprow - 2; sgarbf = TRUE; update(); ewprintf("New size %d by %d", nrow, ncol); @@ -76,12 +76,12 @@ refresh(f, n) * nothing if there is only 1 window on * the screen. */ -/*ARGSUSED*/ +/* ARGSUSED */ nextwind(f, n) { register MGWIN *wp; - if ((wp=curwp->w_wndp) == NULL) + if ((wp = curwp->w_wndp) == NULL) wp = wheadp; curwp = wp; curbp = wp->w_bufp; @@ -97,7 +97,7 @@ nextwind(f, n) * although the command does not do a lot * if there is 1 window. */ -/*ARGSUSED*/ +/* ARGSUSED */ prevwind(f, n) { register MGWIN *wp1; @@ -126,19 +126,19 @@ prevwind(f, n) * distruction of a window makes a buffer * become undisplayed. */ -/*ARGSUSED*/ +/* ARGSUSED */ onlywind(f, n) { register MGWIN *wp; - register LINE *lp; - register int i; + register LINE *lp; + register int i; while (wheadp != curwp) { wp = wheadp; wheadp = wp->w_wndp; if (--wp->w_bufp->b_nwnd == 0) { - wp->w_bufp->b_dotp = wp->w_dotp; - wp->w_bufp->b_doto = wp->w_doto; + wp->w_bufp->b_dotp = wp->w_dotp; + wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; } @@ -148,23 +148,23 @@ onlywind(f, n) wp = curwp->w_wndp; curwp->w_wndp = wp->w_wndp; if (--wp->w_bufp->b_nwnd == 0) { - wp->w_bufp->b_dotp = wp->w_dotp; - wp->w_bufp->b_doto = wp->w_doto; + wp->w_bufp->b_dotp = wp->w_dotp; + wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; } free((char *) wp); } lp = curwp->w_linep; - i = curwp->w_toprow; - while (i!=0 && lback(lp)!=curbp->b_linep) { + i = curwp->w_toprow; + while (i != 0 && lback(lp) != curbp->b_linep) { --i; lp = lback(lp); } curwp->w_toprow = 0; - curwp->w_ntrows = nrow-2; /* 2 = mode, echo. */ - curwp->w_linep = lp; - curwp->w_flag |= WFMODE|WFHARD; + curwp->w_ntrows = nrow - 2; /* 2 = mode, echo. */ + curwp->w_linep = lp; + curwp->w_flag |= WFMODE | WFHARD; return TRUE; } @@ -175,34 +175,34 @@ onlywind(f, n) * a "malloc" failure allocating the structure * for the new window. */ -/*ARGSUSED*/ +/* ARGSUSED */ splitwind(f, n) { register MGWIN *wp; - register LINE *lp; - register int ntru; - register int ntrd; - int ntrl; - MGWIN *wp1, *wp2; + register LINE *lp; + register int ntru; + register int ntrd; + int ntrl; + MGWIN *wp1, *wp2; if (curwp->w_ntrows < 3) { ewprintf("Cannot split a %d line window", curwp->w_ntrows); return (FALSE); } - if ((wp = (MGWIN *)malloc(sizeof(MGWIN))) == NULL) { + if ((wp = (MGWIN *) malloc(sizeof(MGWIN))) == NULL) { ewprintf("Can't get %d", sizeof(MGWIN)); return (FALSE); } - ++curbp->b_nwnd; /* Displayed twice. */ - wp->w_bufp = curbp; - wp->w_dotp = curwp->w_dotp; - wp->w_doto = curwp->w_doto; + ++curbp->b_nwnd; /* Displayed twice. */ + wp->w_bufp = curbp; + wp->w_dotp = curwp->w_dotp; + wp->w_doto = curwp->w_doto; wp->w_markp = curwp->w_markp; wp->w_marko = curwp->w_marko; - wp->w_flag = 0; + wp->w_flag = 0; wp->w_force = 0; - ntru = (curwp->w_ntrows-1) / 2; /* Upper size */ - ntrl = (curwp->w_ntrows-1) - ntru; /* Lower size */ + ntru = (curwp->w_ntrows - 1) / 2; /* Upper size */ + ntrl = (curwp->w_ntrows - 1) - ntru; /* Lower size */ lp = curwp->w_linep; ntrd = 0; while (lp != curwp->w_dotp) { @@ -210,15 +210,15 @@ splitwind(f, n) lp = lforw(lp); } lp = curwp->w_linep; - if (ntrd <= ntru) { /* Old is upper window. */ - if (ntrd == ntru) /* Hit mode line. */ + if (ntrd <= ntru) { /* Old is upper window. */ + if (ntrd == ntru) /* Hit mode line. */ lp = lforw(lp); curwp->w_ntrows = ntru; wp->w_wndp = curwp->w_wndp; curwp->w_wndp = wp; - wp->w_toprow = curwp->w_toprow+ntru+1; + wp->w_toprow = curwp->w_toprow + ntru + 1; wp->w_ntrows = ntrl; - } else { /* Old is lower window */ + } else { /* Old is lower window */ wp1 = NULL; wp2 = wheadp; while (wp2 != curwp) { @@ -229,19 +229,19 @@ splitwind(f, n) wheadp = wp; else wp1->w_wndp = wp; - wp->w_wndp = curwp; + wp->w_wndp = curwp; wp->w_toprow = curwp->w_toprow; wp->w_ntrows = ntru; - ++ntru; /* Mode line. */ + ++ntru; /* Mode line. */ curwp->w_toprow += ntru; - curwp->w_ntrows = ntrl; + curwp->w_ntrows = ntrl; while (ntru--) lp = lforw(lp); } - curwp->w_linep = lp; /* Adjust the top lines */ - wp->w_linep = lp; /* if necessary. */ - curwp->w_flag |= WFMODE|WFHARD; - wp->w_flag |= WFMODE|WFHARD; + curwp->w_linep = lp; /* Adjust the top lines */ + wp->w_linep = lp; /* if necessary. */ + curwp->w_flag |= WFMODE | WFHARD; + wp->w_flag |= WFMODE | WFHARD; return TRUE; } @@ -253,12 +253,12 @@ splitwind(f, n) * hard work. You don't just set "force reframe" * because dot would move. */ -/*ARGSUSED*/ +/* ARGSUSED */ enlargewind(f, n) { register MGWIN *adjwp; - register LINE *lp; - register int i; + register LINE *lp; + register int i; if (n < 0) return shrinkwind(f, -n); @@ -266,7 +266,7 @@ enlargewind(f, n) ewprintf("Only one window"); return FALSE; } - if ((adjwp=curwp->w_wndp) == NULL) { + if ((adjwp = curwp->w_wndp) == NULL) { adjwp = wheadp; while (adjwp->w_wndp != curwp) adjwp = adjwp->w_wndp; @@ -275,23 +275,23 @@ enlargewind(f, n) ewprintf("Impossible change"); return FALSE; } - if (curwp->w_wndp == adjwp) { /* Shrink below. */ + if (curwp->w_wndp == adjwp) { /* Shrink below. */ lp = adjwp->w_linep; - for (i=0; iw_bufp->b_linep; ++i) + for (i = 0; i < n && lp != adjwp->w_bufp->b_linep; ++i) lp = lforw(lp); - adjwp->w_linep = lp; + adjwp->w_linep = lp; adjwp->w_toprow += n; - } else { /* Shrink above. */ + } else { /* Shrink above. */ lp = curwp->w_linep; - for (i=0; ib_linep; ++i) + for (i = 0; i < n && lback(lp) != curbp->b_linep; ++i) lp = lback(lp); - curwp->w_linep = lp; + curwp->w_linep = lp; curwp->w_toprow -= n; } curwp->w_ntrows += n; adjwp->w_ntrows -= n; - curwp->w_flag |= WFMODE|WFHARD; - adjwp->w_flag |= WFMODE|WFHARD; + curwp->w_flag |= WFMODE | WFHARD; + adjwp->w_flag |= WFMODE | WFHARD; return TRUE; } @@ -304,8 +304,8 @@ enlargewind(f, n) shrinkwind(f, n) { register MGWIN *adjwp; - register LINE *lp; - register int i; + register LINE *lp; + register int i; if (n < 0) return enlargewind(f, -n); @@ -317,32 +317,32 @@ shrinkwind(f, n) * Bit of flakiness - KRANDOM means it was an internal call, and * to be trusted implicitly about sizes. */ - if ( !(f & FFRAND) && curwp->w_ntrows <= n) { + if (!(f & FFRAND) && curwp->w_ntrows <= n) { ewprintf("Impossible change"); return (FALSE); } - if ((adjwp=curwp->w_wndp) == NULL) { + if ((adjwp = curwp->w_wndp) == NULL) { adjwp = wheadp; while (adjwp->w_wndp != curwp) adjwp = adjwp->w_wndp; } - if (curwp->w_wndp == adjwp) { /* Grow below. */ + if (curwp->w_wndp == adjwp) { /* Grow below. */ lp = adjwp->w_linep; - for (i=0; iw_bufp->b_linep; ++i) + for (i = 0; i < n && lback(lp) != adjwp->w_bufp->b_linep; ++i) lp = lback(lp); - adjwp->w_linep = lp; + adjwp->w_linep = lp; adjwp->w_toprow -= n; - } else { /* Grow above. */ + } else { /* Grow above. */ lp = curwp->w_linep; - for (i=0; ib_linep; ++i) + for (i = 0; i < n && lp != curbp->b_linep; ++i) lp = lforw(lp); - curwp->w_linep = lp; + curwp->w_linep = lp; curwp->w_toprow += n; } curwp->w_ntrows -= n; adjwp->w_ntrows += n; - curwp->w_flag |= WFMODE|WFHARD; - adjwp->w_flag |= WFMODE|WFHARD; + curwp->w_flag |= WFMODE | WFHARD; + adjwp->w_flag |= WFMODE | WFHARD; return (TRUE); } @@ -350,29 +350,31 @@ shrinkwind(f, n) * Delete current window. Call shrink-window to do the screen * updating, then throw away the window. */ -/*ARGSUSED*/ +/* ARGSUSED */ delwind(f, n) { register MGWIN *wp, *nwp; - wp = curwp; /* Cheap... */ + wp = curwp; /* Cheap... */ /* shrinkwind returning false means only one window... */ if (shrinkwind(FFRAND, wp->w_ntrows + 1) == FALSE) return FALSE; if (--wp->w_bufp->b_nwnd == 0) { - wp->w_bufp->b_dotp = wp->w_dotp; - wp->w_bufp->b_doto = wp->w_doto; + wp->w_bufp->b_dotp = wp->w_dotp; + wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; } /* since shrinkwind did't crap out, we know we have a second window */ - if (wp == wheadp) wheadp = curwp = wp->w_wndp; - else if ((curwp = wp->w_wndp) == NULL) curwp = wheadp; + if (wp == wheadp) + wheadp = curwp = wp->w_wndp; + else if ((curwp = wp->w_wndp) == NULL) + curwp = wheadp; curbp = curwp->w_bufp; for (nwp = wheadp; nwp != NULL; nwp = nwp->w_wndp) if (nwp->w_wndp == wp) { nwp->w_wndp = wp->w_wndp; - break ; + break; } free((char *) wp); return TRUE; @@ -385,15 +387,16 @@ delwind(f, n) * might be better. Return a pointer, or * NULL on error. */ -MGWIN * -wpopup() { +MGWIN * +wpopup() +{ register MGWIN *wp; if (wheadp->w_wndp == NULL - && splitwind(FFRAND, 0) == FALSE) + && splitwind(FFRAND, 0) == FALSE) return NULL; - wp = wheadp; /* Find window to use */ - while (wp!=NULL && wp==curwp) + wp = wheadp; /* Find window to use */ + while (wp != NULL && wp == curwp) wp = wp->w_wndp; return wp; } diff --git a/usr.bin/mg/word.c b/usr.bin/mg/word.c index e06b4cab2a8..859d904f331 100644 --- a/usr.bin/mg/word.c +++ b/usr.bin/mg/word.c @@ -13,10 +13,11 @@ * are performed by the "backchar" and "forwchar" * routines. */ -/*ARGSUSED*/ +/* ARGSUSED */ backword(f, n) { - if (n < 0) return forwword(f | FFRAND, -n); + if (n < 0) + return forwword(f | FFRAND, -n); if (backchar(FFRAND, 1) == FALSE) return FALSE; while (n--) { @@ -37,7 +38,7 @@ backword(f, n) * the specified number of words. All of the * motion is done by "forwchar". */ -/*ARGSUSED*/ +/* ARGSUSED */ forwword(f, n) { if (n < 0) @@ -60,12 +61,13 @@ forwword(f, n) * the specified number of words. As you move, * convert any characters to upper case. */ -/*ARGSUSED*/ +/* ARGSUSED */ upperword(f, n) { - register int c; + register int c; - if (n < 0) return FALSE; + if (n < 0) + return FALSE; while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) @@ -90,12 +92,13 @@ upperword(f, n) * the specified number of words. As you move * convert characters to lower case. */ -/*ARGSUSED*/ +/* ARGSUSED */ lowerword(f, n) { - register int c; + register int c; - if (n < 0) return FALSE; + if (n < 0) + return FALSE; while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) @@ -122,13 +125,14 @@ lowerword(f, n) * case, and subsequent characters to lower case. Error * if you try and move past the end of the buffer. */ -/*ARGSUSED*/ +/* ARGSUSED */ capword(f, n) { - register int c; - VOID lchange(); + register int c; + VOID lchange(); - if (n < 0) return FALSE; + if (n < 0) + return FALSE; while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) @@ -161,16 +165,16 @@ capword(f, n) /* * Kill forward by "n" words. */ -/*ARGSUSED*/ +/* ARGSUSED */ delfword(f, n) { - register RSIZE size; - register LINE *dotp; - register int doto; + register RSIZE size; + register LINE *dotp; + register int doto; if (n < 0) return FALSE; - if ((lastflag&CFKILL) == 0) /* Purge kill buffer. */ + if ((lastflag & CFKILL) == 0) /* Purge kill buffer. */ kdelete(); thisflag |= CFKILL; dotp = curwp->w_dotp; @@ -179,12 +183,12 @@ delfword(f, n) while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) - goto out; /* Hit end of buffer. */ + goto out; /* Hit end of buffer. */ ++size; } while (inword() != FALSE) { if (forwchar(FFRAND, 1) == FALSE) - goto out; /* Hit end of buffer. */ + goto out; /* Hit end of buffer. */ ++size; } } @@ -206,34 +210,35 @@ out: * be wierd. Normally this is bound to "M-Rubout" and * to "M-Backspace". */ -/*ARGSUSED*/ +/* ARGSUSED */ delbword(f, n) { - register RSIZE size; - VOID kdelete(); + register RSIZE size; + VOID kdelete(); - if (n < 0) return FALSE; - if ((lastflag&CFKILL) == 0) /* Purge kill buffer. */ + if (n < 0) + return FALSE; + if ((lastflag & CFKILL) == 0) /* Purge kill buffer. */ kdelete(); thisflag |= CFKILL; if (backchar(FFRAND, 1) == FALSE) - return (TRUE); /* Hit buffer start. */ - size = 1; /* One deleted. */ + return (TRUE); /* Hit buffer start. */ + size = 1; /* One deleted. */ while (n--) { while (inword() == FALSE) { if (backchar(FFRAND, 1) == FALSE) - goto out; /* Hit buffer start. */ + goto out; /* Hit buffer start. */ ++size; } while (inword() != FALSE) { if (backchar(FFRAND, 1) == FALSE) - goto out; /* Hit buffer start. */ + goto out; /* Hit buffer start. */ ++size; } } if (forwchar(FFRAND, 1) == FALSE) return FALSE; - --size; /* Undo assumed delete. */ + --size; /* Undo assumed delete. */ out: return ldelete(size, KBACK); } @@ -244,9 +249,9 @@ out: * part of a word. The word character list is hard * coded. Should be setable. */ -inword() { -/* can't use lgetc in ISWORD due to bug in OSK cpp */ - return curwp->w_doto != llength(curwp->w_dotp) && +inword() +{ + /* can't use lgetc in ISWORD due to bug in OSK cpp */ + return curwp->w_doto != llength(curwp->w_dotp) && ISWORD(curwp->w_dotp->l_text[curwp->w_doto]); } - -- cgit v1.2.3