mirror of
https://github.com/rfivet/uemacs.git
synced 2024-11-04 19:37:18 -05:00
Renaud Fivet
4b2c50f6d2
- Inconsistencies between defines.h and estruct.h. - Review scope of termio local variables. - Type mismatch in utf8.
467 lines
13 KiB
C
467 lines
13 KiB
C
/* termio.c -- implements termio.h */
|
|
#if !defined( POSIX) && !defined( MINGW32)
|
|
|
|
#include "termio.h"
|
|
|
|
/* TERMIO.C
|
|
*
|
|
* The functions in this file negotiate with the operating system for
|
|
* characters, and write characters in a barely buffered fashion on the display.
|
|
* All operating systems.
|
|
*
|
|
* modified by Petri Kutvonen
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "estruct.h"
|
|
#include "retcode.h"
|
|
#include "utf8.h"
|
|
|
|
|
|
#include <unistd.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
int ttrow = HUGE ; /* Row location of HW cursor */
|
|
int ttcol = HUGE ; /* 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>
|
|
#include <termio.h>
|
|
#include <fcntl.h>
|
|
static int kbdflgs ; /* saved keyboard fd flags */
|
|
static int kbdpoll ; /* in O_NDELAY mode */
|
|
static int kbdqp ; /* there is a char in kbdq */
|
|
static char kbdq ; /* char we've already read */
|
|
static struct termio otermio ; /* original terminal characteristics */
|
|
static struct termio ntermio ; /* characteristics to use inside */
|
|
#if XONXOFF
|
|
#define XXMASK 0016000
|
|
#endif
|
|
#endif
|
|
|
|
#if V7 | BSD
|
|
#include <sgtty.h> /* for stty/gtty functions */
|
|
#include <signal.h>
|
|
struct sgttyb ostate; /* saved tty state */
|
|
struct sgttyb nstate; /* values for editor mode */
|
|
struct tchars otchars; /* Saved terminal special character set */
|
|
#if XONXOFF
|
|
struct tchars ntchars = { 0xff, 0xff, 0x11, 0x13, 0xff, 0xff };
|
|
|
|
/* A lot of nothing and XON/XOFF */
|
|
#else
|
|
struct tchars ntchars = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
|
|
|
/* A lot of nothing */
|
|
#endif
|
|
#if BSD & PKCODE
|
|
struct ltchars oltchars; /* Saved terminal local special character set */
|
|
struct ltchars nltchars = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
|
|
|
/* A lot of nothing */
|
|
#endif
|
|
|
|
#if BSD
|
|
#include <sys/ioctl.h> /* to get at the typeahead */
|
|
extern int rtfrmshell(); /* return from suspended shell */
|
|
#define TBUFSIZ 128
|
|
char tobuf[TBUFSIZ]; /* terminal output buffer */
|
|
#endif
|
|
#endif
|
|
|
|
#if __hpux | SVR4
|
|
extern int rtfrmshell(); /* return from suspended shell */
|
|
#define TBUFSIZ 128
|
|
char tobuf[TBUFSIZ]; /* terminal output buffer */
|
|
#endif
|
|
|
|
/*
|
|
* This function is called once to set up the terminal device streams.
|
|
* On VMS, it translates TT until it finds the terminal, then assigns
|
|
* 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 */
|
|
#if XONXOFF
|
|
ntermio.c_iflag = otermio.c_iflag & XXMASK; /* save XON/XOFF P.K. */
|
|
#endif
|
|
ntermio.c_oflag = 0;
|
|
ntermio.c_cflag = otermio.c_cflag;
|
|
ntermio.c_lflag = 0;
|
|
ntermio.c_line = otermio.c_line;
|
|
ntermio.c_cc[VMIN] = 1;
|
|
ntermio.c_cc[VTIME] = 0;
|
|
#if PKCODE
|
|
ioctl(0, TCSETAW, &ntermio); /* and activate them */
|
|
#else
|
|
ioctl(0, TCSETA, &ntermio); /* and activate them */
|
|
#endif
|
|
kbdflgs = fcntl(0, F_GETFL, 0);
|
|
kbdpoll = FALSE;
|
|
#endif
|
|
|
|
#if V7 | BSD
|
|
gtty(0, &ostate); /* save old state */
|
|
gtty(0, &nstate); /* get base of new state */
|
|
#if XONXOFF
|
|
nstate.sg_flags |= (CBREAK | TANDEM);
|
|
#else
|
|
nstate.sg_flags |= RAW;
|
|
#endif
|
|
nstate.sg_flags &= ~(ECHO | CRMOD); /* no echo for now... */
|
|
stty(0, &nstate); /* set mode */
|
|
ioctl(0, TIOCGETC, &otchars); /* Save old characters */
|
|
ioctl(0, TIOCSETC, &ntchars); /* Place new character into K */
|
|
#if BSD & PKCODE
|
|
ioctl(0, TIOCGLTC, &oltchars); /* Save old local characters */
|
|
ioctl(0, TIOCSLTC, &nltchars); /* New local characters */
|
|
#endif
|
|
#if BSD
|
|
/* provide a smaller terminal output buffer so that
|
|
the type ahead detection works better (more often) */
|
|
setbuffer(stdout, &tobuf[0], TBUFSIZ);
|
|
signal(SIGTSTP, SIG_DFL); /* set signals so that we can */
|
|
signal(SIGCONT, rtfrmshell); /* suspend & restart emacs */
|
|
#endif
|
|
#endif
|
|
|
|
#if __hpux | 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 */
|
|
|
|
/* on all screens we are not sure of the initial position
|
|
of the cursor */
|
|
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.
|
|
* 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 */
|
|
#else
|
|
ioctl(0, TCSETA, &otermio); /* restore terminal settings */
|
|
#endif
|
|
fcntl(0, F_SETFL, kbdflgs);
|
|
#endif
|
|
|
|
#if V7 | BSD
|
|
stty(0, &ostate);
|
|
ioctl(0, TIOCSETC, &otchars); /* Place old character into K */
|
|
#if BSD & PKCODE
|
|
ioctl(0, TIOCSLTC, &oltchars); /* Place old local character into K */
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Write a character to the display. On VMS, terminal output is buffered, and
|
|
* 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( int c) {
|
|
#if VMS
|
|
if (nobuf >= NOBUF)
|
|
ttflush();
|
|
obuf[nobuf++] = c;
|
|
#endif
|
|
|
|
#if MSDOS & ~IBMPC
|
|
bdos(6, c, 0);
|
|
#endif
|
|
|
|
#if V7 | USG | BSD
|
|
char utf8[6];
|
|
int bytes;
|
|
|
|
bytes = unicode_to_utf8(c, utf8);
|
|
fwrite(utf8, 1, bytes, stdout);
|
|
#endif
|
|
return 0 ;
|
|
}
|
|
|
|
/*
|
|
* Flush terminal buffer. Does real work where the terminal output is buffered
|
|
* up. A no-operation on systems where byte at a time terminal I/O is done.
|
|
*/
|
|
void ttflush( void) {
|
|
#if VMS
|
|
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.
|
|
*
|
|
* How to recover here, or is it best just to exit and lose
|
|
* everything?
|
|
*
|
|
* jph, 8-Oct-1993
|
|
*/
|
|
|
|
#include <errno.h>
|
|
|
|
int status;
|
|
|
|
status = fflush(stdout);
|
|
|
|
if (status != 0 && errno != EAGAIN) {
|
|
exit(errno);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* 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) {
|
|
#if VMS
|
|
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
|
|
|
|
#if USG
|
|
if (kbdqp)
|
|
kbdqp = FALSE;
|
|
else {
|
|
if (kbdpoll && fcntl(0, F_SETFL, kbdflgs) < 0)
|
|
return FALSE;
|
|
kbdpoll = FALSE;
|
|
while (read(0, &kbdq, 1) != 1);
|
|
}
|
|
return kbdq & 255;
|
|
#endif
|
|
}
|
|
|
|
#if TYPEAH
|
|
/* typahead: Check to see if any characters are already in the
|
|
keyboard buffer
|
|
*/
|
|
|
|
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)
|
|
return FALSE;
|
|
#if PKCODE
|
|
kbdpoll = 1;
|
|
#endif
|
|
kbdqp = (1 == read(0, &kbdq, 1));
|
|
}
|
|
return kbdqp;
|
|
#endif
|
|
|
|
#if !UNIX & !VMS & !MSDOS
|
|
return FALSE;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#endif /* not POSIX */
|