Revise line primitives linstr() and lover()

defines.h

@@ -29,7 +29,6 @@
 #define MSDOS	0
 #define IBMPC	MSDOS
 #define COLOR	MSDOS
-#define MEMMAP	IBMPC
 
 
 #define FILOCK (SVR4 | BSD)
@@ -46,8 +45,8 @@
   void *allocate( size_t size) ;
   void release( void *ptr) ;
 
-# define    malloc  allocate
+# define malloc  allocate
-# define    free    release
+# define free    release
 #endif
 
 /* De-allocate memory always on exit (if the operating system or main

display.c

@@ -2,6 +2,7 @@
 #include "display.h"
 
 #define	REVSTA	1  /* Status line appears in reverse video         */
+#define MEMMAP	0
 
 /* 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
@@ -11,6 +12,7 @@
    Modified by Petri Kutvonen
  */
 
+#include <assert.h>
 #include <errno.h>
 #include <locale.h>
 #include <stdarg.h>
@@ -203,8 +205,9 @@ static void sane_vtputc( unicode_t c) {
 
 static void vtputc( unicode_t c) {
 	/* In case somebody passes us a signed char.. */
-	if( c > 0x10FFFF)	/* Let's assume this is due to sign extension */
+//	if( c > 0x10FFFF)	/* Let's assume this is due to sign extension */
-		c &= 0xFF ;
+//		c &= 0xFF ;
+	assert( c <= 0x10FFFF) ;
 
 	if( c == '\t') {
 		sane_vtputc( viewtab ? 0xBB : ' ') ;	/* 0xBB: '»' */

line.c

@@ -172,8 +172,8 @@ BBINDABLE( forwchar) {
     return TRUE ;
 }
 
-/*
+
- * This routine allocates a block of memory large enough to hold a struct line
+/* This routine allocates a block of memory large enough to hold a struct line
  * containing "used" characters. The block is always rounded up a bit. Return
  * a pointer to the new block, or NULL if there isn't any memory left. Print a
  * message in the message line if no space.
@@ -181,13 +181,13 @@ BBINDABLE( forwchar) {
 line_p lalloc( int used) {
 #define BLOCK_SIZE 16   /* Line block chunk size. */
 
-/* rounding down use masking instead or modulo when BLOCK_SIZE is power of 2 */
+/* rounding down use masking instead of modulo when BLOCK_SIZE is power of 2 */
 #if (BLOCK_SIZE & -BLOCK_SIZE) == BLOCK_SIZE
     int size = (used + BLOCK_SIZE) & ~(BLOCK_SIZE - 1) ;
 #else
     int size = used + BLOCK_SIZE - used % BLOCK_SIZE ;
 #endif
-    line_p lp = (line_p) malloc( offsetof( struct line, l_text) + size) ;
+    line_p lp = malloc( sizeof *lp + size) ;
     if( lp == NULL)
         mloutstr( "(OUT OF MEMORY)") ;
     else {
@@ -266,8 +266,8 @@ void lchange(int flag)
     }
 }
 
-/*
+
- * insert spaces forward into text
+/* insert spaces forward into text
  *
  * int f, n;        default flag and numeric argument
  */
@@ -278,24 +278,18 @@ BINDABLE( insspace) {
     return TRUE ;
 }
 
-/*
- * linstr -- Insert a string at the current point
- */
-
-int linstr( char *instr) {
-    int status = TRUE ;
 
+/* linstr -- Insert a string at the current point */
+boolean linstr( char *instr) {
+    boolean status = TRUE ;
     if( instr != NULL) {
-        unicode_t tmpc ;
+        int c ;
 
-        while( (tmpc = *instr++ & 0xFF)) {
+        while( (c = (unsigned char) *instr++)) {
-            status =
+            status = (c == '\n') ? lnewline() : linsert_byte( 1, c) ;
-                (tmpc == '\n' ? lnewline() : (int) linsert_byte( 1, tmpc)) ;
+            if( status != TRUE) {	/* Insertion error? */
-
-            /* Insertion error? */
-            if( status != TRUE) {
                 mloutstr( "%Out of memory while inserting") ;
-                return status ;
+                break ;
             }
         }
     }
@@ -393,7 +387,7 @@ boolean linsert_byte( int n, int c) {
     return TRUE;
 }
 
-int linsert( int n, unicode_t c) {
+boolean linsert( int n, unicode_t c) {
     assert( n >= 0) ;
     assert( !(curbp->b_mode & MDVIEW)) ;
 
@@ -421,7 +415,7 @@ int linsert( int n, unicode_t c) {
  *
  * int c ;  character to overwrite on current position
  */
-static int lowrite( int c) {
+static boolean lowrite( int c) {
     if( curwp->w_doto < curwp->w_dotp->l_used
     && (    lgetc( curwp->w_dotp, curwp->w_doto) != '\t'
         ||  (curwp->w_doto % tabwidth) == (tabwidth - 1)
@@ -431,20 +425,18 @@ static int lowrite( int c) {
     return linsert( 1, c) ;
 }
 
-/*
- * lover -- Overwrite a string at the current point
- */
-int lover( char *ostr) {
-    int status = TRUE ;
 
+/* lover -- Overwrite a string at the current point */
+boolean lover( char *ostr) {
+    boolean status = TRUE ;
     if( ostr != NULL) {
-        char tmpc ;
+        int c ;
 
-        while( (tmpc = *ostr++)) {
+        while( (c = (unsigned char) *ostr++)) {
-            status = (tmpc == '\n' ? lnewline() : lowrite( tmpc)) ;
+            status = (c == '\n') ? lnewline() : lowrite( c) ;
             if( status != TRUE) {   /* Insertion error? */
                 mloutstr( "%Out of memory while overwriting") ;
-                return status ;
+                break ;
             }
         }
     }
@@ -452,21 +444,15 @@ int lover( char *ostr) {
     return status ;
 }
 
-/*
- * Insert a newline into the buffer at the current location of dot in the
- * current window. The funny ass-backwards way it does things is not a botch;
- * it just makes the last line in the file not a special case. Return TRUE if
- * everything works out and FALSE on error (memory allocation failure). The
- * update of dot and mark is a bit easier then in the above case, because the
- * split forces more updating.
- */
-int lnewline( void) {
-    char *cp1;
-    char *cp2;
-    line_p lp1, lp2 ;
-    int doto;
-    struct window *wp;
 
+/* Insert a newline into the buffer at the current location of dot in the
+   current window.  The funny ass-backwards way it does things is not a
+   botch; it just makes the last line in the file not a special case.
+   Return TRUE if everything works out and FALSE on error (memory
+   allocation failure).  The update of dot and mark is a bit easier then in
+   the above case, because the split forces more updating.
+ */
+boolean lnewline( void) {
     assert( !(curbp->b_mode & MDVIEW)) ;
 
 #if SCROLLCODE
@@ -474,43 +460,39 @@ int lnewline( void) {
 #else
     lchange(WFHARD);
 #endif
-    lp1 = curwp->w_dotp;    /* Get the address and  */
+    line_p lp1 = curwp->w_dotp ;	/* Get the address and	*/
-    doto = curwp->w_doto;   /* offset of "."        */
+    int doto = curwp->w_doto ;		/* offset of "."        */
-    lp2 = lalloc( doto) ;   /* New first half line */
+    line_p lp2 = lalloc( doto) ;	/* New first half line	*/
     if( lp2 == NULL)
         return FALSE ;
 
-    cp1 = &lp1->l_text[0];  /* Shuffle text around  */
+    memcpy( lp2->l_text, lp1->l_text, doto) ;
-    cp2 = &lp2->l_text[0];
+    lp1->l_used -= doto ;
-    while (cp1 != &lp1->l_text[doto])
+	memcpy( lp1->l_text, &lp1->l_text[ doto], lp1->l_used) ;
-        *cp2++ = *cp1++;
+    lp2->l_fp = lp1 ;
-    cp2 = &lp1->l_text[0];
+    lp2->l_bp = lp1->l_bp ;
-    while (cp1 != &lp1->l_text[lp1->l_used])
+    lp1->l_bp = lp2 ;
-        *cp2++ = *cp1++;
+    lp2->l_bp->l_fp = lp2 ;
-    lp1->l_used -= doto;
+    for( window_p wp = wheadp ; wp != NULL ; wp = wp->w_wndp) {
-    lp2->l_bp = lp1->l_bp;
+        if( wp->w_linep == lp1)
-    lp1->l_bp = lp2;
+            wp->w_linep = lp2 ;
-    lp2->l_bp->l_fp = lp2;
+
-    lp2->l_fp = lp1;
+        if( wp->w_dotp == lp1) {
-    wp = wheadp;        /* Windows              */
+            if( wp->w_doto < doto)
-    while (wp != NULL) {
+                wp->w_dotp = lp2 ;
-        if (wp->w_linep == lp1)
-            wp->w_linep = lp2;
-        if (wp->w_dotp == lp1) {
-            if (wp->w_doto < doto)
-                wp->w_dotp = lp2;
             else
-                wp->w_doto -= doto;
+                wp->w_doto -= doto ;
         }
+
         if (wp->w_markp == lp1) {
-            if (wp->w_marko < doto)
+            if( wp->w_marko < doto)
-                wp->w_markp = lp2;
+                wp->w_markp = lp2 ;
             else
-                wp->w_marko -= doto;
+                wp->w_marko -= doto ;
         }
-        wp = wp->w_wndp;
     }
-    return TRUE;
+
+    return TRUE ;
 }
 
 

line.h

@@ -14,11 +14,11 @@
    list of marks into the line.
  */
 typedef struct line {
-    struct line *l_fp ; /* Forward link to the next line        */
+    struct line *l_fp ;		/* Forward link to the next line        */
-    struct line *l_bp ; /* Backward link to the previous line   */
+    struct line *l_bp ;		/* Backward link to the previous line   */
-    int l_size ;        /* Allocated size                       */
+    int l_size ;			/* Allocated size                       */
-    int l_used ;        /* Used size                            */
+    int l_used ;			/* Used size                            */
-    char l_text[ 1] ;   /* A bunch of characters                */
+    char l_text[] ;			/* A bunch of characters                */
 } *line_p ;
 
 #define lforw(lp)       ((lp)->l_fp)
@@ -39,11 +39,11 @@ BBINDABLE( forwchar) ;
 
 void lfree( line_p lp) ;
 void lchange( int flag) ;
-int linstr( char *instr) ;
+boolean linstr( char *instr) ;
-int linsert( int n, unicode_t c) ;
+boolean linsert( int n, unicode_t c) ;
 boolean linsert_byte( int n, int c) ;
-int lover( char *ostr) ;
+boolean lover( char *ostr) ;
-int lnewline( void) ;
+boolean lnewline( void) ;
 boolean ldelete(  long n, boolean kflag) ;
 boolean ldelchar( long n, boolean kflag) ;
 int lgetchar( unicode_t *cref) ;

random.c

@@ -837,7 +837,7 @@ static int adjustmode( int kind, int global) {
 }
 
 
-static int iovstring( int f, int n, const char *prompt, int (*fun)( char *)) {
+static int iovstring( int f, int n, const char *prompt, boolean (*fun)( char *)) {
     char *tstring ; /* string to add */
 
 /* ask for string to insert */