Bindable functions take a boolean as flag.

Emphasize which one always return TRUE.
Use mloutfail() to introduce consistency when a function fails with error message.

basic.c

@@ -1,19 +1,16 @@
 /* basic.c -- implements basic.h */
-
 #include "basic.h"
 
-/*	basic.c
+/* The routines in this file move the cursor around on the screen.  They
- *
+   compute a new value for the cursor, then adjust ".".  The display code
- * The routines in this file move the cursor around on the screen. They
+   always updates the cursor location, so only moves between lines, or
- * compute a new value for the cursor, then adjust ".". The display code
+   functions that adjust the top line in the window and invalidate the
- * always updates the cursor location, so only moves between lines, or
+   framing, are hard.
- * functions that adjust the top line in the window and invalidate the
+
- * framing, are hard.
+   modified by Petri Kutvonen
- *
- *	modified by Petri Kutvonen
  */
 
-#include <stdio.h>
+#include <assert.h>
 #include <stdlib.h>
 
 #include "input.h"
@@ -22,340 +19,302 @@
 #include "terminal.h"
 #include "window.h"
 
+#define CVMVAS  1   /* arguments to page forward/back in pages */
 
-#define CVMVAS  1  /* arguments to page forward/back in pages      */
+int overlap = 0 ;   /* $overlap: line overlap in forw/back page */
+int curgoal ;       /* $target:  column goal for C-P, C-N */
 
 
-int overlap = DEFAULT_OVERLAP ;		/* line overlap in forw/back page	*/
+/* This routine, given a pointer to a struct line, and the current cursor
-int curgoal ;						/* Goal for C-P, C-N			*/
+   goal column, return the best choice for the offset.  The offset is
-
+   returned.  Used by "C-N" and "C-P".
-
-/*
- * This routine, given a pointer to a struct line, and the current cursor goal
- * column, return the best choice for the offset. The offset is returned.
- * Used by "C-N" and "C-P".
  */
 static unsigned getgoal( line_p dlp) {
-	int col ;
+    int col = 0 ;
-	unsigned idx ;
+    const unsigned len = llength( dlp) ;
-	const unsigned len = llength( dlp) ;
+    unsigned idx = 0 ;
+    while( idx < len) {
+        unicode_t c ;
+        unsigned width = utf8_to_unicode( dlp->l_text, idx, len, &c) ;
 
-	col = 0 ;
+    /* Take tabs, ^X and \xx hex characters into account */
-	idx = 0 ;
+        if( c == '\t')
-	while( idx < len) {
+            col += tabwidth - col % tabwidth ;
-		unicode_t c ;
+        else if( c < 0x20 || c == 0x7F)     /* ^x */
-		unsigned width = utf8_to_unicode( dlp->l_text, idx, len, &c) ;
+            col += 2 ;
+        else if( c >= 0x80 && c <= 0xA0)    /* \xx */
+            col += 3 ;
+        else {
+            int w = utf8_width( c) ;        /* work around */
+            col += (w < 0) ? 2 : w ;        /* unknown unicode width as \u */
+        }
 
-		/* Take tabs, ^X and \xx hex characters into account */
+        if( col > curgoal)
-		if( c == '\t')
+            break ;
-			col += tabwidth - col % tabwidth ;
+        else
-		else if( c < 0x20 || c == 0x7F)
+            idx += width ;
-			col += 2 ;
+    }
-		else if( c >= 0x80 && c <= 0xA0)
-			col += 3 ;
-		else
-			col += 1 ;
 
-		if( col > curgoal)
+    return idx ;
-			break ;
-
-		idx += width ;
-	}
-
-	return idx ;
 }
 
-/*
+
- * Move the cursor to the beginning of the current line of active window.
+/* Move the cursor to the beginning of the current line of active window. */
+TBINDABLE( gotobol) {
+    curwp->w_doto = 0 ;
+    return TRUE ;
+}
+
+
+/* Move the cursor to the end of the current line of active window. */
+TBINDABLE( gotoeol) {
+    curwp->w_doto = llength( curwp->w_dotp) ;
+    return TRUE ;
+}
+
+
+/* Goto the beginning of the buffer.  Massive adjustment of dot.  This is
+   considered to be hard motion; it really isn't if the original value of
+   dot is the same as the new value of dot.  Normally bound to "M-<".
  */
-boolean gotobol( int f, int n) {
+TBINDABLE( gotobob) {
-	curwp->w_doto = 0 ;
+    curwp->w_dotp = lforw( curbp->b_linep) ;
-	return TRUE ;
+    curwp->w_doto = 0 ;
+    curwp->w_flag |= WFHARD ;
+    return TRUE ;
 }
 
-/*
+
- * Move the cursor to the end of the current line of active window.
+/* Move to the end of the buffer.  Dot is always put at the end of the file
+   (ZJ).  The standard screen code does most of the hard parts of update.
+   Bound to "M->".
  */
-boolean gotoeol( int f, int n) {
+TBINDABLE( gotoeob) {
-	curwp->w_doto = llength( curwp->w_dotp) ;
+    curwp->w_dotp = curbp->b_linep ;
-	return TRUE ;
+    curwp->w_doto = 0 ;
+    curwp->w_flag |= WFHARD ;
+    return TRUE ;
 }
 
-/*
+
- * Goto the beginning of the buffer. Massive adjustment of dot. This is
+/* Move forward by full lines.  If the number of lines to move is less than
- * considered to be hard motion; it really isn't if the original value of dot
+   zero, call the backward line function to actually do it.  The last
- * is the same as the new value of dot. Normally bound to "M-<".
+   command controls how the goal column is set.  Bound to "C-N".  No errors
+   are possible.
  */
-boolean gotobob( int f, int n) {
+BBINDABLE( forwline) {
-	curwp->w_dotp = lforw( curbp->b_linep) ;
+    assert( f == TRUE || n == 1) ;
-	curwp->w_doto = 0 ;
+
-	curwp->w_flag |= WFHARD ;
+/* if the last command was not a line move, reset the goal column */
-	return TRUE ;
+    if( (lastflag & CFCPCN) == 0)
+        curgoal = getccol( FALSE) ;
+
+/* flag this command as a line move */
+    thisflag |= CFCPCN ;
+
+/* and move the point down */
+    if( n) {
+        line_p dlp = curwp->w_dotp ;
+        if( n > 0)
+            while( n && dlp != curbp->b_linep) {
+                dlp = lforw( dlp) ;
+                n -= 1 ;
+            }
+        else {
+            while( n && lback( dlp) != curbp->b_linep) {
+                dlp = lback( dlp) ;
+                n += 1 ;
+            }
+        }
+
+    /* resetting the current position */
+        curwp->w_dotp = dlp ;
+        curwp->w_doto = getgoal( dlp) ;
+        curwp->w_flag |= WFMOVE ;
+    }
+
+    return (n == 0) ? TRUE : FALSE ;
 }
 
-/*
+
- * Move to the end of the buffer. Dot is always put at the end of the file
+/* This function is like "forwline", but goes backwards.  The scheme is
- * (ZJ). The standard screen code does most of the hard parts of update.
+   exactly the same.  Check for arguments that are less than zero and call
- * Bound to "M->".
+   your alternate.  Figure out the new line and call "movedot" to perform
+   the motion.  No errors are possible.  Bound to "C-P".
  */
-boolean gotoeob( int f, int n) {
+BBINDABLE( backline) {
-	curwp->w_dotp = curbp->b_linep ;
+    assert( f == TRUE || n == 1) ;
-	curwp->w_doto = 0 ;
+
-	curwp->w_flag |= WFHARD ;
+    return forwline( TRUE, -n) ;
-	return TRUE ;
 }
 
-/*
- * Move forward by full lines. If the number of lines to move is less than
- * zero, call the backward line function to actually do it. The last command
- * controls how the goal column is set. Bound to "C-N". No errors are
- * possible.
- */
-boolean forwline( int f, int n) {
-	line_p dlp ;
 
-	if (n < 0)
+/* Move to a particular line.
-		return backline(f, -n);
-
-	/* if we are on the last line as we start....fail the command */
-	if (curwp->w_dotp == curbp->b_linep)
-		return FALSE;
-
-	/* if the last command was not a line move, reset the goal column */
-	if ((lastflag & CFCPCN) == 0)
-		curgoal = getccol(FALSE);
-
-	/* flag this command as a line move */
-	thisflag |= CFCPCN;
-
-	/* and move the point down */
-	dlp = curwp->w_dotp;
-	while( n && dlp != curbp->b_linep) {
-		dlp = lforw( dlp) ;
-		n -= 1 ;
-	}
-
-	/* reseting the current position */
-	curwp->w_dotp = dlp;
-	curwp->w_doto = getgoal(dlp);
-	curwp->w_flag |= WFMOVE;
-	return (n == 0) ? TRUE : FALSE ;
-}
-
-/*
- * This function is like "forwline", but goes backwards. The scheme is exactly
- * the same. Check for arguments that are less than zero and call your
- * alternate. Figure out the new line and call "movedot" to perform the
- * motion. No errors are possible. Bound to "C-P".
- */
-boolean backline( int f, int n) {
-	line_p dlp ;
-
-	if (n < 0)
-		return forwline(f, -n);
-
-	/* if we are on the first line as we start....fail the command */
-	if (lback(curwp->w_dotp) == curbp->b_linep)
-		return FALSE;
-
-	/* if the last command was not a line move, reset the goal column */
-	if ((lastflag & CFCPCN) == 0)
-		curgoal = getccol(FALSE);
-
-	/* flag this command as a line move */
-	thisflag |= CFCPCN;
-
-	/* and move the point up */
-	dlp = curwp->w_dotp;
-	while( n && lback( dlp) != curbp->b_linep) {
-		dlp = lback( dlp) ;
-		n -= 1 ;
-	}
-
-	/* reseting the current position */
-	curwp->w_dotp = dlp;
-	curwp->w_doto = getgoal(dlp);
-	curwp->w_flag |= WFMOVE;
-	return (n == 0) ? TRUE : FALSE ;
-}
-
-/*
- * Move to a particular line.
  *
  * @n: The specified line position at the current buffer.
  */
-int gotoline( int f, int n) {
+BINDABLE( gotoline) {
-	/* Get an argument if one doesnt exist. */
+/* Get an argument if one doesn't exist. */
-	if( f == FALSE) {
+    if( f == FALSE) {
-		int status ;
+        char *arg ; /* Buffer to hold argument. */
-		char *arg ;	/* Buffer to hold argument. */
 
-		status = newmlarg( &arg, "Line to GOTO: ", 0) ;
+        int status = newmlarg( &arg, "goto-line: ", 0) ;
-		if( status != TRUE) {
+        if( status != TRUE)
-			mloutstr( "(Aborted)") ;
+            return status ;
-			return status ;
-		}
 
-		n = atoi( arg) ;
+        n = atoi( arg) ;
-		free( arg) ;
+        free( arg) ;
-	}
+        f = TRUE ;
+    }
 
-	/* Handle the case where the user may be passed something like this:
+/* Handle the case where the user may be passed something like this:
-	 * em filename +
+ *  ue filename +
-	 * In this case we just go to the end of the buffer.
+ * In this case we just go to the end of the buffer.
-	 */
+ */
-	if (n == 0)
+    if( n == 0)
-		return gotoeob(f, n);
+        return gotoeob( f, n) ;
 
-	/* If a bogus argument was passed, then returns false. */
+/* If a bogus argument was passed, then returns false. */
-	if (n < 0)
+    if( n < 0)
-		return FALSE;
+        return FALSE ;
 
-	/* First, we go to the begin of the buffer. */
+/* First, we go to the begin of the buffer. */
-	gotobob(f, n);
+    gotobob( f, n) ;
-	return (n == 1) ? TRUE : forwline( f, n - 1) ;
+    return (n == 1) ? TRUE : forwline( TRUE, n - 1) ;
 }
 
-/*
+
- * Scroll forward by a specified number of lines, or by a full page if no
+/* Scroll forward by a specified number of lines, or by a full page if no
- * argument. Bound to "C-V". The "2" in the arithmetic on the window size is
+   argument.  Bound to "C-V".  The "2" in the arithmetic on the window size
- * the overlap; this value is the default overlap value in ITS EMACS. Because
+   is the overlap; this value is the default overlap value in ITS EMACS.
- * this zaps the top line in the display window, we have to do a hard update.
+   Because this zaps the top line in the display window, we have to do a
+   hard update.
  */
-boolean forwpage( int f, int n) {
+TBINDABLE( forwpage) {
-	line_p lp ;
+    line_p lp ;
 
-	if (f == FALSE) {
+    if( f == FALSE) {
 #if SCROLLCODE
-		if (term.t_scroll != NULL)	/* $scroll == FALSE */
+        if (term.t_scroll != NULL)  /* $scroll == FALSE */
-			if (overlap == 0)		/* $overlap == 0 */
+            if (overlap == 0)       /* $overlap == 0 */
-				n = curwp->w_ntrows * 2 / 3 ;
+                n = curwp->w_ntrows * 2 / 3 ;
-			else
+            else
-				n = curwp->w_ntrows - overlap;
+                n = curwp->w_ntrows - overlap;
-		else
+        else
 #endif
-			n = curwp->w_ntrows - 2;  /* Default scroll. */
+            n = curwp->w_ntrows - 2;  /* Default scroll. */
 
-		if (n <= 0)	/* Forget the overlap. */
+        if (n <= 0) /* Forget the overlap. */
-			n = 1;	/* If tiny window. */
+            n = 1;  /* If tiny window. */
-	} else if (n < 0)
+    } else if( n < 0)
-		return backpage(f, -n);
+        return backpage( f, -n) ;
 #if     CVMVAS
-	else			/* Convert from pages. */
+    else            /* Convert from pages. */
-		n *= curwp->w_ntrows;	/* To lines. */
+        n *= curwp->w_ntrows;   /* To lines. */
 #endif
 
-/*	lp = curwp->w_linep; */
+    lp = curwp->w_dotp ;
-	lp = curwp->w_dotp ;
+    while( n && lp != curbp->b_linep) {
-	while( n && lp != curbp->b_linep) {
+        lp = lforw( lp) ;
-		lp = lforw( lp) ;
+        n -= 1 ;
-		n -= 1 ;
+    }
-	}
 
-/*	curwp->w_linep = lp; */
+    curwp->w_dotp = lp ;
-	curwp->w_dotp = lp;
+    curwp->w_doto = 0 ;
-	curwp->w_doto = 0;
+    reposition( TRUE, 0) ;  /* center at dot, always succeed */
-	reposition( TRUE, 0) ;
 
 #if SCROLLCODE
-	curwp->w_flag |= WFHARD | WFKILLS;
+    curwp->w_flag |= WFHARD | WFKILLS;
 #else
-	curwp->w_flag |= WFHARD;
+    curwp->w_flag |= WFHARD;
 #endif
-	return TRUE;
+    return TRUE ;
 }
 
-/*
- * This command is like "forwpage", but it goes backwards. The "2", like
- * above, is the overlap between the two windows. The value is from the ITS
- * EMACS manual. Bound to "M-V". We do a hard update for exactly the same
- * reason.
- */
-boolean backpage( int f, int n) {
-	line_p lp ;
 
-	if (f == FALSE) {	/* interactive, default n = 1 supplied */
+/* This command is like "forwpage", but it goes backwards.  The "2", like
-	/* in interactive mode, first move dot to top of window */
+   above, is the overlap between the two windows.  The value is from the
-		if( curwp->w_dotp != curwp->w_linep) {
+   ITS EMACS manual.  Bound to "M-V".  We do a hard update for exactly the
-			curwp->w_dotp = curwp->w_linep ;
+   same reason.
-			curwp->w_doto = 0 ;
+ */
-/*			curwp->w_flag |= WFMOVE ; */
+TBINDABLE( backpage) {
-			return TRUE ;
+    line_p lp ;
-		}
+
+    if( f == FALSE) {   /* interactive, default n = 1 supplied */
+    /* in interactive mode, first move dot to top of window */
+        if( curwp->w_dotp != curwp->w_linep) {
+            curwp->w_dotp = curwp->w_linep ;
+            curwp->w_doto = 0 ;
+/*          curwp->w_flag |= WFMOVE ; */
+            return TRUE ;
+        }
 
 #if SCROLLCODE
-		if (term.t_scroll != NULL)	/* $scroll != FALSE */
+        if (term.t_scroll != NULL)  /* $scroll != FALSE */
-			if (overlap == 0)		/* $overlap == 0 */
+            if (overlap == 0)       /* $overlap == 0 */
-				n = curwp->w_ntrows * 2 / 3 ;
+                n = curwp->w_ntrows * 2 / 3 ;
-			else
+            else
-				n = curwp->w_ntrows - overlap;
+                n = curwp->w_ntrows - overlap;
-		else
+        else
 #endif
-			n = curwp->w_ntrows - 2; /* Default scroll. */
+            n = curwp->w_ntrows - 2; /* Default scroll. */
 
-		if (n <= 0)	/* Don't blow up if the. */
+        if (n <= 0) /* Don't blow up if the. */
-			n = 1;	/* Window is tiny. */
+            n = 1;  /* Window is tiny. */
-	} else if (n < 0)
+    } else if (n < 0)
-		return forwpage(f, -n);
+        return forwpage(f, -n);
 #if     CVMVAS
-	else  /* Convert from pages. */
+    else  /* Convert from pages. */
-		n *= curwp->w_ntrows;  /* To lines. */
+        n *= curwp->w_ntrows;  /* To lines. */
 #endif
 
-/*	lp = curwp->w_linep; */
+/*  lp = curwp->w_linep; */
-	lp = curwp->w_dotp ;
+    lp = curwp->w_dotp ;
-	while( n && lback( lp) != curbp->b_linep) {
+    while( n && lback( lp) != curbp->b_linep) {
-		lp = lback( lp) ;
+        lp = lback( lp) ;
-		n -= 1 ;
+        n -= 1 ;
-	}
+    }
 
-/*	curwp->w_linep = lp; */
+/*  curwp->w_linep = lp; */
-	curwp->w_dotp = lp;
+    curwp->w_dotp = lp;
-	curwp->w_doto = 0;
+    curwp->w_doto = 0;
-	reposition( TRUE, (f == FALSE) ? 1 : 0) ;
+    reposition( TRUE, (f == FALSE) ? 1 : 0) ;
 
 #if SCROLLCODE
-	curwp->w_flag |= WFHARD | WFINS;
+    curwp->w_flag |= WFHARD | WFINS;
 #else
-	curwp->w_flag |= WFHARD;
+    curwp->w_flag |= WFHARD;
 #endif
-	return TRUE;
+    return TRUE;
 }
 
-/*
+
- * Set the mark in the current window to the value of "." in the window. No
+/* Set the mark in the current window to the value of "." in the window.
- * errors are possible. Bound to "M-.".
+   No errors are possible.  Bound to M-. set-mark.
  */
-boolean setmark( int f, int n) {
+TBINDABLE( setmark) {
-	curwp->w_markp = curwp->w_dotp;
+    curwp->w_markp = curwp->w_dotp ;
-	curwp->w_marko = curwp->w_doto;
+    curwp->w_marko = curwp->w_doto ;
-	mloutstr( "(Mark set)") ;
+    mloutstr( "(Mark set)") ;
-	return TRUE ;
+    return TRUE ;
 }
 
-/*
+
- * Swap the values of "." and "mark" in the current window. This is pretty
+/* Swap the values of "." and "mark" in the current window.  If no mark as
- * easy, because all of the hard work gets done by the standard routine
+   been previously set, set it.  Bound to C-X C-X exchange-point-and-mark.
- * that moves the mark about. The only possible error is "no mark". Bound to
- * "C-X C-X".
  */
-boolean swapmark( int f, int n) {
+TBINDABLE( swapmark) {
-	line_p odotp ;
+    line_p odotp = curwp->w_dotp ;
-	int odoto;
+    int odoto = curwp->w_doto ;
+    if( curwp->w_markp) {
+        curwp->w_dotp = curwp->w_markp ;
+        curwp->w_doto = curwp->w_marko ;
+        curwp->w_flag |= WFMOVE ;
+    }
 
-	if( curwp->w_markp == NULL) {
+    curwp->w_markp = odotp ;
-		mloutstr( "No mark in this window") ;
+    curwp->w_marko = odoto ;
-		return FALSE ;
+    return TRUE ;
-	}
-
-	odotp = curwp->w_dotp;
-	odoto = curwp->w_doto;
-	curwp->w_dotp = curwp->w_markp;
-	curwp->w_doto = curwp->w_marko;
-	curwp->w_markp = odotp;
-	curwp->w_marko = odoto;
-	curwp->w_flag |= WFMOVE;
-	return TRUE;
 }
 
 /* end of basic.c */

basic.h

@@ -1,35 +1,32 @@
 /* basic.h -- basic commands for cursor movement in active window */
-
 #ifndef _BASIC_H_
-#define _BASIC_H_
+# define _BASIC_H_
 
-#include "retcode.h"
+# include "names.h"
 
-/*
+/* $overlap is the size of the line overlap when kbd calls page forw/back
-** $overlap is the size of the line overlap when kbd calls page forw/back
+   if 0, page will move by 2/3 of the window size (1/3 page overlap)
-** if 0, page will move by 2/3 of the window size (1/3 page overlap)
+   default to 0
-** default to 0
+ */
-*/
+extern int overlap ;    /* $overlap: line overlap in forw/back page */
-#define DEFAULT_OVERLAP	0
-extern int overlap ;		/* line overlap in forw/back page	*/
 
 
 /* $target (== curgoal) is the column target when doing line move */
-extern int curgoal ;		/* Goal for C-P previous-line, C-N next-line */
+extern int curgoal ;    /* $target: Goal for C-P previous-line, C-N next-line */
 
 
-boolean gotobol( int f, int n) ;
+/* Bindable functions */
-boolean gotoeol( int f, int n) ;
+BBINDABLE( backline) ;
-int gotoline( int f, int n) ;
+TBINDABLE( backpage) ;
-boolean gotobob( int f, int n) ;
+BBINDABLE( forwline) ;
-boolean gotoeob( int f, int n) ;
+TBINDABLE( forwpage) ;
-boolean forwline( int f, int n) ;
+TBINDABLE( gotobob) ;
-boolean backline( int f, int n) ;
+TBINDABLE( gotobol) ;
-boolean forwpage( int f, int n) ;
+TBINDABLE( gotoeob) ;
-boolean backpage( int f, int n) ;
+TBINDABLE( gotoeol) ;
-boolean setmark( int f, int n) ;
+ BINDABLE( gotoline) ;
-boolean swapmark( int f, int n) ;
+TBINDABLE( setmark) ;
+TBINDABLE( swapmark) ;
 
 #endif
-
 /* end of basic.h */

bind.c

@@ -9,24 +9,22 @@
  */
 
 #include <assert.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "estruct.h"
 #include "bindable.h"
 #include "buffer.h"
-#include "display.h"
+#include "display.h"    /* upmode(), ostring() */
 #include "exec.h"
 #include "file.h"
 #include "flook.h"
 #include "input.h"
 #include "line.h"
+#include "mlout.h"
 #include "names.h"
 #include "util.h"
 #include "window.h"
 
-
 static int buildlist( char *mstring) ;
 static char *cmdstr( unsigned c, char *seq) ;
 static unsigned int getckey( int mflag) ;
@@ -34,179 +32,175 @@ static unsigned int stock( char *keyname) ;
 static const char *getfname( unsigned keycode, const char *failmsg) ;
 
 
-static boolean cmdfail( const char *msg) {
+/* give me some help!!!! bring up a fake buffer and read the help file into
-	mlwrite( "%s", msg) ;
+   it with view mode
-	return FALSE ;
+ */
-}
-
 BINDABLE( help) {
-/* give me some help!!!!
-   bring up a fake buffer and read the help file into it with view mode */
     char *fname = NULL; /* ptr to file returned by flook() */
 
 /* first check if we are already here */
     buffer_p bp = bfind( hlpfname, FALSE, BFINVS);
-	if( bp == curbp)
+    if( bp == curbp)
-		return TRUE ;
+        return TRUE ;
 
     if( bp == NULL) {
         fname = flook( hlpfname, FALSE) ;
         if( fname == NULL)
-			return cmdfail( "(Help file is not online)") ;
+            return mloutfail( "(Help file is not online)") ;
     }
 
 /* split the current window to make room for the help stuff */
-	if( wheadp->w_wndp == NULL			/* One window */
+    if( wheadp->w_wndp == NULL          /* One window */
-	&&  splitwind( FALSE, 1) == FALSE)	/* Split it */
+    &&  splitwind( FALSE, 1) == FALSE)  /* Split it */
         return FALSE ;
 
-    if (bp == NULL) {
+    if( bp == NULL) {
-        /* and read the stuff in */
+    /* and read the stuff in */
-        if (getfile(fname, FALSE) == FALSE)
+        if( getfile( fname, FALSE) == FALSE)
-            return FALSE;
+            return FALSE ;
     } else
-		swbuffer( bp) ;
+        swbuffer( bp) ;
 
     /* make this window in VIEW mode, update all mode lines */
     curwp->w_bufp->b_mode |= MDVIEW;
     curwp->w_bufp->b_flag |= BFINVS;
     upmode() ;
-    return TRUE;
+    return TRUE ;
 }
 
+
 static boolean invalidkey( void) {
-	return cmdfail( "(Invalid key sequence)") ;
+    return mloutfail( "(Invalid key sequence)") ;
 }
 
+
 /* describe the command for a certain key */
 BINDABLE( deskey) {
-	const char cmdname[] = "describe-key" ;
+    const char cmdname[] = "describe-key" ;
-    char outseq[ NSTRING] ;	/* output buffer for command sequence */
+    char outseq[ 8] ;   /* output buffer for keystroke sequence */
 
 /* prompt the user to type a key to describe */
-    mlwrite( "%s: ", cmdname) ;
+    mloutfmt( "%s: ", cmdname) ;
 
 /* get the command sequence to describe
  * change it to something we can print as well */
     unsigned keycode = getckey( FALSE) ;
-	if( keycode == (unsigned) ~0)
+    if( keycode == (unsigned) ~0)
-		return invalidkey() ;
+        return invalidkey() ;
 
 /* output the command sequence */
-    mlwrite( "%s %s: 0x%x, %s", cmdname, cmdstr( keycode, outseq), keycode,
+    mloutfmt( "%s %s: 0x%x, %s", cmdname, cmdstr( keycode, outseq), keycode,
                                             getfname( keycode, "Not Bound")) ;
     return TRUE ;
 }
 
-/*
+
- * bindtokey:
+/* bindtokey:
  *  add a new key to the key binding table
  *
  * int f, n;        command arguments [IGNORED]
  */
 BINDABLE( bindtokey) {
-    kbind_p ktp ;		/* pointer into the command table */
+    kbind_p ktp ;       /* pointer into the command table */
-    char outseq[ 80] ;  /* output buffer for keystroke sequence */
+    char outseq[ 8] ;   /* output buffer for keystroke sequence */
 
 /* prompt the user to type in a key to bind */
-    mlwrite("bind-to-key: ");
+    mloutstr( "bind-to-key: ") ;
 
 /* get the function name to bind it to */
-	nbind_p nbp = getname() ;
+    nbind_p nbp = getname() ;
-	if( nbp == NULL)	/* abort */
+    if( nbp == NULL)    /* abort */
-		return FALSE ;
+        return FALSE ;
 
     fnp_t kfunc = nbp->n_func ;
     if( kfunc == NULL)
-		return cmdfail( "(No such function)") ;
+        return mloutfail( "(No such function)") ;
 
-	mlwrite( "bind-to-key %s: ", bind_name( nbp)) ;
+    mloutfmt( "bind-to-key %s: ", bind_name( nbp)) ;
 
 /* get the command sequence to bind */
-	boolean prefix_f = (kfunc == metafn) || (kfunc == cex) ||
+    boolean prefix_f = (kfunc == (fnp_t) metafn) || (kfunc == (fnp_t) cex) ||
-            							(kfunc == unarg) || (kfunc == ctrlg) ;
+                        (kfunc == (fnp_t) unarg) || (kfunc == (fnp_t) ctrlg) ;
     int c = getckey( prefix_f) ;
-	if( c == ~0)
+    if( c == ~0)
-		return invalidkey() ;
+        return invalidkey() ;
 
 /* change it to something we can print as well */
 /* and dump it out */
     ostring( cmdstr( c, outseq)) ;
 
 /* key sequence can't be an active prefix key */
-	if( c == metac || c == ctlxc || c == reptc || c == abortc) {
+    if( c == metac || c == ctlxc || c == reptc || c == abortc) {
-		if( (c == metac  && kfunc == metafn)
+        if( (c == metac  && kfunc == (fnp_t) metafn)
-		||  (c == ctlxc  && kfunc == cex)
+        ||  (c == ctlxc  && kfunc == (fnp_t) cex)
-		||  (c == reptc  && kfunc == unarg)
+        ||  (c == reptc  && kfunc == (fnp_t) unarg)
-		||  (c == abortc && kfunc == ctrlg))
+        ||  (c == abortc && kfunc == (fnp_t) ctrlg))
-			return TRUE ;
+            return TRUE ;   /* be silent if keep current */
 
-		return cmdfail( "(Can't bind to active prefix)") ;
+        return mloutfail( "(Can't bind to active prefix)") ;
-	}
+    }
 
 /* if the function is a prefix key */
-	if( prefix_f) {
+    if( prefix_f) {
     /* remove existing binding for the prefix */
         for( ktp = keytab ; ktp->k_code != 0 ; ktp++)
             if( ktp->k_nbp == nbp) {
-				delkeybinding( ktp->k_code) ;
+                delkeybinding( ktp->k_code) ;
-				break ;
+                break ;
-			}
+            }
 
     /* set the appropriate global prefix variable */
-        if( kfunc == metafn)
+        if( kfunc == (fnp_t) metafn)
             metac = c ;
-        else if( kfunc == cex)
+        else if( kfunc == (fnp_t) cex)
             ctlxc = c ;
-        if( kfunc == unarg)
+        if( kfunc == (fnp_t) unarg)
             reptc = c ;
-        if( kfunc == ctrlg)
+        if( kfunc == (fnp_t) ctrlg)
             abortc = c ;
     }
 
-	ktp = setkeybinding( c, nbp) ;
+    ktp = setkeybinding( c, nbp) ;
-	if( ktp->k_code == 0)
+    if( ktp->k_code == 0)
-		return cmdfail( "Binding table FULL!") ;
+        return mloutfail( "Binding table FULL!") ;
 
-	return TRUE ;
+    return TRUE ;
 }
 
-/*
+
- * unbindkey:
+/* unbindkey:
  *  delete a key from the key binding table
  *
  * int f, n;        command arguments [IGNORED]
  */
 BINDABLE( unbindkey) {
-    char outseq[ 80] ;	/* output buffer for keystroke sequence */
+    char outseq[ 8] ;   /* output buffer for keystroke sequence */
 
 /* prompt the user to type in a key to unbind */
-    mlwrite( "unbind-key: ") ;
+    mloutstr( "unbind-key: ") ;
 
 /* get the command sequence to unbind */
-    int c = getckey( FALSE) ;	/* get a command sequence */
+    int c = getckey( FALSE) ;   /* get a command sequence */
-	if( c == ~0)
+    if( c == ~0)
-		return invalidkey() ;
+        return invalidkey() ;
 
 /* change it to something we can print as well */
 /* and dump it out */
     ostring( cmdstr( c, outseq)) ;
 
 /* prefix key sequence can't be undound, just redefined */
-	if( c == reptc || c == abortc)
+    if( c == reptc || c == abortc)
-		return cmdfail( "(Can't unbind prefix)") ;
+        return mloutfail( "(Can't unbind prefix)") ;
 
 /* if it isn't bound, bitch */
-    if( delkeybinding( c) == FALSE) {
+    if( delkeybinding( c) == FALSE)
-        mlwrite( "(Key not bound)") ;
+        return mloutfail( "(Key not bound)") ;
-        return FALSE ;
+
-    }
+    return TRUE ;
-	
-	return TRUE ;
 }
 
-/*
+
- * does source include sub?
+/* does source include sub?
  *
  * char *source;    string to search in
  * char *sub;       substring to look for
@@ -214,8 +208,8 @@ BINDABLE( unbindkey) {
 static boolean strinc( const char *source, const char *sub) {
     /* for each character in the source string */
     for( ; *source ; source++) {
-		const char *nxtsp ;  /* next ptr into source */
+        const char *nxtsp ;  /* next ptr into source */
-		const char *tp ;	/* ptr into substring */
+        const char *tp ;    /* ptr into substring */
 
         nxtsp = source;
 
@@ -232,6 +226,7 @@ static boolean strinc( const char *source, const char *sub) {
     return FALSE ;
 }
 
+
 /* describe bindings
  * bring up a fake buffer and list the key bindings
  * into it with view mode
@@ -240,168 +235,166 @@ BINDABLE( desbind) {
     return buildlist( "") ;
 }
 
+
 /* Apropos (List functions that match a substring) */
 BINDABLE( apro) {
-	char *mstring ;	/* string to match cmd names to */
+    char *mstring ; /* string to match cmd names to */
 
     int status = newmlarg( &mstring, "apropos: ", 0) ;
-	if( status == TRUE) {
+    if( status == TRUE) {
-		status = buildlist( mstring) ;
+        status = buildlist( mstring) ;
-		free( mstring) ;
+        free( mstring) ;
-	} else if( status == FALSE)
+    } else if( status == FALSE)
-		status = buildlist( "") ;	/* build list of all commands */
+        status = buildlist( "") ;   /* build list of all commands */
 
     return status ;
 }
 
-/*
+
- * build a binding list (limited or full)
+/* build a binding list (limited or full)
  *
  * char *mstring;   match string if a partial list, "" matches all
  */
 static int buildlist( char *mstring) {
-    struct window *wp;         /* scanning pointer to windows */
+#define PADDING 28
-    kbind_p ktp;  /* pointer into the command table */
+    char outseq[ PADDING + 8] ;  /* output buffer for command + keystroke */
-    nbind_p nptr;/* pointer into the name binding table */
-    struct buffer *bp;    /* buffer to put binding list into */
-    char outseq[80];      /* output buffer for keystroke sequence */
 
-    /* split the current window to make room for the binding list */
+/* split the current window to make room for the binding list */
-	if( wheadp->w_wndp == NULL			/* One window */
+    if( wheadp->w_wndp == NULL          /* One window */
-	&&  splitwind( FALSE, 1) == FALSE)	/* Split it */
+    &&  splitwind( FALSE, 1) == FALSE)  /* Split it */
-        return FALSE;
+        return FALSE ;
 
-    /* and get a buffer for it */
+/* and get a buffer for it */
-    bp = bfind("*Binding list*", TRUE, 0);
+    buffer_p bp = bfind( "*Binding list*", TRUE, 0) ;
     if( bp == NULL || bclear( bp) == FALSE)
-		return cmdfail( "Can't display binding list") ;
+        return mloutfail( "Can't display binding list") ;
 
-    /* let us know this is in progress */
+/* let us know this is in progress */
-    mlwrite("(Building binding list)");
+    mloutstr( "(Building binding list)") ;
 
-    /* disconnect the current buffer */
+/* disconnect the current buffer */
-    if (--curbp->b_nwnd == 0) { /* Last use.            */
+    if( --curbp->b_nwnd == 0) { /* Last use.            */
-        curbp->b_dotp = curwp->w_dotp;
+        curbp->b_dotp = curwp->w_dotp ;
-        curbp->b_doto = curwp->w_doto;
+        curbp->b_doto = curwp->w_doto ;
-        curbp->b_markp = curwp->w_markp;
+        curbp->b_markp = curwp->w_markp ;
-        curbp->b_marko = curwp->w_marko;
+        curbp->b_marko = curwp->w_marko ;
     }
 
-    /* connect the current window to this buffer */
+/* connect the current window to this buffer */
-    curbp = bp;     /* make this buffer current in current window */
+    curbp = bp ;    /* make this buffer current in current window */
-    bp->b_mode = 0;     /* no modes active in binding list */
+    bp->b_mode = 0 ;    /* no modes active in binding list */
-    bp->b_nwnd++;       /* mark us as more in use */
+    bp->b_nwnd++ ;      /* mark us as more in use */
-    wp = curwp;
+    window_p wp = curwp ;
-    wp->w_bufp = bp;
+    wp->w_bufp = bp ;
-    wp->w_linep = bp->b_linep;
+    wp->w_linep = bp->b_linep ;
-    wp->w_flag = WFHARD | WFFORCE;
+    wp->w_flag = WFHARD | WFFORCE ;
-    wp->w_dotp = bp->b_dotp;
+    wp->w_dotp = bp->b_dotp ;
-    wp->w_doto = bp->b_doto;
+    wp->w_doto = bp->b_doto ;
-    wp->w_markp = NULL;
+    wp->w_markp = NULL ;
-    wp->w_marko = 0;
+    wp->w_marko = 0 ;
 
-    /* build the contents of this window, inserting it line by line */
+/* build the contents of this window, inserting it line by line */
-    for( nptr = names ; nptr->n_func != NULL ; nptr++) {
+    for( nbind_p nptr = names ; nptr->n_func != NULL ; nptr++) {
-	    int cpos ;	/* current position to use in outseq */
+        int cpos ;  /* current position to use in outseq */
 
         /* if we are executing an apropos command..... */
         /* and current string doesn't include the search string */
         if( *mstring && strinc( bind_name( nptr), mstring) == FALSE)
-			continue ;
+            continue ;
 
         /* add in the command name */
         mystrscpy( outseq, bind_name( nptr), sizeof outseq) ;
-        cpos = strlen(outseq);
+        cpos = strlen( outseq) ;
 
         /* search down any keys bound to this */
-        for( ktp = keytab ; ktp->k_code != 0 ; ktp++) {
+        for( kbind_p ktp = keytab ; ktp->k_code != 0 ; ktp++) {
             if( ktp->k_nbp == nptr) {
-                /* padd out some spaces */
+            /* padd out some spaces */
-                while (cpos < 28)
+                while( cpos < PADDING)
-                    outseq[cpos++] = ' ';
+                    outseq[ cpos++] = ' ' ;
 
-                /* add in the command sequence */
+            /* add in the command sequence */
-                cmdstr(ktp->k_code, &outseq[cpos]);
+                cmdstr( ktp->k_code, &outseq[ cpos]) ;
-                strcat(outseq, "\n");
+                strcat( outseq, "\n") ;
 
-                /* and add it as a line into the buffer */
+            /* and add it as a line into the buffer */
-                if (linstr(outseq) != TRUE)
+                if( linstr( outseq) != TRUE)
-                    return FALSE;
+                    return FALSE ;
 
-                cpos = 0;   /* and clear the line */
+                cpos = 0 ;  /* and clear the line */
             }
         }
 
         /* if no key was bound, we need to dump it anyway */
-        if (cpos > 0) {
+        if( cpos > 0) {
-            outseq[cpos++] = '\n';
+            outseq[ cpos++] = '\n';
-            outseq[cpos] = 0;
+            outseq[ cpos] = 0;
-            if (linstr(outseq) != TRUE)
+            if( linstr( outseq) != TRUE)
-                return FALSE;
+                return FALSE ;
         }
     }
 
-    bp->b_mode |= MDVIEW;    /* put this buffer view mode */
+    bp->b_mode |= MDVIEW ;              /* put this buffer view mode */
-    bp->b_flag &= ~BFCHG;    /* don't flag this as a change */
+    bp->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->w_doto = 0 ;
-    upmode() ;			/* and update ALL mode lines */
+    upmode() ;                          /* and update ALL mode lines */
-    mlwrite("");        /* clear the mode line */
+    mloutstr( "") ;                     /* clear the mode line */
-    return TRUE;
+    return TRUE ;
 }
 
-/*
+
- * get a command key sequence from the keyboard
+/* get a command key sequence from the keyboard
  *
  * int mflag;       going for a meta sequence?
  * returns ~0 on failure
  */
 static unsigned int getckey( int mflag) {
-    unsigned int c ;	/* character fetched */
+    unsigned int c ;    /* character fetched */
 
     /* check to see if we are executing a command line */
     if( clexec) {
-		char *tok = getnewtokval() ;	/* get the next token */
+        char *tok = getnewtokval() ;    /* get the next token */
-		if( tok == NULL)
+        if( tok == NULL)
-			c = ~0 ;	/* return invalid key on failure */
+            c = ~0 ;    /* return invalid key on failure */
-		else {
+        else {
-			c = stock( tok) ;
+            c = stock( tok) ;
-			free( tok) ;
+            free( tok) ;
-		}
+        }
-    } else {	/* or the normal way */
+    } else {    /* or the normal way */
-	    if( mflag)
+        if( mflag)
-    	    c = get1key() ;
+            c = get1key() ;
-    	else
+        else
-			c = getcmd() ;
+            c = getcmd() ;
-	}
+    }
 
-	return c ;
+    return c ;
 }
 
-/*
+
- * execute the startup file
+/* execute the startup file
  *
  * char *fname;    name of startup file (null if default)
  */
 int startup( const char *fname) {
-	if( !fname || *fname == 0)		/* use default if empty parameter */
+    if( !fname || *fname == 0)      /* use default if empty parameter */
-		fname = rcfname ;
+        fname = rcfname ;
 
-	fname = flook( fname, TRUE) ;	/* look up the startup file */
+    fname = flook( fname, TRUE) ;   /* look up the startup file */
-	if( fname == NULL)				/* if it isn't around, don't sweat it */
+    if( fname == NULL)              /* if it isn't around, don't sweat it */
-		return TRUE ;
+        return TRUE ;
 
-	return dofile( fname) ;			/* otherwise, execute the sucker */
+    return dofile( fname) ;         /* otherwise, execute the sucker */
 }
 
-/*
+
- * change a key command to a string we can print out
+/* change a key command to a string we can print out
  *
  * int c;       sequence to translate
  * char *seq;       destination string for sequence
  */
 static char *cmdstr( unsigned c, char *seq) {
-    char *ptr = seq ;	/* pointer into current position in sequence */
+    char *ptr = seq ;   /* pointer into current position in sequence */
 
 /* apply meta sequence if needed */
     if( c & META) {
@@ -411,14 +404,14 @@ static char *cmdstr( unsigned c, char *seq) {
 
 /* apply ^X sequence if needed */
     if( c & CTLX) {
-		if( ctlxc & CTRL)
+        if( ctlxc & CTL_)
-	        *ptr++ = '^' ;
+            *ptr++ = '^' ;
 
         *ptr++ = ctlxc & ~PRFXMASK ;
     }
 
 /* apply control sequence if needed */
-    if( c & CTRL)
+    if( c & CTL_)
         *ptr++ = '^' ;
 
 /* apply SPEC sequence if needed */
@@ -428,22 +421,24 @@ static char *cmdstr( unsigned c, char *seq) {
     }
 
 /* and output the final sequence */
-	ptr += unicode_to_utf8( c & ~PRFXMASK, ptr) ;
+    ptr += unicode_to_utf8( c & ~PRFXMASK, ptr) ;
-    *ptr = 0 ;			/* terminate the string */
+    *ptr = 0 ;          /* terminate the string */
-	return seq ;
+    return seq ;
 }
 
+
 static const char *getfname( unsigned keycode, const char *failmsg) {
 /* takes a key code and gets the name of the function bound to it */
-	kbind_p kbp = getkeybinding( keycode) ;
+    kbind_p kbp = getkeybinding( keycode) ;
-	if( kbp->k_code == 0)
+    if( kbp->k_code == 0)
-		return failmsg ;
+        return failmsg ;
 
-	const char *found = bind_name( kbp->k_nbp) ;
+    const char *found = bind_name( kbp->k_nbp) ;
-	assert( *found) ;
+    assert( *found) ;
-	return found ;
+    return found ;
 }
 
+
 /* stock:
  *  String key name TO Command Key
  *
@@ -466,7 +461,7 @@ static unsigned int stock( char *keyname) {
 
 /* a control char? */
     if( *keyname == '^' && keyname[ 1] != 0) {
-        c |= CTRL ;
+        c |= CTL_ ;
         ++keyname ;
     }
 
@@ -477,16 +472,16 @@ static unsigned int stock( char *keyname) {
     }
 
 /* only one character left to parse */
-	if( !*keyname || keyname[1])
+    if( !*keyname || keyname[1])
-		return ~0 ;
+        return ~0 ;
 
 /* only way to redefine ^X is by quoting binary value */
     if( *keyname < 32 || *keyname == 0x7F) {
-        c |= CTRL ;
+        c |= CTL_ ;
         *keyname ^= 0x40 ;
-    } else	if( c && !(c & SPEC)
+    } else  if( c && !(c & SPEC)
-			&&	*keyname >= 'a' && *keyname <= 'z')
+            &&  *keyname >= 'a' && *keyname <= 'z')
-	/* make sure we are not lower case (not with function keys) */
+    /* make sure we are not lower case (not with function keys) */
         *keyname -= 32 ;
 
 /* the final sequence... */
@@ -494,19 +489,19 @@ static unsigned int stock( char *keyname) {
     return c ;
 }
 
-/*
+
- * string key name to binding name....
+/* string key name to binding name....
  *
  * char *skey;      name of key to get binding for
  */
 const char *transbind( char *skey) {
-	static const char failmsg[] = "ERROR" ;
+    static const char failmsg[] = "ERROR" ;
 
-	unsigned c = stock( skey) ;
+    unsigned c = stock( skey) ;
-	if( c == (unsigned) ~0)
+    if( c == (unsigned) ~0)
-		return failmsg ;
+        return failmsg ;
-	else
+    else
-	    return getfname( c, failmsg) ;
+        return getfname( c, failmsg) ;
 }
 
 /* end of bind.c */

bind.h

@@ -1,3 +1,5 @@
+/* bind.h -- bindable functions dealing with name and key bindings */
+
 #ifndef _BIND_H_
 #define _BIND_H_
 
@@ -14,6 +16,8 @@ BINDABLE( unbindkey) ;
 int startup( const char *fname) ;
 
 /* find a key to function association in the key to function mapping table */
-const char *transbind( char *skey) ;	/* by string representation of key */
+const char *transbind( char *skey) ;    /* by string representation of key */
 
 #endif
+
+/* end of bind.h */

bindable.c

@@ -3,146 +3,127 @@
 
 #include <stdlib.h>
 
-
 #include "defines.h"
 #include "buffer.h"
-#include "display.h"
+#include "display.h"    /* vttidy() */
-#include "estruct.h"
 #include "file.h"
 #include "input.h"
 #include "lock.h"
 #include "mlout.h"
 #include "terminal.h"
 
-/*
+
- * Fancy quit command, as implemented by Norm. If the any buffer has
+/* Fancy quit command, as implemented by Norm.  If any buffer has changed
- * changed do a write on that buffer and exit emacs, otherwise simply exit.
+   do a write on that buffer and exit emacs, otherwise simply exit.
  */
-int quickexit(int f, int n)
+BINDABLE( quickexit) {
-{
+    buffer_p oldcb = curbp ;    /* save in case we fail */
-	struct buffer *bp;	/* scanning pointer to buffers */
+    for( buffer_p bp = bheadp ; bp != NULL ; bp = bp->b_bufp) {
-	struct buffer *oldcb;	/* original current buffer */
+        if( (bp->b_flag & (BFCHG | BFTRUNC | BFINVS)) == BFCHG) {
-	int status;
+        /* Changed, Not truncated and real buffer */
+            curbp = bp ;    /* make that buffer cur */
+            mloutfmt( "(Saving %s)", bp->b_fname) ;
+            int status = filesave( f, n) ;
+            if( status != TRUE) {
+                curbp = oldcb ; /* restore curbp */
+                return status ;
+            }
+        }
+    }
 
-	oldcb = curbp;		/* save in case we fail */
+    return quit( f, n) ;    /* conditionally quit   */
-
-	bp = bheadp;
-	while (bp != NULL) {
-		if ((bp->b_flag & BFCHG) != 0	/* Changed.             */
-		    && (bp->b_flag & BFTRUNC) == 0	/* Not truncated P.K.   */
-		    && (bp->b_flag & BFINVS) == 0) {	/* Real.                */
-			curbp = bp;	/* make that buffer cur */
-			mloutfmt( "(Saving %s)", bp->b_fname) ;
-#if	PKCODE
-#else
-			mloutstr( "\n") ;
-#endif
-			if ((status = filesave(f, n)) != TRUE) {
-				curbp = oldcb;	/* restore curbp */
-				return status;
-			}
-		}
-		bp = bp->b_bufp;	/* on to the next buffer */
-	}
-	quit(f, n);		/* conditionally quit   */
-	return TRUE;
 }
 
-/*
+
- * Quit command. If an argument, always quit. Otherwise confirm if a buffer
+/* Quit command. If an argument, always quit. Otherwise confirm if a buffer
  * has been changed and not written out. Normally bound to "C-X C-C".
  */
-int quit(int f, int n)
+BINDABLE( quit) {
-{
+    int s ; /* status of user query */
-	int s;
 
-	if (f != FALSE		/* Argument forces it.  */
+    if( f != FALSE      /* Argument forces it.  */
-	    || anycb() == FALSE	/* All buffers clean.   */
+    || anycb() == FALSE /* All buffers clean.   */
-	    /* User says it's OK.   */
+                        /* User says it's OK.   */
-	    || (s =
+    || (s = mlyesno( "Modified buffers exist. Leave anyway")) == TRUE) {
-		mlyesno("Modified buffers exist. Leave anyway")) == TRUE) {
+#if (FILOCK && BSD) || SVR4
-#if	(FILOCK && BSD) || SVR4
+        if( lockrel() != TRUE) {
-		if (lockrel() != TRUE) {
+            TTputc('\n') ;
-			TTputc('\n');
+            TTputc('\r') ;
-			TTputc('\r');
+            TTclose() ;
-			TTclose();
+            TTkclose() ;
-			TTkclose();
+            exit( EXIT_FAILURE) ;
-			exit( EXIT_FAILURE) ;
+        }
-		}
 #endif
-		vttidy();
+        vttidy() ;
-		if (f)
+        if( f)
-			exit(n);
+            exit( n) ;
-		else
+        else
-			exit( EXIT_SUCCESS) ;
+            exit( EXIT_SUCCESS) ;
-	}
+    }
-	mloutstr( "") ;
+
-	return s;
+    mloutstr( "") ;
+    return s ;
 }
 
-/*
+
- * Begin a keyboard macro.
+/* Begin a keyboard macro.
  * Error if not at the top level in keyboard processing. Set up variables and
  * return.
  */
-int ctlxlp(int f, int n)
+BBINDABLE( ctlxlp) {
-{
+    if( kbdmode != STOP)
-	if (kbdmode != STOP) {
+        return mloutfail( "%Macro already active") ;
-		mloutstr( "%Macro already active") ;
+
-		return FALSE;
+    mloutstr( "(Start macro)") ;
-	}
+    kbdptr = kbdm ;
-	mloutstr( "(Start macro)") ;
+    kbdend = kbdptr ;
-	kbdptr = &kbdm[0];
+    kbdmode = RECORD ;
-	kbdend = kbdptr;
+    return TRUE ;
-	kbdmode = RECORD;
-	return TRUE;
 }
 
-/*
+
- * End keyboard macro. Check for the same limit conditions as the above
+/* End keyboard macro. Check for the same limit conditions as the above
  * routine. Set up the variables and return to the caller.
  */
-int ctlxrp(int f, int n)
+BBINDABLE( ctlxrp) {
-{
+    if( kbdmode == STOP)
-	if (kbdmode == STOP) {
+        return mloutfail( "%Macro not active") ;
-		mloutstr( "%Macro not active") ;
+
-		return FALSE;
+    if (kbdmode == RECORD) {
-	}
+        mloutstr( "(End macro)") ;
-	if (kbdmode == RECORD) {
+        kbdmode = STOP;
-		mloutstr( "(End macro)") ;
+    }
-		kbdmode = STOP;
+
-	}
+    return TRUE ;
-	return TRUE;
 }
 
-/*
+
- * Execute a macro.
+/* Execute a macro.
  * The command argument is the number of times to loop. Quit as soon as a
  * command gets an error. Return TRUE if all ok, else FALSE.
  */
-int ctlxe(int f, int n)
+BBINDABLE( ctlxe) {
-{
+    if( kbdmode != STOP)
-	if (kbdmode != STOP) {
+        return mloutfail( "%Macro already active") ;
-		mloutstr( "%Macro already active") ;
+
-		return FALSE;
+    if( n <= 0)
-	}
+        return TRUE ;
-	if (n <= 0)
+
-		return TRUE;
+    kbdrep = n ;        /* remember how many times to execute */
-	kbdrep = n;		/* remember how many times to execute */
+    kbdmode = PLAY ;    /* start us in play mode */
-	kbdmode = PLAY;		/* start us in play mode */
+    kbdptr = kbdm ;     /*    at the beginning */
-	kbdptr = &kbdm[0];	/*    at the beginning */
+    return TRUE ;
-	return TRUE;
 }
 
-/*
+
- * abort:
+/* abort:
  *  Beep the beeper. Kill off any keyboard macro, etc., that is in progress.
  *  Sometimes called as a routine, to do general aborting of stuff.
  */
-int ctrlg( int f, int n) {
+BINDABLE( ctrlg) {
-	kbdmode = STOP ;
+    kbdmode = STOP ;
-	mloutfmt( "%B(Aborted)") ;
+    mloutfmt( "%B(Aborted)") ;
-	return ABORT ;
+    return ABORT ;
 }
 
 /* end of bindable.c */

bindable.h

@@ -1,9 +1,16 @@
+/* bindable.h -- misc bindable functions */
+#ifndef _BINDABLE_H_
+#define _BINDABLE_H_
+
 #include "names.h"
 
 /* functions that can be bound to keys or procedure names */
-BINDABLE( quickexit) ;
+BBINDABLE( ctlxe) ;
-BINDABLE( quit) ;
+BBINDABLE( ctlxlp) ;
-BINDABLE( ctlxlp) ;
+BBINDABLE( ctlxrp) ;
-BINDABLE( ctlxrp) ;
+ BINDABLE( ctrlg) ;		/* ABORT */
-BINDABLE( ctlxe) ;
+ BINDABLE( quickexit) ;
-BINDABLE( ctrlg) ;
+ BINDABLE( quit) ;
+
+#endif
+/* end of bindable.h */

buffer.h

@@ -1,74 +1,82 @@
+/* buffer.h -- buffer type and functions */
 #ifndef _BUFFER_H_
-#define _BUFFER_H_
+# define _BUFFER_H_
 
 #include "line.h"
+#include "names.h"
 
-typedef char fname_t[ 256] ;	/* file name type */
+/* Text is kept in buffers.  A buffer header, described below, exists for
-typedef char bname_t[ 16] ;		/* buffer name type */
+   every buffer in the system.  The buffers are kept in a big list, so that
+   commands that search for a buffer by name can find the buffer header.
+   There is a safe store for the dot and mark in the header, but this is
+   only valid if the buffer is not being displayed (that is, if "b_nwnd" is
+   0).  The text for the buffer is kept in a circularly linked list of
+   lines, with a pointer to the header line in "b_linep".
 
-/*
+   Buffers may be "Inactive" which means the files associated with them
- * Text is kept in buffers. A buffer header, described below, exists for every
+   have not been read in yet.  These get read in at "use buffer" time.
- * buffer in the system. The buffers are kept in a big list, so that commands
- * that search for a buffer by name can find the buffer header. There is a
- * safe store for the dot and mark in the header, but this is only valid if
- * the buffer is not being displayed (that is, if "b_nwnd" is 0). The text for
- * the buffer is kept in a circularly linked list of lines, with a pointer to
- * the header line in "b_linep".
- * 	Buffers may be "Inactive" which means the files associated with them
- * have not been read in yet. These get read in at "use buffer" time.
  */
+
+typedef char fname_t[ 256] ;    /* file name type */
+typedef char bname_t[ 16] ;     /* buffer name type */
+
 typedef struct buffer {
-    struct buffer *b_bufp;	/* Link to next struct buffer   */
+    struct buffer *b_bufp ; /* Link to next struct buffer           */
-	line_p b_dotp ;		/* Link to "." struct line structure   */
+    line_p b_dotp ;         /* Link to "." struct line structure    */
-	line_p b_markp ;	/* The same as the above two,   */
+    line_p b_markp ;        /* The same as the above two,           */
-	line_p b_linep ;	/* Link to the header struct line      */
+    line_p b_linep ;        /* Link to the header struct line       */
-	int b_doto;		/* Offset of "." in above struct line  */
+    int b_doto ;            /* Offset of "." in above struct line   */
-	int b_marko;		/* but for the "mark"           */
+    int b_marko ;           /* but for the "mark"           */
-	int b_mode;		/* editor mode of this buffer   */
+    int b_mode ;            /* editor mode of this buffer   */
-	char b_active;		/* window activated flag        */
+    char b_active ;         /* window activated flag        */
-	char b_nwnd;		/* Count of windows on buffer   */
+    char b_nwnd ;           /* Count of windows on buffer   */
-	char b_flag;		/* Flags                        */
+    char b_flag ;           /* Flags                        */
-	fname_t b_fname ;	/* File name                    */
+    fname_t b_fname ;       /* File name                    */
-	bname_t b_bname ;	/* Buffer name                  */
+    bname_t b_bname ;       /* Buffer name                  */
 } *buffer_p ;
 
-extern buffer_p curbp ;		/* Current buffer               */
+extern buffer_p curbp ;     /* Current buffer               */
-extern buffer_p bheadp ;	/* Head of list of buffers      */
+extern buffer_p bheadp ;    /* Head of list of buffers      */
-extern buffer_p blistp ;	/* Buffer for C-X C-B           */
+extern buffer_p blistp ;    /* Buffer for C-X C-B           */
 
-#define BFINVS  0x01		/* Internal invisable buffer    */
+#define BFINVS  0x01        /* Internal invisable buffer    */
-#define BFCHG   0x02		/* Changed since last write     */
+#define BFCHG   0x02        /* Changed since last write     */
-#define	BFTRUNC	0x04		/* buffer was truncated when read */
+#define BFTRUNC 0x04        /* buffer was truncated when read */
 
-/*	mode flags	*/
+/*  mode flags  */
-#define	NUMMODES	9		/* # of defined modes           */
+#define NUMMODES    9       /* # of defined modes           */
 
-#define	MDWRAP	0x0001		/* word wrap                    */
+#define MDWRAP  0x0001      /* word wrap                    */
-#define	MDCMOD	0x0002		/* C indentation and fence match */
+#define MDCMOD  0x0002      /* C indentation and fence match */
-#define	MDEXACT	0x0004		/* Exact matching for searches  */
+#define MDEXACT 0x0004      /* Exact matching for searches  */
-#define	MDVIEW	0x0008		/* read-only buffer             */
+#define MDVIEW  0x0008      /* read-only buffer             */
-#define MDOVER	0x0010		/* overwrite mode               */
+#define MDOVER  0x0010      /* overwrite mode               */
-#define MDMAGIC	0x0020		/* regular expresions in search */
+#define MDMAGIC 0x0020      /* regular expresions in search */
-#define	MDASAVE	0x0040		/* auto-save mode               */
+#define MDASAVE 0x0040      /* auto-save mode               */
-#define MDUTF8	0x0080		/* utf8 mode                    */
+#define MDUTF8  0x0080      /* utf8 mode                    */
-#define MDDOS	0x0100		/* CRLF eol mode                */
+#define MDDOS   0x0100      /* CRLF eol mode                */
+
+extern const char *modename[ NUMMODES] ;    /* text names of modes */
+extern int gmode ;                          /* global editor mode */
 
 
-extern const char *modename[] ;	/* text names of modes          */
+/* Bindable functions */
-extern int gmode ;		/* global editor mode           */
+BINDABLE( killbuffer) ;
+BINDABLE( listbuffers) ;
+BINDABLE( namebuffer) ;
+BINDABLE( nextbuffer) ;
+BINDABLE( unmark) ;
+BINDABLE( usebuffer) ;
 
+boolean anycb( void) ;          /* Any changed buffer? */
+int bclear( buffer_p bp) ;      /* empty buffer */
+int swbuffer( buffer_p bp) ;    /* switch to buffer, make it current */
+int zotbuf( buffer_p bp) ;      /* remove buffer */
 
-int usebuffer( int f, int n) ;
+/* Lookup a buffer by name.  If not found and create_f is TRUE then create
-int nextbuffer( int f, int n) ;
+   it with flags set.
-int swbuffer( buffer_p bp) ;
+*/
-int killbuffer( int f, int n) ;
+buffer_p bfind( const char *bname, boolean create_f, int flags) ;
-int zotbuf( buffer_p bp) ;
-int namebuffer( int f, int n) ;
-int listbuffers( int f, int n) ;
-int anycb( void) ;
-int bclear( buffer_p bp) ;
-int unmark( int f, int n) ;
-/* Lookup a buffer by name. */
-buffer_p bfind( const char *bname, int cflag, int bflag) ;
 
 #endif
+/* end of buffer.h */

display.c

@@ -1,17 +1,14 @@
 /* display.c -- implements display.h */
-
 #include "display.h"
 
 #define	REVSTA	1  /* Status line appears in reverse video         */
 
-/*	display.c
+/* The functions in this file handle redisplay.  There are two halves, the
- *
+   ones that update the virtual display screen, and the ones that make the
- *      The functions in this file handle redisplay. There are two halves, the
+   physical display screen the same as the virtual display screen.  These
- *      ones that update the virtual display screen, and the ones that make the
+   functions use hints that are left in the windows by the commands.
- *      physical display screen the same as the virtual display screen. These
+
- *      functions use hints that are left in the windows by the commands.
+   Modified by Petri Kutvonen
- *
- *	Modified by Petri Kutvonen
  */
 
 #include <errno.h>
@@ -251,40 +248,37 @@ static void vteeol( void) {
 		vcp[ vtcol++] = ' ' ;
 }
 
-/*
+/* upscreen:
- * upscreen:
  *	user routine to force a screen update
  *	always finishes complete update
  */
-int upscreen(int f, int n)
+BINDABLE( upscreen) {
-{
+	update( TRUE) ;
-	update(TRUE);
+	return TRUE ;
-	return TRUE;
 }
 
 #if SCROLLCODE
 static int scrflags;
 #endif
 
-/*
+
- * Make sure that the display is right. This is a three part process. First,
+/* Make sure that the display is right.  This is a three part process.
- * scan through all of the windows looking for dirty ones. Check the framing,
+   First, scan through all of the windows looking for dirty ones.  Check
- * and refresh the screen. Second, make sure that "currow" and "curcol" are
+   the framing, and refresh the screen.  Second, make sure that "currow"
- * correct for the current window. Third, make the virtual and physical
+   and "curcol" are correct for the current window.  Third, make the
- * screens the same.
+   virtual and physical screens the same.
- *
+
- * int force;		force update past type ahead?
+   boolean force_f ;		force update past type ahead?
  */
-int update(int force)
+int update( boolean force_f) {
-{
 	struct window *wp;
 
 #if	TYPEAH && ! PKCODE
-	if (force == FALSE && typahead())
+	if( force_f == FALSE && typahead())
 		return TRUE;
 #endif
 #if	VISMAC == 0
-	if (force == FALSE && kbdmode == PLAY)
+	if( force_f == FALSE && kbdmode == PLAY)
 		return TRUE;
 #endif
 
@@ -359,7 +353,7 @@ int update(int force)
 		updgar();
 
 	/* update the virtual screen to the physical screen */
-	updupd(force);
+	updupd( force_f) ;
 
 	/* update the cursor and flush the buffers */
 	movecursor(currow, curcol - lbound);

display.h

@@ -1,10 +1,12 @@
+/* display.h -- display functionality */
 #ifndef _DISPLAY_H_
-#define _DISPLAY_H_
+# define _DISPLAY_H_
 
-#include <stdarg.h>
+# include <stdarg.h>
 
-#include "estruct.h"
+# include "estruct.h"
-#include "utf8.h"
+# include "names.h"		/* BINDABLE() */
+# include "utf8.h"		/* unicode_t */
 
 extern int mpresf ;		/* Stuff in message line */
 extern int scrollcount ;	/* number of lines to scroll */
@@ -13,11 +15,13 @@ extern int disinp ;		/* display input characters (echo)	*/
 extern int gfcolor ;		/* global forgrnd color (white) */
 extern int gbcolor ;		/* global backgrnd color (black) */
 
+/* Bindable functions */
+BINDABLE( upscreen) ;
+
 void vtinit( void) ;
 void vtfree( void) ;
 void vttidy( void) ;
-int upscreen( int f, int n) ;
+int update( boolean force_f) ;
-int update( int force) ;
 void updpos( void) ;
 void upddex( void) ;
 void updgar( void) ;
@@ -33,13 +37,13 @@ void echos( const char *s) ;
 void rubout( void) ;
 void getscreensize( int *widthp, int *heightp) ;
 
-#if UNIX
+# if UNIX
-#include <signal.h>
+#  include <signal.h>
-#ifdef SIGWINCH
+#  ifdef SIGWINCH
 extern int chg_width, chg_height ;
 
 void sizesignal( int signr) ;
+#  endif
+# endif
 #endif
-#endif
+/* end of display.h */
-
-#endif

eval.c

@@ -1,9 +1,7 @@
 /* eval.c -- implements eval.h */
 #include "eval.h"
 
-/*	eval.c
+/*	Expression evaluation functions
- *
- *	Expression evaluation functions
  *
  *	written 1986 by Daniel Lawrence
  *	modified by Petri Kutvonen
@@ -210,7 +208,7 @@ static struct {
 	{ "and", UFAND		| DYNAMIC },	/* logical and */
 	{ "asc", UFASCII	| MONAMIC },	/* char to integer conversion */
 	{ "ban", UFBAND		| DYNAMIC },	/* bitwise and   9-10-87  jwm */
-	{ "bin", UFBIND		| MONAMIC },	/* loopup what function name is bound to a key */
+	{ "bin", UFBIND		| MONAMIC },	/* look up function name bound to key */
 	{ "bno", UFBNOT		| MONAMIC },	/* bitwise not */
 	{ "bor", UFBOR		| DYNAMIC },	/* bitwise or    9-10-87  jwm */
 	{ "bxo", UFBXOR		| DYNAMIC },	/* bitwise xor   9-10-87  jwm */
@@ -797,14 +795,13 @@ static char *gtenv( char *vname) {
 	return errorm ;
 }
 
-/*
+
- * set a variable
+/* set a variable
  *
  * int f;		default flag
  * int n;		numeric arg (can overide prompted value)
  */
-int setvar(int f, int n)
+BINDABLE( setvar) {
-{
 	int status;	/* status return */
 	struct variable_description vd;		/* variable num/type */
 	char var[NVSIZE + 2];	/* name of variable to fetch %1234567890\0 */
@@ -1466,28 +1463,25 @@ static void mlforce( char *s) {
 	discmd = oldcmd;	/* and restore the original setting */
 }
 
-/*
+
- * This function simply clears the message line,
+/* This function simply clears the message line, mainly for macro usage
- * mainly for macro usage
  *
  * int f, n;		arguments ignored
  */
-int clrmes( int f, int n) {
+TBINDABLE( clrmes) {
 	mlforce( "") ;
 	return TRUE ;
 }
 
-/*
- * This function writes a string on the message line
- * mainly for macro usage
- *
- * int f, n;		arguments ignored
- */
-int writemsg( int f, int n) {
-	int status ;
-	char *buf ;		/* buffer to receive message into */
 
-	status = newmlarg( &buf, "Message to write: ", 0) ;
+/* This function writes a string on the message line mainly for macro usage
+ *
+ * int f, n; arguments ignored
+ */
+BINDABLE( writemsg) {
+	char *buf ; /* buffer to receive message into */
+
+	int status = newmlarg( &buf, "write-message: ", 0) ;
 	if( status == TRUE) {
 	/* write the message out */
 		mlforce( buf) ;

eval.h

@@ -1,29 +1,33 @@
+/* eval.h -- variables and operands evaluation */
 #ifndef _EVAL_H_
-#define _EVAL_H_
+# define _EVAL_H_
 
+#include "names.h"
 
-#define DEBUGM	1		/* $debug triggers macro debugging	*/
+#define DEBUGM  1       /* $debug triggers macro debugging  */
 
-#if	DEBUGM
+# if    DEBUGM
 int mdbugout( char *fmt, ...) ;
-#endif
+# endif
 
-
+extern int macbug ;     /* macro debuging flag          */
-extern int macbug ;		/* macro debuging flag          */
+extern int cmdstatus ;  /* last command status          */
-extern int cmdstatus ;		/* last command status          */
+extern int rval ;       /* return value of a subprocess */
-extern int rval ;		/* return value of a subprocess */
+extern long envram ;    /* # of bytes current in use by malloc */
-extern long envram ;		/* # of bytes current in use by malloc */
 
 int readfirst_f( void) ;
 int is_it_cmd( char *token) ;
 
 void varinit( void) ;
-int setvar( int f, int n) ;
 const char *getval( char *token) ;
 int stol( char *val) ;
 char *mklower( char *str) ;
 
-int clrmes( int f, int n) ;
+/* Bindable functions */
-int writemsg( int f, int n) ;
+TBINDABLE( clrmes) ;
+BINDABLE( setvar) ;
+BINDABLE( writemsg) ;
 
 #endif
+
+/* end of eval.h */

exec.h

@@ -1,69 +1,65 @@
+/* exec.h -- bindable functions to execute functions, macros and procedures */
 #ifndef _EXEC_H_
-#define _EXEC_H_
+# define _EXEC_H_
 
-#include "retcode.h"
+#include "names.h"
 
+extern boolean clexec ; /* command line execution flag  */
 
-#define	PROC	1	/* named procedures  */
+int dofile( const char *fname) ;
-
-#if PROC
-int storeproc( int f, int n) ;
-int execproc( int f, int n) ;
-#endif
-
-
-extern boolean clexec ;	/* command line execution flag  */
-
-
-int namedcmd( int f, int n) ;
-int execcmd( int f, int n) ;
 void gettoken( char *tok, int maxtoksize) ;
 boolean gettokval( char *tok, int maxtoksize) ;
 char *getnewtokval( void) ;
-int storemac( int f, int n) ;
-int execbuf( int f, int n) ;
-int execfile( int f, int n) ;
-int dofile( const char *fname) ;
 
-int cbuf1( int f, int n) ;
+/* Bindable functions */
-int cbuf2( int f, int n) ;
+BINDABLE( execbuf) ;
-int cbuf3( int f, int n) ;
+BINDABLE( execcmd) ;
-int cbuf4( int f, int n) ;
+BINDABLE( execfile) ;
-int cbuf5( int f, int n) ;
+BINDABLE( execproc) ;
-int cbuf6( int f, int n) ;
+BINDABLE( namedcmd) ;
-int cbuf7( int f, int n) ;
+BINDABLE( storemac) ;
-int cbuf8( int f, int n) ;
+BINDABLE( storeproc) ;
-int cbuf9( int f, int n) ;
+BINDABLE( cbuf1) ;
-int cbuf10( int f, int n) ;
+BINDABLE( cbuf2) ;
-int cbuf11( int f, int n) ;
+BINDABLE( cbuf3) ;
-int cbuf12( int f, int n) ;
+BINDABLE( cbuf4) ;
-int cbuf13( int f, int n) ;
+BINDABLE( cbuf5) ;
-int cbuf14( int f, int n) ;
+BINDABLE( cbuf6) ;
-int cbuf15( int f, int n) ;
+BINDABLE( cbuf7) ;
-int cbuf16( int f, int n) ;
+BINDABLE( cbuf8) ;
-int cbuf17( int f, int n) ;
+BINDABLE( cbuf9) ;
-int cbuf18( int f, int n) ;
+BINDABLE( cbuf10) ;
-int cbuf19( int f, int n) ;
+BINDABLE( cbuf11) ;
-int cbuf20( int f, int n) ;
+BINDABLE( cbuf12) ;
-int cbuf21( int f, int n) ;
+BINDABLE( cbuf13) ;
-int cbuf22( int f, int n) ;
+BINDABLE( cbuf14) ;
-int cbuf23( int f, int n) ;
+BINDABLE( cbuf15) ;
-int cbuf24( int f, int n) ;
+BINDABLE( cbuf16) ;
-int cbuf25( int f, int n) ;
+BINDABLE( cbuf17) ;
-int cbuf26( int f, int n) ;
+BINDABLE( cbuf18) ;
-int cbuf27( int f, int n) ;
+BINDABLE( cbuf19) ;
-int cbuf28( int f, int n) ;
+BINDABLE( cbuf20) ;
-int cbuf29( int f, int n) ;
+BINDABLE( cbuf21) ;
-int cbuf30( int f, int n) ;
+BINDABLE( cbuf22) ;
-int cbuf31( int f, int n) ;
+BINDABLE( cbuf23) ;
-int cbuf32( int f, int n) ;
+BINDABLE( cbuf24) ;
-int cbuf33( int f, int n) ;
+BINDABLE( cbuf25) ;
-int cbuf34( int f, int n) ;
+BINDABLE( cbuf26) ;
-int cbuf35( int f, int n) ;
+BINDABLE( cbuf27) ;
-int cbuf36( int f, int n) ;
+BINDABLE( cbuf28) ;
-int cbuf37( int f, int n) ;
+BINDABLE( cbuf29) ;
-int cbuf38( int f, int n) ;
+BINDABLE( cbuf30) ;
-int cbuf39( int f, int n) ;
+BINDABLE( cbuf31) ;
-int cbuf40( int f, int n) ;
+BINDABLE( cbuf32) ;
+BINDABLE( cbuf33) ;
+BINDABLE( cbuf34) ;
+BINDABLE( cbuf35) ;
+BINDABLE( cbuf36) ;
+BINDABLE( cbuf37) ;
+BINDABLE( cbuf38) ;
+BINDABLE( cbuf39) ;
+BINDABLE( cbuf40) ;
 
 #endif
+
+/* end of exec.h */

file.c

@@ -1,13 +1,11 @@
 /* file.c -- implements file.h */
 #include "file.h"
 
-/*	file.c
+/* The routines in this file handle the reading, writing and lookup of disk
- *
+   files.  All of details about the reading and writing of the disk are in
- *	The routines in this file handle the reading, writing
+   "fileio.c".
- *	and lookup of disk files.  All of details about the
+
- *	reading and writing of the disk are in "fileio.c".
+   modified by Petri Kutvonen
- *
- *	modified by Petri Kutvonen
  */
 
 #include <assert.h>
@@ -233,8 +231,8 @@ int getfile( const char *fname, boolean lockfl) {
 	return s;
 }
 
-/*
+
- * Read file "fname" into the current buffer, blowing away any text
+/* Read file "fname" into the current buffer, blowing away any text
  * found there.  Called by both the read and find commands.  Return
  * the final status of the read.  Also called by the mainline, to
  * read in a file specified on the command line as an argument.
@@ -284,10 +282,10 @@ int readin(const char *fname, boolean lockfl)
 
 	/* read the file in */
 		mloutstr( "(Reading file)") ;
-		while ((s = ffgetline()) == FIOSUC) {
+		while( (s = ffgetline()) == FIOSUC) {
 			line_p	lp ;
 
-			if( nline >= 10000000 /* MAXNLINE Maximum # of lines from one file */
+			if( nline >= 10000000 /* Maximum # of lines from one file */
 			||	(lp = lalloc( fpayload)) == NULL) {
 				s = FIOMEM ;	/* Keep message on the	*/
 				break ; 		/* display. 			*/
@@ -327,12 +325,11 @@ int readin(const char *fname, boolean lockfl)
 		if( fcode == FCODE_UTF_8)
 			curbp->b_mode |= MDUTF8 ;
 
-		if( s == FIOERR) {
+		if( s == FIOERR
-			errmsg = "I/O ERROR, " ;
+		||	s == FIOMEM) {
-			curbp->b_flag |= BFTRUNC ;
+			errmsg = (s == FIOERR) ? "I/O ERROR, " : "OUT OF MEMORY, " ;
-		} else if( s == FIOMEM) {
-			errmsg = "OUT OF MEMORY, " ;
 			curbp->b_flag |= BFTRUNC ;
+			curbp->b_mode |= MDVIEW ;	/* force view mode as lost data */
 		} else
 			errmsg = "" ;
 
@@ -464,10 +461,8 @@ BINDABLE( filesave) {
 
 	/* complain about truncated files */
 	if( (curbp->b_flag & BFTRUNC) != 0
-	&&	mlyesno("Truncated file ... write it out") == FALSE) {
+	&&	mlyesno( "Truncated file ... write it out") == FALSE)
-		mloutfmt( "%B(Aborted)") ;
+		return mloutfail( "(Aborted)") ;
-		return FALSE ;
-	}
 
 	return writeout( curbp->b_fname) ;
 }

input.c

@@ -15,9 +15,10 @@
 #include "bind.h"
 #include "estruct.h"
 #include "bindable.h"
-#include "display.h"
+#include "display.h"	/* rubout(), echos(), echoc(), update() */
 #include "exec.h"
 #include "isa.h"
+#include "mlout.h"
 #include "names.h"
 #include "terminal.h"
 #include "utf8.h"
@@ -38,12 +39,12 @@ kbdstate kbdmode = STOP ;   /* current keyboard macro mode  */
 int lastkey = 0 ;       /* last keystoke                */
 int kbdrep = 0 ;        /* number of repetitions        */
 
-int metac = CTRL | '[' ;		/* current meta character 	 */
+int metac = CTL_ | '[' ;		/* current meta character 	 */
-int ctlxc = CTRL | 'X' ;		/* current control X prefix char */
+int ctlxc = CTL_ | 'X' ;		/* current control X prefix char */
-int reptc = CTRL | 'U' ;		/* current universal repeat char */
+int reptc = CTL_ | 'U' ;		/* current universal repeat char */
-int abortc = CTRL | 'G' ;		/* current abort command char	 */
+int abortc = CTL_ | 'G' ;		/* current abort command char	 */
 
-const int nlc = CTRL | 'J' ;		/* end of input char */
+const int nlc = CTL_ | 'J' ;		/* end of input char */
 
 
 void ue_system( const char *cmd) {
@@ -66,7 +67,7 @@ int mlyesno( const char *prompt)
 
     for (;;) {
         /* prompt the user */
-		mlwrite( "%s (y/n)? ", prompt) ;
+		mloutfmt( "%s (y/n)? ", prompt) ;
 
         /* get the response */
         c = get1key() ;
@@ -142,11 +143,11 @@ int newmlargt( char **outbufref, const char *prompt, int size) {
 /*
  * ectoc:
  *  expanded character to character
- *  collapse the CTRL and SPEC flags back into an ascii code
+ *  collapse the CTL_ and SPEC flags back into an ascii code
  */
 int ectoc( int c) {
-	if( c & CTRL)
+	if( c & CTL_)
-		c ^= CTRL | 0x40 ;
+		c ^= CTL_ | 0x40 ;
 
 	if( c & SPEC)
 		c &= 255 ;
@@ -189,10 +190,10 @@ nbind_p getname( void) {
             /* and match it off */
             return fncmatch( buf) ;
 
-        } else if (c == ectoc(abortc)) {    /* Bell, abort */
+        } else if( c == ectoc(abortc)) {    /* Bell, abort */
-            ctrlg(FALSE, 0);
+            ctrlg( FALSE, 1) ;
-            TTflush();
+            TTflush() ;
-            return NULL;
+            return NULL ;
 
         } else if (c == 0x7F || c == 0x08) {    /* rubout/erase */
             if (cpos != 0) {
@@ -322,7 +323,7 @@ int tgetc(void)
 }
 
 /*  GET1KEY: Get one keystroke. The only prefixes legal here are the SPEC
-    and CTRL prefixes. */
+    and CTL_ prefixes. */
 static int get1unicode( int *up) {
 /* Accept UTF-8 sequence */
 	int bytes ;
@@ -343,7 +344,7 @@ static int get1unicode( int *up) {
 		bytes = utf8_to_unicode( utf, 0, sizeof utf, (unicode_t *) up) ;
 	} else {
 	    if( (c >= 0x00 && c <= 0x1F) || c == 0x7F)	/* C0 control -> C- */
-			c ^= CTRL | 0x40 ;
+			c ^= CTL_ | 0x40 ;
 
 		*up = c ;
 		bytes = 1 ;
@@ -383,7 +384,7 @@ int getcmd( void) {
 		c = *(kptr++) = get1key() ;
 		if( c == 0x9B)
 			goto foundCSI ;
-		else if( c == (CTRL | '[')) {
+		else if( c == (CTL_ | '[')) {
 		/* fetch terminal sequence */
 			c = *(kptr++) = get1key() ;
 			if( c == 'O') {	/* F1 .. F4 */
@@ -407,7 +408,7 @@ int getcmd( void) {
 								mask = META ;
 
 							if( (v - 1) & 4)
-								mask |= CTRL ;
+								mask |= CTL_ ;
 
 							v = v1 ;
 						}
@@ -513,7 +514,7 @@ int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
     quote_f = FALSE;
 
     /* prompt the user for the input string */
-    mlwrite( "%s", prompt);
+    mloutstr( prompt);
 
     for (;;) {
 #if COMPLC
@@ -538,23 +539,22 @@ int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
 		}
 
 	/* If it is a <ret>, change it to a <NL> */
-        if( c == (CTRL | 'M'))
+        if( c == (CTL_ | 'M'))
-            c = CTRL | 0x40 | '\n' ;
+            c = CTL_ | 0x40 | '\n' ;
 
         if( c == eolchar) {
 		/* if they hit the line terminator, wrap it up */
             buf[ cpos] = 0 ;
 
 		/* clear the message line */
-            mlwrite("");
+            mloutstr( "") ;
 
 		/* if we default the buffer, return FALSE */
 			retval = cpos != 0 ;
 			break ;
         } else if( c == abortc) {
 		/* Abort the input? */
-            ctrlg( FALSE, 0) ;
+            retval = ctrlg( FALSE, 1) ;
-			retval = ABORT ;
 			break ;
 		}
 
@@ -574,7 +574,7 @@ int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
             }
         } else if( c == 0x15) {
         /* C-U, kill */
-			mlwrite( "%s", prompt) ;
+			mloutstr( prompt) ;
 			cpos = 0 ;
 #if COMPLC
         } else if( (c == 0x09 || c == ' ') && file_f) {
@@ -588,7 +588,7 @@ int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
 
             didtry = 1;
             ocpos = cpos;
-			mlwrite( "%s", prompt) ;
+			mloutstr( prompt) ;
 			while( cpos != 0) {
 				c = buf[ --cpos] ;
                 if( c == '*' || c == '?') {

isearch.c

@@ -1,8 +1,7 @@
+/* isearch.c -- implements isearch.h */
 #include "isearch.h"
 
-/*	isearch.c
+/* The functions in this file implement commands that perform incremental
- *
- * The functions in this file implement commands that perform incremental
  * searches in the forward and backward directions.  This "ISearch" command
  * is intended to emulate the same command from the original EMACS
  * implementation (ITS).  Contains references to routines internal to
@@ -24,7 +23,6 @@
  *	Modified by Petri Kutvonen
  */
 
-#include <stdio.h>
 #include <string.h>
 
 #include "basic.h"
@@ -42,8 +40,6 @@
 /*
  * Incremental search defines.
  */
-#if	ISRCH
-
 #define	CMDBUFLEN	256	/* Length of our command buffer */
 
 #define	IS_ABORT	0x07	/* Abort the isearch */
@@ -60,10 +56,7 @@
 
 /* IS_QUIT is no longer used, the variable metac is used instead */
 
-#endif
+static BINDABLE( isearch) ;	/* internal use, not to be bound */
-
-
-static int isearch( int f, int n) ;
 static int checknext( char chr, char *patrn, int dir) ;
 static int scanmore( char *patrn, int dir) ;
 static int match_pat( char *patrn) ;
@@ -73,8 +66,6 @@ static int uneat( void) ;
 static void reeat( int c) ;
 
 
-#if	ISRCH
-
 static int echo_char(int c, int col);
 
 /* A couple of "own" variables for re-eat */
@@ -89,12 +80,10 @@ static int cmd_offset;			/* Current offset into command buff */
 static int cmd_reexecute = -1;		/* > 0 if re-executing command */
 
 
-/*
+/* Subroutine to do incremental reverse search.  It actually uses the
- * Subroutine to do incremental reverse search.  It actually uses the
  * same code as the normal incremental search, as both can go both ways.
  */
-int risearch(int f, int n)
+BINDABLE( risearch) {
-{
 	struct line *curline;		/* Current line on entry              */
 	int curoff;		/* Current offset on entry            */
 
@@ -124,11 +113,10 @@ int risearch(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Again, but for the forward direction
+/* Again, but for the forward direction
  */
-int fisearch(int f, int n)
+BINDABLE( fisearch) {
-{
 	struct line *curline;		/* Current line on entry              */
 	int curoff;		/* Current offset on entry            */
 
@@ -156,8 +144,8 @@ int fisearch(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Subroutine to do an incremental search.  In general, this works similarly
+/* Subroutine to do an incremental search.  In general, this works similarly
  * to the older micro-emacs search function, except that the search happens
  * as each character is typed, with the screen and cursor updated with each
  * new search character.
@@ -182,8 +170,7 @@ int fisearch(int f, int n)
  * exists (or until the search is aborted).
  */
 
-static int isearch(int f, int n)
+static BINDABLE( isearch) {
-{
 	int status;		/* Search status */
 	int col;		/* prompt column */
 	unsigned cpos ;	/* character number in search string  */
@@ -541,8 +528,6 @@ static void reeat(int c)
 	saved_get_char = term.t_getchar;	/* Save the char get routine          */
 	term.t_getchar = uneat;	/* Replace it with ours               */
 }
-#else
+
-int isearch(int f, int n)
+
-{
+/* end of isearch.c */
-}
-#endif

isearch.h

@@ -1,11 +1,11 @@
+/* isearch.h -- incremental search */
 #ifndef __ISEARCH_H__
 #define __ISEARCH_H__
 
-#define	ISRCH	1	/* Incremental searches like ITS EMACS */
+# include "names.h"	/* BINDABLE */
 
-#if ISRCH
+BINDABLE( risearch) ;
-int risearch( int f, int n) ;
+BINDABLE( fisearch) ;
-int fisearch( int f, int n) ;
-#endif
 
 #endif
+/* end of isearch */

line.c

@@ -249,12 +249,11 @@ void lchange(int flag)
  *
  * int f, n;		default flag and numeric argument
  */
-int insspace(int f, int n)
+BINDABLE( insspace) {
-{
 	assert( !(curbp->b_mode & MDVIEW)) ;
-	linsert(n, ' ');
+	linsert( n, ' ') ;
-	backchar(f, n);
+	backchar( f, n) ;
-	return TRUE;
+	return TRUE ;
 }
 
 /*
@@ -821,8 +820,7 @@ BINDABLE( yank) {
  * VIEW (read-only) mode
  */
 boolean rdonly( void) {
-	mloutfmt( "%B(Key illegal in VIEW mode)") ;
+	return mloutfail( "(Key illegal in VIEW mode)") ;
-	return FALSE ;
 }
 
 /* end of line.c */

mlout.c

@@ -12,4 +12,9 @@ void mloutstr( const char *str) {
 	mloutfmt( (*str) ? "%s" : "", str) ;
 }
 
+boolean mloutfail( const char *msg) {
+	mloutfmt( "%B%s", msg) ;
+	return FALSE ;
+}
+
 /* end of mlout.c */

mlout.h

@@ -3,9 +3,12 @@
 #ifndef __MLOUT_H__
 #define __MLOUT_H__
 
+#include "retcode.h"
+
 extern void (*mloutfmt)( const char *, ...) ;
 
 void mloutstr( const char *str) ;
+boolean mloutfail( const char *msg) ;	/* output with BELL and return FALSE */
 
 #endif /* __MLOUT_H__ */
 

names.c

@@ -33,51 +33,51 @@
 
 
 const name_bind names[] = {
-	{" abort-command", ctrlg,	 					CTRL | 'G'} ,
+	{" abort-command", ctrlg,	 					CTL_ | 'G'} ,
 	{" add-global-mode", setgmode,					META | 'M'} ,
 	{" add-mode", setemode,							CTLX | 'M'} ,
 	{" apropos", apro,								META | 'A'} ,
-	{" backward-character", (fnp_t) backchar,		CTRL | 'B'} ,
+	{" backward-character", (fnp_t) backchar,		CTL_ | 'B'} ,
-	{" begin-macro", ctlxlp,						CTLX | '('} ,
+	{" begin-macro", (fnp_t) ctlxlp,				CTLX | '('} ,
 	{" beginning-of-file", (fnp_t) gotobob,			META | '<'} ,
-	{" beginning-of-line", (fnp_t) gotobol,			CTRL | 'A'} ,
+	{" beginning-of-line", (fnp_t) gotobol,			CTL_ | 'A'} ,
 	{" bind-to-key", bindtokey,						META | 'K'} ,
 	{" buffer-position", showcpos,					CTLX | '='} ,
-	{"!case-region-lower", lowerregion,				CTLX | CTRL | 'L'} ,
+	{"!case-region-lower", lowerregion,				CTLX | CTL_ | 'L'} ,
-	{"!case-region-upper", upperregion,				CTLX | CTRL | 'U'} ,
+	{"!case-region-upper", upperregion,				CTLX | CTL_ | 'U'} ,
 	{"!case-word-capitalize", capword,				META | 'C'} ,
 	{"!case-word-lower", lowerword,					META | 'L'} ,
 	{"!case-word-upper", upperword,					META | 'U'} ,
 	{" change-file-name", filename,					CTLX | 'N'} ,
-	{" change-screen-size", newsize,				META | CTRL | 'D'} , /* M^S */
+	{" change-screen-size", newsize,				META | CTL_ | 'D'} , /* M^S */
-	{" change-screen-width", newwidth,				META | CTRL | 'T'} ,
+	{" change-screen-width", newwidth,				META | CTL_ | 'T'} ,
-	{" clear-and-redraw", redraw, 					CTRL | 'L'} ,
+	{" clear-and-redraw", (fnp_t) redraw,			CTL_ | 'L'} ,
-	{" clear-message-line", clrmes, 0} ,
+	{" clear-message-line", (fnp_t) clrmes, 		0} ,
 	{" copy-region", copyregion,					META | 'W'} ,
-	{" count-words", wordcount,						META | CTRL | 'C'} ,
+	{" count-words", wordcount,						META | CTL_ | 'C'} ,
-	{" ctlx-prefix", cex, 							CTRL | 'X'} ,
+	{" ctlx-prefix", (fnp_t) cex,					CTL_ | 'X'} ,
-	{"!delete-blank-lines", deblank,				CTLX | CTRL | 'O'} ,
+	{"!delete-blank-lines", deblank,				CTLX | CTL_ | 'O'} ,
 	{" delete-buffer", killbuffer,					CTLX | 'K'} ,
-	{" delete-global-mode", delgmode,				META | CTRL | 'M'} ,
+	{" delete-global-mode", delgmode,				META | CTL_ | 'M'} ,
-	{" delete-mode", delmode,						CTLX | CTRL | 'M'} ,
+	{" delete-mode", delmode,						CTLX | CTL_ | 'M'} ,
-	{"!delete-next-character", forwdel,				CTRL | 'D'} ,
+	{"!delete-next-character", forwdel,				CTL_ | 'D'} ,
 	{"!delete-next-word", delfword,					META | 'D'} ,
 	{" delete-other-windows", onlywind,				CTLX | '1'} ,
-	{"!delete-previous-character", backdel,			CTRL | 'H'} , /* ^? */
+	{"!delete-previous-character", backdel,			CTL_ | 'H'} , /* ^? */
-	{"!delete-previous-word", delbword,				META | CTRL | 'H'} , /* M^? */
+	{"!delete-previous-word", delbword,				META | CTL_ | 'H'} , /* M^? */
 	{" delete-window", delwind,						CTLX | '0'} ,
 	{" describe-bindings", desbind, 0} ,
 	{" describe-key", deskey,						CTLX | '?'} ,
-	{"!detab-line", detab, 							CTLX | CTRL | 'D'} , /* X^A */
+	{"!detab-line", detab, 							CTLX | CTL_ | 'D'} , /* X^A */
-	{" end-macro", ctlxrp,							CTLX | ')'} ,
+	{" end-macro", (fnp_t) ctlxrp,					CTLX | ')'} ,
 	{" end-of-file", (fnp_t) gotoeob,				META | '>'} ,
-	{" end-of-line", (fnp_t) gotoeol,				CTRL | 'E'} ,
+	{" end-of-line", (fnp_t) gotoeol,				CTL_ | 'E'} ,
-	{"!entab-line", entab, 							CTLX | CTRL | 'E'} ,
+	{"!entab-line", entab, 							CTLX | CTL_ | 'E'} ,
-	{" exchange-point-and-mark", (fnp_t) swapmark,	CTLX | CTRL | 'X'} ,
+	{" exchange-point-and-mark", (fnp_t) swapmark,	CTLX | CTL_ | 'X'} ,
 	{" execute-buffer", execbuf, 0} ,
 	{" execute-command-line", execcmd, 0} ,
 	{" execute-file", execfile, 0} ,
-	{" execute-macro", ctlxe,						CTLX | 'E'} ,
+	{" execute-macro", (fnp_t) ctlxe,				CTLX | 'E'} ,
 	{" execute-macro-1", cbuf1, 0} ,
 	{" execute-macro-10", cbuf10, 0} ,
 	{" execute-macro-11", cbuf11, 0} ,
@@ -119,116 +119,106 @@ const name_bind names[] = {
 	{" execute-macro-8", cbuf8, 0} ,
 	{" execute-macro-9", cbuf9, 0} ,
 	{" execute-named-command", namedcmd,		META | 'X'} ,
-#if	PROC
+	{" execute-procedure", execproc,			META | CTL_ | 'E'} ,
-	{" execute-procedure", execproc,			META | CTRL | 'E'} ,
-#endif
 	{" execute-program", execprg,				CTLX | '$'} ,
-	{" exit-emacs", quit, 						CTLX | CTRL | 'C'} ,
+	{" exit-emacs", quit, 						CTLX | CTL_ | 'C'} ,
 	{"!fill-paragraph", fillpara,				META | 'Q'} ,
 	{"!filter-buffer", filter_buffer,			CTLX | '#'} ,
-	{" find-file", filefind, 					CTLX | CTRL | 'F'} ,
+	{" find-file", filefind, 					CTLX | CTL_ | 'F'} ,
-	{" forward-character", (fnp_t) forwchar,	CTRL | 'F'} ,
+	{" forward-character", (fnp_t) forwchar,	CTL_ | 'F'} ,
 	{" goto-line", gotoline,					META | 'G'} ,
 #if	CFENCE
-	{" goto-matching-fence", getfence,			META | CTRL | 'F'} ,
+	{" goto-matching-fence", getfence,			META | CTL_ | 'F'} ,
 #endif
 	{" grow-window", enlargewind,				CTLX | 'Z'} , /* X^ */
-	{"!handle-tab", insert_tab,					CTRL | 'I'} ,
+	{"!handle-tab", insert_tab,					CTL_ | 'I'} ,
 	{" help", help,								META | '?'} ,
 	{" hunt-backward", backhunt, 0} ,
 	{" hunt-forward", forwhunt,					META | 'S'} ,
 	{" i-shell", spawncli,						CTLX | 'C'} ,
-#if	ISRCH
 	{" incremental-search", fisearch,			CTLX | 'S'} ,
-#endif
+	{"!insert-file", insfile,					CTLX | CTL_ | 'I'} ,
-	{"!insert-file", insfile,					CTLX | CTRL | 'I'} ,
+	{"!insert-space", insspace,					CTL_ | 'C'} ,
-	{"!insert-space", insspace,					CTRL | 'C'} ,
 	{"!insert-string", istring, 0} ,
 #if	PKCODE
 	{"!justify-paragraph", justpara,			META | 'J'} ,
 #endif
-	{"!kill-paragraph", killpara,				META | CTRL | 'W'} ,
+	{"!kill-paragraph", killpara,				META | CTL_ | 'W'} ,
-	{"!kill-region", killregion, 				CTRL | 'W'} ,
+	{"!kill-region", killregion, 				CTL_ | 'W'} ,
-	{"!kill-to-end-of-line", killtext, 			CTRL | 'K'} ,
+	{"!kill-to-end-of-line", killtext, 			CTL_ | 'K'} ,
-	{" list-buffers", listbuffers, 				CTLX | CTRL | 'B'} ,
+	{" list-buffers", listbuffers, 				CTLX | CTL_ | 'B'} ,
-	{" meta-prefix", metafn, 					CTRL | '['} ,
+	{" meta-prefix", (fnp_t) metafn,			CTL_ | '['} ,
-	{" move-window-down", mvdnwind,				CTLX | CTRL | 'N'} ,
+	{" move-window-down", mvdnwind,				CTLX | CTL_ | 'N'} ,
-	{" move-window-up", mvupwind,				CTLX | CTRL | 'P'} ,
+	{" move-window-up", mvupwind,				CTLX | CTL_ | 'P'} ,
-	{" name-buffer", namebuffer,				META | CTRL | 'N'} ,
+	{" name-buffer", namebuffer,				META | CTL_ | 'N'} ,
-	{"!newline", insert_newline, 				CTRL | 'M'} ,
+	{"!newline", insert_newline, 				CTL_ | 'M'} ,
-	{"!newline-and-indent", indent, 			CTRL | 'J'} ,
+	{"!newline-and-indent", indent, 			CTL_ | 'J'} ,
 	{" next-buffer", nextbuffer,				CTLX | 'X'} ,
-	{" next-line", (fnp_t) forwline, 			CTRL | 'N'} ,
+	{" next-line", (fnp_t) forwline, 			CTL_ | 'N'} ,
-	{" next-page", (fnp_t) forwpage,			CTRL | 'V'} ,
+	{" next-page", (fnp_t) forwpage,			CTL_ | 'V'} ,
 	{" next-paragraph", gotoeop,				META | 'N'} ,
 	{" next-window", nextwind,					CTLX | 'O'} ,
 	{" next-word", forwword,					META | 'F'} ,
-	{" nop", nullproc,							SPEC | META | 'C'}, /* hook */
+	{" nop", (fnp_t) nullproc,					META | SPEC | 'C'}, /* hook */
-	{"!open-line", openline,					CTRL | 'O'} ,
+	{"!open-line", openline,					CTL_ | 'O'} ,
 	{"!overwrite-string", ovstring, 0} ,
 	{" pipe-command", pipecmd,					CTLX | '@'} ,
-	{" previous-line", (fnp_t) backline, 		CTRL | 'P'} ,
+	{" previous-line", (fnp_t) backline, 		CTL_ | 'P'} ,
-	{" previous-page", (fnp_t) backpage,		CTRL | 'Z'} , /* MV */
+	{" previous-page", (fnp_t) backpage,		CTL_ | 'Z'} , /* MV */
 	{" previous-paragraph", gotobop,			META | 'P'} ,
 	{" previous-window", prevwind,				CTLX | 'P'} ,
 	{" previous-word", backword,				META | 'B'} ,
-	{"!query-replace-string", qreplace,			META | CTRL | 'R'} ,
+	{"!query-replace-string", qreplace,			META | CTL_ | 'R'} ,
 	{" quick-exit", quickexit,					META | 'Z'} ,
-	{"!quote-character", quote, 				CTRL | 'Q'} , /* also XQ */
+	{"!quote-character", quote, 				CTL_ | 'Q'} ,
-	{"!read-file", fileread,					CTLX | CTRL | 'R'} ,
+	{"!read-file", fileread,					CTLX | CTL_ | 'R'} ,
-	{" redraw-display", reposition,				META | CTRL | 'L'} , /* M! */
+	{" redraw-display", (fnp_t) reposition,		META | CTL_ | 'L'} ,
 	{"!replace-string", sreplace,				META | 'R'} ,
 	{" resize-window", resize,					CTLX | 'W'} ,
 	{" restore-window", restwnd, 0} ,
-#if	ISRCH
 	{" reverse-incremental-search", risearch,	CTLX | 'R'} ,
-#endif
+	{" run", execproc, 0} ,	/* alias of execute-procedure */
-#if	PROC
+	{"!save-file", filesave,					CTLX | CTL_ | 'S'} , /* also X^D */
-	{" run", execproc, 0} ,	// alias of execute-procedure
-#endif
-	{"!save-file", filesave,					CTLX | CTRL | 'S'} , /* also X^D */
 	{" save-window", savewnd, 0} ,
-	{" scroll-next-down", scrnextdw,			META | CTRL | 'V'} ,
+	{" scroll-next-down", scrnextdw,			META | CTL_ | 'V'} ,
-	{" scroll-next-up", scrnextup,				META | CTRL | 'Z'} ,
+	{" scroll-next-up", scrnextup,				META | CTL_ | 'Z'} ,
-	{" search-forward", forwsearch, 			CTRL | 'S'} ,
+	{" search-forward", forwsearch, 			CTL_ | 'S'} ,
-	{" search-reverse", backsearch, 			CTRL | 'R'} ,
+	{" search-reverse", backsearch, 			CTL_ | 'R'} ,
 	{" select-buffer", usebuffer,				CTLX | 'B'} ,
 	{" set", setvar,							CTLX | 'A'} ,
 	{" set-fill-column", setfillcol,			CTLX | 'F'} ,
 	{" set-mark", (fnp_t) setmark,				META | ' '} , /* M. */
 	{" shell-command", spawn,					CTLX | '!'} ,
-	{" shrink-window", shrinkwind,				CTLX | CTRL | 'Z'} ,
+	{" shrink-window", shrinkwind,				CTLX | CTL_ | 'Z'} ,
 	{" split-current-window", splitwind,		CTLX | '2'} ,
 	{" store-macro", storemac, 0} ,
-#if	PROC
 	{" store-procedure", storeproc, 0} ,
-#endif
 #if	BSD | SVR4
 	{" suspend-emacs", bktoshell,				CTLX | 'D'} , /* BSD MS */
 #endif
-	{"!transpose-characters", (fnp_t) twiddle,	CTRL | 'T'} ,
+	{"!transpose-characters", (fnp_t) twiddle,	CTL_ | 'T'} ,
-	{"!trim-line", trim,						CTLX | CTRL | 'T'} ,
+	{"!trim-line", trim,						CTLX | CTL_ | 'T'} ,
-	{" unbind-key", unbindkey,					META | CTRL | 'K'} ,
+	{" unbind-key", unbindkey,					META | CTL_ | 'K'} ,
-	{" universal-argument", unarg, 				CTRL | 'U'} ,
+	{" universal-argument", (fnp_t) unarg,		CTL_ | 'U'} ,
 	{" unmark-buffer", unmark,					META | '~'} ,
 	{" update-screen", upscreen, 0} ,
-	{" view-file", viewfile, 					CTLX | CTRL | 'V'} ,
+	{" view-file", viewfile, 					CTLX | CTL_ | 'V'} ,
-	{"!wrap-word", wrapword,					SPEC | META | 'W'} , /* hook */
+	{"!wrap-word", wrapword,					META | SPEC | 'W'} , /* hook */
-	{" write-file", filewrite,					CTLX | CTRL | 'W'} ,
+	{" write-file", filewrite,					CTLX | CTL_ | 'W'} ,
 	{" write-message", writemsg, 0} ,
-	{"!yank", yank,								CTRL | 'Y'} ,
+	{"!yank", yank,								CTL_ | 'Y'} ,
 
 	{" ", NULL, 0},
 /* extra key mapping */
-//	{ NULL, newsize,							META | CTRL | 'S'},
+//	{ NULL, newsize,							META | CTL_ | 'S'},
-	{ NULL, backdel,							CTRL | '?'},
+	{ NULL, backdel,							CTL_ | '?'},
-	{ NULL, delbword,							META | CTRL | '?'},
+	{ NULL, delbword,							META | CTL_ | '?'},
-	{ NULL, detab,								CTLX | CTRL | 'A'},
+	{ NULL, detab,								CTLX | CTL_ | 'A'},
 	{ NULL, enlargewind,						CTLX | '^'},
 	{ NULL, (fnp_t) backpage,					META | 'V'},
 	{ NULL, quote,				 				CTLX | 'Q'},
-	{ NULL, reposition,							META | '!'},
+	{ NULL, (fnp_t) reposition,					META | '!'},
-//detab { NULL, filesave,						CTLX | CTRL | 'D'},
+//detab { NULL, filesave,						CTLX | CTL_ | 'D'},
 	{ NULL, (fnp_t) setmark,					META | '.'},
 //	{ NULL, bktoshell,							META | 'S'},
 
@@ -246,14 +236,14 @@ const name_bind names[] = {
     { NULL, help,								SPEC | 'P'}, /* F1 */
 
 /* hooks */
-	{ NULL, nullproc,							SPEC | META | 'R'}, /* hook */
+	{ NULL, (fnp_t) nullproc,					META | SPEC | 'R'}, /* hook */
-	{ NULL, nullproc,							SPEC | META | 'X'}, /* hook */
+	{ NULL, (fnp_t) nullproc,					META | SPEC | 'X'}, /* hook */
 
 	{ NULL, NULL, 0}
 } ;
 
-static int lastnmidx = 0 ;	/* index of last name entry */
 
+static int lastnmidx = 0 ;	/* index of last name entry */
 
 kbind_p keytab ;
 static int ktsize = 140 ;	/* last check: need at least 133 + 1 */
@@ -282,6 +272,9 @@ boolean init_bindings( void) {
 	/* Add key definition */
 		if( nbp->n_keycode) {
 			kbind_p ktp = setkeybinding( nbp->n_keycode, nbp) ;
+			if( ktp->k_code == 0)	/* Table full, no memory left */
+				return FALSE ;
+
 		/* check it was indeed an insertion at end of table not a
 		 * key code re-definition */
 			assert( (++ktp)->k_code == 0) ;
@@ -293,14 +286,20 @@ boolean init_bindings( void) {
 
 /* Process extra key bindings if any */
 	for( nbp++ ; nbp->n_func != NULL ; nbp++) {
-	/* Check entry */
+	/* Check entry: a keycode and no name */
 		assert( nbp->n_keycode && (nbp->n_name == NULL)) ;
 
 	/* Look for corresponding function and add extra key binding */
 		nbind_p fnbp ;
 		for( fnbp = names ; fnbp->n_func != NULL ; fnbp++)
 			if( fnbp->n_func == nbp->n_func) {
-				setkeybinding( nbp->n_keycode, fnbp) ;
+				kbind_p ktp = setkeybinding( nbp->n_keycode, fnbp) ;
+				if( ktp->k_code == 0)	/* Table full, no memory left */
+					return FALSE ;
+
+				/* check it was indeed an insertion at end of table not a
+				 * key code re-definition */
+				assert( (++ktp)->k_code == 0) ;
 				break ;
 			}
 
@@ -370,8 +369,8 @@ boolean delkeybinding( unsigned key) {
 	return FALSE ;
 }
 
-/*
+
- * This function looks a key binding up in the binding table
+/* This function looks a key binding up in the binding table
  *
  * int c;       key to find what is bound to it
  */
@@ -416,23 +415,26 @@ nbind_p fncmatch( char *name) {
 }
 
 
-/* user function that does NOTHING */
+/* user function that does NOTHING (bound to hooks) */
-BINDABLE( nullproc) {
+TBINDABLE( nullproc) {
 	return TRUE ;
 }
 
+
 /* dummy function for binding to meta prefix */
-BINDABLE( metafn) {
+TBINDABLE( metafn) {
 	return TRUE ;
 }
 
+
 /* dummy function for binding to control-x prefix */
-BINDABLE( cex) {
+TBINDABLE( cex) {
 	return TRUE ;
 }
 
+
 /* dummy function for binding to universal-argument */
-BINDABLE( unarg) {
+TBINDABLE( unarg) {
 	return TRUE ;
 }
 

names.h

@@ -1,12 +1,10 @@
 /* names.h -- mapping of functions to names and keys */
-
 #ifndef _NAMES_H_
-#define _NAMES_H_
+# define _NAMES_H_
 
 #include "retcode.h"
 
-
+#define CTL_    	0x01000000  /* Control flag, or'ed in       */
-#define CTRL    	0x01000000  /* Control flag, or'ed in       */
 #define META    	0x02000000  /* Meta flag, or'ed in          */
 #define CTLX    	0x04000000  /* ^X flag, or'ed in            */
 #define SPEC    	0x08000000  /* special key (function keys)  */
@@ -14,7 +12,9 @@
 
 
 /* Bindable uEMACS function pointer type and definition template */
-#define BINDABLE( fname)    int fname( int f, int n)
+#define  BINDABLE( fname)    int fname( boolean f, int n)
+#define BBINDABLE( fname)    boolean fname( boolean f, int n)
+#define TBINDABLE	BBINDABLE
 
 typedef BINDABLE( (*fnp_t)) ;
 
@@ -53,11 +53,10 @@ nbind_p fncmatch( char *name) ;     /* look up by name */
 
 
 /* bindable functions mapped to prefix keys and hooks */
-BINDABLE( nullproc) ;
+TBINDABLE( nullproc) ;
-BINDABLE( metafn) ;
+TBINDABLE( metafn) ;
-BINDABLE( cex) ;
+TBINDABLE( cex) ;
-BINDABLE( unarg) ;
+TBINDABLE( unarg) ;
 
 #endif
-
 /* end of names.h */

random.c

@@ -144,15 +144,13 @@ int getcline(void)
 	return numlines + 1;
 }
 
-/*
+/* Return current column.  Stop at first non-blank given TRUE argument.
- * Return current column.  Stop at first non-blank given TRUE argument.
  */
-int getccol(int bflg)
+int getccol( int bflg) {
-{
+	int i, col ;
-	int i, col;
 	line_p dlp = curwp->w_dotp ;
-	int byte_offset = curwp->w_doto;
+	int byte_offset = curwp->w_doto ;
-	int len = llength(dlp);
+	int len = llength( dlp) ;
 
 	col = i = 0;
 	while (i < byte_offset) {
@@ -160,17 +158,20 @@ int getccol(int bflg)
 
 		i += utf8_to_unicode(dlp->l_text, i, len, &c);
 		if( bflg && c != ' ' && c != '\t')	/* Request Stop at first non-blank */
-			break;
+			break ;
 		if (c == '\t')
 			col += tabwidth - col % tabwidth ;
 		else if (c < 0x20 || c == 0x7F)		/* displayed as ^c */
 			col += 2 ;
 		else if (c >= 0x80 && c <= 0xa0)	/* displayed as \xx */
 			col += 3 ;
-		else
+		else {
-			col += 1 ;
+			int w = utf8_width( c) ;		/* incomplete wc_width */
+			col += (w < 0) ? 2 : w ; 
+		}
 	}
-	return col;
+
+	return col ;
 }
 
 /*
@@ -714,60 +715,40 @@ BINDABLE( killtext) {
 	return ldelete(chunk, TRUE);
 }
 
-/*
+
- * prompt and set an editor mode
+/* prompt and set an editor mode
  *
  * int f, n;		default and argument
  */
-int setemode(int f, int n)
+BINDABLE( setemode) {
-{
+	return adjustmode( TRUE, FALSE) ;
-#if 	PKCODE
-	return adjustmode(TRUE, FALSE);
-#else
-	adjustmode(TRUE, FALSE);
-#endif
 }
 
-/*
+
- * prompt and delete an editor mode
+/* prompt and delete an editor mode
  *
  * int f, n;		default and argument
  */
-int delmode(int f, int n)
+BINDABLE( delmode) {
-{
+	return adjustmode( FALSE, FALSE) ;
-#if	PKCODE
-	return adjustmode(FALSE, FALSE);
-#else
-	adjustmode(FALSE, FALSE);
-#endif
 }
 
-/*
+
- * prompt and set a global editor mode
+/* prompt and set a global editor mode
  *
  * int f, n;		default and argument
  */
-int setgmode(int f, int n)
+BINDABLE( setgmode) {
-{
+	return adjustmode( TRUE, TRUE) ;
-#if	PKCODE
-	return adjustmode(TRUE, TRUE);
-#else
-	adjustmode(TRUE, TRUE);
-#endif
 }
 
-/*
+
- * prompt and delete a global editor mode
+/* prompt and delete a global editor mode
  *
  * int f, n;		default and argument
  */
-int delgmode(int f, int n)
+BINDABLE( delgmode) {
-{
+	return adjustmode( FALSE, TRUE) ;
-#if	PKCODE
-	return adjustmode(FALSE, TRUE);
-#else
-	adjustmode(FALSE, TRUE);
-#endif
 }
 
 /*
@@ -858,11 +839,10 @@ static int adjustmode( int kind, int global) {
 
 
 static int iovstring( int f, int n, const char *prompt, int (*fun)( char *)) {
-	int status ;	/* status return code */
 	char *tstring ;	/* string to add */
 
-	/* ask for string to insert */
+/* ask for string to insert */
-	status = newmlargt( &tstring, prompt, 0) ; /* grab as big a token as screen allow */
+ 	int status = newmlargt( &tstring, prompt, 0) ;
 	if( tstring == NULL)
 		return status ;
 

region.c

@@ -9,7 +9,7 @@
  */
 
 #include <assert.h>
-#include <stdio.h>
+#include <stddef.h>
 
 #include "buffer.h"
 #include "estruct.h"
@@ -139,10 +139,9 @@ int getregion( region_p rp) {
 	line_p flp, blp ;
 	long fsize, bsize ;
 
-	if (curwp->w_markp == NULL) {
+	if (curwp->w_markp == NULL)
-		mloutstr( "No mark set in this window") ;
+		return mloutfail( "No mark set in this window") ;
-		return FALSE;
+
-	}
 	if (curwp->w_dotp == curwp->w_markp) {
 		rp->r_linep = curwp->w_dotp;
 		if (curwp->w_doto < curwp->w_marko) {
@@ -182,8 +181,8 @@ int getregion( region_p rp) {
 			}
 		}
 	}
-	mloutstr( "Bug: lost mark") ;
+
-	return FALSE;
+	return mloutfail( "Bug: lost mark") ;
 }
 
 /* end of region.c */

search.c

@@ -1,9 +1,7 @@
 /* search.c -- implements search.h */
 #include "search.h"
 
-/*	search.c
+/* The functions in this file implement commands that search in the forward
- *
- * The functions in this file implement commands that search in the forward
  * and backward directions.  There are no special characters in the search
  * strings.  Probably should have a regular expression search, or something
  * like that.
@@ -177,15 +175,14 @@ static int biteq(int bc, char *cclmap);
 static char *clearbits(void);
 static void setbit(int bc, char *cclmap);
 
-/*
+
- * forwsearch -- Search forward.  Get a search string from the user, and
+/* forwsearch -- Search forward.  Get a search string from the user, and
  *	search for the string.  If found, reset the "." to be just after
  *	the match string, and (perhaps) repaint the display.
  *
  * int f, n;			default flag / numeric argument
  */
-int forwsearch(int f, int n)
+BINDABLE( forwsearch) {
-{
 	int status = TRUE;
 
 	/* If n is negative, search backwards.
@@ -223,15 +220,14 @@ int forwsearch(int f, int n)
 	return status;
 }
 
-/*
+
- * forwhunt -- Search forward for a previously acquired search string.
+/* forwhunt -- Search forward for a previously acquired search string.
  *	If found, reset the "." to be just after the match string,
  *	and (perhaps) repaint the display.
  *
  * int f, n;		default flag / numeric argument
  */
-int forwhunt(int f, int n)
+BINDABLE( forwhunt) {
-{
 	int status = TRUE;
 
 	if (n < 0)		/* search backwards */
@@ -276,16 +272,15 @@ int forwhunt(int f, int n)
 	return status;
 }
 
-/*
+
- * backsearch -- Reverse search.  Get a search string from the user, and
+/* backsearch -- Reverse search.  Get a search string from the user, and
  *	search, starting at "." and proceeding toward the front of the buffer.
  *	If found "." is left pointing at the first character of the pattern
  *	(the last character that was matched).
  *
  * int f, n;		default flag / numeric argument
  */
-int backsearch(int f, int n)
+BINDABLE( backsearch) {
-{
 	int status = TRUE;
 
 	/* If n is negative, search forwards.
@@ -324,16 +319,15 @@ int backsearch(int f, int n)
 	return status;
 }
 
-/*
+
- * backhunt -- Reverse search for a previously acquired search string,
+/* backhunt -- Reverse search for a previously acquired search string,
  *	starting at "." and proceeding toward the front of the buffer.
  *	If found "." is left pointing at the first character of the pattern
  *	(the last character that was matched).
  *
  * int f, n;		default flag / numeric argument
  */
-int backhunt(int f, int n)
+BINDABLE( backhunt) {
-{
 	int status = TRUE;
 
 	if (n < 0)
@@ -788,26 +782,24 @@ void rvstrcpy(char *rvstr, char *str)
 	*rvstr = '\0';
 }
 
-/*
+
- * sreplace -- Search and replace.
+/* sreplace -- Search and replace.
  *
  * int f;		default flag
  * int n;		# of repetitions wanted
  */
-int sreplace(int f, int n)
+BINDABLE( sreplace) {
-{
+	return replaces( FALSE, f, n) ;
-	return replaces(FALSE, f, n);
 }
 
-/*
+
- * qreplace -- search and replace with query.
+/* qreplace -- search and replace with query.
  *
  * int f;		default flag
  * int n;		# of repetitions wanted
  */
-int qreplace(int f, int n)
+BINDABLE( qreplace) {
-{
+	return replaces( TRUE, f, n) ;
-	return replaces(TRUE, f, n);
 }
 
 /*

spawn.c

@@ -1,9 +1,7 @@
 /* spawn.c -- implements spawn.h */
 #include "spawn.h"
 
-/*	spawn.c
+/*	Various operating system access commands.
- *
- *	Various operating system access commands.
  *
  *	Modified by Petri Kutvonen
  */
@@ -34,13 +32,11 @@
 #endif
 
 
-/*
+/* Create a subjob with a copy of the command intrepreter in it. When the
- * Create a subjob with a copy of the command intrepreter in it. When the
  * command interpreter exits, mark the screen as garbage so that you do a full
  * repaint. Bound to "^X C".
  */
-int spawncli(int f, int n)
+BINDABLE( spawncli) {
-{
 #if	USG | BSD
 	char *cp;
 #endif
@@ -81,9 +77,8 @@ int spawncli(int f, int n)
 }
 
 #if	BSD | SVR4
-
+/* suspend MicroEMACS and wait to wake up */
-int bktoshell(int f, int n)
+BINDABLE( bktoshell) {
-{				/* suspend MicroEMACS and wait to wake up */
 	vttidy();
 /******************************
 	int pid;
@@ -103,12 +98,12 @@ void rtfrmshell(void)
 }
 #endif
 
-/*
+
- * Run a one-liner in a subjob. When the command returns, wait for a single
+/* Run a one-liner in a subjob. When the command returns, wait for a single
  * character to be typed, then mark the screen as garbage so a full repaint is
  * done. Bound to "C-X !".
  */
-int spawn( int f, int n) {
+BINDABLE( spawn) {
 	int s ;
 	char *line ;
 
@@ -141,13 +136,13 @@ int spawn( int f, int n) {
 #endif
 }
 
-/*
+
- * Run an external program with arguments. When it returns, wait for a single
+/* Run an external program with arguments. When it returns, wait for a single
  * character to be typed, then mark the screen as garbage so a full repaint is
  * done. Bound to "C-X $".
  */
 
-int execprg( int f, int n) {
+BINDABLE( execprg) {
 	int s ;
 	char *line ;
 
@@ -176,11 +171,11 @@ int execprg( int f, int n) {
 #endif
 }
 
-/*
+
- * Pipe a one line command into a window
+/* Pipe a one line command into a window
  * Bound to ^X @
  */
-int pipecmd( int f, int n) {
+BINDABLE( pipecmd) {
 	int s ;		/* return status from CLI */
 	struct window *wp ;	/* pointer to new window */
 	buffer_p bp ;		/* pointer to buffer to zot */
@@ -271,11 +266,11 @@ int pipecmd( int f, int n) {
 	return TRUE;
 }
 
-/*
+
- * filter a buffer through an external DOS program
+/* filter a buffer through an external DOS program
  * Bound to ^X #
  */
-int filter_buffer( int f, int n) {
+BINDABLE( filter_buffer) {
 	int s ;				/* return status from CLI */
 	buffer_p bp ;		/* pointer to buffer to zot */
 	char *mlarg ;

util.c

@@ -1,17 +1,20 @@
+/* util.c -- implements util.h */
 #include "util.h"
 
 /* Safe zeroing, no complaining about overlap */
-void mystrscpy(char *dst, const char *src, int size)
+void mystrscpy( char *dst, const char *src, int size) {
-{
+	if( size <= 0)
-	if (!size)
+		return ;
-		return;
+
-	while (--size) {
+	while( --size) {
-		char c = *src++;
+		char c = *src++ ;
-		if (!c)
+		if( !c)
-			break;
+			break ;
-		*dst++ = c;
+
+		*dst++ = c ;
 	}
-	*dst = 0;
+
+	*dst = 0 ;
 }
 
-
+/* end of util.c */

util.h

@@ -1,7 +1,9 @@
+/* util.h -- utility functions */
 #ifndef UTIL_H_
-#define UTIL_H_
+# define UTIL_H_
 
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
-void mystrscpy(char *dst, const char *src, int size);
+void mystrscpy( char *dst, const char *src, int size) ;
 
 #endif  /* UTIL_H_ */
+/* end of util.h */

window.c

@@ -1,77 +1,65 @@
 /* window.c -- inplements window.h */
-
 #include "window.h"
 
-/*	window.c
+/* Window management.  Some of the functions are internal, and some are
- *
+   attached to keys that the user actually types.
- *      Window management. Some of the functions are internal, and some are
- *      attached to keys that the user actually types.
- *
  */
 
 #include <assert.h>
-#include <stdio.h>
 
 #include "basic.h"
 #include "buffer.h"
-#include "display.h"
+#include "display.h"	/* upmode() */
 #include "estruct.h"
 #include "execute.h"
 #include "line.h"
+#include "mlout.h"
 #include "terminal.h"
 #include "wrapper.h"
 
+window_p curwp ;		/* Current window               */
+window_p wheadp ;		/* Head of list of windows      */
 
-struct window *curwp ;		/* Current window               */
+static window_p savwindow = NULL ;	/* saved window pointer */
-struct window *wheadp ;		/* Head of list of windows      */
-
-static struct window *swindow = NULL ;	/* saved window pointer */
 
 
-/*
+/* Reposition dot in the current window to line "n".  If the argument is
- * Reposition dot in the current window to line "n". If the argument is
+   positive, it is that line.  If it is negative it is that line from the
- * positive, it is that line. If it is negative it is that line from the
+   bottom.  If it is 0 the window is centered (this is what the standard
- * bottom. If it is 0 the window is centered (this is what the standard
+   redisplay code does).  With no argument it defaults to 0.  Bound to M-!.
- * redisplay code does). With no argument it defaults to 0. Bound to M-!.
  */
-int reposition(int f, int n)
+TBINDABLE( reposition) {
-{
+	curwp->w_force = (f == FALSE) ? 0 : n ;	/* default to 0 to center screen */
-	if (f == FALSE)		/* default to 0 to center screen */
+	curwp->w_flag |= WFFORCE ;
-		n = 0;
+	return TRUE ;
-	curwp->w_force = n;
-	curwp->w_flag |= WFFORCE;
-	return TRUE;
 }
 
-/*
+
- * Refresh the screen. With no argument, it just does the refresh. With an
+/* Refresh the screen.  With no argument, it just does the refresh.  With
- * argument it recenters "." in the current window. Bound to "C-L".
+   an argument it recenters "." in the current window.  Bound to "C-L".
  */
-int redraw(int f, int n)
+TBINDABLE( redraw) {
-{
+	if( f == FALSE)
-	if (f == FALSE)
+		sgarbf = TRUE ;
-		sgarbf = TRUE;
 	else {
-		curwp->w_force = 0;	/* Center dot. */
+		curwp->w_force = 0 ;	/* Center dot. */
-		curwp->w_flag |= WFFORCE;
+		curwp->w_flag |= WFFORCE ;
 	}
 
-	return TRUE;
+	return TRUE ;
 }
 
-/*
+
- * The command make the next window (next => down the screen) the current
+/* The command make the next window (next => down the screen) the current
- * window. There are no real errors, although the command does nothing if
+   window.  There are no real errors, although the command does nothing if
- * there is only 1 window on the screen. Bound to "C-X C-N".
+   there is only 1 window on the screen.  Bound to "C-X C-N".
- *
+
- * with an argument this command finds the <n>th window from the top
+   with an argument this command finds the <n>th window from the top
- *
+ 
- * int f, n;		default flag and numeric argument
+   int f, n;		default flag and numeric argument
- *
  */
-int nextwind(int f, int n)
+BINDABLE( nextwind) {
-{
+	window_p wp;
-	struct window *wp;
 	int nwindows;	/* total number of windows */
 
 	if (f) {
@@ -94,10 +82,8 @@ int nextwind(int f, int n)
 			wp = wheadp;
 			while (--n)
 				wp = wp->w_wndp;
-		} else {
+		} else
-			mlwrite("Window number out of range");
+			return mloutfail( "Window number out of range") ;
-			return FALSE;
-		}
 	} else if ((wp = curwp->w_wndp) == NULL)
 		wp = wheadp;
 	curwp = wp;
@@ -107,15 +93,14 @@ int nextwind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * This command makes the previous window (previous => up the screen) the
+/* This command makes the previous window (previous => up the screen) the
- * current window. There arn't any errors, although the command does not do a
+   current window.  There arn't any errors, although the command does not
- * lot if there is 1 window.
+   do a lot if there is 1 window.
  */
-int prevwind(int f, int n)
+BINDABLE( prevwind) {
-{
+	window_p wp1;
-	struct window *wp1;
+	window_p wp2;
-	struct window *wp2;
 
 	/* if we have an argument, we mean the nth window from the bottom */
 	if (f)
@@ -137,28 +122,26 @@ int prevwind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * This command moves the current window down by "arg" lines. Recompute the
+/* This command moves the current window down by "arg" lines. Recompute the
  * top line in the window. The move up and move down code is almost completely
  * the same; most of the work has to do with reframing the window, and picking
  * a new dot. We share the code by having "move down" just be an interface to
  * "move up". Magic. Bound to "C-X C-N".
  */
-int mvdnwind(int f, int n)
+BINDABLE( mvdnwind) {
-{
+	return mvupwind( f, -n) ;
-	return mvupwind(f, -n);
 }
 
-/*
+
- * Move the current window up by "arg" lines. Recompute the new top line of
+/* Move the current window up by "arg" lines. Recompute the new top line of
  * the window. Look to see if "." is still on the screen. If it is, you win.
  * If it isn't, then move "." to center it in the new framing of the window
  * (this command does not really move "."; it moves the frame). Bound to
  * "C-X C-P".
  */
-int mvupwind(int f, int n)
+BINDABLE( mvupwind) {
-{
+	line_p lp;
-	struct line *lp;
 	int i;
 
 	lp = curwp->w_linep;
@@ -193,17 +176,16 @@ int mvupwind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * This command makes the current window the only window on the screen. Bound
+/* This command makes the current window the only window on the screen. Bound
  * to "C-X 1". Try to set the framing so that "." does not have to move on the
  * display. Some care has to be taken to keep the values of dot and mark in
  * the buffer structures right if the distruction of a window makes a buffer
  * become undisplayed.
  */
-int onlywind(int f, int n)
+BINDABLE( onlywind) {
-{
+	window_p wp;
-	struct window *wp;
+	line_p lp;
-	struct line *lp;
 	int i;
 
 	while (wheadp != curwp) {
@@ -241,23 +223,20 @@ int onlywind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Delete the current window, placing its space in the window above,
+/* Delete the current window, placing its space in the window above,
  * or, if it is the top window, the window below. Bound to C-X 0.
  *
  * int f, n;	arguments are ignored for this command
  */
-int delwind(int f, int n)
+BINDABLE( delwind) {
-{
+	window_p wp;	/* window to recieve deleted space */
-	struct window *wp;	/* window to recieve deleted space */
+	window_p lwp;	/* ptr window before curwp */
-	struct window *lwp;	/* ptr window before curwp */
 	int target;	/* target line to search for */
 
 	/* if there is only one window, don't delete it */
-	if (wheadp->w_wndp == NULL) {
+	if( wheadp->w_wndp == NULL)
-		mlwrite("Can not delete this window");
+		return mloutfail( "Can not delete this window") ;
-		return FALSE;
-	}
 
 	/* find window before curwp in linked list */
 	wp = wheadp;
@@ -316,8 +295,8 @@ int delwind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Split the current window.  A window smaller than 3 lines cannot be
+/* Split the current window.  A window smaller than 3 lines cannot be
  * split.  An argument of 1 forces the cursor into the upper window, an
  * argument of two forces the cursor to the lower window.  The only
  * other error that is possible is a "malloc" failure allocating the
@@ -325,21 +304,21 @@ int delwind(int f, int n)
  *
  * int f, n;	default flag and numeric argument
  */
-int splitwind(int f, int n)
+BINDABLE( splitwind) {
-{
+	window_p wp;
-	struct window *wp;
+	line_p lp;
-	struct line *lp;
 	int ntru;
 	int ntrl;
 	int ntrd;
-	struct window *wp1;
+	window_p wp1;
-	struct window *wp2;
+	window_p wp2;
 
-	if (curwp->w_ntrows < 3) {
+	if( curwp->w_ntrows < 3) {
-		mlwrite("Cannot split a %d line window", curwp->w_ntrows);
+		mloutfmt( "Cannot split a %d line window", curwp->w_ntrows) ;
-		return FALSE;
+		return FALSE ;
 	}
-	wp = xmalloc(sizeof(struct window));
+
+	wp = xmalloc( sizeof *wp) ;
 	++curbp->b_nwnd;	/* Displayed twice.     */
 	wp->w_bufp = curbp;
 	wp->w_dotp = curwp->w_dotp;
@@ -398,33 +377,30 @@ int splitwind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Enlarge the current window. Find the window that loses space. Make sure it
+/* Enlarge the current window. Find the window that loses space. Make sure it
  * is big enough. If so, hack the window descriptions, and ask redisplay to do
  * all the hard work. You don't just set "force reframe" because dot would
  * move. Bound to "C-X Z".
  */
-int enlargewind(int f, int n)
+BINDABLE( enlargewind) {
-{
+	window_p adjwp;
-	struct window *adjwp;
+	line_p lp;
-	struct line *lp;
 	int i;
 
 	if (n < 0)
 		return shrinkwind(f, -n);
-	if (wheadp->w_wndp == NULL) {
+	if( wheadp->w_wndp == NULL)
-		mlwrite("Only one window");
+		return mloutfail( "Only one window") ;
-		return FALSE;
+
-	}
 	if ((adjwp = curwp->w_wndp) == NULL) {
 		adjwp = wheadp;
 		while (adjwp->w_wndp != curwp)
 			adjwp = adjwp->w_wndp;
 	}
-	if (adjwp->w_ntrows <= n) {
+	if( adjwp->w_ntrows <= n)
-		mlwrite("Impossible change");
+		return mloutfail( "Impossible change") ;
-		return FALSE;
+
-	}
 	if (curwp->w_wndp == adjwp) {	/* Shrink below.        */
 		lp = adjwp->w_linep;
 		for (i = 0; i < n && lp != adjwp->w_bufp->b_linep; ++i)
@@ -450,32 +426,29 @@ int enlargewind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Shrink the current window. Find the window that gains space. Hack at the
+/* Shrink the current window. Find the window that gains space. Hack at the
  * window descriptions. Ask the redisplay to do all the hard work. Bound to
  * "C-X C-Z".
  */
-int shrinkwind(int f, int n)
+BINDABLE( shrinkwind) {
-{
+	window_p adjwp;
-	struct window *adjwp;
+	line_p lp;
-	struct line *lp;
 	int i;
 
 	if (n < 0)
 		return enlargewind(f, -n);
-	if (wheadp->w_wndp == NULL) {
+	if( wheadp->w_wndp == NULL)
-		mlwrite("Only one window");
+		return mloutfail( "Only one window") ;
-		return FALSE;
+
-	}
 	if ((adjwp = curwp->w_wndp) == NULL) {
 		adjwp = wheadp;
 		while (adjwp->w_wndp != curwp)
 			adjwp = adjwp->w_wndp;
 	}
-	if (curwp->w_ntrows <= n) {
+	if( curwp->w_ntrows <= n)
-		mlwrite("Impossible change");
+		return mloutfail( "Impossible change") ;
-		return FALSE;
+
-	}
 	if (curwp->w_wndp == adjwp) {	/* Grow below.          */
 		lp = adjwp->w_linep;
 		for (i = 0; i < n && lback(lp) != adjwp->w_bufp->b_linep;
@@ -502,13 +475,12 @@ int shrinkwind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Resize the current window to the requested size
+/* Resize the current window to the requested size
  *
  * int f, n;		default flag and numeric argument
  */
-int resize(int f, int n)
+BINDABLE( resize) {
-{
 	int clines;		/* current # of lines in window */
 
 	/* must have a non-default argument, else ignore call */
@@ -525,14 +497,14 @@ int resize(int f, int n)
 	return enlargewind(TRUE, n - clines);
 }
 
-/*
+
- * Pick a window for a pop-up. Split the screen if there is only one window.
+/* Pick a window for a pop-up. Split the screen if there is only one window.
  * Pick the uppermost window that isn't the current window. An LRU algorithm
  * might be better. Return a pointer, or NULL on error.
  */
-struct window *wpopup(void)
+window_p wpopup(void)
 {
-	struct window *wp;
+	window_p wp;
 
 	if (wheadp->w_wndp == NULL	/* Only 1 window        */
 	    && splitwind(FALSE, 0) == FALSE)	/* and it won't split   */
@@ -543,59 +515,57 @@ struct window *wpopup(void)
 	return wp;
 }
 
-int scrnextup(int f, int n)
+
-{				/* scroll the next window up (back) a page */
+/* scroll the next window up (back) a page */
+BINDABLE( scrnextup) {
 	nextwind(FALSE, 1);
 	backpage(f, n);
 	prevwind(FALSE, 1);
 	return TRUE;
 }
 
-int scrnextdw(int f, int n)
+
-{				/* scroll the next window down (forward) a page */
+/* scroll the next window down (forward) a page */
+BINDABLE( scrnextdw) {
 	nextwind(FALSE, 1);
 	forwpage(f, n);
 	prevwind(FALSE, 1);
 	return TRUE;
 }
 
-int savewnd(int f, int n)
+
-{				/* save ptr to current window */
+/* save ptr to current window */
-	swindow = curwp;
+BINDABLE( savewnd) {
-	return TRUE;
+	savwindow = curwp ;
+	return TRUE ;
 }
 
-int restwnd(int f, int n)
-{				/* restore the saved screen */
-	struct window *wp;
 
-	/* find the window */
+/* restore the saved screen */
-	wp = wheadp;
+BINDABLE( restwnd) {
-	while (wp != NULL) {
+/* check the saved window still exists */
-		if (wp == swindow) {
+	for( window_p wp = wheadp ; wp != NULL ; wp = wp->w_wndp) {
-			curwp = wp;
+		if( wp == savwindow) {
-			curbp = wp->w_bufp;
+			curwp = wp ;
-			upmode();
+			curbp = wp->w_bufp ;
-			return TRUE;
+			upmode() ;
+			return TRUE ;
 		}
-		wp = wp->w_wndp;
 	}
 
-	mlwrite("(No such window exists)");
+	return mloutfail( "(No such window exists)") ;
-	return FALSE;
 }
 
-/*
+
- * resize the screen, re-writing the screen
+/* resize the screen, re-writing the screen
  *
  * int f;	default flag
  * int n;	numeric argument
  */
-int newsize(int f, int n)
+BINDABLE( newsize) {
-{
+	window_p wp;		/* current window being examined */
-	struct window *wp;		/* current window being examined */
+	window_p nextwp;	/* next window to scan */
-	struct window *nextwp;	/* next window to scan */
+	window_p lastwp;	/* last window scanned */
-	struct window *lastwp;	/* last window scanned */
 	int lastline;		/* screen line of last line of current window */
 
 	/* if the command defaults, assume the largest */
@@ -603,10 +573,8 @@ int newsize(int f, int n)
 		n = term.t_mrow ;
 
 	/* make sure it's in range */
-	if (n < 3 || n > term.t_mrow) {
+	if( n < 3 || n > term.t_mrow)
-		mlwrite("%%Screen size out of range");
+		return mloutfail( "%%Screen size out of range") ;
-		return FALSE;
-	}
 
 	if (term.t_nrow == n - 1)
 		return TRUE;
@@ -674,25 +642,22 @@ int newsize(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * resize the screen, re-writing the screen
+/* resize the screen, re-writing the screen
  *
  * int f;		default flag
  * int n;		numeric argument
  */
-int newwidth(int f, int n)
+BINDABLE( newwidth) {
-{
+	window_p wp;
-	struct window *wp;
 
 	/* if the command defaults, assume the largest */
 	if (f == FALSE)
 		n = term.t_mcol;
 
 	/* make sure it's in range */
-	if (n < 10 || n > term.t_mcol) {
+	if (n < 10 || n > term.t_mcol)
-		mlwrite("%%Screen width out of range");
+		return mloutfail( "%%Screen width out of range") ;
-		return FALSE;
-	}
 
 	/* otherwise, just re-width it (no big deal) */
 	term.t_ncol = n;
@@ -713,7 +678,7 @@ int newwidth(int f, int n)
 int getwpos(void)
 {				/* get screen offset of current line in current window */
 	int sline;	/* screen line from top of window */
-	struct line *lp;	/* scannile line pointer */
+	line_p lp;	/* scannile line pointer */
 
 	/* search down the line we want */
 	lp = curwp->w_linep;
@@ -731,3 +696,5 @@ void cknewwindow(void)
 {
 	execute(META | SPEC | 'X', FALSE, 1);
 }
+
+/* end of window.c */

window.h

@@ -1,34 +1,35 @@
+/* window.h -- window functionality */
 #ifndef _WINDOW_H_
 #define _WINDOW_H_
 
 #include "defines.h"	/* COLOR, SCROLLCODE */
-#include "buffer.h"		/* buffer, line */
+#include "buffer.h"		/* buffer_p, line_p */
+#include "names.h"		/* BINDABLE() */
 
-/*
+/* There is a window structure allocated for every active display window.
- * There is a window structure allocated for every active display window. The
+   The windows are kept in a big list, in top to bottom screen order, with
- * windows are kept in a big list, in top to bottom screen order, with the
+   the listhead at "wheadp".  Each window contains its own values of dot
- * listhead at "wheadp". Each window contains its own values of dot and mark.
+   and mark.  The flag field contains some bits that are set by commands to
- * The flag field contains some bits that are set by commands to guide
+   guide redisplay.  Although this is a bit of a compromise in terms of
- * redisplay. Although this is a bit of a compromise in terms of decoupling,
+   decoupling, the full blown redisplay is just too expensive to run for
- * the full blown redisplay is just too expensive to run for every input
+   every input character.
- * character.
  */
 typedef struct window {
 	struct window *w_wndp;	/* Next window                  */
-	struct buffer *w_bufp;	/* Buffer displayed in window   */
+	buffer_p w_bufp ;		/* Buffer displayed in window   */
 	line_p	w_linep ;		/* Top line in the window       */
 	line_p	w_dotp ;		/* Line containing "."          */
 	line_p	w_markp ;		/* Line containing "mark"       */
 	int w_doto ;			/* Byte offset for "."          */
-	int w_marko;		/* Byte offset for "mark"       */
+	int w_marko ;			/* Byte offset for "mark"       */
-	int w_toprow ;		/* Origin 0 top row of window   */
+	int w_toprow ;			/* Origin 0 top row of window   */
-	int w_ntrows ;		/* # of rows of text in window  */
+	int w_ntrows ;			/* # of rows of text in window  */
-	char w_force;		/* If NZ, forcing row.          */
+	char w_force ;			/* If NZ, forcing row.          */
-	char w_flag;		/* Flags.                       */
+	char w_flag ;			/* Flags.                       */
-#if	COLOR
+# if COLOR
-	char w_fcolor;		/* current forground color      */
+	char w_fcolor ;			/* current forground color      */
-	char w_bcolor;		/* current background color     */
+	char w_bcolor ;			/* current background color     */
-#endif
+# endif
 } *window_p ;
 
 extern window_p curwp ;		/* Current window               */
@@ -44,31 +45,34 @@ extern window_p wheadp ;	/* Head of list of windows      */
 #define WFMODE  0x10		/* Update mode line.            */
 #define	WFCOLR	0x20		/* Needs a color change         */
 
-#if SCROLLCODE
+# if SCROLLCODE
-#define WFKILLS 0x40		/* something was deleted        */
+# define WFKILLS 0x40		/* something was deleted        */
-#define WFINS   0x80		/* something was inserted       */
+# define WFINS   0x80		/* something was inserted       */
-#endif
+# endif
+
+/* Bindable functions */
+ BINDABLE( delwind) ;
+ BINDABLE( enlargewind) ;
+ BINDABLE( mvdnwind) ;
+ BINDABLE( mvupwind) ;
+ BINDABLE( newsize) ;
+ BINDABLE( newwidth) ;
+ BINDABLE( nextwind) ;
+ BINDABLE( onlywind) ;
+ BINDABLE( prevwind) ;
+TBINDABLE( redraw) ;
+TBINDABLE( reposition) ;
+ BINDABLE( resize) ;
+ BINDABLE( restwnd) ;
+ BINDABLE( savewnd) ;
+ BINDABLE( scrnextdw) ;
+ BINDABLE( scrnextup) ;
+ BINDABLE( shrinkwind) ;
+ BINDABLE( splitwind) ;
 
-int reposition( int f, int n);
-int redraw( int f, int n) ;
-int nextwind( int f, int n) ;
-int prevwind( int f, int n) ;
-int mvdnwind( int f, int n) ;
-int mvupwind( int f, int n) ;
-int onlywind( int f, int n) ;
-int delwind( int f, int n) ;
-int splitwind( int f, int n) ;
-int enlargewind( int f, int n) ;
-int shrinkwind( int f, int n) ;
-int resize( int f, int n) ;
-int scrnextup( int f, int n) ;
-int scrnextdw( int f, int n) ;
-int savewnd( int f, int n) ;
-int restwnd( int f, int n) ;
-int newsize( int f, int n) ;
-int newwidth( int f, int n) ;
 int getwpos( void) ;
 void cknewwindow( void) ;
 window_p wpopup( void) ;  /* Pop up window creation. */
 
 #endif
+/* end of window.h */

word.c

@@ -1,13 +1,11 @@
 /* word.c -- implements word.h */
 #include "word.h"
 
-/*	word.c
+/* The routines in this file implement commands that work word or a
- *
+   paragraph at a time.  There are all sorts of word mode commands.  If I
- *      The routines in this file implement commands that work word or a
+   do any sentence mode commands, they are likely to be put in this file.
- *      paragraph at a time.  There are all sorts of word mode commands.  If I
+
- *      do any sentence mode commands, they are likely to be put in this file.
+   Modified by Petri Kutvonen
- *
- *	Modified by Petri Kutvonen
  */
 
 #include <assert.h>
@@ -31,18 +29,18 @@ static int justflag = FALSE ;		/* justify, don't fill */
 
 static int inword( void) ;
 
-/* Word wrap on n-spaces. Back-over whatever precedes the point on the current
+/* Word wrap on n-spaces.  Back-over whatever precedes the point on the
- * line and stop on the first word-break or the beginning of the line. If we
+   current line and stop on the first word-break or the beginning of the
- * reach the beginning of the line, jump back to the end of the word and start
+   line.  If we reach the beginning of the line, jump back to the end of
- * a new line.	Otherwise, break the line at the word-break, eat it, and jump
+   the word and start a new line.  Otherwise, break the line at the
- * back to the end of the word.
+   word-break, eat it, and jump back to the end of the word.
- * Returns TRUE on success, FALSE on errors.
+
- *
+   Returns TRUE on success, FALSE on errors.
- * @f: default flag.
+ 
- * @n: numeric argument.
+   @f: default flag.
+   @n: numeric argument.
  */
-int wrapword(int f, int n)
+BINDABLE( wrapword) {
-{
 	int cnt;	/* size of word wrapped to next line */
 	int c;		/* charector temporary */
 
@@ -81,11 +79,12 @@ int wrapword(int f, int n)
 	return TRUE;
 }
 
-/* Move the cursor backward by "n" words. All of the details of motion are
+
- * performed by the "backchar" and "forwchar" routines. Error if you try to
+/* Move the cursor backward by "n" words.  All of the details of motion are
- * move beyond the buffers.
+   performed by the "backchar" and "forwchar" routines.  Error if you try
+   to move beyond the buffers.
  */
-int backword( int f, int n) {
+BINDABLE( backword) {
 	if( n < 0)
 		return forwword( f, -n) ;
 
@@ -106,10 +105,12 @@ int backword( int f, int n) {
 	return forwchar( FALSE, 1) ;
 }
 
-/* Move the cursor forward by the specified number of words. All of the motion
+
- * is done by "forwchar". Error if you try and move beyond the buffer's end.
+/* Move the cursor forward by the specified number of words.  All of the
+   motion is done by "forwchar".  Error if you try and move beyond the
+   buffer's end.
  */
-int forwword( int f, int n) {
+BINDABLE( forwword) {
 	if( n < 0)
 		return backword( f, -n) ;
 
@@ -172,40 +173,41 @@ static boolean capcapword( int n, boolean first_f, boolean rest_f) {
 	return TRUE ;
 }
 
-/* Move the cursor forward by the specified number of words. As you move,
+
- * convert any characters to upper case. Error if you try and move beyond the
+/* Move the cursor forward by the specified number of words.  As you move,
- * end of the buffer. Bound to "M-U".
+   convert any characters to upper case.  Error if you try and move beyond
+   the end of the buffer.  Bound to "M-U".
  */
-int upperword( int f, int n) {
+BINDABLE( upperword) {
 	return capcapword( n, TRUE, TRUE) ;
 }
 
 
-/* Move the cursor forward by the specified number of words. As you move
+/* Move the cursor forward by the specified number of words.  As you move
- * convert characters to lower case. Error if you try and move over the end of
+   convert characters to lower case.  Error if you try and move over the
- * the buffer. Bound to "M-L".
+   end of the buffer.  Bound to "M-L".
  */
-int lowerword( int f, int n) {
+BINDABLE( lowerword) {
 	return capcapword( n, FALSE, FALSE) ;
 }
 
-/* Move the cursor forward by the specified number of words. As you move
+
- * convert the first character of the word to upper case, and subsequent
+/* Move the cursor forward by the specified number of words.  As you move
- * characters to lower case. Error if you try and move past the end of the
+   convert the first character of the word to upper case, and subsequent
- * buffer. Bound to "M-C".
+   characters to lower case.  Error if you try and move past the end of the
+   buffer.  Bound to "M-C".
  */
-int capword( int f, int n) {
+BINDABLE( capword) {
 	return capcapword( n, TRUE, FALSE) ;
 }
 
-/*
+
- * Kill forward by "n" words. Remember the location of dot. Move forward by
+/* Kill forward by "n" words.  Remember the location of dot.  Move forward
- * the right number of words. Put dot back where it was and issue the kill
+   by the right number of words.  Put dot back where it was and issue the
- * command for the right number of characters. With a zero argument, just
+   kill command for the right number of characters.  With a zero argument,
- * kill one word and no whitespace. Bound to "M-D".
+   just kill one word and no whitespace.  Bound to "M-D".
  */
-int delfword(int f, int n)
+BINDABLE( delfword) {
-{
 	line_p dotp;	/* original cursor line */
 	int doto;	/*      and row */
 	int c;		/* temp char */
@@ -285,13 +287,13 @@ int delfword(int f, int n)
 	return ldelete(size, TRUE);
 }
 
-/*
+
- * Kill backwards by "n" words. Move backwards by the desired number of words,
+/* Kill backwards by "n" words.  Move backwards by the desired number of
- * counting the characters. When dot is finally moved to its resting place,
+   words, counting the characters.  When dot is finally moved to its
- * fire off the kill command. Bound to "M-Rubout" and to "M-Backspace".
+   resting place, fire off the kill command.  Bound to "M-Rubout" and to
+   "M-Backspace".
  */
-int delbword(int f, int n)
+BINDABLE( delbword) {
-{
 	assert( !(curbp->b_mode & MDVIEW)) ;
 
 	/* ignore the command if there is a nonpositive argument */
@@ -352,17 +354,13 @@ static int parafillnjustify( int f, int n, int justify_f) {
 
 	assert( !(curbp->b_mode & MDVIEW)) ;
 
-	if (fillcol == 0) {	/* no fill column set */
+	if( fillcol == 0)	/* no fill column set */
-		mloutstr( "No fill column set") ;
+		return mloutfail( "No fill column set") ;
-		return FALSE;
-	}
 
 	if( justify_f) {
 		leftmarg = getccol( FALSE) ;
-		if (leftmarg + 10 > fillcol) {
+		if( leftmarg + 10 > fillcol)
-			mloutstr( "Column too narrow") ;
+			return mloutfail( "Column too narrow") ;
-			return FALSE;
-		}
 
 		justflag = justify_f ;
 	}
@@ -472,33 +470,33 @@ static int parafillnjustify( int f, int n, int justify_f) {
 	return TRUE;
 }
 
-/*
+
- * Fill the current paragraph according to the current
+/* Fill the current paragraph according to the current
  * fill column
  *
  * f and n - deFault flag and Numeric argument
  */
-int fillpara( int f, int n) {
+BINDABLE( fillpara) {
 	return parafillnjustify( f, n, FALSE) ;
 }
 
+
 /* Fill the current paragraph according to the current
  * fill column and cursor position
  *
  * int f, n;		deFault flag and Numeric argument
  */
-int justpara( int f, int n) {
+BINDABLE( justpara) {
 	return parafillnjustify( f, n, TRUE) ;
 }
 
-/*
+
- * delete n paragraphs starting with the current one
+/* delete n paragraphs starting with the current one
  *
  * int f	default flag
  * int n	# of paras to delete
  */
-int killpara(int f, int n)
+BINDABLE( killpara) {
-{
 	while (n--) {		/* for each paragraph to delete */
 
 		/* mark out the end and beginning of the para to delete */
@@ -525,15 +523,13 @@ int killpara(int f, int n)
 }
 
 
-/*
+/*	wordcount:	count the # of words in the marked region,
- *	wordcount:	count the # of words in the marked region,
  *			along with average word sizes, # of chars, etc,
  *			and report on them.
  *
  * int f, n;		ignored numeric arguments
  */
-int wordcount(int f, int n)
+BINDABLE( wordcount) {
-{
 	line_p lp;	/* current line to scan */
 	int offset;	/* current char to scan */
 	long size;		/* size of region left to count */
@@ -591,15 +587,14 @@ int wordcount(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * go back to the beginning of the current paragraph
+/* 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
  */
-int gotobop(int f, int n)
+BINDABLE( gotobop) {
-{
 	if (n < 0) /* the other way... */
 		return gotoeop(f, -n);
 
@@ -629,15 +624,14 @@ int gotobop(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Go forward to the end of the current paragraph
+/* Go forward to the end of the current paragraph here we look for a
- * here we look for a <NL><NL> or <NL><TAB> or <NL><SPACE>
+   <NL><NL> or <NL><TAB> or <NL><SPACE> combination to delimit the
- * combination to delimit the beginning of a paragraph
+   beginning of a paragraph
- *
+
- * int f, n;		default Flag & Numeric argument
+   int f, n;		default Flag & Numeric argument
  */
-int gotoeop(int f, int n)
+BINDABLE( gotoeop) {
-{
 	if (n < 0)  /* the other way... */
 		return gotobop(f, -n);