[spellcheck] Updated Hunspell to 1.6.0

third_party/hunspell/google.patch

-diff --git a/third_party/hunspell/src/hunspell/affixmgr.cxx b/third_party/hunspell/src/hunspell/affixmgr.cxx
-index cc9e69b..d31944e 100644
---- a/third_party/hunspell/src/hunspell/affixmgr.cxx
-+++ b/third_party/hunspell/src/hunspell/affixmgr.cxx
+diff --git a/src/hunspell/affixmgr.cxx b/src/hunspell/affixmgr.cxx
+index 658a8aa..2ece1cd 100644
+--- a/src/hunspell/affixmgr.cxx
++++ b/src/hunspell/affixmgr.cxx
 @@ -87,11 +87,19 @@
  
  #include "csutil.hxx"
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +AffixMgr::AffixMgr(hunspell::BDictReader* reader,
 +                   const std::vector<HashMgr*>& ptr)
 +  : alldic(ptr)
 +  , pHMgr(ptr[0]) {
 +  bdict_reader = reader;
@@ skipping 171 matching lines @@
              ((at == 'P') && (dupflags[aflag] & dupPFX))) {
            HUNSPELL_WARNING(
 @@ -4497,6 +4576,7 @@ bool AffixMgr::parse_affix(const std::string& line,
                af->getlinenum());
          }
          dupflags[aflag] += (char)((at == 'S') ? dupSFX : dupPFX);
 +#endif
          break;
        }
        // piece 3 - is cross product indicator
-diff --git a/third_party/hunspell/src/hunspell/affixmgr.hxx b/third_party/hunspell/src/hunspell/affixmgr.hxx
-index c7d5a63..55acd6a 100644
---- a/third_party/hunspell/src/hunspell/affixmgr.hxx
-+++ b/third_party/hunspell/src/hunspell/affixmgr.hxx
+diff --git a/src/hunspell/affixmgr.hxx b/src/hunspell/affixmgr.hxx
+index 83a4b42..162b475 100644
+--- a/src/hunspell/affixmgr.hxx
++++ b/src/hunspell/affixmgr.hxx
 @@ -92,6 +92,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 52 matching lines @@
    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);
    bool parse_flag(const std::string& line, unsigned short* out, FileMgr* af);
    bool parse_num(const std::string& line, int* out, FileMgr* af);
-diff --git a/third_party/hunspell/src/hunspell/filemgr.cxx b/third_party/hunspell/src/hunspell/filemgr.cxx
+diff --git a/src/hunspell/filemgr.cxx b/src/hunspell/filemgr.cxx
 index b7c89b2..aef6dba 100644
---- a/third_party/hunspell/src/hunspell/filemgr.cxx
-+++ b/third_party/hunspell/src/hunspell/filemgr.cxx
+--- a/src/hunspell/filemgr.cxx
++++ b/src/hunspell/filemgr.cxx
 @@ -78,6 +78,32 @@
  #include "filemgr.hxx"
  #include "csutil.hxx"
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +#include "third_party/hunspell/google/bdict_reader.h"
 +
 +FileMgr::FileMgr(hunspell::LineIterator* iterator) : iterator_(iterator) {
 +}
 +
@@ skipping 18 matching lines @@
 +}
 +#else
  int FileMgr::fail(const char* err, const char* par) {
    fprintf(stderr, err, par);
    return -1;
 @@ -118,3 +144,4 @@ bool FileMgr::getline(std::string& dest) {
  int FileMgr::getlinenum() {
    return linenum;
  }
 +#endif
-diff --git a/third_party/hunspell/src/hunspell/filemgr.hxx b/third_party/hunspell/src/hunspell/filemgr.hxx
-index ca51faf..daa6d0b 100644
---- a/third_party/hunspell/src/hunspell/filemgr.hxx
-+++ b/third_party/hunspell/src/hunspell/filemgr.hxx
+diff --git a/src/hunspell/filemgr.hxx b/src/hunspell/filemgr.hxx
+index 991e924..65fae23 100644
+--- a/src/hunspell/filemgr.hxx
++++ b/src/hunspell/filemgr.hxx
 @@ -80,6 +80,30 @@
  #include <string>
  #include <fstream>
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +namespace hunspell {
 +class LineIterator;
 +}  // namespace hunspell
 +
 +// A class which encapsulates operations of reading a BDICT file.
@@ skipping 16 matching lines @@
 +};
 +#else
  class FileMgr {
   private:
    FileMgr(const FileMgr&);
 @@ -99,3 +123,4 @@ class FileMgr {
    int getlinenum();
  };
  #endif
 +#endif
-diff --git a/third_party/hunspell/src/hunspell/hashmgr.cxx b/third_party/hunspell/src/hunspell/hashmgr.cxx
-index 072bc1a..b07c585 100644
---- a/third_party/hunspell/src/hunspell/hashmgr.cxx
-+++ b/third_party/hunspell/src/hunspell/hashmgr.cxx
+diff --git a/src/hunspell/hashmgr.cxx b/src/hunspell/hashmgr.cxx
+index 1de1690..770fac1 100644
+--- a/src/hunspell/hashmgr.cxx
++++ b/src/hunspell/hashmgr.cxx
 @@ -84,8 +84,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)
 -    : tablesize(0),
@@ skipping 11 matching lines @@
 +  // 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);
-@@ -156,14 +168,57 @@ HashMgr::~HashMgr() {
+@@ -158,14 +170,57 @@ HashMgr::~HashMgr() {
  #endif
  #endif
  
 +#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 37 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)];
-@@ -175,6 +230,7 @@ struct hentry* HashMgr::lookup(const char* word) const {
+@@ -177,6 +232,7 @@ struct hentry* HashMgr::lookup(const char* word) const {
      }
    }
    return NULL;
 +#endif
  }
  
  // add a word to the hash table (private)
-@@ -184,6 +240,8 @@ int HashMgr::add_word(const std::string& in_word,
+@@ -186,6 +242,8 @@ int HashMgr::add_word(const std::string& in_word,
                        int al,
                        const std::string* in_desc,
                        bool onlyupcase) {
 +// TODO: The following 40 lines or so are actually new. Should they be included?
 +#ifndef HUNSPELL_CHROME_CLIENT
    const std::string* word = &in_word;
    const std::string* desc = in_desc;
  
-@@ -316,6 +374,17 @@ int HashMgr::add_word(const std::string& in_word,
+@@ -318,6 +376,17 @@ int HashMgr::add_word(const std::string& in_word,
  
    delete desc_copy;
    delete word_copy;
 +#else
 +  std::map<base::StringPiece, int>::iterator iter =
 +      custom_word_to_affix_id_map_.find(in_word);
 +  if (iter == custom_word_to_affix_id_map_.end()) {  // word needs to be added
 +    std::string* new_string_word = new std::string(in_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;
  }
  
-@@ -376,6 +445,12 @@ int HashMgr::get_clen_and_captype(const std::string& word, int* captype) {
+@@ -378,6 +447,12 @@ int HashMgr::get_clen_and_captype(const std::string& word, int* captype) {
  
  // remove word (personal dictionary function for standalone applications)
  int HashMgr::remove(const std::string& 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.c_str());
    while (dp) {
      if (dp->alen == 0 || !TESTAFF(dp->astr, forbiddenword, dp->alen)) {
-@@ -392,6 +467,7 @@ int HashMgr::remove(const std::string& word) {
+@@ -395,6 +470,7 @@ int HashMgr::remove(const std::string& word) {
      }
      dp = dp->next_homonym;
    }
 +#endif
    return 0;
  }
  
-@@ -465,6 +541,44 @@ int HashMgr::add_with_affix(const std::string& word, const std::string& example)
+@@ -469,6 +545,44 @@ int HashMgr::add_with_affix(const std::string& word, const std::string& example)
  // walk the hash table entry by entry - null at end
  // 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++) {
-@@ -474,10 +588,12 @@ struct hentry* HashMgr::walk_hashtable(int& col, struct hentry* hp) const {
+@@ -478,10 +592,12 @@ struct hentry* HashMgr::walk_hashtable(int& col, struct hentry* hp) const {
    // 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
    // open dictionary file
    FileMgr* dict = new FileMgr(tpath, key);
    if (dict == NULL)
-@@ -606,12 +722,16 @@ int HashMgr::load_tables(const char* tpath, const char* key) {
+@@ -610,12 +726,16 @@ int HashMgr::load_tables(const char* tpath, const char* key) {
    }
  
    delete dict;
 +#endif
    return 0;
  }
  
  // the hash function is a simple load and rotate
  // algorithm borrowed
  int HashMgr::hash(const char* word) const {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +    return 0;
 +#else
    unsigned long hv = 0;
    for (int i = 0; i < 4 && *word != 0; i++)
      hv = (hv << 8) | (*word++);
-@@ -620,6 +740,7 @@ int HashMgr::hash(const char* word) const {
+@@ -624,6 +744,7 @@ int HashMgr::hash(const char* word) const {
      hv ^= (*word++);
    }
    return (unsigned long)hv % tablesize;
 +#endif
  }
  
  int HashMgr::decode_flags(unsigned short** result, const std::string& flags, FileMgr* af) const {
-@@ -829,7 +950,12 @@ int HashMgr::load_config(const char* affpath, const char* key) {
+@@ -833,7 +954,12 @@ int HashMgr::load_config(const char* affpath, const char* key) {
    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);
-@@ -1058,6 +1184,122 @@ bool HashMgr::parse_aliasf(const std::string& line, FileMgr* af) {
+@@ -1062,6 +1188,122 @@ bool HashMgr::parse_aliasf(const std::string& line, FileMgr* af) {
    return true;
  }
  
 +#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 102 matching lines @@
 +  if (found != cache.end())
 +    return found->second;
 +  else
 +    return NULL;
 +}
 +#endif
 +
  int HashMgr::is_aliasf() const {
    return (aliasf != NULL);
  }
-diff --git a/third_party/hunspell/src/hunspell/hashmgr.hxx b/third_party/hunspell/src/hunspell/hashmgr.hxx
-index a158a16..9714a90 100644
---- a/third_party/hunspell/src/hunspell/hashmgr.hxx
-+++ b/third_party/hunspell/src/hunspell/hashmgr.hxx
+diff --git a/src/hunspell/hashmgr.hxx b/src/hunspell/hashmgr.hxx
+index 812171a..af27d6c 100644
+--- a/src/hunspell/hashmgr.hxx
++++ b/src/hunspell/hashmgr.hxx
 @@ -82,9 +82,23 @@
  #include "filemgr.hxx"
  #include "w_char.hxx"
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +#include <map>
 +
 +#include "base/stl_util.h"
 +#include "base/strings/string_piece.h"
 +#include "third_party/hunspell/google/bdict_reader.h"
@@ skipping 69 matching lines @@
 +
 +  // See EmptyHentryCache above. Note that each one is actually a linked list
 +  // followed by the homonym pointer.
 +  typedef std::map<std::string, hentry*> HEntryCache;
 +  HEntryCache hentry_cache;
 +#endif
 +
    int add_hidden_capitalized_word(const std::string& word,
                                    int wcl,
                                    unsigned short* flags,
-diff --git a/third_party/hunspell/src/hunspell/htypes.hxx b/third_party/hunspell/src/hunspell/htypes.hxx
-index d244394..05ef6af 100644
---- a/third_party/hunspell/src/hunspell/htypes.hxx
-+++ b/third_party/hunspell/src/hunspell/htypes.hxx
+diff --git a/src/hunspell/htypes.hxx b/src/hunspell/htypes.hxx
+index 1e6c118..c3aa2be 100644
+--- a/src/hunspell/htypes.hxx
++++ b/src/hunspell/htypes.hxx
 @@ -41,6 +41,16 @@
- #ifndef _HTYPES_HXX_
- #define _HTYPES_HXX_
+ #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) \
-diff --git a/third_party/hunspell/src/hunspell/hunspell.cxx b/third_party/hunspell/src/hunspell/hunspell.cxx
-index 114570f..1110ee0 100644
---- a/third_party/hunspell/src/hunspell/hunspell.cxx
-+++ b/third_party/hunspell/src/hunspell/hunspell.cxx
+diff --git a/src/hunspell/hunspell.cxx b/src/hunspell/hunspell.cxx
+index abcdb8f..c8c5cf4 100644
+--- a/src/hunspell/hunspell.cxx
++++ b/src/hunspell/hunspell.cxx
 @@ -79,6 +79,9 @@
  #include "hunspell.hxx"
  #include "suggestmgr.hxx"
  #include "hunspell.h"
 +#ifndef HUNSPELL_CHROME_CLIENT
 +#    include "config.h"
 +#endif
  #include "csutil.hxx"
  
  #include <limits>
 @@ -89,9 +92,15 @@
  class HunspellImpl
  {
  public:
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  HunspellImpl(const unsigned char* bdict_data, size_t bdict_length);
 +#else
    HunspellImpl(const char* affpath, const char* dpath, const char* key);
 +#endif
    ~HunspellImpl();
 +#ifndef HUNSPELL_CHROME_CLIENT
    int add_dic(const char* dpath, const char* key);
 +#endif
    std::vector<std::string> suffix_suggest(const std::string& root_word);
    std::vector<std::string> generate(const std::string& word, const std::vector<std::string>& pl);
    std::vector<std::string> generate(const std::string& word, const std::string& pattern);
-@@ -115,7 +124,9 @@ private:
+@@ -116,7 +125,9 @@ private:
    AffixMgr* pAMgr;
    std::vector<HashMgr*> m_HMgrs;
    SuggestMgr* pSMgr;
 +#ifndef HUNSPELL_CHROME_CLIENT // We are using BDict instead.
    char* affixpath;
 +#endif
    std::string encoding;
    struct cs_info* csconv;
    int langnum;
-@@ -123,6 +134,11 @@ private:
+@@ -124,6 +135,11 @@ private:
    int complexprefixes;
    std::vector<std::string> wordbreak;
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  // Not owned by us, owned by the Hunspell object.
 +  hunspell::BDictReader* bdict_reader;
 +#endif
 +
  private:
    void cleanword(std::string& dest, const std::string&, int* pcaptype, int* pabbrev);
    size_t cleanword2(std::string& dest,
-@@ -152,22 +168,43 @@ private:
+@@ -153,22 +169,43 @@ private:
    HunspellImpl& operator=(const HunspellImpl&);
  };
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +Hunspell::Hunspell(const unsigned char* bdict_data, size_t bdict_length)
 +  : m_Impl(new HunspellImpl(bdict_data, bdict_length)) {
 +#else
  Hunspell::Hunspell(const char* affpath, const char* dpath, const char* key)
    : m_Impl(new HunspellImpl(affpath, dpath, key)) {
 +#endif
@@ skipping 23 matching lines @@
 +  /* first set up the hash manager */
    m_HMgrs.push_back(new HashMgr(dpath, affpath, key));
  
    /* next set up the affix manager */
    /* it needs access to the hash manager lookup methods */
    pAMgr = new AffixMgr(affpath, m_HMgrs, key);
 +#endif
  
    /* get the preferred try string and the dictionary */
    /* encoding from the Affix Manager for that dictionary */
-@@ -181,7 +218,11 @@ HunspellImpl::HunspellImpl(const char* affpath, const char* dpath, const char* k
-   wordbreak = pAMgr->get_breaktable();
+@@ -185,7 +222,11 @@ HunspellImpl::HunspellImpl(const char* affpath, const char* dpath, const char* k
+   strcpy(&dic_encoding_vec[0], encoding.c_str());
  
    /* 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);
  }
-@@ -201,11 +242,17 @@ HunspellImpl::~HunspellImpl() {
+@@ -205,11 +246,17 @@ HunspellImpl::~HunspellImpl() {
    delete[] csconv;
  #endif
    csconv = 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) {
    return m_Impl->add_dic(dpath, key);
-@@ -218,6 +265,7 @@ int HunspellImpl::add_dic(const char* dpath, const char* key) {
+@@ -222,6 +269,7 @@ int HunspellImpl::add_dic(const char* dpath, const char* key) {
    m_HMgrs.push_back(new HashMgr(dpath, affixpath, key));
    return 0;
  }
 +#endif
  
  // make a copy of src at destination while removing all leading
  // blanks and removing any trailing periods after recording
-@@ -411,6 +459,9 @@ bool Hunspell::spell(const std::string& word, int* info, std::string* root) {
+@@ -415,6 +463,9 @@ bool Hunspell::spell(const std::string& word, int* info, std::string* root) {
  }
  
  bool HunspellImpl::spell(const std::string& word, int* info, std::string* root) {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  if (m_HMgrs[0]) m_HMgrs[0]->EmptyHentryCache();
 +#endif
    struct hentry* rv = NULL;
  
    int info2 = 0;
-@@ -717,6 +768,13 @@ struct hentry* HunspellImpl::checkword(const std::string& w, int* info, std::str
+@@ -721,6 +772,13 @@ struct hentry* HunspellImpl::checkword(const std::string& w, int* info, std::str
    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 (!usebuffer) {
-@@ -829,6 +887,9 @@ std::vector<std::string> Hunspell::suggest(const std::string& word) {
+@@ -833,6 +891,9 @@ std::vector<std::string> Hunspell::suggest(const std::string& word) {
  }
  
  std::vector<std::string> HunspellImpl::suggest(const std::string& word) {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  if (m_HMgrs[0]) m_HMgrs[0]->EmptyHentryCache();
 +#endif
    std::vector<std::string> slst;
  
    int onlycmpdsug = 0;
-@@ -992,9 +1053,9 @@ std::vector<std::string> HunspellImpl::suggest(const std::string& word) {
-         w.append(slst[j].substr(pos + 1));
-         (void)spell(w, &info, NULL);
-         if ((info & SPELL_COMPOUND) && (info & SPELL_FORBIDDEN)) {
--          slst[pos] = ' ';
-+          slst[j][pos] = ' ';
-         } else
--          slst[pos] = '-';
-+          slst[j][pos] = '-';
-       }
-     }
-   }
-@@ -1845,22 +1906,32 @@ int Hunspell::generate(char*** slst, const char* word, const char* pattern) {
+@@ -1875,22 +1936,32 @@ int Hunspell::generate(char*** slst, const char* word, const char* pattern) {
  }
  
  Hunhandle* Hunspell_create(const char* affpath, const char* dpath) {
 +#ifdef HUNSPELL_CHROME_CLIENT
 +        return NULL;
 +#else
    return (Hunhandle*)(new Hunspell(affpath, dpath));
 +#endif
  }
  
@@ skipping 12 matching lines @@
  }
  
 +#ifndef HUNSPELL_CHROME_CLIENT
  int Hunspell_add_dic(Hunhandle* pHunspell, const char* dpath) {
    return reinterpret_cast<Hunspell*>(pHunspell)->add_dic(dpath);
  }
 +#endif
  
  int Hunspell_spell(Hunhandle* pHunspell, const char* word) {
    return reinterpret_cast<Hunspell*>(pHunspell)->spell(std::string(word));
-diff --git a/third_party/hunspell/src/hunspell/hunspell.hxx b/third_party/hunspell/src/hunspell/hunspell.hxx
-index db25bae..251d58e 100644
---- a/third_party/hunspell/src/hunspell/hunspell.hxx
-+++ b/third_party/hunspell/src/hunspell/hunspell.hxx
-@@ -78,6 +78,10 @@
+diff --git a/src/hunspell/hunspell.hxx b/src/hunspell/hunspell.hxx
+index 43af66b..a35df83 100644
+--- a/src/hunspell/hunspell.hxx
++++ b/src/hunspell/hunspell.hxx
+@@ -79,6 +79,10 @@
  #include <string>
  #include <vector>
  
 +#ifdef HUNSPELL_CHROME_CLIENT
 +#include "third_party/hunspell/google/bdict_reader.h"
 +#endif
 +
  #define SPELL_XML "<?xml?>"
  
  #define MAXSUGGESTION 15
-@@ -111,11 +115,17 @@ class LIBHUNSPELL_DLL_EXPORTED Hunspell {
+@@ -115,11 +119,17 @@ class LIBHUNSPELL_DLL_EXPORTED Hunspell {
     * long path names (without the long path prefix Hunspell will use fopen()
     * with system-dependent character encoding instead of _wfopen()).
     */
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  Hunspell(const unsigned char* bdict_data, size_t bdict_length);
 +#else
    Hunspell(const char* affpath, const char* dpath, const char* key = NULL);
 +#endif
    ~Hunspell();
  
 +#ifndef HUNSPELL_CHROME_CLIENT
    /* load extra dictionaries (only dic files) */
    int add_dic(const char* dpath, const char* key = NULL);
 +#endif
  
    /* spell(word) - spellcheck word
     * output: false = bad word, true = good word
-diff --git a/third_party/hunspell/src/hunspell/replist.cxx b/third_party/hunspell/src/hunspell/replist.cxx
-index 8404947..3128420 100644
---- a/third_party/hunspell/src/hunspell/replist.cxx
-+++ b/third_party/hunspell/src/hunspell/replist.cxx
+diff --git a/src/hunspell/replist.cxx b/src/hunspell/replist.cxx
+index 89d4caa..756dc03 100644
+--- a/src/hunspell/replist.cxx
++++ b/src/hunspell/replist.cxx
 @@ -167,6 +167,7 @@ int RepList::add(const std::string& in_pat1, const std::string& pat2) {
    mystrrep(r->outstrings[type], "_", " ");
    dat[pos++] = r;
    // sort to the right place in the list
 +#if 0
    int i;
    for (i = pos - 1; i > 0; i--) {
      int c = strncmp(r->pattern.c_str(), dat[i-1]->pattern.c_str(), dat[i-1]->pattern.size());
 @@ -184,6 +185,15 @@ int RepList::add(const std::string& in_pat1, const std::string& pat2) {
    }
    memmove(dat + i + 1, dat + i, (pos - i - 1) * sizeof(replentry *));
    dat[i] = r;
 +#else
 +  for (int i = pos - 1; i > 0; i--) {
 +    r = dat[i];
 +    if (r->pattern < dat[i - 1]->pattern) {
 +      dat[i] = dat[i - 1];
 +      dat[i - 1] = r;
 +    } else break;
 +  }
 +#endif
    return 0;
  }
  
-diff --git a/third_party/hunspell/src/hunspell/replist.hxx b/third_party/hunspell/src/hunspell/replist.hxx
-index ccf29b5c..176ccec 100644
---- a/third_party/hunspell/src/hunspell/replist.hxx
-+++ b/third_party/hunspell/src/hunspell/replist.hxx
+diff --git a/src/hunspell/replist.hxx b/src/hunspell/replist.hxx
+index 2f9d350..3afe005 100644
+--- a/src/hunspell/replist.hxx
++++ b/src/hunspell/replist.hxx
 @@ -75,6 +75,12 @@
- #ifndef _REPLIST_HXX_
- #define _REPLIST_HXX_
+ #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 "w_char.hxx"
  
  #include <string>
-diff --git a/third_party/hunspell/src/hunspell/suggestmgr.cxx b/third_party/hunspell/src/hunspell/suggestmgr.cxx
-index 7a9dafa..55f99b6 100644
---- a/third_party/hunspell/src/hunspell/suggestmgr.cxx
-+++ b/third_party/hunspell/src/hunspell/suggestmgr.cxx
+diff --git a/src/hunspell/suggestmgr.cxx b/src/hunspell/suggestmgr.cxx
+index b998341..4e122da 100644
+--- a/src/hunspell/suggestmgr.cxx
++++ b/src/hunspell/suggestmgr.cxx
 @@ -82,7 +82,112 @@
  
  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
@@ skipping 133 matching lines @@
 @@ -1047,6 +1168,9 @@ void SuggestMgr::ngsuggest(std::vector<std::string>& wlst,
  
    struct hentry* hp = NULL;
    int col = -1;
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  ScopedHashEntryFactory hash_entry_factory;
 +#endif
    phonetable* ph = (pAMgr) ? pAMgr->get_phonetable() : NULL;
    std::string target;
    std::string candidate;
-@@ -1109,7 +1233,11 @@ void SuggestMgr::ngsuggest(std::vector<std::string>& wlst,
+@@ -1074,12 +1198,12 @@ void SuggestMgr::ngsuggest(std::vector<std::string>& wlst,
+     u8_u16(w_word, word);
+     u8_u16(w_target, target);
+   }
+-  
++
+   std::vector<w_char> w_entry;
+   std::string f;
+   std::vector<w_char> w_f;
+   std::vector<w_char> w_target2;
+-  
++
+   for (size_t i = 0; i < rHMgr.size(); ++i) {
+     while (0 != (hp = rHMgr[i]->walk_hashtable(col, hp))) {
+       if ((hp->astr) && (pAMgr) &&
+@@ -1143,7 +1267,11 @@ void SuggestMgr::ngsuggest(std::vector<std::string>& wlst,
  
        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 (int j = 0; j < MAX_ROOTS; j++)
            if (scores[j] < lval) {
-@@ -1137,6 +1265,7 @@ void SuggestMgr::ngsuggest(std::vector<std::string>& wlst,
-   int thresh = 0;
-   for (int sp = 1; sp < 4; sp++) {
-     if (utf8) {
-+      u8_u16(u8, word);
-       for (int k = sp; k < n; k += 4) {
-         u8[k].l = '*';
-         u8[k].h = 0;
-@@ -1968,8 +2097,8 @@ void SuggestMgr::lcs(const char* s,
+@@ -2058,8 +2186,8 @@ void SuggestMgr::lcs(const char* s,
      m = strlen(s);
      n = strlen(s2);
    }
 -  c = (char*)malloc((m + 1) * (n + 1));
 -  b = (char*)malloc((m + 1) * (n + 1));
 +  c = (char *) calloc(m + 1, n + 1);
 +  b = (char *) calloc(m + 1, n + 1);
    if (!c || !b) {
      if (c)
        free(c);
-@@ -1978,10 +2107,6 @@ void SuggestMgr::lcs(const char* s,
+@@ -2068,10 +2196,6 @@ void SuggestMgr::lcs(const char* s,
      *result = NULL;
      return;
    }
 -  for (i = 1; i <= m; i++)
 -    c[i * (n + 1)] = 0;
 -  for (j = 0; j <= n; j++)
 -    c[j] = 0;
    for (i = 1; i <= m; i++) {
      for (j = 1; j <= n; j++) {
        if (((utf8) && (su[i - 1] == su2[j - 1])) ||
-diff --git a/third_party/hunspell/src/hunspell/suggestmgr.hxx b/third_party/hunspell/src/hunspell/suggestmgr.hxx
-index ee0322c..f940431 100644
---- a/third_party/hunspell/src/hunspell/suggestmgr.hxx
-+++ b/third_party/hunspell/src/hunspell/suggestmgr.hxx
+diff --git a/src/hunspell/suggestmgr.hxx b/src/hunspell/suggestmgr.hxx
+index 6ba9dc8..0b80fac 100644
+--- a/src/hunspell/suggestmgr.hxx
++++ b/src/hunspell/suggestmgr.hxx
 @@ -124,7 +124,11 @@ class SuggestMgr {
    int complexprefixes;
  
   public:
 +#ifdef HUNSPELL_CHROME_CLIENT
 +  SuggestMgr(hunspell::BDictReader* reader, const char * tryme, int maxn, AffixMgr *aptr);
 +#else
    SuggestMgr(const char* tryme, unsigned int maxn, AffixMgr* aptr);
 +#endif
    ~SuggestMgr();
  
    void suggest(std::vector<std::string>& slst, const char* word, int* onlycmpdsug);
 @@ -134,6 +138,10 @@ class SuggestMgr {
    std::string suggest_gen(const std::vector<std::string>& pl, const std::string& pattern);
  
   private:
 +#ifdef HUNSPELL_CHROME_CLIENT
 +   // Not owned by us, owned by the Hunspell object.
 +   hunspell::BDictReader* bdict_reader;
 +#endif
    void testsug(std::vector<std::string>& wlst,
                 const std::string& candidate,
                 int cpdsuggest,
-diff --git a/third_party/hunspell/src/parsers/testparser.cxx b/third_party/hunspell/src/parsers/testparser.cxx
-index 69f2cbc3..81db53a 100644
---- a/third_party/hunspell/src/parsers/testparser.cxx
-+++ b/third_party/hunspell/src/parsers/testparser.cxx
-@@ -14,15 +14,15 @@
-  * The Original Code is Hunspell, based on MySpell.
-  *
-  * The Initial Developers of the Original Code are
-- * Kevin Hendricks (MySpell) and Németh László (Hunspell).
-+ * Kevin Hendricks (MySpell) and Németh László (Hunspell).
-  * Portions created by the Initial Developers are Copyright (C) 2002-2005
-  * the Initial Developers. All Rights Reserved.
-  *
-  * Contributor(s): David Einstein, Davide Prina, Giuseppe Modugno,
-- * Gianluca Turconi, Simon Brouwer, Noll János, Bíró Árpád,
-- * Goldman Eleonóra, Sarlós Tamás, Bencsáth Boldizsár, Halácsy Péter,
-- * Dvornik László, Gefferth András, Nagy Viktor, Varga Dániel, Chris Halls,
-- * Rene Engelhard, Bram Moolenaar, Dafydd Jones, Harri Pitkänen
-+ * Gianluca Turconi, Simon Brouwer, Noll János, Bíró Árpád,
-+ * Goldman Eleonóra, Sarlós Tamás, Bencsáth Boldizsár, Halácsy Péter,
-+ * Dvornik László, Gefferth András, Nagy Viktor, Varga Dániel, Chris Halls,
-+ * Rene Engelhard, Bram Moolenaar, Dafydd Jones, Harri Pitkänen
-  *
-  * Alternatively, the contents of this file may be used under the terms of
-  * either the GNU General Public License Version 2 or later (the "GPL"), or