static int
keyword_or_ident(mvc * c, int cur)
{
struct scanner *lc = &c->scanner;
keyword *k = NULL;
int s;
lc->started = 1;
utf8_putchar(lc, cur);
s = lc->yycur;
lc->yyval = IDENT;
while ((cur = scanner_getc(lc)) != EOF) {
if (!iswalnum(cur) && cur != '_') {
utf8_putchar(lc, cur);
(void)scanner_token(lc, IDENT);
k = find_keyword_bs(lc,s);
if (k)
lc->yyval = k->token;
/* find keyword in SELECT/JOIN/UNION FUNCTIONS */
else if (sql_find_func(c->sa, cur_schema(c), lc->rs->buf+lc->rs->pos+s, -1, F_FILT, NULL))
lc->yyval = FILTER_FUNC;
return lc->yyval;
}
}
(void)scanner_token(lc, IDENT);
k = find_keyword_bs(lc,s);
if (k)
lc->yyval = k->token;
/* find keyword in SELECT/JOIN/UNION FUNCTIONS */
else if (sql_find_func(c->sa, cur_schema(c), lc->rs->buf+lc->rs->pos+s, -1, F_FILT, NULL))
lc->yyval = FILTER_FUNC;
return lc->yyval;
}
static int
number(mvc * c, int cur)
{
struct scanner *lc = &c->scanner;
int token = sqlINT;
int before_cur = EOF;
lc->started = 1;
if (cur == '0' && (cur = scanner_getc(lc)) == 'x') {
while ((cur = scanner_getc(lc)) != EOF &&
(iswdigit(cur) ||
(cur >= 'A' && cur <= 'F') ||
(cur >= 'a' && cur <= 'f')))
token = HEXADECIMAL;
if (token == sqlINT)
before_cur = 'x';
} else {
if (iswdigit(cur))
while ((cur = scanner_getc(lc)) != EOF && iswdigit(cur))
;
if (cur == '@') {
token = OIDNUM;
cur = scanner_getc(lc);
if (cur == '0')
cur = scanner_getc(lc);
}
if (cur == '.') {
token = INTNUM;
while ((cur = scanner_getc(lc)) != EOF && iswdigit(cur))
;
}
if (cur == 'e' || cur == 'E') {
token = APPROXNUM;
cur = scanner_getc(lc);
if (cur == '-' || cur == '+')
token = 0;
while ((cur = scanner_getc(lc)) != EOF && iswdigit(cur))
token = APPROXNUM;
}
}
if (cur == EOF && lc->rs->buf == NULL) /* malloc failure */
return EOF;
if (token) {
if (cur != EOF)
utf8_putchar(lc, cur);
if (before_cur != EOF)
utf8_putchar(lc, before_cur);
return scanner_token(lc, token);
} else {
(void)sql_error( c, 2, "unexpected symbol %lc", (wint_t) cur);
return LEX_ERROR;
}
}
void str_to_all_phokey_chars(char *u8_str, char *out)
{
out[0]=0;
while (*u8_str) {
phokey_t phos[32];
int n=utf8_pho_keys(u8_str, phos);
#if 0
utf8_putchar(u8_str);
dbg("n %d\n", n);
#endif
int i;
for(i=0; i < n; i++) {
char *pstr = phokey_to_str(phos[i]);
strcat(out, pstr);
if (i < n -1)
strcat(out, " ");
}
u8_str+=utf8_sz(u8_str);
if (*u8_str)
strcat(out, " | ");
}
}
void prph2(FILE *fp, phokey_t kk)
{
u_int k[4];
phokey_t okk = kk;
k[3]=(kk&7);
kk>>=3;
k[2]=(kk&15) * PHO_CHAR_LEN;
kk>>=4;
k[1]=(kk&3) * PHO_CHAR_LEN;
kk>>=2;
k[0]=(kk&31) * PHO_CHAR_LEN;
if (k[0]==BACK_QUOTE_NO*PHO_CHAR_LEN) {
utf8_putchar(&pho_chars[0][k[0]]);
char c = okk & 0x7f;
if (c > ' ')
fprintf(fp, "%c", c);
} else {
int i;
for(i=0; i < 3; i++) {
if (!k[i])
continue;
utf8_putchar_fp(fp, &pho_chars[i][k[i]]);
}
if (k[3])
fprintf(fp, "%d", k[3]);
}
}
int utf8_wcstombs(const wchar *src, int srclen, char *dst, int dstlen)
{
int count = 0;
const wchar *src_end = src + srclen;
const char *dst_end = dst + dstlen;
int ch;
while (src < src_end)
{
ch = utf16_getchar(src, src_end);
count += utf8_putchar(ch, dst, dst_end);
}
return count;
}
int utf8_pho_keys(char *utf8, phokey_t *phkeys)
{
int i;
int ofs=0;
int phkeysN=0;
PH_COUNT phcou[256];
do {
for(; ofs < ch_phoN; ofs++)
if (utf8_eq(utf8, pho_idx_str(ofs)))
break;
if (ofs==ch_phoN)
goto ret;
for(i=0; i < idxnum_pho; i++) {
if (idx_pho[i].start<= ofs && ofs < idx_pho[i+1].start) {
// dbg("ofs:%d %d %d %d\n", ofs, i, idx_pho[i].start, idx_pho[i+1].start);
phcou[phkeysN].count = ch_pho[ofs].count;
phcou[phkeysN++].key = idx_pho[i].key;
break;
}
}
ofs++;
} while (ofs < ch_phoN);
ret:
#if 0
utf8_putchar(utf8);
dbg("n %d\n", phkeysN);
#endif
qsort(phcou, phkeysN, sizeof(PH_COUNT), qcmp_pho_count);
for(i=0; i < phkeysN; i++)
phkeys[i] = phcou[i].key;
return phkeysN;
}
static
int scanner_symbol(mvc * c, int cur)
{
struct scanner *lc = &c->scanner;
int next = 0;
int started = lc->started;
switch (cur) {
case '/':
lc->started = 1;
next = scanner_getc(lc);
if (next == '*') {
lc->started = started;
cur = skip_c_comment(lc);
if (cur < 0)
return EOF;
return tokenize(c, cur);
} else {
utf8_putchar(lc, next);
return scanner_token(lc, cur);
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return number(c, cur);
case '#':
if ((cur = skip_sql_comment(lc)) == EOF)
return cur;
return tokenize(c, cur);
case '\'':
case '"':
return scanner_string(c, cur);
case '{':
return scanner_body(c);
case '-':
lc->started = 1;
next = scanner_getc(lc);
if (next == '-') {
lc->started = started;
if ((cur = skip_sql_comment(lc)) == EOF)
return cur;
return tokenize(c, cur);
}
lc->started = 1;
utf8_putchar(lc, next);
return scanner_token(lc, cur);
case '~': /* binary not */
case '^': /* binary xor */
case '*':
case '?':
case '%':
case '+':
case '(':
case ')':
case ',':
case '=':
case '[':
case ']':
lc->started = 1;
return scanner_token(lc, cur);
case '&':
lc->started = 1;
cur = scanner_getc(lc);
if(cur == '<') {
next = scanner_getc(lc);
if(next == '|') {
return scanner_token(lc, GEOM_OVERLAP_OR_BELOW);
} else {
utf8_putchar(lc, next); //put the char back
return scanner_token(lc, GEOM_OVERLAP_OR_LEFT);
}
} else if(cur == '>')
return scanner_token(lc, GEOM_OVERLAP_OR_RIGHT);
else if(cur == '&')
return scanner_token(lc, GEOM_OVERLAP);
else {/* binary and */
utf8_putchar(lc, cur); //put the char back
return scanner_token(lc, '&');
}
case '@':
lc->started = 1;
return scanner_token(lc, AT);
case ';':
lc->started = 0;
return scanner_token(lc, SCOLON);
case '<':
lc->started = 1;
cur = scanner_getc(lc);
if (cur == '=') {
return scanner_token( lc, COMPARISON);
} else if (cur == '>') {
return scanner_token( lc, COMPARISON);
} else if (cur == '<') {
next = scanner_getc(lc);
if (next == '=') {
return scanner_token( lc, LEFT_SHIFT_ASSIGN);
} else if (next == '|') {
return scanner_token(lc, GEOM_BELOW);
} else {
utf8_putchar(lc, next); //put the char back
return scanner_token( lc, LEFT_SHIFT);
}
} else if(cur == '-') {
next = scanner_getc(lc);
if(next == '>') {
return scanner_token(lc, GEOM_DIST);
} else {
//put the characters back and fall in the next possible case
utf8_putchar(lc, next);
utf8_putchar(lc, cur);
return scanner_token( lc, COMPARISON);
}
} else {
utf8_putchar(lc, cur);
return scanner_token( lc, COMPARISON);
}
case '>':
lc->started = 1;
cur = scanner_getc(lc);
if (cur == '>') {
cur = scanner_getc(lc);
if (cur == '=')
return scanner_token( lc, RIGHT_SHIFT_ASSIGN);
utf8_putchar(lc, cur);
return scanner_token( lc, RIGHT_SHIFT);
} else if (cur != '=') {
utf8_putchar(lc, cur);
return scanner_token( lc, COMPARISON);
} else {
return scanner_token( lc, COMPARISON);
}
case '.':
lc->started = 1;
cur = scanner_getc(lc);
if (!iswdigit(cur)) {
utf8_putchar(lc, cur);
return scanner_token( lc, '.');
} else {
utf8_putchar(lc, cur);
cur = '.';
return number(c, cur);
}
case '|': /* binary or or string concat */
lc->started = 1;
cur = scanner_getc(lc);
if (cur == '|') {
return scanner_token(lc, CONCATSTRING);
} else if (cur == '&') {
next = scanner_getc(lc);
if(next == '>') {
return scanner_token(lc, GEOM_OVERLAP_OR_ABOVE);
} else {
utf8_putchar(lc, next); //put the char back
utf8_putchar(lc, cur); //put the char back
return scanner_token(lc, '|');
}
} else if (cur == '>') {
next = scanner_getc(lc);
if(next == '>') {
return scanner_token(lc, GEOM_ABOVE);
} else {
utf8_putchar(lc, next); //put the char back
utf8_putchar(lc, cur); //put the char back
return scanner_token(lc, '|');
}
} else {
utf8_putchar(lc, cur);
return scanner_token(lc, '|');
}
}
(void)sql_error( c, 3, "unexpected symbol (%lc)", (wint_t) cur);
return LEX_ERROR;
}
int tsin_parse_recur(int start, TSIN_PARSE *out,
short *r_match_phr_N, short *r_no_match_ch_N)
{
int plen;
double bestscore = -1;
int bestusecount = 0;
*r_match_phr_N = 0;
*r_no_match_ch_N = tsin_parse_len - start;
for(plen=1; start + plen <= tsin_parse_len && plen <= MAX_PHRASE_LEN; plen++) {
#if DBG
dbg("---- aa st:%d hh plen:%d ", start, plen);utf8_putchar(tss.chpho[start].ch); dbg("\n");
#endif
if (plen > 1) {
if (tsin_is_gtab) {
if (gbuf[start+plen-1].flag & FLAG_CHPHO_PHRASE_USER_HEAD)
break;
} else
if (tss.chpho[start+plen-1].flag & FLAG_CHPHO_PHRASE_USER_HEAD)
break;
}
phokey_t pp[MAX_PHRASE_LEN + 1];
u_int pp32[MAX_PHRASE_LEN + 1];
u_int64_t pp64[MAX_PHRASE_LEN + 1];
int sti, edi;
TSIN_PARSE pbest[MAX_PH_BF_EXT+1];
#define MAXV 1000
int maxusecount = 5-MAXV;
int remlen;
short match_phr_N=0, no_match_ch_N = plen;
void *ppp;
if (ph_key_sz==2)
ppp=pp;
else if (ph_key_sz==4)
ppp=pp32;
else
ppp=pp64;
bzero(pbest, sizeof(TSIN_PARSE) * tsin_parse_len);
pbest[0].len = plen;
pbest[0].start = start;
int i, ofs;
if (tsin_is_gtab)
for(ofs=i=0; i < plen; i++)
ofs += utf8cpy((char *)pbest[0].str + ofs, gbuf[start + i].ch);
else
for(ofs=i=0; i < plen; i++)
ofs += utf8cpy((char *)pbest[0].str + ofs, tss.chpho[start + i].ch);
#if DBG
dbg("st:%d hh plen:%d ", start, plen);utf8_putchar(tss.chpho[start].ch); dbg("\n");
#endif
if (tsin_is_gtab)
extract_gtab_key(start, plen, ppp);
else {
extract_pho(start, plen, (phokey_t *)ppp);
if (c_pinyin_set)
mask_tone(pp, plen, c_pinyin_set + start);
}
#if DBG
for(i=0; i < plen; i++) {
prph(pp[i]); dbg("%d", c_pinyin_set[i+start]);
}
dbg("\n");
#endif
char *pinyin_set = c_pinyin_set ? c_pinyin_set+start:NULL;
if (!tsin_seek(ppp, plen, &sti, &edi, pinyin_set)) {
// dbg("tsin_seek not found...\n");
if (plen > 1)
break;
goto next;
}
phokey_t mtk[MAX_PHRASE_LEN];
u_int mtk32[MAX_PHRASE_LEN];
u_int64_t mtk64[MAX_PHRASE_LEN];
void *pho;
if (ph_key_sz==2)
pho=mtk;
else if (ph_key_sz==4)
pho=mtk32;
else
pho=mtk64;
for (;sti < edi; sti++) {
char mtch[MAX_PHRASE_LEN*CH_SZ+1];
char match_len;
usecount_t usecount;
load_tsin_entry(sti, &match_len, &usecount, pho, (u_char *)mtch);
if (match_len < plen)
continue;
if (tsin_is_gtab) {
if (check_gtab_fixed_mismatch(start, mtch, plen))
continue;
} else
if (check_fixed_mismatch(start, mtch, plen))
continue;
if (usecount < 0)
usecount = 0;
int i;
if (ph_key_sz==2) {
if (c_pinyin_set) {
// mask_tone(pp, plen, c_pinyin_set + start);
mask_tone(mtk, plen, c_pinyin_set + start);
}
for(i=0;i < plen;i++)
if (mtk[i]!=pp[i])
break;
} else if (ph_key_sz==4) {
for(i=0;i < plen;i++)
if (mtk32[i]!=pp32[i])
break;
} else {
for(i=0;i < plen;i++)
if (mtk64[i]!=pp64[i])
break;
}
if (i < plen)
continue;
if (match_len > plen) {
continue;
}
if (usecount <= maxusecount)
continue;
pbest[0].len = plen;
maxusecount = usecount;
utf8cpyN((char *)pbest[0].str, mtch, plen);
pbest[0].flag |= FLAG_TSIN_PARSE_PHRASE;
match_phr_N = 1;
no_match_ch_N = 0;
#if DBG
utf8_putcharn(mtch, plen);
dbg(" plen %d usecount:%d ", plen, usecount);
utf8_putcharn(mtch, plen);
dbg("\n");
#endif
}
next:
#if 0
if (!match_phr_N) {
if (tsin_is_gtab) {
if (!(gbuf[start].ch[0] & 0x80))
no_match_ch_N = 0;
} else
if (!(tss.chpho[start].ch[0] & 0x80))
no_match_ch_N = 0;
}
#else
// dbg("no_match_ch_N %d\n", no_match_ch_N);
#endif
remlen = tsin_parse_len - (start + plen);
if (remlen) {
int next = start + plen;
CACHE *pca;
short smatch_phr_N, sno_match_ch_N;
int uc;
if ((pca = cache_lookup(next))) {
uc = pca->usecount;
smatch_phr_N = pca->match_phr_N;
sno_match_ch_N = pca->no_match_ch_N;
memcpy(&pbest[1], pca->best, (tsin_parse_len - next) * sizeof(TSIN_PARSE));
} else {
uc = tsin_parse_recur(next, &pbest[1], &smatch_phr_N, &sno_match_ch_N);
// dbg(" gg %d\n", smatch_phr_N);
add_cache(next, uc, &pbest[1], smatch_phr_N, sno_match_ch_N, tsin_parse_len);
}
match_phr_N += smatch_phr_N;
no_match_ch_N += sno_match_ch_N;
maxusecount += uc;
}
double score = log((double)maxusecount + MAXV) /
(pow((double)match_phr_N, 10)+ 1.0E-6) / (pow((double)no_match_ch_N, 20) + 1.0E-6);
#if DBG
dbg("st:%d plen:%d zz muse:%d ma:%d noma:%d score:%.4e %.4e\n", start, plen,
maxusecount, match_phr_N, no_match_ch_N, score, bestscore);
#endif
if (score > bestscore) {
#if DBG
dbg("is best org %.4e\n", bestscore);
#endif
bestscore = score;
memcpy(out, pbest, sizeof(TSIN_PARSE) * (tsin_parse_len - start));
#if DBG
dbg(" str:%d ", start);
int i;
for(i=0; i < tsin_parse_len - start; i++) {
utf8_putcharn((char *)out[i].str, out[i].len);
}
dbg("\n");
#endif
bestusecount = maxusecount;
*r_match_phr_N = match_phr_N;
*r_no_match_ch_N = no_match_ch_N;
}
}
if (bestusecount < 0)
bestusecount = 0;
return bestusecount;
}
void tsin_parse()
{
TSIN_PARSE out[MAX_PH_BF_EXT+1];
bzero(out, sizeof(out));
int i, ofsi;
if (tss.c_len <= 1)
return;
load_tsin_db();
set_tsin_parse_len(tss.c_len);
init_cache(tss.c_len);
char pinyin_set[MAX_PH_BF_EXT];
c_pinyin_set = pin_juyin?pinyin_set:NULL;
get_chpho_pinyin_set(pinyin_set);
short smatch_phr_N, sno_match_ch_N;
tsin_parse_recur(0, out, &smatch_phr_N, &sno_match_ch_N);
#if 0
puts("vvvvvvvvvvvvvvvv");
for(i=0; i < tss.c_len; i++) {
printf("%d:", out[i].len);
utf8_putcharn(out[i].str, out[i].len);
}
dbg("\n");
#endif
for(i=0; i < tss.c_len; i++)
tss.chpho[i].flag &= ~(FLAG_CHPHO_PHRASE_HEAD|FLAG_CHPHO_PHRASE_BODY);
for(ofsi=i=0; out[i].len; i++) {
int j, ofsj;
int psta = ofsi;
if (out[i].flag & FLAG_TSIN_PARSE_PHRASE)
tss.chpho[ofsi].flag |= FLAG_CHPHO_PHRASE_HEAD;
for(ofsj=j=0; j < out[i].len; j++) {
ofsj += utf8cpy(tss.chpho[ofsi].cha, (char *)&out[i].str[ofsj]);
// tss.chpho[ofsi].ch = tss.chpho[ofsi].cha;
tss.chpho[ofsi].flag |= FLAG_CHPHO_PHRASE_BODY;
if (out[i].flag & FLAG_TSIN_PARSE_PHRASE)
tss.chpho[ofsi].psta = psta;
ofsi++;
}
}
int ph_sta_idx = tss.ph_sta;
if (tss.chpho[tss.c_len-1].psta>=0 && tss.c_len - tss.chpho[tss.c_len-1].psta > 1) {
ph_sta_idx = tss.chpho[tss.c_len-1].psta;
}
#if 1
disp_ph_sta_idx(ph_sta_idx);
#endif
#if 0
for(i=0;i<tss.c_len;i++)
utf8_putchar(tss.chpho[i].ch);
puts("");
#endif
free_cache();
}
gboolean feedkey_gtab(KeySym key, int kbstate)
{
int i,j=0;
int inkey=0;
char *pselkey= NULL;
gboolean phrase_selected = FALSE;
char seltab_phrase[MAX_SELKEY];
gboolean is_keypad = FALSE;
gboolean shift_m = (kbstate & ShiftMask) > 0;
// gboolean ctrl_m = (kbstate & ControlMask) > 0;
gboolean capslock_on = (kbstate & LockMask);
bzero(seltab_phrase, sizeof(seltab_phrase));
// dbg("uuuuu %x %x shift,ctrl:%d,%d\n", key, kbstate, shift_m, ctrl_m);
if (!cur_inmd)
return 0;
gboolean is_dayi = !strncmp(cur_inmd->filename, "dayi", 4);
if ((tsin_chinese_english_toggle_key == TSIN_CHINESE_ENGLISH_TOGGLE_KEY_CapsLock) &&
(key == XK_Caps_Lock)){
// The CapLock status may be incorrect when XK_Caps_Lock is pressed.
gboolean new_tsin_pho_mode = ! gdk_keymap_get_caps_lock_state(gdk_keymap_get_default());
if (current_CS->tsin_pho_mode != new_tsin_pho_mode) {
current_CS->tsin_pho_mode = new_tsin_pho_mode;
save_CS_current_to_temp();
tsin_set_eng_ch(new_tsin_pho_mode);
}
}
if ((kbstate & (Mod1Mask|Mod4Mask|Mod5Mask|ControlMask))==ControlMask
&& key>='1' && key<='9' && ggg.gbufN) {
save_gtab_buf_phrase(key);
return 1;
}
if (ggg.gbufN && key==XK_Tab)
return 1;
if ((key==XK_Shift_L||key==XK_Shift_R) && !key_press_time) {
key_press_time = current_time();
key_press_time_ctrl = 0;
} else
if ((key==XK_Control_L||key==XK_Control_R) && !key_press_time_ctrl && tss.pre_selN) {
key_press_time_ctrl = current_time();
return TRUE;
} else {
key_press_time_ctrl = 0;
key_press_time = 0;
}
if (kbstate & (Mod1Mask|Mod4Mask|Mod5Mask|ControlMask)) {
return 0;
}
if (poo.same_pho_query_state == SAME_PHO_QUERY_pho_select)
return feedkey_pho(key, 0);
if (poo.same_pho_query_state == SAME_PHO_QUERY_none && gwin_pho &&
GTK_WIDGET_VISIBLE(gwin_pho))
hide_win_pho();
if (!tsin_pho_mode()) {
if (key < 0x20 || key>=0x7f)
goto shift_proc;
if (capslock_on && hime_capslock_lower)
case_inverse((KeySym *)&key, shift_m);
if (ggg.gbufN)
insert_gbuf_cursor_char(key);
else
send_ascii(key);
return 1;
}
int lcase;
lcase = tolower(key);
int ucase;
ucase = toupper(key);
if (key < 127 && cur_inmd->keymap[key]) {
if (key < 'A' || key > 'z' || (key > 'Z' && key < 'a') )
goto shift_proc;
if (cur_inmd->keymap[lcase] != cur_inmd->keymap[ucase])
goto next;
}
shift_proc:
if (shift_m && !strchr(cur_inmd->selkey, key) && !ggg.more_pg && key>=' ' && key < 0x7e &&
key!='*' && (key!='?' || (gtab_shift_phrase_key && !ggg.ci))) {
if (gtab_shift_phrase_key) {
if (tss.pre_selN && shift_char_proc(key, kbstate))
return TRUE;
if (feed_phrase(key, kbstate))
return TRUE;
} else {
if (!cur_inmd->keymap[key] || (lcase != ucase &&
cur_inmd->keymap[lcase]==cur_inmd->keymap[ucase]))
return shift_char_proc(key, kbstate);
}
}
gboolean has_wild;
has_wild = FALSE;
switch (key) {
case XK_BackSpace:
ggg.last_idx=0;
ggg.spc_pressed=0;
ggg.sel1st_i=MAX_SELKEY-1;
clear_gtab_input_error_color();
hide_gtab_pre_sel();
if (ggg.ci==0) {
if (AUTO_SELECT_BY_PHRASE)
return gtab_buf_backspace();
else
return 0;
}
if (ggg.ci>0)
ggg.inch[--ggg.ci]=0;
if (has_wild_card()) {
proc_wild_disp();
return 1;
}
ggg.wild_mode=0;
ggg.invalid_spc = FALSE;
if (ggg.ci==1 && cur_inmd->use_quick) {
int i;
clr_seltab();
for(i=0;i<cur_inmd->M_DUP_SEL;i++)
utf8cpy(seltab[i], (char *)cur_inmd->qkeys->quick1[ggg.inch[0]-1][i]);
ggg.defselN=cur_inmd->M_DUP_SEL;
DispInArea();
goto Disp_opt;
} else
if (ggg.ci==2 && cur_inmd->use_quick) {
int i;
clr_seltab();
for(i=0;i<cur_inmd->M_DUP_SEL;i++)
utf8cpy(seltab[i], (char *)cur_inmd->qkeys->quick2[ggg.inch[0]-1][ggg.inch[1]-1][i]);
ggg.defselN=cur_inmd->M_DUP_SEL;
DispInArea();
goto Disp_opt;
}
break;
case XK_KP_Enter:
case XK_Return:
if (AUTO_SELECT_BY_PHRASE) {
hide_gtab_pre_sel();
if (shift_m) {
return save_gtab_buf_shift_enter();
} else
return output_gbuf();
}
else
return 0;
case XK_Up:
if (gtab_has_input())
return TRUE;
return FALSE;
case XK_Down:
case XK_KP_Down:
if (AUTO_SELECT_BY_PHRASE)
return show_buf_select();
else
return 0;
case XK_Escape:
hide_gtab_pre_sel();
if (ggg.gtab_buf_select) {
ggg.gtab_buf_select = 0;
reset_gtab_all();
ClrSelArea();
if (hime_pop_up_win && !gtab_has_input())
hide_win_gtab();
return 1;
}
ClrSelArea();
close_gtab_pho_win();
if (ggg.ci) {
reset_gtab_all();
return 1;
} else {
if (ggg.gbufN) {
set_gtab_user_head();
return 1;
}
ClrIn();
return 0;
}
case XK_Prior:
case XK_KP_Prior:
case XK_KP_Subtract:
if (ggg.wild_mode) {
if (ggg.wild_page >= cur_inmd->M_DUP_SEL) ggg.wild_page-=cur_inmd->M_DUP_SEL;
wildcard();
return 1;
} else
if (ggg.more_pg) {
if (ggg.gtab_buf_select) {
gbuf_prev_pg();
return 1;
}
ggg.pg_idx -= page_len();
if (ggg.pg_idx < ggg.S1)
ggg.pg_idx = ggg.S1;
goto next_pg;
}
if (key==XK_KP_Subtract)
goto keypad_proc;
return win_sym_page_up();
case XK_Next:
case XK_KP_Next:
case XK_KP_Add:
if (ggg.more_pg) {
if (ggg.gtab_buf_select) {
gbuf_next_pg();
return 1;
}
next_page:
// dbg("more...\n");
ggg.pg_idx += page_len();
if (ggg.pg_idx >=ggg.E1)
ggg.pg_idx = ggg.S1;
goto next_pg;
} else {
if (key==XK_KP_Add)
goto keypad_proc;
if (win_sym_page_down())
return TRUE;
if (!ggg.gtab_buf_select && ggg.gbufN && AUTO_SELECT_BY_PHRASE)
return show_buf_select();
return FALSE;
}
case ' ':
hide_gtab_pre_sel();
if (ggg.invalid_spc && gtab_invalid_key_in)
ClrIn();
if (!gtab_invalid_key_in && ggg.spc_pressed && ggg.invalid_spc) {
ClrIn();
return 1;
}
has_wild = has_wild_card();
// dbg("ggg.wild_mode:%d ggg.more_pg:%d ggg.ci:%d has_wild:%d\n", ggg.wild_mode, ggg.more_pg, ggg.ci, has_wild);
if (ggg.wild_mode) {
// request from tetralet
if (!ggg.wild_page && ggg.total_matchN < cur_inmd->M_DUP_SEL) {
ggg.sel1st_i = 0;
goto direct_select;
}
ggg.wild_page += cur_inmd->M_DUP_SEL;
if (ggg.wild_page >= ggg.total_matchN)
ggg.wild_page=0;
wildcard();
ggg.spc_pressed = TRUE;
return 1;
} else
if (ggg.more_pg && !(_gtab_space_auto_first & GTAB_space_auto_first_any)) {
if (ggg.gtab_buf_select) {
gbuf_next_pg();
return 1;
}
else
goto next_page;
} else
if (ggg.ci==0) {
if (current_CS->b_half_full_char)
return full_char_proc(key);
if (ggg.gbufN) {
output_gbuf();
} else
return 0;
} else
if (!has_wild) {
// dbg("iii %d ggg.defselN:%d %d\n", ggg.sel1st_i, ggg.defselN, cur_inmd->M_DUP_SEL);
if (_gtab_space_auto_first == GTAB_space_auto_first_any && seltab[0][0] &&
ggg.sel1st_i==MAX_SELKEY-1) {
ggg.sel1st_i = 0;
}
if (_gtab_space_auto_first == GTAB_space_auto_first_nofull && ggg.exa_match > 1
&& !AUTO_SELECT_BY_PHRASE && gtab_dup_select_bell)
bell();
if (seltab[ggg.sel1st_i][0]) {
// dbg("ggg.last_full %d %d\n", ggg.last_full,ggg.spc_pressed);
if (gtab_full_space_auto_first || ggg.spc_pressed) {
direct_select:
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input) {
// dbg("ins ggg.kval %x\n", ggg.kval);
insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
}
else
putstr_inp(seltab[ggg.sel1st_i]); /* select 1st */
return 1;
}
}
}
ggg.last_full=0;
ggg.spc_pressed=1;
// dbg("spc_pressed=1\n");
if (has_wild) {
ggg.wild_page=0;
ggg.wild_mode=1;
wildcard();
return 1;
}
break;
case '?':
case '*':
if ((!gtab_que_wild_card && key == '?') || (!gtab_que_wild_card_asterisk && key == '*')) {
inkey=cur_inmd->keymap[key];
if ((inkey && (inkey!=cur_inmd->WILD_QUES && inkey!=cur_inmd->WILD_STAR)) || ptr_selkey(key))
goto next;
if (AUTO_SELECT_BY_PHRASE && ggg.gbufN) {
insert_gbuf_cursor_char(key);
return 1;
} else {
if (current_CS->b_half_full_char)
return full_char_proc(key);
else
return 0;
}
}
if (tss.pre_selN && shift_char_proc(key, kbstate))
return TRUE;
if (current_CS->b_half_full_char)
return full_char_proc(key);
inkey=cur_inmd->keymap[key];
if ((inkey && (inkey!=cur_inmd->WILD_STAR && inkey!=cur_inmd->WILD_QUES)) || ptr_selkey(key)) {
// dbg("%d %d\n", inkey, cur_inmd->WILD_STAR);
goto next;
}
if (ggg.ci< cur_inmd->MaxPress) {
ggg.inch[ggg.ci++]=inkey;
DispInArea();
if (hime_pop_up_win)
show_win_gtab();
ggg.total_matchN = 0;
ggg.wild_page=0;
ggg.wild_mode=1;
wildcard();
return 1;
}
return 0;
case XK_Left:
case XK_KP_Left:
return gbuf_cursor_left();
case XK_Right:
case XK_KP_Right:
return gbuf_cursor_right();
case XK_Home:
case XK_KP_Home:
return gbuf_cursor_home();
case XK_End:
case XK_KP_End:
return gbuf_cursor_end();
case XK_Delete:
case XK_KP_Delete:
return gtab_buf_delete();
case XK_Shift_L:
case XK_Shift_R:
case XK_Control_R:
case XK_Control_L:
case XK_Alt_L:
case XK_Alt_R:
case XK_Caps_Lock:
return 0;
case '`':
if (gtab_pho_query && !cur_inmd->keymap[key]) {
poo.same_pho_query_state = SAME_PHO_QUERY_gtab_input;
reset_gtab_all();
disp_gtab_sel(_("輸入要查的同音字，接著在注音視窗選字"));
if (hime_pop_up_win)
show_win_gtab();
disp_pho_sel("");
init_gtab_pho_query_win();
return 1;
}
default:
next:
if (key < 0x7f)
inkey= cur_inmd->keymap[key];
else
inkey = 0;
if (shift_m && !inkey && !tss.ctrl_pre_sel &&
tss.pre_selN && shift_char_proc(key, kbstate))
return TRUE;
clear_gtab_input_error_color();
if (ggg.invalid_spc && gtab_invalid_key_in) {
ClrIn();
}
if (key>=XK_KP_0 && key<=XK_KP_9) {
if (!ggg.ci) {
if (ggg.gbufN) {
insert_gbuf_cursor_char(key - XK_KP_0 + '0');
return 1;
} else
return 0;
}
if (is_dayi) {
key = key - XK_KP_0 + '0';
is_keypad = TRUE;
}
}
int keypad;
keypad_proc:
keypad = keypad_proc(key);
if (keypad) {
if (!ggg.ci) {
if (ggg.gbufN) {
insert_gbuf_cursor_char(keypad);
return 1;
} else
return 0;
}
}
char *pendkey = strchr(cur_inmd->endkey, key);
pselkey=ptr_selkey(key);
if (!pselkey && (key < 32 || key > 0x7e) && (gtab_full_space_auto_first || ggg.spc_pressed)) {
// dbg("%x %x ggg.sel1st_i:%d '%c'\n", pselkey, key, ggg.sel1st_i, seltab[ggg.sel1st_i][0]);
if (seltab[ggg.sel1st_i][0]) {
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
else
putstr_inp(seltab[ggg.sel1st_i]); /* select 1st */
}
return 0;
}
// dbg("ggg.spc_pressed %d %d %d is_keypad:%d\n", ggg.spc_pressed, ggg.last_full, cur_inmd->MaxPress, is_keypad);
#if 1 // for dayi, testcase : 6 space keypad6
int vv = pselkey - cur_inmd->selkey;
if (pselkey && tss.pre_selN && !ggg.gtab_buf_select && (tss.ctrl_pre_sel||
((!inkey||ggg.spc_pressed||is_keypad)&&! gtab_disp_partial_match_on() && !gtab_pre_select_on()))) {
if (gtab_pre_select_idx(vv))
return TRUE;
} else
if (( (ggg.spc_pressed||ggg.last_full||is_keypad) ||(ggg.wild_mode && (!inkey ||pendkey)) || ggg.gtab_buf_select) && pselkey) {
if ((_gtab_space_auto_first & GTAB_space_auto_first_any) && !ggg.wild_mode)
vv++;
if (vv<0)
vv=9;
if (seltab[vv][0]) {
if (AUTO_SELECT_BY_PHRASE && !same_query_show_pho_win()) {
if (ggg.gtab_buf_select && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
set_gbuf_c_sel(vv);
else
insert_gbuf_cursor1_cond(seltab[vv], ggg.kval, ggg.exa_match);
}
else {
putstr_inp(seltab[vv]);
}
if (hime_pop_up_win && !gtab_has_input())
hide_win_gtab();
return 1;
}
}
#endif
// dbg("iii %x sel1st_i:%d auto:%d\n", pselkey, ggg.sel1st_i, AUTO_SELECT_BY_PHRASE);
if (seltab[ggg.sel1st_i][0] && !ggg.wild_mode &&
(gtab_full_space_auto_first||ggg.spc_pressed||ggg.last_full) ) {
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
else
putstr_inp(seltab[ggg.sel1st_i]); /* select 1st */
}
#if 0
if (key > 0x7f) {
return 0;
}
#endif
ggg.spc_pressed=0;
// for cj & boshiamy to input digits
if (!ggg.ci && !inkey) {
if (current_CS->b_half_full_char)
return full_char_proc(key);
else {
if (ggg.gbufN && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input) {
insert_gbuf_cursor_char(key);
return 1;
}
else
return 0;
}
}
if (ggg.wild_mode && inkey>=1 && ggg.ci< cur_inmd->MaxPress) {
ggg.inch[ggg.ci++]=inkey;
if (hime_pop_up_win)
show_win_gtab();
proc_wild_disp();
return 1;
}
if (inkey>=1 && ggg.ci< cur_inmd->MaxPress) {
ggg.inch[ggg.ci++]=inkey;
hide_gtab_pre_sel();
if (hime_pop_up_win)
show_win_gtab();
ggg.last_full=0;
if (cur_inmd->use_quick && !pendkey) {
if (ggg.ci==1) {
int i;
for(i=0;i < cur_inmd->M_DUP_SEL; i++) {
utf8cpy(seltab[i], (char *)&cur_inmd->qkeys->quick1[inkey-1][i]);
}
ggg.defselN=cur_inmd->M_DUP_SEL;
DispInArea();
goto Disp_opt;
} else
if (ggg.ci==2 && !pselkey) {
int i;
for(i=0;i < cur_inmd->M_DUP_SEL; i++) {
utf8cpy(seltab[i], (char *)&cur_inmd->qkeys->quick2[ggg.inch[0]-1][inkey-1][i]);
}
ggg.defselN=cur_inmd->M_DUP_SEL;
DispInArea();
goto Disp_opt;
}
}
} else
if (ggg.ci == cur_inmd->MaxPress && !pselkey) {
bell();
return 1;
}
if (inkey) {
for(i=0; i < MAX_TAB_KEY_NUM64_6; i++)
if (ggg.inch[i]>=cur_inmd->WILD_QUES) {
DispInArea();
if (ggg.ci==cur_inmd->MaxPress) {
ggg.wild_mode=1;
ggg.wild_page=0;
wildcard();
}
return 1;
}
} else {
if (!pselkey) {
if (current_CS->b_half_full_char)
return full_char_proc(key);
else {
if (key>=' ' && key<0x7f && AUTO_SELECT_BY_PHRASE && ggg.gbufN)
insert_gbuf_cursor_char(key);
else
return 0;
}
}
if (ggg.defselN) {
goto YYYY;
}
}
} /* switch */
if (ggg.ci==0) {
ClrSelArea();
ClrIn();
return 1;
}
ggg.invalid_spc = FALSE;
char *pendkey = NULL;
pendkey = strchr(cur_inmd->endkey, key);
DispInArea();
ggg.kval=0;
for(i=0; i < Max_tab_key_num; i++) {
ggg.kval|= (u_int64_t)ggg.inch[i] << (KeyBits * (Max_tab_key_num - 1 - i));
}
#if 1
if (ggg.last_idx)
ggg.S1=ggg.last_idx;
else
#endif
ggg.S1=cur_inmd->idx1[ggg.inch[0]];
// dbg("--------- ch:%d %d val %llx ggg.S1:%d\n", ggg.inch[0], Max_tab_key_num, ggg.kval, ggg.S1);
int oE1;
oE1=cur_inmd->idx1[ggg.inch[0]+1];
if (cur_inmd->keybits==6)
vmaskci = cur_inmd->key64 ? vmask64[ggg.ci]:vmask[ggg.ci];
else
vmaskci = cur_inmd->key64 ? vmask64_7[ggg.ci]:vmask_7[ggg.ci];
gtab_scan_pre_select(TRUE);
while ((CONVT2(cur_inmd, ggg.S1) & vmaskci) != ggg.kval &&
CONVT2(cur_inmd, ggg.S1) < ggg.kval && ggg.S1<oE1)
ggg.S1++;
ggg.pg_idx=ggg.last_idx=ggg.S1;
#if 0
dbg("MaxPress:%d vmaskci:%llx kval:%llx ggg.ci:%d !=%d S1:%d kval:%x\n", cur_inmd->MaxPress,
vmaskci, ggg.kval, ggg.ci,
((CONVT2(cur_inmd, ggg.S1) & vmaskci)!=ggg.kval), ggg.S1);
#endif
if ((CONVT2(cur_inmd, ggg.S1) & vmaskci)!=ggg.kval || (ggg.wild_mode && ggg.defselN) ||
((/* ggg.ci==cur_inmd->MaxPress|| */ ggg.spc_pressed) && ggg.defselN &&
(pselkey && ( pendkey || ggg.spc_pressed)) ) ) {
YYYY:
if ((pselkey || ggg.wild_mode) && ggg.defselN) {
int vv = pselkey - cur_inmd->selkey;
if ((_gtab_space_auto_first & GTAB_space_auto_first_any) && !ggg.wild_mode
&& ggg.exa_match && (!cur_inmd->use_quick || ggg.ci!=2))
vv++;
if (vv<0)
vv=9;
if (seltab[vv][0]) {
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
insert_gbuf_cursor1_cond(seltab[vv], ggg.kval, ggg.exa_match);
else
putstr_inp(seltab[vv]);
return 1;
}
}
if (pselkey && !ggg.defselN)
return 0;
if (gtab_invalid_key_in) {
if (ggg.spc_pressed) {
bell_err();
ggg.invalid_spc = TRUE;
// dbg("ggg.invalid_spc\n");
} else {
seltab[0][0]=0;
ClrSelArea();
}
} else {
if (gtab_dup_select_bell)
bell();
if (ggg.ci>0)
ggg.inch[--ggg.ci]=0;
}
ggg.last_idx=0;
DispInArea();
return 1;
}
//refill:
j=ggg.S1;
while(CONVT2(cur_inmd, j)==ggg.kval && j<oE1)
j++;
ggg.E1 = j;
ggg.total_matchN = ggg.E1 - ggg.S1;
ggg.pg_idx = ggg.S1;
ggg.more_pg = 0;
if (ggg.total_matchN > page_len()) {
if ((_gtab_space_auto_first & GTAB_space_auto_first_any) || ggg.spc_pressed || pendkey ||
(ggg.ci==cur_inmd->MaxPress && (_gtab_space_auto_first & GTAB_space_auto_first_full)))
ggg.more_pg = 1;
}
if (ggg.ci < cur_inmd->MaxPress && !ggg.spc_pressed && !pendkey && !ggg.more_pg) {
j = ggg.S1;
ggg.exa_match=0;
clr_seltab();
int match_cnt=0;
while (CONVT2(cur_inmd, j)==ggg.kval && ggg.exa_match <= page_len()) {
seltab_phrase[ggg.exa_match] = load_seltab(j, ggg.exa_match);
match_cnt++;
ggg.exa_match++;
j++;
}
ggg.defselN=ggg.exa_match;
// dbg("--- ggg.exa_match %d\n", ggg.exa_match);
if (ggg.defselN > page_len())
ggg.defselN--;
int shiftb=(KEY_N - 1 -ggg.ci) * KeyBits;
// if (gtab_disp_partial_match_on)
while((CONVT2(cur_inmd, j) & vmaskci)==ggg.kval && j<oE1) {
int fff=cur_inmd->keycol[(CONVT2(cur_inmd, j)>>shiftb) & cur_inmd->kmask];
u_char *tbl_ch = tblch(j);
if (gtab_disp_partial_match_on() && (!seltab[fff][0] || seltab_phrase[fff] ||
(bchcmp(seltab[fff], tbl_ch)>0 && fff > ggg.exa_match))) {
seltab_phrase[fff] = load_seltab(j, fff);
ggg.defselN++;
}
match_cnt++;
#if 0
dbg("jj %d", fff); utf8_putchar(seltab[fff]); dbg("\n");
#endif
j++;
}
if (gtab_unique_auto_send_on()) {
char *first_str=NULL;
for(i=0; i < page_len(); i++) {
if (!seltab[i][0])
continue;
if (!first_str)
first_str = seltab[i];
}
if (match_cnt==1 && first_str) {
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
insert_gbuf_nokey(first_str);
else
putstr_inp(first_str);
return 1;
}
}
} else {
int main(int argc, char **argv)
{
gtk_init(&argc, &argv);
#if 1
if (argc != 3)
p_err("%s a_file.gtab outfile", argv[0]);
#endif
#if 1
char *infile = argv[1];
char *outfile = argv[2];
#else
char *infile = "data/ar30.gtab";
char *outfile = "l";
#endif
FILE *fr;
if ((fr=fopen(infile, "rb"))==NULL)
p_err("cannot err open %s", infile);
FILE *fp_out;
if ((fp_out=fopen(outfile,"w"))==NULL) {
printf("Cannot open %s", outfile);
exit(-1);
}
struct TableHead th;
fread(&th,1, sizeof(th), fr);
#if NEED_SWAP
swap_byte_4(&th.version);
swap_byte_4(&th.flag);
swap_byte_4(&th.space_style);
swap_byte_4(&th.KeyS);
swap_byte_4(&th.MaxPress);
swap_byte_4(&th.M_DUP_SEL);
swap_byte_4(&th.DefC);
for(i=0; i <= KeyNum; i++)
swap_byte_4(&idx1[i]);
#endif
int KeyNum = th.KeyS;
dbg("keys %d\n",KeyNum);
if (!th.keybits)
th.keybits = 6;
dbg("keybits:%d maxPress:%d\n", th.keybits, th.MaxPress);
int max_keyN;
if (th.MaxPress*th.keybits > 32) {
max_keyN = 64 / th.keybits;
key64 = TRUE;
dbg("it's a 64-bit .gtab\n");
} else {
max_keyN = 32 / th.keybits;
key64 = FALSE;
}
dbg("key64:%d\n", key64);
char kname[128][CH_SZ];
char keymap[128];
gtab_idx1_t idx1[256];
static char kno[128];
itN = th.DefC;
bzero(keymap, sizeof(keymap));
fread(keymap, 1, th.KeyS, fr);
fread(kname, CH_SZ, th.KeyS, fr);
fread(idx1, sizeof(gtab_idx1_t), KeyNum+1, fr);
int i;
for(i=0; i < th.KeyS; i++) {
kno[keymap[i]] = i;
}
fprintf(fp_out,TSIN_GTAB_KEY" %d %d %s\n", th.keybits, th.MaxPress, keymap+1);
if (key64) {
fread(it64, sizeof(ITEM64), th.DefC, fr);
qsort(it64, th.DefC, sizeof(ITEM64), qcmp_ch64);
}
else {
fread(it, sizeof(ITEM), th.DefC, fr);
qsort(it, th.DefC, sizeof(ITEM), qcmp_ch);
}
itN = th.DefC;
// dbg("itN:%d\n", itN);
#if 0
for(i=0; i < itN; i++) {
printf("\n%d ", i);
utf8_putchar(it64[i].ch);
}
#endif
fclose(fr);
char fname[128];
get_gcin_user_fname(tsin32_f, fname);
FILE *fp;
if ((fp=fopen(fname,"rb"))==NULL) {
printf("Cannot open %s", fname);
exit(-1);
}
while (!feof(fp)) {
int i;
phokey_t phbuf[MAX_PHRASE_LEN];
u_char clen;
usecount_t usecount;
fread(&clen,1,1,fp);
fread(&usecount, sizeof(usecount_t), 1,fp);
fread(phbuf,sizeof(phokey_t), clen, fp);
char str[MAX_PHRASE_LEN * CH_SZ + 1];
int strN = 0;
KKARR kk[MAX_PHRASE_LEN];
KKARR64 kk64[MAX_PHRASE_LEN];
gboolean has_err = FALSE;
if (key64)
bzero(kk64, sizeof(kk64));
else
bzero(kk, sizeof(kk));
// dbg("clen %d\n", clen);
for(i=0;i<clen;i++) {
char ch[CH_SZ];
int n = fread(ch, 1, 1, fp);
if (n<=0)
goto stop;
int len=utf8_sz(ch);
fread(&ch[1], 1, len-1, fp);
// utf8_putchar(ch);
if (key64) {
if (!(kk64[i].arr = find_ch64(ch, &kk64[i].N)))
has_err = TRUE;
} else {
if (!(kk[i].arr = find_ch(ch, &kk[i].N)))
has_err = TRUE;
}
memcpy(str+strN, ch, len);
strN+=len;
}
if (has_err) {
// dbg("has_error\n");
continue;
}
#if 0
for(i=0; i < clen; i++)
printf("%d ", kk64[i].N);
printf("\n");
#endif
str[strN]=0;
int permN;
if (key64) {
permN=kk64[0].N;
for(i=1;i<clen;i++)
permN *= kk64[i].N;
}
else {
permN=kk[0].N;
for(i=1;i<clen;i++)
permN *= kk[i].N;
}
int z;
for(z=0; z < permN; z++) {
char vz[MAX_PHRASE_LEN];
int tz = z;
if (key64) {
for(i=0; i < clen; i++) {
vz[i] = tz % kk64[i].N;
tz /= kk64[i].N;
}
} else {
for(i=0; i < clen; i++) {
vz[i] = tz % kk[i].N;
tz /= kk[i].N;
}
}
char kstr[512];
kstr[0]=0;
for(i=0;i<clen;i++) {
char tkey[16];
u_int64_t k=0;
if (key64) {
memcpy(&k, kk64[i].arr[vz[i]].key, 8);
} else {
u_int t;
memcpy(&t, kk[i].arr[vz[i]].key, 4);
k = t;
}
get_keymap_str(k, keymap, th.keybits, tkey);
strcat(kstr, tkey);
strcat(kstr, " ");
}
fprintf(fp_out,"%s %s%d\n", str, kstr, usecount);
}
}
stop:
fclose(fp);
fclose(fp_out);
return 0;
}
int main(int argc, char **argv)
{
char *fname = "pho.tab2.src";
FILE *fp;
char s[64];
int phrase_area_N=0;
char *phrase_area = NULL;
if (!getenv("NO_GTK_INIT"))
gtk_init(&argc, &argv);
if (argc > 1)
fname = argv[1];
if ((fp=fopen(fname,"rb"))==NULL)
p_err("cannot open %s\n", fname);
while (!feof(fp)) {
s[0]=0;
myfgets(s,sizeof(s),fp);
int len=strlen(s);
if (s[len-1]=='\n')
s[--len]=0;
if (len==0)
continue;
phokey_t kk=0;
char *p = s;
while (*p && *p!=' ' && *p!=9) {
if (kk==(BACK_QUOTE_NO << 9))
kk|=*p;
else
kk |= lookup((u_char *)p);
p += utf8_sz(p);
}
items[itemsN].key = kk;
p++;
char *str = p;
while (*p && *p != ' ' && *p!=9)
p++;
*p = 0;
p++;
int slen = strlen(str);
if (slen==utf8_sz(str)) {
u8cpy((char *)items[itemsN].ch, str);
} else {
dbg("str %s\n", str);
int newN = phrase_area_N + slen + 1;
phrase_area = trealloc(phrase_area, char, newN);
strcpy(phrase_area + phrase_area_N, str);
items[itemsN].ch[0] = PHO_PHRASE_ESCAPE;
items[itemsN].ch[1] = phrase_area_N & 0xff;
items[itemsN].ch[2] = (phrase_area_N>>8) & 0xff;
items[itemsN].ch[3] = (phrase_area_N>>16) & 0xff;
phrase_area_N = newN;
}
items[itemsN].count = atoi(p);
items[itemsN].oseq = itemsN;
itemsN++;
}
fclose(fp);
qsort(items, itemsN, sizeof(PHITEM), qcmp_key_del);
int i;
#if 1
int newN = 1;
for(i=1;i<itemsN;i++)
if (qcmp_key_del(&items[i-1], &items[i]))
items[newN++] = items[i];
else {
#if 0
prph(items[i].key);
utf8_putchar((char *)items[i].ch);
dbg("\n");
#endif
}
if (itemsN != newN) {
dbg("deleted %d %d\n",itemsN, newN);
itemsN = newN;
}
#endif
qsort(items, itemsN, sizeof(PHITEM), qcmp_key);
PHO_IDX pho_idx[3000];
u_short pho_idxN=0;
for(i=0; i < itemsN; ) {
phokey_t key = items[i].key;
pho_idx[pho_idxN].key = key;
pho_idx[pho_idxN].start = i;
pho_idxN++;
int j;
for (j=i+1; j < itemsN && items[j].key == key; j++);
int l;
for(l=i; l<j; l++) {
bchcpy(pho_items[pho_itemsN].ch, items[l].ch);
pho_items[pho_itemsN].count = items[l].count;
pho_itemsN++;
}
i = j;
}
char *tp = strstr(fname, ".tab2.src");
if (!tp)
p_err("file name should be *.tab2.src");
tp = strstr(fname, ".src");
*tp=0;
char *fname_out = fname;
if ((fp=fopen(fname_out,"wb"))==NULL)
p_err("cannot create %s\n", fname_out);
fwrite("PH",1,2,fp);
// dbg("pho_itemsN:%d pho_idxN:%d\n", pho_itemsN, pho_idxN);
fwrite(&pho_idxN, sizeof(u_short), 1, fp);
fwrite(&pho_itemsN, sizeof(pho_itemsN), 1, fp);
fwrite(&phrase_area_N, sizeof(phrase_area_N), 1, fp);
#if 0
fclose(fp); exit(0);
#endif
fwrite(pho_idx, sizeof(PHO_IDX), pho_idxN, fp);
fwrite(pho_items, sizeof(PHO_ITEM), pho_itemsN, fp);
fwrite(phrase_area, 1, phrase_area_N, fp);
fclose(fp);
if (getenv("HIME_NO_RELOAD")==NULL) {
/* caleb- does found where "reload" is used.
* caleb- think the send_hime_message() here does nothing.
*/
send_hime_message(GDK_DISPLAY(), "reload");
}
return 0;
}