#define read ______read

#include "io.h"

#include "terminal.h"

#include "history.h"

#undef read

#include "edit.h"

#ifdef LDYNAMIC

# include "dlldefs.h"

#endif

#ifdef TIOCLBIC

# undef TIOCLBIC

# ifdef _sys_ioctl

# include <sys/ioctl.h>

# endif /* _sys_ioctl */

#endif /* TIOCLBIC */

#undef read

#ifdef __EXPORT__

# define extern __EXPORT__

#endif

#define e_create "cannot create"

char opt_flag = 0;

char ed_errbuf[IOBSIZE+1] = { 0 };

struct fileblk *io_ftable[NFILE+USERIO] = { 0 };

static struct fileblk outfile = { ed_errbuf, ed_errbuf, ed_errbuf+IOBSIZE, 2, IOWRT};

static int editfd;

static int output = 0;

static char beenhere;

#if 0 /* almost always false. Makes a good block comment */

**********************************************************************

* There are two scenarios here.

*

* 1) We ALWAYS want ksh-editing on the terminal input.

* 2) We SOMETIMES want ksh-editing on the terminal input.

*

* If you are running with case 1, then just call read() in the usual

* manner and be happy.

*

* If you want to only have line-editing sometimes, and the very first

* read() is not one of those times, then you must perform the

* initialization first, turn OFF editing, perform your read(), and

* so forth. An example of this is in a curses application in which

* single characters are read in RAW mode and acted upon immediately.

* Line editing here will not work.

*

* Do the following:

* edit_Init();

* SAVopt_flag = set_edit(0,0); /* fd=0 set to NO editing */

* read(0,buffer,1); /* do your single char read */

* set_edit(0,SAVopt_flag); /* restore editing on fd=0 */

**********************************************************************

#endif /* 0 */

int edit_Init()

{

register char *sp;

if(!beenhere)

{

beenhere = 1;

hist_open();

if(!(sp = getenv("VISUAL")))

sp = getenv("EDITOR");

if(sp)

{

if(strrchr(sp,'/'))

sp = strrchr(sp,'/')+1;

if(strcmp(sp,"vi") == 0)

opt_flag = EDITVI;

else if(strcmp(sp,"emacs")==0)

opt_flag = EMACS;

else if(strcmp(sp,"gmacs")==0)

opt_flag = GMACS;

}

}

return(1);

}

#ifdef LDYNAMIC

#ifdef __STDC__

typedef ssize_t (*Read_f)(int, void*, size_t);

#else

typedef ssize_t (*Read_f)();

#endif

ssize_t rEAd(fd,buf,n)

int fd;

void *buf;

size_t n;

{

ssize_t r;

static Read_f readfn;

static int here;

static int loop;

static void* dll;

static char msg[] = "ie: cannot intercept read() system call\n";

/*

if (here++)

{

if (loop++)

return -1;

if (!(dll = (dllnext)(RTLD_LAZY)))

goto bad;

readfn = 0;

}

if (!readfn)

{

if (!dll && !(dll = dllnext(RTLD_LAZY)))

goto bad;

if (!(readfn = (Read_f)dlsym(dll, "_read")) && !(readfn = (Read_f)dlsym(dll, "read")))

goto bad;

}

r = (*readfn)(fd, buf, n);

here--;

return r;

bad:

write(2, msg, sizeof(msg) - 1);

return -1;

}

#endif /* LDYNAMIC */

extern ssize_t read(fd,buf,n)

int fd;

void *buf;

size_t n;

{

register int r, flag;

char *buff = (char*)buf;

if(fd==editfd && !beenhere)

edit_Init();

flag = (fd==editfd?opt_flag&EDITMASK:0);

switch(flag)

{

case EMACS:

case GMACS:

tty_set(-1);

r = emacs_read(fd,buff,n);

break;

case VIRAW:

case EDITVI:

tty_set(-1);

r = vi_read(fd,buff,n);

break;

default:

{

#ifdef SYSCALL

r = syscall(3,fd,buff,n);

#else

r = rEAd(fd,buff,n);

#endif /* SYSCALL */

}

}

if(fd==editfd && hist_ptr && (opt_flag&NOHIST)==0 && r>0)

{

/* write and flush history */

int c = buff[r];

buff[r] = 0;

hist_eof();

p_setout(hist_ptr->fixfd);

p_str(buff,0);

hist_flush();

buff[r] = c;

}

return(r);

}

#ifndef __EXPORT__

extern ssize_t _read(fd,buf,n)

int fd;

void *buf;

size_t n;

{

return(read(fd,buf,n));

}

extern ssize_t __read(fd,buf,n)

int fd;

void *buf;

size_t n;

{

return(read(fd,buf,n));

}

extern ssize_t _libc_read(fd,buf,n)

int fd;

void *buf;

size_t n;

{

return(read(fd,buf,n));

}

extern ssize_t __libc_read(fd,buf,n)

int fd;

void *buf;

size_t n;

{

return(read(fd,buf,n));

}

#endif

int set_edit(fd,mode)

int fd;

int mode;

{

int retval = opt_flag;

opt_flag = mode;

if(fd==2)

return(-1);

editfd = fd;

return(retval);

}

void p_setout(fd)

register int fd;

{

register struct fileblk *fp;

if(!io_ftable[fd])

io_ftable[fd] = &outfile;

fp = io_ftable[fd];

fp->last = fp->base + IOBSIZE;

fp->flag &= ~(IOREAD|IOERR|IOEOF);

if(output==fd)

return;

if(io_ftable[fd]==io_ftable[output])

p_flush();

output = fd;

}

void p_flush()

{

register struct fileblk *fp = io_ftable[output];

register int count;

if(fp && (count=fp->ptr-fp->base))

{

if(write(output,fp->base,count) < 0)

fp->flag |= IOERR;

/* leave previous buffer as a null terminated string */

*fp->ptr = 0;

fp->ptr = fp->base;

}

}

void p_char(c)

register int c;

{

register struct fileblk *fp = io_ftable[output];

if(fp->ptr >= fp->last)

p_flush();

*fp->ptr++ = c;

}

void p_str(string,c)

register char *string;

int c;

{

register struct fileblk *fp = io_ftable[output];

register int cc;

while(1)

{

if((cc= *string)==0)

cc = c,c = 0;

else

string++;

if(cc==0)

break;

if(fp->ptr >= fp->last)

p_flush();

*fp->ptr++ = cc;

}

}

char *ed_movstr(a,b)

register const char *a;

register char *b;

{

while(*b++ = *a++);

return(--b);

}

void ed_failed(name,message)

char *name,*message;

{

p_setout(ERRIO);

p_str(name,' ');

p_char(':');

p_char(' ');

p_str(message,'\n');

exit(2);

}

void pr_prompt(string)

register char *string;

{

register int c;

register char *dp = editb.e_prbuff;

#ifdef TIOCLBIC

int mode;

mode = LFLUSHO;

ioctl(ERRIO,TIOCLBIC,&mode);

#endif /* TIOCLBIC */

p_setout(ERRIO);

while(c= *string++)

{

if(dp < editb.e_prbuff+PRSIZE)

*dp++ = c;

p_char(c);

}

*dp = 0;

if (!(opt_flag&EDITMASK))

p_flush();

}