1 #include "license.hunspell"
\r
2 #include "license.myspell"
\r
4 #ifndef MOZILLA_CLIENT
\r
10 #include <stdlib.h>
\r
16 #include "suggestmgr.hxx"
\r
18 #ifndef MOZILLA_CLIENT
\r
20 using namespace std;
\r
25 SuggestMgr::SuggestMgr(const char * tryme, int maxn,
\r
29 // register affix manager and check in string of chars to
\r
30 // try when building candidate suggestions
\r
39 maxngramsugs = MAXNGRAMSUGS;
\r
42 complexprefixes = 0;
\r
45 char * enc = pAMgr->get_encoding();
\r
46 csconv = get_current_cs(enc);
\r
48 nosplitsugs = pAMgr->get_nosplitsugs();
\r
49 if (pAMgr->get_maxngramsugs() >= 0) maxngramsugs = pAMgr->get_maxngramsugs();
\r
50 utf8 = pAMgr->get_utf8();
\r
51 complexprefixes = pAMgr->get_complexprefixes();
\r
57 ctryl = u8_u16(t, MAXSWL, tryme);
\r
58 ctry_utf = (w_char *) malloc(ctryl * sizeof(w_char));
\r
59 memcpy(ctry_utf, t, ctryl * sizeof(w_char));
\r
61 ctry = mystrdup(tryme);
\r
62 ctryl = strlen(ctry);
\r
68 SuggestMgr::~SuggestMgr()
\r
71 if (ctry) free(ctry);
\r
73 if (ctry_utf) free(ctry_utf);
\r
79 int SuggestMgr::testsug(char** wlst, const char * candidate, int wl, int ns, int cpdsuggest,
\r
80 int * timer, time_t * timelimit) {
\r
82 if (ns == maxSug) return maxSug;
\r
83 for (int k=0; k < ns; k++) {
\r
84 if (strcmp(candidate,wlst[k]) == 0) cwrd = 0;
\r
86 if ((cwrd) && checkword(candidate, wl, cpdsuggest, timer, timelimit)) {
\r
87 wlst[ns] = mystrdup(candidate);
\r
88 if (wlst[ns] == NULL) {
\r
89 for (int j=0; j<ns; j++) free(wlst[j]);
\r
97 // generate suggestions for a mispelled word
\r
98 // pass in address of array of char * pointers
\r
100 int SuggestMgr::suggest(char*** slst, const char * w, int nsug)
\r
102 int nocompoundtwowords = 0;
\r
104 w_char word_utf[MAXSWL];
\r
107 char w2[MAXWORDUTF8LEN];
\r
108 const char * word = w;
\r
110 // word reversing wrapper for complex prefixes
\r
111 if (complexprefixes) {
\r
113 if (utf8) reverseword_utf(w2); else reverseword(w2);
\r
120 wlst = (char **) malloc(maxSug * sizeof(char *));
\r
121 if (wlst == NULL) return -1;
\r
122 for (int i = 0; i < maxSug; i++) {
\r
128 wl = u8_u16(word_utf, MAXSWL, word);
\r
131 for (int cpdsuggest=0; (cpdsuggest<2) && (nocompoundtwowords==0); cpdsuggest++) {
\r
133 // suggestions for an uppercase word (html -> HTML)
\r
134 if ((nsug < maxSug) && (nsug > -1)) {
\r
135 nsug = (utf8) ? capchars_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
\r
136 capchars(wlst, word, nsug, cpdsuggest);
\r
139 // perhaps we made a typical fault of spelling
\r
140 if ((nsug < maxSug) && (nsug > -1))
\r
141 nsug = replchars(wlst, word, nsug, cpdsuggest);
\r
143 // perhaps we made chose the wrong char from a related set
\r
144 if ((nsug < maxSug) && (nsug > -1) && (cpdsuggest == 0)) {
\r
145 nsug = mapchars(wlst, word, nsug);
\r
148 // did we swap the order of chars by mistake
\r
149 if ((nsug < maxSug) && (nsug > -1)) {
\r
150 nsug = (utf8) ? swapchar_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
\r
151 swapchar(wlst, word, nsug, cpdsuggest);
\r
154 // did we swap the order of non adjacent chars by mistake
\r
155 if ((nsug < maxSug) && (nsug > -1)) {
\r
156 nsug = (utf8) ? longswapchar_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
\r
157 longswapchar(wlst, word, nsug, cpdsuggest);
\r
160 // did we forgot a char
\r
161 if ((nsug < maxSug) && (nsug > -1)) {
\r
162 nsug = (utf8) ? forgotchar_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
\r
163 forgotchar(wlst, word, nsug, cpdsuggest);
\r
166 // did we move a char
\r
167 if ((nsug < maxSug) && (nsug > -1)) {
\r
168 nsug = (utf8) ? movechar_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
\r
169 movechar(wlst, word, nsug, cpdsuggest);
\r
172 // did we add a char that should not be there
\r
173 if ((nsug < maxSug) && (nsug > -1)) {
\r
174 nsug = (utf8) ? extrachar_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
\r
175 extrachar(wlst, word, nsug, cpdsuggest);
\r
178 // did we just hit the wrong key in place of a good char
\r
179 if ((nsug < maxSug) && (nsug > -1)) {
\r
180 nsug = (utf8) ? badchar_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
\r
181 badchar(wlst, word, nsug, cpdsuggest);
\r
184 // did we double two characters
\r
185 if ((nsug < maxSug) && (nsug > -1)) {
\r
186 nsug = (utf8) ? doubletwochars_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
\r
187 doubletwochars(wlst, word, nsug, cpdsuggest);
\r
191 // only suggest compound words when no other suggestion
\r
192 if ((cpdsuggest==0) && (nsug>0)) nocompoundtwowords=1;
\r
194 // perhaps we forgot to hit space and two words ran together
\r
195 if ((!nosplitsugs) && (nsug < maxSug) && (nsug > -1)) {
\r
196 nsug = twowords(wlst, word, nsug, cpdsuggest);
\r
199 } // repeating ``for'' statement compounding support
\r
202 // we ran out of memory - we should free up as much as possible
\r
203 for (int i = 0; i < maxSug; i++)
\r
204 if (wlst[i] != NULL) free(wlst[i]);
\r
213 // generate suggestions for a word with typical mistake
\r
214 // pass in address of array of char * pointers
\r
215 #ifdef HUNSPELL_EXPERIMENTAL
\r
216 int SuggestMgr::suggest_auto(char*** slst, const char * w, int nsug)
\r
218 int nocompoundtwowords = 0;
\r
221 char w2[MAXWORDUTF8LEN];
\r
222 const char * word = w;
\r
224 // word reversing wrapper for complex prefixes
\r
225 if (complexprefixes) {
\r
227 if (utf8) reverseword_utf(w2); else reverseword(w2);
\r
234 wlst = (char **) malloc(maxSug * sizeof(char *));
\r
235 if (wlst == NULL) return -1;
\r
238 for (int cpdsuggest=0; (cpdsuggest<2) && (nocompoundtwowords==0); cpdsuggest++) {
\r
240 // perhaps we made a typical fault of spelling
\r
241 if ((nsug < maxSug) && (nsug > -1))
\r
242 nsug = replchars(wlst, word, nsug, cpdsuggest);
\r
244 // perhaps we made chose the wrong char from a related set
\r
245 if ((nsug < maxSug) && (nsug > -1) && (cpdsuggest == 0))
\r
246 nsug = mapchars(wlst, word, nsug);
\r
248 if ((cpdsuggest==0) && (nsug>0)) nocompoundtwowords=1;
\r
250 // perhaps we forgot to hit space and two words ran together
\r
252 if ((nsug < maxSug) && (nsug > -1) && check_forbidden(word, strlen(word))) {
\r
253 nsug = twowords(wlst, word, nsug, cpdsuggest);
\r
256 } // repeating ``for'' statement compounding support
\r
259 for (int i=0;i<maxSug; i++)
\r
260 if (wlst[i] != NULL) free(wlst[i]);
\r
268 #endif // END OF HUNSPELL_EXPERIMENTAL CODE
\r
270 // suggestions for an uppercase word (html -> HTML)
\r
271 int SuggestMgr::capchars_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
\r
273 char candidate[MAXSWUTF8L];
\r
274 w_char candidate_utf[MAXSWL];
\r
275 memcpy(candidate_utf, word, wl * sizeof(w_char));
\r
276 mkallcap_utf(candidate_utf, wl, pAMgr->get_langnum());
\r
277 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl);
\r
278 return testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, NULL, NULL);
\r
281 // suggestions for an uppercase word (html -> HTML)
\r
282 int SuggestMgr::capchars(char** wlst, const char * word, int ns, int cpdsuggest)
\r
284 char candidate[MAXSWUTF8L];
\r
285 strcpy(candidate, word);
\r
286 mkallcap(candidate, csconv);
\r
287 return testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, NULL, NULL);
\r
290 // suggestions for when chose the wrong char out of a related set
\r
291 int SuggestMgr::mapchars(char** wlst, const char * word, int ns)
\r
296 int wl = strlen(word);
\r
297 if (wl < 2 || ! pAMgr) return ns;
\r
299 int nummap = pAMgr->get_nummap();
\r
300 struct mapentry* maptable = pAMgr->get_maptable();
\r
301 if (maptable==NULL) return ns;
\r
303 timelimit = time(NULL);
\r
307 int len = u8_u16(w, MAXSWL, word);
\r
308 ns = map_related_utf(w, len, 0, wlst, ns, maptable, nummap, &timer, &timelimit);
\r
309 } else ns = map_related(word, 0, wlst, ns, maptable, nummap, &timer, &timelimit);
\r
313 int SuggestMgr::map_related(const char * word, int i, char** wlst, int ns,
\r
314 const mapentry* maptable, int nummap, int * timer, time_t * timelimit)
\r
316 char c = *(word + i);
\r
319 int wl = strlen(word);
\r
320 for (int m=0; m < ns; m++)
\r
321 if (strcmp(word,wlst[m]) == 0) cwrd = 0;
\r
322 if ((cwrd) && (checkword(word, wl, 0, timer, timelimit) ||
\r
323 checkword(word, wl, 1, timer, timelimit))) {
\r
325 wlst[ns] = mystrdup(word);
\r
326 if (wlst[ns] == NULL) return -1;
\r
333 for (int j = 0; j < nummap; j++) {
\r
334 if (strchr(maptable[j].set,c) != 0) {
\r
336 char * newword = mystrdup(word);
\r
337 for (int k = 0; k < maptable[j].len; k++) {
\r
338 *(newword + i) = *(maptable[j].set + k);
\r
339 ns = map_related(newword, (i+1), wlst, ns, maptable, nummap, timer, timelimit);
\r
340 if (!(*timelimit)) return ns;
\r
347 ns = map_related(word, i, wlst, ns, maptable, nummap, timer, timelimit);
\r
352 int SuggestMgr::map_related_utf(w_char * word, int len, int i, char** wlst, int ns,
\r
353 const mapentry* maptable, int nummap, int * timer, time_t * timelimit)
\r
358 char s[MAXSWUTF8L];
\r
359 u16_u8(s, MAXSWUTF8L, word, len);
\r
361 for (int m=0; m < ns; m++)
\r
362 if (strcmp(s,wlst[m]) == 0) cwrd = 0;
\r
363 if ((cwrd) && (checkword(s, wl, 0, timer, timelimit) ||
\r
364 checkword(s, wl, 1, timer, timelimit))) {
\r
366 wlst[ns] = mystrdup(s);
\r
367 if (wlst[ns] == NULL) return -1;
\r
374 unsigned short c = *((unsigned short *) word + i);
\r
375 for (int j = 0; j < nummap; j++) {
\r
376 if (flag_bsearch((unsigned short *) maptable[j].set_utf16, c, maptable[j].len)) {
\r
378 for (int k = 0; k < maptable[j].len; k++) {
\r
379 *(word + i) = *(maptable[j].set_utf16 + k);
\r
380 ns = map_related_utf(word, len, i + 1, wlst, ns, maptable, nummap, timer, timelimit);
\r
381 if (!(*timelimit)) return ns;
\r
383 *((unsigned short *) word + i) = c;
\r
388 ns = map_related_utf(word, len, i, wlst, ns, maptable, nummap, timer, timelimit);
\r
395 // suggestions for a typical fault of spelling, that
\r
396 // differs with more, than 1 letter from the right form.
\r
397 int SuggestMgr::replchars(char** wlst, const char * word, int ns, int cpdsuggest)
\r
399 char candidate[MAXSWUTF8L];
\r
402 int wl = strlen(word);
\r
403 if (wl < 2 || ! pAMgr) return ns;
\r
404 int numrep = pAMgr->get_numrep();
\r
405 struct replentry* reptable = pAMgr->get_reptable();
\r
406 if (reptable==NULL) return ns;
\r
407 for (int i=0; i < numrep; i++ ) {
\r
409 lenr = strlen(reptable[i].pattern2);
\r
410 lenp = strlen(reptable[i].pattern);
\r
411 // search every occurence of the pattern in the word
\r
412 while ((r=strstr(r, reptable[i].pattern)) != NULL) {
\r
413 strcpy(candidate, word);
\r
414 if (r-word + lenr + strlen(r+lenp) >= MAXSWUTF8L) break;
\r
415 strcpy(candidate+(r-word),reptable[i].pattern2);
\r
416 strcpy(candidate+(r-word)+lenr, r+lenp);
\r
417 ns = testsug(wlst, candidate, wl-lenp+lenr, ns, cpdsuggest, NULL, NULL);
\r
418 if (ns == -1) return -1;
\r
419 r++; // search for the next letter
\r
425 // perhaps we doubled two characters (pattern aba -> ababa, for example vacation -> vacacation)
\r
426 int SuggestMgr::doubletwochars(char** wlst, const char * word, int ns, int cpdsuggest)
\r
428 char candidate[MAXSWUTF8L];
\r
430 int wl = strlen(word);
\r
431 if (wl < 5 || ! pAMgr) return ns;
\r
432 for (int i=2; i < wl; i++ ) {
\r
433 if (word[i]==word[i-2]) {
\r
436 strcpy(candidate,word);
\r
437 strcpy(candidate+i-1,word+i+1);
\r
438 ns = testsug(wlst, candidate, wl-2, ns, cpdsuggest, NULL, NULL);
\r
439 if (ns == -1) return -1;
\r
449 // perhaps we doubled two characters (pattern aba -> ababa, for example vacation -> vacacation)
\r
450 int SuggestMgr::doubletwochars_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
\r
453 w_char candidate_utf[MAXSWL];
\r
454 char candidate[MAXSWUTF8L];
\r
456 if (wl < 5 || ! pAMgr) return ns;
\r
457 for (int i=2; i < wl; i++) {
\r
458 if ((word[i].l==word[i-2].l) && (word[i].h==word[i-2].h)) {
\r
461 memcpy(candidate_utf, word, (i - 1) * sizeof(w_char));
\r
462 memcpy(candidate_utf+i-1, word+i+1, (wl-i-1) * sizeof(w_char));
\r
463 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl-2);
\r
464 ns = testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, NULL, NULL);
\r
465 if (ns == -1) return -1;
\r
475 // error is wrong char in place of correct one
\r
476 int SuggestMgr::badchar(char ** wlst, const char * word, int ns, int cpdsuggest)
\r
479 char candidate[MAXSWUTF8L];
\r
480 time_t timelimit = time(NULL);
\r
481 int timer = MINTIMER;
\r
482 int wl = strlen(word);
\r
483 strcpy(candidate, word);
\r
484 // swap out each char one by one and try all the tryme
\r
485 // chars in its place to see if that makes a good word
\r
486 for (int i=0; i < wl; i++) {
\r
487 tmpc = candidate[i];
\r
488 for (int j=0; j < ctryl; j++) {
\r
489 if (ctry[j] == tmpc) continue;
\r
490 candidate[i] = ctry[j];
\r
491 ns = testsug(wlst, candidate, wl, ns, cpdsuggest, &timer, &timelimit);
\r
492 if (ns == -1) return -1;
\r
493 if (!timelimit) return ns;
\r
494 candidate[i] = tmpc;
\r
500 // error is wrong char in place of correct one
\r
501 int SuggestMgr::badchar_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
\r
504 w_char candidate_utf[MAXSWL];
\r
505 char candidate[MAXSWUTF8L];
\r
506 time_t timelimit = time(NULL);
\r
507 int timer = MINTIMER;
\r
508 memcpy(candidate_utf, word, wl * sizeof(w_char));
\r
509 // swap out each char one by one and try all the tryme
\r
510 // chars in its place to see if that makes a good word
\r
511 for (int i=0; i < wl; i++) {
\r
512 tmpc = candidate_utf[i];
\r
513 for (int j=0; j < ctryl; j++) {
\r
514 if ((ctry_utf[j].l == tmpc.l) && (ctry_utf[j].h == tmpc.h)) continue;
\r
515 candidate_utf[i] = ctry_utf[j];
\r
516 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl);
\r
517 ns = testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, &timer, &timelimit);
\r
518 if (ns == -1) return -1;
\r
519 if (!timelimit) return ns;
\r
520 candidate_utf[i] = tmpc;
\r
526 // error is word has an extra letter it does not need
\r
527 int SuggestMgr::extrachar_utf(char** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
\r
529 char candidate[MAXSWUTF8L];
\r
530 w_char candidate_utf[MAXSWL];
\r
533 if (wl < 2) return ns;
\r
534 // try omitting one char of word at a time
\r
535 memcpy(candidate_utf, word + 1, (wl - 1) * sizeof(w_char));
\r
536 for (p = word, r = candidate_utf; p < word + wl; ) {
\r
537 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl - 1);
\r
538 ns = testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, NULL, NULL);
\r
539 if (ns == -1) return -1;
\r
545 // error is word has an extra letter it does not need
\r
546 int SuggestMgr::extrachar(char** wlst, const char * word, int ns, int cpdsuggest)
\r
548 char candidate[MAXSWUTF8L];
\r
551 int wl = strlen(word);
\r
552 if (wl < 2) return ns;
\r
553 // try omitting one char of word at a time
\r
554 strcpy (candidate, word + 1);
\r
555 for (p = word, r = candidate; *p != 0; ) {
\r
556 ns = testsug(wlst, candidate, wl-1, ns, cpdsuggest, NULL, NULL);
\r
557 if (ns == -1) return -1;
\r
564 // error is missing a letter it needs
\r
565 int SuggestMgr::forgotchar(char ** wlst, const char * word, int ns, int cpdsuggest)
\r
567 char candidate[MAXSWUTF8L];
\r
571 time_t timelimit = time(NULL);
\r
572 int timer = MINTIMER;
\r
573 int wl = strlen(word);
\r
574 // try inserting a tryme character before every letter
\r
575 strcpy(candidate + 1, word);
\r
576 for (p = word, q = candidate; *p != 0; ) {
\r
577 for (int i = 0; i < ctryl; i++) {
\r
579 ns = testsug(wlst, candidate, wl+1, ns, cpdsuggest, &timer, &timelimit);
\r
580 if (ns == -1) return -1;
\r
581 if (!timelimit) return ns;
\r
585 // now try adding one to end */
\r
586 for (int i = 0; i < ctryl; i++) {
\r
588 ns = testsug(wlst, candidate, wl+1, ns, cpdsuggest, NULL, NULL);
\r
589 if (ns == -1) return -1;
\r
594 // error is missing a letter it needs
\r
595 int SuggestMgr::forgotchar_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
\r
597 w_char candidate_utf[MAXSWL];
\r
598 char candidate[MAXSWUTF8L];
\r
602 time_t timelimit = time(NULL);
\r
603 int timer = MINTIMER;
\r
604 // try inserting a tryme character before every letter
\r
605 memcpy (candidate_utf + 1, word, wl * sizeof(w_char));
\r
606 for (p = word, q = candidate_utf; p < (word + wl); ) {
\r
607 for (int i = 0; i < ctryl; i++) {
\r
610 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl + 1);
\r
611 ns = testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, &timer, &timelimit);
\r
612 if (ns == -1) return -1;
\r
613 if (!timelimit) return ns;
\r
617 // now try adding one to end */
\r
618 for (int i = 0; i < ctryl; i++) {
\r
621 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl + 1);
\r
622 ns = testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, NULL, NULL);
\r
623 if (ns == -1) return -1;
\r
629 /* error is should have been two words */
\r
630 int SuggestMgr::twowords(char ** wlst, const char * word, int ns, int cpdsuggest)
\r
632 char candidate[MAXSWUTF8L];
\r
638 int wl=strlen(word);
\r
639 if (wl < 3) return ns;
\r
641 if (pAMgr->get_langnum() == LANG_hu) forbidden = check_forbidden(word, wl);
\r
643 strcpy(candidate + 1, word);
\r
645 // split the string into two pieces after every char
\r
646 // if both pieces are good words make them a suggestion
\r
647 for (p = candidate + 1; p[1] != '\0'; p++) {
\r
649 // go to end of the UTF-8 character
\r
650 while (utf8 && ((p[1] & 0xc0) == 0x80)) {
\r
655 c1 = checkword(candidate,strlen(candidate), cpdsuggest, NULL, NULL);
\r
657 c2 = checkword((p+1),strlen(p+1), cpdsuggest, NULL, NULL);
\r
661 // spec. Hungarian code (need a better compound word support)
\r
662 if ((pAMgr->get_langnum() == LANG_hu) && !forbidden &&
\r
663 // if 3 repeating letter, use - instead of space
\r
664 (((p[-1] == p[1]) && (((p>candidate+1) && (p[-1] == p[-2])) || (p[-1] == p[2]))) ||
\r
665 // or multiple compounding, with more, than 6 syllables
\r
666 ((c1 == 3) && (c2 >= 2)))) *p = '-';
\r
669 for (int k=0; k < ns; k++)
\r
670 if (strcmp(candidate,wlst[k]) == 0) cwrd = 0;
\r
673 wlst[ns] = mystrdup(candidate);
\r
674 if (wlst[ns] == NULL) return -1;
\r
685 // error is adjacent letter were swapped
\r
686 int SuggestMgr::swapchar(char ** wlst, const char * word, int ns, int cpdsuggest)
\r
688 char candidate[MAXSWUTF8L];
\r
691 int wl=strlen(word);
\r
692 // try swapping adjacent chars one by one
\r
693 strcpy(candidate, word);
\r
694 for (p = candidate; p[1] != 0; p++) {
\r
698 ns = testsug(wlst, candidate, wl, ns, cpdsuggest, NULL, NULL);
\r
699 if (ns == -1) return -1;
\r
706 // error is adjacent letter were swapped
\r
707 int SuggestMgr::swapchar_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
\r
709 w_char candidate_utf[MAXSWL];
\r
710 char candidate[MAXSWUTF8L];
\r
713 // try swapping adjacent chars one by one
\r
714 memcpy (candidate_utf, word, wl * sizeof(w_char));
\r
715 for (p = candidate_utf; p < (candidate_utf + wl - 1); p++) {
\r
719 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl);
\r
720 ns = testsug(wlst, candidate, wl, ns, cpdsuggest, NULL, NULL);
\r
721 if (ns == -1) return -1;
\r
728 // error is not adjacent letter were swapped
\r
729 int SuggestMgr::longswapchar(char ** wlst, const char * word, int ns, int cpdsuggest)
\r
731 char candidate[MAXSWUTF8L];
\r
735 int wl=strlen(word);
\r
736 // try swapping not adjacent chars one by one
\r
737 strcpy(candidate, word);
\r
738 for (p = candidate; *p != 0; p++) {
\r
739 for (q = candidate; *q != 0; q++) {
\r
740 if (abs(p-q) > 1) {
\r
744 ns = testsug(wlst, candidate, wl, ns, cpdsuggest, NULL, NULL);
\r
745 if (ns == -1) return -1;
\r
755 // error is adjacent letter were swapped
\r
756 int SuggestMgr::longswapchar_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
\r
758 w_char candidate_utf[MAXSWL];
\r
759 char candidate[MAXSWUTF8L];
\r
763 // try swapping not adjacent chars
\r
764 memcpy (candidate_utf, word, wl * sizeof(w_char));
\r
765 for (p = candidate_utf; p < (candidate_utf + wl); p++) {
\r
766 for (q = candidate_utf; q < (candidate_utf + wl); q++) {
\r
767 if (abs(p-q) > 1) {
\r
771 ns = testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, NULL, NULL);
\r
772 if (ns == -1) return -1;
\r
781 // error is a letter was moved
\r
782 int SuggestMgr::movechar(char ** wlst, const char * word, int ns, int cpdsuggest)
\r
784 char candidate[MAXSWUTF8L];
\r
789 int wl=strlen(word);
\r
790 // try moving a char
\r
791 strcpy(candidate, word);
\r
792 for (p = candidate; *p != 0; p++) {
\r
793 for (q = p + 1; (*q != 0) && ((q - p) < 10); q++) {
\r
797 if ((q-p) < 2) continue; // omit swap char
\r
798 ns = testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, NULL, NULL);
\r
799 if (ns == -1) return -1;
\r
801 strcpy(candidate, word);
\r
803 for (p = candidate + wl - 1; p > candidate; p--) {
\r
804 for (q = p - 1; (q >= candidate) && ((p - q) < 10); q--) {
\r
808 if ((p-q) < 2) continue; // omit swap char
\r
809 ns = testsug(wlst, candidate, strlen(candidate), ns, cpdsuggest, NULL, NULL);
\r
810 if (ns == -1) return -1;
\r
812 strcpy(candidate, word);
\r
817 // error is a letter was moved
\r
818 int SuggestMgr::movechar_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
\r
820 w_char candidate_utf[MAXSWL];
\r
821 char candidate[MAXSWUTF8L];
\r
825 // try moving a char
\r
826 memcpy (candidate_utf, word, wl * sizeof(w_char));
\r
827 for (p = candidate_utf; p < (candidate_utf + wl); p++) {
\r
828 for (q = p + 1; (q < (candidate_utf + wl)) && ((q - p) < 10); q++) {
\r
832 if ((q-p) < 2) continue; // omit swap char
\r
833 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl);
\r
834 ns = testsug(wlst, candidate, wl, ns, cpdsuggest, NULL, NULL);
\r
835 if (ns == -1) return -1;
\r
837 memcpy (candidate_utf, word, wl * sizeof(w_char));
\r
839 for (p = candidate_utf + wl - 1; p > candidate_utf; p--) {
\r
840 for (q = p - 1; (q >= candidate_utf) && ((p - q) < 10); q--) {
\r
844 if ((p-q) < 2) continue; // omit swap char
\r
845 u16_u8(candidate, MAXSWUTF8L, candidate_utf, wl);
\r
846 ns = testsug(wlst, candidate, wl, ns, cpdsuggest, NULL, NULL);
\r
847 if (ns == -1) return -1;
\r
849 memcpy (candidate_utf, word, wl * sizeof(w_char));
\r
854 // generate a set of suggestions for very poorly spelled words
\r
855 int SuggestMgr::ngsuggest(char** wlst, char * w, HashMgr* pHMgr)
\r
864 if (!pHMgr) return 0;
\r
866 // exhaustively search through all root words
\r
867 // keeping track of the MAX_ROOTS most similar root words
\r
868 struct hentry * roots[MAX_ROOTS];
\r
869 int scores[MAX_ROOTS];
\r
870 for (i = 0; i < MAX_ROOTS; i++) {
\r
872 scores[i] = -100 * i;
\r
874 lp = MAX_ROOTS - 1;
\r
876 char w2[MAXWORDUTF8LEN];
\r
879 // word reversing wrapper for complex prefixes
\r
880 if (complexprefixes) {
\r
882 if (utf8) reverseword_utf(w2); else reverseword(w2);
\r
886 char mw[MAXSWUTF8L];
\r
888 int nc = strlen(word);
\r
889 int n = (utf8) ? u8_u16(u8, MAXSWL, word) : nc;
\r
891 // set character based ngram suggestion for words with non-BMP Unicode characters
\r
898 struct hentry* hp = NULL;
\r
900 while ((hp = pHMgr->walk_hashtable(col, hp))) {
\r
901 if ((hp->astr) && (pAMgr) &&
\r
902 (TESTAFF(hp->astr, pAMgr->get_forbiddenword(), hp->alen) ||
\r
903 TESTAFF(hp->astr, pAMgr->get_nosuggest(), hp->alen) ||
\r
904 TESTAFF(hp->astr, pAMgr->get_onlyincompound(), hp->alen))) continue;
\r
905 sc = ngram(3, word, hp->word, NGRAM_LONGER_WORSE);
\r
906 if (sc > scores[lp]) {
\r
910 for (j=0; j < MAX_ROOTS; j++)
\r
911 if (scores[j] < lval) {
\r
918 // find minimum threshhold for a passable suggestion
\r
919 // mangle original word three differnt ways
\r
920 // and score them to generate a minimum acceptable score
\r
922 for (int sp = 1; sp < 4; sp++) {
\r
924 for (int k=sp; k < n; k+=4) *((unsigned short *) u8 + k) = '*';
\r
925 u16_u8(mw, MAXSWUTF8L, u8, n);
\r
926 thresh = thresh + ngram(n, word, mw, NGRAM_ANY_MISMATCH);
\r
929 for (int k=sp; k < n; k+=4) *(mw + k) = '*';
\r
930 thresh = thresh + ngram(n, word, mw, NGRAM_ANY_MISMATCH);
\r
933 thresh = thresh / 3;
\r
936 // now expand affixes on each of these root words and
\r
937 // and use length adjusted ngram scores to select
\r
938 // possible suggestions
\r
939 char * guess[MAX_GUESS];
\r
940 int gscore[MAX_GUESS];
\r
941 for(i=0;i<MAX_GUESS;i++) {
\r
943 gscore[i] = -100 * i;
\r
946 lp = MAX_GUESS - 1;
\r
948 struct guessword * glst;
\r
949 glst = (struct guessword *) calloc(MAX_WORDS,sizeof(struct guessword));
\r
951 if (nonbmp) utf8 = 1;
\r
955 for (i = 0; i < MAX_ROOTS; i++) {
\r
958 struct hentry * rp = roots[i];
\r
959 int nw = pAMgr->expand_rootword(glst, MAX_WORDS, rp->word, rp->wlen,
\r
960 rp->astr, rp->alen, word, nc);
\r
962 for (int k = 0; k < nw ; k++) {
\r
963 sc = ngram(n, word, glst[k].word, NGRAM_ANY_MISMATCH);
\r
964 if ((sc > thresh)) {
\r
965 if (sc > gscore[lp]) {
\r
966 if (guess[lp]) free (guess[lp]);
\r
968 guess[lp] = glst[k].word;
\r
970 for (j=0; j < MAX_GUESS; j++)
\r
971 if (gscore[j] < lval) {
\r
975 } else free (glst[k].word);
\r
976 } else free(glst[k].word);
\r
982 // now we are done generating guesses
\r
983 // sort in order of decreasing score
\r
985 bubblesort(&guess[0], &gscore[0], MAX_GUESS);
\r
987 // weight suggestions with a similarity index, based on
\r
988 // the longest common subsequent algorithm and resort
\r
991 for (i=0; i < MAX_GUESS; i++) {
\r
993 // lowering guess[i]
\r
994 char gl[MAXSWUTF8L];
\r
998 len = u8_u16(_w, MAXSWL, guess[i]);
\r
999 mkallsmall_utf(_w, len, pAMgr->get_langnum());
\r
1000 u16_u8(gl, MAXSWUTF8L, _w, len);
\r
1002 strcpy(gl, guess[i]);
\r
1003 mkallsmall(gl, csconv);
\r
1004 len = strlen(guess[i]);
\r
1007 int _lcs = lcslen(word, gl);
\r
1009 // same characters with different casing
\r
1010 if ((n == len) && (n == _lcs)) {
\r
1011 gscore[i] += 2000;
\r
1015 // heuristic weigthing of ngram scores
\r
1017 // length of longest common subsequent minus lenght difference
\r
1018 2 * _lcs - abs((int) (n - len)) +
\r
1019 // weight equal first letter
\r
1020 equalfirstletter(word, gl) +
\r
1021 // weight equal character positions
\r
1022 ((_lcs == commoncharacterpositions(word, gl, &is_swap)) ? 1: 0) +
\r
1023 // swap character (not neighboring)
\r
1024 ((is_swap) ? 1000 : 0);
\r
1028 bubblesort(&guess[0], &gscore[0], MAX_GUESS);
\r
1034 for (i=0; i < MAX_GUESS; i++) {
\r
1036 if ((ns < maxngramsugs) && (ns < maxSug) && (!same || (gscore[i] > 1000))) {
\r
1038 // we have excellent suggestion(s)
\r
1039 if (gscore[i] > 1000) same = 1;
\r
1040 for (j=0; j < ns; j++)
\r
1041 // don't suggest previous suggestions or a previous suggestion with prefixes or affixes
\r
1042 if (strstr(guess[i], wlst[j]) ||
\r
1043 // check forbidden words
\r
1044 !checkword(guess[i], strlen(guess[i]), 0, NULL, NULL)) unique = 0;
\r
1045 if (unique) wlst[ns++] = guess[i]; else free(guess[i]);
\r
1046 } else free(guess[i]);
\r
1050 if (nonbmp) utf8 = 1;
\r
1055 // see if a candidate suggestion is spelled correctly
\r
1056 // needs to check both root words and words with affixes
\r
1058 // obsolote MySpell-HU modifications:
\r
1059 // return value 2 and 3 marks compounding with hyphen (-)
\r
1060 // `3' marks roots without suffix
\r
1061 int SuggestMgr::checkword(const char * word, int len, int cpdsuggest, int * timer, time_t * timelimit)
\r
1063 struct hentry * rv=NULL;
\r
1066 // check time limit
\r
1069 if (!(*timer) && timelimit) {
\r
1070 if (time(NULL) > *timelimit) {
\r
1074 *timer = MAXPLUSTIMER;
\r
1079 if (cpdsuggest==1) {
\r
1080 if (pAMgr->get_compound()) {
\r
1081 rv = pAMgr->compound_check(word,len,0,0,0,0,NULL,0,NULL,NULL,1);
\r
1082 if (rv) return 3; // XXX obsolote categorisation
\r
1087 rv = pAMgr->lookup(word);
\r
1090 if ((rv->astr) && (TESTAFF(rv->astr,pAMgr->get_forbiddenword(),rv->alen)
\r
1091 || TESTAFF(rv->astr,pAMgr->get_nosuggest(),rv->alen))) return 0;
\r
1092 if (rv->astr && (TESTAFF(rv->astr,pAMgr->get_pseudoroot(),rv->alen) ||
\r
1093 TESTAFF(rv->astr,pAMgr->get_onlyincompound(),rv->alen))) rv = NULL;
\r
1094 } else rv = pAMgr->prefix_check(word, len, 0); // only prefix, and prefix + suffix XXX
\r
1099 rv = pAMgr->suffix_check(word, len, 0, NULL, NULL, 0, NULL); // only suffix
\r
1102 if (!rv && pAMgr->have_contclass()) {
\r
1103 rv = pAMgr->suffix_check_twosfx(word, len, 0, NULL, FLAG_NULL);
\r
1104 if (!rv) rv = pAMgr->prefix_check_twosfx(word, len, 1, FLAG_NULL);
\r
1107 // check forbidden words
\r
1108 if ((rv) && (rv->astr) && (TESTAFF(rv->astr,pAMgr->get_forbiddenword(),rv->alen)
\r
1109 || TESTAFF(rv->astr,pAMgr->get_nosuggest(),rv->alen) ||
\r
1110 TESTAFF(rv->astr,pAMgr->get_onlyincompound(),rv->alen))) return 0;
\r
1112 if (rv) { // XXX obsolote
\r
1113 if ((pAMgr->get_compoundflag()) &&
\r
1114 TESTAFF(rv->astr, pAMgr->get_compoundflag(), rv->alen)) return 2 + nosuffix;
\r
1121 int SuggestMgr::check_forbidden(const char * word, int len)
\r
1123 struct hentry * rv = NULL;
\r
1126 rv = pAMgr->lookup(word);
\r
1127 if (rv && rv->astr && (TESTAFF(rv->astr,pAMgr->get_pseudoroot(),rv->alen) ||
\r
1128 TESTAFF(rv->astr,pAMgr->get_onlyincompound(),rv->alen))) rv = NULL;
\r
1129 if (!(pAMgr->prefix_check(word,len,1)))
\r
1130 rv = pAMgr->suffix_check(word,len, 0, NULL, NULL, 0, NULL); // prefix+suffix, suffix
\r
1131 // check forbidden words
\r
1132 if ((rv) && (rv->astr) && TESTAFF(rv->astr,pAMgr->get_forbiddenword(),rv->alen)) return 1;
\r
1137 #ifdef HUNSPELL_EXPERIMENTAL
\r
1138 // suggest stems, XXX experimental code
\r
1139 int SuggestMgr::suggest_stems(char*** slst, const char * w, int nsug)
\r
1141 char buf[MAXSWUTF8L];
\r
1143 int prevnsug = nsug;
\r
1145 char w2[MAXWORDUTF8LEN];
\r
1146 const char * word = w;
\r
1148 // word reversing wrapper for complex prefixes
\r
1149 if (complexprefixes) {
\r
1151 if (utf8) reverseword_utf(w2); else reverseword(w2);
\r
1158 wlst = (char **) calloc(maxSug, sizeof(char *));
\r
1159 if (wlst == NULL) return -1;
\r
1161 // perhaps there are a fix stem in the dictionary
\r
1162 if ((nsug < maxSug) && (nsug > -1)) {
\r
1164 nsug = fixstems(wlst, word, nsug);
\r
1165 if (nsug == prevnsug) {
\r
1166 char * s = mystrdup(word);
\r
1167 char * p = s + strlen(s);
\r
1168 while ((*p != '-') && (p != s)) p--;
\r
1171 nsug = fixstems(wlst, s, nsug);
\r
1172 if ((nsug == prevnsug) && (nsug < maxSug) && (nsug >= 0)) {
\r
1175 for (t = s; (t[0] != '\0') && ((t[0] >= '0') || (t[0] <= '9')); t++); // is a number?
\r
1176 if (*t != '\0') strcpy(buf, "# ");
\r
1178 wlst[nsug] = mystrdup(buf);
\r
1179 if (wlst[nsug] == NULL) return -1;
\r
1183 nsug = fixstems(wlst, p, nsug);
\r
1191 for (int i=0;i<maxSug; i++)
\r
1192 if (wlst[i] != NULL) free(wlst[i]);
\r
1202 // there are fix stems in dictionary
\r
1203 int SuggestMgr::fixstems(char ** wlst, const char * word, int ns)
\r
1205 char buf[MAXSWUTF8L];
\r
1206 char prefix[MAXSWUTF8L] = "";
\r
1208 int dicstem = 1; // 0 = lookup, 1= affix, 2 = compound
\r
1210 struct hentry * rv = NULL;
\r
1212 int wl = strlen(word);
\r
1214 int cmpdstem[MAXCOMPOUND];
\r
1217 rv = pAMgr->lookup(word);
\r
1221 // try stripping off affixes
\r
1222 rv = pAMgr->affix_check(word, wl);
\r
1224 // else try check compound word
\r
1225 if (!rv && pAMgr->get_compound()) {
\r
1226 rv = pAMgr->compound_check(word, wl,
\r
1227 0, 0, 100, 0, NULL, 0, &cmpdstemnum, cmpdstem,1);
\r
1231 for (int j = 0; j < cmpdstemnum; j++) {
\r
1232 cpdindex += cmpdstem[j];
\r
1234 if(! (pAMgr->lookup(word + cpdindex)))
\r
1235 pAMgr->affix_check(word + cpdindex, wl - cpdindex); // for prefix
\r
1240 if (pAMgr->get_prefix()) {
\r
1241 strcpy(prefix, pAMgr->get_prefix());
\r
1244 // XXX obsolete, will be a general solution for stemming
\r
1245 if ((prefix) && (strncmp(prefix, "leg", 3)==0)) prefix[0] = '\0'; // (HU)
\r
1252 if ((rv) && (ns < maxSug)) {
\r
1254 // check fixstem flag and not_valid_stem flag
\r
1256 if ((ns < maxSug) && (dicstem < 2)) {
\r
1257 strcpy(buf, prefix);
\r
1258 if ((dicstem > 0) && pAMgr->get_derived()) {
\r
1260 if (strlen(prefix) == 1) {
\r
1261 strcat(buf, (pAMgr->get_derived()) + 1);
\r
1263 strcat(buf, pAMgr->get_derived());
\r
1266 // special stem in affix description
\r
1267 const char * wordchars = pAMgr->get_wordchars();
\r
1268 if (rv->description &&
\r
1269 (strchr(wordchars, *(rv->description)))) {
\r
1270 char * desc = (rv->description) + 1;
\r
1271 while (strchr(wordchars, *desc)) desc++;
\r
1272 strncat(buf, rv->description, desc - (rv->description));
\r
1274 strcat(buf, rv->word);
\r
1277 wlst[ns] = mystrdup(buf);
\r
1278 if (wlst[ns] == NULL) return -1;
\r
1282 if (dicstem == 2) {
\r
1286 // if (rv->astr && (strchr(rv->astr, '0') == NULL)) {
\r
1288 strcpy(buf, word);
\r
1289 buf[cpdindex] = '\0';
\r
1290 if (prefix) strcat(buf, prefix);
\r
1291 if (pAMgr->get_derived()) {
\r
1292 strcat(buf, pAMgr->get_derived());
\r
1294 // special stem in affix description
\r
1295 const char * wordchars = pAMgr->get_wordchars();
\r
1296 if (rv->description &&
\r
1297 (strchr(wordchars, *(rv->description)))) {
\r
1298 char * desc = (rv->description) + 1;
\r
1299 while (strchr(wordchars, *desc)) desc++;
\r
1300 strncat(buf, rv->description, desc - (rv->description));
\r
1302 strcat(buf, rv->word);
\r
1305 if (ns < maxSug) {
\r
1306 wlst[ns] = mystrdup(buf);
\r
1307 if (wlst[ns] == NULL) return -1;
\r
1316 // suggest possible stems
\r
1317 int SuggestMgr::suggest_pos_stems(char*** slst, const char * w, int nsug)
\r
1321 struct hentry * rv = NULL;
\r
1323 char w2[MAXSWUTF8L];
\r
1324 const char * word = w;
\r
1326 // word reversing wrapper for complex prefixes
\r
1327 if (complexprefixes) {
\r
1329 if (utf8) reverseword_utf(w2); else reverseword(w2);
\r
1333 int wl = strlen(word);
\r
1339 wlst = (char **) calloc(maxSug, sizeof(char *));
\r
1340 if (wlst == NULL) return -1;
\r
1343 rv = pAMgr->suffix_check(word, wl, 0, NULL, wlst, maxSug, &nsug);
\r
1345 // delete dash from end of word
\r
1347 for (int j=0; j < nsug; j++) {
\r
1348 if (wlst[j][strlen(wlst[j]) - 1] == '-') wlst[j][strlen(wlst[j]) - 1] = '\0';
\r
1357 char * SuggestMgr::suggest_morph(const char * w)
\r
1359 char result[MAXLNLEN];
\r
1360 char * r = (char *) result;
\r
1363 struct hentry * rv = NULL;
\r
1367 if (! pAMgr) return NULL;
\r
1369 char w2[MAXSWUTF8L];
\r
1370 const char * word = w;
\r
1372 // word reversing wrapper for complex prefixes
\r
1373 if (complexprefixes) {
\r
1375 if (utf8) reverseword_utf(w2); else reverseword(w2);
\r
1379 rv = pAMgr->lookup(word);
\r
1382 if ((!rv->astr) || !(TESTAFF(rv->astr, pAMgr->get_forbiddenword(), rv->alen) ||
\r
1383 TESTAFF(rv->astr, pAMgr->get_pseudoroot(), rv->alen) ||
\r
1384 TESTAFF(rv->astr,pAMgr->get_onlyincompound(),rv->alen))) {
\r
1385 if (rv->description && ((!rv->astr) ||
\r
1386 !TESTAFF(rv->astr, pAMgr->get_lemma_present(), rv->alen)))
\r
1387 strcat(result, word);
\r
1388 if (rv->description) strcat(result, rv->description);
\r
1389 strcat(result, "\n");
\r
1391 rv = rv->next_homonym;
\r
1394 st = pAMgr->affix_check_morph(word,strlen(word));
\r
1396 strcat(result, st);
\r
1400 if (pAMgr->get_compound() && (*result == '\0'))
\r
1401 pAMgr->compound_check_morph(word, strlen(word),
\r
1402 0, 0, 100, 0,NULL, 0, &r, NULL);
\r
1404 return (*result) ? mystrdup(line_uniq(delete_zeros(result))) : NULL;
\r
1407 char * SuggestMgr::suggest_morph_for_spelling_error(const char * word)
\r
1410 char ** wlst = (char **) calloc(maxSug, sizeof(char *));
\r
1411 // we will use only the first suggestion
\r
1412 for (int i = 0; i < maxSug - 1; i++) wlst[i] = "";
\r
1413 int ns = suggest(&wlst, word, maxSug - 1);
\r
1414 if (ns == maxSug) {
\r
1415 p = suggest_morph(wlst[maxSug - 1]);
\r
1416 free(wlst[maxSug - 1]);
\r
1418 if (wlst) free(wlst);
\r
1421 #endif // END OF HUNSPELL_EXPERIMENTAL CODE
\r
1424 // generate an n-gram score comparing s1 and s2
\r
1425 int SuggestMgr::ngram(int n, char * s1, const char * s2, int uselen)
\r
1433 w_char su1[MAXSWL];
\r
1434 w_char su2[MAXSWL];
\r
1435 l1 = u8_u16(su1, MAXSWL, s1);
\r
1436 l2 = u8_u16(su2, MAXSWL, s2);
\r
1437 if (!l2 || (l1==-1) || (l2==-1)) return 0;
\r
1438 // decapitalize dictionary word
\r
1439 if (complexprefixes) {
\r
1440 mkallsmall_utf(su2+l2-1, 1, pAMgr->get_langnum());
\r
1442 mkallsmall_utf(su2, 1, pAMgr->get_langnum());
\r
1444 for (int j = 1; j <= n; j++) {
\r
1446 for (int i = 0; i <= (l1-j); i++) {
\r
1447 for (int l = 0; l <= (l2-j); l++) {
\r
1449 for (k = 0; (k < j); k++) {
\r
1450 w_char * c1 = su1 + i + k;
\r
1451 w_char * c2 = su2 + l + k;
\r
1452 if ((c1->l != c2->l) || (c1->h != c2->h)) break;
\r
1460 nscore = nscore + ns;
\r
1461 if (ns < 2) break;
\r
1464 char t[MAXSWUTF8L];
\r
1467 if (!l2) return 0;
\r
1469 if (complexprefixes) {
\r
1470 *(t+l2-1) = csconv[((unsigned char)*(t+l2-1))].clower;
\r
1472 mkallsmall(t, csconv);
\r
1474 for (int j = 1; j <= n; j++) {
\r
1476 for (int i = 0; i <= (l1-j); i++) {
\r
1477 char c = *(s1 + i + j);
\r
1478 *(s1 + i + j) = '\0';
\r
1479 if (strstr(t,(s1+i))) ns++;
\r
1480 *(s1 + i + j ) = c;
\r
1482 nscore = nscore + ns;
\r
1483 if (ns < 2) break;
\r
1488 if (uselen == NGRAM_LONGER_WORSE) ns = (l2-l1)-2;
\r
1489 if (uselen == NGRAM_ANY_MISMATCH) ns = abs(l2-l1)-2;
\r
1490 ns = (nscore - ((ns > 0) ? ns : 0));
\r
1494 int SuggestMgr::equalfirstletter(char * s1, const char * s2) {
\r
1496 w_char su1[MAXSWL];
\r
1497 w_char su2[MAXSWL];
\r
1498 // decapitalize dictionary word
\r
1499 if (complexprefixes) {
\r
1500 int l1 = u8_u16(su1, MAXSWL, s1);
\r
1501 int l2 = u8_u16(su2, MAXSWL, s2);
\r
1502 if (*((short *)su1+l1-1) == *((short *)su2+l2-1)) return 1;
\r
1504 u8_u16(su1, 1, s1);
\r
1505 u8_u16(su2, 1, s2);
\r
1506 if (*((short *)su1) == *((short *)su2)) return 1;
\r
1509 if (complexprefixes) {
\r
1510 int l1 = strlen(s1);
\r
1511 int l2 = strlen(s2);
\r
1512 if (*(s2+l1-1) == *(s2+l2-1)) return 1;
\r
1514 if (*s1 == *s2) return 1;
\r
1520 int SuggestMgr::commoncharacterpositions(char * s1, const char * s2, int * is_swap) {
\r
1526 w_char su1[MAXSWL];
\r
1527 w_char su2[MAXSWL];
\r
1528 int l1 = u8_u16(su1, MAXSWL, s1);
\r
1529 int l2 = u8_u16(su2, MAXSWL, s2);
\r
1530 // decapitalize dictionary word
\r
1531 if (complexprefixes) {
\r
1532 mkallsmall_utf(su2+l2-1, 1, pAMgr->get_langnum());
\r
1534 mkallsmall_utf(su2, 1, pAMgr->get_langnum());
\r
1536 for (int i = 0; (i < l1) && (i < l2); i++) {
\r
1537 if (((short *) su1)[i] == ((short *) su2)[i]) {
\r
1540 if (diff < 2) diffpos[diff] = i;
\r
1544 if ((diff == 2) && (l1 == l2) &&
\r
1545 (((short *) su1)[diffpos[0]] == ((short *) su2)[diffpos[1]]) &&
\r
1546 (((short *) su1)[diffpos[1]] == ((short *) su2)[diffpos[0]])) *is_swap = 1;
\r
1549 char t[MAXSWUTF8L];
\r
1551 // decapitalize dictionary word
\r
1552 if (complexprefixes) {
\r
1553 int l2 = strlen(t);
\r
1554 *(t+l2-1) = csconv[((unsigned char)*(t+l2-1))].clower;
\r
1556 mkallsmall(t, csconv);
\r
1558 for (i = 0; (*(s1+i) != 0) && (*(t+i) != 0); i++) {
\r
1559 if (*(s1+i) == *(t+i)) {
\r
1562 if (diff < 2) diffpos[diff] = i;
\r
1566 if ((diff == 2) && (*(s1+i) == 0) && (*(t+i) == 0) &&
\r
1567 (*(s1+diffpos[0]) == *(t+diffpos[1])) &&
\r
1568 (*(s1+diffpos[1]) == *(t+diffpos[0]))) *is_swap = 1;
\r
1573 int SuggestMgr::mystrlen(const char * word) {
\r
1576 return u8_u16(w, MAXSWL, word);
\r
1577 } else return strlen(word);
\r
1580 // sort in decreasing order of score
\r
1581 void SuggestMgr::bubblesort(char** rword, int* rsc, int n )
\r
1587 if (rsc[j-1] < rsc[j]) {
\r
1588 int sctmp = rsc[j-1];
\r
1589 char * wdtmp = rword[j-1];
\r
1590 rsc[j-1] = rsc[j];
\r
1591 rword[j-1] = rword[j];
\r
1602 // longest common subsequence
\r
1603 void SuggestMgr::lcs(const char * s, const char * s2, int * l1, int * l2, char ** result) {
\r
1605 w_char su[MAXSWL];
\r
1606 w_char su2[MAXSWL];
\r
1612 m = u8_u16(su, MAXSWL, s);
\r
1613 n = u8_u16(su2, MAXSWL, s2);
\r
1618 c = (char *) malloc((m + 1) * (n + 1));
\r
1619 b = (char *) malloc((m + 1) * (n + 1));
\r
1620 for (i = 1; i <= m; i++) c[i*(n+1)] = 0;
\r
1621 for (j = 0; j <= n; j++) c[j] = 0;
\r
1622 for (i = 1; i <= m; i++) {
\r
1623 for (j = 1; j <= n; j++) {
\r
1624 if ((utf8) && (*((short *) su+i-1) == *((short *)su2+j-1))
\r
1625 || (!utf8) && ((*(s+i-1)) == (*(s2+j-1)))) {
\r
1626 c[i*(n+1) + j] = c[(i-1)*(n+1) + j-1]+1;
\r
1627 b[i*(n+1) + j] = LCS_UPLEFT;
\r
1628 } else if (c[(i-1)*(n+1) + j] >= c[i*(n+1) + j-1]) {
\r
1629 c[i*(n+1) + j] = c[(i-1)*(n+1) + j];
\r
1630 b[i*(n+1) + j] = LCS_UP;
\r
1632 c[i*(n+1) + j] = c[i*(n+1) + j-1];
\r
1633 b[i*(n+1) + j] = LCS_LEFT;
\r
1643 int SuggestMgr::lcslen(const char * s, const char* s2) {
\r
1650 lcs(s, s2, &m, &n, &result);
\r
1653 while ((i != 0) && (j != 0)) {
\r
1654 if (result[i*(n+1) + j] == LCS_UPLEFT) {
\r
1658 } else if (result[i*(n+1) + j] == LCS_UP) {
\r
1662 if (result) free(result);
\r