[comp.emacs] Termcap mods for microemacs 3.8

dca@toylnd.UUCP (David C. Albrecht) (08/14/87)

#!/bin/sh
#
# The following is a posting for a set of mods to the distributed
# microemacs 3.8i.  It might be of interest to those like myself
# who are running microemacs on UNIX based iron.  It consists of
# a set of hacks to input and tcap to provide support for input
# as well as output.  It binds the termcap kl = FNA, kr = FNB,
# ku = FNC, kd = FND, kh = FNE, it also binds k0 through k9 to
# FNF - FNO, l0 through l9 to FNP - FNY.
# 
# Finally, you can put in your startup file:
# 
# bind-to-key previous-line      FNC
# bind-to-key next-line          FND
# bind-to-key forward-character  FNB
# bind-to-key backward-character FNA
# 
# and no matter what kind of terminal you use the cursor keys will work
# (I admit it, I've always hated ^N ^P ^B ^F).
# 
# I also added $term to the predefined variable list in the macros so
# that you can access the TERM environment variable to determine if
# you can make other bindings.  It won't hurt to make bindings to
# FNs that aren't supported by a particular terminal but if you
# use a select set of terminals you can thereby provide a fancier
# mapping.
# 
# Not being a termcap guru I picked the entries from the man page that
# seemed closest to being the kinds of things I wanted to bind to,
# i.e. function keys and keypad.  Note that in this implementation
# the termcap bindings take precedence over any sequences you type
# manually.  I wouldn't expect this to be a problem but it is possible
# that one of the k's or l's would steal a sequence you like to type normally.
# 
# Well, I've done my hack for this month.  Maybe some other crazy person
# could see if they can use this stuff to make microemacs emulate edt :-).
# 
# The following is mostly a bunch of diffs except for I included an entire
# edef.h because I don't like duplicating declarations so I changed it to the
# way I usually do things.
# 
# Hope someone else finds this useful.
# 
# David Albrecht
# 
#
echo 'Start of me3.8mods, part 01 of 01:'
echo 'x - diffs'
sed 's/^X//' > diffs << '/'
Xdiff -bc unmod3.8/display.c me3.8/display.c
X*** unmod3.8/display.c	Wed Jul 29 23:45:41 1987
X--- me3.8/display.c	Wed Jul 22 22:29:53 1987
X***************
X*** 44,49
X      register int i;
X      register VIDEO *vp;
X      char *malloc();
X  
X      TTopen();		/* open the screen */
X      TTkopen();		/* open the keyboard */
X
X--- 44,52 -----
X      register int i;
X      register VIDEO *vp;
X      char *malloc();
X+ #if TERMCAP
X+     char *kpinit;
X+ #endif
X  
X      TTopen();		/* open the screen */
X      TTkopen();		/* open the keyboard */
X***************
X*** 48,53
X      TTopen();		/* open the screen */
X      TTkopen();		/* open the keyboard */
X      TTrev(FALSE);
X      vscreen = (VIDEO **) malloc(term.t_mrow*sizeof(VIDEO *));
X  
X      if (vscreen == NULL)
X
X--- 51,63 -----
X      TTopen();		/* open the screen */
X      TTkopen();		/* open the keyboard */
X      TTrev(FALSE);
X+ #if TERMCAP
X+     if (kpinit = KS) {
X+ 	while (*kpinit) {
X+ 		TTputc(*(kpinit++));
X+ 	}
X+     }
X+ #endif
X      vscreen = (VIDEO **) malloc(term.t_mrow*sizeof(VIDEO *));
X  
X      if (vscreen == NULL)
X***************
X*** 93,98
X   */
X  vttidy()
X  {
X      mlerase();
X      movecursor(term.t_nrow, 0);
X      TTflush();
X
X--- 103,112 -----
X   */
X  vttidy()
X  {
X+ #if TERMCAP
X+     char *kpreset;
X+ #endif
X+ 
X      mlerase();
X      movecursor(term.t_nrow, 0);
X  #if TERMCAP
X***************
X*** 95,100
X  {
X      mlerase();
X      movecursor(term.t_nrow, 0);
X      TTflush();
X      TTclose();
X      TTkclose();
X
X--- 109,121 -----
X  
X      mlerase();
X      movecursor(term.t_nrow, 0);
X+ #if TERMCAP
X+     if (kpreset = KE) {
X+ 	while (*kpreset) {
X+ 	    TTputc(*(kpreset++));
X+ 	}
X+     }
X+ #endif    
X      TTflush();
X      TTclose();
X      TTkclose();
Xdiff -bc unmod3.8/eval.c me3.8/eval.c
X*** unmod3.8/eval.c	Wed Jul 29 23:46:32 1987
X--- me3.8/eval.c	Wed Jul 22 22:29:59 1987
X***************
X*** 163,168
X  		case EVPROGNAME:return(PROGNAME);
X  		case EVSEED:	return(itoa(seed));
X  		case EVDISINP:	return(ltos(disinp));
X  	}
X  	exit(-12);	/* again, we should never get here */
X  }
X
X--- 163,173 -----
X  		case EVPROGNAME:return(PROGNAME);
X  		case EVSEED:	return(itoa(seed));
X  		case EVDISINP:	return(ltos(disinp));
X+ #if TERMCAP
X+ 		case EVTERM:	return(TERMTYPE);
X+ #else
X+ 		case EVTERM:	return("");
X+ #endif
X  	}
X  	exit(-12);	/* again, we should never get here */
X  }
Xdiff -bc unmod3.8/evar.h me3.8/evar.h
X*** unmod3.8/evar.h	Wed Jul 29 23:46:36 1987
X--- me3.8/evar.h	Wed Jul 22 22:30:11 1987
X***************
X*** 42,47
X  	"progname",		/* returns current prog name - "MicroEMACS" */
X  	"seed",			/* current random number seed */
X  	"disinp",		/* display command line input characters */
X  };
X  
X  #define	NEVARS	sizeof(envars) / sizeof(char *)
X
X--- 42,48 -----
X  	"progname",		/* returns current prog name - "MicroEMACS" */
X  	"seed",			/* current random number seed */
X  	"disinp",		/* display command line input characters */
X+ 	"term",			/* display terminal type */
X  };
X  
X  #define	NEVARS	sizeof(envars) / sizeof(char *)
X***************
X*** 70,75
X  #define	EVPROGNAME	19
X  #define	EVSEED		20
X  #define	EVDISINP	21
X  
X  /*	list of recognized user functions	*/
X  
X
X--- 71,77 -----
X  #define	EVPROGNAME	19
X  #define	EVSEED		20
X  #define	EVDISINP	21
X+ #define EVTERM		22
X  
X  /*	list of recognized user functions	*/
X  
Xdiff -bc unmod3.8/input.c me3.8/input.c
X*** unmod3.8/input.c	Wed Jul 29 23:47:23 1987
X--- me3.8/input.c	Wed Jul 22 22:30:14 1987
X***************
X*** 6,11
X  #include	"estruct.h"
X  #include	"edef.h"
X  
X  /*
X   * Ask a yes or no question in the message line. Return either TRUE, FALSE, or
X   * ABORT. The ABORT status is returned if the user bumps out of the question
X
X--- 6,15 -----
X  #include	"estruct.h"
X  #include	"edef.h"
X  
X+ #ifdef	TERMCAP
X+ static int	tseq_putback = 0;
X+ #endif
X+ 
X  /*
X   * Ask a yes or no question in the message line. Return either TRUE, FALSE, or
X   * ABORT. The ABORT status is returned if the user bumps out of the question
X***************
X*** 345,350
X  
X  {
X  	int c;		/* fetched keystroke */
X  
X  	/* get initial character */
X  	c = get1key();
X
X--- 349,359 -----
X  
X  {
X  	int c;		/* fetched keystroke */
X+ #if TERMCAP
X+ 	register int tseqlen = 0;
X+         register int **specpt;
X+ 	static int tseq[6], *tseqnext;
X+ #endif
X  
X  #if	TERMCAP
X  	if (!tseq_putback) {
X***************
X*** 346,351
X  {
X  	int c;		/* fetched keystroke */
X  
X  	/* get initial character */
X  	c = get1key();
X  
X
X--- 355,362 -----
X  	static int tseq[6], *tseqnext;
X  #endif
X  
X+ #if	TERMCAP
X+ 	if (!tseq_putback) {
X  		/* get initial character */
X  		c = get1key();
X  		tseqnext = tseq;
X***************
X*** 348,353
X  
X  	/* get initial character */
X  	c = get1key();
X  
X  	/* process META prefix */
X  	if (c == metac) {
X
X--- 359,408 -----
X  	if (!tseq_putback) {
X  		/* get initial character */
X  		c = get1key();
X+ 		tseqnext = tseq;
X+ 		while (1) {
X+ 		        *(tseqnext++) = c;
X+ 			*tseqnext = 0;
X+ 			tseqlen++;
X+ 			specpt = specs;
X+ 			while (specpt < &specs[MAX_SPECS]) {
X+ 				if (*specpt) {
X+ 					{ register int *c1, *c2, i;
X+ 					c1 = *specpt;
X+ 					c2 = tseq;
X+ 					i = tseqlen;
X+ 					while (i-- && *(c1++) == *(c2++));
X+ 					if (i < 0) {
X+ 						if (!*c1) {
X+ 							return(SPEC | 'A' + (specpt - specs));
X+ 						}
X+ 						else {
X+ 							c = get1key();
X+ 							break;
X+ 						}
X+ 					}
X+ 					} /* end register */
X+ 				}
X+ 				specpt++;
X+ 			}
X+ 			if (specpt >= &specs[MAX_SPECS]) {
X+ 				tseq_putback = tseqlen - 1;
X+ 				if (tseq_putback) {
X+ 					tseqnext = tseq;
X+ 					c = *(tseqnext++);
X+ 				}
X+ 				break;
X+ 			}
X+ 		}
X+ 	}
X+ 	else {
X+ 		c = *(tseqnext++);
X+ 		tseq_putback--;
X+ 	}
X+ #else
X+ 	/* get initial character */
X+ 	c = get1key();
X+ #endif
X  
X  	/* process META prefix */
X  	if (c == metac) {
X***************
X*** 351,356
X  
X  	/* process META prefix */
X  	if (c == metac) {
X  		c = get1key();
X  	        if (islower(c))		/* Force to upper */
X          	        c ^= DIFCASE;
X
X--- 406,417 -----
X  
X  	/* process META prefix */
X  	if (c == metac) {
X+ #if TERMCAP
X+ 		if (tseq_putback) {
X+ 			c =  *(tseqnext++);
X+ 			tseq_putback--;
X+ 		}
X+ 		else {
X  			c = get1key();
X  		}
X  #else
X***************
X*** 352,357
X  	/* process META prefix */
X  	if (c == metac) {
X  		c = get1key();
X  	        if (islower(c))		/* Force to upper */
X          	        c ^= DIFCASE;
X  	        if (c>=0x00 && c<=0x1F)		/* control key */
X
X--- 413,422 -----
X  		}
X  		else {
X  			c = get1key();
X+ 		}
X+ #else
X+ 		c = get1key();
X+ #endif
X  	        if (islower(c))		/* Force to upper */
X          	        c ^= DIFCASE;
X  	        if (c>=0x00 && c<=0x1F)		/* control key */
X***************
X*** 361,366
X  
X  	/* process CTLX prefix */
X  	if (c == ctlxc) {
X  		c = get1key();
X  	        if (c>='a' && c<='z')		/* Force to upper */
X          	        c -= 0x20;
X
X--- 426,437 -----
X  
X  	/* process CTLX prefix */
X  	if (c == ctlxc) {
X+ #if TERMCAP
X+ 		if (tseq_putback) {
X+ 			c =  *(tseqnext++);
X+ 			tseq_putback--;
X+ 		}
X+ 		else {
X  			c = get1key();
X  		}
X  #else
X***************
X*** 362,367
X  	/* process CTLX prefix */
X  	if (c == ctlxc) {
X  		c = get1key();
X  	        if (c>='a' && c<='z')		/* Force to upper */
X          	        c -= 0x20;
X  	        if (c>=0x00 && c<=0x1F)		/* control key */
X
X--- 433,442 -----
X  		}
X  		else {
X  			c = get1key();
X+ 		}
X+ #else
X+ 		c = get1key();
X+ #endif
X  	        if (c>='a' && c<='z')		/* Force to upper */
X          	        c -= 0x20;
X  	        if (c>=0x00 && c<=0x1F)		/* control key */
Xdiff -bc unmod3.8/tcap.c me3.8/tcap.c
X*** unmod3.8/tcap.c	Wed Jul 29 23:48:58 1987
X--- me3.8/tcap.c	Wed Jul 22 22:30:16 1987
X***************
X*** 75,81
X          char *getenv();
X          char *t, *p, *tgetstr();
X          char tcbuf[1024];
X-         char *tv_stype;
X          char err_str[72];
X  
X          if ((tv_stype = getenv("TERM")) == NULL)
X
X--- 75,80 -----
X          char *getenv();
X          char *t, *p, *tgetstr();
X          char tcbuf[1024];
X          char err_str[72];
X  
X          if ((TERMTYPE = getenv("TERM")) == NULL)
X***************
X*** 78,84
X          char *tv_stype;
X          char err_str[72];
X  
X!         if ((tv_stype = getenv("TERM")) == NULL)
X          {
X                  puts("Environment variable TERM not defined!");
X                  exit(1);
X
X--- 77,83 -----
X          char tcbuf[1024];
X          char err_str[72];
X  
X!         if ((TERMTYPE = getenv("TERM")) == NULL)
X          {
X                  puts("Environment variable TERM not defined!");
X                  exit(1);
X***************
X*** 84,90
X                  exit(1);
X          }
X  
X!         if ((tgetent(tcbuf, tv_stype)) != 1)
X          {
X                  sprintf(err_str, "Unknown terminal type %s!", tv_stype);
X                  puts(err_str);
X
X--- 83,89 -----
X                  exit(1);
X          }
X  
X!         if ((tgetent(tcbuf, TERMTYPE)) != 1)
X          {
X                  sprintf(err_str, "Unknown terminal type %s!", TERMTYPE);
X                  puts(err_str);
X***************
X*** 86,92
X  
X          if ((tgetent(tcbuf, tv_stype)) != 1)
X          {
X!                 sprintf(err_str, "Unknown terminal type %s!", tv_stype);
X                  puts(err_str);
X                  exit(1);
X          }
X
X--- 85,91 -----
X  
X          if ((tgetent(tcbuf, TERMTYPE)) != 1)
X          {
X!                 sprintf(err_str, "Unknown terminal type %s!", TERMTYPE);
X                  puts(err_str);
X                  exit(1);
X          }
X***************
X*** 127,132
X  	if (CE == NULL)		/* will we be able to use clear to EOL? */
X  		eolexist = FALSE;
X  		
X          if (p >= &tcapbuf[TCAPSLEN])
X          {
X                  puts("Terminal description too big!\n");
X
X--- 126,160 -----
X  	if (CE == NULL)		/* will we be able to use clear to EOL? */
X  		eolexist = FALSE;
X  
X+ 	KS = tgetstr("ks", &p);
X+ 	KE = tgetstr("ke", &p);
X+ 
X+ 	setkeypad("kl",KL,&p);
X+ 	setkeypad("kr",KR,&p);
X+ 	setkeypad("ku",KU,&p);
X+ 	setkeypad("kd",KD,&p);
X+ 	setkeypad("kh",KH,&p);
X+ 	setkeypad("k0",K0,&p);
X+ 	setkeypad("k1",K1,&p);
X+ 	setkeypad("k2",K2,&p);
X+ 	setkeypad("k3",K3,&p);
X+ 	setkeypad("k4",K4,&p);
X+ 	setkeypad("k5",K5,&p);
X+ 	setkeypad("k6",K6,&p);
X+ 	setkeypad("k7",K7,&p);
X+ 	setkeypad("k8",K8,&p);
X+ 	setkeypad("k9",K9,&p);
X+ 	setkeypad("l0",L0,&p);
X+ 	setkeypad("l1",L1,&p);
X+ 	setkeypad("l2",L2,&p);
X+ 	setkeypad("l3",L3,&p);
X+ 	setkeypad("l4",L4,&p);
X+ 	setkeypad("l5",L5,&p);
X+ 	setkeypad("l6",L6,&p);
X+ 	setkeypad("l7",L7,&p);
X+ 	setkeypad("l8",L8,&p);
X+ 	setkeypad("l9",L9,&p);
X+ 		
X          if (p >= &tcapbuf[TCAPSLEN])
X          {
X                  puts("Terminal description too big!\n");
X***************
X*** 215,220
X  	tputs(str, n, ttputc);
X  }
X  
X  
X  #if	FLABEL
X  fnclabel(f, n)		/* label a function key */
X
X--- 243,269 -----
X  	tputs(str, n, ttputc);
X  }
X  
X+ 
X+ setkeypad(tcapstr, specno, p)
X+ char *tcapstr;
X+ int specno;
X+ char **p;
X+ {	char *tgetstr();
X+         register char c, *str;
X+ 	register int *inseq;
X+ 
X+ 	str = tgetstr(tcapstr, p);
X+         if (str) {
X+ 		inseq = specs[specno] = (int *)malloc(sizeof(int) * (strlen(str)+1));
X+ 		while (c = *(str++)) {
X+ 			if (c>=0x00 && c <=0x1F)
X+ 				*(inseq++) = CTRL | (c+'@');
X+ 			else
X+ 				*(inseq++) = c;
X+ 		}
X+ 		*(inseq) = 0;
X+ 	}
X+ }
X  
X  #if	FLABEL
X  fnclabel(f, n)		/* label a function key */
X
/
echo 'x - edef.h'
sed 's/^X//' > edef.h << '/'
X/*	EDEF:		Global variable definitions for
X			MicroEMACS 3.2
X
X			written by Dave G. Conroy
X			modified by Steve Wilhite, George Jones
X			greatly modified by Daniel Lawrence
X*/
X
X/* some global fuction declarations */
X
Xchar *malloc();
Xchar *strcpy();
Xchar *strcat();
Xchar *strncpy();
Xchar *itoa();
Xchar *getval();
Xchar *gtenv();
Xchar *gtusr();
Xchar *gtfun();
Xchar *token();
Xchar *ltos();
Xchar *flook();
Xchar *mkupper();
Xchar *mklower();
Xunsigned int getckey();
X
X#ifdef	maindef
X#define EXTERN
X#define INIT(x) = x
X#else
X#define EXTERN extern
X#define INIT(x)
X#endif
X
X/* for MAIN.C */
X
X/* initialized global definitions */
X
XEXTERN	int	fillcol	   INIT(72);	/* Current fill column          */
XEXTERN	short   kbdm[NKBDM];		/* Macro                        */
XEXTERN	char	*execstr   INIT(NULL);	/* pointer to string to execute	*/
XEXTERN	char	golabel[NPAT] INIT("");	/* current line to go to	*/
XEXTERN	int	execlevel  INIT(0);	/* execution IF level		*/
XEXTERN	int	eolexist   INIT(TRUE);	/* does clear to EOL exist	*/
XEXTERN	int	revexist   INIT(FALSE);	/* does reverse video exist?	*/
XEXTERN	int	flickcode  INIT(FALSE);	/* do flicker supression?	*/
XEXTERN	char	*modename[]
X#ifdef maindef
X      = {			/* name of modes		*/
X	"WRAP", "CMODE", "SPELL", "EXACT", "VIEW", "OVER",
X	"MAGIC", "CRYPT", "ASAVE"}
X#endif
X     ;
XEXTERN	char	modecode[] INIT("WCSEVOMYA");	/* letters to represent modes	*/
XEXTERN	int	gmode	   INIT(0);		/* global editor mode		*/
XEXTERN	int	gfcolor	   INIT(7);		/* global forgrnd color (white)	*/
XEXTERN	int	gbcolor	   INIT(0);		/* global backgrnd color (black)*/
XEXTERN	int	gasave	   INIT(256);		/* global ASAVE size		*/
XEXTERN	int	gacount	   INIT(256);		/* count until next ASAVE	*/
XEXTERN	int     sgarbf	   INIT(TRUE);          /* TRUE if screen is garbage	*/
XEXTERN	int     mpresf	   INIT(FALSE);         /* TRUE if message in last line */
XEXTERN	int	clexec	   INIT(FALSE);		/* command line execution flag	*/
XEXTERN	int	mstore	   INIT(FALSE);		/* storing text to macro flag	*/
XEXTERN	int	discmd	   INIT(TRUE);		/* display command flag		*/
XEXTERN	int	disinp	   INIT(TRUE);		/* display input characters	*/
XEXTERN	struct	BUFFER *bstore INIT(NULL);	/* buffer to store macro text to*/
XEXTERN	int     vtrow	   INIT(0);             /* Row location of SW cursor */
XEXTERN	int     vtcol	   INIT(0);             /* Column location of SW cursor */
XEXTERN	int     ttrow	   INIT(HUGE);          /* Row location of HW cursor */
XEXTERN	int     ttcol	   INIT(HUGE);          /* Column location of HW cursor */
XEXTERN	int	lbound     INIT(0);		/* leftmost column of current line
X					   being displayed */
XEXTERN	int	taboff	   INIT(0);		/* tab offset for display	*/
XEXTERN	int	metac	   INIT(CTRL | '[');	/* current meta character */
XEXTERN	int	ctlxc	   INIT(CTRL | 'X');	/* current control X prefix char */
XEXTERN	int	reptc	   INIT(CTRL | 'U');	/* current universal repeat char */
XEXTERN	int	abortc	   INIT(CTRL | 'G');	/* current abort command char	*/
X
XEXTERN	int	quotec	   INIT(0x11);		/* quote char during mlreply() */
XEXTERN	char	*cname[]
X#ifdef maindef
X = {			/* names of colors		*/
X	"BLACK", "RED", "GREEN", "YELLOW", "BLUE",
X	"MAGENTA", "CYAN", "WHITE"}
X#endif
X     ;
XEXTERN	KILL	*kbufp	  INIT(NULL);	/* current kill buffer chunk pointer	*/
XEXTERN	KILL	*kbufh	  INIT(NULL);	/* kill buffer header pointer		*/
XEXTERN	int	kused	  INIT(KBLOCK);	/* # of bytes used in kill buffer	*/
XEXTERN	WINDOW	*swindow  INIT(NULL);	/* saved window pointer			*/
XEXTERN	int	cryptflag INIT(FALSE);	/* currently encrypting?		*/
XEXTERN	short	*kbdptr;		/* current position in keyboard buf */
XEXTERN	short	*kbdend	  INIT(&kbdm[0]); /* ptr to end of the keyboard */
XEXTERN	int	kbdmode	  INIT(STOP);	/* current keyboard macro mode	*/
XEXTERN	int	kbdrep	  INIT(0);	/* number of repetitions	*/
XEXTERN	int	restflag  INIT(FALSE);	/* restricted use?		*/
XEXTERN	int	lastkey	  INIT(0);	/* last keystoke		*/
XEXTERN	int	seed	  INIT(0);	/* random number seed		*/
XEXTERN	long	envram	  INIT(0l);	/* # of bytes current in use by malloc */
XEXTERN	int	macbug	  INIT(FALSE);	/* macro debuging flag		*/
XEXTERN	char	errorm[]  INIT("ERROR"); /* error literal		*/
XEXTERN	char	truem[]	  INIT("TRUE");	/* true literal			*/
XEXTERN	char	falsem[]  INIT("FALSE"); /* false litereal		*/
XEXTERN	int	cmdstatus INIT(TRUE);	/* last command status		*/
XEXTERN	char	palstr[49] INIT("");	/* palette string		*/
X
X/* uninitialized global definitions */
X
XEXTERN	int     currow;                 /* Cursor row                   */
XEXTERN	int     curcol;                 /* Cursor column                */
XEXTERN	int     thisflag;               /* Flags, this command          */
XEXTERN	int     lastflag;               /* Flags, last command          */
XEXTERN	int     curgoal;                /* Goal for C-P, C-N            */
XEXTERN	WINDOW  *curwp;                 /* Current window               */
XEXTERN	BUFFER  *curbp;                 /* Current buffer               */
XEXTERN	WINDOW  *wheadp;                /* Head of list of windows      */
XEXTERN	BUFFER  *bheadp;                /* Head of list of buffers      */
XEXTERN	BUFFER  *blistp;                /* Buffer for C-X C-B           */
X
XEXTERN	BUFFER  *bfind();               /* Lookup a buffer by name      */
XEXTERN	WINDOW  *wpopup();              /* Pop up window creation       */
XEXTERN	LINE    *lalloc();              /* Allocate a line              */
XEXTERN	char	sres[NBUFN];		/* current screen resolution	*/
X
XEXTERN	char    pat[NPAT];                      /* Search pattern		*/
XEXTERN	char	tap[NPAT];			/* Reversed pattern array.	*/
XEXTERN	char	rpat[NPAT];			/* replacement pattern		*/
X
X/* The variable matchlen holds the length of the matched
X * string - used by the replace functions.
X * The variable patmatch holds the string that satisfies
X * the search command.
X * The variables matchline and matchoff hold the line and
X * offset position of the start of match.
X */
XEXTERN	unsigned int	matchlen INIT(0);
XEXTERN	unsigned int	mlenold INIT(0);
XEXTERN	char		*patmatch INIT(NULL);
XEXTERN	LINE		*matchline INIT(NULL);
XEXTERN	int		matchoff INIT(0);
X
X#if	MAGIC
X/*
X * The variable magical determines if there are actual
X * metacharacters in the string - if not, then we don't
X * have to use the slower MAGIC mode search functions.
X */
XEXTERN	short int	magical INIT(FALSE);
XEXTERN	MC		mcpat[NPAT];		/* the magic pattern		*/
XEXTERN	MC		tapcm[NPAT];		/* the reversed magic pattern	*/
X
X#endif
X
X#if TERMCAP
X
XEXTERN	char	*TERMTYPE	INIT(NULL);	/* terminal name */
XEXTERN	char	*KS		INIT(NULL);	/* possible keypad enable */
XEXTERN	char	*KE		INIT(NULL);	/* possible keypad disable */
X
X#define KL 0			/* keypad spec numbers */
X#define KR 1
X#define KU 2
X#define KD 3
X#define KH 4
X#define K0 5
X#define K1 6
X#define K2 7
X#define K3 8
X#define K4 9
X#define K5 10
X#define K6 11
X#define K7 12
X#define K8 13
X#define K9 14
X#define L0 15
X#define L1 16
X#define L2 17
X#define L3 18
X#define L4 19
X#define L5 20
X#define L6 21
X#define L7 22
X#define L8 23
X#define L9 24
X#define MAX_SPECS 25
XEXTERN int *specs[MAX_SPECS]
X#ifdef maindef
X    ={
X       NULL, NULL, NULL, NULL, NULL,
X       NULL, NULL, NULL, NULL, NULL,
X       NULL, NULL, NULL, NULL, NULL,
X       NULL, NULL, NULL, NULL, NULL,
X       NULL, NULL, NULL, NULL, NULL
X    }
X#endif
X    ;
X
X#endif
X
X#ifndef maindef
Xextern	KEYTAB keytab[];		/* key bind to functions table	*/
Xextern	NBIND names[];			/* name to function table	*/
X#endif
X
X/* terminal table defined only in TERM.C */
X
X#ifndef	termdef
Xextern  TERM    term;                   /* Terminal information.        */
X#endif
X
X
X#undef EXTERN
X#undef INIT
/
echo 'Part 01 of me3.8mods complete.'
exit

larry@jc3b21.UUCP (Lawrence F. Strickland) (08/20/87)

In article <157@toylnd.UUCP>, dca@toylnd.UUCP (David C. Albrecht) writes:
> #!/bin/sh
> #
> # The following is a posting for a set of mods to the distributed
> # microemacs 3.8i.  It might be of interest to those like myself
> # who are running microemacs on UNIX based iron.  It consists of
> # a set of hacks to input and tcap to provide support for input
> # as well as output.  It binds the termcap kl = FNA, kr = FNB,
> # ku = FNC, kd = FND, kh = FNE, it also binds k0 through k9 to
> # FNF - FNO, l0 through l9 to FNP - FNY.

I've made a set of modifications to uemacs 3.8i which allow it to use
the cursor control keys as well as home, clear, and end keys if you have
them.  It is designed to be used under UNIX and works with both Termcap and
terminfo stuff.  I've run it on a 3b2/300 and on a XENIX system.  Both purport
at least to be System V compatible.  A friend is currently checking to see
whether it will run on BSD 4.[23].  The changes consist of modifications
to three files, estruct.h, tcap.c and termio.c.  They are not particularly
complex and are fairly short.

I don't know whether they will work with 3.8l or anything else, but I believe
they will.  The same changes will also (probably) work with Jove.

The mods are still in the testing stage, but I would like to get a feeling
for how many people would like to see them posted or mailed or if it would
be better to send them to the current 'holder of the mods' to uemacs.  Please
MAIL me your feelings, and I will summarize to the net.  Thanks,

-l

P.S.  you might also try:  ...!gatech!codas!usfvax2!jc3b21!larry    to reach
me!


-- 
+-----------------------------------+-- St. Petersburg Junior College --+
|       Lawrence F. Strickland          P.O. Box 13489                  |
|   ...akgua!usfvax2!jc3b21!larry   |   St. Petersburg, FL 33733        |
+-----------------------------------+-- Phone: +1 813 341 4705 ---------+