Merges our hunspell change to hunspell 1.2.10....

third_party/hunspell/src/hunspell/affixmgr.cxx

 #include "license.hunspell"
 #include "license.myspell"
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <ctype.h>
 
 #include <vector>
 
 #include "affixmgr.hxx"
 #include "affentry.hxx"
 #include "langnum.hxx"
 
 #include "csutil.hxx"
 
+#ifdef HUNSPELL_CHROME_CLIENT
+AffixMgr::AffixMgr(hunspell::BDictReader* reader, HashMgr** ptr, int * md)
+{
+  bdict_reader = reader;
+#else
 AffixMgr::AffixMgr(const char * affpath, HashMgr** ptr, int * md, const char * key) 
 {
+#endif
   // register hash manager and load affix data from aff file
   pHMgr = ptr[0];
   alldic = ptr;
   maxdic = md;
   keystring = NULL;
   trystring = NULL;
   encoding=NULL;
   csconv=NULL;
   utf8 = 0;
   complexprefixes = 0;
@@ skipping 63 matching lines @@
   sfx = NULL;
   pfx = NULL;
 
   for (int i=0; i < SETSIZE; i++) {
      pStart[i] = NULL;
      sStart[i] = NULL;
      pFlag[i] = NULL;
      sFlag[i] = NULL;
   }
 
+#ifdef HUNSPELL_CHROME_CLIENT
+  // Define dummy parameters for parse_file() to avoid changing the parameters
+  // of parse_file(). This may make it easier to merge the changes of the
+  // original hunspell.
+  const char* affpath = NULL;
+  const char* key = NULL;
+#else
   for (int j=0; j < CONTSIZE; j++) {
     contclasses[j] = 0;
   }
+#endif
 
   if (parse_file(affpath, key)) {
      HUNSPELL_WARNING(stderr, "Failure loading aff file %s\n",affpath);
   }
   
   if (cpdmin == -1) cpdmin = MINCPDLEN;
 
 }
 
 
@@ skipping 130 matching lines @@
 #endif
 }
 
 
 // read in aff file and build up prefix and suffix entry objects 
 int  AffixMgr::parse_file(const char * affpath, const char * key)
 {
   char * line; // io buffers
   char ft;     // affix type
   
+#ifdef HUNSPELL_CHROME_CLIENT
+  // open the affix file
+  // We're always UTF-8
+  utf8 = 1;
+
+  // A BDICT file stores PFX and SFX lines in a special section and it provides
+  // a special line iterator for reading PFX and SFX lines.
+  // We create a FileMgr object from this iterator and parse PFX and SFX lines
+  // before parsing other lines.
+  hunspell::LineIterator affix_iterator = bdict_reader->GetAffixLineIterator();
+  FileMgr* iterator = new FileMgr(&affix_iterator);
+  if (!iterator) {
+    HUNSPELL_WARNING(stderr,
+        "error: could not create a FileMgr from an affix line iterator.\n");
+    return 1;
+  }
+
+  while (line = iterator->getline()) {
+    ft = ' ';
+    if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';
+    if (strncmp(line,"SFX",3) == 0) ft = complexprefixes ? 'P' : 'S';
+    if (ft != ' ')
+      parse_affix(line, ft, iterator, NULL);
+  }
+  delete iterator;
+
+  // Create a FileMgr object for reading lines except PFX and SFX lines.
+  // We don't need to change the loop below since our FileMgr emulates the
+  // original one.
+  hunspell::LineIterator other_iterator = bdict_reader->GetOtherLineIterator();
+  FileMgr * afflst = new FileMgr(&other_iterator);
+  if (!afflst) {
+    HUNSPELL_WARNING(stderr,
+        "error: could not create a FileMgr from an other line iterator.\n");
+    return 1;
+  }
+#else
   // checking flag duplication
   char dupflags[CONTSIZE];
   char dupflags_ini = 1;
 
   // first line indicator for removing byte order mark
   int firstline = 1;
   
   // open the affix file
   FileMgr * afflst = new FileMgr(affpath, key);
   if (!afflst) {
     HUNSPELL_WARNING(stderr, "error: could not open affix description file %s\n",affpath);
     return 1;
   }
+#endif
 
   // step one is to parse the affix file building up the internal
   // affix data structures
 
     // read in each line ignoring any that do not
     // start with a known line type indicator
     while ((line = afflst->getline())) {
        mychomp(line);
 
+#ifndef HUNSPELL_CHROME_CLIENT
        /* remove byte order mark */
        if (firstline) {
          firstline = 0;
          // Affix file begins with byte order mark: possible incompatibility with old Hunspell versions
          if (strncmp(line,"\xEF\xBB\xBF",3) == 0) {
             memmove(line, line+3, strlen(line+3)+1);
          }
        }
+#endif
 
        /* parse in the keyboard string */
        if (strncmp(line,"KEY",3) == 0) {
           if (parse_string(line, &keystring, afflst->getlinenum())) {
              delete afflst;
              return 1;
           }
        }
 
        /* parse in the try string */
@@ skipping 215 matching lines @@
        }
 
        /* parse in the ignored characters (for example, Arabic optional diacretics charachters */
        if (strncmp(line,"IGNORE",6) == 0) {
           if (parse_array(line, &ignorechars, &ignorechars_utf16, &ignorechars_utf16_len, utf8, afflst->getlinenum())) {
              delete afflst;
              return 1;
           }
        }
 
+#ifndef HUNSPELL_CHROME_CLIENT
        /* parse in the typical fault correcting table */
        if (strncmp(line,"REP",3) == 0) {
           if (parse_reptable(line, afflst)) {
              delete afflst;
              return 1;
           }
        }
+#endif
 
        /* parse in the input conversion table */
        if (strncmp(line,"ICONV",5) == 0) {
           if (parse_convtable(line, afflst, &iconvtable, "ICONV")) {
              delete afflst;
              return 1;
           }
        }
 
        /* parse in the input conversion table */
@@ skipping 90 matching lines @@
           if (parse_flag(line, &substandard, afflst)) {
              delete afflst;
              return 1;
           }
        }
 
        if (strncmp(line,"CHECKSHARPS",11) == 0) {
                    checksharps=1;
        }
 
+#ifndef HUNSPELL_CHROME_CLIENT  // Chrome handled affixes above.
        /* parse this affix: P - prefix, S - suffix */
        ft = ' ';
        if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';
        if (strncmp(line,"SFX",3) == 0) ft = complexprefixes ? 'P' : 'S';
        if (ft != ' ') {
           if (dupflags_ini) {
             memset(dupflags, 0, sizeof(dupflags));
             dupflags_ini = 0;
           }
           if (parse_affix(line, ft, afflst, dupflags)) {
              delete afflst;
              process_pfx_tree_to_list();
              process_sfx_tree_to_list();
              return 1;
           }
        }
+#endif
 
     }
     delete afflst;
 
     // convert affix trees to sorted list
     process_pfx_tree_to_list();
     process_sfx_tree_to_list();
 
     // now we can speed up performance greatly taking advantage of the 
     // relationship between the affixes and the idea of "subsets".
@@ skipping 577 matching lines @@
     return NULL;
 }
 
 // Is word a non compound with a REP substitution (see checkcompoundrep)?
 int AffixMgr::cpdrep_check(const char * word, int wl)
 {
   char candidate[MAXLNLEN];
   const char * r;
   int lenr, lenp;
 
+#ifdef HUNSPELL_CHROME_CLIENT
+  const char *pattern, *pattern2;
+  hunspell::ReplacementIterator iterator = bdict_reader->GetReplacementIterator();
+  while (iterator.GetNext(&pattern, &pattern2)) {
+    r = word;
+    lenr = strlen(pattern2);
+    lenp = strlen(pattern);
+
+    // search every occurence of the pattern in the word
+    while ((r=strstr(r, pattern)) != NULL) {
+      strcpy(candidate, word);
+      if (r-word + lenr + strlen(r+lenp) >= MAXLNLEN) break;
+      strcpy(candidate+(r-word), pattern2);
+      strcpy(candidate+(r-word)+lenr, r+lenp);
+      if (candidate_check(candidate,strlen(candidate))) return 1;
+      r++; // search for the next letter
+    }
+  }
+
+#else
   if ((wl < 2) || !numrep) return 0;
 
   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) {
           strcpy(candidate, word);
           if (r-word + lenr + strlen(r+lenp) >= MAXLNLEN) break;
           strcpy(candidate+(r-word),reptable[i].pattern2);
           strcpy(candidate+(r-word)+lenr, r+lenp);
           if (candidate_check(candidate,strlen(candidate))) return 1;
           r++; // search for the next letter
       }
    }
+#endif
    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)
 {
   int len;
   for (int i = 0; i < numcheckcpd; i++) {
       if (isSubset(checkcpdtable[i].pattern2, word + pos) &&
         (!r1 || !checkcpdtable[i].cond ||
@@ skipping 2049 matching lines @@
       piece = mystrsep(&tp, 0);
    }
    if (np < 2) {
       HUNSPELL_WARNING(stderr, "error: line %d: missing compoundsyllable information\n", af->getlinenum());
       return 1;
    }
    if (np == 2) cpdvowels = mystrdup("aeiouAEIOU");
    return 0;
 }
 
+#ifndef HUNSPELL_CHROME_CLIENT
 /* parse in the typical fault correcting table */
 int  AffixMgr::parse_reptable(char * line, FileMgr * af)
 {
    if (numrep != 0) {
       HUNSPELL_WARNING(stderr, "error: line %d: multiple table definitions\n", af->getlinenum());
       return 1;
    }
    char * tp = line;
    char * piece;
    int i = 0;
@@ skipping 55 matching lines @@
            piece = mystrsep(&tp, 0);
         }
         if ((!(reptable[j].pattern)) || (!(reptable[j].pattern2))) {
              HUNSPELL_WARNING(stderr, "error: line %d: table is corrupt\n", af->getlinenum());
              numrep = 0;
              return 1;
         }
    }
    return 0;
 }
+#endif
 
 /* parse in the typical fault correcting table */
 int  AffixMgr::parse_convtable(char * line, FileMgr * af, RepList ** rl, const char * keyword)
 {
    if (*rl) {
       HUNSPELL_WARNING(stderr, "error: line %d: multiple table definitions\n", af->getlinenum());
       return 1;
    }
    char * tp = line;
    char * piece;
@@ skipping 583 matching lines @@
    while (piece) {
       if (*piece != '\0') {
           switch(i) {
              // piece 1 - is type of affix
              case 0: { np++; break; }
           
              // piece 2 - is affix char
              case 1: { 
                     np++;
                     aflag = pHMgr->decode_flag(piece);
+#ifndef HUNSPELL_CHROME_CLIENT // We don't check for duplicates.
                     if (((at == 'S') && (dupflags[aflag] & dupSFX)) ||
                         ((at == 'P') && (dupflags[aflag] & dupPFX))) {
                         HUNSPELL_WARNING(stderr, "error: line %d: multiple definitions of an affix flag\n",
                             af->getlinenum());
                         // return 1; XXX permissive mode for bad dictionaries
                     }
                     dupflags[aflag] += (char) ((at == 'S') ? dupSFX : dupPFX);
+#endif
                     break; 
                     }
              // piece 3 - is cross product indicator 
              case 2: { np++; if (*piece == 'Y') ff = aeXPRODUCT; break; }
 
              // piece 4 - is number of affentries
              case 3: { 
                        np++;
                        numents = atoi(piece); 
                        if (numents == 0) {
@@ skipping 287 matching lines @@
             HUNSPELL_WARNING(stderr, "warning: line %d: incompatible stripping characters and condition\n", linenum);
             return 0;
           }
         }
       }
       if (j < 0) return 1;
     }
   }
   return 0;
 }