Fix: avoid extra NL when newline/yank/insert-file at end of last line of non empty buffer.

Refactor yank.
Detab before commit.

.gitattributes

@@ -0,0 +1 @@
+* text=auto

.gitignore

@@ -1,2 +1,4 @@
-em
+ue
 *.o
+*.exe
+*.dep

Makefile

@@ -1,10 +1,5 @@
-# Makefile for emacs, updated Fri, Feb 13, 2015 12:02:52 PM
+# Makefile -- µEMACS
-
+# Copyright © 2013-2022 Renaud Fivet
-SRC=basic.c bind.c bindable.c buffer.c display.c ebind.c eval.c exec.c execute.c file.c fileio.c flook.c input.c isearch.c line.c lock.c main.c mingw32.c mlout.c names.c pklock.c posix.c random.c region.c search.c spawn.c tcap.c termio.c utf8.c window.c word.c wrapper.c wscreen.c
-OBJ=basic.o bind.o bindable.o buffer.o display.o ebind.o eval.o exec.o execute.o file.o fileio.o flook.o input.o isearch.o line.o lock.o main.o mingw32.o mlout.o names.o pklock.o posix.o random.o region.o search.o spawn.o tcap.o termio.o utf8.o window.o word.o wrapper.o wscreen.o
-HDR=basic.h bind.h bindable.h buffer.h defines.h display.h ebind.h estruct.h eval.h exec.h execute.h file.h fileio.h flook.h input.h isearch.h line.h lock.h mlout.h names.h pklock.h random.h region.h retcode.h search.h spawn.h terminal.h termio.h utf8.h version.h window.h word.h wrapper.h wscreen.h
-
-# DO NOT ADD OR MODIFY ANY LINES ABOVE THIS -- make source creates them
 
 # Make the build silent by default
 V =
@@ -18,60 +13,27 @@ else
 endif
 export E Q
 
-uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
-# for windows based target, insure we strip the variant part
-# CYGWIN_NT-6.1, CYGWIN_NT-6.1-WOW, CYGWIN_NT-6.1-WOW64, MINGW32_NT-6.1
-uname_S := $(shell sh -c 'echo $(uname_S) | sed s/_.*$$//')
-
 PROGRAM=ue
 
-CC=gcc
+CC=cc
 WARNINGS=-pedantic -Wall -Wextra -Wstrict-prototypes -Wno-unused-parameter
 CFLAGS=-O2 $(WARNINGS)
-#CC=c89 +O3			# HP
+LDFLAGS=-s
-#CFLAGS= -D_HPUX_SOURCE -DSYSV
+LIBS=-lcurses
-#CFLAGS=-O4 -DSVR4		# Sun
+DEFINES=-DPROGRAM=$(PROGRAM) -D_GNU_SOURCE # -DNDEBUG
-#CFLAGS=-O -qchars=signed	# RS/6000
+
-ifeq ($(uname_S),Linux)
- DEFINES=-DAUTOCONF -DPROGRAM=$(PROGRAM) -DPOSIX -DUSG -D_BSD_SOURCE -D_SVID_SOURCE -D_XOPEN_SOURCE=600
- LIBS=-lcurses
-endif
-ifeq ($(uname_S),FreeBSD)
- DEFINES=-DAUTOCONF -DPOSIX -DSYSV -D_FREEBSD_C_SOURCE -D_BSD_SOURCE -D_SVID_SOURCE -D_XOPEN_SOURCE=600
-endif
-ifeq ($(uname_S),Darwin)
- DEFINES=-DAUTOCONF -DPOSIX -DSYSV -D_DARWIN_C_SOURCE -D_BSD_SOURCE -D_SVID_SOURCE -D_XOPEN_SOURCE=600
-endif
-ifeq ($(uname_S),CYGWIN)
- DEFINES=-DAUTOCONF -DCYGWIN -DSYSV -DPROGRAM=$(PROGRAM)
- LIBS=-lcurses
-endif
-ifeq ($(uname_S),MINGW32)
- DEFINES=-DAUTOCONF -DSYSV -DMINGW32 -DPROGRAM=$(PROGRAM)
- LIBS=
-endif
-#DEFINES=-DAUTOCONF
-#LIBS=-ltermcap			# BSD
-#LIBS=-lcurses			# SYSV
-#LIBS=-ltermlib
-#LIBS=-L/usr/lib/termcap -ltermcap
-LFLAGS=-hbx
 BINDIR=/usr/bin
 LIBDIR=/usr/lib
 
-$(PROGRAM): $(OBJ)
+SRCS = $(sort $(wildcard *.c))
-	$(E) "  LINK    " $@
-	$(Q) $(CC) $(LDFLAGS) $(DEFINES) -o $@ $(OBJ) $(LIBS)
 
-SPARSE=sparse
+$(PROGRAM): $(SRCS:.c=.o)
-SPARSE_FLAGS=-D__LITTLE_ENDIAN__ -D__x86_64__ -D__linux__ -D__unix__
+	$(E) "  LINK  " $@
-
+	$(Q) $(CC) $(LDFLAGS) -o $@ $+ $(LIBS)
-sparse:
-	$(SPARSE) $(SPARSE_FLAGS) $(DEFINES) $(SRC)
 
 clean:
 	$(E) "  CLEAN"
-	$(Q) rm -f $(PROGRAM) core lintout makeout tags Makefile.bak *.o
+	$(Q) rm -f $(PROGRAM) *.dep *.o
 
 install: $(PROGRAM)
 	strip $(PROGRAM)
@@ -81,122 +43,16 @@ install: $(PROGRAM)
 	chmod 755 ${BINDIR}/$(PROGRAM)
 	chmod 644 ${LIBDIR}/emacs.hlp ${LIBDIR}/.emacsrc
 
-lint:	${SRC}
-	@rm -f lintout
-	lint ${LFLAGS} ${SRC} >lintout
-	cat lintout
-
-splint:
-	splint -weak $(DEFINES) $(SRC) -booltype boolean -booltrue TRUE -boolfalse FALSE +posixlib +matchanyintegral
-
-errs:
-	@rm -f makeout
-	make $(PROGRAM) >makeout
-
-tags:	${SRC}
-	@rm -f tags
-	ctags ${SRC}
-
-source:
-	@mv Makefile Makefile.bak
-	@echo "# Makefile for emacs, updated `date`" >Makefile
-	@echo '' >>Makefile
-#Sorted
-	@echo SRC=`ls *.c` >>Makefile
-	@echo OBJ=`ls *.c | sed s/c$$/o/` >>Makefile
-	@echo HDR=`ls *.h` >>Makefile
-#UnSorted
-#	@echo SRC=$(wildcard *.c) >>Makefile
-#	@echo OBJ=$(patsubst %.c,%.o,$(wildcard *.c)) >>Makefile
-#	@echo HDR=$(wildcard *.h) >>Makefile
-	@echo '' >>Makefile
-	@sed -n -e '/^# DO NOT ADD OR MODIFY/,$$p' <Makefile.bak >>Makefile
-
-depend: ${SRC}
-	@mv Makefile Makefile.bak
-	@sed -n -e '1,/^# DO NOT DELETE THIS LINE/p' Makefile.bak > Makefile
-	@echo >> Makefile
-	@for i in ${SRC}; do\
-	    cc ${DEFINES} -MM $$i ; done >> Makefile
-	@echo '' >>Makefile
-	@echo '# DEPENDENCIES MUST END AT END OF FILE' >>Makefile
-	@echo '# IF YOU PUT STUFF HERE IT WILL GO AWAY' >>Makefile
-	@echo '# see make depend above' >>Makefile
-
 .c.o:
-	$(E) "  CC      " $@
+	$(E) "  CC    " $@
-	$(Q) ${CC} ${CFLAGS} ${DEFINES} -c $*.c
+	$(Q) $(CC) $(CFLAGS) $(DEFINES) -c $*.c
 
-# DO NOT DELETE THIS LINE -- make depend uses it
+%.dep: %.c
+	$(E) "  DEPEND" $@
+	$(Q) $(CC) $(DEFINES) -MM $< > $@
 
-basic.o: basic.c basic.h retcode.h input.h bind.h mlout.h random.h \
+ifneq ($(MAKECMDGOALS),clean)
- terminal.h defines.h utf8.h window.h buffer.h line.h
+include $(SRCS:.c=.dep)
-bind.o: bind.c bind.h estruct.h bindable.h buffer.h line.h retcode.h \
+endif
- utf8.h display.h ebind.h exec.h file.h flook.h input.h names.h window.h \
- defines.h
-bindable.o: bindable.c bindable.h defines.h buffer.h line.h retcode.h \
- utf8.h display.h estruct.h file.h input.h bind.h lock.h mlout.h \
- terminal.h
-buffer.o: buffer.c buffer.h line.h retcode.h utf8.h defines.h estruct.h \
- file.h input.h bind.h mlout.h window.h
-display.o: display.c display.h estruct.h utf8.h buffer.h line.h retcode.h \
- input.h bind.h termio.h terminal.h defines.h version.h wrapper.h \
- window.h
-ebind.o: ebind.c ebind.h basic.h retcode.h bind.h estruct.h bindable.h \
- buffer.h line.h utf8.h eval.h exec.h file.h isearch.h random.h region.h \
- search.h spawn.h window.h defines.h word.h
-eval.o: eval.c eval.h basic.h retcode.h bind.h buffer.h line.h utf8.h \
- display.h estruct.h exec.h execute.h flook.h input.h random.h search.h \
- terminal.h defines.h termio.h version.h window.h
-exec.o: exec.c exec.h retcode.h buffer.h line.h utf8.h bind.h display.h \
- estruct.h eval.h file.h flook.h input.h random.h window.h defines.h
-execute.o: execute.c execute.h estruct.h bind.h random.h retcode.h \
- display.h utf8.h file.h buffer.h line.h input.h mlout.h search.h \
- terminal.h defines.h window.h
-file.o: file.c file.h buffer.h line.h retcode.h utf8.h defines.h \
- display.h estruct.h execute.h fileio.h input.h bind.h lock.h mlout.h \
- window.h
-fileio.o: fileio.c fileio.h defines.h retcode.h utf8.h
-flook.o: flook.c flook.h retcode.h defines.h fileio.h
-input.o: input.c input.h bind.h estruct.h bindable.h display.h utf8.h \
- exec.h retcode.h names.h terminal.h defines.h wrapper.h
-isearch.o: isearch.c isearch.h basic.h retcode.h buffer.h line.h utf8.h \
- display.h estruct.h exec.h input.h bind.h search.h terminal.h defines.h \
- window.h
-line.o: line.c line.h retcode.h utf8.h buffer.h estruct.h mlout.h \
- window.h defines.h
-lock.o: lock.c estruct.h lock.h
-main.o: main.c estruct.h basic.h retcode.h bind.h bindable.h buffer.h \
- line.h utf8.h display.h eval.h execute.h file.h lock.h mlout.h random.h \
- search.h terminal.h defines.h termio.h version.h window.h
-mingw32.o: mingw32.c
-mlout.o: mlout.c mlout.h
-names.o: names.c names.h basic.h retcode.h bind.h bindable.h buffer.h \
- line.h utf8.h display.h estruct.h eval.h exec.h file.h isearch.h \
- region.h random.h search.h spawn.h window.h defines.h word.h
-pklock.o: pklock.c estruct.h pklock.h
-posix.o: posix.c
-random.o: random.c random.h retcode.h basic.h buffer.h line.h utf8.h \
- display.h estruct.h execute.h input.h bind.h search.h terminal.h \
- defines.h window.h
-region.o: region.c region.h line.h retcode.h utf8.h buffer.h estruct.h \
- mlout.h random.h window.h defines.h
-search.o: search.c search.h line.h retcode.h utf8.h basic.h buffer.h \
- display.h estruct.h input.h bind.h mlout.h terminal.h defines.h window.h
-spawn.o: spawn.c spawn.h defines.h buffer.h line.h retcode.h utf8.h \
- display.h estruct.h exec.h file.h flook.h input.h bind.h terminal.h \
- window.h
-tcap.o: tcap.c terminal.h defines.h retcode.h utf8.h display.h estruct.h \
- termio.h
-termio.o: termio.c termio.h utf8.h estruct.h retcode.h
-utf8.o: utf8.c utf8.h
-window.o: window.c window.h defines.h buffer.h line.h retcode.h utf8.h \
- basic.h display.h estruct.h execute.h terminal.h wrapper.h
-word.o: word.c word.h basic.h retcode.h buffer.h line.h utf8.h estruct.h \
- mlout.h random.h region.h window.h defines.h
-wrapper.o: wrapper.c wrapper.h
-wscreen.o: wscreen.c wscreen.h
 
-# DEPENDENCIES MUST END AT END OF FILE
+# end of Makefile
-# IF YOU PUT STUFF HERE IT WILL GO AWAY
-# see make depend above

README.md

@@ -1,19 +1,31 @@
 # README #
 
-Ciguë is µEMACS (ue) on Cygwin/Linux, based on uEmacs/PK (em) from kernel.org.
+µEMACS (ue) on Cygwin/MSYS2/Linux/NetBSD/OpenBSD, based on uEmacs/PK (em)
+from [kernel.org](https://git.kernel.org/pub/scm/editors/uemacs/uemacs.git/).
 
 ### Changes compare to uEmacs/PK ###
+
 * Line termination detection with new buffer mode (either Unix or DOS).
+
 * Encoding detection (ASCII, Extended ASCII, UTF-8 or Mixed).
-* Some fixes related to size either unchecked or limited (strcpy, insert-string, filenames, $kill).
+
-* Major refactoring of headers and file dependencies, hopefully to improve maintenance.
+* Some fixes related to size either unchecked or limited (strcpy,
-* Reactivation of target 'source' and 'depend' in Makefile.
+  insert-string, filenames, $kill).
-* Some defaults changed due to 'finger habits': ue instead of em, ^S in commands mapping...
+
+* Major refactoring of headers and file dependencies, hopefully to
+  improve maintenance.
+
+* Some defaults changed due to 'finger habits': ue instead of em, ^S in
+  commands mapping...
+
+### Unicode (UTF-8) support ###
+
+* gcc limitation on Windows (__WCHAR_WIDTH__ 16).
+
+* Display of double and zero width characters ongoing.
 
 ### How to build ###
-* dependencies: ncurses.
-* make depend ; make
-* MINGW32 target is experimental and lacks screen/kbd support.
 
-### Badges ###
+* dependencies: (gcc || clang) && gmake && ncurses-devel.
-[![Coverity Status](https://scan.coverity.com/projects/4449/badge.svg)](https://scan.coverity.com/projects/4449)
+
+* make

basic.c

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

basic.h

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

bind.c

@@ -1,409 +1,215 @@
 /* bind.c -- implements bind.h */
 #include "bind.h"
 
-/*  bind.c
+/*  This file is for functions having to do with key bindings,
- *
- *  This file is for functions having to do with key bindings,
  *  descriptions, help commands and startup file.
  *
  *  Written 11-feb-86 by Daniel Lawrence
  *  Modified by Petri Kutvonen
  */
 
-#include <stdio.h>
+#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "estruct.h"
 #include "bindable.h"
 #include "buffer.h"
-#include "display.h"
+#include "display.h"    /* upmode(), ostring() */
-#include "ebind.h"
 #include "exec.h"
 #include "file.h"
 #include "flook.h"
 #include "input.h"
 #include "line.h"
+#include "mlout.h"
 #include "names.h"
+#include "util.h"
 #include "window.h"
 
-
-#if APROP
 static int buildlist( char *mstring) ;
-static int strinc( char *source, char *sub) ;
+static char *cmdstr( unsigned c, char *seq) ;
-#endif
-
-static void cmdstr( int c, char *seq) ;
 static unsigned int getckey( int mflag) ;
 static unsigned int stock( char *keyname) ;
-static int unbindchar( unsigned c) ;
+static const char *getfname( unsigned keycode, const char *failmsg) ;
-static char *getfname( fn_t) ;
 
 
-int help(int f, int n)
+/* give me some help!!!! bring up a fake buffer and read the help file into
-{               /* give me some help!!!!
+   it with view mode
-                   bring up a fake buffer and read the help file
+ */
-                   into it with view mode                 */
+BINDABLE( help) {
-    struct buffer *bp;  /* buffer pointer to help */
     char *fname = NULL; /* ptr to file returned by flook() */
 
-    /* first check if we are already here */
+/* first check if we are already here */
-    bp = bfind( hlpfname, FALSE, BFINVS);
+    buffer_p bp = bfind( hlpfname, FALSE, BFINVS);
+    if( bp == curbp)
+        return TRUE ;
 
-    if (bp == NULL) {
+    if( bp == NULL) {
-        fname = flook( hlpfname, FALSE);
+        fname = flook( hlpfname, FALSE) ;
-        if (fname == NULL) {
+        if( fname == NULL)
-            mlwrite("(Help file is not online)");
+            return mloutfail( "(Help file is not online)") ;
-            return FALSE;
-        }
     }
 
-    /* split the current window to make room for the help stuff */
+/* split the current window to make room for the help stuff */
-    if (splitwind(FALSE, 1) == FALSE)
+    if( wheadp->w_wndp == NULL          /* One window */
-        return FALSE;
+    &&  splitwind( FALSE, 1) == FALSE)  /* Split it */
+        return FALSE ;
 
-    if (bp == NULL) {
+    if( bp == NULL) {
-        /* and read the stuff in */
+    /* and read the stuff in */
-        if (getfile(fname, FALSE) == FALSE)
+        if( getfile( fname, FALSE) == FALSE)
-            return FALSE;
+            return FALSE ;
     } else
-        swbuffer(bp);
+        swbuffer( bp) ;
 
     /* make this window in VIEW mode, update all mode lines */
     curwp->w_bufp->b_mode |= MDVIEW;
     curwp->w_bufp->b_flag |= BFINVS;
     upmode() ;
-    return TRUE;
+    return TRUE ;
 }
 
-int deskey(int f, int n)
-{               /* describe the command for a certain key */
-    int c;      /* key to describe */
-    char *ptr;  /* string pointer to scan output strings */
-    char outseq[NSTRING];   /* output buffer for command sequence */
 
-    /* prompt the user to type us a key to describe */
+static boolean invalidkey( void) {
-    mlwrite(": describe-key ");
+    return mloutfail( "(Invalid key sequence)") ;
-
-    /* get the command sequence to describe
-       change it to something we can print as well */
-    c = getckey( FALSE) ;
-    mlwrite( ": describe-key 0x%x, ", c) ;
-    cmdstr( c, &outseq[ 0]) ;
-
-    /* and dump it out */
-    ostring(outseq);
-    ostring(" ");
-
-    /* find the right ->function */
-    if ((ptr = getfname(getbind(c))) == NULL)
-        ptr = "Not Bound";
-
-    /* output the command sequence */
-    ostring(ptr);
-    return TRUE;
 }
 
-/*
+
- * bindtokey:
+/* describe the command for a certain key */
+BINDABLE( deskey) {
+    const char cmdname[] = "describe-key" ;
+    char outseq[ 8] ;   /* output buffer for keystroke sequence */
+
+/* prompt the user to type a key to describe */
+    mloutfmt( "%s: ", cmdname) ;
+
+/* get the command sequence to describe
+ * change it to something we can print as well */
+    unsigned keycode = getckey( FALSE) ;
+    if( keycode == (unsigned) ~0)
+        return invalidkey() ;
+
+/* output the command sequence */
+    mloutfmt( "%s %s: 0x%x, %s", cmdname, cmdstr( keycode, outseq), keycode,
+                                            getfname( keycode, "Not Bound")) ;
+    return TRUE ;
+}
+
+
+/* bindtokey:
  *  add a new key to the key binding table
  *
  * int f, n;        command arguments [IGNORED]
  */
-int bindtokey(int f, int n)
+BINDABLE( bindtokey) {
-{
+    kbind_p ktp ;       /* pointer into the command table */
-    unsigned int c;      /* command key to bind */
+    char outseq[ 8] ;   /* output buffer for keystroke sequence */
-    fn_t kfunc;      /* ptr to the requested function to bind to */
-    struct key_tab *ktp; /* pointer into the command table */
-    int found;       /* matched command flag */
-    char outseq[80];     /* output buffer for keystroke sequence */
 
-    /* prompt the user to type in a key to bind */
+/* prompt the user to type in a key to bind */
-    mlwrite(": bind-to-key ");
+    mloutstr( "bind-to-key: ") ;
 
-    /* get the function name to bind it to */
+/* get the function name to bind it to */
-    kfunc = getname();
+    nbind_p nbp = getname() ;
-    if (kfunc == NULL) {
+    if( nbp == NULL)    /* abort */
-        mlwrite("(No such function)");
+        return FALSE ;
-        return FALSE;
-    }
-    ostring(" ");
 
-    /* get the command sequence to bind */
+    fnp_t kfunc = nbp->n_func ;
-    c = getckey((kfunc == metafn) || (kfunc == cex) ||
+    if( kfunc == NULL)
-            (kfunc == unarg) || (kfunc == ctrlg));
+        return mloutfail( "(No such function)") ;
 
-    /* change it to something we can print as well */
+    mloutfmt( "bind-to-key %s: ", bind_name( nbp)) ;
-    cmdstr(c, &outseq[0]);
 
-    /* and dump it out */
+/* get the command sequence to bind */
-    ostring(outseq);
+    boolean prefix_f = (kfunc == (fnp_t) metafn) || (kfunc == (fnp_t) cex) ||
+                        (kfunc == (fnp_t) unarg) || (kfunc == (fnp_t) ctrlg) ;
+    int c = getckey( prefix_f) ;
+    if( c == ~0)
+        return invalidkey() ;
 
-    /* if the function is a prefix key */
+/* change it to something we can print as well */
-    if (kfunc == metafn || kfunc == cex ||
+/* and dump it out */
-        kfunc == unarg || kfunc == ctrlg) {
+    ostring( cmdstr( c, outseq)) ;
 
-        /* search for an existing binding for the prefix key */
+/* key sequence can't be an active prefix key */
-        ktp = &keytab[0];
+    if( c == metac || c == ctlxc || c == reptc || c == abortc) {
-        found = FALSE;
+        if( (c == metac  && kfunc == (fnp_t) metafn)
-        while (ktp->k_fp != NULL) {
+        ||  (c == ctlxc  && kfunc == (fnp_t) cex)
-            if (ktp->k_fp == kfunc)
+        ||  (c == reptc  && kfunc == (fnp_t) unarg)
-                unbindchar(ktp->k_code);
+        ||  (c == abortc && kfunc == (fnp_t) ctrlg))
-            ++ktp;
+            return TRUE ;   /* be silent if keep current */
-        }
 
-        /* reset the appropriate global prefix variable */
+        return mloutfail( "(Can't bind to active prefix)") ;
-        if (kfunc == metafn)
-            metac = c;
-        if (kfunc == cex)
-            ctlxc = c;
-        if (kfunc == unarg)
-            reptc = c;
-        if (kfunc == ctrlg)
-            abortc = c;
     }
 
-    /* search the table to see if it exists */
+/* if the function is a prefix key */
-    ktp = &keytab[0];
+    if( prefix_f) {
-    found = FALSE;
+    /* remove existing binding for the prefix */
-    while (ktp->k_fp != NULL) {
+        for( ktp = keytab ; ktp->k_code != 0 ; ktp++)
-        if (ktp->k_code == c) {
+            if( ktp->k_nbp == nbp) {
-            found = TRUE;
+                delkeybinding( ktp->k_code) ;
-            break;
+                break ;
-        }
+            }
-        ++ktp;
+
+    /* set the appropriate global prefix variable */
+        if( kfunc == (fnp_t) metafn)
+            metac = c ;
+        else if( kfunc == (fnp_t) cex)
+            ctlxc = c ;
+        if( kfunc == (fnp_t) unarg)
+            reptc = c ;
+        if( kfunc == (fnp_t) ctrlg)
+            abortc = c ;
     }
 
-    if (found) {        /* it exists, just change it then */
+    ktp = setkeybinding( c, nbp) ;
-        ktp->k_fp = kfunc;
+    if( ktp->k_code == 0)
-    } else {        /* otherwise we need to add it to the end */
+        return mloutfail( "Binding table FULL!") ;
-        /* if we run out of binding room, bitch */
-        if (ktp >= &keytab[NBINDS]) {
-            mlwrite("Binding table FULL!");
-            return FALSE;
-        }
 
-        ktp->k_code = c;    /* add keycode */
+    return TRUE ;
-        ktp->k_fp = kfunc;  /* and the function pointer */
-        ++ktp;      /* and make sure the next is null */
-        ktp->k_code = 0;
-        ktp->k_fp = NULL;
-    }
-    return TRUE;
 }
 
-/*
+
- * unbindkey:
+/* unbindkey:
  *  delete a key from the key binding table
  *
  * int f, n;        command arguments [IGNORED]
  */
-int unbindkey(int f, int n)
+BINDABLE( unbindkey) {
-{
+    char outseq[ 8] ;   /* output buffer for keystroke sequence */
-    int c;      /* command key to unbind */
-    char outseq[80];    /* output buffer for keystroke sequence */
 
-    /* prompt the user to type in a key to unbind */
+/* prompt the user to type in a key to unbind */
-    mlwrite(": unbind-key ");
+    mloutstr( "unbind-key: ") ;
 
-    /* get the command sequence to unbind */
+/* get the command sequence to unbind */
-    c = getckey(FALSE); /* get a command sequence */
+    int c = getckey( FALSE) ;   /* get a command sequence */
+    if( c == ~0)
+        return invalidkey() ;
 
-    /* change it to something we can print as well */
+/* change it to something we can print as well */
-    cmdstr(c, &outseq[0]);
+/* and dump it out */
+    ostring( cmdstr( c, outseq)) ;
 
-    /* and dump it out */
+/* prefix key sequence can't be undound, just redefined */
-    ostring(outseq);
+    if( c == reptc || c == abortc)
+        return mloutfail( "(Can't unbind prefix)") ;
 
-    /* if it isn't bound, bitch */
+/* if it isn't bound, bitch */
-    if (unbindchar(c) == FALSE) {
+    if( delkeybinding( c) == FALSE)
-        mlwrite("(Key not bound)");
+        return mloutfail( "(Key not bound)") ;
-        return FALSE;
+
-    }
+    return TRUE ;
-    return TRUE;
 }
 
 
-/*
+/* does source include sub?
- * unbindchar()
- *
- * int c;       command key to unbind
- */
-static int unbindchar( unsigned c) {
-    struct key_tab *ktp;   /* pointer into the command table */
-    struct key_tab *sktp;  /* saved pointer into the command table */
-    int found;             /* matched command flag */
-
-    /* search the table to see if the key exists */
-    ktp = &keytab[0];
-    found = FALSE;
-    while (ktp->k_fp != NULL) {
-        if (ktp->k_code == c) {
-            found = TRUE;
-            break;
-        }
-        ++ktp;
-    }
-
-    /* if it isn't bound, bitch */
-    if (!found)
-        return FALSE;
-
-    /* save the pointer and scan to the end of the table */
-    sktp = ktp;
-    while (ktp->k_fp != NULL)
-        ++ktp;
-    --ktp;          /* backup to the last legit entry */
-
-    /* copy the last entry to the current one */
-    sktp->k_code = ktp->k_code;
-    sktp->k_fp = ktp->k_fp;
-
-    /* null out the last one */
-    ktp->k_code = 0;
-    ktp->k_fp = NULL;
-    return TRUE;
-}
-
-/* describe bindings
- * bring up a fake buffer and list the key bindings
- * into it with view mode
- */
-int desbind( int f, int n) {
-#if APROP
-    return buildlist( "") ;
-}
-
-/* Apropos (List functions that match a substring) */
-int apro( int f, int n) {
-	char *mstring ;	/* string to match cmd names to */
-	int status ;	/* status return */
-
-    status = newmlarg( &mstring, "Apropos string: ", 0) ;
-	if( status == TRUE) {
-		status = buildlist( mstring) ;
-		free( mstring) ;
-	} else if( status == FALSE)
-		status = buildlist( "") ;	/* build list of all commands */
-
-    return status ;
-}
-
-/*
- * build a binding list (limited or full)
- *
- * char *mstring;   match string if a partial list, "" matches all
- */
-static int buildlist( char *mstring) {
-#endif
-    struct window *wp;         /* scanning pointer to windows */
-    struct key_tab *ktp;  /* pointer into the command table */
-    struct name_bind *nptr;          /* pointer into the name binding table */
-    struct buffer *bp;    /* buffer to put binding list into */
-    char outseq[80];      /* output buffer for keystroke sequence */
-
-    /* split the current window to make room for the binding list */
-    if (splitwind(FALSE, 1) == FALSE)
-        return FALSE;
-
-    /* and get a buffer for it */
-    bp = bfind("*Binding list*", TRUE, 0);
-    if (bp == NULL || bclear(bp) == FALSE) {
-        mlwrite("Can not display binding list");
-        return FALSE;
-    }
-
-    /* let us know this is in progress */
-    mlwrite("(Building binding list)");
-
-    /* disconect the current buffer */
-    if (--curbp->b_nwnd == 0) { /* Last use.            */
-        curbp->b_dotp = curwp->w_dotp;
-        curbp->b_doto = curwp->w_doto;
-        curbp->b_markp = curwp->w_markp;
-        curbp->b_marko = curwp->w_marko;
-    }
-
-    /* connect the current window to this buffer */
-    curbp = bp;     /* make this buffer current in current window */
-    bp->b_mode = 0;     /* no modes active in binding list */
-    bp->b_nwnd++;       /* mark us as more in use */
-    wp = curwp;
-    wp->w_bufp = bp;
-    wp->w_linep = bp->b_linep;
-    wp->w_flag = WFHARD | WFFORCE;
-    wp->w_dotp = bp->b_dotp;
-    wp->w_doto = bp->b_doto;
-    wp->w_markp = NULL;
-    wp->w_marko = 0;
-
-    /* build the contents of this window, inserting it line by line */
-    for( nptr = &names[ 0] ; nptr->n_func != NULL ; nptr++) {
-	    int cpos ;	/* current position to use in outseq */
-
-#if APROP
-        /* if we are executing an apropos command..... */
-            /* and current string doesn't include the search string */
-        if( *mstring && strinc( nptr->n_name, mstring) == FALSE)
-			continue ;
-#endif
-        /* add in the command name */
-        strncpy( outseq, nptr->n_name, sizeof outseq - 1) ;
-        outseq[ sizeof outseq - 1] = '\0' ;
-        cpos = strlen(outseq);
-
-        /* search down any keys bound to this */
-        ktp = &keytab[0];
-        while (ktp->k_fp != NULL) {
-            if (ktp->k_fp == nptr->n_func) {
-                /* padd out some spaces */
-                while (cpos < 28)
-                    outseq[cpos++] = ' ';
-
-                /* add in the command sequence */
-                cmdstr(ktp->k_code, &outseq[cpos]);
-                strcat(outseq, "\n");
-
-                /* and add it as a line into the buffer */
-                if (linstr(outseq) != TRUE)
-                    return FALSE;
-
-                cpos = 0;   /* and clear the line */
-            }
-            ++ktp;
-        }
-
-        /* if no key was bound, we need to dump it anyway */
-        if (cpos > 0) {
-            outseq[cpos++] = '\n';
-            outseq[cpos] = 0;
-            if (linstr(outseq) != TRUE)
-                return FALSE;
-        }
-    }
-
-    bp->b_mode |= MDVIEW;    /* put this buffer view mode */
-    bp->b_flag &= ~BFCHG;    /* don't flag this as a change */
-    wp->w_dotp = lforw(bp->b_linep);    /* back to the beginning */
-    wp->w_doto = 0;
-    upmode() ;			/* and update ALL mode lines */
-    mlwrite("");        /* clear the mode line */
-    return TRUE;
-}
-
-#if APROP
-
-/*
- * does source include sub?
  *
  * char *source;    string to search in
  * char *sub;       substring to look for
  */
-static int strinc( char *source, char *sub) {
+static boolean strinc( const char *source, const char *sub) {
     /* for each character in the source string */
     for( ; *source ; source++) {
-		char *nxtsp ;   /* next ptr into source */
+        const char *nxtsp ;  /* next ptr into source */
-		char *tp ;		/* ptr into substring */
+        const char *tp ;    /* ptr into substring */
 
         nxtsp = source;
 
@@ -419,214 +225,283 @@ static int strinc( char *source, char *sub) {
 
     return FALSE ;
 }
-#endif
 
-/*
+
- * get a command key sequence from the keyboard
+/* describe bindings
+ * bring up a fake buffer and list the key bindings
+ * into it with view mode
+ */
+BINDABLE( desbind) {
+    return buildlist( "") ;
+}
+
+
+/* Apropos (List functions that match a substring) */
+BINDABLE( apro) {
+    char *mstring ; /* string to match cmd names to */
+
+    int status = newmlarg( &mstring, "apropos: ", 0) ;
+    if( status == TRUE) {
+        status = buildlist( mstring) ;
+        free( mstring) ;
+    } else if( status == FALSE)
+        status = buildlist( "") ;   /* build list of all commands */
+
+    return status ;
+}
+
+
+/* build a binding list (limited or full)
+ *
+ * char *mstring;   match string if a partial list, "" matches all
+ */
+static int buildlist( char *mstring) {
+#define PADDING 28
+    char outseq[ PADDING + 8] ;  /* output buffer for command + keystroke */
+
+/* split the current window to make room for the binding list */
+    if( wheadp->w_wndp == NULL          /* One window */
+    &&  splitwind( FALSE, 1) == FALSE)  /* Split it */
+        return FALSE ;
+
+/* and get a buffer for it */
+    buffer_p bp = bfind( "*Binding list*", TRUE, 0) ;
+    if( bp == NULL || bclear( bp) == FALSE)
+        return mloutfail( "Can't display binding list") ;
+
+/* let us know this is in progress */
+    mloutstr( "(Building binding list)") ;
+
+/* disconnect the current buffer */
+    if( --curbp->b_nwnd == 0) { /* Last use.            */
+        curbp->b_dotp = curwp->w_dotp ;
+        curbp->b_doto = curwp->w_doto ;
+        curbp->b_markp = curwp->w_markp ;
+        curbp->b_marko = curwp->w_marko ;
+    }
+
+/* connect the current window to this buffer */
+    curbp = bp ;    /* make this buffer current in current window */
+    bp->b_mode = 0 ;    /* no modes active in binding list */
+    bp->b_nwnd++ ;      /* mark us as more in use */
+    window_p wp = curwp ;
+    wp->w_bufp = bp ;
+    wp->w_linep = bp->b_linep ;
+    wp->w_flag = WFHARD | WFFORCE ;
+    wp->w_dotp = bp->b_dotp ;
+    wp->w_doto = bp->b_doto ;
+    wp->w_markp = NULL ;
+    wp->w_marko = 0 ;
+
+/* build the contents of this window, inserting it line by line */
+    for( nbind_p nptr = names ; nptr->n_func != NULL ; nptr++) {
+        int cpos ;  /* current position to use in outseq */
+
+        /* if we are executing an apropos command..... */
+        /* and current string doesn't include the search string */
+        if( *mstring && strinc( bind_name( nptr), mstring) == FALSE)
+            continue ;
+
+        /* add in the command name */
+        mystrscpy( outseq, bind_name( nptr), sizeof outseq) ;
+        cpos = strlen( outseq) ;
+
+        /* search down any keys bound to this */
+        for( kbind_p ktp = keytab ; ktp->k_code != 0 ; ktp++) {
+            if( ktp->k_nbp == nptr) {
+            /* padd out some spaces */
+                while( cpos < PADDING)
+                    outseq[ cpos++] = ' ' ;
+
+            /* add in the command sequence */
+                cmdstr( ktp->k_code, &outseq[ cpos]) ;
+                strcat( outseq, "\n") ;
+
+            /* and add it as a line into the buffer */
+                if( linstr( outseq) != TRUE)
+                    return FALSE ;
+
+                cpos = 0 ;  /* and clear the line */
+            }
+        }
+
+        /* if no key was bound, we need to dump it anyway */
+        if( cpos > 0) {
+            outseq[ cpos++] = '\n';
+            outseq[ cpos] = 0;
+            if( linstr( outseq) != TRUE)
+                return FALSE ;
+        }
+    }
+
+    bp->b_mode |= MDVIEW ;              /* put this buffer view mode */
+    bp->b_flag &= ~BFCHG ;              /* don't flag this as a change */
+    wp->w_dotp = lforw( bp->b_linep) ;  /* back to the beginning */
+    wp->w_doto = 0 ;
+    upmode() ;                          /* and update ALL mode lines */
+    mloutstr( "") ;                     /* clear the mode line */
+    return TRUE ;
+}
+
+
+/* get a command key sequence from the keyboard
  *
  * int mflag;       going for a meta sequence?
+ * returns ~0 on failure
  */
 static unsigned int getckey( int mflag) {
-    unsigned int c ;	/* character fetched */
+    unsigned int c ;    /* character fetched */
 
     /* check to see if we are executing a command line */
     if( clexec) {
-		char *tok ;	/* command incoming */
+        char *tok = getnewtokval() ;    /* get the next token */
-		
+        if( tok == NULL)
-		tok = getnewtokval() ;	/* get the next token */
+            c = ~0 ;    /* return invalid key on failure */
-		if( tok == NULL)
+        else {
-			c = 0 ;	/* return dummy key on failure */
+            c = stock( tok) ;
-		else {
+            free( tok) ;
-			c = stock( tok) ;
+        }
-			free( tok) ;
+    } else {    /* or the normal way */
-		}
+        if( mflag)
-    } else {	/* or the normal way */
+            c = get1key() ;
-	    if( mflag)
+        else
-    	    c = get1key() ;
+            c = getcmd() ;
-    	else
+    }
-			c = getcmd() ;
-	}
 
-	return c ;
+    return c ;
 }
 
-/*
+
- * execute the startup file
+/* execute the startup file
  *
  * char *fname;    name of startup file (null if default)
  */
 int startup( const char *fname) {
-    if( !fname || *fname == 0)		/* use default if empty parameter */
+    if( !fname || *fname == 0)      /* use default if empty parameter */
-    	fname = rcfname ;
+        fname = rcfname ;
 
-	fname = flook( fname, TRUE) ;	/* look up the startup file */
+    fname = flook( fname, TRUE) ;   /* look up the startup file */
-    if( fname == NULL)    			/* if it isn't around, don't sweat it */
+    if( fname == NULL)              /* if it isn't around, don't sweat it */
         return TRUE ;
 
-    return dofile( fname) ;			/* otherwise, execute the sucker */
+    return dofile( fname) ;         /* otherwise, execute the sucker */
 }
 
-/*
+
- * change a key command to a string we can print out
+/* change a key command to a string we can print out
  *
  * int c;       sequence to translate
  * char *seq;       destination string for sequence
  */
-static void cmdstr( int c, char *seq) {
+static char *cmdstr( unsigned c, char *seq) {
-    char *ptr;      /* pointer into current position in sequence */
+    char *ptr = seq ;   /* pointer into current position in sequence */
 
-    ptr = seq;
+/* apply meta sequence if needed */
-
+    if( c & META) {
-    /* apply meta sequence if needed */
-    if (c & META) {
         *ptr++ = 'M';
         *ptr++ = '-';
     }
 
-    /* apply ^X sequence if needed */
+/* apply ^X sequence if needed */
-    if (c & CTLX) {
+    if( c & CTLX) {
-        *ptr++ = '^';
+        if( ctlxc & CTL_)
-        *ptr++ = 'X';
+            *ptr++ = '^' ;
+
+        *ptr++ = ctlxc & ~PRFXMASK ;
     }
 
-    /* apply SPEC sequence if needed */
+/* apply control sequence if needed */
-    if (c & SPEC) {
+    if( c & CTL_)
-        *ptr++ = 'F';
+        *ptr++ = '^' ;
-        *ptr++ = 'N';
+
+/* apply SPEC sequence if needed */
+    if( c & SPEC) {
+        *ptr++ = 'F' ;
+        *ptr++ = 'N' ;
     }
 
-    /* apply control sequence if needed */
+/* and output the final sequence */
-    if (c & CONTROL) {
+    ptr += unicode_to_utf8( c & ~PRFXMASK, ptr) ;
-        *ptr++ = '^';
+    *ptr = 0 ;          /* terminate the string */
-    }
+    return seq ;
-
-    /* and output the final sequence */
-
-    *ptr++ = c & 255;   /* strip the prefixes */
-
-    *ptr = 0;       /* terminate the string */
 }
 
-/*
- * This function looks a key binding up in the binding table
- *
- * int c;       key to find what is bound to it
- */
-fn_t getbind( unsigned c) {
-    struct key_tab *ktp;
 
-    ktp = &keytab[0];  /* Look in key table. */
+static const char *getfname( unsigned keycode, const char *failmsg) {
-    while (ktp->k_fp != NULL) {
+/* takes a key code and gets the name of the function bound to it */
-        if (ktp->k_code == c)
+    kbind_p kbp = getkeybinding( keycode) ;
-            return ktp->k_fp;
+    if( kbp->k_code == 0)
-        ++ktp;
+        return failmsg ;
-    }
 
-    /* no such binding */
+    const char *found = bind_name( kbp->k_nbp) ;
-    return NULL;
+    assert( *found) ;
+    return found ;
 }
 
-/*
- * getfname:
- *  This function takes a ptr to function and gets the name
- *  associated with it.
- */
-static char *getfname(fn_t func)
-{
-    struct name_bind *nptr; /* pointer into the name binding table */
 
-    /* skim through the table, looking for a match */
+/* stock:
-    nptr = &names[0];
-    while (nptr->n_func != NULL) {
-        if (nptr->n_func == func)
-            return nptr->n_name;
-        ++nptr;
-    }
-    return NULL;
-}
-
-/*
- * match fname to a function in the names table
- * and return any match or NULL if none
- *
- * char *fname;     name to attempt to match
- */
-int (*fncmatch(char *fname)) (int, int)
-{
-    struct name_bind *ffp;  /* pointer to entry in name binding table */
-
-    /* scan through the table, returning any match */
-    ffp = &names[0];
-    while (ffp->n_func != NULL) {
-        if (strcmp(fname, ffp->n_name) == 0)
-            return ffp->n_func;
-        ++ffp;
-    }
-    return NULL;
-}
-
-/*
- * stock:
  *  String key name TO Command Key
  *
  * char *keyname;   name of key to translate to Command key form
+ * fmt: [M-|^X][^][FN]X
+ * returns ~0 on invalid sequence
  */
 static unsigned int stock( char *keyname) {
-    unsigned int c; /* key sequence to return */
+/* parse it up */
+    unsigned c = 0 ;
 
-    /* parse it up */
+/* first, the prefix META or ^X */
-    c = 0;
+    if( *keyname == 'M' && keyname[ 1] == '-') {
-
+        c = META ;
-    /* first, the META prefix */
+        keyname += 2 ;
-    if (*keyname == 'M' && *(keyname + 1) == '-') {
+    } else if( *keyname == '^' && keyname[ 1] == 'X') {
-        c = META;
+        c = CTLX ;
-        keyname += 2;
+        keyname += 2 ;
     }
 
-    /* next the function prefix */
+/* a control char? */
-    if (*keyname == 'F' && *(keyname + 1) == 'N') {
+    if( *keyname == '^' && keyname[ 1] != 0) {
-        c |= SPEC;
+        c |= CTL_ ;
-        keyname += 2;
+        ++keyname ;
     }
 
-    /* control-x as well... (but not with FN) */
+/* next the function prefix */
-    if (*keyname == '^' && *(keyname + 1) == 'X' && !(c & SPEC)) {
+    if( *keyname == 'F' && keyname[ 1] == 'N') {
-        c |= CTLX;
+        c |= SPEC ;
-        keyname += 2;
+        keyname += 2 ;
-    }
-
-    /* a control char? */
-    if (*keyname == '^' && *(keyname + 1) != 0) {
-        c |= CONTROL;
-        ++keyname;
-    }
-    if (*keyname < 32) {
-        c |= CONTROL;
-        *keyname += 'A';
     }
 
+/* only one character left to parse */
+    if( !*keyname || keyname[1])
+        return ~0 ;
 
+/* only way to redefine ^X is by quoting binary value */
+    if( *keyname < 32 || *keyname == 0x7F) {
+        c |= CTL_ ;
+        *keyname ^= 0x40 ;
+    } else  if( c && !(c & SPEC)
+            &&  *keyname >= 'a' && *keyname <= 'z')
     /* make sure we are not lower case (not with function keys) */
-    if (*keyname >= 'a' && *keyname <= 'z' && !(c & SPEC))
+        *keyname -= 32 ;
-        *keyname -= 32;
 
-    /* the final sequence... */
+/* the final sequence... */
     c |= *keyname & 0xFFU ;
-    return c;
+    return c ;
 }
 
-/*
+
- * string key name to binding name....
+/* string key name to binding name....
  *
- * char *skey;      name of keey to get binding for
+ * char *skey;      name of key to get binding for
  */
-char *transbind(char *skey)
+const char *transbind( char *skey) {
-{
+    static const char failmsg[] = "ERROR" ;
-    char *bindname;
 
-    bindname = getfname(getbind(stock(skey)));
+    unsigned c = stock( skey) ;
-    if (bindname == NULL)
+    if( c == (unsigned) ~0)
-        bindname = "ERROR";
+        return failmsg ;
-
+    else
-    return bindname;
+        return getfname( c, failmsg) ;
 }
+
+/* end of bind.c */

bind.h

@@ -1,23 +1,21 @@
+/* bind.h -- bindable functions dealing with name and key bindings */
 #ifndef _BIND_H_
 #define _BIND_H_
 
-#define	APROP	1  /* Add code for Apropos command                 */
+#include "names.h"  /* BINDABLE() */
 
-#if APROP
+/* Bindable uEMACS functions */
-int apro( int f, int n) ;
+BINDABLE( apro) ;
-#endif
+BINDABLE( bindtokey) ;
+BINDABLE( desbind) ;
+BINDABLE( deskey) ;
+BINDABLE( help) ;
+BINDABLE( unbindkey) ;
 
-/* Some global fuction declarations. */
-typedef int (*fn_t)(int, int);
-
-int help( int f, int n) ;
-int deskey( int f, int n) ;
-int bindtokey( int f, int n) ;
-int unbindkey( int f, int n) ;
-int desbind( int f, int n) ;
 int startup( const char *fname) ;
-fn_t getbind( unsigned keycode) ;
+
-fn_t fncmatch( char *) ;
+/* find a key to function association in the key to function mapping table */
-char *transbind( char *skey) ;
+const char *transbind( char *skey) ;    /* by string representation of key */
 
 #endif
+/* end of bind.h */

bindable.c

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

bindable.h

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

blindmaz.cmd

@@ -0,0 +1,60 @@
+## blindmaz.cmd -- solve maze by walking a left-handed blind mouse
+
+#7 set $seed
+# either maze.cmd, sharpmaz.cmd or floodmaz.cmd
+execute-file floodmaz.cmd
+
+set %dotc &asc "•"	# alternatively use "."
+set $curchar %dotc
+set %x &add $curcol 1
+set %y $curline
+end-of-line
+set %stopcol &sub $curcol 1
+
+# X-Y offset for absolute direction: east, south, west, north
+set %DX0 1
+set %DY0 0
+set %DX1 0
+set %DY1 1
+set %DX2 -1
+set %DY2 0
+set %DX3 0
+set %DY3 -1
+
+set %absD 0							# absolute direction: looking EAST
+!while &les %x %stopcol
+# try move on left, right or front
+	set %relD 3						# 3, 0, 1, 2 == left, front, right, back
+	!while &not &equ %relD 2
+		set %newD &mod &add %absD %relD 4
+		set %offX &ind &cat "%DX" %newD
+		set %offY &ind &cat "%DY" %newD
+		set %nx &add %x %offX
+		set %ny &add %y %offY
+		set $curline %ny
+		set $curcol  %nx
+		!if &or &equ $curchar 32 &equ $curchar %dotc
+			!if &equ $curchar 32
+				set %C %dotc
+			!else
+				set %C &asc " "		# erase (or highlight) when backtracking
+			!endif
+			set %absD %newD
+			set $curchar %C
+			set $curline %y
+			set $curcol  %x
+			set $curchar %C
+			set %x &add %nx %offX
+			set %y &add %ny %offY
+			update-screen
+			!goto moveon
+		!endif
+		set %relD &mod &add %relD 1 4
+	!endwhile
+# else turn around
+	set %absD &mod &add %absD 2 4	# face back!
+:moveon
+!endwhile
+
+set $curcol  &add %x -1
+unmark-buffer

buffer.h

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

defines.h

@@ -1,30 +1,63 @@
-/* defines.h -- */
+/* defines.h -- customization based on gcc predefined macroes */
-
 #ifndef __DEFINES_H__
 #define __DEFINES_H__
 
-
+#if __unix__ || (defined(__APPLE__) && defined(__MACH__))
-/* Must define one of
+# define UNIX 1
-	VMS | V7 | USG | BSD | MSDOS
+# if __NetBSD__ || __OpenBSD__ || (defined(__APPLE__) && defined(__MACH__))
-*/
+#  define BSD 1
-#define USG 1
+#  define POSIX 1
-
+# elif __linux__
-#define PKCODE 1
+#  define USG 1
-#define SCROLLCODE 1   /* scrolling code P.K.                          */
+#  define SVR4 1	/* locks */
-#define ENVFUNC 1
+#  define POSIX 1
-
+# else	/* __CYGWIN__ */
-#define	NSTRING	128		/* # of bytes, string buffers	*/
+#  define USG 1
-
+//#  define POSIX 1
-#define CONTROL 0x01000000	/* Control flag, or'ed in       */
+# endif
-#define META    0x02000000	/* Meta flag, or'ed in          */
+#else
-#define CTLX    0x04000000	/* ^X flag, or'ed in            */
+# error Missing gcc predefined __unix__
-#define	SPEC	0x08000000	/* special key (function keys)  */
-
-/* Actual 380x134 on a 1920x1080 screen in landscape,
-   if smaller font or portrait orientation limit to 400x150 */
-#define MAXCOL	400
-#define MAXROW	150
-
 #endif
 
-/* end of defines.h */
+#define NSTRING 128     /* # of bytes, string buffers   */
+
+#define TERMCAP 1		/* UNIX */
+#define XONXOFF 1		/* UNIX */
+
+#define VISMAC  0  		/* update display during keyboard macros        */
+
+#define MSDOS	0
+#define IBMPC	MSDOS
+#define COLOR	MSDOS
+
+
+#define FILOCK (SVR4 | BSD)
+#define ENVFUNC 1		/* only two types so far (USG | BSD) */
+
+#define PKCODE 1		/* include P.K. extensions, define always    */
+#define SCROLLCODE 1	/* scrolling code P.K. */
+
+/*  Dynamic RAM tracking and reporting redefinitions    */
+#define RAMSIZE 0		/* dynamic RAM memory usage tracking */
+#if RAMSIZE
+# define RAMSHOW 1		/* auto dynamic RAM reporting */
+# include <stdlib.h>	/* size_t */
+  void *allocate( size_t size) ;
+  void release( void *ptr) ;
+
+# define malloc( sz)	allocate(sz)
+# define free( ptr)		release( ptr)
+#endif
+
+/* De-allocate memory always on exit (if the operating system or main
+   program can not)
+*/
+#define CLEAN 0			/* de-alloc memory on exit */
+#if CLEAN
+# define exit(a) cexit(a)
+
+  void cexit( int status) ;
+#endif
+
+#endif
+/* end of predefs.h */

display.h

@@ -1,45 +1,51 @@
+/* display.h -- display functionality */
 #ifndef _DISPLAY_H_
 #define _DISPLAY_H_
 
 #include <stdarg.h>
 
-#include "estruct.h"
+#include "defines.h"		/* UNIX */
-#include "utf8.h"
+#include "names.h"          /* BINDABLE() */
+#include "utf8.h"           /* unicode_t */
 
-extern int mpresf ;		/* Stuff in message line */
+#define MINROWS	3
-extern int scrollcount ;	/* number of lines to scroll */
+#define MINCOLS 10
-extern int discmd ;		/* display command flag         */
+
-extern int disinp ;		/* display input characters (echo)	*/
+extern int mpresf ;         /* Stuff in message line */
-extern int gfcolor ;		/* global forgrnd color (white) */
+extern int scrollcount ;    /* number of lines to scroll */
-extern int gbcolor ;		/* global backgrnd color (black) */
+extern int discmd ;         /* display command flag         */
+extern int disinp ;         /* display input characters (echo)  */
+extern int gfcolor ;        /* global forgrnd color (white) */
+extern int gbcolor ;        /* global backgrnd color (black) */
+
+/* global variables */
+extern boolean viewtab ;    /* $viewtab = TRUE to visualize hardcoded tab */
+
+/* Bindable functions */
+TBINDABLE( upscreen) ;
 
 void vtinit( void) ;
 void vtfree( void) ;
 void vttidy( void) ;
-void vtmove( int row, int col) ;
+void update( boolean force_f) ;
-int upscreen( int f, int n) ;
+void updmargin( void) ;
-int update( int force) ;
-void updpos( void) ;
-void upddex( void) ;
-void updgar( void) ;
-int updupd( int force) ;
 void upmode( void) ;
 void movecursor( int row, int col) ;
 void mlerase( void) ;
 void vmlwrite( const char *fmt, va_list ap) ;
 void mlwrite( const char *fmt, ...) ;
-void ostring( char *s) ;
+void ostring( const char *s) ;
 void echoc( unicode_t c) ;
-void echos( char *s) ;
+void echos( const char *s) ;
+void rubout( void) ;
 void getscreensize( int *widthp, int *heightp) ;
 
 #if UNIX
-#include <signal.h>
+# include <signal.h>
-#ifdef SIGWINCH
+# ifdef SIGWINCH
-extern int chg_width, chg_height ;
+   extern int chg_width, chg_height ;
-
+# endif
-void sizesignal( int signr) ;
-#endif
 #endif
 
 #endif
+/* end of display.h */

ebind.c

@@ -1,437 +0,0 @@
-/* ebind.c -- implements ebind.h */
-#include "ebind.h"
-
-/*  ebind.c
- *
- *  Initial default key to function bindings
- *
- *  Modified by Petri Kutvonen
- */
-
-#include <stdlib.h>
-
-
-#include "basic.h"
-#include "bind.h"
-#include "estruct.h"
-#include "bindable.h"
-#include "buffer.h"
-#include "eval.h"
-#include "exec.h"
-#include "file.h"
-#include "isearch.h"
-#include "line.h"
-#include "random.h"
-#include "region.h"
-#include "search.h"
-#include "spawn.h"
-#include "window.h"
-#include "word.h"
-
-/*
- * Command table.
- * This table  is *roughly* in ASCII order, left to right across the
- * characters of the command. This explains the funny location of the
- * control-X commands.
- */
-struct key_tab keytab[NBINDS] = {
-    {CONTROL | 'A', (fn_t) gotobol}
-    ,
-    {CONTROL | 'B', (fn_t) backchar}
-    ,
-    {CONTROL | 'C', insspace}
-    ,
-    {CONTROL | 'D', forwdel}
-    ,
-    {CONTROL | 'E', (fn_t) gotoeol}
-    ,
-    {CONTROL | 'F', (fn_t) forwchar}
-    ,
-    {CONTROL | 'G', ctrlg}
-    ,
-    {CONTROL | 'H', backdel}
-    ,
-    {CONTROL | 'I', insert_tab}
-    ,
-    {CONTROL | 'J', indent}
-    ,
-    {CONTROL | 'K', killtext}
-    ,
-    {CONTROL | 'L', redraw}
-    ,
-    {CONTROL | 'M', insert_newline}
-    ,
-    {CONTROL | 'N', (fn_t) forwline}
-    ,
-    {CONTROL | 'O', openline}
-    ,
-    {CONTROL | 'P', (fn_t) backline}
-    ,
-    {CONTROL | 'Q', quote}
-    ,
-    {CONTROL | 'R', backsearch}
-    ,
-    {CONTROL | 'S', forwsearch}
-    ,
-    {CONTROL | 'T', (fn_t) twiddle}
-    ,
-    {CONTROL | 'U', unarg}
-    ,
-    {CONTROL | 'V', (fn_t) forwpage}
-    ,
-    {CONTROL | 'W', killregion}
-    ,
-    {CONTROL | 'X', cex}
-    ,
-    {CONTROL | 'Y', yank}
-    ,
-    {CONTROL | 'Z', (fn_t) backpage}
-    ,
-    {CONTROL | ']', metafn}
-    ,
-    {CTLX | CONTROL | 'B', listbuffers}
-    ,
-    {CTLX | CONTROL | 'C', quit}
-    ,           /* Hard quit.           */
-#if PKCODE & AEDIT
-    {CTLX | CONTROL | 'A', detab}
-    ,
-#endif
-#if PKCODE
-    {CTLX | CONTROL | 'D', filesave}
-    ,           /* alternative          */
-#else
-#if AEDIT
-    {CTLX | CONTROL | 'D', detab}
-    ,
-#endif
-#endif
-#if AEDIT
-    {CTLX | CONTROL | 'E', entab}
-    ,
-#endif
-    {CTLX | CONTROL | 'F', filefind}
-    ,
-    {CTLX | CONTROL | 'I', insfile}
-    ,
-    {CTLX | CONTROL | 'L', lowerregion}
-    ,
-    {CTLX | CONTROL | 'M', delmode}
-    ,
-    {CTLX | CONTROL | 'N', mvdnwind}
-    ,
-    {CTLX | CONTROL | 'O', deblank}
-    ,
-    {CTLX | CONTROL | 'P', mvupwind}
-    ,
-    {CTLX | CONTROL | 'R', fileread}
-    ,
-    {CTLX | CONTROL | 'S', filesave}
-    ,
-#if AEDIT
-    {CTLX | CONTROL | 'T', trim}
-    ,
-#endif
-    {CTLX | CONTROL | 'U', upperregion}
-    ,
-    {CTLX | CONTROL | 'V', viewfile}
-    ,
-    {CTLX | CONTROL | 'W', filewrite}
-    ,
-    {CTLX | CONTROL | 'X', (fn_t) swapmark}
-    ,
-    {CTLX | CONTROL | 'Z', shrinkwind}
-    ,
-    {CTLX | '?', deskey}
-    ,
-    {CTLX | '!', spawn}
-    ,
-    {CTLX | '@', pipecmd}
-    ,
-    {CTLX | '#', filter_buffer}
-    ,
-    {CTLX | '$', execprg}
-    ,
-    {CTLX | '=', showcpos}
-    ,
-    {CTLX | '(', ctlxlp}
-    ,
-    {CTLX | ')', ctlxrp}
-    ,
-    {CTLX | '^', enlargewind}
-    ,
-    {CTLX | '0', delwind}
-    ,
-    {CTLX | '1', onlywind}
-    ,
-    {CTLX | '2', splitwind}
-    ,
-    {CTLX | 'A', setvar}
-    ,
-    {CTLX | 'B', usebuffer}
-    ,
-    {CTLX | 'C', spawncli}
-    ,
-#if BSD | __hpux | SVR4
-    {CTLX | 'D', bktoshell}
-    ,
-#endif
-    {CTLX | 'E', ctlxe}
-    ,
-    {CTLX | 'F', setfillcol}
-    ,
-    {CTLX | 'K', killbuffer}
-    ,
-    {CTLX | 'M', setemode}
-    ,
-    {CTLX | 'N', filename}
-    ,
-    {CTLX | 'O', nextwind}
-    ,
-    {CTLX | 'P', prevwind}
-    ,
-#if PKCODE
-    {CTLX | 'Q', quote}
-    ,           /* alternative  */
-#endif
-#if ISRCH
-    {CTLX | 'R', risearch}
-    ,
-    {CTLX | 'S', fisearch}
-    ,
-#endif
-    {CTLX | 'W', resize}
-    ,
-    {CTLX | 'X', nextbuffer}
-    ,
-    {CTLX | 'Z', enlargewind}
-    ,
-#if WORDPRO
-    {META | CONTROL | 'C', wordcount}
-    ,
-#endif
-#if PKCODE
-    {META | CONTROL | 'D', newsize}
-    ,
-#endif
-#if PROC
-    {META | CONTROL | 'E', execproc}
-    ,
-#endif
-#if CFENCE
-    {META | CONTROL | 'F', getfence}
-    ,
-#endif
-    {META | CONTROL | 'H', delbword}
-    ,
-    {META | CONTROL | 'K', unbindkey}
-    ,
-    {META | CONTROL | 'L', reposition}
-    ,
-    {META | CONTROL | 'M', delgmode}
-    ,
-    {META | CONTROL | 'N', namebuffer}
-    ,
-    {META | CONTROL | 'R', qreplace}
-    ,
-    {META | CONTROL | 'S', newsize}
-    ,
-    {META | CONTROL | 'T', newwidth}
-    ,
-    {META | CONTROL | 'V', scrnextdw}
-    ,
-#if WORDPRO
-    {META | CONTROL | 'W', killpara}
-    ,
-#endif
-    {META | CONTROL | 'Z', scrnextup}
-    ,
-    {META | ' ', (fn_t) setmark}
-    ,
-    {META | '?', help}
-    ,
-    {META | '!', reposition}
-    ,
-    {META | '.', (fn_t) setmark}
-    ,
-    {META | '>', (fn_t) gotoeob}
-    ,
-    {META | '<', (fn_t) gotobob}
-    ,
-    {META | '~', unmark}
-    ,
-#if APROP
-    {META | 'A', apro}
-    ,
-#endif
-    {META | 'B', backword}
-    ,
-    {META | 'C', capword}
-    ,
-    {META | 'D', delfword}
-    ,
-    {META | 'F', forwword}
-    ,
-    {META | 'G', gotoline}
-    ,
-#if PKCODE
-#if WORDPRO
-    {META | 'J', justpara}
-    ,
-#endif
-#endif
-    {META | 'K', bindtokey}
-    ,
-    {META | 'L', lowerword}
-    ,
-    {META | 'M', setgmode}
-    ,
-#if WORDPRO
-    {META | 'N', gotoeop}
-    ,
-    {META | 'P', gotobop}
-    ,
-    {META | 'Q', fillpara}
-    ,
-#endif
-    {META | 'R', sreplace}
-    ,
-#if PKCODE
-    {META | 'S', forwhunt}
-    ,
-#else
-#if BSD
-    {META | 'S', bktoshell}
-    ,
-#endif
-#endif
-    {META | 'U', upperword}
-    ,
-    {META | 'V', (fn_t) backpage}
-    ,
-    {META | 'W', copyregion}
-    ,
-    {META | 'X', namedcmd}
-    ,
-    {META | 'Z', quickexit}
-    ,
-    {META | 0x7F, delbword}
-    ,
-
-#if MSDOS
-    {SPEC | CONTROL | '_', forwhunt}
-    ,
-    {SPEC | CONTROL | 'S', backhunt}
-    ,
-    {SPEC | 71, (fn_t) gotobol}
-    ,
-    {SPEC | 72, (fn_t) backline}
-    ,
-    {SPEC | 73, (fn_t) backpage}
-    ,
-    {SPEC | 75, (fn_t) backchar}
-    ,
-    {SPEC | 77, (fn_t) forwchar}
-    ,
-    {SPEC | 79, (fn_t) gotoeol}
-    ,
-    {SPEC | 80, (fn_t) forwline}
-    ,
-    {SPEC | 81, (fn_t) forwpage}
-    ,
-    {SPEC | 82, insspace}
-    ,
-    {SPEC | 83, forwdel}
-    ,
-    {SPEC | 115, backword}
-    ,
-    {SPEC | 116, forwword}
-    ,
-#if WORDPRO
-    {SPEC | 132, gotobop}
-    ,
-    {SPEC | 118, gotoeop}
-    ,
-#endif
-    {SPEC | 84, cbuf1}
-    ,
-    {SPEC | 85, cbuf2}
-    ,
-    {SPEC | 86, cbuf3}
-    ,
-    {SPEC | 87, cbuf4}
-    ,
-    {SPEC | 88, cbuf5}
-    ,
-    {SPEC | 89, cbuf6}
-    ,
-    {SPEC | 90, cbuf7}
-    ,
-    {SPEC | 91, cbuf8}
-    ,
-    {SPEC | 92, cbuf9}
-    ,
-    {SPEC | 93, cbuf10}
-    ,
-#if PKCODE
-    {SPEC | 117, (fn_t) gotoeob}
-    ,
-    {SPEC | 119, (fn_t) gotobob}
-    ,
-    {SPEC | 141, gotobop}
-    ,
-    {SPEC | 145, gotoeop}
-    ,
-    {SPEC | 146, yank}
-    ,
-    {SPEC | 147, killregion}
-    ,
-#endif
-#endif
-
-#if VT220
-    {SPEC | '1', (fn_t) gotobob /* fisearch */}
-    ,           /* VT220 keys   */
-    {SPEC | '2', yank}
-    ,
-    {SPEC | '3', forwdel /* killregion */}
-    ,
-    {SPEC | '4', (fn_t) gotoeob /* setmark */}
-    ,
-    {SPEC | '5', (fn_t) backpage}
-    ,
-    {SPEC | '6', (fn_t) forwpage}
-    ,
-    {SPEC | 'A', (fn_t) backline}
-    ,
-    {SPEC | 'B', (fn_t) forwline}
-    ,
-    {SPEC | 'C', (fn_t) forwchar}
-    ,
-    {SPEC | 'D', (fn_t) backchar}
-    ,
-    {SPEC | 'c', metafn}
-    ,
-    {SPEC | 'd', (fn_t) backchar}
-    ,
-    {SPEC | 'e', (fn_t) forwline}
-    ,
-    {SPEC | 'f', (fn_t) gotobob}
-    ,
-    {SPEC | 'h', help}
-    ,
-    {SPEC | 'i', cex}
-    ,
-#endif
-
-    {0x7F, backdel}
-    ,
-
-    /* special internal bindings */
-    { SPEC | META | 'W', wrapword },    /* called on word wrap */
-    { SPEC | META | 'C', nullproc },    /*  every command input */
-    { SPEC | META | 'R', nullproc },    /*  on file read */
-    { SPEC | META | 'X', nullproc },    /*  on window change P.K. */
-
-    {0, NULL}
-};

ebind.h

@@ -1,9 +0,0 @@
-/* Structure for the table of initial key bindings. */
-struct key_tab {
-	unsigned k_code ;			 /* Key code */
-	int (*k_fp)( int, int) ;	 /* Routine to handle it */
-} ;
-
-#define	NBINDS	256			/* max # of bound keys          */
-extern struct key_tab keytab[ NBINDS] ;	/* key bind to functions table  */
-

emacs.hlp

@@ -1,4 +1,4 @@
-=>                      uEmacs/PK 4.0 HELP INDEX
+=>                         µEMACS 4.2 HELP INDEX
 .. The very basics
 .. Cursor movement
 .. File commands
@@ -19,7 +19,7 @@
 -------------------------------------------------------------------------------
 =>                      THE VERY BASICS
 Notations: ^X means <Ctrl> and X. The <Meta> key is <Esc> on most systems.
-Exiting:   ^G aborts almost any operation. ^X ^C will get you out of uEmacs.
+Exiting:   ^G aborts almost any operation. ^X ^C will get you out of µEMACS.
 
 A BUFFER is a named area containing a FILE being edited. Many buffers may
 be active at once. Many WINDOWS may be active at once on the screen. All
@@ -37,7 +37,7 @@ Beginning of file ..... Meta  <         End of file ........... Meta  >
 -------------------------------------------------------------------------------
 =>                      FILE COMMANDS
 Find file .............   ^X ^F         Quick exit ............ Meta  Z
-View file .............   ^X ^V         Exit emacs ............   ^X ^C
+View file .............   ^X ^V         Exit µEMACS ...........   ^X ^C
 Insert file ...........   ^X ^I
 Change file name ......   ^X  N         Filter buffer .........   ^X  #
 Save file .............   ^X ^D
@@ -111,19 +111,19 @@ Pipe command ..........   ^X  @         Execute buffer ........ not bound
 Search forward ........ Meta  S     ::  End string with Meta.
 Incremental search ....   ^X  S     ::  Search next ^X, stop Meta, cancel ^G.
 Search reverse ........      ^R  
-Reverse incremental search              Hunt forward ..........  Alt-S
+Reverse incremental                     Hunt forward ..........  Alt-S
-.......................   ^X  R         Hunt backward .........  Alt-R
+                 search   ^X  R         Hunt backward .........  Alt-R
 Replace string ........ Meta  R
 Query replace string .. Meta ^R     ::  Yes/no Y/N, replace rest !, cancel ^G.
 -------------------------------------------------------------------------------
 =>                      ACCESSING THE OPERATING SYSTEM
 Quick exit ............ Meta  Z     ::  Write out all changed buffers and exit.
-Exit emacs ............   ^X ^C     ::  Exit without automatic save.
+Exit µEMACS ...........   ^X ^C     ::  Exit without automatic save.
 I shell ...............   ^X  C     ::  Start a new command processor.
 Shell command .........   ^X  !     ::  Execute one operating system command.
-Pipe command ..........   ^X  @     ::  Pipe command results to a new buffer. *
+Pipe command ..........   ^X  @     ::  Pipe command results to a new buffer.
-Filter buffer .........   ^X  #     ::  Filter buffer through a program.      *
+Filter buffer .........   ^X  #     ::  Filter buffer through a program.
-Execute program .......   ^X  $     ::  * Not under VMS.
+Execute program .......   ^X  $     ::
 -------------------------------------------------------------------------------
 =>                      MACRO COMMANDS
 Begin macro ...........   ^X  (
@@ -140,7 +140,7 @@ Clear and redraw ......      ^L         Exchange point and mark   ^X ^X
 Redraw display ........ Meta ^L
 Execute named command . Meta  X         Insert string ......... not bound  
 Execute command line .. not bound       Overwrite string ...... not bound
-Set encryption key .... Meta  E         Wrap word ............. not bound
+                                        Wrap word ............. not bound
 Count words ........... Meta ^C         Update screen ......... not bound
 -------------------------------------------------------------------------------
 =>                      SYSTEM VARIABLES
@@ -164,9 +164,9 @@ Page overlap .......... $overlap    ::  # lines, default 0, 0 = 1/3 page
 =>                      FILE NAME COMPLETION
 
 File name completion can be used with all file commands (find-file,
-view-file, ...) but it works only under UNIX and MS-DOS. It is invoked
+view-file, ...).  It is invoked by a <Space> or <Tab>.  If there exist more
-by a <Space> or <Tab>. If there exist more than one possible completions
+than one possible completions they are displayed one by one.  If the file
-they are displayed one by one. If the file name contains wild card
+name contains wild card characters, the name is expanded instead of simple
-characters, the name is expanded instead of simple completion. Special
+completion.  Special characters can be entered verbatim by prefixing them
-characters can be entered verbatim by prefixing them with ^V (or ^Q).
+with ^V (or ^Q).
 -------------------------------------------------------------------------------

emacs.rc

@@ -1,109 +1,51 @@
-;	EMACS.RC / .emascrc
+;	.emacsrc -- Startup file for µEMACS 4.2
 ;
-;	Startup file for MicroEMACS 3.9 and uEmacs/PK 4.0
 ;	This file is executed every time the editor is entered.
-;
-;	Modified by Petri Kutvonen, last edited September 1991.
 
-set $discmd "FALSE"
+set $discmd FALSE
+!if &not &seq $progname µEMACS
+; uemacs/PK and MicroEMACS
+	set $discmd TRUE
+	!return
+!endif
 
-;	First, try to resolve if we are on a PC ... yes, this is a kludge
+set $tab 4
+# set $viewtab TRUE	# uncomment this line if you need to visualize tabs
+set $fillcol 76
 
-!if &seq $sres "NORMAL"
+
-	set %system "OTHER"
+##	Help facility
+!if &seq $TERM cygwin
+	set $scroll FALSE
+	set %F1		FNP		#currently not readable
+	set %Home	FN1
+	set %End	FN4
 !else
-	set %system "PC"
+	set %F1		FNP
+	set %Home	FNH
+	set %End	FNF
 !endif
 
-!if &seq %system "PC"
+!store 40
-
+	set $discmd FALSE
-;	PC specific initialization
-
-write-message "(Setting up)"
-
-;	Comment out or change this line if you want more than 25 lines,
-;	other possible $sres values include EGA and VGA
-
-set $sres "CGA"
-
-;	Uncomment next line if your old screen "snows"
-
-;set $flicker "TRUE"
-
-;	If your screen "snows" you'll not like scrolling
-
-!if &seq $flicker "TRUE"
-	set $scroll "FALSE"
-!endif
-
-;	Function keys (unshifted)
-;	f1  f2  f3  f4  f5  f6  f7  f8  f9  f10
-;	FN; FN< FN= FN> FN? FN@ FNA FNB FNC FND
-
-bind-to-key help			FN;	
-bind-to-key exit-emacs			FND
-
-;	Function keys (shifted)
-;	F1  F2  F3  F4  F5  F6  F7  F8  F9  F10
-;	FNT FNU FNV FNW FNX FNY FNZ FN[ FN\ FN]
-
-;	Other special keys (unshifted)
-;	Home End  Ins  Del  PgUp PgDn  
-;	FNG  FNO  FNR  FNS  FNI  FNQ
-
-;       Some common Alt-keys
-;	Alt-X Alt-Z Alt-C Alt-F Alt-O
-;	FN-   FN,   FN.   FN!   FN^X
-
-bind-to-key exit-emacs			FN-
-bind-to-key quick-exit			FN,
-bind-to-key i-shell			FN.
-bind-to-key find-file			FN!
-bind-to-key view-file			FN/
-bind-to-key next-window			FN^X
-
-;	Set screen colors
-
-;	You can define a DOS environment variable EMACS_BW (any value)
-;	if you don't like colors, e.g. if you have a LCD screen
-
-!if &seq &env "EMACS_BW" ""
-	add-global-mode "blue"
-	add-global-mode "HIGH"
-!endif
-
-!endif
-
-;	Help facility
-
-40 	store-macro
-	set $discmd "FALSE"
 	!if &not &seq $cbufname "emacs.hlp"
 		write-message "(Loading Help)"
 		!force help
-		!force 8 resize-window
+		!if &not &seq $cbufname "emacs.hlp"
-		!if &seq %system "PC"
+			write-message "(Failed to load Help)"
-			!if &seq &env "EMACS_BW" ""
-				add-mode "red"
-			!endif
-			bind-to-key execute-macro-38 FNI
-			bind-to-key execute-macro-37 FNQ
 		!else
-			bind-to-key execute-macro-38 FN5
+			!force 8 resize-window
-			bind-to-key execute-macro-37 FN6
+			bind-to-key execute-macro-39 FN5
+			bind-to-key execute-macro-38 FN6
+			bind-to-key execute-macro-37 %Home
+			bind-to-key execute-macro-36 %End
+			beginning-of-line
+			2 forward-character
+			1 redraw-display
+			set %hlpupdn "[PgUp] / [PgDn]"
+			set %hlphelp "[F1]"
+			run helponhelp
 		!endif
-		beginning-of-line
-		2 forward-character
-		1 redraw-display
-		save-window
-		!if &seq %system "PC"
-			set %hlpupdn "<PgUp> / <PgDn>"
-			set %hlphelp "<F1>"
-		!else
-			set %hlpupdn "<Prev Scrn> / <Next Scrn>"
-			set %hlphelp "<Help>"
-		!endif
-		execute-macro-39
 	!else
 		set %hlpcode &lef $line 2 
 		!if &seq %hlpcode ".."
@@ -113,33 +55,29 @@ bind-to-key next-window			FN^X
 			beginning-of-line
 			2 forward-character
 			1 redraw-display
-			execute-macro-39
+			run helponhelp
 		!else
-			!if &seq %system "PC"
+			!force search-reverse "=>"
-				bind-to-key previous-page FNI
+			bind-to-key previous-page FN5
-				bind-to-key next-page FNQ
+			bind-to-key next-page FN6
-			!else
+			bind-to-key beginning-of-file %Home
-				bind-to-key previous-page FN5
+			bind-to-key end-of-file %End
-				bind-to-key next-page FN6
-			!endif
-			!force restore-window
 			!force delete-window
 			clear-message-line
 		!endif
 	!endif
-	set $discmd "TRUE"
+	set $discmd TRUE
 !endm
 
 bind-to-key execute-macro-40 M-?
-!if &seq %system "PC"
+bind-to-key execute-macro-40 %F1
-	bind-to-key execute-macro-40 FN;
+bind-to-key execute-macro-40 M-O
-!else
+bind-to-key beginning-of-file %Home
-	bind-to-key execute-macro-40 FNh
+bind-to-key end-of-file %End
-!endif
 
-;	Help on Help
 
-39	store-macro
+##	Help on Help
+!store helponhelp
 	!if &seq &rig $line 5 "INDEX"
 		write-message &cat "Select topic from list and press " %hlphelp
 	!else
@@ -147,148 +85,72 @@ bind-to-key execute-macro-40 M-?
 	!endif
 !endm
 
-;	Previous help page
 
-38 	store-macro
+##	Previous help page
+!store 39
 	!if &seq $cbufname "emacs.hlp"
 		beginning-of-line
 		!force search-reverse "=>"
 		2 forward-character
 		1 redraw-display
-		execute-macro-39
+		run helponhelp
 	!else
 		previous-page
 	!endif
 !endm
 
-;	Next help page
 
-37 	store-macro
+##	Next help page
+!store 38
 	!if &seq $cbufname "emacs.hlp"
 		beginning-of-line
 		2 forward-character
 		!force search-forward "=>"
 		1 redraw-display
-		execute-macro-39
+		run helponhelp
 	!else
 		next-page
 	!endif
 !endm
 
-;	Set up auto CMODE
+!store 37
+	beginning-of-file
+	!if &seq $cbufname "emacs.hlp"
+		execute-macro-39
+	!endif
+!endm
 
-36	store-macro
+!store 36
-	!if &seq &mid $cfname 1 7 "/tmp/Re"
+	end-of-file
-		add-mode "wrap"
+	!if &seq $cbufname "emacs.hlp"
-		!return
+		execute-macro-39
-	!endif
-	!if &gre &sin $cfname "/.ed" 0
-		add-mode "wrap"
-		!return
-	!endif
-	!if &gre &sin $cfname "/.let" 0
-		add-mode "wrap"
-		!return
-	!endif
-	!if &gre &sin $cfname "/.art" 0
-		add-mode "wrap"
-		!return
-	!endif
-	!if &gre &sin $cfname "/nn." 0
-		add-mode "wrap"
-		!return
-	!endif
-	set %rctmp &sin $cfname "."
-	!if &equ %rctmp 0
-		!return
-	!endif
-	set %rctmp &mid $cfname &add %rctmp 1 5
-	!if &or &seq %rctmp "c" &seq %rctmp "h"
-		add-mode "cmode"
-	!endif
-	!if &or &seq %rctmp "txt" &or &seq %rctmp "doc" &or &seq %rctmp "tmp" &seq %rctmp "tex"
-		add-mode "wrap"
 	!endif
+!endm
 
+
+##	Set up auto CMODE or WRAP
+!store 35
+	set %rctmp &right $cfname 4
+	!if &or &seq .txt %rctmp &seq .doc %rctmp
+		add-mode wrap
+		!return
+	!endif
+	set %rctmp &right %rctmp 2
+	!if &or &seq .c %rctmp &seq .h %rctmp
+		add-mode cmode
+		!return
+	!endif
 !endm
 	
-bind-to-key execute-macro-36	M-FNR
+bind-to-key execute-macro-35	M-FNR
 
-;	Setup for ASCII {|}[\] to ISO Latin-1 translation
-
-21	store-macro
-	insert-string "ä"
-!endm
-22	store-macro
-	insert-string "ö"
-!endm
-23	store-macro
-	insert-string "å"
-!endm
-24	store-macro
-	insert-string "Ä"
-!endm
-25	store-macro
-	insert-string "Ö"
-!endm
-26	store-macro
-	insert-string "Å"
-!endm
-
-27	store-macro
-	bind-to-key execute-macro-21 {
-	bind-to-key execute-macro-22 |
-	bind-to-key execute-macro-23 }
-	bind-to-key execute-macro-24 [
-	bind-to-key execute-macro-25 \
-	bind-to-key execute-macro-26 ]
-	write-message "ISO Latin-1 äöåÄÖÅ"
-!endm
-
-28	store-macro
-	unbind-key {
-	unbind-key |
-	unbind-key }
-	unbind-key [
-	unbind-key \
-	unbind-key ]
-	write-message "ASCII {|}[\]"
-!endm
-
-bind-to-key execute-macro-27 ^X[
-bind-to-key execute-macro-28 ^X]
-
-;	Make cut-paste easier in window systems
 
+##	Make cut-paste easier in window systems
 bind-to-key	newline	^J
 
-;	uEmacs/PK specific initialization
 
-!if &seq $progname "uEmacs/PK"
+!if &or &sin $LANG "UTF-8" &sin $LANG "utf8"
-
-;	Don't scroll on a Sun
-
-	!if &or &seq $TERM "sun" &seq $TERM "sun-cmd"
-		set $scroll "FALSE"
-	!endif
-
-;	Execute local initialization files
-
-	!if &seq %system "PC"
-		!force execute-file "EM.RC"
-	!else
-		!force execute-file &cat $HOME "/.emrc"
-		!force execute-file ".emrc"
-	!endif
-!endif
-
-!if &gre &sin $LANG "UTF-8" 0
 	add-global-mode "utf-8"
 !endif
 
-!if &gre &sin $LANG "utf8" 0
+set $discmd TRUE
-	add-global-mode "utf-8"
-!endif
-add-global-mode "utf-8"
-
-set $discmd "TRUE"

estruct.h

@@ -1,291 +0,0 @@
-#ifndef _ESTRUCT_H_
-#define _ESTRUCT_H_
-
-/*      ESTRUCT.H
- *
- *      Structure and preprocessor defines
- *
- *	written by Dave G. Conroy
- *	modified by Steve Wilhite, George Jones
- *      substantially modified by Daniel Lawrence
- *	modified by Petri Kutvonen
- */
-
-
-#ifdef	MSDOS
-#undef	MSDOS
-#endif
-#ifdef	EGA
-#undef	EGA
-#endif
-
-/* Machine/OS definitions. */
-
-#if defined(AUTOCONF) || defined(MSDOS) || defined(BSD) || defined(SYSV) || defined(VMS)
-
-/* Make an intelligent guess about the target system. */
-
-#if defined(__TURBOC__)
-#define MSDOS 1 /* MS/PC DOS 3.1-4.0 with Turbo C 2.0 */
-#else
-#define	MSDOS 0
-#endif
-
-#if defined(BSD) || defined(sun) || defined(ultrix) || (defined(vax) && defined(unix)) || defined(ultrix) || defined(__osf__)
-#ifndef BSD
-#define BSD 1 /* Berkeley UNIX */
-#endif
-#else
-#define	BSD 0
-#endif
-
-#if defined(SVR4) || defined(__linux__)	/* ex. SunOS 5.3 */
-#define SVR4 1
-#define SYSV 1
-#undef BSD
-#endif
-
-#if defined(SYSV) || defined(u3b2) || defined(_AIX) || (defined(i386) && defined(unix)) || defined(__hpux) || defined( __unix__)
-#define	USG 1 /* System V UNIX */
-#else
-#define	USG 0
-#endif
-
-#if defined(VMS) || (defined(vax) && ! defined(unix))
-#define VMS 1 /* VAX/VMS */
-#else
-#define VMS 0
-#endif
-
-#define	V7 0 /* No more. */
-
-#else
-
-#define MSDOS   1		/* MS-DOS                       */
-#define V7      0		/* V7 UNIX or Coherent or BSD4.2 */
-#define	BSD	0		/* UNIX BSD 4.2 and ULTRIX      */
-#define	USG	0		/* UNIX system V                */
-#define VMS     0		/* VAX/VMS                      */
-
-#endif				/*autoconf */
-
-#ifndef	AUTOCONF
-
-/*	Compiler definitions			*/
-#define	UNIX	0		/* a random UNIX compiler */
-#define	MSC	0		/* MicroSoft C compiler, versions 3 up */
-#define	TURBO	1		/* Turbo C/MSDOS */
-
-#else
-
-#define	UNIX	(V7 | BSD | USG)
-#define	MSC	0
-#define	TURBO	MSDOS
-
-#endif				/*autoconf */
-
-/*	Debugging options	*/
-
-#define	RAMSIZE	0		/* dynamic RAM memory usage tracking */
-#if RAMSIZE
-#define	RAMSHOW	1		/* auto dynamic RAM reporting */
-#endif
-
-#ifndef	AUTOCONF
-
-/*   Special keyboard definitions            */
-
-#define VT220	0		/* Use keypad escapes P.K.      */
-#define VT100   0		/* Handle VT100 style keypad.   */
-
-/*	Terminal Output definitions		*/
-
-#define ANSI    0		/* ANSI escape sequences        */
-#define	VMSVT	0		/* various VMS terminal entries */
-#define VT52    0		/* VT52 terminal (Zenith).      */
-#define TERMCAP 0		/* Use TERMCAP                  */
-#define	IBMPC	1		/* IBM-PC CGA/MONO/EGA driver   */
-
-#elif defined( MINGW32)
-
-#define	VT220	(UNIX | VMS)
-#define	VT100	0
-
-#define	ANSI	0
-#define	VMSVT	0
-#define	VT52	0
-#define	TERMCAP	0
-#define	IBMPC	0
-
-#else
-
-#define	VT220	(UNIX | VMS)
-#define	VT100	0
-
-#define	ANSI	0
-#define	VMSVT	VMS
-#define	VT52	0
-#define	TERMCAP	UNIX
-#define	IBMPC	MSDOS
-
-#endif /* Autoconf. */
-
-/*	Configuration options	*/
-
-#define	CFENCE	1  /* fench matching in CMODE                      */
-#define	VISMAC	0  /* update display during keyboard macros        */
-
-#ifndef	AUTOCONF
-
-#define	COLOR	1  /* color commands and windows                   */
-#define	FILOCK	0  /* file locking under unix BSD 4.2              */
-
-#else
-
-#define	COLOR	MSDOS
-#ifdef  SVR4
-#define FILOCK  1
-#else
-#define	FILOCK	BSD
-#endif
-
-#endif /* Autoconf. */
-
-#define	CLEAN	0  /* de-alloc memory on exit                      */
-
-#define ASCII	1  /* always using ASCII char sequences for now    */
-#define EBCDIC	0  /* later IBM mainfraim versions will use EBCDIC */
-
-#ifndef	AUTOCONF
-
-#define	XONXOFF	0  /* don't disable XON-XOFF flow control P.K.     */
-#define	NATIONL	0  /* interprete [,],\,{,},| as characters P.K.    */
-
-#else
-
-#define	XONXOFF	(UNIX | VMS)
-#define	NATIONL	(UNIX | VMS)
-
-#endif /* Autoconf. */
-
-#define	PKCODE	1      /* include my extensions P.K., define always    */
-#define	IBMCHR	MSDOS  /* use IBM PC character set P.K.                */
-#define SCROLLCODE 1   /* scrolling code P.K.                          */
-
-/* System dependant library redefinitions, structures and includes. */
-
-#if TURBO
-#include <dos.h>
-#include <mem.h>
-#undef peek
-#undef poke
-#define       peek(a,b,c,d)   movedata(a,b,FP_SEG(c),FP_OFF(c),d)
-#define       poke(a,b,c,d)   movedata(FP_SEG(c),FP_OFF(c),a,b,d)
-#endif
-
-#if MSDOS & MSC
-#include	<dos.h>
-#include	<memory.h>
-#define	peek(a,b,c,d)	movedata(a,b,FP_SEG(c),FP_OFF(c),d)
-#define	poke(a,b,c,d)	movedata(FP_SEG(c),FP_OFF(c),a,b,d)
-#define	movmem(a, b, c)		memcpy(b, a, c)
-#endif
-
-#if	VMS
-#define	unlink(a)	delete(a)
-#endif
-
-/* Define some ability flags. */
-
-#if	IBMPC
-#define	MEMMAP	1
-#else
-#define	MEMMAP	0
-#endif
-
-#if	MSDOS | V7 | USG | BSD
-#define	ENVFUNC	1
-#else
-#define	ENVFUNC	0
-#endif
-
-/* DIFCASE represents the integer difference between upper
-   and lower case letters.  It is an xor-able value, which is
-   fortunate, since the relative positions of upper to lower
-   case letters is the opposite of ascii in ebcdic.
-*/
-
-#ifdef	islower
-#undef	islower
-#endif
-
-#if	PKCODE
-#ifdef	isupper
-#undef	isupper
-#endif
-#endif
-
-#if	ASCII
-
-#define	DIFCASE		0x20
-
-#if	NATIONL
-#define LASTUL ']'
-#define LASTLL '}'
-#else
-#define LASTUL 'Z'
-#define LASTLL 'z'
-#endif
-
-#if	IBMCHR
-
-#define isletter(c)	(('a' <= c && LASTLL >= c) || ('A' <= c && LASTUL >= c) || (128<=c && c<=167))
-#define islower(c)	(('a' <= c && LASTLL >= c))
-#define isupper(c)	(('A' <= c && LASTUL >= c))
-
-#else
-
-#define isletter(c)	__isxletter((0xFF & (c)))
-#define islower(c)	isxlower((0xFF & (c)))
-#define isupper(c)	isxupper((0xFF & (c)))
-
-#define __isxletter(c)	(('a' <= c && LASTLL >= c) || ('A' <= c && LASTUL >= c) || (192<=c /* && c<=255 */))
-#define isxlower(c)	(('a' <= c && LASTLL >= c) || (224 <= c && 252 >= c))
-#define isxupper(c)	(('A' <= c && LASTUL >= c) || (192 <= c && 220 >= c))
-
-#endif
-
-#endif
-
-#if	EBCDIC
-
-#define	DIFCASE		0x40
-#define isletter(c)	(('a' <= c && 'i' >= c) || ('j' <= c && 'r' >= c) || ('s' <= c && 'z' >= c) || ('A' <= c && 'I' >= c) || ('J' <= c && 'R' >= c) || ('S' <= c && 'Z' >= c))
-#define islower(c)	(('a' <= c && 'i' >= c) || ('j' <= c && 'r' >= c) || ('s' <= c && 'z' >= c))
-#if	PKCODE
-#define isupper(c)	(('A' <= c && 'I' >= c) || ('J' <= c && 'R' >= c) || ('S' <= c && 'Z' >= c))
-#endif
-
-#endif
-
-/*	Dynamic RAM tracking and reporting redefinitions	*/
-
-#if	RAMSIZE
-#include <stdlib.h>
-void *allocate( size_t size) ;
-void release( void *ptr) ;
-#define	malloc	allocate
-#define	free	release
-#endif
-
-/*	De-allocate memory always on exit (if the operating system or
-	main program can not
-*/
-
-#if	CLEAN
-#define	exit(a)	cexit(a)
-
-void cexit( int status) ;
-#endif
-
-#endif

eval.h

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

exec.h

@@ -1,70 +1,64 @@
+/* exec.h -- bindable functions to execute functions, macros and procedures */
 #ifndef _EXEC_H_
 #define _EXEC_H_
 
-#include "retcode.h"
+#include "names.h"
 
+extern boolean clexec ; /* command line execution flag  */
 
-#define	PROC	1	/* named procedures  */
+int dofile( const char *fname) ;
-
-#if PROC
-int storeproc( int f, int n) ;
-int execproc( int f, int n) ;
-#endif
-
-
-extern boolean clexec ;	/* command line execution flag  */
-
-
-void ue_system( const char *cmd) ;
-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) ;
+BBINDABLE( 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 */

execute.c

@@ -3,16 +3,16 @@
 
 #define	CLRMSG	0  /* space clears the message line with no insert */
 
+#include <assert.h>
 #include <stdlib.h>
 #include <unistd.h>
 
-#include "estruct.h"
+#include "defines.h"
-#include "bind.h"
-#include "random.h"
 #include "display.h"
 #include "file.h"
 #include "input.h"
 #include "mlout.h"
+#include "random.h"
 #include "search.h"
 #include "terminal.h"
 #include "window.h"
@@ -55,10 +55,7 @@ static int inspound( int n) {
 static int insbrace( int n, int c) {
 	int ch ;			/* last character before input */
 	int oc ;			/* caractere oppose a c */
-	int i, count ;
 	int target ;		/* column brace should go after */
-	struct line *oldlp ;
-	int oldoff ;
 
 /* if not called with {, acts as insertion */
 	if( c == '}')
@@ -67,18 +64,19 @@ static int insbrace( int n, int c) {
 		return linsert( n, c) ;
 
 /* scan to see if all preceding spaces are white spaces, if not, insert */
-	for( i = curwp->w_doto - 1 ; i >= 0 ; --i) {
+	for( int i = curwp->w_doto - 1 ; i >= 0 ; --i) {
 		ch = lgetc( curwp->w_dotp, i) ;
 		if( ch != ' ' && ch != '\t')
 			return linsert( n, c) ;
 	}
 
-	oldlp = curwp->w_dotp ;
+/* save the original cursor position */
-	oldoff = curwp->w_doto ;
+	line_p oldlp = curwp->w_dotp ;
+	int oldoff = curwp->w_doto ;
 
-	count = 1 ;
+	int count = 1 ;
 	do {
-		if( boundry( curwp->w_dotp, curwp->w_doto, REVERSE)) {
+		if( boundary( curwp->w_dotp, curwp->w_doto, REVERSE)) {
 		/* at beginning of buffer, no match to be found */
 			curwp->w_dotp = oldlp ;
 			curwp->w_doto = oldoff ;
@@ -132,10 +130,6 @@ static int insbrace( int n, int c) {
  * char ch;			fence type to match against
  */
 static void fmatch( int ch) {
-	struct line *oldlp ;	/* original line pointer */
-	int oldoff ;			/* and offset */
-	struct line *toplp ;	/* top line in current window */
-	int count ;				/* current fence level count */
 	int opench ;			/* open fence */
 
 	/* $tpause <= 0 disable fmatch */
@@ -146,8 +140,8 @@ static void fmatch( int ch) {
 	update( FALSE) ;
 
 	/* save the original cursor position */
-	oldlp = curwp->w_dotp ;
+	line_p oldlp = curwp->w_dotp ;
-	oldoff = curwp->w_doto ;
+	int oldoff = curwp->w_doto ;
 
 	/* setup proper open fence for passed close fence */
 	if( ch == ')')
@@ -158,15 +152,15 @@ static void fmatch( int ch) {
 		opench = '[' ;
 
 	/* find the top line and set up for scan */
-	toplp = curwp->w_linep->l_bp ;
+	line_p toplp = curwp->w_linep->l_bp ;
 	backchar( FALSE, 1) ;	/* . was after the }, move back */
 
 	/* scan back until we find it, or reach past the top of the window */
-	count = 1 ;
+	int count = 1 ;				/* current fence level count */
 	do {
 		/* At beginning of window or buffer, no match to be found */
 		if( curwp->w_dotp == toplp
-		||	boundry( curwp->w_dotp, curwp->w_doto, REVERSE))
+		||	boundary( curwp->w_dotp, curwp->w_doto, REVERSE))
 			break ;
 
 		backchar( FALSE, 1) ;
@@ -202,21 +196,114 @@ static void fmatch( int ch) {
 #endif
 
 
+#if	CFENCE
+/*
+ * the cursor is moved to a matching fence
+ *
+ * int f, n;		not used
+ */
+BINDABLE( getfence) {
+	int sdir;	/* direction of search (1/-1) */
+	char ch;	/* fence type to match against */
+	char ofence;	/* open fence */
+	char c;	/* current character in scan */
+
+	/* save the original cursor position */
+	line_p oldlp = curwp->w_dotp ;
+	int oldoff = curwp->w_doto ;
+
+	/* get the current character */
+	if (oldoff == llength(oldlp))
+		ch = '\n';
+	else
+		ch = lgetc(oldlp, oldoff);
+
+	/* setup proper matching fence */
+	switch (ch) {
+	case '(':
+		ofence = ')';
+		sdir = FORWARD;
+		break;
+	case '{':
+		ofence = '}';
+		sdir = FORWARD;
+		break;
+	case '[':
+		ofence = ']';
+		sdir = FORWARD;
+		break;
+	case ')':
+		ofence = '(';
+		sdir = REVERSE;
+		break;
+	case '}':
+		ofence = '{';
+		sdir = REVERSE;
+		break;
+	case ']':
+		ofence = '[';
+		sdir = REVERSE;
+		break;
+	default:
+		TTbeep();
+		return FALSE;
+	}
+
+	/* scan until we find a match, or reach the end of file */
+	int count = 1 ;	/* current fence level count */
+	do {
+		if( boundary( curwp->w_dotp, curwp->w_doto, sdir)) {
+		/* at buffer limit, no match to be found */
+			/* restore the current position */
+			curwp->w_dotp = oldlp ;
+			curwp->w_doto = oldoff ;
+			TTbeep() ;
+			return FALSE ;
+		}
+
+		if( sdir == FORWARD)
+			forwchar( FALSE, 1) ;
+		else
+			backchar( FALSE, 1) ;
+
+		/* if no eol */
+		if( curwp->w_doto != llength(curwp->w_dotp)) {
+			c = curwbyte() ;
+			if( c == ch)
+				++count ;
+			else if( c == ofence)
+				--count ;
+		}
+	} while( count > 0) ;
+
+	/* we have a match, move the sucker */
+	curwp->w_flag |= WFMOVE ;
+	return TRUE ;
+}
+#endif
+
 /*
  * This is the general command execution routine. It handles the fake binding
  * of all the keys to "self-insert". It also clears out the "thisflag" word,
  * and arranges to move it to the "lastflag", so that the next command can
  * look at it. Return the status of command.
  */
-int execute( int c, int f, int n) {
+int execute( unsigned c, int f, int n) {
 	int status ;
-	fn_t execfunc ;
 
 /* if the keystroke is a bound function...do it */
-	execfunc = getbind( c) ;
+	kbind_p ktp = getkeybinding( c) ;
-	if( execfunc != NULL) {
+	if( ktp->k_code != 0) {
 		thisflag = 0 ;
-		status = execfunc( f, n) ;
+		assert( ktp->k_nbp != NULL) ;
+		char tag = bind_tag( ktp->k_nbp) ;
+		if( (tag & 1) && (curbp->b_mode & MDVIEW))
+			status = rdonly() ;
+		else {
+			fnp_t execfunc = ktp->k_nbp->n_func ;
+			status = execfunc( f, n) ;
+		}
+
 		lastflag = thisflag ;
 		return status ;
 	}
@@ -285,6 +372,8 @@ int execute( int c, int f, int n) {
 
 			break ;
 		}
+
+		/* fallthrough */
 	default:
 		status = linsert( n, c) ;
 	}
@@ -328,11 +417,12 @@ void kbd_loop( void) {
 		newc = getcmd() ;
 		update( FALSE) ;
 		do {
-			fn_t execfunc ;
+			kbind_p ktp ;
+			fnp_t execfunc ;
 
 			if( c == newc
-			&& (execfunc = getbind( c)) != NULL
+			&& (ktp = getkeybinding( c))->k_code == c
-			&& execfunc != insert_newline
+			&& (execfunc = ktp->k_nbp->k_func) != insert_newline
 			&& execfunc != insert_tab)
 				newc = getcmd() ;
 			else

execute.h

@@ -1,5 +1,19 @@
-extern int gasave ;		/* global ASAVE size            */
+/* execute.h -- */
-extern int gacount ;		/* count until next ASAVE       */
+#ifndef _EXECUTE_H_
+#define _EXECUTE_H_
 
-int execute( int c, int f, int n) ;
+#include "names.h"      /* BINDABLE() */
+
+extern int gasave ;     /* global ASAVE size            */
+extern int gacount ;    /* count until next ASAVE       */
+
+int execute( unsigned keycode, int f, int n) ;
 void kbd_loop( void) ;
+
+#define CFENCE  1       /* fence matching in CMODE */
+#if CFENCE
+  BINDABLE( getfence) ;
+#endif
+
+#endif
+/* end of execute.h */

file.h

@@ -1,23 +1,27 @@
+/* file.h -- file centric commands */
 #ifndef _FILE_H_
 #define _FILE_H_
 
-#include "buffer.h"
+#include "buffer.h" /* bname_t */
-#include "retcode.h"
+#include "names.h"  /* BINDABLE() */
 
-extern boolean restflag ;		/* restricted use?              */
+extern boolean restflag ;       /* restricted use?              */
-boolean resterr( void) ;		/* restricted error message		*/
+boolean resterr( void) ;        /* restricted error message     */
+
+/* Bindable functions */
+BINDABLE( filefind) ;
+BINDABLE( fileread) ;
+BINDABLE( filename) ;
+BINDABLE( filesave) ;
+BINDABLE( filewrite) ;
+BINDABLE( insfile) ;
+BINDABLE( viewfile) ;
 
-int fileread( int f, int n) ;
-int insfile( int f, int n) ;
-int filefind( int f, int n) ;
-int viewfile( int f, int n) ;
 int getfile( const char *fname, boolean lockfl) ;
 int readin( const char *fname, boolean lockfl) ;
 void makename( bname_t bname, const char *fname) ;
 void unqname( char *name) ;
-int filewrite( int f, int n) ;
-int filesave( int f, int n) ;
 int writeout( const char *fn) ;
-int filename( int f, int n) ;
 
 #endif
+/* end of file.h */

fileio.c

@@ -1,18 +1,10 @@
 /* fileio.c -- implements fileio.h */
-
 #include "fileio.h"
 
-#ifdef	CTRLZ
+/* The routines in this file read and write ASCII files from the disk.  All
-#undef	CTRLZ
+   of the knowledge about files are here.
-#endif
-#define	CTRLZ	0  /* add a ^Z at end of files under MSDOS only    */
 
-/*  FILEIO.C
+   modified by Petri Kutvonen
- *
- * The routines in this file read and write ASCII files from the disk. All of
- * the knowledge about files are here.
- *
- *  modified by Petri Kutvonen
  */
 
 #include <stdio.h>
@@ -23,86 +15,62 @@
 #include "retcode.h"
 #include "utf8.h"
 
-char	*fline = NULL ;		/* dynamic return line     */
+char    *fline = NULL ;     /* dynamic return line     */
-static int	flen = 0 ;		/* current allocated length of fline */
+static int  flen = 0 ;      /* current allocated length of fline */
-int		ftype ;
+int     ftype ;
-int		fcode ;				/* encoding type FCODE_xxxxx */
+int     fcode ;             /* encoding type FCODE_xxxxx */
-int		fpayload ;			/* actual length of fline content */
+int     fpayload ;          /* actual length of fline content */
 
 
-static FILE		*ffp ;		/* File pointer, all functions. */
+static FILE     *ffp ;      /* File pointer, all functions. */
-static boolean	eofflag ;	/* end-of-file flag */
+static boolean  eofflag ;   /* end-of-file flag */
 
 
-/*
+/* Open a file for reading. */
- * Open a file for reading.
+fio_code ffropen( const char *fn) {
- */
+    eofflag = FALSE ;
-fio_code ffropen( const char *fn)
-{
-    if ((ffp = fopen(fn, "r")) == NULL)
-        return FIOFNF;
-    eofflag = FALSE;
     ftype = FTYPE_NONE ;
     fcode = FCODE_ASCII ;
-    return FIOSUC;
+    ffp = fopen( fn, "r") ;
+    return (ffp == NULL) ? FIOFNF : FIOSUC ;
 }
 
-/*
+
- * Open a file for writing. Return TRUE if all is well, and FALSE on error
+/* Open a file for writing.  Return TRUE if all is well, and FALSE on error
- * (cannot create).
+   (cannot create).
  */
-fio_code ffwopen( const char *fn)
+fio_code ffwopen( const char *fn) {
-{
+    ffp = fopen( fn, "w") ;
-#if     VMS
+    return (ffp == NULL) ? FIOERR : FIOSUC ;
-    int fd;
-
-    if ((fd = creat(fn, 0666, "rfm=var", "rat=cr")) < 0
-        || (ffp = fdopen(fd, "w")) == NULL)
-#else
-    if ((ffp = fopen(fn, "w")) == NULL)
-#endif
-        return FIOERR;
-
-    return FIOSUC;
 }
 
-/*
+
- * Close a file. Should look at the status in all systems.
+/* Close a file. Should look at the status in all systems.
  */
-fio_code ffclose(void)
+fio_code ffclose( void) {
-{
     /* free this since we do not need it anymore */
-    if (fline) {
+    if( fline) {
-        free(fline);
+        free( fline) ;
-        fline = NULL;
+        fline = NULL ;
     }
-    eofflag = FALSE;
+
+    eofflag = FALSE ;
     ftype = FTYPE_NONE ;
     fcode = FCODE_ASCII ;
 
-#if MSDOS & CTRLZ
+    return (fclose( ffp) != FALSE) ? FIOERR : FIOSUC ;
-    fputc(26, ffp);     /* add a ^Z at the end of the file */
-#endif
-
-#if     V7 | USG | BSD | (MSDOS & (MSC | TURBO))
-    if (fclose(ffp) != FALSE)
-        return FIOERR;
-#else
-    fclose(ffp);
-#endif
-    return FIOSUC;
 }
 
-/*
+
- * Write a line to the already opened file. The "buf" points to the buffer,
+/* Write a line to the already opened file.  The "buf" points to the
- * and the "nbuf" is its length, less the free newline. Return the status.
+   buffer, and the "nbuf" is its length, less the free newline.  Return the
- * Check only at the newline.
+   status.  Check only at the newline.
  */
 fio_code ffputline( char *buf, int nbuf, int dosflag) {
-	fwrite( buf, 1, nbuf, ffp) ;
+    fwrite( buf, 1, nbuf, ffp) ;
-	
+
-	if( dosflag)
+    if( dosflag)
-		fputc( '\r', ffp) ;
+        fputc( '\r', ffp) ;
 
     fputc( '\n', ffp) ;
 
@@ -112,92 +80,91 @@ fio_code ffputline( char *buf, int nbuf, int dosflag) {
     return FIOSUC ;
 }
 
-/*
+/* Read a line from a file, and store the bytes in the supplied buffer.
- * Read a line from a file, and store the bytes in the supplied buffer. The
+   The "nbuf" is the length of the buffer.  Complain about long lines and
- * "nbuf" is the length of the buffer. Complain about long lines and lines
+   lines at the end of the file that don't have a newline present.  Check
- * at the end of the file that don't have a newline present. Check for I/O
+   for I/O errors too.  Return status.
- * errors too. Return status.
  */
 fio_code ffgetline( void) {
-	int c ;		/* current character read */
+    int c ;                         /* current character read */
-	int i ;		/* current index into fline */
+    int lcode = FCODE_ASCII ;       /* line encoding, defaults to ASCII */
-	int lcode = FCODE_ASCII ;	/* line encoding, defaults to ASCII */
 
 /* if we are at the end...return it */
-	if( eofflag)
+    if( eofflag)
-		return FIOEOF ;
+        return FIOEOF ;
 
 /* dump fline if it ended up too big */
-	if( flen > NSTRING) {
+    if( flen > NSTRING) {
-		free( fline) ;
+        free( fline) ;
-		fline = NULL ;
+        fline = NULL ;
-	}
+    }
 
 /* if we don't have an fline, allocate one */
-	if( fline == NULL)
+    if( fline == NULL)
-		if( (fline = malloc( flen = NSTRING)) == NULL)
+        if( (fline = malloc( flen = NSTRING)) == NULL)
-			return FIOMEM ;
+            return FIOMEM ;
 
 /* read the line in */
-	i = 0 ;
+    int i = 0 ;                     /* current index into fline */
-	while( (c = fgetc( ffp)) != EOF && c != '\r' && c != '\n') {
+    while( (c = fgetc( ffp)) != EOF && c != '\r' && c != '\n') {
-	/* if line is full, get more room */
+    /* if line is full, get more room */
-		if( i >= flen) {
+        if( i >= flen) {
-			char *tmpline ;	/* temp storage for expanding line */
+            char *tmpline ; /* temp storage for expanding line */
 
-			tmpline = malloc( flen + NSTRING) ;
+            tmpline = malloc( flen + NSTRING) ;
-			if( tmpline == NULL)
+            if( tmpline == NULL)
-				return FIOMEM ;
+                return FIOMEM ;
 
-			memcpy( tmpline, fline, flen) ;
+            memcpy( tmpline, fline, flen) ;
-			flen += NSTRING ;
+            flen += NSTRING ;
-			free( fline) ;
+            free( fline) ;
-			fline = tmpline ;
+            fline = tmpline ;
-		}
+        }
 
-		fline[ i++] = c ;
+        fline[ i++] = c ;
-		lcode |= c ;
+        lcode |= c ;
-	}
+    }
 
-	fpayload = i ;
+    fpayload = i ;
-	lcode &= FCODE_MASK ;
+    if( lcode & 0x80                /* line contains extended chars */
-	if( lcode && (fcode != FCODE_MIXED)) {	/* line contains extended chars */
+    &&  (fcode != FCODE_MIXED)) {
-	/* Check if consistent UTF-8 encoding */
+    /* Check if consistent UTF-8 encoding */
-		int pos = 0 ;
+        lcode = FCODE_ASCII ;
+        int pos = 0 ;
+        while( (pos < i) && (lcode != FCODE_MIXED)) {
+            unicode_t uc ;
 
-		while( (pos < i) && (lcode != FCODE_MIXED)) {
+            int bytes = utf8_to_unicode( fline, pos, i, &uc) ;
-			unicode_t uc ;
+            pos += bytes ;
-			int bytes ;
+            if( bytes > 1)      /* Multi byte UTF-8 sequence */
+                lcode |= FCODE_UTF_8 ;
+            else if( uc > 127)  /* Extended ASCII */
+                lcode |= FCODE_EXTND ;
+        }
 
-			bytes = utf8_to_unicode( fline, pos, i, &uc) ;
+        fcode |= lcode ;
-			pos += bytes ;
+    }
-			if( bytes > 1)		/* Multi byte UTF-8 sequence */
-				lcode |= FCODE_UTF_8 ;
-			else if( uc > 127)	/* Extended ASCII */
-				lcode |= FCODE_EXTND ;
-		}
-
-		fcode |= lcode ;
-	}
 
 /* test for any errors that may have occured */
-	if( c == EOF) {
+    if( c == EOF) {
-		if( ferror( ffp))
+        if( ferror( ffp))
-			return FIOERR ;
+            return FIOERR ;
 
-		if( i != 0)
+        if( i != 0)
-			eofflag = TRUE ;
+            eofflag = TRUE ;
-		else
+        else
-			return FIOEOF ;
+            return FIOEOF ;
-	} else if( c == '\r') {
+    } else if( c == '\r') {
-		c = fgetc( ffp) ;
+        c = fgetc( ffp) ;
-		if( c != '\n') {
+        if( c != '\n') {
-			ftype |= FTYPE_MAC ;
+            ftype |= FTYPE_MAC ;
-			ungetc( c, ffp) ;
+            ungetc( c, ffp) ;
-		} else
+        } else
-			ftype |= FTYPE_DOS ;
+            ftype |= FTYPE_DOS ;
-	} else /* c == '\n' */
+    } else /* c == '\n' */
-		ftype |= FTYPE_UNIX ;
+        ftype |= FTYPE_UNIX ;
 
     return FIOSUC ;
 }
+
+/* end of fileio.c */

fileio.h

@@ -1,12 +1,13 @@
+/* fileio.h -- file primitives */
 #ifndef _FILEIO_H_
 #define _FILEIO_H_
 
 typedef enum {
-	FIOSUC,	/* File I/O, success.             */
+    FIOSUC, /* File I/O, success.             */
-	FIOFNF,	/* File I/O, file not found.      */
+    FIOFNF, /* File I/O, file not found.      */
-	FIOEOF,	/* File I/O, end of file.         */
+    FIOEOF, /* File I/O, end of file.         */
-	FIOERR,	/* File I/O, error.               */
+    FIOERR, /* File I/O, error.               */
-	FIOMEM	/* File I/O, out of memory        */
+    FIOMEM  /* File I/O, out of memory        */
 } fio_code ;
 
 #define FTYPE_NONE  0
@@ -16,15 +17,14 @@ typedef enum {
 /*      FTYPE_MIXED [ 3, 5, 6, 7] */
 
 #define FCODE_ASCII 0
-#define FCODE_MASK  0x80
+#define FCODE_UTF_8 1
-#define FCODE_UTF_8 0x81
+#define FCODE_EXTND 2
-#define FCODE_EXTND 0x82
+#define FCODE_MIXED 3
-#define FCODE_MIXED 0x83
 
-extern char		*fline ;		/* dynamic return line     */
+extern char *fline ;        /* dynamic return line     */
-extern int 		ftype ;
+extern int  ftype ;
-extern int		fcode ;			/* encoding type */
+extern int  fcode ;         /* encoding type */
-extern int		fpayload ;		/* actual length of fline content */
+extern int  fpayload ;      /* actual length of fline content */
 
 fio_code ffclose( void) ;
 fio_code ffgetline( void) ;
@@ -33,3 +33,4 @@ fio_code ffropen( const char *fn) ;
 fio_code ffwopen( const char *fn) ;
 
 #endif
+/* end of fileio.h */

floodmaz.cmd

@@ -0,0 +1,67 @@
+## floodmaz.cmd -- solve maze by painting wall on the right
+
+# 6 set $seed
+# either maze.cmd or sharpmaz.cmd
+execute-file sharpmaz.cmd
+
+set %thisbuf $cbufname
+set %meml $curline
+set %memc $curcol
+
+set $curline 1
+set $curcol 0
+!gosub pushxy	#push stop position
+set %x 1
+set $curline 4
+set $curcol %x
+set %OC $curchar
+set %NC &asc "█"
+!while &not &equ %x 0
+	set $curchar %NC
+	set %cc $curcol
+	set %ll $curline
+	set $curcol &add %cc 1
+	!gosub probe
+	set $curcol &add %cc -1
+	!gosub probe
+	set $curline &add %ll 1
+	set $curcol %cc
+	!gosub probe
+	set $curline &add %ll -1
+	set $curcol %cc
+	!gosub probe
+# pop x y
+	select-buffer stack
+	beginning-of-file
+	set %x $line
+1	kill-to-end-of-line
+	set %y $line
+1	kill-to-end-of-line
+	select-buffer %thisbuf
+	set $curline %y
+	set $curcol %x
+!endwhile
+
+set $curline %meml
+set $curcol %memc
+select-buffer stack
+unmark-buffer
+select-buffer %thisbuf
+unmark-buffer
+delete-buffer stack
+!return
+
+:probe
+	!if &not &or &equ $curchar %NC &equ $curchar 32
+	:pushxy					# push x y
+		set %x $curcol
+		set %y $curline
+		select-buffer stack
+		beginning-of-file
+		insert-string %x
+		newline
+		insert-string %y
+		newline
+		select-buffer %thisbuf
+	!endif
+!return

flook.c

@@ -1,172 +1,131 @@
 /* flook.c -- implements flook.h */
 #include "flook.h"
 
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-
 #include "defines.h"
-#include "fileio.h"
 
 
-/*	possible names and paths of help files under different OSs	*/
+/* possible names and paths of help files under different OSes */
 const char *pathname[] = {
-#if	MSDOS
+#if BSD | USG
-	"emacs.rc",
+    ".emacsrc",
-	"emacs.hlp",
+    "emacs.hlp",
-	"\\sys\\public\\",
+# if PKCODE
-	"\\usr\\bin\\",
+    "/usr/global/lib/", "/usr/local/bin/", "/usr/local/lib/",
-	"\\bin\\",
+# endif
-	"\\",
+    "/usr/local/", "/usr/lib/", ""
-	""
 #endif
+} ;
 
-#if	V7 | BSD | USG
+#define PATHTABLE_SIZE (sizeof pathname / sizeof pathname[ 0])
-	".emacsrc",
-	"emacs.hlp",
-#if	PKCODE
-	"/usr/global/lib/", "/usr/local/bin/", "/usr/local/lib/",
-#endif
-	"/usr/local/", "/usr/lib/", ""
-#endif
-
-#if	VMS
-{
-	"emacs.rc", "emacs.hlp", "",
-#if	PKCODE
-	"sys$login:", "emacs_dir:",
-#endif
-	"sys$sysdevice:[vmstools]"
-#endif
-};
-
-#define PATHNAME_SIZE (sizeof pathname / sizeof pathname[ 0])
 
 
-/*
+/* does <fname> exist on disk?
- * does <fname> exist on disk?
  *
  * char *fname;     file to check for existance
  */
-boolean fexist( const char *fname)
+boolean fexist( const char *fname) {
-{
+    FILE *fp = fopen( fname, "r") ;
-    FILE *fp;
+    if( fp == NULL)
+        return FALSE ;
+    else
+        fclose( fp) ;
 
-    /* try to open the file for reading */
+    return TRUE ;
-    fp = fopen(fname, "r");
-
-    /* if it fails, just return false! */
-    if (fp == NULL)
-        return FALSE;
-
-    /* otherwise, close it and report true */
-    fclose(fp);
-    return TRUE;
 }
 
-/*
+
- * Look up the existance of a file along the normal or PATH
+/* Look up the existence of a file along the normal or PATH environment
- * environment variable. Look first in the HOME directory if
+   variable.  Look first in the HOME directory if asked and possible.
- * asked and possible
+
- *
+   char *fname;     base file name to search for
- * char *fname;		base file name to search for
+   boolean hflag;   look in the HOME environment variable first?
- * boolean hflag;		Look in the HOME environment variable first?
  */
-char *flook( const char *fname, boolean hflag)
+char *flook( const char *fname, boolean hflag) {
-{
+    static char fspec[ NSTRING] ;   /* full path spec to search */
-	unsigned i ;	/* index */
-	int len ;
-	static char fspec[NSTRING];	/* full path spec to search */
 
-#if	ENVFUNC
+    int len = sizeof fspec - strlen( fname) - 1 ;
-	char *path;	/* environmental PATH variable */
+    if( len < 0)
+        return NULL ;
+
+#if ENVFUNC
+    if( hflag) {
+        char *home = getenv( "HOME") ;  /* path to home directory */
+        if( home != NULL) {
+            if( len > (int) strlen( home) + 1) {
+            /* build home dir file spec */
+                strcpy( fspec, home) ;
+                strcat( fspec, "/") ;
+                strcat( fspec, fname) ;
+
+            /* and try it out */
+                if( fexist( fspec))
+                    return fspec ;
+            }
+        }
+    }
 #endif
 
-	len = sizeof fspec - strlen( fname) - 1 ;
+    /* always try the current directory first */
-	if( len < 0)
+    if( len >= 0) {
-		return NULL ;
+        strcpy( fspec, fname) ;
+        if( fexist( fspec))
+            return fspec ;
+    }
 
-#if	ENVFUNC
+#if ENVFUNC
-	if (hflag) {
+# if USG | BSD
-		char *home;	/* path to home directory */
+#  define PATHCHR   ':'
+# else
+#  define PATHCHR   ';'
+# endif
 
-		home = getenv("HOME");
+/* get the PATH variable */
-		if (home != NULL) {
+    char *path = getenv( "PATH") ;  /* environmental PATH variable */
-			if( len > (int) strlen( home) + 1) {
+    if( path != NULL)
-			/* build home dir file spec */
+        while( *path) {
-				strcpy( fspec, home) ;
+            int cnt = len ;
-				strcat(fspec, "/");
+        /* build next possible file spec */
-				strcat(fspec, fname);
+            char *sp = fspec ;      /* pointer into path spec */
+            while( *path && (*path != PATHCHR)) {
+                if( cnt-- > 0)
+                    *sp++ = *path ;
 
-			/* and try it out */
+                path += 1 ;
-				if( fexist( fspec))
+            }
-					return fspec ;
+
-			}
+            if( cnt >= 0) {
-		}
+            /* add a terminating dir separator if we need it */
-	}
+                if (sp != fspec)
+                    *sp++ = '/';
+                *sp = 0;
+                strcat(fspec, fname);
+
+            /* and try it out */
+                if( fexist( fspec))
+                    return fspec ;
+            }
+
+            if( *path == PATHCHR)
+                ++path ;
+        }
 #endif
 
-	/* always try the current directory first */
+    /* look it up via the old table method */
-	if( len >= 0) {
+    for( unsigned i = 2 ; i < PATHTABLE_SIZE ; i++)
-		strcpy( fspec, fname) ;
+        if( len >= (int) strlen( pathname[ i])) {
-		if( fexist( fspec))
+            strcpy( fspec, pathname[ i]) ;
-			return fspec ;
+            strcat( fspec, fname);
-	}
 
-#if	ENVFUNC
+        /* and try it out */
-#if	V7 | USG | BSD
+            if( fexist( fspec))
-#define	PATHCHR	':'
+                return fspec ;
-#else
+        }
-#define	PATHCHR	';'
-#endif
 
-	/* get the PATH variable */
+    return NULL ;       /* no such luck */
-	path = getenv("PATH");
-	if (path != NULL)
-		while (*path) {
-			char *sp;	/* pointer into path spec */
-			int cnt ;
-
-			cnt = len ;
-			/* build next possible file spec */
-			sp = fspec;
-			while( *path && (*path != PATHCHR)) {
-				if( cnt-- > 0)
-					*sp++ = *path ;
-
-				path += 1 ;
-			}
-
-			if( cnt >= 0) {
-			/* add a terminating dir separator if we need it */
-				if (sp != fspec)
-					*sp++ = '/';
-				*sp = 0;
-				strcat(fspec, fname);
-
-			/* and try it out */
-				if( fexist( fspec))
-					return fspec ;
-			}
-
-			if (*path == PATHCHR)
-				++path;
-		}
-#endif
-
-	/* look it up via the old table method */
-	for( i = 2; i < PATHNAME_SIZE ; i++)
-		if( len >= (int) strlen( pathname[ i])) {
-			strcpy( fspec, pathname[ i]) ;
-			strcat( fspec, fname);
-
-		/* and try it out */
-			if( fexist( fspec))
-				return fspec ;
-		}
-
-	return NULL;		/* no such luck */
 }
 
+/* end of flook.c */

flook.h

@@ -1,8 +1,11 @@
-#include "retcode.h"
+/* flook.h -- */
+#ifndef _FLOOK_H_
+#define _FLOOK_H_
 
+#include "retcode.h"    /* boolean */
 
-#define rcfname		pathname[ 0]
+#define rcfname     pathname[ 0]
-#define hlpfname	pathname[ 1]
+#define hlpfname    pathname[ 1]
 
 extern const char *pathname[] ;
 
@@ -10,3 +13,5 @@ extern const char *pathname[] ;
 boolean fexist( const char *fname) ;
 char *flook( const char *fname, boolean hflag) ;
 
+#endif
+/* end of flook.h */

fridge/ansi.c

@@ -1,241 +0,0 @@
-/*	ANSI.C
- *
- * The routines in this file provide support for ANSI style terminals
- * over a serial line. The serial I/O services are provided by routines in
- * "termio.c". It compiles into nothing if not an ANSI device.
- *
- *	modified by Petri Kutvonen
- */
-
-#define	termdef	1		/* don't define "term" external */
-
-#include        <stdio.h>
-#include	"estruct.h"
-
-
-#if     ANSI
-
-#define NROW    25		/* Screen size.                 */
-#define NCOL    80		/* Edit if you want to.         */
-
-#if	PKCODE
-#define	MROW	64
-#endif
-#define	NPAUSE	100		/* # times thru update to pause */
-#define	MARGIN	8		/* size of minimim margin and   */
-#define	SCRSIZ	64		/* scroll size for extended lines */
-#define BEL     0x07		/* BEL character.               */
-#define ESC     0x1B		/* ESC character.               */
-
-extern int ttopen();		/* Forward references.          */
-extern int ttgetc();
-extern int ttputc();
-extern int ttflush();
-extern int ttclose();
-extern int ansimove();
-extern int ansieeol();
-extern int ansieeop();
-extern int ansibeep();
-extern int ansiopen();
-extern int ansirev();
-extern int ansiclose();
-extern int ansikopen();
-extern int ansikclose();
-extern int ansicres();
-
-#if	COLOR
-extern int ansifcol();
-extern int ansibcol();
-
-int cfcolor = -1;		/* current forground color */
-int cbcolor = -1;		/* current background color */
-
-#endif
-
-/*
- * Standard terminal interface dispatch table. Most of the fields point into
- * "termio" code.
- */
-struct terminal term = {
-#if	PKCODE
-	MROW - 1,
-#else
-	NROW - 1,
-#endif
-	NROW - 1,
-	NCOL,
-	NCOL,
-	MARGIN,
-	SCRSIZ,
-	NPAUSE,
-	ansiopen,
-	ansiclose,
-	ansikopen,
-	ansikclose,
-	ttgetc,
-	ttputc,
-	ttflush,
-	ansimove,
-	ansieeol,
-	ansieeop,
-	ansibeep,
-	ansirev,
-	ansicres
-#if	COLOR
-	    , ansifcol,
-	ansibcol
-#endif
-#if	SCROLLCODE
-	    , NULL
-#endif
-};
-
-#if	COLOR
-ansifcol(color)
-    /* set the current output color */
-int color;			/* color to set */
-
-{
-	if (color == cfcolor)
-		return;
-	ttputc(ESC);
-	ttputc('[');
-	ansiparm(color + 30);
-	ttputc('m');
-	cfcolor = color;
-}
-
-/* Set the current background color.
- * color: color to set.
- */
-void ansibcol(int color)
-{
-	if (color == cbcolor)
-		return;
-	ttputc(ESC);
-	ttputc('[');
-	ansiparm(color + 40);
-	ttputc('m');
-	cbcolor = color;
-}
-#endif
-
-ansimove(row, col)
-{
-	ttputc(ESC);
-	ttputc('[');
-	ansiparm(row + 1);
-	ttputc(';');
-	ansiparm(col + 1);
-	ttputc('H');
-}
-
-void ansieeol(void)
-{
-	ttputc(ESC);
-	ttputc('[');
-	ttputc('K');
-}
-
-void ansieeop(void)
-{
-#if	COLOR
-	ansifcol(gfcolor);
-	ansibcol(gbcolor);
-#endif
-	ttputc(ESC);
-	ttputc('[');
-	ttputc('J');
-}
-
-/* Change reverse video state.
- * state: TRUE = reverse, FALSE = normal
- */
-void ansirev(int state)
-{
-#if	COLOR
-	int ftmp, btmp;		/* temporaries for colors */
-#endif
-
-	ttputc(ESC);
-	ttputc('[');
-	ttputc(state ? '7' : '0');
-	ttputc('m');
-#if	COLOR
-	if (state == FALSE) {
-		ftmp = cfcolor;
-		btmp = cbcolor;
-		cfcolor = -1;
-		cbcolor = -1;
-		ansifcol(ftmp);
-		ansibcol(btmp);
-	}
-#endif
-}
-
-/* Change screen resolution. */
-int ansicres()
-{
-	return TRUE;
-}
-
-void ansibeep(void)
-{
-	ttputc(BEL);
-	ttflush();
-}
-
-void ansiparm(int n)
-{
-	int q, r;
-
-	q = n / 10;
-	if (q != 0) {
-		r = q / 10;
-		if (r != 0) {
-			ttputc((r % 10) + '0');
-		}
-		ttputc((q % 10) + '0');
-	}
-	ttputc((n % 10) + '0');
-}
-
-void ansiopen(void)
-{
-#if     V7 | USG | BSD
-	char *cp;
-
-	if ((cp = getenv("TERM")) == NULL) {
-		puts("Shell variable TERM not defined!");
-		exit(1);
-	}
-	if (strcmp(cp, "vt100") != 0) {
-		puts("Terminal type not 'vt100'!");
-		exit(1);
-	}
-#endif
-	strcpy(sres, "NORMAL");
-	revexist = TRUE;
-	ttopen();
-}
-
-void ansiclose(void)
-{
-#if	COLOR
-	ansifcol(7);
-	ansibcol(0);
-#endif
-	ttclose();
-}
-
-/* Open the keyboard (a noop here). */
-void ansikopen(void)
-{
-}
-
-/* Close the keyboard (a noop here). */
-void ansikclose(void)
-{
-}
-
-#endif

fridge/ibmpc.c

@@ -1,494 +0,0 @@
-/*	ibmpc.c
- *
- * The routines in this file provide support for the IBM-PC and other
- * compatible terminals. It goes directly to the graphics RAM to do
- * screen output. It compiles into nothing if not an IBM-PC driver
- * Supported monitor cards include CGA, MONO and EGA.
- *
- *	modified by Petri Kutvonen
- */
-
-#define	termdef	1		/* don't define "term" external */
-
-#include        <stdio.h>
-#include	"estruct.h"
-
-#if     IBMPC
-#if	PKCODE
-#define NROW	50
-#else
-#define NROW	43		/* Max Screen size.             */
-#endif
-#define NCOL    80		/* Edit if you want to.         */
-#define	MARGIN	8		/* size of minimim margin and   */
-#define	SCRSIZ	64		/* scroll size for extended lines */
-#define	NPAUSE	200		/* # times thru update to pause */
-#define BEL     0x07		/* BEL character.               */
-#define ESC     0x1B		/* ESC character.               */
-#define	SPACE	32		/* space character              */
-
-#define	SCADC	0xb8000000L	/* CGA address of screen RAM    */
-#define	SCADM	0xb0000000L	/* MONO address of screen RAM   */
-#define SCADE	0xb8000000L	/* EGA address of screen RAM    */
-
-#define MONOCRSR 0x0B0D		/* monochrome cursor        */
-#define CGACRSR 0x0607		/* CGA cursor               */
-#define EGACRSR 0x0709		/* EGA cursor               */
-
-#define	CDCGA	0		/* color graphics card          */
-#define	CDMONO	1		/* monochrome text card         */
-#define	CDEGA	2		/* EGA color adapter            */
-#if	PKCODE
-#define	CDVGA	3
-#endif
-#define	CDSENSE	9		/* detect the card type         */
-
-#if	PKCODE
-#define NDRIVE	4
-#else
-#define NDRIVE	3		/* number of screen drivers     */
-#endif
-
-int dtype = -1;			/* current display type         */
-char drvname[][8] = {		/* screen resolution names      */
-	"CGA", "MONO", "EGA"
-#if	PKCODE
-	    , "VGA"
-#endif
-};
-long scadd;			/* address of screen ram        */
-int *scptr[NROW];		/* pointer to screen lines      */
-unsigned int sline[NCOL];	/* screen line image            */
-int egaexist = FALSE;		/* is an EGA card available?    */
-extern union REGS rg;		/* cpu register for use of DOS calls */
-
-extern int ttopen();		/* Forward references.          */
-extern int ttgetc();
-extern int ttputc();
-extern int ttflush();
-extern int ttclose();
-extern int ibmmove();
-extern int ibmeeol();
-extern int ibmeeop();
-extern int ibmbeep();
-extern int ibmopen();
-extern int ibmrev();
-extern int ibmcres();
-extern int ibmclose();
-extern int ibmputc();
-extern int ibmkopen();
-extern int ibmkclose();
-
-#if	COLOR
-extern int ibmfcol();
-extern int ibmbcol();
-extern int ibmscroll_reg();
-
-int cfcolor = -1;		/* current forground color */
-int cbcolor = -1;		/* current background color */
-int ctrans[] =			/* ansi to ibm color translation table */
-#if	PKCODE
-{ 0, 4, 2, 6, 1, 5, 3, 7, 15 };
-#else
-{ 0, 4, 2, 6, 1, 5, 3, 7 };
-#endif
-#endif
-
-/*
- * Standard terminal interface dispatch table. Most of the fields point into
- * "termio" code.
- */
-struct terminal term = {
-	NROW - 1,
-	NROW - 1,
-	NCOL,
-	NCOL,
-	MARGIN,
-	SCRSIZ,
-	NPAUSE,
-	ibmopen,
-	ibmclose,
-	ibmkopen,
-	ibmkclose,
-	ttgetc,
-	ibmputc,
-	ttflush,
-	ibmmove,
-	ibmeeol,
-	ibmeeop,
-	ibmbeep,
-	ibmrev,
-	ibmcres
-#if	COLOR
-	    , ibmfcol,
-	ibmbcol
-#endif
-#if     SCROLLCODE
-	    , ibmscroll_reg
-#endif
-};
-
-#if	COLOR
-/* Set the current output color.
- *
- * @color: color to set.
- */
-void ibmfcol(int color)
-{
-	cfcolor = ctrans[color];
-}
-
-/* Set the current background color.
- *
- * @color: color to set.
- */
-void ibmbcol(int color)
-{
-	cbcolor = ctrans[color];
-}
-#endif
-
-void ibmmove(int row, int col)
-{
-	rg.h.ah = 2;		/* set cursor position function code */
-	rg.h.dl = col;
-	rg.h.dh = row;
-	rg.h.bh = 0;		/* set screen page number */
-	int86(0x10, &rg, &rg);
-}
-
-void ibmeeol(void)
-{				/* erase to the end of the line */
-	unsigned int attr;	/* attribute byte mask to place in RAM */
-	unsigned int *lnptr;	/* pointer to the destination line */
-	int i;
-	int ccol;		/* current column cursor lives */
-	int crow;		/*         row  */
-
-	/* find the current cursor position */
-	rg.h.ah = 3;		/* read cursor position function code */
-	rg.h.bh = 0;		/* current video page */
-	int86(0x10, &rg, &rg);
-	ccol = rg.h.dl;		/* record current column */
-	crow = rg.h.dh;		/* and row */
-
-	/* build the attribute byte and setup the screen pointer */
-#if	COLOR
-	if (dtype != CDMONO)
-		attr = (((cbcolor & 15) << 4) | (cfcolor & 15)) << 8;
-	else
-		attr = 0x0700;
-#else
-	attr = 0x0700;
-#endif
-	lnptr = &sline[0];
-	for (i = 0; i < term.t_ncol; i++)
-		*lnptr++ = SPACE | attr;
-
-	if (flickcode && (dtype == CDCGA)) {
-		/* wait for vertical retrace to be off */
-		while ((inp(0x3da) & 8));
-
-		/* and to be back on */
-		while ((inp(0x3da) & 8) == 0);
-	}
-
-	/* and send the string out */
-	movmem(&sline[0], scptr[crow] + ccol, (term.t_ncol - ccol) * 2);
-
-}
-
-/* Put a character at the current position in the current colors */
-void ibmputc(int ch)
-{
-	rg.h.ah = 14;		/* write char to screen with current attrs */
-	rg.h.al = ch;
-#if	COLOR
-	if (dtype != CDMONO)
-		rg.h.bl = cfcolor;
-	else
-		rg.h.bl = 0x07;
-#else
-	rg.h.bl = 0x07;
-#endif
-	int86(0x10, &rg, &rg);
-}
-
-void ibmeeop(void)
-{
-	int attr;		/* attribute to fill screen with */
-
-	rg.h.ah = 6;		/* scroll page up function code */
-	rg.h.al = 0;		/* # lines to scroll (clear it) */
-	rg.x.cx = 0;		/* upper left corner of scroll */
-	rg.x.dx = (term.t_nrow << 8) | (term.t_ncol - 1);
-	/* lower right corner of scroll */
-#if	COLOR
-	if (dtype != CDMONO)
-		attr =
-		    ((ctrans[gbcolor] & 15) << 4) | (ctrans[gfcolor] & 15);
-	else
-		attr = 0;
-#else
-	attr = 0;
-#endif
-	rg.h.bh = attr;
-	int86(0x10, &rg, &rg);
-}
-
-/* Change reverse video state.
- *
- * @state: TRUE = reverse, FALSE = normal.
- */
-void ibmrev(int state)
-{
-	/* This never gets used under the IBM-PC driver */
-}
-
-/* Change screen resolution.
- *
- * @res: resolution to change to.
- */
-void ibmcres(char *res)
-{
-	int i;
-	for (i = 0; i < NDRIVE; i++) {
-		if (strcmp(res, drvname[i]) == 0) {
-			scinit(i);
-			return TRUE;
-		}
-	}
-	return FALSE;
-}
-
-#if SCROLLCODE
-
-/* Move howmany lines starting at from to to. */
-void ibmscroll_reg(from, to, howmany)
-{
-	int i;
-
-	if (to < from) {
-		for (i = 0; i < howmany; i++) {
-			movmem(scptr[from + i], scptr[to + i],
-			       term.t_ncol * 2);
-		}
-	}
-	else if (to > from) {
-		for (i = howmany - 1; i >= 0; i--) {
-			movmem(scptr[from + i], scptr[to + i],
-			       term.t_ncol * 2);
-		}
-	}
-}
-
-#endif
-
-void ibmbeep(void)
-{
-	bdos(6, BEL, 0);
-}
-
-void ibmopen(void)
-{
-	scinit(CDSENSE);
-	revexist = TRUE;
-	ttopen();
-}
-
-void ibmclose(void)
-{
-#if	COLOR
-	ibmfcol(7);
-	ibmbcol(0);
-#endif
-	/* if we had the EGA open... close it */
-	if (dtype == CDEGA)
-		egaclose();
-#if	PKCODE
-	if (dtype == CDVGA)
-		egaclose();
-#endif
-
-	ttclose();
-}
-
-/* Open the keyboard. */
-void ibmkopen(void)
-{
-}
-
-/* Close the keyboard. */
-void ibmkclose(void)
-{
-}
-
-/* Initialize the screen head pointers.
- *
- * @type: type of adapter to init for.
- */
-static int scinit(int type)
-{
-	union {
-		long laddr;	/* long form of address */
-		int *paddr;	/* pointer form of address */
-	} addr;
-	int i;
-
-	/* if asked...find out what display is connected */
-	if (type == CDSENSE)
-		type = getboard();
-
-	/* if we have nothing to do....don't do it */
-	if (dtype == type)
-		return TRUE;
-
-	/* if we try to switch to EGA and there is none, don't */
-	if (type == CDEGA && egaexist != TRUE)
-		return FALSE;
-
-	/* if we had the EGA open... close it */
-	if (dtype == CDEGA)
-		egaclose();
-#if	PKCODE
-	if (dtype == CDVGA)
-		egaclose();
-#endif
-
-	/* and set up the various parameters as needed */
-	switch (type) {
-	case CDMONO:		/* Monochrome adapter */
-		scadd = SCADM;
-		newsize(TRUE, 25);
-		break;
-
-	case CDCGA:		/* Color graphics adapter */
-		scadd = SCADC;
-		newsize(TRUE, 25);
-		break;
-
-	case CDEGA:		/* Enhanced graphics adapter */
-		scadd = SCADE;
-		egaopen();
-		newsize(TRUE, 43);
-		break;
-	case CDVGA:		/* Enhanced graphics adapter */
-		scadd = SCADE;
-		egaopen();
-		newsize(TRUE, 50);
-		break;
-	}
-
-	/* reset the $sres environment variable */
-	strcpy(sres, drvname[type]);
-	dtype = type;
-
-	/* initialize the screen pointer array */
-	for (i = 0; i < NROW; i++) {
-		addr.laddr = scadd + (long) (NCOL * i * 2);
-		scptr[i] = addr.paddr;
-	}
-	return TRUE;
-}
-
-/* getboard:	Determine which type of display board is attached.
-		Current known types include:
-
-		CDMONO	Monochrome graphics adapter
-		CDCGA	Color Graphics Adapter
-		CDEGA	Extended graphics Adapter
-*/
-
-/* getboard:	Detect the current display adapter
-		if MONO		set to MONO
-		   CGA		set to CGA	EGAexist = FALSE
-		   EGA		set to CGA	EGAexist = TRUE
-*/
-int getboard(void)
-{
-	int type;		/* board type to return */
-
-	type = CDCGA;
-	int86(0x11, &rg, &rg);
-	if ((((rg.x.ax >> 4) & 3) == 3))
-		type = CDMONO;
-
-	/* test if EGA present */
-	rg.x.ax = 0x1200;
-	rg.x.bx = 0xff10;
-	int86(0x10, &rg, &rg);	/* If EGA, bh=0-1 and bl=0-3 */
-	egaexist = !(rg.x.bx & 0xfefc);	/* Yes, it's EGA */
-	return type;
-}
-
-/* init the computer to work with the EGA */
-void egaopen(void)
-{
-	/* put the beast into EGA 43 row mode */
-	rg.x.ax = 3;
-	int86(16, &rg, &rg);
-
-	rg.h.ah = 17;		/* set char. generator function code */
-	rg.h.al = 18;		/*  to 8 by 8 double dot ROM         */
-	rg.h.bl = 0;		/* block 0                           */
-	int86(16, &rg, &rg);
-
-	rg.h.ah = 18;		/* alternate select function code    */
-	rg.h.al = 0;		/* clear AL for no good reason       */
-	rg.h.bl = 32;		/* alt. print screen routine         */
-	int86(16, &rg, &rg);
-
-	rg.h.ah = 1;		/* set cursor size function code */
-	rg.x.cx = 0x0607;	/* turn cursor on code */
-	int86(0x10, &rg, &rg);
-
-	outp(0x3d4, 10);	/* video bios bug patch */
-	outp(0x3d5, 6);
-}
-
-void egaclose(void)
-{
-	/* put the beast into 80 column mode */
-	rg.x.ax = 3;
-	int86(16, &rg, &rg);
-}
-
-/* Write a line out.
- *
- * @row:    row of screen to place outstr on.
- * @outstr: string to write out (must be term.t_ncol long).
- * @forg:   forground color of string to write.
- * @bacg:   background color.
- */
-void scwrite(int row, char *outstr, int forg, int bacg)
-{
-	unsigned int attr;	/* attribute byte mask to place in RAM */
-	unsigned int *lnptr;	/* pointer to the destination line */
-	int i;
-
-	/* build the attribute byte and setup the screen pointer */
-#if	COLOR
-	if (dtype != CDMONO)
-		attr = (((ctrans[bacg] & 15) << 4) | (ctrans[forg] & 15)) << 8;
-	else
-		attr = (((bacg & 15) << 4) | (forg & 15)) << 8;
-#else
-	attr = (((bacg & 15) << 4) | (forg & 15)) << 8;
-#endif
-	lnptr = &sline[0];
-	for (i = 0; i < term.t_ncol; i++)
-		*lnptr++ = (outstr[i] & 255) | attr;
-
-	if (flickcode && (dtype == CDCGA)) {
-		/* wait for vertical retrace to be off */
-		while ((inp(0x3da) & 8));
-
-		/* and to be back on */
-		while ((inp(0x3da) & 8) == 0);
-	}
-
-	/* and send the string out */
-	movmem(&sline[0], scptr[row], term.t_ncol * 2);
-}
-
-#endif

fridge/vmsvt.c

@@ -1,488 +0,0 @@
-/*	VMSVT.C
- *
- *	Advanced VMS terminal driver
- *
- *	Knows about any terminal defined in SMGTERMS.TXT and TERMTABLE.TXT
- *	located in SYS$SYSTEM.
- *
- *	Author:  Curtis Smith
- *	modified by Petri Kutvonen
- */
-
-#include	<stdio.h>	/* Standard I/O package         */
-#include	"estruct.h"	/* Emacs' structures            */
-
-#if	VMSVT
-
-#include	 <descrip.h>	/* Descriptor definitions       */
-
-/*  These would normally come from iodef.h and ttdef.h  */
-#define IO$_SENSEMODE	0x27	/* Sense mode of terminal       */
-#define TT$_UNKNOWN	0x00	/* Unknown terminal             */
-#define TT$_VT100	96
-
-/** Forward references **/
-int vmsopen(), ttclose(), vmskopen(), vmskclose(), ttgetc(), ttputc();
-int ttflush(), vmsmove(), vmseeol(), vmseeop(), vmsbeep(), vmsrev();
-int vmscres();
-extern int eolexist, revexist;
-extern char sres[];
-
-#if COLOR
-int vmsfcol(), vmsbcol();
-#endif
-
-/** SMG stuff **/
-static char *begin_reverse, *end_reverse, *erase_to_end_line;
-static char *erase_whole_display;
-static int termtype;
-
-#define SMG$K_BEGIN_REVERSE		0x1bf
-#define SMG$K_END_REVERSE		0x1d6
-#define SMG$K_SET_CURSOR_ABS		0x23a
-#define SMG$K_ERASE_WHOLE_DISPLAY	0x1da
-#define SMG$K_ERASE_TO_END_LINE		0x1d9
-
-#if SCROLLCODE
-
-#define SMG$K_SCROLL_FORWARD    561	/* from sys$library:smgtrmptr.h */
-#define SMG$K_SCROLL_REVERSE	562
-#define SMG$K_SET_SCROLL_REGION	572
-
-static char *scroll_forward, *scroll_reverse;
-
-#endif
-
-/* Dispatch table. All hard fields just point into the terminal I/O code. */
-struct terminal term = {
-#if	PKCODE
-	MAXROW,
-#else
-	24 - 1,			/* Max number of rows allowable */
-#endif
-				/* Filled in */ -1,
-				/* Current number of rows used  */
-	MAXCOL,			/* Max number of columns        */
-				/* Filled in */ 0,
-				/* Current number of columns    */
-	64,			/* Min margin for extended lines */
-	8,			/* Size of scroll region        */
-	100,			/* # times thru update to pause */
-	vmsopen,		/* Open terminal at the start   */
-	ttclose,		/* Close terminal at end        */
-	vmskopen,		/* Open keyboard                */
-	vmskclose,		/* Close keyboard               */
-	ttgetc,			/* Get character from keyboard  */
-	ttputc,			/* Put character to display     */
-	ttflush,		/* Flush output buffers         */
-	vmsmove,		/* Move cursor, origin 0        */
-	vmseeol,		/* Erase to end of line         */
-	vmseeop,		/* Erase to end of page         */
-	vmsbeep,		/* Beep                         */
-	vmsrev,			/* Set reverse video state      */
-	vmscres			/* Change screen resolution     */
-#if	COLOR
-	    , vmsfcol,		/* Set forground color          */
-	vmsbcol			/* Set background color         */
-#endif
-#if	SCROLLCODE
-	    , NULL
-#endif
-};
-
-/***
- *  ttputs  -  Send a string to ttputc
- *
- *  Nothing returned
- ***/
-ttputs(string)
-char *string;			/* String to write              */
-{
-	if (string)
-		while (*string != '\0')
-			ttputc(*string++);
-}
-
-
-/***
- *  vmsmove  -  Move the cursor (0 origin)
- *
- *  Nothing returned
- ***/
-vmsmove(row, col)
-int row;			/* Row position                 */
-int col;			/* Column position              */
-{
-	char buffer[32];
-	int ret_length;
-	static int request_code = SMG$K_SET_CURSOR_ABS;
-	static int max_buffer_length = sizeof(buffer);
-	static int arg_list[3] = { 2 };
-	char *cp;
-
-	int i;
-
-	/* Set the arguments into the arg_list array
-	 * SMG assumes the row/column positions are 1 based (boo!)
-	 */
-	arg_list[1] = row + 1;
-	arg_list[2] = col + 1;
-
-	if ((smg$get_term_data(	/* Get terminal data            */
-				      &termtype,	/* Terminal table address       */
-				      &request_code,	/* Request code                 */
-				      &max_buffer_length,	/* Maximum buffer length        */
-				      &ret_length,	/* Return length                */
-				      buffer,	/* Capability data buffer       */
-				      arg_list)
-
-	     /* Argument list array              */
-	     /* We'll know soon enough if this doesn't work         */
-	     &1) == 0) {
-		ttputs("OOPS");
-		return;
-	}
-
-	/* Send out resulting sequence                          */
-	i = ret_length;
-	cp = buffer;
-	while (i-- > 0)
-		ttputc(*cp++);
-}
-
-#if SCROLLCODE
-
-vmsscroll_reg(from, to, howmany)
-{
-	int i;
-	if (to == from)
-		return;
-	if (to < from) {
-		vmsscrollregion(to, from + howmany - 1);
-		vmsmove(from + howmany - 1, 0);
-		for (i = from - to; i > 0; i--)
-			ttputs(scroll_forward);
-	} else {		/* from < to */
-		vmsscrollregion(from, to + howmany - 1);
-		vmsmove(from, 0);
-		for (i = to - from; i > 0; i--)
-			ttputs(scroll_reverse);
-	}
-	vmsscrollregion(-1, -1);
-}
-
-vmsscrollregion(top, bot)
-int top;			/* Top position                 */
-int bot;			/* Bottom position              */
-{
-	char buffer[32];
-	int ret_length;
-	static int request_code = SMG$K_SET_SCROLL_REGION;
-	static int max_buffer_length = sizeof(buffer);
-	static int arg_list[3] = { 2 };
-	char *cp;
-
-	int i;
-
-	/* Set the arguments into the arg_list array
-	 * SMG assumes the row/column positions are 1 based (boo!)
-	 */
-	arg_list[1] = top + 1;
-	arg_list[2] = bot + 1;
-
-	if ((smg$get_term_data(	/* Get terminal data            */
-				      &termtype,	/* Terminal table address       */
-				      &request_code,	/* Request code                 */
-				      &max_buffer_length,	/* Maximum buffer length        */
-				      &ret_length,	/* Return length                */
-				      buffer,	/* Capability data buffer       */
-				      arg_list)
-
-	     /* Argument list array              */
-	     /* We'll know soon enough if this doesn't work         */
-	     &1) == 0) {
-		ttputs("OOPS");
-		return;
-	}
-
-	ttputc(0);
-	/* Send out resulting sequence                          */
-	i = ret_length;
-	cp = buffer;
-	while (i-- > 0)
-		ttputc(*cp++);
-}
-#endif
-
-/***
- *  vmsrev  -  Set the reverse video status
- *
- *  Nothing returned
- ***/
-vmsrev(status)
-int status;			/* TRUE if setting reverse      */
-{
-	if (status)
-		ttputs(begin_reverse);
-	else
-		ttputs(end_reverse);
-}
-
-/***
- *  vmscres  -  Change screen resolution (which it doesn't)
- *
- *  Nothing returned
- ***/
-vmscres()
-{
-	/* But it could.  For vt100/vt200s, one could switch from
-	   80 and 132 columns modes */
-}
-
-
-#if	COLOR
-/***
- *  vmsfcol  -  Set the forground color (not implimented)
- *
- *  Nothing returned
- ***/
-vmsfcol()
-{
-}
-
-/***
- *  vmsbcol  -  Set the background color (not implimented)
- *
- *  Nothing returned
- ***/
-vmsbcol()
-{
-}
-#endif
-
-/***
- *  vmseeol  -  Erase to end of line
- *
- *  Nothing returned
- ***/
-vmseeol()
-{
-	ttputs(erase_to_end_line);
-}
-
-
-/***
- *  vmseeop  -  Erase to end of page (clear screen)
- *
- *  Nothing returned
- ***/
-vmseeop()
-{
-	ttputs(erase_whole_display);
-}
-
-
-/***
- *  vmsbeep  -  Ring the bell
- *
- *  Nothing returned
- ***/
-vmsbeep()
-{
-	ttputc('\007');
-}
-
-
-/***
- *  vmsgetstr  -  Get an SMG string capability by name
- *
- *  Returns:	Escape sequence
- *		NULL	No escape sequence available
- ***/
-char *vmsgetstr(request_code)
-int request_code;		/* Request code                 */
-{
-	char *result;
-	static char seq_storage[1024];
-	static char *buffer = seq_storage;
-	static int arg_list[2] = { 1, 1 };
-	int max_buffer_length, ret_length;
-
-	/*  Precompute buffer length */
-
-	max_buffer_length = (seq_storage + sizeof(seq_storage)) - buffer;
-
-	/* Get terminal commands sequence from master table */
-
-	if ((smg$get_term_data(	/* Get terminal data            */
-				      &termtype,	/* Terminal table address       */
-				      &request_code,	/* Request code                 */
-				      &max_buffer_length,	/* Maximum buffer length     */
-				      &ret_length,	/* Return length                */
-				      buffer,	/* Capability data buffer       */
-				      arg_list)
-
-
-	     /* Argument list array              */
-	     /* If this doesn't work, try again with no arguments */
-	     &1) == 0 && (smg$get_term_data(	/* Get terminal data            */
-						   &termtype,	/* Terminal table address       */
-						   &request_code,	/* Request code                 */
-						   &max_buffer_length,	/* Maximum buffer length     */
-						   &ret_length,	/* Return length                */
-						   buffer)
-
-
-			  /* Capability data buffer   */
-			  /* Return NULL pointer if capability is not available */
-			  &1) == 0)
-		return NULL;
-
-	/* Check for empty result */
-	if (ret_length == 0)
-		return NULL;
-
-	/* Save current position so we can return it to caller */
-
-	result = buffer;
-
-	/* NIL terminate the sequence for return */
-
-	buffer[ret_length] = 0;
-
-	/* Advance buffer */
-
-	buffer += ret_length + 1;
-
-	/* Return capability to user */
-	return result;
-}
-
-
-/** I/O information block definitions **/
-struct iosb {			/* I/O status block                     */
-	short i_cond;		/* Condition value                      */
-	short i_xfer;		/* Transfer count                       */
-	long i_info;		/* Device information                   */
-};
-struct termchar {		/* Terminal characteristics             */
-	char t_class;		/* Terminal class                       */
-	char t_type;		/* Terminal type                        */
-	short t_width;		/* Terminal width in characters         */
-	long t_mandl;		/* Terminal's mode and length           */
-	long t_extend;		/* Extended terminal characteristics    */
-};
-static struct termchar tc;	/* Terminal characteristics             */
-
-/***
- *  vmsgtty - Get terminal type from system control block
- *
- *  Nothing returned
- ***/
-vmsgtty()
-{
-	short fd;
-	int status;
-	struct iosb iostatus;
-	$DESCRIPTOR(devnam, "SYS$INPUT");
-
-	/* Assign input to a channel */
-	status = sys$assign(&devnam, &fd, 0, 0);
-	if ((status & 1) == 0)
-		exit(status);
-
-	/* Get terminal characteristics */
-	status = sys$qiow(	/* Queue and wait               */
-				 0,	/* Wait on event flag zero      */
-				 fd,	/* Channel to input terminal    */
-				 IO$_SENSEMODE,	/* Get current characteristic   */
-				 &iostatus,	/* Status after operation       */
-				 0, 0,	/* No AST service               */
-				 &tc,	/* Terminal characteristics buf */
-				 sizeof(tc),	/* Size of the buffer           */
-				 0, 0, 0, 0);	/* P3-P6 unused                 */
-
-	/* De-assign the input device */
-	if ((sys$dassgn(fd) & 1) == 0)
-		exit(status);
-
-	/* Jump out if bad status */
-	if ((status & 1) == 0)
-		exit(status);
-	if ((iostatus.i_cond & 1) == 0)
-		exit(iostatus.i_cond);
-}
-
-
-/***
- *  vmsopen  -  Get terminal type and open terminal
- *
- *  Nothing returned
- ***/
-vmsopen()
-{
-	/* Get terminal type */
-	vmsgtty();
-	if (tc.t_type == TT$_UNKNOWN) {
-		printf("Terminal type is unknown!\n");
-		printf
-		    ("Try set your terminal type with SET TERMINAL/INQUIRE\n");
-		printf("Or get help on SET TERMINAL/DEVICE_TYPE\n");
-		exit(3);
-	}
-
-	/* Access the system terminal definition table for the          */
-	/* information of the terminal type returned by IO$_SENSEMODE   */
-	if ((smg$init_term_table_by_type(&tc.t_type, &termtype) & 1) == 0)
-		return -1;
-
-	/* Set sizes */
-	term.t_nrow = ((unsigned int) tc.t_mandl >> 24) - 1;
-	term.t_ncol = tc.t_width;
-
-	/* Get some capabilities */
-	begin_reverse = vmsgetstr(SMG$K_BEGIN_REVERSE);
-	end_reverse = vmsgetstr(SMG$K_END_REVERSE);
-	revexist = begin_reverse != NULL && end_reverse != NULL;
-	erase_to_end_line = vmsgetstr(SMG$K_ERASE_TO_END_LINE);
-	eolexist = erase_to_end_line != NULL;
-	erase_whole_display = vmsgetstr(SMG$K_ERASE_WHOLE_DISPLAY);
-
-#if SCROLLCODE
-	scroll_forward = vmsgetstr(SMG$K_SCROLL_FORWARD);
-	scroll_reverse = vmsgetstr(SMG$K_SCROLL_REVERSE);
-	if (tc.t_type < TT$_VT100 || scroll_reverse == NULL ||
-	    scroll_forward == NULL)
-		term.t_scroll = NULL;
-	else
-		term.t_scroll = vmsscroll_reg;
-#endif
-
-	/* Set resolution */
-	strcpy(sres, "NORMAL");
-
-	/* Open terminal I/O drivers */
-	ttopen();
-}
-
-
-/***
- *  vmskopen  -  Open keyboard (not used)
- *
- *  Nothing returned
- ***/
-vmskopen()
-{
-}
-
-
-/***
- *  vmskclose  -  Close keyboard (not used)
- *
- *  Nothing returned
- ***/
-vmskclose()
-{
-}
-
-#endif

fridge/vt52.c

@@ -1,161 +0,0 @@
-/*	vt52.c
- *
- * The routines in this file
- * provide support for VT52 style terminals
- * over a serial line. The serial I/O services are
- * provided by routines in "termio.c". It compiles
- * into nothing if not a VT52 style device. The
- * bell on the VT52 is terrible, so the "beep"
- * routine is conditionalized on defining BEL.
- *
- *	modified by Petri Kutvonen
- */
-
-#define	termdef	1		/* don't define "term" external */
-
-#include        <stdio.h>
-#include        "estruct.h"
-
-#if     VT52
-
-#define NROW    24		/* Screen size.                 */
-#define NCOL    80		/* Edit if you want to.         */
-#define	MARGIN	8		/* size of minimim margin and   */
-#define	SCRSIZ	64		/* scroll size for extended lines */
-#define	NPAUSE	100		/* # times thru update to pause */
-#define BIAS    0x20		/* Origin 0 coordinate bias.    */
-#define ESC     0x1B		/* ESC character.               */
-#define BEL     0x07		/* ascii bell character         */
-
-extern int ttopen();		/* Forward references.          */
-extern int ttgetc();
-extern int ttputc();
-extern int ttflush();
-extern int ttclose();
-extern int vt52move();
-extern int vt52eeol();
-extern int vt52eeop();
-extern int vt52beep();
-extern int vt52open();
-extern int vt52rev();
-extern int vt52cres();
-extern int vt52kopen();
-extern int vt52kclose();
-
-#if COLOR
-extern int vt52fcol();
-extern int vt52bcol();
-#endif
-
-/*
- * Dispatch table.
- * All the hard fields just point into the terminal I/O code.
- */
-struct terminal term = {
-	NROW - 1,
-	NROW - 1,
-	NCOL,
-	NCOL,
-	MARGIN,
-	SCRSIZ,
-	NPAUSE,
-	&vt52open,
-	&ttclose,
-	&vt52kopen,
-	&vt52kclose,
-	&ttgetc,
-	&ttputc,
-	&ttflush,
-	&vt52move,
-	&vt52eeol,
-	&vt52eeop,
-	&vt52beep,
-	&vt52rev,
-	&vt52cres
-#if	COLOR
-	    , &vt52fcol,
-	&vt52bcol
-#endif
-#if	SCROLLCODE
-	    , NULL
-#endif
-};
-
-vt52move(row, col)
-{
-	ttputc(ESC);
-	ttputc('Y');
-	ttputc(row + BIAS);
-	ttputc(col + BIAS);
-}
-
-vt52eeol()
-{
-	ttputc(ESC);
-	ttputc('K');
-}
-
-vt52eeop()
-{
-	ttputc(ESC);
-	ttputc('J');
-}
-
-vt52rev(status)
-    /* set the reverse video state */
-int status;			/* TRUE = reverse video, FALSE = normal video */
-
-{
-	/* can't do this here, so we won't */
-}
-
-vt52cres()
-{				/* change screen resolution - (not here though) */
-	return TRUE;
-}
-
-#if	COLOR
-vt52fcol()
-{				/* set the forground color [NOT IMPLIMENTED] */
-}
-
-vt52bcol()
-{				/* set the background color [NOT IMPLIMENTED] */
-}
-#endif
-
-vt52beep()
-{
-#ifdef  BEL
-	ttputc(BEL);
-	ttflush();
-#endif
-}
-
-vt52open()
-{
-#if     V7 | BSD
-	char *cp;
-	char *getenv();
-
-	if ((cp = getenv("TERM")) == NULL) {
-		puts("Shell variable TERM not defined!");
-		exit(1);
-	}
-	if (strcmp(cp, "vt52") != 0 && strcmp(cp, "z19") != 0) {
-		puts("Terminal type not 'vt52'or 'z19' !");
-		exit(1);
-	}
-#endif
-	ttopen();
-}
-
-vt52kopen()
-{
-}
-
-vt52kclose()
-{
-}
-
-#endif

input.c

@@ -1,36 +1,30 @@
 /* input.c -- implements input.h */
-
 #include "input.h"
 
-/*  input.c
+/*  Various input routines
- *
- *  Various input routines
  *
  *  written by Daniel Lawrence 5/9/86
  *  modified by Petri Kutvonen
  */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "bind.h"
-#include "estruct.h"
 #include "bindable.h"
-#include "display.h"
+#include "defines.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"
 #include "wrapper.h"
 
-#if PKCODE
+#if PKCODE && UNIX
-#if     MSDOS && TURBO
-#include    <dir.h>
-#endif
-#endif
-
-#if PKCODE && (UNIX || (MSDOS && TURBO))
 #define COMPLC  1
 #else
 #define COMPLC  0
@@ -45,15 +39,22 @@ kbdstate kbdmode = STOP ;   /* current keyboard macro mode  */
 int lastkey = 0 ;       /* last keystoke                */
 int kbdrep = 0 ;        /* number of repetitions        */
 
-int metac = CONTROL | '[' ;		/* current meta character 	 */
+int metac = CTL_ | '[' ;		/* current meta character 	 */
-int ctlxc = CONTROL | 'X' ;		/* current control X prefix char */
+int ctlxc = CTL_ | 'X' ;		/* current control X prefix char */
-int reptc = CONTROL | 'U' ;		/* current universal repeat char */
+int reptc = CTL_ | 'U' ;		/* current universal repeat char */
-int abortc = CONTROL | 'G' ;		/* current abort command char	 */
+int abortc = CTL_ | 'G' ;		/* current abort command char	 */
 
-const int nlc = CONTROL | 'J' ;		/* end of input char */
+const int nlc = CTL_ | 'J' ;		/* end of input char */
 
-static const int quotec = 0x11 ;	/* quote char during getstring()	 */
 
+void ue_system( const char *cmd) {
+    int ret ;
+
+    ret = system( cmd) ;
+    if( ret == -1) {
+    /* some actual handling needed here */
+    }
+}
 
 /*
  * Ask a yes or no question in the message line. Return either TRUE, FALSE, or
@@ -62,16 +63,16 @@ static const int quotec = 0x11 ;	/* quote char during getstring()	 */
  */
 int mlyesno( const char *prompt)
 {
-    char c;         /* input character */
+    int	c ;         /* input character */
 
     for (;;) {
         /* prompt the user */
-		mlwrite( "%s (y/n)? ", prompt) ;
+		mloutfmt( "%s (y/n)? ", prompt) ;
 
         /* get the response */
-        c = tgetc();
+        c = get1key() ;
 
-        if (c == ectoc(abortc)) /* Bail out! */
+        if( c == abortc) /* Bail out! */
             return ABORT;
 
         if (c == 'y' || c == 'Y')
@@ -142,15 +143,16 @@ int newmlargt( char **outbufref, const char *prompt, int size) {
 /*
  * ectoc:
  *  expanded character to character
- *  collapse the CONTROL and SPEC flags back into an ascii code
+ *  collapse the CTL_ and SPEC flags back into an ascii code
  */
-int ectoc(int c)
+int ectoc( int c) {
-{
+	if( c & CTL_)
-    if (c & CONTROL)
+		c ^= CTL_ | 0x40 ;
-        c = c & ~(CONTROL | 0x40);
+
-    if (c & SPEC)
+	if( c & SPEC)
-        c = c & 255;
+		c &= 255 ;
-    return c;
+
+	return c ;
 }
 
 /*
@@ -158,12 +160,11 @@ int ectoc(int c)
  * that pressing a <SPACE> will attempt to complete an unfinished command
  * name if it is unique.
  */
-fn_t getname(void)
+nbind_p getname( void) {
-{
     int cpos;   /* current column on screen output */
-    struct name_bind *ffp;  /* first ptr to entry in name binding table */
+    nbind_p ffp;  /* first ptr to entry in name binding table */
-    struct name_bind *cffp; /* current ptr to entry in name binding table */
+    nbind_p cffp; /* current ptr to entry in name binding table */
-    struct name_bind *lffp; /* last ptr to entry in name binding table */
+    nbind_p lffp; /* last ptr to entry in name binding table */
     char buf[NSTRING];  /* buffer to hold tentative command name */
 
     /* starting at the beginning of the string buffer */
@@ -173,7 +174,7 @@ fn_t getname(void)
     if (clexec) {
 		if( TRUE != gettokval( buf, sizeof buf))
             return NULL;
-        return fncmatch(&buf[0]);
+        return fncmatch( buf) ;
     }
 
     /* build a name string from the keyboard */
@@ -187,86 +188,65 @@ fn_t getname(void)
             buf[cpos] = 0;
 
             /* and match it off */
-            return fncmatch(&buf[0]);
+            return fncmatch( buf) ;
 
-        } else if (c == ectoc(abortc)) {    /* Bell, abort */
+        } else if( c == ectoc(abortc)) {    /* Bell, abort */
-            ctrlg(FALSE, 0);
+            ctrlg( FALSE, 1) ;
-            TTflush();
+            TTflush() ;
-            return NULL;
+            return NULL ;
 
         } else if (c == 0x7F || c == 0x08) {    /* rubout/erase */
             if (cpos != 0) {
-				echos( "\b \b") ;
+				rubout() ;
-                --ttcol;
                 --cpos;
                 TTflush();
             }
 
         } else if (c == 0x15) { /* C-U, kill */
             while (cpos != 0) {
-				echos( "\b \b") ;
+				rubout() ;
                 --cpos;
-                --ttcol;
             }
 
             TTflush();
 
         } else if (c == ' ' || c == 0x1b || c == 0x09) {
 /* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
-            /* attempt a completion */
+        /* attempt a completion */
-            buf[cpos] = 0;  /* terminate it for us */
+            buf[ cpos] = 0 ;  /* terminate it for us */
-            ffp = &names[0];    /* scan for matches */
+			int buflen = strlen( buf) ;
-            while (ffp->n_func != NULL) {
+		/* scan for matches */
-                if (strncmp(buf, ffp->n_name, strlen(buf))
+            for( ffp = names ; ffp->n_func != NULL ; ffp++) {
-                    == 0) {
+                if( strncmp( buf, bind_name( ffp), buflen) == 0) {
                     /* a possible match! More than one? */
-                    if ((ffp + 1)->n_func == NULL ||
+                    if( (ffp + 1)->n_func == NULL ||
-                        (strncmp
+                        (strncmp( buf, bind_name( ffp + 1), buflen) != 0)) {
-                         (buf, (ffp + 1)->n_name,
-                          strlen(buf)) != 0)) {
                         /* no...we match, print it */
-						echos( ffp->n_name + cpos) ;
+						echos( &bind_name( ffp)[ cpos]) ;
-                        TTflush();
+                        TTflush() ;
-                        return ffp->n_func;
+                        return ffp ;
                     } else {
 /* << << << << << << << << << << << << << << << << << */
                         /* try for a partial match against the list */
 
-                        /* first scan down until we no longer match the current input */
+                        /* first scan down until we no longer match the
-                        lffp = (ffp + 1);
+						 * current input */
-                        while ((lffp +
+                        for( lffp = ffp + 1 ; (lffp + 1)->n_func != NULL ;
-                            1)->n_func !=
+																		lffp++)
-                               NULL) {
+                            if( strncmp( buf, bind_name( lffp + 1),
-                            if (strncmp
+							                                 	buflen) != 0)
-                                (buf,
+                                break ;
-                                 (lffp +
-                                  1)->n_name,
-                                 strlen(buf))
-                                != 0)
-                                break;
-                            ++lffp;
-                        }
 
-                        /* and now, attempt to partial complete the string, char at a time */
+                        /* and now, attempt to partial complete the string,
+						 * one char at a time */
                         while (TRUE) {
                             /* add the next char in */
-                            buf[cpos] =
+                            buf[ cpos] = bind_name( ffp)[ cpos] ;
-                                ffp->
-                                n_name[cpos];
 
                             /* scan through the candidates */
-                            cffp = ffp + 1;
+                            for( cffp = ffp + 1 ; cffp <= lffp ; cffp++)
-                            while (cffp <=
+                                if( bind_name( cffp)[ cpos] != buf[ cpos])
-                                   lffp) {
+                                    goto onward ;
-                                if (cffp->
-                                    n_name
-                                    [cpos]
-                                    !=
-                                    buf
-                                    [cpos])
-                                    goto onward;
-                                ++cffp;
-                            }
 
                             /* add the character */
                             echoc( buf[ cpos++]) ;
@@ -274,22 +254,19 @@ fn_t getname(void)
 /* << << << << << << << << << << << << << << << << << */
                     }
                 }
-                ++ffp;
             }
 
             /* no match.....beep and onward */
             TTbeep();
-              onward:;
+        onward:
             TTflush();
 /* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
         } else {
-            if (cpos < NSTRING - 1 && c > ' ') {
+            if( cpos < NSTRING - 1 && (islower( c) || c == '-')) {
                 buf[cpos++] = c;
                 echoc( c) ;
+				TTflush();
             }
-
-            ++ttcol;
-            TTflush();
         }
     }
 }
@@ -308,7 +285,7 @@ int tgetc(void)
         if (kbdptr < kbdend)
             return (int) *kbdptr++;
 
-        /* at the end of last repitition? */
+        /* at the end of last repetition? */
         if (--kbdrep < 1) {
             kbdmode = STOP;
 #if VISMAC == 0
@@ -345,172 +322,181 @@ int tgetc(void)
     return c;
 }
 
-/*  GET1KEY:    Get one keystroke. The only prefixs legal here
+/*  GET1KEY: Get one keystroke. The only prefixes legal here are the SPEC
-            are the SPEC and CONTROL prefixes.
+    and CTL_ prefixes. */
-                                */
+static int get1unicode( int *up) {
+/* Accept UTF-8 sequence */
+	int bytes ;
 
-int get1key(void)
+	int c = tgetc() ;
-{
+	if( c > 0xC1 && c <= 0xF4) {
-    int c;
-
-    /* get a keystroke */
-    c = tgetc();
-
-#if MSDOS
-    if (c == 0) {       /* Apply SPEC prefix    */
-        c = tgetc();
-        if (c >= 0x00 && c <= 0x1F) /* control key? */
-            c = CONTROL | (c + '@');
-        return SPEC | c;
-    }
-#endif
-
-    if (c >= 0x00 && c <= 0x1F) /* C0 control -> C-     */
-        c = CONTROL | (c + '@');
-    return c;
-}
-
-/*  GETCMD: Get a command from the keyboard. Process all applicable
-        prefix keys
-                            */
-int getcmd(void)
-{
-    int c;          /* fetched keystroke */
-#if VT220
-    int d;          /* second character P.K. */
-    int cmask = 0;
-#endif
-    /* get initial character */
-    c = get1key();
-
-#if VT220
-      proc_metac:
-#endif
-    if (c == 128+27)        /* CSI */
-        goto handle_CSI;
-    /* process META prefix */
-    if (c == (CONTROL | '[')) {
-        c = get1key();
-#if VT220
-        if (c == '[' || c == 'O') { /* CSI P.K. */
-handle_CSI:
-            c = get1key();
-            if (c >= 'A' && c <= 'D')
-                return SPEC | c | cmask;
-            if (c >= 'E' && c <= 'z' && c != 'i' && c != 'c')
-                return SPEC | c | cmask;
-            d = get1key();
-            if (d == '~')   /* ESC [ n ~   P.K. */
-                return SPEC | c | cmask;
-            switch (c) {    /* ESC [ n n ~ P.K. */
-            case '1':
-                c = d + 32;
-                break;
-            case '2':
-                c = d + 48;
-                break;
-            case '3':
-                c = d + 64;
-                break;
-            default:
-                c = '?';
-                break;
-            }
-            if (d != '~')   /* eat tilde P.K. */
-                get1key();
-            if (c == 'i') { /* DO key    P.K. */
-                c = ctlxc;
-                goto proc_ctlxc;
-            } else if (c == 'c')    /* ESC key   P.K. */
-                c = get1key();
-            else
-                return SPEC | c | cmask;
-        }
-#endif
-#if VT220
-        if (c == (CONTROL | '[')) {
-            cmask = META;
-            goto proc_metac;
-        }
-#endif
-        if (islower(c)) /* Force to upper */
-            c ^= DIFCASE;
-        if (c >= 0x00 && c <= 0x1F) /* control key */
-            c = CONTROL | (c + '@');
-        return META | c;
-    }
-#if PKCODE
-    else if (c == metac) {
-        c = get1key();
-#if VT220
-        if (c == (CONTROL | '[')) {
-            cmask = META;
-            goto proc_metac;
-        }
-#endif
-        if (islower(c)) /* Force to upper */
-            c ^= DIFCASE;
-        if (c >= 0x00 && c <= 0x1F) /* control key */
-            c = CONTROL | (c + '@');
-        return META | c;
-    }
-#endif
-
-
-#if VT220
-      proc_ctlxc:
-#endif
-    /* process CTLX prefix */
-    if (c == ctlxc) {
-        c = get1key();
-#if VT220
-        if (c == (CONTROL | '[')) {
-            cmask = CTLX;
-            goto proc_metac;
-        }
-#endif
-        if (c >= 'a' && c <= 'z')   /* Force to upper */
-            c -= 0x20;
-        if (c >= 0x00 && c <= 0x1F) /* control key */
-            c = CONTROL | (c + '@');
-        return CTLX | c;
-    }
-
-#ifdef CYGWIN
-	/* Accept UTF-8 sequence */
-	if( c <= 0xC1 || c > 0xF4)
-		return c ;
-	else {
 		char utf[ 4] ;
-		char cc ;
+    	char cc ;
 
 		utf[ 0] = c ;
-		utf[ 1] = cc = get1key() ;
+		utf[ 1] = cc = tgetc() ;
 		if( (c & 0x20) && ((cc & 0xC0) == 0x80)) { /* at least 3 bytes and a valid encoded char */
-			utf[ 2] = cc = get1key() ;
+			utf[ 2] = cc = tgetc() ;
 			if( (c & 0x10) && ((cc & 0xC0) == 0x80)) /* at least 4 bytes and a valid encoded char */
-				utf[ 3] = get1key() ;
+				utf[ 3] = tgetc() ;
 		}
 
-		utf8_to_unicode( utf, 0, sizeof utf, (unicode_t *) &c) ;
+		bytes = utf8_to_unicode( utf, 0, sizeof utf, (unicode_t *) up) ;
+	} else {
+	    if( (c >= 0x00 && c <= 0x1F) || c == 0x7F)	/* C0 control -> C- */
+			c ^= CTL_ | 0x40 ;
+
+		*up = c ;
+		bytes = 1 ;
 	}
-#endif
+
-	
+    return bytes ;
-    /* otherwise, just return it */
+}
-    return c;
+
+/* Terminal sequences need up to 7 read ahead characters */
+#define STACKSIZE	7
+static int keystack[ STACKSIZE] ;
+static int *stackptr = &keystack[ STACKSIZE] ;
+#define KPUSH( c) *(--stackptr) = (c)
+
+int get1key( void) {
+	int c ;
+
+/* fetch from queue if any were pushed back */
+	if( stackptr != &keystack[ STACKSIZE])
+		return *(stackptr++) ;
+
+/* fetch from keyboard */
+	get1unicode( &c) ;
+	return c ;
+}
+
+/* GETCMD: Get a command from the keyboard.  Process all applicable prefix
+   keys.  Handle alted and controlled FNx, not shifted.
+*/
+int getcmd( void) {
+	int prefix = 0 ;			/* prefixes M- or ^X */
+	int keyread[ STACKSIZE] ;	/* room to process sequences like ^[[24;2~ */
+	int *kptr = keyread ;
+	int c ;
+
+	for( ;;) {
+		c = *(kptr++) = get1key() ;
+		if( c == 0x9B)
+			goto foundCSI ;
+		else if( c == (CTL_ | '[')) {
+		/* fetch terminal sequence */
+			c = *(kptr++) = get1key() ;
+			if( c == 'O') {	/* F1 .. F4 */
+				c = *(kptr++) = get1key() ;
+				if( c >= 'P' && c <= 'S')
+					return c | SPEC | prefix ;
+			} else if( c == '[') {
+				int v1, v ;		/* ^[[v1;v~ or ^[[v~ */
+
+			foundCSI:
+				v1 = v = 0 ;
+				while( kptr < &keyread[ STACKSIZE]) {
+					c = *(kptr++) = get1key() ;
+					if( (c == '~')
+					||	(c >= 'A' && c <= 'Z')
+					||	(c >= 'a' && c <= 'z')) {
+					/* Found end of sequence */
+						int mask = prefix ;
+						if( v1) {	/* Handle ALT/CTL, not SHFT */
+							if( (v - 1) & 2)
+								mask = META ;
+
+							if( (v - 1) & 4)
+								mask |= CTL_ ;
+
+							v = v1 ;
+						}
+
+						if( c == '~') {
+							if( v)
+								c = v + ((v <= 9) ? '0' : 'a' - 10) ;
+							else
+								break ;
+						}
+
+						return c | SPEC | mask ;
+					} else if( c == ';') {	/* Start of SHFT/ALT/CTL state */
+						v1 = v ;
+						v = 0 ;
+					} else if( c >= '0' && c <= '9')
+						v = v * 10 + c - '0' ;
+					else
+						break ;
+				}
+			}
+
+		/* not a match, unget the keys read so far */
+			while( kptr > keyread)
+				KPUSH( *(--kptr)) ;
+
+			c = get1key() ;
+		} else
+			kptr-- ;
+
+		if( c == metac) {
+			prefix = META ;
+		} else if( c == ctlxc) {
+			if( prefix)
+				break ;	/* ^X^X or M-^X */
+			else
+				prefix = CTLX ;
+		} else
+			break ;
+	}
+
+	if( prefix && islower( c))
+		c = flipcase( c) ;
+
+    return c | prefix ;
 }
 
 /*  A more generalized prompt/reply function allowing the caller
     to specify the proper terminator. If the terminator is not
     a return ('\n') it will echo as "<NL>"
-                            */
+*/
+
+static void echov( int c) {
+/* verbose echo of a character */
+	if( c == '\n')		/* put out <NL> for <ret> */
+		echos( "<NL>") ;
+	else {
+		if( c < ' ' || c == 0x7F) {
+			echoc( '^') ;
+			c ^= 0x40 ;
+		}
+
+		echoc( c) ;
+	}
+}
+
+static void rubc( int c) {
+	rubout() ;
+	if( (c >= 0 && c < ' ') || c == 0x7F) {
+	/* ^x range */
+		rubout() ;
+		if( c == '\n') {	/* <NL> */
+			rubout() ;
+			rubout() ;
+		}
+	} else if( utf8_width( c) == 2)
+		rubout() ;
+}
+
 int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
 {
     int cpos;   /* current character position in string */
     int c;
-    boolean quotef ;    /* are we quoting the next char? */
+    boolean quote_f ;    /* are we quoting the next char? */
+	int retval ;		/* TRUE, FALSE, ABORT */
 #if COMPLC
-    int ffile, ocpos, nskip = 0, didtry = 0;
+	boolean file_f ;
+    int ocpos, nskip = 0, didtry = 0;
 #if     MSDOS
     struct ffblk ffblk;
     char *fcp;
@@ -519,16 +505,16 @@ int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
     static char tmp[] = "/tmp/meXXXXXX";
     FILE *tmpf = NULL;
 #endif
-/*	Look for "Find file: ", "View file: ", "Insert file: ", "Write file: ",
+/*	Look for "find-file: ", "View file: ", "Insert file: ", "Write file: ",
 **	"Read file: ", "Execute file: " */
-	ffile = NULL != strstr( prompt, " file: ") ;
+	file_f = NULL != strstr( prompt, "file: ") ;
 #endif
 
     cpos = 0;
-    quotef = FALSE;
+    quote_f = FALSE;
 
     /* prompt the user for the input string */
-    mlwrite( "%s", prompt);
+    mloutstr( prompt);
 
     for (;;) {
 #if COMPLC
@@ -536,89 +522,63 @@ int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
             nskip = -1;
         didtry = 0;
 #endif
-        /* get a character from the user */
+	/* get a character from the user */
-        c = get1key();
+		int bytes = get1unicode( &c) ;
 
-        /* If it is a <ret>, change it to a <NL> */
+	/* Quoting? Store as it is */
-#if PKCODE
+		if( quote_f == TRUE) {
-        if (c == (CONTROL | 0x4d) && !quotef)
+			quote_f = FALSE ;
-#else
+			if( cpos < nbuf - bytes) {
-        if (c == (CONTROL | 0x4d))
+				c = ectoc( c) ;
-#endif
+				cpos += unicode_to_utf8( c, &buf[ cpos]) ;
-            c = CONTROL | 0x40 | '\n';
+				echov( c) ;
-
+				TTflush() ;
-        /* if they hit the line terminate, wrap it up */
-        if (c == eolchar && quotef == FALSE) {
-            buf[cpos++] = 0;
-
-            /* clear the message line */
-            mlwrite("");
-            TTflush();
-
-			if( tmpf != NULL) {
-				fclose( tmpf) ;
-				unlink( tmp) ;
 			}
 
-            /* if we default the buffer, return FALSE */
+			continue ;
-            if (buf[0] == 0)
+		}
-                return FALSE;
 
-            return TRUE;
+	/* If it is a <ret>, change it to a <NL> */
-        }
+        if( c == (CTL_ | 'M'))
+            c = CTL_ | 0x40 | '\n' ;
 
-        /* change from command form back to character form */
+        if( c == eolchar) {
-        c = ectoc(c);
+		/* if they hit the line terminator, wrap it up */
+            buf[ cpos] = 0 ;
 
-        if (c == ectoc(abortc) && quotef == FALSE) {
+		/* clear the message line */
-            /* Abort the input? */
+            mloutstr( "") ;
-            ctrlg(FALSE, 0);
-            TTflush();
-			if( tmpf != NULL) {
-				fclose( tmpf) ;
-				unlink( tmp) ;
-			}
 
-            return ABORT;
+		/* if we default the buffer, return FALSE */
-        } else if ((c == 0x7F || c == 0x08) && quotef == FALSE) {
+			retval = cpos != 0 ;
-            /* rubout/erase */
+			break ;
+        } else if( c == abortc) {
+		/* Abort the input? */
+            retval = ctrlg( FALSE, 1) ;
+			break ;
+		}
+
+	/* change from command form back to character form */
+        c = ectoc( c) ;
+
+        if( c == 0x7F || c == 0x08) {
+		/* rubout/erase */
             if (cpos != 0) {
-                echos("\b \b");
+				int c ;
-                --ttcol;
-
-                if (buf[--cpos] < 0x20) {
-                    echos("\b \b");
-                    --ttcol;
-                }
-                if (buf[cpos] == '\n') {
-                    echos("\b\b  \b\b");
-                    ttcol -= 2;
-                }
 
+				cpos -= 1 ;
+				cpos -= utf8_revdelta( (unsigned char *) &buf[ cpos], cpos) ;
+				utf8_to_unicode( &buf[ cpos], 0, 4, (unicode_t *) &c) ;
+				rubc( c) ;
                 TTflush();
             }
-
+        } else if( c == 0x15) {
-        } else if (c == 0x15 && quotef == FALSE) {
+        /* C-U, kill */
-            /* C-U, kill */
+			mloutstr( prompt) ;
-            while (cpos != 0) {
+			cpos = 0 ;
-                echos("\b \b");
-                --ttcol;
-
-                if (buf[--cpos] < 0x20) {
-                    echos("\b \b");
-                    --ttcol;
-                }
-                if (buf[cpos] == '\n') {
-                    echos("\b\b  \b\b");
-                    ttcol -= 2;
-                }
-            }
-            TTflush();
-
 #if COMPLC
-        } else if ((c == 0x09 || c == ' ') && quotef == FALSE
+        } else if( (c == 0x09 || c == ' ') && file_f) {
-               && ffile) {
+        /* TAB, complete file name */
-            /* TAB, complete file name */
             char ffbuf[255];
 #if MSDOS
             char sffbuf[128];
@@ -628,29 +588,16 @@ int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
 
             didtry = 1;
             ocpos = cpos;
-            while (cpos != 0) {
+			mloutstr( prompt) ;
-                echos("\b \b");
+			while( cpos != 0) {
-                --ttcol;
+				c = buf[ --cpos] ;
+                if( c == '*' || c == '?') {
+                    iswild = 1 ;
+					cpos = 0 ;
+					break ;
+				}
+			}
 
-                if (buf[--cpos] < 0x20) {
-                    echos("\b \b");
-                    --ttcol;
-                }
-                if (buf[cpos] == '\n') {
-                    echos("\b\b  \b\b");
-                    ttcol -= 2;
-                }
-                if (buf[cpos] == '*' || buf[cpos] == '?')
-                    iswild = 1;
-#if MSDOS
-                if (lsav < 0 && (buf[cpos] == '\\' ||
-                         buf[cpos] == '/' ||
-                         buf[cpos] == ':'
-                         && cpos == 1))
-                    lsav = cpos;
-#endif
-            }
-            TTflush();
             if (nskip < 0) {
                 buf[ocpos] = 0;
 #if UNIX
@@ -721,50 +668,37 @@ int getstring( const char *prompt, char *buf, int nbuf, int eolchar)
                 TTbeep();
 #endif
 
-            for (n = 0; n < cpos; n++) {
+            for( n = 0 ; n < cpos ; ) {
-                c = buf[n];
+				n += utf8_to_unicode( buf, n, nbuf, (unicode_t *) &c) ;
-                if ((c < ' ') && (c != '\n')) {
+				echov( c) ;
-                    echoc( '^') ;
-                    ++ttcol;
-                    c ^= 0x40;
-                }
-
-                if( c != '\n')
-					echoc( c) ;
-                else {    /* put out <NL> for <ret> */
-                    echos("<NL>");
-                    ttcol += 3;
-                }
-                ++ttcol;
             }
-            TTflush();
+
+            TTflush() ;
 #if UNIX
             rewind(tmpf);
 #endif
 #endif
 
-        } else if ((c == quotec || c == 0x16) && quotef == FALSE) {
+        } else if( c == 0x11 || c == 0x16)
-            quotef = TRUE;
+		/* ^Q or ^V */
-        } else {
+			quote_f = TRUE ;
-            quotef = FALSE;
+        else {
-            if (cpos < nbuf - 1) {
+		/* store as it is */
-                buf[cpos++] = c;
+            if( cpos + bytes < nbuf) {
-
+				cpos += unicode_to_utf8( c, &buf[ cpos]) ;
-                if ((c < ' ') && (c != '\n')) {
+				echov( c) ;
-                    echoc( '^') ;
+				TTflush() ;
-                    ++ttcol;
-                    c ^= 0x40;
-                }
-
-                if( c != '\n')
-					echoc( c) ;
-                else {    /* put out <NL> for <ret> */
-                    echos("<NL>");
-                    ttcol += 3;
-                }
-                ++ttcol;
-                TTflush();
             }
-        }
+		}
     }
+
+	TTflush() ;
+	if( tmpf != NULL) {
+		fclose( tmpf) ;
+		unlink( tmp) ;
+	}
+
+	return retval ;
 }
+
+/* end of input.c */

input.h

@@ -1,34 +1,41 @@
+/* input.h -- */
 #ifndef _INPUT_H_
 #define _INPUT_H_
 
-#include "bind.h"
+#include "names.h"  /* nbind_p */
-
 
 typedef enum {
-	STOP, PLAY, RECORD
+    STOP, PLAY, RECORD
 } kbdstate ;
-extern kbdstate kbdmode ;	/* current keyboard macro mode  */
-extern int lastkey ;		/* last keystoke                */
-extern int kbdrep ;		/* number of repetitions        */
-extern int kbdm[] ;		/* Holds kayboard macro data    */
-extern int *kbdptr ;		/* current position in keyboard buf */
-extern int *kbdend ;		/* ptr to end of the keyboard	*/
-
-extern int metac;		/* current meta character */
-extern int ctlxc;		/* current control X prefix char */
-extern int reptc;		/* current universal repeat char */
-extern int abortc;		/* current abort command char   */
-extern const int nlc ;	/* end of input char */
 
 
+extern kbdstate kbdmode ;   /* current keyboard macro mode  */
+extern int lastkey ;        /* last keystoke                */
+extern int kbdrep ;         /* number of repetitions        */
+extern int kbdm[] ;         /* Holds kayboard macro data    */
+extern int *kbdptr ;        /* current position in keyboard buf */
+extern int *kbdend ;        /* ptr to end of the keyboard   */
+
+extern int metac ;          /* current meta character */
+extern int ctlxc ;          /* current control X prefix char */
+extern int reptc ;          /* current universal repeat char */
+extern int abortc ;         /* current abort command char   */
+extern const int nlc ;      /* end of input char */
+
+
+void ue_system( const char *cmd) ;
 int mlyesno( const char *prompt) ;
 int newmlarg( char **outbufref, const char *prompt, int size) ;
 int newmlargt( char **outbufref, const char *prompt, int size) ;
 int ectoc( int c) ;
-fn_t getname( void) ;
+
+/* Get a command binding from the command line or interactively */
+nbind_p getname( void) ;
+
 int tgetc( void) ;
 int get1key( void) ;
 int getcmd( void) ;
 int getstring( const char *prompt, char *buf, int nbuf, int eolchar) ;
 
 #endif
+/* end of input.h */

isa.h

@@ -0,0 +1,41 @@
+/* isa.h -- isletter, islower, isupper, flipcase */
+#ifndef __ISA_H__
+#define __ISA_H__
+
+#ifdef  islower
+# undef islower
+#endif
+
+#ifdef  isupper
+# undef isupper
+#endif
+
+#define NATIONL 0   /* if 1, interpret [,],\,{,},| as characters P.K.    */
+#if NATIONL
+# define LASTUL ']'
+# define LASTLL '}'
+#else
+# define LASTUL 'Z'
+# define LASTLL 'z'
+#endif
+
+#define isletter(c) __isxletter((0xFF & (c)))
+#define islower(c)  isxlower((0xFF & (c)))
+#define isupper(c)  isxupper((0xFF & (c)))
+
+#define __isxletter(c)  (('a' <= c && LASTLL >= c) || \
+                        ('A' <= c && LASTUL >= c) || (192<=c /* && c<=255 */))
+#define isxlower(c) (('a' <= c && LASTLL >= c) || (224 <= c && 252 >= c))
+#define isxupper(c) (('A' <= c && LASTUL >= c) || (192 <= c && 220 >= c))
+
+/* DIFCASE represents the integer difference between upper and lower
+   case letters. It is an xor-able value, which is fortunate, since the
+   relative positions of upper to lower case letters is the opposite of
+   ascii in ebcdic.
+*/
+
+#define DIFCASE 0x20                    /* ASCII 'a' - 'A' */
+#define flipcase( c) ((c) ^ DIFCASE)    /* Toggle the case of a letter. */
+
+#endif
+/* end of isa.h */

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,25 +23,23 @@
  *	Modified by Petri Kutvonen
  */
 
-#include <stdio.h>
 #include <string.h>
 
 #include "basic.h"
 #include "buffer.h"
+#include "defines.h"
 #include "display.h"
-#include "estruct.h"
 #include "exec.h"
 #include "input.h"
 #include "line.h"
 #include "search.h"
 #include "terminal.h"
+#include "util.h"
 #include "window.h"
 
 /*
  * Incremental search defines.
  */
-#if	ISRCH
-
 #define	CMDBUFLEN	256	/* Length of our command buffer */
 
 #define	IS_ABORT	0x07	/* Abort the isearch */
@@ -59,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) ;
@@ -72,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 */
@@ -88,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            */
 
@@ -123,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            */
 
@@ -155,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.
@@ -181,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  */
@@ -198,8 +186,7 @@ static int isearch(int f, int n)
 	cmd_reexecute = -1;	/* We're not re-executing (yet?)      */
 	cmd_offset = 0;		/* Start at the beginning of the buff */
 	cmd_buff[0] = '\0';	/* Init the command buffer            */
-	strncpy( pat_save, pat, sizeof pat_save - 1) ;	/* Save the old pattern string        */
+	mystrscpy( pat_save, pat, sizeof pat_save) ;	/* Save the old pattern string        */
-	pat_save[ sizeof pat_save - 1] = '\0' ;
 	curline = curwp->w_dotp;	/* Save the current line pointer      */
 	curoff = curwp->w_doto;	/* Save the current offset            */
 	init_direction = n;	/* Save the initial search direction  */
@@ -277,7 +264,7 @@ static int isearch(int f, int n)
 			curwp->w_dotp = curline;	/* Reset the line pointer     */
 			curwp->w_doto = curoff;	/*  and the offset            */
 			n = init_direction;	/* Reset the search direction */
-			strncpy( pat, pat_save, sizeof pat) ;	/* Restore the old search str */
+			mystrscpy( pat, pat_save, sizeof pat) ;	/* Restore the old search str */
 			cmd_reexecute = 0;	/* Start the whole mess over  */
 			goto start_over;	/* Let it take care of itself */
 
@@ -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.h

@@ -1,23 +1,24 @@
-#ifndef LINE_H_
+/* line.h -- line centric interface */
-#define LINE_H_
+#ifndef _LINE_H_
+#define _LINE_H_
 
-#include "retcode.h"
+#include "names.h"
 #include "utf8.h"
 
-/*
+/* All text is kept in circularly linked lists of "struct line" structures.
- * All text is kept in circularly linked lists of "struct line" structures.
+   These begin at the header line (which is the blank line beyond the end
- * These begin at the header line (which is the blank line beyond the end of the
+   of the buffer).  This line is pointed to by the "struct buffer".  Each
- * buffer). This line is pointed to by the "struct buffer". Each line contains a
+   line contains a number of bytes in the line (the "used" size), the size
- * number of bytes in the line (the "used" size), the size of the text array,
+   of the text array, and the text.  The end of line is not stored as a
- * and the text. The end of line is not stored as a byte; it's implied. Future
+   byte; it's implied.  Future additions will include update hints, and a
- * additions will include update hints, and a list of marks into the line.
+   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)
@@ -26,30 +27,30 @@ typedef struct line {
 #define lputc(lp, n, c) ((lp)->l_text[(n)]=(c))
 #define llength(lp)     ((lp)->l_used)
 
-extern int tabwidth ;	/* Map to $tab, default to 8, can be set to [1, .. */
+extern int tabwidth ;   /* Map to $tab, default to 8, can be set to [1, .. */
 
-char *getkill( void) ;
+/* Bindable functions */
+BBINDABLE( backchar) ;
+BBINDABLE( forwchar) ;
+ BINDABLE( insspace) ;
+ BINDABLE( yank) ;
 
-boolean backchar( int f, int n) ;
-boolean forwchar( int f, int n) ;
-
-void lfree( line_p lp) ;
 void lchange( int flag) ;
-int insspace( int f, int n) ;
+boolean linstr( char *instr) ;
-int linstr( char *instr) ;
+boolean linsert( int n, unicode_t c) ;
-int 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 *) ;
+int lgetchar( unicode_t *cref) ;
-char *getctext( void) ;
 void kdelete( void) ;
 int kinsert( int c) ;
-int yank( int f, int n) ;
+line_p lalloc( int minsize) ; 	/* Allocate a line of at least minsize chars. */
-line_p lalloc( int minsize) ;  /* Allocate a line of at least minsize chars. */
+void lfree( line_p lp) ;		/* free a line, updating buffers and windows */
+const char *getkill( void) ;	/* get value of $kill */
 
-boolean rdonly( void) ;		/* Read Only error message */
+boolean rdonly( void) ;     /* Read Only error message */
 
-#endif  /* LINE_H_ */
+#endif
+/* end of line.h */

list.c

@@ -0,0 +1,16 @@
+/* list.c -- implements list.h */
+/* Copyright © 2021 Renaud Fivet */
+#include "list.h"
+
+#include <stdlib.h> /* free() */
+
+/* free a list */
+void freelist( list_p lp) {
+	while( lp) {
+		list_p next = lp->next ;
+		free( lp) ;
+		lp = next ;
+	}
+}
+
+/* end of list.c */

list.h

@@ -0,0 +1,13 @@
+/* list.h -- generic list deletion */
+/* Copyright © 2021 Renaud Fivet */
+#ifndef _LIST_H_
+#define _LIST_H_
+
+typedef struct list {
+	struct list *next ;
+} *list_p ;
+
+void freelist( list_p lp) ;
+
+#endif
+/* end of list.h */

lock.c

@@ -1,6 +1,4 @@
 /* lock.c -- implements lock.h */
-
-#include "estruct.h"
 #include "lock.h"
 
 /*	LOCK.C
@@ -24,7 +22,11 @@
 #include "pklock.h"
 #endif
 
+#if BSD
+#include <errno.h>
+#else
 #include <sys/errno.h>
+#endif
 
 #define	NLOCKS	100			/* max # of file locks active	*/
 static char *lname[ NLOCKS] ;		/* names of all locked files	*/

lock.h

@@ -1,16 +1,15 @@
+/* lock.h -- */
 #ifndef _LOCK_H_
 #define _LOCK_H_
 
-#ifndef _ESTRUCT_H_
+#include "defines.h"	/* BSD, SVR4 */
-#error uEmacs compilation settings needs to be done!
-#endif
-
-#if	BSD | SVR4
 
+#if BSD | SVR4
 int lockchk( const char *fname) ;
 int lockrel( void) ;
 int lock( const char *fname) ;
 int unlock( const char *fname) ;
+#endif
 
 #endif
-#endif
+/* end of lock.h */

main.c

@@ -1,9 +1,6 @@
 /* main.c -- */
 
-/*
+/*	µEMACS 4.2
- *	main.c
- *
- *	µEMACS 4.2
  *
  *	Based on:
  *
@@ -69,9 +66,10 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "estruct.h"	/* Global structures and defines. */
+#include "defines.h"	/* OS specific customization */
 #if UNIX
-#include <signal.h>
+# include <signal.h>
+# include <unistd.h>
 #endif
 
 #include "basic.h"
@@ -88,22 +86,13 @@
 #include "search.h"
 #include "terminal.h"
 #include "termio.h"
+#include "util.h"
 #include "version.h"
 #include "window.h"
 
-/* For MSDOS, increase the default stack space. */
-#if MSDOS & TURBO
-#if PKCODE
-extern unsigned _stklen = 20000;
-#else
-extern unsigned _stklen = 32766;
-#endif
-#endif
-
 #if UNIX
-static void emergencyexit(int signr)
+static void emergencyexit( int signr) {
-{
+	quickexit( FALSE, 0) ;
-	quickexit(FALSE, 0);
 	quit( TRUE, 0) ; /* If quickexit fails (to save changes), do a force quit */
 }
 #endif
@@ -111,17 +100,16 @@ static void emergencyexit(int signr)
 static void edinit( char *bname) ;
 
 static void version( void) {
-    fputs( PROGRAM_NAME_PFX PROGRAM_NAME_LONG " version " VERSION "\n", stdout) ;
+    fputs( PROGRAM_NAME_UTF8 " version " VERSION "\n", stdout) ;
 }
 
 
 static void usage( void) {
-    fputs( "Usage: " PROGRAM_NAME " [OPTION].. [FILE]..\n\n"
+    fputs( "Usage: " PROGRAM_NAME " [OPTION|FILE]..\n\n"
            "      +             start at the end of file\n"
            "      +<n>          start at line <n>\n"
            "      --help        display this help and exit\n"
            "      --version     output version information and exit\n"
-           "      @cmdfile      execute startup file\n"
            "      -a|A          process error file\n"
            "      -e|E          edit file\n"
            "      -g|G<n>       go to line <n>\n"
@@ -130,17 +118,17 @@ static void usage( void) {
            "      -v|V          view file\n"
            "      -x|Xcmdfile\n"
            "      -x|X cmdfile  execute command file\n"
+           "      @cmdfile      execute startup file\n"
            , stdout) ;
 }
 
 
-int main(int argc, char **argv)
+int main( int argc, char *argv[]) {
-{
+	buffer_p bp;	/* temp buffer pointer */
-	struct buffer *bp;	/* temp buffer pointer */
 	int firstfile;	/* first file flag */
 	int carg;	/* current arg to scan */
 	int startflag;	/* startup executed flag */
-	struct buffer *firstbp = NULL;	/* ptr to first buffer in cmd line */
+	buffer_p firstbp = NULL;	/* ptr to first buffer in cmd line */
 	int viewflag;		/* are we starting in view mode? */
 	int gotoflag;		/* do we need to goto a line at start? */
 	int gline = 0;		/* if so, what line? */
@@ -148,19 +136,10 @@ int main(int argc, char **argv)
 	int errflag;		/* C error processing? */
 	bname_t bname ;	/* buffer name of file to read */
 
-#if	PKCODE & VMS
-	(void) umask(-1); /* Use old protection (this is at wrong place). */
-#endif
-
 #if	PKCODE & BSD
 	sleep(1); /* Time for window manager. */
 #endif
 
-#if	UNIX
-#ifdef SIGWINCH
-	signal(SIGWINCH, sizesignal);
-#endif
-#endif
 	if( argc == 2) {
 		if( strcmp( argv[ 1], "--help") == 0) {
 			usage() ;
@@ -173,11 +152,10 @@ int main(int argc, char **argv)
 		}
 	}
 
-	/* Initialize the editor. */
+	vtinit() ;			/* Display */
-	vtinit();		/* Display */
 	mloutfmt = mlwrite ;
-	edinit("main");		/* Buffers, windows */
+	edinit( "main") ;	/* Bindings, buffers, windows */
-	varinit();		/* user variables */
+	varinit() ;			/* user variables */
 
 	viewflag = FALSE;	/* view mode defaults off in command line */
 	gotoflag = FALSE;	/* set to off to begin with */
@@ -221,8 +199,7 @@ int main(int argc, char **argv)
 			case 's':	/* -s for initial search string */
 			case 'S':
 				searchflag = TRUE;
-				strncpy( pat, &argv[ carg][ 2], sizeof pat - 1) ;
+				mystrscpy( pat, &argv[ carg][ 2], sizeof pat) ;
-				pat[ sizeof pat -1] = 0 ;
 				break;
 			case 'v':	/* -v for View File */
 			case 'V':
@@ -236,7 +213,7 @@ int main(int argc, char **argv)
 				} else if( argv[ carg + 1]) {	/* -X filename */
 					if( startup( &argv[ carg + 1][ 0]) == TRUE)
 						startflag = TRUE ;	/* don't execute emacs.rc */
-					
+
 					carg += 1 ;
 				}
 
@@ -268,8 +245,7 @@ int main(int argc, char **argv)
 				exit( EXIT_FAILURE) ;
 			}
 
-			strncpy( bp->b_fname, argv[ carg], sizeof bp->b_fname - 1) ; /* max filename length limited to NFILEN - 1 (79) */
+			mystrscpy( bp->b_fname, argv[ carg], sizeof bp->b_fname) ; /* max filename length limited to NFILEN - 1 */
-			bp->b_fname[ sizeof bp->b_fname - 1] = 0 ;
 			bp->b_active = FALSE;
 			if (firstfile) {
 				firstbp = bp;
@@ -338,14 +314,14 @@ int main(int argc, char **argv)
  * as an argument, because the main routine may have been told to read in a
  * file by default, and we want the buffer name to be right.
  */
-static void edinit(char *bname)
+static void edinit( char *bname) {
-{
+	buffer_p bp;
-	struct buffer *bp;
+	window_p wp;
-	struct window *wp;
 
-	if( NULL == (bp = bfind( bname, TRUE, 0))	/* First buffer         */
+	if( !init_bindings()	/* initialize mapping of function to name and key */
-	||	NULL == (blistp = bfind( "*List*", TRUE, BFINVS))	/* Buffer list buffer   */
+	||  NULL == (bp = bfind( bname, TRUE, 0))				/* First buffer */
-	||	NULL == (wp = (struct window *) malloc( sizeof( struct window)))) {	/* First window         */
+	||	NULL == (blistp = bfind( "*List*", TRUE, BFINVS))	/* Buffer list */
+	||	NULL == (wp = malloc( sizeof *wp))) {				/* First window */
 		fputs( "First initialisation failed!\n", stderr) ;
 		exit( EXIT_FAILURE) ;
 	}
@@ -372,126 +348,109 @@ static void edinit(char *bname)
 	wp->w_flag = WFMODE | WFHARD;	/* Full.                */
 }
 
+
 /*****		Compiler specific Library functions	****/
 
-#if	RAMSIZE
+#if RAMSIZE 
-/*	These routines will allow me to track memory usage by placing
-	a layer on top of the standard system malloc() and free() calls.
-	with this code defined, the environment variable, $RAM, will
-	report on the number of bytes allocated via malloc.
 
-	with SHOWRAM defined, the number is also posted on the
+/* These routines will allow me to track memory usage by placing a layer on
-	end of the bottom mode line and is updated whenever it is changed.
+   top of the standard system malloc() and free() calls.  with this code
+   defined, the environment variable, $RAM, will report on the number of
+   bytes allocated via malloc.
+
+   with SHOWRAM defined, the number is also posted on the end of the bottom
+   mode line and is updated whenever it is changed.
 */
 
-static void dspram( void) ;
-
-#undef	malloc
-#undef	free
-#if 0
-char *allocate(nbytes)
-			    /* allocate nbytes and track */
-unsigned nbytes;		/* # of bytes to allocate */
-#endif
-void *allocate( size_t nbytes)
-{
-	char *mp;		/* ptr returned from malloc */
-/*	char *malloc(); */
-
-	mp = malloc(nbytes);
-	if (mp) {
-		envram += nbytes;
 #if	RAMSHOW
-		dspram();
+ static void dspram( void) ;
+#endif
+
+void *allocate( size_t nbytes) {
+	nbytes += sizeof nbytes ;			/* add overhead to track allocation */
+	size_t *mp = (malloc)( nbytes) ;	/* call the function not the macro */
+	if( mp) {
+		*mp++ = nbytes ;
+		envram += nbytes ;
+#if	RAMSHOW
+		dspram() ;
 #endif
 	}
 
-	return mp;
+	return mp ;
 }
 
-#if 0
+void release( void *mp) {
-release(mp)
+	if( mp) {
-    /* release malloced memory and track */
+		size_t *sp = mp ;
-char *mp;			/* chunk of RAM to release */
+		sp-- ;
-#endif
-void release( void *mp)
-{
-	unsigned *lp;		/* ptr to the long containing the block size */
-
-	if (mp) {
 		/* update amount of ram currently malloced */
-		lp = ((unsigned *) mp) - 1;
+		envram -= *sp ;
-		envram -= (long) *lp - 2;
+		(free)( sp) ;				/* call the function not the macro */
-		free(mp);
 #if	RAMSHOW
-		dspram();
+		dspram() ;
 #endif
 	}
 }
 
 #if	RAMSHOW
-static void dspram( void)
+static void dspram( void) {	/* display the amount of RAM currently malloced */
-{				/* display the amount of RAM currently malloced */
+	char mbuf[ 20] ;
-	char mbuf[20];
-	char *sp;
 
-	TTmove(term.t_nrow - 1, 70);
+	TTmove( term.t_nrow, term.t_ncol - 12) ;
 #if	COLOR
-	TTforg(7);
+	TTforg( 7) ;
-	TTbacg(0);
+	TTbacg(0) ;
 #endif
-	sprintf(mbuf, "[%lu]", envram);
+	sprintf( mbuf, "[%10u]", envram) ;
-	sp = &mbuf[0];
+	char *sp = mbuf ;
-	while (*sp)
+	while( *sp)
-		TTputc(*sp++);
+		TTputc( *sp++) ;
-	TTmove(term.t_nrow, 0);
+
-	movecursor(term.t_nrow, 0);
+	TTmove( term.t_nrow, 0) ;
+	movecursor( term.t_nrow, 0) ;
 }
 #endif
 #endif
 
-/*	On some primitave operation systems, and when emacs is used as
+/*	On some primitive operation systems, and when emacs is used as
 	a subprogram to a larger project, emacs needs to de-alloc its
 	own used memory
 */
 
 #if	CLEAN
 
-/*
+/* cexit()
- * cexit()
  *
  * int status;		return status of emacs
  */
 void cexit( int status) {
-	struct buffer *bp;	/* buffer list pointer */
+/* first clean up the windows */
-	struct window *wp;	/* window list pointer */
+	window_p wp = wheadp ;
-	struct window *tp;	/* temporary window pointer */
+	while( wp) {
-
+		window_p tp = wp->w_wndp ;
-	/* first clean up the windows */
+		free( wp) ;
-	wp = wheadp;
+		wp = tp ;
-	while (wp) {
-		tp = wp->w_wndp;
-		free(wp);
-		wp = tp;
 	}
-	wheadp = NULL;
+	
+	wheadp = NULL ;
 
-	/* then the buffers */
+/* then the buffers */
-	bp = bheadp;
+	buffer_p bp ;
-	while (bp) {
+	while( (bp = bheadp) != NULL) {
-		bp->b_nwnd = 0;
+		bp->b_nwnd = 0 ;
-		bp->b_flag = 0;	/* don't say anything about a changed buffer! */
+		bp->b_flag = 0 ;	/* don't say anything about a changed buffer! */
-		zotbuf(bp);
+		zotbuf( bp) ;
-		bp = bheadp;
 	}
 
-	/* and the kill buffer */
+/* and the kill buffer */
-	kdelete();
+	kdelete() ;
 
-	/* and the video buffers */
+/* and the video buffers */
-	vtfree();
+	vtfree() ;
 
-#undef	exit
+	(exit)( status) ;	/* call the function, not the macro */
-	exit(status);
 }
 #endif
+
+/* end of main.c */

maze.cmd

@@ -0,0 +1,105 @@
+## maze.cmd -- draw a block maze
+
+# 5 set $seed
+set %S $seed	# record seed
+
+# setup direction offsets
+set %D1 0
+set %D2 1
+set %D3 0
+set %D4 -1
+set %D5 0
+
+select-buffer maze
+
+# draw the maze layout
+$curwidth insert-string " "
+newline
+set %w &sub $curwidth 2
+!if &equ 0 &mod %w 2
+	set %w &sub %w 1
+!endif
+insert-string " "
+%w insert-string "▒"
+insert-string " "
+set %buf $line
+set %l &sub $pagelen 4
+!if &equ 1 &mod %l 2
+	set %l &sub %l 1
+!endif
+set %cnt %l
+!while &less 0 %cnt
+	set %cnt &sub %cnt 1
+	newline
+	insert-string %buf
+!endwhile
+newline
+set %w &add %w 1
+%w insert-string " "
+set %l &add %l 3
+
+# draw the exit
+set $curline &sub %l 2
+set $curcol &sub %w 1
+set $curchar 32
+
+# draw the maze
+set %x 2
+set %y 3
+set $curline %y
+set $curcol %x
+set $curchar 32
+set %flags 0
+set %cnt &tim &sub &div %w 2 1 &sub &div %l 2 1 
+!while &les 1 %cnt
+	!if &or &equ %flags 15 &not &equ $curchar 32
+		set %flags 0
+		set %y &add %y 2
+		!if &equ %y %l
+			set %y 3
+			set %x &add %x 2
+			!if &equ %x %w
+				set %x 2
+			!endif
+		!endif
+	!else
+		set %D &rnd 4
+		set %OX &ind &cat "%D" %D
+		set %OY &ind &cat "%D" &add %D 1
+		set $curline &add %y &tim 2 %OY
+		set %i &add %x &tim 2 %OX
+		set $curcol %i
+		!if &equ $curchar 32
+			!if &equ %D 3		# turn direction into bitmask {1,2,4,8}
+				set %D 8
+			!endif
+			set %flags &bor %flags %D	# mark direction as checked
+		!else
+			set $curchar 32
+			set %y $curline		# update current position
+			set %x %i
+			set $curline &sub %y %OY	# erase path between old and cur pos
+			set $curcol &sub %x %OX
+			set $curchar 32
+			set %flags 0
+			set %cnt &sub %cnt 1
+			update-screen
+		!endif		
+	!endif
+	set $curline %y
+	set $curcol %x
+!endwhile
+
+# id maze
+beginning-of-file
+kill-to-end-of-line
+insert-string &cat " Maze " &cat %w &cat "x" &cat &sub %l 2 &cat " #" %S
+write-message $line
+&sub $curwidth $curcol insert-string " "
+
+# draw the entrance
+set $curline 3
+set $curcol 1
+set $curchar 32
+
+unmark-buffer

mingw32.c

@@ -1,197 +0,0 @@
-/* mingw32.c -- */
-
-#ifdef MINGW32
-#include "termio.h"
-#include "terminal.h"
-
-#include <errno.h>
-#include <io.h>
-#include <memory.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "utf8.h"
-#include "wscreen.h"
-
-static void vv( void) {}
-static void vi( int i) {}
-static int is( char *s) { return *s ; }
-
-static void ttmove( int l, int c) ;
-
-#define	MARGIN	8
-#define	SCRSIZ	64
-#define	NPAUSE	10    /* # times thru update to pause. */
-
-struct terminal term = {
-	24, /* These four values are set dynamically at open time. */
-	24,
-	80,
-	80,
-	MARGIN,
-	SCRSIZ,
-	NPAUSE,
-	ttopen,
-#if	PKCODE
-	ttclose,
-#else
-	ttclose,
-#endif
-	vv,		/* ttkopen, */
-	vv,		/* ttkclose, */
-	ttgetc,
-	ttputc,
-	ttflush,
-	ttmove,
-	vv, 	/* tteeol, */
-	vv, 	/* tteeop, */
-	vv, 	/* ttbeep, */
-	vi, 	/* ttrev, */
-	is  	/* ttcres */
-#if	COLOR
-  , iv, 	/* ttfcol, */
-	iv		/* ttbcol */
-#endif
-#if     SCROLLCODE
-  , NULL		/* set dynamically at open time */
-#endif
-} ;
-
-
-int ttrow ;		/* Row location of HW cursor */
-int ttcol ;		/* Column location of HW cursor */
-
-boolean eolexist = TRUE ;	/* does clear to EOL exist?     */
-boolean revexist = FALSE ;	/* does reverse video exist?    */
-boolean sgarbf = TRUE ;		/* State of screen unknown      */
-
-char sres[ 16] ;	        /* Current screen resolution.   */
-							/* NORMAL, CGA, EGA, VGA	*/
-
-void ttopen( void) {
-	winit() ;
-	wcls() ;
-	term.t_mrow = term.t_nrow = wbottom() - wtop() ;
-	term.t_mcol = term.t_ncol = wright() - wleft() + 1 ;
-	wtitle( "uEMACS") ;
-}
-
-void ttclose( void) {
-}
-
-int ttputc( int c) {
-	char utf8[ 6] ;
-	int bytes ;
-
-	bytes = unicode_to_utf8( c, utf8) ;
-	fwrite( utf8, 1, bytes, stdout);
-	return 0 ;
-}
-
-void ttflush( void) {
-	int status ;
-
-	status = fflush( stdout);
-	while( status < 0 && errno == EAGAIN) {
-		_sleep( 1) ;
-		status = fflush( stdout) ;
-	}
-
-	if( status < 0)
-		exit( 15) ;
-}
-
-int ttgetc( void) {
-	static char buffer[ 32] ;
-	static int pending ;
-	unicode_t c ;
-	int count, bytes = 1, expected ;
-
-	count = pending ;
-	if( !count) {
-		count = read( 0, buffer, sizeof( buffer)) ;
-		if( count <= 0)
-			return 0 ;
-
-		pending = count ;
-	}
-
-	c = (unsigned char) buffer[ 0] ;
-	if( c >= 32 && c < 128)
-		goto done ;
-
-	/*
-	 * Lazy. We don't bother calculating the exact
-	 * expected length. We want at least two characters
-	 * for the special character case (ESC+[) and for
-	 * the normal short UTF8 sequence that starts with
-	 * the 110xxxxx pattern.
-	 *
-	 * But if we have any of the other patterns, just
-	 * try to get more characters. At worst, that will
-	 * just result in a barely perceptible 0.1 second
-	 * delay for some *very* unusual utf8 character
-	 * input.
-	 */
-	expected = 2 ;
-	if( (c & 0xe0) == 0xe0)
-		expected = 6 ;
-
-	/* Special character - try to fill buffer */
-	if( count < expected) {
-		int n;
-#if 0
-		ntermios.c_cc[VMIN] = 0;
-		ntermios.c_cc[VTIME] = 1;		/* A .1 second lag */
-		tcsetattr(0, TCSANOW, &ntermios);
-#endif
-		n = read(0, buffer + count, sizeof(buffer) - count);
-
-		/* Undo timeout */
-#if 0
-		ntermios.c_cc[VMIN] = 1;
-		ntermios.c_cc[VTIME] = 0;
-		tcsetattr(0, TCSANOW, &ntermios);
-#endif
-		if (n > 0)
-			pending += n;
-	}
-
-	if( pending > 1) {
-		unsigned char second = buffer[1];
-
-		/* Turn ESC+'[' into CSI */
-		if (c == 27 && second == '[') {
-			bytes = 2;
-			c = 128+27;
-			goto done;
-		}
-	}
-
-	bytes = utf8_to_unicode( buffer, 0, pending, &c) ;
-
-done:
-	pending -= bytes ;
-	memmove( buffer, buffer+bytes, pending) ;
-	return c ;
-}
-
-int typahead( void) {
-	int x ;			/* holds # of pending chars */
-
-#ifdef FIONREAD
-	if( ioctl( 0, FIONREAD, &x) < 0)
-#endif
-	x = 0 ;
-	return x ;
-}
-
-static void ttmove( int l, int c) {
-	wgoxy( c, l) ;
-}
-
-#else
-typedef void _pedantic_empty_translation_unit ;
-#endif
-
-/* end of mingw32.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

@@ -1,12 +1,13 @@
 /* mlout.h -- message line output interface */
-
 #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__ */
+#endif
-
 /* end of mlout.h */

names.c

@@ -3,20 +3,24 @@
 
 /* Name to function binding table.
  *
- * This table gives the names of all the bindable functions
+ * This table gives the names of all the bindable functions and their C
- * and their C function address. These are used for the bind-to-key
+ * function address.  These are used for the bind-to-key function and
- * function.
+ * command line parsing.
-*/
+ */
 
+#include <assert.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "basic.h"
 #include "bind.h"
 #include "bindable.h"
 #include "buffer.h"
+#include "defines.h"	/* malloc/allocate */
 #include "display.h"
 #include "eval.h"
 #include "exec.h"
+#include "execute.h"
 #include "file.h"
 #include "isearch.h"
 #include "line.h"
@@ -24,212 +28,415 @@
 #include "random.h"
 #include "search.h"
 #include "spawn.h"
+#include "util.h"
 #include "window.h"
 #include "word.h"
 
-struct name_bind names[] = {
-	{"abort-command", ctrlg},
-	{"add-mode", setemode},
-	{"add-global-mode", setgmode},
-#if	APROP
-	{"apropos", apro},
-#endif
-	{"backward-character", (fn_t) backchar},
-	{"begin-macro", ctlxlp},
-	{"beginning-of-file", (fn_t) gotobob},
-	{"beginning-of-line", (fn_t) gotobol},
-	{"bind-to-key", bindtokey},
-	{"buffer-position", showcpos},
-	{"case-region-lower", lowerregion},
-	{"case-region-upper", upperregion},
-	{"case-word-capitalize", capword},
-	{"case-word-lower", lowerword},
-	{"case-word-upper", upperword},
-	{"change-file-name", filename},
-	{"change-screen-size", newsize},
-	{"change-screen-width", newwidth},
-	{"clear-and-redraw", redraw},
-	{"clear-message-line", clrmes},
-	{"copy-region", copyregion},
-#if	WORDPRO
-	{"count-words", wordcount},
-#endif
-	{"ctlx-prefix", cex},
-	{"delete-blank-lines", deblank},
-	{"delete-buffer", killbuffer},
-	{"delete-mode", delmode},
-	{"delete-global-mode", delgmode},
-	{"delete-next-character", forwdel},
-	{"delete-next-word", delfword},
-	{"delete-other-windows", onlywind},
-	{"delete-previous-character", backdel},
-	{"delete-previous-word", delbword},
-	{"delete-window", delwind},
-	{"describe-bindings", desbind},
-	{"describe-key", deskey},
-#if	AEDIT
-	{"detab-line", detab},
-#endif
-	{"end-macro", ctlxrp},
-	{"end-of-file", (fn_t) gotoeob},
-	{"end-of-line", (fn_t) gotoeol},
-#if	AEDIT
-	{"entab-line", entab},
-#endif
-	{"exchange-point-and-mark", (fn_t) swapmark},
-	{"execute-buffer", execbuf},
-	{"execute-command-line", execcmd},
-	{"execute-file", execfile},
-	{"execute-macro", ctlxe},
-	{"execute-macro-1", cbuf1},
-	{"execute-macro-2", cbuf2},
-	{"execute-macro-3", cbuf3},
-	{"execute-macro-4", cbuf4},
-	{"execute-macro-5", cbuf5},
-	{"execute-macro-6", cbuf6},
-	{"execute-macro-7", cbuf7},
-	{"execute-macro-8", cbuf8},
-	{"execute-macro-9", cbuf9},
-	{"execute-macro-10", cbuf10},
-	{"execute-macro-11", cbuf11},
-	{"execute-macro-12", cbuf12},
-	{"execute-macro-13", cbuf13},
-	{"execute-macro-14", cbuf14},
-	{"execute-macro-15", cbuf15},
-	{"execute-macro-16", cbuf16},
-	{"execute-macro-17", cbuf17},
-	{"execute-macro-18", cbuf18},
-	{"execute-macro-19", cbuf19},
-	{"execute-macro-20", cbuf20},
-	{"execute-macro-21", cbuf21},
-	{"execute-macro-22", cbuf22},
-	{"execute-macro-23", cbuf23},
-	{"execute-macro-24", cbuf24},
-	{"execute-macro-25", cbuf25},
-	{"execute-macro-26", cbuf26},
-	{"execute-macro-27", cbuf27},
-	{"execute-macro-28", cbuf28},
-	{"execute-macro-29", cbuf29},
-	{"execute-macro-30", cbuf30},
-	{"execute-macro-31", cbuf31},
-	{"execute-macro-32", cbuf32},
-	{"execute-macro-33", cbuf33},
-	{"execute-macro-34", cbuf34},
-	{"execute-macro-35", cbuf35},
-	{"execute-macro-36", cbuf36},
-	{"execute-macro-37", cbuf37},
-	{"execute-macro-38", cbuf38},
-	{"execute-macro-39", cbuf39},
-	{"execute-macro-40", cbuf40},
-	{"execute-named-command", namedcmd},
-#if	PROC
-	{"execute-procedure", execproc},
-#endif
-	{"execute-program", execprg},
-	{"exit-emacs", quit},
-#if	WORDPRO
-	{"fill-paragraph", fillpara},
-#endif
-	{"filter-buffer", filter_buffer},
-	{"find-file", filefind},
-	{"forward-character", (fn_t) forwchar},
-	{"goto-line", gotoline},
-#if	CFENCE
-	{"goto-matching-fence", getfence},
-#endif
-	{"grow-window", enlargewind},
-	{"handle-tab", insert_tab},
-	{"hunt-forward", forwhunt},
-	{"hunt-backward", backhunt},
-	{"help", help},
-	{"i-shell", spawncli},
-#if	ISRCH
-	{"incremental-search", fisearch},
-#endif
-	{"insert-file", insfile},
-	{"insert-space", insspace},
-	{"insert-string", istring},
-#if	WORDPRO
-#if	PKCODE
-	{"justify-paragraph", justpara},
-#endif
-	{"kill-paragraph", killpara},
-#endif
-	{"kill-region", killregion},
-	{"kill-to-end-of-line", killtext},
-	{"list-buffers", listbuffers},
-	{"meta-prefix", metafn},
-	{"move-window-down", mvdnwind},
-	{"move-window-up", mvupwind},
-	{"name-buffer", namebuffer},
-	{"newline", insert_newline},
-	{"newline-and-indent", indent},
-	{"next-buffer", nextbuffer},
-	{"next-line", (fn_t) forwline},
-	{"next-page", (fn_t) forwpage},
-#if	WORDPRO
-	{"next-paragraph", gotoeop},
-#endif
-	{"next-window", nextwind},
-	{"next-word", forwword},
-	{"nop", nullproc},
-	{"open-line", openline},
-	{"overwrite-string", ovstring},
-	{"pipe-command", pipecmd},
-	{"previous-line", (fn_t) backline},
-	{"previous-page", (fn_t) backpage},
-#if	WORDPRO
-	{"previous-paragraph", gotobop},
-#endif
-	{"previous-window", prevwind},
-	{"previous-word", backword},
-	{"query-replace-string", qreplace},
-	{"quick-exit", quickexit},
-	{"quote-character", quote},
-	{"read-file", fileread},
-	{"redraw-display", reposition},
-	{"resize-window", resize},
-	{"restore-window", restwnd},
-	{"replace-string", sreplace},
-#if	ISRCH
-	{"reverse-incremental-search", risearch},
-#endif
-#if	PROC
-	{"run", execproc},
-#endif
-	{"save-file", filesave},
-	{"save-window", savewnd},
-	{"scroll-next-up", scrnextup},
-	{"scroll-next-down", scrnextdw},
-	{"search-forward", forwsearch},
-	{"search-reverse", backsearch},
-	{"select-buffer", usebuffer},
-	{"set", setvar},
-	{"set-fill-column", setfillcol},
-	{"set-mark", (fn_t) setmark},
-	{"shell-command", spawn},
-	{"shrink-window", shrinkwind},
-	{"split-current-window", splitwind},
-	{"store-macro", storemac},
-#if	PROC
-	{"store-procedure", storeproc},
-#endif
-#if	BSD | __hpux | SVR4
-	{"suspend-emacs", bktoshell},
-#endif
-	{"transpose-characters", (fn_t) twiddle},
-#if	AEDIT
-	{"trim-line", trim},
-#endif
-	{"unbind-key", unbindkey},
-	{"universal-argument", unarg},
-	{"unmark-buffer", unmark},
-	{"update-screen", upscreen},
-	{"view-file", viewfile},
-	{"wrap-word", wrapword},
-	{"write-file", filewrite},
-	{"write-message", writemsg},
-	{"yank", yank},
 
-	{"", NULL}
+const name_bind names[] = {
-};
+	{" 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,		CTL_ | 'B'} ,
+	{" begin-macro", (fnp_t) ctlxlp,				CTLX | '('} ,
+	{" beginning-of-file", (fnp_t) gotobob,			META | '<'} ,
+	{" beginning-of-line", (fnp_t) gotobol,			CTL_ | 'A'} ,
+	{" bind-to-key", bindtokey,						META | 'K'} ,
+	{" buffer-position", showcpos,					CTLX | '='} ,
+	{"!case-region-lower", lowerregion,				CTLX | CTL_ | 'L'} ,
+	{"!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", (fnp_t) newsize,		META | CTL_ | 'D'} , /* M^S */
+	{" change-screen-width", (fnp_t) newwidth,		META | CTL_ | 'T'} ,
+	{" clear-and-redraw", (fnp_t) redraw,			CTL_ | 'L'} ,
+	{" clear-message-line", (fnp_t) clrmes, 		0} ,
+	{" copy-region", copyregion,					META | 'W'} ,
+	{" count-words", wordcount,						META | CTL_ | 'C'} ,
+	{" ctlx-prefix", (fnp_t) cex,					CTL_ | 'X'} ,
+	{"!delete-blank-lines", deblank,				CTLX | CTL_ | 'O'} ,
+	{" delete-buffer", killbuffer,					CTLX | 'K'} ,
+	{" delete-global-mode", delgmode,				META | CTL_ | 'M'} ,
+	{" delete-mode", delmode,						CTLX | CTL_ | 'M'} ,
+	{"!delete-next-character", forwdel,				CTL_ | 'D'} ,
+	{"!delete-next-word", delfword,					META | 'D'} ,
+	{" delete-other-windows", onlywind,				CTLX | '1'} ,
+	{"!delete-previous-character", backdel,			CTL_ | 'H'} , /* ^? */
+	{"!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 | CTL_ | 'D'} , /* X^A */
+	{" end-macro", (fnp_t) ctlxrp,					CTLX | ')'} ,
+	{" end-of-file", (fnp_t) gotoeob,				META | '>'} ,
+	{" end-of-line", (fnp_t) gotoeol,				CTL_ | 'E'} ,
+	{"!entab-line", entab, 							CTLX | CTL_ | 'E'} ,
+	{" 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", (fnp_t) ctlxe,				CTLX | 'E'} ,
+	{" execute-macro-1", cbuf1, 0} ,
+	{" execute-macro-10", cbuf10, 0} ,
+	{" execute-macro-11", cbuf11, 0} ,
+	{" execute-macro-12", cbuf12, 0} ,
+	{" execute-macro-13", cbuf13, 0} ,
+	{" execute-macro-14", cbuf14, 0} ,
+	{" execute-macro-15", cbuf15, 0} ,
+	{" execute-macro-16", cbuf16, 0} ,
+	{" execute-macro-17", cbuf17, 0} ,
+	{" execute-macro-18", cbuf18, 0} ,
+	{" execute-macro-19", cbuf19, 0} ,
+	{" execute-macro-2", cbuf2, 0} ,
+	{" execute-macro-20", cbuf20, 0} ,
+	{" execute-macro-21", cbuf21, 0} ,
+	{" execute-macro-22", cbuf22, 0} ,
+	{" execute-macro-23", cbuf23, 0} ,
+	{" execute-macro-24", cbuf24, 0} ,
+	{" execute-macro-25", cbuf25, 0} ,
+	{" execute-macro-26", cbuf26, 0} ,
+	{" execute-macro-27", cbuf27, 0} ,
+	{" execute-macro-28", cbuf28, 0} ,
+	{" execute-macro-29", cbuf29, 0} ,
+	{" execute-macro-3", cbuf3, 0} ,
+	{" execute-macro-30", cbuf30, 0} ,
+	{" execute-macro-31", cbuf31, 0} ,
+	{" execute-macro-32", cbuf32, 0} ,
+	{" execute-macro-33", cbuf33, 0} ,
+	{" execute-macro-34", cbuf34, 0} ,
+	{" execute-macro-35", cbuf35, 0} ,
+	{" execute-macro-36", cbuf36, 0} ,
+	{" execute-macro-37", cbuf37, 0} ,
+	{" execute-macro-38", cbuf38, 0} ,
+	{" execute-macro-39", cbuf39, 0} ,
+	{" execute-macro-4", cbuf4, 0} ,
+	{" execute-macro-40", cbuf40, 0} ,
+	{" execute-macro-5", cbuf5, 0} ,
+	{" execute-macro-6", cbuf6, 0} ,
+	{" execute-macro-7", cbuf7, 0} ,
+	{" execute-macro-8", cbuf8, 0} ,
+	{" execute-macro-9", cbuf9, 0} ,
+	{" execute-named-command", namedcmd,		META | 'X'} ,
+	{" execute-procedure", execproc,			META | CTL_ | 'E'} ,
+	{" execute-program", execprg,				CTLX | '$'} ,
+	{" exit-emacs", quit, 						CTLX | CTL_ | 'C'} ,
+	{"!fill-paragraph", fillpara,				META | 'Q'} ,
+	{"!filter-buffer", filter_buffer,			CTLX | '#'} ,
+	{" find-file", filefind, 					CTLX | CTL_ | 'F'} ,
+	{" forward-character", (fnp_t) forwchar,	CTL_ | 'F'} ,
+	{" goto-line", gotoline,					META | 'G'} ,
+#if	CFENCE
+	{" goto-matching-fence", getfence,			META | CTL_ | 'F'} ,
+#endif
+	{" grow-window", enlargewind,				CTLX | 'Z'} , /* X^ */
+	{"!handle-tab", insert_tab,					CTL_ | 'I'} ,
+	{" help", help,								META | '?'} ,
+	{" hunt-backward", backhunt, 0} ,
+	{" hunt-forward", forwhunt,					META | 'S'} ,
+	{" i-shell", spawncli,						CTLX | 'C'} ,
+	{" incremental-search", fisearch,			CTLX | 'S'} ,
+	{"!insert-file", insfile,					CTLX | CTL_ | 'I'} ,
+	{"!insert-space", insspace,					CTL_ | 'C'} ,
+	{"!insert-string", istring, 0} ,
+#if	PKCODE
+	{"!justify-paragraph", justpara,			META | 'J'} ,
+#endif
+	{"!kill-paragraph", killpara,				META | CTL_ | 'W'} ,
+	{"!kill-region", killregion, 				CTL_ | 'W'} ,
+	{"!kill-to-end-of-line", killtext, 			CTL_ | 'K'} ,
+	{" list-buffers", listbuffers, 				CTLX | CTL_ | 'B'} ,
+	{" meta-prefix", (fnp_t) metafn,			CTL_ | '['} ,
+	{" move-window-down", mvdnwind,				CTLX | CTL_ | 'N'} ,
+	{" move-window-up", mvupwind,				CTLX | CTL_ | 'P'} ,
+	{" name-buffer", namebuffer,				META | CTL_ | 'N'} ,
+	{"!newline", insert_newline, 				CTL_ | 'M'} ,
+	{"!newline-and-indent", indent, 			CTL_ | 'J'} ,
+	{" next-buffer", nextbuffer,				CTLX | 'X'} ,
+	{" next-line", (fnp_t) forwline, 			CTL_ | 'N'} ,
+	{" next-page", (fnp_t) forwpage,			CTL_ | 'V'} ,
+	{" next-paragraph", gotoeop,				META | 'N'} ,
+	{" next-window", nextwind,					CTLX | 'O'} ,
+	{" next-word", forwword,					META | 'F'} ,
+	{" nop", (fnp_t) nullproc,					META | SPEC | 'C'}, /* hook */
+	{"!open-line", openline,					CTL_ | 'O'} ,
+	{"!overwrite-string", ovstring, 0} ,
+	{" pipe-command", pipecmd,					CTLX | '@'} ,
+	{" previous-line", (fnp_t) backline, 		CTL_ | 'P'} ,
+	{" 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 | CTL_ | 'R'} ,
+	{" quick-exit", quickexit,					META | 'Z'} ,
+	{"!quote-character", quote, 				CTL_ | 'Q'} ,
+	{"!read-file", fileread,					CTLX | CTL_ | 'R'} ,
+	{" redraw-display", (fnp_t) reposition,		META | CTL_ | 'L'} ,
+	{"!replace-string", sreplace,				META | 'R'} ,
+	{" resize-window", resize,					CTLX | 'W'} ,
+	{" restore-window", restwnd, 0} ,
+	{" reverse-incremental-search", risearch,	CTLX | 'R'} ,
+	{" run", execproc, 0} ,	/* alias of execute-procedure */
+	{"!save-file", filesave,					CTLX | CTL_ | 'S'} , /* also X^D */
+	{" save-window", savewnd, 0} ,
+	{" scroll-next-down", scrnextdw,			META | CTL_ | 'V'} ,
+	{" scroll-next-up", scrnextup,				META | CTL_ | 'Z'} ,
+	{" search-forward", forwsearch, 			CTL_ | 'S'} ,
+	{" 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 | CTL_ | 'Z'} ,
+	{" split-current-window", splitwind,		CTLX | '2'} ,
+	{" store-macro", (fnp_t) storemac, 0} ,
+	{" store-procedure", storeproc, 0} ,
+#if	BSD | SVR4
+	{" suspend-emacs", bktoshell,				CTLX | 'D'} , /* BSD MS */
+#endif
+	{"!transpose-characters", (fnp_t) twiddle,	CTL_ | 'T'} ,
+	{"!trim-line", trim,						CTLX | CTL_ | 'T'} ,
+	{" unbind-key", unbindkey,					META | CTL_ | 'K'} ,
+	{" universal-argument", (fnp_t) unarg,		CTL_ | 'U'} ,
+	{" unmark-buffer", unmark,					META | '~'} ,
+	{" update-screen", (fnp_t) upscreen, 0} ,
+	{" view-file", viewfile, 					CTLX | CTL_ | 'V'} ,
+	{"!wrap-word", wrapword,					META | SPEC | 'W'} , /* hook */
+	{" write-file", filewrite,					CTLX | CTL_ | 'W'} ,
+	{" write-message", writemsg, 0} ,
+	{"!yank", yank,								CTL_ | 'Y'} ,
+
+	{" ", NULL, 0},
+/* extra key mapping */
+//	{ NULL, newsize,							META | CTL_ | 'S'},
+	{ NULL, backdel,							CTL_ | '?'},
+	{ NULL, delbword,							META | CTL_ | '?'},
+	{ NULL, detab,								CTLX | CTL_ | 'A'},
+	{ NULL, enlargewind,						CTLX | '^'},
+	{ NULL, (fnp_t) backpage,					META | 'V'},
+	{ NULL, quote,				 				CTLX | 'Q'},
+	{ NULL, (fnp_t) reposition,					META | '!'},
+//detab { NULL, filesave,						CTLX | CTL_ | 'D'},
+	{ NULL, (fnp_t) setmark,					META | '.'},
+//	{ NULL, bktoshell,							META | 'S'},
+
+/* special key mapping */
+	{ NULL, yank,								SPEC | '2'}, /* Insert */
+	{ NULL, forwdel /* killregion */,			SPEC | '3'}, /* Delete */
+    { NULL, (fnp_t) backpage,					SPEC | '5'}, /* Page Up */
+    { NULL, (fnp_t) forwpage,					SPEC | '6'}, /* Page Down */
+    { NULL, (fnp_t) backline,					SPEC | 'A'}, /* Up */
+    { NULL, (fnp_t) forwline,					SPEC | 'B'}, /* Down */
+    { NULL, (fnp_t) forwchar,					SPEC | 'C'}, /* Right */
+    { NULL, (fnp_t) backchar,					SPEC | 'D'}, /* Left */
+    { NULL, (fnp_t) gotoeob,					SPEC | 'F'}, /* End */
+    { NULL, (fnp_t) gotobob,					SPEC | 'H'}, /* Home */
+    { NULL, help,								SPEC | 'P'}, /* F1 */
+
+/* hooks */
+	{ NULL, (fnp_t) nullproc,					META | SPEC | 'R'}, /* hook */
+	{ NULL, (fnp_t) nullproc,					META | SPEC | 'X'}, /* hook */
+
+	{ NULL, NULL, 0}
+} ;
+
+
+static int lastnmidx = 0 ;	/* index of last name entry */
+
+kbind_p keytab ;
+static int ktsize = 140 ;	/* last check: need at least 133 + 1 */
+
+
+boolean init_bindings( void) {
+/* allocate table */
+	keytab = malloc( ktsize * sizeof *keytab) ;
+	if( keytab == NULL)
+		return FALSE ;
+
+/* insert end of table mark */
+	keytab->k_code = 0 ;
+	keytab->k_nbp = NULL ;
+
+/* Add default key bindings */
+	nbind_p nbp ;
+	for( nbp = names ; nbp->n_func != NULL ; nbp++) {
+	/* Check entries and strict order */
+		assert( (nbp->n_name != NULL) &&
+				((nbp == names) ||
+							(0 > strcmp( bind_name( nbp - 1), bind_name( nbp)))
+				)
+		) ;
+
+	/* 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) ;
+		}
+	}
+
+/* memorize position after last valid function entry */
+	lastnmidx = nbp - names ;
+
+/* Process extra key bindings if any */
+	for( nbp++ ; nbp->n_func != NULL ; nbp++) {
+	/* 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) {
+				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 ;
+			}
+
+	/* Insure there is a name entry for the keycode */
+		assert( fnbp->n_func != NULL) ;
+	}
+
+	return TRUE ;
+}
+
+kbind_p setkeybinding( unsigned key, nbind_p nbp) {
+	kbind_p ktp ;
+
+/* search the table to see if it exists */
+    for( ktp = keytab ; ktp->k_code != 0 ; ktp++)
+        if( ktp->k_code == key) {
+		/* it exists, just change it then */
+			ktp->k_nbp = nbp ;
+			return ktp ;
+        }
+
+/* otherwise we need to add it to the end */
+	/* check if the end marker is at the end of the table */
+    if( ktp == &keytab[ ktsize - 1]) {
+    /* out of binding room */
+		int newsize = ktsize + 10 ;
+		kbind_p newkeytab = realloc( keytab, newsize * sizeof *keytab) ;
+		if( newkeytab == NULL)
+		/* out of space */
+	        return ktp ;
+
+		keytab = newkeytab ;
+		ktp = &keytab[ ktsize - 1] ;
+		ktsize = newsize ;
+	}
+
+    ktp->k_code = key ;		/* add keycode */
+	ktp->k_nbp = nbp ;
+    ++ktp ;      			/* and make sure the next is null */
+    ktp->k_code = 0 ;
+	ktp->k_nbp = NULL ;
+    return ktp - 1 ;
+}
+
+boolean delkeybinding( unsigned key) {
+    kbind_p ktp ;   /* pointer into the key binding table */
+
+/* search the table to see if the key exists */
+    for( ktp = keytab ; ktp->k_code != 0 ; ktp++) {
+        if( ktp->k_code == key) {
+	    /* save the pointer and scan to the end of the table */
+    		kbind_p sav_ktp = ktp ;
+    		while( (++ktp)->k_code != 0) ;
+    		ktp -= 1 ;          /* backup to the last legit entry */
+
+    	/* copy the last entry to the current one */
+    		sav_ktp->k_code = ktp->k_code ;
+		    sav_ktp->k_nbp  = ktp->k_nbp ;
+
+	    /* null out the last one */
+		    ktp->k_code = 0 ;
+		    ktp->k_nbp  = NULL ;
+		    return TRUE ;
+        }
+    }
+
+	return FALSE ;
+}
+
+
+/* This function looks a key binding up in the binding table
+ *
+ * int c;       key to find what is bound to it
+ */
+kbind_p getkeybinding( unsigned c) {
+    kbind_p ktp ;
+
+    for( ktp = keytab ; ktp->k_code != 0 ; ktp++)
+        if (ktp->k_code == c)
+			break ;
+
+    return ktp ;
+}
+
+#define BINARY 1
+
+nbind_p fncmatch( char *name) {
+#ifdef BINARY
+	int found = lastnmidx ;
+	int low = 0 ;
+	int high = found - 1 ;
+	do {
+		int cur = (high + low) / 2 ;
+		int s = strcmp( name, bind_name( &names[ cur])) ;
+		if( s < 0)
+			high = cur - 1 ;
+		else if( s == 0) {
+			found = cur ;
+			break ;
+		} else
+			low = cur + 1 ;
+	} while( low <= high) ;
+
+	return &names[ found] ;
+#else
+	nbind_p nbp ;
+	for( nbp = names ; nbp->n_func != NULL ; nbp++)
+		if( !strcmp( name, bind_name( nbp)))
+			break ;
+
+	return nbp ;
+#endif
+}
+
+
+/* user function that does NOTHING (bound to hooks) */
+TBINDABLE( nullproc) {
+	return TRUE ;
+}
+
+
+/* dummy function for binding to meta prefix */
+TBINDABLE( metafn) {
+	return TRUE ;
+}
+
+
+/* dummy function for binding to control-x prefix */
+TBINDABLE( cex) {
+	return TRUE ;
+}
+
+
+/* dummy function for binding to universal-argument */
+TBINDABLE( unarg) {
+	return TRUE ;
+}
+
+/* end of names.c */

names.h

@@ -1,8 +1,62 @@
+/* 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 META        0x02000000  /* Meta flag, or'ed in          */
+#define CTLX        0x04000000  /* ^X flag, or'ed in            */
+#define SPEC        0x08000000  /* special key (function keys)  */
+#define PRFXMASK    0x0F000000  /* prefix mask */
+
+
+/* Bindable uEMACS function pointer type and definition template */
+#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)) ;
+
+
 /* Structure for the name binding table. */
-struct name_bind {
+typedef struct {
-	char *n_name;		 /* name of function key */
+    const char  *n_name ;   /* name starting with one tag character */
-	int (*n_func)(int, int); /* function name is bound to */
+    fnp_t       n_func ;    /* function the name is bound to */
-};
+    unsigned    n_keycode ; /* default key assignment, 0 when none */
+} name_bind ;
 
-extern struct name_bind names[];/* name to function table */
+typedef const name_bind *nbind_p ;
 
+#define bind_name( p) (&( p)->n_name[ 1])
+#define bind_tag( p)  ( p)->n_name[ 0]
+
+
+/* Structure for the key bindings table. */
+typedef struct {
+    unsigned    k_code ;            /* Key code */
+    nbind_p     k_nbp ;             /* entry in name to function map table */
+} *kbind_p ;
+
+
+extern const name_bind  names[] ;   /* name to function mapping table */
+extern kbind_p          keytab ;    /* key bind to functions table  */
+
+
+boolean init_bindings( void) ;
+kbind_p setkeybinding( unsigned key, nbind_p nbp) ;
+boolean delkeybinding( unsigned key) ;
+kbind_p getkeybinding( unsigned key) ;  /* look up by key code */
+
+/* find a name to function association in the name to function mapping table */
+nbind_p fncmatch( char *name) ;     /* look up by name */
+
+
+/* bindable functions mapped to prefix keys and hooks */
+TBINDABLE( nullproc) ;
+TBINDABLE( metafn) ;
+TBINDABLE( cex) ;
+TBINDABLE( unarg) ;
+
+#endif
+/* end of names.h */

pklock.c

@@ -1,5 +1,4 @@
 /* pklock.c -- implements pklock.h */
-#include "estruct.h"
 #include "pklock.h"
 
 /*	PKLOCK.C
@@ -13,13 +12,11 @@
 #include <unistd.h>
 #include <stdio.h>
 #include <fcntl.h>
-#ifdef SVR4
 #include <string.h>
-#else
-#include <strings.h>
-#endif
 #include <errno.h>
 
+#include "util.h"
+
 /* Maximum file length name 255 */
 #define MAXLOCK 256
 #define MAXNAME 128
@@ -33,6 +30,7 @@ int gethostname(char *name, int namelen)
 }
 #endif
 
+char *cuserid( char *retbuf) ;	/* should have been declared in stdio.h */
 
 
 /**********************
@@ -50,8 +48,7 @@ char *dolock( const char *fname)
 	int mask;
 	struct stat sbuf;
 
-	strncpy( lname, fname, sizeof lname - 1 - 6) ;
+	mystrscpy( lname, fname, sizeof lname - 6) ;
-	lname[ sizeof lname - 1 - 6] = 0 ;
 	strcat( lname, ".lock~") ;
 
 	/* check that we are not being cheated, qname must point to     */
@@ -84,8 +81,19 @@ char *dolock( const char *fname)
 	}
 	if ((n = read(fd, locker, MAXNAME)) < 1) {
 		lseek(fd, 0, SEEK_SET);
-/*		strcpy(locker, getlogin()); */
+/*
-		cuserid(locker);
+**	Since Ubuntu 17.04, cuserid prototype seems missing. Replacing it by
+**  getlogin does the trick on 64 bits but fails on 32 bits.
+**  So let's work around with cuserid for a while.
+**		logname = getlogin() ;
+**		strcpy( locker, logname ? logname : cuserid( NULL)) ;
+*/
+#if BSD
+		strcpy( locker, getlogin()) ;
+#else
+		strcpy( locker, cuserid( NULL)) ;
+#endif
+
 		strcat(locker + strlen(locker), "@");
 		gethostname(locker + strlen(locker), 64);
 		{
@@ -118,8 +126,7 @@ char *dolock( const char *fname)
 char *undolock( const char *fname) {
 	char lname[ MAXLOCK] ;
 
-	strncpy( lname, fname, sizeof lname - 1 - 6) ;
+	mystrscpy( lname, fname, sizeof lname - 6) ;
-	lname[ sizeof lname - 1 - 6] = 0 ;
 	strcat( lname, ".lock~") ;
 	if (unlink(lname) != 0) {
 		if (errno == EACCES || errno == ENOENT)

pklock.h

@@ -1,15 +1,13 @@
+/* pklock.h -- */
 #ifndef _PKLOCK_H_
 #define _PKLOCK_H_
 
-#ifndef _ESTRUCT_H_
+#include "defines.h"	/* FILOCK, BSD, SVR4 */
-#error uEmacs compilation settings needs to be done!
-#endif
 
 #if (FILOCK && BSD) || SVR4
-
 char *dolock( const char *fname) ;
 char *undolock( const char *fname) ;
-
 #endif
 
 #endif
+/* end of pklock.h */

posix.c

@@ -1,18 +1,17 @@
 /* posix.c -- posix implementation of termio.h */
-#ifdef POSIX
-
 #include "termio.h"
 
-/*	posix.c
+#include "defines.h"	/* POSIX */
- *
+#ifdef POSIX
- *      The functions in this file negotiate with the operating system for
+
- *      characters, and write characters in a barely buffered fashion on the
+/* The functions in this file negotiate with the operating system for
- *      display. All operating systems.
+   characters, and write characters in a barely buffered fashion on the
- *
+   display.  All operating systems.
- *	modified by Petri Kutvonen
+
- *
+   modified by Petri Kutvonen
- *	based on termio.c, with all the old cruft removed, and
+
- *	fixed for termios rather than the old termio.. Linus Torvalds
+   based on termio.c, with all the old cruft removed, and
+   fixed for termios rather than the old termio.. Linus Torvalds
  */
 
 #include <errno.h>
@@ -24,21 +23,23 @@
 #include <termios.h>
 #include <unistd.h>
 
-#include "estruct.h"
 #include "retcode.h"
 #include "utf8.h"
 
-int ttrow = HUGE ;		/* Row location of HW cursor */
+int ttrow = -1 ;		/* Row location of HW cursor */
-int ttcol = HUGE ;		/* Column location of HW cursor */
+int ttcol = -1 ;		/* Column location of HW cursor */
 
-/* Since Mac OS X's termios.h doesn't have the following 2 macros, define them.
+/* Define missing macroes for BSD and CYGWIN environment */
- */
+#if BSD
-#if defined(SYSV) && (defined(_DARWIN_C_SOURCE) || defined(_FREEBSD_C_SOURCE))
+# ifndef OLCUC
-#define OLCUC 0000002
+#  define OLCUC 0000002
-#define XCASE 0000004
+# endif
+# ifndef XCASE
+#  define XCASE 0000004
+# endif
 #endif
 
-#ifdef CYGWIN
+#ifdef __CYGWIN__			/* gcc predefined (see cpp -dM) */
 #define XCASE 0
 #define ECHOPRT 0
 #define PENDIN 0
@@ -56,8 +57,7 @@ static char tobuf[TBUFSIZ];		/* terminal output buffer */
 
 /*
  * This function is called once to set up the terminal device streams.
- * On VMS, it translates TT until it finds the terminal, then assigns
+ * On CPM it is a no-op.
- * a channel to it and sets it raw. On CPM it is a no-op.
  */
 void ttopen(void)
 {
@@ -97,15 +97,13 @@ void ttopen(void)
 	kbdflgs = fcntl(0, F_GETFL, 0);
 	kbdpoll = FALSE;
 
-	/* on all screens we are not sure of the initial position
+/* on all screens we are not sure of the initial position of the cursor */
-	   of the cursor                                        */
+	ttrow = ttcol = -1 ;
-	ttrow = 999;
-	ttcol = 999;
 }
 
 /*
  * This function gets called just before we go back home to the command
- * interpreter. On VMS it puts the terminal back in a reasonable state.
+ * interpreter.
  * Another no-operation on CPM.
  */
 void ttclose(void)
@@ -114,8 +112,7 @@ void ttclose(void)
 }
 
 /*
- * Write a character to the display. On VMS, terminal output is buffered, and
+ * Write a character to the display.
- * we just put the characters in the big array, after checking for overflow.
  * On CPM terminal I/O unbuffered, so we just write the byte out. Ditto on
  * MS-DOS (use the very very raw console output routine).
  */
@@ -156,27 +153,28 @@ void ttflush(void)
 		exit(15);
 }
 
-/*
- * Read a character from the terminal, performing no editing and doing no echo
- * at all. More complex in VMS that almost anyplace else, which figures. Very
- * simple on CPM, because the system can do exactly what you want.
- */
-int ttgetc(void)
-{
-	static char buffer[32];
-	static int pending;
-	unicode_t c;
-	int count, bytes = 1, expected;
 
-	count = pending;
+/* Read a character from the terminal, performing no editing and doing no
-	if (!count) {
+   echo at all.
-		count = read(0, buffer, sizeof(buffer));
+ */
-		if (count <= 0)
+int ttgetc( void) {
-			return 0;
+	static char buffer[ 32] ;
-		pending = count;
+	static int pending ;
+	unicode_t c ;
+
+	int count = pending ;
+	if( !count) {
+		count = read( 0, buffer, sizeof( buffer)) ;
+		if( count <= 0)
+			return 0 ;
+
+		pending = count ;
 	}
 
-	c = (unsigned char) buffer[0];
+	int bytes = 1 ;
+	c = (unsigned char) buffer[ 0] ;
+#if 0	// temporary fix for wsl
+
 	if (c >= 32 && c < 128)
 		goto done;
 
@@ -193,7 +191,7 @@ int ttgetc(void)
 	 * delay for some *very* unusual utf8 character
 	 * input.
 	 */
-	expected = 2;
+	int expected = 2;
 	if ((c & 0xe0) == 0xe0)
 		expected = 6;
 
@@ -227,9 +225,10 @@ int ttgetc(void)
 	bytes = utf8_to_unicode(buffer, 0, pending, &c);
 
 done:
-	pending -= bytes;
+#endif
-	memmove(buffer, buffer+bytes, pending);
+	pending -= bytes ;
-	return c;
+	memmove( buffer, buffer + bytes, pending) ;
+	return c ;
 }
 
 /* typahead:	Check to see if any characters are already in the
@@ -249,8 +248,6 @@ int typahead(void)
 	return x;
 }
 
-#else
+#endif
-typedef void _pedantic_empty_translation_unit ;
-#endif              /* not POSIX */
 
 /* end of posix.c */

random.h

@@ -1,50 +1,46 @@
+/* random.h -- various commands */
 #ifndef _RANDOM_H_
 #define _RANDOM_H_
 
+#include "names.h"
 
-#include "retcode.h"
+/* Command flags */
+#define CFCPCN  0x0001      /* Flag that last command was C-P, C-N  */
+#define CFKILL  0x0002      /* Flag that last command was a kill    */
+
+extern int thisflag ;       /* Flags, this command */
+extern int lastflag ;       /* Flags, last command */
+
+extern int fillcol ;        /* Fill column */
+extern boolean  hardtab ;   /* Use hard tab instead of soft tab */
 
 
-#define AEDIT 1
-
-extern int fillcol ;	/* Fill column                  */
-extern boolean	hardtab ;	/* Use hard tab instead of soft tab */
-
-
-/* Uninitialized global external declarations. */
-
-#define CFCPCN  0x0001	/* Last command was C-P, C-N    */
-#define CFKILL  0x0002	/* Last command was a kill      */
-
-extern int thisflag ;	/* Flags, this command          */
-extern int lastflag ;	/* Flags, last command          */
-
-int setfillcol( int f, int n) ;
-int showcpos( int f, int n) ;
 int getcline( void) ;
 int getccol( int bflg) ;
-int setccol( int pos) ;
+boolean setccol( int pos) ;
-boolean twiddle( int f, int n) ;
+
-int quote( int f, int n) ;
+/* Bindable functions */
-int insert_tab( int f, int n) ;
+ BINDABLE( setfillcol) ;
-#if AEDIT
+ BINDABLE( showcpos) ;
-int detab( int f, int n) ;
+BBINDABLE( twiddle) ;
-int entab( int f, int n) ;
+ BINDABLE( quote) ;
-int trim( int f, int n) ;
+ BINDABLE( insert_tab) ;
-#endif
+ BINDABLE( detab) ;
-int openline( int f, int n) ;
+ BINDABLE( entab) ;
-int insert_newline( int f, int n) ;
+ BINDABLE( trim) ;
-int deblank( int f, int n) ;
+ BINDABLE( openline) ;
-int indent( int f, int n) ;
+ BINDABLE( insert_newline) ;
-int forwdel( int f, int n) ;
+ BINDABLE( deblank) ;
-int backdel( int f, int n) ;
+ BINDABLE( indent) ;
-int killtext( int f, int n) ;
+ BINDABLE( forwdel) ;
-int setemode( int f, int n) ;
+ BINDABLE( backdel) ;
-int delmode( int f, int n) ;
+ BINDABLE( killtext) ;
-int setgmode( int f, int n) ;
+ BINDABLE( setemode) ;
-int delgmode( int f, int n) ;
+ BINDABLE( delmode) ;
-int getfence( int f, int n) ;
+ BINDABLE( setgmode) ;
-int istring( int f, int n) ;
+ BINDABLE( delgmode) ;
-int ovstring( int f, int n) ;
+ BINDABLE( istring) ;
+ BINDABLE( ovstring) ;
 
 #endif
+/* end of random.h */

region.c

@@ -1,179 +1,147 @@
 /* region.c -- implements region.h */
 #include "region.h"
 
-/*	region.c
+/* The routines in this file deal with the region, that magic space between
- *
+   "." and mark.  Some functions are commands.  Some functions are just for
- *      The routines in this file deal with the region, that magic space
+   internal use.
- *      between "." and mark. Some functions are commands. Some functions are
+
- *      just for internal use.
+	Modified by Petri Kutvonen
- *
- *	Modified by Petri Kutvonen
  */
 
-#include <stdio.h>
+#include <assert.h>
+#include <stddef.h>
 
 #include "buffer.h"
-#include "estruct.h"
+#include "defines.h"
 #include "line.h"
 #include "mlout.h"
 #include "random.h"
 #include "window.h"
 
-/*
+/* Kill the region.  Ask getregion() to figure out the bounds of the
- * Kill the region. Ask "getregion"
+   region.  Move "." to the start, and kill the characters.  Bound to C-W
- * to figure out the bounds of the region.
+   kill-region.
- * Move "." to the start, and kill the characters.
- * Bound to "C-W".
  */
-int killregion(int f, int n)
+BINDABLE( killregion) {
-{
+	region_t region ;
-	int s;
-	struct region region;
 
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
+	assert( !(curbp->b_mode & MDVIEW)) ;
-		return rdonly();	/* we are in read only mode     */
+
-	if ((s = getregion(&region)) != TRUE)
+	int ret = getregion( &region) ;
-		return s;
+	if( ret != TRUE)
-	if ((lastflag & CFKILL) == 0)	/* This is a kill type  */
+		return ret ;
-		kdelete();	/* command, so do magic */
+
-	thisflag |= CFKILL;	/* kill buffer stuff.   */
+	if( (lastflag & CFKILL) == 0)	/* This is a kill type  */
-	curwp->w_dotp = region.r_linep;
+		kdelete() ;	/* command, so do magic */
-	curwp->w_doto = region.r_offset;
+
-	return ldelete(region.r_size, TRUE);
+	thisflag |= CFKILL ;	/* kill buffer stuff.   */
+	curwp->w_dotp = region.r_linep ;
+	curwp->w_doto = region.r_offset ;
+	return ldelete( region.r_size, TRUE) ;
 }
 
-/*
+/* Copy all of the characters in the region to the kill buffer.  Don't move
- * Copy all of the characters in the
+   dot at all.  This is a bit like a kill region followed by a yank.  Bound
- * region to the kill buffer. Don't move dot
+   to M-W copy-region.
- * at all. This is a bit like a kill region followed
- * by a yank. Bound to "M-W".
  */
-int copyregion(int f, int n)
+BINDABLE( copyregion) {
-{
+	region_t region ;
-	struct line *linep;
-	int loffs;
-	int s;
-	struct region region;
 
-	if ((s = getregion(&region)) != TRUE)
+	int ret = getregion( &region) ;
-		return s;
+	if( ret != TRUE)
-	if ((lastflag & CFKILL) == 0)	/* Kill type command.   */
+		return ret ;
-		kdelete();
+
-	thisflag |= CFKILL;
+	if( (lastflag & CFKILL) == 0)	/* Kill type command.   */
-	linep = region.r_linep;	/* Current line.        */
+		kdelete() ;
-	loffs = region.r_offset;	/* Current offset.      */
+
-	while (region.r_size--) {
+	thisflag |= CFKILL ;
-		if (loffs == llength(linep)) {	/* End of line.         */
+	line_p linep = region.r_linep ;	/* Current line.        */
-			if ((s = kinsert('\n')) != TRUE)
+	int loffs = region.r_offset ;	/* Current offset.      */
-				return s;
+	while( region.r_size--) {
-			linep = lforw(linep);
+		if( loffs == llength( linep)) {	/* End of line.         */
-			loffs = 0;
+			ret = kinsert( '\n') ;
+			if( ret != TRUE)
+				return ret ;
+
+			linep = lforw( linep) ;
+			loffs = 0 ;
 		} else {	/* Middle of line.      */
-			if ((s = kinsert(lgetc(linep, loffs))) != TRUE)
+			ret = kinsert( lgetc( linep, loffs)) ;
-				return s;
+			if( ret != TRUE)
-			++loffs;
+				return ret ;
+
+			++loffs ;
 		}
 	}
+
 	mloutstr( "(region copied)") ;
-	return TRUE;
+	return TRUE ;
 }
 
-/*
+/* Lower case region & Upper case region.  Zap all of the upper/lower case
- * Lower case region. Zap all of the upper
+   characters in the region to lower/upper case.  Use the region code to
- * case characters in the region to lower case. Use
+   set the limits.  Scan the buffer, doing the changes.  Call "lchange" to
- * the region code to set the limits. Scan the buffer,
+   ensure that redisplay is done in all buffers.  Bound to C-X C-L
- * doing the changes. Call "lchange" to ensure that
+   case-region-lower and C-X C-U case-region-upper.
- * redisplay is done in all buffers. Bound to
- * "C-X C-L".
  */
-int lowerregion(int f, int n)
+static int utol( int c) {
-{
+	return (c >= 'A' && c <= 'Z') ? c + 'a' - 'A' : -1 ;
-	struct line *linep;
+}
-	int loffs;
-	int c;
-	int s;
-	struct region region;
 
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
+static int ltou( int c) {
-		return rdonly();	/* we are in read only mode     */
+	return (c >= 'a' && c <= 'z') ? c + 'A' - 'a' : -1 ;
-	if ((s = getregion(&region)) != TRUE)
+}
-		return s;
+
-	lchange(WFHARD);
+static int caseregion( int (* cconv)( int)) {
-	linep = region.r_linep;
+	region_t region ;
-	loffs = region.r_offset;
+
-	while (region.r_size--) {
+	assert( !(curbp->b_mode & MDVIEW)) ;
-		if (loffs == llength(linep)) {
+	
-			linep = lforw(linep);
+	int ret = getregion( &region) ;
-			loffs = 0;
+	if( ret != TRUE)
+		return ret ;
+
+	lchange( WFHARD) ;
+	line_p linep = region.r_linep ;
+	int loffs = region.r_offset ;
+	while( region.r_size--) {
+		if( loffs == llength( linep)) {
+			linep = lforw( linep) ;
+			loffs = 0 ;
 		} else {
-			c = lgetc(linep, loffs);
+			int c = cconv( lgetc( linep, loffs)) ;
-			if (c >= 'A' && c <= 'Z')
+			if( c != -1)
-				lputc(linep, loffs, c + 'a' - 'A');
+				lputc( linep, loffs, c) ;
-			++loffs;
+
+			++loffs ;
 		}
 	}
-	return TRUE;
+
+	return TRUE ;
 }
 
-/*
+BINDABLE( lowerregion) {
- * Upper case region. Zap all of the lower
+	return caseregion( utol) ;
- * case characters in the region to upper case. Use
- * the region code to set the limits. Scan the buffer,
- * doing the changes. Call "lchange" to ensure that
- * redisplay is done in all buffers. Bound to
- * "C-X C-L".
- */
-int upperregion(int f, int n)
-{
-	struct line *linep;
-	int loffs;
-	int c;
-	int s;
-	struct region region;
-
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return rdonly();	/* we are in read only mode     */
-	if ((s = getregion(&region)) != TRUE)
-		return s;
-	lchange(WFHARD);
-	linep = region.r_linep;
-	loffs = region.r_offset;
-	while (region.r_size--) {
-		if (loffs == llength(linep)) {
-			linep = lforw(linep);
-			loffs = 0;
-		} else {
-			c = lgetc(linep, loffs);
-			if (c >= 'a' && c <= 'z')
-				lputc(linep, loffs, c - 'a' + 'A');
-			++loffs;
-		}
-	}
-	return TRUE;
 }
 
-/*
+BINDABLE( upperregion) {
- * This routine figures out the
+	return caseregion( ltou) ;
- * bounds of the region in the current window, and
+}
- * fills in the fields of the "struct region" structure pointed
+
- * to by "rp". Because the dot and mark are usually very
+/* This routine figures out the bounds of the region in the current window,
- * close together, we scan outward from dot looking for
+ * and fills in the fields of the "region_t" structure pointed to by "rp".
- * mark. This should save time. Return a standard code.
+ * Because the dot and mark are usually very close together, we scan
- * Callers of this routine should be prepared to get
+ * outward from dot looking for mark.  This should save time.  Return a
- * an "ABORT" status; we might make this have the
+ * standard code.  Callers of this routine should be prepared to get an
- * conform thing later.
+ * "ABORT" status; we might make this have the conform thing later.
- */
+ */
-int getregion(struct region *rp)
+int getregion( region_p rp) {
-{
+	line_p flp, blp ;
-	struct line *flp;
+	long fsize, bsize ;
-	struct line *blp;
+
-	long fsize;
+	if (curwp->w_markp == NULL)
-	long bsize;
+		return mloutfail( "No mark set in this window") ;
 
-	if (curwp->w_markp == NULL) {
-		mloutstr( "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) {
@@ -213,6 +181,8 @@ int getregion(struct region *rp)
 			}
 		}
 	}
-	mloutstr( "Bug: lost mark") ;
+
-	return FALSE;
+	return mloutfail( "Bug: lost mark") ;
 }
+
+/* end of region.c */

region.h

@@ -1,22 +1,27 @@
+/* region.h -- a region starts at the mark and end at the dot */
 #ifndef _REGION_H_
 #define _REGION_H_
 
 #include "line.h"
 
-/*
+/* The starting position of a region, and the size of the region in
- * The starting position of a region, and the size of the region in
+   characters, is kept in a region structure.  Used by the region commands.
- * characters, is kept in a region structure.  Used by the region commands.
  */
-struct region {
+typedef struct {
-	struct line *r_linep;	/* Origin struct line address.         */
+    line_p  r_linep ;   /* Origin struct line address.  */
-	int r_offset;		/* Origin struct line offset.          */
+    int     r_offset ;  /* Origin struct line offset.   */
-	long r_size;		/* Length in characters.        */
+    long    r_size ;    /* Length in characters.        */
-};
+} region_t ;
 
-int killregion( int f, int n) ;
+typedef region_t *region_p ;
-int copyregion( int f, int n) ;
+
-int lowerregion( int f, int n) ;
+/* Bindable functions */
-int upperregion( int f, int n) ;
+BINDABLE( killregion) ;
-int getregion( struct region *rp) ;
+BINDABLE( copyregion) ;
+BINDABLE( lowerregion) ;
+BINDABLE( upperregion) ;
+
+int getregion( region_p rp) ;
 
 #endif
+/* end of region.h */

retcode.h

@@ -1,20 +1,23 @@
+/* retcode.h -- */
 #ifndef __RETCODE_H__
 #define __RETCODE_H__
 
-#ifdef	FALSE
+#ifdef  FALSE
-#error "FALSE shouldn't be defined"
+# error "FALSE shouldn't be defined"
-#undef	FALSE
+# undef FALSE
 #endif
-#ifdef	TRUE
+
-#error "TRUE shouldn't be defined"
+#ifdef  TRUE
-#undef	TRUE
+# error "TRUE shouldn't be defined"
+# undef TRUE
 #endif
 
 typedef enum {
-	FALSE,			/* 0, false, no, bad, etc.		*/
+    FALSE,          /* 0, false, no, bad, etc.      */
-	TRUE			/* 1, true, yes, good, etc.		*/
+    TRUE            /* 1, true, yes, good, etc.     */
 } boolean ;
 
-#define ABORT 2		/* 2, death, ^G, abort, etc.	*/
+#define ABORT 2     /* 2, death, ^G, abort, etc.    */
 
 #endif
+/* end of retcode.h */

screensize.cmd

@@ -0,0 +1,10 @@
+# Visualize Screen Dimensions
+select-buffer screensize
+insert-string &cat $curwidth &cat "x" $pagelen
+insert-string &rig "---------+" &sub 10 $curcol
+&sub &div $curwidth 10 1 insert-string "---------+"
+insert-string &lef "1234567890" &mod $curwidth 10
+&sub $pagelen 3 execute-command-line "insert-string &cat ~n &add $curline 1"
+beginning-of-file
+unmark-buffer
+write-message $line

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.
@@ -60,18 +58,21 @@
  *	Modified by Petri Kutvonen
  */
 
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "basic.h"
 #include "buffer.h"
+#include "defines.h"
 #include "display.h"
-#include "estruct.h"
 #include "input.h"
+#include "isa.h"
 #include "line.h"
 #include "mlout.h"
 #include "terminal.h"
+#include "util.h"
 #include "window.h"
 
 /* The variable matchlen holds the length of the matched
@@ -84,7 +85,7 @@
 unsigned int matchlen = 0 ;
 static unsigned int mlenold = 0 ;
 char *patmatch = NULL ;
-static struct line *matchline = NULL;
+static line_p matchline = NULL;
 static int matchoff = 0;
 
 spat_t pat ;	/* Search pattern               */
@@ -123,7 +124,6 @@ spat_t rpat ;	/* replacement pattern          */
 #define	MC_ESC		'\\'	/* Escape - suppress meta-meaning. */
 
 #define	BIT(n)		(1 << (n))	/* An integer with one bit set. */
-#define	CHCASE(c)	((c) ^ DIFCASE)	/* Toggle the case of a letter. */
 
 /* HICHAR - 1 is the largest character we will deal with.
  * HIBYTE represents the number of bytes in the bitmap.
@@ -163,10 +163,10 @@ static struct magic_replacement rmcpat[NPAT]; /* The replacement magic array. */
 static int mcscanner( struct magic *mcpatrn, int direct, int beg_or_end) ;
 #endif
 
-static int amatch(struct magic *mcptr, int direct, struct line **pcwline, int *pcwoff);
+static int amatch(struct magic *mcptr, int direct, line_p *pcwline, int *pcwoff);
 static int readpattern(char *prompt, char *apat, int srch);
 static int replaces(int kind, int f, int n);
-static int nextch(struct line **pcurline, int *pcuroff, int dir);
+static int nextch( line_p *pcurline, int *pcuroff, int dir);
 static int mcstr(void);
 static int rmcstr(void);
 static int mceq(int bc, struct magic *mt);
@@ -175,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.
@@ -221,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 */
@@ -274,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.
@@ -322,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)
@@ -388,7 +384,7 @@ int backhunt(int f, int n)
  */
 static int mcscanner(struct magic *mcpatrn, int direct, int beg_or_end)
 {
-	struct line *curline;		/* current line during scan */
+	line_p curline;		/* current line during scan */
 	int curoff;		/* position within current line */
 
 	/* If we are going in reverse, then the 'end' is actually
@@ -411,7 +407,7 @@ static int mcscanner(struct magic *mcpatrn, int direct, int beg_or_end)
 
 	/* Scan each character until we hit the head link record.
 	 */
-	while (!boundry(curline, curoff, direct)) {
+	while (!boundary(curline, curoff, direct)) {
 		/* Save the current position in case we need to
 		 * restore it on a match, and initialize matchlen to
 		 * zero in case we are doing a search for replacement.
@@ -452,13 +448,13 @@ static int mcscanner(struct magic *mcpatrn, int direct, int beg_or_end)
  *
  * struct magic *mcptr;		string to scan for
  * int direct;		which way to go.
- * struct line **pcwline;	current line during scan
+ * line_p *pcwline;	current line during scan
  * int *pcwoff;		position within current line
  */
-static int amatch(struct magic *mcptr, int direct, struct line **pcwline, int *pcwoff)
+static int amatch(struct magic *mcptr, int direct, line_p *pcwline, int *pcwoff)
 {
 	int c;		/* character at current position */
-	struct line *curline;		/* current line during scan */
+	line_p curline;		/* current line during scan */
 	int curoff;		/* position within current line */
 	int nchars;
 
@@ -598,9 +594,9 @@ int scanner(const char *patrn, int direct, int beg_or_end)
 {
 	int c;		/* character at current position */
 	const char *patptr;	/* pointer into pattern */
-	struct line *curline;		/* current line during scan */
+	line_p curline;		/* current line during scan */
 	int curoff;		/* position within current line */
-	struct line *scanline;		/* current line during scanning */
+	line_p scanline;		/* current line during scanning */
 	int scanoff;		/* position in scanned line */
 
 	/* If we are going in reverse, then the 'end' is actually
@@ -615,7 +611,7 @@ int scanner(const char *patrn, int direct, int beg_or_end)
 
 	/* Scan each character until we hit the head link record.
 	 */
-	while (!boundry(curline, curoff, direct)) {
+	while (!boundary(curline, curoff, direct)) {
 		/* Save the current position in case we match
 		 * the search string at this point.
 		 */
@@ -672,19 +668,18 @@ int scanner(const char *patrn, int direct, int beg_or_end)
 int eq(unsigned char bc, unsigned char pc)
 {
 	if ((curwp->w_bufp->b_mode & MDEXACT) == 0) {
-		if (islower(bc))
+		if( islower( bc))
-			bc ^= DIFCASE;
+			bc = flipcase( bc) ;
 
-		if (islower(pc))
+		if( islower( pc))
-			pc ^= DIFCASE;
+			pc = flipcase( pc) ;
 	}
 
 	return bc == pc;
 }
 
 void setprompt( char *tpat, unsigned tpat_size, char *prompt, char *apat) {
-	strncpy( tpat, prompt, 14) ;	/* copy prompt to output string */
+	mystrscpy( tpat, prompt, 15) ;	/* copy prompt to output string */
-	tpat[ 14] = '\0' ;				/* longest prompt is "Reverse Search" */
 	strcat( tpat, " (") ;			/* build new prompt string */
 	expandp( apat, &tpat[ strlen( tpat)], tpat_size) ;	/* add old pattern */
 	strcat( tpat, ")<Meta>: ") ;
@@ -716,8 +711,7 @@ static int readpattern(char *prompt, char *apat, int srch)
 	 */
 	status = newmlargt( &dynpat, tpat, NPAT) ;
 	if( status == TRUE) {
-		strncpy( apat, dynpat, NPAT - 1) ;
+		mystrscpy( apat, dynpat, NPAT) ;
-		apat[ NPAT - 1] = 0 ;
 		free( dynpat) ;
 		if (srch) {	/* If we are doing the search string. */
 			/* Reverse string copy, and remember
@@ -749,7 +743,7 @@ static int readpattern(char *prompt, char *apat, int srch)
 void savematch(void)
 {
 	char *ptr;	/* pointer to last match string */
-	struct line *curline;		/* line of last match */
+	line_p curline;		/* line of last match */
 	int curoff;		/* offset "      "    */
 
 	/* Free any existing match string, then
@@ -788,26 +782,24 @@ void rvstrcpy(char *rvstr, char *str)
 	*rvstr = '\0';
 }
 
-/*
+
- * sreplace -- Search and replace.
+/* sreplace -- Search and replace.
  *
  * int f;		default flag
  * int n;		# of repetitions wanted
  */
-int sreplace(int f, int n)
+BINDABLE( sreplace) {
-{
+	return replaces( FALSE, f, n) ;
-	return replaces(FALSE, f, n);
 }
 
-/*
+
- * qreplace -- search and replace with query.
+/* qreplace -- search and replace with query.
  *
  * int f;		default flag
  * int n;		# of repetitions wanted
  */
-int qreplace(int f, int n)
+BINDABLE( qreplace) {
-{
+	return replaces( TRUE, f, n) ;
-	return replaces(TRUE, f, n);
 }
 
 /*
@@ -828,17 +820,16 @@ static int replaces(int kind, int f, int n)
 	int nlrepl;		/* was a replace done on the last line? */
 	char c;			/* input char for query */
 	spat_t tpat ;	/* temporary to hold search pattern */
-	struct line *origline;		/* original "." position */
+	line_p origline;		/* original "." position */
 	int origoff;		/* and offset (for . query option) */
-	struct line *lastline;		/* position of last replace and */
+	line_p lastline;		/* position of last replace and */
 	int lastoff;		/* offset (for 'u' query option) */
 
-/* rfi */
+///* rfi */
 	lastline = NULL ;
 	lastoff = 0 ;
 
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
+	assert( !(curbp->b_mode & MDVIEW)) ;
-		return rdonly();	/* we are in read only mode     */
 
 	/* Check for negative repetitions.
 	 */
@@ -1115,25 +1106,23 @@ int expandp(char *srcstr, char *deststr, int maxlength)
 	return TRUE;
 }
 
-/*
- * boundry -- Return information depending on whether we may search no
- *	further.  Beginning of file and end of file are the obvious
- *	cases, but we may want to add further optional boundry restrictions
- *	in future, a' la VMS EDT.  At the moment, just return TRUE or
- *	FALSE depending on if a boundry is hit (ouch).
- */
-int boundry(struct line *curline, int curoff, int dir)
-{
-	int border;
 
-	if (dir == FORWARD) {
+/* boundary -- Returns information depending on whether we may search no
-		border = (curoff == llength(curline)) &&
+   further.  Beginning of file and end of file are the obvious cases, but
-		    (lforw(curline) == curbp->b_linep);
+   we may want to add further optional boundary restrictions in future, a'
-	} else {
+   la VMS EDT.  At the moment, just return TRUE or FALSE depending on if a
-		border = (curoff == 0) &&
+   boundary is hit (ouch).
-		    (lback(curline) == curbp->b_linep);
+ */
-	}
+int boundary( line_p curline, int curoff, int dir) {
-	return border;
+	int border ;
+
+	if( dir == FORWARD)
+		border = (curoff == llength( curline)) &&
+										(lforw( curline) == curbp->b_linep) ;
+	else
+		border = (curoff == 0) && (lback( curline) == curbp->b_linep) ;
+
+	return border ;
 }
 
 /*
@@ -1144,9 +1133,9 @@ int boundry(struct line *curline, int curoff, int dir)
  *	the current character and move, reverse searches move and
  *	look at the character.
  */
-static int nextch(struct line **pcurline, int *pcuroff, int dir)
+static int nextch( line_p *pcurline, int *pcuroff, int dir)
 {
-	struct line *curline;
+	line_p curline;
 	int curoff;
 	int c;
 
@@ -1288,7 +1277,7 @@ static int mcstr(void)
 	if (status) {
 		rtpcm = &tapcm[0];
 		while (--mj >= 0) {
-#if	MSC | TURBO | VMS | USG | BSD | V7
+#if	USG | BSD
 			*rtpcm++ = *--mcptr;
 #endif
 		}
@@ -1456,7 +1445,7 @@ static int mceq(int bc, struct magic *mt)
 		if (!(result = biteq(bc, mt->u.cclmap))) {
 			if ((curwp->w_bufp->b_mode & MDEXACT) == 0 &&
 			    (isletter(bc))) {
-				result = biteq(CHCASE(bc), mt->u.cclmap);
+				result = biteq( flipcase( bc), mt->u.cclmap) ;
 			}
 		}
 		break;
@@ -1466,7 +1455,7 @@ static int mceq(int bc, struct magic *mt)
 
 		if ((curwp->w_bufp->b_mode & MDEXACT) == 0 &&
 		    (isletter(bc))) {
-			result &= !biteq(CHCASE(bc), mt->u.cclmap);
+			result &= !biteq( flipcase( bc), mt->u.cclmap) ;
 		}
 		break;
 
@@ -1543,7 +1532,7 @@ static int cclmake(char **ppatptr, struct magic *mcptr)
 			 */
 		case MC_ESC:
 			pchr = *++patptr;
-			/* falltrhough */
+			/* fallthrough */
 		default:
 			setbit(pchr, bmap);
 			break;
@@ -1605,3 +1594,5 @@ static void setbit(int bc, char *cclmap)
 		*(cclmap + (bc >> 3)) |= BIT(bc & 7);
 }
 #endif
+
+/* end of search.c */

search.h

@@ -1,49 +1,53 @@
+/* search.h -- */
 #ifndef _SEARCH_H_
 #define _SEARCH_H_
 
-#define MAGIC	1	/* include regular expression matching? */
+#include "line.h"   /* line_p */
+#include "names.h"  /* BINDABLE() */
 
-#include "line.h"
+typedef char spat_t[ 128] ;     /* search pattern type */
-
+#define NPAT sizeof( spat_t)    /* # of bytes, pattern      */
-typedef char spat_t[ 128] ;		/* search pattern type */
-#define	NPAT sizeof( spat_t)	/* # of bytes, pattern		*/
 
 extern unsigned int matchlen ;
 extern char *patmatch ;
 
-extern spat_t pat ;		/* Search pattern               */
+extern spat_t pat ;     /* Search pattern               */
-extern spat_t tap ;		/* Reversed pattern array.      */
+extern spat_t tap ;     /* Reversed pattern array.      */
-extern spat_t rpat ;	/* replacement pattern          */
+extern spat_t rpat ;    /* replacement pattern          */
 
 /*
  * PTBEG, PTEND, FORWARD, and REVERSE are all toggle-able values for
  * the scan routines.
  */
-#define	PTBEG	0		/* Leave the point at the beginning on search   */
+#define PTBEG   0       /* Leave the point at the beginning on search   */
-#define	PTEND	1		/* Leave the point at the end on search         */
+#define PTEND   1       /* Leave the point at the end on search         */
-#define	FORWARD	0		/* forward direction            */
+#define FORWARD 0       /* forward direction            */
-#define REVERSE	1		/* backwards direction          */
+#define REVERSE 1       /* backwards direction          */
 
 int scanner( const char *patrn, int direct, int beg_or_end) ;
 
-int forwsearch( int f, int n) ;
+/* Bindable functions */
-int forwhunt( int f, int n) ;
+BINDABLE( backhunt) ;
-int backsearch( int f, int n) ;
+BINDABLE( backsearch) ;
-int backhunt( int f, int n) ;
+BINDABLE( forwhunt) ;
+BINDABLE( forwsearch) ;
+BINDABLE( qreplace) ;
+BINDABLE( sreplace) ;
+
 int eq( unsigned char bc, unsigned char pc) ;
 void savematch( void) ;
 void rvstrcpy( char *rvstr, char *str) ;
-int sreplace( int f, int n) ;
-int qreplace( int f, int n) ;
 int delins( int dlength, char *instr, int use_meta) ;
 int expandp( char *srcstr, char *deststr, int maxlength) ;
-int boundry( struct line *curline, int curoff, int dir) ;
+int boundary( line_p curline, int curoff, int dir) ;
 
 void setprompt( char *tpat, unsigned tpat_size, char *prompt, char *apat) ;
 
+#define MAGIC   1   /* include regular expression matching? */
 #if MAGIC
 void mcclear( void) ;
 void rmcclear( void) ;
 #endif
 
 #endif
+/* end of search.h */

sharpmaz.cmd

@@ -0,0 +1,54 @@
+## sharpmaz.cmd -- redraw a block maze using line characters
+
+execute-file maze.cmd
+
+set %meml $curline
+set %memc $curcol
+end-of-line
+set %ec &sub $curcol 1
+end-of-file
+set %el &sub $curline 1
+previous-line
+set %spaces $line
+beginning-of-file
+set %old $line
+set $line %spaces
+next-line
+
+!while &less $curline %el
+	set $curcol 1
+	!while &less $curcol %ec
+		!if &not &equ $curchar 32
+			set %v 0
+			set %inc 1
+			previous-line
+			!gosub check
+			next-line
+			backward-character
+			!gosub check
+			2 forward-character
+			!gosub check
+			next-line
+			backward-character
+			!gosub check
+			previous-line
+			# alternatively use single width "╳╵╴┘╶└─┴╷│┐┤┌├┬┼"
+			set $curchar &asc &mid "╳╹╸┛╺┗━┻╻┃┓┫┏┣┳╋" &add %v 1 1
+		!endif
+		forward-character
+	!endwhile
+	next-line
+!endwhile
+
+beginning-of-file
+set $line %old
+set $curline %meml
+set $curcol %memc
+!return
+
+:check
+	!if &not &equ $curchar 32
+		set %v &add %v %inc
+	!endif
+	set %inc &tim %inc 2
+!return

spawn.c

@@ -1,23 +1,20 @@
 /* spawn.c -- implements spawn.h */
 #include "spawn.h"
 
-/*	spawn.c
+/*	Various operating system access commands.
  *
- *	Various operating system access commands.
+ *	Modified by Petri Kutvonen
- *
- *	<odified by Petri Kutvonen
  */
 
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
-#include "defines.h"
-
 #include "buffer.h"
+#include "defines.h"
 #include "display.h"
-#include "estruct.h"
 #include "exec.h"
 #include "file.h"
 #include "flook.h"
@@ -25,39 +22,18 @@
 #include "terminal.h"
 #include "window.h"
 
-#if     VMS
-#define EFN     0		/* Event flag.          */
 
-#include        <ssdef.h>	/* Random headers.      */
+#if	USG | BSD
-#include        <stsdef.h>
-#include        <descrip.h>
-#include        <iodef.h>
-
-extern int oldmode[3];		/* In "termio.c"        */
-extern int newmode[3];		/* In "termio.c"        */
-extern short iochan;		/* In "termio.c"        */
-#endif
-
-#if     V7 | USG | BSD
 #include        <signal.h>
-#ifdef SIGWINCH
-#endif
-#endif
-
-#if	MSDOS & (MSC | TURBO)
-#include	<process.h>
 #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". The message at the start in VMS puts out a newline.
+ * repaint. Bound to "^X C".
- * Under some (unknown) condition, you don't get one free when DCL starts up.
  */
-int spawncli(int f, int n)
+BINDABLE( spawncli) {
-{
+#if	USG | BSD
-#if     V7 | USG | BSD
 	char *cp;
 #endif
 
@@ -65,28 +41,7 @@ int spawncli(int f, int n)
 	if (restflag)
 		return resterr();
 
-#if     VMS
+#if	USG | BSD
-	movecursor(term.t_nrow, 0);	/* In last line.        */
-	mlwrite("(Starting DCL)\r\n");
-	TTflush();		/* Ignore "ttcol".      */
-	sgarbf = TRUE;
-	sys(NULL);
-	sleep(1);
-	mlwrite("\r\n(Returning from DCL)\r\n");
-	TTflush();
-	sleep(1);
-	return TRUE;
-#endif
-#if     MSDOS & (MSC | TURBO)
-	movecursor(term.t_nrow, 0);	/* Seek to last line.   */
-	TTflush();
-	TTkclose();
-	shellprog("");
-	TTkopen();
-	sgarbf = TRUE;
-	return TRUE;
-#endif
-#if     V7 | USG | BSD
 	movecursor(term.t_nrow, 0);	/* Seek to last line.   */
 	TTflush();
 	TTclose();		/* stty to old settings */
@@ -117,10 +72,9 @@ int spawncli(int f, int n)
 #endif
 }
 
-#if	BSD | __hpux | SVR4
+#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;
@@ -140,12 +94,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 ;
 
@@ -153,7 +107,7 @@ int spawn( int f, int n) {
 	if( restflag)
 		return resterr();
 
-#if     V7 | USG | BSD
+#if	USG | BSD
 	s = newmlarg( &line, "!", 0) ;
 	if( s != TRUE)
 		return s ;
@@ -178,13 +132,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 ;
 
@@ -192,7 +146,7 @@ int execprg( int f, int n) {
 	if( restflag)
 		return resterr() ;
 
-#if     V7 | USG | BSD
+#if	USG | BSD
 	s = newmlarg( &line, "$", 0) ;
 	if( s != TRUE)
 		return s ;
@@ -213,108 +167,99 @@ int execprg( int f, int n) {
 #endif
 }
 
-/*
- * Pipe a one line command into a window
- * Bound to ^X @
- */
-int pipecmd( int f, int n) {
-	int s ;		/* return status from CLI */
-	struct window *wp ;	/* pointer to new window */
-	struct buffer *bp ;	/* pointer to buffer to zot */
-	char *mlarg ;
-	char *line ;	/* command line send to shell */
-	static char bname[] = "command" ;
-	static char filnam[ NSTRING] = "command" ;
 
-	/* don't allow this command if restricted */
+/* Pipe a one line command into a window
+ * Bound to pipe-command ^X @
+ */
+BINDABLE( pipecmd) {
+	window_p wp ;	/* pointer to new window */
+	char *mlarg ;
+	const char filnam[] = "command" ;
+
+/* don't allow this command if restricted */
 	if( restflag)
 		return resterr() ;
 
-	/* get the command to pipe in */
+/* get the command to pipe in */
-	s = newmlarg( &mlarg, "@", 0) ;
+	int s = newmlarg( &mlarg, "pipe-command: ", 0) ;
 	if( s != TRUE)
 		return s ;
 
-	line = malloc( strlen( mlarg) + strlen( filnam) + 2) ;
+	char *cmdline = malloc( strlen( mlarg) + strlen( filnam) + 4) ;
-	if( line == NULL) {
+	if( cmdline == NULL) {
 		free( mlarg) ;
 		return FALSE ;
 	}
 
-	strcpy( line, mlarg) ;
+	strcpy( cmdline, mlarg) ;
 	free( mlarg) ;
+	strcat( cmdline, " > ") ;
+	strcat( cmdline, filnam) ;
 
-	/* get rid of the command output buffer if it exists */
+/* get rid of the command output buffer if it exists */
-	if ((bp = bfind(bname, FALSE, 0)) != FALSE) {
+	buffer_p bp = bfind( filnam, FALSE, 0) ;
-		/* try to make sure we are off screen */
+	if( bp != NULL) {
-		wp = wheadp;
+	/* try to make sure we are off screen */
-		while (wp != NULL) {
+		for( wp = wheadp ; wp != NULL ; wp = wp->w_wndp) {
-			if (wp->w_bufp == bp) {
+			if( wp->w_bufp == bp) {
 #if	PKCODE
-				if (wp == curwp)
+				if( wp == curwp)
-					delwind(FALSE, 1);
+					delwind( FALSE, 1) ;
 				else
-					onlywind(FALSE, 1);
+					onlywind( FALSE, 1) ;
-				break;
+				break ;
 #else
-				onlywind(FALSE, 1);
+				onlywind( FALSE, 1) ;
-				break;
+				break ;
 #endif
 			}
-			wp = wp->w_wndp;
 		}
 
 		if( zotbuf( bp) != TRUE) {
-			free( line) ;
+			free( cmdline) ;
 			return FALSE ;
 		}
 	}
-#if     V7 | USG | BSD
+
+#if	USG | BSD
 	TTflush();
 	TTclose();		/* stty to old modes    */
 	TTkclose();
-	strcat( line, ">") ;
+	ue_system( cmdline) ;
-	strcat( line, filnam) ;
+	free( cmdline) ;
-	ue_system( line) ;
-	free( line) ;
 	TTopen();
 	TTkopen();
 	TTflush();
 	sgarbf = TRUE;
 	s = TRUE;
 #else
-	if (s != TRUE)
+	if( s != TRUE)
 		return s;
 #endif
 
-	/* split the current window to make room for the command output */
+/* split the current window to make room for the command output
-	if (splitwind(FALSE, 1) == FALSE)
+** and read the stuff in */
-		return FALSE;
+	if( splitwind( FALSE, 1) == FALSE
+	||  getfile( filnam, FALSE) == FALSE)
+		return FALSE ;
 
-	/* and read the stuff in */
+/* make this window in VIEW mode, update all mode lines */
-	if (getfile(filnam, FALSE) == FALSE)
+	curwp->w_bufp->b_mode |= MDVIEW ;
-		return FALSE;
+	for( wp = wheadp ; wp != NULL ; wp = wp->w_wndp)
+		wp->w_flag |= WFMODE ;
 
-	/* make this window in VIEW mode, update all mode lines */
+/* and get rid of the temporary file */
-	curwp->w_bufp->b_mode |= MDVIEW;
+	unlink( filnam) ;
-	wp = wheadp;
+	return TRUE ;
-	while (wp != NULL) {
-		wp->w_flag |= WFMODE;
-		wp = wp->w_wndp;
-	}
-
-	/* and get rid of the temporary file */
-	unlink(filnam);
-	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 */
-	struct buffer *bp ;	/* pointer to buffer to zot */
+	buffer_p bp ;		/* pointer to buffer to zot */
 	char *mlarg ;
 	char *line ;		/* command line send to shell */
 	fname_t tmpnam ;	/* place to store real file name */
@@ -327,8 +272,7 @@ int filter_buffer( int f, int n) {
 	if( restflag)
 		return resterr() ;
 
-	if( curbp->b_mode & MDVIEW)	/* don't allow this command if      */
+	assert( !(curbp->b_mode & MDVIEW)) ;
-		return rdonly() ;		/* we are in read only mode     */
 
 	/* get the filter name and its args */
 	s = newmlarg( &mlarg, "#", 0) ;
@@ -357,7 +301,7 @@ int filter_buffer( int f, int n) {
 		return FALSE ;
 	}
 
-#if     V7 | USG | BSD
+#if	USG | BSD
 	TTputc('\n');		/* Already have '\r'    */
 	TTflush();
 	TTclose();		/* stty to old modes    */
@@ -391,166 +335,4 @@ int filter_buffer( int f, int n) {
 	return TRUE;
 }
 
-#if     VMS
+/* end of spawn.c */
-/*
- * Run a command. The "cmd" is a pointer to a command string, or NULL if you
- * want to run a copy of DCL in the subjob (this is how the standard routine
- * LIB$SPAWN works. You have to do wierd stuff with the terminal on the way in
- * and the way out, because DCL does not want the channel to be in raw mode.
- */
-int sys(char *cmd)
-{
-	struct dsc$descriptor cdsc;
-	struct dsc$descriptor *cdscp;
-	long status;
-	long substatus;
-	long iosb[2];
-
-	status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
-			  oldmode, sizeof(oldmode), 0, 0, 0, 0);
-	if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
-		return FALSE;
-	cdscp = NULL;		/* Assume DCL.          */
-	if (cmd != NULL) {	/* Build descriptor.    */
-		cdsc.dsc$a_pointer = cmd;
-		cdsc.dsc$w_length = strlen(cmd);
-		cdsc.dsc$b_dtype = DSC$K_DTYPE_T;
-		cdsc.dsc$b_class = DSC$K_CLASS_S;
-		cdscp = &cdsc;
-	}
-	status = LIB$SPAWN(cdscp, 0, 0, 0, 0, 0, &substatus, 0, 0, 0);
-	if (status != SS$_NORMAL)
-		substatus = status;
-	status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
-			  newmode, sizeof(newmode), 0, 0, 0, 0);
-	if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
-		return FALSE;
-	if ((substatus & STS$M_SUCCESS) == 0)	/* Command failed.      */
-		return FALSE;
-	return TRUE;
-}
-#endif
-
-#if	MSDOS & (TURBO | MSC)
-
-/*
- * SHELLPROG: Execute a command in a subshell
- *
- * char *cmd;		Incoming command line to execute
- */
-int shellprog(char *cmd)
-{
-	char *shell;		/* Name of system command processor */
-	char *p;		/* Temporary pointer */
-	char swchar;		/* switch character to use */
-	union REGS regs;	/* parameters for dos call */
-	char comline[NSTRING];	/* constructed command line */
-
-	/*  detect current switch character and set us up to use it */
-	regs.h.ah = 0x37;	/*  get setting data  */
-	regs.h.al = 0x00;	/*  get switch character  */
-	intdos(&regs, &regs);
-	swchar = (char) regs.h.dl;
-
-	/*  get name of system shell  */
-	if ((shell = getenv("COMSPEC")) == NULL) {
-		return FALSE;	/*  No shell located  */
-	}
-
-	/* trim leading whitespace off the command */
-	while (*cmd == ' ' || *cmd == '\t')	/*  find out if null command */
-		cmd++;
-
-	/**  If the command line is not empty, bring up the shell  **/
-	/**  and execute the command.  Otherwise, bring up the     **/
-	/**  shell in interactive mode.   **/
-
-	if (*cmd) {
-		strcpy(comline, shell);
-		strcat(comline, " ");
-		comline[strlen(comline) + 1] = 0;
-		comline[strlen(comline)] = swchar;
-		strcat(comline, "c ");
-		strcat(comline, cmd);
-		return execprog(comline);
-	} else
-		return execprog(shell);
-}
-
-/*
- * EXECPROG:
- *	A function to execute a named program
- *	with arguments
- *
- * char *cmd;		Incoming command line to execute
- */
-int execprog(char *cmd)
-{
-	char *sp;		/* temporary string pointer */
-	char f1[38];		/* FCB1 area (not initialized */
-	char f2[38];		/* FCB2 area (not initialized */
-	char prog[NSTRING];	/* program filespec */
-	char tail[NSTRING];	/* command tail with length byte */
-	union REGS regs;	/* parameters for dos call  */
-	struct SREGS segreg;	/* segment registers for dis call */
-	struct pblock {		/* EXEC parameter block */
-		short envptr;	/* 2 byte pointer to environment string */
-		char *cline;	/* 4 byte pointer to command line */
-		char *fcb1;	/* 4 byte pointer to FCB at PSP+5Ch */
-		char *fcb2;	/* 4 byte pointer to FCB at PSP+6Ch */
-	} pblock;
-
-	/* parse the command name from the command line */
-	sp = prog;
-	while (*cmd && (*cmd != ' ') && (*cmd != '\t'))
-		*sp++ = *cmd++;
-	*sp = 0;
-
-	/* and parse out the command tail */
-	while (*cmd && ((*cmd == ' ') || (*cmd == '\t')))
-		++cmd;
-	*tail = (char) (strlen(cmd));	/* record the byte length */
-	strcpy(&tail[1], cmd);
-	strcat(&tail[1], "\r");
-
-	/* look up the program on the path trying various extentions */
-	if ((sp = flook(prog, TRUE)) == NULL)
-		if ((sp = flook(strcat(prog, ".exe"), TRUE)) == NULL) {
-			strcpy(&prog[strlen(prog) - 4], ".com");
-			if ((sp = flook(prog, TRUE)) == NULL)
-				return FALSE;
-		}
-	strcpy(prog, sp);
-
-	/* get a pointer to this PSPs environment segment number */
-	segread(&segreg);
-
-	/* set up the EXEC parameter block */
-	pblock.envptr = 0;	/* make the child inherit the parents env */
-	pblock.fcb1 = f1;	/* point to a blank FCB */
-	pblock.fcb2 = f2;	/* point to a blank FCB */
-	pblock.cline = tail;	/* parameter line pointer */
-
-	/* and make the call */
-	regs.h.ah = 0x4b;	/* EXEC Load or Execute a Program */
-	regs.h.al = 0x00;	/* load end execute function subcode */
-	segreg.ds = ((unsigned long) (prog) >> 16);	/* program name ptr */
-	regs.x.dx = (unsigned int) (prog);
-	segreg.es = ((unsigned long) (&pblock) >> 16);	/* set up param block ptr */
-	regs.x.bx = (unsigned int) (&pblock);
-#if	TURBO | MSC
-	intdosx(&regs, &regs, &segreg);
-	if (regs.x.cflag == 0) {
-		regs.h.ah = 0x4d;	/* get child process return code */
-		intdos(&regs, &regs);	/* go do it */
-		rval = regs.x.ax;	/* save child's return code */
-	} else
-#if	MSC
-		rval = -1;
-#else
-		rval = -_doserrno;	/* failed child call */
-#endif
-#endif
-	return (rval < 0) ? FALSE : TRUE;
-}
-#endif

spawn.h

@@ -1,11 +1,18 @@
-int spawncli( int f, int n) ;
+/* spawn.h -- various operating system access commands */
-int bktoshell( int f, int n) ;
+#ifndef _SPAWN_H_
-void rtfrmshell( void) ;
+#define _SPAWN_H_
-int spawn( int f, int n) ;
-int execprg( int f, int n) ;
-int pipecmd( int f, int n) ;
-int filter_buffer( int f, int n) ;
-int sys( char *cmd) ;
-int shellprog( char *cmd) ;
-int execprog( char *cmd) ;
 
+#include "names.h"  /* BINDABLE() */
+
+/* Bindable functions */
+BINDABLE( spawncli) ;
+BINDABLE( bktoshell) ;
+BINDABLE( spawn) ;
+BINDABLE( execprg) ;
+BINDABLE( pipecmd) ;
+BINDABLE( filter_buffer) ;
+
+void rtfrmshell( void) ;
+
+#endif
+/* end of spawn.h */

tcap.c

@@ -1,9 +1,7 @@
 /* tcap.c -- implements terminal.h */
 #include "terminal.h"
 
-/*	tcap.c
+/*	Unix V7 SysV and BS4 Termcap video driver
- *
- *	Unix V7 SysV and BS4 Termcap video driver
  *
  *	modified by Petri Kutvonen
  */
@@ -19,13 +17,11 @@
 #define USE_BROKEN_OPTIMIZATION 0
 #define	termdef	1 /* Don't define "term" external. */
 
-#ifndef MINGW32
 #include <curses.h>
 #include <term.h>
-#endif
 
+#include "defines.h"
 #include "display.h"
-#include "estruct.h"
 #include "termio.h"
 
 #if TERMCAP
@@ -37,9 +33,9 @@ boolean sgarbf = TRUE ;		/* TRUE if screen is garbage    */
 char sres[ 16] ;		/* current screen resolution    */
 				/* NORMAL, CGA, EGA, VGA	*/
 
-#if UNIX
+# if UNIX
-#include <signal.h>
+# include <signal.h>
-#endif
+# endif
 
 #define	MARGIN	8
 #define	SCRSIZ	64
@@ -59,36 +55,38 @@ static void tcapscrollregion(int top, int bot);
 static void putpad(char *str);
 
 static void tcapopen(void);
-#if PKCODE
+# if PKCODE
-static void tcapclose(void);
+   static void tcapclose(void);
-#endif
+# endif
 
-#if COLOR
+# if COLOR
-static void tcapfcol(void);
+   static void tcapfcol(void);
-static void tcapbcol(void);
+   static void tcapbcol(void);
-#endif
+# endif
-#if SCROLLCODE
+# if SCROLLCODE
-static void tcapscroll_reg(int from, int to, int linestoscroll);
+   static void tcapscroll_reg(int from, int to, int linestoscroll);
-static void tcapscroll_delins(int from, int to, int linestoscroll);
+   static void tcapscroll_delins(int from, int to, int linestoscroll);
-#endif
+# endif
 
 #define TCAPSLEN 315
 static char tcapbuf[TCAPSLEN];
-static char *UP, PC, *CM, *CE, *CL, *SO, *SE;
+static char *_UP, _PC, *CM, *CE, *CL, *SO, *SE;
 
-#if PKCODE
+# if PKCODE
-static char *TI, *TE;
+   static char *TI, *TE;
-#if USE_BROKEN_OPTIMIZATION
+#  if USE_BROKEN_OPTIMIZATION
-static int term_init_ok = 0;
+    static int term_init_ok = 0;
-#endif
+#  endif
-#endif
+# endif
 
-#if SCROLLCODE
+# if SCROLLCODE
-static char *CS, *DL, *AL, *SF, *SR;
+   static char *CS, *DL, *AL, *SF, *SR;
-#endif
+# endif
 
-struct terminal term = {
+terminal_t term = {
-	0, /* These four values are set dynamically at open time. */
+	480,	/* actual 479 on 2560x1440 landscape terminal window */
+	2550,	/* actual 2541 */
+	0,		/* These four values are set dynamically at open time. */
 	0,
 	0,
 	0,
@@ -96,11 +94,11 @@ struct terminal term = {
 	SCRSIZ,
 	NPAUSE,
 	tcapopen,
-#if	PKCODE
+# if PKCODE
 	tcapclose,
-#else
+# else
 	ttclose,
-#endif
+# endif
 	tcapkopen,
 	tcapkclose,
 	ttgetc,
@@ -112,14 +110,14 @@ struct terminal term = {
 	tcapbeep,
 	tcaprev,
 	tcapcres
-#if	COLOR
+# if COLOR
-	    , tcapfcol,
+    , tcapfcol,
 	tcapbcol
-#endif
+# endif
-#if     SCROLLCODE
+# if SCROLLCODE
-	    , NULL		/* set dynamically at open time */
+    , NULL		/* set dynamically at open time */
-#endif
+# endif
-};
+} ;
 
 static void tcapopen(void)
 {
@@ -128,9 +126,9 @@ static void tcapopen(void)
 	char *tv_stype;
 	int int_col, int_row;
 
-#if PKCODE && USE_BROKEN_OPTIMIZATION
+# if PKCODE && USE_BROKEN_OPTIMIZATION
 	if (!term_init_ok) {
-#endif
+# endif
 		if ((tv_stype = getenv("TERM")) == NULL) {
 			fputs( "Environment variable TERM not defined!\n", stderr) ;
 			exit( EXIT_FAILURE) ;
@@ -144,50 +142,40 @@ static void tcapopen(void)
 		}
 
 		/* Get screen size from system, or else from termcap.  */
-		getscreensize(&int_col, &int_row);
+		getscreensize( &int_col, &int_row) ;
-		term.t_nrow = int_row - 1;
+		if( (int_row <= 0)
-		term.t_ncol = int_col;
+		    && ((int_row = tgetnum("li")) == -1)) {
-
-		if ((term.t_nrow <= 0)
-		    && (term.t_nrow = (short) tgetnum("li") - 1) == -1) {
 			fputs( "termcap entry incomplete (lines)\n", stderr) ;
 			exit( EXIT_FAILURE) ;
 		}
 
-		if ((term.t_ncol <= 0)
+		if( (int_col <= 0)
-		    && (term.t_ncol = (short) tgetnum("co")) == -1) {
+		    && ((int_col = tgetnum("co")) == -1)) {
 			fputs( "Termcap entry incomplete (columns)\n", stderr) ;
 			exit( EXIT_FAILURE) ;
 		}
-#ifdef SIGWINCH
-/* At initialization we use maximum size even if current OS window is smaller */
-		term.t_mrow = MAXROW ;
-		term.t_mcol = MAXCOL ;
-		if( term.t_nrow >= term.t_mrow)
-			term.t_nrow = term.t_mrow - 1 ;
 
-		if( term.t_ncol > term.t_mcol)
+		term.t_mrow = int_row < term.t_maxrow ? int_row : term.t_maxrow ;
-			term.t_ncol = term.t_mcol ;
+		term.t_nrow = term.t_mrow - 1 ;
-#else
+		term.t_mcol = int_col < term.t_maxcol ? int_col : term.t_maxcol ;
-		term.t_mrow = term.t_nrow > MAXROW ? MAXROW : term.t_nrow;
+		term.t_ncol = term.t_mcol ;
-		term.t_mcol = term.t_ncol > MAXCOL ? MAXCOL : term.t_ncol;
+
-#endif
 		p = tcapbuf;
 		t = tgetstr("pc", &p);
 		if (t)
-			PC = *t;
+			_PC = *t;
 		else
-			PC = 0;
+			_PC = 0;
 
 		CL = tgetstr("cl", &p);
 		CM = tgetstr("cm", &p);
 		CE = tgetstr("ce", &p);
-		UP = tgetstr("up", &p);
+		_UP = tgetstr("up", &p);
 		SE = tgetstr("se", &p);
 		SO = tgetstr("so", &p);
 		if (SO != NULL)
 			revexist = TRUE;
-#if	PKCODE
+# if PKCODE
 		if (tgetnum("sg") > 0) {	/* can reverse be used? P.K. */
 			revexist = FALSE;
 			SE = NULL;
@@ -195,16 +183,16 @@ static void tcapopen(void)
 		}
 		TI = tgetstr("ti", &p);	/* terminal init and exit */
 		TE = tgetstr("te", &p);
-#endif
+# endif
 
-		if (CL == NULL || CM == NULL || UP == NULL) {
+		if (CL == NULL || CM == NULL || _UP == NULL) {
 			fputs( "Incomplete termcap entry\n", stderr) ;
 			exit( EXIT_FAILURE) ;
 		}
 
 		if (CE == NULL)	/* will we be able to use clear to EOL? */
 			eolexist = FALSE;
-#if SCROLLCODE
+# if SCROLLCODE
 		CS = tgetstr("cs", &p);
 		SF = tgetstr("sf", &p);
 		SR = tgetstr("sr", &p);
@@ -220,20 +208,20 @@ static void tcapopen(void)
 		} else {
 			term.t_scroll = NULL;
 		}
-#endif
+# endif
 
 		if (p >= &tcapbuf[TCAPSLEN]) {
 			fputs( "Terminal description too big!\n", stderr) ;
 			exit( EXIT_FAILURE) ;
 		}
-#if PKCODE && USE_BROKEN_OPTIMIZATION
+# if PKCODE && USE_BROKEN_OPTIMIZATION
 		term_init_ok = 1;
 	}
-#endif
+# endif
 	ttopen();
 }
 
-#if	PKCODE
+# if PKCODE
 static void tcapclose(void)
 {
 	putpad(tgoto(CM, 0, term.t_nrow));
@@ -241,26 +229,24 @@ static void tcapclose(void)
 	ttflush();
 	ttclose();
 }
-#endif
+# endif
 
-static void tcapkopen(void)
+static void tcapkopen( void) {
-{
+# if PKCODE
-#if	PKCODE
+	putpad( TI) ;
-	putpad(TI);
+	ttflush() ;
-	ttflush();
+	ttrow = ttcol = -1 ;
-	ttrow = 999;
+	sgarbf = TRUE ;
-	ttcol = 999;
+# endif
-	sgarbf = TRUE;
+	strcpy(sres, "NORMAL") ;
-#endif
-	strcpy(sres, "NORMAL");
 }
 
 static void tcapkclose(void)
 {
-#if	PKCODE
+# if PKCODE
 	putpad(TE);
 	ttflush();
-#endif
+# endif
 }
 
 static void tcapmove(int row, int col)
@@ -298,7 +284,7 @@ static int tcapcres(char *res)
 	return TRUE;
 }
 
-#if SCROLLCODE
+# if SCROLLCODE
 
 /* move howmanylines lines starting at from to to */
 static void tcapscroll_reg(int from, int to, int howmanylines)
@@ -346,13 +332,13 @@ static void tcapscroll_delins(int from, int to, int howmanylines)
 /* cs is set up just like cm, so we use tgoto... */
 static void tcapscrollregion(int top, int bot)
 {
-	ttputc(PC);
+	ttputc(_PC);
 	putpad(tgoto(CS, bot, top));
 }
 
-#endif
+# endif
 
-#if COLOR
+# if COLOR
 /* No colors here, ignore this. */
 static void tcapfcol(void)
 {
@@ -361,7 +347,7 @@ static void tcapfcol(void)
 static void tcapbcol(void)
 {
 }
-#endif
+# endif
 
 static void tcapbeep(void)
 {
@@ -373,3 +359,5 @@ static void putpad(char *str)
 	tputs( str, 1, (int (*)( int)) ttputc) ;
 }
 #endif /* TERMCAP */
+
+/* end of tcap.c */

terminal.h

@@ -1,82 +1,82 @@
+/* terminal.h -- */
 #ifndef __TERMINAL_H__
 #define __TERMINAL_H__
 
-
+#include "defines.h"    /* COLOR, SCROLLCODE */
-#include "defines.h"	/* COLOR, SCROLLCODE */
 #include "retcode.h"
 #include "utf8.h"
 
-/*
+/* The editor communicates with the display using a high level interface.
- * The editor communicates with the display using a high level interface. A
+   A "TERM" structure holds useful variables, and indirect pointers to
- * "TERM" structure holds useful variables, and indirect pointers to routines
+   routines that do useful operations.  The low level get and put routines
- * that do useful operations. The low level get and put routines are here too.
+   are here too.  This lets a terminal, in addition to having non standard
- * This lets a terminal, in addition to having non standard commands, have
+   commands, have funny get and put character code too.  The calls might
- * funny get and put character code too. The calls might get changed to
+   get changed to "termp->t_field" style in the future, to make it possible
- * "termp->t_field" style in the future, to make it possible to run more than
+   to run more than one terminal type.
- * one terminal type.
  */
-struct terminal {
+typedef struct {
-	short t_mrow;		/* max number of rows allowable */
+    const short t_maxrow ;          /* max number of rows allowable */
-	short t_nrow;		/* current number of rows used  */
+    const short t_maxcol ;          /* max number of columns allowable */
-	short t_mcol;		/* max Number of columns.       */
+    short t_mrow ;                  /* max number of rows displayable */
-	short t_ncol;		/* current Number of columns.   */
+    short t_nrow ;                  /* current number of rows displayed */
-	short t_margin;		/* min margin for extended lines */
+    short t_mcol ;                  /* max number of rows displayable */
-	short t_scrsiz;		/* size of scroll region "      */
+    short t_ncol ;                  /* current number of columns displayed */
-	int t_pause;		/* # times thru update to pause */
+    short t_margin ;                /* min margin for extended lines */
-	void (*t_open)(void);	/* Open terminal at the start.  */
+    short t_scrsiz ;                /* size of scroll region */
-	void (*t_close)(void);	/* Close terminal at end.       */
+    int t_pause ;                   /* # times thru update to pause */
-	void (*t_kopen)(void);	/* Open keyboard                */
+    void (*t_open)( void) ;         /* Open terminal at the start */
-	void (*t_kclose)(void);	/* close keyboard               */
+    void (*t_close)( void) ;        /* Close terminal at end. */
-	int (*t_getchar)(void);	/* Get character from keyboard. */
+    void (*t_kopen)( void) ;        /* Open keyboard */
-	int (*t_putchar)( unicode_t) ;	/* Put character to display.    */
+    void (*t_kclose)( void) ;       /* close keyboard */
-	void (*t_flush) (void);	/* Flush output buffers.        */
+    int (*t_getchar)( void) ;       /* Get character from keyboard */
-	void (*t_move)(int, int);/* Move the cursor, origin 0.   */
+    int (*t_putchar)( unicode_t) ;  /* Put character to display */
-	void (*t_eeol)(void);	/* Erase to end of line.        */
+    void (*t_flush) (void) ;        /* Flush output buffers */
-	void (*t_eeop)(void);	/* Erase to end of page.        */
+    void (*t_move)( int, int) ;     /* Move the cursor, origin 0 */
-	void (*t_beep)(void);	/* Beep.                        */
+    void (*t_eeol)( void) ;         /* Erase to end of line */
-	void (*t_rev)(int);	/* set reverse video state      */
+    void (*t_eeop)( void) ;         /* Erase to end of page */
-	int (*t_rez)(char *);	/* change screen resolution     */
+    void (*t_beep)( void) ;         /* Beep */
-#if	COLOR
+    void (*t_rev)( int) ;           /* set reverse video state */
-	int (*t_setfor) ();	/* set forground color          */
+    int (*t_rez)( char *) ;         /* change screen resolution */
-	int (*t_setback) ();	/* set background color         */
+#if COLOR
+    int (*t_setfor)() ;             /* set forground color */
+    int (*t_setback)() ;            /* set background color */
 #endif
-#if     SCROLLCODE
+#if SCROLLCODE
-	void (*t_scroll)(int, int,int);	/* scroll a region of the screen */
+    void (*t_scroll)( int, int,int) ; /* scroll a region of the screen */
 #endif
-};
+} terminal_t ;
 
-/*	TEMPORARY macros for terminal I/O  (to be placed in a machine
+/* TEMPORARY macros for terminal I/O (to be placed in a machine dependant
-					    dependant place later)	*/
+   place later)
+ */
 
-#define	TTopen		(*term.t_open)
+#define TTopen      (*term.t_open)
-#define	TTclose		(*term.t_close)
+#define TTclose     (*term.t_close)
-#define	TTkopen		(*term.t_kopen)
+#define TTkopen     (*term.t_kopen)
-#define	TTkclose	(*term.t_kclose)
+#define TTkclose    (*term.t_kclose)
-#define	TTgetc		(*term.t_getchar)
+#define TTgetc      (*term.t_getchar)
-#define	TTputc		(*term.t_putchar)
+#define TTputc      (*term.t_putchar)
-#define	TTflush		(*term.t_flush)
+#define TTflush     (*term.t_flush)
-#define	TTmove		(*term.t_move)
+#define TTmove      (*term.t_move)
-#define	TTeeol		(*term.t_eeol)
+#define TTeeol      (*term.t_eeol)
-#define	TTeeop		(*term.t_eeop)
+#define TTeeop      (*term.t_eeop)
-#define	TTbeep		(*term.t_beep)
+#define TTbeep      (*term.t_beep)
-#define	TTrev		(*term.t_rev)
+#define TTrev       (*term.t_rev)
-#define	TTrez		(*term.t_rez)
+#define TTrez       (*term.t_rez)
-#if	COLOR
+#if COLOR
-#define	TTforg		(*term.t_setfor)
+#define TTforg      (*term.t_setfor)
-#define	TTbacg		(*term.t_setback)
+#define TTbacg      (*term.t_setback)
 #endif
 
-/* Terminal table defined only in term.c */
+/* Terminal table defined only in tcap.c */
-extern struct terminal term ;
+extern terminal_t term ;
 
-extern int ttrow ;		/* Row location of HW cursor */
+extern boolean eolexist ;   /* does clear to EOL exist?     */
-extern int ttcol ;		/* Column location of HW cursor */
+extern boolean revexist ;   /* does reverse video exist?    */
+extern boolean sgarbf ;     /* State of screen unknown      */
 
-extern boolean eolexist ;	/* does clear to EOL exist?     */
+extern char sres[] ;        /* Current screen resolution.   */
-extern boolean revexist ;	/* does reverse video exist?    */
+                            /* NORMAL, CGA, EGA, VGA    */
-extern boolean sgarbf ;		/* State of screen unknown      */
-
-extern char sres[] ;	        /* Current screen resolution.   */
-				/* NORMAL, CGA, EGA, VGA	*/
 
 #endif
+/* end of terminal.h */

termio.c

@@ -1,21 +1,19 @@
 /* termio.c -- implements termio.h */
-#if !defined( POSIX) && !defined( MINGW32)
-
 #include "termio.h"
 
-/*  TERMIO.C
+#include "defines.h"	/* POSIX */
- *
+#ifndef POSIX
- * The functions in this file negotiate with the operating system for
+
- * characters, and write characters in a barely buffered fashion on the display.
+/* The functions in this file negotiate with the operating system for
- * All operating systems.
+   characters, and write characters in a barely buffered fashion on the
- *
+   display.  All operating systems.
- *  modified by Petri Kutvonen
+
+   modified by Petri Kutvonen
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "estruct.h"
 #include "retcode.h"
 #include "utf8.h"
 
@@ -23,35 +21,9 @@
 #include <unistd.h>
 #include <sys/ioctl.h>
 
-int ttrow = HUGE ;      /* Row location of HW cursor */
+int ttrow = -1 ;    /* Row location of HW cursor */
-int ttcol = HUGE ;      /* Column location of HW cursor */
+int ttcol = -1 ;	/* Column location of HW cursor */
 
-#if     VMS
-#include        <stsdef.h>
-#include        <ssdef.h>
-#include        <descrip.h>
-#include        <iodef.h>
-#include        <ttdef.h>
-#include    <tt2def.h>
-
-#define NIBUF   128     /* Input buffer size            */
-#define NOBUF   1024        /* MM says bug buffers win!     */
-#define EFN     0       /* Event flag                   */
-
-char obuf[NOBUF];       /* Output buffer                */
-int nobuf;          /* # of bytes in above          */
-char ibuf[NIBUF];       /* Input buffer                 */
-int nibuf;          /* # of bytes in above          */
-int ibufi;          /* Read index                   */
-int oldmode[3];         /* Old TTY mode bits            */
-int newmode[3];         /* New TTY mode bits            */
-short iochan;           /* TTY I/O channel              */
-#endif
-
-#if     MSDOS & (MSC | TURBO)
-union REGS rg;          /* cpu register for use of DOS calls */
-int nxtchar = -1;       /* character held from type ahead    */
-#endif
 
 #if USG         /* System V */
 #include    <signal.h>
@@ -68,7 +40,7 @@ static struct termio ntermio ;	/* characteristics to use inside		*/
 #endif
 #endif
 
-#if V7 | BSD
+#if BSD
 #include        <sgtty.h>   /* for stty/gtty functions */
 #include    <signal.h>
 struct sgttyb ostate;       /* saved tty state */
@@ -98,7 +70,7 @@ char tobuf[TBUFSIZ];        /* terminal output buffer */
 #endif
 #endif
 
-#if __hpux | SVR4
+#if SVR4
 extern int rtfrmshell();    /* return from suspended shell */
 #define TBUFSIZ 128
 char tobuf[TBUFSIZ];        /* terminal output buffer */
@@ -106,68 +78,10 @@ char tobuf[TBUFSIZ];        /* terminal output buffer */
 
 /*
  * This function is called once to set up the terminal device streams.
- * On VMS, it translates TT until it finds the terminal, then assigns
+ * On CPM it is a no-op.
- * a channel to it and sets it raw. On CPM it is a no-op.
  */
 void ttopen(void)
 {
-#if     VMS
-    struct dsc$descriptor idsc;
-    struct dsc$descriptor odsc;
-    char oname[40];
-    int iosb[2];
-    int status;
-
-    odsc.dsc$a_pointer = "TT";
-    odsc.dsc$w_length = strlen(odsc.dsc$a_pointer);
-    odsc.dsc$b_dtype = DSC$K_DTYPE_T;
-    odsc.dsc$b_class = DSC$K_CLASS_S;
-    idsc.dsc$b_dtype = DSC$K_DTYPE_T;
-    idsc.dsc$b_class = DSC$K_CLASS_S;
-    do {
-        idsc.dsc$a_pointer = odsc.dsc$a_pointer;
-        idsc.dsc$w_length = odsc.dsc$w_length;
-        odsc.dsc$a_pointer = &oname[0];
-        odsc.dsc$w_length = sizeof(oname);
-        status = LIB$SYS_TRNLOG(&idsc, &odsc.dsc$w_length, &odsc);
-        if (status != SS$_NORMAL && status != SS$_NOTRAN)
-            exit(status);
-        if (oname[0] == 0x1B) {
-            odsc.dsc$a_pointer += 4;
-            odsc.dsc$w_length -= 4;
-        }
-    } while (status == SS$_NORMAL);
-    status = SYS$ASSIGN(&odsc, &iochan, 0, 0);
-    if (status != SS$_NORMAL)
-        exit(status);
-    status = SYS$QIOW(EFN, iochan, IO$_SENSEMODE, iosb, 0, 0,
-              oldmode, sizeof(oldmode), 0, 0, 0, 0);
-    if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
-        exit(status);
-    newmode[0] = oldmode[0];
-    newmode[1] = oldmode[1] | TT$M_NOECHO;
-#if XONXOFF
-#else
-    newmode[1] &= ~(TT$M_TTSYNC | TT$M_HOSTSYNC);
-#endif
-    newmode[2] = oldmode[2] | TT2$M_PASTHRU;
-    status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
-              newmode, sizeof(newmode), 0, 0, 0, 0);
-    if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
-        exit(status);
-    term.t_nrow = (newmode[1] >> 24) - 1;
-    term.t_ncol = newmode[0] >> 16;
-
-#endif
-
-#if     MSDOS & (TURBO | (PKCODE & MSC))
-    /* kill the CONTROL-break interupt */
-    rg.h.ah = 0x33;     /* control-break check dos call */
-    rg.h.al = 1;        /* set the current state */
-    rg.h.dl = 0;        /* set it OFF */
-    intdos(&rg, &rg);   /* go for it! */
-#endif
-
 #if USG
     ioctl(0, TCGETA, &otermio); /* save old settings */
     ntermio.c_iflag = 0;    /* setup new settings */
@@ -189,7 +103,7 @@ void ttopen(void)
     kbdpoll = FALSE;
 #endif
 
-#if     V7 | BSD
+#if BSD
     gtty(0, &ostate);   /* save old state */
     gtty(0, &nstate);   /* get base of new state */
 #if XONXOFF
@@ -214,49 +128,27 @@ void ttopen(void)
 #endif
 #endif
 
-#if __hpux | SVR4
+#if SVR4
     /* provide a smaller terminal output buffer so that
        the type ahead detection works better (more often) */
     setvbuf(stdout, &tobuf[0], _IOFBF, TBUFSIZ);
     signal(SIGTSTP, SIG_DFL);   /* set signals so that we can */
     signal(SIGCONT, rtfrmshell);    /* suspend & restart emacs */
     TTflush();
-#endif              /* __hpux */
+#endif
 
     /* on all screens we are not sure of the initial position
        of the cursor                                        */
-    ttrow = 999;
+    ttrow = ttcol = -1 ;
-    ttcol = 999;
 }
 
 /*
  * This function gets called just before we go back home to the command
- * interpreter. On VMS it puts the terminal back in a reasonable state.
+ * interpreter.
  * Another no-operation on CPM.
  */
 void ttclose(void)
 {
-#if     VMS
-    int status;
-    int iosb[1];
-
-    ttflush();
-    status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
-              oldmode, sizeof(oldmode), 0, 0, 0, 0);
-    if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
-        exit(status);
-    status = SYS$DASSGN(iochan);
-    if (status != SS$_NORMAL)
-        exit(status);
-#endif
-#if     MSDOS & (TURBO | (PKCODE & MSC))
-    /* restore the CONTROL-break interupt */
-    rg.h.ah = 0x33;     /* control-break check dos call */
-    rg.h.al = 1;        /* set the current state */
-    rg.h.dl = 1;        /* set it ON */
-    intdos(&rg, &rg);   /* go for it! */
-#endif
-
 #if USG
 #if PKCODE
     ioctl(0, TCSETAW, &otermio);    /* restore terminal settings */
@@ -266,7 +158,7 @@ void ttclose(void)
     fcntl(0, F_SETFL, kbdflgs);
 #endif
 
-#if     V7 | BSD
+#if BSD
     stty(0, &ostate);
     ioctl(0, TIOCSETC, &otchars);   /* Place old character into K */
 #if BSD & PKCODE
@@ -276,30 +168,15 @@ void ttclose(void)
 }
 
 /*
- * Write a character to the display. On VMS, terminal output is buffered, and
+ * Write a character to the display.
- * we just put the characters in the big array, after checking for overflow.
- * On CPM terminal I/O unbuffered, so we just write the byte out. Ditto on
- * MS-DOS (use the very very raw console output routine).
  */
 int ttputc( unicode_t c) {
-#if     VMS
+	char utf8[ 4] ;
-    if (nobuf >= NOBUF)
+	int bytes ;
-        ttflush();
-    obuf[nobuf++] = c;
-#endif
 
-#if MSDOS & ~IBMPC
+	bytes = unicode_to_utf8( c, utf8) ;
-    bdos(6, c, 0);
+	fwrite( utf8, 1, bytes, stdout) ;
-#endif
+	return 0 ;
-
-#if     V7 | USG | BSD
-    char utf8[6];
-    int bytes;
-
-    bytes = unicode_to_utf8(c, utf8);
-    fwrite(utf8, 1, bytes, stdout);
-#endif
-    return 0 ;
 }
 
 /*
@@ -307,26 +184,7 @@ int ttputc( unicode_t c) {
  * up. A no-operation on systems where byte at a time terminal I/O is done.
  */
 void ttflush( void) {
-#if     VMS
+#if	USG | BSD
-    int status;
-    int iosb[2];
-
-    status = SS$_NORMAL;
-    if (nobuf != 0) {
-        status =
-            SYS$QIOW(EFN, iochan, IO$_WRITELBLK | IO$M_NOFORMAT,
-                 iosb, 0, 0, obuf, nobuf, 0, 0, 0, 0);
-        if (status == SS$_NORMAL)
-            status = iosb[0] & 0xFFFF;
-        nobuf = 0;
-    }
-    return status;
-#endif
-
-#if     MSDOS
-#endif
-
-#if     V7 | USG | BSD
 /*
  * Add some terminal output success checking, sometimes an orphaned
  * process may be left looping on SunOS 4.1.
@@ -351,60 +209,11 @@ void ttflush( void) {
 
 /*
  * Read a character from the terminal, performing no editing and doing no echo
- * at all. More complex in VMS that almost anyplace else, which figures. Very
+ * at all.
- * simple on CPM, because the system can do exactly what you want.
+ * Very simple on CPM, because the system can do exactly what you want.
  */
 int ttgetc( void) {
-#if     VMS
+#if BSD
-    int status;
-    int iosb[2];
-    int term[2];
-
-    while (ibufi >= nibuf) {
-        ibufi = 0;
-        term[0] = 0;
-        term[1] = 0;
-        status = SYS$QIOW(EFN, iochan, IO$_READLBLK | IO$M_TIMED,
-                  iosb, 0, 0, ibuf, NIBUF, 0, term, 0, 0);
-        if (status != SS$_NORMAL)
-            exit(status);
-        status = iosb[0] & 0xFFFF;
-        if (status != SS$_NORMAL && status != SS$_TIMEOUT &&
-            status != SS$_DATAOVERUN)
-            exit(status);
-        nibuf = (iosb[0] >> 16) + (iosb[1] >> 16);
-        if (nibuf == 0) {
-            status = SYS$QIOW(EFN, iochan, IO$_READLBLK,
-                      iosb, 0, 0, ibuf, 1, 0, term, 0,
-                      0);
-            if (status != SS$_NORMAL
-                || (status = (iosb[0] & 0xFFFF)) != SS$_NORMAL)
-                if (status != SS$_DATAOVERUN)
-                    exit(status);
-            nibuf = (iosb[0] >> 16) + (iosb[1] >> 16);
-        }
-    }
-    return ibuf[ibufi++] & 0xFF;    /* Allow multinational  */
-#endif
-
-#if MSDOS & (MSC | TURBO)
-    int c;          /* character read */
-
-    /* if a char already is ready, return it */
-    if (nxtchar >= 0) {
-        c = nxtchar;
-        nxtchar = -1;
-        return c;
-    }
-
-    /* call the dos to get a char */
-    rg.h.ah = 7;        /* dos Direct Console Input call */
-    intdos(&rg, &rg);
-    c = rg.h.al;        /* grab the char */
-    return c & 255;
-#endif
-
-#if     V7 | BSD
     return 255 & fgetc(stdin);  /* 8BIT P.K. */
 #endif
 
@@ -428,23 +237,12 @@ int ttgetc( void) {
 
 int typahead( void)
 {
-#if MSDOS & (MSC | TURBO)
-    if (kbhit() != 0)
-        return TRUE;
-    else
-        return FALSE;
-#endif
-
 #if BSD
     int x;          /* holds # of pending chars */
 
     return (ioctl(0, FIONREAD, &x) < 0) ? 0 : x;
 #endif
 
-#if PKCODE & VMS
-    return ibufi < nibuf;
-#endif
-
 #if USG
     if (!kbdqp) {
         if (!kbdpoll && fcntl(0, F_SETFL, kbdflgs | O_NDELAY) < 0)
@@ -457,14 +255,12 @@ int typahead( void)
     return kbdqp;
 #endif
 
-#if !UNIX & !VMS & !MSDOS
+#  if !UNIX
     return FALSE;
-#endif
+#  endif
 }
-#endif
+# endif
 
-#else
-typedef void _pedantic_empty_translation_unit ;
 #endif              /* not POSIX */
 
 /* end of termio.c */

termio.h

@@ -1,14 +1,13 @@
+/* termio.h -- */
 #ifndef _TERMIO_H_
 #define _TERMIO_H_
 
 #include "utf8.h"
 
-#define	TYPEAH	1  /* type ahead causes update to be skipped       */
+#define TYPEAH  1       /* type ahead causes update to be skipped */
 
-#define HUGE    1000		/* Huge number (for row/col)	*/
+extern int ttrow ;      /* Row location of HW cursor    */
-
+extern int ttcol ;      /* Column location of HW cursor */
-extern int ttrow ;		/* Row location of HW cursor	*/
-extern int ttcol ;		/* Column location of HW cursor */
 
 void ttopen( void) ;
 void ttclose( void) ;
@@ -18,3 +17,4 @@ int ttgetc( void) ;
 int typahead( void) ;
 
 #endif
+/* end of termio.h */

utf8.c

@@ -1,11 +1,27 @@
-/* utf8.c -- implements utf8.h, converts between unicode and UTF-8 */
+/* utf8.c -- implements utf8.h, conversion between unicode and UTF-8 */
-
 #include "utf8.h"
 
 #include <assert.h>
+#include <wchar.h>					/* either _XOPEN_SOURCE or _GNU_SOURCE */
 
-/*
+
- * utf8_to_unicode()
+/* Display width of UTF-8 character */
+int _utf8_width( unicode_t c) {
+#if __SIZEOF_WCHAR_T__ == 2		    /* wcwidth only supports UTF-16 */
+    return (c < 0x10000) ? wcwidth( (wchar_t) c) : -1 ;
+#else
+    return wcwidth( (wchar_t) c) ;
+#endif
+}
+
+
+int utf8_width( unicode_t c) {
+    int w = _utf8_width( c) ;
+    return (w < 0) ? 2 : w ;        /* display \u if can't figure out width */
+}
+
+
+/* utf8_to_unicode()
  *
  * Convert a UTF-8 sequence to its unicode value, and return the length of
  * the sequence in bytes.
@@ -17,66 +33,54 @@
  * NOTE 2! This does *not* verify things like minimality. So overlong forms
  * are happily accepted and decoded, as are the various "invalid values".
  */
-unsigned utf8_to_unicode(char *line, unsigned index, unsigned len, unicode_t *res)
+unsigned utf8_to_unicode( const char *line, unsigned index, unsigned len,
-{
+                                                            unicode_t *res) {
-    unicode_t   value ;
+    assert( index < len) ;
-    unsigned	c = line[ index] & 0xFFU ;
+    unsigned c = *res = (unsigned char) line[ index] ;
-    unsigned	bytes, mask, i;
 
-    *res = c;
+    /* 0xxxxxxx is valid one byte utf8
-
-    /*
-     * 0xxxxxxx is valid one byte utf8
      * 10xxxxxx is invalid UTF-8 start byte, we assume it is Latin1
      * 1100000x is start of overlong encoding sequence
      * Sequence longer than 4 bytes are invalid
      * Last valid code is 0x10FFFF, encoding start with 0xF4
      */
     if( c <= 0xC1 || c > 0xF4)
-        return 1;
+        return 1 ;
 
     /* Ok, it's 11xxxxxx, do a stupid decode */
-    mask = 0x20;
+    unsigned mask = 0x20 ;
-    bytes = 2;
+    unsigned bytes = 2 ;
     while( (c & mask) != 0) {
-        bytes++;
+        bytes++ ;
-        mask >>= 1;
+        mask >>= 1 ;
     }
 
-	/* bytes is in range [2..4] as c was in range [C2..F4] */
+    /* bytes is in range [2..4] as c was in range [C2..F4] */
-    len -= index;
+    len -= index ;
-    if (bytes > len)
+    if( bytes > len)
-        return 1;
+        return 1 ;
 
-    value = c & (mask-1);
+    unicode_t value = c & (mask - 1) ;
 
     /* Ok, do the bytes */
-    line += index;
+    line += index ;
-    for (i = 1; i < bytes; i++) {
+    for( unsigned i = 2 ; i <= bytes ; i++) {
-        c = line[i] & 0xFFU ;
+        c = (unsigned char) *++line ;
-        if ((c & 0xc0) != 0x80)
+        if( (c & 0xc0) != 0x80)
-            return 1;
+            return 1 ;
-        value = (value << 6) | (c & 0x3f);
+
+        value = (value << 6) | (c & 0x3f) ;
     }
 
     if( value > 0x10FFFF) /* Avoid 110000 - 13FFFF */
         return 1 ;
 
-    *res = value;
+    *res = value ;
-    return bytes;
+    return bytes ;
 }
 
-static void reverse_string(char *begin, char *end)
-{
-    do {
-        char a = *begin, b = *end;
-        *end = a; *begin = b;
-        begin++; end--;
-    } while (begin < end);
-}
 
-/*
+/* unicode_to_utf8()
- * unicode_to_utf8()
  *
  * Convert a unicode value to its canonical utf-8 sequence.
  *
@@ -92,12 +96,12 @@ unsigned unicode_to_utf8( unicode_t c, char *utf8) {
     assert( c <= 0x10FFFF) ;
 
 #ifdef NDEBUG
-	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 ;
 #endif
 
     if( c <= 0x7f)
-	    *utf8 = (char) c ;
+        *utf8 = (char) c ;
     else {
         unsigned prefix = 0x40 ;
         char *p = utf8 ;
@@ -108,12 +112,39 @@ unsigned unicode_to_utf8( unicode_t c, char *utf8) {
             c >>= 6 ;
         } while( c >= prefix) ;
 
-        *p = (char) (c - 2 * prefix) ;
+        *p-- = *utf8 ;
-        reverse_string( utf8, p) ;
+        *utf8++ = (char) (c - 2 * prefix) ;
+        if( utf8 < p) { /* swap middle two bytes if 4 bytes utf-8 code */
+            char c = *p ;
+            *p = *utf8 ;
+            *utf8 = c ;
+        }
     }
 
     return bytes ;
 }
 
+unsigned utf8_revdelta( unsigned char *p, unsigned pos) {
+    unsigned delta = 0 ;
+
+    if( (*p & 0xC0) == 0x80) {
+        unsigned char c ;
+
+        c = *--p ;
+        if( (c & 0xE0) == 0xC0) /* valid 2 bytes unicode seq */
+            delta = 1 ;
+        else if( ((c & 0xC0) == 0x80) && (pos > 1)) {
+            c = *--p ;
+            if( (c & 0xF0) == 0xE0) /* valid 3 bytes unicode seq */
+                delta = 2 ;
+            else if( ((c & 0xC0) == 0x80) && (pos > 2))
+                if( (p[ -1] & 0xF8) == 0xF0)    /* valid 4 bytes unicode seq */
+                    delta = 3 ;
+        }
+    }
+
+    return delta ;
+}
+
 
 /* end of utf8.c */

utf8.h

@@ -1,10 +1,15 @@
-#ifndef UTF8_H
+/* utf8.h -- conversion between unicode and UTF-8 */
-#define UTF8_H
+#ifndef _UTF8_H_
+#define _UTF8_H_
 
 typedef unsigned int unicode_t ;
 
-unsigned utf8_to_unicode( char *line, unsigned index, unsigned len,
+int _utf8_width( unicode_t c) ;	/* straight width */
+int  utf8_width( unicode_t c) ;	/* workaround width */
+unsigned utf8_to_unicode( const char *line, unsigned index, unsigned len,
                                                             unicode_t *res) ;
+unsigned utf8_revdelta( unsigned char *buf, unsigned pos) ;
 unsigned unicode_to_utf8( unicode_t c, char *utf8) ;
 
 #endif
+/* end of utf8.h */

util.c

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

util.h

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

version.h

@@ -1,17 +1,18 @@
-#ifndef VERSION_H_
+/* version.h -- name and version strings */
-#define VERSION_H_
+#ifndef _VERSION_H_
+#define _VERSION_H_
 
 #ifdef PROGRAM
 # define _QUOTE( s) #s
 # define QUOTE( s) _QUOTE( s)
 # define PROGRAM_NAME QUOTE(PROGRAM)
 #else
-# define PROGRAM_NAME "em"
+# define PROGRAM_NAME "ue"
 #endif
 
-# define PROGRAM_NAME_PFX "\xC2"
+#define PROGRAM_NAME_UTF8 "µEMACS"
-# define PROGRAM_NAME_LONG "\xB5""EMACS"	/* UTF-8 µEMACS */
 
-# define VERSION "4.2.3"
+#define VERSION "4.2.5"
 
-#endif  /* VERSION_H_ */
+#endif
+/* end of version.h */

window.c

@@ -1,76 +1,66 @@
 /* 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 <stdio.h>
+#include <assert.h>
+#include <stdlib.h>		/* malloc(), free() */
 
 #include "basic.h"
 #include "buffer.h"
-#include "display.h"
+#include "defines.h"
-#include "estruct.h"
+#include "display.h"	/* upmode() */
 #include "execute.h"
 #include "line.h"
+#include "mlout.h"
 #include "terminal.h"
 #include "wrapper.h"
 
+window_p curwp ;		/* Current window               */
+window_p wheadp ;		/* Head of list of windows      */
 
-struct window *curwp ;		/* Current window               */
+static window_p savwindow = NULL ;	/* saved window pointer */
-struct window *wheadp ;		/* Head of list of windows      */
-
-static struct window *swindow = NULL ;	/* saved window pointer */
 
 
-/*
+/* Reposition dot in the current window to line "n".  If the argument is
- * Reposition dot in the current window to line "n". If the argument is
+   positive, it is that line.  If it is negative it is that line from the
- * positive, it is that line. If it is negative it is that line from the
+   bottom.  If it is 0 the window is centered (this is what the standard
- * bottom. If it is 0 the window is centered (this is what the standard
+   redisplay code does).  With no argument it defaults to 0.  Bound to M-!.
- * redisplay code does). With no argument it defaults to 0. Bound to M-!.
  */
-int reposition(int f, int n)
+TBINDABLE( reposition) {
-{
+	curwp->w_force = (f == FALSE) ? 0 : n ;	/* default to 0 to center screen */
-	if (f == FALSE)		/* default to 0 to center screen */
+	curwp->w_flag |= WFFORCE ;
-		n = 0;
+	return TRUE ;
-	curwp->w_force = n;
-	curwp->w_flag |= WFFORCE;
-	return TRUE;
 }
 
-/*
+
- * Refresh the screen. With no argument, it just does the refresh. With an
+/* Refresh the screen.  With no argument, it just does the refresh.  With
- * argument it recenters "." in the current window. Bound to "C-L".
+   an argument it recenters "." in the current window.  Bound to "C-L".
  */
-int redraw(int f, int n)
+TBINDABLE( redraw) {
-{
+	if( f == FALSE)
-	if (f == FALSE)
+		sgarbf = TRUE ;
-		sgarbf = TRUE;
 	else {
-		curwp->w_force = 0;	/* Center dot. */
+		curwp->w_force = 0 ;	/* Center dot. */
-		curwp->w_flag |= WFFORCE;
+		curwp->w_flag |= WFFORCE ;
 	}
 
-	return TRUE;
+	return TRUE ;
 }
 
-/*
+
- * The command make the next window (next => down the screen) the current
+/* The command make the next window (next => down the screen) the current
- * window. There are no real errors, although the command does nothing if
+   window.  There are no real errors, although the command does nothing if
- * there is only 1 window on the screen. Bound to "C-X C-N".
+   there is only 1 window on the screen.  Bound to "C-X O".
- *
+
- * 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) {
@@ -93,10 +83,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;
@@ -106,15 +94,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)
@@ -136,28 +123,26 @@ int prevwind(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * This command moves the current window down by "arg" lines. Recompute the
+/* This command moves the current window down by "arg" lines. Recompute the
  * top line in the window. The move up and move down code is almost completely
  * the same; most of the work has to do with reframing the window, and picking
  * a new dot. We share the code by having "move down" just be an interface to
  * "move up". Magic. Bound to "C-X C-N".
  */
-int mvdnwind(int f, int n)
+BINDABLE( mvdnwind) {
-{
+	return mvupwind( f, -n) ;
-	return mvupwind(f, -n);
 }
 
-/*
+
- * Move the current window up by "arg" lines. Recompute the new top line of
+/* Move the current window up by "arg" lines. Recompute the new top line of
  * the window. Look to see if "." is still on the screen. If it is, you win.
  * If it isn't, then move "." to center it in the new framing of the window
  * (this command does not really move "."; it moves the frame). Bound to
  * "C-X C-P".
  */
-int mvupwind(int f, int n)
+BINDABLE( mvupwind) {
-{
+	line_p lp;
-	struct line *lp;
 	int i;
 
 	lp = curwp->w_linep;
@@ -192,17 +177,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) {
@@ -240,23 +224,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;
@@ -315,8 +296,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
@@ -324,21 +305,24 @@ int delwind(int f, int n)
  *
  * int f, n;	default flag and numeric argument
  */
-int splitwind(int f, int n)
+BINDABLE( splitwind) {
-{
+	window_p wp;
-	struct window *wp;
+	line_p lp;
-	struct line *lp;
 	int ntru;
 	int ntrl;
 	int ntrd;
-	struct window *wp1;
+	window_p wp1;
-	struct window *wp2;
+	window_p wp2;
 
-	if (curwp->w_ntrows < 3) {
+	if( curwp->w_ntrows < 3) {
-		mlwrite("Cannot split a %d line window", curwp->w_ntrows);
+		mloutfmt( "Cannot split a %d line window", curwp->w_ntrows) ;
-		return FALSE;
+		return FALSE ;
 	}
-	wp = xmalloc(sizeof(struct window));
+
+	wp = malloc( sizeof *wp) ;
+	if( wp == NULL)
+		return mloutfail( "Out of memory") ;
+
 	++curbp->b_nwnd;	/* Displayed twice.     */
 	wp->w_bufp = curbp;
 	wp->w_dotp = curwp->w_dotp;
@@ -397,33 +381,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)
@@ -449,32 +430,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;
@@ -501,13 +479,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 */
@@ -524,14 +501,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   */
@@ -542,176 +519,159 @@ struct window *wpopup(void)
 	return wp;
 }
 
-int scrnextup(int f, int n)
+
-{				/* scroll the next window up (back) a page */
+/* scroll the next window up (back) a page */
+BINDABLE( scrnextup) {
 	nextwind(FALSE, 1);
 	backpage(f, n);
 	prevwind(FALSE, 1);
 	return TRUE;
 }
 
-int scrnextdw(int f, int n)
+
-{				/* scroll the next window down (forward) a page */
+/* scroll the next window down (forward) a page */
+BINDABLE( scrnextdw) {
 	nextwind(FALSE, 1);
 	forwpage(f, n);
 	prevwind(FALSE, 1);
 	return TRUE;
 }
 
-int savewnd(int f, int n)
+
-{				/* save ptr to current window */
+/* save ptr to current window */
-	swindow = curwp;
+BINDABLE( savewnd) {
-	return TRUE;
+	savwindow = curwp ;
+	return TRUE ;
 }
 
-int restwnd(int f, int n)
-{				/* restore the saved screen */
-	struct window *wp;
 
-	/* find the window */
+/* restore the saved screen */
-	wp = wheadp;
+BINDABLE( restwnd) {
-	while (wp != NULL) {
+/* check the saved window still exists */
-		if (wp == swindow) {
+	for( window_p wp = wheadp ; wp != NULL ; wp = wp->w_wndp) {
-			curwp = wp;
+		if( wp == savwindow) {
-			curbp = wp->w_bufp;
+			curwp = wp ;
-			upmode();
+			curbp = wp->w_bufp ;
-			return TRUE;
+			upmode() ;
+			return TRUE ;
 		}
-		wp = wp->w_wndp;
 	}
 
-	mlwrite("(No such window exists)");
+	return mloutfail( "(No such window exists)") ;
-	return FALSE;
 }
 
-/*
+
- * resize the screen, re-writing the screen
+static void adjust( window_p wp, int screenrows) {
+	wp->w_ntrows = screenrows - wp->w_toprow - 2 ;
+	wp->w_flag |= WFHARD | WFMODE ;
+}
+
+/* resize the screen, re-writing the screen
  *
  * int f;	default flag
  * int n;	numeric argument
  */
-int newsize(int f, int n)
+BBINDABLE( newsize) {
-{
+	window_p wp ;		/* current window being examined */
-	struct window *wp;		/* current window being examined */
-	struct window *nextwp;	/* next window to scan */
-	struct window *lastwp;	/* last window scanned */
-	int lastline;		/* screen line of last line of current window */
 
 	/* if the command defaults, assume the largest */
-	if (f == FALSE)
+	if( f == FALSE)
 		n = term.t_mrow ;
 
 	/* make sure it's in range */
-	if (n < 3 || n > term.t_mrow) {
+	if( n < MINROWS || 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;
-	else if (term.t_nrow < n - 1) {
 
+	if( term.t_nrow == n - 1)
+	/* no change */
+		return TRUE ;
+	else if( term.t_nrow < n - 1) {
+	/* new size is bigger */
 		/* go to the last window */
-		wp = wheadp;
+		for( wp = wheadp ; wp->w_wndp != NULL ; wp = wp->w_wndp)
-		while (wp->w_wndp != NULL)
+			;
-			wp = wp->w_wndp;
 
 		/* and enlarge it as needed */
-		wp->w_ntrows = n - wp->w_toprow - 2;
+		adjust( wp, n) ;
-		wp->w_flag |= WFHARD | WFMODE;
-
 	} else {
-
+	/* new size is smaller */
 		/* rebuild the window structure */
-		nextwp = wheadp;
+		assert( wheadp->w_toprow == 0) ;	/* proves coverity wrong */
-		wp = NULL;
+		window_p lastwp = NULL ;
-		lastwp = NULL;
+		for( window_p nextwp = wheadp ; nextwp != NULL ; ) {
-		while (nextwp != NULL) {
+			wp = nextwp ;
-			wp = nextwp;
+			nextwp = wp->w_wndp ;
-			nextwp = wp->w_wndp;
+
+			/* expand previous window if current would have zero lines */
+			if( wp->w_toprow == n - 2)
+				adjust( lastwp, n) ;
 
 			/* get rid of it if it is too low */
-			if (wp->w_toprow > n - 2) {
+			if( wp->w_toprow >= n - 2) {
-
 				/* save the point/mark if needed */
-				if (--wp->w_bufp->b_nwnd == 0) {
+				if( --wp->w_bufp->b_nwnd == 0) {
-					wp->w_bufp->b_dotp = wp->w_dotp;
+					wp->w_bufp->b_dotp = wp->w_dotp ;
-					wp->w_bufp->b_doto = wp->w_doto;
+					wp->w_bufp->b_doto = wp->w_doto ;
-					wp->w_bufp->b_markp = wp->w_markp;
+					wp->w_bufp->b_markp = wp->w_markp ;
-					wp->w_bufp->b_marko = wp->w_marko;
+					wp->w_bufp->b_marko = wp->w_marko ;
 				}
 
 				/* update curwp and lastwp if needed */
-				if (wp == curwp)
+				if( wp == curwp) {
-					curwp = wheadp;
+					curwp = wheadp ;
-				curbp = curwp->w_bufp;
+					curbp = curwp->w_bufp ;
-				if (lastwp != NULL)
+				}
-					lastwp->w_wndp = NULL;
 
 				/* free the structure */
-				free((char *) wp);
+				free( wp) ;
-				wp = NULL;
+				lastwp->w_wndp = NULL ;
-
 			} else {
-				/* need to change this window size? */
+			/* need to change this window size? */
-				lastline = wp->w_toprow + wp->w_ntrows - 1;
+				if( (wp->w_toprow + wp->w_ntrows - 1) >= n - 2)
-				if (lastline >= n - 2) {
+					adjust( wp, n) ;
-					wp->w_ntrows =
-					    n - wp->w_toprow - 2;
-					wp->w_flag |= WFHARD | WFMODE;
-				}
-			}
 
-			lastwp = wp;
+				lastwp = wp ;
+			}
 		}
 	}
 
 	/* screen is garbage */
-	term.t_nrow = n - 1;
+	term.t_nrow = n - 1 ;
-	sgarbf = TRUE;
+	sgarbf = TRUE ;
-	return TRUE;
+	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)
+BBINDABLE( newwidth) {
-{
-	struct window *wp;
-
 	/* if the command defaults, assume the largest */
-	if (f == FALSE)
+	if( f == FALSE)
-		n = term.t_mcol;
+		n = term.t_mcol ;
 
 	/* make sure it's in range */
-	if (n < 10 || n > term.t_mcol) {
+	if( n < MINCOLS || 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;
+	term.t_ncol = n ;
-	term.t_margin = n / 10;
+	updmargin() ;
-	term.t_scrsiz = n - (term.t_margin * 2);
 
-	/* florce all windows to redraw */
+	/* force all windows to redraw */
-	wp = wheadp;
+	for( window_p wp = wheadp ; wp; wp = wp->w_wndp)
-	while (wp) {
+		wp->w_flag |= WFHARD | WFMOVE | WFMODE ;
-		wp->w_flag |= WFHARD | WFMOVE | WFMODE;
-		wp = wp->w_wndp;
-	}
-	sgarbf = TRUE;
 
-	return TRUE;
+	sgarbf = TRUE ;
+	return TRUE ;
 }
 
 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;
@@ -729,3 +689,5 @@ void cknewwindow(void)
 {
 	execute(META | SPEC | 'X', FALSE, 1);
 }
+
+/* end of window.c */

window.h

@@ -1,74 +1,78 @@
+/* window.h -- window functionality */
 #ifndef _WINDOW_H_
 #define _WINDOW_H_
 
-#include "defines.h"	/* COLOR, SCROLLCODE */
+#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 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_linep ;       /* Top line in the window       */
-	line_p	w_dotp ;		/* Line containing "."          */
+    line_p  w_dotp ;        /* Line containing "."          */
-	line_p	w_markp ;		/* Line containing "mark"       */
+    line_p  w_markp ;       /* Line containing "mark"       */
-	int w_doto ;			/* Byte offset for "."          */
+    int w_doto ;            /* Byte offset for "."          */
-	int w_marko;		/* Byte offset for "mark"       */
+    int w_marko ;           /* Byte offset for "mark"       */
-	int w_toprow ;		/* Origin 0 top row of window   */
+    int w_toprow ;          /* Origin 0 top row of window   */
-	int w_ntrows ;		/* # of rows of text in window  */
+    int w_ntrows ;          /* # of rows of text in window  */
-	char w_force;		/* If NZ, forcing row.          */
+    char w_force ;          /* If NZ, forcing row.          */
-	char w_flag;		/* Flags.                       */
+    char w_flag ;           /* Flags.                       */
-#if	COLOR
+#if COLOR
-	char w_fcolor;		/* current forground color      */
+    char w_fcolor ;         /* current forground color      */
-	char w_bcolor;		/* current background color     */
+    char w_bcolor ;         /* current background color     */
 #endif
 } *window_p ;
 
-extern window_p curwp ;		/* Current window               */
+extern window_p curwp ;     /* Current window               */
-extern window_p wheadp ;	/* Head of list of windows      */
+extern window_p wheadp ;    /* Head of list of windows      */
 
 /* curwbyte return the byte after the dot in current window */
 #define curwbyte() lgetc( curwp->w_dotp, curwp->w_doto)
 
-#define WFFORCE 0x01		/* Window needs forced reframe  */
+#define WFFORCE 0x01        /* Window needs forced reframe  */
-#define WFMOVE  0x02		/* Movement from line to line   */
+#define WFMOVE  0x02        /* Movement from line to line   */
-#define WFEDIT  0x04		/* Editing within a line        */
+#define WFEDIT  0x04        /* Editing within a line        */
-#define WFHARD  0x08		/* Better to a full display     */
+#define WFHARD  0x08        /* Better to a full display     */
-#define WFMODE  0x10		/* Update mode line.            */
+#define WFMODE  0x10        /* Update mode line.            */
-#define	WFCOLR	0x20		/* Needs a color change         */
+#define WFCOLR  0x20        /* Needs a color change         */
 
 #if SCROLLCODE
-#define WFKILLS 0x40		/* something was deleted        */
+# define WFKILLS 0x40       /* something was deleted        */
-#define WFINS   0x80		/* something was inserted       */
+# define WFINS   0x80       /* something was inserted       */
 #endif
 
-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) ;
+BBINDABLE( newsize) ;
-int onlywind( int f, int n) ;
+BBINDABLE( 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,46 +1,46 @@
 /* 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 <stdio.h>
+#include <assert.h>
+#include <stdlib.h>	/* malloc, free */
+#include <string.h> /* memcpy */
 
 #include "basic.h"
 #include "buffer.h"
-#include "estruct.h"
+#include "defines.h"
+#include "isa.h"
 #include "line.h"
 #include "mlout.h"
 #include "random.h"
 #include "region.h"
 #include "window.h"
 
+#define ALLOCSZ	32
 #define	TAB	0x09		/* a tab character              */
 
-#if	PKCODE
 static int justflag = FALSE ;		/* justify, don't fill */
-#endif
 
 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 */
 
@@ -79,192 +79,140 @@ int wrapword(int f, int n)
 	return TRUE;
 }
 
-/*
+
- * Move the cursor backward by "n" words. All of the details of motion are
+/* 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)
-	if (n < 0)
+		return forwword( f, -n) ;
-		return forwword(f, -n);
+
-	if (backchar(FALSE, 1) == FALSE)
+	if( backchar( FALSE, 1) == FALSE)
-		return FALSE;
+		return FALSE ;
-	while (n--) {
+
-		while (inword() == FALSE) {
+	while( n--) {
-			if (backchar(FALSE, 1) == FALSE)
+		while( !inword())
-				return FALSE;
+			if( backchar( FALSE, 1) == FALSE)
-		}
+				return FALSE ;
-		while (inword() != FALSE) {
+
-			if (backchar(FALSE, 1) == FALSE)
+		do {
-				return FALSE;
+			if( backchar( FALSE, 1) == FALSE)
-		}
+				return FALSE ;
+		} while( inword()) ;
 	}
-	return forwchar(FALSE, 1);
+
+	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.
- */
-int forwword(int f, int n)
-{
-	if (n < 0)
-		return backword(f, -n);
-	while (n--) {
-		while (inword() == TRUE) {
-			if (forwchar(FALSE, 1) == FALSE)
-				return FALSE;
-		}
 
-		while (inword() == FALSE) {
+/* Move the cursor forward by the specified number of words.  All of the
-			if (forwchar(FALSE, 1) == FALSE)
+   motion is done by "forwchar".  Error if you try and move beyond the
-				return FALSE;
+   buffer's end.
-		}
+ */
+BINDABLE( forwword) {
+	if( n < 0)
+		return backword( f, -n) ;
+
+	while( n--) {
+		while( inword())
+			if( forwchar( FALSE, 1) == FALSE)
+				return FALSE ;
+
+		do {
+			if( forwchar( FALSE, 1) == FALSE)
+				return FALSE ;
+		} while( !inword()) ;
 	}
-	return TRUE;
+
+	return TRUE ;
 }
 
-/*
+/* Word capitalize, to upper and to lower
- * 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
+static boolean uniflip( boolean toupper_f) {	/* flip unicode case and forward */
- * end of the buffer. Bound to "M-U".
+	unicode_t	c ;
- */
+	int	len ;
-int upperword(int f, int n)
-{
-	int c;
 
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
+	len = lgetchar( &c) ;	/* len => unicode or extended ASCII */
-		return rdonly();	/* we are in read only mode     */
+	if( (c <= 255) && ( toupper_f ? islower( c) : isupper( c))) {
-	if (n < 0)
+		c = flipcase( c) ;
-		return FALSE;
+		ldelchar( 1, FALSE) ;
-	while (n--) {
+		if( len == 1)
-		while (inword() == FALSE) {
+			linsert_byte( 1, c) ;
-			if (forwchar(FALSE, 1) == FALSE)
+		else
-				return FALSE;
+			linsert( 1, c) ;
-		}
+
-		while (inword() != FALSE) {
+		lchange( WFHARD) ;
-			c = lgetc(curwp->w_dotp, curwp->w_doto);
+	} else
-#if	PKCODE
+		if( forwchar( FALSE, 1) == FALSE)
-			if (islower(c)) {
+			return FALSE ;
-#else
+
-			if (c >= 'a' && c <= 'z') {
+	return TRUE ;
-#endif
-				c -= 'a' - 'A';
-				lputc(curwp->w_dotp, curwp->w_doto, c);
-				lchange(WFHARD);
-			}
-			if (forwchar(FALSE, 1) == FALSE)
-				return FALSE;
-		}
-	}
-	return TRUE;
 }
 
-/*
+static boolean capcapword( int n, boolean first_f, boolean rest_f) {
- * Move the cursor forward by the specified number of words. As you move
+	assert( !(curbp->b_mode & MDVIEW)) ;
- * convert characters to lower case. Error if you try and move over the end of
- * the buffer. Bound to "M-L".
- */
-int lowerword(int f, int n)
-{
-	int c;
 
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
+	if( n < 0)
-		return rdonly();	/* we are in read only mode     */
+		return FALSE ;
-	if (n < 0)
+
-		return FALSE;
+	while( n--) {
-	while (n--) {
+		while( !inword())
-		while (inword() == FALSE) {
+			if( forwchar( FALSE, 1) == FALSE)
-			if (forwchar(FALSE, 1) == FALSE)
+				return FALSE ;
-				return FALSE;
+
-		}
+		if( !uniflip( first_f))
-		while (inword() != FALSE) {
+			return FALSE ;
-			c = lgetc(curwp->w_dotp, curwp->w_doto);
+
-#if	PKCODE
+		while( inword())
-			if (isupper(c)) {
+			if( !uniflip( rest_f))
-#else
+				return FALSE ;
-			if (c >= 'A' && c <= 'Z') {
-#endif
-				c += 'a' - 'A';
-				lputc(curwp->w_dotp, curwp->w_doto, c);
-				lchange(WFHARD);
-			}
-			if (forwchar(FALSE, 1) == FALSE)
-				return FALSE;
-		}
 	}
-	return TRUE;
+
+	return TRUE ;
 }
 
-/*
- * 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
- * characters to lower case. Error if you try and move past the end of the
- * buffer. Bound to "M-C".
- */
-int capword(int f, int n)
-{
-	int c;
 
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
+/* Move the cursor forward by the specified number of words.  As you move,
-		return rdonly();	/* we are in read only mode     */
+   convert any characters to upper case.  Error if you try and move beyond
-	if (n < 0)
+   the end of the buffer.  Bound to "M-U".
-		return FALSE;
+ */
-	while (n--) {
+BINDABLE( upperword) {
-		while (inword() == FALSE) {
+	return capcapword( n, TRUE, TRUE) ;
-			if (forwchar(FALSE, 1) == FALSE)
-				return FALSE;
-		}
-		if (inword() != FALSE) {
-			c = lgetc(curwp->w_dotp, curwp->w_doto);
-#if	PKCODE
-			if (islower(c)) {
-#else
-			if (c >= 'a' && c <= 'z') {
-#endif
-				c -= 'a' - 'A';
-				lputc(curwp->w_dotp, curwp->w_doto, c);
-				lchange(WFHARD);
-			}
-			if (forwchar(FALSE, 1) == FALSE)
-				return FALSE;
-			while (inword() != FALSE) {
-				c = lgetc(curwp->w_dotp, curwp->w_doto);
-#if	PKCODE
-				if (isupper(c)) {
-#else
-				if (c >= 'A' && c <= 'Z') {
-#endif
-					c += 'a' - 'A';
-					lputc(curwp->w_dotp, curwp->w_doto,
-					      c);
-					lchange(WFHARD);
-				}
-				if (forwchar(FALSE, 1) == FALSE)
-					return FALSE;
-			}
-		}
-	}
-	return TRUE;
 }
 
-/*
+
- * Kill forward by "n" words. Remember the location of dot. Move forward by
+/* Move the cursor forward by the specified number of words.  As you move
- * the right number of words. Put dot back where it was and issue the kill
+   convert characters to lower case.  Error if you try and move over the
- * command for the right number of characters. With a zero argument, just
+   end of the buffer.  Bound to "M-L".
- * kill one word and no whitespace. Bound to "M-D".
  */
-int delfword(int f, int n)
+BINDABLE( lowerword) {
-{
+	return capcapword( n, FALSE, FALSE) ;
-	struct line *dotp;	/* original cursor line */
+}
+
+
+/* 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
+   characters to lower case.  Error if you try and move past the end of the
+   buffer.  Bound to "M-C".
+ */
+BINDABLE( capword) {
+	return capcapword( n, TRUE, FALSE) ;
+}
+
+
+/* Kill forward by "n" words.  Remember the location of dot.  Move forward
+   by the right number of words.  Put dot back where it was and issue the
+   kill command for the right number of characters.  With a zero argument,
+   just kill one word and no whitespace.  Bound to "M-D".
+ */
+BINDABLE( delfword) {
+	line_p dotp;	/* original cursor line */
 	int doto;	/*      and row */
 	int c;		/* temp char */
-	long size;		/* # of chars to delete */
 
-	/* don't allow this command if we are in read only mode */
+	assert( !(curbp->b_mode & MDVIEW)) ;
-	if (curbp->b_mode & MDVIEW)
-		return rdonly();
 
 	/* ignore the command if there is a negative argument */
 	if (n < 0)
@@ -280,7 +228,7 @@ int delfword(int f, int n)
 	doto = curwp->w_doto;
 
 	/* figure out how many characters to give the axe */
-	size = 0;
+	long size = 0 ;
 
 	/* get us into a word.... */
 	while (inword() == FALSE) {
@@ -339,18 +287,14 @@ int delfword(int f, int n)
 	return ldelete(size, TRUE);
 }
 
-/*
- * Kill backwards by "n" words. Move backwards by the desired number of words,
- * counting the characters. When dot is finally moved to its resting place,
- * fire off the kill command. Bound to "M-Rubout" and to "M-Backspace".
- */
-int delbword(int f, int n)
-{
-	long size;
 
-	/* don't allow this command if we are in read only mode */
+/* Kill backwards by "n" words.  Move backwards by the desired number of
-	if (curbp->b_mode & MDVIEW)
+   words, counting the characters.  When dot is finally moved to its
-		return rdonly();
+   resting place, fire off the kill command.  Bound to "M-Rubout" and to
+   "M-Backspace".
+ */
+BINDABLE( delbword) {
+	assert( !(curbp->b_mode & MDVIEW)) ;
 
 	/* ignore the command if there is a nonpositive argument */
 	if (n <= 0)
@@ -363,7 +307,8 @@ int delbword(int f, int n)
 
 	if (backchar(FALSE, 1) == FALSE)
 		return FALSE;
-	size = 0;
+
+	long size = 0 ;
 	while (n--) {
 		while (inword() == FALSE) {
 			if (backchar(FALSE, 1) == FALSE)
@@ -385,72 +330,70 @@ int delbword(int f, int n)
  * Return TRUE if the character at dot is a character that is considered to be
  * part of a word. The word character list is hard coded. Should be setable.
  */
-static int inword(void)
+static int inword( void) {
-{
 	int c;
 
-	if (curwp->w_doto == llength(curwp->w_dotp))
+	if( curwp->w_doto == llength( curwp->w_dotp))
-		return FALSE;
+		return FALSE ;
-	c = lgetc(curwp->w_dotp, curwp->w_doto);
+
-#if	PKCODE
+	c = lgetc( curwp->w_dotp, curwp->w_doto) ;
-	if (isletter(c))
+	return isletter( c) || ( c >= '0' && c <= '9') ;
-#else
-	if (c >= 'a' && c <= 'z')
-		return TRUE;
-	if (c >= 'A' && c <= 'Z')
-#endif
-		return TRUE;
-	if (c >= '0' && c <= '9')
-		return TRUE;
-	return FALSE;
 }
 
-#if	WORDPRO
+static int parafillnjustify( int f, int n, int justify_f) {
-/*
+	unicode_t c;		/* current char during scan	*/
- * Fill the current paragraph according to the current
+	unicode_t *wbuf ;	/* buffer for current word	*/
- * fill column
+	int wbufsize ;
- *
- * f and n - deFault flag and Numeric argument
- */
-int fillpara(int f, int n)
-{
-	unicode_t c;		/* current char during scan    */
-	unicode_t wbuf[NSTRING];/* buffer for current word      */
 	int wordlen;	/* length of current word       */
 	int clength;	/* position on line during fill */
-	int i;		/* index during word copy       */
-	int newlength;	/* tentative new line length    */
 	int eopflag;	/* Are we at the End-Of-Paragraph? */
-	int firstflag;	/* first word? (needs no space) */
+	int firstflag = TRUE ;	/* first word? (needs no space) */
-	struct line *eopline;	/* pointer to line just past EOP */
+	line_p eopline;	/* pointer to line just past EOP */
-	int dotflag;	/* was the last char a period?  */
+	int	dotflag = 0 ;		/* was the last char a period?  */
+	int leftmarg = 0 ;		/* left marginal */
 
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
+	assert( !(curbp->b_mode & MDVIEW)) ;
-		return rdonly();	/* we are in read only mode     */
+
-	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)
+			return mloutfail( "Column too narrow") ;
+
+		justflag = justify_f ;
+	}
+
+	wbufsize = ALLOCSZ ;
+	wbuf = malloc( ALLOCSZ * sizeof *wbuf) ;
+	if( NULL == wbuf) {
+		justflag = FALSE ;
+		return FALSE ;
 	}
-#if	PKCODE
-	justflag = FALSE;
-#endif
 
 	/* record the pointer to the line just past the EOP */
 	gotoeop(FALSE, 1);
 	eopline = lforw(curwp->w_dotp);
 
-	/* and back top the beginning of the paragraph */
+	/* and back to the beginning of the paragraph */
 	gotobop(FALSE, 1);
 
 	/* initialize various info */
-	clength = curwp->w_doto;
+	if( justflag && leftmarg < llength(curwp->w_dotp)) {
-	if (clength && curwp->w_dotp->l_text[0] == TAB)
+		setccol( leftmarg) ;
-		clength = 8;
+		lgetchar( &c) ;
+		if( c == ' ' || c == '\t')
+		/* on a space */
+			if( getccol( TRUE) < getccol( FALSE))
+			/* first non space before current position */
+				firstflag = FALSE ;
+	}
+
+	clength = getccol( FALSE) ;
 	wordlen = 0;
-	dotflag = FALSE;
 
 	/* scan through lines, filling words */
-	firstflag = TRUE;
 	eopflag = FALSE;
 	while (!eopflag) {
 		int bytes = 1;
@@ -468,165 +411,92 @@ int fillpara(int f, int n)
 
 		/* if not a separator, just add it in */
 		if (c != ' ' && c != '\t') {
-			dotflag = (c == '.');	/* was it a dot */
+			if (wordlen < wbufsize)
-			if (wordlen < NSTRING - 1)
 				wbuf[wordlen++] = c;
+			else {
+			/* overflow */
+				unicode_t *newptr ;
+
+				newptr = realloc( wbuf, (wbufsize + ALLOCSZ) * sizeof *wbuf) ;
+				if( newptr != NULL) {
+					wbuf = newptr ;
+					wbufsize += ALLOCSZ ;
+					wbuf[ wordlen++] = c ;
+				} /* else the word is truncated silently */
+			}
 		} else if (wordlen) {
-			/* at a word break with a word waiting */
+		/* at a word break with a word waiting */
-			/* calculate tentitive new length with word added */
+			if( firstflag)
-			newlength = clength + 1 + wordlen;
+				firstflag = FALSE ;
-			if (newlength <= fillcol) {
+			else {
+			/* calculate tentative new length with word added */
+				if( fillcol > clength + dotflag + 1 + wordlen) {
 				/* add word to current line */
-				if (!firstflag) {
+					linsert( dotflag + 1, ' ') ;	/* the space */
-					linsert(1, ' ');	/* the space */
+					clength += dotflag + 1 ;
-					++clength;
+				} else {
+					/* start a new line */
+					lnewline();
+					linsert( leftmarg, ' ') ;
+					clength = leftmarg;
 				}
-				firstflag = FALSE;
-			} else {
-				/* start a new line */
-				lnewline();
-				clength = 0;
 			}
 
 			/* and add the word in in either case */
-			for (i = 0; i < wordlen; i++) {
+			for( int i = 0 ; i < wordlen ; i++) {
-				linsert(1, wbuf[i]);
+				c = wbuf[ i] ;
-				++clength;
+				linsert( 1, c) ;
-			}
-			if (dotflag) {
-				linsert(1, ' ');
 				++clength;
 			}
+
+			dotflag = c == '.' ;	/* was the last char a period?  */
 			wordlen = 0;
 		}
 	}
+
 	/* and add a last newline for the end of our new paragraph */
-	lnewline();
+	if( eopline == curbp->b_linep)	/* at EOF? */
+		forwchar( FALSE, 1) ;
+	else
+		lnewline() ;
+
+	if( justflag) {
+		forwword(FALSE, 1);
+		setccol( leftmarg) ;
+		justflag = FALSE;
+	}
+
+	free( wbuf) ;
 	return TRUE;
 }
 
-#if	PKCODE
+
+/* Fill the current paragraph according to the current
+ * fill column
+ *
+ * f and n - deFault flag and Numeric argument
+ */
+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) ;
-	unicode_t c;		/* current char durring scan    */
-	unicode_t wbuf[NSTRING];/* buffer for current word      */
-	int wordlen;	/* length of current word       */
-	int clength;	/* position on line during fill */
-	int i;		/* index during word copy       */
-	int newlength;	/* tentative new line length    */
-	int eopflag;	/* Are we at the End-Of-Paragraph? */
-	int firstflag;	/* first word? (needs no space) */
-	struct line *eopline;	/* pointer to line just past EOP */
-	int leftmarg;		/* left marginal */
-
-	if (curbp->b_mode & MDVIEW)	/* don't allow this command if      */
-		return rdonly();	/* we are in read only mode     */
-	if (fillcol == 0) {	/* no fill column set */
-		mloutstr( "No fill column set") ;
-		return FALSE;
-	}
-	justflag = TRUE;
-	leftmarg = curwp->w_doto;
-	if (leftmarg + 10 > fillcol) {
-		leftmarg = 0;
-		mloutstr( "Column too narrow") ;
-		return FALSE;
-	}
-
-	/* record the pointer to the line just past the EOP */
-	gotoeop(FALSE, 1);
-	eopline = lforw(curwp->w_dotp);
-
-	/* and back top the beginning of the paragraph */
-	gotobop(FALSE, 1);
-
-	/* initialize various info */
-	if (leftmarg < llength(curwp->w_dotp))
-		curwp->w_doto = leftmarg;
-
-	clength = curwp->w_doto;
-	if (clength && curwp->w_dotp->l_text[0] == TAB)
-		clength = 8;
-
-	wordlen = 0;
-
-	/* scan through lines, filling words */
-	firstflag = TRUE;
-	eopflag = FALSE;
-	while (!eopflag) {
-		int bytes = 1;
-
-		/* get the next character in the paragraph */
-		if (curwp->w_doto == llength(curwp->w_dotp)) {
-			c = ' ';
-			if (lforw(curwp->w_dotp) == eopline)
-				eopflag = TRUE;
-		} else
-			bytes = lgetchar(&c);
-
-		/* and then delete it */
-		ldelete(bytes, FALSE);
-
-		/* if not a separator, just add it in */
-		if (c != ' ' && c != '\t') {
-			if (wordlen < NSTRING - 1)
-				wbuf[wordlen++] = c;
-		} else if (wordlen) {
-			/* at a word break with a word waiting */
-			/* calculate tentitive new length with word added */
-			newlength = clength + 1 + wordlen;
-			if (newlength <= fillcol) {
-				/* add word to current line */
-				if (!firstflag) {
-					linsert(1, ' ');	/* the space */
-					++clength;
-				}
-				firstflag = FALSE;
-			} else {
-				/* start a new line */
-				lnewline();
-				for (i = 0; i < leftmarg; i++)
-					linsert(1, ' ');
-				clength = leftmarg;
-			}
-
-			/* and add the word in in either case */
-			for (i = 0; i < wordlen; i++) {
-				linsert(1, wbuf[i]);
-				++clength;
-			}
-			wordlen = 0;
-		}
-	}
-	/* and add a last newline for the end of our new paragraph */
-	lnewline();
-
-	forwword(FALSE, 1);
-	if (llength(curwp->w_dotp) > leftmarg)
-		curwp->w_doto = leftmarg;
-	else
-		curwp->w_doto = llength(curwp->w_dotp);
-
-	justflag = FALSE;
-	return TRUE;
 }
-#endif
 
-/*
+
- * 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) {
-{
-	int status;	/* returned status of functions */
-
 	while (n--) {		/* for each paragraph to delete */
 
 		/* mark out the end and beginning of the para to delete */
@@ -641,26 +511,26 @@ int killpara(int f, int n)
 		curwp->w_doto = 0;	/* force us to the beginning of line */
 
 		/* and delete it */
-		if ((status = killregion(FALSE, 1)) != TRUE)
+		int status = killregion( FALSE, 1) ;
-			return status;
+		if( status != TRUE)
+			return status ;
 
 		/* and clean up the 2 extra lines */
 		ldelete(2L, TRUE);
 	}
-	return TRUE;
+
+	return TRUE ;
 }
 
 
-/*
+/*	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 */
-	struct line *lp;	/* current line to scan */
 	int offset;	/* current char to scan */
 	long size;		/* size of region left to count */
 	int ch;	/* current character to scan */
@@ -671,10 +541,10 @@ int wordcount(int f, int n)
 	int nlines;		/* total number of lines in region */
 	int avgch;		/* average number of chars/word */
 	int status;		/* status return code */
-	struct region region;		/* region to look at */
+	region_t region ;	/* region to look at */
 
 	/* make sure we have a region to count */
-	if ((status = getregion(&region)) != TRUE)
+	if( (status = getregion( &region)) != TRUE)
 		return status;
 	lp = region.r_linep;
 	offset = region.r_offset;
@@ -699,14 +569,7 @@ int wordcount(int f, int n)
 		}
 
 		/* and tabulate it */
-		wordflag = (
+		wordflag = isletter( ch) || (ch >= '0' && ch <= '9') ;
-#if	PKCODE
-				   (isletter(ch)) ||
-#else
-				   (ch >= 'a' && ch <= 'z') ||
-				   (ch >= 'A' && ch <= 'Z') ||
-#endif
-				   (ch >= '0' && ch <= '9'));
 		if (wordflag == TRUE && lastword == FALSE)
 			++nwords;
 		lastword = wordflag;
@@ -723,104 +586,82 @@ int wordcount(int f, int n)
 		nwords, nchars, nlines + 1, avgch) ;
 	return TRUE;
 }
-#endif
 
-#if WORDPRO
+
-/*
+/* 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) {
-{
-	int suc;  /* success of last backchar */
-
 	if (n < 0) /* the other way... */
 		return gotoeop(f, -n);
 
 	while (n-- > 0) {  /* for each one asked for */
 
 		/* first scan back until we are in a word */
-		suc = backchar(FALSE, 1);
+		while( backchar( FALSE, 1) && !inword()) ;
-		while (!inword() && suc)
+
-			suc = backchar(FALSE, 1);
 		curwp->w_doto = 0;	/* and go to the B-O-Line */
 
 		/* and scan back until we hit a <NL><NL> or <NL><TAB>
 		   or a <NL><SPACE>                                     */
 		while (lback(curwp->w_dotp) != curbp->b_linep)
 			if (llength(curwp->w_dotp) != 0 &&
-#if	PKCODE
 			    ((justflag == TRUE) ||
-#endif
 			     (lgetc(curwp->w_dotp, curwp->w_doto) != TAB &&
 			      lgetc(curwp->w_dotp, curwp->w_doto) != ' '))
-#if	PKCODE
 			    )
-#endif
 				curwp->w_dotp = lback(curwp->w_dotp);
 			else
 				break;
 
 		/* and then forward until we are in a word */
-		suc = forwchar(FALSE, 1);
+		while( !inword() && forwchar( FALSE, 1)) ;
-		while (suc && !inword())
-			suc = forwchar(FALSE, 1);
 	}
 	curwp->w_flag |= WFMOVE;	/* force screen update */
 	return TRUE;
 }
 
-/*
- * Go forword to the end of the current paragraph
- * here we look for a <NL><NL> or <NL><TAB> or <NL><SPACE>
- * combination to delimit the beginning of a paragraph
- *
- * int f, n;		default Flag & Numeric argument
- */
-int gotoeop(int f, int n)
-{
-	int suc;  /* success of last backchar */
 
+/* Go forward to the end of the current paragraph here we look for a
+   <NL><NL> or <NL><TAB> or <NL><SPACE> combination to delimit the
+   beginning of a paragraph
+
+   int f, n;		default Flag & Numeric argument
+ */
+BINDABLE( gotoeop) {
 	if (n < 0)  /* the other way... */
 		return gotobop(f, -n);
 
 	while (n-- > 0) {  /* for each one asked for */
 		/* first scan forward until we are in a word */
-		suc = forwchar(FALSE, 1);
+		while( !inword() && forwchar( FALSE, 1)) ;
-		while (!inword() && suc)
+		curwp->w_doto = 0 ;						/* and go to the B-O-Line */
-			suc = forwchar(FALSE, 1);
+		if( curwp->w_dotp != curbp->b_linep)	/* of next line if not at EOF */
-		curwp->w_doto = 0;	/* and go to the B-O-Line */
+			curwp->w_dotp = lforw( curwp->w_dotp) ;
-		if (suc)	/* of next line if not at EOF */
-			curwp->w_dotp = lforw(curwp->w_dotp);
 
-		/* and scan forword until we hit a <NL><NL> or <NL><TAB>
+		/* and scan forward until we hit a <NL><NL> or <NL><TAB>
 		   or a <NL><SPACE>                                     */
 		while (curwp->w_dotp != curbp->b_linep) {
 			if (llength(curwp->w_dotp) != 0 &&
-#if	PKCODE
 			    ((justflag == TRUE) ||
-#endif
 			     (lgetc(curwp->w_dotp, curwp->w_doto) != TAB &&
 			      lgetc(curwp->w_dotp, curwp->w_doto) != ' '))
-#if	PKCODE
 			    )
-#endif
 				curwp->w_dotp = lforw(curwp->w_dotp);
 			else
 				break;
 		}
 
 		/* and then backward until we are in a word */
-		suc = backchar(FALSE, 1);
+		while( backchar( FALSE, 1) && !inword()) ;
-		while (suc && !inword()) {
+
-			suc = backchar(FALSE, 1);
-		}
 		curwp->w_doto = llength(curwp->w_dotp);	/* and to the EOL */
 	}
 	curwp->w_flag |= WFMOVE;  /* force screen update */
 	return TRUE;
 }
-#endif
+
+/* end of word.c */

word.h

@@ -1,23 +1,24 @@
+/* word.h -- word processing functions */
 #ifndef _WORD_H_
 #define _WORD_H_
 
-#define WORDPRO 1
+#include "names.h"
 
-int wrapword( int f, int n) ;
+/* Bindable functions */
-int backword( int f, int n) ;
+BINDABLE( wrapword) ;
-int forwword( int f, int n) ;
+BINDABLE( backword) ;
-int upperword( int f, int n) ;
+BINDABLE( forwword) ;
-int lowerword( int f, int n) ;
+BINDABLE( upperword) ;
-int capword( int f, int n) ;
+BINDABLE( lowerword) ;
-int delfword( int f, int n) ;
+BINDABLE( capword) ;
-int delbword( int f, int n) ;
+BINDABLE( delfword) ;
-#if WORDPRO
+BINDABLE( delbword) ;
-int gotobop( int f, int n) ;
+BINDABLE( gotobop) ;
-int gotoeop( int f, int n) ;
+BINDABLE( gotoeop) ;
-int fillpara( int f, int n) ;
+BINDABLE( fillpara) ;
-int justpara( int f, int n) ;
+BINDABLE( justpara) ;
-int killpara( int f, int n) ;
+BINDABLE( killpara) ;
-int wordcount( int f, int n) ;
+BINDABLE( wordcount) ;
-#endif
 
 #endif
+/* end of word.h */

wrapper.c

@@ -1,5 +1,4 @@
 /* wrapper.c -- implements wrapper.h */
-
 #include "wrapper.h"
 
 #include <stdio.h>
@@ -7,12 +6,6 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-#ifdef MINGW32
-int mkstemp( char *template) {
-	return -1 ;
-}
-#endif
-
 static void die( const char *err) {
 	fprintf( stderr, "fatal: %s\n", err) ;
 	exit( EXIT_FAILURE) ;
@@ -32,12 +25,4 @@ void xmkstemp( char *template) {
 	close( fd) ;
 }
 
-void *xmalloc( size_t size) {
-	void *ret = malloc( size) ;
-	if( !ret)
-		die( "Out of memory") ;
-
-	return ret ;
-}
-
 /* end of wrapper.c */

wrapper.h

@@ -1,10 +1,8 @@
+/* wrapper.h -- */
 #ifndef WRAPPER_H_
 #define WRAPPER_H_
 
-#include <stdlib.h>
-
 void xmkstemp( char *fname_template) ;
 
-void *xmalloc( size_t size) ;
+#endif
-
+/* end of wrapper.h */
-#endif  /* WRAPPER_H_ */

wscreen.c

@@ -1,117 +0,0 @@
-/* wscreen.c -- windows screen console for MINGW32 */
-#include "wscreen.h"
-
-#ifdef MINGW32
-
-#include <windows.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-/* Standard error macro for reporting API errors */ 
-#define PERR(bSuccess, api){if(!(bSuccess)) printf("%s:Error %d from %s \
-    on line %d\n", __FILE__, GetLastError(), api, __LINE__);}
-
-static void cls( HANDLE hConsole )
-{
-    COORD coordScreen = { 0, 0 };    /* here's where we'll home the
-                                        cursor */ 
-    BOOL bSuccess;
-    DWORD cCharsWritten;
-    CONSOLE_SCREEN_BUFFER_INFO csbi; /* to get buffer info */ 
-    DWORD dwConSize;                 /* number of character cells in
-                                        the current buffer */ 
-
-    /* get the number of character cells in the current buffer */
-
-    bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
-    PERR( bSuccess, "GetConsoleScreenBufferInfo" );
-    dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
-
-    /* fill the entire screen with blanks */ 
-
-    bSuccess = FillConsoleOutputCharacter( hConsole, (TCHAR) ' ',
-       dwConSize, coordScreen, &cCharsWritten );
-    PERR( bSuccess, "FillConsoleOutputCharacter" );
-
-    /* get the current text attribute */ 
-
-    bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
-    PERR( bSuccess, "ConsoleScreenBufferInfo" );
-
-    /* now set the buffer's attributes accordingly */ 
-
-    bSuccess = FillConsoleOutputAttribute( hConsole, csbi.wAttributes,
-       dwConSize, coordScreen, &cCharsWritten );
-    PERR( bSuccess, "FillConsoleOutputAttribute" );
-
-    /* put the cursor at (0, 0) */ 
-
-    bSuccess = SetConsoleCursorPosition( hConsole, coordScreen );
-    PERR( bSuccess, "SetConsoleCursorPosition" );
-    return;
-}
-
-void wcls( void) {
-    cls( GetStdHandle( STD_OUTPUT_HANDLE)) ;
-}
- 
-static struct {
-	int width ;
-	int height ;
-	int curTop, curBot, curRight, curLeft ;
-} Screen ;
-
-void winit( void) {
-    CONSOLE_SCREEN_BUFFER_INFO    csbInfo ;
-
-    wcls() ;
-    if( GetConsoleScreenBufferInfo(
-                                 GetStdHandle( STD_OUTPUT_HANDLE), &csbInfo)) {
-        Screen.width = csbInfo.dwSize.X ;
-	Screen.height = csbInfo.dwSize.Y ;
-        Screen.curLeft = csbInfo.srWindow.Left ;
-	Screen.curTop = csbInfo.srWindow.Top ;
-	Screen.curRight = csbInfo.srWindow.Right ;
-	Screen.curBot = csbInfo.srWindow.Bottom ;
-    }
-}
-
-int wwidth( void) {
-	return Screen.width ;
-}
-
-int wheight( void) {
-	return Screen.height ;
-}
-
-int wleft( void) {
-	return Screen.curLeft ;
-}
-
-int wtop( void) {
-	return Screen.curTop ;
-}
-
-int wright( void) {
-	return Screen.curRight ;
-}
-
-int wbottom( void) {
-	return Screen.curBot ;
-}
-
-void wgoxy( int x, int y) {
-    COORD coord ;
-    
-    coord.X = x ;
-    coord.Y = y ;
-    SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE), coord );
-}
-
-void wtitle( const char *title) {
-    SetConsoleTitle( title) ;
-}
-
-#endif /* MINGW32 */
-
-/* end of wscreen.c */

wscreen.h

@@ -1,14 +0,0 @@
-/* wscreen.h -- character screen drawing */
-
-void winit( void) ;
-void wcls( void) ;
-void wgoxy( int x, int y) ;
-void wtitle( const char *title) ;
-int wwidth( void) ;
-int wheight( void) ;
-int wleft( void) ;
-int wright( void) ;
-int wtop( void) ;
-int wbottom( void) ;
-
-/* end of wscreen.h */