a9a6c86f12
replace: u_char -> unsigned char u_short -> unsigned short u_int -> unsigned int u_long (not used) include <sys/types.h> is kept. dicttool.h: fix include guard DICTTOLL -> DICTTOOL addelcmn.c:unsigned int addel_arg() deldic.c:unsigned int deldic() change u_short err -> unsigned int err (used for return value) Signed-off-by: SASANO Takayoshi <uaa@uaa.org.uk>
487 lines
10 KiB
C
487 lines
10 KiB
C
/*
|
|
* Copyright (c) 1994 Sony Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL SONY CORPORATION BE LIABLE FOR ANY CLAIM,
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
|
|
* THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name of Sony Corporation
|
|
* shall not be used in advertising or otherwise to promote the sale, use
|
|
* or other dealings in this Software without prior written authorization
|
|
* from Sony Corporation.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* $SonyRCSfile: sjgetchar.c,v $
|
|
* $SonyRevision: 1.5 $
|
|
* $SonyDate: 1997/01/23 11:26:31 $
|
|
*/
|
|
|
|
|
|
|
|
#include "sj_sysvdef.h"
|
|
#include "wchar16.h"
|
|
#include "kctype.h"
|
|
#ifdef SVR4
|
|
#include <sys/stream.h>
|
|
#include <sys/stropts.h>
|
|
#include <sys/types.h>
|
|
#include <sys/fcntl.h>
|
|
#endif
|
|
#ifdef linux
|
|
#include <sys/types.h>
|
|
#include <sys/fcntl.h>
|
|
#endif
|
|
#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__bsdi__) || defined(__DragonFly__)
|
|
#define USE_OLD_TTY
|
|
#include <curses.h>
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
#include <sys/file.h>
|
|
#include "sj2.h"
|
|
#include "select.h"
|
|
|
|
#if !defined(FREAD) && defined(O_RDONLY)
|
|
#define FREAD (O_RDONLY+1)
|
|
#define FWRITE (O_WRONLY+1)
|
|
#endif
|
|
|
|
#define Isknj1(s) ((eucmode) ? (iseuc(s) || (SS2 == (s))) : (issjis1(s)))
|
|
#define Isknj2(s) ((eucmode) ? (SS3 == (s)) : 0)
|
|
|
|
static wchar16_t backup = (wchar16_t) 0;
|
|
|
|
static int eucmode = 0;
|
|
extern int master;
|
|
|
|
wchar16_t SJ_getchar()
|
|
{
|
|
SELECT_FD ifds;
|
|
wchar16_t c;
|
|
|
|
if (backup) {
|
|
if (SJ_read (&c, 1) > 0)
|
|
return (c);
|
|
}
|
|
for (;;) {
|
|
FD_ZERO (&ifds);
|
|
FD_SET (STDIN, &ifds);
|
|
FD_SET (master, &ifds);
|
|
if (select (master + 1, &ifds, 0, 0, 0) <= 0) {
|
|
if (errno == EINTR) {
|
|
errno = 0;
|
|
continue;
|
|
} else
|
|
return (EOF);
|
|
}
|
|
|
|
if (FD_ISSET (STDIN, &ifds)) {
|
|
if (SJ_read (&c, 1) > 0) {
|
|
if (FD_ISSET (master, &ifds)) {
|
|
output_master();
|
|
}
|
|
return (c);
|
|
}
|
|
return (EOF);
|
|
}
|
|
if (FD_ISSET (master, &ifds)) {
|
|
output_master();
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef SVR4
|
|
#define TIOCPKT_DOSTOP 0x10
|
|
#define TIOCPKT_NOSTOP 0x20
|
|
|
|
static int stopmode = TIOCPKT_DOSTOP;
|
|
static char stopc = CTRL('s');
|
|
static char startc = CTRL('q');
|
|
static char outbuf[BUFSIZ];
|
|
extern int slave;
|
|
extern char *slave_name, *ptsname(int);
|
|
|
|
output_master()
|
|
{
|
|
struct strbuf ctlbuf;
|
|
struct strbuf databuf;
|
|
int flags = 0;
|
|
unsigned char ctlstuff;
|
|
int f, stop, ixon, ret;
|
|
struct iocblk *ioc;
|
|
struct termios *tp;
|
|
struct termio *ti;
|
|
struct tchars tc, tc1;
|
|
|
|
memset((char *)&ctlbuf, '\0', sizeof(ctlbuf));
|
|
memset((char *)&databuf,'\0', sizeof(databuf));
|
|
ctlbuf.maxlen = sizeof(ctlstuff);
|
|
ctlbuf.buf = (char *)&ctlstuff;
|
|
databuf.maxlen = BUFSIZ;
|
|
databuf.buf = outbuf;
|
|
if ((ret = getmsg(master, &ctlbuf, &databuf, &flags)) == -1) {
|
|
return;
|
|
}
|
|
if (ctlbuf.len <= 0) {
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
if (ret & MORECTL) {
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
if ((ctlstuff != M_DATA) && (ret & MOREDATA)) {
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
if (ctlbuf.len != sizeof(ctlstuff)) {
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
switch (ctlstuff) {
|
|
case M_DATA:
|
|
|
|
write_stdout((unsigned char *)&outbuf[0], databuf.len);
|
|
fflush (stdout);
|
|
while (ret & MOREDATA) {
|
|
if ((ret = getmsg(master, &ctlbuf, &databuf, &flags)) == -1) {
|
|
return;
|
|
}
|
|
write_stdout((unsigned char *)&outbuf[0], databuf.len);
|
|
fflush (stdout);
|
|
}
|
|
return;
|
|
break;
|
|
|
|
case M_FLUSH:
|
|
if (databuf.len <= 0) {
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
fflush (stdout);
|
|
break;
|
|
|
|
case M_IOCTL:
|
|
ioc = (struct iocblk *)databuf.buf;
|
|
if (databuf.len <= sizeof(struct iocblk)) {
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
switch (ioc->ioc_cmd) {
|
|
case TCSETS:
|
|
case TCSETSW:
|
|
case TCSETSF:
|
|
if (databuf.len < (sizeof(struct termios)
|
|
+ sizeof(struct iocblk))) {
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
tp = (struct termios *)(databuf.buf + sizeof (struct iocblk));
|
|
stopc = tp->c_cc[VSTOP];
|
|
startc = tp->c_cc[VSTART];
|
|
ixon = tp->c_iflag & IXON;
|
|
break;
|
|
case TCSETA:
|
|
case TCSETAW:
|
|
case TCSETAF:
|
|
if (databuf.len < (sizeof (struct termio)
|
|
+ sizeof (struct iocblk))) {
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
ti = (struct termio *)(databuf.buf + sizeof (struct iocblk));
|
|
ixon = ti->c_iflag & IXON;
|
|
break;
|
|
|
|
default:
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
}
|
|
stop = (ixon && (stopc == CTRL('s')) && (startc == CTRL('q')));
|
|
if (stopmode == TIOCPKT_NOSTOP) {
|
|
if (stop) {
|
|
ioctl (STDOUT, TIOCGETC, &tc);
|
|
|
|
|
|
if (slave == 0) {
|
|
slave_name = ptsname(master);
|
|
slave = open(slave_name, O_RDWR);
|
|
}
|
|
ioctl (slave, TIOCGETC, &tc1);
|
|
tc.t_stopc = tc1.t_stopc;
|
|
tc.t_startc = tc1.t_startc;
|
|
ioctl (STDOUT, TIOCSETC, &tc);
|
|
stopmode = TIOCPKT_DOSTOP;
|
|
}
|
|
} else {
|
|
if (!stop) {
|
|
ioctl (STDOUT, TIOCGETC, &tc);
|
|
tc.t_stopc = -1;
|
|
tc.t_startc = -1;
|
|
ioctl (STDOUT, TIOCSETC, &tc);
|
|
stopmode = TIOCPKT_NOSTOP;
|
|
}
|
|
}
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
break;
|
|
default:
|
|
|
|
errno = EWOULDBLOCK;
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
#else
|
|
#if defined(linux) && defined (__GLIBC__) && (__GLIBC__ >= 2)
|
|
#include <termios.h>
|
|
#endif
|
|
|
|
output_master()
|
|
{
|
|
int n, m;
|
|
char outbuf[BUFSIZ];
|
|
int f;
|
|
#ifdef SYSV_TERMIOS
|
|
struct termios tc, tc1;
|
|
#else
|
|
struct tchars tc, tc1;
|
|
#endif
|
|
extern int master;
|
|
|
|
if ((n = read (master, outbuf, BUFSIZ)) > 0) {
|
|
m = outbuf[0];
|
|
if (m == TIOCPKT_DATA) {
|
|
|
|
write_stdout((unsigned char *)&outbuf[1], n - 1);
|
|
|
|
fflush (stdout);
|
|
return;
|
|
}
|
|
else if (m & (TIOCPKT_FLUSHREAD | TIOCPKT_FLUSHWRITE)) {
|
|
f = 0;
|
|
if (m & TIOCPKT_FLUSHREAD)
|
|
f |= FREAD;
|
|
if (m & TIOCPKT_FLUSHWRITE)
|
|
f |= FWRITE;
|
|
fflush (stdout);
|
|
#ifdef TCFLSH
|
|
ioctl (STDOUT, TCFLSH, &f);
|
|
#else
|
|
ioctl (STDOUT, TIOCFLUSH, &f);
|
|
#endif
|
|
}
|
|
else if (m & TIOCPKT_NOSTOP) {
|
|
#ifdef SYSV_TERMIOS
|
|
ioctl (1, TCGETS, &tc);
|
|
tc.c_cc[VSTOP] = 0;
|
|
tc.c_cc[VSTART] = 0;
|
|
ioctl (STDOUT, TCSETS, &tc);
|
|
#else
|
|
|
|
ioctl (1, TIOCGETC, &tc);
|
|
tc.t_stopc = -1;
|
|
tc.t_startc = -1;
|
|
ioctl (STDOUT, TIOCSETC, &tc);
|
|
#endif
|
|
}
|
|
else if (m & TIOCPKT_DOSTOP) {
|
|
#ifdef SYSV_TERMIOS
|
|
ioctl (master, TCGETS, &tc1);
|
|
ioctl (STDOUT, TCGETS, &tc);
|
|
tc.c_cc[VSTOP] = tc1.c_cc[VSTOP];
|
|
tc.c_cc[VSTART] = tc1.c_cc[VSTART];
|
|
ioctl (STDOUT, TCSETS, &tc);
|
|
#else
|
|
ioctl (master, TIOCGETC, &tc1);
|
|
ioctl (STDOUT, TIOCGETC, &tc);
|
|
tc.t_stopc = tc1.t_stopc;
|
|
tc.t_startc = tc1.t_startc;
|
|
ioctl (STDOUT, TIOCSETC, &tc);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
set_eucmode ()
|
|
{
|
|
eucmode = 1;
|
|
}
|
|
|
|
SJ_write (s, n)
|
|
wchar16_t *s;
|
|
int n;
|
|
{
|
|
int val;
|
|
wchar16_t wb[BUFFLENGTH];
|
|
unsigned char buff[BUFFLENGTH * 3];
|
|
|
|
wsncpy(wb, s, n);
|
|
wb[n] = 0;
|
|
val = wcstombs((char *) buff, wb, (size_t) n * 3);
|
|
if ((val == 0) && n) {
|
|
int i;
|
|
val = n;
|
|
for (i = 0; i <= n; i++)
|
|
buff[i] = 0;
|
|
}
|
|
if (val > 0)
|
|
val = write(master, buff, val);
|
|
return(val);
|
|
}
|
|
|
|
write_stdout(s, n)
|
|
unsigned char *s;
|
|
int n;
|
|
{
|
|
static unsigned char knj1st = 0, knj2nd = 0;
|
|
|
|
while (n-- > 0) {
|
|
if (knj1st) {
|
|
if (knj2nd) {
|
|
putchar(knj2nd);
|
|
putchar(knj1st);
|
|
putchar(*s++);
|
|
knj2nd = 0;
|
|
knj1st = 0;
|
|
} else {
|
|
putchar(knj1st);
|
|
putchar(*s++);
|
|
knj1st = 0;
|
|
}
|
|
} else if (knj2nd) {
|
|
knj1st = *s++;
|
|
} else if (Isknj2(*s)) {
|
|
knj2nd = *s++;
|
|
} else if (Isknj1(*s))
|
|
knj1st = *s++;
|
|
else
|
|
putchar(*s++);
|
|
}
|
|
}
|
|
|
|
|
|
SJ_read (s, n)
|
|
wchar16_t *s;
|
|
int n;
|
|
{
|
|
unsigned char buff[BUFFLENGTH];
|
|
wchar16_t wcbuff[BUFFLENGTH];
|
|
int i, count, remain, c;
|
|
size_t wnum;
|
|
extern int current_locale;
|
|
|
|
if (backup) {
|
|
*s = backup;
|
|
backup = 0;
|
|
return (1);
|
|
}
|
|
if ((count = read(STDIN, buff, n)) <= 0)
|
|
return (count);
|
|
remain = 0;
|
|
for (i = 0; i < count; i++) {
|
|
c = buff[i];
|
|
#ifdef __sony_news
|
|
if (is3byte(c)) {
|
|
if (i + 2 >= count) {
|
|
if (i + 2 == count) {
|
|
remain = 1;
|
|
break;
|
|
} else
|
|
remain = 2;
|
|
} else
|
|
i += 2;
|
|
} else if (is2byte(c)) {
|
|
if (i + 1 >= count)
|
|
remain = 1;
|
|
else
|
|
i++;
|
|
}
|
|
#else
|
|
if (current_locale == LC_CTYPE_EUC) {
|
|
if (iseuc3byte(c)) {
|
|
if (i + 2 >= count) {
|
|
if (i + 2 == count) {
|
|
remain = 1;
|
|
break;
|
|
} else
|
|
remain = 2;
|
|
} else
|
|
i += 2;
|
|
} else if (iseuc2byte(c)) {
|
|
if (i + 1 >= count)
|
|
remain = 1;
|
|
else
|
|
i++;
|
|
}
|
|
} else {
|
|
if (issjis1(c)) {
|
|
if (i + 1 >= count)
|
|
remain = 1;
|
|
else
|
|
i++;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
if (remain) {
|
|
if ((i = read(STDIN, &buff[count], remain)) > 0)
|
|
count += i;
|
|
}
|
|
buff[count] = 0;
|
|
wnum = mbstowcs((wchar16_t *) wcbuff, (char *) buff, count);
|
|
if ((wnum == 0) && count) {
|
|
wnum = count;
|
|
for ( i = 0; i <= count; i++)
|
|
wcbuff[i] = (wchar16_t) 0;
|
|
}
|
|
if (wnum > n) {
|
|
backup = wcbuff[--wnum];
|
|
}
|
|
memcpy((void *) s, (void *) wcbuff, wnum * sizeof(wchar16_t));
|
|
return(wnum);
|
|
}
|
|
|
|
SJ_warnning (s)
|
|
wchar16_t *s;
|
|
{
|
|
SJ_print (s);
|
|
}
|
|
|
|
SJ_print (s)
|
|
wchar16_t *s;
|
|
{
|
|
unsigned char buff[BUFFLENGTH * 3];
|
|
size_t num;
|
|
|
|
num = wcstombs((char *) buff, s, (size_t ) (BUFFLENGTH * 3));
|
|
if ((int) num > 0)
|
|
printf("%s", buff);
|
|
}
|
|
|
|
SJ_through (s, n)
|
|
wchar16_t *s;
|
|
int n;
|
|
{
|
|
SJ_write (s, n);
|
|
}
|
|
|