ref: 1b09060f468f530af2f4ef75441a40084e912e54
dir: /sys/src/cmd/ktrans/main.c/
#include <u.h>
#include <libc.h>
#include <ctype.h>
#include <bio.h>
#include <plumb.h>
#include <thread.h>
#include <draw.h>
#include <mouse.h>
#include <keyboard.h>
#include "hash.h"
char*
pushutf(char *dst, char *e, char *u, int nrune)
{
Rune r;
char *p;
char *d;
if(dst >= e)
return dst;
d = dst;
p = u;
while(d < e-1){
if(isascii(*p)){
if((*d = *p) == '\0')
return d;
p++;
d++;
} else {
p += chartorune(&r, p);
if(r == Runeerror){
*d = '\0';
return d;
}
d += runetochar(d, &r);
}
if(nrune > 0 && --nrune == 0)
break;
}
if(d > e-1)
d = e-1;
*d = '\0';
return d;
}
char*
peekstr(char *s, char *b)
{
while(s > b && (*--s & 0xC0)==Runesync)
;
return s;
}
typedef struct Str Str;
struct Str {
char b[128];
char *p;
};
#define strend(s) ((s)->b + sizeof (s)->b)
void
resetstr(Str *s, ...)
{
va_list args;
va_start(args, s);
do {
s->p = s->b;
s->p[0] = '\0';
s = va_arg(args, Str*);
} while(s != nil);
va_end(args);
}
void
popstr(Str *s)
{
s->p = peekstr(s->p, s->b);
s->p[0] = '\0';
}
typedef struct Map Map;
struct Map {
char *roma;
char *kana;
char leadstomore;
};
Hmap*
openmap(char *file)
{
Biobuf *b;
char *s;
Map map;
Hmap *h;
char *key, *val;
Str partial;
Rune r;
h = hmapalloc(64, sizeof(Map));
b = Bopen(file, OREAD);
if(b == nil)
return nil;
while(key = Brdstr(b, '\n', 1)){
if(key[0] == '\0'){
Err:
free(key);
continue;
}
val = strchr(key, '\t');
if(val == nil || val[1] == '\0')
goto Err;
*val = '\0';
val++;
resetstr(&partial, nil);
for(s = key; *s; s += chartorune(&r, s)){
partial.p = pushutf(partial.p, strend(&partial), s, 1);
map.leadstomore = 0;
if(hmapget(h, partial.b, &map) == 0){
if(map.leadstomore == 1 && s[1] == '\0')
map.leadstomore = 1;
}
if(s[1] == '\0'){
map.roma = key;
map.kana = val;
hmaprepl(&h, strdup(map.roma), &map, nil, 1);
} else {
map.roma = strdup(partial.b);
map.leadstomore = 1;
map.kana = nil;
hmaprepl(&h, strdup(partial.b), &map, nil, 1);
}
}
}
Bterm(b);
return h;
}
enum{
Maxkouho=32,
};
Hmap*
opendict(Hmap *h, char *name)
{
Biobuf *b;
char *p;
char *dot, *rest;
char *kouho[Maxkouho];
int i;
b = Bopen(name, OREAD);
if(b == nil)
return nil;
if(h == nil)
h = hmapalloc(8192, sizeof(kouho));
while(p = Brdstr(b, '\n', 1)){
if(p[0] == '\0' || p[0] == ';'){
Err:
free(p);
continue;
}
dot = strchr(p, '\t');
if(dot == nil)
goto Err;
*dot = '\0';
rest = dot+1;
if(*rest == '\0')
goto Err;
memset(kouho, 0, sizeof kouho);
i = 0;
while(i < nelem(kouho)-1 && (dot = utfrune(rest, ' '))){
*dot = '\0';
kouho[i++] = rest;
rest = dot+1;
}
if(i < nelem(kouho)-1)
kouho[i] = rest;
/* key is the base pointer; overwrites clean up for us */
hmaprepl(&h, p, kouho, nil, 1);
}
Bterm(b);
return h;
}
enum{
LangEN = '', // ^t
LangJP = '', // ^n
LangJPK = ' ', // ^k
LangKO = '', // ^s
LangZH = '', // ^c
LangVN = '', // ^v
};
int deflang;
Hmap *natural;
Hmap *hira, *kata, *jisho;
Hmap *hangul;
Hmap *judou, *zidian;
Hmap *telex;
Hmap **langtab[] = {
[LangEN] &natural,
[LangJP] &hira,
[LangJPK] &kata,
[LangKO] &hangul,
[LangZH] &judou,
[LangVN] &telex,
};
char *langcodetab[] = {
[LangEN] "en",
[LangJP] "jp",
[LangJPK] "jpk",
[LangKO] "ko",
[LangZH] "zh",
[LangVN] "vn",
};
int
parselang(char *s)
{
int i;
for(i = 0; i < nelem(langcodetab); i++){
if(langcodetab[i] == nil)
continue;
if(strcmp(langcodetab[i], s) == 0)
return i;
}
return -1;
}
int
checklang(int *dst, int c)
{
Hmap **p;
if(c >= nelem(langtab))
return 0;
p = langtab[c];
if(p == nil)
return 0;
*dst = c;
return c;
}
int
maplkup(int lang, char *s, Map *m)
{
Hmap **h;
if(lang >= nelem(langtab))
return -1;
h = langtab[lang];
if(h == nil || *h == nil)
return -1;
return hmapget(*h, s, m);
}
enum { Msgsize = 256 };
static Channel *dictch;
static Channel *output;
static Channel *input;
static char backspace[Msgsize];
static Channel *displaych;
static Channel *selectch;
static void
displaythread(void*)
{
Mousectl *mctl;
Mouse m;
Keyboardctl *kctl;
Rune key;
char *kouho[Maxkouho], **s, **e;
int i, page, total, height, round;
Image *back, *text, *board, *high, *scroll;
Font *f;
Point p;
Rectangle r, exitr, selr, scrlr;
int selected;
char *mp, move[Msgsize];
enum { Adisp, Aresize, Amouse, Asel, Akbd, Amove, Aend };
Alt a[] = {
[Adisp] { nil, kouho, CHANRCV },
[Aresize] { nil, nil, CHANRCV },
[Amouse] { nil, &m, CHANRCV },
[Asel] { nil, &selected, CHANRCV },
[Akbd] { nil, &key, CHANRCV },
[Amove] { nil, move, CHANNOP },
[Aend] { nil, nil, CHANEND },
};
if(initdraw(nil, nil, "ktrans") < 0)
sysfatal("failed to initdraw: %r");
mctl = initmouse(nil, screen);
if(mctl == nil)
sysfatal("failed to get mouse: %r");
/*
* For keys coming in to our specific window.
* We've already transliterated these, but should
* consume keys and exit on del to avoid artifacts.
*/
kctl = initkeyboard(nil);
if(kctl == nil)
sysfatal("failed to get keyboard: %r");
memset(kouho, 0, sizeof kouho);
selected = -1;
f = display->defaultfont;
high = allocimagemix(display, DYellowgreen, DWhite);
text = display->black;
back = allocimagemix(display, DPaleyellow, DWhite);
board = allocimagemix(display, DBlack, DWhite);
scroll = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DYellowgreen);
a[Adisp].c = displaych;
a[Aresize].c = mctl->resizec;
a[Amouse].c = mctl->c;
a[Asel].c = selectch;
a[Akbd].c = kctl->c;
a[Amove].c = input;
threadsetname("display");
goto Redraw;
for(;;)
switch(alt(a)){
case Amove:
a[Amove].op = CHANNOP;
break;
case Akbd:
if(key != Kdel)
break;
closedisplay(display);
threadexitsall(nil);
case Amouse:
if(!m.buttons)
break;
if(ptinrect(m.xy, exitr)){
closedisplay(display);
threadexitsall(nil);
}
if(kouho[0] == nil)
break;
if(m.xy.x > scrlr.min.x && m.xy.x < scrlr.max.x){
if(m.xy.y > scrlr.min.y && m.xy.y < scrlr.max.y)
break;
if(m.xy.y < scrlr.min.y)
goto Up;
else
goto Down;
}
if(m.buttons & 7){
m.xy.y -= screen->r.min.y;
m.xy.y -= f->height;
if(m.xy.y < 0)
break;
i = round + m.xy.y/f->height + 1;
if(selected != -1)
i = i - selected - 1;
} else if(m.buttons == 8){
Up:
i = -1 * (selected % height + height);
if(selected + i < 0)
i = -(selected + (total % height));
} else if(m.buttons == 16){
Down:
i = height - (selected % height);
if(selected + i > total)
i = total - selected;
} else
break;
memset(move, 0, sizeof move);
move[0] = 'c';
if(i == 0)
break;
else if(i > 0)
memset(move+1, ' ', i);
else for(mp = move+1; i < 0; i++)
mp = seprint(mp, move + sizeof move, "%C", Kup);
a[Amove].op = CHANSND;
break;
case Aresize:
getwindow(display, Refnone);
case Adisp:
Redraw:
for(s = kouho, total = 0; *s != nil; s++, total++)
;
r = screen->r;
height = Dy(r)/f->height - 2;
draw(screen, r, back, nil, ZP);
r.max.y = r.min.y + f->height;
draw(screen, r, board, nil, ZP);
round = selected - (selected % height);
if(selected >= 0 && kouho[selected] != nil){
selr = screen->r;
selr.min.y += f->height*(selected-round+1);
selr.max.y = selr.min.y + f->height;
draw(screen, selr, high, nil, ZP);
}
scrlr = screen->r;
scrlr.min.y += f->height;
scrlr.max.y -= f->height;
scrlr.max.x = scrlr.min.x + 10;
draw(screen, scrlr, scroll, nil, ZP);
if(kouho[0] != nil){
scrlr.max.x--;
page = Dy(scrlr) / (total / height + 1);
scrlr.min.y = scrlr.min.y + page*(round / height);
scrlr.max.y = scrlr.min.y + page;
/* fill to the bottom on last page */
if((screen->r.max.y - f->height) - scrlr.max.y < page)
scrlr.max.y = screen->r.max.y - f->height;
draw(screen, scrlr, back, nil, ZP);
}
r.min.x += Dx(r)/2;
p.y = r.min.y;
p.x = r.min.x - stringwidth(f, "候補")/2;
string(screen, p, text, ZP, f, "候補");
p.y += f->height;
for(s = kouho+round, e = kouho+round+height; *s != nil && s < e; s++){
p.x = r.min.x - stringwidth(f, *s)/2;
string(screen, p, text, ZP, f, *s);
p.y += f->height;
}
p.x = r.min.x - stringwidth(f, "終了")/2;
p.y = screen->r.max.y - f->height;
exitr = Rpt(Pt(0, p.y), screen->r.max);
draw(screen, exitr, board, nil, ZP);
string(screen, p, text, ZP, f, "終了");
flushimage(display, 1);
break;
}
}
static int
emitutf(Channel *out, char *u, int nrune)
{
char b[Msgsize];
char *e;
b[0] = 'c';
e = pushutf(b+1, b + Msgsize - 1, u, nrune);
send(out, b);
return e - b;
}
static int compacting = 0;
static void
dictthread(void*)
{
char m[Msgsize];
Rune r;
int n;
char *p;
Hmap *dict;
char *kouho[Maxkouho];
Str line;
Str last;
Str okuri;
int selected, loop;
enum{
Kanji,
Okuri,
Joshi,
};
int mode;
dict = jisho;
selected = -1;
loop = 0;
mode = Kanji;
memset(kouho, 0, sizeof kouho);
resetstr(&last, &line, &okuri, nil);
threadsetname("dict");
while(recv(dictch, m) != -1){
compacting = 1;
for(p = m+1; *p; p += n){
n = chartorune(&r, p);
switch(r){
case LangJP:
dict = jisho;
break;
case LangZH:
dict = zidian;
break;
case '':
if(line.b == line.p){
emitutf(output, "", 1);
break;
}
emitutf(output, backspace, utflen(line.b));
/* fallthrough */
case ' ': case ' ': case '\n':
mode = Kanji;
resetstr(&line, &okuri, &last, nil);
break;
case '\b':
if(mode != Kanji){
if(okuri.p == okuri.b){
mode = Kanji;
popstr(&line);
}else
popstr(&okuri);
break;
}
popstr(&line);
break;
case Kup:
if(selected == -1){
emitutf(output, p, 1);
break;
}
if(--selected < 0){
//wrap
while(kouho[++selected] != nil)
;
selected--;
}
loop = 1;
goto Select;
case Kdown:
if(selected == -1){
emitutf(output, p, 1);
break;
}
case ' ':
selected++;
if(selected == 0){
if(hmapget(dict, line.b, kouho) < 0)
break;
if(dict == jisho && line.p > line.b && isascii(line.p[-1]))
line.p[-1] = '\0';
}
if(kouho[selected] == nil){
selected = 0;
loop = 1;
}
Select:
send(selectch, &selected);
send(displaych, kouho);
if(okuri.p != okuri.b)
emitutf(output, backspace, utflen(okuri.b));
if(selected == 0 && !loop)
emitutf(output, backspace, utflen(line.b));
else
emitutf(output, backspace, utflen(last.b));
emitutf(output, kouho[selected], 0);
last.p = pushutf(last.b, strend(&last), kouho[selected], 0);
emitutf(output, okuri.b, 0);
mode = Kanji;
loop = 0;
continue;
case ',': case '.':
case L'。': case L'、':
if(dict == zidian || line.p == line.b){
selected = 0; //hit cleanup below
break;
}
mode = Joshi;
okuri.p = pushutf(okuri.p, strend(&okuri), p, 1);
break;
default:
if(dict == zidian)
goto Line;
if(mode == Joshi)
goto Okuri;
if(isupper(*p)){
if(mode == Okuri){
popstr(&line);
mode = Joshi;
goto Okuri;
}
mode = Okuri;
*p = tolower(*p);
okuri.p = pushutf(okuri.b, strend(&okuri), p, 1);
goto Line;
}
switch(mode){
case Kanji:
Line:
line.p = pushutf(line.p, strend(&line), p, 1);
break;
default:
Okuri:
okuri.p = pushutf(okuri.p, strend(&okuri), p, 1);
break;
}
}
if(selected >= 0){
resetstr(&okuri, &last, &line, nil);
if(dict == zidian)
line.p = pushutf(line.p, strend(&line), p, 1);
selected = -1;
send(selectch, &selected);
}
memset(kouho, 0, sizeof kouho);
hmapget(dict, line.b, kouho);
send(displaych, kouho);
}
compacting = 0;
}
}
static void
telexlkup(Str *line)
{
Map lkup;
char buf[UTFmax*3], *p, *e, *dot;
Str out;
int n, ln;
for(dot = line->b; (ln = utflen(dot)) >= 2; dot += n){
p = pushutf(buf, buf+sizeof buf, dot, 1);
n = p-buf;
if(hmapget(telex, buf, &lkup) < 0)
continue;
e = peekstr(line->p, line->b);
pushutf(p, buf+sizeof buf, e, 1);
if(hmapget(telex, buf, &lkup) < 0)
continue;
out.p = pushutf(out.b, strend(&out), lkup.kana, 0);
out.p = pushutf(out.p, strend(&out), dot+n, 0);
popstr(&out);
emitutf(output, backspace, ln);
emitutf(output, out.b, 0);
line->p = pushutf(line->b, strend(line), out.b, 0);
return;
}
}
static void
dubeolbksp(Str *line)
{
Map lkup;
popstr(line);
/* lookup and emit remaining Jamo to output */
if(hmapget(hangul, line->b, &lkup) < 0)
return;
emitutf(output, lkup.kana, 0);
}
static void
dubeollkup(Str *line)
{
Map lkup;
char buf[UTFmax*2];
char *e2, *e1;
e1 = peekstr(line->p, line->b);
if(e1 != line->b){
e2 = peekstr(e1, line->b);
pushutf(buf, buf+sizeof buf, e2, utflen(e2));
}else
pushutf(buf, buf+sizeof buf, e1, utflen(e1));
if(hmapget(hangul, line->b, &lkup) < 0){
if(hmapget(hangul, buf, &lkup) < 0){
resetstr(line, nil);
line->p = pushutf(line->p, strend(line), e1, utflen(e1));
if(hmapget(hangul, line->b, &lkup) < 0)
return;
}else{
/* treat Jongseong as Choseong when it matches with new Jamo */
popstr(line);
popstr(line);
hmapget(hangul, line->b, &lkup);
emitutf(output, backspace, 2);
emitutf(output, lkup.kana, 0);
hmapget(hangul, buf, &lkup);
emitutf(output, lkup.kana, 0);
line->p = pushutf(line->b, strend(line), buf, utflen(buf));
return;
}
}
if(utflen(line->b) == 1)
emitutf(output, backspace, 1);
else
emitutf(output, backspace, 2);
emitutf(output, lkup.kana, 0);
}
static void
keythread(void*)
{
int lang;
char m[Msgsize];
char *todict;
Map lkup;
char *p;
int n;
Rune r;
char peek[UTFmax+1];
Str line;
peek[0] = lang = deflang;
resetstr(&line, nil);
if(lang == LangJP || lang == LangZH)
emitutf(dictch, peek, 1);
todict = smprint(" %C%C", Kup, Kdown);
threadsetname("keytrans");
while(recv(input, m) != -1){
if(m[0] == 'z'){
emitutf(dictch, " ", 1);
resetstr(&line, nil);
continue;
}
if(m[0] != 'c'){
send(output, m);
continue;
}
for(p = m+1; *p; p += n){
while(compacting)
yield();
n = chartorune(&r, p);
if(checklang(&lang, r)){
emitutf(dictch, " ", 1);
if(lang == LangJP || lang == LangZH)
emitutf(dictch, p, 1);
resetstr(&line, nil);
continue;
}
if(lang == LangEN){
emitutf(output, p, 1);
continue;
}
if(utfrune(todict, r) != nil){
resetstr(&line, nil);
emitutf(dictch, p, 1);
continue;
}
emitutf(output, p, 1);
switch(lang){
case LangZH:
emitutf(dictch, p, 1);
break;
case LangJP:
emitutf(dictch, p, 1);
if(isupper(*p))
*p = tolower(*p);
break;
}
if(utfrune("\n\t ", r) != nil){
resetstr(&line, nil);
continue;
} else if(r == '\b'){
if(lang == LangKO){
dubeolbksp(&line);
continue;
}
popstr(&line);
continue;
}
line.p = pushutf(line.p, strend(&line), p, 1);
if(lang == LangVN){
telexlkup(&line);
continue;
}else if(lang == LangKO){
dubeollkup(&line);
continue;
}
if(maplkup(lang, line.b, &lkup) < 0){
resetstr(&line, nil);
pushutf(peek, peek + sizeof peek, p, 1);
if(maplkup(lang, peek, &lkup) == 0)
line.p = pushutf(line.p, strend(&line), p, 1);
continue;
}
if(lkup.kana == nil)
continue;
if(!lkup.leadstomore)
resetstr(&line, nil);
if(lang == LangJP){
emitutf(dictch, backspace, utflen(lkup.roma));
emitutf(dictch, lkup.kana, 0);
}
emitutf(output, backspace, utflen(lkup.roma));
emitutf(output, lkup.kana, 0);
}
}
}
static int kbdin;
static int kbdout;
static void
kbdtap(void*)
{
char m[Msgsize];
char buf[Msgsize];
char *p;
int n;
threadsetname("kbdtap");
for(;;){
Drop:
n = read(kbdin, buf, sizeof buf);
if(n < 0)
break;
for(p = buf; p < buf+n; p += strlen(p) + 1){
switch(*p){
case 'c': case 'k': case 'K':
case 'z':
break;
default:
goto Drop;
}
strcpy(m, p);
if(send(input, m) == -1)
return;
}
}
threadexitsall(nil);
}
static void
kbdsink(void*)
{
char in[Msgsize];
char out[Msgsize];
char *p;
int n;
Rune rn;
out[0] = 'c';
threadsetname("kbdsink");
while(recv(output, in) != -1){
if(in[0] != 'c'){
if(write(kbdout, in, strlen(in)+1) < 0)
break;
continue;
}
for(p = in+1; *p; p += n){
n = chartorune(&rn, p);
if(rn == Runeerror || rn == '\0')
break;
memmove(out+1, p, n);
out[1+n] = '\0';
if(write(kbdout, out, 1+n+1) < 0)
break;
}
}
}
static int plumbfd;
static void
plumbproc(void*)
{
char m[Msgsize];
Plumbmsg *p;
threadsetname("plumbproc");
for(; p = plumbrecv(plumbfd); plumbfree(p)){
if(p->ndata > sizeof m - 1)
continue;
memmove(m, p->data, p->ndata);
m[p->ndata] = '\0';
m[1] = parselang(m);
if(m[1] == -1)
continue;
m[0] = 'c';
m[2] = '\0';
if(send(input, m) == -1)
break;
}
plumbfree(p);
}
void
usage(void)
{
fprint(2, "usage: %s [ -G ] [ -l lang ] [ kbdtap ]\n", argv0);
threadexits("usage");
}
static char *kdir = "/lib/ktrans";
struct {
char *s;
Hmap **m;
} initmaptab[] = {
"judou", &judou,
"hira", &hira,
"kata", &kata,
"hangul", &hangul,
"telex", &telex,
};
struct {
char *env;
char *def;
Hmap **m;
} initdicttab[] = {
"jisho", "kanji.dict", &jisho,
"zidian", "wubi.dict", &zidian,
};
mainstacksize = 8192*2;
void
threadmain(int argc, char *argv[])
{
int nogui, i;
char buf[128];
char *e, *home;
Hmap *m;
deflang = LangEN;
nogui = 0;
ARGBEGIN{
case 'l':
deflang = parselang(EARGF(usage()));
if(deflang < 0)
usage();
break;
case 'G':
nogui++;
break;
default:
usage();
}ARGEND;
switch(argc){
case 0:
kbdin = 0;
kbdout = 1;
break;
case 1:
kbdin = kbdout = open(argv[0], ORDWR);
if(kbdin < 0)
sysfatal("failed to open kbdtap: %r");
break;
default:
usage();
}
dictch = chancreate(Msgsize, 0);
input = chancreate(Msgsize, 0);
output = chancreate(Msgsize, 0);
/* allow gui to warm up while we're busy reading maps */
if(nogui || access("/dev/winid", AEXIST) < 0){
displaych = nil;
selectch = nil;
} else {
selectch = chancreate(sizeof(int), 0);
displaych = chancreate(sizeof(char*)*Maxkouho, 0);
proccreate(displaythread, nil, mainstacksize);
}
memset(backspace, '\b', sizeof backspace-1);
backspace[sizeof backspace-1] = '\0';
if((home = getenv("home")) == nil)
sysfatal("$home undefined");
for(i = 0; i < nelem(initdicttab); i++){
e = getenv(initdicttab[i].env);
if(e != nil){
snprint(buf, sizeof buf, "%s", e);
free(e);
} else
snprint(buf, sizeof buf, "%s/%s", kdir, initdicttab[i].def);
if((*initdicttab[i].m = opendict(*initdicttab[i].m, buf)) == nil)
sysfatal("failed to open dict: %r");
snprint(buf, sizeof buf, "%s/%s/%s", home, kdir, initdicttab[i].def);
m = opendict(*initdicttab[i].m, buf);
if(m != nil)
*initdicttab[i].m = m;
}
free(home);
natural = nil;
for(i = 0; i < nelem(initmaptab); i++){
snprint(buf, sizeof buf, "%s/%s.map", kdir, initmaptab[i].s);
if((*initmaptab[i].m = openmap(buf)) == nil)
sysfatal("failed to open map: %r");
}
plumbfd = plumbopen("lang", OREAD);
if(plumbfd >= 0)
proccreate(plumbproc, nil, mainstacksize);
proccreate(kbdtap, nil, mainstacksize);
proccreate(kbdsink, nil, mainstacksize);
threadcreate(dictthread, nil, mainstacksize);
threadcreate(keythread, nil, mainstacksize);
threadexits(nil);
}