Run "indent -kr -i8" on the sources

Let's see how nasty it is to clean things up. For real.

ansi.c

@@ -58,11 +58,11 @@ int	cbcolor = -1;		/* current background color */
  */
 TERM term = {
 #if	PKCODE
-	MROW-1,
+	MROW - 1,
 #else
-	NROW-1,
+	NROW - 1,
 #endif
-   	NROW-1,
+	NROW - 1,
 	NCOL,
 	NCOL,
 	MARGIN,
@@ -91,8 +91,8 @@ TERM    term    = {
 };
 
 #if	COLOR
-ansifcol(color)		/* set the current output color */
+ansifcol(color)
-
+    /* set the current output color */
 int color;			/* color to set */
 
 {
@@ -100,13 +100,13 @@ int color;	/* color to set */
 		return;
 	ttputc(ESC);
 	ttputc('[');
-	ansiparm(color+30);
+	ansiparm(color + 30);
 	ttputc('m');
 	cfcolor = color;
 }
 
-ansibcol(color)		/* set the current background color */
+ansibcol(color)
-
+    /* set the current background color */
 int color;			/* color to set */
 
 {
@@ -114,7 +114,7 @@ int color;	/* color to set */
 		return;
 	ttputc(ESC);
 	ttputc('[');
-	ansiparm(color+40);
+	ansiparm(color + 40);
 	ttputc('m');
 	cbcolor = color;
 }
@@ -124,9 +124,9 @@ ansimove(row, col)
 {
 	ttputc(ESC);
 	ttputc('[');
-        ansiparm(row+1);
+	ansiparm(row + 1);
 	ttputc(';');
-        ansiparm(col+1);
+	ansiparm(col + 1);
 	ttputc('H');
 }
 
@@ -148,8 +148,8 @@ ansieeop()
 	ttputc('J');
 }
 
-ansirev(state)		/* change reverse video state */
+ansirev(state)
-
+    /* change reverse video state */
 int state;			/* TRUE = reverse, FALSE = normal */
 
 {
@@ -159,7 +159,7 @@ int state;	/* TRUE = reverse, FALSE = normal */
 
 	ttputc(ESC);
 	ttputc('[');
-	ttputc(state ? '7': '0');
+	ttputc(state ? '7' : '0');
 	ttputc('m');
 #if	COLOR
 	if (state == FALSE) {
@@ -173,15 +173,13 @@ int state;	/* TRUE = reverse, FALSE = normal */
 #endif
 }
 
-ansicres()	/* change screen resolution */
+ansicres()
-
+{				/* change screen resolution */
-{
+	return (TRUE);
-	return(TRUE);
 }
 
-spal(dummy)		/* change pallette settings */
+spal(dummy)
-
+{				/* change pallette settings */
-{
 	/* none for now */
 }
 
@@ -194,17 +192,17 @@ ansibeep()
 ansiparm(n)
 register int n;
 {
-        register int q,r;
+	register int q, r;
 
-        q = n/10;
+	q = n / 10;
 	if (q != 0) {
-		r = q/10;
+		r = q / 10;
 		if (r != 0) {
-			ttputc((r%10)+'0');
+			ttputc((r % 10) + '0');
 		}
-		ttputc((q%10) + '0');
+		ttputc((q % 10) + '0');
 	}
-        ttputc((n%10) + '0');
+	ttputc((n % 10) + '0');
 }
 
 ansiopen()
@@ -228,7 +226,6 @@ ansiopen()
 }
 
 ansiclose()
-
 {
 #if	COLOR
 	ansifcol(7);
@@ -237,24 +234,22 @@ ansiclose()
 	ttclose();
 }
 
-ansikopen()	/* open the keyboard (a noop here) */
+ansikopen()
-
+{				/* open the keyboard (a noop here) */
-{
 }
 
-ansikclose()	/* close the keyboard (a noop here) */
+ansikclose()
-
+{				/* close the keyboard (a noop here) */
-{
 }
 
 #if	FNLABEL
-fnclabel(f, n)		/* label a function key */
+fnclabel(f, n)
-
+    /* label a function key */
-int f,n;	/* default flag, numeric argument [unused] */
+int f, n;			/* default flag, numeric argument [unused] */
 
 {
 	/* on machines with no function keys...don't bother */
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 #else

basic.c

@@ -39,7 +39,7 @@ register int    n;
 		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)
 				return (FALSE);
 			curwp->w_dotp = lp;
 			curwp->w_doto = llength(lp);
@@ -83,30 +83,30 @@ register int    n;
 	return (TRUE);
 }
 
-gotoline(f, n)		/* move to a particular line.
+gotoline(f, n)
+{				/* move to a particular line.
 				   argument (n) must be a positive integer for
 				   this to actually do anything           */
-
-{
 	register int status;	/* status return */
 	char arg[NSTRING];	/* buffer to hold argument */
 
 	/* get an argument if one doesnt exist */
 	if (f == FALSE) {
-		if ((status = mlreply("Line to GOTO: ", arg, NSTRING)) != TRUE) {
+		if ((status =
+		     mlreply("Line to GOTO: ", arg, NSTRING)) != TRUE) {
 			mlwrite("(Aborted)");
-			return(status);
+			return (status);
 		}
 		n = atoi(arg);
 	}
 
 	if (n < 1)		/* if a bogus argument...then leave */
-		return(FALSE);
+		return (FALSE);
 
 	/* first, we go to the start of the buffer */
 	curwp->w_dotp = lforw(curbp->b_linep);
 	curwp->w_doto = 0;
-	return(forwline(f, n-1));
+	return (forwline(f, n - 1));
 }
 
 /*
@@ -150,11 +150,11 @@ forwline(f, n)
 
 	/* if we are on the last line as we start....fail the command */
 	if (curwp->w_dotp == curbp->b_linep)
-		return(FALSE);
+		return (FALSE);
 
 	/* if the last command was not note a line move,
 	   reset the goal column */
-        if ((lastflag&CFCPCN) == 0)
+	if ((lastflag & CFCPCN) == 0)
 		curgoal = getccol(FALSE);
 
 	/* flag this command as a line move */
@@ -162,7 +162,7 @@ forwline(f, n)
 
 	/* and move the point down */
 	dlp = curwp->w_dotp;
-        while (n-- && dlp!=curbp->b_linep)
+	while (n-- && dlp != curbp->b_linep)
 		dlp = lforw(dlp);
 
 	/* reseting the current position */
@@ -188,11 +188,11 @@ backline(f, n)
 
 	/* if we are on the last line as we start....fail the command */
 	if (lback(curwp->w_dotp) == curbp->b_linep)
-		return(FALSE);
+		return (FALSE);
 
 	/* if the last command was not note a line move,
 	   reset the goal column */
-        if ((lastflag&CFCPCN) == 0)
+	if ((lastflag & CFCPCN) == 0)
 		curgoal = getccol(FALSE);
 
 	/* flag this command as a line move */
@@ -200,7 +200,7 @@ backline(f, n)
 
 	/* and move the point up */
 	dlp = curwp->w_dotp;
-        while (n-- && lback(dlp)!=curbp->b_linep)
+	while (n-- && lback(dlp) != curbp->b_linep)
 		dlp = lback(dlp);
 
 	/* reseting the current position */
@@ -211,17 +211,17 @@ backline(f, n)
 }
 
 #if	WORDPRO
-gotobop(f, n)	/* go back to the beginning of the current paragraph
+gotobop(f, n)
+    /* go back to the beginning of the current paragraph
        here we look for a <NL><NL> or <NL><TAB> or <NL><SPACE>
        combination to delimit the beginning of a paragraph      */
-
 int f, n;			/* default Flag & Numeric argument */
 
 {
 	register int suc;	/* success of last backchar */
 
-	if (n < 0)	/* the other way...*/
+	if (n < 0)		/* the other way... */
-		return(gotoeop(f, -n));
+		return (gotoeop(f, -n));
 
 	while (n-- > 0) {	/* for each one asked for */
 
@@ -253,20 +253,20 @@ int f, n;	/* default Flag & Numeric argument */
 			suc = forwchar(FALSE, 1);
 	}
 	curwp->w_flag |= WFMOVE;	/* force screen update */
-	return(TRUE);
+	return (TRUE);
 }
 
-gotoeop(f, n)	/* go forword to the end of the current paragraph
+gotoeop(f, n)
+    /* go forword to the end of the current paragraph
        here we look for a <NL><NL> or <NL><TAB> or <NL><SPACE>
        combination to delimit the beginning of a paragraph      */
-
 int f, n;			/* default Flag & Numeric argument */
 
 {
 	register int suc;	/* success of last backchar */
 
-	if (n < 0)	/* the other way...*/
+	if (n < 0)		/* the other way... */
-		return(gotobop(f, -n));
+		return (gotobop(f, -n));
 
 	while (n-- > 0) {	/* for each one asked for */
 
@@ -303,7 +303,7 @@ int f, n;	/* default Flag & Numeric argument */
 		curwp->w_doto = llength(curwp->w_dotp);	/* and to the EOL */
 	}
 	curwp->w_flag |= WFMOVE;	/* force screen update */
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 
@@ -327,7 +327,7 @@ register LINE   *dlp;
 		newcol = col;
 		if (c == '\t')
 			newcol |= tabmask;
-                else if (c<0x20 || c==0x7F)
+		else if (c < 0x20 || c == 0x7F)
 			++newcol;
 		++newcol;
 		if (newcol > curgoal)
@@ -368,13 +368,13 @@ register int    n;
 		n *= curwp->w_ntrows;	/* to lines.            */
 #endif
 	lp = curwp->w_linep;
-        while (n-- && lp!=curbp->b_linep)
+	while (n-- && lp != curbp->b_linep)
 		lp = lforw(lp);
 	curwp->w_linep = lp;
 	curwp->w_dotp = lp;
 	curwp->w_doto = 0;
 #if SCROLLCODE
-	curwp->w_flag |= WFHARD|WFKILLS;
+	curwp->w_flag |= WFHARD | WFKILLS;
 #else
 	curwp->w_flag |= WFHARD;
 #endif
@@ -411,13 +411,13 @@ register int    n;
 		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_dotp = lp;
 	curwp->w_doto = 0;
 #if SCROLLCODE
-        curwp->w_flag |= WFHARD|WFINS;
+	curwp->w_flag |= WFHARD | WFINS;
 #else
 	curwp->w_flag |= WFHARD;
 #endif

bind.c

@@ -14,10 +14,10 @@
 
 extern int meta(), cex(), unarg(), ctrlg();	/* dummy prefix binding functions */
 
-help(f, n)	/* give me some help!!!!
+help(f, n)
+{				/* give me some help!!!!
 				   bring up a fake buffer and read the help file
 				   into it with view mode                 */
-{
 	register WINDOW *wp;	/* scaning pointer to windows */
 	register BUFFER *bp;	/* buffer pointer to help */
 	char *fname;		/* ptr to file returned by flook() */
@@ -29,18 +29,18 @@ help(f, n)	/* give me some help!!!!
 		fname = flook(pathname[1], FALSE);
 		if (fname == NULL) {
 			mlwrite("(Help file is not online)");
-			return(FALSE);
+			return (FALSE);
 		}
 	}
 
 	/* split the current window to make room for the help stuff */
 	if (splitwind(FALSE, 1) == FALSE)
-			return(FALSE);
+		return (FALSE);
 
 	if (bp == NULL) {
 		/* and read the stuff in */
 		if (getfile(fname, FALSE) == FALSE)
-			return(FALSE);
+			return (FALSE);
 	} else
 		swbuffer(bp);
 
@@ -52,16 +52,15 @@ help(f, n)	/* give me some help!!!!
 		wp->w_flag |= WFMODE;
 		wp = wp->w_wndp;
 	}
-	return(TRUE);
+	return (TRUE);
 }
 
-deskey(f, n)	/* describe the command for a certain key */
+deskey(f, n)
-
+{				/* describe the command for a certain key */
-{
 	register int c;		/* key to describe */
 	register char *ptr;	/* string pointer to scan output strings */
 	char outseq[NSTRING];	/* output buffer for command sequence */
-	int (*getbind())();
+	int (*getbind()) ();
 
 	/* prompt the user to type us a key to describe */
 	mlwrite(": describe-key ");
@@ -89,12 +88,12 @@ bindtokey(f, n)
 int f, n;			/* command arguments [IGNORED] */
 
 {
-	register unsigned int c;/* command key to bind */
+	register unsigned int c;	/* command key to bind */
-	register int (*kfunc)();/* ptr to the requested function to bind to */
+	register int (*kfunc) ();	/* ptr to the requested function to bind to */
 	register KEYTAB *ktp;	/* pointer into the command table */
 	register int found;	/* matched command flag */
 	char outseq[80];	/* output buffer for keystroke sequence */
-	int (*getname())();
+	int (*getname()) ();
 
 	/* prompt the user to type in a key to bind */
 	mlwrite(": bind-to-key ");
@@ -103,7 +102,7 @@ int f, n;	/* command arguments [IGNORED] */
 	kfunc = getname();
 	if (kfunc == NULL) {
 		mlwrite("(No such function)");
-		return(FALSE);
+		return (FALSE);
 	}
 	ostring(" ");
 
@@ -158,7 +157,7 @@ int f, n;	/* command arguments [IGNORED] */
 		/* if we run out of binding room, bitch */
 		if (ktp >= &keytab[NBINDS]) {
 			mlwrite("Binding table FULL!");
-			return(FALSE);
+			return (FALSE);
 		}
 
 		ktp->k_code = c;	/* add keycode */
@@ -167,7 +166,7 @@ int f, n;	/* command arguments [IGNORED] */
 		ktp->k_code = 0;
 		ktp->k_fp = NULL;
 	}
-	return(TRUE);
+	return (TRUE);
 }
 
 /* unbindkey:	delete a key from the key binding table	*/
@@ -195,9 +194,9 @@ int f, n;	/* command arguments [IGNORED] */
 	/* if it isn't bound, bitch */
 	if (unbindchar(c) == FALSE) {
 		mlwrite("(Key not bound)");
-		return(FALSE);
+		return (FALSE);
 	}
-	return(TRUE);
+	return (TRUE);
 }
 
 unbindchar(c)
@@ -222,7 +221,7 @@ int c;		/* command key to unbind */
 
 	/* if it isn't bound, bitch */
 	if (!found)
-		return(FALSE);
+		return (FALSE);
 
 	/* save the pointer and scan to the end of the table */
 	sktp = ktp;
@@ -237,33 +236,32 @@ int c;		/* command key to unbind */
 	/* null out the last one */
 	ktp->k_code = 0;
 	ktp->k_fp = NULL;
-	return(TRUE);
+	return (TRUE);
 }
 
-desbind(f, n)	/* describe bindings
+desbind(f, n)
+    /* describe bindings
        bring up a fake buffer and list the key bindings
        into it with view mode                   */
-
 #if	APROP
 {
 	buildlist(TRUE, "");
 }
 
-apro(f, n)	/* Apropos (List functions that match a substring) */
+apro(f, n)
-
+{				/* Apropos (List functions that match a substring) */
-{
 	char mstring[NSTRING];	/* string to match cmd names to */
 	int status;		/* status return */
 
 	status = mlreply("Apropos string: ", mstring, NSTRING - 1);
 	if (status != TRUE)
-		return(status);
+		return (status);
 
-	return(buildlist(FALSE, mstring));
+	return (buildlist(FALSE, mstring));
 }
 
-buildlist(type, mstring)  /* build a binding list (limited or full) */
+buildlist(type, mstring)
-
+    /* build a binding list (limited or full) */
 int type;			/* true = full list,   false = partial list */
 char *mstring;			/* match string if a partial list */
 
@@ -279,13 +277,13 @@ char *mstring;	/* match string if a partial list */
 
 	/* split the current window to make room for the binding list */
 	if (splitwind(FALSE, 1) == FALSE)
-			return(FALSE);
+		return (FALSE);
 
 	/* and get a buffer for it */
 	bp = bfind("*Binding list*", TRUE, 0);
 	if (bp == NULL || bclear(bp) == FALSE) {
 		mlwrite("Can not display binding list");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* let us know this is in progress */
@@ -306,7 +304,7 @@ char *mstring;	/* match string if a partial list */
 	wp = curwp;
 	wp->w_bufp = bp;
 	wp->w_linep = bp->b_linep;
-	wp->w_flag = WFHARD|WFFORCE;
+	wp->w_flag = WFHARD | WFFORCE;
 	wp->w_dotp = bp->b_dotp;
 	wp->w_doto = bp->b_doto;
 	wp->w_markp = NULL;
@@ -341,7 +339,7 @@ char *mstring;	/* match string if a partial list */
 
 				/* and add it as a line into the buffer */
 				if (linstr(outseq) != TRUE)
-					return(FALSE);
+					return (FALSE);
 
 				cpos = 0;	/* and clear the line */
 			}
@@ -353,16 +351,16 @@ char *mstring;	/* match string if a partial list */
 			outseq[cpos++] = '\n';
 			outseq[cpos] = 0;
 			if (linstr(outseq) != TRUE)
-				return(FALSE);
+				return (FALSE);
 		}
 
-fail:		/* and on to the next name */
+	      fail:		/* and on to the next name */
 		++nptr;
 	}
 
-	curwp->w_bufp->b_mode |= MDVIEW;/* put this buffer view mode */
+	curwp->w_bufp->b_mode |= MDVIEW;	/* put this buffer view mode */
 	curbp->b_flag &= ~BFCHG;	/* don't flag this as a change */
-	wp->w_dotp = lforw(bp->b_linep);/* back to the beginning */
+	wp->w_dotp = lforw(bp->b_linep);	/* back to the beginning */
 	wp->w_doto = 0;
 	wp = wheadp;		/* and update ALL mode lines */
 	while (wp != NULL) {
@@ -370,12 +368,12 @@ fail:		/* and on to the next name */
 		wp = wp->w_wndp;
 	}
 	mlwrite("");		/* clear the mode line */
-	return(TRUE);
+	return (TRUE);
 }
 
 #if	APROP
-strinc(source, sub)	/* does source include sub? */
+strinc(source, sub)
-
+    /* does source include sub? */
 char *source;			/* string to search in */
 char *sub;			/* substring to look for */
 
@@ -400,12 +398,12 @@ char *sub;	/* substring to look for */
 
 		/* yes, return a success */
 		if (*tp == 0)
-			return(TRUE);
+			return (TRUE);
 
 		/* no, onward */
 		sp++;
 	}
-	return(FALSE);
+	return (FALSE);
 }
 #endif
 
@@ -422,7 +420,7 @@ int mflag;	/* going for a meta sequence? */
 	/* check to see if we are executing a command line */
 	if (clexec) {
 		macarg(tok);	/* get the next token */
-		return(stock(tok));
+		return (stock(tok));
 	}
 
 	/* or the normal way */
@@ -430,7 +428,7 @@ int mflag;	/* going for a meta sequence? */
 		c = get1key();
 	else
 		c = getcmd();
-	return(c);
+	return (c);
 }
 
 /* execute the startup file */
@@ -450,10 +448,10 @@ char *sfname;	/* name of startup file (null if default) */
 
 	/* if it isn't around, don't sweat it */
 	if (fname == NULL)
-		return(TRUE);
+		return (TRUE);
 
 	/* otherwise, execute the sucker */
-	return(dofile(fname));
+	return (dofile(fname));
 }
 
 /*	Look up the existance of a file along the normal or PATH
@@ -487,7 +485,7 @@ int hflag;	/* Look in the HOME environment variable first? */
 			/* and try it out */
 			if (ffropen(fspec) == FIOSUC) {
 				ffclose();
-				return(fspec);
+				return (fspec);
 			}
 		}
 	}
@@ -496,9 +494,8 @@ int hflag;	/* Look in the HOME environment variable first? */
 	/* always try the current directory first */
 	if (ffropen(fname) == FIOSUC) {
 		ffclose();
-		return(fname);
+		return (fname);
 	}
-
 #if	ENVFUNC
 	/* get the PATH variable */
 	path = getenv("PATH");
@@ -519,7 +516,7 @@ int hflag;	/* Look in the HOME environment variable first? */
 			/* and try it out */
 			if (ffropen(fspec) == FIOSUC) {
 				ffclose();
-				return(fspec);
+				return (fspec);
 			}
 
 			if (*path == PATHCHR)
@@ -528,22 +525,22 @@ int hflag;	/* Look in the HOME environment variable first? */
 #endif
 
 	/* look it up via the old table method */
-	for (i=2; i < NPNAMES; i++) {
+	for (i = 2; i < NPNAMES; i++) {
 		strcpy(fspec, pathname[i]);
 		strcat(fspec, fname);
 
 		/* and try it out */
 		if (ffropen(fspec) == FIOSUC) {
 			ffclose();
-			return(fspec);
+			return (fspec);
 		}
 	}
 
-	return(NULL);	/* no such luck */
+	return (NULL);		/* no such luck */
 }
 
-cmdstr(c, seq)	/* change a key command to a string we can print out */
+cmdstr(c, seq)
-
+    /* change a key command to a string we can print out */
 int c;				/* sequence to translate */
 char *seq;			/* destination string for sequence */
 
@@ -584,7 +581,7 @@ char *seq;	/* destination string for sequence */
 
 /*	This function looks a key binding up in the binding table	*/
 
-int (*getbind(c))()
+int (*getbind(c)) ()
 
 int c;				/* key to find what is bound to it */
 
@@ -594,12 +591,12 @@ int c;	/* key to find what is bound to it */
 	ktp = &keytab[0];	/* Look in key table.   */
 	while (ktp->k_fp != NULL) {
 		if (ktp->k_code == c)
-                        return(ktp->k_fp);
+			return (ktp->k_fp);
 		++ktp;
 	}
 
 	/* no such binding */
-	return(NULL);
+	return (NULL);
 }
 
 /* getfname:	This function takes a ptr to function and gets the name
@@ -608,7 +605,7 @@ int c;	/* key to find what is bound to it */
 
 char *getfname(func)
 
-int (*func)();	/* ptr to the requested function to bind to */
+int (*func) ();			/* ptr to the requested function to bind to */
 
 {
 	register NBIND *nptr;	/* pointer into the name binding table */
@@ -617,15 +614,15 @@ int (*func)();	/* ptr to the requested function to bind to */
 	nptr = &names[0];
 	while (nptr->n_func != NULL) {
 		if (nptr->n_func == func)
-			return(nptr->n_name);
+			return (nptr->n_name);
 		++nptr;
 	}
-	return(NULL);
+	return (NULL);
 }
 
-int (*fncmatch(fname))() /* match fname to a function in the names table
+int (*fncmatch(fname)) ()
+			     /* match fname to a function in the names table
 			        and return any match or NULL if none            */
-
 char *fname;			/* name to attempt to match */
 
 {
@@ -635,10 +632,10 @@ char *fname;	/* name to attempt to match */
 	ffp = &names[0];
 	while (ffp->n_func != NULL) {
 		if (strcmp(fname, ffp->n_name) == 0)
-			return(ffp->n_func);
+			return (ffp->n_func);
 		++ffp;
 	}
-	return(NULL);
+	return (NULL);
 }
 
 /* stock:	String key name TO Command Key		*/
@@ -654,25 +651,25 @@ char *keyname;		/* name of key to translate to Command key form */
 	c = 0;
 
 	/* first, the META prefix */
-	if (*keyname == 'M' && *(keyname+1) == '-') {
+	if (*keyname == 'M' && *(keyname + 1) == '-') {
 		c = META;
 		keyname += 2;
 	}
 
 	/* next the function prefix */
-	if (*keyname == 'F' && *(keyname+1) == 'N') {
+	if (*keyname == 'F' && *(keyname + 1) == 'N') {
 		c |= SPEC;
 		keyname += 2;
 	}
 
 	/* control-x as well... (but not with FN) */
-	if (*keyname == '^' && *(keyname+1) == 'X'&& !(c & SPEC)) {
+	if (*keyname == '^' && *(keyname + 1) == 'X' && !(c & SPEC)) {
 		c |= CTLX;
 		keyname += 2;
 	}
 
 	/* a control char? */
-	if (*keyname == '^' && *(keyname+1) != 0) {
+	if (*keyname == '^' && *(keyname + 1) != 0) {
 		c |= CONTROL;
 		++keyname;
 	}
@@ -682,27 +679,27 @@ char *keyname;		/* name of key to translate to Command key form */
 	}
 
 
-	/* make sure we are not lower case (not with function keys)*/
+	/* make sure we are not lower case (not with function keys) */
 	if (*keyname >= 'a' && *keyname <= 'z' && !(c & SPEC))
 		*keyname -= 32;
 
 	/* the final sequence... */
 	c |= *keyname;
-	return(c);
+	return (c);
 }
 
-char *transbind(skey)	/* string key name to binding name.... */
+char *transbind(skey)
-
+			    /* string key name to binding name.... */
 char *skey;			/* name of keey to get binding for */
 
 {
 	char *bindname;
 	unsigned int stock();
-	int (*getbind())();
+	int (*getbind()) ();
 
 	bindname = getfname(getbind(stock(skey)));
 	if (bindname == NULL)
 		bindname = "ERROR";
 
-	return(bindname);
+	return (bindname);
 }

buffer.c

@@ -25,25 +25,25 @@ usebuffer(f, n)
 	register int s;
 	char bufn[NBUFN];
 
-        if ((s=mlreply("Use buffer: ", bufn, NBUFN)) != TRUE)
+	if ((s = mlreply("Use buffer: ", bufn, NBUFN)) != TRUE)
 		return (s);
-        if ((bp=bfind(bufn, TRUE, 0)) == NULL)
+	if ((bp = bfind(bufn, TRUE, 0)) == NULL)
 		return (FALSE);
-	return(swbuffer(bp));
+	return (swbuffer(bp));
 }
 
-nextbuffer(f, n)	/* switch to the next buffer in the buffer list */
+nextbuffer(f, n)
-
+    /* switch to the next buffer in the buffer list */
 int f, n;			/* default flag, numeric argument */
 {
-	register BUFFER *bp;	/* eligable buffer to switch to*/
+	register BUFFER *bp;	/* eligable buffer to switch to */
-	register BUFFER *bbp;	/* eligable buffer to switch to*/
+	register BUFFER *bbp;	/* eligable buffer to switch to */
 
 	/* make sure the arg is legit */
 	if (f == FALSE)
 		n = 1;
 	if (n < 1)
-		return(FALSE);
+		return (FALSE);
 
 	bbp = curbp;
 	while (n-- > 0) {
@@ -59,18 +59,18 @@ int f, n;	/* default flag, numeric argument */
 
 			/* don't get caught in an infinite loop! */
 			if (bp == bbp)
-				return(FALSE);
+				return (FALSE);
 
 		}
 
 		bbp = bp;
 	}
 
-	return(swbuffer(bp));
+	return (swbuffer(bp));
 }
 
-swbuffer(bp)	/* make buffer BP current */
+swbuffer(bp)
-
+    /* make buffer BP current */
 BUFFER *bp;
 
 {
@@ -83,7 +83,7 @@ BUFFER *bp;
 		curbp->b_marko = curwp->w_marko;
 	}
 	curbp = bp;		/* Switch.              */
-	if (curbp->b_active != TRUE) {		/* buffer not active yet*/
+	if (curbp->b_active != TRUE) {	/* buffer not active yet */
 		/* read it in and activate it */
 		readin(curbp->b_fname, TRUE);
 		curbp->b_dotp = lforw(curbp->b_linep);
@@ -93,7 +93,7 @@ BUFFER *bp;
 	}
 	curwp->w_bufp = bp;
 	curwp->w_linep = bp->b_linep;	/* For macros, ignored. */
-        curwp->w_flag |= WFMODE|WFFORCE|WFHARD; /* Quite nasty.         */
+	curwp->w_flag |= WFMODE | WFFORCE | WFHARD;	/* Quite nasty.         */
 	if (bp->b_nwnd++ == 0) {	/* First use.           */
 		curwp->w_dotp = bp->b_dotp;
 		curwp->w_doto = bp->b_doto;
@@ -104,7 +104,7 @@ BUFFER *bp;
 	}
 	wp = wheadp;		/* Look for old.        */
 	while (wp != NULL) {
-                if (wp!=curwp && wp->w_bufp==bp) {
+		if (wp != curwp && wp->w_bufp == bp) {
 			curwp->w_dotp = wp->w_dotp;
 			curwp->w_doto = wp->w_doto;
 			curwp->w_markp = wp->w_markp;
@@ -126,23 +126,22 @@ BUFFER *bp;
  * line and the buffer header. Bound to "C-X K".
  */
 killbuffer(f, n)
-
 {
 	register BUFFER *bp;
 	register int s;
 	char bufn[NBUFN];
 
-        if ((s=mlreply("Kill buffer: ", bufn, NBUFN)) != TRUE)
+	if ((s = mlreply("Kill buffer: ", bufn, NBUFN)) != TRUE)
-                return(s);
+		return (s);
-        if ((bp=bfind(bufn, FALSE, 0)) == NULL) /* Easy if unknown.     */
+	if ((bp = bfind(bufn, FALSE, 0)) == NULL)	/* Easy if unknown.     */
 		return (TRUE);
-	if(bp->b_flag & BFINVS)		/* Deal with special buffers	*/
+	if (bp->b_flag & BFINVS)	/* Deal with special buffers        */
 		return (TRUE);	/* by doing nothing.    */
-	return(zotbuf(bp));
+	return (zotbuf(bp));
 }
 
-zotbuf(bp)	/* kill the buffer pointed to by bp */
+zotbuf(bp)
-
+    /* kill the buffer pointed to by bp */
 register BUFFER *bp;
 
 {
@@ -154,7 +153,7 @@ register BUFFER *bp;
 		mlwrite("Buffer is being displayed");
 		return (FALSE);
 	}
-        if ((s=bclear(bp)) != TRUE)             /* Blow text away.      */
+	if ((s = bclear(bp)) != TRUE)	/* Blow text away.      */
 		return (s);
 	free((char *) bp->b_linep);	/* Release header line. */
 	bp1 = NULL;		/* Find the header.     */
@@ -172,8 +171,8 @@ register BUFFER *bp;
 	return (TRUE);
 }
 
-namebuffer(f,n)		/*	Rename the current buffer	*/
+namebuffer(f, n)
-
+    /*  Rename the current buffer       */
 int f, n;			/* default Flag & Numeric arg */
 
 {
@@ -181,8 +180,9 @@ int f, n;		/* default Flag & Numeric arg */
 	char bufn[NBUFN];	/* buffer to hold buffer name */
 
 	/* prompt for and get the new buffer name */
-ask:	if (mlreply("Change buffer name to: ", bufn, NBUFN) != TRUE)
+      ask:if (mlreply("Change buffer name to: ", bufn, NBUFN) !=
-		return(FALSE);
+	    TRUE)
+		return (FALSE);
 
 	/* and check for duplicates */
 	bp = bheadp;
@@ -198,7 +198,7 @@ ask:	if (mlreply("Change buffer name to: ", bufn, NBUFN) != TRUE)
 	strcpy(curbp->b_bname, bufn);	/* copy buffer name to structure */
 	curwp->w_flag |= WFMODE;	/* make mode line replot */
 	mlerase();
-	return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -217,10 +217,10 @@ listbuffers(f, n)
 	register BUFFER *bp;
 	register int s;
 
-        if ((s=makelist(f)) != TRUE)
+	if ((s = makelist(f)) != TRUE)
 		return (s);
 	if (blistp->b_nwnd == 0) {	/* Not on screen yet.   */
-                if ((wp=wpopup()) == NULL)
+		if ((wp = wpopup()) == NULL)
 			return (FALSE);
 		bp = wp->w_bufp;
 		if (--bp->b_nwnd == 0) {
@@ -240,7 +240,7 @@ listbuffers(f, n)
 			wp->w_doto = 0;
 			wp->w_markp = NULL;
 			wp->w_marko = 0;
-                        wp->w_flag |= WFMODE|WFHARD;
+			wp->w_flag |= WFMODE | WFHARD;
 		}
 		wp = wp->w_wndp;
 	}
@@ -270,15 +270,16 @@ int iflag;	/* list hidden buffer flag */
 	register int s;
 	register int i;
 	long nbytes;		/* # of bytes in current buffer */
-        char b[7+1];
+	char b[7 + 1];
 	char line[MAXLINE];
 
 	blistp->b_flag &= ~BFCHG;	/* Don't complain!      */
-        if ((s=bclear(blistp)) != TRUE)         /* Blow old text away   */
+	if ((s = bclear(blistp)) != TRUE)	/* Blow old text away   */
 		return (s);
 	strcpy(blistp->b_fname, "");
 	if (addline("ACT MODES        Size Buffer        File") == FALSE
-        ||  addline("--- -----        ---- ------        ----") == FALSE)
+	    || addline("--- -----        ---- ------        ----") ==
+	    FALSE)
 		return (FALSE);
 	bp = bheadp;		/* For all buffers      */
 
@@ -297,12 +298,12 @@ int iflag;	/* list hidden buffer flag */
 			*cp1++ = '.';
 	strcpy(cp1, "         Global Modes");
 	if (addline(line) == FALSE)
-		return(FALSE);
+		return (FALSE);
 
 	/* output the list of buffers */
 	while (bp != NULL) {
 		/* skip invisable buffers if iflag is false */
-                if (((bp->b_flag&BFINVS) != 0) && (iflag != TRUE)) {
+		if (((bp->b_flag & BFINVS) != 0) && (iflag != TRUE)) {
 			bp = bp->b_bufp;
 			continue;
 		}
@@ -315,13 +316,13 @@ int iflag;	/* list hidden buffer flag */
 			*cp1++ = ' ';
 
 		/* output status of changed flag */
-                if ((bp->b_flag&BFCHG) != 0)    /* "*" if changed       */
+		if ((bp->b_flag & BFCHG) != 0)	/* "*" if changed       */
 			*cp1++ = '*';
 		else
 			*cp1++ = ' ';
 
 		/* report if the file is truncated */
-                if ((bp->b_flag&BFTRUNC) != 0)
+		if ((bp->b_flag & BFTRUNC) != 0)
 			*cp1++ = '#';
 		else
 			*cp1++ = ' ';
@@ -339,7 +340,7 @@ int iflag;	/* list hidden buffer flag */
 		nbytes = 0L;	/* Count bytes in buf.  */
 		lp = lforw(bp->b_linep);
 		while (lp != bp->b_linep) {
-                        nbytes += (long)llength(lp)+1L;
+			nbytes += (long) llength(lp) + 1L;
 			lp = lforw(lp);
 		}
 		ltoa(b, 7, nbytes);	/* 6 digit buffer size. */
@@ -352,10 +353,10 @@ int iflag;	/* list hidden buffer flag */
 			*cp1++ = c;
 		cp2 = &bp->b_fname[0];	/* File name            */
 		if (*cp2 != 0) {
-                        while (cp1 < &line[3+1+5+1+6+4+NBUFN])
+			while (cp1 < &line[3 + 1 + 5 + 1 + 6 + 4 + NBUFN])
 				*cp1++ = ' ';
 			while ((c = *cp2++) != 0) {
-                                if (cp1 < &line[MAXLINE-1])
+				if (cp1 < &line[MAXLINE - 1])
 					*cp1++ = c;
 			}
 		}
@@ -376,10 +377,10 @@ long   num;
 {
 	buf[width] = 0;		/* End of string.       */
 	while (num >= 10) {	/* Conditional digits.  */
-                buf[--width] = (int)(num%10L) + '0';
+		buf[--width] = (int) (num % 10L) + '0';
 		num /= 10L;
 	}
-        buf[--width] = (int)num + '0';          /* Always 1 digit.      */
+	buf[--width] = (int) num + '0';	/* Always 1 digit.      */
 	while (width != 0)	/* Pad with blanks.     */
 		buf[--width] = ' ';
 }
@@ -399,9 +400,9 @@ char    *text;
 	register int ntext;
 
 	ntext = strlen(text);
-        if ((lp=lalloc(ntext)) == NULL)
+	if ((lp = lalloc(ntext)) == NULL)
 		return (FALSE);
-        for (i=0; i<ntext; ++i)
+	for (i = 0; i < ntext; ++i)
 		lputc(lp, i, text[i]);
 	blistp->b_linep->l_bp->l_fp = lp;	/* Hook onto the end    */
 	lp->l_bp = blistp->b_linep->l_bp;
@@ -428,7 +429,8 @@ anycb()
 
 	bp = bheadp;
 	while (bp != NULL) {
-                if ((bp->b_flag&BFINVS)==0 && (bp->b_flag&BFCHG)!=0)
+		if ((bp->b_flag & BFINVS) == 0
+		    && (bp->b_flag & BFCHG) != 0)
 			return (TRUE);
 		bp = bp->b_bufp;
 	}
@@ -442,8 +444,7 @@ anycb()
  * and the "cflag" is TRUE, create it. The "bflag" is
  * the settings for the flags in in buffer.
  */
-BUFFER  *
+BUFFER *bfind(bname, cflag, bflag)
-bfind(bname, cflag, bflag)
 register char *bname;
 {
 	register BUFFER *bp;
@@ -458,9 +459,9 @@ register char   *bname;
 		bp = bp->b_bufp;
 	}
 	if (cflag != FALSE) {
-                if ((bp=(BUFFER *)malloc(sizeof(BUFFER))) == NULL)
+		if ((bp = (BUFFER *) malloc(sizeof(BUFFER))) == NULL)
 			return (NULL);
-                if ((lp=lalloc(0)) == NULL) {
+		if ((lp = lalloc(0)) == NULL) {
 			free((char *) bp);
 			return (NULL);
 		}
@@ -519,12 +520,12 @@ register BUFFER *bp;
 	register LINE *lp;
 	register int s;
 
-        if ((bp->b_flag&BFINVS) == 0            /* Not scratch buffer.  */
+	if ((bp->b_flag & BFINVS) == 0	/* Not scratch buffer.  */
-        && (bp->b_flag&BFCHG) != 0              /* Something changed    */
+	    && (bp->b_flag & BFCHG) != 0	/* Something changed    */
-        && (s=mlyesno("Discard changes")) != TRUE)
+	    && (s = mlyesno("Discard changes")) != TRUE)
 		return (s);
 	bp->b_flag &= ~BFCHG;	/* Not changed          */
-        while ((lp=lforw(bp->b_linep)) != bp->b_linep)
+	while ((lp = lforw(bp->b_linep)) != bp->b_linep)
 		lfree(lp);
 	bp->b_dotp = bp->b_linep;	/* Fix "."              */
 	bp->b_doto = 0;
@@ -533,12 +534,12 @@ register BUFFER *bp;
 	return (TRUE);
 }
 
-unmark(f, n)	/* unmark the current buffers change flag */
+unmark(f, n)
-
+    /* unmark the current buffers change flag */
 int f, n;			/* unused command arguments */
 
 {
 	curbp->b_flag &= ~BFCHG;
 	curwp->w_flag |= WFMODE;
-	return(TRUE);
+	return (TRUE);
 }

crypt.c

@@ -13,8 +13,8 @@
 
 static int mod95();
 
-setkey(f, n)	/* reset encryption key of current buffer */
+setkey(f, n)
-
+    /* reset encryption key of current buffer */
 int f;				/* default flag */
 int n;				/* numeric argument */
 
@@ -31,16 +31,16 @@ int n;		/* numeric argument */
 	status = mlreply("Encryption String: ", key, NPAT - 1);
 	disinp = odisinp;
 	if (status != TRUE)
-                return(status);
+		return (status);
 
 	/* and encrypt it */
-	crypt((char *)NULL, 0);
+	crypt((char *) NULL, 0);
 	crypt(key, strlen(key));
 
 	/* and save it off */
 	strcpy(curbp->b_key, key);
 	mlwrite(" ");		/* clear it off the bottom line */
-	return(TRUE);
+	return (TRUE);
 }
 
 /**********
@@ -170,7 +170,7 @@ register unsigned len;	/* number of characters in the buffer */
 	so that the left shift here will be more portable and the 
 	mod95() faster   **/
 
-			cc = mod95((int)(key % 95) - (cc - ' ')) + ' ';
+			cc = mod95((int) (key % 95) - (cc - ' ')) + ' ';
 
 /**  the salt will spice up the key a little bit, helping to obscure 
 	any patterns in the clear text, particularly when all the 

display.c

@@ -61,21 +61,20 @@ vtinit()
 	TTopen();		/* open the screen */
 	TTkopen();		/* open the keyboard */
 	TTrev(FALSE);
-    vscreen = (VIDEO **) malloc(term.t_mrow*sizeof(VIDEO *));
+	vscreen = (VIDEO **) malloc(term.t_mrow * sizeof(VIDEO *));
 
 	if (vscreen == NULL)
 		exit(1);
 
 #if	MEMMAP == 0 || SCROLLCODE
-    pscreen = (VIDEO **) malloc(term.t_mrow*sizeof(VIDEO *));
+	pscreen = (VIDEO **) malloc(term.t_mrow * sizeof(VIDEO *));
 
 	if (pscreen == NULL)
 		exit(1);
 #endif
 
-    for (i = 0; i < term.t_mrow; ++i)
+	for (i = 0; i < term.t_mrow; ++i) {
-        {
+		vp = (VIDEO *) malloc(sizeof(VIDEO) + term.t_mcol);
-        vp = (VIDEO *) malloc(sizeof(VIDEO)+term.t_mcol);
 
 		if (vp == NULL)
 			exit(1);
@@ -87,7 +86,7 @@ vtinit()
 #endif
 		vscreen[i] = vp;
 #if	MEMMAP == 0 || SCROLLCODE
-        vp = (VIDEO *) malloc(sizeof(VIDEO)+term.t_mcol);
+		vp = (VIDEO *) malloc(sizeof(VIDEO) + term.t_mcol);
 
 		if (vp == NULL)
 			exit(1);
@@ -169,7 +168,7 @@ int c;
 		if (c == '\t') {
 			do {
 				vtputc(' ');
-			} while (((vtcol + taboff)&tabmask) != 0);
+			} while (((vtcol + taboff) & tabmask) != 0);
 		} else {
 			vtputc('^');
 			vtputc(c ^ 0x40);
@@ -200,10 +199,9 @@ vteeol()
 		always finishes complete update		*/
 
 upscreen(f, n)
-
 {
 	update(TRUE);
-	return(TRUE);
+	return (TRUE);
 }
 
 #if SCROLLCODE
@@ -226,11 +224,11 @@ int force;	/* force update past type ahead? */
 
 #if	TYPEAH && ! PKCODE
 	if (force == FALSE && typahead())
-		return(TRUE);
+		return (TRUE);
 #endif
 #if	VISMAC == 0
 	if (force == FALSE && kbdmode == PLAY)
-		return(TRUE);
+		return (TRUE);
 #endif
 
 	displaying = TRUE;
@@ -265,9 +263,10 @@ int force;	/* force update past type ahead? */
 			/* if the window has changed, service it */
 			reframe(wp);	/* check the framing */
 #if SCROLLCODE
-                        if (wp->w_flag & (WFKILLS|WFINS)) {
+			if (wp->w_flag & (WFKILLS | WFINS)) {
-                                scrflags |= (wp->w_flag & (WFINS|WFKILLS));
+				scrflags |=
-                                wp->w_flag &= ~(WFKILLS|WFINS);
+				    (wp->w_flag & (WFINS | WFKILLS));
+				wp->w_flag &= ~(WFKILLS | WFINS);
 			}
 #endif
 			if ((wp->w_flag & ~WFMODE) == WFEDIT)
@@ -311,9 +310,9 @@ int force;	/* force update past type ahead? */
 	displaying = FALSE;
 #if SIGWINCH
 	while (chg_width || chg_height)
-                newscreensize(chg_height,chg_width);
+		newscreensize(chg_height, chg_width);
 #endif
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	reframe:	check to see if the cursor is on in the window
@@ -339,7 +338,7 @@ WINDOW *wp;
 			i = -1;
 			lp = lp0;
 		}
-                for (; i <= (int)(wp->w_ntrows); i++)
+		for (; i <= (int) (wp->w_ntrows); i++)
 #else
 		lp = wp->w_linep;
 		for (i = 0; i < wp->w_ntrows; i++)
@@ -349,7 +348,7 @@ WINDOW *wp;
 			if (lp == wp->w_dotp) {
 #if SCROLLCODE
 				/* if not _quite_ in, we'll reframe gently */
-                                if ( i < 0 || i == wp->w_ntrows) {
+				if (i < 0 || i == wp->w_ntrows) {
 					/* if the terminal can't help, then
 					   we're simply outside */
 					if (term.t_scroll == NULL)
@@ -357,7 +356,7 @@ WINDOW *wp;
 					break;
 				}
 #endif
-				return(TRUE);
+				return (TRUE);
 			}
 
 			/* if we are at the end of the file, reframe */
@@ -368,7 +367,6 @@ WINDOW *wp;
 			lp = lforw(lp);
 		}
 	}
-
 #if SCROLLCODE
 	if (i == -1) {		/* we're just above the window */
 		i = scrollcount;	/* put dot at first line */
@@ -404,7 +402,7 @@ WINDOW *wp;
 	wp->w_linep = lp;
 	wp->w_flag |= WFHARD;
 	wp->w_flag &= ~WFFORCE;
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	updone:	update the current line	to the virtual screen		*/
@@ -430,7 +428,7 @@ WINDOW *wp;	/* window to update current line in */
 	vscreen[sline]->v_flag |= VFCHG;
 	vscreen[sline]->v_flag &= ~VFREQ;
 	vtmove(sline, 0);
-	for (i=0; i < llength(lp); ++i)
+	for (i = 0; i < llength(lp); ++i)
 		vtputc(lgetc(lp, i));
 #if	COLOR
 	vscreen[sline]->v_rfcolor = wp->w_fcolor;
@@ -461,7 +459,7 @@ WINDOW *wp;	/* window to update lines in */
 		vtmove(sline, 0);
 		if (lp != wp->w_bufp->b_linep) {
 			/* if we are not at the end */
-			for (i=0; i < llength(lp); ++i)
+			for (i = 0; i < llength(lp); ++i)
 				vtputc(lgetc(lp, i));
 			lp = lforw(lp);
 		}
@@ -481,7 +479,6 @@ WINDOW *wp;	/* window to update lines in */
 		lines. This is the only update for simple moves.	*/
 
 updpos()
-
 {
 	register LINE *lp;
 	register int c;
@@ -502,8 +499,7 @@ updpos()
 		c = lgetc(lp, i++);
 		if (c == '\t')
 			curcol |= tabmask;
-		else
+		else if (c < 0x20 || c == 0x7f)
-			if (c < 0x20 || c == 0x7f)
 			++curcol;
 
 		++curcol;
@@ -520,11 +516,10 @@ updpos()
 /*	upddex:	de-extend any line that derserves it		*/
 
 upddex()
-
 {
 	register WINDOW *wp;
 	register LINE *lp;
-	register int i,j;
+	register int i, j;
 
 	wp = wheadp;
 
@@ -558,10 +553,9 @@ upddex()
 		the virtual screen and force a full update		*/
 
 updgar()
-
 {
 	register char *txt;
-	register int i,j;
+	register int i, j;
 
 	for (i = 0; i < term.t_nrow; ++i) {
 		vscreen[i]->v_flag |= VFCHG;
@@ -580,7 +574,7 @@ updgar()
 	}
 
 	movecursor(0, 0);	/* Erase the screen. */
-	(*term.t_eeop)();
+	(*term.t_eeop) ();
 	sgarbf = FALSE;		/* Erase-page clears */
 	mpresf = FALSE;		/* the message area. */
 #if	COLOR
@@ -609,11 +603,11 @@ int force;	/* forced update flag */
 	for (i = 0; i < term.t_nrow; ++i) {
 		vp1 = vscreen[i];
 
-		/* for each line that needs to be updated*/
+		/* for each line that needs to be updated */
 		if ((vp1->v_flag & VFCHG) != 0) {
 #if	TYPEAH && ! PKCODE
 			if (force == FALSE && typahead())
-				return(TRUE);
+				return (TRUE);
 #endif
 #if	MEMMAP && ! SCROLLCODE
 			updateline(i, vp1);
@@ -622,33 +616,32 @@ int force;	/* forced update flag */
 #endif
 		}
 	}
-	return(TRUE);
+	return (TRUE);
 }
 
 #if SCROLLCODE
 
 /* optimize out scrolls (line breaks, and newlines) */
 /* arg. chooses between looking for inserts or deletes */
-int
+int scrolls(inserts)
-scrolls(inserts)	/* returns true if it does something */
+{				/* returns true if it does something */
-{
+	struct VIDEO *vpv;	/* virtual screen image */
-	struct	VIDEO *vpv ;	/* virtual screen image */
+	struct VIDEO *vpp;	/* physical screen image */
-	struct	VIDEO *vpp ;	/* physical screen image */
+	int i, j, k;
-	int	i, j, k ;
+	int rows, cols;
-	int	rows, cols ;
+	int first, match, count, ptarget, vtarget, end;
-	int	first, match, count, ptarget, vtarget, end ;
 	int longmatch, longcount;
 	int from, to;
 
 	if (!term.t_scroll)	/* no way to scroll */
 		return FALSE;
 
-	rows = term.t_nrow ;
+	rows = term.t_nrow;
-	cols = term.t_ncol ;
+	cols = term.t_ncol;
 
-	first = -1 ;
+	first = -1;
 	for (i = 0; i < rows; i++) {	/* find first wrong line */
-		if (!texttest(i,i)) {
+		if (!texttest(i, i)) {
 			first = i;
 			break;
 		}
@@ -657,36 +650,38 @@ scrolls(inserts)	/* returns true if it does something */
 	if (first < 0)
 		return FALSE;	/* no text changes */
 
-	vpv = vscreen[first] ;
+	vpv = vscreen[first];
-	vpp = pscreen[first] ;
+	vpp = pscreen[first];
 
 	if (inserts) {
 		/* determine types of potential scrolls */
-		end = endofline(vpv->v_text,cols) ;
+		end = endofline(vpv->v_text, cols);
-		if ( end == 0 )
+		if (end == 0)
-			ptarget = first ;		/* newlines */
+			ptarget = first;	/* newlines */
-		else if ( strncmp(vpp->v_text, vpv->v_text, end) == 0 )
+		else if (strncmp(vpp->v_text, vpv->v_text, end) == 0)
-			ptarget = first + 1 ;	/* broken line newlines */
+			ptarget = first + 1;	/* broken line newlines */
 		else
-			ptarget = first ;
+			ptarget = first;
 	} else {
-		vtarget = first + 1 ;
+		vtarget = first + 1;
 	}
 
 	/* find the matching shifted area */
-	match = -1 ;
+	match = -1;
 	longmatch = -1;
 	longcount = 0;
 	from = inserts ? ptarget : vtarget;
-	for (i = from+1; i < rows-longcount /* P.K. */; i++) {
+	for (i = from + 1; i < rows - longcount /* P.K. */ ; i++) {
-		if (inserts ? texttest(i,from) : texttest(from,i) ) {
+		if (inserts ? texttest(i, from) : texttest(from, i)) {
-			match = i ;
+			match = i;
-			count = 1 ;
+			count = 1;
-			for (j=match+1, k=from+1; j<rows && k<rows; j++, k++) {
+			for (j = match + 1, k = from + 1;
-				if (inserts ? texttest(j,k) : texttest(k,j))
+			     j < rows && k < rows; j++, k++) {
-					count++ ;
+				if (inserts ? texttest(j, k) :
+				    texttest(k, j))
+					count++;
 				else
-					break ;
+					break;
 			}
 			if (longcount < count) {
 				longcount = count;
@@ -699,15 +694,15 @@ scrolls(inserts)	/* returns true if it does something */
 
 	if (!inserts) {
 		/* full kill case? */
-		if (match > 0 && texttest(first, match-1)) {
+		if (match > 0 && texttest(first, match - 1)) {
-			vtarget-- ;
+			vtarget--;
-			match-- ;
+			match--;
-			count++ ;
+			count++;
 		}
 	}
 
 	/* do the scroll */
-	if (match>0 && count>2) {		 /* got a scroll */
+	if (match > 0 && count > 2) {	/* got a scroll */
 		/* move the count lines starting at ptarget to match */
 		if (inserts) {
 			from = ptarget;
@@ -721,32 +716,33 @@ scrolls(inserts)	/* returns true if it does something */
 			char line[NLINE];
 			sprintf(line,
 				"scrolls: move the %d lines starting at %d to %d, first %d, scrolls %d",
-				count,from,to,first, 2*count >= abs(from-to));
+				count, from, to, first,
+				2 * count >= abs(from - to));
 			mlwrite(line);
 		}
 #endif
-		if (2*count < abs(from-to))
+		if (2 * count < abs(from - to))
-			return(FALSE);
+			return (FALSE);
-		scrscroll(from, to, count) ;
+		scrscroll(from, to, count);
 		for (i = 0; i < count; i++) {
-			vpp = pscreen[to+i] ;
+			vpp = pscreen[to + i];
-			vpv = vscreen[to+i];
+			vpv = vscreen[to + i];
-			strncpy(vpp->v_text, vpv->v_text, cols) ;
+			strncpy(vpp->v_text, vpv->v_text, cols);
 			vpp->v_flag = vpv->v_flag;	/* XXX */
 			if (vpp->v_flag & VFREV) {
 				vpp->v_flag &= ~VFREV;
 				vpp->v_flag |= ~VFREQ;
 			}
 #if	MEMMAP
-			vscreen[to+i]->v_flag &= ~VFCHG;
+			vscreen[to + i]->v_flag &= ~VFCHG;
 #endif
 		}
 		if (inserts) {
 			from = ptarget;
 			to = match;
 		} else {
-			from = vtarget+count;
+			from = vtarget + count;
-			to = match+count;
+			to = match + count;
 		}
 #if	MEMMAP == 0
 		for (i = from; i < to; i++) {
@@ -757,36 +753,36 @@ scrolls(inserts)	/* returns true if it does something */
 			vscreen[i]->v_flag |= VFCHG;
 		}
 #endif
-		return(TRUE) ;
+		return (TRUE);
 	}
-	return(FALSE) ;
+	return (FALSE);
 }
 
 /* move the "count" lines starting at "from" to "to" */
 scrscroll(from, to, count)
 {
 	ttrow = ttcol = -1;
-	(*term.t_scroll)(from,to,count);
+	(*term.t_scroll) (from, to, count);
 }
 
-texttest(vrow,prow)		/* return TRUE on text match */
+texttest(vrow, prow)		/* return TRUE on text match */
-int	vrow, prow ;		/* virtual, physical rows */
+int vrow, prow;			/* virtual, physical rows */
 {
-struct	VIDEO *vpv = vscreen[vrow] ;	/* virtual screen image */
+	struct VIDEO *vpv = vscreen[vrow];	/* virtual screen image */
-struct	VIDEO *vpp = pscreen[prow]  ;	/* physical screen image */
+	struct VIDEO *vpp = pscreen[prow];	/* physical screen image */
 
-	return (!memcmp(vpv->v_text, vpp->v_text, term.t_ncol)) ;
+	return (!memcmp(vpv->v_text, vpp->v_text, term.t_ncol));
 }
 
 /* return the index of the first blank of trailing whitespace */
-int
+int endofline(s, n)
-endofline(s,n)
+char *s;
-char 	*s ;
 {
-int	i ;
+	int i;
 	for (i = n - 1; i >= 0; i--)
-		if (s[i] != ' ') return(i+1) ;
+		if (s[i] != ' ')
-	return(0) ;
+			return (i + 1);
+	return (0);
 }
 
 #endif				/* SCROLLCODE */
@@ -798,7 +794,6 @@ int	i ;
 								*/
 
 updext()
-
 {
 	register int rcursor;	/* real cursor location */
 	register LINE *lp;	/* pointer to current line */
@@ -812,7 +807,7 @@ updext()
 	/* 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 */
+	for (j = 0; j < llength(lp); ++j)	/* until the end-of-line */
 		vtputc(lgetc(lp, j));
 
 	/* truncate the virtual line, restore tab offset */
@@ -836,7 +831,7 @@ updateline(row, vp1
 #if	SCROLLCODE
 	   , vp2
 #endif
-)
+    )
 
 int row;			/* row of screen to update */
 struct VIDEO *vp1;		/* virtual screen image */
@@ -853,8 +848,7 @@ struct VIDEO *vp2;
 	cp1 = &vp1->v_text[0];
 	cp2 = &vp2->v_text[0];
 	nch = term.t_ncol;
-	do
+	do {
-        {
 		*cp2 = *cp1;
 		++cp2;
 		++cp1;
@@ -896,11 +890,10 @@ struct VIDEO *vp2;	/* physical screen image */
 
 	cp1 = &vp1->v_text[0];	/* Use fast video. */
 	cp2 = &vp2->v_text[0];
-    putline(row+1, 1, cp1);
+	putline(row + 1, 1, cp1);
 	nch = term.t_ncol;
 
-    do
+	do {
-        {
 		*cp2 = *cp1;
 		++cp2;
 		++cp1;
@@ -936,13 +929,14 @@ struct VIDEO *vp2;	/* physical screen image */
 	req = (vp1->v_flag & VFREQ) == VFREQ;
 	if ((rev != req)
 #if	COLOR
-	    || (vp1->v_fcolor != vp1->v_rfcolor) || (vp1->v_bcolor != vp1->v_rbcolor)
+	    || (vp1->v_fcolor != vp1->v_rfcolor)
+	    || (vp1->v_bcolor != vp1->v_rbcolor)
 #endif
 	    ) {
 		movecursor(row, 0);	/* Go to start of line. */
 		/* set rev video if needed */
 		if (rev != req)
-			(*term.t_rev)(req);
+			(*term.t_rev) (req);
 
 		/* scan through the line and dump it to the screen and
 		   the virtual screen array                             */
@@ -954,7 +948,7 @@ struct VIDEO *vp2;	/* physical screen image */
 		}
 		/* turn rev video off */
 		if (rev != req)
-			(*term.t_rev)(FALSE);
+			(*term.t_rev) (FALSE);
 
 		/* update the needed flags */
 		vp1->v_flag &= ~VFCHG;
@@ -966,7 +960,7 @@ struct VIDEO *vp2;	/* physical screen image */
 		vp1->v_fcolor = vp1->v_rfcolor;
 		vp1->v_bcolor = vp1->v_rbcolor;
 #endif
-		return(TRUE);
+		return (TRUE);
 	}
 #endif
 
@@ -985,7 +979,7 @@ struct VIDEO *vp2;	/* physical screen image */
 	/* if both lines are the same, no update needs to be done */
 	if (cp1 == &vp1->v_text[term.t_ncol]) {
 		vp1->v_flag &= ~VFCHG;	/* flag this line is changed */
-		return(TRUE);
+		return (TRUE);
 	}
 
 	/* find out if there is a match on the right */
@@ -1004,10 +998,10 @@ struct VIDEO *vp2;	/* physical screen image */
 
 	/* Erase to EOL ? */
 	if (nbflag == FALSE && eolexist == TRUE && (req != TRUE)) {
-		while (cp5!=cp1 && cp5[-1]==' ')
+		while (cp5 != cp1 && cp5[-1] == ' ')
 			--cp5;
 
-		if (cp3-cp5 <= 3)		/* Use only if erase is */
+		if (cp3 - cp5 <= 3)	/* Use only if erase is */
 			cp5 = cp3;	/* fewer characters. */
 	}
 
@@ -1031,7 +1025,7 @@ struct VIDEO *vp2;	/* physical screen image */
 	TTrev(FALSE);
 #endif
 	vp1->v_flag &= ~VFCHG;	/* flag this line as updated */
-	return(TRUE);
+	return (TRUE);
 #endif
 }
 #endif
@@ -1043,7 +1037,7 @@ struct VIDEO *vp2;	/* physical screen image */
  * any time there is a dirty window.
  */
 modeline(wp)
-    WINDOW *wp;
+WINDOW *wp;
 {
 	register char *cp;
 	register int c;
@@ -1054,11 +1048,11 @@ modeline(wp)
 	register int firstm;	/* is this the first mode? */
 	char tline[NLINE];	/* buffer for part of mode line */
 
-    n = wp->w_toprow+wp->w_ntrows;      	/* Location. */
+	n = wp->w_toprow + wp->w_ntrows;	/* Location. */
-    vscreen[n]->v_flag |= VFCHG | VFREQ | VFCOL;/* Redraw next time. */
+	vscreen[n]->v_flag |= VFCHG | VFREQ | VFCOL;	/* Redraw next time. */
 #if	COLOR
 	vscreen[n]->v_rfcolor = 0;	/* black on */
-    vscreen[n]->v_rbcolor = 7;			/* white.....*/
+	vscreen[n]->v_rbcolor = 7;	/* white..... */
 #endif
 	vtmove(n, 0);		/* Seek to right line. */
 	if (wp == curwp)	/* mark the current buffer */
@@ -1077,13 +1071,13 @@ modeline(wp)
 
 	bp = wp->w_bufp;
 #if	PKCODE == 0
-    if ((bp->b_flag&BFTRUNC) != 0)
+	if ((bp->b_flag & BFTRUNC) != 0)
 		vtputc('#');
 	else
 #endif
 		vtputc(lchar);
 
-    if ((bp->b_flag&BFCHG) != 0)                /* "*" if changed. */
+	if ((bp->b_flag & BFCHG) != 0)	/* "*" if changed. */
 		vtputc('*');
 	else
 		vtputc(lchar);
@@ -1096,15 +1090,13 @@ modeline(wp)
 	strcat(tline, VERSION);
 	strcat(tline, ": ");
 	cp = &tline[0];
-    while ((c = *cp++) != 0)
+	while ((c = *cp++) != 0) {
-    {
 		vtputc(c);
 		++n;
 	}
 
 	cp = &bp->b_bname[0];
-    while ((c = *cp++) != 0)
+	while ((c = *cp++) != 0) {
-    {
 		vtputc(c);
 		++n;
 	}
@@ -1114,8 +1106,7 @@ modeline(wp)
 	/* display the modes */
 
 	firstm = TRUE;
-	if ((bp->b_flag&BFTRUNC) != 0)
+	if ((bp->b_flag & BFTRUNC) != 0) {
-	{
 		firstm = FALSE;
 		strcat(tline, "Truncated");
 	}
@@ -1126,30 +1117,28 @@ modeline(wp)
 			firstm = FALSE;
 			strcat(tline, mode2name[i]);
 		}
-	strcat(tline,") ");
+	strcat(tline, ") ");
 
 	cp = &tline[0];
-    while ((c = *cp++) != 0)
+	while ((c = *cp++) != 0) {
-    {
 		vtputc(c);
 		++n;
 	}
 
 #if 0
 	vtputc(lchar);
-    vtputc((wp->w_flag&WFCOLR) != 0  ? 'C' : lchar);
+	vtputc((wp->w_flag & WFCOLR) != 0 ? 'C' : lchar);
-    vtputc((wp->w_flag&WFMODE) != 0  ? 'M' : lchar);
+	vtputc((wp->w_flag & WFMODE) != 0 ? 'M' : lchar);
-    vtputc((wp->w_flag&WFHARD) != 0  ? 'H' : lchar);
+	vtputc((wp->w_flag & WFHARD) != 0 ? 'H' : lchar);
-    vtputc((wp->w_flag&WFEDIT) != 0  ? 'E' : lchar);
+	vtputc((wp->w_flag & WFEDIT) != 0 ? 'E' : lchar);
-    vtputc((wp->w_flag&WFMOVE) != 0  ? 'V' : lchar);
+	vtputc((wp->w_flag & WFMOVE) != 0 ? 'V' : lchar);
-    vtputc((wp->w_flag&WFFORCE) != 0 ? 'F' : lchar);
+	vtputc((wp->w_flag & WFFORCE) != 0 ? 'F' : lchar);
 	vtputc(lchar);
 	n += 8;
 #endif
 
 #if	PKCODE
-    if (bp->b_fname[0] != 0 &&
+	if (bp->b_fname[0] != 0 && strcmp(bp->b_bname, bp->b_fname) != 0)
-    	strcmp(bp->b_bname, bp->b_fname) != 0)
 #else
 	if (bp->b_fname[0] != 0)	/* File name. */
 #endif
@@ -1157,8 +1146,7 @@ modeline(wp)
 #if	PKCODE == 0
 		cp = "File: ";
 
-        while ((c = *cp++) != 0)
+		while ((c = *cp++) != 0) {
-            {
 			vtputc(c);
 			++n;
 		}
@@ -1166,8 +1154,7 @@ modeline(wp)
 
 		cp = &bp->b_fname[0];
 
-        while ((c = *cp++) != 0)
+		while ((c = *cp++) != 0) {
-            {
 			vtputc(c);
 			++n;
 		}
@@ -1176,8 +1163,7 @@ modeline(wp)
 		++n;
 	}
 
-    while (n < term.t_ncol)             /* Pad to full width. */
+	while (n < term.t_ncol) {	/* Pad to full width. */
-        {
 		vtputc(lchar);
 		++n;
 	}
@@ -1205,8 +1191,7 @@ modeline(wp)
 				msg = " Top ";
 			}
 		}
-		if (!msg)
+		if (!msg) {
-		{
 			LINE *lp;
 			int numlines, predlines, ratio;
 
@@ -1224,7 +1209,8 @@ modeline(wp)
 			} else {
 				ratio = 0;
 				if (numlines != 0)
-					ratio = (100L*predlines) / numlines;
+					ratio =
+					    (100L * predlines) / numlines;
 				if (ratio > 99)
 					ratio = 99;
 				sprintf(tline, " %2d%% ", ratio);
@@ -1233,17 +1219,15 @@ modeline(wp)
 		}
 
 		cp = msg;
-	        while ((c = *cp++) != 0)
+		while ((c = *cp++) != 0) {
-        	{
 			vtputc(c);
 			++n;
 		}
 	}
 }
 
-upmode()	/* update all the mode lines */
+upmode()
-
+{				/* update all the mode lines */
-{
 	register WINDOW *wp;
 
 	wp = wheadp;
@@ -1259,14 +1243,13 @@ upmode()	/* update all the mode lines */
  * random calls. Update "ttrow" and "ttcol".
  */
 movecursor(row, col)
-    {
+{
-    if (row!=ttrow || col!=ttcol)
+	if (row != ttrow || col != ttcol) {
-        {
 		ttrow = row;
 		ttcol = col;
 		TTmove(row, col);
 	}
-    }
+}
 
 /*
  * Erase the message line. This is a special routine because the message line
@@ -1274,7 +1257,7 @@ movecursor(row, col)
  * immediately; the terminal buffer is flushed via a call to the flusher.
  */
 mlerase()
-    {
+{
 	int i;
 
 	movecursor(term.t_nrow, 0);
@@ -1295,7 +1278,7 @@ mlerase()
 	}
 	TTflush();
 	mpresf = FALSE;
-    }
+}
 
 /*
  * Write a message into the message line. Keep track of the physical cursor
@@ -1318,7 +1301,6 @@ char *arg;	/* pointer to first argument to print */
 		movecursor(term.t_nrow, 0);
 		return;
 	}
-
 #if	COLOR
 	/* set up the proper colors for the command line */
 	TTforg(7);
@@ -1342,36 +1324,36 @@ char *arg;	/* pointer to first argument to print */
 			switch (c) {
 #if	PKCODE
 			case '*':
-					ap = *(char **)ap;
+				ap = *(char **) ap;
 				break;
 #endif
 			case 'd':
-					mlputi(*(int *)ap, 10);
+				mlputi(*(int *) ap, 10);
 				ap += sizeof(int);
 				break;
 
 			case 'o':
-					mlputi(*(int *)ap,  8);
+				mlputi(*(int *) ap, 8);
 				ap += sizeof(int);
 				break;
 
 			case 'x':
-					mlputi(*(int *)ap, 16);
+				mlputi(*(int *) ap, 16);
 				ap += sizeof(int);
 				break;
 
 			case 'D':
-					mlputli(*(long *)ap, 10);
+				mlputli(*(long *) ap, 10);
 				ap += sizeof(long);
 				break;
 
 			case 's':
-					mlputs(*(char **)ap);
+				mlputs(*(char **) ap);
 				ap += sizeof(char *);
 				break;
 
 			case 'f':
-					mlputf(*(int *)ap);
+				mlputf(*(int *) ap);
 				ap += sizeof(int);
 				break;
 
@@ -1413,63 +1395,60 @@ char *s;	/* string to force out */
  * things will get screwed up a little.
  */
 mlputs(s)
-    char *s;
+char *s;
-    {
+{
 	register int c;
 
-    while ((c = *s++) != 0)
+	while ((c = *s++) != 0) {
-        {
 		TTputc(c);
 		++ttcol;
 	}
-    }
+}
 
 /*
  * Write out an integer, in the specified radix. Update the physical cursor
  * position.
  */
 mlputi(i, r)
-    {
+{
 	register int q;
 	static char hexdigits[] = "0123456789ABCDEF";
 
-    if (i < 0)
+	if (i < 0) {
-        {
 		i = -i;
 		TTputc('-');
 	}
 
-    q = i/r;
+	q = i / r;
 
 	if (q != 0)
 		mlputi(q, r);
 
-    TTputc(hexdigits[i%r]);
+	TTputc(hexdigits[i % r]);
 	++ttcol;
-    }
+}
 
 /*
  * do the same except as a long integer.
  */
 mlputli(l, r)
-    long l;
+long l;
-    {
+{
 	register long q;
 
-    if (l < 0)
+	if (l < 0) {
-        {
 		l = -l;
 		TTputc('-');
 	}
 
-    q = l/r;
+	q = l / r;
 
 	if (q != 0)
 		mlputli(q, r);
 
-    TTputc((int)(l%r)+'0');
+	TTputc((int) (l % r) + '0');
 	++ttcol;
-    }
+}
 
 /*
  *	write out a scaled integer with two decimal places
@@ -1498,30 +1477,30 @@ int s;	/* scaled integer to output */
 #if RAINBOW
 
 putline(row, col, buf)
-    int row, col;
+int row, col;
-    char buf[];
+char buf[];
-    {
+{
 	int n;
 
 	n = strlen(buf);
 	if (col + n - 1 > term.t_ncol)
 		n = term.t_ncol - col + 1;
 	Put_Data(row, col, n, buf);
-    }
+}
 #endif
 
 /* Get terminal size from system.
    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)
+getscreensize(widthp, heightp)
 int *widthp, *heightp;
 {
 #ifdef TIOCGWINSZ
 	struct winsize size;
 	*widthp = 0;
 	*heightp = 0;
-        if (ioctl (0, TIOCGWINSZ, &size) < 0)
+	if (ioctl(0, TIOCGWINSZ, &size) < 0)
 		return;
 	*widthp = size.ws_col;
 	*heightp = size.ws_row;
@@ -1539,16 +1518,16 @@ int signr;
 	extern int errno;
 	int old_errno = errno;
 
-        getscreensize (&w, &h);
+	getscreensize(&w, &h);
 
-        if (h && w && (h-1 != term.t_nrow || w != term.t_ncol))
+	if (h && w && (h - 1 != term.t_nrow || w != term.t_ncol))
 		newscreensize(h, w);
 
-        signal (SIGWINCH, sizesignal);
+	signal(SIGWINCH, sizesignal);
 	errno = old_errno;
 }
 
-newscreensize (h, w) 
+newscreensize(h, w)
 int h, w;
 {
 	/* do the change later */
@@ -1559,13 +1538,12 @@ int h, w;
 	}
 	chg_width = chg_height = 0;
 	if (h - 1 < term.t_mrow)
-                newsize(TRUE,h);
+		newsize(TRUE, h);
 	if (w < term.t_mcol)
-                newwidth(TRUE,w);
+		newwidth(TRUE, w);
 
 	update(TRUE);
 	return TRUE;
 }
 
 #endif
-

ebind.h

@@ -12,238 +12,407 @@
  * control-X commands.
  */
 KEYTAB keytab[NBINDS] = {
-	{CONTROL|'A',	gotobol},
+	{CONTROL | 'A', gotobol}
-	{CONTROL|'B',	backchar},
+	,
-	{CONTROL|'C',	insspace},
+	{CONTROL | 'B', backchar}
-	{CONTROL|'D',	forwdel},
+	,
-	{CONTROL|'E',	gotoeol},
+	{CONTROL | 'C', insspace}
-	{CONTROL|'F',	forwchar},
+	,
-	{CONTROL|'G',	ctrlg},
+	{CONTROL | 'D', forwdel}
-	{CONTROL|'H',	backdel},
+	,
-	{CONTROL|'I',	tab},
+	{CONTROL | 'E', gotoeol}
-	{CONTROL|'J',	indent},
+	,
-	{CONTROL|'K',	killtext},
+	{CONTROL | 'F', forwchar}
-	{CONTROL|'L',	refresh},
+	,
-	{CONTROL|'M',	newline},
+	{CONTROL | 'G', ctrlg}
-	{CONTROL|'N',	forwline},
+	,
-	{CONTROL|'O',	openline},
+	{CONTROL | 'H', backdel}
-	{CONTROL|'P',	backline},
+	,
-	{CONTROL|'Q',	quote},
+	{CONTROL | 'I', tab}
-	{CONTROL|'R',	backsearch},
+	,
-	{CONTROL|'S',	forwsearch},
+	{CONTROL | 'J', indent}
-	{CONTROL|'T',	twiddle},
+	,
-	{CONTROL|'U',	unarg},
+	{CONTROL | 'K', killtext}
-	{CONTROL|'V',	forwpage},
+	,
-	{CONTROL|'W',	killregion},
+	{CONTROL | 'L', refresh}
-	{CONTROL|'X',	cex},
+	,
-	{CONTROL|'Y',	yank},
+	{CONTROL | 'M', newline}
-	{CONTROL|'Z',	backpage},
+	,
-	{CONTROL|']',	meta},
+	{CONTROL | 'N', forwline}
-	{CTLX|CONTROL|'B',	listbuffers},
+	,
-	{CTLX|CONTROL|'C',	quit},          /* Hard quit.           */
+	{CONTROL | 'O', openline}
+	,
+	{CONTROL | 'P', backline}
+	,
+	{CONTROL | 'Q', quote}
+	,
+	{CONTROL | 'R', backsearch}
+	,
+	{CONTROL | 'S', forwsearch}
+	,
+	{CONTROL | 'T', twiddle}
+	,
+	{CONTROL | 'U', unarg}
+	,
+	{CONTROL | 'V', forwpage}
+	,
+	{CONTROL | 'W', killregion}
+	,
+	{CONTROL | 'X', cex}
+	,
+	{CONTROL | 'Y', yank}
+	,
+	{CONTROL | 'Z', backpage}
+	,
+	{CONTROL | ']', meta}
+	,
+	{CTLX | CONTROL | 'B', listbuffers}
+	,
+	{CTLX | CONTROL | 'C', quit}
+	,			/* Hard quit.           */
 #if	PKCODE & AEDIT
-	{CTLX|CONTROL|'A',	detab},
+	{CTLX | CONTROL | 'A', detab}
+	,
 #endif
 #if	PKCODE
-	{CTLX|CONTROL|'D',	filesave},	/* alternative		*/
+	{CTLX | CONTROL | 'D', filesave}
+	,			/* alternative          */
 #else
 #if	AEDIT
-	{CTLX|CONTROL|'D',	detab},
+	{CTLX | CONTROL | 'D', detab}
+	,
 #endif
 #endif
 #if	AEDIT
-	{CTLX|CONTROL|'E',	entab},
+	{CTLX | CONTROL | 'E', entab}
+	,
 #endif
-	{CTLX|CONTROL|'F',	filefind},
+	{CTLX | CONTROL | 'F', filefind}
-	{CTLX|CONTROL|'I',	insfile},
+	,
-	{CTLX|CONTROL|'L',	lowerregion},
+	{CTLX | CONTROL | 'I', insfile}
-	{CTLX|CONTROL|'M',	delmode},
+	,
-	{CTLX|CONTROL|'N',	mvdnwind},
+	{CTLX | CONTROL | 'L', lowerregion}
-	{CTLX|CONTROL|'O',	deblank},
+	,
-	{CTLX|CONTROL|'P',	mvupwind},
+	{CTLX | CONTROL | 'M', delmode}
-	{CTLX|CONTROL|'R',	fileread},
+	,
-	{CTLX|CONTROL|'S',	filesave},
+	{CTLX | CONTROL | 'N', mvdnwind}
+	,
+	{CTLX | CONTROL | 'O', deblank}
+	,
+	{CTLX | CONTROL | 'P', mvupwind}
+	,
+	{CTLX | CONTROL | 'R', fileread}
+	,
+	{CTLX | CONTROL | 'S', filesave}
+	,
 #if	AEDIT
-	{CTLX|CONTROL|'T',	trim},
+	{CTLX | CONTROL | 'T', trim}
+	,
 #endif
-	{CTLX|CONTROL|'U',	upperregion},
+	{CTLX | CONTROL | 'U', upperregion}
-	{CTLX|CONTROL|'V',	viewfile},
+	,
-	{CTLX|CONTROL|'W',	filewrite},
+	{CTLX | CONTROL | 'V', viewfile}
-	{CTLX|CONTROL|'X',	swapmark},
+	,
-	{CTLX|CONTROL|'Z',	shrinkwind},
+	{CTLX | CONTROL | 'W', filewrite}
-	{CTLX|'?',		deskey},
+	,
-	{CTLX|'!',		spawn},
+	{CTLX | CONTROL | 'X', swapmark}
-	{CTLX|'@',		pipecmd},
+	,
-	{CTLX|'#',		filter},
+	{CTLX | CONTROL | 'Z', shrinkwind}
-	{CTLX|'$',		execprg},
+	,
-	{CTLX|'=',		showcpos},
+	{CTLX | '?', deskey}
-	{CTLX|'(',		ctlxlp},
+	,
-	{CTLX|')',		ctlxrp},
+	{CTLX | '!', spawn}
-	{CTLX|'^',		enlargewind},
+	,
-	{CTLX|'0',		delwind},
+	{CTLX | '@', pipecmd}
-	{CTLX|'1',		onlywind},
+	,
-	{CTLX|'2',		splitwind},
+	{CTLX | '#', filter}
-	{CTLX|'A',		setvar},
+	,
-	{CTLX|'B',		usebuffer},
+	{CTLX | '$', execprg}
-	{CTLX|'C',		spawncli},
+	,
+	{CTLX | '=', showcpos}
+	,
+	{CTLX | '(', ctlxlp}
+	,
+	{CTLX | ')', ctlxrp}
+	,
+	{CTLX | '^', enlargewind}
+	,
+	{CTLX | '0', delwind}
+	,
+	{CTLX | '1', onlywind}
+	,
+	{CTLX | '2', splitwind}
+	,
+	{CTLX | 'A', setvar}
+	,
+	{CTLX | 'B', usebuffer}
+	,
+	{CTLX | 'C', spawncli}
+	,
 #if	BSD | __hpux | SVR4
-	{CTLX|'D',		bktoshell},
+	{CTLX | 'D', bktoshell}
+	,
 #endif
-	{CTLX|'E',		ctlxe},
+	{CTLX | 'E', ctlxe}
-	{CTLX|'F',		setfillcol},
+	,
-	{CTLX|'K',		killbuffer},
+	{CTLX | 'F', setfillcol}
-	{CTLX|'M',		setmode},
+	,
-	{CTLX|'N',		filename},
+	{CTLX | 'K', killbuffer}
-	{CTLX|'O',		nextwind},
+	,
-	{CTLX|'P',		prevwind},
+	{CTLX | 'M', setmode}
+	,
+	{CTLX | 'N', filename}
+	,
+	{CTLX | 'O', nextwind}
+	,
+	{CTLX | 'P', prevwind}
+	,
 #if	PKCODE
-	{CTLX|'Q',		quote},		/* alternative	*/
+	{CTLX | 'Q', quote}
+	,			/* alternative  */
 #endif
 #if	ISRCH
-	{CTLX|'R',		risearch},
+	{CTLX | 'R', risearch}
-	{CTLX|'S',		fisearch},
+	,
+	{CTLX | 'S', fisearch}
+	,
 #endif
-	{CTLX|'W',		resize},
+	{CTLX | 'W', resize}
-	{CTLX|'X',		nextbuffer},
+	,
-	{CTLX|'Z',		enlargewind},
+	{CTLX | 'X', nextbuffer}
+	,
+	{CTLX | 'Z', enlargewind}
+	,
 #if	WORDPRO
-	{META|CONTROL|'C',	wordcount},
+	{META | CONTROL | 'C', wordcount}
+	,
 #endif
 #if	PKCODE
-	{META|CONTROL|'D',	newsize},
+	{META | CONTROL | 'D', newsize}
+	,
 #endif
 #if	PROC
-	{META|CONTROL|'E',	execproc},
+	{META | CONTROL | 'E', execproc}
+	,
 #endif
 #if	CFENCE
-	{META|CONTROL|'F',	getfence},
+	{META | CONTROL | 'F', getfence}
+	,
 #endif
-	{META|CONTROL|'H',	delbword},
+	{META | CONTROL | 'H', delbword}
-	{META|CONTROL|'K',	unbindkey},
+	,
-	{META|CONTROL|'L',	reposition},
+	{META | CONTROL | 'K', unbindkey}
-	{META|CONTROL|'M',	delgmode},
+	,
-	{META|CONTROL|'N',	namebuffer},
+	{META | CONTROL | 'L', reposition}
-	{META|CONTROL|'R',	qreplace},
+	,
-	{META|CONTROL|'S',	newsize},
+	{META | CONTROL | 'M', delgmode}
-	{META|CONTROL|'T',	newwidth},
+	,
-	{META|CONTROL|'V',	scrnextdw},
+	{META | CONTROL | 'N', namebuffer}
+	,
+	{META | CONTROL | 'R', qreplace}
+	,
+	{META | CONTROL | 'S', newsize}
+	,
+	{META | CONTROL | 'T', newwidth}
+	,
+	{META | CONTROL | 'V', scrnextdw}
+	,
 #if	WORDPRO
-	{META|CONTROL|'W',	killpara},
+	{META | CONTROL | 'W', killpara}
+	,
 #endif
-	{META|CONTROL|'Z',	scrnextup},
+	{META | CONTROL | 'Z', scrnextup}
-	{META|' ',		setmark},
+	,
-	{META|'?',		help},
+	{META | ' ', setmark}
-	{META|'!',		reposition},
+	,
-	{META|'.',		setmark},
+	{META | '?', help}
-	{META|'>',		gotoeob},
+	,
-	{META|'<',		gotobob},
+	{META | '!', reposition}
-	{META|'~',		unmark},
+	,
+	{META | '.', setmark}
+	,
+	{META | '>', gotoeob}
+	,
+	{META | '<', gotobob}
+	,
+	{META | '~', unmark}
+	,
 #if	APROP
-	{META|'A',		apro},
+	{META | 'A', apro}
+	,
 #endif
-	{META|'B',		backword},
+	{META | 'B', backword}
-	{META|'C',		capword},
+	,
-	{META|'D',		delfword},
+	{META | 'C', capword}
+	,
+	{META | 'D', delfword}
+	,
 #if	CRYPT
-	{META|'E',		setkey},
+	{META | 'E', setkey}
+	,
 #endif
-	{META|'F',		forwword},
+	{META | 'F', forwword}
-	{META|'G',		gotoline},
+	,
+	{META | 'G', gotoline}
+	,
 #if	PKCODE
 #if	WORDPRO
-	{META|'J',		justpara},
+	{META | 'J', justpara}
+	,
 #endif
 #endif
-	{META|'K',		bindtokey},
+	{META | 'K', bindtokey}
-	{META|'L',		lowerword},
+	,
-	{META|'M',		setgmode},
+	{META | 'L', lowerword}
+	,
+	{META | 'M', setgmode}
+	,
 #if	WORDPRO
-	{META|'N',		gotoeop},
+	{META | 'N', gotoeop}
-	{META|'P',		gotobop},
+	,
-	{META|'Q',		fillpara},
+	{META | 'P', gotobop}
+	,
+	{META | 'Q', fillpara}
+	,
 #endif
-	{META|'R',		sreplace},
+	{META | 'R', sreplace}
+	,
 #if	PKCODE
-	{META|'S',		forwsearch},	/* alternative P.K.	*/
+	{META | 'S', forwsearch}
+	,			/* alternative P.K.     */
 #else
 #if	BSD
-	{META|'S',		bktoshell},
+	{META | 'S', bktoshell}
+	,
 #endif
 #endif
-	{META|'U',		upperword},
+	{META | 'U', upperword}
-	{META|'V',		backpage},
+	,
-	{META|'W',		copyregion},
+	{META | 'V', backpage}
-	{META|'X',		namedcmd},
+	,
-	{META|'Z',		quickexit},
+	{META | 'W', copyregion}
-	{META|0x7F,             delbword},
+	,
+	{META | 'X', namedcmd}
+	,
+	{META | 'Z', quickexit}
+	,
+	{META | 0x7F, delbword}
+	,
 
 #if	MSDOS
-	{SPEC|CONTROL|'_',	forwhunt},
+	{SPEC | CONTROL | '_', forwhunt}
-	{SPEC|CONTROL|'S',	backhunt},
+	,
-	{SPEC|71,		gotobol},
+	{SPEC | CONTROL | 'S', backhunt}
-	{SPEC|72,		backline},
+	,
-	{SPEC|73,		backpage},
+	{SPEC | 71, gotobol}
-	{SPEC|75,		backchar},
+	,
-	{SPEC|77,		forwchar},
+	{SPEC | 72, backline}
-	{SPEC|79,		gotoeol},
+	,
-	{SPEC|80,		forwline},
+	{SPEC | 73, backpage}
-	{SPEC|81,		forwpage},
+	,
-	{SPEC|82,		insspace},
+	{SPEC | 75, backchar}
-	{SPEC|83,		forwdel},
+	,
-	{SPEC|115,		backword},
+	{SPEC | 77, forwchar}
-	{SPEC|116,		forwword},
+	,
+	{SPEC | 79, gotoeol}
+	,
+	{SPEC | 80, forwline}
+	,
+	{SPEC | 81, forwpage}
+	,
+	{SPEC | 82, insspace}
+	,
+	{SPEC | 83, forwdel}
+	,
+	{SPEC | 115, backword}
+	,
+	{SPEC | 116, forwword}
+	,
 #if	WORDPRO
-	{SPEC|132,		gotobop},
+	{SPEC | 132, gotobop}
-	{SPEC|118,		gotoeop},
+	,
+	{SPEC | 118, gotoeop}
+	,
 #endif
-	{SPEC|84,		cbuf1},
+	{SPEC | 84, cbuf1}
-	{SPEC|85,		cbuf2},
+	,
-	{SPEC|86,		cbuf3},
+	{SPEC | 85, cbuf2}
-	{SPEC|87,		cbuf4},
+	,
-	{SPEC|88,		cbuf5},
+	{SPEC | 86, cbuf3}
-	{SPEC|89,		cbuf6},
+	,
-	{SPEC|90,		cbuf7},
+	{SPEC | 87, cbuf4}
-	{SPEC|91,		cbuf8},
+	,
-	{SPEC|92,		cbuf9},
+	{SPEC | 88, cbuf5}
-	{SPEC|93,		cbuf10},
+	,
+	{SPEC | 89, cbuf6}
+	,
+	{SPEC | 90, cbuf7}
+	,
+	{SPEC | 91, cbuf8}
+	,
+	{SPEC | 92, cbuf9}
+	,
+	{SPEC | 93, cbuf10}
+	,
 #if PKCODE
-	{SPEC|117,		gotoeob},
+	{SPEC | 117, gotoeob}
-	{SPEC|119,		gotobob},
+	,
-	{SPEC|141,		gotobop},
+	{SPEC | 119, gotobob}
-	{SPEC|145,		gotoeop},
+	,
-	{SPEC|146,		yank},
+	{SPEC | 141, gotobop}
-	{SPEC|147,		killregion},
+	,
+	{SPEC | 145, gotoeop}
+	,
+	{SPEC | 146, yank}
+	,
+	{SPEC | 147, killregion}
+	,
 #endif
 #endif
 
 #if	VT220
-	{SPEC|'1',		fisearch},	/* VT220 keys	*/
+	{SPEC | '1', fisearch}
-	{SPEC|'2',		yank},
+	,			/* VT220 keys   */
-	{SPEC|'3',		killregion},
+	{SPEC | '2', yank}
-	{SPEC|'4',		setmark},
+	,
-	{SPEC|'5',		backpage},
+	{SPEC | '3', killregion}
-	{SPEC|'6',		forwpage},
+	,
-	{SPEC|'A',		backline},
+	{SPEC | '4', setmark}
-	{SPEC|'B',		forwline},
+	,
-	{SPEC|'C',		forwchar},
+	{SPEC | '5', backpage}
-	{SPEC|'D',		backchar},
+	,
-	{SPEC|'c',		meta},
+	{SPEC | '6', forwpage}
-	{SPEC|'d',		backchar},
+	,
-	{SPEC|'e',		forwline},
+	{SPEC | 'A', backline}
-	{SPEC|'f',		gotobob},
+	,
-	{SPEC|'h',		help},
+	{SPEC | 'B', forwline}
-	{SPEC|'i',		cex},
+	,
+	{SPEC | 'C', forwchar}
+	,
+	{SPEC | 'D', backchar}
+	,
+	{SPEC | 'c', meta}
+	,
+	{SPEC | 'd', backchar}
+	,
+	{SPEC | 'e', forwline}
+	,
+	{SPEC | 'f', gotobob}
+	,
+	{SPEC | 'h', help}
+	,
+	{SPEC | 'i', cex}
+	,
 #endif
 
-	{0x7F,			backdel},
+	{0x7F, backdel}
+	,
 
 	/* special internal bindings */
-	SPEC|META|'W',		wrapword,	/* called on word wrap */
+	SPEC | META | 'W', wrapword,	/* called on word wrap */
-	SPEC|META|'C',		nullproc,	/*  every command input */
+	SPEC | META | 'C', nullproc,	/*  every command input */
-	SPEC|META|'R',		nullproc,	/*  on file read */
+	SPEC | META | 'R', nullproc,	/*  on file read */
-	SPEC|META|'X',		nullproc,	/*  on window change P.K. */
+	SPEC | META | 'X', nullproc,	/*  on window change P.K. */
 
 	{0, NULL}
 };
-
-

edef.h

@@ -46,10 +46,12 @@ int	revexist = FALSE;		/* does reverse video exist?	*/
 int flickcode = FALSE;		/* do flicker supression?       */
 char *modename[] = {		/* name of modes                */
 	"WRAP", "CMODE", "SPELL", "EXACT", "VIEW", "OVER",
-	"MAGIC", "CRYPT", "ASAVE"};
+	"MAGIC", "CRYPT", "ASAVE"
+};
 char *mode2name[] = {		/* name of modes                */
 	"Wrap", "Cmode", "Spell", "Exact", "View", "Over",
-	"Magic", "Crypt", "Asave"};
+	"Magic", "Crypt", "Asave"
+};
 char modecode[] = "WCSEVOMYA";	/* letters to represent modes   */
 int gmode = 0;			/* global editor mode           */
 int gflags = GFREAD;		/* global control flag          */
@@ -58,7 +60,7 @@ int	gfcolor = 8;			/* global forgrnd color (white)	*/
 #else
 int gfcolor = 7;		/* global forgrnd color (white) */
 #endif
-int	gbcolor	= 0;			/* global backgrnd color (black)*/
+int gbcolor = 0;		/* global backgrnd color (black) */
 int gasave = 256;		/* global ASAVE size            */
 int gacount = 256;		/* count until next ASAVE       */
 int sgarbf = TRUE;		/* TRUE if screen is garbage    */
@@ -67,7 +69,7 @@ int	clexec	= FALSE;		/* command line execution flag	*/
 int mstore = FALSE;		/* storing text to macro flag   */
 int discmd = TRUE;		/* display command flag         */
 int disinp = TRUE;		/* display input characters     */
-struct	BUFFER *bstore = NULL;		/* buffer to store macro text to*/
+struct BUFFER *bstore = NULL;	/* buffer to store macro text to */
 int vtrow = 0;			/* Row location of SW cursor */
 int vtcol = 0;			/* Column location of SW cursor */
 int ttrow = HUGE;		/* Row location of HW cursor */
@@ -86,9 +88,9 @@ char	*cname[] = {			/* names of colors		*/
 	"BLACK", "RED", "GREEN", "YELLOW", "BLUE",
 	"MAGENTA", "CYAN", "WHITE"
 #if	PKCODE & IBMPC
-       ,"HIGH"
+	    , "HIGH"
 #endif
-              };
+};
 KILL *kbufp = NULL;		/* current kill buffer chunk pointer    */
 KILL *kbufh = NULL;		/* kill buffer header pointer           */
 int kused = KBLOCK;		/* # of bytes used in kill buffer       */
@@ -212,7 +214,7 @@ extern	NBIND names[];			/* name to function table	*/
 extern int gmode;		/* global editor mode           */
 extern int gflags;		/* global control flag          */
 extern int gfcolor;		/* global forgrnd color (white) */
-extern	int	gbcolor;		/* global backgrnd color (black)*/
+extern int gbcolor;		/* global backgrnd color (black) */
 extern int gasave;		/* global ASAVE size            */
 extern int gacount;		/* count until next ASAVE       */
 extern int sgarbf;		/* State of screen unknown      */
@@ -221,7 +223,7 @@ extern	int	clexec;			/* command line execution flag	*/
 extern int mstore;		/* storing text to macro flag   */
 extern int discmd;		/* display command flag         */
 extern int disinp;		/* display input characters     */
-extern	struct	BUFFER *bstore;		/* buffer to store macro text to*/
+extern struct BUFFER *bstore;	/* buffer to store macro text to */
 extern int vtrow;		/* Row location of SW cursor */
 extern int vtcol;		/* Column location of SW cursor */
 extern int ttrow;		/* Row location of HW cursor */
@@ -319,5 +321,3 @@ extern char outline[];		/* global string to hold debug line text */
 #ifndef	termdef
 extern TERM term;		/* Terminal information.        */
 #endif
-
-

efunc.h

@@ -79,8 +79,8 @@ extern  int     copyregion();           /* Copy region to kill buffer.  */
 extern int spawncli();		/* Run CLI in a subjob.         */
 extern int spawn();		/* Run a command in a subjob.   */
 #if	BSD | __hpux | SVR4
-extern	int	bktoshell();		/* suspend emacs to parent shell*/
+extern int bktoshell();		/* suspend emacs to parent shell */
-extern	int	rtfrmshell();		/* return from a suspended state*/
+extern int rtfrmshell();	/* return from a suspended state */
 #endif
 extern int quickexit();		/* low keystroke style exit.    */
 extern int setmode();		/* set an editor mode           */
@@ -116,7 +116,7 @@ extern	int	setgmode();		/* set a global mode		*/
 extern int delgmode();		/* delete a global mode         */
 extern int insspace();		/* insert a space forword       */
 extern int forwhunt();		/* hunt forward for next match  */
-extern	int	backhunt();		/* hunt backwards for next match*/
+extern int backhunt();		/* hunt backwards for next match */
 extern int pipecmd();		/* pipe command into buffer     */
 extern int filter();		/* filter buffer through dos    */
 extern int delwind();		/* delete the current window    */

epath.h

@@ -9,7 +9,6 @@
 /*	possible names and paths of help files under different OSs	*/
 
 char *pathname[] =
-
 #if	MSDOS
 {
 	"emacs.rc",
@@ -24,30 +23,20 @@ char *pathname[] =
 
 #if	V7 | BSD | USG
 {
-	".emacsrc",
+	".emacsrc", "emacs.hlp",
-	"emacs.hlp",
 #if	PKCODE
-	"/usr/global/lib/",
+	    "/usr/global/lib/", "/usr/local/bin/", "/usr/local/lib/",
-	"/usr/local/bin/",
-	"/usr/local/lib/",
 #endif
-	"/usr/local/",
+"/usr/local/", "/usr/lib/", ""};
-	"/usr/lib/",
-	""
-};
 #endif
 
 #if	VMS
 {
-	"emacs.rc",
+	"emacs.rc", "emacs.hlp", "",
-	"emacs.hlp",
-	"",
 #if	PKCODE
-	"sys$login:",
+	    "sys$login:", "emacs_dir:",
-	"emacs_dir:",
 #endif
-	"sys$sysdevice:[vmstools]"
+"sys$sysdevice:[vmstools]"};
-};
 #endif
 
 #define	NPNAMES	(sizeof(pathname)/sizeof(char *))

estruct.h

@@ -77,7 +77,7 @@
 #else
 
 #define MSDOS   1		/* MS-DOS                       */
-#define V7      0                       /* V7 UNIX or Coherent or BSD4.2*/
+#define V7      0		/* V7 UNIX or Coherent or BSD4.2 */
 #define	BSD	0		/* UNIX BSD 4.2 and ULTRIX      */
 #define	USG	0		/* UNIX system V                */
 #define VMS     0		/* VAX/VMS                      */
@@ -308,7 +308,7 @@
 #define FIOEOF  2		/* File I/O, end of file.       */
 #define FIOERR  3		/* File I/O, error.             */
 #define	FIOMEM	4		/* File I/O, out of memory      */
-#define	FIOFUN	5			/* File I/O, eod of file/bad line*/
+#define	FIOFUN	5		/* File I/O, eod of file/bad line */
 
 #define CFCPCN  0x0001		/* Last command was C-P, C-N    */
 #define CFKILL  0x0002		/* Last command was a kill      */
@@ -496,7 +496,7 @@ typedef struct  BUFFER {
 #define	NUMMODES	9	/* # of defined modes           */
 
 #define	MDWRAP	0x0001		/* word wrap                    */
-#define	MDCMOD	0x0002			/* C indentation and fence match*/
+#define	MDCMOD	0x0002		/* C indentation and fence match */
 #define	MDSPELL	0x0004		/* spell error parcing          */
 #define	MDEXACT	0x0008		/* Exact matching for searches  */
 #define	MDVIEW	0x0010		/* read-only buffer             */
@@ -551,28 +551,28 @@ typedef struct  {
 	short t_nrow;		/* current number of rows used  */
 	short t_mcol;		/* max Number of columns.       */
 	short t_ncol;		/* current Number of columns.   */
-	short	t_margin;		/* min margin for extended lines*/
+	short t_margin;		/* min margin for extended lines */
 	short t_scrsiz;		/* size of scroll region "      */
 	int t_pause;		/* # times thru update to pause */
-        int     (*t_open)();            /* Open terminal at the start.  */
+	int (*t_open) ();	/* Open terminal at the start.  */
-        int     (*t_close)();           /* Close terminal at end.       */
+	int (*t_close) ();	/* Close terminal at end.       */
-	int	(*t_kopen)();		/* Open keyboard		*/
+	int (*t_kopen) ();	/* Open keyboard                */
-	int	(*t_kclose)();		/* close keyboard		*/
+	int (*t_kclose) ();	/* close keyboard               */
-        int     (*t_getchar)();         /* Get character from keyboard. */
+	int (*t_getchar) ();	/* Get character from keyboard. */
-        int     (*t_putchar)();         /* Put character to display.    */
+	int (*t_putchar) ();	/* Put character to display.    */
-        int     (*t_flush)();           /* Flush output buffers.        */
+	int (*t_flush) ();	/* Flush output buffers.        */
-        int     (*t_move)();            /* Move the cursor, origin 0.   */
+	int (*t_move) ();	/* Move the cursor, origin 0.   */
-        int     (*t_eeol)();            /* Erase to end of line.        */
+	int (*t_eeol) ();	/* Erase to end of line.        */
-        int     (*t_eeop)();            /* Erase to end of page.        */
+	int (*t_eeop) ();	/* Erase to end of page.        */
-        int     (*t_beep)();            /* Beep.                        */
+	int (*t_beep) ();	/* Beep.                        */
-	int	(*t_rev)();		/* set reverse video state	*/
+	int (*t_rev) ();	/* set reverse video state      */
-	int	(*t_rez)();		/* change screen resolution	*/
+	int (*t_rez) ();	/* change screen resolution     */
 #if	COLOR
-	int	(*t_setfor)();		/* set forground color		*/
+	int (*t_setfor) ();	/* set forground color          */
-	int	(*t_setback)();		/* set background color		*/
+	int (*t_setback) ();	/* set background color         */
 #endif
 #if     SCROLLCODE
-        int     (*t_scroll)();          /* scroll a region of the screen */
+	int (*t_scroll) ();	/* scroll a region of the screen */
 #endif
 } TERM;
 
@@ -601,14 +601,14 @@ typedef struct  {
 
 typedef struct {
 	short k_code;		/* Key code                     */
-        int     (*k_fp)();              /* Routine to handle it         */
+	int (*k_fp) ();		/* Routine to handle it         */
 } KEYTAB;
 
 /*	structure for the name binding table		*/
 
 typedef struct {
 	char *n_name;		/* name of function key */
-	int (*n_func)();	/* function name is bound to */
+	int (*n_func) ();	/* function name is bound to */
 } NBIND;
 
 /*	The editor holds deleted text chunks in the KILL buffer. The
@@ -642,7 +642,7 @@ typedef struct VDESC {
 
 typedef struct WHBLOCK {
 	LINE *w_begin;		/* ptr to !while statement */
-	LINE *w_end;		/* ptr to the !endwhile statement*/
+	LINE *w_end;		/* ptr to the !endwhile statement */
 	int w_type;		/* block type */
 	struct WHBLOCK *w_next;	/* next while */
 } WHBLOCK;
@@ -678,30 +678,30 @@ typedef struct WHBLOCK {
  * Defines for the metacharacters in the regular expression
  * search routines.
  */
-#define	MCNIL		0	/* Like the '\0' for strings.*/
+#define	MCNIL		0	/* Like the '\0' for strings. */
-#define	LITCHAR		1	/* Literal character, or string.*/
+#define	LITCHAR		1	/* Literal character, or string. */
 #define	ANY		2
 #define	CCL		3
 #define	NCCL		4
 #define	BOL		5
 #define	EOL		6
 #define	DITTO		7
-#define	CLOSURE		256	/* An or-able value.*/
+#define	CLOSURE		256	/* An or-able value. */
 #define	MASKCL		CLOSURE - 1
 
-#define	MC_ANY		'.'	/* 'Any' character (except newline).*/
+#define	MC_ANY		'.'	/* 'Any' character (except newline). */
-#define	MC_CCL		'['	/* Character class.*/
+#define	MC_CCL		'['	/* Character class. */
-#define	MC_NCCL		'^'	/* Negate character class.*/
+#define	MC_NCCL		'^'	/* Negate character class. */
-#define	MC_RCCL		'-'	/* Range in character class.*/
+#define	MC_RCCL		'-'	/* Range in character class. */
-#define	MC_ECCL		']'	/* End of character class.*/
+#define	MC_ECCL		']'	/* End of character class. */
-#define	MC_BOL		'^'	/* Beginning of line.*/
+#define	MC_BOL		'^'	/* Beginning of line. */
-#define	MC_EOL		'$'	/* End of line.*/
+#define	MC_EOL		'$'	/* End of line. */
-#define	MC_CLOSURE	'*'	/* Closure - does not extend past newline.*/
+#define	MC_CLOSURE	'*'	/* Closure - does not extend past newline. */
-#define	MC_DITTO	'&'	/* Use matched string in replacement.*/
+#define	MC_DITTO	'&'	/* Use matched string in replacement. */
-#define	MC_ESC		'\\'	/* Escape - suppress meta-meaning.*/
+#define	MC_ESC		'\\'	/* Escape - suppress meta-meaning. */
 
-#define	BIT(n)		(1 << (n))	/* An integer with one bit set.*/
+#define	BIT(n)		(1 << (n))	/* An integer with one bit set. */
-#define	CHCASE(c)	((c) ^ DIFCASE)	/* Toggle the case of a letter.*/
+#define	CHCASE(c)	((c) ^ DIFCASE)	/* Toggle the case of a letter. */
 
 /* HICHAR - 1 is the largest character we will deal with.
  * HIBYTE represents the number of bytes in the bitmap.
@@ -728,4 +728,3 @@ typedef	struct {
 	char *rstr;
 } RMC;
 #endif
-

eval.c

@@ -11,17 +11,16 @@
 #include	"edef.h"
 #include	"evar.h"
 
-varinit()		/* initialize the user variable list */
+varinit()
-
+{				/* initialize the user variable list */
-{
 	register int i;
 
-	for (i=0; i < MAXVARS; i++)
+	for (i = 0; i < MAXVARS; i++)
 		uv[i].u_name[0] = 0;
 }
 
-char *gtfun(fname)	/* evaluate a function */
+char *gtfun(fname)
-
+			    /* evaluate a function */
 char *fname;			/* name of function to evaluate */
 
 {
@@ -47,89 +46,126 @@ char *fname;		/* name of function to evaluate */
 
 	/* return errorm on a bad reference */
 	if (fnum == NFUNCS)
-		return(errorm);
+		return (errorm);
 
 	/* if needed, retrieve the first argument */
 	if (funcs[fnum].f_type >= MONAMIC) {
 		if ((status = macarg(arg1)) != TRUE)
-			return(errorm);
+			return (errorm);
 
 		/* if needed, retrieve the second argument */
 		if (funcs[fnum].f_type >= DYNAMIC) {
 			if ((status = macarg(arg2)) != TRUE)
-				return(errorm);
+				return (errorm);
 
 			/* if needed, retrieve the third argument */
 			if (funcs[fnum].f_type >= TRINAMIC)
 				if ((status = macarg(arg3)) != TRUE)
-					return(errorm);
+					return (errorm);
 		}
 	}
 
 
 	/* and now evaluate it! */
 	switch (fnum) {
-		case UFADD:	return(itoa(atoi(arg1) + atoi(arg2)));
+	case UFADD:
-		case UFSUB:	return(itoa(atoi(arg1) - atoi(arg2)));
+		return (itoa(atoi(arg1) + atoi(arg2)));
-		case UFTIMES:	return(itoa(atoi(arg1) * atoi(arg2)));
+	case UFSUB:
-		case UFDIV:	return(itoa(atoi(arg1) / atoi(arg2)));
+		return (itoa(atoi(arg1) - atoi(arg2)));
-		case UFMOD:	return(itoa(atoi(arg1) % atoi(arg2)));
+	case UFTIMES:
-		case UFNEG:	return(itoa(-atoi(arg1)));
+		return (itoa(atoi(arg1) * atoi(arg2)));
-		case UFCAT:	strcpy(result, arg1);
+	case UFDIV:
-				return(strcat(result, arg2));
+		return (itoa(atoi(arg1) / atoi(arg2)));
-		case UFLEFT:	return(strncpy(result, arg1, atoi(arg2)));
+	case UFMOD:
-		case UFRIGHT:	return(strcpy(result,
+		return (itoa(atoi(arg1) % atoi(arg2)));
+	case UFNEG:
+		return (itoa(-atoi(arg1)));
+	case UFCAT:
+		strcpy(result, arg1);
+		return (strcat(result, arg2));
+	case UFLEFT:
+		return (strncpy(result, arg1, atoi(arg2)));
+	case UFRIGHT:
+		return (strcpy(result,
 			       &arg1[(strlen(arg1) - atoi(arg2))]));
-		case UFMID:	return(strncpy(result, &arg1[atoi(arg2)-1],
+	case UFMID:
+		return (strncpy(result, &arg1[atoi(arg2) - 1],
 				atoi(arg3)));
-		case UFNOT:	return(ltos(stol(arg1) == FALSE));
+	case UFNOT:
-		case UFEQUAL:	return(ltos(atoi(arg1) == atoi(arg2)));
+		return (ltos(stol(arg1) == FALSE));
-		case UFLESS:	return(ltos(atoi(arg1) < atoi(arg2)));
+	case UFEQUAL:
-		case UFGREATER:	return(ltos(atoi(arg1) > atoi(arg2)));
+		return (ltos(atoi(arg1) == atoi(arg2)));
-		case UFSEQUAL:	return(ltos(strcmp(arg1, arg2) == 0));
+	case UFLESS:
-		case UFSLESS:	return(ltos(strcmp(arg1, arg2) < 0));
+		return (ltos(atoi(arg1) < atoi(arg2)));
-		case UFSGREAT:	return(ltos(strcmp(arg1, arg2) > 0));
+	case UFGREATER:
-		case UFIND:	return(strcpy(result, getval(arg1)));
+		return (ltos(atoi(arg1) > atoi(arg2)));
-		case UFAND:	return(ltos(stol(arg1) && stol(arg2)));
+	case UFSEQUAL:
-		case UFOR:	return(ltos(stol(arg1) || stol(arg2)));
+		return (ltos(strcmp(arg1, arg2) == 0));
-		case UFLENGTH:	return(itoa(strlen(arg1)));
+	case UFSLESS:
-		case UFUPPER:	return(mkupper(arg1));
+		return (ltos(strcmp(arg1, arg2) < 0));
-		case UFLOWER:	return(mklower(arg1));
+	case UFSGREAT:
-		case UFTRUTH:	return(ltos(atoi(arg1) == 42));
+		return (ltos(strcmp(arg1, arg2) > 0));
-		case UFASCII:	return(itoa((int)arg1[0]));
+	case UFIND:
-		case UFCHR:	result[0] = atoi(arg1);
+		return (strcpy(result, getval(arg1)));
+	case UFAND:
+		return (ltos(stol(arg1) && stol(arg2)));
+	case UFOR:
+		return (ltos(stol(arg1) || stol(arg2)));
+	case UFLENGTH:
+		return (itoa(strlen(arg1)));
+	case UFUPPER:
+		return (mkupper(arg1));
+	case UFLOWER:
+		return (mklower(arg1));
+	case UFTRUTH:
+		return (ltos(atoi(arg1) == 42));
+	case UFASCII:
+		return (itoa((int) arg1[0]));
+	case UFCHR:
+		result[0] = atoi(arg1);
 		result[1] = 0;
-				return(result);
+		return (result);
-		case UFGTKEY:	result[0] = tgetc();
+	case UFGTKEY:
+		result[0] = tgetc();
 		result[1] = 0;
-				return(result);
+		return (result);
-		case UFRND:	return(itoa((ernd() % abs(atoi(arg1))) + 1));
+	case UFRND:
-		case UFABS:	return(itoa(abs(atoi(arg1))));
+		return (itoa((ernd() % abs(atoi(arg1))) + 1));
-		case UFSINDEX:	return(itoa(sindex(arg1, arg2)));
+	case UFABS:
+		return (itoa(abs(atoi(arg1))));
+	case UFSINDEX:
+		return (itoa(sindex(arg1, arg2)));
 	case UFENV:
 #if	ENVFUNC
 		tsp = getenv(arg1);
-				return(tsp == NULL ? "" : tsp);
+		return (tsp == NULL ? "" : tsp);
 #else
-				return("");
+		return ("");
 #endif
-		case UFBIND:	return(transbind(arg1));
+	case UFBIND:
-		case UFEXIST:	return(ltos(fexist(arg1)));
+		return (transbind(arg1));
+	case UFEXIST:
+		return (ltos(fexist(arg1)));
 	case UFFIND:
 		tsp = flook(arg1, TRUE);
-				return(tsp == NULL ? "" : tsp);
+		return (tsp == NULL ? "" : tsp);
- 		case UFBAND:	return(itoa(atoi(arg1) & atoi(arg2)));
+	case UFBAND:
- 		case UFBOR:	return(itoa(atoi(arg1) | atoi(arg2)));
+		return (itoa(atoi(arg1) & atoi(arg2)));
- 		case UFBXOR:	return(itoa(atoi(arg1) ^ atoi(arg2)));
+	case UFBOR:
-		case UFBNOT:	return(itoa(~atoi(arg1)));
+		return (itoa(atoi(arg1) | atoi(arg2)));
-		case UFXLATE:	return(xlat(arg1, arg2, arg3));
+	case UFBXOR:
+		return (itoa(atoi(arg1) ^ atoi(arg2)));
+	case UFBNOT:
+		return (itoa(~atoi(arg1)));
+	case UFXLATE:
+		return (xlat(arg1, arg2, arg3));
 	}
 
 	exit(-11);		/* never should get here */
 }
 
-char *gtusr(vname)	/* look up a user var's value */
+char *gtusr(vname)
-
+			    /* look up a user var's value */
 char *vname;			/* name of user variable to fetch */
 
 {
@@ -139,13 +175,13 @@ char *vname;		/* name of user variable to fetch */
 	/* scan the list looking for the user var name */
 	for (vnum = 0; vnum < MAXVARS; vnum++) {
 		if (uv[vnum].u_name[0] == 0)
-			return(errorm);
+			return (errorm);
 		if (strcmp(vname, uv[vnum].u_name) == 0)
-			return(uv[vnum].u_value);
+			return (uv[vnum].u_value);
 	}
 
 	/* return errorm if we run off the end */
-	return(errorm);
+	return (errorm);
 }
 
 char *gtenv(vname)
@@ -169,78 +205,116 @@ char *vname;		/* name of environment variable to retrieve */
 		char *ename = getenv(vname);
 
 		if (ename != NULL)
-			return(ename);
+			return (ename);
 		else
-			return(errorm);
+			return (errorm);
 	}
 #else
-		return(errorm);
+		return (errorm);
 #endif
 
 	/* otherwise, fetch the appropriate value */
 	switch (vnum) {
-		case EVFILLCOL:	return(itoa(fillcol));
+	case EVFILLCOL:
-		case EVPAGELEN:	return(itoa(term.t_nrow + 1));
+		return (itoa(fillcol));
-		case EVCURCOL:	return(itoa(getccol(FALSE)));
+	case EVPAGELEN:
-		case EVCURLINE: return(itoa(getcline()));
+		return (itoa(term.t_nrow + 1));
-		case EVRAM:	return(itoa((int)(envram / 1024l)));
+	case EVCURCOL:
-		case EVFLICKER:	return(ltos(flickcode));
+		return (itoa(getccol(FALSE)));
-		case EVCURWIDTH:return(itoa(term.t_ncol));
+	case EVCURLINE:
-		case EVCBUFNAME:return(curbp->b_bname);
+		return (itoa(getcline()));
-		case EVCFNAME:	return(curbp->b_fname);
+	case EVRAM:
-		case EVSRES:	return(sres);
+		return (itoa((int) (envram / 1024l)));
-		case EVDEBUG:	return(ltos(macbug));
+	case EVFLICKER:
-		case EVSTATUS:	return(ltos(cmdstatus));
+		return (ltos(flickcode));
-		case EVPALETTE:	return(palstr);
+	case EVCURWIDTH:
-		case EVASAVE:	return(itoa(gasave));
+		return (itoa(term.t_ncol));
-		case EVACOUNT:	return(itoa(gacount));
+	case EVCBUFNAME:
-		case EVLASTKEY: return(itoa(lastkey));
+		return (curbp->b_bname);
+	case EVCFNAME:
+		return (curbp->b_fname);
+	case EVSRES:
+		return (sres);
+	case EVDEBUG:
+		return (ltos(macbug));
+	case EVSTATUS:
+		return (ltos(cmdstatus));
+	case EVPALETTE:
+		return (palstr);
+	case EVASAVE:
+		return (itoa(gasave));
+	case EVACOUNT:
+		return (itoa(gacount));
+	case EVLASTKEY:
+		return (itoa(lastkey));
 	case EVCURCHAR:
-			return(curwp->w_dotp->l_used ==
+		return (curwp->w_dotp->l_used ==
 			curwp->w_doto ? itoa('\n') :
 			itoa(lgetc(curwp->w_dotp, curwp->w_doto)));
-		case EVDISCMD:	return(ltos(discmd));
+	case EVDISCMD:
-		case EVVERSION:	return(VERSION);
+		return (ltos(discmd));
-		case EVPROGNAME:return(PROGNAME);
+	case EVVERSION:
-		case EVSEED:	return(itoa(seed));
+		return (VERSION);
-		case EVDISINP:	return(ltos(disinp));
+	case EVPROGNAME:
-		case EVWLINE:	return(itoa(curwp->w_ntrows));
+		return (PROGNAME);
-		case EVCWLINE:	return(itoa(getwpos()));
+	case EVSEED:
-		case EVTARGET:	saveflag = lastflag;
+		return (itoa(seed));
-				return(itoa(curgoal));
+	case EVDISINP:
-		case EVSEARCH:	return(pat);
+		return (ltos(disinp));
-		case EVREPLACE:	return(rpat);
+	case EVWLINE:
-		case EVMATCH:	return((patmatch == NULL)? "": patmatch);
+		return (itoa(curwp->w_ntrows));
-		case EVKILL:	return(getkill());
+	case EVCWLINE:
-		case EVCMODE:	return(itoa(curbp->b_mode));
+		return (itoa(getwpos()));
-		case EVGMODE:	return(itoa(gmode));
+	case EVTARGET:
-		case EVTPAUSE:	return(itoa(term.t_pause));
+		saveflag = lastflag;
+		return (itoa(curgoal));
+	case EVSEARCH:
+		return (pat);
+	case EVREPLACE:
+		return (rpat);
+	case EVMATCH:
+		return ((patmatch == NULL) ? "" : patmatch);
+	case EVKILL:
+		return (getkill());
+	case EVCMODE:
+		return (itoa(curbp->b_mode));
+	case EVGMODE:
+		return (itoa(gmode));
+	case EVTPAUSE:
+		return (itoa(term.t_pause));
 	case EVPENDING:
 #if	TYPEAH
-				return(ltos(typahead()));
+		return (ltos(typahead()));
 #else
-				return(falsem);
+		return (falsem);
 #endif
-		case EVLWIDTH:	return(itoa(llength(curwp->w_dotp)));
+	case EVLWIDTH:
-		case EVLINE:	return(getctext());
+		return (itoa(llength(curwp->w_dotp)));
-		case EVGFLAGS:	return(itoa(gflags));
+	case EVLINE:
-		case EVRVAL:	return(itoa(rval));
+		return (getctext());
-		case EVTAB:	return(itoa(tabmask+1));
+	case EVGFLAGS:
-		case EVOVERLAP:	return(itoa(overlap));
+		return (itoa(gflags));
+	case EVRVAL:
+		return (itoa(rval));
+	case EVTAB:
+		return (itoa(tabmask + 1));
+	case EVOVERLAP:
+		return (itoa(overlap));
 	case EVSCROLLCOUNT:
-				return(itoa(scrollcount));
+		return (itoa(scrollcount));
 #if SCROLLCODE
-		case EVSCROLL:	return(ltos(term.t_scroll != NULL));
+	case EVSCROLL:
+		return (ltos(term.t_scroll != NULL));
 #else
-		case EVSCROLL:	return(ltos(0));
+	case EVSCROLL:
+		return (ltos(0));
 #endif
 	}
 	exit(-12);		/* again, we should never get here */
 }
 
-char *getkill()		/* return some of the contents of the kill buffer */
+char *getkill()
-
+{				/* return some of the contents of the kill buffer */
-{
 	register int size;	/* max number of chars to return */
 	static char value[NSTRING];	/* temp buffer for value */
 
@@ -257,11 +331,11 @@ char *getkill()		/* return some of the contents of the kill buffer */
 	}
 
 	/* and return the constructed value */
-	return(value);
+	return (value);
 }
 
-int setvar(f, n)		/* set a variable */
+int setvar(f, n)
-
+				    /* set a variable */
 int f;				/* default flag */
 int n;				/* numeric arg (can overide prompted value) */
 
@@ -272,14 +346,14 @@ int n;		/* numeric arg (can overide prompted value) */
 	register char *ep;	/* ptr to end of outline */
 #endif
 	VDESC vd;		/* variable num/type */
-	char var[NVSIZE+1];	/* name of variable to fetch */
+	char var[NVSIZE + 1];	/* name of variable to fetch */
 	char value[NSTRING];	/* value to set variable to */
 
 	/* first get the variable to set.. */
 	if (clexec == FALSE) {
 		status = mlreply("Variable to set: ", &var[0], NVSIZE);
 		if (status != TRUE)
-			return(status);
+			return (status);
 	} else {		/* macro line argument */
 		/* grab token and skip it */
 		execstr = token(execstr, var, NVSIZE + 1);
@@ -291,7 +365,7 @@ int n;		/* numeric arg (can overide prompted value) */
 	/* if its not legal....bitch */
 	if (vd.v_type == -1) {
 		mlwrite("%%No such variable as '%s'", var);
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* get the value for that variable */
@@ -300,7 +374,7 @@ int n;		/* numeric arg (can overide prompted value) */
 	else {
 		status = mlreply("Value: ", &value[0], NSTRING);
 		if (status != TRUE)
-			return(status);
+			return (status);
 	}
 
 	/* and set the appropriate value */
@@ -331,12 +405,11 @@ int n;		/* numeric arg (can overide prompted value) */
 			if (*sp++ == '%') {
 				/* advance to the end */
 				ep = --sp;
-				while (*ep++)
+				while (*ep++);
-					;
 				/* null terminate the string one out */
 				*(ep + 1) = 0;
 				/* copy backwards */
-				while(ep-- > sp)
+				while (ep-- > sp)
 					*(ep + 1) = *ep;
 
 				/* and advance sp past the new % */
@@ -356,11 +429,11 @@ int n;		/* numeric arg (can overide prompted value) */
 #endif
 
 	/* and return it */
-	return(status);
+	return (status);
 }
 
-findvar(var, vd, size)	/* find a variables type and name */
+findvar(var, vd, size)
-
+    /* find a variables type and name */
 char *var;			/* name of var to get */
 VDESC *vd;			/* structure to hold type and ptr */
 int size;			/* size of var array */
@@ -369,7 +442,7 @@ int size;	/* size of var array */
 	register int vnum;	/* subscript in varable arrays */
 	register int vtype;	/* type to return */
 
-fvar:	vtype = -1;
+      fvar:vtype = -1;
 	switch (var[0]) {
 
 	case '$':		/* check for legal enviromnent var */
@@ -414,8 +487,8 @@ fvar:	vtype = -1;
 	return;
 }
 
-int svar(var, value)		/* set a variable */
+int svar(var, value)
-
+				    /* set a variable */
 VDESC *var;			/* variable to set */
 char *value;			/* value to set to */
 
@@ -424,7 +497,7 @@ char *value;	/* value to set to */
 	register int vtype;	/* type of variable to set */
 	register int status;	/* status return */
 	register int c;		/* translated character */
-	register char * sp;	/* scratch string pointer */
+	register char *sp;	/* scratch string pointer */
 
 	/* simplify the vd structure (we are gonna look at it a lot) */
 	vnum = var->v_num;
@@ -438,7 +511,7 @@ char *value;	/* value to set to */
 			free(uv[vnum].u_value);
 		sp = malloc(strlen(value) + 1);
 		if (sp == NULL)
-			return(FALSE);
+			return (FALSE);
 		strcpy(sp, value);
 		uv[vnum].u_value = sp;
 		break;
@@ -446,41 +519,58 @@ char *value;	/* value to set to */
 	case TKENV:		/* set an environment variable */
 		status = TRUE;	/* by default */
 		switch (vnum) {
-		case EVFILLCOL:	fillcol = atoi(value);
+		case EVFILLCOL:
+			fillcol = atoi(value);
 			break;
-		case EVPAGELEN:	status = newsize(TRUE, atoi(value));
+		case EVPAGELEN:
+			status = newsize(TRUE, atoi(value));
 			break;
-		case EVCURCOL:	status = setccol(atoi(value));
+		case EVCURCOL:
+			status = setccol(atoi(value));
 			break;
-		case EVCURLINE:	status = gotoline(TRUE, atoi(value));
+		case EVCURLINE:
+			status = gotoline(TRUE, atoi(value));
 			break;
-		case EVRAM:	break;
+		case EVRAM:
-		case EVFLICKER:	flickcode = stol(value);
 			break;
-		case EVCURWIDTH:status = newwidth(TRUE, atoi(value));
+		case EVFLICKER:
+			flickcode = stol(value);
 			break;
-		case EVCBUFNAME:strcpy(curbp->b_bname, value);
+		case EVCURWIDTH:
+			status = newwidth(TRUE, atoi(value));
+			break;
+		case EVCBUFNAME:
+			strcpy(curbp->b_bname, value);
 			curwp->w_flag |= WFMODE;
 			break;
-		case EVCFNAME:	strcpy(curbp->b_fname, value);
+		case EVCFNAME:
+			strcpy(curbp->b_fname, value);
 			curwp->w_flag |= WFMODE;
 			break;
-		case EVSRES:	status = TTrez(value);
+		case EVSRES:
+			status = TTrez(value);
 			break;
-		case EVDEBUG:	macbug = stol(value);
+		case EVDEBUG:
+			macbug = stol(value);
 			break;
-		case EVSTATUS:	cmdstatus = stol(value);
+		case EVSTATUS:
+			cmdstatus = stol(value);
 			break;
-		case EVPALETTE:	strncpy(palstr, value, 48);
+		case EVPALETTE:
+			strncpy(palstr, value, 48);
 			spal(palstr);
 			break;
-		case EVASAVE:	gasave = atoi(value);
+		case EVASAVE:
+			gasave = atoi(value);
 			break;
-		case EVACOUNT:	gacount = atoi(value);
+		case EVACOUNT:
+			gacount = atoi(value);
 			break;
-		case EVLASTKEY:	lastkey = atoi(value);
+		case EVLASTKEY:
+			lastkey = atoi(value);
 			break;
-		case EVCURCHAR:	ldelete(1L, FALSE);	/* delete 1 char */
+		case EVCURCHAR:
+			ldelete(1L, FALSE);	/* delete 1 char */
 			c = atoi(value);
 			if (c == '\n')
 				lnewline(FALSE, 1);
@@ -488,65 +578,86 @@ char *value;	/* value to set to */
 				linsert(1, c);
 			backchar(FALSE, 1);
 			break;
-		case EVDISCMD:	discmd = stol(value);
+		case EVDISCMD:
+			discmd = stol(value);
 			break;
-		case EVVERSION:	break;
+		case EVVERSION:
-		case EVPROGNAME:break;
-		case EVSEED:	seed = atoi(value);
 			break;
-		case EVDISINP:	disinp = stol(value);
+		case EVPROGNAME:
 			break;
-		case EVWLINE:	status = resize(TRUE, atoi(value));
+		case EVSEED:
+			seed = atoi(value);
 			break;
-		case EVCWLINE:	status = forwline(TRUE,
+		case EVDISINP:
-						atoi(value) - getwpos());
+			disinp = stol(value);
 			break;
-		case EVTARGET:	curgoal = atoi(value);
+		case EVWLINE:
+			status = resize(TRUE, atoi(value));
+			break;
+		case EVCWLINE:
+			status = forwline(TRUE, atoi(value) - getwpos());
+			break;
+		case EVTARGET:
+			curgoal = atoi(value);
 			thisflag = saveflag;
 			break;
-		case EVSEARCH:	strcpy(pat, value);
+		case EVSEARCH:
+			strcpy(pat, value);
 			rvstrcpy(tap, pat);
 #if	MAGIC
 			mcclear();
 #endif
 			break;
-		case EVREPLACE:	strcpy(rpat, value);
+		case EVREPLACE:
+			strcpy(rpat, value);
 			break;
-		case EVMATCH:	break;
+		case EVMATCH:
-		case EVKILL:	break;
+			break;
-		case EVCMODE:	curbp->b_mode = atoi(value);
+		case EVKILL:
+			break;
+		case EVCMODE:
+			curbp->b_mode = atoi(value);
 			curwp->w_flag |= WFMODE;
 			break;
-		case EVGMODE:	gmode = atoi(value);
+		case EVGMODE:
+			gmode = atoi(value);
 			break;
-		case EVTPAUSE:	term.t_pause = atoi(value);
+		case EVTPAUSE:
+			term.t_pause = atoi(value);
 			break;
-		case EVPENDING:	break;
+		case EVPENDING:
-		case EVLWIDTH:	break;
-		case EVLINE:	putctext(value);
-		case EVGFLAGS:	gflags = atoi(value);
 			break;
-		case EVRVAL:	break;
+		case EVLWIDTH:
-		case EVTAB:	tabmask = atoi(value)-1;
+			break;
+		case EVLINE:
+			putctext(value);
+		case EVGFLAGS:
+			gflags = atoi(value);
+			break;
+		case EVRVAL:
+			break;
+		case EVTAB:
+			tabmask = atoi(value) - 1;
 			if (tabmask != 0x07 && tabmask != 0x03)
 				tabmask = 0x07;
 			curwp->w_flag |= WFHARD;
 			break;
-		case EVOVERLAP:	overlap = atoi(value);
+		case EVOVERLAP:
+			overlap = atoi(value);
 			break;
 		case EVSCROLLCOUNT:
 			scrollcount = atoi(value);
 			break;
 		case EVSCROLL:
 #if SCROLLCODE
-				if (! stol(value))
+			if (!stol(value))
 				term.t_scroll = NULL;
 #endif
 			break;
 		}
 		break;
 	}
-	return(status);
+	return (status);
 }
 
 /*	atoi:	ascii string to integer......This is too
@@ -581,9 +692,9 @@ char *st;
 		if (c >= '0' && c <= '9')
 			result = result * 10 + c - '0';
 		else
-			return(0);
+			return (0);
 
-	return(result * sign);
+	return (result * sign);
 }
 
 /*	itoa:	integer to ascii string.......... This is too
@@ -597,9 +708,9 @@ int i;	/* integer to translate to a string */
 	register int digit;	/* current digit being used */
 	register char *sp;	/* pointer into result */
 	register int sign;	/* sign of resulting number */
-	static char result[INTWIDTH+1];	/* resulting string */
+	static char result[INTWIDTH + 1];	/* resulting string */
 
-	/* record the sign...*/
+	/* record the sign... */
 	sign = 1;
 	if (i < 0) {
 		sign = -1;
@@ -620,11 +731,11 @@ int i;	/* integer to translate to a string */
 		*(--sp) = '-';	/* and install the minus sign */
 	}
 
-	return(sp);
+	return (sp);
 }
 
-int gettyp(token)	/* find the type of a passed token */
+int gettyp(token)
-
+			    /* find the type of a passed token */
 char *token;			/* token to analyze */
 
 {
@@ -635,29 +746,38 @@ char *token;	/* token to analyze */
 
 	/* no blanks!!! */
 	if (c == 0)
-		return(TKNUL);
+		return (TKNUL);
 
 	/* a numeric literal? */
 	if (c >= '0' && c <= '9')
-		return(TKLIT);
+		return (TKLIT);
 
 	switch (c) {
-		case '"':	return(TKSTR);
+	case '"':
+		return (TKSTR);
 
-		case '!':	return(TKDIR);
+	case '!':
-		case '@':	return(TKARG);
+		return (TKDIR);
-		case '#':	return(TKBUF);
+	case '@':
-		case '$':	return(TKENV);
+		return (TKARG);
-		case '%':	return(TKVAR);
+	case '#':
-		case '&':	return(TKFUN);
+		return (TKBUF);
-		case '*':	return(TKLBL);
+	case '$':
+		return (TKENV);
+	case '%':
+		return (TKVAR);
+	case '&':
+		return (TKFUN);
+	case '*':
+		return (TKLBL);
 
-		default:	return(TKCMD);
+	default:
+		return (TKCMD);
 	}
 }
 
-char *getval(token)	/* find the value of a token */
+char *getval(token)
-
+			    /* find the value of a token */
 char *token;			/* token to evaluate */
 
 {
@@ -665,21 +785,21 @@ char *token;		/* token to evaluate */
 	register BUFFER *bp;	/* temp buffer pointer */
 	register int blen;	/* length of buffer argument */
 	register int distmp;	/* temporary discmd flag */
-	static char buf[NSTRING];/* string buffer for some returns */
+	static char buf[NSTRING];	/* string buffer for some returns */
 
 	switch (gettyp(token)) {
-		case TKNUL:	return("");
+	case TKNUL:
+		return ("");
 
 	case TKARG:		/* interactive argument */
 		strcpy(token, getval(&token[1]));
 		distmp = discmd;	/* echo it always! */
 		discmd = TRUE;
-				status = getstring(token,
+		status = getstring(token, buf, NSTRING, ctoec('\n'));
-					   buf, NSTRING, ctoec('\n'));
 		discmd = distmp;
 		if (status == ABORT)
-					return(errorm);
+			return (errorm);
-				return(buf);
+		return (buf);
 
 	case TKBUF:		/* buffer contents fetch */
 
@@ -687,7 +807,7 @@ char *token;		/* token to evaluate */
 		strcpy(token, getval(&token[1]));
 		bp = bfind(token, FALSE, 0);
 		if (bp == NULL)
-					return(errorm);
+			return (errorm);
 
 		/* if the buffer is displayed, get the window
 		   vars instead of the buffer vars */
@@ -698,21 +818,20 @@ char *token;		/* token to evaluate */
 
 		/* make sure we are not at the end */
 		if (bp->b_linep == bp->b_dotp)
-					return(errorm);
+			return (errorm);
 
 		/* grab the line as an argument */
 		blen = bp->b_dotp->l_used - bp->b_doto;
 		if (blen > NSTRING)
 			blen = NSTRING;
-				strncpy(buf, bp->b_dotp->l_text + bp->b_doto,
+		strncpy(buf, bp->b_dotp->l_text + bp->b_doto, blen);
-					blen);
 		buf[blen] = 0;
 
 		/* and step the buffer's line ptr ahead a line */
 		bp->b_dotp = bp->b_dotp->l_fp;
 		bp->b_doto = 0;
 
-				/* if displayed buffer, reset window ptr vars*/
+		/* if displayed buffer, reset window ptr vars */
 		if (bp->b_nwnd > 0) {
 			curwp->w_dotp = curbp->b_dotp;
 			curwp->w_doto = 0;
@@ -720,47 +839,55 @@ char *token;		/* token to evaluate */
 		}
 
 		/* and return the spoils */
-				return(buf);		
+		return (buf);
 
-		case TKVAR:	return(gtusr(token+1));
+	case TKVAR:
-		case TKENV:	return(gtenv(token+1));
+		return (gtusr(token + 1));
-		case TKFUN:	return(gtfun(token+1));
+	case TKENV:
-		case TKDIR:	return(errorm);
+		return (gtenv(token + 1));
-		case TKLBL:	return(errorm);
+	case TKFUN:
-		case TKLIT:	return(token);
+		return (gtfun(token + 1));
-		case TKSTR:	return(token+1);
+	case TKDIR:
-		case TKCMD:	return(token);
+		return (errorm);
+	case TKLBL:
+		return (errorm);
+	case TKLIT:
+		return (token);
+	case TKSTR:
+		return (token + 1);
+	case TKCMD:
+		return (token);
 	}
 }
 
-int stol(val)	/* convert a string to a numeric logical */
+int stol(val)
-
+		    /* convert a string to a numeric logical */
 char *val;			/* value to check for stol */
 
 {
 	/* check for logical values */
 	if (val[0] == 'F')
-		return(FALSE);
+		return (FALSE);
 	if (val[0] == 'T')
-		return(TRUE);
+		return (TRUE);
 
 	/* check for numeric truth (!= 0) */
-	return((atoi(val) != 0));
+	return ((atoi(val) != 0));
 }
 
-char *ltos(val)		/* numeric logical to string logical */
+char *ltos(val)
-
+			    /* numeric logical to string logical */
 int val;			/* value to translate */
 
 {
 	if (val)
-		return(truem);
+		return (truem);
 	else
-		return(falsem);
+		return (falsem);
 }
 
-char *mkupper(str)	/* make a string upper case */
+char *mkupper(str)
-
+			    /* make a string upper case */
 char *str;			/* string to upper case */
 
 {
@@ -772,11 +899,11 @@ char *str;		/* string to upper case */
 			*sp += 'A' - 'a';
 		++sp;
 	}
-	return(str);
+	return (str);
 }
 
-char *mklower(str)	/* make a string lower case */
+char *mklower(str)
-
+			    /* make a string lower case */
 char *str;			/* string to lower case */
 
 {
@@ -788,26 +915,25 @@ char *str;		/* string to lower case */
 			*sp += 'a' - 'A';
 		++sp;
 	}
-	return(str);
+	return (str);
 }
 
-int abs(x)	/* take the absolute value of an integer */
+int abs(x)
-
+		    /* take the absolute value of an integer */
 int x;
 
 {
-	return(x < 0 ? -x : x);
+	return (x < 0 ? -x : x);
 }
 
-int ernd()	/* returns a random integer */
+int ernd()
-
+{				/* returns a random integer */
-{
 	seed = abs(seed * 1721 + 10007);
-	return(seed);
+	return (seed);
 }
 
-int sindex(source, pattern)	/* find pattern within source */
+int sindex(source, pattern)
-
+				    /* find pattern within source */
 char *source;			/* source string to search */
 char *pattern;			/* string to look for */
 
@@ -831,12 +957,12 @@ char *pattern;	/* string to look for */
 
 		/* was it a match? */
 		if (*cp == 0)
-			return((int)(sp - source) + 1);
+			return ((int) (sp - source) + 1);
 		++sp;
 	}
 
 	/* no match at all.. */
-	return(0);
+	return (0);
 }
 
 /*	Filter a string through a translation table	*/
@@ -870,10 +996,10 @@ char *trans;	/* resulting translated characters */
 		/* no match, copy in the source char untranslated */
 		*rp++ = *sp;
 
-xnext:		++sp;
+	      xnext:++sp;
 	}
 
 	/* terminate and return the result */
 	*rp = 0;
-	return(result);
+	return (result);
 }

exec.c

@@ -18,8 +18,8 @@ namedcmd(f, n)
 int f, n;			/* command arguments [passed through to command executed] */
 
 {
-	register int (*kfunc)(); /* ptr to the requexted function to bind to */
+	register int (*kfunc) ();	/* ptr to the requexted function to bind to */
-	int (*getname())();
+	int (*getname()) ();
 
 	/* prompt the user to type a named command */
 	mlwrite(": ");
@@ -28,11 +28,11 @@ int f, n;	/* command arguments [passed through to command executed] */
 	kfunc = getname();
 	if (kfunc == NULL) {
 		mlwrite("(No such function)");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* and then execute the command */
-	return((*kfunc)(f, n));
+	return ((*kfunc) (f, n));
 }
 
 /*	execcmd:	Execute a command line command to be typed in
@@ -48,10 +48,10 @@ int f, n;	/* default Flag and Numeric argument */
 
 	/* get the line wanted */
 	if ((status = mlreply(": ", cmdstr, NSTRING)) != TRUE)
-		return(status);
+		return (status);
 
 	execlevel = 0;
-	return(docmd(cmdstr));
+	return (docmd(cmdstr));
 }
 
 /*	docmd:	take a passed string as a command line and translate
@@ -72,16 +72,16 @@ char *cline;	/* command line to execute */
 {
 	register int f;		/* default argument flag */
 	register int n;		/* numeric repeat value */
-	int (*fnc)();		/* function to execute */
+	int (*fnc) ();		/* function to execute */
 	int status;		/* return status of function */
 	int oldcle;		/* old contents of clexec flag */
 	char *oldestr;		/* original exec string */
 	char tkn[NSTRING];	/* next token off of command line */
-	int (*fncmatch())();
+	int (*fncmatch()) ();
 
 	/* if we are scanning and not executing..go back here */
 	if (execlevel)
-		return(TRUE);
+		return (TRUE);
 
 	oldestr = execstr;	/* save last ptr to string to execute */
 	execstr = cline;	/* and set this one as current */
@@ -94,7 +94,7 @@ char *cline;	/* command line to execute */
 
 	if ((status = macarg(tkn)) != TRUE) {	/* and grab the first token */
 		execstr = oldestr;
-		return(status);
+		return (status);
 	}
 
 	/* process leadin argument */
@@ -106,7 +106,7 @@ char *cline;	/* command line to execute */
 		/* and now get the command to execute */
 		if ((status = macarg(tkn)) != TRUE) {
 			execstr = oldestr;
-			return(status);	
+			return (status);
 		}
 	}
 
@@ -114,17 +114,17 @@ char *cline;	/* command line to execute */
 	if ((fnc = fncmatch(tkn)) == NULL) {
 		mlwrite("(No such Function)");
 		execstr = oldestr;
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* save the arguments and go execute the command */
 	oldcle = clexec;	/* save old clexec flag */
 	clexec = TRUE;		/* in cline execution */
-	status = (*fnc)(f, n);		/* call the function */
+	status = (*fnc) (f, n);	/* call the function */
 	cmdstatus = status;	/* save the status */
 	clexec = oldcle;	/* restore clexec flag */
 	execstr = oldestr;
-	return(status);
+	return (status);
 }
 
 /* token:	chop a token off a string
@@ -153,12 +153,23 @@ int size;		/* maximum size of token */
 			if (*src == 0)
 				break;
 			switch (*src++) {
-				case 'r':	c = 13; break;
+			case 'r':
-				case 'n':	c = 10; break;
+				c = 13;
-				case 't':	c = 9;  break;
+				break;
-				case 'b':	c = 8;  break;
+			case 'n':
-				case 'f':	c = 12; break;
+				c = 10;
-				default:	c = *(src-1);
+				break;
+			case 't':
+				c = 9;
+				break;
+			case 'b':
+				c = 8;
+				break;
+			case 'f':
+				c = 12;
+				break;
+			default:
+				c = *(src - 1);
 			}
 			if (--size > 0) {
 				*tok++ = c;
@@ -188,11 +199,11 @@ int size;		/* maximum size of token */
 	if (*src)
 		++src;
 	*tok = 0;
-	return(src);
+	return (src);
 }
 
-macarg(tok)	/* get a macro line argument */
+macarg(tok)
-
+    /* get a macro line argument */
 char *tok;			/* buffer to place argument */
 
 {
@@ -203,7 +214,7 @@ char *tok;	/* buffer to place argument */
 	clexec = TRUE;		/* get the argument */
 	status = nextarg("", tok, NSTRING, ctoec('\n'));
 	clexec = savcle;	/* restore execution mode */
-	return(status);
+	return (status);
 }
 
 /*	nextarg:	get the next argument	*/
@@ -218,14 +229,14 @@ int terminator;		/* terminating char to be used on interactive fetch */
 {
 	/* if we are interactive, go get it! */
 	if (clexec == FALSE)
-		return(getstring(prompt, buffer, size, terminator));
+		return (getstring(prompt, buffer, size, terminator));
 
 	/* grab token and advance past */
 	execstr = token(execstr, buffer, size);
 
 	/* evaluate it */
 	strcpy(buffer, getval(buffer));
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	storemac:	Set up a macro buffer and flag to store all
@@ -243,13 +254,13 @@ int n;		/* macro number to use */
 	/* must have a numeric argument to this function */
 	if (f == FALSE) {
 		mlwrite("No macro specified");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* range check the macro number */
 	if (n < 1 || n > 40) {
 		mlwrite("Macro number out of range");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* construct the macro buffer name */
@@ -260,7 +271,7 @@ int n;		/* macro number to use */
 	/* set up the new macro buffer */
 	if ((bp = bfind(bname, TRUE, BFINVS)) == NULL) {
 		mlwrite("Can not create macro");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* and make sure it is empty */
@@ -269,7 +280,7 @@ int n;		/* macro number to use */
 	/* and set the macro store pointers to it */
 	mstore = TRUE;
 	bstore = bp;
-	return(TRUE);
+	return (TRUE);
 }
 
 #if	PROC
@@ -288,11 +299,12 @@ int n;		/* macro number to use */
 
 	/* a numeric argument means its a numbered macro */
 	if (f == TRUE)
-		return(storemac(f, n));
+		return (storemac(f, n));
 
 	/* get the name of the procedure */
-        if ((status = mlreply("Procedure name: ", &bname[1], NBUFN-2)) != TRUE)
+	if ((status =
-                return(status);
+	     mlreply("Procedure name: ", &bname[1], NBUFN - 2)) != TRUE)
+		return (status);
 
 	/* construct the macro buffer name */
 	bname[0] = '*';
@@ -301,7 +313,7 @@ int n;		/* macro number to use */
 	/* set up the new macro buffer */
 	if ((bp = bfind(bname, TRUE, BFINVS)) == NULL) {
 		mlwrite("Can not create macro");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* and make sure it is empty */
@@ -310,7 +322,7 @@ int n;		/* macro number to use */
 	/* and set the macro store pointers to it */
 	mstore = TRUE;
 	bstore = bp;
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	execproc:	Execute a procedure				*/
@@ -322,27 +334,28 @@ int f, n;	/* default flag and numeric arg */
 {
 	register BUFFER *bp;	/* ptr to buffer to execute */
 	register int status;	/* status return */
-        char bufn[NBUFN+2];		/* name of buffer to execute */
+	char bufn[NBUFN + 2];	/* name of buffer to execute */
 
 	/* find out what buffer the user wants to execute */
-        if ((status = mlreply("Execute procedure: ", &bufn[1], NBUFN)) != TRUE)
+	if ((status =
-                return(status);
+	     mlreply("Execute procedure: ", &bufn[1], NBUFN)) != TRUE)
+		return (status);
 
 	/* construct the buffer name */
 	bufn[0] = '*';
 	strcat(bufn, "*");
 
 	/* find the pointer to that buffer */
-        if ((bp=bfind(bufn, FALSE, 0)) == NULL) {
+	if ((bp = bfind(bufn, FALSE, 0)) == NULL) {
 		mlwrite("No such procedure");
-                return(FALSE);
+		return (FALSE);
 	}
 
 	/* and now execute it as asked */
 	while (n-- > 0)
 		if ((status = dobuf(bp)) != TRUE)
-			return(status);
+			return (status);
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 
@@ -359,19 +372,19 @@ int f, n;	/* default flag and numeric arg */
 
 	/* find out what buffer the user wants to execute */
 	if ((status = mlreply("Execute buffer: ", bufn, NBUFN)) != TRUE)
-                return(status);
+		return (status);
 
 	/* find the pointer to that buffer */
-        if ((bp=bfind(bufn, FALSE, 0)) == NULL) {
+	if ((bp = bfind(bufn, FALSE, 0)) == NULL) {
 		mlwrite("No such buffer");
-                return(FALSE);
+		return (FALSE);
 	}
 
 	/* and now execute it as asked */
 	while (n-- > 0)
 		if ((status = dobuf(bp)) != TRUE)
-			return(status);
+			return (status);
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	dobuf:	execute the contents of the buffer pointed to
@@ -445,12 +458,14 @@ BUFFER *bp;	/* buffer to execute */
 
 		/* if is a while directive, make a block... */
 		if (eline[0] == '!' && eline[1] == 'w' && eline[2] == 'h') {
-			whtemp = (WHBLOCK *)malloc(sizeof(WHBLOCK));
+			whtemp = (WHBLOCK *) malloc(sizeof(WHBLOCK));
 			if (whtemp == NULL) {
-noram:				mlwrite("%%Out of memory during while scan");
+			      noram:mlwrite
-failexit:			freewhile(scanner);
+				    ("%%Out of memory during while scan");
+			      failexit:freewhile
+				    (scanner);
 				freewhile(whlist);
-				return(FALSE);
+				return (FALSE);
 			}
 			whtemp->w_begin = lp;
 			whtemp->w_type = BTWHILE;
@@ -461,10 +476,11 @@ failexit:			freewhile(scanner);
 		/* if is a BREAK directive, make a block... */
 		if (eline[0] == '!' && eline[1] == 'b' && eline[2] == 'r') {
 			if (scanner == NULL) {
-				mlwrite("%%!BREAK outside of any !WHILE loop");
+				mlwrite
+				    ("%%!BREAK outside of any !WHILE loop");
 				goto failexit;
 			}
-			whtemp = (WHBLOCK *)malloc(sizeof(WHBLOCK));
+			whtemp = (WHBLOCK *) malloc(sizeof(WHBLOCK));
 			if (whtemp == NULL)
 				goto noram;
 			whtemp->w_begin = lp;
@@ -476,7 +492,8 @@ failexit:			freewhile(scanner);
 		/* if it is an endwhile directive, record the spot... */
 		if (eline[0] == '!' && strncmp(&eline[1], "endw", 4) == 0) {
 			if (scanner == NULL) {
-				mlwrite("%%!ENDWHILE with no preceding !WHILE in '%s'",
+				mlwrite
+				    ("%%!ENDWHILE with no preceding !WHILE in '%s'",
 				     bp->b_bname);
 				goto failexit;
 			}
@@ -492,7 +509,7 @@ failexit:			freewhile(scanner);
 			} while (whlist->w_type == BTBREAK);
 		}
 
-nxtscan:	/* on to the next line */
+	      nxtscan:		/* on to the next line */
 		lp = lp->l_fp;
 	}
 
@@ -503,7 +520,7 @@ nxtscan:	/* on to the next line */
 		goto failexit;
 	}
 
-	/* let the first command inherit the flags from the last one..*/
+	/* let the first command inherit the flags from the last one.. */
 	thisflag = lastflag;
 
 	/* starting at the beginning of the buffer */
@@ -512,10 +529,10 @@ nxtscan:	/* on to the next line */
 	while (lp != hlp) {
 		/* allocate eline and copy macro line to it */
 		linlen = lp->l_used;
-		if ((einit = eline = malloc(linlen+1)) == NULL) {
+		if ((einit = eline = malloc(linlen + 1)) == NULL) {
 			mlwrite("%%Out of Memory during macro execution");
 			freewhile(whlist);
-			return(FALSE);
+			return (FALSE);
 		}
 		strncpy(eline, lp->l_text, linlen);
 		eline[linlen] = 0;	/* make sure it ends */
@@ -554,12 +571,11 @@ nxtscan:	/* on to the next line */
 				if (*sp++ == '%') {
 					/* advance to the end */
 					ep = --sp;
-				while (*ep++)
+					while (*ep++);
-					;
 					/* null terminate the string one out */
 					*(ep + 1) = 0;
 					/* copy backwards */
-				while(ep-- > sp)
+					while (ep-- > sp)
 						*(ep + 1) = *ep;
 
 					/* and advance sp past the new % */
@@ -574,7 +590,7 @@ nxtscan:	/* on to the next line */
 			if ((c = get1key()) == abortc) {
 				mlforce("(Macro aborted)");
 				freewhile(whlist);
-				return(FALSE);
+				return (FALSE);
 			}
 
 			if (c == metac)
@@ -596,7 +612,7 @@ nxtscan:	/* on to the next line */
 			if (dirnum == NUMDIRS) {
 				mlwrite("%%Unknown Directive");
 				freewhile(whlist);
-				return(FALSE);
+				return (FALSE);
 			}
 
 			/* service only the !ENDM macro here */
@@ -606,7 +622,7 @@ nxtscan:	/* on to the next line */
 				goto onward;
 			}
 
-			/* restore the original eline....*/
+			/* restore the original eline.... */
 			--eline;
 		}
 
@@ -614,13 +630,14 @@ nxtscan:	/* on to the next line */
 		if (mstore) {
 			/* allocate the space for the line */
 			linlen = strlen(eline);
-			if ((mp=lalloc(linlen)) == NULL) {
+			if ((mp = lalloc(linlen)) == NULL) {
-				mlwrite("Out of memory while storing macro");
+				mlwrite
+				    ("Out of memory while storing macro");
 				return (FALSE);
 			}
 
 			/* copy the text into the new line */
-			for (i=0; i<linlen; ++i)
+			for (i = 0; i < linlen; ++i)
 				lputc(mp, i, eline[i]);
 
 			/* attach the line to the end of the buffer */
@@ -681,9 +698,10 @@ nxtscan:	/* on to the next line */
 				}
 
 				if (whtemp == NULL) {
-					mlwrite("%%Internal While loop error");
+					mlwrite
+					    ("%%Internal While loop error");
 					freewhile(whlist);
-					return(FALSE);
+					return (FALSE);
 				}
 
 				/* reset the line pointer back.. */
@@ -693,7 +711,7 @@ nxtscan:	/* on to the next line */
 			case DELSE:	/* ELSE directive */
 				if (execlevel == 1)
 					--execlevel;
-				else if (execlevel == 0 )
+				else if (execlevel == 0)
 					++execlevel;
 				goto onward;
 
@@ -707,12 +725,15 @@ nxtscan:	/* on to the next line */
 				if (execlevel == 0) {
 
 					/* grab label to jump to */
-					eline = token(eline, golabel, NPAT);
+					eline =
+					    token(eline, golabel, NPAT);
 					linlen = strlen(golabel);
 					glp = hlp->l_fp;
 					while (glp != hlp) {
 						if (*glp->l_text == '*' &&
-						    (strncmp(&glp->l_text[1], golabel,
+						    (strncmp
+						     (&glp->l_text[1],
+						      golabel,
 						      linlen) == 0)) {
 							lp = glp;
 							goto onward;
@@ -721,7 +742,7 @@ nxtscan:	/* on to the next line */
 					}
 					mlwrite("%%No such label");
 					freewhile(whlist);
-					return(FALSE);
+					return (FALSE);
 				}
 				goto onward;
 
@@ -738,16 +759,18 @@ nxtscan:	/* on to the next line */
 					/* find the right while loop */
 					whtemp = whlist;
 					while (whtemp) {
-						if (whtemp->w_type == BTWHILE &&
+						if (whtemp->w_type ==
-						    whtemp->w_end == lp)
+						    BTWHILE
+						    && whtemp->w_end == lp)
 							break;
 						whtemp = whtemp->w_next;
 					}
 
 					if (whtemp == NULL) {
-						mlwrite("%%Internal While loop error");
+						mlwrite
+						    ("%%Internal While loop error");
 						freewhile(whlist);
-						return(FALSE);
+						return (FALSE);
 					}
 
 					/* reset the line pointer back.. */
@@ -785,22 +808,22 @@ nxtscan:	/* on to the next line */
 			free(einit);
 			execlevel = 0;
 			freewhile(whlist);
-			return(status);
+			return (status);
 		}
 
-onward:		/* on to the next line */
+	      onward:		/* on to the next line */
 		free(einit);
 		lp = lp->l_fp;
 	}
 
-eexec:	/* exit the current function */
+      eexec:			/* exit the current function */
 	execlevel = 0;
 	freewhile(whlist);
-        return(TRUE);
+	return (TRUE);
 }
 
-freewhile(wp)	/* free a list of while block pointers */
+freewhile(wp)
-
+    /* free a list of while block pointers */
 WHBLOCK *wp;			/* head of structure to free */
 
 {
@@ -811,8 +834,8 @@ WHBLOCK *wp;	/* head of structure to free */
 	free(wp);
 }
 
-execfile(f, n)	/* execute a series of commands in a file */
+execfile(f, n)
-
+    /* execute a series of commands in a file */
 int f, n;			/* default flag and numeric arg to pass on to file */
 
 {
@@ -820,8 +843,9 @@ int f, n;	/* default flag and numeric arg to pass on to file */
 	char fname[NSTRING];	/* name of file to execute */
 	char *fspec;		/* full file spec */
 
-	if ((status = mlreply("File to execute: ", fname, NSTRING -1)) != TRUE)
+	if ((status =
-		return(status);
+	     mlreply("File to execute: ", fname, NSTRING - 1)) != TRUE)
+		return (status);
 
 #if	1
 	/* look up the path for the file */
@@ -829,15 +853,15 @@ int f, n;	/* default flag and numeric arg to pass on to file */
 
 	/* if it isn't around */
 	if (fspec == NULL)
-		return(FALSE);
+		return (FALSE);
 
 #endif
 	/* otherwise, execute it */
 	while (n-- > 0)
-		if ((status=dofile(fspec)) != TRUE)
+		if ((status = dofile(fspec)) != TRUE)
-			return(status);
+			return (status);
 
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	dofile:	yank a file into a buffer and execute it
@@ -856,7 +880,7 @@ char *fname;	/* file name to execute */
 	makename(bname, fname);	/* derive the name of the buffer */
 	unqname(bname);		/* make sure we don't stomp things */
 	if ((bp = bfind(bname, TRUE, 0)) == NULL)	/* get the needed buffer */
-		return(FALSE);
+		return (FALSE);
 
 	bp->b_mode = MDVIEW;	/* mark the buffer as read only */
 	cb = curbp;		/* save the old buffer */
@@ -864,18 +888,18 @@ char *fname;	/* file name to execute */
 	/* and try to read in the file to execute */
 	if ((status = readin(fname, FALSE)) != TRUE) {
 		curbp = cb;	/* restore the current buffer */
-		return(status);
+		return (status);
 	}
 
 	/* go execute it! */
 	curbp = cb;		/* restore the current buffer */
 	if ((status = dobuf(bp)) != TRUE)
-		return(status);
+		return (status);
 
 	/* if not displayed, remove the now unneeded buffer and exit */
 	if (bp->b_nwnd == 0)
 		zotbuf(bp);
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	cbuf:	Execute the contents of a numbered buffer	*/
@@ -895,254 +919,214 @@ int bufnum;	/* number of buffer to execute */
 	bufname[8] = '0' + (bufnum % 10);
 
 	/* find the pointer to that buffer */
-        if ((bp=bfind(bufname, FALSE, 0)) == NULL) {
+	if ((bp = bfind(bufname, FALSE, 0)) == NULL) {
 		mlwrite("Macro not defined");
-                return(FALSE);
+		return (FALSE);
 	}
 
 	/* and now execute it as asked */
 	while (n-- > 0)
 		if ((status = dobuf(bp)) != TRUE)
-			return(status);
+			return (status);
-	return(TRUE);
+	return (TRUE);
 }
 
 cbuf1(f, n)
-
 {
 	return cbuf(f, n, 1);
 }
 
 cbuf2(f, n)
-
 {
 	return cbuf(f, n, 2);
 }
 
 cbuf3(f, n)
-
 {
 	return cbuf(f, n, 3);
 }
 
 cbuf4(f, n)
-
 {
 	return cbuf(f, n, 4);
 }
 
 cbuf5(f, n)
-
 {
 	return cbuf(f, n, 5);
 }
 
 cbuf6(f, n)
-
 {
 	return cbuf(f, n, 6);
 }
 
 cbuf7(f, n)
-
 {
 	return cbuf(f, n, 7);
 }
 
 cbuf8(f, n)
-
 {
 	return cbuf(f, n, 8);
 }
 
 cbuf9(f, n)
-
 {
 	return cbuf(f, n, 9);
 }
 
 cbuf10(f, n)
-
 {
 	return cbuf(f, n, 10);
 }
 
 cbuf11(f, n)
-
 {
 	return cbuf(f, n, 11);
 }
 
 cbuf12(f, n)
-
 {
 	return cbuf(f, n, 12);
 }
 
 cbuf13(f, n)
-
 {
 	return cbuf(f, n, 13);
 }
 
 cbuf14(f, n)
-
 {
 	return cbuf(f, n, 14);
 }
 
 cbuf15(f, n)
-
 {
 	return cbuf(f, n, 15);
 }
 
 cbuf16(f, n)
-
 {
 	return cbuf(f, n, 16);
 }
 
 cbuf17(f, n)
-
 {
 	return cbuf(f, n, 17);
 }
 
 cbuf18(f, n)
-
 {
 	return cbuf(f, n, 18);
 }
 
 cbuf19(f, n)
-
 {
 	return cbuf(f, n, 19);
 }
 
 cbuf20(f, n)
-
 {
 	return cbuf(f, n, 20);
 }
 
 cbuf21(f, n)
-
 {
 	return cbuf(f, n, 21);
 }
 
 cbuf22(f, n)
-
 {
 	return cbuf(f, n, 22);
 }
 
 cbuf23(f, n)
-
 {
 	return cbuf(f, n, 23);
 }
 
 cbuf24(f, n)
-
 {
 	return cbuf(f, n, 24);
 }
 
 cbuf25(f, n)
-
 {
 	return cbuf(f, n, 25);
 }
 
 cbuf26(f, n)
-
 {
 	return cbuf(f, n, 26);
 }
 
 cbuf27(f, n)
-
 {
 	return cbuf(f, n, 27);
 }
 
 cbuf28(f, n)
-
 {
 	return cbuf(f, n, 28);
 }
 
 cbuf29(f, n)
-
 {
 	return cbuf(f, n, 29);
 }
 
 cbuf30(f, n)
-
 {
 	return cbuf(f, n, 30);
 }
 
 cbuf31(f, n)
-
 {
 	return cbuf(f, n, 31);
 }
 
 cbuf32(f, n)
-
 {
 	return cbuf(f, n, 32);
 }
 
 cbuf33(f, n)
-
 {
 	return cbuf(f, n, 33);
 }
 
 cbuf34(f, n)
-
 {
 	return cbuf(f, n, 34);
 }
 
 cbuf35(f, n)
-
 {
 	return cbuf(f, n, 35);
 }
 
 cbuf36(f, n)
-
 {
 	return cbuf(f, n, 36);
 }
 
 cbuf37(f, n)
-
 {
 	return cbuf(f, n, 37);
 }
 
 cbuf38(f, n)
-
 {
 	return cbuf(f, n, 38);
 }
 
 cbuf39(f, n)
-
 {
 	return cbuf(f, n, 39);
 }
 
 cbuf40(f, n)
-
 {
 	return cbuf(f, n, 40);
 }

file.c

@@ -24,10 +24,10 @@ fileread(f, n)
 	char fname[NFILEN];
 
 	if (restflag)		/* don't allow this command if restricted */
-		return(resterr());
+		return (resterr());
-        if ((s=mlreply("Read file: ", fname, NFILEN)) != TRUE)
+	if ((s = mlreply("Read file: ", fname, NFILEN)) != TRUE)
-                return(s);
+		return (s);
-        return(readin(fname, TRUE));
+	return (readin(fname, TRUE));
 }
 
 /*
@@ -43,14 +43,14 @@ insfile(f, n)
 	char fname[NFILEN];
 
 	if (restflag)		/* don't allow this command if restricted */
-		return(resterr());
+		return (resterr());
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
-        if ((s=mlreply("Insert file: ", fname, NFILEN)) != TRUE)
+	if ((s = mlreply("Insert file: ", fname, NFILEN)) != TRUE)
-                return(s);
+		return (s);
-	if ((s=ifile(fname)) != TRUE)
+	if ((s = ifile(fname)) != TRUE)
-		return(s);
+		return (s);
-	return(reposition(TRUE, -1));
+	return (reposition(TRUE, -1));
 }
 
 /*
@@ -68,21 +68,21 @@ filefind(f, n)
 	register int s;		/* status return */
 
 	if (restflag)		/* don't allow this command if restricted */
-		return(resterr());
+		return (resterr());
-        if ((s=mlreply("Find file: ", fname, NFILEN)) != TRUE)
+	if ((s = mlreply("Find file: ", fname, NFILEN)) != TRUE)
-                return(s);
+		return (s);
-	return(getfile(fname, TRUE));
+	return (getfile(fname, TRUE));
 }
 
-viewfile(f, n)	/* visit a file in VIEW mode */
+viewfile(f, n)
-{
+{				/* visit a file in VIEW mode */
 	char fname[NFILEN];	/* file user wishes to find */
 	register int s;		/* status return */
 	register WINDOW *wp;	/* scan for windows that need updating */
 
 	if (restflag)		/* don't allow this command if restricted */
-		return(resterr());
+		return (resterr());
-        if ((s=mlreply("View file: ", fname, NFILEN)) != TRUE)
+	if ((s = mlreply("View file: ", fname, NFILEN)) != TRUE)
 		return (s);
 	s = getfile(fname, FALSE);
 	if (s) {		/* if we succeed, put it in view mode */
@@ -95,13 +95,12 @@ viewfile(f, n)	/* visit a file in VIEW mode */
 			wp = wp->w_wndp;
 		}
 	}
-	return(s);
+	return (s);
 }
 
 #if	CRYPT
-resetkey()	/* reset the encryption key if needed */
+resetkey()
-
+{				/* reset the encryption key if needed */
-{
 	register int s;		/* return status */
 
 	/* turn off the encryption flag */
@@ -112,7 +111,7 @@ resetkey()	/* reset the encryption key if needed */
 		if (curbp->b_key[0] == 0) {
 			s = setkey(FALSE, 0);
 			if (s != TRUE)
-				return(s);
+				return (s);
 		}
 
 		/* let others know... */
@@ -120,15 +119,15 @@ resetkey()	/* reset the encryption key if needed */
 
 		/* and set up the key to be used! */
 		/* de-encrypt it */
-		crypt((char *)NULL, 0);
+		crypt((char *) NULL, 0);
 		crypt(curbp->b_key, strlen(curbp->b_key));
 
 		/* re-encrypt it...seeding it to start */
-		crypt((char *)NULL, 0);
+		crypt((char *) NULL, 0);
 		crypt(curbp->b_key, strlen(curbp->b_key));
 	}
 
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 
@@ -147,22 +146,23 @@ int lockfl;		/* check the file for locks? */
 #if	MSDOS
 	mklower(fname);		/* msdos isn't case sensitive */
 #endif
-        for (bp=bheadp; bp!=NULL; bp=bp->b_bufp) {
+	for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
-                if ((bp->b_flag&BFINVS)==0 && strcmp(bp->b_fname, fname)==0) {
+		if ((bp->b_flag & BFINVS) == 0
+		    && strcmp(bp->b_fname, fname) == 0) {
 			swbuffer(bp);
 			lp = curwp->w_dotp;
-                        i = curwp->w_ntrows/2;
+			i = curwp->w_ntrows / 2;
-                        while (i-- && lback(lp)!=curbp->b_linep)
+			while (i-- && lback(lp) != curbp->b_linep)
 				lp = lback(lp);
 			curwp->w_linep = lp;
-                        curwp->w_flag |= WFMODE|WFHARD;
+			curwp->w_flag |= WFMODE | WFHARD;
 			cknewwindow();
 			mlwrite("(Old buffer)");
 			return (TRUE);
 		}
 	}
 	makename(bname, fname);	/* New buffer name.     */
-        while ((bp=bfind(bname, FALSE, 0)) != NULL) {
+	while ((bp = bfind(bname, FALSE, 0)) != NULL) {
 		/* old buffer name conflict code */
 		s = mlreply("Buffer name: ", bname, NBUFN);
 		if (s == ABORT)	/* ^G to just quit      */
@@ -172,7 +172,7 @@ int lockfl;		/* check the file for locks? */
 			break;
 		}
 	}
-        if (bp==NULL && (bp=bfind(bname, TRUE, 0))==NULL) {
+	if (bp == NULL && (bp = bfind(bname, TRUE, 0)) == NULL) {
 		mlwrite("Cannot create buffer");
 		return (FALSE);
 	}
@@ -226,27 +226,27 @@ int	lockfl;		/* check for file locks? */
 		goto out;
 	}
 #else
-		return(ABORT);
+		return (ABORT);
 #endif
 #endif
 #if	CRYPT
 	s = resetkey();
 	if (s != TRUE)
-		return(s);
+		return (s);
 #endif
 	bp = curbp;		/* Cheap.               */
-        if ((s=bclear(bp)) != TRUE)             /* Might be old.        */
+	if ((s = bclear(bp)) != TRUE)	/* Might be old.        */
 		return (s);
-        bp->b_flag &= ~(BFINVS|BFCHG);
+	bp->b_flag &= ~(BFINVS | BFCHG);
 	strcpy(bp->b_fname, fname);
 
 	/* let a user macro get hold of things...if he wants */
-	execute(META|SPEC|'R', FALSE, 1);
+	execute(META | SPEC | 'R', FALSE, 1);
 
 	/* turn off ALL keyboard translation in case we get a dos error */
 	TTkclose();
 
-        if ((s=ffropen(fname)) == FIOERR)       /* Hard file open.      */
+	if ((s = ffropen(fname)) == FIOERR)	/* Hard file open.      */
 		goto out;
 
 	if (s == FIOFNF) {	/* File not found.      */
@@ -258,9 +258,9 @@ int	lockfl;		/* check for file locks? */
 	mlwrite("(Reading file)");
 	nline = 0;
 	lflag = FALSE;
-        while ((s=ffgetline()) == FIOSUC) {
+	while ((s = ffgetline()) == FIOSUC) {
 		nbytes = strlen(fline);
-                if ((lp1=lalloc(nbytes)) == NULL) {
+		if ((lp1 = lalloc(nbytes)) == NULL) {
 			s = FIOMEM;	/* Keep message on the  */
 			break;	/* display.             */
 		}
@@ -275,13 +275,13 @@ int	lockfl;		/* check for file locks? */
 		lp1->l_fp = curbp->b_linep;
 		lp1->l_bp = lp2;
 		curbp->b_linep->l_bp = lp1;
-                for (i=0; i<nbytes; ++i)
+		for (i = 0; i < nbytes; ++i)
 			lputc(lp1, i, fline[i]);
 		++nline;
 	}
 	ffclose();		/* Ignore errors.       */
 	strcpy(mesg, "(");
-	if (s==FIOERR) {
+	if (s == FIOERR) {
 		strcat(mesg, "I/O ERROR, ");
 		curbp->b_flag |= BFTRUNC;
 	}
@@ -295,23 +295,23 @@ int	lockfl;		/* check for file locks? */
 	strcat(mesg, ")");
 	mlwrite(mesg);
 
-out:
+      out:
 	TTkopen();		/* open the keyboard again */
-        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_linep = lforw(curbp->b_linep);
 			wp->w_dotp = lforw(curbp->b_linep);
 			wp->w_doto = 0;
 			wp->w_markp = NULL;
 			wp->w_marko = 0;
-                        wp->w_flag |= WFMODE|WFHARD;
+			wp->w_flag |= WFMODE | WFHARD;
 		}
 	}
 	if (s == FIOERR || s == FIOFNF)	/* False if error.      */
-                return(FALSE);
+		return (FALSE);
 #if 0
 	if (s == ABORT)
-		return(ABORT);
+		return (ABORT);
 #endif
 	return (TRUE);
 }
@@ -336,28 +336,30 @@ char    fname[];
 
 #if     VMS
 #if	PKCODE
-	while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!=']' && cp1[-1]!='>')
+	while (cp1 != &fname[0] && cp1[-1] != ':' && cp1[-1] != ']'
+	       && cp1[-1] != '>')
 #else
-        while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!=']')
+	while (cp1 != &fname[0] && cp1[-1] != ':' && cp1[-1] != ']')
 #endif
 		--cp1;
 #endif
 #if     MSDOS
-        while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!='\\'&&cp1[-1]!='/')
+	while (cp1 != &fname[0] && cp1[-1] != ':' && cp1[-1] != '\\'
+	       && cp1[-1] != '/')
 		--cp1;
 #endif
 #if     V7 | USG | BSD
-        while (cp1!=&fname[0] && cp1[-1]!='/')
+	while (cp1 != &fname[0] && cp1[-1] != '/')
 		--cp1;
 #endif
 	cp2 = &bname[0];
-        while (cp2!=&bname[NBUFN-1] && *cp1!=0 && *cp1!=';')
+	while (cp2 != &bname[NBUFN - 1] && *cp1 != 0 && *cp1 != ';')
 		*cp2++ = *cp1++;
 	*cp2 = 0;
 }
 
-unqname(name)	/* make sure a buffer name is unique */
+unqname(name)
-
+    /* make sure a buffer name is unique */
 char *name;			/* name to check on */
 
 {
@@ -370,7 +372,7 @@ char *name;	/* name to check on */
 		sp = name;
 		while (*sp)
 			++sp;
-		if (sp == name || (*(sp-1) <'0' || *(sp-1) > '8')) {
+		if (sp == name || (*(sp - 1) < '0' || *(sp - 1) > '8')) {
 			*sp++ = '0';
 			*sp = 0;
 		} else
@@ -394,10 +396,10 @@ filewrite(f, n)
 	char fname[NFILEN];
 
 	if (restflag)		/* don't allow this command if restricted */
-		return(resterr());
+		return (resterr());
-        if ((s=mlreply("Write file: ", fname, NFILEN)) != TRUE)
+	if ((s = mlreply("Write file: ", fname, NFILEN)) != TRUE)
 		return (s);
-        if ((s=writeout(fname)) == TRUE) {
+	if ((s = writeout(fname)) == TRUE) {
 		strcpy(curbp->b_fname, fname);
 		curbp->b_flag &= ~BFCHG;
 		wp = wheadp;	/* Update mode lines.   */
@@ -423,9 +425,9 @@ filesave(f, n)
 	register WINDOW *wp;
 	register int s;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
-        if ((curbp->b_flag&BFCHG) == 0)         /* Return, no changes.  */
+	if ((curbp->b_flag & BFCHG) == 0)	/* Return, no changes.  */
 		return (TRUE);
 	if (curbp->b_fname[0] == 0) {	/* Must have a name.    */
 		mlwrite("No file name");
@@ -433,14 +435,14 @@ filesave(f, n)
 	}
 
 	/* complain about truncated files */
-	if ((curbp->b_flag&BFTRUNC) != 0) {
+	if ((curbp->b_flag & BFTRUNC) != 0) {
 		if (mlyesno("Truncated file ... write it out") == FALSE) {
 			mlwrite("(Aborted)");
-			return(FALSE);
+			return (FALSE);
 		}
 	}
 
-        if ((s=writeout(curbp->b_fname)) == TRUE) {
+	if ((s = writeout(curbp->b_fname)) == TRUE) {
 		curbp->b_flag &= ~BFCHG;
 		wp = wheadp;	/* Update mode lines.   */
 		while (wp != NULL) {
@@ -470,12 +472,12 @@ char    *fn;
 #if	CRYPT
 	s = resetkey();
 	if (s != TRUE)
-		return(s);
+		return (s);
 #endif
 	/* turn off ALL keyboard translation in case we get a dos error */
 	TTkclose();
 
-        if ((s=ffwopen(fn)) != FIOSUC) {        /* Open writes message. */
+	if ((s = ffwopen(fn)) != FIOSUC) {	/* Open writes message. */
 		TTkopen();
 		return (FALSE);
 	}
@@ -483,7 +485,7 @@ char    *fn;
 	lp = lforw(curbp->b_linep);	/* First line.          */
 	nline = 0;		/* Number of lines.     */
 	while (lp != curbp->b_linep) {
-                if ((s=ffputline(&lp->l_text[0], llength(lp))) != FIOSUC)
+		if ((s = ffputline(&lp->l_text[0], llength(lp))) != FIOSUC)
 			break;
 		++nline;
 		lp = lforw(lp);
@@ -520,8 +522,8 @@ filename(f, n)
 	char fname[NFILEN];
 
 	if (restflag)		/* don't allow this command if restricted */
-		return(resterr());
+		return (resterr());
-        if ((s=mlreply("Name: ", fname, NFILEN)) == ABORT)
+	if ((s = mlreply("Name: ", fname, NFILEN)) == ABORT)
 		return (s);
 	if (s == FALSE)
 		strcpy(curbp->b_fname, "");
@@ -558,19 +560,19 @@ char    fname[];
 
 	bp = curbp;		/* Cheap.               */
 	bp->b_flag |= BFCHG;	/* we have changed      */
-	bp->b_flag &= ~BFINVS;			/* and are not temporary*/
+	bp->b_flag &= ~BFINVS;	/* and are not temporary */
-        if ((s=ffropen(fname)) == FIOERR)       /* Hard file open.      */
+	if ((s = ffropen(fname)) == FIOERR)	/* Hard file open.      */
 		goto out;
 	if (s == FIOFNF) {	/* File not found.      */
 		mlwrite("(No such file)");
-		return(FALSE);
+		return (FALSE);
 	}
 	mlwrite("(Inserting file)");
 
 #if	CRYPT
 	s = resetkey();
 	if (s != TRUE)
-		return(s);
+		return (s);
 #endif
 	/* back up a line and save the mark here */
 	curwp->w_dotp = lback(curwp->w_dotp);
@@ -580,9 +582,9 @@ char    fname[];
 
 	nline = 0;
 	lflag = FALSE;
-        while ((s=ffgetline()) == FIOSUC) {
+	while ((s = ffgetline()) == FIOSUC) {
 		nbytes = strlen(fline);
-                if ((lp1=lalloc(nbytes)) == NULL) {
+		if ((lp1 = lalloc(nbytes)) == NULL) {
 			s = FIOMEM;	/* Keep message on the  */
 			break;	/* display.             */
 		}
@@ -597,14 +599,14 @@ char    fname[];
 
 		/* and advance and write out the current line */
 		curwp->w_dotp = lp1;
-                for (i=0; i<nbytes; ++i)
+		for (i = 0; i < nbytes; ++i)
 			lputc(lp1, i, fline[i]);
 		++nline;
 	}
 	ffclose();		/* Ignore errors.       */
 	curwp->w_markp = lforw(curwp->w_markp);
 	strcpy(mesg, "(");
-	if (s==FIOERR) {
+	if (s == FIOERR) {
 		strcat(mesg, "I/O ERROR, ");
 		curbp->b_flag |= BFTRUNC;
 	}
@@ -618,7 +620,7 @@ char    fname[];
 	strcat(mesg, ")");
 	mlwrite(mesg);
 
-out:
+      out:
 	/* advance to the next line and mark the window for changes */
 	curwp->w_dotp = lforw(curwp->w_dotp);
 	curwp->w_flag |= WFHARD | WFMODE;

fileio.c

@@ -23,7 +23,7 @@ int eofflag;		/* end-of-file flag */
 ffropen(fn)
 char *fn;
 {
-        if ((ffp=fopen(fn, "r")) == NULL)
+	if ((ffp = fopen(fn, "r")) == NULL)
 		return (FIOFNF);
 	eofflag = FALSE;
 	return (FIOSUC);
@@ -39,10 +39,10 @@ char    *fn;
 #if     VMS
 	register int fd;
 
-        if ((fd=creat(fn, 0666, "rfm=var", "rat=cr")) < 0
+	if ((fd = creat(fn, 0666, "rfm=var", "rat=cr")) < 0
-        || (ffp=fdopen(fd, "w")) == NULL) {
+	    || (ffp = fdopen(fd, "w")) == NULL) {
 #else
-        if ((ffp=fopen(fn, "w")) == NULL) {
+	if ((ffp = fopen(fn, "w")) == NULL) {
 #endif
 		mlwrite("Cannot open file for writing");
 		return (FIOERR);
@@ -69,9 +69,9 @@ ffclose()
 #if     V7 | USG | BSD | (MSDOS & (MSC | TURBO))
 	if (fclose(ffp) != FALSE) {
 		mlwrite("Error closing file");
-                return(FIOERR);
+		return (FIOERR);
 	}
-        return(FIOSUC);
+	return (FIOSUC);
 #else
 	fclose(ffp);
 	return (FIOSUC);
@@ -98,10 +98,10 @@ char    buf[];
 		}
 	} else
 		for (i = 0; i < nbuf; ++i)
-        	        fputc(buf[i]&0xFF, ffp);
+			fputc(buf[i] & 0xFF, ffp);
 #else
 	for (i = 0; i < nbuf; ++i)
-                fputc(buf[i]&0xFF, ffp);
+		fputc(buf[i] & 0xFF, ffp);
 #endif
 
 	fputc('\n', ffp);
@@ -121,7 +121,6 @@ char    buf[];
  * errors too. Return status.
  */
 ffgetline()
-
 {
 	register int c;		/* current character read */
 	register int i;		/* current index into fline */
@@ -129,7 +128,7 @@ ffgetline()
 
 	/* if we are at the end...return it */
 	if (eofflag)
-		return(FIOEOF);
+		return (FIOEOF);
 
 	/* dump fline if it ended up too big */
 	if (flen > NSTRING) {
@@ -140,25 +139,23 @@ ffgetline()
 	/* if we don't have an fline, allocate one */
 	if (fline == NULL)
 		if ((fline = malloc(flen = NSTRING)) == NULL)
-			return(FIOMEM);
+			return (FIOMEM);
 
 	/* read the line in */
 #if	PKCODE
 	if (!nullflag) {
-	if (fgets(fline, NSTRING, ffp) == (char *)NULL) {	/* EOF ? */
+		if (fgets(fline, NSTRING, ffp) == (char *) NULL) {	/* EOF ? */
 			i = 0;
 			c = EOF;
-	}
+		} else {
-	else {
 			i = strlen(fline);
 			c = 0;
 			if (i > 0) {
-			c = fline[i-1];
+				c = fline[i - 1];
 				i--;
 			}
 		}
-	}
+	} else {
-	else {
 		i = 0;
 		c = fgetc(ffp);
 	}
@@ -173,8 +170,9 @@ ffgetline()
 			fline[i++] = c;
 			/* if it's longer, get more room */
 			if (i >= flen) {
-                	if ((tmpline = malloc(flen+NSTRING)) == NULL)
+				if ((tmpline =
-                		return(FIOMEM);
+				     malloc(flen + NSTRING)) == NULL)
+					return (FIOMEM);
 				strncpy(tmpline, fline, flen);
 				flen += NSTRING;
 				free(fline);
@@ -190,13 +188,13 @@ ffgetline()
 	if (c == EOF) {
 		if (ferror(ffp)) {
 			mlwrite("File read error");
-                        return(FIOERR);
+			return (FIOERR);
 		}
 
 		if (i != 0)
 			eofflag = TRUE;
 		else
-			return(FIOEOF);
+			return (FIOEOF);
 	}
 
 	/* terminate and decrypt the string */
@@ -205,11 +203,11 @@ ffgetline()
 	if (cryptflag)
 		crypt(fline, strlen(fline));
 #endif
-        return(FIOSUC);
+	return (FIOSUC);
 }
 
-int fexist(fname)	/* does <fname> exist on disk? */
+int fexist(fname)
-
+			    /* does <fname> exist on disk? */
 char *fname;			/* file to check for existance */
 
 {
@@ -220,9 +218,9 @@ char *fname;		/* file to check for existance */
 
 	/* if it fails, just return false! */
 	if (fp == NULL)
-		return(FALSE);
+		return (FALSE);
 
 	/* otherwise, close it and report true */
 	fclose(fp);
-	return(TRUE);
+	return (TRUE);
 }

ibmpc.c

@@ -54,7 +54,7 @@ int dtype = -1;				/* current display type		*/
 char drvname[][8] = {		/* screen resolution names      */
 	"CGA", "MONO", "EGA"
 #if	PKCODE
-       ,"VGA"
+	    , "VGA"
 #endif
 };
 long scadd;			/* address of screen ram        */
@@ -89,9 +89,9 @@ int	cfcolor = -1;		/* current forground color */
 int cbcolor = -1;		/* current background color */
 int ctrans[] =			/* ansi to ibm color translation table */
 #if	PKCODE
-	{0, 4, 2, 6, 1, 5, 3, 7, 15};
+{ 0, 4, 2, 6, 1, 5, 3, 7, 15 };
 #else
-	{0, 4, 2, 6, 1, 5, 3, 7};
+{ 0, 4, 2, 6, 1, 5, 3, 7 };
 #endif
 #endif
 
@@ -100,8 +100,8 @@ int	ctrans[] =		/* ansi to ibm color translation table */
  * "termio" code.
  */
 TERM term = {
-	NROW-1,
+	NROW - 1,
-        NROW-1,
+	NROW - 1,
 	NCOL,
 	NCOL,
 	MARGIN,
@@ -130,16 +130,16 @@ TERM    term    = {
 };
 
 #if	COLOR
-ibmfcol(color)		/* set the current output color */
+ibmfcol(color)
-
+    /* set the current output color */
 int color;			/* color to set */
 
 {
 	cfcolor = ctrans[color];
 }
 
-ibmbcol(color)		/* set the current background color */
+ibmbcol(color)
-
+    /* set the current background color */
 int color;			/* color to set */
 
 {
@@ -156,9 +156,8 @@ ibmmove(row, col)
 	int86(0x10, &rg, &rg);
 }
 
-ibmeeol()	/* erase to the end of the line */
+ibmeeol()
-
+{				/* erase to the end of the line */
-{
 	unsigned int attr;	/* attribute byte mask to place in RAM */
 	unsigned int *lnptr;	/* pointer to the destination line */
 	int i;
@@ -182,27 +181,25 @@ ibmeeol()	/* erase to the end of the line */
 	attr = 0x0700;
 #endif
 	lnptr = &sline[0];
-	for (i=0; i < term.t_ncol; i++)
+	for (i = 0; i < term.t_ncol; i++)
 		*lnptr++ = SPACE | attr;
 
 	if (flickcode && (dtype == CDCGA)) {
 		/* wait for vertical retrace to be off */
-		while ((inp(0x3da) & 8))
+		while ((inp(0x3da) & 8));
-			;
 
 		/* and to be back on */
-		while ((inp(0x3da) & 8) == 0)
+		while ((inp(0x3da) & 8) == 0);
-			;
 	}
 
 	/* and send the string out */
-	movmem(&sline[0], scptr[crow]+ccol, (term.t_ncol-ccol)*2);
+	movmem(&sline[0], scptr[crow] + ccol, (term.t_ncol - ccol) * 2);
 
 }
 
-ibmputc(ch)	/* put a character at the current position in the
+ibmputc(ch)
+    /* put a character at the current position in the
        current colors */
-
 int ch;
 
 {
@@ -230,7 +227,8 @@ ibmeeop()
 	/* lower right corner of scroll */
 #if	COLOR
 	if (dtype != CDMONO)
-		attr = ((ctrans[gbcolor] & 15) << 4) | (ctrans[gfcolor] & 15);
+		attr =
+		    ((ctrans[gbcolor] & 15) << 4) | (ctrans[gfcolor] & 15);
 	else
 		attr = 0;
 #else
@@ -240,16 +238,16 @@ ibmeeop()
 	int86(0x10, &rg, &rg);
 }
 
-ibmrev(state)		/* change reverse video state */
+ibmrev(state)
-
+    /* change reverse video state */
 int state;			/* TRUE = reverse, FALSE = normal */
 
 {
 	/* This never gets used under the IBM-PC driver */
 }
 
-ibmcres(res)	/* change screen resolution */
+ibmcres(res)
-
+    /* change screen resolution */
 char *res;			/* resolution to change to */
 
 {
@@ -258,9 +256,9 @@ char *res;	/* resolution to change to */
 	for (i = 0; i < NDRIVE; i++)
 		if (strcmp(res, drvname[i]) == 0) {
 			scinit(i);
-			return(TRUE);
+			return (TRUE);
 		}
-	return(FALSE);
+	return (FALSE);
 }
 
 #if SCROLLCODE
@@ -272,19 +270,19 @@ ibmscroll_reg(from, to, howmany)
 
 	if (to < from)
 		for (i = 0; i < howmany; i++)
-			movmem(scptr[from+i], scptr[to+i], term.t_ncol*2);
+			movmem(scptr[from + i], scptr[to + i],
-	else
+			       term.t_ncol * 2);
-	if (to > from)
+	else if (to > from)
-		for (i = howmany-1; i >= 0; i--)
+		for (i = howmany - 1; i >= 0; i--)
-			movmem(scptr[from+i], scptr[to+i], term.t_ncol*2);
+			movmem(scptr[from + i], scptr[to + i],
+			       term.t_ncol * 2);
 	return;
 }
 
 #endif
 
-spal()	/* reset the pallette registers */
+spal()
-
+{				/* reset the pallette registers */
-{
 	/* nothin here now..... */
 }
 
@@ -301,7 +299,6 @@ ibmopen()
 }
 
 ibmclose()
-
 {
 #if	COLOR
 	ibmfcol(7);
@@ -318,18 +315,16 @@ ibmclose()
 	ttclose();
 }
 
-ibmkopen()	/* open the keyboard */
+ibmkopen()
-
+{				/* open the keyboard */
-{
 }
 
-ibmkclose()	/* close the keyboard */
+ibmkclose()
-
+{				/* close the keyboard */
-{
 }
 
-scinit(type)	/* initialize the screen head pointers */
+scinit(type)
-
+    /* initialize the screen head pointers */
 int type;			/* type of adapter to init for */
 
 {
@@ -345,11 +340,11 @@ int type;	/* type of adapter to init for */
 
 	/* if we have nothing to do....don't do it */
 	if (dtype == type)
-		return(TRUE);
+		return (TRUE);
 
 	/* if we try to switch to EGA and there is none, don't */
 	if (type == CDEGA && egaexist != TRUE)
-		return(FALSE);
+		return (FALSE);
 
 	/* if we had the EGA open... close it */
 	if (dtype == CDEGA)
@@ -389,10 +384,10 @@ int type;	/* type of adapter to init for */
 
 	/* initialize the screen pointer array */
 	for (i = 0; i < NROW; i++) {
-		addr.laddr = scadd + (long)(NCOL * i * 2);
+		addr.laddr = scadd + (long) (NCOL * i * 2);
 		scptr[i] = addr.paddr;
 	}
-	return(TRUE);
+	return (TRUE);
 }
 
 /* getboard:	Determine which type of display board is attached.
@@ -410,7 +405,6 @@ int type;	/* type of adapter to init for */
 */
 
 int getboard()
-
 {
 	int type;		/* board type to return */
 
@@ -422,14 +416,13 @@ int getboard()
 	/* test if EGA present */
 	rg.x.ax = 0x1200;
 	rg.x.bx = 0xff10;
-	int86(0x10,&rg, &rg);		/* If EGA, bh=0-1 and bl=0-3 */
+	int86(0x10, &rg, &rg);	/* If EGA, bh=0-1 and bl=0-3 */
 	egaexist = !(rg.x.bx & 0xfefc);	/* Yes, it's EGA */
-	return(type);
+	return (type);
 }
 
-egaopen()	/* init the computer to work with the EGA */
+egaopen()
-
+{				/* init the computer to work with the EGA */
-{
 	/* put the beast into EGA 43 row mode */
 	rg.x.ax = 3;
 	int86(16, &rg, &rg);
@@ -453,15 +446,14 @@ egaopen()	/* init the computer to work with the EGA */
 }
 
 egaclose()
-
 {
 	/* put the beast into 80 column mode */
 	rg.x.ax = 3;
 	int86(16, &rg, &rg);
 }
 
-scwrite(row, outstr, forg, bacg)	/* write a line out*/
+scwrite(row, outstr, forg, bacg)
-
+    /* write a line out */
 int row;			/* row of screen to place outstr on */
 char *outstr;			/* string to write out (must be term.t_ncol long) */
 int forg;			/* forground color of string to write */
@@ -475,38 +467,38 @@ int bacg;	/* background color */
 	/* build the attribute byte and setup the screen pointer */
 #if	COLOR
 	if (dtype != CDMONO)
-		attr = (((ctrans[bacg] & 15) << 4) | (ctrans[forg] & 15)) << 8;
+		attr =
+		    (((ctrans[bacg] & 15) << 4) | (ctrans[forg] & 15)) <<
+		    8;
 	else
 		attr = (((bacg & 15) << 4) | (forg & 15)) << 8;
 #else
 	attr = (((bacg & 15) << 4) | (forg & 15)) << 8;
 #endif
 	lnptr = &sline[0];
-	for (i=0; i<term.t_ncol; i++)
+	for (i = 0; i < term.t_ncol; i++)
 		*lnptr++ = (outstr[i] & 255) | attr;
 
 	if (flickcode && (dtype == CDCGA)) {
 		/* wait for vertical retrace to be off */
-		while ((inp(0x3da) & 8))
+		while ((inp(0x3da) & 8));
-			;
 
 		/* and to be back on */
-		while ((inp(0x3da) & 8) == 0)
+		while ((inp(0x3da) & 8) == 0);
-			;
 	}
 
 	/* and send the string out */
-	movmem(&sline[0], scptr[row], term.t_ncol*2);
+	movmem(&sline[0], scptr[row], term.t_ncol * 2);
 }
 
 #if	FNLABEL
-fnclabel(f, n)		/* label a function key */
+fnclabel(f, n)
-
+    /* label a function key */
-int f,n;	/* default flag, numeric argument [unused] */
+int f, n;			/* default flag, numeric argument [unused] */
 
 {
 	/* on machines with no function keys...don't bother */
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 #else
@@ -514,4 +506,3 @@ ibmhello()
 {
 }
 #endif
-

input.c

@@ -46,13 +46,13 @@ char *prompt;
 		c = tgetc();
 
 		if (c == ectoc(abortc))	/* Bail out! */
-			return(ABORT);
+			return (ABORT);
 
-		if (c=='y' || c=='Y')
+		if (c == 'y' || c == 'Y')
-			return(TRUE);
+			return (TRUE);
 
-		if (c=='n' || c=='N')
+		if (c == 'n' || c == 'N')
-			return(FALSE);
+			return (FALSE);
 	}
 }
 
@@ -65,10 +65,10 @@ char *prompt;
  */
 
 mlreply(prompt, buf, nbuf)
-    char *prompt;
+char *prompt;
-    char *buf;
+char *buf;
 {
-	return(nextarg(prompt, buf, nbuf, ctoec('\n')));
+	return (nextarg(prompt, buf, nbuf, ctoec('\n')));
 }
 
 mlreplyt(prompt, buf, nbuf, eolchar)
@@ -78,7 +78,7 @@ char *buf;
 int eolchar;
 
 {
-	return(nextarg(prompt, buf, nbuf, eolchar));
+	return (nextarg(prompt, buf, nbuf, eolchar));
 }
 
 /*	ectoc:	expanded character to character
@@ -92,8 +92,8 @@ int c;
 	if (c & CONTROL)
 		c = c & ~(CONTROL | 0x40);
 	if (c & SPEC)
-		c= c & 255;
+		c = c & 255;
-	return(c);
+	return (c);
 }
 
 /*	ctoec:	character to extended character
@@ -104,8 +104,8 @@ ctoec(c)
 int c;
 
 {
-        if (c>=0x00 && c<=0x1F)
+	if (c >= 0x00 && c <= 0x1F)
-                c = CONTROL | (c+'@');
+		c = CONTROL | (c + '@');
 	return (c);
 }
 
@@ -114,8 +114,7 @@ int c;
    name if it is unique.
 */
 
-int (*getname())()
+int (*getname()) ()
-
 {
 	register int cpos;	/* current column on screen output */
 	register int c;
@@ -124,7 +123,7 @@ int (*getname())()
 	register NBIND *cffp;	/* current ptr to entry in name binding table */
 	register NBIND *lffp;	/* last ptr to entry in name binding table */
 	char buf[NSTRING];	/* buffer to hold tentative command name */
-	int (*fncmatch())();
+	int (*fncmatch()) ();
 
 	/* starting at the beginning of the string buffer */
 	cpos = 0;
@@ -132,8 +131,8 @@ int (*getname())()
 	/* if we are executing a command line get the next arg and match it */
 	if (clexec) {
 		if (macarg(buf) != TRUE)
-			return(FALSE);
+			return (FALSE);
-		return(fncmatch(&buf[0]));
+		return (fncmatch(&buf[0]));
 	}
 
 	/* build a name string from the keyboard */
@@ -145,12 +144,12 @@ int (*getname())()
 			buf[cpos] = 0;
 
 			/* and match it off */
-			return(fncmatch(&buf[0]));
+			return (fncmatch(&buf[0]));
 
 		} else if (c == ectoc(abortc)) {	/* Bell, abort */
 			ctrlg(FALSE, 0);
 			TTflush();
-			return( (int (*)()) NULL);
+			return ((int (*)()) NULL);
 
 		} else if (c == 0x7F || c == 0x08) {	/* rubout/erase */
 			if (cpos != 0) {
@@ -179,24 +178,34 @@ int (*getname())()
 			buf[cpos] = 0;	/* terminate it for us */
 			ffp = &names[0];	/* scan for matches */
 			while (ffp->n_func != NULL) {
-		if (strncmp(buf, ffp->n_name, strlen(buf)) == 0) {
+				if (strncmp(buf, ffp->n_name, strlen(buf))
+				    == 0) {
 					/* a possible match! More than one? */
 					if ((ffp + 1)->n_func == NULL ||
-			   (strncmp(buf, (ffp+1)->n_name, strlen(buf)) != 0)) {
+					    (strncmp
+					     (buf, (ffp + 1)->n_name,
+					      strlen(buf)) != 0)) {
 						/* no...we match, print it */
 						sp = ffp->n_name + cpos;
 						while (*sp)
 							TTputc(*sp++);
 						TTflush();
-				return(ffp->n_func);
+						return (ffp->n_func);
 					} else {
 /* << << << << << << << << << << << << << << << << << */
 						/* try for a partial match against the list */
 
 						/* first scan down until we no longer match the current input */
 						lffp = (ffp + 1);
-	while ((lffp+1)->n_func != NULL) {
+						while ((lffp +
-		if (strncmp(buf, (lffp+1)->n_name, strlen(buf)) != 0)
+							1)->n_func !=
+						       NULL) {
+							if (strncmp
+							    (buf,
+							     (lffp +
+							      1)->n_name,
+							     strlen(buf))
+							    != 0)
 								break;
 							++lffp;
 						}
@@ -204,18 +213,27 @@ int (*getname())()
 						/* and now, attempt to partial complete the string, char at a time */
 						while (TRUE) {
 							/* add the next char in */
-		buf[cpos] = ffp->n_name[cpos];
+							buf[cpos] =
+							    ffp->
+							    n_name[cpos];
 
 							/* scan through the candidates */
 							cffp = ffp + 1;
-		while (cffp <= lffp) {
+							while (cffp <=
-			if (cffp->n_name[cpos] != buf[cpos])
+							       lffp) {
+								if (cffp->
+								    n_name
+								    [cpos]
+								    !=
+								    buf
+								    [cpos])
 									goto onward;
 								++cffp;
 							}
 
 							/* add the character */
-		TTputc(buf[cpos++]);
+							TTputc(buf
+							       [cpos++]);
 						}
 /* << << << << << << << << << << << << << << << << << */
 					}
@@ -225,11 +243,11 @@ int (*getname())()
 
 			/* no match.....beep and onward */
 			TTbeep();
-onward:;
+		      onward:;
 			TTflush();
 /* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
 		} else {
-			if (cpos < NSTRING-1 && c > ' ') {
+			if (cpos < NSTRING - 1 && c > ' ') {
 				buf[cpos++] = c;
 				TTputc(c);
 			}
@@ -244,7 +262,6 @@ onward:;
 		macro action					*/
 
 int tgetc()
-
 {
 	int c;			/* fetched character */
 
@@ -253,7 +270,7 @@ int tgetc()
 
 		/* if there is some left... */
 		if (kbdptr < kbdend)
-			return((int)*kbdptr++);
+			return ((int) *kbdptr++);
 
 		/* at the end of last repitition? */
 		if (--kbdrep < 1) {
@@ -266,7 +283,7 @@ int tgetc()
 
 			/* reset the macro to the begining for the next rep */
 			kbdptr = &kbdm[0];
-			return((int)*kbdptr++);
+			return ((int) *kbdptr++);
 		}
 	}
 
@@ -289,7 +306,7 @@ int tgetc()
 	}
 
 	/* and finally give the char back */
-	return(c);
+	return (c);
 }
 
 /*	GET1KEY:	Get one keystroke. The only prefixs legal here
@@ -297,7 +314,6 @@ int tgetc()
 								*/
 
 get1key()
-
 {
 	int c;
 
@@ -307,14 +323,14 @@ get1key()
 #if	MSDOS
 	if (c == 0) {		/* Apply SPEC prefix    */
 		c = tgetc();
-	        if (c>=0x00 && c<=0x1F)		/* control key? */
+		if (c >= 0x00 && c <= 0x1F)	/* control key? */
-        	        c = CONTROL | (c+'@');
+			c = CONTROL | (c + '@');
-		return(SPEC | c);
+		return (SPEC | c);
 	}
 #endif
 
-        if (c>=0x00 && c<=0x1F)                 /* C0 control -> C-     */
+	if (c >= 0x00 && c <= 0x1F)	/* C0 control -> C-     */
-                c = CONTROL | (c+'@');
+		c = CONTROL | (c + '@');
 	return (c);
 }
 
@@ -322,7 +338,6 @@ get1key()
 		prefix keys
 							*/
 getcmd()
-
 {
 	int c;			/* fetched keystroke */
 #if VT220
@@ -333,7 +348,7 @@ getcmd()
 	c = get1key();
 
 #if VT220
-proc_metac:
+      proc_metac:
 #endif
 	/* process META prefix */
 	if (c == (CONTROL | '[')) {
@@ -342,20 +357,24 @@ proc_metac:
 		if (c == '[' || c == 'O') {	/* CSI P.K. */
 			c = get1key();
 			if (c >= 'A' && c <= 'D')
-				return(SPEC | c | cmask);
+				return (SPEC | c | cmask);
 			if (c >= 'E' && c <= 'z' && c != 'i' && c != 'c')
-				return(SPEC | c | cmask);
+				return (SPEC | c | cmask);
 			d = get1key();
 			if (d == '~')	/* ESC [ n ~   P.K. */
-				return(SPEC | c | cmask);
+				return (SPEC | c | cmask);
 			switch (c) {	/* ESC [ n n ~ P.K. */
-			case '1':	c = d + 32;
+			case '1':
+				c = d + 32;
 				break;
-			case '2':	c = d + 48;
+			case '2':
+				c = d + 48;
 				break;
-			case '3':	c = d + 64;
+			case '3':
+				c = d + 64;
 				break;
-			default:	c = '?';
+			default:
+				c = '?';
 				break;
 			}
 			if (d != '~')	/* eat tilde P.K. */
@@ -363,11 +382,10 @@ proc_metac:
 			if (c == 'i') {	/* DO key    P.K. */
 				c = ctlxc;
 				goto proc_ctlxc;
-			}
+			} else if (c == 'c')	/* ESC key   P.K. */
-			else if (c == 'c')	/* ESC key   P.K. */
 				c = get1key();
 			else
-				return(SPEC | c | cmask);
+				return (SPEC | c | cmask);
 		}
 #endif
 #if VT220
@@ -378,13 +396,12 @@ proc_metac:
 #endif
 		if (islower(c))	/* Force to upper */
 			c ^= DIFCASE;
-	        if (c>=0x00 && c<=0x1F)		/* control key */
+		if (c >= 0x00 && c <= 0x1F)	/* control key */
-	        	c = CONTROL | (c+'@');
+			c = CONTROL | (c + '@');
-		return(META | c );
+		return (META | c);
 	}
 #if	PKCODE
-	else
+	else if (c == metac) {
-	if (c == metac) {
 		c = get1key();
 #if VT220
 		if (c == (CONTROL | '[')) {
@@ -394,15 +411,15 @@ proc_metac:
 #endif
 		if (islower(c))	/* Force to upper */
 			c ^= DIFCASE;
-	        if (c>=0x00 && c<=0x1F)		/* control key */
+		if (c >= 0x00 && c <= 0x1F)	/* control key */
-	        	c = CONTROL | (c+'@');
+			c = CONTROL | (c + '@');
-		return(META | c );
+		return (META | c);
 	}
 #endif
 
 
 #if	VT220
-proc_ctlxc:
+      proc_ctlxc:
 #endif
 	/* process CTLX prefix */
 	if (c == ctlxc) {
@@ -413,15 +430,15 @@ proc_ctlxc:
 			goto proc_metac;
 		}
 #endif
-	        if (c>='a' && c<='z')		/* Force to upper */
+		if (c >= 'a' && c <= 'z')	/* Force to upper */
 			c -= 0x20;
-	        if (c>=0x00 && c<=0x1F)		/* control key */
+		if (c >= 0x00 && c <= 0x1F)	/* control key */
-	        	c = CONTROL | (c+'@');
+			c = CONTROL | (c + '@');
-		return(CTLX | c);
+		return (CTLX | c);
 	}
 
 	/* otherwise, just return it */
-	return(c);
+	return (c);
 }
 
 /*	A more generalized prompt/reply function allowing the caller
@@ -430,7 +447,9 @@ proc_ctlxc:
 							*/
 getstring(prompt, buf, nbuf, eolchar)
 
-char *prompt; char *buf; int eolchar;
+char *prompt;
+char *buf;
+int eolchar;
 
 {
 	register int cpos;	/* current character position in string */
@@ -462,7 +481,7 @@ char *prompt; char *buf; int eolchar;
 
 	for (;;) {
 #if	COMPLC
-		if (! didtry)
+		if (!didtry)
 			nskip = -1;
 		didtry = 0;
 #endif
@@ -487,9 +506,9 @@ char *prompt; char *buf; int eolchar;
 
 			/* if we default the buffer, return FALSE */
 			if (buf[0] == 0)
-				return(FALSE);
+				return (FALSE);
 
-			return(TRUE);
+			return (TRUE);
 		}
 
 		/* change from command form back to character form */
@@ -499,8 +518,8 @@ char *prompt; char *buf; int eolchar;
 			/* Abort the input? */
 			ctrlg(FALSE, 0);
 			TTflush();
-			return(ABORT);
+			return (ABORT);
-		} else if ((c==0x7F || c==0x08) && quotef==FALSE) {
+		} else if ((c == 0x7F || c == 0x08) && quotef == FALSE) {
 			/* rubout/erase */
 			if (cpos != 0) {
 				outstring("\b \b");
@@ -536,7 +555,8 @@ char *prompt; char *buf; int eolchar;
 			TTflush();
 
 #if	COMPLC
-		} else if ((c == 0x09 || c == ' ') && quotef == FALSE && ffile) {
+		} else if ((c == 0x09 || c == ' ') && quotef == FALSE
+			   && ffile) {
 			/* TAB, complete file name */
 			char ffbuf[255];
 #if	MSDOS
@@ -564,13 +584,13 @@ char *prompt; char *buf; int eolchar;
 #if	MSDOS
 				if (lsav < 0 && (buf[cpos] == '\\' ||
 						 buf[cpos] == '/' ||
-						 buf[cpos] == ':'  && cpos == 1))
+						 buf[cpos] == ':'
+						 && cpos == 1))
 					lsav = cpos;
 #endif
 			}
 			TTflush();
-			if (nskip < 0)
+			if (nskip < 0) {
-			{
 				buf[ocpos] = 0;
 #if	UNIX
 				if (tmpf != NULL)
@@ -578,8 +598,8 @@ char *prompt; char *buf; int eolchar;
 				strcpy(tmp, "/tmp/meXXXXXX");
 				strcpy(ffbuf, "echo ");
 				strcat(ffbuf, buf);
-				if (! iswild)
+				if (!iswild)
-					strcat(ffbuf,"*");
+					strcat(ffbuf, "*");
 				strcat(ffbuf, " >");
 				mktemp(tmp);
 				strcat(ffbuf, tmp);
@@ -589,49 +609,47 @@ char *prompt; char *buf; int eolchar;
 #endif
 #if	MSDOS
 				strcpy(sffbuf, buf);
-				if (! iswild)
+				if (!iswild)
-					strcat(sffbuf,"*.*");
+					strcat(sffbuf, "*.*");
 #endif
 				nskip = 0;
 			}
 #if	UNIX
 			c = ' ';
 			for (n = nskip; n > 0; n--)
-				while ((c = getc(tmpf)) != EOF && c != ' ');
+				while ((c = getc(tmpf)) != EOF
+				       && c != ' ');
 #endif
 #if	MSDOS
-			if (nskip == 0)
+			if (nskip == 0) {
-			{
 				strcpy(ffbuf, sffbuf);
-				c = findfirst(ffbuf, &ffblk, FA_DIREC) ? '*' : ' ';
+				c = findfirst(ffbuf, &ffblk,
-			}
+					      FA_DIREC) ? '*' : ' ';
-			else if (nskip > 0)
+			} else if (nskip > 0)
 				c = findnext(&ffblk) ? 0 : ' ';
 #endif
 			nskip++;
 
-			if (c != ' ')
+			if (c != ' ') {
-			{
 				TTbeep();
 				nskip = 0;
 			}
-
 #if	UNIX
-			while ((c = getc(tmpf)) != EOF && c != '\n' && c != ' ' && c != '*')
+			while ((c = getc(tmpf)) != EOF && c != '\n'
+			       && c != ' ' && c != '*')
 #endif
 #if	MSDOS
 				if (c == '*')
 					fcp = sffbuf;
-			else
+				else {
-			{
+					strncpy(buf, sffbuf, lsav + 1);
-				strncpy(buf, sffbuf, lsav+1);
+					cpos = lsav + 1;
-				cpos = lsav+1;
 					fcp = ffblk.ff_name;
 				}
 			while (c != 0 && (c = *fcp++) != 0 && c != '*')
 #endif
 			{
-				if (cpos < nbuf-1)
+				if (cpos < nbuf - 1)
 					buf[cpos++] = c;
 			}
 #if	UNIX
@@ -639,8 +657,7 @@ char *prompt; char *buf; int eolchar;
 				TTbeep();
 #endif
 
-			for (n = 0; n < cpos; n++)
+			for (n = 0; n < cpos; n++) {
-			{
 				c = buf[n];
 				if ((c < ' ') && (c != '\n')) {
 					outstring("^");
@@ -668,7 +685,7 @@ char *prompt; char *buf; int eolchar;
 			quotef = TRUE;
 		} else {
 			quotef = FALSE;
-			if (cpos < nbuf-1) {
+			if (cpos < nbuf - 1) {
 				buf[cpos++] = c;
 
 				if ((c < ' ') && (c != '\n')) {
@@ -691,8 +708,8 @@ char *prompt; char *buf; int eolchar;
 	}
 }
 
-outstring(s)	/* output a string of characters */
+outstring(s)
-
+    /* output a string of characters */
 char *s;			/* string to output */
 
 {
@@ -701,8 +718,8 @@ char *s;	/* string to output */
 			TTputc(*s++);
 }
 
-ostring(s)	/* output a string of output characters */
+ostring(s)
-
+    /* output a string of output characters */
 char *s;			/* string to output */
 
 {
@@ -710,4 +727,3 @@ char *s;	/* string to output */
 		while (*s)
 			TTputc(*s++);
 }
-

isearch.c

@@ -33,7 +33,7 @@ extern int eq();			/* Compare chars, match case */
 
 /* A couple of "own" variables for re-eat */
 
-int	(*saved_get_char)();		/* Get character routine */
+int (*saved_get_char) ();	/* Get character routine */
 int eaten_char = -1;		/* Re-eaten char */
 
 /* A couple more "own" variables for the command string */
@@ -62,17 +62,17 @@ int risearch(f, n)
 
 	backchar(TRUE, 1);	/* Back up a character                */
 
-    if (!(isearch(f, -n)))		/* Call ISearch backwards	      */
+	if (!(isearch(f, -n))) {	/* Call ISearch backwards       *//* If error in search:                */
-    {					/* If error in search:		      */
 		curwp->w_dotp = curline;	/* Reset the line pointer             */
 		curwp->w_doto = curoff;	/*  and the offset to original value  */
 		curwp->w_flag |= WFMOVE;	/* Say we've moved                    */
 		update(FALSE);	/* And force an update                */
-	mlwrite ("(search failed)");	/* Say we died			      */
+		mlwrite("(search failed)");	/* Say we died                        */
 #if	PKCODE
 		matchlen = strlen(pat);
 #endif
-    } else mlerase ();			/* If happy, just erase the cmd line  */
+	} else
+		mlerase();	/* If happy, just erase the cmd line  */
 #if	PKCODE
 	matchlen = strlen(pat);
 #endif
@@ -92,17 +92,17 @@ int fisearch(f, n)
 
 	/* do the search */
 
-    if (!(isearch(f, n)))		/* Call ISearch forwards	      */
+	if (!(isearch(f, n))) {	/* Call ISearch forwards        *//* If error in search:                */
-    {					/* If error in search:		      */
 		curwp->w_dotp = curline;	/* Reset the line pointer             */
 		curwp->w_doto = curoff;	/*  and the offset to original value  */
 		curwp->w_flag |= WFMOVE;	/* Say we've moved                    */
 		update(FALSE);	/* And force an update                */
-	mlwrite ("(search failed)");	/* Say we died			      */
+		mlwrite("(search failed)");	/* Say we died                        */
 #if	PKCODE
 		matchlen = strlen(pat);
 #endif
-   } else mlerase ();			/* If happy, just erase the cmd line  */
+	} else
+		mlerase();	/* If happy, just erase the cmd line  */
 #if	PKCODE
 	matchlen = strlen(pat);
 #endif
@@ -151,14 +151,14 @@ isearch(f, n)
 	cmd_reexecute = -1;	/* We're not re-executing (yet?)      */
 	cmd_offset = 0;		/* Start at the beginning of the buff */
 	cmd_buff[0] = '\0';	/* Init the command buffer            */
-    strncpy (pat_save, pat, NPAT);	/* Save the old pattern string	      */
+	strncpy(pat_save, pat, NPAT);	/* Save the old pattern string        */
 	curline = curwp->w_dotp;	/* Save the current line pointer      */
 	curoff = curwp->w_doto;	/* Save the current offset            */
 	init_direction = n;	/* Save the initial search direction  */
 
 	/* This is a good place to start a re-execution: */
 
-start_over:
+      start_over:
 
 	/* ask the user for the text of a pattern */
 	col = promptpattern("ISearch: ");	/* Prompt, remember the col   */
@@ -172,15 +172,12 @@ start_over:
 	 */
 
 	c = ectoc(expc = get_char());	/* Get the first character    */
-    if ((c == IS_FORWARD) ||
+	if ((c == IS_FORWARD) || (c == IS_REVERSE) || (c == IS_VMSFORW)) {	/* Reuse old search string?   */
-        (c == IS_REVERSE) ||
-        (c == IS_VMSFORW))			/* Reuse old search string?   */
-    {
 		for (cpos = 0; pat[cpos] != 0; cpos++)	/* Yup, find the length           */
-    	    col = echochar(pat[cpos],col);	/*  and re-echo the string    */
+			col = echochar(pat[cpos], col);	/*  and re-echo the string    */
 		if (c == IS_REVERSE) {	/* forward search?            */
 			n = -1;	/* No, search in reverse      */
-	    backchar (TRUE, 1);			/* Be defensive about EOB     */
+			backchar(TRUE, 1);	/* Be defensive about EOB     */
 		} else
 			n = 1;	/* Yes, search forward        */
 		status = scanmore(pat, n);	/* Do the search              */
@@ -189,18 +186,16 @@ start_over:
 
 	/* Top of the per character loop */
 
-    for (;;)					/* ISearch per character loop */
+	for (;;) {		/* ISearch per character loop */
-    {
 		/* Check for special characters first: */
 		/* Most cases here change the search */
 
 		if (expc == metac)	/* Want to quit searching?    */
 			return (TRUE);	/* Quit searching now         */
 
-	switch (c)				/* dispatch on the input char */
+		switch (c) {	/* dispatch on the input char */
-	{
 		case IS_ABORT:	/* If abort search request    */
-	    return(FALSE);			/* Quit searching again	      */
+			return (FALSE);	/* Quit searching again       */
 
 		case IS_REVERSE:	/* If backward search         */
 		case IS_FORWARD:	/* If forward search          */
@@ -211,7 +206,7 @@ start_over:
 				n = 1;	/*  go forward                */
 			status = scanmore(pat, n);	/* Start the search again     */
 			c = ectoc(expc = get_char());	/* Get the next char          */
-	    continue;				/* Go continue with the search*/
+			continue;	/* Go continue with the search */
 
 		case IS_NEWLINE:	/* Carriage return            */
 			c = '\n';	/* Make it a new line         */
@@ -234,16 +229,15 @@ start_over:
 			curwp->w_dotp = curline;	/* Reset the line pointer     */
 			curwp->w_doto = curoff;	/*  and the offset            */
 			n = init_direction;	/* Reset the search direction */
-	    strncpy (pat, pat_save, NPAT);	/* Restore the old search str */
+			strncpy(pat, pat_save, NPAT);	/* Restore the old search str */
 			cmd_reexecute = 0;	/* Start the whole mess over  */
 			goto start_over;	/* Let it take care of itself */
 
 			/* Presumably a quasi-normal character comes here */
 
 		default:	/* All other chars            */
-	    if (c < ' ')			/* Is it printable?	      */
+			if (c < ' ') {	/* Is it printable?             *//* Nope.                      */
-	    {					/* Nope.		      */
+				reeat(c);	/* Re-eat the char            */
-		reeat (c);			/* Re-eat the char	      */
 				return (TRUE);	/* And return the last status */
 			}
 		}		/* Switch */
@@ -251,18 +245,16 @@ start_over:
 		/* I guess we got something to search for, so search for it           */
 
 		pat[cpos++] = c;	/* put the char in the buffer */
-	if (cpos >= NPAT)			/* too many chars in string?  */
+		if (cpos >= NPAT) {	/* too many chars in string?  *//* Yup.  Complain about it    */
-	{					/* Yup.  Complain about it    */
 			mlwrite("? Search string too long");
-	    return(TRUE);			/* Return an error	      */
+			return (TRUE);	/* Return an error            */
 		}
 		pat[cpos] = 0;	/* null terminate the buffer  */
-	col = echochar(c,col);			/* Echo the character	      */
+		col = echochar(c, col);	/* Echo the character         */
 		if (!status) {	/* If we lost last time       */
 			TTputc(BELL);	/* Feep again                 */
 			TTflush();	/* see that the feep feeps    */
-	} else					/* Otherwise, we must have won*/
+		} else /* Otherwise, we must have won */ if (!(status = checknext(c, pat, n)))	/* See if match         */
-	    if (!(status = checknext(c, pat, n))) /* See if match	      */
 			status = scanmore(pat, n);	/*  or find the next match    */
 		c = ectoc(expc = get_char());	/* Get the next char          */
 	}			/* for {;;} */
@@ -279,7 +271,7 @@ start_over:
  * scanmore or something.
  */
 
-int checknext (chr, patrn, dir)	/* Check next character in search string */
+int checknext(chr, patrn, dir)	/* Check next character in search string */
 char chr;			/* Next char to look for                 */
 char *patrn;			/* The entire search string (incl chr)   */
 int dir;			/* Search direction                      */
@@ -295,10 +287,8 @@ int	dir;			/* Search direction			 */
 	curline = curwp->w_dotp;	/* Get the current line structure     */
 	curoff = curwp->w_doto;	/* Get the offset within that line    */
 
-    if (dir > 0)			/* If searching forward		      */
+	if (dir > 0) {		/* If searching forward                 */
-    {
+		if (curoff == llength(curline)) {	/* If at end of line                    */
-    	if (curoff == llength(curline)) /* If at end of line		      */
-    	{
 			curline = lforw(curline);	/* Skip to the next line              */
 			if (curline == curbp->b_linep)
 				return (FALSE);	/* Abort if at end of buffer          */
@@ -306,15 +296,14 @@ int	dir;			/* Search direction			 */
 			buffchar = '\n';	/* And say the next char is NL        */
 		} else
 			buffchar = lgetc(curline, curoff++);	/* Get the next char         */
-	if (status = eq(buffchar, chr))	/* Is it what we're looking for?      */
+		if (status = eq(buffchar, chr)) {	/* Is it what we're looking for?      */
-	{
 			curwp->w_dotp = curline;	/* Yes, set the buffer's point        */
 			curwp->w_doto = curoff;	/*  to the matched character          */
 			curwp->w_flag |= WFMOVE;	/* Say that we've moved               */
 		}
 		return (status);	/* And return the status              */
 	} else			/* Else, if reverse search:       */
-	return (match_pat (patrn));	/* See if we're in the right place    */
+		return (match_pat(patrn));	/* See if we're in the right place    */
 }
 
 /*
@@ -333,21 +322,18 @@ int	dir;			/* direction to search			      */
 {
 	int sts;		/* search status                      */
 
-    	if (dir < 0)				/* reverse search?	      */
+	if (dir < 0) {		/* reverse search?              */
-    	{
 		rvstrcpy(tap, patrn);	/* Put reversed string in tap */
 		sts = scanner(tap, REVERSE, PTBEG);
-	}
+	} else
-	else
 		sts = scanner(patrn, FORWARD, PTEND);	/* Nope. Go forward   */
 
-	if (!sts)
+	if (!sts) {
-	{
 		TTputc(BELL);	/* Feep if search fails       */
 		TTflush();	/* see that the feep feeps    */
 	}
 
-	return(sts);				/* else, don't even try	      */
+	return (sts);		/* else, don't even try       */
 }
 
 /*
@@ -360,7 +346,7 @@ int	dir;			/* direction to search			      */
  * be done is match the last char input.
  */
 
-int match_pat (patrn)	/* See if the pattern string matches string at "."   */
+int match_pat(patrn)		/* See if the pattern string matches string at "."   */
 char *patrn;			/* String to match to buffer                         */
 {
 	register int i;		/* Generic loop index/offset          */
@@ -375,10 +361,8 @@ char	*patrn;		/* String to match to buffer			     */
 
 	/* top of per character compare loop: */
 
-    for (i = 0; i < strlen(patrn); i++)	/* Loop for all characters in patrn   */
+	for (i = 0; i < strlen(patrn); i++) {	/* Loop for all characters in patrn   */
-    {
+		if (curoff == llength(curline)) {	/* If at end of line                    */
-    	if (curoff == llength(curline)) /* If at end of line		      */
-    	{
 			curline = lforw(curline);	/* Skip to the next line              */
 			curoff = 0;	/* Start at the beginning of the line */
 			if (curline == curbp->b_linep)
@@ -389,7 +373,7 @@ char	*patrn;		/* String to match to buffer			     */
 		if (!eq(buffchar, patrn[i]))	/* Is it what we're looking for?      */
 			return (FALSE);	/* Nope, just punt it then            */
 	}
-    return (TRUE);			/* Everything matched? Let's celebrate*/
+	return (TRUE);		/* Everything matched? Let's celebrate */
 }
 
 /* Routine to prompt for I-Search string. */
@@ -397,31 +381,29 @@ char	*patrn;		/* String to match to buffer			     */
 int promptpattern(prompt)
 char *prompt;
 {
-    char tpat[NPAT+20];
+	char tpat[NPAT + 20];
 
 	strcpy(tpat, prompt);	/* copy prompt to output string */
 	strcat(tpat, " (");	/* build new prompt string */
-    expandp(pat, &tpat[strlen(tpat)], NPAT/2);	/* add old pattern */
+	expandp(pat, &tpat[strlen(tpat)], NPAT / 2);	/* add old pattern */
 	strcat(tpat, ")<Meta>: ");
 
 	/* check to see if we are executing a command line */
 	if (!clexec) {
 		mlwrite(tpat);
 	}
-    return(strlen(tpat));
+	return (strlen(tpat));
 }
 
 /* routine to echo i-search characters */
 
-int echochar(c,col)
+int echochar(c, col)
 int c;				/* character to be echoed */
 int col;			/* column to be echoed in */
 {
-    movecursor(term.t_nrow,col);		/* Position the cursor	      */
+	movecursor(term.t_nrow, col);	/* Position the cursor        */
-    if ((c < ' ') || (c == 0x7F))		/* Control character?	      */
+	if ((c < ' ') || (c == 0x7F)) {	/* Control character?           */
-    {
+		switch (c) {	/* Yes, dispatch special cases */
-	switch (c)				/* Yes, dispatch special cases*/
-	{
 		case '\n':	/* Newline                    */
 			TTputc('<');
 			TTputc('N');
@@ -447,13 +429,13 @@ int	col;	/* column to be echoed in */
 
 		default:	/* Vanilla control char       */
 			TTputc('^');	/* Yes, output prefix         */
-    	    TTputc(c+0x40);		/* Make it "^X"		      */
+			TTputc(c + 0x40);	/* Make it "^X"               */
 			col++;	/* Count this char            */
 		}
 	} else
 		TTputc(c);	/* Otherwise, output raw char */
 	TTflush();		/* Flush the output           */
-    return(++col);				/* return the new column no   */
+	return (++col);		/* return the new column no   */
 }
 
 /*
@@ -463,7 +445,7 @@ int	col;	/* column to be echoed in */
  * next character.
  */
 
-int get_char ()
+int get_char()
 {
 	int c;			/* A place to get a character         */
 
@@ -477,14 +459,13 @@ int get_char ()
 
 	cmd_reexecute = -1;	/* Say we're in real mode again       */
 	update(FALSE);		/* Pretty up the screen               */
-    if (cmd_offset >= CMDBUFLEN-1)	/* If we're getting too big ...	      */
+	if (cmd_offset >= CMDBUFLEN - 1) {	/* If we're getting too big ...         */
-    {
+		mlwrite("? command too long");	/* Complain loudly and bitterly       */
-	mlwrite ("? command too long");	/* Complain loudly and bitterly	      */
 		return (metac);	/* And force a quit                   */
 	}
 	c = get1key();		/* Get the next character             */
 	cmd_buff[cmd_offset++] = c;	/* Save the char for next time        */
-    cmd_buff[cmd_offset] = '\0';/* And terminate the buffer	      */
+	cmd_buff[cmd_offset] = '\0';	/* And terminate the buffer           */
 	return (c);		/* Return the character               */
 }
 
@@ -502,14 +483,14 @@ int uneat()
 	term.t_getchar = saved_get_char;	/* restore the routine address        */
 	c = eaten_char;		/* Get the re-eaten char              */
 	eaten_char = -1;	/* Clear the old char                 */
-    return(c);				/* and return the last char	      */
+	return (c);		/* and return the last char           */
 }
 
 int reeat(c)
 int c;
 {
 	if (eaten_char != -1)	/* If we've already been here             */
-	return/*(NULL)*/;		/* Don't do it again		      */
+		return /*(NULL) */ ;	/* Don't do it again                  */
 	eaten_char = c;		/* Else, save the char for later      */
 	saved_get_char = term.t_getchar;	/* Save the char get routine          */
 	term.t_getchar = uneat;	/* Replace it with ours               */

line.c

@@ -35,10 +35,10 @@ register int	used;
 	register int size;
 	char *malloc();
 
-	size = (used+NBLOCK-1) & ~(NBLOCK-1);
+	size = (used + NBLOCK - 1) & ~(NBLOCK - 1);
 	if (size == 0)		/* Assume that an empty */
 		size = NBLOCK;	/* line is for type-in. */
-	if ((lp = (LINE *) malloc(sizeof(LINE)+size)) == NULL) {
+	if ((lp = (LINE *) malloc(sizeof(LINE) + size)) == NULL) {
 		mlwrite("(OUT OF MEMORY)");
 		return (NULL);
 	}
@@ -106,7 +106,7 @@ register int	flag;
 
 	if (curbp->b_nwnd != 1)	/* Ensure hard.     */
 		flag = WFHARD;
-	if ((curbp->b_flag&BFCHG) == 0) {	/* First change, so	*/
+	if ((curbp->b_flag & BFCHG) == 0) {	/* First change, so     */
 		flag |= WFMODE;	/* update mode lines.   */
 		curbp->b_flag |= BFCHG;
 	}
@@ -118,8 +118,8 @@ register int	flag;
 	}
 }
 
-insspace(f, n)	/* insert spaces forward into text */
+insspace(f, n)
-
+    /* insert spaces forward into text */
 int f, n;			/* default flag and numeric argument */
 
 {
@@ -139,7 +139,8 @@ char	*instr;
 
 	if (instr != NULL)
 		while ((tmpc = *instr) && status == TRUE) {
-			status = (tmpc == '\n'? lnewline(): linsert(1, tmpc));
+			status =
+			    (tmpc == '\n' ? lnewline() : linsert(1, tmpc));
 
 			/* Insertion error? */
 			if (status != TRUE) {
@@ -148,7 +149,7 @@ char	*instr;
 			}
 			instr++;
 		}
-	return(status);
+	return (status);
 }
 
 /*
@@ -172,8 +173,8 @@ linsert(n, c)
 	register int i;
 	register WINDOW *wp;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	lchange(WFEDIT);
 	lp1 = curwp->w_dotp;	/* Current line         */
 	if (lp1 == curbp->b_linep) {	/* At the end: special  */
@@ -181,22 +182,22 @@ linsert(n, c)
 			mlwrite("bug: linsert");
 			return (FALSE);
 		}
-		if ((lp2=lalloc(n)) == NULL)	/* Allocate new line	*/
+		if ((lp2 = lalloc(n)) == NULL)	/* Allocate new line        */
 			return (FALSE);
 		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; i<n; ++i)
+		for (i = 0; i < n; ++i)
 			lp2->l_text[i] = c;
 		curwp->w_dotp = lp2;
 		curwp->w_doto = n;
 		return (TRUE);
 	}
 	doto = curwp->w_doto;	/* Save for later.      */
-	if (lp1->l_used+n > lp1->l_size) {	/* Hard: reallocate	*/
+	if (lp1->l_used + n > lp1->l_size) {	/* Hard: reallocate     */
-		if ((lp2=lalloc(lp1->l_used+n)) == NULL)
+		if ((lp2 = lalloc(lp1->l_used + n)) == NULL)
 			return (FALSE);
 		cp1 = &lp1->l_text[0];
 		cp2 = &lp2->l_text[0];
@@ -214,19 +215,19 @@ linsert(n, c)
 		lp2 = lp1;	/* Pretend new line     */
 		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; i<n; ++i)			/* Add the characters	*/
+	for (i = 0; i < n; ++i)	/* Add the characters       */
-		lp2->l_text[doto+i] = c;
+		lp2->l_text[doto + i] = c;
 	wp = wheadp;		/* Update windows       */
 	while (wp != NULL) {
 		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)
+			if (wp == curwp || wp->w_doto > doto)
 				wp->w_doto += n;
 		}
 		if (wp->w_markp == lp1) {
@@ -253,7 +254,7 @@ char c;		/* character to overwrite on current position */
 	    (lgetc(curwp->w_dotp, curwp->w_doto) != '\t' ||
 	     ((curwp->w_doto) & tabmask) == tabmask))
 		ldelete(1L, FALSE);
-	return(linsert(1, c));
+	return (linsert(1, c));
 }
 
 /*
@@ -270,16 +271,18 @@ char	*ostr;
 
 	if (ostr != NULL)
 		while ((tmpc = *ostr) && status == TRUE) {
-			status = (tmpc == '\n'? lnewline(): lowrite(tmpc));
+			status =
+			    (tmpc == '\n' ? lnewline() : lowrite(tmpc));
 
 			/* Insertion error? */
 			if (status != TRUE) {
-				mlwrite("%%Out of memory while overwriting");
+				mlwrite
+				    ("%%Out of memory while overwriting");
 				break;
 			}
 			ostr++;
 		}
-	return(status);
+	return (status);
 }
 
 /*
@@ -299,16 +302,16 @@ lnewline()
 	register int doto;
 	register WINDOW *wp;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 #if SCROLLCODE
-	lchange(WFHARD|WFINS);
+	lchange(WFHARD | WFINS);
 #else
 	lchange(WFHARD);
 #endif
 	lp1 = curwp->w_dotp;	/* Get the address and  */
 	doto = curwp->w_doto;	/* offset of "."        */
-	if ((lp2=lalloc(doto)) == NULL) 	/* New first half line	*/
+	if ((lp2 = lalloc(doto)) == NULL)	/* New first half line      */
 		return (FALSE);
 	cp1 = &lp1->l_text[0];	/* Shuffle text around  */
 	cp2 = &lp2->l_text[0];
@@ -362,24 +365,24 @@ int kflag;	/* put killed text in kill buffer flag */
 	register int chunk;
 	register WINDOW *wp;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	while (n != 0) {
 		dotp = curwp->w_dotp;
 		doto = curwp->w_doto;
 		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 SCROLLCODE
-			lchange(WFHARD|WFKILLS);
+			lchange(WFHARD | WFKILLS);
 #else
 			lchange(WFHARD);
 #endif
 			if (ldelnewline() == FALSE
-			|| (kflag!=FALSE && kinsert('\n')==FALSE))
+			    || (kflag != FALSE && kinsert('\n') == FALSE))
 				return (FALSE);
 			--n;
 			continue;
@@ -400,12 +403,12 @@ int kflag;	/* put killed text in kill buffer flag */
 		dotp->l_used -= chunk;
 		wp = wheadp;	/* Fix windows          */
 		while (wp != NULL) {
-			if (wp->w_dotp==dotp && wp->w_doto>=doto) {
+			if (wp->w_dotp == dotp && wp->w_doto >= doto) {
 				wp->w_doto -= chunk;
 				if (wp->w_doto < doto)
 					wp->w_doto = doto;
 			}
-			if (wp->w_markp==dotp && wp->w_marko>=doto) {
+			if (wp->w_markp == dotp && wp->w_marko >= doto) {
 				wp->w_marko -= chunk;
 				if (wp->w_marko < doto)
 					wp->w_marko = doto;
@@ -422,7 +425,6 @@ int kflag;	/* put killed text in kill buffer flag */
 */
 
 char *getctext()
-
 {
 	register LINE *lp;	/* line to copy */
 	register int size;	/* length of line to return */
@@ -442,7 +444,7 @@ char *getctext()
 	while (size--)
 		*dp++ = *sp++;
 	*dp = 0;
-	return(rline);
+	return (rline);
 }
 
 /* putctext:	replace the current line with the passed in text	*/
@@ -457,14 +459,14 @@ char *iline;	/* contents of new line */
 	/* delete the current line */
 	curwp->w_doto = 0;	/* starting at the beginning of the line */
 	if ((status = killtext(TRUE, 1)) != TRUE)
-		return(status);
+		return (status);
 
 	/* insert the new line */
 	if ((status = linstr(iline)) != TRUE)
-		return(status);
+		return (status);
 	status = lnewline();
 	backline(TRUE, 1);
-	return(status);
+	return (status);
 }
 
 /*
@@ -485,8 +487,8 @@ ldelnewline()
 	register LINE *lp3;
 	register WINDOW *wp;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	lp1 = curwp->w_dotp;
 	lp2 = lp1->l_fp;
 	if (lp2 == curbp->b_linep) {	/* At the buffer end.   */
@@ -494,7 +496,7 @@ ldelnewline()
 			lfree(lp1);
 		return (TRUE);
 	}
-	if (lp2->l_used <= lp1->l_size-lp1->l_used) {
+	if (lp2->l_used <= lp1->l_size - lp1->l_used) {
 		cp1 = &lp1->l_text[lp1->l_used];
 		cp2 = &lp2->l_text[0];
 		while (cp2 != &lp2->l_text[lp2->l_used])
@@ -519,7 +521,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);
 	cp1 = &lp1->l_text[0];
 	cp2 = &lp3->l_text[0];
@@ -534,7 +536,7 @@ ldelnewline()
 	lp3->l_bp = lp1->l_bp;
 	wp = wheadp;
 	while (wp != NULL) {
-		if (wp->w_linep==lp1 || wp->w_linep==lp2)
+		if (wp->w_linep == lp1 || wp->w_linep == lp2)
 			wp->w_linep = lp3;
 		if (wp->w_dotp == lp1)
 			wp->w_dotp = lp3;
@@ -594,8 +596,8 @@ int c;		/* character to insert in the kill buffer */
 
 	/* check to see if we need a new chunk */
 	if (kused >= KBLOCK) {
-		if ((nchunk = (KILL *)malloc(sizeof(KILL))) == NULL)
+		if ((nchunk = (KILL *) malloc(sizeof(KILL))) == NULL)
-			return(FALSE);
+			return (FALSE);
 		if (kbufh == NULL)	/* set head ptr if first time */
 			kbufh = nchunk;
 		if (kbufp != NULL)	/* point the current to this new one */
@@ -607,7 +609,7 @@ int c;		/* character to insert in the kill buffer */
 
 	/* and now insert the character */
 	kbufp->d_chunk[kused++] = c;
-	return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -622,13 +624,13 @@ yank(f, n)
 	register char *sp;	/* pointer into string to insert */
 	KILL *kp;		/* pointer into kill buffer */
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (FALSE);
 	/* make sure there is something to yank */
 	if (kbufh == NULL)
-		return(TRUE);		/* not an error, just nothing */
+		return (TRUE);	/* not an error, just nothing */
 
 	/* for each time.... */
 	while (n--) {

lock.c

@@ -32,41 +32,40 @@ char *fname;	/* file to check for a lock */
 
 	/* check to see if that file is already locked here */
 	if (numlocks > 0)
-		for (i=0; i < numlocks; ++i)
+		for (i = 0; i < numlocks; ++i)
 			if (strcmp(fname, lname[i]) == 0)
-				return(TRUE);
+				return (TRUE);
 
 	/* if we have a full locking table, bitch and leave */
 	if (numlocks == NLOCKS) {
 		mlwrite("LOCK ERROR: Lock table full");
-		return(ABORT);
+		return (ABORT);
 	}
 
 	/* next, try to lock it */
 	status = lock(fname);
 	if (status == ABORT)	/* file is locked, no override */
-		return(ABORT);
+		return (ABORT);
 	if (status == FALSE)	/* locked, overriden, dont add to table */
-		return(TRUE);
+		return (TRUE);
 
 	/* we have now locked it, add it to our table */
-	lname[++numlocks - 1] = (char *)malloc(strlen(fname) + 1);
+	lname[++numlocks - 1] = (char *) malloc(strlen(fname) + 1);
 	if (lname[numlocks - 1] == NULL) {	/* malloc failure */
 		undolock(fname);	/* free the lock */
 		mlwrite("Cannot lock, out of memory");
 		--numlocks;
-		return(ABORT);
+		return (ABORT);
 	}
 
 	/* everthing is cool, add it to the table */
-	strcpy(lname[numlocks-1], fname);
+	strcpy(lname[numlocks - 1], fname);
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	lockrel:	release all the file locks so others may edit */
 
 lockrel()
-
 {
 	register int i;		/* loop index */
 	register int status;	/* status of locks */
@@ -74,13 +73,13 @@ lockrel()
 
 	status = TRUE;
 	if (numlocks > 0)
-		for (i=0; i < numlocks; ++i) {
+		for (i = 0; i < numlocks; ++i) {
 			if ((s = unlock(lname[i])) != TRUE)
 				status = s;
 			free(lname[i]);
 		}
 	numlocks = 0;
-	return(status);
+	return (status);
 }
 
 /* lock:	Check and lock a file from access by others
@@ -102,12 +101,12 @@ char *fname;	/* file name to lock */
 	/* attempt to lock the file */
 	locker = dolock(fname);
 	if (locker == NULL)	/* we win */
-		return(TRUE);
+		return (TRUE);
 
 	/* file failed...abort */
 	if (strncmp(locker, "LOCK", 4) == 0) {
 		lckerror(locker);
-		return(ABORT);
+		return (ABORT);
 	}
 
 	/* someone else has it....override? */
@@ -116,9 +115,9 @@ char *fname;	/* file name to lock */
 	strcat(msg, ", override?");
 	status = mlyesno(msg);	/* ask them */
 	if (status == TRUE)
-		return(FALSE);
+		return (FALSE);
 	else
-		return(ABORT);
+		return (ABORT);
 }
 
 /*	unlock:	Unlock a file
@@ -136,15 +135,15 @@ char *fname;	/* file to unlock */
 	/* unclock and return */
 	locker = undolock(fname);
 	if (locker == NULL)
-		return(TRUE);
+		return (TRUE);
 
 	/* report the error and come back */
 	lckerror(locker);
-	return(FALSE);
+	return (FALSE);
 }
 
-lckerror(errstr)	/* report a lock error */
+lckerror(errstr)
-
+    /* report a lock error */
 char *errstr;			/* lock error string to print out */
 
 {
@@ -160,7 +159,7 @@ char *errstr;		/* lock error string to print out */
 }
 #endif
 #else
-lckhello()	/* dummy function */
+lckhello()
-{
+{				/* dummy function */
 }
 #endif

main.c

@@ -84,7 +84,7 @@ extern unsigned _stklen = 32766;
 #include <signal.h>
 static void emergencyexit();
 #ifdef SIGWINCH
-        extern void sizesignal();
+extern void sizesignal();
 #endif
 #endif
 
@@ -122,8 +122,8 @@ char *argv[];	/* argument strings */
 	extern *pathname[];	/* startup file path/name array */
 	int newc;
 #if	PKCODE
-	int (*getbind())();
+	int (*getbind()) ();
-	int (*execfunc)();		/* ptr to function to execute */
+	int (*execfunc) ();	/* ptr to function to execute */
 #endif
 
 #if	PKCODE & VMS
@@ -204,7 +204,7 @@ char *argv[];	/* argument strings */
 			case 's':	/* -s for initial search string */
 			case 'S':
 				searchflag = TRUE;
-					strncpy(pat,&argv[carg][2],NPAT);
+				strncpy(pat, &argv[carg][2], NPAT);
 				break;
 			case 'v':	/* -v for View File */
 			case 'V':
@@ -215,7 +215,7 @@ char *argv[];	/* argument strings */
 				break;
 			}
 
-		} else if (argv[carg][0]== '@') {
+		} else if (argv[carg][0] == '@') {
 
 			/* Process Startup macroes */
 			if (startup(&argv[carg][1]) == TRUE)
@@ -245,7 +245,7 @@ char *argv[];	/* argument strings */
 #if	CRYPT
 			if (cryptflag) {
 				bp->b_mode |= MDCRYPT;
-				crypt((char *)NULL, 0);
+				crypt((char *) NULL, 0);
 				crypt(ekey, strlen(ekey));
 				strncpy(bp->b_key, ekey, NPAT);
 			}
@@ -284,9 +284,8 @@ char *argv[];	/* argument strings */
 	if (gotoflag && searchflag) {
 		update(FALSE);
 		mlwrite("(Can not search and goto at the same time!)");
-	}
+	} else if (gotoflag) {
-        else if (gotoflag) {
+		if (gotoline(TRUE, gline) == FALSE) {
-                if (gotoline(TRUE,gline) == FALSE) {
 			update(FALSE);
 			mlwrite("(Bogus goto argument)");
 		}
@@ -298,37 +297,32 @@ char *argv[];	/* argument strings */
 	/* setup to process commands */
 	lastflag = 0;		/* Fake last flags.     */
 
-loop:
+      loop:
 
 #if	CALLED
 	/* if we were called as a subroutine and want to leave, do so */
 	if (eexitflag)
-		return(eexitval);
+		return (eexitval);
 #endif
 
 	/* execute the "command" macro...normally null */
 	saveflag = lastflag;	/* preserve lastflag through this */
-	execute(META|SPEC|'C', FALSE, 1);
+	execute(META | SPEC | 'C', FALSE, 1);
 	lastflag = saveflag;
 
 #if 	TYPEAH && PKCODE
-	if (typahead())
+	if (typahead()) {
-	{
 		newc = getcmd();
 		update(FALSE);
-		do
+		do {
-		{
 			if (c == newc && (execfunc = getbind(c)) != NULL
-				      &&  execfunc != newline 
+			    && execfunc != newline && execfunc != tab)
-				      &&  execfunc != tab)
 				newc = getcmd();
 			else
 				break;
 		} while (typahead());
 		c = newc;
-	}
+	} else {
-	else
-	{
 		update(FALSE);
 		c = getcmd();
 	}
@@ -371,7 +365,7 @@ loop:
 			if ((n == 0) && (mflag == -1))	/* lonely - */
 				mlwrite("Arg:");
 			else
-				mlwrite("Arg: %d",n * mflag);
+				mlwrite("Arg: %d", n * mflag);
 
 			c = getcmd();	/* get the next key */
 		}
@@ -385,10 +379,11 @@ loop:
 		n = 4;		/* with argument of 4 */
 		mflag = 0;	/* that can be discarded. */
 		mlwrite("Arg: 4");
-                while ((c=getcmd()) >='0' && c<='9' || c==reptc || c=='-'){
+		while ((c = getcmd()) >= '0' && c <= '9' || c == reptc
+		       || c == '-') {
 			if (c == reptc)
-				if ((n > 0) == ((n*4) > 0))
+				if ((n > 0) == ((n * 4) > 0))
-	                                n = n*4;
+					n = n * 4;
 				else
 					n = 1;
 			/*
@@ -410,9 +405,10 @@ loop:
 					n = 0;
 					mflag = 1;
 				}
-                                n = 10*n + c - '0';
+				n = 10 * n + c - '0';
 			}
-                        mlwrite("Arg: %d", (mflag >=0) ? n : (n ? -n : -1));
+			mlwrite("Arg: %d",
+				(mflag >= 0) ? n : (n ? -n : -1));
 		}
 		/*
 		 * Make arguments preceded by a minus sign negative and change
@@ -445,7 +441,7 @@ char    bname[];
 	bp = bfind(bname, TRUE, 0);	/* First buffer         */
 	blistp = bfind("*List*", TRUE, BFINVS);	/* Buffer list buffer   */
 	wp = (WINDOW *) malloc(sizeof(WINDOW));	/* First window         */
-        if (bp==NULL || wp==NULL || blistp==NULL)
+	if (bp == NULL || wp == NULL || blistp == NULL)
 		exit(1);
 	curbp = bp;		/* Make this current    */
 	wheadp = wp;
@@ -464,9 +460,9 @@ char    bname[];
 	wp->w_fcolor = gfcolor;
 	wp->w_bcolor = gbcolor;
 #endif
-        wp->w_ntrows = term.t_nrow-1;           /* "-1" for mode line.  */
+	wp->w_ntrows = term.t_nrow - 1;	/* "-1" for mode line.  */
 	wp->w_force = 0;
-        wp->w_flag  = WFMODE|WFHARD;            /* Full.                */
+	wp->w_flag = WFMODE | WFHARD;	/* Full.                */
 }
 
 /*
@@ -478,14 +474,14 @@ char    bname[];
 execute(c, f, n)
 {
 	register int status;
-	int (*execfunc)();		/* ptr to function to execute */
+	int (*execfunc) ();	/* ptr to function to execute */
-	int (*getbind())();
+	int (*getbind()) ();
 
 	/* if the keystroke is a bound function...do it */
 	execfunc = getbind(c);
 	if (execfunc != NULL) {
 		thisflag = 0;
-		status	 = (*execfunc)(f, n);
+		status = (*execfunc) (f, n);
 		lastflag = thisflag;
 		return (status);
 	}
@@ -498,25 +494,25 @@ execute(c, f, n)
 	if (c == ' ' && (curwp->w_bufp->b_mode & MDWRAP) && fillcol > 0 &&
 	    n >= 0 && getccol(FALSE) > fillcol &&
 	    (curwp->w_bufp->b_mode & MDVIEW) == FALSE)
-		execute(META|SPEC|'W', FALSE, 1);
+		execute(META | SPEC | 'W', FALSE, 1);
 
 #if	PKCODE
-        if ((c>=0x20 && c<=0x7E)                /* Self inserting.      */
+	if ((c >= 0x20 && c <= 0x7E)	/* Self inserting.      */
 #if	IBMPC
-        ||  (c>=0x80 && c<=0xFE)) {
+	    || (c >= 0x80 && c <= 0xFE)) {
 #else
 #if	VMS || BSD || USG	/* 8BIT P.K. */
-        ||  (c>=0xA0 && c<=0xFE)) {
+	    || (c >= 0xA0 && c <= 0xFE)) {
 #else
 	    ) {
 #endif
 #endif
 #else
-        if ((c>=0x20 && c<=0xFF)) {	/* Self inserting.      */
+	if ((c >= 0x20 && c <= 0xFF)) {	/* Self inserting.      */
 #endif
 		if (n <= 0) {	/* Fenceposts.          */
 			lastflag = 0;
-                        return (n<0 ? FALSE : TRUE);
+			return (n < 0 ? FALSE : TRUE);
 		}
 		thisflag = 0;	/* For the future.      */
 
@@ -576,24 +572,24 @@ quickexit(f, n)
 
 	bp = bheadp;
 	while (bp != NULL) {
-		if ((bp->b_flag&BFCHG) != 0	/* Changed.             */
+		if ((bp->b_flag & BFCHG) != 0	/* Changed.             */
-		&& (bp->b_flag&BFTRUNC) == 0	/* Not truncated P.K.	*/
+		    && (bp->b_flag & BFTRUNC) == 0	/* Not truncated P.K.   */
-        	&& (bp->b_flag&BFINVS) == 0) {	/* Real.                */
+		    && (bp->b_flag & BFINVS) == 0) {	/* Real.                */
 			curbp = bp;	/* make that buffer cur */
-			mlwrite("(Saving %s)",bp->b_fname);
+			mlwrite("(Saving %s)", bp->b_fname);
 #if	PKCODE
 #else
 			mlwrite("\n");
 #endif
 			if ((status = filesave(f, n)) != TRUE) {
 				curbp = oldcb;	/* restore curbp */
-                		return(status);
+				return (status);
 			}
 		}
 		bp = bp->b_bufp;	/* on to the next buffer */
 	}
 	quit(f, n);		/* conditionally quit   */
-	return(TRUE);
+	return (TRUE);
 }
 
 static void emergencyexit(signr)
@@ -614,7 +610,8 @@ quit(f, n)
 	if (f != FALSE		/* Argument forces it.  */
 	    || anycb() == FALSE	/* All buffers clean.   */
 	    /* User says it's OK.   */
-        || (s=mlyesno("Modified buffers exist. Leave anyway")) == TRUE) {
+	    || (s =
+		mlyesno("Modified buffers exist. Leave anyway")) == TRUE) {
 #if	(FILOCK && BSD) || SVR4
 		if (lockrel() != TRUE) {
 			TTputc('\n');
@@ -631,7 +628,7 @@ quit(f, n)
 			exit(GOOD);
 	}
 	mlwrite("");
-        return(s);
+	return (s);
 }
 
 /*
@@ -643,7 +640,7 @@ ctlxlp(f, n)
 {
 	if (kbdmode != STOP) {
 		mlwrite("%%Macro already active");
-                return(FALSE);
+		return (FALSE);
 	}
 	mlwrite("(Start macro)");
 	kbdptr = &kbdm[0];
@@ -660,13 +657,13 @@ ctlxrp(f, n)
 {
 	if (kbdmode == STOP) {
 		mlwrite("%%Macro not active");
-                return(FALSE);
+		return (FALSE);
 	}
 	if (kbdmode == RECORD) {
 		mlwrite("(End macro)");
 		kbdmode = STOP;
 	}
-        return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -678,14 +675,14 @@ ctlxe(f, n)
 {
 	if (kbdmode != STOP) {
 		mlwrite("%%Macro already active");
-                return(FALSE);
+		return (FALSE);
 	}
 	if (n <= 0)
 		return (TRUE);
 	kbdrep = n;		/* remember how many times to execute */
 	kbdmode = PLAY;		/* start us in play mode */
 	kbdptr = &kbdm[0];	/*    at the beginning */
-	return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -698,43 +695,40 @@ ctrlg(f, n)
 	TTbeep();
 	kbdmode = STOP;
 	mlwrite("(Aborted)");
-        return(ABORT);
+	return (ABORT);
 }
 
 /* tell the user that this command is illegal while we are in
    VIEW (read-only) mode				*/
 
 rdonly()
-
 {
 	TTbeep();
 	mlwrite("(Key illegal in VIEW mode)");
-	return(FALSE);
+	return (FALSE);
 }
 
 resterr()
-
 {
 	TTbeep();
 	mlwrite("(That command is RESTRICTED)");
-	return(FALSE);
+	return (FALSE);
 }
 
-nullproc()	/* user function that does NOTHING */
+nullproc()
-
+{				/* user function that does NOTHING */
-{
 }
 
-meta()	/* dummy function for binding to meta prefix */
+meta()
-{
+{				/* dummy function for binding to meta prefix */
 }
 
-cex()	/* dummy function for binding to control-x prefix */
+cex()
-{
+{				/* dummy function for binding to control-x prefix */
 }
 
-unarg()	/* dummy function for binding to universal-argument */
+unarg()
-{
+{				/* dummy function for binding to universal-argument */
 }
 
 /*****		Compiler specific Library functions	****/
@@ -764,7 +758,7 @@ int maxlen;	/* maximum length */
 	*dptr = 0;		/* orig */
 /*	if (maxlen > 0)
 		*dptr = 0;		*/
-	return(dst);
+	return (dst);
 }
 #endif
 
@@ -781,8 +775,8 @@ int maxlen;	/* maximum length */
 #undef	malloc
 #undef	free
 
-char *allocate(nbytes)	/* allocate nbytes and track */
+char *allocate(nbytes)
-
+			    /* allocate nbytes and track */
 unsigned nbytes;		/* # of bytes to allocate */
 
 {
@@ -797,11 +791,11 @@ unsigned nbytes;	/* # of bytes to allocate */
 #endif
 	}
 
-	return(mp);
+	return (mp);
 }
 
-release(mp)	/* release malloced memory and track */
+release(mp)
-
+    /* release malloced memory and track */
 char *mp;			/* chunk of RAM to release */
 
 {
@@ -809,8 +803,8 @@ char *mp;	/* chunk of RAM to release */
 
 	if (mp) {
 		/* update amount of ram currently malloced */
-		lp = ((unsigned *)mp) - 1;
+		lp = ((unsigned *) mp) - 1;
-		envram -= (long)*lp - 2;
+		envram -= (long) *lp - 2;
 		free(mp);
 #if	RAMSHOW
 		dspram();
@@ -819,9 +813,8 @@ char *mp;	/* chunk of RAM to release */
 }
 
 #if	RAMSHOW
-dspram()	/* display the amount of RAM currently malloced */
+dspram()
-
+{				/* display the amount of RAM currently malloced */
-{
 	char mbuf[20];
 	char *sp;
 
@@ -883,7 +876,7 @@ int status;	/* return status of emacs */
 #if	CALLED
 	eexitflag = TRUE;	/* flag a program exit */
 	eexitval = status;
-	return(status);
+	return (status);
 #else
 #undef	exit
 	exit(status);

pklock.c

@@ -26,7 +26,7 @@
 
 int gethostname(char *name, int namelen)
 {
-  return(sysinfo(SI_HOSTNAME, name, namelen));
+	return (sysinfo(SI_HOSTNAME, name, namelen));
 }
 #endif
 
@@ -40,10 +40,10 @@ int gethostname(char *name, int namelen)
  *
  *********************/
 char *dolock(fname)
-	char *fname;
+char *fname;
 {
 	int fd, lk, n;
-	static char lname[MAXLOCK], locker[MAXNAME+1];
+	static char lname[MAXLOCK], locker[MAXNAME + 1];
 	int mask;
 	struct stat sbuf;
 
@@ -59,17 +59,16 @@ char *dolock(fname)
 	if (stat(lname, &sbuf) == 0)
 #endif
 #if defined(S_ISREG)
-		if (! S_ISREG(sbuf.st_mode))
+		if (!S_ISREG(sbuf.st_mode))
 #else
-		if (! (((sbuf.st_mode) & 070000) == 0))	/* SysV R2 */
+		if (!(((sbuf.st_mode) & 070000) == 0))	/* SysV R2 */
 #endif
 			return "LOCK ERROR: not a regular file";
 
 	mask = umask(0);
 	fd = open(lname, O_RDWR | O_CREAT, 0666);
 	umask(mask);
-	if (fd < 0)
+	if (fd < 0) {
-	{
 		if (errno == EACCES)
 			return NULL;
 #ifdef EROFS
@@ -78,13 +77,12 @@ char *dolock(fname)
 #endif
 		return "LOCK ERROR: cannot access lock file";
 	}
-	if ((n = read(fd, locker, MAXNAME)) < 1)
+	if ((n = read(fd, locker, MAXNAME)) < 1) {
-	{
 		lseek(fd, 0, SEEK_SET);
 /*		strcpy(locker, getlogin()); */
 		cuserid(locker);
-		strcat(locker+strlen(locker), "@");
+		strcat(locker + strlen(locker), "@");
-		gethostname(locker+strlen(locker), 64);
+		gethostname(locker + strlen(locker), 64);
 		write(fd, locker, strlen(locker));
 		close(fd);
 		return NULL;
@@ -104,14 +102,13 @@ char *dolock(fname)
  *********************/
 
 char *undolock(fname)
-	char *fname;
+char *fname;
 {
 	int fd, lk;
 	static char lname[MAXLOCK];
 
 	strcat(strcpy(lname, fname), ".lock~");
-	if (unlink(lname) != 0)
+	if (unlink(lname) != 0) {
-	{
 		if (errno == EACCES || errno == ENOENT)
 			return NULL;
 #ifdef EROFS

posix.c

@@ -53,12 +53,13 @@ ttopen()
 			      | INPCK | INLCR | IGNCR | ICRNL);
 
 	/* raw CR/NR etc output handling */
-	ntermios.c_oflag &= ~(OPOST | ONLCR | OLCUC | OCRNL | ONOCR | ONLRET);
+	ntermios.c_oflag &=
+	    ~(OPOST | ONLCR | OLCUC | OCRNL | ONOCR | ONLRET);
 
 	/* No signal handling, no echo etc */
 	ntermios.c_lflag &= ~(ISIG | ICANON | XCASE | ECHO | ECHOE | ECHOK
-			     | ECHONL | NOFLSH | TOSTOP | ECHOCTL | ECHOPRT
+			      | ECHONL | NOFLSH | TOSTOP | ECHOCTL |
-			     | ECHOKE | FLUSHO | PENDIN | IEXTEN);
+			      ECHOPRT | ECHOKE | FLUSHO | PENDIN | IEXTEN);
 
 	/* one character, no timeout */
 	ntermios.c_cc[VMIN] = 1;
@@ -71,7 +72,7 @@ ttopen()
 	 */
 	setbuffer(stdout, &tobuf[0], TBUFSIZ);
 
-	kbdflgs = fcntl( 0, F_GETFL, 0 );
+	kbdflgs = fcntl(0, F_GETFL, 0);
 	kbdpoll = FALSE;
 
 	/* on all screens we are not sure of the initial position
@@ -136,7 +137,7 @@ ttflush()
  */
 ttgetc()
 {
-	return(255 & fgetc(stdin)); /* 8BIT P.K. */
+	return (255 & fgetc(stdin));	/* 8BIT P.K. */
 }
 
 /* typahead:	Check to see if any characters are already in the
@@ -148,7 +149,7 @@ typahead()
 	int x;			/* holds # of pending chars */
 
 #ifdef FIONREAD
-	if (ioctl(0,FIONREAD,&x) < 0)
+	if (ioctl(0, FIONREAD, &x) < 0)
 		x = 0;
 #else
 	x = 0;

random.c

@@ -18,8 +18,8 @@ int     tabsize;                        /* Tab size (0: use real tabs)  */
 setfillcol(f, n)
 {
 	fillcol = n;
-	mlwrite("(Fill column is %d)",n);
+	mlwrite("(Fill column is %d)", n);
-        return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -94,12 +94,12 @@ showcpos(f, n)
 
 	ratio = 0;		/* Ratio before dot. */
 	if (numchars != 0)
-                ratio = (100L*predchars) / numchars;
+		ratio = (100L * predchars) / numchars;
 
 	/* summarize and report the info */
 #if	PKCODE
-	pk_mlrec.pk_clin = predlines+1;
+	pk_mlrec.pk_clin = predlines + 1;
-	pk_mlrec.pk_tlin = numlines+1;
+	pk_mlrec.pk_tlin = numlines + 1;
 	pk_mlrec.pk_ccol = col;
 	pk_mlrec.pk_tcol = ecol;
 	pk_mlrec.pk_cchr = predchars;
@@ -110,15 +110,14 @@ showcpos(f, n)
 		&pk_mlrec);
 #else
 	mlwrite("Line %d/%d Col %d/%d Char %D/%D (%d%%) char = 0x%x",
-		predlines+1, numlines+1, col, ecol,
+		predlines + 1, numlines + 1, col, ecol,
 		predchars, numchars, ratio, curchar);
 #endif
 	return (TRUE);
 }
 
-getcline()	/* get the current line number */
+getcline()
-
+{				/* get the current line number */
-{
 	register LINE *lp;	/* current line */
 	register int numlines;	/* # of lines before point */
 
@@ -136,7 +135,7 @@ getcline()	/* get the current line number */
 	}
 
 	/* and return the resulting count */
-	return(numlines + 1);
+	return (numlines + 1);
 }
 
 /*
@@ -147,17 +146,17 @@ int bflg;
 {
 	register int c, i, col;
 	col = 0;
-        for (i=0; i<curwp->w_doto; ++i) {
+	for (i = 0; i < curwp->w_doto; ++i) {
 		c = lgetc(curwp->w_dotp, i);
-                if (c!=' ' && c!='\t' && bflg)
+		if (c != ' ' && c != '\t' && bflg)
 			break;
 		if (c == '\t')
 			col |= tabmask;
-                else if (c<0x20 || c==0x7F)
+		else if (c < 0x20 || c == 0x7F)
 			++col;
 		++col;
 	}
-        return(col);
+	return (col);
 }
 
 /*
@@ -186,7 +185,7 @@ int pos;	/* position to set cursor */
 		c = lgetc(curwp->w_dotp, i);
 		if (c == '\t')
 			col |= tabmask;
-                else if (c<0x20 || c==0x7F)
+		else if (c < 0x20 || c == 0x7F)
 			++col;
 		++col;
 	}
@@ -195,7 +194,7 @@ int pos;	/* position to set cursor */
 	curwp->w_doto = i;
 
 	/* and tell weather we made it */
-	return(col >= pos);
+	return (col >= pos);
 }
 
 /*
@@ -212,18 +211,18 @@ twiddle(f, n)
 	register int cl;
 	register int cr;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	dotp = curwp->w_dotp;
 	doto = curwp->w_doto;
-        if (doto==llength(dotp) && --doto<0)
+	if (doto == llength(dotp) && --doto < 0)
 		return (FALSE);
 	cr = lgetc(dotp, doto);
 	if (--doto < 0)
 		return (FALSE);
 	cl = lgetc(dotp, doto);
-        lputc(dotp, doto+0, cr);
+	lputc(dotp, doto + 0, cr);
-        lputc(dotp, doto+1, cl);
+	lputc(dotp, doto + 1, cl);
 	lchange(WFEDIT);
 	return (TRUE);
 }
@@ -239,8 +238,8 @@ quote(f, n)
 	register int s;
 	register int c;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	c = tgetc();
 	if (n < 0)
 		return (FALSE);
@@ -249,7 +248,7 @@ quote(f, n)
 	if (c == '\n') {
 		do {
 			s = lnewline();
-                } while (s==TRUE && --n);
+		} while (s == TRUE && --n);
 		return (s);
 	}
 	return (linsert(n, c));
@@ -268,23 +267,23 @@ tab(f, n)
 		return (FALSE);
 	if (n == 0 || n > 1) {
 		tabsize = n;
-                return(TRUE);
+		return (TRUE);
 	}
-        if (! tabsize)
+	if (!tabsize)
-                return(linsert(1, '\t'));
+		return (linsert(1, '\t'));
-        return(linsert(tabsize - (getccol(FALSE) % tabsize), ' '));
+	return (linsert(tabsize - (getccol(FALSE) % tabsize), ' '));
 }
 
 #if	AEDIT
-detab(f, n)		/* change tabs to spaces */
+detab(f, n)
-
+    /* change tabs to spaces */
-int f,n;	/* default flag and numeric repeat count */
+int f, n;			/* default flag and numeric repeat count */
 
 {
 	register int inc;	/* increment to next line [sgn(n)] */
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 
 	if (f == FALSE)
 		n = 1;
@@ -299,7 +298,9 @@ int f,n;	/* default flag and numeric repeat count */
 			/* if we have a tab */
 			if (lgetc(curwp->w_dotp, curwp->w_doto) == '\t') {
 				ldelete(1L, FALSE);
-				insspace(TRUE, (tabmask+1) - (curwp->w_doto & tabmask));
+				insspace(TRUE,
+					 (tabmask + 1) -
+					 (curwp->w_doto & tabmask));
 			}
 			forwchar(FALSE, 1);
 		}
@@ -311,12 +312,12 @@ int f,n;	/* default flag and numeric repeat count */
 	curwp->w_doto = 0;	/* to the begining of the line */
 	thisflag &= ~CFCPCN;	/* flag that this resets the goal column */
 	lchange(WFEDIT);	/* yes, we have made at least an edit */
-	return(TRUE);
+	return (TRUE);
 }
 
-entab(f, n)		/* change spaces to tabs where posible */
+entab(f, n)
-
+    /* change spaces to tabs where posible */
-int f,n;	/* default flag and numeric repeat count */
+int f, n;			/* default flag and numeric repeat count */
 
 {
 	register int inc;	/* increment to next line [sgn(n)] */
@@ -324,8 +325,8 @@ int f,n;	/* default flag and numeric repeat count */
 	register int ccol;	/* current cursor column */
 	register char cchar;	/* current character */
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 
 	if (f == FALSE)
 		n = 1;
@@ -347,7 +348,8 @@ int f,n;	/* default flag and numeric repeat count */
 					/* there is a bug here dealing with mixed space/tabed
 					   lines.......it will get fixed                */
 					backchar(TRUE, ccol - fspace);
-					ldelete((long)(ccol - fspace), FALSE);
+					ldelete((long) (ccol - fspace),
+						FALSE);
 					linsert(1, '\t');
 					fspace = -1;
 				}
@@ -381,12 +383,12 @@ int f,n;	/* default flag and numeric repeat count */
 	curwp->w_doto = 0;	/* to the begining of the line */
 	thisflag &= ~CFCPCN;	/* flag that this resets the goal column */
 	lchange(WFEDIT);	/* yes, we have made at least an edit */
-	return(TRUE);
+	return (TRUE);
 }
 
-trim(f, n)	/* trim trailing whitespace from the point to eol */
+trim(f, n)
-
+    /* trim trailing whitespace from the point to eol */
-int f,n;	/* default flag and numeric repeat count */
+int f, n;			/* default flag and numeric repeat count */
 
 {
 	register LINE *lp;	/* current line pointer */
@@ -394,8 +396,8 @@ int f,n;	/* default flag and numeric repeat count */
 	register int length;	/* current length */
 	register int inc;	/* increment to next line [sgn(n)] */
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 
 	if (f == FALSE)
 		n = 1;
@@ -409,8 +411,8 @@ int f,n;	/* default flag and numeric repeat count */
 
 		/* trim the current line */
 		while (length > offset) {
-			if (lgetc(lp, length-1) != ' ' &&
+			if (lgetc(lp, length - 1) != ' ' &&
-			    lgetc(lp, length-1) != '\t')
+			    lgetc(lp, length - 1) != '\t')
 				break;
 			length--;
 		}
@@ -422,7 +424,7 @@ int f,n;	/* default flag and numeric repeat count */
 	}
 	lchange(WFEDIT);
 	thisflag &= ~CFCPCN;	/* flag that this resets the goal column */
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 
@@ -436,8 +438,8 @@ openline(f, n)
 	register int i;
 	register int s;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (FALSE);
 	if (n == 0)
@@ -445,7 +447,7 @@ openline(f, n)
 	i = n;			/* Insert newlines.     */
 	do {
 		s = lnewline();
-        } while (s==TRUE && --i);
+	} while (s == TRUE && --i);
 	if (s == TRUE)		/* Then back up overtop */
 		s = backchar(f, n);	/* of them all.         */
 	return (s);
@@ -459,15 +461,15 @@ newline(f, n)
 {
 	register int s;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (FALSE);
 
 	/* if we are in C mode and this is a default <NL> */
 	if (n == 1 && (curbp->b_mode & MDCMOD) &&
 	    curwp->w_dotp != curbp->b_linep)
-		return(cinsert());
+		return (cinsert());
 
 	/*
 	 * If a newline was typed, fill column is defined, the argument is non-
@@ -477,11 +479,11 @@ newline(f, n)
 	if ((curwp->w_bufp->b_mode & MDWRAP) && fillcol > 0 &&
 	    getccol(FALSE) > fillcol &&
 	    (curwp->w_bufp->b_mode & MDVIEW) == FALSE)
-		execute(META|SPEC|'W', FALSE, 1);
+		execute(META | SPEC | 'W', FALSE, 1);
 
 	/* insert some lines */
 	while (n--) {
-		if ((s=lnewline()) != TRUE)
+		if ((s = lnewline()) != TRUE)
 			return (s);
 #if SCROLLCODE
 		curwp->w_flag |= WFINS;
@@ -490,9 +492,8 @@ newline(f, n)
 	return (TRUE);
 }
 
-cinsert()	/* insert a newline and indentation for C */
+cinsert()
-
+{				/* insert a newline and indentation for C */
-{
 	register char *cptr;	/* string pointer into text to copy */
 	register int tptr;	/* index to scan into line */
 	register int bracef;	/* was there a brace at the end of line? */
@@ -517,7 +518,7 @@ cinsert()	/* insert a newline and indentation for C */
 
 	/* put in the newline */
 	if (lnewline() == FALSE)
-		return(FALSE);
+		return (FALSE);
 
 	/* and the saved indentation */
 	linstr(ichar);
@@ -529,12 +530,12 @@ cinsert()	/* insert a newline and indentation for C */
 #if SCROLLCODE
 	curwp->w_flag |= WFINS;
 #endif
-	return(TRUE);
+	return (TRUE);
 }
 
 #if	NBRACE
-insbrace(n, c)	/* insert a brace into the text here...we are in CMODE */
+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) */
 
@@ -553,21 +554,29 @@ int c;	/* brace to insert (always } for now) */
 		for (i = curwp->w_doto - 1; i >= 0; --i) {
 			ch = lgetc(curwp->w_dotp, i);
 			if (ch != ' ' && ch != '\t')
-				return(linsert(n, c));
+				return (linsert(n, c));
 		}
 
 	/* chercher le caractere oppose correspondant */
 	switch (c) {
-		case '}': oc = '{'; break;
+	case '}':
-		case ']': oc = '['; break;
+		oc = '{';
-		case ')': oc = '('; break;
+		break;
-		default: return(FALSE);
+	case ']':
+		oc = '[';
+		break;
+	case ')':
+		oc = '(';
+		break;
+	default:
+		return (FALSE);
 	}
 
 	oldlp = curwp->w_dotp;
 	oldoff = curwp->w_doto;
 
-	count = 1; backchar(FALSE, 1);
+	count = 1;
+	backchar(FALSE, 1);
 
 	while (count > 0) {
 		if (curwp->w_doto == llength(curwp->w_dotp))
@@ -575,8 +584,10 @@ int c;	/* brace to insert (always } for now) */
 		else
 			ch = lgetc(curwp->w_dotp, curwp->w_doto);
 
-		if (ch == c)  ++count;
+		if (ch == c)
-		if (ch == oc) --count;
+			++count;
+		if (ch == oc)
+			--count;
 
 		backchar(FALSE, 1);
 		if (boundry(curwp->w_dotp, curwp->w_doto, REVERSE))
@@ -586,12 +597,13 @@ int c;	/* brace to insert (always } for now) */
 	if (count != 0) {	/* no match */
 		curwp->w_dotp = oldlp;
 		curwp->w_doto = oldoff;
-		return(linsert(n, c));
+		return (linsert(n, c));
 	}
 
 	curwp->w_doto = 0;	/* debut de ligne */
 	/* aller au debut de la ligne apres la tabulation */
-	while ((ch = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ' || ch == '\t')
+	while ((ch = lgetc(curwp->w_dotp, curwp->w_doto)) == ' '
+	       || ch == '\t')
 		forwchar(FALSE, 1);
 
 	/* delete back first */
@@ -605,17 +617,17 @@ int c;	/* brace to insert (always } for now) */
 				backdel(FALSE, 1);
 		else {		/* on doit en inserer */
 			while (target - getccol(FALSE) >= 8)
-				linsert(1,'\t');
+				linsert(1, '\t');
 			linsert(target - getccol(FALSE), ' ');
 		}
 	}
 
 	/* and insert the required brace(s) */
-	return(linsert(n, c));
+	return (linsert(n, c));
 }
 #else
-insbrace(n, c)	/* insert a brace into the text here...we are in CMODE */
+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) */
 
@@ -626,13 +638,13 @@ int c;	/* brace to insert (always { for now) */
 
 	/* if we are at the beginning of the line, no go */
 	if (curwp->w_doto == 0)
-		return(linsert(n,c));
+		return (linsert(n, c));
 
 	/* scan to see if all space before this is white space */
 	for (i = curwp->w_doto - 1; i >= 0; --i) {
 		ch = lgetc(curwp->w_dotp, i);
 		if (ch != ' ' && ch != '\t')
-			return(linsert(n, c));
+			return (linsert(n, c));
 	}
 
 	/* delete back first */
@@ -643,25 +655,24 @@ int c;	/* brace to insert (always { for now) */
 		backdel(FALSE, 1);
 
 	/* and insert the required brace(s) */
-	return(linsert(n, c));
+	return (linsert(n, c));
 }
 #endif
 
-inspound()	/* insert a # into the text here...we are in CMODE */
+inspound()
-
+{				/* insert a # into the text here...we are in CMODE */
-{
 	register int ch;	/* last character before input */
 	register int i;
 
 	/* if we are at the beginning of the line, no go */
 	if (curwp->w_doto == 0)
-		return(linsert(1,'#'));
+		return (linsert(1, '#'));
 
 	/* scan to see if all space before this is white space */
 	for (i = curwp->w_doto - 1; i >= 0; --i) {
 		ch = lgetc(curwp->w_dotp, i);
 		if (ch != ' ' && ch != '\t')
-			return(linsert(1, '#'));
+			return (linsert(1, '#'));
 	}
 
 	/* delete back first */
@@ -669,7 +680,7 @@ inspound()	/* insert a # into the text here...we are in CMODE */
 		backdel(FALSE, 1);
 
 	/* and insert the required pound */
-	return(linsert(1, '#'));
+	return (linsert(1, '#'));
 }
 
 /*
@@ -686,14 +697,14 @@ deblank(f, n)
 	register LINE *lp2;
 	long nld;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	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 = 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);
@@ -716,23 +727,23 @@ indent(f, n)
 	register int c;
 	register int i;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (FALSE);
 	while (n--) {
 		nicol = 0;
-                for (i=0; i<llength(curwp->w_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 |= tabmask;
 			++nicol;
 		}
 		if (lnewline() == FALSE
-                || ((i=nicol/8)!=0 && linsert(i, '\t')==FALSE)
+		    || ((i = nicol / 8) != 0 && linsert(i, '\t') == FALSE)
-                || ((i=nicol%8)!=0 && linsert(i,  ' ')==FALSE))
+		    || ((i = nicol % 8) != 0 && linsert(i, ' ') == FALSE))
 			return (FALSE);
 	}
 	return (TRUE);
@@ -746,16 +757,16 @@ indent(f, n)
  */
 forwdel(f, n)
 {
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (backdel(f, -n));
 	if (f != FALSE) {	/* Really a kill.       */
-                if ((lastflag&CFKILL) == 0)
+		if ((lastflag & CFKILL) == 0)
 			kdelete();
 		thisflag |= CFKILL;
 	}
-        return (ldelete((long)n, f));
+	return (ldelete((long) n, f));
 }
 
 /*
@@ -768,17 +779,17 @@ backdel(f, n)
 {
 	register int s;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (forwdel(f, -n));
 	if (f != FALSE) {	/* Really a kill.       */
-                if ((lastflag&CFKILL) == 0)
+		if ((lastflag & CFKILL) == 0)
 			kdelete();
 		thisflag |= CFKILL;
 	}
-        if ((s=backchar(f, n)) == TRUE)
+	if ((s = backchar(f, n)) == TRUE)
-                s = ldelete((long)n, f);
+		s = ldelete((long) n, f);
 	return (s);
 }
 
@@ -795,36 +806,36 @@ killtext(f, n)
 	register LINE *nextp;
 	long chunk;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
-        if ((lastflag&CFKILL) == 0)             /* Clear kill buffer if */
+	if ((lastflag & CFKILL) == 0)	/* Clear kill buffer if */
 		kdelete();	/* last wasn't a kill.  */
 	thisflag |= CFKILL;
 	if (f == FALSE) {
-                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 = curwp->w_doto;
 		curwp->w_doto = 0;
 	} 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);
 		while (--n) {
 			if (nextp == curbp->b_linep)
 				return (FALSE);
-                        chunk += llength(nextp)+1;
+			chunk += llength(nextp) + 1;
 			nextp = lforw(nextp);
 		}
 	} else {
 		mlwrite("neg kill");
 		return (FALSE);
 	}
-        return(ldelete(chunk, TRUE));
+	return (ldelete(chunk, TRUE));
 }
 
-setmode(f, n)	/* prompt and set an editor mode */
+setmode(f, n)
-
+    /* prompt and set an editor mode */
 int f, n;			/* default and argument */
 
 {
@@ -835,8 +846,8 @@ int f, n;	/* default and argument */
 #endif
 }
 
-delmode(f, n)	/* prompt and delete an editor mode */
+delmode(f, n)
-
+    /* prompt and delete an editor mode */
 int f, n;			/* default and argument */
 
 {
@@ -847,8 +858,8 @@ int f, n;	/* default and argument */
 #endif
 }
 
-setgmode(f, n)	/* prompt and set a global editor mode */
+setgmode(f, n)
-
+    /* prompt and set a global editor mode */
 int f, n;			/* default and argument */
 
 {
@@ -859,8 +870,8 @@ int f, n;	/* default and argument */
 #endif
 }
 
-delgmode(f, n)	/* prompt and delete a global editor mode */
+delgmode(f, n)
-
+    /* prompt and delete a global editor mode */
 int f, n;			/* default and argument */
 
 {
@@ -871,8 +882,8 @@ int f, n;	/* default and argument */
 #endif
 }
 
-adjustmode(kind, global)	/* change the editor mode status */
+adjustmode(kind, global)
-
+				    /* change the editor mode status */
 int kind;			/* true = set,          false = delete */
 int global;			/* true = global flag,  false = current buffer flag */
 {
@@ -887,9 +898,9 @@ int global;	/* true = global flag,	false = current buffer flag */
 
 	/* build the proper prompt string */
 	if (global)
-		strcpy(prompt,"Global mode to ");
+		strcpy(prompt, "Global mode to ");
 	else
-		strcpy(prompt,"Mode to ");
+		strcpy(prompt, "Mode to ");
 
 	if (kind == TRUE)
 		strcat(prompt, "add: ");
@@ -900,7 +911,7 @@ int global;	/* true = global flag,	false = current buffer flag */
 
 	status = mlreply(prompt, cbuf, NPAT - 1);
 	if (status != TRUE)
-		return(status);
+		return (status);
 
 	/* make it uppercase */
 
@@ -916,24 +927,21 @@ int global;	/* true = global flag,	false = current buffer flag */
 
 	/* test it first against the colors we know */
 #if	PKCODE & IBMPC
-	for (i=0; i<=NCOLORS; i++) {
+	for (i = 0; i <= NCOLORS; i++) {
 #else
-	for (i=0; i<NCOLORS; i++) {
+	for (i = 0; i < NCOLORS; i++) {
 #endif
 		if (strcmp(cbuf, cname[i]) == 0) {
 			/* finding the match, we set the color */
 #if	COLOR
-			if (uflag)
+			if (uflag) {
-			{
 				if (global)
 					gfcolor = i;
 #if	PKCODE == 0
 				else
 #endif
 					curwp->w_fcolor = i;
-			}
+			} else {
-			else
-			{
 				if (global)
 					gbcolor = i;
 #if	PKCODE == 0
@@ -945,13 +953,13 @@ int global;	/* true = global flag,	false = current buffer flag */
 			curwp->w_flag |= WFCOLR;
 #endif
 			mlerase();
-			return(TRUE);
+			return (TRUE);
 		}
 	}
 
 	/* test it against the modes we know */
 
-	for (i=0; i < NUMMODES; i++) {
+	for (i = 0; i < NUMMODES; i++) {
 		if (strcmp(cbuf, modename[i]) == 0) {
 			/* finding a match, we process it */
 			if (kind == TRUE)
@@ -959,8 +967,7 @@ int global;	/* true = global flag,	false = current buffer flag */
 					gmode |= (1 << i);
 				else
 					curbp->b_mode |= (1 << i);
-			else
+			else if (global)
-				if (global)
 				gmode &= ~(1 << i);
 			else
 				curbp->b_mode &= ~(1 << i);
@@ -968,12 +975,12 @@ int global;	/* true = global flag,	false = current buffer flag */
 			if (global == 0)
 				upmode();
 			mlerase();	/* erase the junk */
-			return(TRUE);
+			return (TRUE);
 		}
 	}
 
 	mlwrite("No such mode!");
-	return(FALSE);
+	return (FALSE);
 }
 
 /*	This function simply clears the message line,
@@ -985,7 +992,7 @@ int f, n;	/* arguments ignored */
 
 {
 	mlforce("");
-	return(TRUE);
+	return (TRUE);
 }
 
 /*	This function writes a string on the message line
@@ -1000,10 +1007,11 @@ int f, n;	/* arguments ignored */
 	register char *np;	/* ptr into nbuf */
 	register int status;
 	char buf[NPAT];		/* buffer to recieve message into */
-	char nbuf[NPAT*2];	/* buffer to expand string into */
+	char nbuf[NPAT * 2];	/* buffer to expand string into */
 
-	if ((status = mlreply("Message to write: ", buf, NPAT - 1)) != TRUE)
+	if ((status =
-		return(status);
+	     mlreply("Message to write: ", buf, NPAT - 1)) != TRUE)
+		return (status);
 
 	/* expand all '%' to "%%" so mlwrite won't expect arguments */
 	sp = buf;
@@ -1017,7 +1025,7 @@ int f, n;	/* arguments ignored */
 
 	/* write the message out */
 	mlforce(nbuf);
-	return(TRUE);
+	return (TRUE);
 }
 
 #if	CFENCE
@@ -1048,13 +1056,33 @@ int f, n;	/* not used */
 
 	/* setup proper matching fence */
 	switch (ch) {
-		case '(': ofence = ')'; sdir = FORWARD; break;
+	case '(':
-		case '{': ofence = '}'; sdir = FORWARD; break;
+		ofence = ')';
-		case '[': ofence = ']'; sdir = FORWARD; break;
+		sdir = FORWARD;
-		case ')': ofence = '('; sdir = REVERSE; break;
+		break;
-		case '}': ofence = '{'; sdir = REVERSE; break;
+	case '{':
-		case ']': ofence = '['; sdir = REVERSE; break;
+		ofence = '}';
-		default: TTbeep(); return(FALSE);
+		sdir = FORWARD;
+		break;
+	case '[':
+		ofence = ']';
+		sdir = FORWARD;
+		break;
+	case ')':
+		ofence = '(';
+		sdir = REVERSE;
+		break;
+	case '}':
+		ofence = '{';
+		sdir = REVERSE;
+		break;
+	case ']':
+		ofence = '[';
+		sdir = REVERSE;
+		break;
+	default:
+		TTbeep();
+		return (FALSE);
 	}
 
 	/* set up for scan */
@@ -1089,14 +1117,14 @@ int f, n;	/* not used */
 		else
 			forwchar(FALSE, 1);
 		curwp->w_flag |= WFMOVE;
-		return(TRUE);
+		return (TRUE);
 	}
 
 	/* restore the current position */
 	curwp->w_dotp = oldlp;
 	curwp->w_doto = oldoff;
 	TTbeep();
-	return(FALSE);
+	return (FALSE);
 }
 #endif
 
@@ -1164,58 +1192,57 @@ char ch;	/* fence type to match against */
 	/* restore the current position */
 	curwp->w_dotp = oldlp;
 	curwp->w_doto = oldoff;
-	return(TRUE);
+	return (TRUE);
 }
 
-istring(f, n)	/* ask for and insert a string into the current
+istring(f, n)
+    /* ask for and insert a string into the current
        buffer at the current point */
-
 int f, n;			/* ignored arguments */
 
 {
 	register int status;	/* status return code */
-	char tstring[NPAT+1];	/* string to add */
+	char tstring[NPAT + 1];	/* string to add */
 
 	/* ask for string to insert */
-	status = mlreplyt("String to insert<META>: ", tstring, NPAT, metac);
+	status =
+	    mlreplyt("String to insert<META>: ", tstring, NPAT, metac);
 	if (status != TRUE)
-		return(status);
+		return (status);
 
 	if (f == FALSE)
 		n = 1;
 
 	if (n < 0)
-		n = - n;
+		n = -n;
 
 	/* insert it */
-	while (n-- && (status = linstr(tstring)))
+	while (n-- && (status = linstr(tstring)));
-		;
+	return (status);
-	return(status);
 }
 
-ovstring(f, n)	/* ask for and overwite a string into the current
+ovstring(f, n)
+    /* ask for and overwite a string into the current
        buffer at the current point */
-
 int f, n;			/* ignored arguments */
 
 {
 	register int status;	/* status return code */
-	char tstring[NPAT+1];	/* string to add */
+	char tstring[NPAT + 1];	/* string to add */
 
 	/* ask for string to insert */
-	status = mlreplyt("String to overwrite<META>: ", tstring, NPAT, metac);
+	status =
+	    mlreplyt("String to overwrite<META>: ", tstring, NPAT, metac);
 	if (status != TRUE)
-		return(status);
+		return (status);
 
 	if (f == FALSE)
 		n = 1;
 
 	if (n < 0)
-		n = - n;
+		n = -n;
 
 	/* insert it */
-	while (n-- && (status = lover(tstring)))
+	while (n-- && (status = lover(tstring)));
-		;
+	return (status);
-	return(status);
 }
-

region.c

@@ -24,11 +24,11 @@ killregion(f, n)
 	register int s;
 	REGION region;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
-        if ((s=getregion(&region)) != TRUE)
+	if ((s = getregion(&region)) != TRUE)
 		return (s);
-        if ((lastflag&CFKILL) == 0)             /* This is a kill type  */
+	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;
@@ -49,21 +49,21 @@ copyregion(f, n)
 	register int s;
 	REGION region;
 
-        if ((s=getregion(&region)) != TRUE)
+	if ((s = getregion(&region)) != 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.      */
 	while (region.r_size--) {
 		if (loffs == llength(linep)) {	/* End of line.         */
-                        if ((s=kinsert('\n')) != TRUE)
+			if ((s = kinsert('\n')) != TRUE)
 				return (s);
 			linep = lforw(linep);
 			loffs = 0;
 		} else {	/* Middle of line.      */
-                        if ((s=kinsert(lgetc(linep, loffs))) != TRUE)
+			if ((s = kinsert(lgetc(linep, loffs))) != TRUE)
 				return (s);
 			++loffs;
 		}
@@ -88,9 +88,9 @@ lowerregion(f, n)
 	register int s;
 	REGION region;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
-        if ((s=getregion(&region)) != TRUE)
+	if ((s = getregion(&region)) != TRUE)
 		return (s);
 	lchange(WFHARD);
 	linep = region.r_linep;
@@ -101,8 +101,8 @@ lowerregion(f, n)
 			loffs = 0;
 		} else {
 			c = lgetc(linep, loffs);
-                        if (c>='A' && c<='Z')
+			if (c >= 'A' && c <= 'Z')
-                                lputc(linep, loffs, c+'a'-'A');
+				lputc(linep, loffs, c + 'a' - 'A');
 			++loffs;
 		}
 	}
@@ -125,9 +125,9 @@ upperregion(f, n)
 	register int s;
 	REGION region;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
-        if ((s=getregion(&region)) != TRUE)
+	if ((s = getregion(&region)) != TRUE)
 		return (s);
 	lchange(WFHARD);
 	linep = region.r_linep;
@@ -138,8 +138,8 @@ upperregion(f, n)
 			loffs = 0;
 		} else {
 			c = lgetc(linep, loffs);
-                        if (c>='a' && c<='z')
+			if (c >= 'a' && c <= 'z')
-                                lputc(linep, loffs, c-'a'+'A');
+				lputc(linep, loffs, c - 'a' + 'A');
 			++loffs;
 		}
 	}
@@ -173,31 +173,33 @@ register REGION *rp;
 		rp->r_linep = curwp->w_dotp;
 		if (curwp->w_doto < curwp->w_marko) {
 			rp->r_offset = curwp->w_doto;
-                        rp->r_size = (long)(curwp->w_marko-curwp->w_doto);
+			rp->r_size =
+			    (long) (curwp->w_marko - curwp->w_doto);
 		} else {
 			rp->r_offset = curwp->w_marko;
-                        rp->r_size = (long)(curwp->w_doto-curwp->w_marko);
+			rp->r_size =
+			    (long) (curwp->w_doto - curwp->w_marko);
 		}
 		return (TRUE);
 	}
 	blp = curwp->w_dotp;
-        bsize = (long)curwp->w_doto;
+	bsize = (long) curwp->w_doto;
 	flp = curwp->w_dotp;
-        fsize = (long)(llength(flp)-curwp->w_doto+1);
+	fsize = (long) (llength(flp) - curwp->w_doto + 1);
-        while (flp!=curbp->b_linep || lback(blp)!=curbp->b_linep) {
+	while (flp != curbp->b_linep || lback(blp) != curbp->b_linep) {
 		if (flp != curbp->b_linep) {
 			flp = lforw(flp);
 			if (flp == curwp->w_markp) {
 				rp->r_linep = curwp->w_dotp;
 				rp->r_offset = curwp->w_doto;
-                                rp->r_size = fsize+curwp->w_marko;
+				rp->r_size = fsize + curwp->w_marko;
 				return (TRUE);
 			}
-                        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;
@@ -209,4 +211,3 @@ register REGION *rp;
 	mlwrite("Bug: lost mark");
 	return (FALSE);
 }
-

spawn.c

@@ -49,7 +49,7 @@ spawncli(f, n)
 
 	/* don't allow this command if restricted */
 	if (restflag)
-		return(resterr());
+		return (resterr());
 
 #if     VMS
 	movecursor(term.t_nrow, 0);	/* In last line.        */
@@ -61,7 +61,7 @@ spawncli(f, n)
 	mlputs("\r\n(Returning from DCL)\r\n");
 	TTflush();
 	sleep(1);
-	return(TRUE);
+	return (TRUE);
 #endif
 #if     MSDOS & (MSC | TURBO)
 	movecursor(term.t_nrow, 0);	/* Seek to last line.   */
@@ -70,7 +70,7 @@ spawncli(f, n)
 	shellprog("");
 	TTkopen();
 	sgarbf = TRUE;
-        return(TRUE);
+	return (TRUE);
 #endif
 #if     V7 | USG | BSD
 	movecursor(term.t_nrow, 0);	/* Seek to last line.   */
@@ -95,17 +95,17 @@ spawncli(f, n)
  *		-lbt
  */
 	chg_width = term.t_ncol;
-	chg_height = term.t_nrow+1;
+	chg_height = term.t_nrow + 1;
 	term.t_nrow = term.t_ncol = 0;
 #endif
-        return(TRUE);
+	return (TRUE);
 #endif
 }
 
 #if	BSD | __hpux | SVR4
 
-bktoshell()		/* suspend MicroEMACS and wait to wake up */
+bktoshell()
-{
+{				/* suspend MicroEMACS and wait to wake up */
 	int pid;
 
 	vttidy();
@@ -136,10 +136,10 @@ spawn(f, n)
 
 	/* don't allow this command if restricted */
 	if (restflag)
-		return(resterr());
+		return (resterr());
 
 #if     VMS
-        if ((s=mlreply("!", line, NLINE)) != TRUE)
+	if ((s = mlreply("!", line, NLINE)) != TRUE)
 		return (s);
 	movecursor(term.t_nrow, 0);
 	TTflush();
@@ -153,8 +153,8 @@ spawn(f, n)
 	return (s);
 #endif
 #if     MSDOS
-        if ((s=mlreply("!", line, NLINE)) != TRUE)
+	if ((s = mlreply("!", line, NLINE)) != TRUE)
-                return(s);
+		return (s);
 	movecursor(term.t_nrow, 0);
 	TTkclose();
 	shellprog(line);
@@ -168,7 +168,7 @@ spawn(f, n)
 	return (TRUE);
 #endif
 #if     V7 | USG | BSD
-        if ((s=mlreply("!", line, NLINE)) != TRUE)
+	if ((s = mlreply("!", line, NLINE)) != TRUE)
 		return (s);
 	TTflush();
 	TTclose();		/* stty to old modes    */
@@ -180,8 +180,7 @@ spawn(f, n)
 	if (clexec == FALSE) {
 		mlputs("(End)");	/* Pause.               */
 		TTflush();
-		while ((s = tgetc()) != '\r' && s != ' ')
+		while ((s = tgetc()) != '\r' && s != ' ');
-                ;
 		mlputs("\r\n");
 	}
 	TTkopen();
@@ -197,17 +196,16 @@ spawn(f, n)
  */
 
 execprg(f, n)
-
 {
 	register int s;
 	char line[NLINE];
 
 	/* don't allow this command if restricted */
 	if (restflag)
-		return(resterr());
+		return (resterr());
 
 #if     VMS
-        if ((s=mlreply("!", line, NLINE)) != TRUE)
+	if ((s = mlreply("!", line, NLINE)) != TRUE)
 		return (s);
 	TTflush();
 	s = sys(line);		/* Run the command.     */
@@ -219,8 +217,8 @@ execprg(f, n)
 #endif
 
 #if     MSDOS
-        if ((s=mlreply("$", line, NLINE)) != TRUE)
+	if ((s = mlreply("$", line, NLINE)) != TRUE)
-                return(s);
+		return (s);
 	movecursor(term.t_nrow, 0);
 	TTkclose();
 	execprog(line);
@@ -235,7 +233,7 @@ execprg(f, n)
 #endif
 
 #if     V7 | USG | BSD
-        if ((s=mlreply("!", line, NLINE)) != TRUE)
+	if ((s = mlreply("!", line, NLINE)) != TRUE)
 		return (s);
 	TTputc('\n');		/* Already have '\r'    */
 	TTflush();
@@ -245,8 +243,7 @@ execprg(f, n)
 	TTopen();
 	mlputs("(End)");	/* Pause.               */
 	TTflush();
-        while ((s = tgetc()) != '\r' && s != ' ')
+	while ((s = tgetc()) != '\r' && s != ' ');
-                ;
 	sgarbf = TRUE;
 	return (TRUE);
 #endif
@@ -276,31 +273,33 @@ pipecmd(f, n)
 
 	/* don't allow this command if restricted */
 	if (restflag)
-		return(resterr());
+		return (resterr());
 
 #if	MSDOS
-	if ((tmp = getenv("TMP")) == NULL && (tmp = getenv("TEMP")) == NULL)
+	if ((tmp = getenv("TMP")) == NULL
+	    && (tmp = getenv("TEMP")) == NULL)
 		strcpy(filnam, "command");
 	else {
 		strcpy(filnam, tmp);
 		len = strlen(tmp);
-		if (len <= 0 || filnam[len-1] != '\\' && filnam[len-1] != '/')
+		if (len <= 0 || filnam[len - 1] != '\\'
-			strcat(filnam,"\\");
+		    && filnam[len - 1] != '/')
-                strcat(filnam,"command");
+			strcat(filnam, "\\");
+		strcat(filnam, "command");
 	}
 #endif
 
 #if     VMS
 	mlwrite("Not available under VMS");
-	return(FALSE);
+	return (FALSE);
 #endif
 
 	/* get the command to pipe in */
-        if ((s=mlreply("@", line, NLINE)) != TRUE)
+	if ((s = mlreply("@", line, NLINE)) != TRUE)
-                return(s);
+		return (s);
 
 	/* get rid of the command output buffer if it exists */
-        if ((bp=bfind(bname, FALSE, 0)) != FALSE) {
+	if ((bp = bfind(bname, FALSE, 0)) != FALSE) {
 		/* try to make sure we are off screen */
 		wp = wheadp;
 		while (wp != NULL) {
@@ -320,12 +319,11 @@ pipecmd(f, n)
 		}
 		if (zotbuf(bp) != TRUE)
 
-			return(FALSE);
+			return (FALSE);
 	}
-
 #if     MSDOS
-	strcat(line," >>");
+	strcat(line, " >>");
-	strcat(line,filnam);
+	strcat(line, filnam);
 	movecursor(term.t_nrow, 0);
 	TTkclose();
 	shellprog(line);
@@ -342,8 +340,8 @@ pipecmd(f, n)
 #if     V7 | USG | BSD
 	TTflush();
 	TTclose();		/* stty to old modes    */
-	strcat(line,">");
+	strcat(line, ">");
-	strcat(line,filnam);
+	strcat(line, filnam);
 	system(line);
 	TTopen();
 	TTflush();
@@ -352,15 +350,15 @@ pipecmd(f, n)
 #endif
 
 	if (s != TRUE)
-		return(s);
+		return (s);
 
 	/* split the current window to make room for the command output */
 	if (splitwind(FALSE, 1) == FALSE)
-			return(FALSE);
+		return (FALSE);
 
 	/* and read the stuff in */
 	if (getfile(filnam, FALSE) == FALSE)
-		return(FALSE);
+		return (FALSE);
 
 	/* make this window in VIEW mode, update all mode lines */
 	curwp->w_bufp->b_mode |= MDVIEW;
@@ -372,7 +370,7 @@ pipecmd(f, n)
 
 	/* and get rid of the temporary file */
 	unlink(filnam);
-	return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -380,7 +378,6 @@ pipecmd(f, n)
  * Bound to ^X #
  */
 filter(f, n)
-
 {
 	register int s;		/* return status from CLI */
 	register BUFFER *bp;	/* pointer to buffer to zot */
@@ -393,19 +390,19 @@ filter(f, n)
 
 	/* don't allow this command if restricted */
 	if (restflag)
-		return(resterr());
+		return (resterr());
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 
 #if     VMS
 	mlwrite("Not available under VMS");
-	return(FALSE);
+	return (FALSE);
 #endif
 
 	/* get the filter name and its args */
-        if ((s=mlreply("#", line, NLINE)) != TRUE)
+	if ((s = mlreply("#", line, NLINE)) != TRUE)
-                return(s);
+		return (s);
 
 	/* setup the proper file names */
 	bp = curbp;
@@ -416,11 +413,10 @@ filter(f, n)
 	if (writeout(filnam1) != TRUE) {
 		mlwrite("(Cannot write filter file)");
 		strcpy(bp->b_fname, tmpnam);
-		return(FALSE);
+		return (FALSE);
 	}
-
 #if     MSDOS
-	strcat(line," <fltinp >fltout");
+	strcat(line, " <fltinp >fltout");
 	movecursor(term.t_nrow - 1, 0);
 	TTkclose();
 	shellprog(line);
@@ -433,7 +429,7 @@ filter(f, n)
 	TTputc('\n');		/* Already have '\r'    */
 	TTflush();
 	TTclose();		/* stty to old modes    */
-	strcat(line," <fltinp >fltout");
+	strcat(line, " <fltinp >fltout");
 	system(line);
 	TTopen();
 	TTflush();
@@ -442,12 +438,12 @@ filter(f, n)
 #endif
 
 	/* on failure, escape gracefully */
-	if (s != TRUE || (readin(filnam2,FALSE) == FALSE)) {
+	if (s != TRUE || (readin(filnam2, FALSE) == FALSE)) {
 		mlwrite("(Execution failed)");
 		strcpy(bp->b_fname, tmpnam);
 		unlink(filnam1);
 		unlink(filnam2);
-		return(s);
+		return (s);
 	}
 
 	/* reset file name */
@@ -457,7 +453,7 @@ filter(f, n)
 	/* and get rid of the temporary file */
 	unlink(filnam1);
 	unlink(filnam2);
-	return(TRUE);
+	return (TRUE);
 }
 
 #if     VMS
@@ -478,7 +474,7 @@ register char   *cmd;
 
 	status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
 			  oldmode, sizeof(oldmode), 0, 0, 0, 0);
-        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
+	if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
 		return (FALSE);
 	cdscp = NULL;		/* Assume DCL.          */
 	if (cmd != NULL) {	/* Build descriptor.    */
@@ -493,9 +489,9 @@ register char   *cmd;
 		substatus = status;
 	status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
 			  newmode, sizeof(newmode), 0, 0, 0, 0);
-        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
+	if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
 		return (FALSE);
-        if ((substatus&STS$M_SUCCESS) == 0)     /* Command failed.      */
+	if ((substatus & STS$M_SUCCESS) == 0)	/* Command failed.      */
 		return (FALSE);
 	return (TRUE);
 }
@@ -521,11 +517,11 @@ char *cmd;	/*  Incoming command line to execute  */
 	regs.h.ah = 0x37;	/*  get setting data  */
 	regs.h.al = 0x00;	/*  get switch character  */
 	intdos(&regs, &regs);
-	swchar = (char)regs.h.dl;
+	swchar = (char) regs.h.dl;
 
 	/*  get name of system shell  */
 	if ((shell = getenv("COMSPEC")) == NULL) {
-		return(FALSE);		/*  No shell located  */
+		return (FALSE);	/*  No shell located  */
 	}
 
 	/* trim leading whitespace off the command */
@@ -543,9 +539,9 @@ char *cmd;	/*  Incoming command line to execute  */
 		comline[strlen(comline)] = swchar;
 		strcat(comline, "c ");
 		strcat(comline, cmd);
-		return(execprog(comline));
+		return (execprog(comline));
 	} else
-		return(execprog(shell));
+		return (execprog(shell));
 }
 
 /*	EXECPROG:	A function to execute a named program
@@ -581,16 +577,16 @@ char *cmd;	/*  Incoming command line to execute  */
 	/* and parse out the command tail */
 	while (*cmd && ((*cmd == ' ') || (*cmd == '\t')))
 		++cmd;
-	*tail = (char)(strlen(cmd)); /* record the byte length */
+	*tail = (char) (strlen(cmd));	/* record the byte length */
 	strcpy(&tail[1], cmd);
 	strcat(&tail[1], "\r");
 
 	/* look up the program on the path trying various extentions */
 	if ((sp = flook(prog, TRUE)) == NULL)
 		if ((sp = flook(strcat(prog, ".exe"), TRUE)) == NULL) {
-			strcpy(&prog[strlen(prog)-4], ".com");
+			strcpy(&prog[strlen(prog) - 4], ".com");
 			if ((sp = flook(prog, TRUE)) == NULL)
-				return(FALSE);
+				return (FALSE);
 		}
 	strcpy(prog, sp);
 
@@ -606,10 +602,10 @@ char *cmd;	/*  Incoming command line to execute  */
 	/* and make the call */
 	regs.h.ah = 0x4b;	/* EXEC Load or Execute a Program */
 	regs.h.al = 0x00;	/* load end execute function subcode */
-	segreg.ds = ((unsigned long)(prog) >> 16);	/* program name ptr */
+	segreg.ds = ((unsigned long) (prog) >> 16);	/* program name ptr */
-	regs.x.dx = (unsigned int)(prog);
+	regs.x.dx = (unsigned int) (prog);
-	segreg.es = ((unsigned long)(&pblock) >> 16);	/* set up param block ptr */
+	segreg.es = ((unsigned long) (&pblock) >> 16);	/* set up param block ptr */
-	regs.x.bx = (unsigned int)(&pblock);
+	regs.x.bx = (unsigned int) (&pblock);
 #if	TURBO | MSC
 	intdosx(&regs, &regs, &segreg);
 	if (regs.x.cflag == 0) {
@@ -623,6 +619,6 @@ char *cmd;	/*  Incoming command line to execute  */
 		rval = -_doserrno;	/* failed child call */
 #endif
 #endif
-	return((rval < 0) ? FALSE : TRUE);
+	return ((rval < 0) ? FALSE : TRUE);
 }
 #endif

tcap.c

@@ -107,7 +107,6 @@ TERM term = {
 };
 
 tcapopen()
-
 {
 	char *getenv();
 	char *t, *p, *tgetstr();
@@ -117,37 +116,36 @@ tcapopen()
 	int int_col, int_row;
 
 #if PKCODE && USE_BROKEN_OPTIMIZATION
-	if (! term_init_ok)
+	if (!term_init_ok) {
-	{
 #endif
-        if ((tv_stype = getenv("TERM")) == NULL)
+		if ((tv_stype = getenv("TERM")) == NULL) {
-        {
 			puts("Environment variable TERM not defined!");
 			exit(1);
 		}
 
-        if ((tgetent(tcbuf, tv_stype)) != 1)
+		if ((tgetent(tcbuf, tv_stype)) != 1) {
-        {
+			sprintf(err_str, "Unknown terminal type %s!",
-                sprintf(err_str, "Unknown terminal type %s!", tv_stype);
+				tv_stype);
 			puts(err_str);
 			exit(1);
 		}
 
 		/* Get screen size from system, or else from termcap.  */
 		getscreensize(&int_col, &int_row);
-	term.t_nrow = int_row-1;
+		term.t_nrow = int_row - 1;
 		term.t_ncol = int_col;
 
-       if ((term.t_nrow <= 0) && (term.t_nrow=(short)tgetnum("li")-1) == -1){
+		if ((term.t_nrow <= 0)
+		    && (term.t_nrow = (short) tgetnum("li") - 1) == -1) {
 			puts("termcap entry incomplete (lines)");
 			exit(1);
 		}
 
-       if ((term.t_ncol <= 0) && (term.t_ncol=(short)tgetnum("co")) == -1){
+		if ((term.t_ncol <= 0)
+		    && (term.t_ncol = (short) tgetnum("co")) == -1) {
 			puts("Termcap entry incomplete (columns)");
 			exit(1);
 		}
-
 #ifdef SIGWINCH
 		term.t_mrow = MAXROW;
 		term.t_mcol = MAXCOL;
@@ -157,7 +155,7 @@ tcapopen()
 #endif
 		p = tcapbuf;
 		t = tgetstr("pc", &p);
-        if(t)
+		if (t)
 			PC = *t;
 		else
 			PC = 0;
@@ -180,8 +178,7 @@ tcapopen()
 		TE = tgetstr("te", &p);
 #endif
 
-        if(CL == NULL || CM == NULL || UP == NULL)
+		if (CL == NULL || CM == NULL || UP == NULL) {
-        {
 			puts("Incomplete termcap entry\n");
 			exit(1);
 		}
@@ -206,8 +203,7 @@ tcapopen()
 		}
 #endif
 
-        if (p >= &tcapbuf[TCAPSLEN])
+		if (p >= &tcapbuf[TCAPSLEN]) {
-        {
 			puts("Terminal description too big!\n");
 			exit(1);
 		}
@@ -221,7 +217,6 @@ tcapopen()
 #if	PKCODE
 
 tcapclose()
-
 {
 	putpad(tgoto(CM, 0, term.t_nrow));
 	putpad(TE);
@@ -231,7 +226,6 @@ tcapclose()
 #endif
 
 tcapkopen()
-
 {
 #if	PKCODE
 	putpad(TI);
@@ -241,7 +235,6 @@ tcapkopen()
 }
 
 tcapkclose()
-
 {
 }
 
@@ -261,8 +254,8 @@ tcapeeop()
 	putpad(CL);
 }
 
-tcaprev(state)		/* change reverse video status */
+tcaprev(state)
-
+    /* change reverse video status */
 int state;			/* FALSE = normal video, TRUE = reverse video */
 
 {
@@ -270,32 +263,31 @@ int state;		/* FALSE = normal video, TRUE = reverse video */
 	if (state) {
 		if (SO != NULL)
 			putpad(SO);
-	} else
+	} else if (SE != NULL)
-		if (SE != NULL)
 		putpad(SE);
 }
 
-tcapcres()	/* change screen resolution */
+tcapcres()
-
+{				/* change screen resolution */
-{
+	return (TRUE);
-	return(TRUE);
 }
 
 #if SCROLLCODE
 
 /* move howmanylines lines starting at from to to */
-tcapscroll_reg(from,to,howmanylines)
+tcapscroll_reg(from, to, howmanylines)
 {
 	int i;
-        if (to == from) return;
+	if (to == from)
+		return;
 	if (to < from) {
 		tcapscrollregion(to, from + howmanylines - 1);
-                tcapmove(from + howmanylines - 1,0);
+		tcapmove(from + howmanylines - 1, 0);
 		for (i = from - to; i > 0; i--)
 			putpad(SF);
 	} else {		/* from < to */
 		tcapscrollregion(from, to + howmanylines - 1);
-                tcapmove(from,0);
+		tcapmove(from, 0);
 		for (i = to - from; i > 0; i--)
 			putpad(SR);
 	}
@@ -303,29 +295,30 @@ tcapscroll_reg(from,to,howmanylines)
 }
 
 /* move howmanylines lines starting at from to to */
-tcapscroll_delins(from,to,howmanylines)
+tcapscroll_delins(from, to, howmanylines)
 {
 	int i;
-        if (to == from) return;
+	if (to == from)
+		return;
 	if (to < from) {
-                tcapmove(to,0);
+		tcapmove(to, 0);
 		for (i = from - to; i > 0; i--)
 			putpad(DL);
-                tcapmove(to+howmanylines,0);
+		tcapmove(to + howmanylines, 0);
 		for (i = from - to; i > 0; i--)
 			putpad(AL);
 	} else {
-                tcapmove(from+howmanylines,0);
+		tcapmove(from + howmanylines, 0);
 		for (i = to - from; i > 0; i--)
 			putpad(DL);
-                tcapmove(from,0);
+		tcapmove(from, 0);
 		for (i = to - from; i > 0; i--)
 			putpad(AL);
 	}
 }
 
 /* cs is set up just like cm, so we use tgoto... */
-tcapscrollregion(top,bot)
+tcapscrollregion(top, bot)
 {
 	ttputc(PC);
 	putpad(tgoto(CS, bot, top));
@@ -333,19 +326,18 @@ tcapscrollregion(top,bot)
 
 #endif
 
-spal(dummy)	/* change palette string */
+spal(dummy)
-
+{				/* change palette string */
-{
 	/*      Does nothing here       */
 }
 
 #if	COLOR
-tcapfcol()	/* no colors here, ignore this */
+tcapfcol()
-{
+{				/* no colors here, ignore this */
 }
 
-tcapbcol()	/* no colors here, ignore this */
+tcapbcol()
-{
+{				/* no colors here, ignore this */
 }
 #endif
 
@@ -368,13 +360,13 @@ char    *str;
 
 
 #if	FNLABEL
-fnclabel(f, n)		/* label a function key */
+fnclabel(f, n)
-
+    /* label a function key */
-int f,n;	/* default flag, numeric argument [unused] */
+int f, n;			/* default flag, numeric argument [unused] */
 
 {
 	/* on machines with no function keys...don't bother */
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 #else

termio.c

@@ -64,14 +64,17 @@ struct  sgttyb  nstate;		/* values for editor mode */
 struct tchars otchars;		/* Saved terminal special character set */
 #if	XONXOFF
 struct tchars ntchars = { 0xff, 0xff, 0x11, 0x13, 0xff, 0xff };
+
 				/* A lot of nothing and XON/XOFF */
 #else
 struct tchars ntchars = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+
 				/* A lot of nothing */
 #endif
 #if	BSD & PKCODE
 struct ltchars oltchars;	/* Saved terminal local special character set */
 struct ltchars nltchars = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+
 				/* A lot of nothing */
 #endif
 
@@ -115,7 +118,7 @@ ttopen()
 		odsc.dsc$a_pointer = &oname[0];
 		odsc.dsc$w_length = sizeof(oname);
 		status = LIB$SYS_TRNLOG(&idsc, &odsc.dsc$w_length, &odsc);
-                if (status!=SS$_NORMAL && status!=SS$_NOTRAN)
+		if (status != SS$_NORMAL && status != SS$_NOTRAN)
 			exit(status);
 		if (oname[0] == 0x1B) {
 			odsc.dsc$a_pointer += 4;
@@ -127,21 +130,21 @@ ttopen()
 		exit(status);
 	status = SYS$QIOW(EFN, iochan, IO$_SENSEMODE, iosb, 0, 0,
 			  oldmode, sizeof(oldmode), 0, 0, 0, 0);
-        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
+	if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
 		exit(status);
 	newmode[0] = oldmode[0];
 	newmode[1] = oldmode[1] | TT$M_NOECHO;
 #if	XONXOFF
 #else
-        newmode[1] &= ~(TT$M_TTSYNC|TT$M_HOSTSYNC);
+	newmode[1] &= ~(TT$M_TTSYNC | TT$M_HOSTSYNC);
 #endif
 	newmode[2] = oldmode[2] | TT2$M_PASTHRU;
 	status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
 			  newmode, sizeof(newmode), 0, 0, 0, 0);
-        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
+	if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
 		exit(status);
-        term.t_nrow = (newmode[1]>>24) - 1;
+	term.t_nrow = (newmode[1] >> 24) - 1;
-        term.t_ncol = newmode[0]>>16;
+	term.t_ncol = newmode[0] >> 16;
 
 #endif
 
@@ -170,7 +173,7 @@ ttopen()
 #else
 	ioctl(0, TCSETA, &ntermio);	/* and activate them */
 #endif
-	kbdflgs = fcntl( 0, F_GETFL, 0 );
+	kbdflgs = fcntl(0, F_GETFL, 0);
 	kbdpoll = FALSE;
 #endif
 
@@ -178,11 +181,11 @@ ttopen()
 	gtty(0, &ostate);	/* save old state */
 	gtty(0, &nstate);	/* get base of new state */
 #if	XONXOFF
-	nstate.sg_flags |= (CBREAK|TANDEM);
+	nstate.sg_flags |= (CBREAK | TANDEM);
 #else
 	nstate.sg_flags |= RAW;
 #endif
-        nstate.sg_flags &= ~(ECHO|CRMOD);       /* no echo for now... */
+	nstate.sg_flags &= ~(ECHO | CRMOD);	/* no echo for now... */
 	stty(0, &nstate);	/* set mode */
 	ioctl(0, TIOCGETC, &otchars);	/* Save old characters */
 	ioctl(0, TIOCSETC, &ntchars);	/* Place new character into K */
@@ -194,8 +197,8 @@ ttopen()
 	/* provide a smaller terminal output buffer so that
 	   the type ahead detection works better (more often) */
 	setbuffer(stdout, &tobuf[0], TBUFSIZ);
-	signal(SIGTSTP,SIG_DFL);	/* set signals so that we can */
+	signal(SIGTSTP, SIG_DFL);	/* set signals so that we can */
-	signal(SIGCONT,rtfrmshell);	/* suspend & restart emacs */
+	signal(SIGCONT, rtfrmshell);	/* suspend & restart emacs */
 #endif
 #endif
 
@@ -203,8 +206,8 @@ ttopen()
 	/* provide a smaller terminal output buffer so that
 	   the type ahead detection works better (more often) */
 	setvbuf(stdout, &tobuf[0], _IOFBF, TBUFSIZ);
-        signal(SIGTSTP,SIG_DFL);        /* set signals so that we can */
+	signal(SIGTSTP, SIG_DFL);	/* set signals so that we can */
-        signal(SIGCONT,rtfrmshell);     /* suspend & restart emacs */
+	signal(SIGCONT, rtfrmshell);	/* suspend & restart emacs */
 	TTflush();
 #endif				/* __hpux */
 
@@ -228,7 +231,7 @@ ttclose()
 	ttflush();
 	status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
 			  oldmode, sizeof(oldmode), 0, 0, 0, 0);
-        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
+	if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
 		exit(status);
 	status = SYS$DASSGN(iochan);
 	if (status != SS$_NORMAL)
@@ -295,7 +298,8 @@ ttflush()
 
 	status = SS$_NORMAL;
 	if (nobuf != 0) {
-                status = SYS$QIOW(EFN, iochan, IO$_WRITELBLK|IO$M_NOFORMAT,
+		status =
+		    SYS$QIOW(EFN, iochan, IO$_WRITELBLK | IO$M_NOFORMAT,
 			     iosb, 0, 0, obuf, nobuf, 0, 0, 0, 0);
 		if (status == SS$_NORMAL)
 			status = iosb[0] & 0xFFFF;
@@ -346,23 +350,24 @@ ttgetc()
 		ibufi = 0;
 		term[0] = 0;
 		term[1] = 0;
-                status = SYS$QIOW(EFN, iochan, IO$_READLBLK|IO$M_TIMED,
+		status = SYS$QIOW(EFN, iochan, IO$_READLBLK | IO$M_TIMED,
 				  iosb, 0, 0, ibuf, NIBUF, 0, term, 0, 0);
 		if (status != SS$_NORMAL)
 			exit(status);
 		status = iosb[0] & 0xFFFF;
-		if (status!=SS$_NORMAL && status!=SS$_TIMEOUT &&
+		if (status != SS$_NORMAL && status != SS$_TIMEOUT &&
-					  status!=SS$_DATAOVERUN)
+		    status != SS$_DATAOVERUN)
 			exit(status);
-                nibuf = (iosb[0]>>16) + (iosb[1]>>16);
+		nibuf = (iosb[0] >> 16) + (iosb[1] >> 16);
 		if (nibuf == 0) {
 			status = SYS$QIOW(EFN, iochan, IO$_READLBLK,
-                                 iosb, 0, 0, ibuf, 1, 0, term, 0, 0);
+					  iosb, 0, 0, ibuf, 1, 0, term, 0,
+					  0);
 			if (status != SS$_NORMAL
-                        || (status = (iosb[0]&0xFFFF)) != SS$_NORMAL)
+			    || (status = (iosb[0] & 0xFFFF)) != SS$_NORMAL)
 				if (status != SS$_DATAOVERUN)
 					exit(status);
-                        nibuf = (iosb[0]>>16) + (iosb[1]>>16);
+			nibuf = (iosb[0] >> 16) + (iosb[1] >> 16);
 		}
 	}
 	return (ibuf[ibufi++] & 0xFF);	/* Allow multinational  */
@@ -375,32 +380,30 @@ ttgetc()
 	if (nxtchar >= 0) {
 		c = nxtchar;
 		nxtchar = -1;
-		return(c);
+		return (c);
 	}
 
 	/* call the dos to get a char */
 	rg.h.ah = 7;		/* dos Direct Console Input call */
 	intdos(&rg, &rg);
 	c = rg.h.al;		/* grab the char */
-	return(c & 255);
+	return (c & 255);
 #endif
 
 #if     V7 | BSD
-        return(255 & fgetc(stdin)); /* 8BIT P.K. */
+	return (255 & fgetc(stdin));	/* 8BIT P.K. */
 #endif
 
 #if	USG
-	if( kbdqp )
+	if (kbdqp)
 		kbdqp = FALSE;
-	else
+	else {
-	{
+		if (kbdpoll && fcntl(0, F_SETFL, kbdflgs) < 0)
-		if( kbdpoll && fcntl( 0, F_SETFL, kbdflgs ) < 0 )
 			return FALSE;
 		kbdpoll = FALSE;
-		while (read(0, &kbdq, 1) != 1)
+		while (read(0, &kbdq, 1) != 1);
-			;
 	}
-	return ( kbdq & 255 );
+	return (kbdq & 255);
 #endif
 }
 
@@ -410,40 +413,38 @@ ttgetc()
 */
 
 typahead()
-
 {
 #if	MSDOS & (MSC | TURBO)
 	if (kbhit() != 0)
-		return(TRUE);
+		return (TRUE);
 	else
-		return(FALSE);
+		return (FALSE);
 #endif
 
 #if	BSD
 	int x;			/* holds # of pending chars */
 
-	return((ioctl(0,FIONREAD,&x) < 0) ? 0 : x);
+	return ((ioctl(0, FIONREAD, &x) < 0) ? 0 : x);
 #endif
 
 #if	PKCODE & VMS
-	return(ibufi < nibuf);
+	return (ibufi < nibuf);
 #endif
 
 #if	USG
-	if( !kbdqp )
+	if (!kbdqp) {
-	{
+		if (!kbdpoll && fcntl(0, F_SETFL, kbdflgs | O_NDELAY) < 0)
-		if( !kbdpoll && fcntl( 0, F_SETFL, kbdflgs | O_NDELAY ) < 0 )
+			return (FALSE);
-			return(FALSE);
 #if	PKCODE
 		kbdpoll = 1;
 #endif
-		kbdqp = (1 == read( 0, &kbdq, 1 ));
+		kbdqp = (1 == read(0, &kbdq, 1));
 	}
-	return ( kbdqp );
+	return (kbdqp);
 #endif
 
 #if !UNIX & !VMS & !MSDOS
-	return(FALSE);
+	return (FALSE);
 #endif
 }
 #endif

vmsvt.c

@@ -34,8 +34,8 @@ int vmsfcol(), vmsbcol();
 #endif
 
 /** SMG stuff **/
-static char * begin_reverse, * end_reverse, * erase_to_end_line;
+static char *begin_reverse, *end_reverse, *erase_to_end_line;
-static char * erase_whole_display;
+static char *erase_whole_display;
 static int termtype;
 
 #define SMG$K_BEGIN_REVERSE		0x1bf
@@ -61,10 +61,12 @@ TERM	term	= {
 #else
 	24 - 1,			/* Max number of rows allowable */
 #endif
-	/* Filled in */ - 1,		/* Current number of rows used	*/
+				/* Filled in */ -1,
+				/* Current number of rows used  */
 	MAXCOL,			/* Max number of columns        */
-	/* Filled in */ 0,		/* Current number of columns	*/
+				/* Filled in */ 0,
-	64,				/* Min margin for extended lines*/
+				/* Current number of columns    */
+	64,			/* Min margin for extended lines */
 	8,			/* Size of scroll region        */
 	100,			/* # times thru update to pause */
 	vmsopen,		/* Open terminal at the start   */
@@ -95,7 +97,7 @@ TERM	term	= {
  *  Nothing returned
  ***/
 ttputs(string)
-char * string;				/* String to write		*/
+char *string;			/* String to write              */
 {
 	if (string)
 		while (*string != '\0')
@@ -117,7 +119,7 @@ int col;				/* Column position		*/
 	static int request_code = SMG$K_SET_CURSOR_ABS;
 	static int max_buffer_length = sizeof(buffer);
 	static int arg_list[3] = { 2 };
-	register char * cp;
+	register char *cp;
 
 	register int i;
 
@@ -133,10 +135,11 @@ int col;				/* Column position		*/
 				      &max_buffer_length,	/* Maximum buffer length        */
 				      &ret_length,	/* Return length                */
 				      buffer,	/* Capability data buffer       */
-		arg_list)		/* Argument list array		*/
+				      arg_list)
 
+	     /* Argument list array              */
 	     /* We'll know soon enough if this doesn't work         */
-			& 1) == 0) {
+	     &1) == 0) {
 		ttputs("OOPS");
 		return;
 	}
@@ -150,18 +153,19 @@ int col;				/* Column position		*/
 
 #if SCROLLCODE
 
-vmsscroll_reg(from,to,howmany)
+vmsscroll_reg(from, to, howmany)
 {
 	int i;
-        if (to == from) return;
+	if (to == from)
+		return;
 	if (to < from) {
 		vmsscrollregion(to, from + howmany - 1);
-                vmsmove(from + howmany - 1,0);
+		vmsmove(from + howmany - 1, 0);
 		for (i = from - to; i > 0; i--)
 			ttputs(scroll_forward);
 	} else {		/* from < to */
 		vmsscrollregion(from, to + howmany - 1);
-                vmsmove(from,0);
+		vmsmove(from, 0);
 		for (i = to - from; i > 0; i--)
 			ttputs(scroll_reverse);
 	}
@@ -177,7 +181,7 @@ int bot;				/* Bottom position		*/
 	static int request_code = SMG$K_SET_SCROLL_REGION;
 	static int max_buffer_length = sizeof(buffer);
 	static int arg_list[3] = { 2 };
-	register char * cp;
+	register char *cp;
 
 	register int i;
 
@@ -193,10 +197,11 @@ int bot;				/* Bottom position		*/
 				      &max_buffer_length,	/* Maximum buffer length        */
 				      &ret_length,	/* Return length                */
 				      buffer,	/* Capability data buffer       */
-		arg_list)		/* Argument list array		*/
+				      arg_list)
 
+	     /* Argument list array              */
 	     /* We'll know soon enough if this doesn't work         */
-			& 1) == 0) {
+	     &1) == 0) {
 		ttputs("OOPS");
 		return;
 	}
@@ -295,12 +300,12 @@ vmsbeep()
  *  Returns:	Escape sequence
  *		NULL	No escape sequence available
  ***/
-char * vmsgetstr(request_code)
+char *vmsgetstr(request_code)
 int request_code;		/* Request code                 */
 {
-	register char * result;
+	register char *result;
 	static char seq_storage[1024];
-	static char * buffer = seq_storage;
+	static char *buffer = seq_storage;
 	static int arg_list[2] = { 1, 1 };
 	int max_buffer_length, ret_length;
 
@@ -313,25 +318,25 @@ int request_code;			/* Request code			*/
 	if ((smg$get_term_data(	/* Get terminal data            */
 				      &termtype,	/* Terminal table address       */
 				      &request_code,	/* Request code                 */
-		&max_buffer_length,/* Maximum buffer length	*/
+				      &max_buffer_length,	/* Maximum buffer length     */
 				      &ret_length,	/* Return length                */
 				      buffer,	/* Capability data buffer       */
-		arg_list)	/* Argument list array		*/
+				      arg_list)
 
+
+	     /* Argument list array              */
 	     /* If this doesn't work, try again with no arguments */
-	
+	     &1) == 0 && (smg$get_term_data(	/* Get terminal data            */
-		& 1) == 0 && 
-
-		(smg$get_term_data(	/* Get terminal data		*/
 						   &termtype,	/* Terminal table address       */
 						   &request_code,	/* Request code                 */
-			&max_buffer_length,/* Maximum buffer length	*/
+						   &max_buffer_length,	/* Maximum buffer length     */
 						   &ret_length,	/* Return length                */
-			buffer)		/* Capability data buffer	*/
+						   buffer)
 
+
+			  /* Capability data buffer   */
 			  /* Return NULL pointer if capability is not available */
-
+			  &1) == 0)
-			& 1) == 0)
 		return NULL;
 
 	/* Check for empty result */
@@ -385,7 +390,7 @@ vmsgtty()
 	/* Assign input to a channel */
 	status = sys$assign(&devnam, &fd, 0, 0);
 	if ((status & 1) == 0)
-		exit (status);
+		exit(status);
 
 	/* Get terminal characteristics */
 	status = sys$qiow(	/* Queue and wait               */
@@ -421,7 +426,8 @@ vmsopen()
 	vmsgtty();
 	if (tc.t_type == TT$_UNKNOWN) {
 		printf("Terminal type is unknown!\n");
-		printf("Try set your terminal type with SET TERMINAL/INQUIRE\n");
+		printf
+		    ("Try set your terminal type with SET TERMINAL/INQUIRE\n");
 		printf("Or get help on SET TERMINAL/DEVICE_TYPE\n");
 		exit(3);
 	}
@@ -488,10 +494,10 @@ vmskclose()
  ***/
 #if	FNLABEL
 fnclabel(f, n)			/* label a function key */
-int f,n;	/* default flag, numeric argument [unused] */
+int f, n;			/* default flag, numeric argument [unused] */
 {
 	/* on machines with no function keys...don't bother */
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 

vt52.c

@@ -54,8 +54,8 @@ extern	int	vt52bcol();
  * terminal I/O code.
  */
 TERM term = {
-	NROW-1,
+	NROW - 1,
-        NROW-1,
+	NROW - 1,
 	NCOL,
 	NCOL,
 	MARGIN,
@@ -87,8 +87,8 @@ vt52move(row, col)
 {
 	ttputc(ESC);
 	ttputc('Y');
-        ttputc(row+BIAS);
+	ttputc(row + BIAS);
-        ttputc(col+BIAS);
+	ttputc(col + BIAS);
 }
 
 vt52eeol()
@@ -103,33 +103,31 @@ vt52eeop()
 	ttputc('J');
 }
 
-vt52rev(status)	/* set the reverse video state */
+vt52rev(status)
-
+    /* set the reverse video state */
 int status;			/* TRUE = reverse video, FALSE = normal video */
 
 {
 	/* can't do this here, so we won't */
 }
 
-vt52cres()	/* change screen resolution - (not here though) */
+vt52cres()
-
+{				/* change screen resolution - (not here though) */
-{
+	return (TRUE);
-	return(TRUE);
 }
 
-spal()		/* change palette string */
+spal()
-
+{				/* change palette string */
-{
 	/*      Does nothing here       */
 }
 
 #if	COLOR
-vt52fcol()	/* set the forground color [NOT IMPLIMENTED] */
+vt52fcol()
-{
+{				/* set the forground color [NOT IMPLIMENTED] */
 }
 
-vt52bcol()	/* set the background color [NOT IMPLIMENTED] */
+vt52bcol()
-{
+{				/* set the background color [NOT IMPLIMENTED] */
 }
 #endif
 
@@ -160,30 +158,27 @@ vt52open()
 }
 
 vt52kopen()
-
 {
 }
 
 vt52kclose()
-
 {
 }
 
 
 #if	FNLABEL
-fnclabel(f, n)		/* label a function key */
+fnclabel(f, n)
-
+    /* label a function key */
-int f,n;	/* default flag, numeric argument [unused] */
+int f, n;			/* default flag, numeric argument [unused] */
 
 {
 	/* on machines with no function keys...don't bother */
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 #else
 
 vt52hello()
-
 {
 }
 

window.c

@@ -16,30 +16,29 @@
  * redisplay code does). With no argument it defaults to 0. Bound to M-!.
  */
 reposition(f, n)
-    {
+{
 	if (f == FALSE)		/* default to 0 to center screen */
 		n = 0;
 	curwp->w_force = n;
 	curwp->w_flag |= WFFORCE;
 	return (TRUE);
-    }
+}
 
 /*
  * 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)
-    {
+{
 	if (f == FALSE)
 		sgarbf = TRUE;
-    else
+	else {
-        {
 		curwp->w_force = 0;	/* Center dot. */
 		curwp->w_flag |= WFFORCE;
 	}
 
 	return (TRUE);
-    }
+}
 
 /*
  * The command make the next window (next => down the screen) the current
@@ -79,10 +78,9 @@ int f, n;	/* default flag and numeric argument */
 				wp = wp->w_wndp;
 		} else {
 			mlwrite("Window number out of range");
-			return(FALSE);
+			return (FALSE);
 		}
-	} else
+	} else if ((wp = curwp->w_wndp) == NULL)
-		if ((wp = curwp->w_wndp) == NULL)
 		wp = wheadp;
 	curwp = wp;
 	curbp = wp->w_bufp;
@@ -103,7 +101,7 @@ prevwind(f, n)
 
 	/* if we have an argument, we mean the nth window from the bottom */
 	if (f)
-		return(nextwind(f, -n));
+		return (nextwind(f, -n));
 
 	wp1 = wheadp;
 	wp2 = curwp;
@@ -144,30 +142,26 @@ int n;
  * "C-X C-P".
  */
 mvupwind(f, n)
-    int n;
+int n;
 
-    {
+{
 	register LINE *lp;
 	register int i;
 
 	lp = curwp->w_linep;
 
-    if (n < 0)
+	if (n < 0) {
-        {
+		while (n++ && lp != curbp->b_linep)
-        while (n++ && lp!=curbp->b_linep)
 			lp = lforw(lp);
-        }
+	} else {
-    else
+		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;	/* Mode line is OK. */
 
-    for (i = 0; i < curwp->w_ntrows; ++i)
+	for (i = 0; i < curwp->w_ntrows; ++i) {
-        {
 		if (lp == curwp->w_dotp)
 			return (TRUE);
 		if (lp == curbp->b_linep)
@@ -176,7 +170,7 @@ mvupwind(f, n)
 	}
 
 	lp = curwp->w_linep;
-    i  = curwp->w_ntrows/2;
+	i = curwp->w_ntrows / 2;
 
 	while (i-- && lp != curbp->b_linep)
 		lp = lforw(lp);
@@ -184,7 +178,7 @@ mvupwind(f, n)
 	curwp->w_dotp = lp;
 	curwp->w_doto = 0;
 	return (TRUE);
-    }
+}
 
 /*
  * This command makes the current window the only window on the screen. Bound
@@ -223,14 +217,14 @@ onlywind(f, n)
 	}
 	lp = curwp->w_linep;
 	i = curwp->w_toprow;
-        while (i!=0 && lback(lp)!=curbp->b_linep) {
+	while (i != 0 && lback(lp) != curbp->b_linep) {
 		--i;
 		lp = lback(lp);
 	}
 	curwp->w_toprow = 0;
-        curwp->w_ntrows = term.t_nrow-1;
+	curwp->w_ntrows = term.t_nrow - 1;
 	curwp->w_linep = lp;
-        curwp->w_flag  |= WFMODE|WFHARD;
+	curwp->w_flag |= WFMODE | WFHARD;
 	return (TRUE);
 }
 
@@ -239,7 +233,7 @@ onlywind(f, n)
  * or, if it is the top window, the window below. Bound to C-X 0.
  */
 
-delwind(f,n)
+delwind(f, n)
 
 int f, n;			/* arguments are ignored for this command */
 
@@ -251,7 +245,7 @@ int f, n;	/* arguments are ignored for this command */
 	/* if there is only one window, don't delete it */
 	if (wheadp->w_wndp == NULL) {
 		mlwrite("Can not delete this window");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* find window before curwp in linked list */
@@ -275,7 +269,7 @@ int f, n;	/* arguments are ignored for this command */
 			wp = wp->w_wndp;
 		}
 		if (wp == NULL)
-			return(FALSE);
+			return (FALSE);
 		wp->w_toprow = 0;
 		wp->w_ntrows += target;
 	} else {
@@ -287,7 +281,7 @@ int f, n;	/* arguments are ignored for this command */
 			wp = wp->w_wndp;
 		}
 		if (wp == NULL)
-			return(FALSE);
+			return (FALSE);
 		wp->w_ntrows += 1 + curwp->w_ntrows;
 	}
 
@@ -302,13 +296,13 @@ int f, n;	/* arguments are ignored for this command */
 		wheadp = curwp->w_wndp;
 	else
 		lwp->w_wndp = curwp->w_wndp;
-	free((char *)curwp);
+	free((char *) curwp);
 	curwp = wp;
 	wp->w_flag |= WFHARD;
 	curbp = wp->w_bufp;
 	cknewwindow();
 	upmode();
-	return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -355,8 +349,8 @@ int f, n;	/* default flag and numeric argument */
 	wp->w_fcolor = gfcolor;
 	wp->w_bcolor = gbcolor;
 #endif
-        ntru = (curwp->w_ntrows-1) / 2;         /* Upper size           */
+	ntru = (curwp->w_ntrows - 1) / 2;	/* Upper size           */
-        ntrl = (curwp->w_ntrows-1) - ntru;      /* Lower size           */
+	ntrl = (curwp->w_ntrows - 1) - ntru;	/* Lower size           */
 	lp = curwp->w_linep;
 	ntrd = 0;
 	while (lp != curwp->w_dotp) {
@@ -371,7 +365,7 @@ int f, n;	/* default flag and numeric argument */
 		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  */
 		wp1 = NULL;
@@ -395,8 +389,8 @@ int f, n;	/* default flag and numeric argument */
 	}
 	curwp->w_linep = lp;	/* Adjust the top lines */
 	wp->w_linep = lp;	/* if necessary.        */
-        curwp->w_flag |= WFMODE|WFHARD;
+	curwp->w_flag |= WFMODE | WFHARD;
-        wp->w_flag |= WFMODE|WFHARD;
+	wp->w_flag |= WFMODE | WFHARD;
 	return (TRUE);
 }
 
@@ -418,7 +412,7 @@ enlargewind(f, n)
 		mlwrite("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;
@@ -429,13 +423,13 @@ enlargewind(f, n)
 	}
 	if (curwp->w_wndp == adjwp) {	/* Shrink below.        */
 		lp = adjwp->w_linep;
-                for (i=0; i<n && lp!=adjwp->w_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_toprow += n;
 	} else {		/* Shrink above.        */
 		lp = curwp->w_linep;
-                for (i=0; i<n && lback(lp)!=curbp->b_linep; ++i)
+		for (i = 0; i < n && lback(lp) != curbp->b_linep; ++i)
 			lp = lback(lp);
 		curwp->w_linep = lp;
 		curwp->w_toprow -= n;
@@ -443,11 +437,11 @@ enlargewind(f, n)
 	curwp->w_ntrows += n;
 	adjwp->w_ntrows -= n;
 #if	SCROLLCODE
-        curwp->w_flag |= WFMODE|WFHARD|WFINS;
+	curwp->w_flag |= WFMODE | WFHARD | WFINS;
-        adjwp->w_flag |= WFMODE|WFHARD|WFKILLS;
+	adjwp->w_flag |= WFMODE | WFHARD | WFKILLS;
 #else
-        curwp->w_flag |= WFMODE|WFHARD;
+	curwp->w_flag |= WFMODE | WFHARD;
-        adjwp->w_flag |= WFMODE|WFHARD;
+	adjwp->w_flag |= WFMODE | WFHARD;
 #endif
 	return (TRUE);
 }
@@ -469,7 +463,7 @@ shrinkwind(f, n)
 		mlwrite("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;
@@ -480,13 +474,14 @@ shrinkwind(f, n)
 	}
 	if (curwp->w_wndp == adjwp) {	/* Grow below.          */
 		lp = adjwp->w_linep;
-                for (i=0; i<n && lback(lp)!=adjwp->w_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_toprow -= n;
 	} else {		/* Grow above.          */
 		lp = curwp->w_linep;
-                for (i=0; i<n && lp!=curbp->b_linep; ++i)
+		for (i = 0; i < n && lp != curbp->b_linep; ++i)
 			lp = lforw(lp);
 		curwp->w_linep = lp;
 		curwp->w_toprow += n;
@@ -494,11 +489,11 @@ shrinkwind(f, n)
 	curwp->w_ntrows -= n;
 	adjwp->w_ntrows += n;
 #if	SCROLLCODE
-        curwp->w_flag |= WFMODE|WFHARD|WFKILLS;
+	curwp->w_flag |= WFMODE | WFHARD | WFKILLS;
-        adjwp->w_flag |= WFMODE|WFHARD|WFINS;
+	adjwp->w_flag |= WFMODE | WFHARD | WFINS;
 #else
-        curwp->w_flag |= WFMODE|WFHARD;
+	curwp->w_flag |= WFMODE | WFHARD;
-        adjwp->w_flag |= WFMODE|WFHARD;
+	adjwp->w_flag |= WFMODE | WFHARD;
 #endif
 	return (TRUE);
 }
@@ -514,16 +509,16 @@ int f, n;	/* default flag and numeric argument */
 
 	/* must have a non-default argument, else ignore call */
 	if (f == FALSE)
-		return(TRUE);
+		return (TRUE);
 
 	/* find out what to do */
 	clines = curwp->w_ntrows;
 
 	/* already the right size? */
 	if (clines == n)
-		return(TRUE);
+		return (TRUE);
 
-	return(enlargewind(TRUE, n - clines));
+	return (enlargewind(TRUE, n - clines));
 }
 
 /*
@@ -531,8 +526,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  *
+WINDOW *wpopup()
-wpopup()
 {
 	register WINDOW *wp;
 
@@ -540,37 +534,33 @@ wpopup()
 	    && splitwind(FALSE, 0) == FALSE)	/* and it won't split   */
 		return (NULL);
 	wp = wheadp;		/* Find window to use   */
-        while (wp!=NULL && wp==curwp)
+	while (wp != NULL && wp == curwp)
 		wp = wp->w_wndp;
 	return (wp);
 }
 
-scrnextup(f, n)		/* scroll the next window up (back) a page */
+scrnextup(f, n)
-
+{				/* scroll the next window up (back) a page */
-{
 	nextwind(FALSE, 1);
 	backpage(f, n);
 	prevwind(FALSE, 1);
 }
 
-scrnextdw(f, n)		/* scroll the next window down (forward) a page */
+scrnextdw(f, n)
-
+{				/* scroll the next window down (forward) a page */
-{
 	nextwind(FALSE, 1);
 	forwpage(f, n);
 	prevwind(FALSE, 1);
 }
 
-savewnd(f, n)		/* save ptr to current window */
+savewnd(f, n)
-
+{				/* save ptr to current window */
-{
 	swindow = curwp;
-	return(TRUE);
+	return (TRUE);
 }
 
-restwnd(f, n)		/* restore the saved screen */
+restwnd(f, n)
-
+{				/* restore the saved screen */
-{
 	register WINDOW *wp;
 
 	/* find the window */
@@ -586,11 +576,11 @@ restwnd(f, n)		/* restore the saved screen */
 	}
 
 	mlwrite("(No such window exists)");
-	return(FALSE);
+	return (FALSE);
 }
 
-newsize(f, n)	/* resize the screen, re-writing the screen */
+newsize(f, n)
-
+    /* resize the screen, re-writing the screen */
 int f;				/* default flag */
 int n;				/* numeric argument */
 
@@ -607,11 +597,11 @@ int n;	/* numeric argument */
 	/* make sure it's in range */
 	if (n < 3 || n > term.t_mrow + 1) {
 		mlwrite("%%Screen size out of range");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	if (term.t_nrow == n - 1)
-		return(TRUE);
+		return (TRUE);
 	else if (term.t_nrow < n - 1) {
 
 		/* go to the last window */
@@ -621,7 +611,7 @@ int n;	/* numeric argument */
 
 		/* and enlarge it as needed */
 		wp->w_ntrows = n - wp->w_toprow - 2;
-		wp->w_flag |= WFHARD|WFMODE;
+		wp->w_flag |= WFHARD | WFMODE;
 
 	} else {
 
@@ -652,15 +642,16 @@ int n;	/* numeric argument */
 					lastwp->w_wndp = NULL;
 
 				/* free the structure */
-				free((char *)wp);
+				free((char *) wp);
 				wp = NULL;
 
 			} else {
 				/* need to change this window size? */
 				lastline = wp->w_toprow + wp->w_ntrows - 1;
 				if (lastline >= n - 2) {
-					wp->w_ntrows = n - wp->w_toprow - 2;
+					wp->w_ntrows =
-					wp->w_flag |= WFHARD|WFMODE;
+					    n - wp->w_toprow - 2;
+					wp->w_flag |= WFHARD | WFMODE;
 				}
 			}
 
@@ -671,11 +662,11 @@ int n;	/* numeric argument */
 	/* screen is garbage */
 	term.t_nrow = n - 1;
 	sgarbf = TRUE;
-	return(TRUE);
+	return (TRUE);
 }
 
-newwidth(f, n)	/* resize the screen, re-writing the screen */
+newwidth(f, n)
-
+    /* resize the screen, re-writing the screen */
 int f;				/* default flag */
 int n;				/* numeric argument */
 
@@ -689,7 +680,7 @@ int n;	/* numeric argument */
 	/* make sure it's in range */
 	if (n < 10 || n > term.t_mcol) {
 		mlwrite("%%Screen width out of range");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* otherwise, just re-width it (no big deal) */
@@ -705,12 +696,11 @@ int n;	/* numeric argument */
 	}
 	sgarbf = TRUE;
 
-	return(TRUE);
+	return (TRUE);
 }
 
-int getwpos()	/* get screen offset of current line in current window */
+int getwpos()
-
+{				/* get screen offset of current line in current window */
-{
 	register int sline;	/* screen line from top of window */
 	register LINE *lp;	/* scannile line pointer */
 
@@ -723,11 +713,10 @@ int getwpos()	/* get screen offset of current line in current window */
 	}
 
 	/* and return the value */
-	return(sline);
+	return (sline);
 }
 
 cknewwindow()
 {
-	execute(META|SPEC|'X', FALSE, 1);
+	execute(META | SPEC | 'X', FALSE, 1);
 }
-

word.c

@@ -29,7 +29,7 @@ int n;		/* numeric argument */
 
 	/* backup from the <NL> 1 char */
 	if (!backchar(0, 1))
-		return(FALSE);
+		return (FALSE);
 
 	/* back up until we aren't in a word,
 	   make sure there is a break in the line */
@@ -38,28 +38,28 @@ int n;		/* numeric argument */
 	       && (c != '\t')) {
 		cnt++;
 		if (!backchar(0, 1))
-			return(FALSE);
+			return (FALSE);
 		/* if we make it to the beginning, start a new line */
 		if (curwp->w_doto == 0) {
 			gotoeol(FALSE, 0);
-			return(lnewline());
+			return (lnewline());
 		}
 	}
 
 	/* delete the forward white space */
 	if (!forwdel(0, 1))
-		return(FALSE);
+		return (FALSE);
 
 	/* put in a end of line */
 	if (!lnewline())
-		return(FALSE);
+		return (FALSE);
 
 	/* and past the first word */
 	while (cnt-- > 0) {
 		if (forwchar(FALSE, 1) == FALSE)
-			return(FALSE);
+			return (FALSE);
 	}
-	return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -105,7 +105,7 @@ forwword(f, n)
 				return (FALSE);
 		}
 	}
-	return(TRUE);
+	return (TRUE);
 }
 
 /*
@@ -117,8 +117,8 @@ upperword(f, n)
 {
 	register int c;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (FALSE);
 	while (n--) {
@@ -131,9 +131,9 @@ upperword(f, n)
 #if	PKCODE
 			if (islower(c)) {
 #else
-			if (c>='a' && c<='z') {
+			if (c >= 'a' && c <= 'z') {
 #endif
-				c -= 'a'-'A';
+				c -= 'a' - 'A';
 				lputc(curwp->w_dotp, curwp->w_doto, c);
 				lchange(WFHARD);
 			}
@@ -153,8 +153,8 @@ lowerword(f, n)
 {
 	register int c;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (FALSE);
 	while (n--) {
@@ -167,9 +167,9 @@ lowerword(f, n)
 #if	PKCODE
 			if (isupper(c)) {
 #else
-			if (c>='A' && c<='Z') {
+			if (c >= 'A' && c <= 'Z') {
 #endif
-				c += 'a'-'A';
+				c += 'a' - 'A';
 				lputc(curwp->w_dotp, curwp->w_doto, c);
 				lchange(WFHARD);
 			}
@@ -190,8 +190,8 @@ capword(f, n)
 {
 	register int c;
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (n < 0)
 		return (FALSE);
 	while (n--) {
@@ -204,9 +204,9 @@ capword(f, n)
 #if	PKCODE
 			if (islower(c)) {
 #else
-			if (c>='a' && c<='z') {
+			if (c >= 'a' && c <= 'z') {
 #endif
-				c -= 'a'-'A';
+				c -= 'a' - 'A';
 				lputc(curwp->w_dotp, curwp->w_doto, c);
 				lchange(WFHARD);
 			}
@@ -217,10 +217,11 @@ capword(f, n)
 #if	PKCODE
 				if (isupper(c)) {
 #else
-				if (c>='A' && c<='Z') {
+				if (c >= 'A' && c <= 'Z') {
 #endif
-					c += 'a'-'A';
+					c += 'a' - 'A';
-					lputc(curwp->w_dotp, curwp->w_doto, c);
+					lputc(curwp->w_dotp, curwp->w_doto,
+					      c);
 					lchange(WFHARD);
 				}
 				if (forwchar(FALSE, 1) == FALSE)
@@ -245,15 +246,15 @@ delfword(f, n)
 	long size;		/* # of chars to delete */
 
 	/* don't allow this command if we are in read only mode */
-	if (curbp->b_mode&MDVIEW)
+	if (curbp->b_mode & MDVIEW)
-		return(rdonly());
+		return (rdonly());
 
 	/* ignore the command if there is a negative argument */
 	if (n < 0)
 		return (FALSE);
 
 	/* Clear the kill buffer if last command wasn't a kill */
-	if ((lastflag&CFKILL) == 0)
+	if ((lastflag & CFKILL) == 0)
 		kdelete();
 	thisflag |= CFKILL;	/* this command is a kill */
 
@@ -267,7 +268,7 @@ delfword(f, n)
 	/* get us into a word.... */
 	while (inword() == FALSE) {
 		if (forwchar(FALSE, 1) == FALSE)
-			return(FALSE);
+			return (FALSE);
 		++size;
 	}
 
@@ -275,7 +276,7 @@ delfword(f, n)
 		/* skip one word, no whitespace! */
 		while (inword() == TRUE) {
 			if (forwchar(FALSE, 1) == FALSE)
-				return(FALSE);
+				return (FALSE);
 			++size;
 		}
 	} else {
@@ -285,14 +286,14 @@ delfword(f, n)
 			/* if we are at EOL; skip to the beginning of the next */
 			while (curwp->w_doto == llength(curwp->w_dotp)) {
 				if (forwchar(FALSE, 1) == FALSE)
-					return(FALSE);
+					return (FALSE);
 				++size;
 			}
 
 			/* move forward till we are at the end of the word */
 			while (inword() == TRUE) {
 				if (forwchar(FALSE, 1) == FALSE)
-					return(FALSE);
+					return (FALSE);
 				++size;
 			}
 
@@ -300,15 +301,15 @@ delfword(f, n)
 			if (n != 0)
 				while (inword() == FALSE) {
 					if (forwchar(FALSE, 1) == FALSE)
-						return(FALSE);
+						return (FALSE);
 					++size;
 				}
 		}
 
 		/* skip whitespace and newlines */
 		while ((curwp->w_doto == llength(curwp->w_dotp)) ||
-			((c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ') ||
+		       ((c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ')
-			(c == '\t')) {
+		       || (c == '\t')) {
 			if (forwchar(FALSE, 1) == FALSE)
 				break;
 			++size;
@@ -331,15 +332,15 @@ delbword(f, n)
 	long size;
 
 	/* don't allow this command if we are in read only mode */
-	if (curbp->b_mode&MDVIEW)
+	if (curbp->b_mode & MDVIEW)
-		return(rdonly());
+		return (rdonly());
 
 	/* ignore the command if there is a nonpositive argument */
 	if (n <= 0)
 		return (FALSE);
 
 	/* Clear the kill buffer if last command wasn't a kill */
-	if ((lastflag&CFKILL) == 0)
+	if ((lastflag & CFKILL) == 0)
 		kdelete();
 	thisflag |= CFKILL;	/* this command is a kill */
 
@@ -360,7 +361,7 @@ delbword(f, n)
 	}
 	if (forwchar(FALSE, 1) == FALSE)
 		return (FALSE);
-bckdel:	return (ldelete(size, TRUE));
+      bckdel:return (ldelete(size, TRUE));
 }
 
 /*
@@ -377,20 +378,20 @@ inword()
 #if	PKCODE
 	if (isletter(c))
 #else
-	if (c>='a' && c<='z')
+	if (c >= 'a' && c <= 'z')
 		return (TRUE);
-	if (c>='A' && c<='Z')
+	if (c >= 'A' && c <= 'Z')
 #endif
 		return (TRUE);
-	if (c>='0' && c<='9')
+	if (c >= '0' && c <= '9')
 		return (TRUE);
 	return (FALSE);
 }
 
 #if	WORDPRO
-fillpara(f, n)	/* Fill the current paragraph according to the current
+fillpara(f, n)
+    /* Fill the current paragraph according to the current
        fill column                                              */
-
 int f, n;			/* deFault flag and Numeric argument */
 
 {
@@ -405,11 +406,11 @@ int f, n;	/* deFault flag and Numeric argument */
 	register int dotflag;	/* was the last char a period?  */
 	char wbuf[NSTRING];	/* buffer for current word      */
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (fillcol == 0) {	/* no fill column set */
 		mlwrite("No fill column set");
-		return(FALSE);
+		return (FALSE);
 	}
 #if	PKCODE
 	justflag = FALSE;
@@ -467,7 +468,7 @@ int f, n;	/* deFault flag and Numeric argument */
 			}
 
 			/* and add the word in in either case */
-			for (i=0; i<wordlen; i++) {
+			for (i = 0; i < wordlen; i++) {
 				linsert(1, wbuf[i]);
 				++clength;
 			}
@@ -480,13 +481,13 @@ int f, n;	/* deFault flag and Numeric argument */
 	}
 	/* and add a last newline for the end of our new paragraph */
 	lnewline();
-	return(TRUE);
+	return (TRUE);
 }
 
 #if	PKCODE
-justpara(f, n)	/* Fill the current paragraph according to the current
+justpara(f, n)
+    /* Fill the current paragraph according to the current
        fill column and cursor position                  */
-
 int f, n;			/* deFault flag and Numeric argument */
 
 {
@@ -501,18 +502,18 @@ int f, n;	/* deFault flag and Numeric argument */
 	char wbuf[NSTRING];	/* buffer for current word      */
 	int leftmarg;		/* left marginal */
 
-	if (curbp->b_mode&MDVIEW)	/* don't allow this command if	*/
+	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return(rdonly());	/* we are in read only mode	*/
+		return (rdonly());	/* we are in read only mode     */
 	if (fillcol == 0) {	/* no fill column set */
 		mlwrite("No fill column set");
-		return(FALSE);
+		return (FALSE);
 	}
 	justflag = TRUE;
 	leftmarg = curwp->w_doto;
-	if (leftmarg+10 > fillcol) {
+	if (leftmarg + 10 > fillcol) {
 		leftmarg = 0;
 		mlwrite("Column too narrow");
-		return(FALSE);
+		return (FALSE);
 	}
 
 	/* record the pointer to the line just past the EOP */
@@ -565,13 +566,13 @@ int f, n;	/* deFault flag and Numeric argument */
 			} else {
 				/* start a new line */
 				lnewline();
-				for (i=0; i<leftmarg; i++)
+				for (i = 0; i < leftmarg; i++)
 					linsert(1, ' ');
 				clength = leftmarg;
 			}
 
 			/* and add the word in in either case */
-			for (i=0; i<wordlen; i++) {
+			for (i = 0; i < wordlen; i++) {
 				linsert(1, wbuf[i]);
 				++clength;
 			}
@@ -588,12 +589,12 @@ int f, n;	/* deFault flag and Numeric argument */
 		curwp->w_doto = llength(curwp->w_dotp);
 
 	justflag = FALSE;
-	return(TRUE);
+	return (TRUE);
 }
 #endif
 
-killpara(f, n)	/* delete n paragraphs starting with the current one */
+killpara(f, n)
-
+    /* delete n paragraphs starting with the current one */
 int f;				/* default flag */
 int n;				/* # of paras to delete */
 
@@ -615,12 +616,12 @@ int n;	/* # of paras to delete */
 
 		/* and delete it */
 		if ((status = killregion(FALSE, 1)) != TRUE)
-			return(status);
+			return (status);
 
 		/* and clean up the 2 extra lines */
 		ldelete(2L, TRUE);
 	}
-	return(TRUE);
+	return (TRUE);
 }
 
 
@@ -657,7 +658,7 @@ int f, n;	/* ignored numeric arguments */
 
 	/* make sure we have a region to count */
 	if ((status = getregion(&region)) != TRUE)
-		return(status);
+		return (status);
 	lp = region.r_linep;
 	offset = region.r_offset;
 	size = region.r_size;
@@ -697,7 +698,7 @@ int f, n;	/* ignored numeric arguments */
 
 	/* and report on the info */
 	if (nwords > 0L)
-		avgch = (int)((100L * nchars) / nwords);
+		avgch = (int) ((100L * nchars) / nwords);
 	else
 		avgch = 0;
 
@@ -712,6 +713,6 @@ int f, n;	/* ignored numeric arguments */
 	mlwrite("Words %D Chars %D Lines %d Avg chars/word %f",
 		nwords, nchars, nlines + 1, avgch);
 #endif
-	return(TRUE);
+	return (TRUE);
 }
 #endif