Attachment #501038 for bug #620626

Attachment #501038: Release Hunspell 1.2.13 patch for bug #620626

View | Details | Raw Unified | Return to bug 620626
Collapse All | Expand All





* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
******* END LICENSE BLOCK *******

Hunspell Version: 1.2.13
Additional Patches: 

Hunspell Author: László Németh
MySpell Author: Kevin Hendricks & David Einstein

Hunspell is a spell checker and morphological analyser library. Hunspell
is based on OpenOffice.org's Myspell. Documentation, tests, and examples
are available at http://hunspell.sourceforge.net.






                pos = st; break;
            }
        case '^': { p = nextchar(p); neg = true; break; }
        case ']': { 
                if ((neg && ingroup) || (!neg && !ingroup)) return 0;
                pos = NULL;
                p = nextchar(p);
                // skip the next character
                if (!ingroup && *st) for (st++; (opts & aeUTF8) && (*st & 0xc0) == 0x80; st++);
                if (*st == '\0' && p) return 0; // word <= condition
                break;
            }
         case '.': if (!pos) { // dots are not metacharacters in groups: [.]
                p = nextchar(p);
                // skip the next character
                for (st++; (opts & aeUTF8) && (*st & 0xc0) == 0x80; st++);
                if (*st == '\0' && p) return 0; // word <= condition





  trystring = NULL;
  encoding=NULL;
  csconv=NULL;
  utf8 = 0;
  complexprefixes = 0;
  maptable = NULL;
  nummap = 0;
  breaktable = NULL;
  numbreak = -1;
  reptable = NULL;
  numrep = 0;
  iconvtable = NULL;
  oconvtable = NULL;
  checkcpdtable = NULL;
  // allow simplified compound forms (see 3rd field of CHECKCOMPOUNDPATTERN)
  simplifiedcpd = 0;
  numcheckcpd = 0;

                *(expw + strlen(expw)) = (char) i;
        }
    }

    wordchars = mystrdup(expw);
    }

    // default BREAK definition
    if (numbreak == -1) {
        breaktable = (char **) malloc(sizeof(char *) * 3);
        if (!breaktable) return 1;
        breaktable[0] = mystrdup("-");
        breaktable[1] = mystrdup("^-");
        breaktable[2] = mystrdup("-$");
        if (breaktable[0] && breaktable[1] && breaktable[2]) numbreak = 3;
    }
    return 0;

          if (candidate_check(candidate,strlen(candidate))) return 1;
          r++; // search for the next letter
      }
   }
   return 0;
}

// forbid compoundings when there are special patterns at word bound
int AffixMgr::cpdpat_check(const char * word, int pos, hentry * r1, hentry * r2, const char affixed)
{
  int len;
  for (int i = 0; i < numcheckcpd; i++) {
      if (isSubset(checkcpdtable[i].pattern2, word + pos) &&
        (!r1 || !checkcpdtable[i].cond ||
          (r1->astr && TESTAFF(r1->astr, checkcpdtable[i].cond, r1->alen))) &&
        (!r2 || !checkcpdtable[i].cond2 ||
          (r2->astr && TESTAFF(r2->astr, checkcpdtable[i].cond2, r2->alen))) &&
        // zero length pattern => only TESTAFF
        // zero pattern (0/flag) => unmodified stem (zero affixes allowed)
        (!*(checkcpdtable[i].pattern) || (
            (*(checkcpdtable[i].pattern)=='0' && r1->blen <= pos && strncmp(word + pos - r1->blen, r1->word, r1->blen) == 0) ||
            (*(checkcpdtable[i].pattern)!='0' && (len = strlen(checkcpdtable[i].pattern)) &&
                strncmp(word + pos - len, checkcpdtable[i].pattern, len) == 0)))) {
            return 1;
        }
  }
  return 0;
}

// forbid compounding with neighbouring upper and lower case characters at word bounds
int AffixMgr::cpdcase_check(const char * word, int pos)
{
  if (utf8) {

          for ((*cmax)--; (word[*cmax] & 0xc0) == 0x80; (*cmax)--);
        }
    } else {
        *cmin = cpdmin;
        *cmax = len - cpdmin + 1;
    }
}


// check if compound word is correctly spelled
// hu_mov_rule = spec. Hungarian rule (XXX)
struct hentry * AffixMgr::compound_check(const char * word, int len, 
    short wordnum, short numsyllable, short maxwordnum, short wnum, hentry ** words = NULL,
    char hu_mov_rule = 0, char is_sug = 0)
{
    int i; 
    short oldnumsyllable, oldnumsyllable2, oldwordnum, oldwordnum2;

    int cmax;
    int striple = 0;
    int scpd = 0;
    int soldi = 0;
    int oldcmin = 0;
    int oldcmax = 0;
    int oldlen = 0;
    int checkedstriple = 0;
    int onlycpdrule;
    int affixed = 0;

    int checked_prefix;

    setcminmax(&cmin, &cmax, word, len);

    strcpy(st, word);

    for (i = cmin; i < cmax; i++) {

        oldnumsyllable = numsyllable;
        oldwordnum = wordnum;
        checked_prefix = 0;

        // go to end of the UTF-8 character
        if (utf8) {
            for (; (st[i] & 0xc0) == 0x80; i++);
            if (i >= cmax) return NULL;
        }

        onlycpdrule = 0;

        do { // onlycpdrule loop

        oldnumsyllable = numsyllable;
        oldwordnum = wordnum;
        checked_prefix = 0;

        do { // simplified checkcompoundpattern loop

        if (scpd > 0) {
          for (; scpd <= numcheckcpd && (!checkcpdtable[scpd-1].pattern3 ||
            strncmp(word + i, checkcpdtable[scpd-1].pattern3, strlen(checkcpdtable[scpd-1].pattern3)) != 0); scpd++);

          if (scpd > numcheckcpd) break; // break simplified checkcompoundpattern loop
          strcpy(st + i, checkcpdtable[scpd-1].pattern);

          len += strlen(checkcpdtable[scpd-1].pattern) + strlen(checkcpdtable[scpd-1].pattern2) - strlen(checkcpdtable[scpd-1].pattern3);
          oldcmin = cmin;
          oldcmax = cmax;
          setcminmax(&cmin, &cmax, st, len);

          cmax = len - cpdmin + 1;
        }


        ch = st[i];
        st[i] = '\0';

        sfx = NULL;
        pfx = NULL;

        // FIRST WORD

        affixed = 1;
        rv = lookup(st); // perhaps without prefix

        // search homonym with compound flag
        while ((rv) && !hu_mov_rule &&
            ((needaffix && TESTAFF(rv->astr, needaffix, rv->alen)) ||
                !((compoundflag && !words && !onlycpdrule && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
                  (compoundbegin && !wordnum && !onlycpdrule && 
                        TESTAFF(rv->astr, compoundbegin, rv->alen)) ||
                  (compoundmiddle && wordnum && !words && !onlycpdrule &&
                    TESTAFF(rv->astr, compoundmiddle, rv->alen)) ||
                  (numdefcpd &&
                    ((!words && !wordnum && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0)) ||
                    (words && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0))) && (onlycpdrule = 1))) || // switch onlycpdrule on
                  (scpd != 0 && checkcpdtable[scpd-1].cond != FLAG_NULL &&
                    !TESTAFF(rv->astr, checkcpdtable[scpd-1].cond, rv->alen)))
                  ) {
            rv = rv->next_homonym;
        }

        if (rv) affixed = 0;

        if (!rv) {
            if (onlycpdrule) break;
            if (compoundflag && 
             !(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundflag))) {
                if ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL,
                        FLAG_NULL, compoundflag, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) && !hu_mov_rule &&
                    sfx->getCont() &&
                        ((compoundforbidflag && TESTAFF(sfx->getCont(), compoundforbidflag, 
                            sfx->getContLen())) || (compoundend &&
                        TESTAFF(sfx->getCont(), compoundend, 

                ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundbegin, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||
                (rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundbegin)))) ||
              ((wordnum > 0) && compoundmiddle &&
                ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundmiddle, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||
                (rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundmiddle)))))
              ) checked_prefix = 1;
        // else check forbiddenwords and needaffix
        } else if (rv->astr && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
            TESTAFF(rv->astr, needaffix, rv->alen) ||
            TESTAFF(rv->astr, ONLYUPCASEFLAG, rv->alen) ||
            (is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen))
             )) {
                st[i] = ch;
                //continue;
                break;
        }

            // check non_compound flag in suffix and prefix
            if ((rv) && !hu_mov_rule &&
                ((pfx && pfx->getCont() &&
                    TESTAFF(pfx->getCont(), compoundforbidflag, 
                        pfx->getContLen())) ||
                (sfx && sfx->getCont() &&

                (sfx && sfx->getCont() &&
                    TESTAFF(sfx->getCont(), compoundmiddle, 
                        sfx->getContLen())))) {
                    rv = NULL;
            }

        // check forbiddenwords
        if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
            TESTAFF(rv->astr, ONLYUPCASEFLAG, rv->alen) ||
            (is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) {
                return NULL;
            }

        // increment word number, if the second root has a compoundroot flag
        if ((rv) && compoundroot && 
            (TESTAFF(rv->astr, compoundroot, rv->alen))) {
                wordnum++;

                // calculate syllable number of the word
                numsyllable += get_syllable(st, i);

                // + 1 word, if syllable number of the prefix > 1 (hungarian convention)
                if (pfx && (get_syllable(pfx->getKey(),strlen(pfx->getKey())) > 1)) wordnum++;
            }
// END of LANG_hu section


            // NEXT WORD(S)
            rv_first = rv;
            st[i] = ch;

        do { // striple loop

            // check simplifiedtriple
            if (simplifiedtriple) { 

            // increment word number, if the second root has a compoundroot flag
            if ((rv) && (compoundroot) && 
                (TESTAFF(rv->astr, compoundroot, rv->alen))) {
                    wordnum++;
            }

            // check forbiddenwords
            if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
                TESTAFF(rv->astr, ONLYUPCASEFLAG, rv->alen) ||
               (is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) return NULL;

            // second word is acceptable, as a root?
            // hungarian conventions: compounding is acceptable,
            // when compound forms consist of 2 words, or if more,
            // then the syllable number of root words must be 6, or lesser.

            if ((rv) && (

                    )
                && (
                      ((cpdwordmax==-1) || (wordnum+1<cpdwordmax)) || 
                      ((cpdmaxsyllable!=0) && 
                          (numsyllable + get_syllable(HENTRY_WORD(rv), rv->clen)<=cpdmaxsyllable))
                    ) &&
               (
                 // test CHECKCOMPOUNDPATTERN
                 !numcheckcpd || scpd != 0 || !cpdpat_check(word, i, rv_first, rv, 0)
               ) &&
                (
                     (!checkcompounddup || (rv != rv_first))
                   )
            // test CHECKCOMPOUNDPATTERN conditions
                && (scpd == 0 || checkcpdtable[scpd-1].cond2 == FLAG_NULL ||
                      TESTAFF(rv->astr, checkcpdtable[scpd-1].cond2, rv->alen))
                )

            }

            numsyllable = oldnumsyllable2;
            wordnum = oldwordnum2;

            // perhaps second word has prefix or/and suffix
            sfx = NULL;
            sfxflag = FLAG_NULL;
            rv = (compoundflag && !onlycpdrule) ? affix_check((word+i),strlen(word+i), compoundflag, IN_CPD_END) : NULL;
            if (!rv && compoundend && !onlycpdrule) {
                sfx = NULL;
                pfx = NULL;
                rv = affix_check((word+i),strlen(word+i), compoundend, IN_CPD_END);
            }

            if (!rv && numdefcpd && words) {
                rv = affix_check((word+i),strlen(word+i), 0, IN_CPD_END);
                if (rv && defcpd_check(&words, wnum + 1, rv, NULL, 1)) return rv_first;
                rv = NULL;
            }

            // test CHECKCOMPOUNDPATTERN conditions (allowed forms)
            if (rv && !(scpd == 0 || checkcpdtable[scpd-1].cond2 == FLAG_NULL || 
                TESTAFF(rv->astr, checkcpdtable[scpd-1].cond2, rv->alen))) rv = NULL;

            // test CHECKCOMPOUNDPATTERN conditions (forbidden compounds)
            if (rv && numcheckcpd && scpd == 0 && cpdpat_check(word, i, rv_first, rv, affixed)) rv = NULL;

            // check non_compound flag in suffix and prefix
            if ((rv) && 
                ((pfx && pfx->getCont() &&
                    TESTAFF(pfx->getCont(), compoundforbidflag, 
                        pfx->getContLen())) ||
                (sfx && sfx->getCont() &&
                    TESTAFF(sfx->getCont(), compoundforbidflag, 
                        sfx->getContLen())))) {
                    rv = NULL;
            }

            // check forbiddenwords
            if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
                TESTAFF(rv->astr, ONLYUPCASEFLAG, rv->alen) ||
               (is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) return NULL;

            // pfxappnd = prefix of word+i, or NULL
            // calculate syllable number of prefix.
            // hungarian convention: when syllable number of prefix is more,
            // than 1, the prefix+word counts as two words.

            if (langnum == LANG_hu) {


                // increment syllable num, if last word has a SYLLABLENUM flag
                // and the suffix is beginning `s'

                if (cpdsyllablenum) {
                    switch (sfxflag) {
                        case 'c': { numsyllable+=2; break; }
                        case 'J': { numsyllable += 1; break; }
                        case 'I': { if (rv && TESTAFF(rv->astr, 'J', rv->alen)) numsyllable += 1; break; }
                    }
                }
            }

            // increment word number, if the second word has a compoundroot flag
            if ((rv) && (compoundroot) && 
                (TESTAFF(rv->astr, compoundroot, rv->alen))) {
                    wordnum++;


            numsyllable = oldnumsyllable2;
            wordnum = oldwordnum2;

            // perhaps second word is a compound word (recursive call)
            if (wordnum < maxwordnum) {
                rv = compound_check((st+i),strlen(st+i), wordnum+1,
                     numsyllable, maxwordnum, wnum + 1, words, 0, is_sug);
                if (rv && numcheckcpd && ((scpd == 0 && cpdpat_check(word, i, rv_first, rv, affixed)) ||
                   (scpd != 0 && !cpdpat_check(word, i, rv_first, rv, affixed)))) rv = NULL;
            } else {
                rv=NULL;
            }
            if (rv) {
                // forbid compound word, if it is a non compound word with typical fault
                if (checkcompoundrep || forbiddenword) {
                    struct hentry * rv2 = NULL;
                    if (checkcompoundrep && cpdrep_check(word, len)) return NULL;
                    // check first part
                    if (strncmp(rv->word, word + i, rv->blen) == 0) {
                        char r = *(st + i + rv->blen);
                        *(st + i + rv->blen) = '\0';
                        if (checkcompoundrep && cpdrep_check(st, i + rv->blen)) return NULL;
                        if (forbiddenword) {
                    	    rv2 = lookup(word);
                    	    if (!rv2) rv2 = affix_check(word, len);
                    	    if (rv2 && rv2->astr && TESTAFF(rv2->astr, forbiddenword, rv2->alen) && 
                    		(strncmp(rv2->word, st, i + rv->blen) == 0)) {
                		    return NULL;
                	    }
                	}
                	*(st + i + rv->blen) = r;
                    }
                }

                return rv_first;
            }
          } while (striple && !checkedstriple); // end of striple loop

          if (checkedstriple) {
            i++;
            checkedstriple = 0;
            striple = 0;

          i = soldi;
          soldi = 0;
          len = oldlen;
          cmin = oldcmin;
          cmax = oldcmax;
        }
        scpd++;

        } while (!onlycpdrule && simplifiedcpd && scpd <= numcheckcpd); // end of simplifiedcpd loop

        scpd = 0;
        wordnum = oldwordnum;
        numsyllable = oldnumsyllable;

        if (soldi != 0) {
          i = soldi;
          strcpy(st, word); // XXX add more optim.
          soldi = 0;
        } else st[i] = ch;

        } while (numdefcpd && oldwordnum == 0 && !onlycpdrule && (onlycpdrule = 1)); // end of onlycpd loop

        numsyllable = oldnumsyllable;
    }

    return NULL;
}

// check if compound word is correctly spelled
// hu_mov_rule = spec. Hungarian rule (XXX)
int AffixMgr::compound_check_morph(const char * word, int len, 

                    sprintf(presult + strlen(presult), "%c%s%s%s", MSEP_FLD,
                        MORPH_PART, st, line_uniq_app(&p, MSEP_REC));
                }
                if (p) free(p);
                checked_prefix = 1;
            }
        // else check forbiddenwords
        } else if (rv->astr && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
            TESTAFF(rv->astr, ONLYUPCASEFLAG, rv->alen) ||
            TESTAFF(rv->astr, needaffix, rv->alen))) {
                st[i] = ch;
                continue;
        }

            // check non_compound flag in suffix and prefix
            if ((rv) && !hu_mov_rule &&
                ((pfx && pfx->getCont() &&

                        pfx->getContLen())) ||
                (sfx && sfx->getCont() &&
                    TESTAFF(sfx->getCont(), compoundmiddle, 
                        sfx->getContLen())))) {
                    rv = NULL;
            }       

        // check forbiddenwords
        if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen)
            || TESTAFF(rv->astr, ONLYUPCASEFLAG, rv->alen))) continue;

        // increment word number, if the second root has a compoundroot flag
        if ((rv) && (compoundroot) && 
            (TESTAFF(rv->astr, compoundroot, rv->alen))) {
                wordnum++;
        }

        // first word is acceptable in compound words?

          && ! (( checkcompoundtriple && !words && // test triple letters
                   (word[i-1]==word[i]) && (
                      ((i>1) && (word[i-1]==word[i-2])) || 
                      ((word[i-1]==word[i+1])) // may be word[i+1] == '\0'
                   )
               ) ||
               (
                   // test CHECKCOMPOUNDPATTERN
                   numcheckcpd && !words && cpdpat_check(word, i, rv, NULL, 0)
               ) ||
               ( 
                 checkcompoundcase && !words && cpdcase_check(word, i)
               ))
         )
// LANG_hu section: spec. Hungarian rule
         || ((!rv) && (langnum == LANG_hu) && hu_mov_rule && (rv = affix_check(st,i)) &&
              (sfx && sfx->getCont() && (

// END of LANG_hu section
            // increment word number, if the second root has a compoundroot flag
            if ((rv) && (compoundroot) && 
                (TESTAFF(rv->astr, compoundroot, rv->alen))) {
                    wordnum++;
            }

            // check forbiddenwords
            if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
                TESTAFF(rv->astr, ONLYUPCASEFLAG, rv->alen))) {
                st[i] = ch;
                continue;
            }

            // second word is acceptable, as a root?
            // hungarian conventions: compounding is acceptable,
            // when compound forms consist of 2 words, or if more,
            // then the syllable number of root words must be 6, or lesser.

                        pfx->getContLen())) ||
                (sfx && sfx->getCont() &&
                    TESTAFF(sfx->getCont(), compoundforbidflag, 
                        sfx->getContLen())))) {
                    rv = NULL;
            }

            // check forbiddenwords
            if ((rv) && (rv->astr) && (TESTAFF(rv->astr,forbiddenword,rv->alen) ||
                    TESTAFF(rv->astr, ONLYUPCASEFLAG, rv->alen))
                    && (! TESTAFF(rv->astr, needaffix, rv->alen))) {
                        st[i] = ch;
                        continue;
                    }

            if (langnum == LANG_hu) {
                // calculate syllable number of the word
                numsyllable += get_syllable(word + i, strlen(word + i));


                int cmp = morphcmp(stemmorph, targetmorph);

                if (cmp == 0) {
                    char * newword = sptr->add(ts, wl);
                    if (newword) {
                        hentry * check = pHMgr->lookup(newword); // XXX extra dic
                        if (!check || !check->astr || 
                            !(TESTAFF(check->astr, forbiddenword, check->alen) || 
                              TESTAFF(check->astr, ONLYUPCASEFLAG, check->alen))) {
                                return newword;
                        }
                        free(newword);
                    }
                }
                
                // recursive call for secondary suffixes
                if ((level == 0) && (cmp == 1) && (sptr->getContLen() > 0) &&

                  case 0: {
                             if (strncmp(piece,"REP",3) != 0) {
                                 HUNSPELL_WARNING(stderr, "error: line %d: table is corrupt\n", af->getlinenum());
                                 numrep = 0;
                                 return 1;
                             }
                             break;
                          }
                  case 1: {
                            if (*piece == '^') reptable[j].start = true; else reptable[j].start = false;
                            reptable[j].pattern = mystrrep(mystrdup(piece + int(reptable[j].start)),"_"," ");
                            int lr = strlen(reptable[j].pattern) - 1;
                            if (reptable[j].pattern[lr] == '$') {
                                reptable[j].end = true;
                                reptable[j].pattern[lr] = '\0';
                            } else reptable[j].end = false;
                            break;
                          }
                  case 2: { reptable[j].pattern2 = mystrrep(mystrdup(piece),"_"," "); break; }
                  default: break;
               }
               i++;
           }
           piece = mystrsep(&tp, 0);
        }
        if ((!(reptable[j].pattern)) || (!(reptable[j].pattern2))) {

                  }
                  default: break;
               }
               i++;
           }
           piece = mystrsep(&tp, 0);
        }
        if (!pattern || !pattern2) {
            if (pattern)
                free(pattern);
            if (pattern2)
                free(pattern2);
            HUNSPELL_WARNING(stderr, "error: line %d: table is corrupt\n", af->getlinenum());
            return 1;
        }
        (*rl)->add(pattern, pattern2);
   }
   return 0;
}


/* parse in the typical fault correcting table */

        }
   }
   return 0;
}

/* parse in the word breakpoint table */
int  AffixMgr::parse_breaktable(char * line, FileMgr * af)
{
   if (numbreak > -1) {
      HUNSPELL_WARNING(stderr, "error: line %d: multiple table definitions\n", af->getlinenum());
      return 1;
   }
   char * tp = line;
   char * piece;
   int i = 0;
   int np = 0;
   piece = mystrsep(&tp, 0);
   while (piece) {
       if (*piece != '\0') {
          switch(i) {
             case 0: { np++; break; }
             case 1: { 
                       numbreak = atoi(piece);
                       if (numbreak < 0) {
                          HUNSPELL_WARNING(stderr, "error: line %d: bad entry number\n", af->getlinenum());
                          return 1;
                       }
                       if (numbreak == 0) return 0;
                       breaktable = (char **) malloc(numbreak * sizeof(char *));
                       if (!breaktable) return 1;
                       np++;
                       break;
                     }
             default: break;
          }
          i++;





            unsigned short al, char * morph, char * targetmorph, int level);

  int    expand_rootword(struct guessword * wlst, int maxn, const char * ts,
            int wl, const unsigned short * ap, unsigned short al, char * bad,
            int, char *);

  short       get_syllable (const char * word, int wlen);
  int         cpdrep_check(const char * word, int len);
  int         cpdpat_check(const char * word, int len, hentry * r1, hentry * r2,
                    const char affixed);
  int         defcpd_check(hentry *** words, short wnum, hentry * rv,
                    hentry ** rwords, char all);
  int         cpdcase_check(const char * word, int len);
  inline int  candidate_check(const char * word, int len);
  void        setcminmax(int * cmin, int * cmax, const char * word, int len);
  struct hentry * compound_check(const char * word, int len, short wordnum,
            short numsyllable, short maxwordnum, short wnum, hentry ** words,
            char hu_mov_rule, char is_sug);





#include <string.h>
#include <stdio.h> 
#include <ctype.h>

#include "csutil.hxx"
#include "atypes.hxx"
#include "langnum.hxx"

// Unicode character encoding information
struct unicode_info {
  unsigned short c;
  unsigned short cupper;
  unsigned short clower;
};

#ifdef OPENOFFICEORG
#  include <unicode/uchar.h>
#else
#  ifndef MOZILLA_CLIENT
#    include "utf_info.cxx"
#    define UTF_LST_LEN (sizeof(utf_lst) / (sizeof(unicode_info)))
#  endif
#endif

#ifdef MOZILLA_CLIENT
#include "nsCOMPtr.h"
#include "nsServiceManagerUtils.h"
#include "nsIUnicodeEncoder.h"
#include "nsIUnicodeDecoder.h"
#include "nsICaseConversion.h"
#include "nsICharsetConverterManager.h"
#include "nsUnicharUtilCIID.h"
#include "nsUnicharUtils.h"

static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
static NS_DEFINE_CID(kUnicharUtilCID, NS_UNICHARUTIL_CID);
#endif

struct unicode_info2 {
  char cletter;
  unsigned short cupper;
  unsigned short clower;
};

static struct unicode_info2 * utf_tbl = NULL;
static int utf_tbl_count = 0; // utf_tbl can be used by multiple Hunspell instances

/* only UTF-16 (BMP) implementation */
char * u16_u8(char * dest, int size, const w_char * src, int srclen) {
    signed char * u8 = (signed char *)dest;
    signed char * u8_max = (signed char *)(u8 + size);
    const w_char * u2 = src;

       return dest;
  }
  return NULL;
}

char * mystrrep(char * word, const char * pat, const char * rep) {
    char * pos = strstr(word, pat);
    if (pos) {
      int replen = strlen(rep);
      int patlen = strlen(pat);
      while (pos) {
        if (replen < patlen) {
            char * end = word + strlen(word);
            char * next = pos + replen;
            char * prev = pos + strlen(pat);
            for (; prev < end; *next = *prev, prev++, next++);
            *next = '\0';
        } else if (replen > patlen) {
            char * end = pos + patlen;
            char * next = word + strlen(word) + replen - patlen;
            char * prev = next - replen + patlen;
            for (; prev >= end; *next = *prev, prev--, next--);
        }
        strncpy(pos, rep, replen);
        pos = strstr(word, pat);
      }
    }
    return word;
}

 // reverse word 
 int reverseword(char * word) {
   char r;
   for (char * dest = word + strlen(word) - 1; word < dest; word++, dest--) {

{ 0x00, 0xfa, 0xfa },
{ 0x00, 0xfb, 0xfb },
{ 0x00, 0xfc, 0xfc },
{ 0x00, 0xfd, 0xfd },
{ 0x00, 0xfe, 0xfe },
{ 0x00, 0xff, 0xff }
};

struct enc_entry {
  const char * enc_name;
  struct cs_info * cs_table;
{"ISO8859-3",iso3_tbl},
{"ISO8859-4",iso4_tbl},
{"ISO8859-5",iso5_tbl},
{"ISO8859-6",iso6_tbl},
{"ISO8859-7",iso7_tbl},
{"ISO8859-8",iso8_tbl},
{"ISO8859-9",iso9_tbl},
{"ISO8859-10",iso10_tbl},
{"KOI8-R",koi8r_tbl},
{"KOI8-U",koi8u_tbl},
{"microsoft-cp1251",cp1251_tbl},
{"ISO8859-13", iso13_tbl},
{"ISO8859-14", iso14_tbl},
{"ISO8859-15", iso15_tbl},
{"ISCII-DEVANAGARI", iscii_devanagari_tbl}
};

static struct enc_entry encds[] = {
  {"iso88591",iso1_tbl},                     //ISO-8859-1
  {"iso88592",iso2_tbl},                     //ISO-8859-2
  {"iso88593",iso3_tbl},                     //ISO-8859-3
  {"iso88594",iso4_tbl},                     //ISO-8859-4
  {"iso88595",iso5_tbl},                     //ISO-8859-5
  {"iso88596",iso6_tbl},                     //ISO-8859-6
  {"iso88597",iso7_tbl},                     //ISO-8859-7
  {"iso88598",iso8_tbl},                     //ISO-8859-8
  {"iso88599",iso9_tbl},                     //ISO-8859-9
  {"iso885910",iso10_tbl},                   //ISO-8859-10
  {"iso885913", iso13_tbl},                  //ISO-8859-13
  {"iso885914", iso14_tbl},                  //ISO-8859-14
  {"iso885915", iso15_tbl},                  //ISO-8859-15
  {"koi8r",koi8r_tbl},                       //KOI8-R
  {"koi8u",koi8u_tbl},                       //KOI8-U
  {"cp1251",cp1251_tbl},                     //CP-1251
  {"microsoftcp1251",cp1251_tbl},            //microsoft-cp1251
  {"xisciias", iscii_devanagari_tbl},        //x-iscii-as
  {"isciidevanagari", iscii_devanagari_tbl}  //ISCII-DEVANAGARI
};

/* map to lower case and remove non alphanumeric chars */
static void toAsciiLowerAndRemoveNonAlphanumeric( const char* pName, char* pBuf )
{
    while ( *pName )
    {
        /* A-Z */
        if ( (*pName >= 0x41) && (*pName <= 0x5A) )
        {
            *pBuf = (*pName)+0x20;  /* toAsciiLower */
            pBuf++;
        }
        /* a-z, 0-9 */
        else if ( ((*pName >= 0x61) && (*pName <= 0x7A)) ||
                  ((*pName >= 0x30) && (*pName <= 0x39)) )
        {
            *pBuf = *pName;
            pBuf++;
        }

        pName++;
    }

    *pBuf = '\0';
}

struct cs_info * get_current_cs(const char * es) {
  char *normalized_encoding = new char[strlen(es)+1];
  toAsciiLowerAndRemoveNonAlphanumeric(es, normalized_encoding);

  struct cs_info * ccs = NULL;
  int n = sizeof(encds) / sizeof(encds[0]);
  for (int i = 0; i < n; i++) {
    if (strcmp(normalized_encoding,encds[i].enc_name) == 0) {
      ccs = encds[i].cs_table;
      break;
    }
  }

  delete[] normalized_encoding;

  if (!ccs) {
    HUNSPELL_WARNING(stderr, "error: unknown encoding %s: using %s as fallback\n", es, encds[0].enc_name);
    ccs = encds[0].cs_table;
  }

  return ccs;
}
#else
// XXX This function was rewritten for mozilla. Instead of storing the
// conversion tables static in this file, create them when needed
// with help the mozilla backend.
struct cs_info * get_current_cs(const char * es) {
  struct cs_info *ccs;

  nsCOMPtr<nsIUnicodeEncoder> encoder; 
  nsCOMPtr<nsIUnicodeDecoder> decoder; 
  nsCOMPtr<nsICaseConversion> caseConv;

  nsresult rv;
  nsCOMPtr<nsICharsetConverterManager> ccm = do_GetService(kCharsetConverterManagerCID, &rv);
  if (NS_FAILED(rv))
    return nsnull;

  rv = ccm->GetUnicodeEncoder(es, getter_AddRefs(encoder));
  if (NS_FAILED(rv))
    return nsnull;
  encoder->SetOutputErrorBehavior(encoder->kOnError_Signal, nsnull, '?');
  rv = ccm->GetUnicodeDecoder(es, getter_AddRefs(decoder));
  if (NS_FAILED(rv))
    return nsnull;
  decoder->SetInputErrorBehavior(decoder->kOnError_Signal);

  caseConv = do_GetService(kUnicharUtilCID, &rv);
  if (NS_FAILED(rv))
    return nsnull;

  ccs = new cs_info[256];

  for (unsigned int i = 0; i <= 0xff; ++i) {
    PRBool success = PR_FALSE;
    // We want to find the upper/lowercase equivalents of each byte
    // in this 1-byte character encoding.  Call our encoding/decoding
    // APIs separately for each byte since they may reject some of the
    // bytes, and we want to handle errors separately for each byte.

      PRUnichar uni, uniCased;
      PRInt32 charLength = 1, uniLength = 1;

      rv = decoder->Convert(&source, &charLength, &uni, &uniLength);
      // Explicitly check NS_OK because we don't want to allow
      // NS_OK_UDEC_MOREOUTPUT or NS_OK_UDEC_MOREINPUT.
      if (rv != NS_OK || charLength != 1 || uniLength != 1)
        break;
      rv = caseConv->ToLower(uni, &uniCased);
      if (NS_FAILED(rv))
        break;
      rv = encoder->Convert(&uniCased, &uniLength, &lower, &charLength);
      // Explicitly check NS_OK because we don't want to allow
      // NS_OK_UDEC_MOREOUTPUT or NS_OK_UDEC_MOREINPUT.
      if (rv != NS_OK || charLength != 1 || uniLength != 1)
        break;

      rv = caseConv->ToUpper(uni, &uniCased);
      if (NS_FAILED(rv))
        break;
      rv = encoder->Convert(&uniCased, &uniLength, &upper, &charLength);
      // Explicitly check NS_OK because we don't want to allow
      // NS_OK_UDEC_MOREOUTPUT or NS_OK_UDEC_MOREINPUT.
      if (rv != NS_OK || charLength != 1 || uniLength != 1)
        break;

      success = PR_TRUE;
    } while (0);

    }
    *p = '\0';
#ifdef MOZILLA_CLIENT
    delete [] csconv;
#endif
    return mystrdup(expw);
}

// language to encoding default map

struct lang_map {
  const char * lang;
  int num;
};

static struct lang_map lang2enc[] = {
{"ar", LANG_ar},
{"az", LANG_az},
{"bg", LANG_bg},
{"ca", LANG_ca},
{"cs", LANG_cs},
{"da", LANG_da},
{"de", LANG_de},
{"el", LANG_el},
{"en", LANG_en},
{"es", LANG_es},
{"eu", LANG_eu},
{"gl", LANG_gl},
{"fr", LANG_fr},
{"hr", LANG_hr},
{"hu", LANG_hu},
{"it", LANG_it},
{"la", LANG_la},
{"lv", LANG_lv},
{"nl", LANG_nl},
{"pl", LANG_pl},
{"pt", LANG_pt},
{"sv", LANG_sv},
{"tr", LANG_tr},
{"ru", LANG_ru},
{"uk", LANG_uk}
};


const char * get_default_enc(const char * lang) {
  int n = sizeof(lang2enc) / sizeof(lang2enc[0]);
  for (int i = 0; i < n; i++) {
    if (strcmp(lang,lang2enc[i].lang) == 0) {
      return lang2enc[i].def_enc;
    }
  }
  return NULL;
}

int get_lang_num(const char * lang) {
  int n = sizeof(lang2enc) / sizeof(lang2enc[0]);
  for (int i = 0; i < n; i++) {
    if (strcmp(lang, lang2enc[i].lang) == 0) {
      return lang2enc[i].num;
    }
  }
  return LANG_xx;
}

#ifndef OPENOFFICEORG
#ifndef MOZILLA_CLIENT

void free_utf_tbl() {
  if (utf_tbl_count > 0) utf_tbl_count--;
  if (utf_tbl && (utf_tbl_count == 0)) {
    free(utf_tbl);
    utf_tbl = NULL;
  }
}

#ifdef MOZILLA_CLIENT
static nsCOMPtr<nsICaseConversion>& getcaseConv()
{
  nsresult rv;
  static nsCOMPtr<nsICaseConversion> caseConv = do_GetService(kUnicharUtilCID, &rv);
  return caseConv;
}
#endif

unsigned short unicodetoupper(unsigned short c, int langnum)
{
  // In Azeri and Turkish, I and i dictinct letters:
  // There are a dotless lower case i pair of upper `I',
  // and an upper I with dot pair of lower `i'. 
  if (c == 0x0069 && ((langnum == LANG_az) || (langnum == LANG_tr)))
    return 0x0130;
#ifdef OPENOFFICEORG
  return u_toupper(c);
#else
#ifdef MOZILLA_CLIENT
  PRUnichar ch2;
  getcaseConv()->ToUpper((PRUnichar) c, &ch2);
  return ch2;
#else
  return (utf_tbl) ? utf_tbl[c].cupper : c;
#endif
#endif
}

unsigned short unicodetolower(unsigned short c, int langnum)
{

  // There are a dotless lower case i pair of upper `I',
  // and an upper I with dot pair of lower `i'. 
  if (c == 0x0049 && ((langnum == LANG_az) || (langnum == LANG_tr)))
    return 0x0131;
#ifdef OPENOFFICEORG
  return u_tolower(c);
#else
#ifdef MOZILLA_CLIENT
  PRUnichar ch2;
  getcaseConv()->ToLower((PRUnichar) c, &ch2);
  return ch2;
#else
  return (utf_tbl) ? utf_tbl[c].clower : c;
#endif
#endif
}

int unicodeisalpha(unsigned short c)
{






// character encoding information
struct cs_info {
  unsigned char ccase;
  unsigned char clower;
  unsigned char cupper;
};

// Unicode character encoding information
struct unicode_info {
  unsigned short c;
  unsigned short cupper;
  unsigned short clower;
};

struct unicode_info2 {
  char cletter;
  unsigned short cupper;
  unsigned short clower;
};

LIBHUNSPELL_DLL_EXPORTED int initialize_utf_tbl();
LIBHUNSPELL_DLL_EXPORTED void free_utf_tbl();
LIBHUNSPELL_DLL_EXPORTED unsigned short unicodetoupper(unsigned short c, int langnum);
LIBHUNSPELL_DLL_EXPORTED unsigned short unicodetolower(unsigned short c, int langnum);
LIBHUNSPELL_DLL_EXPORTED int unicodeisalpha(unsigned short c);

struct enc_entry {
  const char * enc_name;
  struct cs_info * cs_table;
};

// language to encoding default map

struct lang_map {
  const char * lang;
  const char * def_enc;
  int num;
};

LIBHUNSPELL_DLL_EXPORTED struct cs_info * get_current_cs(const char * es);

LIBHUNSPELL_DLL_EXPORTED const char * get_default_enc(const char * lang);

// get language identifiers of language codes
LIBHUNSPELL_DLL_EXPORTED int get_lang_num(const char * lang);

// get characters of the given 8bit encoding with lower- and uppercase forms
LIBHUNSPELL_DLL_EXPORTED char * get_casechars(const char * enc);

// convert null terminated string to all caps using encoding
LIBHUNSPELL_DLL_EXPORTED void enmkallcap(char * d, const char * p, const char * encoding);


// hash entry macros
LIBHUNSPELL_DLL_EXPORTED inline char* HENTRY_DATA(struct hentry *h)
{
    char *ret;
    if (!h->var)
        ret = NULL;
    else if (h->var & H_OPT_ALIASM)
        ret = get_stored_pointer(HENTRY_WORD(h) + h->blen + 1);
    else 
        ret = HENTRY_WORD(h) + h->blen + 1;
    return ret;
}

// NULL-free version for warning-free OOo build
LIBHUNSPELL_DLL_EXPORTED inline const char* HENTRY_DATA2(const struct hentry *h)
{
    const char *ret;
    if (!h->var)
        ret = "";
    else if (h->var & H_OPT_ALIASM)
        ret = get_stored_pointer(HENTRY_WORD(h) + h->blen + 1);
    else
        ret = HENTRY_WORD(h) + h->blen + 1;
    return ret;
}

LIBHUNSPELL_DLL_EXPORTED inline char* HENTRY_FIND(struct hentry *h, const char *p)
{
    return (HENTRY_DATA(h) ? strstr(HENTRY_DATA(h), p) : NULL);
}






        if (!al) {
            HUNSPELL_WARNING(stderr, "error: line %d: bad flag vector alias\n", dict->getlinenum());
            *ap = '\0';
        }
      } else {
        al = decode_flags(&flags, ap + 1, dict);
        if (al == -1) {
            HUNSPELL_WARNING(stderr, "Can't allocate memory.\n");
            delete dict;
            return 6;
        }
        flag_qsort(flags, 0, al);
      }
    } else {
      al = 0;
      ap = NULL;
      flags = NULL;

      hv ^= (*word++);
    }
    return (unsigned long) hv % tablesize;
}

int HashMgr::decode_flags(unsigned short ** result, char * flags, FileMgr * af) {
    int len;
    if (*flags == '\0') {
        HUNSPELL_WARNING(stderr, "error: line %d: bad flagvector\n", af->getlinenum());
        *result = NULL;
        return 0;
    }
    switch (flag_mode) {
      case FLAG_LONG: { // two-character flags (1x2yZz -> 1x 2y Zz)
        len = strlen(flags);
        if (len%2 == 1) HUNSPELL_WARNING(stderr, "error: line %d: bad flagvector\n", af->getlinenum());
        len /= 2;





    /* next set up the affix manager */
    /* it needs access to the hash manager lookup methods */
    pAMgr = new AffixMgr(affpath, pHMgr, &maxdic, key);

    /* get the preferred try string and the dictionary */
    /* encoding from the Affix Manager for that dictionary */
    char * try_string = pAMgr->get_try_string();
    encoding = pAMgr->get_encoding();
    csconv = get_current_cs(encoding);
    langnum = pAMgr->get_langnum();
    utf8 = pAMgr->get_utf8();
    if (!utf8)
        csconv = get_current_cs(encoding);
    complexprefixes = pAMgr->get_complexprefixes();
    wordbreak = pAMgr->get_breaktable();

    /* and finally set up the suggestion manager */
    pSMgr = new SuggestMgr(try_string, MAXSUGGESTION, pAMgr);
    if (try_string) free(try_string);
}


        unsigned short * ignoredchars_utf16 = pAMgr->get_ignore_utf16(&ignoredchars_utf16_len);
        remove_ignored_chars_utf(w2, ignoredchars_utf16, ignoredchars_utf16_len);
     } else {
        remove_ignored_chars(w2,ignoredchars);
     }
     word = w2;
  } else word = w;

  len = strlen(word);

  if (!len)
      return NULL;

  // word reversing wrapper for complex prefixes
  if (complexprefixes) {
    if (word != w2) {
      strcpy(w2, word);
      word = w2;
    }
    if (utf8) reverseword_utf(w2); else reverseword(w2);
  }

       (pAMgr->get_onlyincompound() && TESTAFF(he->astr, pAMgr->get_onlyincompound(), he->alen)) ||
       (info && (*info & SPELL_INITCAP) && TESTAFF(he->astr, ONLYUPCASEFLAG, he->alen))
    )) he = he->next_homonym;
  }

  // check with affixes
  if (!he && pAMgr) {
     // try stripping off affixes */
     len = strlen(word);
     he = pAMgr->affix_check(word, len, 0);

     // check compound restriction and onlyupcase
     if (he && he->astr && (
        (pAMgr->get_onlyincompound() &&
    	    TESTAFF(he->astr, pAMgr->get_onlyincompound(), he->alen)) ||
        (info && (*info & SPELL_INITCAP) &&
    	    TESTAFF(he->astr, ONLYUPCASEFLAG, he->alen)))) {

  // remove duplications
  int l = 0;
  for (int j = 0; j < ns; j++) {
    (*slst)[l] = (*slst)[j];
    for (int k = 0; k < l; k++) {
      if (strcmp((*slst)[k], (*slst)[j]) == 0) {
        free((*slst)[j]);
        l--;
        break;
      }
    }
    l++;
  }
  ns = l;

  // output conversion
  rl = (pAMgr) ? pAMgr->get_oconvtable() : NULL;
  for (int j = 0; rl && j < ns; j++) {
    if (rl->conv((*slst)[j], wspace)) {
      free((*slst)[j]);
      (*slst)[j] = mystrdup(wspace);
    }

  // LANG_hu section: set dash information for suggestions
  if (langnum == LANG_hu) dash = (char *) strchr(cw,'-');
  if ((langnum == LANG_hu) && dash) {
      *dash='\0';
      // examine 2 sides of the dash
      if (dash[1] == '\0') { // base word ending with dash
        if (spell(cw)) {
		char * p = pSMgr->suggest_morph(cw);
		if (p) {
		    int ret = line_tok(p, slst, MSEP_REC);
		    free(p);
		    return ret;
		}
		
	}
      } else if ((dash[1] == 'e') && (dash[2] == '\0')) { // XXX (HU) -e hat.
        if (spell(cw) && (spell("-e"))) {
                        st = pSMgr->suggest_morph(cw);
                        if (st) {
                                mystrcat(result, st, MAXLNLEN);
                                free(st);
                        }

    if (!list) return 0;
    for (p = list; (p = strstr(p, tag)); p++) n++;
    if (n == 0) return 0;
    *slst = (char **) malloc(sizeof(char *) * n);
    if (!*slst) return 0;
    for (p = list, n = 0; (p = strstr(p, tag)); p++, n++) {
        int l = strlen(p);
        (*slst)[n] = (char *) malloc(l + 1);
        if (!(*slst)[n]) return n;
        if (!get_xml_par((*slst)[n], p + strlen(tag) - 1, l)) {
            free((*slst)[n]);
            break;
        }
    }
    return n;
}


      int n = get_xml_par(cw, strchr(q2, '>'), MAXWORDUTF8LEN - 1);
      if (n == 0) return 0;
      char * q3 = strstr(q2 + 1, "<word");
      if (q3) {
        if (get_xml_par(cw2, strchr(q3, '>'), MAXWORDUTF8LEN - 1)) {
            return generate(slst, cw, cw2);
        }
      } else {
        if ((q2 = strstr(q2 + 1, "<code"))) {
          char ** slst2;
          if ((n = get_xml_list(&slst2, strchr(q2, '>'), "<a>"))) {
            int n2 = generate(slst, cw, slst2, n);
            freelist(&slst2, n);
            return uniqlist(*slst, n2);
          }
          freelist(&slst2, n);
        }
      }
  }
  return 0;
}


#ifdef HUNSPELL_EXPERIMENTAL





}

int RepList::add(char * pat1, char * pat2) {
    if (pos >= size || pat1 == NULL || pat2 == NULL) return 1;
    replentry * r = (replentry *) malloc(sizeof(replentry));
    if (r == NULL) return 1;
    r->pattern = mystrrep(pat1, "_", " ");
    r->pattern2 = mystrrep(pat2, "_", " ");
    r->start = false;
    r->end = false;
    dat[pos++] = r;
    for (int i = pos - 1; i > 0; i--) {
      r = dat[i];
      if (strcmp(r->pattern, dat[i - 1]->pattern) < 0) {
          dat[i] = dat[i - 1];
          dat[i - 1] = r;
      } else break;
    }





  langnum = 0;
  complexprefixes = 0;  
  
  maxSug = maxn;
  nosplitsugs = 0;
  maxngramsugs = MAXNGRAMSUGS;

  if (pAMgr) {
        char * enc = pAMgr->get_encoding();
        csconv = get_current_cs(enc);
        free(enc);
        langnum = pAMgr->get_langnum();
        ckey = pAMgr->get_key_string();
        nosplitsugs = pAMgr->get_nosplitsugs();
        if (pAMgr->get_maxngramsugs() >= 0)
            maxngramsugs = pAMgr->get_maxngramsugs();
        utf8 = pAMgr->get_utf8();
        if (!utf8)
        {
            char * enc = pAMgr->get_encoding();
            csconv = get_current_cs(enc);
            free(enc);
        }
        complexprefixes = pAMgr->get_complexprefixes();
  }

  if (ckey) {  
    if (utf8) {
        w_char t[MAXSWL];    
        ckeyl = u8_u16(t, MAXSWL, ckey);
        ckey_utf = (w_char *) malloc(ckeyl * sizeof(w_char));


int SuggestMgr::suggest(char*** slst, const char * w, int nsug,
    int * onlycompoundsug)
{
  int nocompoundtwowords = 0;
  char ** wlst;    
  w_char word_utf[MAXSWL];
  int wl = 0;
  int nsugorig = nsug;
  char w2[MAXWORDUTF8LEN];
  const char * word = w;

  // word reversing wrapper for complex prefixes
  if (complexprefixes) {
    strcpy(w2, w);
    if (utf8) reverseword_utf(w2); else reverseword(w2);
    word = w2;


    // did we just hit the wrong key in place of a good char (case and keyboard)
    if ((nsug < maxSug) && (nsug > -1)) {
        nsug = (utf8) ? badcharkey_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
                    badcharkey(wlst, word, nsug, cpdsuggest);
    }

    // only suggest compound words when no other suggestion
    if ((cpdsuggest == 0) && (nsug > nsugorig)) nocompoundtwowords=1;

    // did we add a char that should not be there
    if ((nsug < maxSug) && (nsug > -1)) {
        nsug = (utf8) ? extrachar_utf(wlst, word_utf, wl, nsug, cpdsuggest) :
                    extrachar(wlst, word, nsug, cpdsuggest);
    }



  int numrep = pAMgr->get_numrep();
  struct replentry* reptable = pAMgr->get_reptable();
  if (reptable==NULL) return ns;
  for (int i=0; i < numrep; i++ ) {
      r = word;
      lenr = strlen(reptable[i].pattern2);
      lenp = strlen(reptable[i].pattern);
      // search every occurence of the pattern in the word
      while ((r=strstr(r, reptable[i].pattern)) != NULL && (!reptable[i].end || strlen(r) == strlen(reptable[i].pattern)) &&
        (!reptable[i].start || r == word)) {
          strcpy(candidate, word);
          if (r-word + lenr + strlen(r+lenp) >= MAXSWUTF8L) break;
          strcpy(candidate+(r-word),reptable[i].pattern2);
          strcpy(candidate+(r-word)+lenr, r+lenp);
          ns = testsug(wlst, candidate, wl-lenp+lenr, ns, cpdsuggest, NULL, NULL);
          if (ns == -1) return -1;
          // check REP suggestions with space
          char * sp = strchr(candidate, ' ');
          if (sp) {
            char * prev = candidate;
            while (sp) {
              *sp = '\0';
              if (checkword(prev, strlen(prev), 0, NULL, NULL)) {
                int oldns = ns;
                *sp = ' ';
                ns = testsug(wlst, sp + 1, strlen(sp + 1), ns, cpdsuggest, NULL, NULL);
                if (ns == -1) return -1;
                if (oldns < ns) {
                  free(wlst[ns - 1]);
                  wlst[ns - 1] = mystrdup(candidate);
                  if (!wlst[ns - 1]) return -1;
                }
              }
              *sp = ' ';
              prev = sp + 1;
              sp = strchr(prev, ' ');
            }
                free(wlst[ns - 1]);
                wlst[ns - 1] = mystrdup(candidate);
                if (!wlst[ns - 1]) return -1;
              }
            }            
            *sp = ' ';
          }
          r++; // search for the next letter
      }
   }
   return ns;
}

// perhaps we doubled two characters (pattern aba -> ababa, for example vacation -> vacacation)

(-)a/extensions/spellcheck/hunspell/src/w_char.hxx (+2 lines)

Line	Link Here

Lines 42-52 typedef struct __attribute__ ((packed))	Link Here

    unsigned char l;

    unsigned char l;

    unsigned char h;

    unsigned char h;

} w_char;

} w_char;

// two character arrays

// two character arrays

struct replentry {

struct replentry {

  char * pattern;

  char * pattern;

  char * pattern2;

  char * pattern2;

  bool start;

  bool end;

};

};

#endif

#endif

Return to bug 620626