Use up to 8 affixes in Hunspell spellcheck suggestions

google.patch

 Index: src/hunspell/affixmgr.cxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/affixmgr.cxx,v
 retrieving revision 1.41
-diff -u -r1.41 affixmgr.cxx
+diff -u -p -r1.41 affixmgr.cxx
 --- src/hunspell/affixmgr.cxx   16 Dec 2011 09:15:34 -0000      1.41
-+++ src/hunspell/affixmgr.cxx   8 Jan 2013 00:30:25 -0000
++++ src/hunspell/affixmgr.cxx   26 Feb 2013 23:13:13 -0000
 @@ -14,8 +14,14 @@
  
  #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;
-@@ -107,9 +113,17 @@
+@@ -107,9 +113,17 @@ AffixMgr::AffixMgr(const char * affpath,
       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);
-@@ -269,6 +283,43 @@
+@@ -269,6 +283,43 @@ int  AffixMgr::parse_file(const char * a
    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.
@@ skipping 23 matching lines @@
 +  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;
-@@ -282,6 +333,7 @@
+@@ -282,6 +333,7 @@ int  AffixMgr::parse_file(const char * a
      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
-@@ -291,6 +343,7 @@
+@@ -291,6 +343,7 @@ int  AffixMgr::parse_file(const char * a
      while ((line = afflst->getline()) != NULL) {
         mychomp(line);
  
 +#ifndef HUNSPELL_CHROME_CLIENT
         /* remove byte order mark */
         if (firstline) {
           firstline = 0;
-@@ -299,6 +352,7 @@
+@@ -299,6 +352,7 @@ int  AffixMgr::parse_file(const char * a
              memmove(line, line+3, strlen(line+3)+1);
           }
         }
 +#endif
  
         /* parse in the keyboard string */
         if (strncmp(line,"KEY",3) == 0) {
-@@ -545,6 +599,7 @@
+@@ -545,6 +599,7 @@ int  AffixMgr::parse_file(const char * a
            }
         }
  
 +#ifndef HUNSPELL_CHROME_CLIENT
         /* parse in the typical fault correcting table */
         if (strncmp(line,"REP",3) == 0) {
            if (parse_reptable(line, afflst)) {
-@@ -552,6 +607,7 @@
+@@ -552,6 +607,7 @@ int  AffixMgr::parse_file(const char * a
               return 1;
            }
         }
 +#endif
  
         /* parse in the input conversion table */
         if (strncmp(line,"ICONV",5) == 0) {
-@@ -699,6 +755,7 @@
+@@ -699,6 +755,7 @@ int  AffixMgr::parse_file(const char * a
                     checksharps=1;
         }
  
 +#ifndef HUNSPELL_CHROME_CLIENT
         /* parse this affix: P - prefix, S - suffix */
         ft = ' ';
         if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';
-@@ -713,6 +770,7 @@
+@@ -713,6 +770,7 @@ int  AffixMgr::parse_file(const char * a
               return 1;
            }
         }
 +#endif
      }
  
      finishFileMgr(afflst);
-@@ -1307,6 +1365,26 @@
+@@ -1307,6 +1365,26 @@ int AffixMgr::cpdrep_check(const char * 
    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++ ) {
-@@ -1323,6 +1401,7 @@
+@@ -1323,6 +1401,7 @@ int AffixMgr::cpdrep_check(const char * 
            r++; // search for the next letter
        }
     }
 +#endif
     return 0;
  }
  
-@@ -4219,6 +4298,7 @@
+@@ -4219,6 +4298,7 @@ int  AffixMgr::parse_affix(char * line, 
               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",
-@@ -4226,6 +4306,7 @@
+@@ -4226,6 +4306,7 @@ int  AffixMgr::parse_affix(char * line, 
                          // return 1; XXX permissive mode for bad dictionaries
                      }
                      dupflags[aflag] += (char) ((at == 'S') ? dupSFX : dupPFX);
 +#endif
                      break; 
                      }
               // piece 3 - is cross product indicator 
 Index: src/hunspell/affixmgr.hxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/affixmgr.hxx,v
 retrieving revision 1.15
-diff -u -r1.15 affixmgr.hxx
+diff -u -p -r1.15 affixmgr.hxx
 --- src/hunspell/affixmgr.hxx   13 Oct 2011 13:41:54 -0000      1.15
-+++ src/hunspell/affixmgr.hxx   8 Jan 2013 00:30:25 -0000
++++ src/hunspell/affixmgr.hxx   26 Feb 2013 23:13:13 -0000
 @@ -18,6 +18,40 @@
  class PfxEntry;
  class SfxEntry;
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +
 +#include <vector>
 +
 +// This class provides an implementation of the contclasses array in AffixMgr
 +// that is normally a large static array. We should almost never need more than
@@ skipping 21 matching lines @@
 +  }
 +
 +  std::vector<char> data;
 +};
 +
 +#endif  // HUNSPELL_CHROME_CLIENT
 +
  class LIBHUNSPELL_DLL_EXPORTED AffixMgr
  {
  
-@@ -106,12 +140,20 @@
+@@ -106,12 +140,20 @@ class LIBHUNSPELL_DLL_EXPORTED AffixMgr
    int                 fullstrip;
  
    int                 havecontclass; // boolean variable
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  ContClasses         contclasses;
 +#else
    char                contclasses[CONTSIZE]; // flags of possible continuing classes (twofold affix)
 +#endif
  
  public:
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  AffixMgr(hunspell::BDictReader* reader, HashMgr** ptr, int * md);
 +#else
    AffixMgr(const char * affpath, HashMgr** ptr, int * md,
      const char * key = NULL);
 +#endif
    ~AffixMgr();
    struct hentry *     affix_check(const char * word, int len,
              const unsigned short needflag = (unsigned short) 0,
-@@ -218,6 +260,10 @@
+@@ -218,6 +260,10 @@ public:
    int                 get_fullstrip() const;
  
  private:
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  // Not owned by us, owned by the Hunspell object.
 +  hunspell::BDictReader* bdict_reader;
 +#endif
    int  parse_file(const char * affpath, const char * key);
    int  parse_flag(char * line, unsigned short * out, FileMgr * af);
    int  parse_num(char * line, int * out, FileMgr * af);
-@@ -249,4 +295,3 @@
+@@ -249,4 +295,3 @@ private:
  };
  
  #endif
 -
 Index: src/hunspell/filemgr.cxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/filemgr.cxx,v
 retrieving revision 1.5
-diff -u -r1.5 filemgr.cxx
+diff -u -p -r1.5 filemgr.cxx
 --- src/hunspell/filemgr.cxx    23 Jun 2011 09:21:50 -0000      1.5
-+++ src/hunspell/filemgr.cxx    8 Jan 2013 00:30:25 -0000
++++ src/hunspell/filemgr.cxx    26 Feb 2013 23:13:13 -0000
 @@ -7,6 +7,32 @@
  
  #include "filemgr.hxx"
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +#include "third_party/hunspell/google/bdict_reader.h"
 +
 +FileMgr::FileMgr(hunspell::LineIterator* iterator) : iterator_(iterator) {
 +}
 +
@@ skipping 13 matching lines @@
 +  // This function is used only for displaying a line number that causes a
 +  // parser error. For a BDICT file, providing a line number doesn't help
 +  // identifying the place where causes a parser error so much since it is a
 +  // binary file. So, we just return 0.
 +  return 0;
 +}
 +#else
  int FileMgr::fail(const char * err, const char * par) {
      fprintf(stderr, err, par);
      return -1;
-@@ -47,3 +73,4 @@
+@@ -47,3 +73,4 @@ char * FileMgr::getline() {
  int FileMgr::getlinenum() {
      return linenum;
  }
 +#endif
 Index: src/hunspell/filemgr.hxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/filemgr.hxx,v
 retrieving revision 1.3
-diff -u -r1.3 filemgr.hxx
+diff -u -p -r1.3 filemgr.hxx
 --- src/hunspell/filemgr.hxx    15 Apr 2010 11:22:08 -0000      1.3
-+++ src/hunspell/filemgr.hxx    8 Jan 2013 00:30:25 -0000
++++ src/hunspell/filemgr.hxx    26 Feb 2013 23:13:13 -0000
 @@ -7,6 +7,30 @@
  #include "hunzip.hxx"
  #include <stdio.h>
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +namespace hunspell {
 +class LineIterator;
 +}  // namespace hunspell
 +
 +// A class which encapsulates operations of reading a BDICT file.
@@ skipping 11 matching lines @@
 +  int getlinenum();
 +
 + protected:
 +  hunspell::LineIterator* iterator_;
 +  char line_[BUFSIZE + 50]; // input buffer
 +};
 +#else
  class LIBHUNSPELL_DLL_EXPORTED FileMgr
  {
  protected:
-@@ -23,3 +47,4 @@
+@@ -23,3 +47,4 @@ public:
      int getlinenum();
  };
  #endif
 +#endif
 Index: src/hunspell/hashmgr.cxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/hashmgr.cxx,v
 retrieving revision 1.12
-diff -u -r1.12 hashmgr.cxx
+diff -u -p -r1.12 hashmgr.cxx
 --- src/hunspell/hashmgr.cxx    23 Jun 2011 09:21:50 -0000      1.12
-+++ src/hunspell/hashmgr.cxx    8 Jan 2013 00:30:25 -0000
++++ src/hunspell/hashmgr.cxx    26 Feb 2013 23:13:13 -0000
 @@ -12,8 +12,14 @@
  
  // build a hash table from a munched word list
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +HashMgr::HashMgr(hunspell::BDictReader* reader)
 +{
 +  bdict_reader = reader;
 +#else
  HashMgr::HashMgr(const char * tpath, const char * apath, const char * key)
  {
 +#endif
    tablesize = 0;
    tableptr = NULL;
    flag_mode = FLAG_CHAR;
-@@ -31,8 +37,14 @@
+@@ -31,8 +37,14 @@ HashMgr::HashMgr(const char * tpath, con
    numaliasm = 0;
    aliasm = NULL;
    forbiddenword = FORBIDDENWORD; // forbidden word signing flag
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  // No tables to load, just the AF lines.
 +  load_config(NULL, NULL);
 +  int ec = LoadAFLines();
 +#else
    load_config(apath, key);
    int ec = load_tables(tpath, key);
 +#endif
    if (ec) {
      /* error condition - what should we do here */
      HUNSPELL_WARNING(stderr, "Hash Manager Error : %d\n",ec);
-@@ -91,15 +103,58 @@
+@@ -91,15 +103,58 @@ HashMgr::~HashMgr()
    if (ignorechars) free(ignorechars);
    if (ignorechars_utf16) free(ignorechars_utf16);
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  EmptyHentryCache();
 +  for (std::vector<std::string*>::iterator it = pointer_to_strings_.begin();
 +       it != pointer_to_strings_.end(); ++it) {
 +    delete *it;
 +  }
 +#endif
@@ skipping 38 matching lines @@
 +  static const int kMaxWordLen = 128;
 +  static char word_buf[kMaxWordLen];
 +  // To take account of null-termination, we use upto 127.
 +  strncpy(word_buf, word, kMaxWordLen - 1);
 +
 +  return AffixIDsToHentry(word_buf, affix_ids, affix_count);
 +#else
      struct hentry * dp;
      if (tableptr) {
         dp = tableptr[hash(word)];
-@@ -109,12 +164,14 @@
+@@ -109,12 +164,14 @@ struct hentry * HashMgr::lookup(const ch
         }
      }
      return NULL;
 +#endif
  }
  
  // add a word to the hash table (private)
  int HashMgr::add_word(const char * word, int wbl, int wcl, unsigned short * aff,
      int al, const char * desc, bool onlyupcase)
  {
 +#ifndef HUNSPELL_CHROME_CLIENT
      bool upcasehomonym = false;
      int descl = desc ? (aliasm ? sizeof(short) : strlen(desc) + 1) : 0;
      // variable-length hash record with word and optional fields
-@@ -206,6 +263,17 @@
+@@ -206,6 +263,17 @@ int HashMgr::add_word(const char * word,
             if (hp->astr) free(hp->astr);
             free(hp);
         }
 +#else
 +    std::map<base::StringPiece, int>::iterator iter =
 +        custom_word_to_affix_id_map_.find(word);
 +    if(iter == custom_word_to_affix_id_map_.end()) {  // word needs to be added
 +      std::string* new_string_word = new std::string(word);
 +      pointer_to_strings_.push_back(new_string_word);
 +      base::StringPiece sp(*(new_string_word));
 +      custom_word_to_affix_id_map_[sp] = 0; // no affixes for custom words
 +      return 1;
 +    }
 +#endif
      return 0;
  }     
  
-@@ -256,6 +324,12 @@
+@@ -256,6 +324,12 @@ int HashMgr::get_clen_and_captype(const 
  // remove word (personal dictionary function for standalone applications)
  int HashMgr::remove(const char * word)
  {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +    std::map<base::StringPiece, int>::iterator iter =
 +        custom_word_to_affix_id_map_.find(word);
 +    if (iter != custom_word_to_affix_id_map_.end())
 +        custom_word_to_affix_id_map_.erase(iter);
 +#else
      struct hentry * dp = lookup(word);
      while (dp) {
          if (dp->alen == 0 || !TESTAFF(dp->astr, forbiddenword, dp->alen)) {
-@@ -270,6 +344,7 @@
+@@ -270,6 +344,7 @@ int HashMgr::remove(const char * word)
          }
          dp = dp->next_homonym;
      }
 +#endif
      return 0;
  }
  
-@@ -339,6 +414,44 @@
+@@ -339,6 +414,44 @@ int HashMgr::add_with_affix(const char *
  // initialize: col=-1; hp = NULL; hp = walk_hashtable(&col, hp);
  struct hentry * HashMgr::walk_hashtable(int &col, struct hentry * hp) const
  {  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  // Return NULL if dictionary is not valid.
 +  if (!bdict_reader->IsValid())
 +    return NULL;
 +
 +  // This function is only ever called by one place and not nested. We can
 +  // therefore keep static state between calls and use |col| as a "reset" flag
@@ skipping 24 matching lines @@
 +    hentry entry;
 +    char word[kMaxWordLen];
 +  } hash_entry;
 +
 +  return InitHashEntry(&hash_entry.entry, sizeof(hash_entry),
 +                       &word[0], word_len, affix_ids[0]);
 +#else
    if (hp && hp->next != NULL) return hp->next;
    for (col++; col < tablesize; col++) {
      if (tableptr[col]) return tableptr[col];
-@@ -346,11 +459,13 @@
+@@ -346,11 +459,13 @@ struct hentry * HashMgr::walk_hashtable(
    // null at end and reset to start
    col = -1;
    return NULL;
 +#endif
  }
  
  // load a munched word list and build a hash table on the fly
  int HashMgr::load_tables(const char * tpath, const char * key)
  {
 +#ifndef HUNSPELL_CHROME_CLIENT
    int al;
    char * ap;
    char * dp;
-@@ -471,6 +586,7 @@
+@@ -471,6 +586,7 @@ int HashMgr::load_tables(const char * tp
    }
  
    delete dict;
 +#endif
    return 0;
  }
  
-@@ -479,6 +595,9 @@
+@@ -479,6 +595,9 @@ int HashMgr::load_tables(const char * tp
  
  int HashMgr::hash(const char * word) const
  {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +    return 0;
 +#else
      long  hv = 0;
      for (int i=0; i < 4  &&  *word != 0; i++)
          hv = (hv << 8) | (*word++);
-@@ -487,6 +606,7 @@
+@@ -487,6 +606,7 @@ int HashMgr::hash(const char * word) con
        hv ^= (*word++);
      }
      return (unsigned long) hv % tablesize;
 +#endif
  }
  
  int HashMgr::decode_flags(unsigned short ** result, char * flags, FileMgr * af) {
-@@ -607,7 +727,12 @@
+@@ -607,7 +727,12 @@ int  HashMgr::load_config(const char * a
    int firstline = 1;
   
    // open the affix file
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  hunspell::LineIterator iterator = bdict_reader->GetOtherLineIterator();
 +  FileMgr * afflst = new FileMgr(&iterator);
 +#else
    FileMgr * afflst = new FileMgr(affpath, key);
 +#endif
    if (!afflst) {
      HUNSPELL_WARNING(stderr, "Error - could not open affix description file %s\n",affpath);
      return 1;
-@@ -802,6 +927,121 @@
+@@ -802,6 +927,121 @@ int  HashMgr::parse_aliasf(char * line, 
     return 0;
  }
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +int HashMgr::LoadAFLines()
 +{
 +  utf8 = 1;  // We always use UTF-8.
 +
 +  // Read in all the AF lines which tell us the rules for each affix group ID.
 +  hunspell::LineIterator iterator = bdict_reader->GetAfLineIterator();
@@ skipping 105 matching lines @@
 +}
 +#endif
 +
  int HashMgr::is_aliasf() {
      return (aliasf != NULL);
  }
 Index: src/hunspell/hashmgr.hxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/hashmgr.hxx,v
 retrieving revision 1.3
-diff -u -r1.3 hashmgr.hxx
+diff -u -p -r1.3 hashmgr.hxx
 --- src/hunspell/hashmgr.hxx    15 Apr 2010 11:22:08 -0000      1.3
-+++ src/hunspell/hashmgr.hxx    8 Jan 2013 00:30:25 -0000
++++ src/hunspell/hashmgr.hxx    26 Feb 2013 23:13:13 -0000
 @@ -8,10 +8,25 @@
  #include "htypes.hxx"
  #include "filemgr.hxx"
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +#include <string>
 +#include <map>
 +
 +#include "base/stl_util.h"
 +#include "base/string_piece.h"
 +#include "third_party/hunspell/google/bdict_reader.h"
 +#endif
 +
  enum flag { FLAG_CHAR, FLAG_LONG, FLAG_NUM, FLAG_UNI };
  
  class LIBHUNSPELL_DLL_EXPORTED HashMgr
  {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  // Not owned by this class, owned by the Hunspell object.
 +  hunspell::BDictReader* bdict_reader;
 +  std::map<base::StringPiece, int> custom_word_to_affix_id_map_;
 +  std::vector<std::string*> pointer_to_strings_;
 +#endif
    int               tablesize;
    struct hentry **  tableptr;
    int               userword;
-@@ -34,7 +49,23 @@
+@@ -34,7 +49,23 @@ class LIBHUNSPELL_DLL_EXPORTED HashMgr
  
  
  public:
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  HashMgr(hunspell::BDictReader* reader);
 +
 +  // Return the hentry corresponding to the given word. Returns NULL if the
 +  // word is not there in the cache.
 +  hentry* GetHentryFromHEntryCache(char* word);
 +
 +  // Called before we do a new operation. This will empty the cache of pointers
 +  // to hentries that we have cached. In Chrome, we make these on-demand, but
 +  // they must live as long as the single spellcheck operation that they're part
 +  // of since Hunspell will save pointers to various ones as it works.
 +  //
 +  // This function allows that cache to be emptied and not grow infinitely.
 +  void EmptyHentryCache();
 +#else
    HashMgr(const char * tpath, const char * apath, const char * key = NULL);
 +#endif
    ~HashMgr();
  
    struct hentry * lookup(const char *) const;
-@@ -59,6 +90,40 @@
+@@ -59,6 +90,40 @@ private:
      int al, const char * desc, bool onlyupcase);
    int load_config(const char * affpath, const char * key);
    int parse_aliasf(char * line, FileMgr * af);
 +
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  // Loads the AF lines from a BDICT.
 +  // A BDICT file compresses its AF lines to save memory.
 +  // This function decompresses each AF line and call parse_aliasf().
 +  int LoadAFLines();
 +
@@ skipping 24 matching lines @@
 +  HEntryCache hentry_cache;
 +#endif
 +
    int add_hidden_capitalized_word(char * word, int wbl, int wcl,
      unsigned short * flags, int al, char * dp, int captype);
    int parse_aliasm(char * line, FileMgr * af);
 Index: src/hunspell/htypes.hxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/htypes.hxx,v
 retrieving revision 1.3
-diff -u -r1.3 htypes.hxx
+diff -u -p -r1.3 htypes.hxx
 --- src/hunspell/htypes.hxx     6 Sep 2010 07:58:53 -0000       1.3
-+++ src/hunspell/htypes.hxx     8 Jan 2013 00:30:25 -0000
++++ src/hunspell/htypes.hxx     26 Feb 2013 23:13:13 -0000
 @@ -1,6 +1,16 @@
  #ifndef _HTYPES_HXX_
  #define _HTYPES_HXX_
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +// This is a workaround for preventing errors in parsing Turkish BDICs, which
 +// contain very long AF lines (~ 12,000 chars).
 +// TODO(hbono) change the HashMgr::parse_aliasf() function to be able to parse
 +// longer lines than MAXDELEN.
 +#define MAXDELEN    (8192 * 2)
 +#else
 +#define MAXDELEN    8192
 +#endif  // HUNSPELL_CHROME_CLIENT
 +
  #define ROTATE_LEN   5
  
  #define ROTATE(v,q) \
 Index: src/hunspell/hunspell.cxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/hunspell.cxx,v
 retrieving revision 1.29
-diff -u -r1.29 hunspell.cxx
+diff -u -p -r1.29 hunspell.cxx
 --- src/hunspell/hunspell.cxx   23 Jun 2011 09:21:50 -0000      1.29
-+++ src/hunspell/hunspell.cxx   8 Jan 2013 00:30:25 -0000
++++ src/hunspell/hunspell.cxx   26 Feb 2013 23:13:13 -0000
 @@ -7,20 +7,37 @@
  
  #include "hunspell.hxx"
  #include "hunspell.h"
 +#ifndef HUNSPELL_CHROME_CLIENT
  #ifndef MOZILLA_CLIENT
  #    include "config.h"
  #endif
 +#endif
  #include "csutil.hxx"
@@ skipping 18 matching lines @@
 +    bdict_reader->Init(bdict_data, bdict_length);
 +
 +    pHMgr[0] = new HashMgr(bdict_reader);
 +    if (pHMgr[0]) maxdic = 1;
 +
 +    pAMgr = new AffixMgr(bdict_reader, pHMgr, &maxdic);
 +#else
      /* first set up the hash manager */
      pHMgr[0] = new HashMgr(dpath, affpath, key);
      if (pHMgr[0]) maxdic = 1;
-@@ -28,6 +45,7 @@
+@@ -28,6 +45,7 @@ Hunspell::Hunspell(const char * affpath,
      /* next set up the affix manager */
      /* it needs access to the hash manager lookup methods */
      pAMgr = new AffixMgr(affpath, pHMgr, &maxdic, key);
 +#endif
  
      /* get the preferred try string and the dictionary */
      /* encoding from the Affix Manager for that dictionary */
-@@ -41,7 +59,11 @@
+@@ -41,7 +59,11 @@ Hunspell::Hunspell(const char * affpath,
      wordbreak = pAMgr->get_breaktable();
  
      /* and finally set up the suggestion manager */
 +#ifdef HUNSPELL_CHROME_CLIENT
 +    pSMgr = new SuggestMgr(bdict_reader, try_string, MAXSUGGESTION, pAMgr);
 +#else
      pSMgr = new SuggestMgr(try_string, MAXSUGGESTION, pAMgr);
 +#endif
      if (try_string) free(try_string);
  }
  
-@@ -59,10 +81,16 @@
+@@ -59,10 +81,16 @@ Hunspell::~Hunspell()
      csconv= NULL;
      if (encoding) free(encoding);
      encoding = NULL;
 +#ifdef HUNSPELL_CHROME_CLIENT
 +    if (bdict_reader) delete bdict_reader;
 +    bdict_reader = NULL;
 +#else
      if (affixpath) free(affixpath);
      affixpath = NULL;
 +#endif
  }
  
 +#ifndef HUNSPELL_CHROME_CLIENT
  // load extra dictionaries
  int Hunspell::add_dic(const char * dpath, const char * key) {
      if (maxdic == MAXDIC || !affixpath) return 1;
-@@ -70,6 +98,7 @@
+@@ -70,6 +98,7 @@ int Hunspell::add_dic(const char * dpath
      if (pHMgr[maxdic]) maxdic++; else return 1;
      return 0;
  }
 +#endif
  
  // make a copy of src at destination while removing all leading
  // blanks and removing any trailing periods after recording
-@@ -322,6 +351,9 @@
+@@ -322,6 +351,9 @@ int Hunspell::insert_sug(char ***slst, c
  
  int Hunspell::spell(const char * word, int * info, char ** root)
  {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  if (pHMgr) pHMgr[0]->EmptyHentryCache();
 +#endif
    struct hentry * rv=NULL;
    // need larger vector. For example, Turkish capital letter I converted a
    // 2-byte UTF-8 character (dotless i) by mkallsmall.
-@@ -586,6 +618,13 @@
+@@ -586,6 +618,13 @@ struct hentry * Hunspell::checkword(cons
    if (!len)
        return NULL;
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  // We need to check if the word length is valid to make coverity (Event
 +  // fixed_size_dest: Possible overrun of N byte fixed size buffer) happy.
 +  if ((utf8 && strlen(word) >= MAXWORDUTF8LEN) || (!utf8 && strlen(word) >= MAXWORDLEN))
 +    return NULL;
 +#endif
 +
    // word reversing wrapper for complex prefixes
    if (complexprefixes) {
      if (word != w2) {
-@@ -675,6 +714,9 @@
+@@ -675,6 +714,9 @@ struct hentry * Hunspell::checkword(cons
  
  int Hunspell::suggest(char*** slst, const char * word)
  {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  if (pHMgr) pHMgr[0]->EmptyHentryCache();
 +#endif
    int onlycmpdsug = 0;
    char cw[MAXWORDUTF8LEN];
    char wspace[MAXWORDUTF8LEN];
-@@ -1921,13 +1963,21 @@
+@@ -1921,13 +1963,21 @@ char * Hunspell::morph_with_correction(c
  
  Hunhandle *Hunspell_create(const char * affpath, const char * dpath)
  {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +        return NULL;
 +#else
          return (Hunhandle*)(new Hunspell(affpath, dpath));
 +#endif
  }
  
  Hunhandle *Hunspell_create_key(const char * affpath, const char * dpath,
      const char * key)
  {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +        return NULL;
 +#else
          return (Hunhandle*)(new Hunspell(affpath, dpath, key));
 +#endif
  }
  
  void Hunspell_destroy(Hunhandle *pHunspell)
 Index: src/hunspell/hunspell.hxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/hunspell.hxx,v
 retrieving revision 1.6
-diff -u -r1.6 hunspell.hxx
+diff -u -p -r1.6 hunspell.hxx
 --- src/hunspell/hunspell.hxx   21 Jan 2011 17:30:41 -0000      1.6
-+++ src/hunspell/hunspell.hxx   8 Jan 2013 00:30:25 -0000
++++ src/hunspell/hunspell.hxx   26 Feb 2013 23:13:13 -0000
 @@ -5,6 +5,10 @@
  #include "suggestmgr.hxx"
  #include "langnum.hxx"
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +#include "third_party/hunspell/google/bdict_reader.h"
 +#endif
 +
  #define  SPELL_XML "<?xml?>"
  
  #define MAXDIC 20
-@@ -23,7 +27,9 @@
+@@ -23,7 +27,9 @@ class LIBHUNSPELL_DLL_EXPORTED Hunspell
    HashMgr*        pHMgr[MAXDIC];
    int             maxdic;
    SuggestMgr*     pSMgr;
 +#ifndef HUNSPELL_CHROME_CLIENT // We are using BDict instead.
    char *          affixpath;
 +#endif
    char *          encoding;
    struct cs_info * csconv;
    int             langnum;
-@@ -31,17 +37,28 @@
+@@ -31,17 +37,28 @@ class LIBHUNSPELL_DLL_EXPORTED Hunspell
    int             complexprefixes;
    char**          wordbreak;
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  // Not owned by us, owned by the Hunspell object.
 +  hunspell::BDictReader* bdict_reader;
 +#endif
 +
  public:
  
@@ skipping 12 matching lines @@
    /* load extra dictionaries (only dic files) */
    int add_dic(const char * dpath, const char * key = NULL);
 +#endif
  
    /* spell(word) - spellcheck word
     * output: 0 = bad word, not 0 = good word
 Index: src/hunspell/replist.hxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/replist.hxx,v
 retrieving revision 1.2
-diff -u -r1.2 replist.hxx
+diff -u -p -r1.2 replist.hxx
 --- src/hunspell/replist.hxx    15 Apr 2010 11:22:09 -0000      1.2
-+++ src/hunspell/replist.hxx    8 Jan 2013 00:30:25 -0000
++++ src/hunspell/replist.hxx    26 Feb 2013 23:13:13 -0000
 @@ -2,6 +2,12 @@
  #ifndef _REPLIST_HXX_
  #define _REPLIST_HXX_
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +// Compilation issues in spellchecker.cc think near is a macro, therefore
 +// removing it here solves that problem.
 +#undef near
 +#endif
 +
  #include "hunvisapi.h"
  
  #include "w_char.hxx"
 Index: src/hunspell/suggestmgr.cxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/suggestmgr.cxx,v
 retrieving revision 1.24
-diff -u -r1.24 suggestmgr.cxx
+diff -u -p -r1.24 suggestmgr.cxx
 --- src/hunspell/suggestmgr.cxx 14 Feb 2011 21:47:24 -0000      1.24
-+++ src/hunspell/suggestmgr.cxx 8 Jan 2013 00:30:26 -0000
-@@ -12,9 +12,110 @@
++++ src/hunspell/suggestmgr.cxx 26 Feb 2013 23:13:13 -0000
+@@ -12,9 +12,114 @@
  
  const w_char W_VLINE = { '\0', '|' };
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +namespace {
 +// A simple class which creates temporary hentry objects which are available
 +// only in a scope. To conceal memory operations from SuggestMgr functions,
 +// this object automatically deletes all hentry objects created through
 +// CreateScopedHashEntry() calls in its destructor. So, the following snippet
 +// raises a memory error.
@@ skipping 25 matching lines @@
 +  hentry* CreateScopedHashEntry(int index, const hentry* source);
 +
 + private:
 +  // A struct which encapsulates the new hentry struct introduced in hunspell
 +  // 1.2.8. For a pointer to an hentry struct 'h', hunspell 1.2.8 stores a word
 +  // (including a NUL character) into 'h->word[0]',...,'h->word[h->blen]' even
 +  // though arraysize(h->word[]) is 1. Also, it changed 'astr' to a pointer so
 +  // it can store affix flags into 'h->astr[0]',...,'h->astr[alen-1]'. To handle
 +  // this new hentry struct, we define a struct which combines three values: an
 +  // hentry struct 'hentry'; a char array 'word[kMaxWordLen]', and; an unsigned
-+  // short value 'astr' so a hentry struct 'h' returned from
++  // short array 'astr' so a hentry struct 'h' returned from
 +  // CreateScopedHashEntry() satisfies the following equations:
 +  //   hentry* h = factory.CreateScopedHashEntry(0, source);
 +  //   h->word[0] == ((HashEntryItem*)h)->entry.word[0].
 +  //   h->word[1] == ((HashEntryItem*)h)->word[0].
 +  //   ...
 +  //   h->word[h->blen] == ((HashEntryItem*)h)->word[h->blen-1].
-+  //   h->astr[0] == ((HashEntryItem*)h)->astr.
-+  // Our BDICT does not use affix flags longer than one for now since they are
-+  // discarded by convert_dict, i.e. 'h->astr' is always <= 1. Therefore, this
-+  // struct does not use an array for 'astr'.
++  //   h->astr[0] == ((HashEntryItem*)h)->astr[0].
++  //   h->astr[1] == ((HashEntryItem*)h)->astr[1].
++  //   ...
++  //   h->astr[h->alen-1] == ((HashEntryItem*)h)->astr[h->alen-1].
 +  enum {
 +    kMaxWordLen = 128,
++    kMaxAffixLen = 8,
 +  };
 +  struct HashEntryItem {
 +    hentry entry;
 +    char word[kMaxWordLen];
-+    unsigned short astr;
++    unsigned short astr[kMaxAffixLen];
 +  };
 +
 +  HashEntryItem hash_items_[MAX_ROOTS];
 +};
 +
 +ScopedHashEntryFactory::ScopedHashEntryFactory() {
 +  memset(&hash_items_[0], 0, sizeof(hash_items_));
 +}
 +
 +ScopedHashEntryFactory::~ScopedHashEntryFactory() {
 +}
 +
 +hentry* ScopedHashEntryFactory::CreateScopedHashEntry(int index,
 +                                                      const hentry* source) {
-+  if (index >= MAX_ROOTS || source->blen >= kMaxWordLen || source->alen > 1)
++  if (index >= MAX_ROOTS || source->blen >= kMaxWordLen)
 +    return NULL;
 +
 +  // Retrieve a HashEntryItem struct from our spool, initialize it, and
 +  // returns the address of its 'hentry' member.
 +  size_t source_size = sizeof(hentry) + source->blen + 1;
 +  HashEntryItem* hash_item = &hash_items_[index];
 +  memcpy(&hash_item->entry, source, source_size);
 +  if (source->astr) {
-+    hash_item->astr = *source->astr;
-+    hash_item->entry.astr = &hash_item->astr;
++    hash_item->entry.alen = source->alen;
++    if (source->alen > kMaxAffixLen)
++      hash_item->entry.alen = kMaxAffixLen;
++    memcpy(hash_item->astr, source->astr, hash_item->entry.alen * sizeof(unsigned short));
++    hash_item->entry.astr = &hash_item->astr[0];
 +  }
 +  return &hash_item->entry;
 +}
 +
 +}  // namespace
 +#endif
 +
 +
 +#ifdef HUNSPELL_CHROME_CLIENT
 +SuggestMgr::SuggestMgr(hunspell::BDictReader* reader,
 +                       const char * tryme, int maxn, 
 +                       AffixMgr * aptr)
 +{
 +  bdict_reader = reader;
 +#else
  SuggestMgr::SuggestMgr(const char * tryme, int maxn, 
                         AffixMgr * aptr)
  {
 +#endif
  
    // register affix manager and check in string of chars to 
    // try when building candidate suggestions
-@@ -407,6 +508,49 @@
+@@ -407,6 +512,49 @@ int SuggestMgr::replchars(char** wlst, c
    int lenr, lenp;
    int wl = strlen(word);
    if (wl < 2 || ! pAMgr) return ns;
 +  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  const char *pattern, *pattern2;
 +  hunspell::ReplacementIterator iterator = bdict_reader->GetReplacementIterator();
 +  while (iterator.GetNext(&pattern, &pattern2)) {
 +      r = word;
 +      lenr = strlen(pattern2);
@@ skipping 29 matching lines @@
 +              sp = strchr(prev, ' ');
 +            }
 +          }
 +          r++; // search for the next letter
 +    }
 +  }
 +#else
    int numrep = pAMgr->get_numrep();
    struct replentry* reptable = pAMgr->get_reptable();
    if (reptable==NULL) return ns;
-@@ -448,6 +592,7 @@
+@@ -448,6 +596,7 @@ int SuggestMgr::replchars(char** wlst, c
            r++; // search for the next letter
        }
     }
 +#endif
     return ns;
  }
  
-@@ -678,7 +823,9 @@
+@@ -678,7 +827,9 @@ int SuggestMgr::extrachar(char** wlst, c
  // error is missing a letter it needs
  int SuggestMgr::forgotchar(char ** wlst, const char * word, int ns, int cpdsuggest)
  {
 -   char candidate[MAXSWUTF8L];
 +   // TODO(rouslan): Remove the interim change below when this patch lands:
 +   // http://sf.net/tracker/?func=detail&aid=3595024&group_id=143754&atid=756395
 +   char candidate[MAXSWUTF8L + 4];
     char * p;
     clock_t timelimit = clock();
     int timer = MINTIMER;
-@@ -700,8 +847,10 @@
+@@ -700,8 +851,10 @@ int SuggestMgr::forgotchar(char ** wlst,
  // error is missing a letter it needs
  int SuggestMgr::forgotchar_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
  {
 -   w_char  candidate_utf[MAXSWL];
 -   char    candidate[MAXSWUTF8L];
 +   // TODO(rouslan): Remove the interim change below when this patch lands:
 +   // http://sf.net/tracker/?func=detail&aid=3595024&group_id=143754&atid=756395
 +   w_char  candidate_utf[MAXSWL + 1];
 +   char    candidate[MAXSWUTF8L + 4];
     w_char * p;
     clock_t timelimit = clock();
     int timer = MINTIMER;
-@@ -1057,6 +1206,9 @@
+@@ -1057,6 +1210,9 @@ int SuggestMgr::ngsuggest(char** wlst, c
  
    struct hentry* hp = NULL;
    int col = -1;
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  ScopedHashEntryFactory hash_entry_factory;
 +#endif
    phonetable * ph = (pAMgr) ? pAMgr->get_phonetable() : NULL;
    char target[MAXSWUTF8L];
    char candidate[MAXSWUTF8L];
-@@ -1115,7 +1267,11 @@
+@@ -1115,7 +1271,11 @@ int SuggestMgr::ngsuggest(char** wlst, c
  
      if (sc > scores[lp]) {
        scores[lp] = sc;  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +      roots[lp] = hash_entry_factory.CreateScopedHashEntry(lp, hp);
 +#else
        roots[lp] = hp;
 +#endif
        lval = sc;
        for (j=0; j < MAX_ROOTS; j++)
          if (scores[j] < lval) {
 Index: src/hunspell/suggestmgr.hxx
 ===================================================================
 RCS file: /cvsroot/hunspell/hunspell/src/hunspell/suggestmgr.hxx,v
 retrieving revision 1.5
-diff -u -r1.5 suggestmgr.hxx
+diff -u -p -r1.5 suggestmgr.hxx
 --- src/hunspell/suggestmgr.hxx 21 Jan 2011 22:10:24 -0000      1.5
-+++ src/hunspell/suggestmgr.hxx 8 Jan 2013 00:30:26 -0000
-@@ -52,7 +52,11 @@
++++ src/hunspell/suggestmgr.hxx 26 Feb 2013 23:13:13 -0000
+@@ -52,7 +52,11 @@ class LIBHUNSPELL_DLL_EXPORTED SuggestMg
  
  
  public:
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  SuggestMgr(hunspell::BDictReader* reader, const char * tryme, int maxn, AffixMgr *aptr);
 +#else
    SuggestMgr(const char * tryme, int maxn, AffixMgr *aptr);
 +#endif
    ~SuggestMgr();
  
    int suggest(char*** slst, const char * word, int nsug, int * onlycmpdsug);
-@@ -66,6 +70,10 @@
+@@ -66,6 +70,10 @@ public:
    char * suggest_morph_for_spelling_error(const char * word);
  
  private:
 +#ifdef HUNSPELL_CHROME_CLIENT
 +   // Not owned by us, owned by the Hunspell object.
 +   hunspell::BDictReader* bdict_reader;
 +#endif
     int testsug(char** wlst, const char * candidate, int wl, int ns, int cpdsuggest,
       int * timer, clock_t * timelimit);
     int checkword(const char *, int, int, int *, clock_t *);