/* * 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. * */ #include #include "wchar16.h" #include "select.h" #include "key.h" #include "inkey.h" #include "common.h" #define MSEC 300 int keyvalue; char* funckey[] = { "\033OH", "\033OP", "\033OQ", "\033OR", "\033OS", "\033OT", "\033OU", "\033OV", "\033OW", "\033OX", "\033OY", "\033OZ", "\033[C", "\033OC", "\033[D", "\033OD", "\033[A", "\033OA", "\033[B", "\033OB", "\033[H", "\033[4~", "\033[11~", "\033[8~", "\033[12~", "\033[13~", "\033[9~", "\033[14~", "\033[15~", "\033[17~", "\033[18~", "\033[19~", "\033[20~", "\033[21~", "\033[7~", }; int funcvalue[] = { KEY_CONV, KEY_HENKAN, KEY_MUHENKAN, KEY_ETC, KEY_KETTEI, KEY_CODE, KEY_HALPHA, KEY_ZALPHA, KEY_HKATA, KEY_ZKATA, KEY_ZHIRA, KEY_OTHER, KEY_RIGHT, KEY_RIGHT, KEY_LEFT, KEY_LEFT, KEY_UP, KEY_UP, KEY_DOWN, KEY_DOWN, KEY_CONV, KEY_HENKAN, KEY_HENKAN, KEY_MUHENKAN, KEY_MUHENKAN, KEY_ETC, KEY_KETTEI, KEY_KETTEI, KEY_CODE, KEY_HALPHA, KEY_ZALPHA, KEY_HKATA, KEY_ZKATA, KEY_ZHIRA, KEY_CONV, }; int keynumber = sizeof(funckey) / sizeof(char*); extern int Direct; extern int master; extern wchar16_t Ukey[UKEYNUM][SEQLEN + 1]; extern int Uvalue[]; extern int Unumber; int convert_stat(void) { stat_init(); stat_conv(); } int inputprocess(void) { int c; wchar16_t obuf[2]; if(Direct) { set_guide_line(KEY_CONV); convert_stat(); } set_guide_line(KEY_NORMAL); print_guide_line(); for(;;) { if((c = inkey()) == EOF) continue; switch(keyvalue) { case KEY_NORMAL: obuf[0] = c; obuf[1] = 0; SJ_write(obuf, 1); break; case KEY_CONV: set_guide_line(KEY_CONV); convert_stat(); set_guide_line(KEY_NORMAL); print_guide_line(); break; default: write_pseq(0); break; } } } wchar16_t ibuf[KEYBUFSIZ]; wchar16_t pars_seq[KEYBUFSIZ]; int buf_count = 0; int pars_n; static int escape = 0; int inkey(void) { Conversion* cv; int i, j; wchar16_t c; cv = current_conversion; keyvalue = KEY_NORMAL; pars_n = 0; if(buf_count) { if(escape && cv->Cflag) master_flush(); c = *ibuf; } else { if((c = SJ_getchar()) == (wchar16_t)EOF) return ((short)c); *ibuf = c; buf_count = 1; } if(*ibuf == ESC) { keyvalue = sequence(ibuf, &buf_count); escape = 1; } else { escape = 0; } if(keyvalue == KEY_NORMAL) keyvalue = parse_command(ibuf, &buf_count); if(keyvalue == KEY_NORMAL) { c = *ibuf; for(i = 1; i < buf_count; i++) ibuf[i - 1] = ibuf[i]; buf_count--; } if(buf_count > KEYBUFLIM) { for(i = buf_count - 1; i >= 0; i--) { if(ibuf[i] == ESC) { for(j = i; j < buf_count; j++) ibuf[j - i] = ibuf[j]; buf_count -= i; return (c); } } buf_count = 0; } return (c); } int sequence(wchar16_t * buf, int * count) { int n; SELECT_FD ifds; struct timeval t; wchar16_t* s; int value; if(*count > 1 && (value = parse_escape(buf, count, 1)) != KEY_MORE) return (value); s = buf + *count; for(;;) { t.tv_sec = 0; t.tv_usec = UsecWeight(0); FD_ZERO(&ifds); FD_SET(STDIN, &ifds); if(select(STDIN + 1, &ifds, 0, 0, &t) <= 0) { if(errno == EINTR) { errno = 0; continue; } else { return (parse_escape(buf, count, 0)); } } if((n = SJ_read(s, KEYBUFLIM)) <= 0) { return (parse_escape(buf, *count, 0)); } s += n; *count += n; if((value = parse_escape(buf, count, 1)) == KEY_MORE) continue; else { return (value); } } } int parse_escape(wchar16_t * s, int * count, int more) { int i, j; wchar16_t temp[KEYBUFSIZ]; int possible; possible = 0; for(i = 0; i < Unumber; i++) { for(j = 0; j < *count; j++) { if(s[j] != Ukey[i][j]) break; } if(j == wslen(&Ukey[i][0])) { Strncpy(pars_seq, s, j); pars_seq[j] = (wchar16_t)'\0'; pars_n = j; *count -= j; if(*count > 0) { Strncpy(temp, &s[j], *count); temp[*count] = (wchar16_t)'\0'; wscpy(s, temp); } return (Uvalue[i]); } else if(j == *count) possible = 1; } for(i = 0; i < keynumber; i++) { for(j = 0; j < *count; j++) { if(s[j] != (unsigned char)funckey[i][j]) break; } if(j == strlen(funckey[i])) { Strncpy(pars_seq, s, j); pars_seq[j] = (wchar16_t)'\0'; pars_n = j; *count -= j; if(*count > 0) { Strncpy(temp, &s[j], *count); temp[*count] = (wchar16_t)'\0'; wscpy(s, temp); } return (funcvalue[i]); } else if(j == *count) possible = 1; } if(*count == 1) return (KEY_NORMAL); else if(more && possible) return (KEY_MORE); else { Strncpy(pars_seq, s, *count); pars_seq[*count] = (wchar16_t)'\0'; pars_n = *count; *count = 0; *s = '\0'; return (KEY_OTHER); } } int write_pseq(int mod) { if(mod == 3) { if(pars_n > 0) { pars_n = 0; return (*pars_seq); } } if(mod == 2) { if(pars_n == 1) { pars_n = 0; return (*pars_seq); } pars_n = 0; return (0); } if(mod == 1) { if(pars_n == 1) { pars_n = 0; return (*pars_seq); } else if(IsGoto(*pars_seq)) { Strncpy(&ibuf[buf_count], &pars_seq[1], pars_n - 1); buf_count += pars_n - 1; pars_n = 0; return (*pars_seq); } } if(pars_n > 0) SJ_through(pars_seq, pars_n); pars_n = 0; return (0); }