===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/mg/util.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- src/usr.bin/mg/util.c	2000/04/13 06:12:16	1.2
+++ src/usr.bin/mg/util.c	2000/09/01 14:59:09	1.3
@@ -1,51 +1,61 @@
 /*
  *		Assorted commands.
- * The file contains the command
- * processors for a large assortment of unrelated
- * commands. The only thing they have in common is
- * that they are all command processors.
+ * This file contains the command processors for a large assortment of 
+ * unrelated commands.  The only thing they have in common is that they 
+ * are all command processors.
  */
-#include	"def.h"
 
+#include "def.h"
+
 /*
- * Display a bunch of useful information about
- * the current location of dot. The character under the
- * cursor (in octal), the current line, row, and column, and
- * approximate position of the cursor in the file (as a percentage)
- * is displayed. The column position assumes an infinite position
- * display; it does not truncate just because the screen does.
+ * Display a bunch of useful information about the current location of dot. 
+ * The character under the cursor (in octal), the current line, row, and 
+ * column, and approximate position of the cursor in the file (as a 
+ * percentage) is displayed.  The column position assumes an infinite 
+ * position display; it does not truncate just because the screen does.
  * This is normally bound to "C-X =".
  */
 /* ARGSUSED */
+int
 showcpos(f, n)
+	int f, n;
 {
-	register LINE  *clp;
-	register long   nchar;
-	long            cchar;
-	register int    nline, row;
-	int             cline, cbyte;	/* Current line/char/byte */
-	int             ratio;
+	LINE	*clp;
+	long	 nchar; 
+	long	 cchar;
+	int	 nline, row;
+	int	 cline, cbyte;		/* Current line/char/byte */
+	int	 ratio;
 
-	clp = lforw(curbp->b_linep);	/* Collect the data.	 */
+	/* collect the data */
+	clp = lforw(curbp->b_linep);
+	cchar = 0;
+	cline = 0;
+	cbyte = 0;
 	nchar = 0;
 	nline = 0;
-	for (;;) {
-		++nline;	/* Count this line	 */
+	for (;;) {	
+		/* count this line */
+		++nline;
 		if (clp == curwp->w_dotp) {
-			cline = nline;	/* Mark line		 */
+			/* mark line */
+			cline = nline;
 			cchar = nchar + curwp->w_doto;
 			if (curwp->w_doto == llength(clp))
 				cbyte = '\n';
 			else
 				cbyte = lgetc(clp, curwp->w_doto);
 		}
-		nchar += llength(clp);	/* Now count the chars	 */
+		/* now count the chars */
+		nchar += llength(clp);
 		clp = lforw(clp);
 		if (clp == curbp->b_linep)
 			break;
-		nchar++;	/* count the newline	 */
+		/* count the newline */
+		nchar++;
 	}
-	row = curwp->w_toprow + 1;	/* Determine row.	 */
+	/* determine row */
+	row = curwp->w_toprow + 1;
 	clp = curwp->w_linep;
 	while (clp != curbp->b_linep && clp != curwp->w_dotp) {
 		++row;
@@ -54,21 +64,24 @@
 	/* NOSTRICT */
 	ratio = nchar ? (100L * cchar) / nchar : 100;
 	ewprintf("Char: %c (0%o)  point=%ld(%d%%)  line=%d  row=%d  col=%d",
-		 cbyte, cbyte, cchar, ratio, cline, row, getcolpos());
+	    cbyte, cbyte, cchar, ratio, cline, row, getcolpos());
 	return TRUE;
 }
 
+int
 getcolpos()
 {
-	register int    col, i, c;
+	int	col, i, c;
 
-	col = 1;		/* Determine column.	 */
+	/* determine column */
+	col = 1;
+
 	for (i = 0; i < curwp->w_doto; ++i) {
 		c = lgetc(curwp->w_dotp, i);
 		if (c == '\t'
-#ifdef	NOTAB
+#ifdef NOTAB
 		    && !(curbp->b_flag & BFNOTAB)
-#endif
+#endif /* NOTAB */
 			) {
 			col |= 0x07;
 			++col;
@@ -78,23 +91,22 @@
 	}
 	return col;
 }
+
 /*
- * Twiddle the two characters on either side of
- * dot. If dot is at the end of the line twiddle the
- * two characters before it. Return with an error if dot
- * is at the beginning of line; it seems to be a bit
- * pointless to make this work. This fixes up a very
- * common typo with a single stroke. Normally bound
- * to "C-T". This always works within a line, so
- * "WFEDIT" is good enough.
+ * Twiddle the two characters on either side of dot.  If dot is at the end 
+ * of the line twiddle the two characters before it.  Return with an error 
+ * if dot is at the beginning of line; it seems to be a bit pointless to 
+ * make this work.  This fixes up a very common typo with a single stroke. 
+ * Normally bound to "C-T".  This always works within a line, so "WFEDIT" 
+ * is good enough.
  */
 /* ARGSUSED */
+int
 twiddle(f, n)
+	int f, n;
 {
-	register LINE  *dotp;
-	register int    doto;
-	register int    cr;
-	VOID            lchange();
+	LINE	*dotp;
+	int	 doto, cr;
 
 	dotp = curwp->w_dotp;
 	doto = curwp->w_doto;
@@ -114,51 +126,55 @@
 }
 
 /*
- * Open up some blank space. The basic plan
- * is to insert a bunch of newlines, and then back
- * up over them. Everything is done by the subcommand
- * procerssors. They even handle the looping. Normally
- * this is bound to "C-O".
+ * Open up some blank space.  The basic plan is to insert a bunch of 
+ * newlines, and then back up over them.  Everything is done by the 
+ * subcommand procerssors.  They even handle the looping.  Normally this 
+ * is bound to "C-O".
  */
 /* ARGSUSED */
+int
 openline(f, n)
+	int f, n;
 {
-	register int    i;
-	register int    s;
+	int	i;
+	int	s;
 
 	if (n < 0)
 		return FALSE;
 	if (n == 0)
 		return TRUE;
-	i = n;			/* Insert newlines.	 */
+
+	/* insert newlines */
+	i = n;
 	do {
 		s = lnewline();
 	} while (s == TRUE && --i);
-	if (s == TRUE)		/* Then back up overtop */
-		s = backchar(f | FFRAND, n);	/* of them all.		 */
+
+	/* then go back up overtop of them all */
+	if (s == TRUE)
+		s = backchar(f | FFRAND, n);
 	return s;
 }
 
 /*
- * Insert a newline.
- * [following "feature" not present in current version of
- *  Gnu, and now disabled here too]
- * If you are at the end of the line and the
- * next line is a blank line, just move into the
- * blank line. This makes "C-O" and "C-X C-O" work
- * nicely, and reduces the ammount of screen
- * update that has to be done. This would not be
- * as critical if screen update were a lot
- * more efficient.
+ * Insert a newline.  [following "feature" not present in current version of
+ * Gnu, and now disabled here too] If you are at the end of the line and the
+ * next line is a blank line, just move into the blank line.  This makes 
+ * "C-O" and "C-X C-O" work nicely, and reduces the ammount of screen update 
+ * that has to be done.  This would not be as critical if screen update were a 
+ * lot more efficient.
  */
 /* ARGSUSED */
+int
 newline(f, n)
+	int f, n;
 {
-	register LINE  *lp;
-	register int    s;
+	LINE	*lp;
+	int	 s;
 
 	if (n < 0)
 		return FALSE;
+
 	while (n--) {
 		lp = curwp->w_dotp;
 #ifdef undef
@@ -168,7 +184,7 @@
 			if ((s = forwchar(FFRAND, 1)) != TRUE)
 				return s;
 		} else
-#endif
+#endif /* undef */
 		if ((s = lnewline()) != TRUE)
 			return s;
 	}
@@ -176,53 +192,58 @@
 }
 
 /*
- * Delete blank lines around dot.
- * What this command does depends if dot is
- * sitting on a blank line. If dot is sitting on a
- * blank line, this command deletes all the blank lines
- * above and below the current line. If it is sitting
- * on a non blank line then it deletes all of the
- * blank lines after the line. Normally this command
- * is bound to "C-X C-O". Any argument is ignored.
+ * Delete blank lines around dot. What this command does depends if dot is
+ * sitting on a blank line. If dot is sitting on a blank line, this command 
+ * deletes all the blank lines above and below the current line. If it is 
+ * sitting on a non blank line then it deletes all of the blank lines after 
+ * the line. Normally this command is bound to "C-X C-O". Any argument is 
+ * ignored.
  */
 /* ARGSUSED */
+int
 deblank(f, n)
+	int f, n;
 {
-	register LINE  *lp1;
-	register LINE  *lp2;
-	register RSIZE  nld;
+	LINE	*lp1, *lp2;
+	RSIZE	 nld;
 
 	lp1 = curwp->w_dotp;
 	while (llength(lp1) == 0 && (lp2 = lback(lp1)) != curbp->b_linep)
 		lp1 = lp2;
 	lp2 = lp1;
-	nld = (RSIZE) 0;
+	nld = (RSIZE)0;
 	while ((lp2 = lforw(lp2)) != curbp->b_linep && llength(lp2) == 0)
 		++nld;
 	if (nld == 0)
 		return (TRUE);
 	curwp->w_dotp = lforw(lp1);
 	curwp->w_doto = 0;
-	return ldelete((RSIZE) nld, KNONE);
+	return ldelete((RSIZE)nld, KNONE);
 }
 
 /*
  * Delete any whitespace around dot, then insert a space.
  */
+int
 justone(f, n)
+	int f, n;
 {
-	(VOID) delwhite(f, n);
+	(VOID)delwhite(f, n);
 	return linsert(1, ' ');
 }
+
 /*
  * Delete any whitespace around dot.
  */
 /* ARGSUSED */
+int
 delwhite(f, n)
+	int f, n;
 {
-	register int    col, c, s;
+	int	col, c, s;
 
 	col = curwp->w_doto;
+
 	while (((c = lgetc(curwp->w_dotp, col)) == ' ' || c == '\t')
 	       && col < llength(curwp->w_dotp))
 		++col;
@@ -236,31 +257,31 @@
 	} while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ' || c == '\t');
 
 	if (s == TRUE)
-		(VOID) forwchar(FFRAND, 1);
-	(VOID) ldelete((RSIZE) (col - curwp->w_doto), KNONE);
+		(VOID)forwchar(FFRAND, 1);
+	(VOID)ldelete((RSIZE)(col - curwp->w_doto), KNONE);
 	return TRUE;
 }
+
 /*
- * Insert a newline, then enough
- * tabs and spaces to duplicate the indentation
- * of the previous line. Assumes tabs are every eight
- * characters. Quite simple. Figure out the indentation
- * of the current line. Insert a newline by calling
- * the standard routine. Insert the indentation by
- * inserting the right number of tabs and spaces.
- * Return TRUE if all ok. Return FALSE if one
- * of the subcomands failed. Normally bound
- * to "C-J".
+ * Insert a newline, then enough tabs and spaces to duplicate the indentation
+ * of the previous line.  Assumes tabs are every eight characters.  Quite 
+ * simple.  Figure out the indentation of the current line.  Insert a newline 
+ * by calling the standard routine.  Insert the indentation by inserting the 
+ * right number of tabs and spaces.  Return TRUE if all ok.  Return FALSE if 
+ * one of the subcomands failed. Normally bound to "C-J".
  */
 /* ARGSUSED */
+int
 indent(f, n)
+	int f, n;
 {
-	register int    nicol;
-	register int    c;
-	register int    i;
+	int	nicol;
+	int	c;
+	int	i;
 
 	if (n < 0)
 		return (FALSE);
+
 	while (n--) {
 		nicol = 0;
 		for (i = 0; i < llength(curwp->w_dotp); ++i) {
@@ -273,83 +294,87 @@
 		}
 		if (lnewline() == FALSE || ((
 #ifdef	NOTAB
-					     curbp->b_flag & BFNOTAB) ?
-					    linsert(nicol, ' ') == FALSE : (
-#endif
-		      ((i = nicol / 8) != 0 && linsert(i, '\t') == FALSE) ||
-		       ((i = nicol % 8) != 0 && linsert(i, ' ') == FALSE))))
+		    curbp->b_flag & BFNOTAB) ? linsert(nicol, ' ') == FALSE : (
+#endif /* NOTAB */
+		    ((i = nicol / 8) != 0 && linsert(i, '\t') == FALSE) ||
+		    ((i = nicol % 8) != 0 && linsert(i, ' ') == FALSE))))
 			return FALSE;
 	}
 	return TRUE;
 }
 
 /*
- * Delete forward. This is real
- * easy, because the basic delete routine does
- * all of the work. Watches for negative arguments,
- * and does the right thing. If any argument is
- * present, it kills rather than deletes, to prevent
- * loss of text if typed with a big argument.
- * Normally bound to "C-D".
+ * Delete forward.  This is real easy, because the basic delete routine does
+ * all of the work.  Watches for negative arguments, and does the right thing. 
+ * If any argument is present, it kills rather than deletes, to prevent loss 
+ * of text if typed with a big argument.  Normally bound to "C-D".
  */
 /* ARGSUSED */
+int
 forwdel(f, n)
+	int f, n;
 {
 	if (n < 0)
 		return backdel(f | FFRAND, -n);
-	if (f & FFARG) {	/* Really a kill.	 */
+
+	/* really a kill */
+	if (f & FFARG) {
 		if ((lastflag & CFKILL) == 0)
 			kdelete();
 		thisflag |= CFKILL;
 	}
+
 	return ldelete((RSIZE) n, (f & FFARG) ? KFORW : KNONE);
 }
 
 /*
- * Delete backwards. This is quite easy too,
- * because it's all done with other functions. Just
- * move the cursor back, and delete forwards.
- * Like delete forward, this actually does a kill
- * if presented with an argument.
+ * Delete backwards.  This is quite easy too, because it's all done with 
+ * other functions.  Just move the cursor back, and delete forwards.  Like 
+ * delete forward, this actually does a kill if presented with an argument.
  */
 /* ARGSUSED */
+int
 backdel(f, n)
+	int f, n;
 {
-	register int    s;
+	int	s;
 
 	if (n < 0)
 		return forwdel(f | FFRAND, -n);
-	if (f & FFARG) {	/* Really a kill.	 */
+
+	/* really a kill */
+	if (f & FFARG) {
 		if ((lastflag & CFKILL) == 0)
 			kdelete();
 		thisflag |= CFKILL;
 	}
 	if ((s = backchar(f | FFRAND, n)) == TRUE)
-		s = ldelete((RSIZE) n, (f & FFARG) ? KFORW : KNONE);
+		s = ldelete((RSIZE)n, (f & FFARG) ? KFORW : KNONE);
+
 	return s;
 }
 
 /*
- * Kill line. If called without an argument,
- * it kills from dot to the end of the line, unless it
- * is at the end of the line, when it kills the newline.
- * If called with an argument of 0, it kills from the
- * start of the line to dot. If called with a positive
- * argument, it kills from dot forward over that number
- * of newlines. If called with a negative argument it
- * kills any text before dot on the current line,
- * then it kills back abs(arg) lines.
+ * Kill line.  If called without an argument, it kills from dot to the end 
+ * of the line, unless it is at the end of the line, when it kills the 
+ * newline.  If called with an argument of 0, it kills from the start of the 
+ * line to dot.  If called with a positive argument, it kills from dot 
+ * forward over that number of newlines.  If called with a negative argument 
+ * it kills any text before dot on the current line, then it kills back 
+ * abs(arg) lines.
  */
 /* ARGSUSED */
+int
 killline(f, n)
+	int f, n;
 {
-	register RSIZE  chunk;
-	register LINE  *nextp;
-	register int    i, c;
-	VOID            kdelete();
+	LINE	*nextp;
+	RSIZE	 chunk;
+	int	 i, c;
 
-	if ((lastflag & CFKILL) == 0)	/* Clear kill buffer if */
-		kdelete();	/* last wasn't a kill.	 */
+	/* clear kill buffer if last wasn't a kill */
+	if ((lastflag & CFKILL) == 0)
+		kdelete();
 	thisflag |= CFKILL;
 	if (!(f & FFARG)) {
 		for (i = curwp->w_doto; i < llength(curwp->w_dotp); ++i)
@@ -372,7 +397,8 @@
 			chunk += llength(nextp) + 1;
 			nextp = lforw(nextp);
 		}
-	} else {		/* n <= 0		 */
+	} else {
+		/* n <= 0 */
 		chunk = curwp->w_doto;
 		curwp->w_doto = 0;
 		i = n;
@@ -385,41 +411,39 @@
 		}
 	}
 	/*
-	 * KFORW here is a bug. Should be KBACK/KFORW, but we need to
+	 * KFORW here is a bug.  Should be KBACK/KFORW, but we need to
 	 * rewrite the ldelete code (later)?
 	 */
 	return (ldelete(chunk, KFORW));
 }
 
 /*
- * Yank text back from the kill buffer. This
- * is really easy. All of the work is done by the
- * standard insert routines. All you do is run the loop,
- * and check for errors. The blank
- * lines are inserted with a call to "newline"
- * instead of a call to "lnewline" so that the magic
- * stuff that happens when you type a carriage
- * return also happens when a carriage return is
- * yanked back from the kill buffer.
- * An attempt has been made to fix the cosmetic bug
- * associated with a yank when dot is on the top line of
- * the window (nothing moves, because all of the new
- * text landed off screen).
+ * Yank text back from the kill buffer.  This is really easy.  All of the work 
+ * is done by the standard insert routines.  All you do is run the loop, and 
+ * check for errors.  The blank lines are inserted with a call to "newline"
+ * instead of a call to "lnewline" so that the magic stuff that happens when 
+ * you type a carriage return also happens when a carriage return is yanked 
+ * back from the kill buffer.  An attempt has been made to fix the cosmetic 
+ * bug associated with a yank when dot is on the top line of the window 
+ * (nothing moves, because all of the new text landed off screen).
  */
 /* ARGSUSED */
+int
 yank(f, n)
+	int f, n;
 {
-	register int    c;
-	register int    i;
-	register LINE  *lp;
-	register int    nline;
-	VOID            isetmark();
+	LINE	*lp;
+	int	 c, i, nline;
 
 	if (n < 0)
 		return FALSE;
-	nline = 0;		/* Newline counting.	 */
+
+	/* newline counting */
+	nline = 0;
+
 	while (n--) {
-		isetmark();	/* mark around last yank */
+		/* mark around last yank */
+		isetmark();
 		i = 0;
 		while ((c = kremove(i)) >= 0) {
 			if (c == '\n') {
@@ -433,11 +457,15 @@
 			++i;
 		}
 	}
-	lp = curwp->w_linep;	/* Cosmetic adjustment	 */
-	if (curwp->w_dotp == lp) {	/* if offscreen insert. */
+	/* cosmetic adjustment */
+	lp = curwp->w_linep;
+
+	/* if offscreen insert */
+	if (curwp->w_dotp == lp) {
 		while (nline-- && lback(lp) != curbp->b_linep)
 			lp = lback(lp);
-		curwp->w_linep = lp;	/* Adjust framing.	 */
+		/* adjust framing */
+		curwp->w_linep = lp;
 		curwp->w_flag |= WFHARD;
 	}
 	return TRUE;
@@ -445,8 +473,9 @@
 
 #ifdef	NOTAB
 /* ARGSUSED */
+int
 space_to_tabstop(f, n)
-	int             f, n;
+	int f, n;
 {
 	if (n < 0)
 		return FALSE;
@@ -454,4 +483,4 @@
 		return TRUE;
 	return linsert((n << 3) - (curwp->w_doto & 7), ' ');
 }
-#endif
+#endif /* NOTAB */