| 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 |
| --- src/hunspell/affixmgr.cxx 16 Dec 2011 09:15:34 -0000 1.41 |
| +++ src/hunspell/affixmgr.cxx 29 May 2014 01:05:07 -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 @@ |
| 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 @@ |
| 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; |
| @@ -282,6 +333,7 @@ |
| 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 @@ |
| while ((line = afflst->getline()) != NULL) { |
| mychomp(line); |
| |
| +#ifndef HUNSPELL_CHROME_CLIENT |
| /* remove byte order mark */ |
| if (firstline) { |
| firstline = 0; |
| @@ -299,6 +352,7 @@ |
| memmove(line, line+3, strlen(line+3)+1); |
| } |
| } |
| +#endif |
| |
| /* parse in the keyboard string */ |
| if (strncmp(line,"KEY",3) == 0) { |
| @@ -545,6 +599,7 @@ |
| } |
| } |
| |
| +#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 @@ |
| return 1; |
| } |
| } |
| +#endif |
| |
| /* parse in the input conversion table */ |
| if (strncmp(line,"ICONV",5) == 0) { |
| @@ -699,6 +755,7 @@ |
| 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 @@ |
| return 1; |
| } |
| } |
| +#endif |
| } |
| |
| finishFileMgr(afflst); |
| @@ -1307,6 +1365,26 @@ |
| 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 @@ |
| r++; // search for the next letter |
| } |
| } |
| +#endif |
| return 0; |
| } |
| |
| @@ -4219,6 +4298,7 @@ |
| 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 @@ |
| // 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 |
| --- src/hunspell/affixmgr.hxx 13 Oct 2011 13:41:54 -0000 1.15 |
| +++ src/hunspell/affixmgr.hxx 29 May 2014 01:05:07 -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 |
| +// 256 elements, so this class only allocates that much to start off with. If |
| +// elements higher than that are actually used, we'll automatically expand. |
| +class ContClasses { |
| + public: |
| + ContClasses() { |
| + // Pre-allocate a buffer so that typically, we'll never have to resize. |
| + EnsureSizeIs(256); |
| + } |
| + |
| + char& operator[](size_t index) { |
| + EnsureSizeIs(index + 1); |
| + return data[index]; |
| + } |
| + |
| + void EnsureSizeIs(size_t new_size) { |
| + if (data.size() >= new_size) |
| + return; // Nothing to do. |
| + |
| + size_t old_size = data.size(); |
| + data.resize(new_size); |
| + memset(&data[old_size], 0, new_size - old_size); |
| + } |
| + |
| + std::vector<char> data; |
| +}; |
| + |
| +#endif // HUNSPELL_CHROME_CLIENT |
| + |
| class LIBHUNSPELL_DLL_EXPORTED AffixMgr |
| { |
| |
| @@ -106,12 +140,20 @@ |
| 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 @@ |
| 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 @@ |
| }; |
| |
| #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 |
| --- src/hunspell/filemgr.cxx 23 Jun 2011 09:21:50 -0000 1.5 |
| +++ src/hunspell/filemgr.cxx 29 May 2014 01:05:07 -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) { |
| +} |
| + |
| +FileMgr::~FileMgr() { |
| +} |
| + |
| +char * FileMgr::getline() { |
| + // Read one line from a BDICT file and store the line to our line buffer. |
| + // To emulate the original FileMgr::getline(), this function returns |
| + // the pointer to our line buffer if we can read a line without errors. |
| + // Otherwise, this function returns NULL. |
| + bool result = iterator_->AdvanceAndCopy(line_, BUFSIZE - 1); |
| + return result ? line_ : NULL; |
| +} |
| + |
| +int FileMgr::getlinenum() { |
| + // 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 @@ |
| 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 |
| --- src/hunspell/filemgr.hxx 15 Apr 2010 11:22:08 -0000 1.3 |
| +++ src/hunspell/filemgr.hxx 29 May 2014 01:05:07 -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. |
| +// Chrome uses a BDICT file to compress hunspell dictionaries. A BDICT file is |
| +// a binary file converted from a DIC file and an AFF file. (See |
| +// "bdict_reader.h" for its format.) |
| +// This class encapsulates the operations of reading a BDICT file and emulates |
| +// the original FileMgr operations for AffixMgr so that it can read a BDICT |
| +// file without so many changes. |
| +class FileMgr { |
| + public: |
| + FileMgr(hunspell::LineIterator* iterator); |
| + ~FileMgr(); |
| + char* getline(); |
| + int getlinenum(); |
| + |
| + protected: |
| + hunspell::LineIterator* iterator_; |
| + char line_[BUFSIZE + 50]; // input buffer |
| +}; |
| +#else |
| class LIBHUNSPELL_DLL_EXPORTED FileMgr |
| { |
| protected: |
| @@ -23,3 +47,4 @@ |
| 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 |
| --- src/hunspell/hashmgr.cxx 23 Jun 2011 09:21:50 -0000 1.12 |
| +++ src/hunspell/hashmgr.cxx 29 May 2014 01:05:07 -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 @@ |
| 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 @@ |
| 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 |
| #ifdef MOZILLA_CLIENT |
| delete [] csconv; |
| #endif |
| } |
| |
| +#ifdef HUNSPELL_CHROME_CLIENT |
| +void HashMgr::EmptyHentryCache() { |
| + // We need to delete each cache entry, and each additional one in the linked |
| + // list of homonyms. |
| + for (HEntryCache::iterator i = hentry_cache.begin(); |
| + i != hentry_cache.end(); ++i) { |
| + hentry* cur = i->second; |
| + while (cur) { |
| + hentry* next = cur->next_homonym; |
| + DeleteHashEntry(cur); |
| + cur = next; |
| + } |
| + } |
| + hentry_cache.clear(); |
| +} |
| +#endif |
| + |
| // lookup a root word in the hashtable |
| |
| struct hentry * HashMgr::lookup(const char *word) const |
| { |
| +#ifdef HUNSPELL_CHROME_CLIENT |
| + int affix_ids[hunspell::BDict::MAX_AFFIXES_PER_WORD]; |
| + int affix_count = bdict_reader->FindWord(word, affix_ids); |
| + if (affix_count == 0) { // look for custom added word |
| + std::map<base::StringPiece, int>::const_iterator iter = |
| + custom_word_to_affix_id_map_.find(word); |
| + if (iter != custom_word_to_affix_id_map_.end()) { |
| + affix_count = 1; |
| + affix_ids[0] = iter->second; |
| + } |
| + } |
| + |
| + 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 @@ |
| } |
| } |
| 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 @@ |
| 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 @@ |
| // 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 @@ |
| } |
| dp = dp->next_homonym; |
| } |
| +#endif |
| return 0; |
| } |
| |
| @@ -339,6 +414,44 @@ |
| // 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 |
| + // to avoid changing the API. It is set to -1 for the first call. |
| + // Allocate the iterator on the heap to prevent an exit time destructor. |
| + static hunspell::WordIterator& word_iterator = |
| + *new hunspell::WordIterator(bdict_reader->GetAllWordIterator()); |
| + if (col < 0) { |
| + col = 1; |
| + word_iterator = bdict_reader->GetAllWordIterator(); |
| + } |
| + |
| + int affix_ids[hunspell::BDict::MAX_AFFIXES_PER_WORD]; |
| + static const int kMaxWordLen = 128; |
| + static char word[kMaxWordLen]; |
| + int affix_count = word_iterator.Advance(word, kMaxWordLen, affix_ids); |
| + if (affix_count == 0) |
| + return NULL; |
| + short word_len = static_cast<short>(strlen(word)); |
| + |
| + // Since hunspell 1.2.8, an hentry struct becomes a variable-length struct, |
| + // i.e. a struct which uses its array 'word[1]' as a variable-length array. |
| + // As noted above, this function is not nested. So, we just use a static |
| + // struct which consists of an hentry and a char[kMaxWordLen], and initialize |
| + // the static struct and return it for now. |
| + // No need to create linked lists for the extra affixes. |
| + static struct { |
| + 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 @@ |
| // 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 @@ |
| } |
| |
| delete dict; |
| +#endif |
| return 0; |
| } |
| |
| @@ -479,6 +595,9 @@ |
| |
| 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 @@ |
| hv ^= (*word++); |
| } |
| return (unsigned long) hv % tablesize; |
| +#endif |
| } |
| |
| int HashMgr::decode_flags(unsigned short ** result, char * flags, FileMgr * af) { |
| @@ -607,7 +727,12 @@ |
| 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 @@ |
| 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(); |
| + FileMgr afflst(&iterator); |
| + while (char* line = afflst.getline()) { |
| + int rv = parse_aliasf(line, &afflst); |
| + if (rv) |
| + return rv; |
| + } |
| + |
| + return 0; |
| +} |
| + |
| +hentry* HashMgr::InitHashEntry(hentry* entry, |
| + size_t item_size, |
| + const char* word, |
| + int word_length, |
| + int affix_index) const { |
| + // Return if the given buffer doesn't have enough space for a hentry struct |
| + // or the given word is too long. |
| + // Our BDICT cannot handle words longer than (128 - 1) bytes. So, it is |
| + // better to return an error if the given word is too long and prevent |
| + // an unexpected result caused by a long word. |
| + const int kMaxWordLen = 128; |
| + if (item_size < sizeof(hentry) + word_length + 1 || |
| + word_length >= kMaxWordLen) |
| + return NULL; |
| + |
| + // Initialize a hentry struct with the given parameters, and |
| + // append the given string at the end of this hentry struct. |
| + memset(entry, 0, item_size); |
| + FileMgr af(NULL); |
| + entry->alen = static_cast<short>( |
| + const_cast<HashMgr*>(this)->get_aliasf(affix_index, &entry->astr, &af)); |
| + entry->blen = static_cast<unsigned char>(word_length); |
| + memcpy(&entry->word, word, word_length); |
| + |
| + return entry; |
| +} |
| + |
| +hentry* HashMgr::CreateHashEntry(const char* word, |
| + int word_length, |
| + int affix_index) const { |
| + // Return if the given word is too long. |
| + // (See the comment in HashMgr::InitHashEntry().) |
| + const int kMaxWordLen = 128; |
| + if (word_length >= kMaxWordLen) |
| + return NULL; |
| + |
| + const size_t kEntrySize = sizeof(hentry) + word_length + 1; |
| + struct hentry* entry = reinterpret_cast<hentry*>(malloc(kEntrySize)); |
| + if (entry) |
| + InitHashEntry(entry, kEntrySize, word, word_length, affix_index); |
| + |
| + return entry; |
| +} |
| + |
| +void HashMgr::DeleteHashEntry(hentry* entry) const { |
| + free(entry); |
| +} |
| + |
| +hentry* HashMgr::AffixIDsToHentry(char* word, |
| + int* affix_ids, |
| + int affix_count) const |
| +{ |
| + if (affix_count == 0) |
| + return NULL; |
| + |
| + HEntryCache& cache = const_cast<HashMgr*>(this)->hentry_cache; |
| + std::string std_word(word); |
| + HEntryCache::iterator found = cache.find(std_word); |
| + if (found != cache.end()) { |
| + // We must return an existing hentry for the same word if we've previously |
| + // handed one out. Hunspell will compare pointers in some cases to see if |
| + // two words it has found are the same. |
| + return found->second; |
| + } |
| + |
| + short word_len = static_cast<short>(strlen(word)); |
| + |
| + // We can get a number of prefixes per word. There will normally be only one, |
| + // but if not, there will be a linked list of "hentry"s for the "homonym"s |
| + // for the word. |
| + struct hentry* first_he = NULL; |
| + struct hentry* prev_he = NULL; // For making linked list. |
| + for (int i = 0; i < affix_count; i++) { |
| + struct hentry* he = CreateHashEntry(word, word_len, affix_ids[i]); |
| + if (!he) |
| + break; |
| + if (i == 0) |
| + first_he = he; |
| + if (prev_he) |
| + prev_he->next_homonym = he; |
| + prev_he = he; |
| + } |
| + |
| + cache[std_word] = first_he; // Save this word in the cache for later. |
| + return first_he; |
| +} |
| + |
| +hentry* HashMgr::GetHentryFromHEntryCache(char* word) { |
| + HEntryCache& cache = const_cast<HashMgr*>(this)->hentry_cache; |
| + std::string std_word(word); |
| + HEntryCache::iterator found = cache.find(std_word); |
| + if (found != cache.end()) |
| + return found->second; |
| + else |
| + return NULL; |
| +} |
| +#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 |
| --- src/hunspell/hashmgr.hxx 15 Apr 2010 11:22:08 -0000 1.3 |
| +++ src/hunspell/hashmgr.hxx 29 May 2014 01:05:07 -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/strings/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 @@ |
| |
| |
| 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 @@ |
| 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(); |
| + |
| + // Helper functions that create a new hentry struct, initialize it, and |
| + // delete it. |
| + // These functions encapsulate non-trivial operations in creating and |
| + // initializing a hentry struct from BDICT data to avoid changing code so much |
| + // even when a hentry struct is changed. |
| + hentry* InitHashEntry(hentry* entry, |
| + size_t item_size, |
| + const char* word, |
| + int word_length, |
| + int affix_index) const; |
| + hentry* CreateHashEntry(const char* word, |
| + int word_length, |
| + int affix_index) const; |
| + void DeleteHashEntry(hentry* entry) const; |
| + |
| + // Converts the list of affix IDs to a linked list of hentry structures. The |
| + // hentry structures will point to the given word. The returned pointer will |
| + // be a statically allocated variable that will change for the next call. The |
| + // |word| buffer must be the same. |
| + hentry* AffixIDsToHentry(char* word, int* affix_ids, int affix_count) const; |
| + |
| + // 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(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 |
| --- src/hunspell/htypes.hxx 6 Sep 2010 07:58:53 -0000 1.3 |
| +++ src/hunspell/htypes.hxx 29 May 2014 01:05:07 -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 |
| --- src/hunspell/hunspell.cxx 23 Jun 2011 09:21:50 -0000 1.29 |
| +++ src/hunspell/hunspell.cxx 29 May 2014 01:05:07 -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" |
| |
| +#ifdef HUNSPELL_CHROME_CLIENT |
| +Hunspell::Hunspell(const unsigned char* bdict_data, size_t bdict_length) |
| +#else |
| Hunspell::Hunspell(const char * affpath, const char * dpath, const char * key) |
| +#endif |
| { |
| encoding = NULL; |
| csconv = NULL; |
| utf8 = 0; |
| complexprefixes = 0; |
| +#ifndef HUNSPELL_CHROME_CLIENT |
| affixpath = mystrdup(affpath); |
| +#endif |
| maxdic = 0; |
| |
| +#ifdef HUNSPELL_CHROME_CLIENT |
| + bdict_reader = new hunspell::BDictReader; |
| + 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 @@ |
| /* 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 @@ |
| 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 @@ |
| 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 @@ |
| 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 @@ |
| |
| int Hunspell::spell(const char * word, int * info, char ** root) |
| { |
| +#ifdef HUNSPELL_CHROME_CLIENT |
| + if (pHMgr[0]) 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 @@ |
| 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 @@ |
| |
| int Hunspell::suggest(char*** slst, const char * word) |
| { |
| +#ifdef HUNSPELL_CHROME_CLIENT |
| + if (pHMgr[0]) pHMgr[0]->EmptyHentryCache(); |
| +#endif |
| int onlycmpdsug = 0; |
| char cw[MAXWORDUTF8LEN]; |
| char wspace[MAXWORDUTF8LEN]; |
| @@ -1921,13 +1963,21 @@ |
| |
| 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 |
| --- src/hunspell/hunspell.hxx 21 Jan 2011 17:30:41 -0000 1.6 |
| +++ src/hunspell/hunspell.hxx 29 May 2014 01:05:07 -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 @@ |
| 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 @@ |
| int complexprefixes; |
| char** wordbreak; |
| |
| +#ifdef HUNSPELL_CHROME_CLIENT |
| + // Not owned by us, owned by the Hunspell object. |
| + hunspell::BDictReader* bdict_reader; |
| +#endif |
| + |
| public: |
| |
| /* Hunspell(aff, dic) - constructor of Hunspell class |
| * input: path of affix file and dictionary file |
| */ |
| |
| +#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: 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 |
| --- src/hunspell/replist.hxx 15 Apr 2010 11:22:09 -0000 1.2 |
| +++ src/hunspell/replist.hxx 29 May 2014 01:05:07 -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 |
| --- src/hunspell/suggestmgr.cxx 14 Feb 2011 21:47:24 -0000 1.24 |
| +++ src/hunspell/suggestmgr.cxx 29 May 2014 01:05:07 -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. |
| +// |
| +// hentry* bad_copy = NULL; |
| +// { |
| +// ScopedHashEntryFactory factory; |
| +// hentry* scoped_copy = factory.CreateScopedHashEntry(0, source); |
| +// ... |
| +// bad_copy = scoped_copy; |
| +// } |
| +// if (bad_copy->word[0]) // memory for scoped_copy has been deleted! |
| +// |
| +// As listed in the above snippet, it is simple to use this class. |
| +// 1. Declare an instance of this ScopedHashEntryFactory, and; |
| +// 2. Call its CreateHashEntry() member instead of using 'new hentry' or |
| +// 'operator='. |
| +// |
| +class ScopedHashEntryFactory { |
| + public: |
| + ScopedHashEntryFactory(); |
| + ~ScopedHashEntryFactory(); |
| + |
| + // Creates a temporary copy of the given hentry struct. |
| + // The returned copy is available only while this object is available. |
| + // NOTE: this function just calls memcpy() in creating a copy of the given |
| + // hentry struct, i.e. it does NOT copy objects referred by pointers of the |
| + // given hentry struct. |
| + 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 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[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[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) |
| + 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->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, |
| + 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 +512,49 @@ |
| 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); |
| + 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); |
| + 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, ' '); |
| + } |
| + } |
| + 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 +596,7 @@ |
| r++; // search for the next letter |
| } |
| } |
| +#endif |
| return ns; |
| } |
| |
| @@ -678,7 +827,9 @@ |
| // 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 +851,10 @@ |
| // 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 +1210,9 @@ |
| |
| 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 +1271,11 @@ |
| |
| 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) { |
| @@ -1948,16 +2108,14 @@ |
| 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); |
| if (b) free(b); |
| *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) && (*((short *) su+i-1) == *((short *)su2+j-1))) |
| 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 |
| --- src/hunspell/suggestmgr.hxx 21 Jan 2011 22:10:24 -0000 1.5 |
| +++ src/hunspell/suggestmgr.hxx 29 May 2014 01:05:07 -0000 |
| @@ -52,7 +52,11 @@ |
| |
| |
| 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 @@ |
| 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 *); |