+/* @(#)edit.c 1.1 */
+
+/*
+ * edit.c - common routines for vi and emacs one line editors in shell
+ *
+ * David Korn P.D. Sullivan
+ * AT&T Bell Laboratories AT&T Bell Laboratories
+ * Room 5D-112 Room 1E253
+ * Murray Hill, N. J. 07974 Columbus, OH 43213
+ * Tel. x7975 Tel. x 2655
+ *
+ * Coded April 1983.
+ */
+
+#include <errno.h>
+
+#ifdef KSHELL
+#include "shtype.h"
+#include "flags.h"
+#include "defs.h"
+#include "io.h"
+#include "name.h"
+#include "sym.h"
+#include "stak.h"
+#include "mode.h"
+#include "builtins.h"
+#include "brkincr.h"
+
+#else
+#include <stdio.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <ctype.h>
+#endif /* KSHELL */
+
+#include "history.h"
+#include "edit.h"
+
+#define BAD -1
+#define GOOD 0
+#define TRUE (-1)
+#define FALSE 0
+#define SYSERR -1
+
+#ifdef VENIX
+#define RT 1
+#endif /* VENIX */
+
+void e_crlf();
+void e_flush();
+int e_getchar();
+void e_putchar();
+void e_ringbell();
+void e_setup();
+int e_virt_to_phys();
+int e_window();
+void setcooked();
+void ungetchar();
+
+#if BSD || RT
+#include <sgtty.h>
+# ifdef BSD_4_2
+# include <sys/time.h>
+# endif /* BSD_4_2 */
+static struct sgttyb ttyparm; /* initial tty parameters */
+static struct sgttyb nttyparm; /* raw tty parameters */
+# ifdef BSD
+extern int tty_speeds[];
+static int delay;
+static int l_mask;
+static struct tchars l_ttychars;
+static struct ltchars l_chars;
+static char l_changed; /* set if mode bits changed */
+#define L_CHARS 4
+#define T_CHARS 2
+#define L_MASK 1
+# endif /* BSD */
+#else
+# ifdef XENIX /* avoid symbol table overflows */
+# define NCC 8
+struct termio {
+ unsigned short c_iflag; /* input modes */
+ unsigned short c_oflag; /* output modes */
+ unsigned short c_cflag; /* control modes */
+ unsigned short c_lflag; /* line discipline modes */
+ char c_line; /* line discipline */
+ unsigned char c_cc[NCC]; /* control chars */
+ char c_res; /* padding, AFTER the array */
+};
+#define TIOC ('T'<<8)
+#define BRKINT 0000002
+#define CBAUD 0000017
+#define ECHO 0000010
+#define ECHOE 0000020
+#define ECHOK 0000040
+#define ECHONL 0000100
+#define ICANON 0000002
+#define ICRNL 0000400
+#define IGNCR 0000200
+#define IGNPAR 0000004
+#define INLCR 0000100
+#define PARMRK 0000010
+#define TCGETA (TIOC|1)
+#define TCSETAW (TIOC|3)
+#define TCXONC (TIOC|6)
+#define VEOF 4
+#define VERASE 2
+#define VKILL 3
+#define VMIN 4
+#define VTIME 5
+#define TM_CECHO 0010
+# else
+# include <termio.h>
+# endif /* XENIX */
+
+static struct termio ttyparm; /* initial tty parameters */
+static struct termio nttyparm; /* raw tty parameters */
+#endif /* RT */
+
+#define lookahead editb.e_index
+#define env editb.e_env
+#define previous editb.e_lbuf
+#define fildes editb.e_fd
+
+#ifdef KSHELL
+extern struct Amemory *alias;
+extern char **arg_build();
+extern void failed();
+extern void fault();
+extern struct Namnod *findnod();
+extern int f_complete();
+extern void gsort();
+extern char *movstr();
+extern void p_flush();
+extern void p_setout();
+extern char *simple();
+extern char *tilde();
+extern char *valup();
+static char macro[] = "_?";
+
+#else
+static char badcooked[] = "cannot reset tty to cooked mode";
+struct edit editb;
+char trapnote;
+extern char trapnote;
+extern int errno;
+#define p_flush() fflush(stderr)
+#define p_setout(s) fflush(stdout)
+#define error(s) failed(s,NULL)
+#define SIGSLOW 1
+#define output stderr
+#endif /* KSHELL */
+
+extern char *strrchr();
+extern char *strcpy();
+
+static char bellchr[] = "\7"; /* bell char */
+
+static int control();
+/*{ SETCOOKED( fd )
+ *
+ * This routine will set the tty in cooked mode.
+ * It is also called by error.done().
+ *
+}*/
+
+void setcooked(fd)
+register int fd;
+{
+ /*** don't do ioctl unless ttyparm has valid data ***/
+ /* or in raw mode */
+
+ if(editb.e_ttyspeed==0 || editb.e_raw==0)
+ return;
+
+#ifdef BSD
+ if(editb.e_raw==RAWMODE && ioctl(fd, TIOCSETN, &ttyparm) == SYSERR )
+ {
+ if(errno!=EBADF && errno!=ENOTTY)
+ error(badcooked);
+ return;
+ }
+ /* restore flags */
+ if(l_changed&L_MASK)
+ ioctl(fd,TIOCLSET,&l_mask);
+ if(l_changed&T_CHARS)
+ /* restore alternate break character */
+ ioctl(fd,TIOCSETC,&l_ttychars);
+ if(l_changed&L_CHARS)
+ /* restore alternate break character */
+ ioctl(fd,TIOCSLTC,&l_chars);
+ l_changed = 0;
+#else
+# ifdef RT
+ if (stty(fd,&ttyparm) == SYSERR)
+# else
+ if( editb.e_raw && control(fd, TCSETAW, &ttyparm) == SYSERR )
+# endif /* RT */
+ {
+ if(errno!=EBADF && errno!=ENOTTY)
+ error(badcooked);
+ return;
+ }
+#endif /* BSD */
+ editb.e_raw = 0;
+ return;
+}
+
+/*{ SETRAW( fd )
+ *
+ * This routine will set the tty in raw mode.
+ *
+}*/
+
+setraw(fd)
+register int fd;
+{
+#ifdef BSD
+ struct ltchars lchars;
+#endif /* BSD */
+ if(editb.e_raw==RAWMODE)
+ return(GOOD);
+ /* characters are echoed on standard error */
+ p_setout(stderr);
+#if BSD || RT
+# ifdef BSD
+ if((ioctl(fd,TIOCGETP,&ttyparm) == SYSERR)
+# else
+ if ((gtty(fd,&ttyparm) == SYSERR)
+# endif /* BSD */
+ || !(ttyparm.sg_flags & ECHO )
+ || (ttyparm.sg_flags & LCASE ))
+ {
+ return(BAD);
+ }
+ nttyparm = ttyparm;
+ nttyparm.sg_flags &= ~(ECHO | TBDELAY);
+# ifdef BSD
+ nttyparm.sg_flags |= CBREAK;
+# else
+ nttyparm.sg_flags |= RAW;
+# endif /* BSD */
+ editb.e_erase = ttyparm.sg_erase;
+ editb.e_kill = ttyparm.sg_kill;
+ editb.e_eof = cntl(D);
+# ifdef BSD
+ if( ioctl(fd, TIOCSETN, &nttyparm) == SYSERR )
+# else
+ if( stty(fd, &nttyparm) == SYSERR )
+# endif /* BSD */
+ {
+ return(BAD);
+ }
+ editb.e_ttyspeed = (ttyparm.sg_ospeed>=B1200?FAST:SLOW);
+#ifdef BSD
+ delay = tty_speeds[ttyparm.sg_ospeed];
+ /* try to remove effect of ^V and ^Y */
+ if(ioctl(fd,TIOCGLTC,&l_chars) != SYSERR)
+ {
+ lchars = l_chars;
+ lchars.t_lnextc = -1;
+ lchars.t_dsuspc = -1; /* no delayed stop process signal */
+ if(ioctl(fd,TIOCSLTC,&lchars) != SYSERR)
+ l_changed |= L_CHARS;
+ }
+#endif /* BSD */
+#else
+
+# ifndef RAWONLY
+ if(editb.e_raw != ALTMODE)
+# endif /* RAWONLY */
+ if( (ioctl(fd, TCGETA, &ttyparm) == SYSERR)
+ || (!(ttyparm.c_lflag & ECHO )))
+ {
+ return(BAD);
+ }
+
+ nttyparm = ttyparm;
+#ifndef u370
+ nttyparm.c_iflag &= ~(IGNPAR|PARMRK|INLCR|IGNCR|ICRNL);
+ nttyparm.c_iflag |= BRKINT;
+ nttyparm.c_lflag &= ~(ICANON|ECHO);
+#else
+ nttyparm.c_iflag &=
+ ~(IGNBRK|PARMRK|INLCR|IGNCR|ICRNL|INPCK);
+ nttyparm.c_iflag |= (BRKINT|IGNPAR);
+ nttyparm.c_lflag &= ~(ICANON|ECHO);
+#endif /* u370 */
+ nttyparm.c_cc[VTIME] = 0;
+ nttyparm.c_cc[VMIN] = 1;
+ editb.e_eof = ttyparm.c_cc[VEOF];
+ editb.e_erase = ttyparm.c_cc[VERASE];
+ editb.e_kill = ttyparm.c_cc[VKILL];
+#ifndef u370
+ if( control(fd, TCSETAW, &nttyparm) == SYSERR )
+#else
+ /* delays are too long, don't wait for output to drain */
+ if( control(fd, TCSETA, &nttyparm) == SYSERR )
+#endif /* u370 */
+ {
+ return(BAD);
+ }
+ control(fd,TCXONC,1);
+ editb.e_ttyspeed = ttyparm.c_cflag & CBAUD;
+#endif
+ editb.e_raw = RAWMODE;
+ return(GOOD);
+}
+
+#ifndef BSD
+/*
+ * give two tries for ioctl
+ * interrupts are ignored
+ */
+
+static int control(fd,request,arg)
+{
+ register int i;
+ register int k = 2;
+ errno = 0;
+ while(k--)
+ {
+ if((i = ioctl(fd,request,arg)) != SYSERR)
+ return(i);
+ if(errno == EINTR)
+ {
+ errno = 0;
+ k++;
+ }
+ }
+ return(SYSERR);
+}
+#endif /* BSD */
+#ifndef RAWONLY
+
+/* SET_TTY( fd )
+ *
+ * Get tty parameters and make ESC and '\r' wakeup characters.
+ *
+ */
+
+#ifdef BSD
+setalt(fd)
+register int fd;
+{
+ int mask;
+ struct tchars ttychars;
+ if(editb.e_raw==ALTMODE)
+ return(GOOD);
+ if(editb.e_raw==RAWMODE)
+ setcooked(fd);
+ l_changed = 0;
+ if( editb.e_ttyspeed == 0)
+ {
+ if((ioctl(fd,TIOCGETP,&ttyparm) != SYSERR))
+ editb.e_ttyspeed = (ttyparm.sg_ospeed>=B1200?FAST:SLOW);
+ }
+ if(ioctl(fd,TIOCGETC,&l_ttychars) == SYSERR)
+ return(BAD);
+ if(ioctl(fd,TIOCLGET,&l_mask)==SYSERR)
+ return(BAD);
+ ttychars = l_ttychars;
+ mask = LCRTBS|LCRTERA|LCTLECH|LPENDIN|LCRTKIL;
+ if((l_mask|mask) != l_mask)
+ l_changed = L_MASK;
+ if(ioctl(fd,TIOCLBIS,&mask)==SYSERR)
+ return(BAD);
+ ttychars.t_brkc = ESC;
+ l_changed |= T_CHARS;
+ if(ioctl(fd,TIOCSETC,&ttychars) == SYSERR)
+ return(BAD);
+ editb.e_raw = ALTMODE;
+ return(GOOD);
+}
+#else
+setalt(fd)
+register int fd;
+{
+ if(editb.e_raw==ALTMODE)
+ return(GOOD);
+ if(editb.e_raw==RAWMODE)
+ setcooked(fd);
+ if( (control(fd, TCGETA, &ttyparm) == SYSERR)
+ || (!(ttyparm.c_lflag & ECHO )))
+ {
+ return(BAD);
+ }
+ nttyparm = ttyparm;
+ nttyparm.c_iflag &= ~(IGNCR|ICRNL);
+ nttyparm.c_iflag |= INLCR;
+ nttyparm.c_lflag |= (ECHOE|ECHOK);
+ nttyparm.c_cc[VEOF] = ESC; /* make ESC the eof char */
+ nttyparm.c_cc[VEOL] = '\r'; /* make CR an eol char */
+ editb.e_eof = ttyparm.c_cc[VEOF];
+ nttyparm.c_cc[VEOL2] = editb.e_eof; /* make EOF an eol char */
+ editb.e_erase = ttyparm.c_cc[VERASE];
+ editb.e_kill = ttyparm.c_cc[VKILL];
+ if( control(fd, TCSETAW, &nttyparm) == SYSERR )
+ {
+ return(BAD);
+ }
+ editb.e_ttyspeed = ((ttyparm.c_cflag&CBAUD)>=B1200?FAST:SLOW);
+ editb.e_raw = ALTMODE;
+ return(GOOD);
+}
+
+#endif /* BSD */
+#endif /* RAWONLY */
+
+/*
+ * E_WINDOW()
+ *
+ * return the window size
+ */
+
+int e_window()
+{
+ register int n = DFLTWINDOW-1;
+ register char *cp = valup(COLUMNS);
+ if(cp)
+ {
+ n = atoi(cp)-1;
+ if(n < MINWINDOW)
+ n = MINWINDOW;
+ if(n > MAXWINDOW)
+ n = MAXWINDOW;
+ }
+ return(n);
+}
+
+/* E_FLUSH()
+ *
+ * Flush the output buffer.
+ *
+ */
+
+void e_flush()
+{
+ register unsigned char *buf = (unsigned char*)output->_base;
+ register int n = editb.e_outptr-buf;
+ register int fd = fileno(output);
+ if(n<=0)
+ return;
+ write(fd,(char*)buf,n);
+ editb.e_outptr = buf;
+#ifdef BSD
+# ifdef BSD_4_2
+ if(delay && n > delay/100)
+ {
+ /* delay until output drains */
+ struct timeval timeloc;
+ n *= 10;
+ timeloc.tv_sec = n/delay;
+ timeloc.tv_usec = (1000000*(n%delay))/delay;
+ select(0,0,0,0,&timeloc);
+ }
+# endif /* BSD_4_2 */
+#else
+# ifndef RT
+ if(editb.e_raw==RAWMODE && n > 16)
+ ioctl(fd, TCSETAW, &nttyparm);
+# endif /* RT */
+#endif /* BSD */
+}
+
+/*
+ * send the bell character ^G to the terminal
+ */
+
+void e_ringbell()
+{
+ write(fileno(output),bellchr,1);
+}
+
+/*
+ * send a carriage return line feed to the terminal
+ */
+
+void e_crlf()
+{
+#ifdef u370
+ e_putchar('\r');
+#endif /* u370 */
+#ifdef VENIX
+ e_putchar('\r');
+#endif /* VENIX */
+ e_putchar('\n');
+ e_flush();
+}
+
+/* E_SETUP( max_prompt_size )
+ *
+ * This routine sets up the prompt string
+ */
+
+void e_setup(fd,PRSIZE)
+{
+ register char *last;
+ register char *pp = (char*)(output->_base);
+ char *ppmax;
+ editb.e_fd = fd;
+ if(fc_fix)
+ {
+ register struct fixcmd *fp = fc_fix;
+ editb.e_hismax = fp->fixind;
+ editb.e_hloff = fp->fixline;
+ editb.e_hismin = fp->fixind-fp->fixmax;
+ if(editb.e_hismin<0)
+ editb.e_hismin = 0;
+ }
+ else
+ {
+ editb.e_hismax = editb.e_hismin = editb.e_hloff = 0;
+ }
+ editb.e_hline = editb.e_hismax;
+ editb.e_wsize = e_window()-2;
+ editb.e_outptr = (unsigned char*)pp;
+ editb.e_crlf = YES;
+ *(output->_ptr) = 0;
+ if((last=strrchr(pp,'\n'))==NULL)
+ {
+ if(*(last=pp)==0)
+ editb.e_crlf = NO;
+ }
+ else
+ last++;
+ pp = editb.e_prompt;
+ ppmax = pp+PRSIZE-1;
+ *pp++ = '\r';
+ {
+ register int c;
+ while(c = *last++)
+ {
+ /* cut out bells */
+ if(c!=BELL)
+ {
+ if(pp < ppmax)
+ *pp++ = c;
+ if(!isprint(c))
+ editb.e_crlf = NO;
+ }
+ }
+ }
+ editb.e_plen = pp - editb.e_prompt - 1;
+ *pp = 0;
+#ifdef u370
+ if (editb.e_raw == RAWMODE)
+ u370fflush(output);
+ else
+#endif /* u370 */
+ p_flush();
+}
+
+#ifdef u370
+/* The u370 does not \r before \n in raw mode (known bug).
+ To get around this we will insert a \r before each \n
+ in the output buffer.
+*/
+
+u370fflush(file)
+FILE *file;
+{
+ unsigned char *base,*ptr,buffer[BUFSIZ*2];
+ int icnt,ocnt;
+ ptr = buffer;
+ icnt = file->_ptr - file->_base;
+ ocnt = icnt;
+ base = file->_base ;
+ if (icnt <= 0) return;
+ while (base < file->_ptr)
+ {
+ if (*base == '\n' )
+ {
+ *ptr++ = '\r';
+ ocnt++;
+ }
+ *ptr++ = *base++;
+ }
+ base = file->_base;
+ ptr = buffer;
+ while (ocnt>0)
+ {
+ for(icnt=0;icnt<BUFSIZ;icnt++)
+ {
+ *base++ = *ptr++;
+ if (--ocnt <= 0) break;
+ }
+ file->_ptr = base;
+ p_flush();
+ base = file->_base;
+ }
+}
+#endif /* u370 */
+
+#ifdef KSHELL
+/*
+ * look for edit macro named _i
+ * if found, puts the macro definition into lookahead buffer and returns 1
+ */
+
+e_macro(i)
+register int i;
+{
+ register char *out;
+ struct Namnod *np;
+ genchar buff[LOOKAHEAD+1];
+ if(i != '@')
+ macro[1] = i;
+ if (isalnum(i)&&(np=findnod(macro,alias,0))&&(out=valup(np)))
+ {
+#ifdef MULTIBYTE
+ /* copy to buff in internal representation */
+ int c = out[LOOKAHEAD];
+ out[LOOKAHEAD] = 0;
+ i = e_internal(out,buff);
+ out[LOOKAHEAD] = c;
+#else
+ strncpy((char*)buff,out,LOOKAHEAD);
+ i = strlen((char*)buff);
+#endif /* MULTIBYTE */
+ while(i-- > 0)
+ ungetchar(buff[i]);
+ return(1);
+ }
+ return(0);
+}
+/*
+ * file name generation for edit modes
+ * non-zero exit for error, <0 ring bell
+ * don't search back past <start> character of the buffer
+ * mode is '*' for inline expansion, otherwise files are listed in select format
+ */
+
+q_expand(outbuff,cur,eol,start,mode)
+char outbuff[];
+int *cur;
+int *eol;
+int start;
+int mode;
+{
+ STKPTR staksav = stakbot;
+ COMPTR comptr = (COMPTR)getstak(COMTYPE);
+ ARGPTR ap = (ARGPTR)locstak();
+ register char *out;
+ char *outmin = outbuff + start;
+ char *begin;
+ char *last;
+ int rval = 0;
+ int strip;
+ optflag savflags = flags;
+#ifdef MULTIBYTE
+ {
+ register int c = *cur;
+ register genchar *cp;
+ /* adjust cur */
+ cp = (genchar *)outbuff + *cur;
+ c = *cp;
+ *cp = 0;
+ *cur = e_external((genchar*)outbuff,(char*)stakbot);
+ *cp = c;
+ *eol = e_external((genchar*)outbuff,outbuff);
+ }
+#endif /* MULTIBYTE */
+ out = outbuff + *cur;
+ comptr->comtyp = COMSCAN;
+ comptr->comarg = ap;
+ ap->argflag = (A_MAC|A_EXP);
+ ap->argnxt = 0;
+ {
+ register int c;
+ register char *ptr = ap->argval;
+ int chktilde = 0;
+ int flag;
+ char *cp;
+ if(out>outmin)
+ {
+ /* go to beginning of word */
+ do
+ {
+ out--;
+ c = *(unsigned char*)out;
+ }
+ while(out>outmin && !isqmeta(c));
+ /* copy word into arg */
+ if(isqmeta(c))
+ out++;
+ }
+ else
+ out = outmin;
+ begin = out;
+ flag = '*';
+ strip = TRUE;
+ /* copy word to arg and do ~ expansion */
+ do
+ {
+ c = *(unsigned char*)out++;
+ if(isexp(c))
+ flag = 0;
+ if ((c == '/') && (flag == 0))
+ strip = FALSE;
+ *ptr++ = c;
+ if(chktilde==0 && (c==0 || c == '/'))
+ {
+ chktilde++;
+ if(cp=tilde(begin))
+ {
+ ptr = movstr(cp,ap->argval);
+ *ptr++ = c;
+ }
+ }
+
+ } while (c && !isqmeta(c));
+
+ out--;
+ *(ptr-1) = flag;
+ endstak(ptr);
+ last = ptr-1;
+ }
+ if(mode!='*')
+ on_option(MARKDIR);
+ {
+ register char **com;
+ int narg;
+ register int size;
+ while(1)
+ {
+ com = arg_build(&narg,comptr);
+ /* match? */
+ if (narg > 1 || !eq(ap->argval,*com))
+ break;
+ if (*last == 0)
+ *last = '*';
+ else
+ {
+ rval = -1;
+ goto done;
+ }
+ }
+ if(mode!='*')
+ {
+ if (strip)
+ {
+ register char **ptrcom;
+ for(ptrcom=com;*ptrcom;ptrcom++)
+ /* trim directory prefix */
+ *ptrcom = simple (*ptrcom);
+ }
+ p_setout(stderr);
+ newline();
+ p_list(narg,com);
+ p_flush();
+ goto done;
+ }
+ /* see if there is enough room */
+ size = *eol - (out-begin);
+ size += narg;
+ {
+ char **savcom = com;
+ while (*com)
+ size += strlen(*com++);
+ com = savcom;
+ }
+ /* see if room for expansion */
+ if(outbuff+size >= &outbuff[MAXLINE])
+ {
+ com[0] = ap->argval;
+ com[1] = NULL;
+ }
+ /* save remainder of the buffer */
+ strcpy(stakbot,out);
+ out = begin;
+ while (*com)
+ {
+ out = movstr(*com,out);
+ if (*++com)
+ *out++ = ' ';
+ }
+ *cur = (out-outbuff);
+ /* restore rest of buffer */
+ out = movstr(stakbot,out);
+ *eol = (out-outbuff);
+ }
+ done:
+ tdystak(staksav);
+ flags = savflags;
+#ifdef MULTIBYTE
+ {
+ register int c;
+ /* first re-adjust cur */
+ out = outbuff + *cur;
+ c = *out;
+ *out = 0;
+ *cur = e_internal(outbuff,(genchar*)stakbot);
+ *out = c;
+ outbuff[*eol+1] = 0;
+ *eol = e_internal(outbuff,(genchar*)outbuff);
+ }
+#endif /* MULTIBYTE */
+ return(rval);
+}
+#endif /* KSHELL */
+
+
+/*
+ * routine to perform read from terminal for vi and emacs mode
+ */
+
+
+int
+e_getchar()
+{
+ register int i;
+ register int c;
+ register int maxtry = 100;
+ int nchar; /* number of characters to read at a time */
+#ifdef MULTIBYTE
+ static int curchar;
+ static int cursize;
+#endif /* MULTIBYTE */
+ char readin[LOOKAHEAD] ;
+ if (lookahead)
+ {
+ c = previous[--lookahead];
+ /*** map '\r' to '\n' ***/
+ if(c == '\r')
+ c = '\n';
+ return(c);
+ }
+
+ e_flush() ;
+ /* you can't chance read ahead at the end of line */
+ nchar = (editb.e_cur>=editb.e_eol?1:READAHEAD);
+ /* Set 'i' to indicate read failed, in case intr set */
+retry:
+ i = -1;
+ errno = 0;
+ editb.e_inmacro = 0;
+ while((trapnote&SIGSLOW)==0 && maxtry--)
+ {
+ errno=0;
+ if ((i = read(fildes,readin, nchar)) != -1)
+ break;
+ }
+#ifdef MULTIBYTE
+ lookahead = maxtry = i;
+ i = 0;
+ while (i < maxtry)
+ {
+ c = readin[i++] & STRIP;
+ next:
+ if(cursize-- > 0)
+ {
+ curchar = (curchar<<7) | (c&~HIGHBIT);
+ if(cursize==0)
+ {
+ c = curchar;
+ goto gotit;
+ }
+ else if(i>=maxtry)
+ goto retry;
+ continue;
+ }
+ else if(curchar = echarset(c))
+ {
+ cursize = in_csize(curchar);
+ if(curchar != 1)
+ c = 0;
+ curchar <<= 7*(ESS_MAXCHAR-cursize);
+ if(c)
+ goto next;
+ else if(i>=maxtry)
+ goto retry;
+ continue;
+ }
+ gotit:
+ previous[--lookahead] = c;
+#else
+ while (i > 0)
+ {
+ c = readin[--i] & STRIP;
+ previous[lookahead++] = c;
+#endif /* MULTIBYTE */
+#ifndef BSD
+ if( c == '\0' )
+ {
+ /*** user break key ***/
+ lookahead = 0;
+# ifdef KSHELL
+ fault(SIGINT);
+ longjmp(env, UINTR);
+# endif /* KSHELL */
+ }
+#endif /* !BSD */
+ }
+#ifdef MULTIBYTE
+ /* shift lookahead buffer if necessary */
+ if(lookahead)
+ {
+ for(i=lookahead;i < maxtry;i++)
+ previous[i-lookahead] = previous[i];
+ }
+ lookahead = maxtry-lookahead;
+#endif /* MULTIBYTE */
+ if (lookahead > 0)
+ return(e_getchar(1));
+ longjmp(env,(i==0?UEOF:UINTR)); /* What a mess! Give up */
+ /* NOTREACHED */
+}
+
+void ungetchar(c)
+register int c;
+{
+ if (lookahead < LOOKAHEAD)
+ previous[lookahead++] = c;
+ return;
+}
+
+/*
+ * put a character into the output buffer
+ */
+
+void e_putchar(c)
+register int c;
+{
+ register unsigned char *dp = editb.e_outptr;
+#ifdef MULTIBYTE
+ register int d;
+ /* check for place holder */
+ if(c == MARKER)
+ return;
+ if(d = icharset(c))
+ {
+ if(d == 2)
+ *dp++ = ESS2;
+ else if(d == 3)
+ *dp++ = ESS3;
+ d = in_csize(d);
+ while(--d>0)
+ *dp++ = HIGHBIT|(c>>(7*d));
+ c |= HIGHBIT;
+ }
+#endif /* MULTIBYTE */
+ if (c == '_')
+ {
+ *dp++ = ' ';
+ *dp++ = '\b';
+ }
+ *dp++ = c;
+ *dp = '\0';
+ if ((dp - (unsigned char*)(output->_base))>=(BUFSIZ-3))
+ e_flush();
+ else
+ editb.e_outptr = dp;
+}
+
+/*
+ * copy virtual to physical and return the index for cursor in physical buffer
+ */
+e_virt_to_phys(virt,phys,cur,voff,poff)
+genchar *virt;
+genchar *phys;
+int cur;
+{
+ register genchar *sp = virt;
+ register genchar *dp = phys;
+ register int c;
+ genchar *curp = sp + cur;
+ genchar *dpmax = phys+MAXLINE;
+ int r = 0;
+#ifdef MULTIBYTE
+ int d;
+#endif /* MULTIBYTE */
+ sp += voff;
+ dp += poff;
+ for(r=poff;c= *sp;sp++)
+ {
+ if(curp == sp)
+ r = dp - phys;
+#ifdef MULTIBYTE
+ d = out_csize(icharset(c));
+ if(d>1)
+ {
+ /* multiple width character put in place holders */
+ *dp++ = c;
+ while(--d >0)
+ *dp++ = MARKER;
+ /* in vi mode the cursor is at the last character */
+ if(dp>=dpmax)
+ break;
+ continue;
+ }
+ else
+#endif /* MULTIBYTE */
+ if(!isprint(c))
+ {
+ if(c=='\t')
+ {
+ c = dp-phys;
+ c = ((c+8)&~07) - c;
+ while(--c>0)
+ *dp++ = ' ';
+ c = ' ';
+ }
+ else
+ {
+ *dp++ = '^';
+ c ^= TO_PRINT;
+ }
+ /* in vi mode the cursor is at the last character */
+ if(curp == sp && is_option(EDITVI))
+ r = dp - phys;
+ }
+ *dp++ = c;
+ if(dp>=dpmax)
+ break;
+ }
+ *dp = 0;
+ return(r);
+}
+
+#ifdef MULTIBYTE
+/*
+ * convert external representation <src> to an array of genchars <dest>
+ * <src> and <dest> can be the same
+ * returns number of chars in dest
+ */
+
+int e_internal(src,dest)
+register unsigned char *src;
+genchar *dest;
+{
+ register int c;
+ register genchar *dp = dest;
+ register int d;
+ register int size;
+ if((unsigned char*)dest == src)
+ {
+ genchar buffer[MAXLINE];
+ c = e_internal(src,buffer);
+ e_gencpy(dp,buffer);
+ return(c);
+ }
+ while(c = *src++)
+ {
+ if(size = echarset(c))
+ {
+ d = (size==1?c:0);
+ c = size;
+ size = in_csize(c);
+ c <<= 7*(ESS_MAXCHAR-size);
+ if(d)
+ {
+ size--;
+ c = (c<<7) | (d&~HIGHBIT);
+ }
+ while(size-- >0)
+ c = (c<<7) | ((*src++)&~HIGHBIT);
+ }
+ *dp++ = c;
+ }
+ *dp = 0;
+ return(dp-dest);
+}
+
+/*
+ * convert internal representation <src> into character array <dest>.
+ * The <src> and <dest> may be the same.
+ * returns number of chars in dest.
+ */
+
+int e_external(src,dest)
+genchar *src;
+char *dest;
+{
+ register int c;
+ register char *dp = dest;
+ register int d;
+ char *dpmax = dp+sizeof(genchar)*MAXLINE-2;
+ if((char*)src == dp)
+ {
+ char buffer[MAXLINE*sizeof(genchar)];
+ c = e_external(src,buffer);
+ strcpy(dest,buffer);
+ return(c);
+ }
+ while((c = *src++) && dp<dpmax)
+ {
+ if(d = icharset(c))
+ {
+ if(d == 2)
+ *dp++ = ESS2;
+ else if(d == 3)
+ *dp++ = ESS3;
+ d = in_csize(d);
+ while(--d>0)
+ *dp++ = HIGHBIT|(c>>(7*d));
+ c |= HIGHBIT;
+ }
+ *dp++ = c;
+ }
+ *dp = 0;
+ return(dp-dest);
+}
+
+/*
+ * copy <sp> to <dp>
+ */
+
+int e_gencpy(dp,sp)
+register genchar *dp;
+register genchar *sp;
+{
+ while(*dp++ = *sp++);
+}
+
+/*
+ * copy at most <n> items from <sp> to <dp>
+ */
+
+int e_genncpy(dp,sp, n)
+register genchar *dp;
+register genchar *sp;
+register int n;
+{
+ while(n-->0 && (*dp++ = *sp++));
+}
+
+/*
+ * find the string length of <str>
+ */
+
+int e_genlen(str)
+register genchar *str;
+{
+ register genchar *sp = str;
+ while(*sp++);
+ return(sp-str-1);
+}
+#endif /* MULTIBYTE */
projects / unix-history / commitdiff