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

@@ -22,7 +22,7 @@
 #define CVMVAS  1   /* arguments to page forward/back in pages */
 
 int overlap = 0 ;   /* $overlap: line overlap in forw/back page */
-int curgoal ;       /* $target:  Goal for C-P, C-N */
+int curgoal ;       /* $target:  column goal for C-P, C-N */
 
 
 /* This routine, given a pointer to a struct line, and the current cursor
@@ -60,14 +60,14 @@ static unsigned getgoal( line_p dlp) {
 
 
 /* Move the cursor to the beginning of the current line of active window. */
-boolean gotobol( int f, int n) {
+TBINDABLE( gotobol) {
     curwp->w_doto = 0 ;
     return TRUE ;
 }
 
 
 /* Move the cursor to the end of the current line of active window. */
-boolean gotoeol( int f, int n) {
+TBINDABLE( gotoeol) {
     curwp->w_doto = llength( curwp->w_dotp) ;
     return TRUE ;
 }
@@ -77,7 +77,7 @@ boolean gotoeol( int f, int n) {
    considered to be hard motion; it really isn't if the original value of
    dot is the same as the new value of dot.  Normally bound to "M-<".
  */
-boolean gotobob( int f, int n) {
+TBINDABLE( gotobob) {
     curwp->w_dotp = lforw( curbp->b_linep) ;
     curwp->w_doto = 0 ;
     curwp->w_flag |= WFHARD ;
@@ -89,7 +89,7 @@ boolean gotobob( int f, int n) {
    (ZJ).  The standard screen code does most of the hard parts of update.
    Bound to "M->".
  */
-boolean gotoeob( int f, int n) {
+TBINDABLE( gotoeob) {
     curwp->w_dotp = curbp->b_linep ;
     curwp->w_doto = 0 ;
     curwp->w_flag |= WFHARD ;
@@ -102,14 +102,8 @@ boolean gotoeob( int f, int n) {
    command controls how the goal column is set.  Bound to "C-N".  No errors
    are possible.
  */
-boolean forwline( int f, int n) {
+BBINDABLE( forwline) {
     assert( f == TRUE || n == 1) ;
-    if( n < 0)
-        return backline( f, -n) ;
-
-/* if we are on the last line as we start....fail the command */
-    if( n && 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)
@@ -119,16 +113,26 @@ boolean forwline( int f, int n) {
     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 ;
+            }
+        }
 
-/* reseting the current position */
+    /* resetting the current position */
         curwp->w_dotp = dlp ;
         curwp->w_doto = getgoal( dlp) ;
         curwp->w_flag |= WFMOVE ;
+    }
+
     return (n == 0) ? TRUE : FALSE ;
 }
 
@@ -138,33 +142,10 @@ boolean forwline( int f, int n) {
    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) {
+BBINDABLE( backline) {
-    if( n < 0)
+    assert( f == TRUE || n == 1) ;
-        return forwline( f, -n) ;
 
-/* if we are on the first line as we start....fail the command */
+    return forwline( TRUE, -n) ;
-    if( n && 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 */
-    line_p 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 ;
 }
 
 
@@ -209,7 +190,7 @@ BINDABLE( gotoline) {
    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 ;
 
     if( f == FALSE) {
@@ -232,17 +213,15 @@ boolean forwpage( int f, int n) {
         n *= curwp->w_ntrows;   /* To lines. */
 #endif
 
-/*  lp = curwp->w_linep; */
     lp = curwp->w_dotp ;
     while( n && lp != curbp->b_linep) {
         lp = lforw( lp) ;
         n -= 1 ;
     }
 
-/*  curwp->w_linep = lp; */
     curwp->w_dotp = lp ;
     curwp->w_doto = 0 ;
-    reposition( TRUE, 0) ;
+    reposition( TRUE, 0) ;  /* center at dot, always succeed */
 
 #if SCROLLCODE
     curwp->w_flag |= WFHARD | WFKILLS;
@@ -258,7 +237,7 @@ boolean forwpage( int f, int n) {
    ITS EMACS manual.  Bound to "M-V".  We do a hard update for exactly the
    same reason.
  */
-boolean backpage( int f, int n) {
+TBINDABLE( backpage) {
     line_p lp ;
 
     if( f == FALSE) {   /* interactive, default n = 1 supplied */
@@ -313,7 +292,7 @@ boolean backpage( int f, int n) {
 /* Set the mark in the current window to the value of "." in the window.
    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_marko = curwp->w_doto ;
     mloutstr( "(Mark set)") ;
@@ -324,7 +303,7 @@ boolean setmark( int f, int n) {
 /* Swap the values of "." and "mark" in the current window.  If no mark as
    been previously set, set it.  Bound to C-X C-X exchange-point-and-mark.
  */
-boolean swapmark( int f, int n) {
+TBINDABLE( swapmark) {
     line_p odotp = curwp->w_dotp ;
     int odoto = curwp->w_doto ;
     if( curwp->w_markp) {

basic.h

@@ -1,5 +1,4 @@
 /* basic.h -- basic commands for cursor movement in active window */
-
 #ifndef _BASIC_H_
 # define _BASIC_H_
 
@@ -17,18 +16,17 @@ extern int curgoal ;    /* $target: Goal for C-P previous-line, C-N next-line */
 
 
 /* Bindable functions */
-boolean gotobol( int f, int n) ;
+BBINDABLE( backline) ;
-boolean gotoeol( int f, int n) ;
+TBINDABLE( backpage) ;
+BBINDABLE( forwline) ;
+TBINDABLE( forwpage) ;
+TBINDABLE( gotobob) ;
+TBINDABLE( gotobol) ;
+TBINDABLE( gotoeob) ;
+TBINDABLE( gotoeol) ;
  BINDABLE( gotoline) ;
-boolean gotobob( int f, int n) ;
+TBINDABLE( setmark) ;
-boolean gotoeob( int f, int n) ;
+TBINDABLE( swapmark) ;
-boolean forwline( int f, int n) ;
-boolean backline( int f, int n) ;
-boolean forwpage( int f, int n) ;
-boolean backpage( int f, int n) ;
-boolean setmark( int f, int n) ;
-boolean swapmark( int f, int n) ;
 
 #endif
-
 /* end of basic.h */

bind.c

@@ -119,8 +119,8 @@ BINDABLE( bindtokey) {
     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)
         return invalidkey() ;
@@ -131,10 +131,10 @@ BINDABLE( bindtokey) {
 
 /* key sequence can't be an active prefix key */
     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 ;   /* be silent if keep current */
 
         return mloutfail( "(Can't bind to active prefix)") ;
@@ -150,13 +150,13 @@ BINDABLE( bindtokey) {
             }
 
     /* 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 ;
     }
 
@@ -404,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++ = ctlxc & ~PRFXMASK ;
     }
 
 /* apply control sequence if needed */
-    if( c & CTRL)
+    if( c & CTL_)
         *ptr++ = '^' ;
 
 /* apply SPEC sequence if needed */
@@ -461,7 +461,7 @@ static unsigned int stock( char *keyname) {
 
 /* a control char? */
     if( *keyname == '^' && keyname[ 1] != 0) {
-        c |= CTRL ;
+        c |= CTL_ ;
         ++keyname ;
     }
 
@@ -477,7 +477,7 @@ static unsigned int stock( char *keyname) {
 
 /* 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)
             &&  *keyname >= 'a' && *keyname <= 'z')

bindable.c

@@ -70,7 +70,7 @@ BINDABLE( quit) {
  * Error if not at the top level in keyboard processing. Set up variables and
  * return.
  */
-BINDABLE( ctlxlp) {
+BBINDABLE( ctlxlp) {
     if( kbdmode != STOP)
         return mloutfail( "%Macro already active") ;
 
@@ -85,7 +85,7 @@ BINDABLE( ctlxlp) {
 /* End keyboard macro. Check for the same limit conditions as the above
  * routine. Set up the variables and return to the caller.
  */
-BINDABLE( ctlxrp) {
+BBINDABLE( ctlxrp) {
     if( kbdmode == STOP)
         return mloutfail( "%Macro not active") ;
 
@@ -102,7 +102,7 @@ BINDABLE( ctlxrp) {
  * 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.
  */
-BINDABLE( ctlxe) {
+BBINDABLE( ctlxe) {
     if( kbdmode != STOP)
         return mloutfail( "%Macro already active") ;
 

bindable.h

@@ -1,18 +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 */
+BBINDABLE( ctlxe) ;
+BBINDABLE( ctlxlp) ;
+BBINDABLE( ctlxrp) ;
+ BINDABLE( ctrlg) ;		/* ABORT */
  BINDABLE( quickexit) ;
  BINDABLE( quit) ;
-BINDABLE( ctlxlp) ;
-BINDABLE( ctlxrp) ;
-BINDABLE( ctlxe) ;
-BINDABLE( ctrlg) ;
 
 #endif
-
 /* end of bindable.h */

buffer.c

@@ -1,18 +1,12 @@
 /* buffer.c -- implements buffer.h */
 #include "buffer.h"
 
-/*	buffer.c
+/*  Buffer management.  Some of the functions are internal, and some are actually attached to
- *
+    user keys.  Like everyone else, they set hints for the display system.
- *	Buffer management.
+
- *	Some of the functions are internal,
+    modified by Petri Kutvonen
- *	and some are actually attached to user
- *	keys. Like everyone else, they set hints
- *	for the display system
- *
- *	modified by Petri Kutvonen
  */
 
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -26,11 +20,11 @@
 #include "window.h"
 
 
-struct buffer *curbp ;		/* Current buffer               */
+buffer_p curbp ;        /* Current buffer               */
-struct buffer *bheadp ;		/* Head of list of buffers      */
+buffer_p bheadp ;       /* Head of list of buffers      */
-struct buffer *blistp ;		/* Buffer for C-X C-B           */
+buffer_p blistp ;       /* Buffer for C-X C-B           */
 
-const char *modename[] = {	/* name of modes                */
+const char *modename[ NUMMODES] = { /* name of modes */
     "Wrap", "Cmode", "Exact", "View", "Over",
     "Magic",
     "Asave", "Utf-8", "Dos"
@@ -43,24 +37,20 @@ static int addline( char *text) ;
 static void l_to_a( char *buf, int width, long num) ;
 
 
-/*
+/* Attach a buffer to a window.  The values of dot and mark come from the
- * Attach a buffer to a window. The
+   buffer if the use count is 0.  Otherwise, they come from some other
- * values of dot and mark come from the buffer
+   window.
- * if the use count is 0. Otherwise, they come
- * from some other window.
  */
-int usebuffer( int f, int n) {
+BINDABLE( usebuffer) {
-	struct buffer *bp ;
-	int status ;
     char *bufn ;
 
 /* Get buffer name */
-	status = newmlarg( &bufn, "Use buffer: ", sizeof( bname_t)) ;
+    int status = newmlarg( &bufn, "select-buffer: ", sizeof( bname_t)) ;
     if( status != TRUE)
         return status ;
 
 /* Find buffer in list */
-	bp = bfind( bufn, TRUE, 0) ;
+    buffer_p bp = bfind( bufn, TRUE, 0) ;
     free( bufn) ;
     if( bp == NULL)
         return FALSE ;
@@ -69,28 +59,27 @@ int usebuffer( int f, int n) {
     return swbuffer( bp) ;
 }
 
-/*
+
- * switch to the next buffer in the buffer list
+/* switch to the next buffer in the buffer list
  *
  * int f, n;        default flag, numeric argument
  */
-int nextbuffer(int f, int n)
+BINDABLE( nextbuffer) {
-{
+    buffer_p bp = NULL ;    /* eligible buffer to switch to */
-	struct buffer *bp = NULL;  /* eligable buffer to switch to */
-	struct buffer *bbp;        /* eligable buffer to switch to */
 
     /* make sure the arg is legit */
     if( f == FALSE)
         n = 1 ;
+
     if( n < 1)
         return FALSE ;
 
-	bbp = curbp;
+    buffer_p bbp = curbp ;  /* eligible buffer to switch to */
     while( n-- > 0) {
         /* advance to the next buffer */
         bp = bbp->b_bufp ;
 
-		/* cycle through the buffers to find an eligable one */
+        /* cycle through the buffers to find an eligible one */
         while( bp == NULL || bp->b_flag & BFINVS) {
             if (bp == NULL)
                 bp = bheadp ;
@@ -100,7 +89,6 @@ int nextbuffer(int f, int n)
             /* don't get caught in an infinite loop! */
             if( bp == bbp)
                 return FALSE ;
-
         }
 
         bbp = bp ;
@@ -109,12 +97,11 @@ int nextbuffer(int f, int n)
     return swbuffer( bp) ;
 }
 
-/*
+
- * make buffer BP current
+/* make buffer BP current
  */
-int swbuffer(struct buffer *bp)
+int swbuffer( buffer_p bp) {
-{
+    window_p wp ;
-	struct window *wp;
 
     if (--curbp->b_nwnd == 0) { /* Last use.            */
         curbp->b_dotp = curwp->w_dotp;
@@ -157,21 +144,19 @@ int swbuffer(struct buffer *bp)
     return TRUE;
 }
 
-/*
+
- * Dispose of a buffer, by name.
+/* Dispose of a buffer, by name.  Ask for the name.  Look it up (don't get
- * Ask for the name. Look it up (don't get too
+   too upset if it isn't there at all!).  Get quite upset if the buffer is
- * upset if it isn't there at all!). Get quite upset
+   being displayed.  Clear the buffer (ask if the buffer has been changed).
- * if the buffer is being displayed. Clear the buffer (ask
+   Then free the header line and the buffer header.  Bound to "C-X K".
- * if the buffer has been changed). Then free the header
- * line and the buffer header. Bound to "C-X K".
  */
-int killbuffer( int f, int n) {
+BINDABLE( killbuffer) {
-	struct buffer *bp ;
+    buffer_p bp ;
     int status ;
     char *bufn ;
 
 /* Get buffer name */
-	status = newmlarg( &bufn, "Kill buffer: ", sizeof( bname_t)) ;
+    status = newmlarg( &bufn, "delete-buffer: ", sizeof( bname_t)) ;
     if( status != TRUE)
         return status ;
 
@@ -187,66 +172,60 @@ int killbuffer( int f, int n) {
     return zotbuf( bp) ;
 }
 
-/*
- * kill the buffer pointed to by bp
- */
-int zotbuf(struct buffer *bp)
-{
-	struct buffer *bp1;
-	struct buffer *bp2;
-	int s;
 
-	if (bp->b_nwnd != 0) {	/* Error if on screen.  */
+/* kill the buffer pointed to by bp
-		mloutstr("Buffer is being displayed");
+ */
-		return FALSE;
+int zotbuf( buffer_p bp) {
-	}
+    if( bp->b_nwnd != 0)	/* Error if on screen.  */
-	if ((s = bclear(bp)) != TRUE)	/* Blow text away.      */
+        return mloutfail( "Buffer is being displayed") ;
+
+    int s = bclear( bp) ;	/* Blow text away.      */
+    if( s != TRUE)
         return s ;
-	free((char *) bp->b_linep);	/* Release header line. */
+
-	bp1 = NULL;		/* Find the header.     */
+    free( bp->b_linep) ;	/* Release header line. */
-	bp2 = bheadp;
+
-	while (bp2 != bp) {
+/* unlink buffer from buffer chain */
-		bp1 = bp2;
+	if( bheadp == bp)
-		bp2 = bp2->b_bufp;
+		bheadp = bp->b_bufp ;
+	else for( buffer_p prev = bheadp ; prev != NULL ; prev = prev->b_bufp)
+		if( prev->b_bufp == bp) {
+			prev->b_bufp = bp->b_bufp ;
+			break ;
 		}
-	bp2 = bp2->b_bufp;	/* Next one in chain.   */
+
-	if (bp1 == NULL)	/* Unlink it.           */
+    free( bp) ;				/* Release buffer block */
-		bheadp = bp2;
-	else
-		bp1->b_bufp = bp2;
-	free((char *) bp);	/* Release buffer block */
     return TRUE ;
 }
 
-/*
+
- * Rename the current buffer
+/* Rename the current buffer
  *
  * int f, n;        default Flag & Numeric arg
  */
-int namebuffer( int f, int n) {
+BINDABLE( namebuffer) {
-	struct buffer *bp ;	/* pointer to scan through all buffers */
-	int status ;
     char *bufn ;        /* buffer to hold buffer name */
+    int status ;
 
-/* prompt for and get the new buffer name */
+/* iterate until it gets a unique new buffer name */
-ask:
+    do {
-    status = newmlarg( &bufn, "Change buffer name to: ", sizeof( bname_t)) ;
+    /* prompt for it */
+        status = newmlarg( &bufn, "name-buffer: ", sizeof( bname_t)) ;
         if( status != TRUE)
             return status ;
 
     /* and check for duplicates */
-	bp = bheadp ;
+        for( buffer_p bp = bheadp ; bp != NULL ; bp = bp->b_bufp) {
-	while( bp != NULL) {
+            if( bp != curbp) {  /* it's ok to rename buffer to same, so skip */
-		if( bp != curbp) {
             /* retry if the names are the same */
                 if( strcmp( bufn, bp->b_bname) == 0) {
                     free( bufn) ;
-				goto ask ;	/* try again */
+                    status = FALSE ;    /* try again */
+                    break ;
                 }
             }
-
-		bp = bp->b_bufp ;	/* onward */
         }
+    } while( !status) ;
 
 /* copy buffer name to structure */
     mystrscpy( curbp->b_bname, bufn, sizeof( bname_t)) ;
@@ -257,28 +236,28 @@ ask:
     return TRUE ;
 }
 
-/*
- * List all of the active buffers.  First update the special
- * buffer that holds the list.  Next make sure at least 1
- * window is displaying the buffer list, splitting the screen
- * if this is what it takes.  Lastly, repaint all of the
- * windows that are displaying the list.  Bound to "C-X C-B". 
- *
- * A numeric argument forces it to list invisible buffers as
- * well.
- */
-int listbuffers(int f, int n)
-{
-	struct window *wp;
-	int s;
 
-	if ((s = makelist(f)) != TRUE)
+/* List all of the active buffers.  First update the special buffer that
+   holds the list.  Next make sure at least 1 window is displaying the
+   buffer list, splitting the screen if this is what it takes.  Lastly,
+   repaint all of the windows that are displaying the list.  Bound to "C-X
+   C-B".
+   
+   A numeric argument forces it to list invisible buffers as well.
+ */
+BINDABLE( listbuffers) {
+    window_p wp ;
+
+    int s = makelist( f) ;
+    if( s != TRUE)
         return s ;
+
     if( blistp->b_nwnd == 0) {  /* Not on screen yet.   */
-		struct buffer *bp ;
+        buffer_p bp ;
 
         if( (wp = wpopup()) == NULL)
             return FALSE ;
+
         bp = wp->w_bufp ;
         if( --bp->b_nwnd == 0) {
             bp->b_dotp = wp->w_dotp ;
@@ -286,11 +265,12 @@ int listbuffers(int f, int n)
             bp->b_markp = wp->w_markp ;
             bp->b_marko = wp->w_marko ;
         }
+        
         wp->w_bufp = blistp ;
         ++blistp->b_nwnd ;
     }
-	wp = wheadp;
+    
-	while (wp != NULL) {
+    for( wp = wheadp ; wp != NULL ; wp = wp->w_wndp) {
         if( wp->w_bufp == blistp) {
             wp->w_linep = lforw( blistp->b_linep) ;
             wp->w_dotp = lforw( blistp->b_linep) ;
@@ -299,21 +279,18 @@ int listbuffers(int f, int n)
             wp->w_marko = 0 ;
             wp->w_flag |= WFMODE | WFHARD ;
         }
-		wp = wp->w_wndp;
     }
+    
     return TRUE ;
 }
 
-/*
+
- * This routine rebuilds the
+/* This routine rebuilds the text in the special secret buffer that holds
- * text in the special secret buffer
+   the buffer list.  It is called by the list buffers command.  Return TRUE
- * that holds the buffer list. It is called
+   if everything works.  Return FALSE if there is an error (if there is no
- * by the list buffers command. Return TRUE
+   memory).  Iflag indicates wether to list hidden buffers.
- * if everything works. Return FALSE if there
+
- * is an error (if there is no memory). Iflag
+   int iflag;       list hidden buffer flag
- * indicates wether to list hidden buffers.
- *
- * int iflag;		list hidden buffer flag
  */
 /* Layout: "ACT MODES          Size Buffer          File"
             AAA MMMMMMMMMSSSSSSSSSS BBBBBBBBBBBBBBB FFF...
@@ -333,6 +310,7 @@ static void do_layout( char *line, int mode) {
             line[ 4 + i] = '.' ;
 }
 
+
 static unsigned int utf8_disp_len( const char *s) {
     unsigned int len = 0 ;
 
@@ -346,9 +324,9 @@ static unsigned int utf8_disp_len( const char *s) {
     return len ;
 }
 
-static int makelist( int iflag)
+
-{
+static int makelist( int iflag) {
-	struct buffer *bp;
+    buffer_p bp;
     int s;
     char line[ FNAMSTART + sizeof( fname_t)] ;
 
@@ -371,7 +349,7 @@ static int makelist( int iflag)
     for( bp = bheadp ; bp != NULL ; bp = bp->b_bufp) {  /* For all buffers */
         char *cp1, *cp2 ;
         int c ;
-		struct line *lp ;
+        line_p lp ;
         long nbytes ;       /* # of bytes in current buffer */
         long nlines ;       /* # of lines in current buffer */
 
@@ -430,8 +408,8 @@ static int makelist( int iflag)
     return TRUE ;       /* All done             */
 }
 
-static void l_to_a(char *buf, int width, long num)
+
-{
+static void l_to_a(char *buf, int width, long num) {
     buf[ --width] = 0 ;     /* End of string.       */
     while (num >= 10) { /* Conditional digits.  */
         buf[--width] = (int) (num % 10L) + '0';
@@ -442,87 +420,82 @@ static void l_to_a(char *buf, int width, long num)
         buf[--width] = ' ';
 }
 
-/*
- * The argument "text" points to
- * a string. Append this line to the
- * buffer list buffer. Handcraft the EOL
- * on the end. Return TRUE if it worked and
- * FALSE if you ran out of room.
- */
-static int addline( char *text)
-{
-	struct line *lp;
-	int i;
-	int ntext;
 
-	ntext = strlen(text);
+/* The argument "text" points to a string.  Append this line to the buffer
-	if ((lp = lalloc(ntext)) == NULL)
+   list buffer.  Handcraft the EOL on the end.  Return TRUE if it worked
+   and FALSE if you ran out of room.
+ */
+static int addline( char *text) {
+    int ntext = strlen( text) ;
+    line_p lp = lalloc( ntext) ;
+    if( lp == NULL)
         return FALSE ;
-	for (i = 0; i < ntext; ++i)
+
+    for( int i = 0 ; i < ntext ; ++i)
         lputc( lp, i, text[ i]) ;
+
     blistp->b_linep->l_bp->l_fp = lp ;      /* Hook onto the end    */
     lp->l_bp = blistp->b_linep->l_bp ;
     blistp->b_linep->l_bp = lp ;
     lp->l_fp = blistp->b_linep ;
     if( blistp->b_dotp == blistp->b_linep)  /* If "." is at the end */
         blistp->b_dotp = lp ;               /* move it to new line  */
+
     return TRUE ;
 }
 
-/*
+
- * Look through the list of
+/* Look through the list of buffers.  Return TRUE if there are any changed
- * buffers. Return TRUE if there
+   buffers.  Buffers that hold magic internal stuff are not considered; who
- * are any changed buffers. Buffers
+   cares if the list of buffer names is hacked.  Return FALSE if no buffers
- * that hold magic internal stuff are
+   have been changed.
- * not considered; who cares if the
- * list of buffer names is hacked.
- * Return FALSE if no buffers
- * have been changed.
  */
-int anycb(void)
+boolean anycb( void) {
-{
+    for( buffer_p bp = bheadp ; bp != NULL ; bp = bp->b_bufp) {
-	struct buffer *bp;
+        if( (bp->b_flag & (BFINVS | BFCHG)) == BFCHG)
-
-	bp = bheadp;
-	while (bp != NULL) {
-		if ((bp->b_flag & BFINVS) == 0
-		    && (bp->b_flag & BFCHG) != 0)
             return TRUE ;
-		bp = bp->b_bufp;
     }
+
     return FALSE ;
 }
 
-/*
+
- * Find a buffer, by name. Return a pointer
+/* Find a buffer, by name.  Return a pointer to the buffer structure
- * to the buffer structure associated with it.
+   associated with it.  If the buffer is not found and the "create_f" is
- * If the buffer is not found
+   TRUE, create it.  The "flags" is the settings for the buffer flags.
- * and the "cflag" is TRUE, create it. The "bflag" is
- * the settings for the flags in in buffer.
  */
-struct buffer *bfind( const char *bname, int cflag, int bflag)
+buffer_p bfind( const char *bname, boolean create_f, int flags) {
-{
+    buffer_p bp ;
-	struct buffer *bp;
-	struct line *lp;
 
     for( bp = bheadp ; bp != NULL ; bp = bp->b_bufp)
         if( strcmp( bname, bp->b_bname) == 0)
             return bp ;
 
-	if (cflag != FALSE) {
+    if( create_f != FALSE) {
-		if ((bp = (struct buffer *)malloc(sizeof(struct buffer))) == NULL)
+    /* allocate empty buffer */
+        bp = malloc( sizeof *bp) ;
+        if( bp == NULL)
             return NULL ;
-		if ((lp = lalloc(0)) == NULL) {
+
-			free((char *) bp);
+        line_p lp = lalloc( 0) ;
+        if( lp == NULL) {
+            free( bp) ;
             return NULL ;
         }
+
+        lp->l_fp = lp ;
+        lp->l_bp = lp ;
+        bp->b_linep = lp ;
+        bp->b_dotp = lp ;
+        bp->b_doto = 0 ;
+
     /* find the place in the list to insert this buffer */
         if( bheadp == NULL || strcmp( bheadp->b_bname, bname) > 0) {
         /* insert at the beginning */
             bp->b_bufp = bheadp ;
             bheadp = bp ;
         } else {
-			struct buffer *sb;	/* buffer to insert after */
+            buffer_p sb ;   /* buffer to insert after */
 
             for( sb = bheadp ; sb->b_bufp != NULL ; sb = sb->b_bufp)
                 if( strcmp( sb->b_bufp->b_bname, bname) > 0)
@@ -535,44 +508,37 @@ struct buffer *bfind( const char *bname, int cflag, int bflag)
 
         /* and set up the other buffer fields */
         bp->b_active = TRUE ;
-		bp->b_dotp = lp;
-		bp->b_doto = 0;
         bp->b_markp = NULL ;
         bp->b_marko = 0 ;
-		bp->b_flag = bflag;
+        bp->b_flag = flags ;
         bp->b_mode = gmode ;
         bp->b_nwnd = 0 ;
-		bp->b_linep = lp;
         bp->b_fname[ 0] = '\0' ;
         mystrscpy( bp->b_bname, bname, sizeof( bname_t)) ;
-		lp->l_fp = lp;
-		lp->l_bp = lp;
     }
+
     return bp ;
 }
 
-/*
+
- * This routine blows away all of the text
+/* This routine blows away all of the text in a buffer.  If the buffer is
- * in a buffer. If the buffer is marked as changed
+   marked as changed then we ask if it is ok to blow it away; this is to
- * then we ask if it is ok to blow it away; this is
+   save the user the grief of losing text.  The window chain is nearly
- * to save the user the grief of losing text. The
+   always wrong if this gets called; the caller must arrange for the
- * window chain is nearly always wrong if this gets
+   updates that are required.  Return TRUE if everything looks good.
- * called; the caller must arrange for the updates
- * that are required. Return TRUE if everything
- * looks good.
  */
-int bclear(struct buffer *bp)
+int bclear( buffer_p bp) {
-{
+    line_p lp ;
-	struct line *lp;
     int s ;
 
-	if ((bp->b_flag & BFINVS) == 0	/* Not scratch buffer.  */
+    if( (bp->b_flag & (BFINVS | BFCHG)) == BFCHG    /* regular and changed */
-	    && (bp->b_flag & BFCHG) != 0	/* Something changed    */
     &&  (s = mlyesno( "Discard changes")) != TRUE)
         return s ;
+
     bp->b_flag &= ~BFCHG ;      /* Not changed          */
     while( (lp = lforw( bp->b_linep)) != bp->b_linep)
         lfree( lp) ;
+
     bp->b_dotp = bp->b_linep ;  /* Fix "."              */
     bp->b_doto = 0 ;
     bp->b_markp = NULL ;        /* Invalidate "mark"    */
@@ -580,14 +546,15 @@ int bclear(struct buffer *bp)
     return TRUE ;
 }
 
-/*
+
- * unmark the current buffers change flag
+/* unmark the current buffers change flag
  *
  * int f, n;        unused command arguments
  */
-int unmark(int f, int n)
+BINDABLE( unmark) {
-{
     curbp->b_flag &= ~BFCHG ;
     curwp->w_flag |= WFMODE ;
     return TRUE ;
 }
+
+/* end of buffer.c */

buffer.h

@@ -1,22 +1,25 @@
+/* buffer.h -- buffer type and functions */
 #ifndef _BUFFER_H_
 # define _BUFFER_H_
 
 #include "line.h"
+#include "names.h"
+
+/* Text is kept in buffers.  A buffer header, described below, exists for
+   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
+   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 */
 
-/*
- * Text is kept in buffers. A buffer header, described below, exists for 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
- * have not been read in yet. These get read in at "use buffer" time.
- */
 typedef struct buffer {
     struct buffer *b_bufp ; /* Link to next struct buffer           */
     line_p b_dotp ;         /* Link to "." struct line structure    */
@@ -53,22 +56,27 @@ extern buffer_p blistp ;	/* Buffer for C-X C-B           */
 #define MDUTF8  0x0080      /* utf8 mode                    */
 #define MDDOS   0x0100      /* CRLF eol mode                */
 
-
+extern const char *modename[ NUMMODES] ;    /* text names of modes */
-extern const char *modename[] ;	/* text names of modes          */
 extern int gmode ;                          /* global editor mode */
 
 
-int usebuffer( int f, int n) ;
+/* Bindable functions */
-int nextbuffer( int f, int n) ;
+BINDABLE( killbuffer) ;
-int swbuffer( buffer_p bp) ;
+BINDABLE( listbuffers) ;
-int killbuffer( int f, int n) ;
+BINDABLE( namebuffer) ;
-int zotbuf( buffer_p bp) ;
+BINDABLE( nextbuffer) ;
-int namebuffer( int f, int n) ;
+BINDABLE( unmark) ;
-int listbuffers( int f, int n) ;
+BINDABLE( usebuffer) ;
-int anycb( void) ;
+
-int bclear( buffer_p bp) ;
+boolean anycb( void) ;          /* Any changed buffer? */
-int unmark( int f, int n) ;
+int bclear( buffer_p bp) ;      /* empty buffer */
-/* Lookup a buffer by name. */
+int swbuffer( buffer_p bp) ;    /* switch to buffer, make it current */
-buffer_p bfind( const char *bname, int cflag, int bflag) ;
+int zotbuf( buffer_p bp) ;      /* remove buffer */
+
+/* Lookup a buffer by name.  If not found and create_f is TRUE then create
+   it with flags set.
+*/
+buffer_p bfind( const char *bname, boolean create_f, int flags) ;
 
 #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,13 +248,11 @@ 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) ;
 	return TRUE ;
 }
@@ -266,25 +261,24 @@ int upscreen(int f, int n)
 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_
 
 # include <stdarg.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) ;
@@ -41,5 +45,5 @@ extern int chg_width, chg_height ;
 void sizesignal( int signr) ;
 #  endif
 # endif
-
 #endif
+/* end of display.h */

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
+/* This function writes a string on the message line mainly for macro usage
- * mainly for macro usage
  *
  * int f, n; arguments ignored
  */
-int writemsg( int f, int n) {
+BINDABLE( writemsg) {
-	int status ;
 	char *buf ; /* buffer to receive message into */
 
-	status = newmlarg( &buf, "Message to write: ", 0) ;
+	int status = newmlarg( &buf, "write-message: ", 0) ;
 	if( status == TRUE) {
 	/* write the message out */
 		mlforce( buf) ;

eval.h

@@ -1,6 +1,8 @@
+/* eval.h -- variables and operands evaluation */
 #ifndef _EVAL_H_
 # define _EVAL_H_
 
+#include "names.h"
 
 #define DEBUGM  1       /* $debug triggers macro debugging  */
 
@@ -8,7 +10,6 @@
 int mdbugout( char *fmt, ...) ;
 # endif
 
-
 extern int macbug ;     /* macro debuging flag          */
 extern int cmdstatus ;  /* last command status          */
 extern int rval ;       /* return value of a subprocess */
@@ -18,12 +19,15 @@ 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.c

@@ -1,38 +1,31 @@
 /* exec.c -- implements exec.h */
 #include "exec.h"
 
-/*  exec.c
+/* This file is for bindable functions dealing with execution of commands,
- *
+   command lines, buffers, files and startup files.
- *  This file is for functions dealing with execution of
+
- *  commands, command lines, buffers, files and startup files.
+   written 1986 by Daniel Lawrence
- *
+   modified by Petri Kutvonen
- *  written 1986 by Daniel Lawrence
- *  modified by Petri Kutvonen
  */
 
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "buffer.h"
 #include "bind.h"
-#include "display.h"
-#include "estruct.h"
 #include "eval.h"
 #include "file.h"
 #include "flook.h"
 #include "input.h"
 #include "line.h"
+#include "mlout.h"
 #include "random.h"
 #include "util.h"
 #include "window.h"
 
-
 static char *execstr = NULL ;	/* pointer to string to execute */
 boolean clexec = FALSE ;    	/* command line execution flag  */
 
-
-
 /*  Directive definitions   */
 
 #define DIF     	0
@@ -46,59 +39,52 @@ boolean clexec = FALSE ;    /* command line execution flag  */
 #define DBREAK      8
 #define DFORCE      9
 
-#define NUMDIRS     10
 
 /* The !WHILE directive in the execution language needs to
  * stack references to pending whiles. These are stored linked
  * to each currently open procedure via a linked list of
  * the following structure.
 */
-struct while_block {
+typedef struct while_block {
-    struct line *w_begin;        /* ptr to !while statement */
+    line_p w_begin ;				/* ptr to !while statement */
-    struct line *w_end;          /* ptr to the !endwhile statement */
+    line_p w_end ;					/* ptr to the !endwhile statement */
     int w_type ;					/* block type */
     struct while_block *w_next ;	/* next while */
-};
+} *while_p ;
 
 #define BTWHILE     1
 #define BTBREAK     2
 
-/* directive name table:
+/* directive name table: holds the names of all the directives....  */
-    This holds the names of all the directives....  */
 
 static const char *dname[] = {
-    "if", "else", "endif",
+    "if", 	"else", 	"endif",	"goto",		"return",
-    "goto", "return", "endm",
+	"endm", "while",	"endwhile", "break",	"force"
-    "while", "endwhile", "break",
-    "force"
 } ;
 
+#define NUMDIRS     ARRAY_SIZE( dname)
+
 static char golabel[ NSTRING] = "" ;	/* current line to go to */
 static int execlevel = 0 ;				/* execution IF level */
-static struct buffer *bstore = NULL ;   /* buffer to store macro text to */
+static buffer_p bstore = NULL ;			/* buffer to store macro text to */
 static int mstore = FALSE ;				/* storing text to macro flag */
 
-static int dobuf( struct buffer *bp) ;
+static int dobuf( buffer_p bp) ;
-static void freewhile( struct while_block *wp) ;
 static int macarg( char *tok, int toksz) ;
 
-/*
+/* Execute a named command even if it is not bound. */
- * Execute a named command even if it is not bound.
+BINDABLE( namedcmd) {
- */
-int namedcmd( int f, int n) {
 /* prompt the user to type a named command */
-    mlwrite("execute-named-cmd: ");
+    mloutstr( "execute-named-cmd: ");
 
 /* and now get the function name to execute */
 	nbind_p nbp = getname() ;
 	if( nbp == NULL)	/* abort */
-		return FALSE ;
+		return ABORT ;
 
     fnp_t kfunc = nbp->n_func ;
-    if (kfunc == NULL) {
+    if( kfunc == NULL)
-        mlwrite("(No such function)");
+		return mloutfail( "(No such function)") ;
-        return FALSE;
-    }
 
 	if( (bind_tag( nbp) & 1) && (curbp->b_mode & MDVIEW))
 		return rdonly() ;
@@ -109,19 +95,17 @@ int namedcmd( int f, int n) {
 
 static int docmd( char *cline) ;
 
-/*
+/* execcmd:
- * execcmd:
  *  Execute a command line command to be typed in
  *  by the user
  *
  * int f, n;        default Flag and Numeric argument
  */
-int execcmd( int f, int n) {
+BINDABLE( execcmd) {
-    int status ;	/* status return */
     char *cmdstr ;	/* string holding command to execute */
 
 /* get the line wanted */
-    status = newmlarg( &cmdstr, "execute-command-line: ", 0) ;
+    int status = newmlarg( &cmdstr, "execute-command-line: ", 0) ;
     if( status != TRUE)
         return status ;
 
@@ -133,8 +117,7 @@ int execcmd( int f, int n) {
     return status ;
 }
 
-/*
+/* docmd:
- * docmd:
  *  take a passed string as a command line and translate
  *  it to be executed as a command. This function will be
  *  used by execute-command-line and by all source and
@@ -147,9 +130,6 @@ int execcmd( int f, int n) {
  * char *cline;     command line to execute
  */
 static int docmd( char *cline) {
-    int f;      /* default argument flag */
-    int n;      /* numeric repeat value */
-    int status;     /* return status of function */
     boolean oldcle ;	/* old contents of clexec flag */
     char *oldestr ;     /* original exec string */
     char tkn[NSTRING] ; /* next token off of command line */
@@ -162,12 +142,12 @@ static int docmd( char *cline) {
     execstr = cline ;   /* and set this one as current */
 
     /* first set up the default command values */
-    f = FALSE;
+    int f = FALSE ;
-    n = 1;
+    int n = 1 ;
     lastflag = thisflag ;
     thisflag = 0 ;
 
-    status = macarg( tkn, sizeof tkn) ;
+    int status = macarg( tkn, sizeof tkn) ;
     if( status != TRUE) {   /* and grab the first token */
         execstr = oldestr;
         return status;
@@ -193,9 +173,8 @@ static int docmd( char *cline) {
 	nbind_p nbp = fncmatch( tkn) ;
     fnp_t fnc = nbp->n_func ;
     if( fnc == NULL) {
-        mlwrite("(No such Function)");
         execstr = oldestr ;
-        return FALSE;
+        return mloutfail( "(No such Function)") ;
     }
 
 	if( (bind_tag( nbp) & 1) && (curbp->b_mode & MDVIEW))
@@ -222,20 +201,16 @@ static int docmd( char *cline) {
  * char **tokref	out, destination of newly allocated token string
  */
 static char *newtoken( char *src, char **tokref) {
-    boolean quotef ;	/* is the current string quoted? */
+	char *tok = malloc( NSTRING) ;
-    char	*tok ;		/* allocated string */
+	int size = (tok == NULL) ? 0 : NSTRING ;
-    int		size ;		/* allocated size */
     int idx = 0 ;	/* insertion point into token string */
 
-	tok = malloc( NSTRING) ;
-	size = (tok == NULL) ? 0 : NSTRING ;
-
     /* first scan past any whitespace in the source string */
     while( *src == ' ' || *src == '\t')
         ++src ;
 
     /* scan through the source string */
-    quotef = FALSE;
+    boolean quotef = FALSE ;	/* is the current string quoted? */
     while( *src) {
 	    char c ;	/* temporary character */
 
@@ -395,32 +370,23 @@ static int macarg( char *tok, int toksz) {
 static char macbufname[] = "*Macro xx*" ;
 #define MACDIGITPOS 7
 
-int storemac(int f, int n)
+BINDABLE( storemac) {
-{
-    struct buffer *bp;  /* pointer to macro buffer */
-
 /* must have a numeric argument to this function */
-    if (f == FALSE) {
+    if( f == FALSE)
-        mlwrite("No macro specified");
+        return mloutfail( "No macro number specified");
-        return FALSE;
-    }
 
 /* range check the macro number */
-    if (n < 1 || n > 40) {
+    if( n < 1 || n > 40)
-        mlwrite("Macro number out of range");
+        return mloutfail( "Macro number out of range") ;
-        return FALSE;
-    }
 
 /* construct the macro buffer name */
     macbufname[ MACDIGITPOS]     = '0' + (n / 10) ;
     macbufname[ MACDIGITPOS + 1] = '0' + (n % 10) ;
 
 /* set up the new macro buffer */
-    bp = bfind( macbufname, TRUE, BFINVS) ;
+    buffer_p bp = bfind( macbufname, TRUE, BFINVS) ;
-    if( bp == NULL) {
+    if( bp == NULL)
-        mlwrite("Can not create macro");
+        return mloutfail( "Can not create macro") ;
-        return FALSE;
-    }
 
 /* and make sure it is empty */
     bclear( bp) ; 
@@ -436,12 +402,10 @@ int storemac(int f, int n)
 **	common to execute buffer, procedure and macro
 */
 static int exec( int n, char *bufname, char *errstr) {
-    struct buffer *bp ;		/* ptr to buffer to execute */
-
     /* find the pointer to that buffer */
-    bp = bfind( bufname, FALSE, 0) ;
+    buffer_p bp = bfind( bufname, FALSE, 0) ;
     if( bp == NULL) {
-        mlwrite( "No such %s", errstr) ;
+        mloutfmt( "No such %s", errstr) ;
 		return FALSE ;
 	}
 
@@ -453,7 +417,6 @@ static int exec( int n, char *bufname, char *errstr) {
     return status ;
 }
 
-#if PROC
 /*
  * storeproc:
  *  Set up a procedure buffer and flag to store all
@@ -462,9 +425,7 @@ static int exec( int n, char *bufname, char *errstr) {
  * int f;       default flag
  * int n;       macro number to use
  */
-int storeproc( int f, int n) {
+BINDABLE( storeproc) {
-    struct buffer *bp ;	/* pointer to macro buffer */
-    int status ;		/* return status */
     bname_t bname ;		/* name of buffer to use */
     char *name ;
 
@@ -473,7 +434,7 @@ int storeproc( int f, int n) {
         return storemac( f, n) ;
 
     /* get the name of the procedure */
-    status = newmlarg( &name, "Procedure name: ", sizeof bname - 2) ;
+    int status = newmlarg( &name, "Procedure name: ", sizeof bname - 2) ;
     if( status != TRUE)
         return status ;
 
@@ -484,11 +445,9 @@ int storeproc( int f, int n) {
 	free( name) ;
 
     /* set up the new macro buffer */
-    bp = bfind( bname, TRUE, BFINVS) ;
+    buffer_p bp = bfind( bname, TRUE, BFINVS) ;
-    if( bp == NULL) {
+    if( bp == NULL)
-        mlwrite( "Can not create macro") ;
+        return mloutfail( "Can not create macro") ;
-        return FALSE ;
-    }
 
     /* and make sure it is empty */
     bclear( bp) ;
@@ -505,13 +464,12 @@ int storeproc( int f, int n) {
  *
  * int f, n;        default flag and numeric arg
  */
-int execproc( int f, int n) {
+BINDABLE( execproc) {
-    int status ;			/* status return */
     bname_t bufn ;	/* name of buffer to execute */
     char *name ;
 
     /* find out what buffer the user wants to execute */
-    status = newmlarg( &name, "execute-procedure: ", sizeof bufn - 2) ;
+    int status = newmlarg( &name, "execute-procedure: ", sizeof bufn - 2) ;
     if( status != TRUE)
         return status ;
 
@@ -523,20 +481,18 @@ int execproc( int f, int n) {
 
 	return exec( n, bufn, "procedure") ;
 }
-#endif
 
-/*
+
- * execbuf:
+/* execbuf:
  *  Execute the contents of a buffer of commands
  *
  * int f, n;        default flag and numeric arg
  */
-int execbuf( int f, int n) {
+BINDABLE( execbuf) {
-    int status ;		/* status return */
     char *bufn ;		/* name of buffer to execute */
 
 /* find out what buffer the user wants to execute */
-    status = newmlarg( &bufn, "Execute buffer: ", sizeof( bname_t)) ;
+    int status = newmlarg( &bufn, "Execute buffer: ", sizeof( bname_t)) ;
     if( status != TRUE)
         return status ;
 
@@ -545,8 +501,21 @@ int execbuf( int f, int n) {
     return status ;
 }
 
-/*
+
- * dobuf:
+/* free a list of while block pointers
+ *
+ * while_p wp;      head of structure to free
+ */
+static void freewhile( while_p wp) {
+	while( wp != NULL) {
+		while_p next = wp->w_next ;
+		free( wp) ;
+		wp = next ;
+	}
+}
+
+
+/* dobuf:
  *  execute the contents of the buffer pointed to
  *  by the passed BP
  *
@@ -566,36 +535,23 @@ int execbuf( int f, int n) {
  *
  *  *LBL01
  *
- * struct buffer *bp;       buffer to execute
+ * buffer_p bp;       buffer to execute
  */
-static int dobuf(struct buffer *bp)
+static int dobuf( buffer_p bp) {
-{
-    int status; /* status return */
-    struct line *lp;    /* pointer to line to execute */
-    struct line *hlp;   /* pointer to line header */
-    struct line *glp;   /* line to goto */
-    struct line *mp;        /* Macro line storage temp */
-    int dirnum;     /* directive index */
     int linlen ;    		/* length of line to execute */
     int i ;         		/* index */
-    int force;      /* force TRUE result? */
+    while_p whtemp ;		/* temporary ptr to a struct while_block */
-    struct window *wp;      /* ptr to windows to scan */
-    struct while_block *whlist; /* ptr to !WHILE list */
-    struct while_block *scanner;    /* ptr during scan */
-    struct while_block *whtemp; /* temporary ptr to a struct while_block */
-    char *einit;        /* initial value of eline */
     char *eline ;       	/* text of line to execute */
-    char tkn[NSTRING];  /* buffer to evaluate an expresion in */
+    char tkn[ NSTRING] ;	/* buffer to evaluate an expression in */
 
 /* clear IF level flags/while ptr */
     execlevel = 0 ;
-    whlist = NULL;
+    while_p whlist = NULL ;		/* ptr to !WHILE list */
-    scanner = NULL;
+    while_p scanner = NULL ;	/* ptr during scan */
 
 /* scan the buffer to execute, building WHILE header blocks */
-    hlp = bp->b_linep;
+    line_p hlp = bp->b_linep ;	/* pointer to line header */
-    lp = hlp->l_fp;
+    for( line_p lp = hlp->l_fp ; lp != hlp ; lp = lp->l_fp) {
-    while (lp != hlp) {
     /* scan the current line */
         eline = lp->l_text ;
         i = lp->l_used ;
@@ -606,19 +562,22 @@ static int dobuf(struct buffer *bp)
 
     /* if theres nothing here, don't bother */
         if( i <= 0)
-            goto nxtscan;
+            continue ;
 
-        /* if is a while directive, make a block... */
+    /* if it is a while directive, make a block... */
-        if (eline[0] == '!' && eline[1] == 'w' && eline[2] == 'h') {
+        if(	eline[0] == '!'
-            whtemp = (struct while_block *)malloc(sizeof(struct while_block));
+		&&	eline[1] == 'w'
+		&&	eline[2] == 'h') {
+            whtemp = malloc( sizeof *whtemp) ;
             if( whtemp == NULL) {
-                  noram:mlwrite
+            noram:
-                    ("%%Out of memory during while scan");
+				mloutstr( "%%Out of memory during while scan") ;
-                  failexit:freewhile
+            failexit:
-                    (scanner);
+				freewhile( scanner) ;
                 freewhile( whlist) ;
                 return FALSE ;
             }
+			
             whtemp->w_begin = lp ;
             whtemp->w_type = BTWHILE ;
             whtemp->w_next = scanner ;
@@ -626,15 +585,18 @@ static int dobuf(struct buffer *bp)
         }
 
         /* if is a BREAK directive, make a block... */
-        if (eline[0] == '!' && eline[1] == 'b' && eline[2] == 'r') {
+        if(	eline[0] == '!'
+		&&	eline[1] == 'b'
+		&& 	eline[2] == 'r') {
             if (scanner == NULL) {
-                mlwrite
+                mloutstr( "%%!BREAK outside of any !WHILE loop") ;
-                    ("%%!BREAK outside of any !WHILE loop");
                 goto failexit ;
             }
-            whtemp = (struct while_block *)malloc(sizeof(struct while_block));
+
+            whtemp = malloc( sizeof *whtemp) ;
             if( whtemp == NULL)
                 goto noram ;
+
             whtemp->w_begin = lp;
             whtemp->w_type = BTBREAK;
             whtemp->w_next = scanner;
@@ -642,13 +604,14 @@ static int dobuf(struct buffer *bp)
         }
 
         /* if it is an endwhile directive, record the spot... */
-        if (eline[0] == '!' && strncmp(&eline[1], "endw", 4) == 0) {
+        if(	eline[0] == '!'
+		&& strncmp( &eline[1], "endw", 4) == 0) {
             if (scanner == NULL) {
-                mlwrite
+                mloutfmt( "%%!ENDWHILE with no preceding !WHILE in '%s'",
-                    ("%%!ENDWHILE with no preceding !WHILE in '%s'",
 																bp->b_bname) ;
                 goto failexit ;
             }
+			
             /* move top records from the scanner list to the
                whlist until we have moved all BREAK records
                and one WHILE record */
@@ -660,15 +623,11 @@ static int dobuf(struct buffer *bp)
                 whlist->w_next = whtemp ;
             } while( whlist->w_type == BTBREAK) ;
         }
-
-          nxtscan:      /* on to the next line */
-        lp = lp->l_fp;
     }
 
     /* while and endwhile should match! */
     if( scanner != NULL) {
-        mlwrite("%%!WHILE with no matching !ENDWHILE in '%s'",
+		mloutfmt( "%%!WHILE with no matching !ENDWHILE in '%s'", bp->b_bname) ;
-            bp->b_bname);
         goto failexit ;
     }
 
@@ -677,14 +636,19 @@ static int dobuf(struct buffer *bp)
 
     /* starting at the beginning of the buffer */
     hlp = bp->b_linep ;
-    lp = hlp->l_fp;
+    char *einit = NULL ;	/* initial value of eline */
-    while (lp != hlp) {
+	int status = TRUE ;		/* status of command execution */
+	boolean done = FALSE ;
+    for( line_p lp = hlp->l_fp ; !done && (lp != hlp) ; lp = lp->l_fp) {
+		if( einit)
+			free( einit) ;
+
     /* allocate eline and copy macro line to it */
         linlen = lp->l_used ;
-        if ((einit = eline = malloc(linlen + 1)) == NULL) {
+        einit = eline = malloc( linlen + 1) ;
-            mlwrite("%%Out of Memory during macro execution");
+        if( eline == NULL) {
-            freewhile(whlist);
+            status = mloutfail( "%%Out of Memory during macro execution") ;
-            return FALSE;
+			break ;
         }
 
         mystrscpy( eline, lp->l_text, linlen + 1) ;
@@ -695,7 +659,7 @@ static int dobuf(struct buffer *bp)
 
     /* dump comments and blank lines */
         if( *eline == ';' || *eline == '#' || *eline == 0)
-            goto onward;
+            continue ;
 
 #if DEBUGM
         /* if $debug == TRUE, every line to execute
@@ -708,9 +672,8 @@ static int dobuf(struct buffer *bp)
             /* debug macro name, if levels and lastly the line */
 			c = mdbugout( "<<<%s:%d:%s>>>", bp->b_bname, execlevel, eline) ;
         	if( c == abortc) {
-                freewhile( whlist) ;
+                status = FALSE ;
-				free( einit) ;
+				break ;
-                return FALSE ;
         	} else if( c == metac) {
         		macbug = FALSE ;
         	}
@@ -718,28 +681,25 @@ static int dobuf(struct buffer *bp)
 #endif
 
     /* Parse directives here.... */
-        dirnum = -1;
+	    unsigned dirnum = NUMDIRS ;     /* directive index */
         if( *eline == '!') {
         /* Find out which directive this is */
             ++eline ;
             for( dirnum = 0 ; dirnum < NUMDIRS ; dirnum++)
-                if (strncmp(eline, dname[dirnum],
+                if( !strncmp( eline, dname[ dirnum], strlen( dname[ dirnum])))
-                        strlen(dname[dirnum])) == 0)
                     break ;
 
         /* and bitch if it's illegal */
             if( dirnum == NUMDIRS) {
-                mlwrite("%%Unknown Directive");
+                status = mloutfail( "%%Unknown Directive") ;
-                freewhile(whlist);
+				break ;
-				free( einit) ;
-                return FALSE;
             }
 
             /* service only the !ENDM macro here */
             if( dirnum == DENDM) {
                 mstore = FALSE ;
                 bstore = NULL ;
-                goto onward;
+                continue ;
             }
 
             /* restore the original eline.... */
@@ -750,10 +710,10 @@ static int dobuf(struct buffer *bp)
         if( mstore) {
         /* allocate the space for the line */
             linlen = strlen( eline) ;
-            if ((mp = lalloc(linlen)) == NULL) {
+            line_p mp = lalloc( linlen) ;
-				free( einit) ;
+            if( mp == NULL) {
-                mlwrite( "Out of memory while storing macro") ;
+                status =  mloutfail( "Out of memory while storing macro") ;
-                return FALSE ;
+				break ;
             }
 
             /* copy the text into the new line */
@@ -765,136 +725,129 @@ static int dobuf(struct buffer *bp)
             mp->l_bp = bstore->b_linep->l_bp ;
             bstore->b_linep->l_bp = mp ;
             mp->l_fp = bstore->b_linep ;
-            goto onward;
+            continue ;
         }
 
-
+        int force = FALSE ;		/* force TRUE result? */
-        force = FALSE;
 
         /* dump comments */
         if( *eline == '*')
-            goto onward;
+            continue ;
 
         /* now, execute directives */
-        if (dirnum != -1) {
+        if( dirnum != NUMDIRS) {
             /* skip past the directive */
             while( *eline && *eline != ' ' && *eline != '\t')
                 ++eline ;
-            execstr = eline;
 
+            execstr = eline;
             switch( dirnum) {
             case DIF:   	/* IF directive */
             /* grab the value of the logical exp */
                 if( execlevel == 0) {
                     if( macarg( tkn, sizeof tkn) != TRUE)
-                        goto eexec;
+                        done = TRUE ;
-                    if (stol(tkn) == FALSE)
+                    else if( stol( tkn) == FALSE)
                         ++execlevel ;
                 } else
                     ++execlevel ;
-                goto onward;
+
+                continue ;
 
             case DWHILE:	/* WHILE directive */
             /* grab the value of the logical exp */
                 if( execlevel == 0) {
-                    if( macarg( tkn, sizeof tkn) != TRUE)
+                    if( macarg( tkn, sizeof tkn) != TRUE) {
-                        goto eexec;
+                        done = TRUE ;
-                    if (stol(tkn) == TRUE)
+						continue ;
-                        goto onward;
+                    } else if( stol( tkn) == TRUE)
+                        continue ;
                 }
             /* drop down and act just like !BREAK */
 
 				/* fallthrough */
             case DBREAK:    /* BREAK directive */
                 if( dirnum == DBREAK && execlevel)
-                    goto onward;
+                    continue ;
 
                 /* jump down to the endwhile */
                 /* find the right while loop */
-                whtemp = whlist;
+                for( whtemp = whlist ; whtemp ; whtemp = whtemp->w_next)
-                while (whtemp) {
                     if( whtemp->w_begin == lp)
                         break ;
-                    whtemp = whtemp->w_next;
-                }
 
                 if( whtemp == NULL) {
-                    mlwrite
+                    status = mloutfail( "%%Internal While loop error") ;
-                        ("%%Internal While loop error");
+					done = TRUE ;
-                    freewhile(whlist);
+                } else
-                    return FALSE;
-                }
-
                 /* reset the line pointer back.. */
 	                lp = whtemp->w_end ;
-                goto onward;
+
+                continue ;
 
             case DELSE:		/* ELSE directive */
                 if( execlevel == 1)
                     --execlevel ;
                 else if( execlevel == 0)
                     ++execlevel ;
-                goto onward;
+
+                continue ;
 
             case DENDIF:	/* ENDIF directive */
                 if (execlevel)
                     --execlevel;
-                goto onward;
+
+                continue ;
 
             case DGOTO:		/* GOTO directive */
             /* .....only if we are currently executing */
                 if( execlevel == 0) {
+				    line_p glp ;   /* line to goto */
+
                 /* grab label to jump to */
                     eline = token( eline, golabel, sizeof golabel) ;
                     linlen = strlen( golabel) ;
-                    glp = hlp->l_fp;
+                    for( glp = hlp->l_fp ; glp != hlp ; glp = glp->l_fp) {
-                    while (glp != hlp) {
+                        if(	*glp->l_text == '*'
-                        if (*glp->l_text == '*' &&
+						&&	!strncmp( &glp->l_text[ 1], golabel, linlen)) {
-                            (strncmp
+                            break ;
-                             (&glp->l_text[1],
+                        }
-                              golabel,
+                    }
-                              linlen) == 0)) {
+
+					if( glp == hlp) {
+        	            status =  mloutfail( "%%No such label") ;
+						done = TRUE ;
+					} else
 						lp = glp ;
-                            goto onward;
                 }
-                        glp = glp->l_fp;
+
-                    }
+                continue ;
-                    mlwrite("%%No such label");
-                    freewhile(whlist);
-                    return FALSE;
-                }
-                goto onward;
 
             case DRETURN:   /* RETURN directive */
                 if( execlevel == 0)
-                    goto eexec;
+                    done = TRUE ;
-                goto onward;
+
+                continue ;
 
             case DENDWHILE: /* ENDWHILE directive */
                 if( execlevel) {
                     --execlevel ;
-                    goto onward;
+                    continue ;
                 } else {
                 /* find the right while loop */
-                    whtemp = whlist;
+                    for( whtemp = whlist ; whtemp ; whtemp = whtemp->w_next)
-                    while (whtemp) {
+                        if( whtemp->w_type == BTWHILE
-                        if (whtemp->w_type ==
-                            BTWHILE
                         &&	whtemp->w_end == lp)
                             break ;
-                        whtemp = whtemp->w_next;
-                    }
 
                     if( whtemp == NULL) {
-                        mlwrite
+                        status = mloutfail( "%%Internal While loop error") ;
-                            ("%%Internal While loop error");
+						done = TRUE ;
-                        freewhile(whlist);
+                    } else
-                        return FALSE;
-                    }
-
     	            /* reset the line pointer back.. */
 	                    lp = whtemp->w_begin->l_bp ;
-                    goto onward;
+
+                    continue ;
                 }
 
             case DFORCE:    /* FORCE directive */
@@ -911,66 +864,44 @@ static int dobuf(struct buffer *bp)
     /* check for a command error */
         if( status != TRUE) {
         /* look if buffer is showing */
-            wp = wheadp;
+            for( window_p wp = wheadp ; wp != NULL ; wp = wp->w_wndp) {
-            while (wp != NULL) {
                 if( wp->w_bufp == bp) {
                 /* and point it */
                     wp->w_dotp = lp ;
                     wp->w_doto = 0 ;
                     wp->w_flag |= WFHARD ;
                 }
-                wp = wp->w_wndp;
             }
+
             /* in any case set the buffer . */
             bp->b_dotp = lp ;
             bp->b_doto = 0 ;
-            free(einit);
+			break ;
+        }
+    }
+
     execlevel = 0 ;
     freewhile( whlist) ;
+    if( einit)
+		free( einit) ;
+
     return status ;
 }
 
-          onward:       /* on to the next line */
-        free(einit);
-        lp = lp->l_fp;
-    }
 
-      eexec:            /* exit the current function */
+/* execute a series of commands in a file
-    execlevel = 0;
-    freewhile(whlist);
-    return TRUE;
-}
-
-/*
- * free a list of while block pointers
- *
- * struct while_block *wp;      head of structure to free
- */
-static void freewhile(struct while_block *wp)
-{
-    if (wp == NULL)
-        return;
-    if (wp->w_next)
-        freewhile(wp->w_next);
-    free(wp);
-}
-
-/*
- * execute a series of commands in a file
  *
  * int f, n;        default flag and numeric arg to pass on to file
  */
-int execfile( int f, int n) {
+BINDABLE( execfile) {
-    int status ;	/* return status of name query */
     char *fname ;	/* name of file to execute */
-    char *fspec ;	/* full file spec */
 
-    status = newmlarg( &fname, "Execute file: ", 0) ;
+    int status = newmlarg( &fname, "Execute file: ", 0) ;
     if( status != TRUE)
         return status ;
 
 /* look up the path for the file */
-    fspec = flook( fname, FALSE) ;    /* used to be TRUE, P.K. */
+    char *fspec = flook( fname, FALSE) ;    /* used to be TRUE, P.K. */
     free( fname) ;
 
 /* if it isn't around */
@@ -984,46 +915,54 @@ int execfile( int f, int n) {
     return status ;
 }
 
-/*
+/* dofile:
- * dofile:
  *  yank a file into a buffer and execute it
  *  if there are no errors, delete the buffer on exit
  *
  * char *fname;     file name to execute
  */
 int dofile( const char *fname) {
-    struct buffer *bp;  /* buffer to place file to exeute */
-    struct buffer *cb;  /* temp to hold current buf while we read */
-    int status; /* results of various calls */
     bname_t bname ;				/* name of buffer */
 
     makename( bname, fname) ;	/* derive the name of the buffer */
     unqname( bname) ;			/* make sure we don't stomp things */
-    if ((bp = bfind(bname, TRUE, 0)) == NULL)   /* get the needed buffer */
+    buffer_p bp = bfind( bname, TRUE, 0) ;	   /* get the needed buffer */
+    if( bp == NULL)
         return FALSE ;
 
     bp->b_mode = MDVIEW ;		/* mark the buffer as read only */
-    cb = curbp;     /* save the old buffer */
+    buffer_p cb = curbp ;		/* save the old buffer */
     curbp = bp ;				/* make this one current */
 /* and try to read in the file to execute */
-    if ((status = readin(fname, FALSE)) != TRUE) {
+    int status = readin( fname, FALSE) ;
     curbp = cb ;				/* restore the current buffer */
-        return status;
+	if( status == TRUE) {
+	/* go execute it! */
+		status = dobuf( bp) ;
+		if( status == TRUE && bp->b_nwnd == 0)
+	    /* if not displayed, remove the now unneeded buffer and exit */
+			zotbuf( bp) ;
 	}
 
+	return status ;
+#if 0
+    if( status != TRUE)
+        return status ;
+
 /* go execute it! */
-    curbp = cb;     /* restore the current buffer */
+    status = dobuf( bp) ;
-    if ((status = dobuf(bp)) != TRUE)
+    if( status != TRUE)
         return status ;
 
     /* if not displayed, remove the now unneeded buffer and exit */
     if( bp->b_nwnd == 0)
         zotbuf( bp) ;
+
     return TRUE ;
+#endif
 }
 
-/*
+/* cbuf:
- * cbuf:
  *  Execute the contents of a numbered buffer
  *
  * int f, n;        default flag and numeric arg
@@ -1039,7 +978,7 @@ static int cbuf( int f, int n, int bufnum) {
 
 /* execute buffer of numbered macro [1..40] */
 #define cbufnn( nn) \
-int cbuf##nn( int f, int n) { \
+BINDABLE( cbuf##nn) { \
     return cbuf( f, n, nn) ; \
 }
 

exec.h

@@ -1,69 +1,65 @@
+/* exec.h -- bindable functions to execute functions, macros and procedures */
 #ifndef _EXEC_H_
 # define _EXEC_H_
 
-#include "retcode.h"
+#include "names.h"
-
-
-#define	PROC	1	/* named procedures  */
-
-#if PROC
-int storeproc( int f, int n) ;
-int execproc( int f, int n) ;
-#endif
-
 
 extern boolean clexec ; /* command line execution flag  */
 
-
+int dofile( const char *fname) ;
-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.
@@ -287,7 +285,7 @@ int readin(const char *fname, boolean lockfl)
 		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 ;
@@ -190,7 +191,7 @@ nbind_p getname( void) {
             return fncmatch( buf) ;
 
         } else if( c == ectoc(abortc)) {    /* Bell, abort */
-            ctrlg(FALSE, 0);
+            ctrlg( FALSE, 1) ;
             TTflush() ;
             return NULL ;
 
@@ -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,8 +249,7 @@ 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, ' ') ;
 	backchar( f, n) ;
@@ -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_
 
 #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,11 +144,9 @@ 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 ;
 	line_p dlp = curwp->w_dotp ;
 	int byte_offset = curwp->w_doto ;
@@ -167,9 +165,12 @@ int getccol(int bflg)
 			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 ;
 }
 
@@ -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) {
-{
-#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) {
-{
-#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) {
-{
-#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) {
-{
-#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 */
-	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,25 +782,23 @@ 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) ;
 }
 
-/*
+
- * 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) ;
 }
 

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 ;
+
 	while( --size) {
 		char c = *src++ ;
 		if( !c)
 			break ;
+
 		*dst++ = c ;
 	}
+
 	*dst = 0 ;
 }
 
-
+/* end of util.c */

util.h

@@ -1,3 +1,4 @@
+/* util.h -- utility functions */
 #ifndef UTIL_H_
 # define UTIL_H_
 
@@ -5,3 +6,4 @@
 void mystrscpy( char *dst, const char *src, int size) ;
 
 #endif  /* UTIL_H_ */
+/* end of util.h */

window.c

@@ -1,54 +1,44 @@
 /* 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 */
-		n = 0;
-	curwp->w_force = n;
 	curwp->w_flag |= WFFORCE ;
 	return TRUE ;
 }
 
-/*
+
- * Refresh the screen. With no argument, it just does the refresh. With an
+/* 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)
 		sgarbf = TRUE ;
 	else {
@@ -59,19 +49,17 @@ int redraw(int f, int n)
 	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) ;
 }
 
-/*
+
- * 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) {
-		mlwrite("Cannot split a %d line window", curwp->w_ntrows);
+		mloutfmt( "Cannot split a %d line window", curwp->w_ntrows) ;
 		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) {
+	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) {
+		if( wp == savwindow) {
 			curwp = wp ;
 			curbp = wp->w_bufp ;
 			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,21 +1,22 @@
+/* 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"       */
@@ -49,26 +50,29 @@ extern window_p wheadp ;	/* Head of list of windows      */
 # define WFINS   0x80		/* something was inserted       */
 # endif
 
-int reposition( int f, int n);
+/* Bindable functions */
-int redraw( int f, int n) ;
+ BINDABLE( delwind) ;
-int nextwind( int f, int n) ;
+ BINDABLE( enlargewind) ;
-int prevwind( int f, int n) ;
+ BINDABLE( mvdnwind) ;
-int mvdnwind( int f, int n) ;
+ BINDABLE( mvupwind) ;
-int mvupwind( int f, int n) ;
+ BINDABLE( newsize) ;
-int onlywind( int f, int n) ;
+ BINDABLE( newwidth) ;
-int delwind( int f, int n) ;
+ BINDABLE( nextwind) ;
-int splitwind( int f, int n) ;
+ BINDABLE( onlywind) ;
-int enlargewind( int f, int n) ;
+ BINDABLE( prevwind) ;
-int shrinkwind( int f, int n) ;
+TBINDABLE( redraw) ;
-int resize( int f, int n) ;
+TBINDABLE( reposition) ;
-int scrnextup( int f, int n) ;
+ BINDABLE( resize) ;
-int scrnextdw( int f, int n) ;
+ BINDABLE( restwnd) ;
-int savewnd( int f, int n) ;
+ BINDABLE( savewnd) ;
-int restwnd( int f, int n) ;
+ BINDABLE( scrnextdw) ;
-int newsize( int f, int n) ;
+ BINDABLE( scrnextup) ;
-int newwidth( int f, int n) ;
+ BINDABLE( shrinkwind) ;
+ BINDABLE( splitwind) ;
+
 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
+   performed by the "backchar" and "forwchar" routines.  Error if you try
- * move beyond the buffers.
+   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
+   convert any characters to upper case.  Error if you try and move beyond
- * end of the buffer. Bound to "M-U".
+   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
- * 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
+   convert the first character of the word to upper case, and subsequent
- * characters to lower case. Error if you try and move past the end of the
+   characters to lower case.  Error if you try and move past the end of the
- * buffer. Bound to "M-C".
+   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);