diff -c -N -r screen-3.7.2/Makefile.in screen-3.7.2+onew/Makefile.in *** screen-3.7.2/Makefile.in Mon Sep 2 06:54:24 1996 --- screen-3.7.2+onew/Makefile.in Tue Jul 1 10:15:44 1997 *************** *** 55,65 **** CFILES= screen.c ansi.c fileio.c mark.c misc.c resize.c socket.c \ search.c tty.c term.c window.c utmp.c loadav.c putenv.c help.c \ termcap.c input.c attacher.c pty.c process.c display.c comm.c \ ! kmapdef.c acls.c OFILES= screen.o ansi.o fileio.o mark.o misc.o resize.o socket.o \ search.o tty.o term.o window.o utmp.o loadav.o putenv.o help.o \ termcap.o input.o attacher.o pty.o process.o display.o comm.o \ ! kmapdef.o acls.o all: screen screen.info --- 55,65 ---- CFILES= screen.c ansi.c fileio.c mark.c misc.c resize.c socket.c \ search.c tty.c term.c window.c utmp.c loadav.c putenv.c help.c \ termcap.c input.c attacher.c pty.c process.c display.c comm.c \ ! kmapdef.c acls.c onew.c OFILES= screen.o ansi.o fileio.o mark.o misc.o resize.o socket.o \ search.o tty.o term.o window.o utmp.o loadav.o putenv.o help.o \ termcap.o input.o attacher.o pty.o process.o display.o comm.o \ ! kmapdef.o acls.o onew.o all: screen screen.info *************** *** 70,81 **** $(CC) -c -I. -I$(srcdir) $(M_CFLAGS) $(DEFS) $(OPTIONS) $(CFLAGS) $< install_bin: screen ! $(INSTALL_PROGRAM) screen $(bindir)/screen-$(VERSION) ! -chown root $(bindir)/screen-$(VERSION) && chmod 4755 $(bindir)/screen-$(VERSION) # This doesn't work if $(bindir)/screen is a symlink ! -if [ -f $(bindir)/screen ] && [ ! -f $(bindir)/screen.old ]; then mv $(bindir)/screen $(bindir)/screen.old; fi ! rm -f $(bindir)/screen ! ln -s screen-$(VERSION) $(bindir)/screen install: installdirs install_bin cd doc ; $(MAKE) install --- 70,83 ---- $(CC) -c -I. -I$(srcdir) $(M_CFLAGS) $(DEFS) $(OPTIONS) $(CFLAGS) $< install_bin: screen ! $(INSTALL_PROGRAM) screen $(bindir)/oscreen ! -chown root $(bindir)/oscreen && chmod 4755 $(bindir)/oscreen ! # $(INSTALL_PROGRAM) screen $(bindir)/screen-$(VERSION) ! # -chown root $(bindir)/screen-$(VERSION) && chmod 4755 $(bindir)/screen-$(VERSION) # This doesn't work if $(bindir)/screen is a symlink ! # -if [ -f $(bindir)/screen ] && [ ! -f $(bindir)/screen.old ]; then mv $(bindir)/screen $(bindir)/screen.old; fi ! # rm -f $(bindir)/screen ! # ln -s screen-$(VERSION) $(bindir)/screen install: installdirs install_bin cd doc ; $(MAKE) install *************** *** 251,253 **** --- 253,257 ---- comm.o: comm.c acls.h comm.h config.h rcs.h kmapdef.o: kmapdef.c config.h acls.o: acls.c acls.h ansi.h comm.h config.h display.h extern.h image.h os.h osdef.h overlay.h rcs.h screen.h term.h window.h + onew.o: onew.c onew.h + diff -c -N -r screen-3.7.2/comm.c screen-3.7.2+onew/comm.c *** screen-3.7.2/comm.c Tue Nov 21 03:03:04 1995 --- screen-3.7.2+onew/comm.c Mon Jun 30 11:58:53 1997 *************** *** 150,155 **** --- 150,160 ---- { "next", NEED_DISPLAY|NEED_FORE|ARGS_ZERO }, { "number", NEED_FORE|ARGS_ZEROONE }, { "obuflimit", NEED_DISPLAY|ARGS_ZEROONE }, + #ifdef ONEW + { "onewinputcode", ARGS_ONE }, + { "onewoutputcode", ARGS_ONE }, + { "onewromkankey", ARGS_ONE }, + #endif /* ONEW */ { "other", NEED_DISPLAY|NEED_FORE|ARGS_ZERO }, { "partial", NEED_FORE|ARGS_ZEROONE }, #ifdef PASSWORD diff -c -N -r screen-3.7.2/config.h.in screen-3.7.2+onew/config.h.in *** screen-3.7.2/config.h.in Mon Sep 2 06:54:24 1996 --- screen-3.7.2+onew/config.h.in Fri Jul 18 15:32:49 1997 *************** *** 124,129 **** --- 124,132 ---- # define COLOR #endif /* SIMPLESCREEN */ #define KANJI + #define ONEW + /* #define ONEW_CTRLG_HACK */ + #define JP_CURSOR /* * As error messages are mostly meaningless to the user, we diff -c -N -r screen-3.7.2/extern.h screen-3.7.2+onew/extern.h *** screen-3.7.2/extern.h Tue Nov 21 03:03:04 1995 --- screen-3.7.2+onew/extern.h Wed Jul 9 11:01:18 1997 *************** *** 313,315 **** --- 313,320 ---- extern struct user **FindUserPtr __P((char *)); extern int UserAdd __P((char *, char *, struct user **)); extern int UserDel __P((char *, struct user **)); + #ifdef ONEW + extern int ThruOnew __P((char *, int, int, int)); + extern int GetKakuteiStr __P((char *)); + extern int InitOnewKeys __P(()); + #endif /* ONEW */ diff -c -N -r screen-3.7.2/fileio.c screen-3.7.2+onew/fileio.c *** screen-3.7.2/fileio.c Tue Nov 21 03:03:04 1995 --- screen-3.7.2+onew/fileio.c Fri Jul 18 15:01:38 1997 *************** *** 123,129 **** --- 123,135 ---- debug(" ...nothing in $SCREENRC, defaulting $HOME/.screenrc\n"); if (strlen(home) > 244) Panic(0, "Rc: home too large"); + #ifdef ONEW + sprintf(buf, "%s/.oscreenrc", home); + if (access(buf, R_OK)) + sprintf(buf, "%s/.iscreenrc", home); + #else sprintf(buf, "%s/.iscreenrc", home); + #endif if (access(buf, R_OK)) sprintf(buf, "%s/.screenrc", home); rc = SaveStr(buf); diff -c -N -r screen-3.7.2/onew.c screen-3.7.2+onew/onew.c *** screen-3.7.2/onew.c Thu Jan 1 09:00:00 1970 --- screen-3.7.2+onew/onew.c Fri Jul 18 15:48:34 1997 *************** *** 0 **** --- 1,601 ---- + /* + onew.c + + Using ONEW library for Japanese Input. + + */ + + #include "config.h" + #include "screen.h" + #include "onew.h" + + extern struct win *windows; /* linked list of all windows */ + extern struct win *fore; + extern struct display *display, *displays; + + static char onew_getchar_buffer[ONEW_GETCHAR_MAX]; + static int onew_getchar_buffer_len; + static char kanakan_buf[ONEW_GETCHAR_MAX]; + static int kanakan_buf_len; + static char kanji_buf[ONEW_GETCHAR_MAX]; + static char kakutei_buf[ONEW_GETCHAR_MAX]; + static int kakutei_buf_len; + static int onew_buffer_empty; + static int onew_current_io_fd; + static int onew_current_io_maxlen; + static int kanji_first; + + static char kanji_conv_buf[ONEW_GETCHAR_MAX]; + static int kanji_conv_buf_len; + + int onew_input_code; + int onew_output_code; + + void + InitOnewKeys() + { + ONEW_getch_asis = 1; + ONEW_I_ESC |= 0x100; + ONEW_I_KAKUTEI |= 0x100; + ONEW_I_THRU_NEXTCH |= 0x100; + ONEW_I_SYNC_CHAR |= 0x100; + } + + void + add_onew_getchar_buffer(buf, len) + char* buf; + int len; + { + int i, curlen; + debug1("exec add_onew_getchar_buffer() ... len:%d\n", len); + if (onew_getchar_buffer_len + len > ONEW_GETCHAR_MAX) + return; + memcpy(&onew_getchar_buffer[onew_getchar_buffer_len], buf, len); + onew_getchar_buffer_len += len; + onew_buffer_empty = 0; + } + + void + unget_onew_getchar_buffer(ch) + int ch; + { + debug("exec unget_onew_getchar_buffer_ch\n"); + if (onew_getchar_buffer_len + 1 > ONEW_GETCHAR_MAX) + return; + bcopy(onew_getchar_buffer, &onew_getchar_buffer[1], onew_getchar_buffer_len); + onew_getchar_buffer[0] = ch; + onew_getchar_buffer_len ++; + } + + void + onewgoto(x, y) + int x, y; + { + PutStr(tgoto(D_CM, x, y)); + D_x = x; + D_y = y; + } + + void + EUC_TO_SJIS(dst, len) + unsigned char *dst; + int len; + { + int i, first_byte = 0; + debug("exec EUC_TO_SJIS\n"); + kanji_conv_buf_len = 0; + for (i = 0; i < len; i ++) { + int ch; + ch = kanji_conv_buf[i]; + if (ch & 0x80) { + if (!first_byte) { + first_byte = ch & 0x7f; + } else { + ch &= 0x7f; + if (first_byte & 1) + ch += 0x1f; + else + ch += 0x7d; + if (0x7f <= ch) + ch ++; + first_byte = ((first_byte - 0x21) >> 1) + 0x81; + if (0x9f < first_byte) + first_byte += 0x40; + kanji_conv_buf[kanji_conv_buf_len++] = first_byte; + kanji_conv_buf[kanji_conv_buf_len++] = ch; + first_byte = 0; + } + } else { + kanji_conv_buf[kanji_conv_buf_len++] = ch; + } + } + kanji_conv_buf[kanji_conv_buf_len] = '\0'; + } + + void + EUC_TO_JIS(dst, len) + unsigned char *dst; + int len; + { + int in_jp = 0, i; + debug("exec EUC_TO_JIS\n"); + kanji_conv_buf_len = 0; + for (i = 0; i < len; i ++) { + if (!in_jp) { + if (dst[i] & 0x80) { + kanji_conv_buf[kanji_conv_buf_len++] = ESC; + kanji_conv_buf[kanji_conv_buf_len++] = TOJIS1; + kanji_conv_buf[kanji_conv_buf_len++] = TOJIS2; + kanji_conv_buf[kanji_conv_buf_len++] = dst[i] & 0x7f; + in_jp = 1; + } else { + kanji_conv_buf[kanji_conv_buf_len++] = dst[i]; + } + } else { + if (dst[i] & 0x80) { + kanji_conv_buf[kanji_conv_buf_len++] = dst[i] & 0x7f; + } else { + kanji_conv_buf[kanji_conv_buf_len++] = ESC; + kanji_conv_buf[kanji_conv_buf_len++] = TOASCII1; + kanji_conv_buf[kanji_conv_buf_len++] = TOASCII2; + kanji_conv_buf[kanji_conv_buf_len++] = dst[i]; + in_jp = 0; + } + } + } + if (in_jp) { + kanji_conv_buf[kanji_conv_buf_len++] = ESC; + kanji_conv_buf[kanji_conv_buf_len++] = TOASCII1; + kanji_conv_buf[kanji_conv_buf_len++] = TOASCII2; + } + kanji_conv_buf[kanji_conv_buf_len] = '\0'; + } + + void + JAddStr(str) + char *str; + { + debug("exec JAddStr\n"); + if (onew_output_code == 0) { + EUC_TO_JIS(str, strlen(str)); + AddStr(kanji_conv_buf); + } else if (onew_output_code == SJIS) { + EUC_TO_SJIS(str, strlen(str)); + AddStr(kanji_conv_buf); + } else { + AddStr(str); + } + } + + void + EnableKeys() + { + ONEW_getch_asis = 0; + if (ONEW_MODESW_CALL & 0x100) { + ONEW_MODESW_CALL &= 0xff; + ONEW_SELECT_YANK &= 0xff; + ONEW_HENKAN_START &= 0xff; + THRUSYMS_TOGGLE &= 0xff; + ONEW_THRU_NEXTCH &= 0xff; + ONEW_THRUSYMS_SETUP &= 0xff; + #ifdef ONEW_CTRLG_HACK + ONEW_PRE_HENKAN_START &= 0xff; + #endif /* ONEW_CTRLG_HACK */ + } + } + + void + DisableKeys() + { + ONEW_getch_asis = 1; + if (!(ONEW_MODESW_CALL & 0x100)) { + ONEW_MODESW_CALL |= 0x100; + ONEW_SELECT_YANK |= 0x100; + ONEW_HENKAN_START |= 0x100; + THRUSYMS_TOGGLE |= 0x100; + ONEW_THRU_NEXTCH |= 0x100; + ONEW_THRUSYMS_SETUP |= 0x100; + #ifdef ONEW_CTRLG_HACK + ONEW_PRE_HENKAN_START |= 0x100; + #endif /* ONEW_CTRLG_HACK */ + } + } + + int + ThruOnew(ibuf, ilen, fd, max) + char *ibuf; + int ilen, fd, max; + { + int ch, rkmode; + debug("exec ThruOnew()\n"); + onew_current_io_fd = fd; + onew_current_io_maxlen = max; + add_onew_getchar_buffer(ibuf, ilen); + for (;;) { + ch = Onew_romkan(); + if (ch == REPLACE_NULL) + ch = '\0'; + debug1("ch=%x\n", ch); + if (onew_buffer_empty) + if (kakutei_buf_len) + return 1; + else + return 0; + rkmode = Onew_RK_imode(); + if (rkmode) { + switch (ch) { + case DEL: + case BS: + back_char(); break; + case KILL: + kill_line(); break; + default: + if (ch < 0x20) + break; + if (!(ch & 0x80)) { + if ((kakutei_buf_len + kanakan_buf_len) < (D_width - ONEW_MSG_COL - 1)) { + kanakan_buf[kanakan_buf_len ++] = ch; + kanakan_buf[kanakan_buf_len] = '\0'; + debug("print char\n"); + PutStr(D_US); + AddChar(ch); + PutStr(D_UE); + Flush(); + } else { + AddChar(' '); + PutStr(D_LE); + ONEW_BEEP(0); + Flush(); + } + } else { + if (kanji_first) { + if ((kakutei_buf_len + kanakan_buf_len) < (D_width - ONEW_MSG_COL -2)) { + char tmp[3]; + kanakan_buf[kanakan_buf_len ++] = kanji_first; + kanakan_buf[kanakan_buf_len ++] = ch; + kanakan_buf[kanakan_buf_len] = '\0'; + debug("print kanji char\n"); + sprintf(tmp, "%c%c", kanji_first, ch); + PutStr(D_US); + JAddStr(tmp); + PutStr(D_UE); + Flush(); + } else { + AddChar(' '); + PutStr(D_LE); + ONEW_BEEP(0); + Flush(); + } + kanji_first = 0; + } else { + kanji_first = ch; + } + } + } + } else { + int l; + if (ch == ONEW_ROMKAN_TOGGLE) { + if (ONEW_getch_asis) { + unget_onew_getchar_buffer(ONEW_ROMKAN_TOGGLE); + EnableKeys(); + continue; + } + } else { + DisableKeys(); + kakutei_buf[kakutei_buf_len ++] = ch; + kakutei_buf[kakutei_buf_len] = '\0'; + } + } + } + } + + int + back_char() + { + if (0 < kanakan_buf_len) { + kanakan_buf_len --; + if (0x80 & kanakan_buf[kanakan_buf_len]) + kanakan_buf_len --; + kanakan_buf[kanakan_buf_len] = '\0'; + PutStr(D_LE); + PutStr(D_LE); + JAddStr(" "); + PutStr(D_LE); + PutStr(D_LE); + Flush(); + return 1; + } else if (kakutei_buf_len) { + kakutei_buf_len --; + if (0x80 & kakutei_buf[kakutei_buf_len]) + kakutei_buf_len --; + kakutei_buf[kakutei_buf_len] = '\0'; + PutStr(D_LE); + PutStr(D_LE); + JAddStr(" "); + PutStr(D_LE); + PutStr(D_LE); + Flush(); + return 1; + } + return 0; + } + + int + kill_line() + { + if (kanakan_buf_len) { + onewgoto(kakutei_buf_len, STATLINE); + AddStrn("", kanakan_buf_len); + onewgoto(kakutei_buf_len, STATLINE); + Flush(); + kanakan_buf_len = 0; + kanakan_buf[0] = '\0'; + return 1; + } else if (kakutei_buf_len) { + onewgoto(0, STATLINE); + AddStrn("", kakutei_buf_len); + onewgoto(0, STATLINE); + Flush(); + kakutei_buf_len = 0; + kakutei_buf[0] = '\0'; + return 1; + } + return 0; + } + + void + read_fd() + { + fd_set rfds; + struct timeval tv; + char buf[ONEW_GETCHAR_MAX]; + int buflen, ret; + + for (;;) { + debug("selecting ... read_fd()\n"); + FD_ZERO(&rfds); + FD_SET(onew_current_io_fd, &rfds); + tv.tv_sec = 5; + tv.tv_usec = 0; + ret = select(onew_current_io_fd + 1, &rfds, NULL, NULL, &tv); + if (ret) + break; + } + buflen = read(onew_current_io_fd, buf, onew_current_io_maxlen); + add_onew_getchar_buffer(buf, buflen); + } + + int + GetKakuteiStr(ibuf) + char *ibuf; + { + int len = kakutei_buf_len; + debug1("exec GetKakuteiStr() ... kakutei_buf_len:%d\n", len); + if (onew_input_code == 0) { + EUC_TO_JIS(kakutei_buf, len); + len = kanji_conv_buf_len; + memcpy(ibuf, kanji_conv_buf, len); + } else if (onew_input_code == SJIS) { + EUC_TO_SJIS(kakutei_buf, len); + memcpy(ibuf, kanji_conv_buf, len); + } else { + memcpy(ibuf, kakutei_buf, len); + } + kakutei_buf_len = 0; + return len; + } + + int + ONEW_GETCHAR() + { + int i, ret; + debug("exec ONEW_GETCHAR()\n"); + if (onew_getchar_buffer_len > 0) { + debug1("ONEW_GETCHAR from onew_getchar_buffer ... remain:%d\n", onew_getchar_buffer_len - 1); + ret = onew_getchar_buffer[0]; + bcopy(&onew_getchar_buffer[1], onew_getchar_buffer, onew_getchar_buffer_len - 1); + onew_getchar_buffer_len --; + } else { + debug("ONEW_GETCHAR:onew_getchar_buffer is empty.\n"); + if (Onew_RK_imode()) { + read_fd(); + ret = onew_getchar_buffer[0]; + bcopy(&onew_getchar_buffer[1], onew_getchar_buffer, onew_getchar_buffer_len - 1); + onew_getchar_buffer_len --; + } else { + onew_buffer_empty = 1; + ret = ' '; + } + } + if (ret == '\0') + ret = REPLACE_NULL; + return ret; + } + + int + ONEW_PEEKCHAR(timeout) + int *timeout; + { + debug("exec ONEW_PEEK_CHAR\n"); + if (onew_getchar_buffer_len > 0) { + return onew_getchar_buffer[0]; + } + *timeout = -1; + return 0; + } + + /* Using default ONEW_GOT_2BCHAR() */ + + int + ONEW_MESSAGE_COLS() + { + return ONEW_MSG_COL; + } + + static int prev_modef; + static char *prev_chelp = ""; + static prev_rkmode; + + void + ONEW_DISP_ROMKANMODE(cmode, chelp, modef) + char *cmode, *chelp; + int modef; + { + int rkmode; + debug("exec ONEW_DISP_ROMKANMODE()\n"); + rkmode = Onew_RK_imode(); + debug1("rkmode:%d\n", rkmode); + if (rkmode) { + if (!prev_rkmode) { + clearstatline(); + onewgoto(0, STATLINE); + } + if (prev_modef != modef) + Onew_putmsg(rkmode, "%s", cmode); + } else { + if (prev_rkmode) + resetstatline(); + } + prev_modef = modef; + prev_chelp = chelp; + prev_rkmode = rkmode; + } + + ONEW_MESSAGE(so, form, a, b, c, d, e) + int so; + char *form, *a, *b, *c, *d, *e; + { + int x, y, len; + char mbuf[1024]; + debug("exec ONEW_MESSAGE\n"); + sprintf(mbuf, form, a, b, c, d, e); + len = strlen(mbuf); + debug2("message ... mbuf len:%d {%s}\n", len, mbuf); + onewgoto(D_width - 1 - ONEW_MSG_COL , STATLINE); + JAddStr(mbuf); + onewgoto(kakutei_buf_len, STATLINE); + Flush(); + } + + static org_x; + static org_y; + + clearstatline() + { + debug("exec clearstatline\n"); + org_x = D_x; + org_y = D_y; + debug2("store position: %d, %d\n", D_x, D_y); + ClearLine(STATLINE, 0, D_width - 1); + } + + resetstatline() + { + debug("exec resetstatline\n"); + ClearLine(STATLINE, 0, D_width - 1); + onewgoto(0, STATLINE); + AddStrn("", D_width); + onewgoto(0, STATLINE); + RedisplayLine(STATLINE, 0, D_width - 1, 1); + debug2("restore position: %d, %d\n", org_x, org_y); + onewgoto(org_x, org_y); + Flush(); + } + + ONEW_BEEP(nsec) { + debug("exec ONEW_BEEP\n"); + } + + ONEW_DISP_KANAHALVES(str) + char *str; + { + int i, len; + debug("exec ONEW_DISP_KANAHALVES\n"); + if (!Onew_RK_imode()) { + debug("not rkmode... no effect.\n"); + return; + } + len = strlen(str); + JAddStr(str); + for (i = 0; i < len; i ++) + PutStr(D_LE); + Flush(); + } + + ONEW_KANAKAN(ch) + { + int ech; + debug("exec ONEW_KANAKAN\n"); + if (kanakan_buf_len) { + ech = Onew_kanakan(ch, kanakan_buf, 0, kanakan_buf_len); + Onew_kakutei(ech); + if (ch == ' ') + return 0; + if (ech == '\n') + return 0; + } + return ch; + } + + ONEW_DISP_KANAKANB(so, left, cur, right) + char *left, *cur, *right; + { + int len; + debug("exec ONEW_DISP_KANAKANB\n"); + sprintf(kanji_buf, "%s%s%s", left, cur, right); + len = strlen(kanji_buf) + kakutei_buf_len; + onewgoto(0, STATLINE); + if (kakutei_buf_len) + JAddStr(kakutei_buf); + if (so) { + if (*left) { + PutStr(D_US); + JAddStr(left); + PutStr(D_UE); + } + PutStr(D_SO); + JAddStr(cur); + PutStr(D_SE); + if (*right) { + PutStr(D_US); + JAddStr(right); + PutStr(D_UE); + } + } else { + if (*left) { + JAddStr(left); + } + JAddStr(cur); + if (*right) { + JAddStr(right); + } + } + AddStrn("", D_width - ONEW_MSG_COL - len - 1); + onewgoto(kakutei_buf_len, STATLINE); + Flush(); + } + + ONEW_KAKUTEI(ch) + { + debug("exec ONEW_KAKUTEI\n"); + if (kanakan_buf_len > 0) { + if (kanji_buf[0]) { + int klen; + klen = strlen(kanji_buf); + memcpy(&kakutei_buf[kakutei_buf_len], kanji_buf, klen); + kakutei_buf_len += klen; + } else { + memcpy(&kakutei_buf[kakutei_buf_len], kanakan_buf, kanakan_buf_len); + kakutei_buf_len += kanakan_buf_len; + } + kakutei_buf[kakutei_buf_len] = '\0'; + onewgoto(0, STATLINE); + JAddStr(kakutei_buf); + Flush(); + kanji_buf[0] = '\0'; + kanakan_buf_len = 0; + kanakan_buf[0] = '\0'; + return 1; + } + return 0; + } diff -c -N -r screen-3.7.2/onew.h screen-3.7.2+onew/onew.h *** screen-3.7.2/onew.h Thu Jan 1 09:00:00 1970 --- screen-3.7.2+onew/onew.h Mon Jul 14 13:39:57 1997 *************** *** 0 **** --- 1,44 ---- + /* + onew.h + + Using ONEW library for Japanese Input. + + */ + + #if defined(ONEW) + + #if !defined(_ONEW_H) + #define _ONEW_H + + #define ONEW_GETCHAR_MAX (8192) + #define ONEW_MSG_COL (8) + + extern int Onew_romkan(), Onew_RK_imode(), Onew_kakutei(), Onew_kanakan(); + extern int Onew_RK_cmode_set(); + extern void Onew_putmsg(), Onew_RK_init(); + + extern int ONEW_ROMKAN_TOGGLE, ONEW_MODESW_CALL, ONEW_SELECT_YANK; + extern int ONEW_HENKAN_START, THRUSYMS_TOGGLE, ONEW_THRU_NEXTCH, ONEW_THRUSYMS_SETUP; + extern int ONEW_I_ESC, ONEW_I_KAKUTEI, ONEW_I_THRU_NEXTCH, ONEW_I_SYNC_CHAR; + extern int ONEW_getch_asis; + #ifdef ONEW_CTRLG_HACK + extern int ONEW_PRE_HENKAN_START; + #endif /* ONEW_CTRLG_HACK */ + + #define ESC 033 + #define SPACE ' ' + #define NL '\n' + #define BS '\b' + #define DEL 0177 + #define KILL ('U'-0x40) + + #define TOASCII1 '(' + #define TOASCII2 'B' + #define TOJIS1 '$' + #define TOJIS2 'B' + + #define REPLACE_NULL 0x1ff + + #endif /* !defined(_ONEW_H) */ + + #endif /* ONEW */ diff -c -N -r screen-3.7.2/process.c screen-3.7.2+onew/process.c *** screen-3.7.2/process.c Mon Jul 1 18:54:32 1996 --- screen-3.7.2+onew/process.c Mon Jun 30 11:58:24 1997 *************** *** 133,138 **** --- 133,144 ---- extern struct win *fore, *console_window, *windows; extern struct user *users; + #ifdef ONEW + extern int onew_input_code; + extern int onew_output_code; + extern int ONEW_ROMKAN_TOGGLE; + #endif /* ONEW */ + extern char screenterm[], HostName[], version[]; extern struct NewWindow nwin_undef, nwin_default; extern struct LayFuncs WinLf; *************** *** 178,184 **** #endif - static const unsigned char digraphs[][3] = { {'~', '!', 161}, /* ¡ */ {'!', '!', 161}, /* ¡ */ --- 184,189 ---- *************** *** 2317,2322 **** --- 2322,2360 ---- } nwin_default.kanji = n; break; + #ifdef ONEW + case RC_ONEWINPUTCODE: + if (strcmp(*args, "jis") == 0) + onew_input_code = 0; + else if (strcmp(*args, "euc") == 0) + onew_input_code = EUC; + else if (strcmp(*args, "sjis") == 0) + onew_input_code = SJIS; + else { + Msg(0, "onewinputcode: illegal argument (%s)", *args); + } + break; + case RC_ONEWOUTPUTCODE: + if (strcmp(*args, "jis") == 0) + onew_output_code = 0; + else if (strcmp(*args, "euc") == 0) + onew_output_code = EUC; + else if (strcmp(*args, "sjis") == 0) + onew_output_code = SJIS; + else { + Msg(0, "onewinputcode: illegal argument (%s)", *args); + } + break; + case RC_ONEWROMKANKEY: + if ((s = ParseChar(*args, &ch)) == NULL || *s) + { + Msg(0, "%s: onewromkankey: character, ^x, or (octal) \\032 expected.", + rc_name); + break; + } + ONEW_ROMKAN_TOGGLE = (int) ch; + break; + #endif /* ONEW */ #endif case RC_PRINTCMD: if (*args) diff -c -N -r screen-3.7.2/screen.c screen-3.7.2+onew/screen.c *** screen-3.7.2/screen.c Wed Jul 10 16:55:48 1996 --- screen-3.7.2+onew/screen.c Wed Jul 9 11:00:54 1997 *************** *** 71,76 **** --- 71,80 ---- #include "patchlevel.h" + #ifdef ONEW + #include "onew.h" + #endif /* ONEW */ + /* * At the moment we only need the real password if the * builtin lock is used. Therefore disable SHADOWPW if *************** *** 1217,1222 **** --- 1221,1229 ---- #ifdef LOADAV InitLoadav(); #endif /* LOADAV */ + #ifdef ONEW + InitOnewKeys(); + #endif /* ONEW */ MakeNewEnv(); signal(SIGHUP, SigHup); signal(SIGINT, FinitHandler); *************** *** 1645,1650 **** --- 1652,1665 ---- } else { + #ifdef ONEW + if (ThruOnew(buf, buflen, D_userfd, maxlen) == 1) { + buflen = GetKakuteiStr(buf); + } else { + debug("reread\n"); + buflen = 0; + } + #endif ONEW /* This refills inbuf or p_inbuf */ ProcessInput(buf, buflen); }