/* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * 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). * 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 * * 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 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /* * Copyright 2002 Kevin B. Hendricks, Stratford, Ontario, Canada * And Contributors. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. All modifications to the source code must be clearly marked as * such. Binary redistributions based on modified source code * must be clearly marked as modified versions in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY KEVIN B. HENDRICKS AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * KEVIN B. HENDRICKS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include <stdlib.h> #include <string.h> #include <stdio.h> #include <ctype.h> #include <algorithm> #include <limits> #include <string> #include <vector> #include "affixmgr.hxx" #include "affentry.hxx" #include "langnum.hxx" #include "csutil.hxx" #ifdef HUNSPELL_CHROME_CLIENT AffixMgr::AffixMgr(hunspell::BDictReader* reader, const std::vector<HashMgr*>& ptr) : … { … } AffixMgr::~AffixMgr() { … } void AffixMgr::finishFileMgr(FileMgr* afflst) { … } // read in aff file and build up prefix and suffix entry objects int AffixMgr::parse_file(const char* affpath, const char* key) { … } // we want to be able to quickly access prefix information // both by prefix flag, and sorted by prefix string itself // so we need to set up two indexes int AffixMgr::build_pfxtree(PfxEntry* pfxptr) { … } // we want to be able to quickly access suffix information // both by suffix flag, and sorted by the reverse of the // suffix string itself; so we need to set up two indexes int AffixMgr::build_sfxtree(SfxEntry* sfxptr) { … } // convert from binary tree to sorted list int AffixMgr::process_pfx_tree_to_list() { … } PfxEntry* AffixMgr::process_pfx_in_order(PfxEntry* ptr, PfxEntry* nptr) { … } // convert from binary tree to sorted list int AffixMgr::process_sfx_tree_to_list() { … } SfxEntry* AffixMgr::process_sfx_in_order(SfxEntry* ptr, SfxEntry* nptr) { … } // reinitialize the PfxEntry links NextEQ and NextNE to speed searching // using the idea of leading subsets this time int AffixMgr::process_pfx_order() { … } // initialize the SfxEntry links NextEQ and NextNE to speed searching // using the idea of leading subsets this time int AffixMgr::process_sfx_order() { … } // add flags to the result for dictionary debugging std::string& AffixMgr::debugflag(std::string& result, unsigned short flag) { … } // calculate the character length of the condition int AffixMgr::condlen(const char* st) { … } int AffixMgr::encodeit(AffEntry& entry, const char* cs) { … } // return 1 if s1 is a leading subset of s2 (dots are for infixes) inline int AffixMgr::isSubset(const char* s1, const char* s2) { … } // check word for prefixes struct hentry* AffixMgr::prefix_check(const char* word, int len, char in_compound, const FLAG needflag) { … } // check word for prefixes struct hentry* AffixMgr::prefix_check_twosfx(const char* word, int len, char in_compound, const FLAG needflag) { … } // check word for prefixes std::string AffixMgr::prefix_check_morph(const char* word, int len, char in_compound, const FLAG needflag) { … } // check word for prefixes std::string AffixMgr::prefix_check_twosfx_morph(const char* word, int len, char in_compound, const FLAG needflag) { … } // Is word a non compound with a REP substitution (see checkcompoundrep)? int AffixMgr::cpdrep_check(const char* word, int wl) { … } // forbid compoundings when there are special patterns at word bound int AffixMgr::cpdpat_check(const char* word, int pos, hentry* r1, hentry* r2, const char /*affixed*/) { … } // forbid compounding with neighbouring upper and lower case characters at word // bounds int AffixMgr::cpdcase_check(const char* word, int pos) { … } struct metachar_data { … }; // check compound patterns int AffixMgr::defcpd_check(hentry*** words, short wnum, hentry* rv, hentry** def, char all) { … } inline int AffixMgr::candidate_check(const char* word, int len) { … } // calculate number of syllable for compound-checking short AffixMgr::get_syllable(const std::string& word) { … } void AffixMgr::setcminmax(int* cmin, int* cmax, const char* word, int len) { … } // check if compound word is correctly spelled // hu_mov_rule = spec. Hungarian rule (XXX) struct hentry* AffixMgr::compound_check(const std::string& word, short wordnum, short numsyllable, short maxwordnum, short wnum, hentry** words = NULL, hentry** rwords = NULL, char hu_mov_rule = 0, char is_sug = 0, int* info = NULL) { … } // check if compound word is correctly spelled // hu_mov_rule = spec. Hungarian rule (XXX) int AffixMgr::compound_check_morph(const char* word, int len, short wordnum, short numsyllable, short maxwordnum, short wnum, hentry** words, hentry** rwords, char hu_mov_rule, std::string& result, const std::string* partresult) { … } inline int AffixMgr::isRevSubset(const char* s1, const char* end_of_s2, int len) { … } // check word for suffixes struct hentry* AffixMgr::suffix_check(const char* word, int len, int sfxopts, PfxEntry* ppfx, const FLAG cclass, const FLAG needflag, char in_compound) { … } // check word for two-level suffixes struct hentry* AffixMgr::suffix_check_twosfx(const char* word, int len, int sfxopts, PfxEntry* ppfx, const FLAG needflag) { … } std::string AffixMgr::suffix_check_twosfx_morph(const char* word, int len, int sfxopts, PfxEntry* ppfx, const FLAG needflag) { … } std::string AffixMgr::suffix_check_morph(const char* word, int len, int sfxopts, PfxEntry* ppfx, const FLAG cclass, const FLAG needflag, char in_compound) { … } // check if word with affixes is correctly spelled struct hentry* AffixMgr::affix_check(const char* word, int len, const FLAG needflag, char in_compound) { … } // check if word with affixes is correctly spelled std::string AffixMgr::affix_check_morph(const char* word, int len, const FLAG needflag, char in_compound) { … } // morphcmp(): compare MORPH_DERI_SFX, MORPH_INFL_SFX and MORPH_TERM_SFX fields // in the first line of the inputs // return 0, if inputs equal // return 1, if inputs may equal with a secondary suffix // otherwise return -1 static int morphcmp(const char* s, const char* t) { … } std::string AffixMgr::morphgen(const char* ts, int wl, const unsigned short* ap, unsigned short al, const char* morph, const char* targetmorph, int level) { … } int AffixMgr::expand_rootword(struct guessword* wlst, int maxn, const char* ts, int wl, const unsigned short* ap, unsigned short al, const char* bad, int badl, const char* phon) { … } // return replacing table const std::vector<replentry>& AffixMgr::get_reptable() const { … } // return iconv table RepList* AffixMgr::get_iconvtable() const { … } // return oconv table RepList* AffixMgr::get_oconvtable() const { … } // return replacing table struct phonetable* AffixMgr::get_phonetable() const { … } // return character map table const std::vector<mapentry>& AffixMgr::get_maptable() const { … } // return character map table const std::vector<std::string>& AffixMgr::get_breaktable() const { … } // return text encoding of dictionary const std::string& AffixMgr::get_encoding() { … } // return text encoding of dictionary int AffixMgr::get_langnum() const { … } // return double prefix option int AffixMgr::get_complexprefixes() const { … } // return FULLSTRIP option int AffixMgr::get_fullstrip() const { … } FLAG AffixMgr::get_keepcase() const { … } FLAG AffixMgr::get_forceucase() const { … } FLAG AffixMgr::get_warn() const { … } int AffixMgr::get_forbidwarn() const { … } int AffixMgr::get_checksharps() const { … } char* AffixMgr::encode_flag(unsigned short aflag) const { … } // return the preferred ignore string for suggestions const char* AffixMgr::get_ignore() const { … } // return the preferred ignore string for suggestions const std::vector<w_char>& AffixMgr::get_ignore_utf16() const { … } // return the keyboard string for suggestions char* AffixMgr::get_key_string() { … } // return the preferred try string for suggestions char* AffixMgr::get_try_string() const { … } // return the preferred try string for suggestions const std::string& AffixMgr::get_wordchars() const { … } const std::vector<w_char>& AffixMgr::get_wordchars_utf16() const { … } // is there compounding? int AffixMgr::get_compound() const { … } // return the compound words control flag FLAG AffixMgr::get_compoundflag() const { … } // return the forbidden words control flag FLAG AffixMgr::get_forbiddenword() const { … } // return the forbidden words control flag FLAG AffixMgr::get_nosuggest() const { … } // return the forbidden words control flag FLAG AffixMgr::get_nongramsuggest() const { … } // return the forbidden words flag modify flag FLAG AffixMgr::get_needaffix() const { … } // return the onlyincompound flag FLAG AffixMgr::get_onlyincompound() const { … } // return the value of suffix const std::string& AffixMgr::get_version() const { … } // utility method to look up root words in hash table struct hentry* AffixMgr::lookup(const char* word) { … } // return the value of suffix int AffixMgr::have_contclass() const { … } // return utf8 int AffixMgr::get_utf8() const { … } int AffixMgr::get_maxngramsugs(void) const { … } int AffixMgr::get_maxcpdsugs(void) const { … } int AffixMgr::get_maxdiff(void) const { … } int AffixMgr::get_onlymaxdiff(void) const { … } // return nosplitsugs int AffixMgr::get_nosplitsugs(void) const { … } // return sugswithdots int AffixMgr::get_sugswithdots(void) const { … } /* parse flag */ bool AffixMgr::parse_flag(const std::string& line, unsigned short* out, FileMgr* af) { … } /* parse num */ bool AffixMgr::parse_num(const std::string& line, int* out, FileMgr* af) { … } /* parse in the max syllablecount of compound words and */ bool AffixMgr::parse_cpdsyllable(const std::string& line, FileMgr* af) { … } /* parse in the typical fault correcting table */ bool AffixMgr::parse_reptable(const std::string& line, FileMgr* af) { … } /* parse in the typical fault correcting table */ bool AffixMgr::parse_convtable(const std::string& line, FileMgr* af, RepList** rl, const std::string& keyword) { … } /* parse in the typical fault correcting table */ bool AffixMgr::parse_phonetable(const std::string& line, FileMgr* af) { … } /* parse in the checkcompoundpattern table */ bool AffixMgr::parse_checkcpdtable(const std::string& line, FileMgr* af) { … } /* parse in the compound rule table */ bool AffixMgr::parse_defcpdtable(const std::string& line, FileMgr* af) { … } /* parse in the character map table */ bool AffixMgr::parse_maptable(const std::string& line, FileMgr* af) { … } /* parse in the word breakpoint table */ bool AffixMgr::parse_breaktable(const std::string& line, FileMgr* af) { … } void AffixMgr::reverse_condition(std::string& piece) { … } class entries_container { … }; bool AffixMgr::parse_affix(const std::string& line, const char at, FileMgr* af, char* dupflags) { … } int AffixMgr::redundant_condition(char ft, const char* strip, int stripl, const char* cond, int linenum) { … } std::vector<std::string> AffixMgr::get_suffix_words(short unsigned* suff, int len, const char* root_word) { … }
Codebase Browser
chromium