From 9605cf882670d8647dd8ed1fe05b90e1c1a12461 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Fri, 30 Sep 2005 16:34:11 -0700 Subject: [PATCH] First cut at turning things into proper modern ANSI C Hey! Real declarations! --- basic.c | 71 +++++++------- display.c | 279 +++++++++++++++++++++++++++--------------------------- edef.h | 164 ++++++++++++++++++++++++++++++++ eval.c | 2 +- line.c | 87 ++++++++--------- main.c | 55 ++++++----- random.c | 238 ++++++++++++++++++++++++---------------------- spawn.c | 1 - window.c | 105 ++++++++++---------- word.c | 86 ++++++++--------- 10 files changed, 618 insertions(+), 470 deletions(-) diff --git a/basic.c b/basic.c index 868b95c..96c25e5 100644 --- a/basic.c +++ b/basic.c @@ -18,7 +18,7 @@ * beginning of the current line. * Trivial. */ -gotobol(f, n) +int gotobol(int f, int n) { curwp->w_doto = 0; return (TRUE); @@ -30,8 +30,7 @@ gotobol(f, n) * location. Error if you try and move out of the buffer. Set the flag if the * line pointer for dot changes. */ -backchar(f, n) -register int n; +int backchar(int f, int n) { register LINE *lp; @@ -53,7 +52,7 @@ register int n; /* * Move the cursor to the end of the current line. Trivial. No errors. */ -gotoeol(f, n) +int gotoeol(int f, int n) { curwp->w_doto = llength(curwp->w_dotp); return (TRUE); @@ -65,8 +64,7 @@ gotoeol(f, n) * location, and move ".". Error if you try and move off the end of the * buffer. Set the flag if the line pointer for dot changes. */ -forwchar(f, n) -register int n; +int forwchar(int f, int n) { if (n < 0) return (backchar(f, -n)); @@ -83,10 +81,14 @@ register int n; return (TRUE); } -gotoline(f, n) -{ /* move to a particular line. - argument (n) must be a positive integer for - this to actually do anything */ +/* + * move to a particular line. + * + * argument (n) must be a positive integer for + * this to actually do anything + */ +int gotoline(int f, int n) +{ register int status; /* status return */ char arg[NSTRING]; /* buffer to hold argument */ @@ -114,7 +116,7 @@ gotoline(f, n) * considered to be hard motion; it really isn't if the original value of dot * is the same as the new value of dot. Normally bound to "M-<". */ -gotobob(f, n) +int gotobob(int f, int n) { curwp->w_dotp = lforw(curbp->b_linep); curwp->w_doto = 0; @@ -127,7 +129,7 @@ gotobob(f, n) * (ZJ). The standard screen code does most of the hard parts of update. * Bound to "M->". */ -gotoeob(f, n) +int gotoeob(int f, int n) { curwp->w_dotp = curbp->b_linep; curwp->w_doto = 0; @@ -141,7 +143,7 @@ gotoeob(f, n) * controls how the goal column is set. Bound to "C-N". No errors are * possible. */ -forwline(f, n) +int forwline(int f, int n) { register LINE *dlp; @@ -178,7 +180,7 @@ forwline(f, n) * alternate. Figure out the new line and call "movedot" to perform the * motion. No errors are possible. Bound to "C-P". */ -backline(f, n) +int backline(int f, int n) { register LINE *dlp; @@ -211,12 +213,14 @@ backline(f, n) } #if WORDPRO -gotobop(f, n) - /* go back to the beginning of the current paragraph - here we look for a or or - combination to delimit the beginning of a paragraph */ -int f, n; /* default Flag & Numeric argument */ - +/* + * go back to the beginning of the current paragraph + * here we look for a or or + * combination to delimit the beginning of a paragraph + * + * int f, n; default Flag & Numeric argument + */ +int gotobop(int f, int n) { register int suc; /* success of last backchar */ @@ -256,12 +260,14 @@ int f, n; /* default Flag & Numeric argument */ return (TRUE); } -gotoeop(f, n) - /* go forword to the end of the current paragraph - here we look for a or or - combination to delimit the beginning of a paragraph */ -int f, n; /* default Flag & Numeric argument */ - +/* + * go forword to the end of the current paragraph + * here we look for a or or + * combination to delimit the beginning of a paragraph + * + * int f, n; default Flag & Numeric argument + */ +int gotoeop(int f, int n) { register int suc; /* success of last backchar */ @@ -312,8 +318,7 @@ int f, n; /* default Flag & Numeric argument */ * column, return the best choice for the offset. The offset is returned. * Used by "C-N" and "C-P". */ -getgoal(dlp) -register LINE *dlp; +int getgoal(LINE *dlp) { register int c; register int col; @@ -344,8 +349,7 @@ register LINE *dlp; * the overlap; this value is the default overlap value in ITS EMACS. Because * this zaps the top line in the display window, we have to do a hard update. */ -forwpage(f, n) -register int n; +int forwpage(int f, int n) { register LINE *lp; @@ -387,8 +391,7 @@ register int n; * EMACS manual. Bound to "M-V". We do a hard update for exactly the same * reason. */ -backpage(f, n) -register int n; +int backpage(int f, int n) { register LINE *lp; @@ -428,7 +431,7 @@ register int n; * Set the mark in the current window to the value of "." in the window. No * errors are possible. Bound to "M-.". */ -setmark(f, n) +int setmark(int f, int n) { curwp->w_markp = curwp->w_dotp; curwp->w_marko = curwp->w_doto; @@ -442,7 +445,7 @@ setmark(f, n) * that moves the mark about. The only possible error is "no mark". Bound to * "C-X C-X". */ -swapmark(f, n) +int swapmark(int f, int n) { register LINE *odotp; register int odoto; diff --git a/display.c b/display.c index a45cd07..ba0b8dc 100644 --- a/display.c +++ b/display.c @@ -10,6 +10,7 @@ #include #include +#include #include "estruct.h" #include "edef.h" @@ -52,7 +53,7 @@ int chg_width, chg_height; * The original window has "WFCHG" set, so that it will get completely * redrawn on the first call to "update". */ -vtinit() +void vtinit(void) { register int i; register VIDEO *vp; @@ -99,7 +100,7 @@ vtinit() #if CLEAN /* free up all the dynamically allocated video structures */ -vtfree() +void vtfree(void) { int i; for (i = 0; i < term.t_mrow; ++i) { @@ -121,7 +122,7 @@ vtfree() * system prompt will be written in the line). Shut down the channel to the * terminal. */ -vttidy() +void vttidy(void) { mlerase(); movecursor(term.t_nrow, 0); @@ -138,23 +139,21 @@ vttidy() * screen. There is no checking for nonsense values; this might be a good * idea during the early stages. */ -vtmove(row, col) +void vtmove(int row, int col) { vtrow = row; vtcol = col; } -/* Write a character to the virtual screen. The virtual row and - column are updated. If we are not yet on left edge, don't print - it yet. If the line is too long put a "$" in the last column. - This routine only puts printing characters into the virtual - terminal buffers. Only column overflow is checked. -*/ - -vtputc(c) - -int c; - +/* + * Write a character to the virtual screen. The virtual row and + * column are updated. If we are not yet on left edge, don't print + * it yet. If the line is too long put a "$" in the last column. + * + * This routine only puts printing characters into the virtual + * terminal buffers. Only column overflow is checked. + */ +void vtputc(int c) { register VIDEO *vp; /* ptr to line being updated */ @@ -183,7 +182,7 @@ int c; * Erase from the end of the software cursor to the end of the line on which * the software cursor is located. */ -vteeol() +void vteeol(void) { /* register VIDEO *vp; */ register char *vcp = vscreen[vtrow]->v_text; @@ -194,10 +193,12 @@ vteeol() vcp[vtcol++] = ' '; } -/* upscreen: user routine to force a screen update - always finishes complete update */ - -upscreen(f, n) +/* + * upscreen: + * user routine to force a screen update + * always finishes complete update + */ +int upscreen(int f, int n) { update(TRUE); return (TRUE); @@ -213,11 +214,10 @@ int scrflags; * and refresh the screen. Second, make sure that "currow" and "curcol" are * correct for the current window. Third, make the virtual and physical * screens the same. + * + * int force; force update past type ahead? */ -update(force) - -int force; /* force update past type ahead? */ - +int update(int force) { register WINDOW *wp; @@ -314,13 +314,12 @@ int force; /* force update past type ahead? */ return (TRUE); } -/* reframe: check to see if the cursor is on in the window - and re-frame it if needed or wanted */ - -reframe(wp) - -WINDOW *wp; - +/* + * reframe: + * check to see if the cursor is on in the window + * and re-frame it if needed or wanted + */ +int reframe(WINDOW *wp) { register LINE *lp, *lp0; register int i; @@ -404,12 +403,13 @@ WINDOW *wp; return (TRUE); } -/* updone: update the current line to the virtual screen */ - -updone(wp) - -WINDOW *wp; /* window to update current line in */ - +/* + * updone: + * update the current line to the virtual screen + * + * WINDOW *wp; window to update current line in + */ +void updone(WINDOW *wp) { register LINE *lp; /* line to update */ register int sline; /* physical screen line to update */ @@ -436,12 +436,13 @@ WINDOW *wp; /* window to update current line in */ vteeol(); } -/* updall: update all the lines in a window on the virtual screen */ - -updall(wp) - -WINDOW *wp; /* window to update lines in */ - +/* + * updall: + * update all the lines in a window on the virtual screen + * + * WINDOW *wp; window to update lines in + */ +void updall(WINDOW *wp) { register LINE *lp; /* line to update */ register int sline; /* physical screen line to update */ @@ -474,10 +475,12 @@ WINDOW *wp; /* window to update lines in */ } -/* updpos: update the position of the hardware cursor and handle extended - lines. This is the only update for simple moves. */ - -updpos() +/* + * updpos: + * update the position of the hardware cursor and handle extended + * lines. This is the only update for simple moves. + */ +void updpos(void) { register LINE *lp; register int c; @@ -512,9 +515,11 @@ updpos() lbound = 0; } -/* upddex: de-extend any line that derserves it */ - -upddex() +/* + * upddex: + * de-extend any line that derserves it + */ +void upddex(void) { register WINDOW *wp; register LINE *lp; @@ -548,10 +553,12 @@ upddex() } } -/* updgar: if the screen is garbage, clear the physical screen and - the virtual screen and force a full update */ - -updgar() +/* + * updgar: + * if the screen is garbage, clear the physical screen and + * the virtual screen and force a full update + */ +void updgar(void) { register char *txt; register int i, j; @@ -581,12 +588,13 @@ updgar() #endif } -/* updupd: update the physical screen from the virtual screen */ - -updupd(force) - -int force; /* forced update flag */ - +/* + * updupd: + * update the physical screen from the virtual screen + * + * int force; forced update flag + */ +int updupd(int force) { register VIDEO *vp1; register int i; @@ -620,9 +628,11 @@ int force; /* forced update flag */ #if SCROLLCODE -/* optimize out scrolls (line breaks, and newlines) */ -/* arg. chooses between looking for inserts or deletes */ -int scrolls(inserts) +/* + * optimize out scrolls (line breaks, and newlines) + * arg. chooses between looking for inserts or deletes + */ +int scrolls(int inserts) { /* returns true if it does something */ struct VIDEO *vpv; /* virtual screen image */ struct VIDEO *vpp; /* physical screen image */ @@ -758,14 +768,18 @@ int scrolls(inserts) } /* move the "count" lines starting at "from" to "to" */ -scrscroll(from, to, count) +void scrscroll(int from, int to, int count) { ttrow = ttcol = -1; (*term.t_scroll) (from, to, count); } -texttest(vrow, prow) /* return TRUE on text match */ -int vrow, prow; /* virtual, physical rows */ +/* + * return TRUE on text match + * + * int vrow, prow; virtual, physical rows + */ +int texttest(int vrow, int prow) { struct VIDEO *vpv = vscreen[vrow]; /* virtual screen image */ struct VIDEO *vpp = pscreen[prow]; /* physical screen image */ @@ -773,9 +787,10 @@ int vrow, prow; /* virtual, physical rows */ return (!memcmp(vpv->v_text, vpp->v_text, term.t_ncol)); } -/* return the index of the first blank of trailing whitespace */ -int endofline(s, n) -char *s; +/* + * return the index of the first blank of trailing whitespace + */ +int endofline(char *s, int n) { int i; for (i = n - 1; i >= 0; i--) @@ -786,13 +801,14 @@ char *s; #endif /* SCROLLCODE */ -/* 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() +/* + * 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(void) { register int rcursor; /* real cursor location */ register LINE *lp; /* pointer to current line */ @@ -870,12 +886,14 @@ struct VIDEO *vp2; #else -updateline(row, vp1, vp2) - -int row; /* row of screen to update */ -struct VIDEO *vp1; /* virtual screen image */ -struct VIDEO *vp2; /* physical screen image */ - +/* + * updateline() + * + * int row; row of screen to update + * struct VIDEO *vp1; virtual screen image + * struct VIDEO *vp2; physical screen image + */ +int updateline(int row, struct VIDEO *vp1, struct VIDEO *vp2) { #if RAINBOW /* UPDATELINE specific code for the DEC rainbow 100 micro */ @@ -1035,8 +1053,7 @@ struct VIDEO *vp2; /* physical screen image */ * change the modeline format by hacking at this routine. Called by "update" * any time there is a dirty window. */ -modeline(wp) -WINDOW *wp; +void modeline(WINDOW *wp) { register char *cp; register int c; @@ -1225,7 +1242,7 @@ WINDOW *wp; } } -upmode() +void upmode(void) { /* update all the mode lines */ register WINDOW *wp; @@ -1241,7 +1258,7 @@ upmode() * and column "col". The row and column arguments are origin 0. Optimize out * random calls. Update "ttrow" and "ttcol". */ -movecursor(row, col) +void movecursor(int row, int col) { if (row != ttrow || col != ttcol) { ttrow = row; @@ -1255,7 +1272,7 @@ movecursor(row, col) * is not considered to be part of the virtual screen. It always works * immediately; the terminal buffer is flushed via a call to the flusher. */ -mlerase() +void mlerase(void) { int i; @@ -1284,16 +1301,14 @@ mlerase() * position. A small class of printf like format items is handled. Assumes the * stack grows down; this assumption is made by the "++" in the argument scan * loop. Set the "message line" flag TRUE. + * + * char *fmt; format string for output + * char *arg; pointer to first argument to print */ - -mlwrite(fmt, arg) - -char *fmt; /* format string for output */ -char *arg; /* pointer to first argument to print */ - +void mlwrite(const char *fmt, ...) { register int c; /* current char in format string */ - register char *ap; /* ptr to current data field */ + va_list ap; /* if we are not currently echoing on the command line, abort this */ if (discmd == FALSE) { @@ -1313,7 +1328,7 @@ char *arg; /* pointer to first argument to print */ } movecursor(term.t_nrow, 0); - ap = (char *) &arg; + va_start(ap, fmt); while ((c = *fmt++) != 0) { if (c != '%') { TTputc(c); @@ -1321,39 +1336,28 @@ char *arg; /* pointer to first argument to print */ } else { c = *fmt++; switch (c) { -#if PKCODE - case '*': - ap = *(char **) ap; - break; -#endif case 'd': - mlputi(*(int *) ap, 10); - ap += sizeof(int); + mlputi(va_arg(ap, int), 10); break; case 'o': - mlputi(*(int *) ap, 8); - ap += sizeof(int); + mlputi(va_arg(ap, int), 8); break; case 'x': - mlputi(*(int *) ap, 16); - ap += sizeof(int); + mlputi(va_arg(ap, int), 16); break; case 'D': - mlputli(*(long *) ap, 10); - ap += sizeof(long); + mlputli(va_arg(ap, long), 10); break; case 's': - mlputs(*(char **) ap); - ap += sizeof(char *); + mlputs(va_arg(ap, char *)); break; case 'f': - mlputf(*(int *) ap); - ap += sizeof(int); + mlputf(va_arg(ap, int)); break; default: @@ -1362,6 +1366,7 @@ char *arg; /* pointer to first argument to print */ } } } + va_end(ap); /* if we can, erase to the end of screen */ if (eolexist == TRUE) @@ -1370,15 +1375,14 @@ char *arg; /* pointer to first argument to print */ mpresf = TRUE; } -/* Force a string out to the message line regardless of the - current $discmd setting. This is needed when $debug is TRUE - and for the write-message and clear-message-line commands -*/ - -mlforce(s) - -char *s; /* string to force out */ - +/* + * Force a string out to the message line regardless of the + * current $discmd setting. This is needed when $debug is TRUE + * and for the write-message and clear-message-line commands + * + * char *s; string to force out + */ +void mlforce(char *s) { register int oldcmd; /* original command display flag */ @@ -1393,8 +1397,7 @@ char *s; /* string to force out */ * the characters in the string all have width "1"; if this is not the case * things will get screwed up a little. */ -mlputs(s) -char *s; +void mlputs(char *s) { register int c; @@ -1408,7 +1411,7 @@ char *s; * Write out an integer, in the specified radix. Update the physical cursor * position. */ -mlputi(i, r) +void mlputi(int i, int r) { register int q; static char hexdigits[] = "0123456789ABCDEF"; @@ -1430,8 +1433,7 @@ mlputi(i, r) /* * do the same except as a long integer. */ -mlputli(l, r) -long l; +void mlputli(long l, int r) { register long q; @@ -1450,13 +1452,11 @@ long l; } /* - * write out a scaled integer with two decimal places + * write out a scaled integer with two decimal places + * + * int s; scaled integer to output */ - -mlputf(s) - -int s; /* scaled integer to output */ - +void mlputf(int s) { int i; /* integer portion of number */ int f; /* fractional portion of number */ @@ -1475,9 +1475,7 @@ int s; /* scaled integer to output */ #if RAINBOW -putline(row, col, buf) -int row, col; -char buf[]; +void putline(int row, int col, char *buf) { int n; @@ -1492,8 +1490,7 @@ char buf[]; Store number of lines into *heightp and width into *widthp. If zero or a negative number is stored, the value is not valid. */ -getscreensize(widthp, heightp) -int *widthp, *heightp; +void getscreensize(int *widthp, int *heightp) { #ifdef TIOCGWINSZ struct winsize size; @@ -1510,8 +1507,7 @@ int *widthp, *heightp; } #ifdef SIGWINCH -void sizesignal(signr) -int signr; +void sizesignal(int signr) { int w, h; extern int errno; @@ -1526,14 +1522,13 @@ int signr; errno = old_errno; } -newscreensize(h, w) -int h, w; +int newscreensize(int h, int w) { /* do the change later */ if (displaying) { chg_width = w; chg_height = h; - return; + return FALSE; } chg_width = chg_height = 0; if (h - 1 < term.t_mrow) diff --git a/edef.h b/edef.h index 2effd8e..fa9c892 100644 --- a/edef.h +++ b/edef.h @@ -13,6 +13,8 @@ #include #include +struct VIDEO; + char *flook(); char *getctext(); char *getfname(); @@ -320,3 +322,165 @@ extern char outline[]; /* global string to hold debug line text */ #ifndef termdef extern TERM term; /* Terminal information. */ #endif + +/* word.c */ +extern int wrapword(int f, int n); +extern int backword(int f, int n); +extern int forwword(int f, int n); +extern int upperword(int f, int n); +extern int lowerword(int f, int n); +extern int capword(int f, int n); +extern int delfword(int f, int n); +extern int delbword(int f, int n); +extern int inword(void); +extern int fillpara(int f, int n); +extern int justpara(int f, int n); +extern int killpara(int f, int n); +extern int wordcount(int f, int n); + +/* line.c */ +extern int lfree(LINE *lp); +extern int lchange(int flag); +extern int insspace(int f, int n); +extern int linstr(char *instr); +extern int linsert(int n, int c); +extern int lowrite(int c); +extern int lover(char *ostr); +extern int lnewline(void); +extern int ldelete(long n, int kflag); +extern char *getctext(void); +extern int putctext(char *iline); +extern int ldelnewline(void); +extern int kdelete(void); +extern int kinsert(int c); +extern int yank(int f, int n); + +/* window.c */ +extern int reposition(int f, int n); +extern int refresh(int f, int n); +extern int nextwind(int f, int n); +extern int prevwind(int f, int n); +extern int mvdnwind(int f, int n); +extern int mvupwind(int f, int n); +extern int onlywind(int f, int n); +extern int delwind(int f, int n); +extern int splitwind(int f, int n); +extern int enlargewind(int f, int n); +extern int shrinkwind(int f, int n); +extern int resize(int f, int n); +extern int scrnextup(int f, int n); +extern int scrnextdw(int f, int n); +extern int savewnd(int f, int n); +extern int restwnd(int f, int n); +extern int newsize(int f, int n); +extern int newwidth(int f, int n); +extern int getwpos(void); +extern int cknewwindow(void); + +/* basic.c */ +extern int gotobol(int f, int n); +extern int backchar(int f, int n); +extern int gotoeol(int f, int n); +extern int forwchar(int f, int n); +extern int gotoline(int f, int n); +extern int gotobob(int f, int n); +extern int gotoeob(int f, int n); +extern int forwline(int f, int n); +extern int backline(int f, int n); +extern int gotobop(int f, int n); +extern int gotoeop(int f, int n); +extern int getgoal(LINE *dlp); +extern int forwpage(int f, int n); +extern int backpage(int f, int n); +extern int setmark(int f, int n); +extern int swapmark(int f, int n); + +/* random.c */ +extern int tabsize; /* Tab size (0: use real tabs) */; +extern int setfillcol(int f, int n); +extern int showcpos(int f, int n); +extern int getcline(void); +extern int getccol(int bflg); +extern int setccol(int pos); +extern int twiddle(int f, int n); +extern int quote(int f, int n); +extern int tab(int f, int n); +extern int detab(int f, int n); +extern int entab(int f, int n); +extern int trim(int f, int n); +extern int openline(int f, int n); +extern int newline(int f, int n); +extern int cinsert(void); +extern int insbrace(int n, int c); +extern int insbrace(int n, int c); +extern int inspound(void); +extern int deblank(int f, int n); +extern int indent(int f, int n); +extern int forwdel(int f, int n); +extern int backdel(int f, int n); +extern int killtext(int f, int n); +extern int setmode(int f, int n); +extern int delmode(int f, int n); +extern int setgmode(int f, int n); +extern int delgmode(int f, int n); +extern int adjustmode(int kind, int global); +extern int clrmes(int f, int n); +extern int writemsg(int f, int n); +extern int getfence(int f, int n); +extern int fmatch(int ch); +extern int istring(int f, int n); +extern int ovstring(int f, int n); + +/* main.c */ +extern int edinit(char *bname); +extern int execute(int c, int f, int n); +extern int quickexit(int f, int n); +extern int quit(int f, int n); +extern int ctlxlp(int f, int n); +extern int ctlxrp(int f, int n); +extern int ctlxe(int f, int n); +extern int ctrlg(int f, int n); +extern int rdonly(void); +extern int resterr(void); +extern int nullproc(int f, int n); +extern int meta(int f, int n); +extern int cex(int f, int n); +extern int unarg(int f, int n); +extern int cexit(int status); + +/* display.c */ +extern void vtinit(void); +extern void vtfree(void); +extern void vttidy(void); +extern void vtmove(int row, int col); +extern void vtputc(int c); +extern void vteeol(void); +extern int upscreen(int f, int n); +extern int update(int force); +extern int reframe(WINDOW *wp); +extern void updone(WINDOW *wp); +extern void updall(WINDOW *wp); +extern void updpos(void); +extern void upddex(void); +extern void updgar(void); +extern int updupd(int force); +extern int scrolls(int inserts); +extern void scrscroll(int from, int to, int count); +extern int texttest(int vrow, int prow); +extern int endofline(char *s, int n); +extern void updext(void); +extern int updateline(int row, struct VIDEO *vp1, struct VIDEO *vp2); +extern void modeline(WINDOW *wp); +extern void upmode(void); +extern void movecursor(int row, int col); +extern void mlerase(void); +extern void mlwrite(const char *fmt, ...); +extern void mlforce(char *s); +extern void mlputs(char *s); +extern void mlputi(int i, int r); +extern void mlputli(long l, int r); +extern void mlputf(int s); +extern void putline(int row, int col, char *buf); +extern void getscreensize(int *widthp, int *heightp); +extern void sizesignal(int signr); +extern int newscreensize(int h, int w); diff --git a/eval.c b/eval.c index d063b68..5a22643 100644 --- a/eval.c +++ b/eval.c @@ -573,7 +573,7 @@ char *value; /* value to set to */ ldelete(1L, FALSE); /* delete 1 char */ c = atoi(value); if (c == '\n') - lnewline(FALSE, 1); + lnewline(); else linsert(1, c); backchar(FALSE, 1); diff --git a/line.c b/line.c index e7ca1b6..a3be448 100644 --- a/line.c +++ b/line.c @@ -26,10 +26,7 @@ int ykboff; /* offset into that chunk */ * a pointer to the new block, or NULL if there isn't any memory left. Print a * message in the message line if no space. */ -LINE *lalloc(used) - -register int used; - +LINE *lalloc(int used) { register LINE *lp; register int size; @@ -52,8 +49,7 @@ register int used; * might be in. Release the memory. The buffers are updated too; the magic * conditions described in the above comments don't hold here. */ -lfree(lp) -register LINE *lp; +int lfree(LINE *lp) { register BUFFER *bp; register WINDOW *wp; @@ -98,8 +94,7 @@ register LINE *lp; * displayed in more than 1 window we change EDIT t HARD. Set MODE if the * mode line needs to be updated (the "*" has to be set). */ -lchange(flag) -register int flag; +int lchange(int flag) { register WINDOW *wp; @@ -117,10 +112,12 @@ register int flag; } } -insspace(f, n) - /* insert spaces forward into text */ -int f, n; /* default flag and numeric argument */ - +/* + * insert spaces forward into text + * + * int f, n; default flag and numeric argument + */ +int insspace(int f, int n) { linsert(n, ' '); backchar(f, n); @@ -130,8 +127,7 @@ int f, n; /* default flag and numeric argument */ * linstr -- Insert a string at the current point */ -linstr(instr) -char *instr; +int linstr(char *instr) { register int status = TRUE; char tmpc; @@ -161,7 +157,7 @@ char *instr; * well, and FALSE on errors. */ -linsert(n, c) +int linsert(int n, int c) { register char *cp1; register char *cp2; @@ -242,12 +238,9 @@ linsert(n, c) /* * Overwrite a character into the current line at the current position * + * int c; character to overwrite on current position */ - -lowrite(c) - -char c; /* character to overwrite on current position */ - +int lowrite(int c) { if (curwp->w_doto < curwp->w_dotp->l_used && (lgetc(curwp->w_dotp, curwp->w_doto) != '\t' || @@ -259,11 +252,7 @@ char c; /* character to overwrite on current position */ /* * lover -- Overwrite a string at the current point */ - -lover(ostr) - -char *ostr; - +int lover(char *ostr) { register int status = TRUE; char tmpc; @@ -292,7 +281,7 @@ char *ostr; * update of dot and mark is a bit easier then in the above case, because the * split forces more updating. */ -lnewline() +int lnewline(void) { register char *cp1; register char *cp2; @@ -350,12 +339,11 @@ lnewline() * with end of lines, etc. It returns TRUE if all of the characters were * deleted, and FALSE if they were not (because dot ran into the end of the * buffer. The "kflag" is TRUE if the text should be put in the kill buffer. + * + * long n; # of chars to delete + * int kflag; put killed text in kill buffer flag */ -ldelete(n, kflag) - -long n; /* # of chars to delete */ -int kflag; /* put killed text in kill buffer flag */ - +int ldelete(long n, int kflag) { register char *cp1; register char *cp2; @@ -419,11 +407,11 @@ int kflag; /* put killed text in kill buffer flag */ return (TRUE); } -/* getctext: grab and return a string with the text of - the current line -*/ - -char *getctext() +/* + * getctext: grab and return a string with the text of + * the current line + */ +char *getctext(void) { register LINE *lp; /* line to copy */ register int size; /* length of line to return */ @@ -446,12 +434,13 @@ char *getctext() return (rline); } -/* putctext: replace the current line with the passed in text */ - -putctext(iline) - -char *iline; /* contents of new line */ - +/* + * putctext: + * replace the current line with the passed in text + * + * char *iline; contents of new line + */ +int putctext(char *iline) { register int status; @@ -477,7 +466,7 @@ char *iline; /* contents of new line */ * about in memory. Return FALSE on error and TRUE if all looks ok. Called by * "ldelete" only. */ -ldelnewline() +int ldelnewline(void) { register char *cp1; register char *cp2; @@ -561,7 +550,7 @@ ldelnewline() * new kill context is being created. The kill buffer array is released, just * in case the buffer has grown to immense size. No errors. */ -kdelete() +int kdelete(void) { KILL *kp; /* ptr to scan kill buffer chunk list */ @@ -584,12 +573,10 @@ kdelete() /* * Insert a character to the kill buffer, allocating new chunks as needed. * Return TRUE if all is well, and FALSE on errors. + * + * int c; character to insert in the kill buffer */ - -kinsert(c) - -int c; /* character to insert in the kill buffer */ - +int kinsert(int c) { KILL *nchunk; /* ptr to newly malloced chunk */ @@ -616,7 +603,7 @@ int c; /* character to insert in the kill buffer */ * is done by the standard insert routines. All you do is run the loop, and * check for errors. Bound to "C-Y". */ -yank(f, n) +int yank(int f, int n) { register int c; register int i; diff --git a/main.c b/main.c index 17fd216..43f556b 100644 --- a/main.c +++ b/main.c @@ -89,13 +89,10 @@ extern void sizesignal(); #endif #if CALLED -emacs(argc, argv) +int emacs(int argc, char **argv) #else -main(argc, argv) +int main(int argc, char **argv) #endif -int argc; /* # of arguments */ -char *argv[]; /* argument strings */ - { register int c; /* command character */ register int f; /* default flag */ @@ -430,8 +427,7 @@ char *argv[]; /* argument strings */ * as an argument, because the main routine may have been told to read in a * file by default, and we want the buffer name to be right. */ -edinit(bname) -char bname[]; +int edinit(char *bname) { register BUFFER *bp; register WINDOW *wp; @@ -469,7 +465,7 @@ char bname[]; * and arranges to move it to the "lastflag", so that the next command can * look at it. Return the status of command. */ -execute(c, f, n) +int execute(int c, int f, int n) { register int status; int (*execfunc) (); /* ptr to function to execute */ @@ -560,7 +556,7 @@ execute(c, f, n) * Fancy quit command, as implemented by Norm. If the any buffer has * changed do a write on that buffer and exit emacs, otherwise simply exit. */ -quickexit(f, n) +int quickexit(int f, int n) { register BUFFER *bp; /* scanning pointer to buffers */ register BUFFER *oldcb; /* original current buffer */ @@ -590,8 +586,7 @@ quickexit(f, n) return (TRUE); } -static void emergencyexit(signr) -int signr; +static void emergencyexit(int signr) { quickexit(FALSE, 0); quit(TRUE, 0); @@ -601,7 +596,7 @@ int signr; * Quit command. If an argument, always quit. Otherwise confirm if a buffer * has been changed and not written out. Normally bound to "C-X C-C". */ -quit(f, n) +int quit(int f, int n) { register int s; @@ -634,7 +629,7 @@ quit(f, n) * Error if not at the top level in keyboard processing. Set up variables and * return. */ -ctlxlp(f, n) +int ctlxlp(int f, int n) { if (kbdmode != STOP) { mlwrite("%%Macro already active"); @@ -651,7 +646,7 @@ ctlxlp(f, n) * End keyboard macro. Check for the same limit conditions as the above * routine. Set up the variables and return to the caller. */ -ctlxrp(f, n) +int ctlxrp(int f, int n) { if (kbdmode == STOP) { mlwrite("%%Macro not active"); @@ -669,7 +664,7 @@ ctlxrp(f, n) * The command argument is the number of times to loop. Quit as soon as a * command gets an error. Return TRUE if all ok, else FALSE. */ -ctlxe(f, n) +int ctlxe(int f, int n) { if (kbdmode != STOP) { mlwrite("%%Macro already active"); @@ -688,7 +683,7 @@ ctlxe(f, n) * Beep the beeper. Kill off any keyboard macro, etc., that is in progress. * Sometimes called as a routine, to do general aborting of stuff. */ -ctrlg(f, n) +int ctrlg(int f, int n) { TTbeep(); kbdmode = STOP; @@ -696,36 +691,37 @@ ctrlg(f, n) return (ABORT); } -/* tell the user that this command is illegal while we are in - VIEW (read-only) mode */ - -rdonly() +/* + * tell the user that this command is illegal while we are in + * VIEW (read-only) mode + */ +int rdonly(void) { TTbeep(); mlwrite("(Key illegal in VIEW mode)"); return (FALSE); } -resterr() +int resterr(void) { TTbeep(); mlwrite("(That command is RESTRICTED)"); return (FALSE); } -nullproc() +int nullproc(int f, int n) { /* user function that does NOTHING */ } -meta() +int meta(int f, int n) { /* dummy function for binding to meta prefix */ } -cex() +int cex(int f, int n) { /* dummy function for binding to control-x prefix */ } -unarg() +int unarg(int f, int n) { /* dummy function for binding to universal-argument */ } @@ -808,10 +804,13 @@ dspram() */ #if CLEAN -cexit(status) - -int status; /* return status of emacs */ +/* + * cexit() + * + * int status; return status of emacs + */ +int cexit(int status) { register BUFFER *bp; /* buffer list pointer */ register WINDOW *wp; /* window list pointer */ diff --git a/random.c b/random.c index 9131849..54ce943 100644 --- a/random.c +++ b/random.c @@ -15,7 +15,7 @@ int tabsize; /* Tab size (0: use real tabs) */ /* * Set fill column to n. */ -setfillcol(f, n) +int setfillcol(int f, int n) { fillcol = n; mlwrite("(Fill column is %d)", n); @@ -29,7 +29,7 @@ setfillcol(f, n) * column, but the column that would be used on an infinite width display. * Normally this is bound to "C-X =". */ -showcpos(f, n) +int showcpos(int f, int n) { register LINE *lp; /* current line */ register long numchars; /* # of chars in file */ @@ -97,26 +97,13 @@ showcpos(f, n) ratio = (100L * predchars) / numchars; /* summarize and report the info */ -#if PKCODE - pk_mlrec.pk_clin = predlines + 1; - pk_mlrec.pk_tlin = numlines + 1; - pk_mlrec.pk_ccol = col; - pk_mlrec.pk_tcol = ecol; - pk_mlrec.pk_cchr = predchars; - pk_mlrec.pk_tchr = numchars; - pk_mlrec.pk_perc = ratio; - pk_mlrec.pk_char = curchar; - mlwrite("%*Line %d/%d Col %d/%d Char %D/%D (%d%%) char = 0x%x", - &pk_mlrec); -#else mlwrite("Line %d/%d Col %d/%d Char %D/%D (%d%%) char = 0x%x", predlines + 1, numlines + 1, col, ecol, predchars, numchars, ratio, curchar); -#endif return (TRUE); } -getcline() +int getcline(void) { /* get the current line number */ register LINE *lp; /* current line */ register int numlines; /* # of lines before point */ @@ -141,8 +128,7 @@ getcline() /* * Return current column. Stop at first non-blank given TRUE argument. */ -getccol(bflg) -int bflg; +int getccol(int bflg) { register int c, i, col; col = 0; @@ -161,11 +147,10 @@ int bflg; /* * Set current column. + * + * int pos; position to set cursor */ -setccol(pos) - -int pos; /* position to set cursor */ - +int setccol(int pos) { register int c; /* character being scanned */ register int i; /* index into current line */ @@ -204,7 +189,7 @@ int pos; /* position to set cursor */ * work. This fixes up a very common typo with a single stroke. Normally bound * to "C-T". This always works within a line, so "WFEDIT" is good enough. */ -twiddle(f, n) +int twiddle(int f, int n) { register LINE *dotp; register int doto; @@ -233,7 +218,7 @@ twiddle(f, n) * its line splitting meaning. The character is always read, even if it is * inserted 0 times, for regularity. Bound to "C-Q" */ -quote(f, n) +int quote(int f, int n) { register int s; register int c; @@ -261,7 +246,7 @@ quote(f, n) * done in this slightly funny way because the tab (in ASCII) has been turned * into "C-I" (in 10 bit code) already. Bound to "C-I". */ -tab(f, n) +int tab(int f, int n) { if (n < 0) return (FALSE); @@ -275,10 +260,12 @@ tab(f, n) } #if AEDIT -detab(f, n) - /* change tabs to spaces */ -int f, n; /* default flag and numeric repeat count */ - +/* + * change tabs to spaces + * + * int f, n; default flag and numeric repeat count + */ +int detab(int f, int n) { register int inc; /* increment to next line [sgn(n)] */ @@ -315,10 +302,12 @@ int f, n; /* default flag and numeric repeat count */ return (TRUE); } -entab(f, n) - /* change spaces to tabs where posible */ -int f, n; /* default flag and numeric repeat count */ - +/* + * change spaces to tabs where posible + * + * int f, n; default flag and numeric repeat count + */ +int entab(int f, int n) { register int inc; /* increment to next line [sgn(n)] */ register int fspace; /* pointer to first space if in a run */ @@ -386,10 +375,12 @@ int f, n; /* default flag and numeric repeat count */ return (TRUE); } -trim(f, n) - /* trim trailing whitespace from the point to eol */ -int f, n; /* default flag and numeric repeat count */ - +/* + * trim trailing whitespace from the point to eol + * + * int f, n; default flag and numeric repeat count + */ +int trim(int f, int n) { register LINE *lp; /* current line pointer */ register int offset; /* original line offset position */ @@ -433,7 +424,7 @@ int f, n; /* default flag and numeric repeat count */ * and then back up over them. Everything is done by the subcommand * procerssors. They even handle the looping. Normally this is bound to "C-O". */ -openline(f, n) +int openline(int f, int n) { register int i; register int s; @@ -457,7 +448,7 @@ openline(f, n) * Insert a newline. Bound to "C-M". If we are in CMODE, do automatic * indentation as specified. */ -newline(f, n) +int newline(int f, int n) { register int s; @@ -492,7 +483,7 @@ newline(f, n) return (TRUE); } -cinsert() +int cinsert(void) { /* insert a newline and indentation for C */ register char *cptr; /* string pointer into text to copy */ register int tptr; /* index to scan into line */ @@ -534,11 +525,13 @@ cinsert() } #if NBRACE -insbrace(n, c) - /* insert a brace into the text here...we are in CMODE */ -int n; /* repeat count */ -int c; /* brace to insert (always } for now) */ - +/* + * insert a brace into the text here...we are in CMODE + * + * int n; repeat count + * int c; brace to insert (always } for now) + */ +int insbrace(int n, int c) { register int ch; /* last character before input */ register int oc; /* caractere oppose a c */ @@ -625,12 +618,16 @@ int c; /* brace to insert (always } for now) */ /* and insert the required brace(s) */ return (linsert(n, c)); } -#else -insbrace(n, c) - /* insert a brace into the text here...we are in CMODE */ -int n; /* repeat count */ -int c; /* brace to insert (always { for now) */ +#else + +/* + * insert a brace into the text here...we are in CMODE + * + * int n; repeat count + * int c; brace to insert (always { for now) + */ +int insbrace(int n, int c) { register int ch; /* last character before input */ register int i; @@ -659,7 +656,7 @@ int c; /* brace to insert (always { for now) */ } #endif -inspound() +int inspound(void) { /* insert a # into the text here...we are in CMODE */ register int ch; /* last character before input */ register int i; @@ -691,7 +688,7 @@ inspound() * the line. Normally this command is bound to "C-X C-O". Any argument is * ignored. */ -deblank(f, n) +int deblank(int f, int n) { register LINE *lp1; register LINE *lp2; @@ -721,7 +718,7 @@ deblank(f, n) * of tabs and spaces. Return TRUE if all ok. Return FALSE if one of the * subcomands failed. Normally bound to "C-J". */ -indent(f, n) +int indent(int f, int n) { register int nicol; register int c; @@ -755,7 +752,7 @@ indent(f, n) * If any argument is present, it kills rather than deletes, to prevent loss * of text if typed with a big argument. Normally bound to "C-D". */ -forwdel(f, n) +int forwdel(int f, int n) { if (curbp->b_mode & MDVIEW) /* don't allow this command if */ return (rdonly()); /* we are in read only mode */ @@ -775,7 +772,7 @@ forwdel(f, n) * forward, this actually does a kill if presented with an argument. Bound to * both "RUBOUT" and "C-H". */ -backdel(f, n) +int backdel(int f, int n) { register int s; @@ -801,7 +798,7 @@ backdel(f, n) * number of newlines. If called with a negative argument it kills backwards * that number of newlines. Normally bound to "C-K". */ -killtext(f, n) +int killtext(int f, int n) { register LINE *nextp; long chunk; @@ -834,10 +831,12 @@ killtext(f, n) return (ldelete(chunk, TRUE)); } -setmode(f, n) - /* prompt and set an editor mode */ -int f, n; /* default and argument */ - +/* + * prompt and set an editor mode + * + * int f, n; default and argument + */ +int setmode(int f, int n) { #if PKCODE return adjustmode(TRUE, FALSE); @@ -846,10 +845,12 @@ int f, n; /* default and argument */ #endif } -delmode(f, n) - /* prompt and delete an editor mode */ -int f, n; /* default and argument */ - +/* + * prompt and delete an editor mode + * + * int f, n; default and argument + */ +int delmode(int f, int n) { #if PKCODE return adjustmode(FALSE, FALSE); @@ -858,10 +859,12 @@ int f, n; /* default and argument */ #endif } -setgmode(f, n) - /* prompt and set a global editor mode */ -int f, n; /* default and argument */ - +/* + * prompt and set a global editor mode + * + * int f, n; default and argument + */ +int setgmode(int f, int n) { #if PKCODE return adjustmode(TRUE, TRUE); @@ -870,10 +873,12 @@ int f, n; /* default and argument */ #endif } -delgmode(f, n) - /* prompt and delete a global editor mode */ -int f, n; /* default and argument */ - +/* + * prompt and delete a global editor mode + * + * int f, n; default and argument + */ +int delgmode(int f, int n) { #if PKCODE return adjustmode(FALSE, TRUE); @@ -882,10 +887,13 @@ int f, n; /* default and argument */ #endif } -adjustmode(kind, global) - /* change the editor mode status */ -int kind; /* true = set, false = delete */ -int global; /* true = global flag, false = current buffer flag */ +/* + * change the editor mode status + * + * int kind; true = set, false = delete + * int global; true = global flag, false = current buffer flag + */ +int adjustmode(int kind, int global) { register char *scan; /* scanning pointer to convert prompt */ register int i; /* loop index */ @@ -983,25 +991,25 @@ int global; /* true = global flag, false = current buffer flag */ return (FALSE); } -/* This function simply clears the message line, - mainly for macro usage */ - -clrmes(f, n) - -int f, n; /* arguments ignored */ - +/* + * This function simply clears the message line, + * mainly for macro usage + * + * int f, n; arguments ignored + */ +int clrmes(int f, int n) { mlforce(""); return (TRUE); } -/* This function writes a string on the message line - mainly for macro usage */ - -writemsg(f, n) - -int f, n; /* arguments ignored */ - +/* + * This function writes a string on the message line + * mainly for macro usage + * + * int f, n; arguments ignored + */ +int writemsg(int f, int n) { register char *sp; /* pointer into buf to expand %s */ register char *np; /* ptr into nbuf */ @@ -1029,12 +1037,12 @@ int f, n; /* arguments ignored */ } #if CFENCE -/* the cursor is moved to a matching fence */ - -getfence(f, n) - -int f, n; /* not used */ - +/* + * the cursor is moved to a matching fence + * + * int f, n; not used + */ +int getfence(int f, int n) { register LINE *oldlp; /* original line pointer */ register int oldoff; /* and offset */ @@ -1128,13 +1136,13 @@ int f, n; /* not used */ } #endif -/* Close fences are matched against their partners, and if - on screen the cursor briefly lights there */ - -fmatch(ch) - -char ch; /* fence type to match against */ - +/* + * Close fences are matched against their partners, and if + * on screen the cursor briefly lights there + * + * char ch; fence type to match against + */ +int fmatch(int ch) { register LINE *oldlp; /* original line pointer */ register int oldoff; /* and offset */ @@ -1195,11 +1203,13 @@ char ch; /* fence type to match against */ return (TRUE); } -istring(f, n) - /* ask for and insert a string into the current - buffer at the current point */ -int f, n; /* ignored arguments */ - +/* + * ask for and insert a string into the current + * buffer at the current point + * + * int f, n; ignored arguments + */ +int istring(int f, int n) { register int status; /* status return code */ char tstring[NPAT + 1]; /* string to add */ @@ -1221,11 +1231,13 @@ int f, n; /* ignored arguments */ return (status); } -ovstring(f, n) - /* ask for and overwite a string into the current - buffer at the current point */ -int f, n; /* ignored arguments */ - +/* + * ask for and overwite a string into the current + * buffer at the current point + * + * int f, n; ignored arguments + */ +int ovstring(int f, int n) { register int status; /* status return code */ char tstring[NPAT + 1]; /* string to add */ diff --git a/spawn.c b/spawn.c index 616e37b..b7a140c 100644 --- a/spawn.c +++ b/spawn.c @@ -23,7 +23,6 @@ extern short iochan; /* In "termio.c" */ #if V7 | USG | BSD #include -extern int vttidy(); #ifdef SIGWINCH extern int chg_width, chg_height; extern void sizesignal(); diff --git a/window.c b/window.c index 7ed3775..7ea6407 100644 --- a/window.c +++ b/window.c @@ -15,7 +15,7 @@ * bottom. If it is 0 the window is centered (this is what the standard * redisplay code does). With no argument it defaults to 0. Bound to M-!. */ -reposition(f, n) +int reposition(int f, int n) { if (f == FALSE) /* default to 0 to center screen */ n = 0; @@ -28,7 +28,7 @@ reposition(f, n) * Refresh the screen. With no argument, it just does the refresh. With an * argument it recenters "." in the current window. Bound to "C-L". */ -refresh(f, n) +int refresh(int f, int n) { if (f == FALSE) sgarbf = TRUE; @@ -47,11 +47,10 @@ refresh(f, n) * * with an argument this command finds the th window from the top * + * int f, n; default flag and numeric argument + * */ -nextwind(f, n) - -int f, n; /* default flag and numeric argument */ - +int nextwind(int f, int n) { register WINDOW *wp; register int nwindows; /* total number of windows */ @@ -94,7 +93,7 @@ int f, n; /* default flag and numeric argument */ * current window. There arn't any errors, although the command does not do a * lot if there is 1 window. */ -prevwind(f, n) +int prevwind(int f, int n) { register WINDOW *wp1; register WINDOW *wp2; @@ -126,10 +125,7 @@ prevwind(f, n) * a new dot. We share the code by having "move down" just be an interface to * "move up". Magic. Bound to "C-X C-N". */ -mvdnwind(f, n) - -int n; - +int mvdnwind(int f, int n) { return (mvupwind(f, -n)); } @@ -141,9 +137,7 @@ int n; * (this command does not really move "."; it moves the frame). Bound to * "C-X C-P". */ -mvupwind(f, n) -int n; - +int mvupwind(int f, int n) { register LINE *lp; register int i; @@ -187,7 +181,7 @@ int n; * the buffer structures right if the distruction of a window makes a buffer * become undisplayed. */ -onlywind(f, n) +int onlywind(int f, int n) { register WINDOW *wp; register LINE *lp; @@ -231,12 +225,10 @@ onlywind(f, n) /* * Delete the current window, placing its space in the window above, * or, if it is the top window, the window below. Bound to C-X 0. + * + * int f, n; arguments are ignored for this command */ - -delwind(f, n) - -int f, n; /* arguments are ignored for this command */ - +int delwind(int f, int n) { register WINDOW *wp; /* window to recieve deleted space */ register WINDOW *lwp; /* ptr window before curwp */ @@ -306,18 +298,15 @@ int f, n; /* arguments are ignored for this command */ } /* - -Split the current window. A window smaller than 3 lines cannot be -split. An argument of 1 forces the cursor into the upper window, an -argument of two forces the cursor to the lower window. The only other -error that is possible is a "malloc" failure allocating the structure -for the new window. Bound to "C-X 2". - + * Split the current window. A window smaller than 3 lines cannot be + * split. An argument of 1 forces the cursor into the upper window, an + * argument of two forces the cursor to the lower window. The only + * other error that is possible is a "malloc" failure allocating the + * structure for the new window. Bound to "C-X 2". + * + * int f, n; default flag and numeric argument */ -splitwind(f, n) - -int f, n; /* default flag and numeric argument */ - +int splitwind(int f, int n) { register WINDOW *wp; register LINE *lp; @@ -399,7 +388,7 @@ int f, n; /* default flag and numeric argument */ * all the hard work. You don't just set "force reframe" because dot would * move. Bound to "C-X Z". */ -enlargewind(f, n) +int enlargewind(int f, int n) { register WINDOW *adjwp; register LINE *lp; @@ -450,7 +439,7 @@ enlargewind(f, n) * window descriptions. Ask the redisplay to do all the hard work. Bound to * "C-X C-Z". */ -shrinkwind(f, n) +int shrinkwind(int f, int n) { register WINDOW *adjwp; register LINE *lp; @@ -497,12 +486,12 @@ shrinkwind(f, n) return (TRUE); } -/* Resize the current window to the requested size */ - -resize(f, n) - -int f, n; /* default flag and numeric argument */ - +/* + * Resize the current window to the requested size + * + * int f, n; default flag and numeric argument + */ +int resize(int f, int n) { int clines; /* current # of lines in window */ @@ -525,7 +514,7 @@ int f, n; /* default flag and numeric argument */ * Pick the uppermost window that isn't the current window. An LRU algorithm * might be better. Return a pointer, or NULL on error. */ -WINDOW *wpopup() +WINDOW *wpopup(void) { register WINDOW *wp; @@ -538,27 +527,27 @@ WINDOW *wpopup() return (wp); } -scrnextup(f, n) +int scrnextup(int f, int n) { /* scroll the next window up (back) a page */ nextwind(FALSE, 1); backpage(f, n); prevwind(FALSE, 1); } -scrnextdw(f, n) +int scrnextdw(int f, int n) { /* scroll the next window down (forward) a page */ nextwind(FALSE, 1); forwpage(f, n); prevwind(FALSE, 1); } -savewnd(f, n) +int savewnd(int f, int n) { /* save ptr to current window */ swindow = curwp; return (TRUE); } -restwnd(f, n) +int restwnd(int f, int n) { /* restore the saved screen */ register WINDOW *wp; @@ -578,11 +567,13 @@ restwnd(f, n) return (FALSE); } -newsize(f, n) - /* resize the screen, re-writing the screen */ -int f; /* default flag */ -int n; /* numeric argument */ - +/* + * resize the screen, re-writing the screen + * + * int f; default flag + * int n; numeric argument + */ +int newsize(int f, int n) { WINDOW *wp; /* current window being examined */ WINDOW *nextwp; /* next window to scan */ @@ -664,11 +655,13 @@ int n; /* numeric argument */ return (TRUE); } -newwidth(f, n) - /* resize the screen, re-writing the screen */ -int f; /* default flag */ -int n; /* numeric argument */ - +/* + * resize the screen, re-writing the screen + * + * int f; default flag + * int n; numeric argument + */ +int newwidth(int f, int n) { register WINDOW *wp; @@ -698,7 +691,7 @@ int n; /* numeric argument */ return (TRUE); } -int getwpos() +int getwpos(void) { /* get screen offset of current line in current window */ register int sline; /* screen line from top of window */ register LINE *lp; /* scannile line pointer */ @@ -715,7 +708,7 @@ int getwpos() return (sline); } -cknewwindow() +int cknewwindow(void) { execute(META | SPEC | 'X', FALSE, 1); } diff --git a/word.c b/word.c index 85548d4..0f8e153 100644 --- a/word.c +++ b/word.c @@ -17,12 +17,12 @@ * a new line. Otherwise, break the line at the word-break, eat it, and jump * back to the end of the word. * Returns TRUE on success, FALSE on errors. + * + * int f; default flag + * int n; numeric argument + * */ -wrapword(f, n) - -int f; /* default flag */ -int n; /* numeric argument */ - +int wrapword(int f, int n) { register int cnt; /* size of word wrapped to next line */ register int c; /* charector temporary */ @@ -67,7 +67,7 @@ int n; /* numeric argument */ * performed by the "backchar" and "forwchar" routines. Error if you try to * move beyond the buffers. */ -backword(f, n) +int backword(int f, int n) { if (n < 0) return (forwword(f, -n)); @@ -90,7 +90,7 @@ backword(f, n) * Move the cursor forward by the specified number of words. All of the motion * is done by "forwchar". Error if you try and move beyond the buffer's end. */ -forwword(f, n) +int forwword(int f, int n) { if (n < 0) return (backword(f, -n)); @@ -113,7 +113,7 @@ forwword(f, n) * convert any characters to upper case. Error if you try and move beyond the * end of the buffer. Bound to "M-U". */ -upperword(f, n) +int upperword(int f, int n) { register int c; @@ -149,7 +149,7 @@ upperword(f, n) * convert characters to lower case. Error if you try and move over the end of * the buffer. Bound to "M-L". */ -lowerword(f, n) +int lowerword(int f, int n) { register int c; @@ -186,7 +186,7 @@ lowerword(f, n) * characters to lower case. Error if you try and move past the end of the * buffer. Bound to "M-C". */ -capword(f, n) +int capword(int f, int n) { register int c; @@ -238,7 +238,7 @@ capword(f, n) * command for the right number of characters. With a zero argument, just * kill one word and no whitespace. Bound to "M-D". */ -delfword(f, n) +int delfword(int f, int n) { register LINE *dotp; /* original cursor line */ register int doto; /* and row */ @@ -327,7 +327,7 @@ delfword(f, n) * counting the characters. When dot is finally moved to its resting place, * fire off the kill command. Bound to "M-Rubout" and to "M-Backspace". */ -delbword(f, n) +int delbword(int f, int n) { long size; @@ -368,7 +368,7 @@ delbword(f, n) * Return TRUE if the character at dot is a character that is considered to be * part of a word. The word character list is hard coded. Should be setable. */ -inword() +int inword(void) { register int c; @@ -389,11 +389,13 @@ inword() } #if WORDPRO -fillpara(f, n) - /* Fill the current paragraph according to the current - fill column */ -int f, n; /* deFault flag and Numeric argument */ - +/* + * Fill the current paragraph according to the current + * fill column + * + * f and n - deFault flag and Numeric argument + */ +int fillpara(int f, int n) { register int c; /* current char durring scan */ register int wordlen; /* length of current word */ @@ -485,11 +487,12 @@ int f, n; /* deFault flag and Numeric argument */ } #if PKCODE -justpara(f, n) - /* Fill the current paragraph according to the current - fill column and cursor position */ -int f, n; /* deFault flag and Numeric argument */ - +/* Fill the current paragraph according to the current + * fill column and cursor position + * + * int f, n; deFault flag and Numeric argument + */ +int justpara(int f, int n) { register int c; /* current char durring scan */ register int wordlen; /* length of current word */ @@ -593,11 +596,13 @@ int f, n; /* deFault flag and Numeric argument */ } #endif -killpara(f, n) - /* delete n paragraphs starting with the current one */ -int f; /* default flag */ -int n; /* # of paras to delete */ - +/* + * delete n paragraphs starting with the current one + * + * int f default flag + * int n # of paras to delete + */ +int killpara(int f, int n) { register int status; /* returned status of functions */ @@ -625,14 +630,14 @@ int n; /* # of paras to delete */ } -/* wordcount: count the # of words in the marked region, - along with average word sizes, # of chars, etc, - and report on them. */ - -wordcount(f, n) - -int f, n; /* ignored numeric arguments */ - +/* + * wordcount: count the # of words in the marked region, + * along with average word sizes, # of chars, etc, + * and report on them. + * + * int f, n; ignored numeric arguments + */ +int wordcount(int f, int n) { register LINE *lp; /* current line to scan */ register int offset; /* current char to scan */ @@ -702,17 +707,8 @@ int f, n; /* ignored numeric arguments */ else avgch = 0; -#if PKCODE - pk_mlrec.pk_1 = nwords; - pk_mlrec.pk_2 = nchars; - pk_mlrec.pk_3 = nlines + 1; - pk_mlrec.pk_4 = avgch; - mlwrite("%*Words %D Chars %D Lines %d Avg chars/word %f", - &pk_mlrec); -#else mlwrite("Words %D Chars %D Lines %d Avg chars/word %f", nwords, nchars, nlines + 1, avgch); -#endif return (TRUE); } #endif