Use up to 8 affixes in Hunspell spellcheck suggestions

src/hunspell/suggestmgr.cxx

 #include "license.hunspell"
 #include "license.myspell"
 
 #include <stdlib.h> 
 #include <string.h>
 #include <stdio.h> 
 #include <ctype.h>
 
 #include "suggestmgr.hxx"
 #include "htypes.hxx"
@@ skipping 36 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 (hash_item->entry.alen > kMaxAffixLen)
+      hash_item->entry.alen = kMaxAffixLen;
+    memcpy(hash_item->astr, source->astr, hash_item->entry.alen * sizeof(hash_item->astr[0]));
+    hash_item->entry.astr = &hash_item->astr[0];
   }
   return &hash_item->entry;
 }
 
 }  // namespace
 #endif
 
 
 #ifdef HUNSPELL_CHROME_CLIENT
 SuggestMgr::SuggestMgr(hunspell::BDictReader* reader,
@@ skipping 2041 matching lines @@
       len++;
       i--;
       j--;
     } else if (result[i*(n+1) + j] == LCS_UP) {
       i--;
     } else j--;
   }
   free(result);
   return len;
 }