← Back to branch summary

~ubuntu-branches/ubuntu/lucid/libchewing/lucid

« back to all changes in this revision

Viewing changes to src/chewingutil.c

  • Committer: Bazaar Package Importer
  • Author(s): Kanru Chen
  • Date: 2008-12-04 15:34:03 UTC
  • mfrom: (1.1.4 upstream) (2.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20081204153403-l9cksddl1k2e71zy
Tags: 0.3.2-1
* New Upstream Version 
* [5d96bf5] Update watch address
* [351d417] Add Vcs-Git field
* [63cd26a] Add Vcs-Browser field
* [e2a59e2] Conflict with scim-chewing << 0.3.3
* [cd15be8] Change libchewing3-data from all to any since we build
  binary data now.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/chewingutil.c
5
5
 *      Lu-chuan Kung and Kang-pen Chen.
6
6
 *      All rights reserved.
7
7
 *
8
 
 * Copyright (c) 2004, 2005, 2006
 
8
 * Copyright (c) 2004, 2005, 2006, 2008
9
9
 *      libchewing Core Team. See ChangeLog for details.
10
10
 *
11
11
 * See the file "COPYING" for information on usage and redistribution
17
17
#include <ctype.h>
18
18
#include <string.h>
19
19
#include <stdio.h>
 
20
#include <assert.h>
 
21
#include <stdlib.h>
20
22
 
21
23
#include "chewing-utf8-util.h"
22
24
#include "global.h"
 
25
#include "global-private.h"
23
26
#include "chewingutil.h"
24
 
#include "zuin.h"
25
 
#include "userphrase.h"
 
27
#include "zuin-private.h"
 
28
#include "choice-private.h"
 
29
#include "tree-private.h"
 
30
#include "userphrase-private.h"
26
31
#include "private.h"
27
32
 
28
33
extern const char *zhuin_tab[]; 
29
34
static void MakePreferInterval( ChewingData *pgdata );
30
35
static void ShiftInterval( ChewingOutput *pgo, ChewingData *pgdata );
 
36
static int ChewingKillSelectIntervalAcross( int cursor, ChewingData *pgdata );
31
37
 
 
38
static int FindSymbolKey( const char *symbol );
32
39
static SymbolEntry** symbol_table = NULL;
33
 
static int n_symbol_entry = 0;
 
40
static unsigned int n_symbol_entry = 0;
34
41
 
35
42
static char g_easy_symbol_key[] = {
36
43
        '0','1','2','3','4','5','6','7','8','9',
67
74
 
68
75
void SetUpdatePhraseMsg( ChewingData *pgdata, char *addWordSeq, int len, int state )
69
76
{
70
 
        char *insert = "加入：", *modify = "已有：";
 
77
        char *insert = "\xE5\x8A\xA0\xE5\x85\xA5\xEF\xBC\x9A";
 
78
                /* 加入： */
 
79
        char *modify = "\xE5\xB7\xB2\xE6\x9C\x89\xEF\xBC\x9A";
 
80
                /* 已有： */
71
81
        int begin = 3, i;
72
82
 
73
83
        pgdata->showMsgLen = begin + len;
128
138
int HaninSymbolInput(
129
139
                ChoiceInfo *pci, 
130
140
                AvailInfo *pai, 
131
 
                const uint16 phoneSeq[],
 
141
                const uint16 phoneSeq[] UNUSED, 
132
142
                int candPerPage)
133
143
{
134
 
        int i;
 
144
        unsigned int i;
135
145
 
136
146
        /* No available symbol table */
137
147
        if ( ! symbol_table )
172
182
                        sizeof( wch_t ) * ( pgdata->chiSymbolBufLen - pgdata->chiSymbolCursor ) );
173
183
 
174
184
                pgdata->chiSymbolBuf[ pgdata->chiSymbolCursor ].wch = (wchar_t) 0;
175
 
                ueStrNCpy( pgdata->chiSymbolBuf[ pgdata->chiSymbolCursor ].s,
 
185
                ueStrNCpy( (char *) pgdata->chiSymbolBuf[ pgdata->chiSymbolCursor ].s,
176
186
                                chibuf, 1, 1);
177
187
                /* Save Symbol Key */
178
188
                memmove( 
181
191
                        sizeof( pgdata->symbolKeyBuf[0] ) * 
182
192
                        ( pgdata->chiSymbolBufLen - pgdata->chiSymbolCursor ) );
183
193
                pgdata->symbolKeyBuf[ pgdata->chiSymbolCursor ] = key;
 
194
                pgdata->bUserArrCnnct[ PhoneSeqCursor( pgdata ) ] = 0;
184
195
                pgdata->chiSymbolCursor++;
185
196
                pgdata->chiSymbolBufLen++;
186
 
                pgdata->bUserArrCnnct[ pgdata->cursor ] = 0;
187
197
                /* reset Zuin data */
188
198
                /* Don't forget the kbtype */
189
199
                kbtype = pgdata->zuinData.kbtype;
219
229
        };
220
230
 
221
231
        static char *chibuf[] = {
222
 
                "「", "」", "『", "』", "、", "，", "：", "；", "。",
223
 
                "～", "！", "＠", "＃", "＄", "％", "︿", "＆", "＊",
224
 
                "（", "）", "﹍", "＋", "＝", "＼", "｜", "？",
225
 
                "，", "。", "；"
 
232
                "\xE3\x80\x8C", "\xE3\x80\x8D", "\xE3\x80\x8E", "\xE3\x80\x8F",
 
233
                        /* "「", "」", "『", "』" */
 
234
                "\xE3\x80\x81", "\xEF\xBC\x8C", "\xEF\xBC\x9A", "\xEF\xBC\x9B",
 
235
                        /* "、", "，", "：", "；" */
 
236
                "\xE3\x80\x82", "\xEF\xBD\x9E", "\xEF\xBC\x81", "\xEF\xBC\xA0",
 
237
                        /* "。", "～", "！", "＠" */
 
238
                "\xEF\xBC\x83", "\xEF\xBC\x84", "\xEF\xBC\x85", "\xEF\xB8\xBF",
 
239
                        /* "＃", "＄", "％", "︿" */
 
240
                "\xEF\xBC\x86", "\xEF\xBC\x8A", "\xEF\xBC\x88", "\xEF\xBC\x89",
 
241
                        /* "＆", "＊", "（", "）" */
 
242
                "\xEF\xB9\x8D", "\xEF\xBC\x8B", "\xEF\xBC\x9D", "\xEF\xBC\xBC",
 
243
                        /* "﹍", "＋", "＝", "＼" */
 
244
                "\xEF\xBD\x9C", "\xEF\xBC\x9F", "\xEF\xBC\x8C", "\xE3\x80\x82",
 
245
                        /* "｜", "？", "，", "。" */
 
246
                "\xEF\xBC\x9B"
 
247
                        /* "；" */
226
248
        };
227
249
        static int nSpecial = 29;
228
250
        return InternalSpecialSymbol( key, pgdata, nSpecial, keybuf, chibuf );
242
264
                ']','{','}','+','-'
243
265
        };
244
266
        static char* chibuf[] = {
245
 
                "０","１","２","３","４","５","６","７","８","９",
246
 
                "ａ","ｂ","ｃ","ｄ","ｅ","ｆ","ｇ","ｈ","ｉ","ｊ",
247
 
                "ｋ","ｌ","ｍ","ｎ","ｏ","ｐ","ｑ","ｒ","ｓ","ｔ",
248
 
                "ｕ","ｖ","ｗ","ｘ","ｙ","ｚ","Ａ","Ｂ","Ｃ","Ｄ",
249
 
                "Ｅ","Ｆ","Ｇ","Ｈ","Ｉ","Ｊ","Ｋ","Ｌ","Ｍ","Ｎ",
250
 
                "Ｏ","Ｐ","Ｑ","Ｒ","Ｓ","Ｔ","Ｕ","Ｖ","Ｗ","Ｘ",
251
 
                "Ｙ","Ｚ","　","”","’","／","＜","＞","‵","〔",
252
 
                "〕","｛","｝","＋","－"
 
267
                "\xEF\xBC\x90","\xEF\xBC\x91","\xEF\xBC\x92","\xEF\xBC\x93",
 
268
                        /* "０","１","２","３" */
 
269
                "\xEF\xBC\x94","\xEF\xBC\x95","\xEF\xBC\x96","\xEF\xBC\x97",
 
270
                        /* "４","５","６","７" */
 
271
                "\xEF\xBC\x98","\xEF\xBC\x99","\xEF\xBD\x81","\xEF\xBD\x82",
 
272
                        /* "８","９","ａ","ｂ" */
 
273
                "\xEF\xBD\x83","\xEF\xBD\x84","\xEF\xBD\x85","\xEF\xBD\x86",
 
274
                        /* "ｃ","ｄ","ｅ","ｆ" */
 
275
                "\xEF\xBD\x87","\xEF\xBD\x88","\xEF\xBD\x89","\xEF\xBD\x8A",
 
276
                        /* "ｇ","ｈ","ｉ","ｊ" */
 
277
                "\xEF\xBD\x8B","\xEF\xBD\x8C","\xEF\xBD\x8D","\xEF\xBD\x8E",
 
278
                        /* "ｋ","ｌ","ｍ","ｎ" */
 
279
                "\xEF\xBD\x8F","\xEF\xBD\x90","\xEF\xBD\x91","\xEF\xBD\x92",
 
280
                        /* "ｏ","ｐ","ｑ","ｒ" */
 
281
                "\xEF\xBD\x93","\xEF\xBD\x94","\xEF\xBD\x95","\xEF\xBD\x96",
 
282
                        /* "ｓ","ｔ","ｕ","ｖ" */
 
283
                "\xEF\xBD\x97","\xEF\xBD\x98","\xEF\xBD\x99","\xEF\xBD\x9A",
 
284
                        /* "ｗ","ｘ","ｙ","ｚ" */
 
285
                "\xEF\xBC\xA1","\xEF\xBC\xA2","\xEF\xBC\xA3","\xEF\xBC\xA4",
 
286
                        /* "Ａ","Ｂ","Ｃ","Ｄ" */
 
287
                "\xEF\xBC\xA5","\xEF\xBC\xA6","\xEF\xBC\xA7","\xEF\xBC\xA8",
 
288
                        /* "Ｅ","Ｆ","Ｇ","Ｈ" */
 
289
                "\xEF\xBC\xA9","\xEF\xBC\xAA","\xEF\xBC\xAB","\xEF\xBC\xAC",
 
290
                        /* "Ｉ","Ｊ","Ｋ","Ｌ" */
 
291
                "\xEF\xBC\xAD","\xEF\xBC\xAE","\xEF\xBC\xAF","\xEF\xBC\xB0",
 
292
                        /* "Ｍ","Ｎ","Ｏ","Ｐ" */
 
293
                "\xEF\xBC\xB1","\xEF\xBC\xB2","\xEF\xBC\xB3","\xEF\xBC\xB4",
 
294
                        /* "Ｑ","Ｒ","Ｓ","Ｔ" */
 
295
                "\xEF\xBC\xB5","\xEF\xBC\xB6","\xEF\xBC\xB7","\xEF\xBC\xB8",
 
296
                        /* "Ｕ","Ｖ","Ｗ","Ｘ" */
 
297
                "\xEF\xBC\xB9","\xEF\xBC\xBA","\xE3\x80\x80","\xE2\x80\x9D",
 
298
                        /* "Ｙ","Ｚ","　","”" */
 
299
                "\xE2\x80\x99","\xEF\xBC\x8F","\xEF\xBC\x9C","\xEF\xBC\x9E",
 
300
                        /* "’","／","＜","＞" */
 
301
                "\xE2\x80\xB5","\xE3\x80\x94","\xE3\x80\x95","\xEF\xBD\x9B",
 
302
                        /* "‵","〔""〕","｛" */
 
303
                "\xEF\xBD\x9D","\xEF\xBC\x8B","\xEF\xBC\x8D"
 
304
                        /* "｝","＋","－" */
253
305
        };
254
306
        static int nSpecial = sizeof(keybuf) / sizeof(char);
255
307
        rtn = InternalSpecialSymbol( key, pgdata, nSpecial, keybuf, chibuf );
258
310
        return (rtn == ZUIN_IGNORE ? SYMBOL_KEY_ERROR : SYMBOL_KEY_OK);
259
311
}
260
312
 
261
 
int EasySymbolInput( int key, ChewingData *pgdata, ChewingOutput *pgo )
 
313
int EasySymbolInput( int key, ChewingData *pgdata, ChewingOutput *pgo UNUSED )
262
314
{
263
315
        int rtn, loop, index;
264
316
        char wordbuf[ 8 ];
293
345
        };
294
346
 
295
347
        static char *chibuf[] = {
296
 
                "┌","┬","┐","□","〈","〉", "…","、","。","※",
297
 
                "├","┼","┤","【","】","◇","○", "—", "│", "；","：",
298
 
                "└","┴","┘", "ˇ", "《", "》" ,"─", "，","．","？"
 
348
                "\xE2\x94\x8C","\xE2\x94\xAC","\xE2\x94\x90","\xE2\x96\xA1","\xE3\x80\x88",
 
349
                "\xE3\x80\x89","\xE2\x80\xA6","\xE3\x80\x81","\xE3\x80\x82","\xE2\x80\xBB",
 
350
                "\xE2\x94\x9C","\xE2\x94\xBC","\xE2\x94\xA4","\xE3\x80\x90","\xE3\x80\x91",
 
351
                "\xE2\x97\x87","\xE2\x97\x8B","\xE2\x80\x94","\xE2\x94\x82","\xEF\xBC\x9B",
 
352
                "\xEF\xBC\x9A","\xE2\x94\x94","\xE2\x94\xB4","\xE2\x94\x98", "\xCB\x87",
 
353
                "\xE3\x80\x8A", "\xE3\x80\x8B" ,"\xE2\x94\x80", "\xEF\xBC\x8C","\xEF\xBC\x8E",
 
354
                "\xEF\xBC\x9F"
299
355
        };
300
356
        static int nSpecial = 31;
301
357
        return InternalSpecialSymbol( key, pgdata, nSpecial, keybuf, chibuf );
350
406
                                sizeof( wch_t ) * ( pgdata->chiSymbolBufLen - pgdata->chiSymbolCursor ) );
351
407
                }
352
408
                pgdata->chiSymbolBuf[ pgdata->chiSymbolCursor ].wch = (wchar_t) 0 ;
353
 
                ueStrNCpy( pgdata->chiSymbolBuf[ pgdata->chiSymbolCursor ].s,
 
409
                ueStrNCpy( (char *) pgdata->chiSymbolBuf[ pgdata->chiSymbolCursor ].s,
354
410
                                pgdata->choiceInfo.totalChoiceStr[ sel_i ], 1, 1);
355
411
 
356
412
                /* This is very strange */
357
413
                key = FindSymbolKey( pgdata->choiceInfo.totalChoiceStr[ sel_i ] );
358
414
                pgdata->symbolKeyBuf[ pgdata->chiSymbolCursor ] = key ? key : '1';
359
415
 
360
 
                pgdata->bUserArrCnnct[ pgdata->cursor ] = 0;
 
416
                pgdata->bUserArrCnnct[ PhoneSeqCursor( pgdata ) ] = 0;
361
417
                ChoiceEndChoice(pgdata);
362
418
                /* Don't forget the kbtype */
363
419
                kbtype = pgdata->zuinData.kbtype;
367
423
                if ( symbol_type == 2 ) {
368
424
                        pgdata->chiSymbolBufLen++;
369
425
                        pgdata->chiSymbolCursor ++ ; 
370
 
                        if ( ! pgdata->bAutoShiftCur ) {
 
426
                        if ( ! pgdata->config.bAutoShiftCur ) {
371
427
                                /* No action */
372
428
                        }
373
429
                }
398
454
                        ( pgdata->chiSymbolBufLen - pgdata->chiSymbolCursor ) );
399
455
                        pgdata->symbolKeyBuf[ pgdata->chiSymbolCursor ] = toupper( key );
400
456
 
 
457
                pgdata->bUserArrCnnct[ PhoneSeqCursor( pgdata ) ] = 0;
401
458
                pgdata->chiSymbolCursor++;
402
459
                pgdata->chiSymbolBufLen++;
403
 
                pgdata->bUserArrCnnct[ pgdata->cursor ] = 0;
404
460
                return SYMBOL_KEY_OK;
405
461
        }
406
462
        return SYMBOL_KEY_ERROR;
451
507
        int remain, i;
452
508
 
453
509
        /* reserve ZUIN_SIZE positions for Zuin */
454
 
        remain = pgdata->chiSymbolBufLen + ZUIN_SIZE - pgdata->config.maxChiSymbolLen;
455
 
        if ( remain <= 0 )
 
510
        remain = pgdata->config.maxChiSymbolLen - (pgdata->chiSymbolBufLen + ZUIN_SIZE);
 
511
        if ( remain > 0 )
456
512
                return 0;
457
513
 
458
514
        qsort(
483
539
        int i;
484
540
 
485
541
        for ( i = 0; i < nKill; i++ )
486
 
                ChewingKillChar( pgdata, 0, 0, DECREASE_CURSOR );
 
542
                ChewingKillChar( pgdata, 0, DECREASE_CURSOR );
487
543
}
488
544
 
489
545
void CleanAllBuf( ChewingData *pgdata )
499
555
        /* 4 */
500
556
        pgdata->nSelect = 0;
501
557
        /* 5 */
502
 
        pgdata->cursor = 0;
 
558
        pgdata->chiSymbolCursor = 0;
503
559
        /* 6 */
504
 
        pgdata->chiSymbolCursor = 0;
505
 
        /* 7 */
506
560
        memset( pgdata->bUserArrCnnct, 0, sizeof( pgdata->bUserArrCnnct ) );
507
561
 
508
562
        pgdata->phrOut.nNumCut = 0;
516
570
{
517
571
        int throwEnd;
518
572
        uint16 bufPhoneSeq[ MAX_PHONE_SEQ_LEN + 1 ];
519
 
        char bufWordSeq[ MAX_PHONE_SEQ_LEN * 3 + 1 ];
 
573
        char bufWordSeq[ MAX_PHONE_SEQ_LEN * MAX_UTF8_SIZE + 1 ];
520
574
 
521
575
        throwEnd = CountReleaseNum( pgdata );
522
576
 
539
593
        return throwEnd;
540
594
}
541
595
 
 
596
static int ChewingIsBreakPoint( int cursor, ChewingData *pgdata )
 
597
{
 
598
        static char *break_word[] = {
 
599
                "\xE6\x98\xAF", "\xE7\x9A\x84", "\xE4\xBA\x86", "\xE4\xB8\x8D",
 
600
                /* 是              的              了              不 */
 
601
                "\xE4\xB9\x9F", "\xE8\x80\x8C", "\xE4\xBD\xA0", "\xE6\x88\x91",
 
602
                /* 也              而              你              我 */
 
603
                "\xE4\xBB\x96", "\xE8\x88\x87", "\xE5\xAE\x83", "\xE5\xA5\xB9",
 
604
                /* 他              與              它              她 */
 
605
                "\xE5\x85\xB6", "\xE5\xB0\xB1", "\xE5\x92\x8C", "\xE6\x88\x96",
 
606
                /* 其              就              和              或 */
 
607
                "\xE5\x80\x91", "\xE6\x80\xA7", "\xE5\x93\xA1", "\xE5\xAD\x90",
 
608
                /* 們              性              員              子 */
 
609
                "\xE4\xB8\x8A", "\xE4\xB8\x8B", "\xE4\xB8\xAD", "\xE5\x85\xA7",
 
610
                /* 上              下              中              內 */
 
611
                "\xE5\xA4\x96", "\xE5\x8C\x96", "\xE8\x80\x85", "\xE5\xAE\xB6",
 
612
                /* 外              化              者              家 */
 
613
                "\xE5\x85\x92", "\xE5\xB9\xB4", "\xE6\x9C\x88", "\xE6\x97\xA5",
 
614
                /* 兒              年              月              日 */
 
615
                "\xE6\x99\x82", "\xE5\x88\x86", "\xE7\xA7\x92", "\xE8\xA1\x97",
 
616
                /* 時              分              秒              街 */
 
617
                "\xE8\xB7\xAF", "\xE6\x9D\x91",
 
618
                /* 路              村 */
 
619
                "\xE5\x9C\xA8",
 
620
                /* 在 */
 
621
        };
 
622
        char buf[ MAX_UTF8_SIZE + 1 ];
 
623
        int i = 0, symbols = 0;
 
624
        for ( i = 0; i < cursor; i++ )
 
625
                if ( ! ChewingIsChiAt ( i + symbols, pgdata ) )
 
626
                        symbols++;
 
627
        if ( ! ChewingIsChiAt( i + symbols, pgdata ) )
 
628
                return 1;
 
629
        else {
 
630
                ueStrNCpy( buf,
 
631
                                ueStrSeek( (char *) &pgdata->phrOut.chiBuf, cursor ),
 
632
                                1, 1 );
 
633
                for ( i = 0; i < sizeof(break_word) / sizeof(break_word[0]); i++ ) {
 
634
                        if ( ! strcmp ( buf, break_word[ i ] ) )
 
635
                                return 1;
 
636
                }
 
637
        }
 
638
        return 0;
 
639
}
 
640
 
542
641
void AutoLearnPhrase( ChewingData *pgdata )
543
642
{
544
643
        uint16 bufPhoneSeq[ MAX_PHONE_SEQ_LEN + 1 ];
545
 
        char bufWordSeq[ MAX_PHONE_SEQ_LEN * 3 + 1 ];
 
644
        char bufWordSeq[ MAX_PHONE_SEQ_LEN * MAX_UTF8_SIZE + 1 ];
546
645
        int i, from, len;
 
646
        int prev_pos = 0;
 
647
        int pending = 0;
547
648
 
548
649
        for ( i = 0; i < pgdata->nPrefer; i++ ) {
549
650
                from = pgdata->preferInterval[ i ].from;
550
651
                len = pgdata->preferInterval[i].to - from;
551
 
                memcpy( bufPhoneSeq, &pgdata->phoneSeq[ from ], sizeof( uint16 ) * len );
552
 
                bufPhoneSeq[ len ] = (uint16) 0;
553
 
                ueStrNCpy( bufWordSeq,
554
 
                           ueStrSeek( (char *) &pgdata->phrOut.chiBuf, from ),
555
 
                           len, 1);
 
652
                if ( len == 1 && ! ChewingIsBreakPoint( from, pgdata ) ) {
 
653
                        memcpy( bufPhoneSeq + prev_pos, &pgdata->phoneSeq[ from ], sizeof( uint16 ) * len );
 
654
                        bufPhoneSeq[ prev_pos + len ] = (uint16) 0;
 
655
                        ueStrNCpy( ueStrSeek( bufWordSeq, prev_pos ),
 
656
                                        ueStrSeek( (char *) &pgdata->phrOut.chiBuf, from ),
 
657
                                        len, 1);
 
658
                        prev_pos += len;
 
659
                        pending = 1;
 
660
                }
 
661
                else {
 
662
                        if ( pending ) {
 
663
                                UserUpdatePhrase( bufPhoneSeq, bufWordSeq );
 
664
                                prev_pos = 0;
 
665
                                pending = 0;
 
666
                        }
 
667
                        memcpy( bufPhoneSeq, &pgdata->phoneSeq[ from ], sizeof( uint16 ) * len );
 
668
                        bufPhoneSeq[ len ] = (uint16) 0;
 
669
                        ueStrNCpy( bufWordSeq,
 
670
                                        ueStrSeek( (char *) &pgdata->phrOut.chiBuf, from ),
 
671
                                        len, 1);
 
672
                        UserUpdatePhrase( bufPhoneSeq, bufWordSeq );
 
673
                }
 
674
        }
 
675
        if ( pending ) {
556
676
                UserUpdatePhrase( bufPhoneSeq, bufWordSeq );
 
677
                prev_pos = 0;
 
678
                pending = 0;
557
679
        }
558
680
}
559
681
 
560
682
int AddChi( uint16 phone, ChewingData *pgdata )
561
683
{
562
684
        int i;
 
685
        int cursor = PhoneSeqCursor( pgdata );
563
686
 
564
687
        /* shift the selectInterval */
565
688
        for ( i = 0; i < pgdata->nSelect; i++ ) {
566
 
                if ( pgdata->selectInterval[ i ].from >= pgdata->cursor ) {
 
689
                if ( pgdata->selectInterval[ i ].from >= cursor ) {
567
690
                        pgdata->selectInterval[ i ].from++;
568
691
                        pgdata->selectInterval[ i ].to++;
569
692
                }
571
694
 
572
695
        /* shift the Brkpt */
573
696
        memmove( 
574
 
                &( pgdata->bUserArrBrkpt[ pgdata->cursor + 2 ] ),
575
 
                &( pgdata->bUserArrBrkpt[ pgdata->cursor + 1 ] ),
576
 
                sizeof( int ) * ( pgdata->nPhoneSeq - pgdata->cursor ) );
 
697
                &( pgdata->bUserArrBrkpt[ cursor + 2 ] ),
 
698
                &( pgdata->bUserArrBrkpt[ cursor + 1 ] ),
 
699
                sizeof( int ) * ( pgdata->nPhoneSeq - cursor ) );
577
700
        memmove(
578
 
                &( pgdata->bUserArrCnnct[ pgdata->cursor + 2 ] ),
579
 
                &( pgdata->bUserArrCnnct[pgdata->cursor + 1 ] ),
580
 
                sizeof( int ) * ( pgdata->nPhoneSeq - pgdata->cursor ) );
 
701
                &( pgdata->bUserArrCnnct[ cursor + 2 ] ),
 
702
                &( pgdata->bUserArrCnnct[ cursor + 1 ] ),
 
703
                sizeof( int ) * ( pgdata->nPhoneSeq - cursor ) );
581
704
 
582
705
        /* add to phoneSeq */
583
706
        memmove(
584
 
                &( pgdata->phoneSeq[ pgdata->cursor + 1 ] ),
585
 
                &( pgdata->phoneSeq[ pgdata->cursor ] ) ,
586
 
                sizeof( uint16 ) * ( pgdata->nPhoneSeq - pgdata->cursor ) );
587
 
        pgdata->phoneSeq[ pgdata->cursor ] = phone;
 
707
                &( pgdata->phoneSeq[ cursor + 1 ] ),
 
708
                &( pgdata->phoneSeq[ cursor ] ) ,
 
709
                sizeof( uint16 ) * ( pgdata->nPhoneSeq - cursor ) );
 
710
        pgdata->phoneSeq[ cursor ] = phone;
588
711
        pgdata->nPhoneSeq ++;
589
 
        pgdata->cursor ++;
590
712
 
591
713
        /* add to chiSymbolBuf */
592
714
        memmove(
608
730
 
609
731
        DEBUG_OUT(
610
732
                "nPhoneSeq : %d\n"
611
 
                "phoneSeq : ", 
 
733
                "phoneSeq  : ", 
612
734
                pgdata->nPhoneSeq );
613
735
        for ( i = 0; i < pgdata->nPhoneSeq; i++ )
614
736
                DEBUG_OUT( "%hu ", pgdata->phoneSeq[ i ] );
615
737
        DEBUG_OUT(
616
 
                "cursor : %d\n"
 
738
                "[cursor : %d]\n"
617
739
                "nSelect : %d\n"
618
740
                "selectStr       selectInterval\n", 
619
 
                pgdata->cursor, 
 
741
                PhoneSeqCursor( pgdata ),
620
742
                pgdata->nSelect );
621
743
        for ( i = 0; i < pgdata->nSelect; i++ ) {
622
744
                DEBUG_OUT(
636
758
                DEBUG_OUT( "%d ", pgdata->bUserArrBrkpt[ i ] );
637
759
        DEBUG_OUT( "\n" );
638
760
 
639
 
        DEBUG_OUT( "bArrBrkpt : " );
 
761
        DEBUG_OUT( "bArrBrkpt     : " );
640
762
        for ( i = 0; i <= pgdata->nPhoneSeq; i++ )
641
763
                DEBUG_OUT( "%d ", pgdata->bArrBrkpt[ i ] );
642
764
        DEBUG_OUT( "\n" );
678
800
                }
679
801
        }
680
802
 
 
803
#ifdef ENABLE_DEBUG
 
804
        ShowChewingData(pgdata);
 
805
#endif
 
806
 
681
807
        /* then phrasing */
682
808
        Phrasing( 
683
809
                &( pgdata->phrOut ), pgdata->phoneSeq, pgdata->nPhoneSeq,
727
853
                        belong_set[ j ] = i + 1;
728
854
                }
729
855
        }
730
 
        set_no = i;
 
856
        set_no = i + 1;
731
857
        for ( i = 0; i < pgdata->nPhoneSeq; i++ )
732
858
                if ( belong_set[i] == 0 ) 
733
859
                        belong_set[ i ] = set_no++;
872
998
 
873
999
int AddSelect( ChewingData *pgdata, int sel_i )
874
1000
{
875
 
        int length, nSelect;
 
1001
        int length, nSelect, cursor;
876
1002
 
877
1003
        /* save the typing time */
878
1004
        length = pgdata->availInfo.avail[ pgdata->availInfo.currentAvail ].len;
882
1008
        ueStrNCpy( pgdata->selectStr[ nSelect ],
883
1009
                        pgdata->choiceInfo.totalChoiceStr[ sel_i ],
884
1010
                        length, 1 );
885
 
        pgdata->selectInterval[ nSelect ].from = pgdata->cursor;
886
 
        pgdata->selectInterval[ nSelect ].to = pgdata->cursor + length;
 
1011
        cursor = PhoneSeqCursor( pgdata );
 
1012
        pgdata->selectInterval[ nSelect ].from = cursor;
 
1013
        pgdata->selectInterval[ nSelect ].to = cursor + length;
887
1014
        pgdata->nSelect++;
888
1015
        return 0;
889
1016
}
899
1026
        return -1;
900
1027
}
901
1028
 
 
1029
int CountSymbols( ChewingData *pgdata, int to )
 
1030
{
 
1031
        int chi;
 
1032
        int i;
 
1033
        for ( chi = i = 0; i < to; i++ ) {
 
1034
                if ( ChewingIsChiAt( i, pgdata ) )
 
1035
                        chi++;
 
1036
        }
 
1037
        return to - chi;
 
1038
}
 
1039
 
 
1040
int PhoneSeqCursor( ChewingData *pgdata )
 
1041
{
 
1042
    int cursor = pgdata->chiSymbolCursor - CountSymbols( pgdata, pgdata->chiSymbolCursor );
 
1043
    return cursor > 0 ? cursor : 0;
 
1044
}
 
1045
 
902
1046
int ChewingIsChiAt( int chiSymbolCursor, ChewingData *pgdata )
903
1047
{
904
1048
        /* wch == 0 means Chinese */
958
1102
 
959
1103
int ChewingKillChar(
960
1104
                ChewingData *pgdata, 
961
 
                int cursorToKill, 
962
1105
                int chiSymbolCursorToKill, 
963
1106
                int minus )
964
1107
{
 
1108
        int tmp, cursorToKill;
 
1109
        tmp = pgdata->chiSymbolCursor;
 
1110
        pgdata->chiSymbolCursor = chiSymbolCursorToKill;
 
1111
        cursorToKill = PhoneSeqCursor( pgdata ); 
 
1112
        pgdata->chiSymbolCursor = tmp;
965
1113
        if ( ChewingIsChiAt( chiSymbolCursorToKill, pgdata ) ) {
966
1114
                KillCharInSelectIntervalAndBrkpt(pgdata, cursorToKill);
967
1115
                memmove(
969
1117
                        &(pgdata->phoneSeq[ cursorToKill + 1 ] ),
970
1118
                        (pgdata->nPhoneSeq - cursorToKill - 1) * sizeof( uint16 ) );
971
1119
                pgdata->nPhoneSeq--;
972
 
                pgdata->cursor -= minus;
973
 
                if (pgdata->cursor < 0)
974
 
                        pgdata->cursor = 0;
975
1120
        }
976
1121
        pgdata->symbolKeyBuf[ chiSymbolCursorToKill ] = 0;
977
1122
        memmove( 
999
1144
}
1000
1145
 
1001
1146
static char *symbol_buf[][ 50 ] = {
1002
 
        { "0", "ø", 0 },
1003
 
        { "[", "「", "『", "《", "〈", "【", "〔", 0 },
1004
 
        { "]", "」", "』", "》", "〉", "】", "〕", 0 },
1005
 
        { "{", "｛", 0 },
1006
 
        { "}", "｝", 0 },
1007
 
        { "<", "，", "←", 0 },
1008
 
        { ">", "。", "→", "．", 0 },
1009
 
        { "?", "？", "¿", 0 },
1010
 
        { "!", "！", "Ⅰ","¡", 0 },
1011
 
        { "@", "＠", "Ⅱ", "⊕", "⊙", "㊣", "﹫", 0 },
1012
 
        { "#", "＃", "Ⅲ", "﹟", 0 },
1013
 
        { "$", "＄", "Ⅳ", "€", "﹩", "￠", "∮","￡", "￥", 0 },
1014
 
        { "%", "％", "Ⅴ", 0 },
1015
 
        { "^", "︿", "Ⅵ", "﹀", "︽", "︾", 0 },
1016
 
        { "&", "＆", "Ⅶ", "﹠", 0 },
1017
 
        { "*", "＊", "Ⅷ", "×", "※", "╳", "﹡", "☯", "☆", "★", 0 },
1018
 
        { "(", "（", "Ⅸ", 0 },
1019
 
        { ")", "）", "Ⅹ", 0 },
1020
 
        { "_", "＿", "…", "‥", "←", "→", "﹍", "﹉", "ˍ", "￣", 
1021
 
               "–", "—", "¯", "﹊", "﹎", "﹏", "﹣", "－", 0 },
1022
 
        { "+", "＋", "±", "﹢", 0 },
1023
 
        { "=", "＝", "≒", "≠", "≡", "≦", "≧", "﹦", 0 },
1024
 
        { "`", "』", "『", "′", "‵", 0 },
1025
 
        { "~", "～", 0 },
1026
 
        { ":", "：", "；", "︰", "﹕", 0 },
1027
 
        { "\"", "；", 0 },
1028
 
        { "\'", "、", "…", "‥", 0 },
1029
 
        { "\\", "＼", "↖", "↘", "﹨", 0 },
1030
 
        { "-", "－", "＿", "￣", "¯", "ˍ", "–", "—", "‥", "…",
1031
 
               "←", "→", "╴", "﹉", "﹊", "﹍", "﹎", "﹏", "﹣", 0 },
1032
 
        { "/", "／","÷","↗","↙","∕", 0 },
1033
 
        { "|", "↑", "↓", "∣", "∥", "︱", "︳", "︴" ,0 },
1034
 
        { "A", "Å","Α", "α", "├", "╠", "╟", "╞", 0 },
1035
 
        { "B", "Β", "β","∵", 0 },
1036
 
        { "C", "Χ", "χ", "┘", "╯", "╝", "╜", "╛",
1037
 
               "㏄", "℃", "㎝", "♣", "©", 0 },
1038
 
        { "D", "Δ", "δ", "◇", "◆", "┤", "╣", "╢", "╡","♦", 0 },
1039
 
        { "E", "Ε", "ε", "┐", "╮", "╗", "╓", "╕", 0 },
1040
 
        { "F", "Φ", "ψ", "│", "║", "♀", 0 },
1041
 
        { "G", "Γ", "γ", 0 },
1042
 
        { "H", "Η", "η","♥", 0 },
1043
 
        { "I", "Ι", "ι", 0 },
1044
 
        { "J", "φ", 0 },
1045
 
        { "K", "Κ", "κ","㎞", "㏎", 0 },
1046
 
        { "L", "Λ", "λ","㏒", "㏑", 0 },
1047
 
        { "M", "Μ", "μ", "♂", "ℓ", "㎎", "㏕", "㎜","㎡", 0 },
1048
 
        { "N", "Ν", "ν","№", 0 },
1049
 
        { "O", "Ο", "ο", 0 },
1050
 
        { "P", "Π", "π", 0 },
1051
 
        { "Q", "Θ", "θ","Д","┌", "╭", "╔", "╓", "╒", 0 },
1052
 
        { "R", "Ρ", "ρ", "─", "═" ,"®" , 0 },
1053
 
        { "S", "Σ", "σ", "∴", "□", "■", "┼", "╬", "╪", "╫",
1054
 
               "∫", "§", "♠", 0 },
1055
 
        { "T", "Τ", "τ","θ","△","▲","▽","▼","™","⊿", "™", 0 },
1056
 
        { "U", "Υ", "υ","μ","∪", "∩", 0 },
1057
 
        { "V",  0 },
1058
 
        { "W", "Ω", "ω", "┬", "╦", "╤", "╥", 0 },
1059
 
        { "X", "Ξ", "ξ", "┴", "╩", "╧", "╨", 0 },
1060
 
        { "Y", "Ψ", 0 },
1061
 
        { "Z", "Ζ", "ζ", "└", "╰", "╚", "╙", "╘", 0 },
 
1147
        { "0", "\xC3\xB8", 0 },
 
1148
                /* "ø" */
 
1149
        { "[", "\xE3\x80\x8C", "\xE3\x80\x8E", "\xE3\x80\x8A", "\xE3\x80\x88",
 
1150
                  "\xE3\x80\x90", "\xE3\x80\x94", 0 },
 
1151
                /* "「", "『", "《", "〈", "【", "〔" */
 
1152
        { "]", "\xE3\x80\x8D", "\xE3\x80\x8F", "\xE3\x80\x8B", "\xE3\x80\x89",
 
1153
                  "\xE3\x80\x91", "\xE3\x80\x95", 0 },
 
1154
                /* "」", "』", "》", "〉", "】", "〕" */
 
1155
        { "{", "\xEF\xBD\x9B", 0 },
 
1156
                /* "｛" */
 
1157
        { "}", "\xEF\xBD\x9D", 0 },
 
1158
                /* "｝" */
 
1159
        { "<", "\xEF\xBC\x8C", "\xE2\x86\x90", 0 },
 
1160
                /* "，", "←" */
 
1161
        { ">", "\xE3\x80\x82", "\xE2\x86\x92", "\xEF\xBC\x8E", 0 },
 
1162
                /* "。", "→", "．" */
 
1163
        { "?", "\xEF\xBC\x9F", "\xC2\xBF", 0 },
 
1164
                /* "？", "¿" */
 
1165
        { "!", "\xEF\xBC\x81", "\xE2\x85\xA0","\xC2\xA1", 0 },
 
1166
                /* "！", "Ⅰ","¡" */
 
1167
        { "@", "\xEF\xBC\xA0", "\xE2\x85\xA1", "\xE2\x8A\x95", "\xE2\x8A\x99",
 
1168
                  "\xE3\x8A\xA3", "\xEF\xB9\xAB", 0 },
 
1169
                /* "＠", "Ⅱ", "⊕", "⊙", "㊣", "﹫" */
 
1170
        { "#", "\xEF\xBC\x83", "\xE2\x85\xA2", "\xEF\xB9\x9F", 0 },
 
1171
                /* "＃", "Ⅲ", "﹟" */
 
1172
        { "$", "\xEF\xBC\x84", "\xE2\x85\xA3", "\xE2\x82\xAC", "\xEF\xB9\xA9",
 
1173
                  "\xEF\xBF\xA0", "\xE2\x88\xAE","\xEF\xBF\xA1", "\xEF\xBF\xA5", 0 },
 
1174
                /* "＄", "Ⅳ", "€", "﹩", "￠", "∮","￡", "￥" */
 
1175
        { "%", "\xEF\xBC\x85", "\xE2\x85\xA4", 0 },
 
1176
                /* "％", "Ⅴ" */
 
1177
        { "^", "\xEF\xB8\xBF", "\xE2\x85\xA5", "\xEF\xB9\x80", "\xEF\xB8\xBD",
 
1178
                  "\xEF\xB8\xBE", 0 },
 
1179
                /* "︿", "Ⅵ", "﹀", "︽", "︾" */
 
1180
        { "&", "\xEF\xBC\x86", "\xE2\x85\xA6", "\xEF\xB9\xA0", 0 },
 
1181
                /* "＆", "Ⅶ", "﹠" */
 
1182
        { "*", "\xEF\xBC\x8A", "\xE2\x85\xA7", "\xC3\x97", "\xE2\x80\xBB",
 
1183
                  "\xE2\x95\xB3", "\xEF\xB9\xA1", "\xE2\x98\xAF", "\xE2\x98\x86",
 
1184
                  "\xE2\x98\x85", 0 },
 
1185
                /* "＊", "Ⅷ", "×", "※", "╳", "﹡", "☯", "☆", "★" */
 
1186
        { "(", "\xEF\xBC\x88", "\xE2\x85\xA8", 0 },
 
1187
                /* "（", "Ⅸ" */
 
1188
        { ")", "\xEF\xBC\x89", "\xE2\x85\xA9", 0 },
 
1189
                /* "）", "Ⅹ" */
 
1190
        { "_", "\xEF\xBC\xBF", "\xE2\x80\xA6", "\xE2\x80\xA5", "\xE2\x86\x90",
 
1191
                  "\xE2\x86\x92", "\xEF\xB9\x8D", "\xEF\xB9\x89", "\xCB\x8D",
 
1192
                  "\xEF\xBF\xA3", "\xE2\x80\x93", "\xE2\x80\x94", "\xC2\xAF",
 
1193
                  "\xEF\xB9\x8A", "\xEF\xB9\x8E", "\xEF\xB9\x8F", "\xEF\xB9\xA3",
 
1194
                  "\xEF\xBC\x8D", 0 },
 
1195
                /* "＿", "…", "‥", "←", "→", "﹍", "﹉", "ˍ", "￣"
 
1196
                 * "–", "—", "¯", "﹊", "﹎", "﹏", "﹣", "－" */
 
1197
        { "+", "\xEF\xBC\x8B", "\xC2\xB1", "\xEF\xB9\xA2", 0 },
 
1198
                /* "＋", "±", "﹢" */
 
1199
        { "=", "\xEF\xBC\x9D", "\xE2\x89\x92", "\xE2\x89\xA0", "\xE2\x89\xA1",
 
1200
                  "\xE2\x89\xA6", "\xE2\x89\xA7", "\xEF\xB9\xA6", 0 },
 
1201
                /* "＝", "≒", "≠", "≡", "≦", "≧", "﹦" */
 
1202
        { "`", "\xE3\x80\x8F", "\xE3\x80\x8E", "\xE2\x80\xB2", "\xE2\x80\xB5", 0 },
 
1203
                /* "』", "『", "′", "‵" */
 
1204
        { "~", "\xEF\xBD\x9E", 0 },
 
1205
                /* "～" */
 
1206
        { ":", "\xEF\xBC\x9A", "\xEF\xBC\x9B", "\xEF\xB8\xB0", "\xEF\xB9\x95", 0 },
 
1207
                /* "：", "；", "︰", "﹕" */
 
1208
        { "\"", "\xEF\xBC\x9B", 0 },
 
1209
                /* "；" */
 
1210
        { "\'", "\xE3\x80\x81", "\xE2\x80\xA6", "\xE2\x80\xA5", 0 },
 
1211
                /* "、", "…", "‥" */
 
1212
        { "\\", "\xEF\xBC\xBC", "\xE2\x86\x96", "\xE2\x86\x98", "\xEF\xB9\xA8", 0 },
 
1213
                /* "＼", "↖", "↘", "﹨" */
 
1214
        { "-", "\xEF\xBC\x8D", "\xEF\xBC\xBF", "\xEF\xBF\xA3", "\xC2\xAF",
 
1215
                  "\xCB\x8D", "\xE2\x80\x93", "\xE2\x80\x94", "\xE2\x80\xA5",
 
1216
                  "\xE2\x80\xA6", "\xE2\x86\x90", "\xE2\x86\x92", "\xE2\x95\xB4",
 
1217
                  "\xEF\xB9\x89", "\xEF\xB9\x8A", "\xEF\xB9\x8D", "\xEF\xB9\x8E",
 
1218
                  "\xEF\xB9\x8F", "\xEF\xB9\xA3", 0 },
 
1219
                /* "－", "＿", "￣", "¯", "ˍ", "–", "—", "‥", "…"
 
1220
                 * "←", "→", "╴", "﹉", "﹊", "﹍", "﹎", "﹏", "﹣" */
 
1221
        { "/", "\xEF\xBC\x8F", "\xC3\xB7", "\xE2\x86\x97", "\xE2\x86\x99",
 
1222
                  "\xE2\x88\x95", 0 },
 
1223
                /* "／","÷","↗","↙","∕" */
 
1224
        { "|", "\xE2\x86\x91", "\xE2\x86\x93", "\xE2\x88\xA3", "\xE2\x88\xA5",
 
1225
                  "\xEF\xB8\xB1", "\xEF\xB8\xB3", "\xEF\xB8\xB4" ,0 },
 
1226
                /* "↑", "↓", "∣", "∥", "︱", "︳", "︴" */
 
1227
        { "A", "\xC3\x85","\xCE\x91", "\xCE\xB1", "\xE2\x94\x9C", "\xE2\x95\xA0",
 
1228
                  "\xE2\x95\x9F", "\xE2\x95\x9E", 0 },
 
1229
                /* "Å","Α", "α", "├", "╠", "╟", "╞" */
 
1230
        { "B", "\xCE\x92", "\xCE\xB2","\xE2\x88\xB5", 0 },
 
1231
                /* "Β", "β","∵" */
 
1232
        { "C", "\xCE\xA7", "\xCF\x87", "\xE2\x94\x98", "\xE2\x95\xAF",
 
1233
                  "\xE2\x95\x9D", "\xE2\x95\x9C", "\xE2\x95\x9B", "\xE3\x8F\x84",
 
1234
                  "\xE2\x84\x83", "\xE3\x8E\x9D", "\xE2\x99\xA3", "\xC2\xA9", 0 },
 
1235
                /* "Χ", "χ", "┘", "╯", "╝", "╜", "╛"
 
1236
                 * "㏄", "℃", "㎝", "♣", "©" */
 
1237
        { "D", "\xCE\x94", "\xCE\xB4", "\xE2\x97\x87", "\xE2\x97\x86",
 
1238
                  "\xE2\x94\xA4", "\xE2\x95\xA3", "\xE2\x95\xA2", "\xE2\x95\xA1",
 
1239
                  "\xE2\x99\xA6", 0 },
 
1240
                /* "Δ", "δ", "◇", "◆", "┤", "╣", "╢", "╡","♦" */
 
1241
        { "E", "\xCE\x95", "\xCE\xB5", "\xE2\x94\x90", "\xE2\x95\xAE",
 
1242
                  "\xE2\x95\x97", "\xE2\x95\x93", "\xE2\x95\x95", 0 },
 
1243
                /* "Ε", "ε", "┐", "╮", "╗", "╓", "╕" */
 
1244
        { "F", "\xCE\xA6", "\xCF\x88", "\xE2\x94\x82", "\xE2\x95\x91",
 
1245
                  "\xE2\x99\x80", 0 },
 
1246
                /* "Φ", "ψ", "│", "║", "♀" */
 
1247
        { "G", "\xCE\x93", "\xCE\xB3", 0 },
 
1248
                /* "Γ", "γ" */
 
1249
        { "H", "\xCE\x97", "\xCE\xB7","\xE2\x99\xA5", 0 },
 
1250
                /* "Η", "η","♥" */
 
1251
        { "I", "\xCE\x99", "\xCE\xB9", 0 },
 
1252
                /* "Ι", "ι" */
 
1253
        { "J", "\xCF\x86", 0 },
 
1254
                /* "φ" */
 
1255
        { "K", "\xCE\x9A", "\xCE\xBA","\xE3\x8E\x9E", "\xE3\x8F\x8E", 0 },
 
1256
                /* "Κ", "κ","㎞", "㏎" */
 
1257
        { "L", "\xCE\x9B", "\xCE\xBB","\xE3\x8F\x92", "\xE3\x8F\x91", 0 },
 
1258
                /* "Λ", "λ","㏒", "㏑" */
 
1259
        { "M", "\xCE\x9C", "\xCE\xBC", "\xE2\x99\x82", "\xE2\x84\x93",
 
1260
                  "\xE3\x8E\x8E", "\xE3\x8F\x95", "\xE3\x8E\x9C","\xE3\x8E\xA1", 0 },
 
1261
                /* "Μ", "μ", "♂", "ℓ", "㎎", "㏕", "㎜","㎡" */
 
1262
        { "N", "\xCE\x9D", "\xCE\xBD","\xE2\x84\x96", 0 },
 
1263
                /* "Ν", "ν","№" */
 
1264
        { "O", "\xCE\x9F", "\xCE\xBF", 0 },
 
1265
                /* "Ο", "ο" */
 
1266
        { "P", "\xCE\xA0", "\xCF\x80", 0 },
 
1267
                /* "Π", "π" */
 
1268
        { "Q", "\xCE\x98", "\xCE\xB8","\xD0\x94","\xE2\x94\x8C", "\xE2\x95\xAD",
 
1269
                  "\xE2\x95\x94", "\xE2\x95\x93", "\xE2\x95\x92", 0 },
 
1270
                /* "Θ", "θ","Д","┌", "╭", "╔", "╓", "╒" */
 
1271
        { "R", "\xCE\xA1", "\xCF\x81", "\xE2\x94\x80", "\xE2\x95\x90" ,"\xC2\xAE" , 0 },
 
1272
                /* "Ρ", "ρ", "─", "═" ,"®" */
 
1273
        { "S", "\xCE\xA3", "\xCF\x83", "\xE2\x88\xB4", "\xE2\x96\xA1",
 
1274
                  "\xE2\x96\xA0", "\xE2\x94\xBC", "\xE2\x95\xAC", "\xE2\x95\xAA",
 
1275
                  "\xE2\x95\xAB", "\xE2\x88\xAB", "\xC2\xA7", "\xE2\x99\xA0", 0 },
 
1276
                /* "Σ", "σ", "∴", "□", "■", "┼", "╬", "╪", "╫"
 
1277
                 * "∫", "§", "♠" */
 
1278
        { "T", "\xCE\xA4", "\xCF\x84", "\xCE\xB8", "\xE2\x96\xB3", "\xE2\x96\xB2",
 
1279
                  "\xE2\x96\xBD", "\xE2\x96\xBC", "\xE2\x84\xA2", "\xE2\x8A\xBF",
 
1280
                  "\xE2\x84\xA2", 0 },
 
1281
                /* "Τ", "τ","θ","△","▲","▽","▼","™","⊿", "™" */
 
1282
        { "U", "\xCE\xA5", "\xCF\x85","\xCE\xBC","\xE2\x88\xAA", "\xE2\x88\xA9", 0 },
 
1283
                /* "Υ", "υ","μ","∪", "∩" */
 
1284
        { "V", "\xCE\xBD", 0 },
 
1285
        { "W", "\xE2\x84\xA6", "\xCF\x89", "\xE2\x94\xAC", "\xE2\x95\xA6",
 
1286
                  "\xE2\x95\xA4", "\xE2\x95\xA5", 0 },
 
1287
                /* "Ω", "ω", "┬", "╦", "╤", "╥" */
 
1288
        { "X", "\xCE\x9E", "\xCE\xBE", "\xE2\x94\xB4", "\xE2\x95\xA9",
 
1289
                  "\xE2\x95\xA7", "\xE2\x95\xA8", 0 },
 
1290
                /* "Ξ", "ξ", "┴", "╩", "╧", "╨" */
 
1291
        { "Y", "\xCE\xA8", 0 },
 
1292
                /* "Ψ" */
 
1293
        { "Z", "\xCE\x96", "\xCE\xB6", "\xE2\x94\x94", "\xE2\x95\xB0",
 
1294
                  "\xE2\x95\x9A", "\xE2\x95\x99", "\xE2\x95\x98", 0 },
 
1295
                /* "Ζ", "ζ", "└", "╰", "╚", "╙", "╘" */
1062
1296
};
1063
1297
 
1064
1298
static int FindSymbolKey( const char *symbol )
1065
1299
{
1066
 
        int i;
 
1300
        unsigned int i;
1067
1301
        char **buf;
1068
1302
        for ( i = 0; i < sizeof( symbol_buf ) / sizeof( symbol_buf[ 0 ] ); ++i ) {
1069
1303
                for ( buf = symbol_buf[ i ]; *buf; ++buf )      {
1079
1313
        int i, symbol_buf_len = sizeof( symbol_buf ) / sizeof( symbol_buf[ 0 ] );
1080
1314
        char **pBuf;
1081
1315
        ChoiceInfo *pci = &( pgdata->choiceInfo );
1082
 
        pci->oldCursor = pgdata->cursor;
1083
1316
        pci->oldChiSymbolCursor = pgdata->chiSymbolCursor;
1084
1317
 
1085
1318
        /* see if there is some word in the cursor position */
1131
1364
{
1132
1365
        const char DIRPATH_SEP_FILENAME[] = "%s" PLAT_SEPARATOR "%s";
1133
1366
        FILE *file;
1134
 
        char filename[ 100 ];
 
1367
        char filename[ PATH_MAX ];
1135
1368
        char line[512];
1136
1369
        char *category;
1137
1370
        char *symbols, *symbol;
1191
1424
 
1192
1425
static void TerminateSymbolTable()
1193
1426
{
1194
 
        int i;
 
1427
        unsigned int i;
1195
1428
        if ( symbol_table ) {
1196
1429
                for ( i = 0; i < n_symbol_entry; ++i )
1197
1430
                        free( symbol_table[ i ] );
1205
1438
{
1206
1439
        const char DIRPATH_SEP_FILENAME[] = "%s" PLAT_SEPARATOR "%s";
1207
1440
        FILE *file;
1208
 
        char filename[ 512 ];
 
1441
        char filename[ PATH_MAX ];
1209
1442
        char line[ 512 ];
1210
1443
        char *symbol;
1211
1444
        int len = 0, index;
1259
1492
 
1260
1493
static void TerminateEasySymbolTable()
1261
1494
{
1262
 
        int i;
 
1495
        unsigned int i;
1263
1496
        for ( i = 0; i < EASY_SYMBOL_KEY_TAB_LEN / sizeof( char ); ++i ) {
1264
1497
                if ( NULL != g_easy_symbol_value[ i ] ) {
1265
1498
                        free( g_easy_symbol_value[ i ] );