4041 lines
128 KiB
C++
4041 lines
128 KiB
C++
|
#include "license.hun"
|
||
|
|
#include "license.mys"
|
||
|
|
|
||
|
|
#include <cstdlib>
|
||
|
|
#include <cstring>
|
||
|
|
#include <cctype>
|
||
|
|
#include <cstdio>
|
||
|
|
|
||
|
|
#include "affixmgr.hxx"
|
||
|
|
#include "affentry.hxx"
|
||
|
|
#include "langnum.hxx"
|
||
|
|
|
||
|
|
#include "csutil.hxx"
|
||
|
|
|
||
|
|
#if !defined(_MSC_VER)
|
||
|
|
using namespace std;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
AffixMgr::AffixMgr(const char * affpath, HashMgr* ptr)
|
||
|
|
{
|
||
|
|
// register hash manager and load affix data from aff file
|
||
|
|
pHMgr = ptr;
|
||
|
|
trystring = NULL;
|
||
|
|
encoding=NULL;
|
||
|
|
utf8 = 0;
|
||
|
|
utf_tbl = NULL;
|
||
|
|
complexprefixes = 0;
|
||
|
|
maptable = NULL;
|
||
|
|
nummap = 0;
|
||
|
|
breaktable = NULL;
|
||
|
|
numbreak = 0;
|
||
|
|
reptable = NULL;
|
||
|
|
numrep = 0;
|
||
|
|
checkcpdtable = NULL;
|
||
|
|
numcheckcpd = 0;
|
||
|
|
defcpdtable = NULL;
|
||
|
|
numdefcpd = 0;
|
||
|
|
compoundflag = FLAG_NULL; // permits word in compound forms
|
||
|
|
compoundbegin = FLAG_NULL; // may be first word in compound forms
|
||
|
|
compoundmiddle = FLAG_NULL; // may be middle word in compound forms
|
||
|
|
compoundend = FLAG_NULL; // may be last word in compound forms
|
||
|
|
compoundroot = FLAG_NULL; // compound word signing flag
|
||
|
|
compoundpermitflag = FLAG_NULL; // compound permitting flag for suffixed word
|
||
|
|
compoundforbidflag = FLAG_NULL; // compound fordidden flag for suffixed word
|
||
|
|
checkcompounddup = 0; // forbid double words in compounds
|
||
|
|
checkcompoundrep = 0; // forbid bad compounds (may be non compound word with a REP substitution)
|
||
|
|
checkcompoundcase = 0; // forbid upper and lowercase combinations at word bounds
|
||
|
|
checkcompoundtriple = 0; // forbid compounds with triple letters
|
||
|
|
forbiddenword = FLAG_NULL; // forbidden word signing flag
|
||
|
|
nosuggest = FLAG_NULL; // don't suggest words signed with NOSUGGEST flag
|
||
|
|
lang = NULL; // language
|
||
|
|
langnum = 0; // language code (see http://l10n.openoffice.org/languages.html)
|
||
|
|
pseudoroot = FLAG_NULL; // forbidden root, allowed only with suffixes
|
||
|
|
cpdwordmax=0; // default: unlimited wordcount in compound words
|
||
|
|
cpdmin = 3; // default value
|
||
|
|
cpdmaxsyllable = 0; // default: unlimited syllablecount in compound words
|
||
|
|
cpdvowels=NULL; // vowels (for calculating of Hungarian compounding limit, O(n) search! XXX)
|
||
|
|
cpdvowels_utf16=NULL; // vowels for UTF-8 encoding (bsearch instead of O(n) search)
|
||
|
|
cpdvowels_utf16_len=0; // vowels
|
||
|
|
pfxappnd=NULL; // previous prefix for counting the syllables of prefix BUG
|
||
|
|
sfxappnd=NULL; // previous suffix for counting a special syllables BUG
|
||
|
|
cpdsyllablenum=NULL; // syllable count incrementing flag
|
||
|
|
checknum=0; // checking numbers, and word with numbers
|
||
|
|
wordchars=NULL; // letters + spec. word characters
|
||
|
|
wordchars_utf16=NULL; // letters + spec. word characters
|
||
|
|
wordchars_utf16_len=0; // letters + spec. word characters
|
||
|
|
version=NULL; // affix and dictionary file version string
|
||
|
|
havecontclass=0; // flags of possible continuing classes (double affix)
|
||
|
|
// LEMMA_PRESENT: not put root into the morphological output. Lemma presents
|
||
|
|
// in morhological description in dictionary file. It's often combined with PSEUDOROOT.
|
||
|
|
lemma_present = FLAG_NULL;
|
||
|
|
circumfix = FLAG_NULL;
|
||
|
|
onlyincompound = FLAG_NULL;
|
||
|
|
flag_mode = FLAG_CHAR; // default one-character flags in affix and dic file
|
||
|
|
maxngramsugs = -1; // undefined
|
||
|
|
nosplitsugs = 0;
|
||
|
|
sugswithdots = 0;
|
||
|
|
keepcase = 0;
|
||
|
|
checksharps = 0;
|
||
|
|
|
||
|
|
derived = NULL; // XXX not threadsafe variable for experimental stemming
|
||
|
|
sfx = NULL;
|
||
|
|
pfx = NULL;
|
||
|
|
|
||
|
|
for (int i=0; i < SETSIZE; i++) {
|
||
|
|
pStart[i] = NULL;
|
||
|
|
sStart[i] = NULL;
|
||
|
|
pFlag[i] = NULL;
|
||
|
|
sFlag[i] = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int j=0; j < CONTSIZE; j++) {
|
||
|
|
contclasses[j] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parse_file(affpath)) {
|
||
|
|
fprintf(stderr,"Failure loading aff file %s\n",affpath);
|
||
|
|
fflush(stderr);
|
||
|
|
wordchars = mystrdup("qwertzuiopasdfghjklyxcvbnmQWERTZUIOPASDFGHJKLYXCVBNM");
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
AffixMgr::~AffixMgr()
|
||
|
|
{
|
||
|
|
|
||
|
|
// pass through linked prefix entries and clean up
|
||
|
|
for (int i=0; i < SETSIZE ;i++) {
|
||
|
|
pFlag[i] = NULL;
|
||
|
|
PfxEntry * ptr = (PfxEntry *)pStart[i];
|
||
|
|
PfxEntry * nptr = NULL;
|
||
|
|
while (ptr) {
|
||
|
|
nptr = ptr->getNext();
|
||
|
|
delete(ptr);
|
||
|
|
ptr = nptr;
|
||
|
|
nptr = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// pass through linked suffix entries and clean up
|
||
|
|
for (int j=0; j < SETSIZE ; j++) {
|
||
|
|
sFlag[j] = NULL;
|
||
|
|
SfxEntry * ptr = (SfxEntry *)sStart[j];
|
||
|
|
SfxEntry * nptr = NULL;
|
||
|
|
while (ptr) {
|
||
|
|
nptr = ptr->getNext();
|
||
|
|
delete(ptr);
|
||
|
|
ptr = nptr;
|
||
|
|
nptr = NULL;
|
||
|
|
}
|
||
|
|
sStart[j] = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (trystring) free(trystring);
|
||
|
|
trystring=NULL;
|
||
|
|
if (encoding) free(encoding);
|
||
|
|
encoding=NULL;
|
||
|
|
if (maptable) {
|
||
|
|
for (int j=0; j < nummap; j++) {
|
||
|
|
if (maptable[j].set) free(maptable[j].set);
|
||
|
|
if (maptable[j].set_utf16) free(maptable[j].set_utf16);
|
||
|
|
maptable[j].set = NULL;
|
||
|
|
maptable[j].len = 0;
|
||
|
|
}
|
||
|
|
free(maptable);
|
||
|
|
maptable = NULL;
|
||
|
|
}
|
||
|
|
nummap = 0;
|
||
|
|
if (breaktable) {
|
||
|
|
for (int j=0; j < numbreak; j++) {
|
||
|
|
if (breaktable[j]) free(breaktable[j]);
|
||
|
|
breaktable[j] = NULL;
|
||
|
|
}
|
||
|
|
free(breaktable);
|
||
|
|
breaktable = NULL;
|
||
|
|
}
|
||
|
|
numbreak = 0;
|
||
|
|
if (reptable) {
|
||
|
|
for (int j=0; j < numrep; j++) {
|
||
|
|
free(reptable[j].pattern);
|
||
|
|
free(reptable[j].pattern2);
|
||
|
|
reptable[j].pattern = NULL;
|
||
|
|
reptable[j].pattern2 = NULL;
|
||
|
|
}
|
||
|
|
free(reptable);
|
||
|
|
reptable = NULL;
|
||
|
|
}
|
||
|
|
if (defcpdtable) {
|
||
|
|
for (int j=0; j < numdefcpd; j++) {
|
||
|
|
free(defcpdtable[j].def);
|
||
|
|
defcpdtable[j].def = NULL;
|
||
|
|
}
|
||
|
|
free(defcpdtable);
|
||
|
|
defcpdtable = NULL;
|
||
|
|
}
|
||
|
|
numrep = 0;
|
||
|
|
if (checkcpdtable) {
|
||
|
|
for (int j=0; j < numcheckcpd; j++) {
|
||
|
|
free(checkcpdtable[j].pattern);
|
||
|
|
free(checkcpdtable[j].pattern2);
|
||
|
|
checkcpdtable[j].pattern = NULL;
|
||
|
|
checkcpdtable[j].pattern2 = NULL;
|
||
|
|
}
|
||
|
|
free(checkcpdtable);
|
||
|
|
checkcpdtable = NULL;
|
||
|
|
}
|
||
|
|
numcheckcpd = 0;
|
||
|
|
FREE_FLAG(compoundflag);
|
||
|
|
FREE_FLAG(compoundbegin);
|
||
|
|
FREE_FLAG(compoundmiddle);
|
||
|
|
FREE_FLAG(compoundend);
|
||
|
|
FREE_FLAG(compoundpermitflag);
|
||
|
|
FREE_FLAG(compoundforbidflag);
|
||
|
|
FREE_FLAG(compoundroot);
|
||
|
|
FREE_FLAG(forbiddenword);
|
||
|
|
FREE_FLAG(nosuggest);
|
||
|
|
FREE_FLAG(pseudoroot);
|
||
|
|
FREE_FLAG(lemma_present);
|
||
|
|
FREE_FLAG(circumfix);
|
||
|
|
FREE_FLAG(onlyincompound);
|
||
|
|
|
||
|
|
cpdwordmax = 0;
|
||
|
|
pHMgr = NULL;
|
||
|
|
cpdmin = 0;
|
||
|
|
cpdmaxsyllable = 0;
|
||
|
|
if (cpdvowels) free(cpdvowels);
|
||
|
|
if (cpdvowels_utf16) free(cpdvowels_utf16);
|
||
|
|
if (cpdsyllablenum) free(cpdsyllablenum);
|
||
|
|
if (utf_tbl) free(utf_tbl);
|
||
|
|
if (lang) free(lang);
|
||
|
|
if (wordchars) free(wordchars);
|
||
|
|
if (wordchars_utf16) free(wordchars_utf16);
|
||
|
|
if (version) free(version);
|
||
|
|
if (derived) free(derived);
|
||
|
|
checknum=0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// read in aff file and build up prefix and suffix entry objects
|
||
|
|
int AffixMgr::parse_file(const char * affpath)
|
||
|
|
{
|
||
|
|
|
||
|
|
// io buffers
|
||
|
|
char line[MAXLNLEN+1];
|
||
|
|
|
||
|
|
// affix type
|
||
|
|
char ft;
|
||
|
|
|
||
|
|
// checking flag duplication
|
||
|
|
char dupflags[CONTSIZE];
|
||
|
|
char dupflags_ini = 1;
|
||
|
|
|
||
|
|
// open the affix file
|
||
|
|
FILE * afflst;
|
||
|
|
afflst = fopen(affpath,"r");
|
||
|
|
if (!afflst) {
|
||
|
|
fprintf(stderr,"Error - could not open affix description file %s\n",affpath);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// step one is to parse the affix file building up the internal
|
||
|
|
// affix data structures
|
||
|
|
|
||
|
|
|
||
|
|
// read in each line ignoring any that do not
|
||
|
|
// start with a known line type indicator
|
||
|
|
|
||
|
|
while (fgets(line,MAXLNLEN,afflst)) {
|
||
|
|
mychomp(line);
|
||
|
|
|
||
|
|
/* parse in the try string */
|
||
|
|
if (strncmp(line,"TRY",3) == 0) {
|
||
|
|
if (parse_try(line)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the name of the character set used by the .dict and .aff */
|
||
|
|
if (strncmp(line,"SET",3) == 0) {
|
||
|
|
if (parse_set(line)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse COMPLEXPREFIXES for agglutinative languages with right-to-left writing system */
|
||
|
|
if (strncmp(line,"COMPLEXPREFIXES",15) == 0)
|
||
|
|
complexprefixes = 1;
|
||
|
|
|
||
|
|
/* parse in the flag used by the controlled compound words */
|
||
|
|
if (strncmp(line,"COMPOUNDFLAG",12) == 0) {
|
||
|
|
if (parse_flag(line, &compoundflag, "COMPOUNDFLAG")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by compound words */
|
||
|
|
if (strncmp(line,"COMPOUNDBEGIN",13) == 0) {
|
||
|
|
if (complexprefixes) {
|
||
|
|
if (parse_flag(line, &compoundend, "COMPOUNDBEGIN")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (parse_flag(line, &compoundbegin, "COMPOUNDBEGIN")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by compound words */
|
||
|
|
if (strncmp(line,"COMPOUNDMIDDLE",14) == 0) {
|
||
|
|
if (parse_flag(line, &compoundmiddle, "COMPOUNDMIDDLE")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/* parse in the flag used by compound words */
|
||
|
|
if (strncmp(line,"COMPOUNDEND",11) == 0) {
|
||
|
|
if (complexprefixes) {
|
||
|
|
if (parse_flag(line, &compoundbegin, "COMPOUNDEND")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (parse_flag(line, &compoundend, "COMPOUNDEND")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by compound_check() method */
|
||
|
|
if (strncmp(line,"COMPOUNDWORDMAX",15) == 0) {
|
||
|
|
if (parse_num(line, &cpdwordmax, "COMPOUNDWORDMAX")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag sign compounds in dictionary */
|
||
|
|
if (strncmp(line,"COMPOUNDROOT",12) == 0) {
|
||
|
|
if (parse_flag(line, &compoundroot, "COMPOUNDROOT")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by compound_check() method */
|
||
|
|
if (strncmp(line,"COMPOUNDPERMITFLAG",18) == 0) {
|
||
|
|
if (parse_flag(line, &compoundpermitflag, "COMPOUNDPERMITFLAG")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by compound_check() method */
|
||
|
|
if (strncmp(line,"COMPOUNDFORBIDFLAG",18) == 0) {
|
||
|
|
if (parse_flag(line, &compoundforbidflag, "COMPOUNDFORBIDFLAG")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (strncmp(line,"CHECKCOMPOUNDDUP",16) == 0)
|
||
|
|
checkcompounddup = 1;
|
||
|
|
|
||
|
|
if (strncmp(line,"CHECKCOMPOUNDREP",16) == 0)
|
||
|
|
checkcompoundrep = 1;
|
||
|
|
|
||
|
|
if (strncmp(line,"CHECKCOMPOUNDTRIPLE",19) == 0)
|
||
|
|
checkcompoundtriple = 1;
|
||
|
|
|
||
|
|
if (strncmp(line,"CHECKCOMPOUNDCASE",17) == 0)
|
||
|
|
checkcompoundcase = 1;
|
||
|
|
|
||
|
|
if (strncmp(line,"NOSUGGEST",9) == 0) {
|
||
|
|
if (parse_flag(line, &nosuggest, "NOSUGGEST")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by forbidden words */
|
||
|
|
if (strncmp(line,"FORBIDDENWORD",13) == 0) {
|
||
|
|
if (parse_flag(line, &forbiddenword, "FORBIDDENWORD")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by forbidden words */
|
||
|
|
if (strncmp(line,"LEMMA_PRESENT",13) == 0) {
|
||
|
|
if (parse_flag(line, &lemma_present, "LEMMA_PRESENT")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by circumfixes */
|
||
|
|
if (strncmp(line,"CIRCUMFIX",9) == 0) {
|
||
|
|
if (parse_flag(line, &circumfix, "CIRCUMFIX")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by fogemorphemes */
|
||
|
|
if (strncmp(line,"ONLYINCOMPOUND",14) == 0) {
|
||
|
|
if (parse_flag(line, &onlyincompound, "ONLYINCOMPOUND")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by `pseudoroots' */
|
||
|
|
if (strncmp(line,"PSEUDOROOT",10) == 0) {
|
||
|
|
if (parse_flag(line, &pseudoroot, "PSEUDOROOT")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by `pseudoroots' */
|
||
|
|
if (strncmp(line,"NEEDAFFIX",9) == 0) {
|
||
|
|
if (parse_flag(line, &pseudoroot, "NEEDAFFIX")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the minimal length for words in compounds */
|
||
|
|
if (strncmp(line,"COMPOUNDMIN",11) == 0) {
|
||
|
|
if (parse_num(line, &cpdmin, "COMPOUNDMIN")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
if (cpdmin < 1) cpdmin = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the max. words and syllables in compounds */
|
||
|
|
if (strncmp(line,"COMPOUNDSYLLABLE",16) == 0) {
|
||
|
|
if (parse_cpdsyllable(line)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by compound_check() method */
|
||
|
|
if (strncmp(line,"SYLLABLENUM",11) == 0) {
|
||
|
|
if (parse_syllablenum(line)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by the controlled compound words */
|
||
|
|
if (strncmp(line,"CHECKNUM",8) == 0) {
|
||
|
|
checknum=1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the try string */
|
||
|
|
if (strncmp(line,"WORDCHARS",9) == 0) {
|
||
|
|
if (parse_wordchars(line)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the typical fault correcting table */
|
||
|
|
if (strncmp(line,"REP",3) == 0) {
|
||
|
|
if (parse_reptable(line, afflst)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the checkcompoundpattern table */
|
||
|
|
if (strncmp(line,"CHECKCOMPOUNDPATTERN",20) == 0) {
|
||
|
|
if (parse_checkcpdtable(line, afflst)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the defcompound table */
|
||
|
|
if (strncmp(line,"COMPOUNDRULE",12) == 0) {
|
||
|
|
if (parse_defcpdtable(line, afflst)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the related character map table */
|
||
|
|
if (strncmp(line,"MAP",3) == 0) {
|
||
|
|
if (parse_maptable(line, afflst)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the word breakpoints table */
|
||
|
|
if (strncmp(line,"BREAK",5) == 0) {
|
||
|
|
if (parse_breaktable(line, afflst)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the language for language specific codes */
|
||
|
|
if (strncmp(line,"LANG",4) == 0) {
|
||
|
|
if (parse_lang(line)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (strncmp(line,"VERSION",7) == 0) {
|
||
|
|
if (parse_version(line)) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (strncmp(line,"MAXNGRAMSUGS",12) == 0) {
|
||
|
|
if (parse_num(line, &maxngramsugs, "MAXNGRAMSUGS")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (strncmp(line,"NOSPLITSUGS",11) == 0)
|
||
|
|
nosplitsugs=1;
|
||
|
|
|
||
|
|
if (strncmp(line,"SUGSWITHDOTS",12) == 0)
|
||
|
|
sugswithdots=1;
|
||
|
|
|
||
|
|
/* parse in the flag used by forbidden words */
|
||
|
|
if (strncmp(line,"KEEPCASE",8) == 0) {
|
||
|
|
if (parse_flag(line, &keepcase, "KEEPCASE")) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (strncmp(line,"CHECKSHARPS",11) == 0)
|
||
|
|
checksharps=1;
|
||
|
|
|
||
|
|
/* parse this affix: P - prefix, S - suffix */
|
||
|
|
ft = ' ';
|
||
|
|
if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';
|
||
|
|
if (strncmp(line,"SFX",3) == 0) ft = complexprefixes ? 'P' : 'S';
|
||
|
|
if (ft != ' ') {
|
||
|
|
if (dupflags_ini) {
|
||
|
|
for (int i = 0; i < CONTSIZE; i++) dupflags[i] = 0;
|
||
|
|
dupflags_ini = 0;
|
||
|
|
}
|
||
|
|
if (parse_affix(line, ft, afflst, dupflags)) {
|
||
|
|
fclose(afflst);
|
||
|
|
process_pfx_tree_to_list();
|
||
|
|
process_sfx_tree_to_list();
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
fclose(afflst);
|
||
|
|
|
||
|
|
// convert affix trees to sorted list
|
||
|
|
process_pfx_tree_to_list();
|
||
|
|
process_sfx_tree_to_list();
|
||
|
|
|
||
|
|
// now we can speed up performance greatly taking advantage of the
|
||
|
|
// relationship between the affixes and the idea of "subsets".
|
||
|
|
|
||
|
|
// View each prefix as a potential leading subset of another and view
|
||
|
|
// each suffix (reversed) as a potential trailing subset of another.
|
||
|
|
|
||
|
|
// To illustrate this relationship if we know the prefix "ab" is found in the
|
||
|
|
// word to examine, only prefixes that "ab" is a leading subset of need be examined.
|
||
|
|
// Furthermore is "ab" is not present then none of the prefixes that "ab" is
|
||
|
|
// is a subset need be examined.
|
||
|
|
// The same argument goes for suffix string that are reversed.
|
||
|
|
|
||
|
|
// Then to top this off why not examine the first char of the word to quickly
|
||
|
|
// limit the set of prefixes to examine (i.e. the prefixes to examine must
|
||
|
|
// be leading supersets of the first character of the word (if they exist)
|
||
|
|
|
||
|
|
// To take advantage of this "subset" relationship, we need to add two links
|
||
|
|
// from entry. One to take next if the current prefix is found (call it nexteq)
|
||
|
|
// and one to take next if the current prefix is not found (call it nextne).
|
||
|
|
|
||
|
|
// Since we have built ordered lists, all that remains is to properly intialize
|
||
|
|
// the nextne and nexteq pointers that relate them
|
||
|
|
|
||
|
|
process_pfx_order();
|
||
|
|
process_sfx_order();
|
||
|
|
|
||
|
|
// expand wordchars string, based on csutil (for external tokenization)
|
||
|
|
|
||
|
|
char * enc = get_encoding();
|
||
|
|
csconv = get_current_cs(enc);
|
||
|
|
free(enc);
|
||
|
|
enc = NULL;
|
||
|
|
|
||
|
|
char expw[MAXLNLEN];
|
||
|
|
if (wordchars) {
|
||
|
|
strcpy(expw, wordchars);
|
||
|
|
free(wordchars);
|
||
|
|
} else *expw = '\0';
|
||
|
|
|
||
|
|
for (int i = 0; i <= 255; i++) {
|
||
|
|
if ( (csconv[i].cupper != csconv[i].clower) &&
|
||
|
|
(! strchr(expw, (char) i))) {
|
||
|
|
*(expw + strlen(expw) + 1) = '\0';
|
||
|
|
*(expw + strlen(expw)) = (char) i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
wordchars = mystrdup(expw);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// 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(AffEntry* pfxptr)
|
||
|
|
{
|
||
|
|
PfxEntry * ptr;
|
||
|
|
PfxEntry * pptr;
|
||
|
|
PfxEntry * ep = (PfxEntry*) pfxptr;
|
||
|
|
|
||
|
|
// get the right starting points
|
||
|
|
const char * key = ep->getKey();
|
||
|
|
const unsigned char flg = ep->getFlag();
|
||
|
|
|
||
|
|
// first index by flag which must exist
|
||
|
|
ptr = (PfxEntry*)pFlag[flg];
|
||
|
|
ep->setFlgNxt(ptr);
|
||
|
|
pFlag[flg] = (AffEntry *) ep;
|
||
|
|
|
||
|
|
|
||
|
|
// handle the special case of null affix string
|
||
|
|
if (strlen(key) == 0) {
|
||
|
|
// always inset them at head of list at element 0
|
||
|
|
ptr = (PfxEntry*)pStart[0];
|
||
|
|
ep->setNext(ptr);
|
||
|
|
pStart[0] = (AffEntry*)ep;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the normal case
|
||
|
|
ep->setNextEQ(NULL);
|
||
|
|
ep->setNextNE(NULL);
|
||
|
|
|
||
|
|
unsigned char sp = *((const unsigned char *)key);
|
||
|
|
ptr = (PfxEntry*)pStart[sp];
|
||
|
|
|
||
|
|
// handle the first insert
|
||
|
|
if (!ptr) {
|
||
|
|
pStart[sp] = (AffEntry*)ep;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// otherwise use binary tree insertion so that a sorted
|
||
|
|
// list can easily be generated later
|
||
|
|
pptr = NULL;
|
||
|
|
for (;;) {
|
||
|
|
pptr = ptr;
|
||
|
|
if (strcmp(ep->getKey(), ptr->getKey() ) <= 0) {
|
||
|
|
ptr = ptr->getNextEQ();
|
||
|
|
if (!ptr) {
|
||
|
|
pptr->setNextEQ(ep);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
ptr = ptr->getNextNE();
|
||
|
|
if (!ptr) {
|
||
|
|
pptr->setNextNE(ep);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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(AffEntry* sfxptr)
|
||
|
|
{
|
||
|
|
SfxEntry * ptr;
|
||
|
|
SfxEntry * pptr;
|
||
|
|
SfxEntry * ep = (SfxEntry *) sfxptr;
|
||
|
|
|
||
|
|
/* get the right starting point */
|
||
|
|
const char * key = ep->getKey();
|
||
|
|
const unsigned char flg = ep->getFlag();
|
||
|
|
|
||
|
|
// first index by flag which must exist
|
||
|
|
ptr = (SfxEntry*)sFlag[flg];
|
||
|
|
ep->setFlgNxt(ptr);
|
||
|
|
sFlag[flg] = (AffEntry *) ep;
|
||
|
|
|
||
|
|
// next index by affix string
|
||
|
|
|
||
|
|
// handle the special case of null affix string
|
||
|
|
if (strlen(key) == 0) {
|
||
|
|
// always inset them at head of list at element 0
|
||
|
|
ptr = (SfxEntry*)sStart[0];
|
||
|
|
ep->setNext(ptr);
|
||
|
|
sStart[0] = (AffEntry*)ep;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the normal case
|
||
|
|
ep->setNextEQ(NULL);
|
||
|
|
ep->setNextNE(NULL);
|
||
|
|
|
||
|
|
unsigned char sp = *((const unsigned char *)key);
|
||
|
|
ptr = (SfxEntry*)sStart[sp];
|
||
|
|
|
||
|
|
// handle the first insert
|
||
|
|
if (!ptr) {
|
||
|
|
sStart[sp] = (AffEntry*)ep;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// otherwise use binary tree insertion so that a sorted
|
||
|
|
// list can easily be generated later
|
||
|
|
pptr = NULL;
|
||
|
|
for (;;) {
|
||
|
|
pptr = ptr;
|
||
|
|
if (strcmp(ep->getKey(), ptr->getKey() ) <= 0) {
|
||
|
|
ptr = ptr->getNextEQ();
|
||
|
|
if (!ptr) {
|
||
|
|
pptr->setNextEQ(ep);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
ptr = ptr->getNextNE();
|
||
|
|
if (!ptr) {
|
||
|
|
pptr->setNextNE(ep);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// convert from binary tree to sorted list
|
||
|
|
int AffixMgr::process_pfx_tree_to_list()
|
||
|
|
{
|
||
|
|
for (int i=1; i< SETSIZE; i++) {
|
||
|
|
pStart[i] = process_pfx_in_order(pStart[i],NULL);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
AffEntry* AffixMgr::process_pfx_in_order(AffEntry* ptr, AffEntry* nptr)
|
||
|
|
{
|
||
|
|
if (ptr) {
|
||
|
|
nptr = process_pfx_in_order(((PfxEntry*) ptr)->getNextNE(), nptr);
|
||
|
|
((PfxEntry*) ptr)->setNext((PfxEntry*) nptr);
|
||
|
|
nptr = process_pfx_in_order(((PfxEntry*) ptr)->getNextEQ(), ptr);
|
||
|
|
}
|
||
|
|
return nptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// convert from binary tree to sorted list
|
||
|
|
int AffixMgr:: process_sfx_tree_to_list()
|
||
|
|
{
|
||
|
|
for (int i=1; i< SETSIZE; i++) {
|
||
|
|
sStart[i] = process_sfx_in_order(sStart[i],NULL);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
AffEntry* AffixMgr::process_sfx_in_order(AffEntry* ptr, AffEntry* nptr)
|
||
|
|
{
|
||
|
|
if (ptr) {
|
||
|
|
nptr = process_sfx_in_order(((SfxEntry*) ptr)->getNextNE(), nptr);
|
||
|
|
((SfxEntry*) ptr)->setNext((SfxEntry*) nptr);
|
||
|
|
nptr = process_sfx_in_order(((SfxEntry*) ptr)->getNextEQ(), ptr);
|
||
|
|
}
|
||
|
|
return nptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// reinitialize the PfxEntry links NextEQ and NextNE to speed searching
|
||
|
|
// using the idea of leading subsets this time
|
||
|
|
int AffixMgr::process_pfx_order()
|
||
|
|
{
|
||
|
|
PfxEntry* ptr;
|
||
|
|
|
||
|
|
// loop through each prefix list starting point
|
||
|
|
for (int i=1; i < SETSIZE; i++) {
|
||
|
|
|
||
|
|
ptr = (PfxEntry*)pStart[i];
|
||
|
|
|
||
|
|
// look through the remainder of the list
|
||
|
|
// and find next entry with affix that
|
||
|
|
// the current one is not a subset of
|
||
|
|
// mark that as destination for NextNE
|
||
|
|
// use next in list that you are a subset
|
||
|
|
// of as NextEQ
|
||
|
|
|
||
|
|
for (; ptr != NULL; ptr = ptr->getNext()) {
|
||
|
|
|
||
|
|
PfxEntry * nptr = ptr->getNext();
|
||
|
|
for (; nptr != NULL; nptr = nptr->getNext()) {
|
||
|
|
if (! isSubset( ptr->getKey() , nptr->getKey() )) break;
|
||
|
|
}
|
||
|
|
ptr->setNextNE(nptr);
|
||
|
|
ptr->setNextEQ(NULL);
|
||
|
|
if ((ptr->getNext()) && isSubset(ptr->getKey() , (ptr->getNext())->getKey()))
|
||
|
|
ptr->setNextEQ(ptr->getNext());
|
||
|
|
}
|
||
|
|
|
||
|
|
// now clean up by adding smart search termination strings:
|
||
|
|
// if you are already a superset of the previous prefix
|
||
|
|
// but not a subset of the next, search can end here
|
||
|
|
// so set NextNE properly
|
||
|
|
|
||
|
|
ptr = (PfxEntry *) pStart[i];
|
||
|
|
for (; ptr != NULL; ptr = ptr->getNext()) {
|
||
|
|
PfxEntry * nptr = ptr->getNext();
|
||
|
|
PfxEntry * mptr = NULL;
|
||
|
|
for (; nptr != NULL; nptr = nptr->getNext()) {
|
||
|
|
if (! isSubset(ptr->getKey(),nptr->getKey())) break;
|
||
|
|
mptr = nptr;
|
||
|
|
}
|
||
|
|
if (mptr) mptr->setNextNE(NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// initialize the SfxEntry links NextEQ and NextNE to speed searching
|
||
|
|
// using the idea of leading subsets this time
|
||
|
|
int AffixMgr::process_sfx_order()
|
||
|
|
{
|
||
|
|
SfxEntry* ptr;
|
||
|
|
|
||
|
|
// loop through each prefix list starting point
|
||
|
|
for (int i=1; i < SETSIZE; i++) {
|
||
|
|
|
||
|
|
ptr = (SfxEntry *) sStart[i];
|
||
|
|
|
||
|
|
// look through the remainder of the list
|
||
|
|
// and find next entry with affix that
|
||
|
|
// the current one is not a subset of
|
||
|
|
// mark that as destination for NextNE
|
||
|
|
// use next in list that you are a subset
|
||
|
|
// of as NextEQ
|
||
|
|
|
||
|
|
for (; ptr != NULL; ptr = ptr->getNext()) {
|
||
|
|
SfxEntry * nptr = ptr->getNext();
|
||
|
|
for (; nptr != NULL; nptr = nptr->getNext()) {
|
||
|
|
if (! isSubset(ptr->getKey(),nptr->getKey())) break;
|
||
|
|
}
|
||
|
|
ptr->setNextNE(nptr);
|
||
|
|
ptr->setNextEQ(NULL);
|
||
|
|
if ((ptr->getNext()) && isSubset(ptr->getKey(),(ptr->getNext())->getKey()))
|
||
|
|
ptr->setNextEQ(ptr->getNext());
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// now clean up by adding smart search termination strings:
|
||
|
|
// if you are already a superset of the previous suffix
|
||
|
|
// but not a subset of the next, search can end here
|
||
|
|
// so set NextNE properly
|
||
|
|
|
||
|
|
ptr = (SfxEntry *) sStart[i];
|
||
|
|
for (; ptr != NULL; ptr = ptr->getNext()) {
|
||
|
|
SfxEntry * nptr = ptr->getNext();
|
||
|
|
SfxEntry * mptr = NULL;
|
||
|
|
for (; nptr != NULL; nptr = nptr->getNext()) {
|
||
|
|
if (! isSubset(ptr->getKey(),nptr->getKey())) break;
|
||
|
|
mptr = nptr;
|
||
|
|
}
|
||
|
|
if (mptr) mptr->setNextNE(NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// takes aff file condition string and creates the
|
||
|
|
// conds array - please see the appendix at the end of the
|
||
|
|
// file affentry.cxx which describes what is going on here
|
||
|
|
// in much more detail
|
||
|
|
|
||
|
|
int AffixMgr::encodeit(struct affentry * ptr, char * cs)
|
||
|
|
{
|
||
|
|
unsigned char c;
|
||
|
|
int i, j, k;
|
||
|
|
unsigned char mbr[MAXLNLEN];
|
||
|
|
w_char wmbr[MAXLNLEN];
|
||
|
|
w_char * wpos = wmbr;
|
||
|
|
|
||
|
|
// now clear the conditions array */
|
||
|
|
for (i=0;i<SETSIZE;i++) ptr->conds.base[i] = (unsigned char) 0;
|
||
|
|
|
||
|
|
// now parse the string to create the conds array */
|
||
|
|
int nc = strlen(cs);
|
||
|
|
int neg = 0; // complement indicator
|
||
|
|
int grp = 0; // group indicator
|
||
|
|
int n = 0; // number of conditions
|
||
|
|
int ec = 0; // end condition indicator
|
||
|
|
int nm = 0; // number of member in group
|
||
|
|
|
||
|
|
// if no condition just return
|
||
|
|
if (strcmp(cs,".")==0) {
|
||
|
|
ptr->numconds = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
i = 0;
|
||
|
|
while (i < nc) {
|
||
|
|
c = *((unsigned char *)(cs + i));
|
||
|
|
|
||
|
|
// start group indicator
|
||
|
|
if (c == '[') {
|
||
|
|
grp = 1;
|
||
|
|
c = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// complement flag
|
||
|
|
if ((grp == 1) && (c == '^')) {
|
||
|
|
neg = 1;
|
||
|
|
c = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// end goup indicator
|
||
|
|
if (c == ']') {
|
||
|
|
ec = 1;
|
||
|
|
c = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// add character of group to list
|
||
|
|
if ((grp == 1) && (c != 0)) {
|
||
|
|
*(mbr + nm) = c;
|
||
|
|
nm++;
|
||
|
|
c = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// end of condition
|
||
|
|
if (c != 0) {
|
||
|
|
ec = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ec) {
|
||
|
|
if (!utf8) {
|
||
|
|
if (grp == 1) {
|
||
|
|
if (neg == 0) {
|
||
|
|
// set the proper bits in the condition array vals for those chars
|
||
|
|
for (j=0;j<nm;j++) {
|
||
|
|
k = (unsigned int) mbr[j];
|
||
|
|
ptr->conds.base[k] = ptr->conds.base[k] | (1 << n);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// complement so set all of them and then unset indicated ones
|
||
|
|
for (j=0;j<SETSIZE;j++) ptr->conds.base[j] = ptr->conds.base[j] | (1 << n);
|
||
|
|
for (j=0;j<nm;j++) {
|
||
|
|
k = (unsigned int) mbr[j];
|
||
|
|
ptr->conds.base[k] = ptr->conds.base[k] & ~(1 << n);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
neg = 0;
|
||
|
|
grp = 0;
|
||
|
|
nm = 0;
|
||
|
|
} else {
|
||
|
|
// not a group so just set the proper bit for this char
|
||
|
|
// but first handle special case of . inside condition
|
||
|
|
if (c == '.') {
|
||
|
|
// wild card character so set them all
|
||
|
|
for (j=0;j<SETSIZE;j++) ptr->conds.base[j] = ptr->conds.base[j] | (1 << n);
|
||
|
|
} else {
|
||
|
|
ptr->conds.base[(unsigned int) c] = ptr->conds.base[(unsigned int)c] | (1 << n);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
n++;
|
||
|
|
ec = 0;
|
||
|
|
} else { // UTF-8 character set
|
||
|
|
if (grp == 1) {
|
||
|
|
ptr->conds.utf8.neg[n] = neg;
|
||
|
|
if (neg == 0) {
|
||
|
|
// set the proper bits in the condition array vals for those chars
|
||
|
|
for (j=0;j<nm;j++) {
|
||
|
|
k = (unsigned int) mbr[j];
|
||
|
|
if (k >> 7) {
|
||
|
|
u8_u16(wpos, 1, (char *) mbr + j);
|
||
|
|
wpos++;
|
||
|
|
if ((k & 0xe0) == 0xe0) j+=2; else j++; // 3-byte UTF-8 character
|
||
|
|
} else {
|
||
|
|
ptr->conds.utf8.ascii[k] = ptr->conds.utf8.ascii[k] | (1 << n);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else { // neg == 1
|
||
|
|
// complement so set all of them and then unset indicated ones
|
||
|
|
for (j=0;j<(SETSIZE/2);j++) ptr->conds.utf8.ascii[j] = ptr->conds.utf8.ascii[j] | (1 << n);
|
||
|
|
for (j=0;j<nm;j++) {
|
||
|
|
k = (unsigned int) mbr[j];
|
||
|
|
if (k >> 7) {
|
||
|
|
u8_u16(wpos, 1, (char *) mbr + j);
|
||
|
|
wpos++;
|
||
|
|
if ((k & 0xe0) == 0xe0) j+=2; else j++; // 3-byte UTF-8 character
|
||
|
|
} else {
|
||
|
|
ptr->conds.utf8.ascii[k] = ptr->conds.utf8.ascii[k] & ~(1 << n);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
neg = 0;
|
||
|
|
grp = 0;
|
||
|
|
nm = 0;
|
||
|
|
ptr->conds.utf8.wlen[n] = wpos - wmbr;
|
||
|
|
if ((wpos - wmbr) != 0) {
|
||
|
|
ptr->conds.utf8.wchars[n] = (w_char *) malloc(sizeof(w_char) * (wpos - wmbr));
|
||
|
|
if (!ptr->conds.utf8.wchars[n]) return 1;
|
||
|
|
memcpy(ptr->conds.utf8.wchars[n], wmbr, sizeof(w_char) * (wpos - wmbr));
|
||
|
|
flag_qsort((unsigned short *) ptr->conds.utf8.wchars[n], 0, ptr->conds.utf8.wlen[n]);
|
||
|
|
wpos = wmbr;
|
||
|
|
}
|
||
|
|
} else { // grp == 0
|
||
|
|
// is UTF-8 character?
|
||
|
|
if (c >> 7) {
|
||
|
|
ptr->conds.utf8.wchars[n] = (w_char *) malloc(sizeof(w_char));
|
||
|
|
if (!ptr->conds.utf8.wchars[n]) return 1;
|
||
|
|
ptr->conds.utf8.wlen[n] = 1;
|
||
|
|
u8_u16(ptr->conds.utf8.wchars[n], 1, cs + i);
|
||
|
|
if ((c & 0xe0) == 0xe0) i+=2; else i++; // 3-byte UFT-8 character
|
||
|
|
} else {
|
||
|
|
ptr->conds.utf8.wchars[n] = NULL;
|
||
|
|
// not a group so just set the proper bit for this char
|
||
|
|
// but first handle special case of . inside condition
|
||
|
|
if (c == '.') {
|
||
|
|
ptr->conds.utf8.all[n] = 1;
|
||
|
|
// wild card character so set them all
|
||
|
|
for (j=0;j<(SETSIZE/2);j++) ptr->conds.utf8.ascii[j] = ptr->conds.utf8.ascii[j] | (1 << n);
|
||
|
|
} else {
|
||
|
|
ptr->conds.utf8.all[n] = 0;
|
||
|
|
ptr->conds.utf8.ascii[(unsigned int) c] = ptr->conds.utf8.ascii[(unsigned int)c] | (1 << n);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
neg = 0;
|
||
|
|
}
|
||
|
|
n++;
|
||
|
|
ec = 0;
|
||
|
|
neg = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
ptr->numconds = n;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return 1 if s1 is a leading subset of s2
|
||
|
|
inline int AffixMgr::isSubset(const char * s1, const char * s2)
|
||
|
|
{
|
||
|
|
while ((*s1 == *s2) && *s1) {
|
||
|
|
s1++;
|
||
|
|
s2++;
|
||
|
|
}
|
||
|
|
return (*s1 == '\0');
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// check word for prefixes
|
||
|
|
struct hentry * AffixMgr::prefix_check(const char * word, int len, char in_compound,
|
||
|
|
const FLAG needflag)
|
||
|
|
{
|
||
|
|
struct hentry * rv= NULL;
|
||
|
|
|
||
|
|
pfx = NULL;
|
||
|
|
pfxappnd = NULL;
|
||
|
|
sfxappnd = NULL;
|
||
|
|
|
||
|
|
// first handle the special case of 0 length prefixes
|
||
|
|
PfxEntry * pe = (PfxEntry *) pStart[0];
|
||
|
|
while (pe) {
|
||
|
|
if (
|
||
|
|
// fogemorpheme
|
||
|
|
((in_compound != IN_CPD_NOT) || !(pe->getCont() &&
|
||
|
|
(TESTAFF(pe->getCont(), onlyincompound, pe->getContLen())))) &&
|
||
|
|
// permit prefixes in compounds
|
||
|
|
((in_compound != IN_CPD_END) || (pe->getCont() &&
|
||
|
|
(TESTAFF(pe->getCont(), compoundpermitflag, pe->getContLen())))) &&
|
||
|
|
// check prefix
|
||
|
|
(rv = pe->check(word, len, in_compound, needflag))
|
||
|
|
) {
|
||
|
|
pfx=(AffEntry *)pe; // BUG: pfx not stateless
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
pe = pe->getNext();
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the general case
|
||
|
|
unsigned char sp = *((const unsigned char *)word);
|
||
|
|
PfxEntry * pptr = (PfxEntry *)pStart[sp];
|
||
|
|
|
||
|
|
while (pptr) {
|
||
|
|
if (isSubset(pptr->getKey(),word)) {
|
||
|
|
if (
|
||
|
|
// fogemorpheme
|
||
|
|
((in_compound != IN_CPD_NOT) || !(pptr->getCont() &&
|
||
|
|
(TESTAFF(pptr->getCont(), onlyincompound, pptr->getContLen())))) &&
|
||
|
|
// permit prefixes in compounds
|
||
|
|
((in_compound != IN_CPD_END) || (pptr->getCont() &&
|
||
|
|
(TESTAFF(pptr->getCont(), compoundpermitflag, pptr->getContLen())))) &&
|
||
|
|
// check prefix
|
||
|
|
(rv = pptr->check(word, len, in_compound, needflag))
|
||
|
|
) {
|
||
|
|
pfx=(AffEntry *)pptr; // BUG: pfx not stateless
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
pptr = pptr->getNextEQ();
|
||
|
|
} else {
|
||
|
|
pptr = pptr->getNextNE();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check word for prefixes
|
||
|
|
struct hentry * AffixMgr::prefix_check_twosfx(const char * word, int len,
|
||
|
|
char in_compound, const FLAG needflag)
|
||
|
|
{
|
||
|
|
struct hentry * rv= NULL;
|
||
|
|
|
||
|
|
pfx = NULL;
|
||
|
|
sfxappnd = NULL;
|
||
|
|
|
||
|
|
// first handle the special case of 0 length prefixes
|
||
|
|
PfxEntry * pe = (PfxEntry *) pStart[0];
|
||
|
|
|
||
|
|
while (pe) {
|
||
|
|
rv = pe->check_twosfx(word, len, in_compound, needflag);
|
||
|
|
if (rv) return rv;
|
||
|
|
pe = pe->getNext();
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the general case
|
||
|
|
unsigned char sp = *((const unsigned char *)word);
|
||
|
|
PfxEntry * pptr = (PfxEntry *)pStart[sp];
|
||
|
|
|
||
|
|
while (pptr) {
|
||
|
|
if (isSubset(pptr->getKey(),word)) {
|
||
|
|
rv = pptr->check_twosfx(word, len, in_compound, needflag);
|
||
|
|
if (rv) {
|
||
|
|
pfx = (AffEntry *)pptr;
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
pptr = pptr->getNextEQ();
|
||
|
|
} else {
|
||
|
|
pptr = pptr->getNextNE();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// check word for prefixes
|
||
|
|
char * AffixMgr::prefix_check_morph(const char * word, int len, char in_compound,
|
||
|
|
const FLAG needflag)
|
||
|
|
{
|
||
|
|
char * st;
|
||
|
|
|
||
|
|
char result[MAXLNLEN];
|
||
|
|
result[0] = '\0';
|
||
|
|
|
||
|
|
pfx = NULL;
|
||
|
|
sfxappnd = NULL;
|
||
|
|
|
||
|
|
// first handle the special case of 0 length prefixes
|
||
|
|
PfxEntry * pe = (PfxEntry *) pStart[0];
|
||
|
|
while (pe) {
|
||
|
|
st = pe->check_morph(word,len,in_compound, needflag);
|
||
|
|
if (st) {
|
||
|
|
strcat(result, st);
|
||
|
|
free(st);
|
||
|
|
}
|
||
|
|
// if (rv) return rv;
|
||
|
|
pe = pe->getNext();
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the general case
|
||
|
|
unsigned char sp = *((const unsigned char *)word);
|
||
|
|
PfxEntry * pptr = (PfxEntry *)pStart[sp];
|
||
|
|
|
||
|
|
while (pptr) {
|
||
|
|
if (isSubset(pptr->getKey(),word)) {
|
||
|
|
st = pptr->check_morph(word,len,in_compound, needflag);
|
||
|
|
if (st) {
|
||
|
|
// fogemorpheme
|
||
|
|
if ((in_compound != IN_CPD_NOT) || !((pptr->getCont() &&
|
||
|
|
(TESTAFF(pptr->getCont(), onlyincompound, pptr->getContLen()))))) {
|
||
|
|
strcat(result, st);
|
||
|
|
pfx = (AffEntry *)pptr;
|
||
|
|
}
|
||
|
|
free(st);
|
||
|
|
}
|
||
|
|
pptr = pptr->getNextEQ();
|
||
|
|
} else {
|
||
|
|
pptr = pptr->getNextNE();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*result) return mystrdup(result);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// check word for prefixes
|
||
|
|
char * AffixMgr::prefix_check_twosfx_morph(const char * word, int len,
|
||
|
|
char in_compound, const FLAG needflag)
|
||
|
|
{
|
||
|
|
char * st;
|
||
|
|
|
||
|
|
char result[MAXLNLEN];
|
||
|
|
result[0] = '\0';
|
||
|
|
|
||
|
|
pfx = NULL;
|
||
|
|
sfxappnd = NULL;
|
||
|
|
|
||
|
|
// first handle the special case of 0 length prefixes
|
||
|
|
PfxEntry * pe = (PfxEntry *) pStart[0];
|
||
|
|
while (pe) {
|
||
|
|
st = pe->check_twosfx_morph(word,len,in_compound, needflag);
|
||
|
|
if (st) {
|
||
|
|
strcat(result, st);
|
||
|
|
free(st);
|
||
|
|
}
|
||
|
|
pe = pe->getNext();
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the general case
|
||
|
|
unsigned char sp = *((const unsigned char *)word);
|
||
|
|
PfxEntry * pptr = (PfxEntry *)pStart[sp];
|
||
|
|
|
||
|
|
while (pptr) {
|
||
|
|
if (isSubset(pptr->getKey(),word)) {
|
||
|
|
st = pptr->check_twosfx_morph(word, len, in_compound, needflag);
|
||
|
|
if (st) {
|
||
|
|
strcat(result, st);
|
||
|
|
free(st);
|
||
|
|
pfx = (AffEntry *)pptr;
|
||
|
|
}
|
||
|
|
pptr = pptr->getNextEQ();
|
||
|
|
} else {
|
||
|
|
pptr = pptr->getNextNE();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*result) return mystrdup(result);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Is word a non compound with a REP substitution (see checkcompoundrep)?
|
||
|
|
int AffixMgr::cpdrep_check(const char * word, int wl)
|
||
|
|
{
|
||
|
|
char candidate[MAXLNLEN];
|
||
|
|
const char * r;
|
||
|
|
int lenr, lenp;
|
||
|
|
|
||
|
|
if ((wl < 2) || !numrep) return 0;
|
||
|
|
|
||
|
|
for (int i=0; i < numrep; i++ ) {
|
||
|
|
r = word;
|
||
|
|
lenr = strlen(reptable[i].pattern2);
|
||
|
|
lenp = strlen(reptable[i].pattern);
|
||
|
|
// search every occurence of the pattern in the word
|
||
|
|
while ((r=strstr(r, reptable[i].pattern)) != NULL) {
|
||
|
|
strcpy(candidate, word);
|
||
|
|
if (r-word + lenr + strlen(r+lenp) >= MAXLNLEN) break;
|
||
|
|
strcpy(candidate+(r-word),reptable[i].pattern2);
|
||
|
|
strcpy(candidate+(r-word)+lenr, r+lenp);
|
||
|
|
if (candidate_check(candidate,strlen(candidate))) return 1;
|
||
|
|
if (candidate_check(candidate,strlen(candidate))) return 1;
|
||
|
|
r++; // search for the next letter
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// forbid compoundings when there are special patterns at word bound
|
||
|
|
int AffixMgr::cpdpat_check(const char * word, int pos)
|
||
|
|
{
|
||
|
|
int len;
|
||
|
|
for (int i = 0; i < numcheckcpd; i++) {
|
||
|
|
if (isSubset(checkcpdtable[i].pattern2, word + pos) &&
|
||
|
|
(len = strlen(checkcpdtable[i].pattern)) && (pos > len) &&
|
||
|
|
(strncmp(word + pos - len, checkcpdtable[i].pattern, len) == 0)) return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// forbid compounding with neighbouring upper and lower case characters at word bounds
|
||
|
|
int AffixMgr::cpdcase_check(const char * word, int pos)
|
||
|
|
{
|
||
|
|
if (utf8) {
|
||
|
|
w_char u, w;
|
||
|
|
const char * p;
|
||
|
|
u8_u16(&u, 1, word + pos);
|
||
|
|
for (p = word + pos - 1; (*p & 0xc0) == 0x80; p--);
|
||
|
|
u8_u16(&w, 1, p);
|
||
|
|
unsigned short a = (u.h << 8) + u.l;
|
||
|
|
unsigned short b = (w.h << 8) + w.l;
|
||
|
|
if (utf_tbl[a].cletter && utf_tbl[a].cletter &&
|
||
|
|
((utf_tbl[a].cupper == a) || (utf_tbl[b].cupper == b))) return 1;
|
||
|
|
} else {
|
||
|
|
unsigned char a = *(word + pos - 1);
|
||
|
|
unsigned char b = *(word + pos);
|
||
|
|
if ((csconv[a].ccase || csconv[b].ccase) && (a != '-') && (b != '-')) return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check compound patterns
|
||
|
|
int AffixMgr::defcpd_check(hentry *** words, short wnum, hentry * rv, hentry ** def, char all)
|
||
|
|
{
|
||
|
|
short btpp[MAXWORDLEN]; // metacharacter (*, ?) positions for backtracking
|
||
|
|
short btwp[MAXWORDLEN]; // word positions for metacharacters
|
||
|
|
int btnum[MAXWORDLEN]; // number of matched characters in metacharacter positions
|
||
|
|
short bt = 0;
|
||
|
|
int i;
|
||
|
|
int ok;
|
||
|
|
int w = 0;
|
||
|
|
if (!*words) {
|
||
|
|
w = 1;
|
||
|
|
*words = def;
|
||
|
|
}
|
||
|
|
(*words)[wnum] = rv;
|
||
|
|
|
||
|
|
for (i = 0; i < numdefcpd; i++) {
|
||
|
|
int pp = 0; // pattern position
|
||
|
|
int wp = 0; // "words" position
|
||
|
|
int ok2;
|
||
|
|
ok = 1;
|
||
|
|
ok2 = 1;
|
||
|
|
do {
|
||
|
|
while ((pp < defcpdtable[i].len) && (wp <= wnum)) {
|
||
|
|
if (((pp+1) < defcpdtable[i].len) &&
|
||
|
|
((defcpdtable[i].def[pp+1] == '*') || (defcpdtable[i].def[pp+1] == '?'))) {
|
||
|
|
int wend = (defcpdtable[i].def[pp+1] == '?') ? wp : wnum;
|
||
|
|
ok2 = 1;
|
||
|
|
pp+=2;
|
||
|
|
btpp[bt] = pp;
|
||
|
|
btwp[bt] = wp;
|
||
|
|
while (wp <= wend) {
|
||
|
|
if (!(*words)[wp]->alen ||
|
||
|
|
!TESTAFF((*words)[wp]->astr, defcpdtable[i].def[pp-2], (*words)[wp]->alen)) {
|
||
|
|
ok2 = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
wp++;
|
||
|
|
}
|
||
|
|
if (wp <= wnum) ok2 = 0;
|
||
|
|
btnum[bt] = wp - btwp[bt];
|
||
|
|
if (btnum[bt] > 0) bt++;
|
||
|
|
if (ok2) break;
|
||
|
|
} else {
|
||
|
|
ok2 = 1;
|
||
|
|
if (!(*words)[wp] || !(*words)[wp]->alen ||
|
||
|
|
!TESTAFF((*words)[wp]->astr, defcpdtable[i].def[pp], (*words)[wp]->alen)) {
|
||
|
|
ok = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
pp++;
|
||
|
|
wp++;
|
||
|
|
if ((defcpdtable[i].len == pp) && !(wp > wnum)) ok = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (ok && ok2) {
|
||
|
|
int r = pp;
|
||
|
|
while ((defcpdtable[i].len > r) && ((r+1) < defcpdtable[i].len) &&
|
||
|
|
((defcpdtable[i].def[r+1] == '*') || (defcpdtable[i].def[r+1] == '?'))) r+=2;
|
||
|
|
if (defcpdtable[i].len <= r) return 1;
|
||
|
|
}
|
||
|
|
// backtrack
|
||
|
|
if (bt) do {
|
||
|
|
ok = 1;
|
||
|
|
btnum[bt - 1]--;
|
||
|
|
pp = btpp[bt - 1];
|
||
|
|
wp = btwp[bt - 1] + btnum[bt - 1];
|
||
|
|
} while ((btnum[bt - 1] < 0) && --bt);
|
||
|
|
} while (bt);
|
||
|
|
|
||
|
|
if (ok && ok2 && (!all || (defcpdtable[i].len <= pp))) return 1;
|
||
|
|
// check zero ending
|
||
|
|
while (ok && ok2 && (defcpdtable[i].len > pp) && ((pp+1) < defcpdtable[i].len) &&
|
||
|
|
((defcpdtable[i].def[pp+1] == '*') || (defcpdtable[i].def[pp+1] == '?'))) pp+=2;
|
||
|
|
if (ok && ok2 && (defcpdtable[i].len <= pp)) return 1;
|
||
|
|
}
|
||
|
|
(*words)[wnum] = NULL;
|
||
|
|
if (w) *words = NULL;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline int AffixMgr::candidate_check(const char * word, int len)
|
||
|
|
{
|
||
|
|
struct hentry * rv=NULL;
|
||
|
|
|
||
|
|
rv = lookup(word);
|
||
|
|
if (rv) return 1;
|
||
|
|
|
||
|
|
// rv = prefix_check(word,len,1);
|
||
|
|
// if (rv) return 1;
|
||
|
|
|
||
|
|
rv = affix_check(word,len);
|
||
|
|
if (rv) return 1;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// calculate number of syllable for compound-checking
|
||
|
|
int AffixMgr::get_syllable(const char * word, int wlen)
|
||
|
|
{
|
||
|
|
if (cpdmaxsyllable==0) return 0;
|
||
|
|
|
||
|
|
int num=0;
|
||
|
|
|
||
|
|
if (!utf8) {
|
||
|
|
for (int i=0; i<wlen; i++) {
|
||
|
|
if (strchr(cpdvowels, word[i])) num++;
|
||
|
|
}
|
||
|
|
} else if (cpdvowels_utf16) {
|
||
|
|
w_char w[MAXWORDUTF8LEN];
|
||
|
|
int i = u8_u16(w, MAXWORDUTF8LEN, word);
|
||
|
|
for (; i; i--) {
|
||
|
|
if (flag_bsearch((unsigned short *) cpdvowels_utf16,
|
||
|
|
((unsigned short *) w)[i - 1], cpdvowels_utf16_len)) num++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return num;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if compound word is correctly spelled
|
||
|
|
// hu_mov_rule = spec. Hungarian rule (XXX)
|
||
|
|
struct hentry * AffixMgr::compound_check(const char * word, int len,
|
||
|
|
short wordnum, short numsyllable, short maxwordnum, short wnum, hentry ** words = NULL,
|
||
|
|
char hu_mov_rule = 0, int * cmpdstemnum = NULL, int * cmpdstem = NULL, char is_sug = 0)
|
||
|
|
{
|
||
|
|
int i, oldnumsyllable, oldnumsyllable2, oldwordnum, oldwordnum2;
|
||
|
|
int oldcmpdstemnum = 0;
|
||
|
|
struct hentry * rv = NULL;
|
||
|
|
struct hentry * rv_first;
|
||
|
|
struct hentry * rwords[MAXWORDLEN]; // buffer for COMPOUND pattern checking
|
||
|
|
char st [MAXWORDUTF8LEN + 4];
|
||
|
|
char ch;
|
||
|
|
int cmin;
|
||
|
|
int cmax;
|
||
|
|
|
||
|
|
int checked_prefix;
|
||
|
|
|
||
|
|
#ifdef HUNSTEM
|
||
|
|
if (cmpdstemnum) {
|
||
|
|
if (wordnum == 0) {
|
||
|
|
*cmpdstemnum = 1;
|
||
|
|
} else {
|
||
|
|
(*cmpdstemnum)++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
if (utf8) {
|
||
|
|
for (cmin = 0, i = 0; (i < cpdmin) && word[cmin]; i++) {
|
||
|
|
cmin++;
|
||
|
|
for (; (word[cmin] & 0xc0) == 0x80; cmin++);
|
||
|
|
}
|
||
|
|
for (cmax = len, i = 0; (i < (cpdmin - 1)) && cmax; i++) {
|
||
|
|
cmax--;
|
||
|
|
for (; (word[cmax] & 0xc0) == 0x80; cmax--);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
cmin = cpdmin;
|
||
|
|
cmax = len - cpdmin + 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
strcpy(st, word);
|
||
|
|
|
||
|
|
for (i = cmin; i < cmax; i++) {
|
||
|
|
|
||
|
|
oldnumsyllable = numsyllable;
|
||
|
|
oldwordnum = wordnum;
|
||
|
|
checked_prefix = 0;
|
||
|
|
|
||
|
|
// go to end of the UTF-8 character
|
||
|
|
if (utf8) {
|
||
|
|
for (; (st[i] & 0xc0) == 0x80; i++);
|
||
|
|
if (i >= cmax) return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ch = st[i];
|
||
|
|
st[i] = '\0';
|
||
|
|
|
||
|
|
sfx = NULL;
|
||
|
|
pfx = NULL;
|
||
|
|
|
||
|
|
// FIRST WORD
|
||
|
|
|
||
|
|
rv = lookup(st); // perhaps without prefix
|
||
|
|
|
||
|
|
// search homonym with compound flag
|
||
|
|
while ((rv) && !hu_mov_rule &&
|
||
|
|
((pseudoroot && TESTAFF(rv->astr, pseudoroot, rv->alen)) ||
|
||
|
|
!((compoundflag && !words && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
|
||
|
|
(compoundbegin && !wordnum &&
|
||
|
|
TESTAFF(rv->astr, compoundbegin, rv->alen)) ||
|
||
|
|
(compoundmiddle && wordnum && !words &&
|
||
|
|
TESTAFF(rv->astr, compoundmiddle, rv->alen)) ||
|
||
|
|
(numdefcpd &&
|
||
|
|
((!words && !wordnum && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0)) ||
|
||
|
|
(words && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0))))
|
||
|
|
))) {
|
||
|
|
rv = rv->next_homonym;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!rv) {
|
||
|
|
if (compoundflag &&
|
||
|
|
!(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundflag))) {
|
||
|
|
if ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL,
|
||
|
|
FLAG_NULL, compoundflag, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) && !hu_mov_rule &&
|
||
|
|
((SfxEntry*)sfx)->getCont() &&
|
||
|
|
((compoundforbidflag && TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag,
|
||
|
|
((SfxEntry*)sfx)->getContLen())) || (compoundend &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundend,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
rv = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (rv ||
|
||
|
|
(((wordnum == 0) && compoundbegin &&
|
||
|
|
((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundbegin, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||
|
||
|
|
(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundbegin)))) ||
|
||
|
|
((wordnum > 0) && compoundmiddle &&
|
||
|
|
((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundmiddle, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||
|
||
|
|
(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundmiddle)))))
|
||
|
|
) checked_prefix = 1;
|
||
|
|
// else check forbiddenwords and pseudoroot
|
||
|
|
} else if (rv->astr && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
|
||
|
|
TESTAFF(rv->astr, pseudoroot, rv->alen) ||
|
||
|
|
(is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen))
|
||
|
|
)) {
|
||
|
|
st[i] = ch;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check non_compound flag in suffix and prefix
|
||
|
|
if ((rv) && !hu_mov_rule &&
|
||
|
|
((pfx && ((PfxEntry*)pfx)->getCont() &&
|
||
|
|
TESTAFF(((PfxEntry*)pfx)->getCont(), compoundforbidflag,
|
||
|
|
((PfxEntry*)pfx)->getContLen())) ||
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
rv = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check compoundend flag in suffix and prefix
|
||
|
|
if ((rv) && !checked_prefix && compoundend && !hu_mov_rule &&
|
||
|
|
((pfx && ((PfxEntry*)pfx)->getCont() &&
|
||
|
|
TESTAFF(((PfxEntry*)pfx)->getCont(), compoundend,
|
||
|
|
((PfxEntry*)pfx)->getContLen())) ||
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundend,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
rv = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check compoundmiddle flag in suffix and prefix
|
||
|
|
if ((rv) && !checked_prefix && (wordnum==0) && compoundmiddle && !hu_mov_rule &&
|
||
|
|
((pfx && ((PfxEntry*)pfx)->getCont() &&
|
||
|
|
TESTAFF(((PfxEntry*)pfx)->getCont(), compoundmiddle,
|
||
|
|
((PfxEntry*)pfx)->getContLen())) ||
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundmiddle,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
rv = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check forbiddenwords
|
||
|
|
if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
|
||
|
|
(is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// increment word number, if the second root has a compoundroot flag
|
||
|
|
if ((rv) && compoundroot &&
|
||
|
|
(TESTAFF(rv->astr, compoundroot, rv->alen))) {
|
||
|
|
wordnum++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// first word is acceptable in compound words?
|
||
|
|
if (((rv) &&
|
||
|
|
( checked_prefix || (words && words[wnum]) ||
|
||
|
|
(compoundflag && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
|
||
|
|
((oldwordnum == 0) && compoundbegin && TESTAFF(rv->astr, compoundbegin, rv->alen)) ||
|
||
|
|
((oldwordnum > 0) && compoundmiddle && TESTAFF(rv->astr, compoundmiddle, rv->alen))// ||
|
||
|
|
// (numdefcpd && )
|
||
|
|
|
||
|
|
// LANG_hu section: spec. Hungarian rule
|
||
|
|
|| ((langnum == LANG_hu) && hu_mov_rule && (
|
||
|
|
TESTAFF(rv->astr, 'F', rv->alen) || // XXX hardwired Hungarian dictionary codes
|
||
|
|
TESTAFF(rv->astr, 'G', rv->alen) ||
|
||
|
|
TESTAFF(rv->astr, 'H', rv->alen)
|
||
|
|
)
|
||
|
|
)
|
||
|
|
// END of LANG_hu section
|
||
|
|
)
|
||
|
|
&& ! (( checkcompoundtriple && // test triple letters
|
||
|
|
(word[i-1]==word[i]) && (
|
||
|
|
((i>1) && (word[i-1]==word[i-2])) ||
|
||
|
|
((word[i-1]==word[i+1])) // may be word[i+1] == '\0'
|
||
|
|
)
|
||
|
|
) ||
|
||
|
|
(
|
||
|
|
// test CHECKCOMPOUNDPATTERN
|
||
|
|
numcheckcpd && cpdpat_check(word, i)
|
||
|
|
) ||
|
||
|
|
(
|
||
|
|
checkcompoundcase && cpdcase_check(word, i)
|
||
|
|
))
|
||
|
|
)
|
||
|
|
// LANG_hu section: spec. Hungarian rule
|
||
|
|
|| ((!rv) && (langnum == LANG_hu) && hu_mov_rule && (rv = affix_check(st,i)) &&
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() && ( // XXX hardwired Hungarian dic. codes
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), (unsigned short) 'x', ((SfxEntry*)sfx)->getContLen()) ||
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), (unsigned short) '%', ((SfxEntry*)sfx)->getContLen())
|
||
|
|
)
|
||
|
|
)
|
||
|
|
)
|
||
|
|
// END of LANG_hu section
|
||
|
|
) {
|
||
|
|
|
||
|
|
// LANG_hu section: spec. Hungarian rule
|
||
|
|
if (langnum == LANG_hu) {
|
||
|
|
// calculate syllable number of the word
|
||
|
|
numsyllable += get_syllable(st, i);
|
||
|
|
|
||
|
|
// + 1 word, if syllable number of the prefix > 1 (hungarian convention)
|
||
|
|
if (pfx && (get_syllable(((PfxEntry *)pfx)->getKey(),strlen(((PfxEntry *)pfx)->getKey())) > 1)) wordnum++;
|
||
|
|
}
|
||
|
|
// END of LANG_hu section
|
||
|
|
|
||
|
|
#ifdef HUNSTEM
|
||
|
|
if (cmpdstem) cmpdstem[*cmpdstemnum - 1] = i;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// NEXT WORD(S)
|
||
|
|
rv_first = rv;
|
||
|
|
rv = lookup((word+i)); // perhaps without prefix
|
||
|
|
|
||
|
|
// search homonym with compound flag
|
||
|
|
while ((rv) && ((pseudoroot && TESTAFF(rv->astr, pseudoroot, rv->alen)) ||
|
||
|
|
!((compoundflag && !words && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
|
||
|
|
(compoundend && !words && TESTAFF(rv->astr, compoundend, rv->alen)) ||
|
||
|
|
(numdefcpd && words && defcpd_check(&words, wnum + 1, rv, NULL,1))))) {
|
||
|
|
rv = rv->next_homonym;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (rv && words && words[wnum + 1]) return rv;
|
||
|
|
|
||
|
|
oldnumsyllable2 = numsyllable;
|
||
|
|
oldwordnum2 = wordnum;
|
||
|
|
|
||
|
|
// LANG_hu section: spec. Hungarian rule, XXX hardwired dictionary code
|
||
|
|
if ((rv) && (langnum == LANG_hu) && (TESTAFF(rv->astr, 'I', rv->alen)) && !(TESTAFF(rv->astr, 'J', rv->alen))) {
|
||
|
|
numsyllable--;
|
||
|
|
}
|
||
|
|
// END of LANG_hu section
|
||
|
|
|
||
|
|
// increment word number, if the second root has a compoundroot flag
|
||
|
|
if ((rv) && (compoundroot) &&
|
||
|
|
(TESTAFF(rv->astr, compoundroot, rv->alen))) {
|
||
|
|
wordnum++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check forbiddenwords
|
||
|
|
if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
|
||
|
|
(is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) return NULL;
|
||
|
|
|
||
|
|
// second word is acceptable, as a root?
|
||
|
|
// hungarian conventions: compounding is acceptable,
|
||
|
|
// when compound forms consist of 2 words, or if more,
|
||
|
|
// then the syllable number of root words must be 6, or lesser.
|
||
|
|
|
||
|
|
if ((rv) && (
|
||
|
|
(compoundflag && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
|
||
|
|
(compoundend && TESTAFF(rv->astr, compoundend, rv->alen))
|
||
|
|
)
|
||
|
|
&& (
|
||
|
|
((cpdwordmax==0) || (wordnum+1<cpdwordmax)) ||
|
||
|
|
((cpdmaxsyllable==0) ||
|
||
|
|
(numsyllable + get_syllable(rv->word,rv->wlen)<=cpdmaxsyllable))
|
||
|
|
)
|
||
|
|
&& (
|
||
|
|
(!checkcompounddup || (rv != rv_first))
|
||
|
|
)
|
||
|
|
)
|
||
|
|
{
|
||
|
|
// forbid compound word, if it is a non compound word with typical fault
|
||
|
|
if (checkcompoundrep && cpdrep_check(word,len)) return NULL;
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
|
||
|
|
numsyllable = oldnumsyllable2 ;
|
||
|
|
wordnum = oldwordnum2;
|
||
|
|
|
||
|
|
// perhaps second word has prefix or/and suffix
|
||
|
|
sfx = NULL;
|
||
|
|
sfxflag = FLAG_NULL;
|
||
|
|
rv = (compoundflag) ? affix_check((word+i),strlen(word+i), compoundflag, IN_CPD_END) : NULL;
|
||
|
|
if (!rv && compoundend) {
|
||
|
|
sfx = NULL;
|
||
|
|
pfx = NULL;
|
||
|
|
rv = affix_check((word+i),strlen(word+i), compoundend, IN_CPD_END);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!rv && numdefcpd && words) {
|
||
|
|
rv = affix_check((word+i),strlen(word+i), 0, IN_CPD_END);
|
||
|
|
if (rv && defcpd_check(&words, wnum + 1, rv, NULL, 1)) return rv;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check non_compound flag in suffix and prefix
|
||
|
|
if ((rv) &&
|
||
|
|
((pfx && ((PfxEntry*)pfx)->getCont() &&
|
||
|
|
TESTAFF(((PfxEntry*)pfx)->getCont(), compoundforbidflag,
|
||
|
|
((PfxEntry*)pfx)->getContLen())) ||
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
rv = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check forbiddenwords
|
||
|
|
if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
|
||
|
|
(is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) return NULL;
|
||
|
|
|
||
|
|
// pfxappnd = prefix of word+i, or NULL
|
||
|
|
// calculate syllable number of prefix.
|
||
|
|
// hungarian convention: when syllable number of prefix is more,
|
||
|
|
// than 1, the prefix+word counts as two words.
|
||
|
|
|
||
|
|
if (langnum == LANG_hu) {
|
||
|
|
// calculate syllable number of the word
|
||
|
|
numsyllable += get_syllable(word + i, strlen(word + i));
|
||
|
|
|
||
|
|
// - affix syllable num.
|
||
|
|
// XXX only second suffix (inflections, not derivations)
|
||
|
|
if (sfxappnd) {
|
||
|
|
char * tmp = myrevstrdup(sfxappnd);
|
||
|
|
numsyllable -= get_syllable(tmp, strlen(tmp));
|
||
|
|
free(tmp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// + 1 word, if syllable number of the prefix > 1 (hungarian convention)
|
||
|
|
if (pfx && (get_syllable(((PfxEntry *)pfx)->getKey(),strlen(((PfxEntry *)pfx)->getKey())) > 1)) wordnum++;
|
||
|
|
|
||
|
|
// increment syllable num, if last word has a SYLLABLENUM flag
|
||
|
|
// and the suffix is beginning `s'
|
||
|
|
|
||
|
|
if (cpdsyllablenum) {
|
||
|
|
switch (sfxflag) {
|
||
|
|
case 'c': { numsyllable+=2; break; }
|
||
|
|
case 'J': { numsyllable += 1; break; }
|
||
|
|
case 'I': { if (TESTAFF(rv->astr, 'J', rv->alen)) numsyllable += 1; break; }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// increment word number, if the second word has a compoundroot flag
|
||
|
|
if ((rv) && (compoundroot) &&
|
||
|
|
(TESTAFF(rv->astr, compoundroot, rv->alen))) {
|
||
|
|
wordnum++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// second word is acceptable, as a word with prefix or/and suffix?
|
||
|
|
// hungarian conventions: compounding is acceptable,
|
||
|
|
// when compound forms consist 2 word, otherwise
|
||
|
|
// the syllable number of root words is 6, or lesser.
|
||
|
|
if ((rv) &&
|
||
|
|
(
|
||
|
|
((cpdwordmax ==0 ) || (wordnum + 1 < cpdwordmax)) ||
|
||
|
|
((cpdmaxsyllable == 0) ||
|
||
|
|
(numsyllable <= cpdmaxsyllable))
|
||
|
|
)
|
||
|
|
&& (
|
||
|
|
(!checkcompounddup || (rv != rv_first))
|
||
|
|
)) {
|
||
|
|
// forbid compound word, if it is a non compound word with typical fault
|
||
|
|
if (checkcompoundrep && cpdrep_check(word, len)) return NULL;
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
|
||
|
|
numsyllable = oldnumsyllable2;
|
||
|
|
wordnum = oldwordnum2;
|
||
|
|
#ifdef HUNSTEM
|
||
|
|
if (cmpdstemnum) oldcmpdstemnum = *cmpdstemnum;
|
||
|
|
#endif
|
||
|
|
// perhaps second word is a compound word (recursive call)
|
||
|
|
if (wordnum < maxwordnum) {
|
||
|
|
rv = compound_check((word+i),strlen(word+i), wordnum+1,
|
||
|
|
numsyllable, maxwordnum, wnum + 1, words,
|
||
|
|
0, cmpdstemnum, cmpdstem, is_sug);
|
||
|
|
} else {
|
||
|
|
rv=NULL;
|
||
|
|
}
|
||
|
|
if (rv) {
|
||
|
|
// forbid compound word, if it is a non compound word with typical fault
|
||
|
|
if (checkcompoundrep && cpdrep_check(word, len)) return NULL;
|
||
|
|
return rv;
|
||
|
|
} else {
|
||
|
|
#ifdef HUNSTEM
|
||
|
|
if (cmpdstemnum) *cmpdstemnum = oldcmpdstemnum;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
}
|
||
|
|
st[i] = ch;
|
||
|
|
wordnum = oldwordnum;
|
||
|
|
numsyllable = oldnumsyllable;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 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,
|
||
|
|
char hu_mov_rule = 0, char ** result = NULL, char * partresult = NULL)
|
||
|
|
{
|
||
|
|
int i, oldnumsyllable, oldnumsyllable2, oldwordnum, oldwordnum2;
|
||
|
|
int ok = 0;
|
||
|
|
|
||
|
|
struct hentry * rv = NULL;
|
||
|
|
struct hentry * rv_first;
|
||
|
|
struct hentry * rwords[MAXWORDLEN]; // buffer for COMPOUND pattern checking
|
||
|
|
char st [MAXWORDUTF8LEN + 4];
|
||
|
|
char ch;
|
||
|
|
|
||
|
|
int checked_prefix;
|
||
|
|
char presult[MAXLNLEN];
|
||
|
|
|
||
|
|
int cmin;
|
||
|
|
int cmax;
|
||
|
|
|
||
|
|
if (utf8) {
|
||
|
|
for (cmin = 0, i = 0; (i < cpdmin) && word[cmin]; i++) {
|
||
|
|
cmin++;
|
||
|
|
for (; (word[cmin] & 0xc0) == 0x80; cmin++);
|
||
|
|
}
|
||
|
|
for (cmax = len, i = 0; (i < (cpdmin - 1)) && cmax; i++) {
|
||
|
|
cmax--;
|
||
|
|
for (; (word[cmax] & 0xc0) == 0x80; cmax--);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
cmin = cpdmin;
|
||
|
|
cmax = len - cpdmin + 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
strcpy(st, word);
|
||
|
|
|
||
|
|
for (i = cmin; i < cmax; i++) {
|
||
|
|
oldnumsyllable = numsyllable;
|
||
|
|
oldwordnum = wordnum;
|
||
|
|
checked_prefix = 0;
|
||
|
|
|
||
|
|
// go to end of the UTF-8 character
|
||
|
|
if (utf8) {
|
||
|
|
for (; (st[i] & 0xc0) == 0x80; i++);
|
||
|
|
if (i >= cmax) return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
ch = st[i];
|
||
|
|
st[i] = '\0';
|
||
|
|
sfx = NULL;
|
||
|
|
|
||
|
|
// FIRST WORD
|
||
|
|
*presult = '\0';
|
||
|
|
if (partresult) strcat(presult, partresult);
|
||
|
|
|
||
|
|
rv = lookup(st); // perhaps without prefix
|
||
|
|
|
||
|
|
// search homonym with compound flag
|
||
|
|
while ((rv) && !hu_mov_rule &&
|
||
|
|
((pseudoroot && TESTAFF(rv->astr, pseudoroot, rv->alen)) ||
|
||
|
|
!((compoundflag && !words && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
|
||
|
|
(compoundbegin && !wordnum &&
|
||
|
|
TESTAFF(rv->astr, compoundbegin, rv->alen)) ||
|
||
|
|
(compoundmiddle && wordnum && !words &&
|
||
|
|
TESTAFF(rv->astr, compoundmiddle, rv->alen)) ||
|
||
|
|
(numdefcpd &&
|
||
|
|
((!words && !wordnum && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0)) ||
|
||
|
|
(words && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0))))
|
||
|
|
))) {
|
||
|
|
rv = rv->next_homonym;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (rv) {
|
||
|
|
if (rv->description) {
|
||
|
|
if ((!rv->astr) || !TESTAFF(rv->astr, lemma_present, rv->alen))
|
||
|
|
strcat(presult, st);
|
||
|
|
strcat(presult, rv->description);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!rv) {
|
||
|
|
if (compoundflag &&
|
||
|
|
!(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundflag))) {
|
||
|
|
if ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL,
|
||
|
|
FLAG_NULL, compoundflag, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) && !hu_mov_rule &&
|
||
|
|
((SfxEntry*)sfx)->getCont() &&
|
||
|
|
((compoundforbidflag && TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag,
|
||
|
|
((SfxEntry*)sfx)->getContLen())) || (compoundend &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundend,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
rv = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (rv ||
|
||
|
|
(((wordnum == 0) && compoundbegin &&
|
||
|
|
((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundbegin, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||
|
||
|
|
(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundbegin)))) ||
|
||
|
|
((wordnum > 0) && compoundmiddle &&
|
||
|
|
((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundmiddle, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||
|
||
|
|
(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundmiddle)))))
|
||
|
|
) {
|
||
|
|
//char * p = prefix_check_morph(st, i, 0, compound);
|
||
|
|
char * p = NULL;
|
||
|
|
if (compoundflag) p = affix_check_morph(st, i, compoundflag);
|
||
|
|
if (!p || (*p == '\0')) {
|
||
|
|
if ((wordnum == 0) && compoundbegin) {
|
||
|
|
p = affix_check_morph(st, i, compoundbegin);
|
||
|
|
} else if ((wordnum > 0) && compoundmiddle) {
|
||
|
|
p = affix_check_morph(st, i, compoundmiddle);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (*p != '\0') {
|
||
|
|
line_uniq(p);
|
||
|
|
if (strchr(p, '\n')) {
|
||
|
|
strcat(presult, "(");
|
||
|
|
strcat(presult, line_join(p, '|'));
|
||
|
|
strcat(presult, ")");
|
||
|
|
} else {
|
||
|
|
strcat(presult, p);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (presult[strlen(presult) - 1] == '\n') {
|
||
|
|
presult[strlen(presult) - 1] = '\0';
|
||
|
|
}
|
||
|
|
checked_prefix = 1;
|
||
|
|
//strcat(presult, "+");
|
||
|
|
}
|
||
|
|
// else check forbiddenwords
|
||
|
|
} else if (rv->astr && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||
|
||
|
|
TESTAFF(rv->astr, pseudoroot, rv->alen))) {
|
||
|
|
st[i] = ch;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check non_compound flag in suffix and prefix
|
||
|
|
if ((rv) && !hu_mov_rule &&
|
||
|
|
((pfx && ((PfxEntry*)pfx)->getCont() &&
|
||
|
|
TESTAFF(((PfxEntry*)pfx)->getCont(), compoundforbidflag,
|
||
|
|
((PfxEntry*)pfx)->getContLen())) ||
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check compoundend flag in suffix and prefix
|
||
|
|
if ((rv) && !checked_prefix && compoundend && !hu_mov_rule &&
|
||
|
|
((pfx && ((PfxEntry*)pfx)->getCont() &&
|
||
|
|
TESTAFF(((PfxEntry*)pfx)->getCont(), compoundend,
|
||
|
|
((PfxEntry*)pfx)->getContLen())) ||
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundend,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check compoundmiddle flag in suffix and prefix
|
||
|
|
if ((rv) && !checked_prefix && (wordnum==0) && compoundmiddle && !hu_mov_rule &&
|
||
|
|
((pfx && ((PfxEntry*)pfx)->getCont() &&
|
||
|
|
TESTAFF(((PfxEntry*)pfx)->getCont(), compoundmiddle,
|
||
|
|
((PfxEntry*)pfx)->getContLen())) ||
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundmiddle,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
rv = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check forbiddenwords
|
||
|
|
if ((rv) && (rv->astr) && TESTAFF(rv->astr, forbiddenword, rv->alen)) continue;
|
||
|
|
|
||
|
|
// increment word number, if the second root has a compoundroot flag
|
||
|
|
if ((rv) && (compoundroot) &&
|
||
|
|
(TESTAFF(rv->astr, compoundroot, rv->alen))) {
|
||
|
|
wordnum++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// first word is acceptable in compound words?
|
||
|
|
if (((rv) &&
|
||
|
|
( checked_prefix || (words && words[wnum]) ||
|
||
|
|
(compoundflag && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
|
||
|
|
((oldwordnum == 0) && compoundbegin && TESTAFF(rv->astr, compoundbegin, rv->alen)) ||
|
||
|
|
((oldwordnum > 0) && compoundmiddle && TESTAFF(rv->astr, compoundmiddle, rv->alen))
|
||
|
|
// LANG_hu section: spec. Hungarian rule
|
||
|
|
|| ((langnum == LANG_hu) && // hu_mov_rule
|
||
|
|
hu_mov_rule && (
|
||
|
|
TESTAFF(rv->astr, 'F', rv->alen) ||
|
||
|
|
TESTAFF(rv->astr, 'G', rv->alen) ||
|
||
|
|
TESTAFF(rv->astr, 'H', rv->alen)
|
||
|
|
)
|
||
|
|
)
|
||
|
|
// END of LANG_hu section
|
||
|
|
)
|
||
|
|
&& ! (( checkcompoundtriple && // test triple letters
|
||
|
|
(word[i-1]==word[i]) && (
|
||
|
|
((i>1) && (word[i-1]==word[i-2])) ||
|
||
|
|
((word[i-1]==word[i+1])) // may be word[i+1] == '\0'
|
||
|
|
)
|
||
|
|
) ||
|
||
|
|
(
|
||
|
|
// test CHECKCOMPOUNDPATTERN
|
||
|
|
numcheckcpd && cpdpat_check(word, i)
|
||
|
|
) ||
|
||
|
|
(
|
||
|
|
checkcompoundcase && cpdcase_check(word, i)
|
||
|
|
))
|
||
|
|
)
|
||
|
|
// LANG_hu section: spec. Hungarian rule
|
||
|
|
|| ((!rv) && (langnum == LANG_hu) && hu_mov_rule && (rv = affix_check(st,i)) &&
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() && (
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), (unsigned short) 'x', ((SfxEntry*)sfx)->getContLen()) ||
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), (unsigned short) '%', ((SfxEntry*)sfx)->getContLen())
|
||
|
|
)
|
||
|
|
)
|
||
|
|
)
|
||
|
|
// END of LANG_hu section
|
||
|
|
) {
|
||
|
|
|
||
|
|
// LANG_hu section: spec. Hungarian rule
|
||
|
|
if (langnum == LANG_hu) {
|
||
|
|
// calculate syllable number of the word
|
||
|
|
numsyllable += get_syllable(st, i);
|
||
|
|
|
||
|
|
// + 1 word, if syllable number of the prefix > 1 (hungarian convention)
|
||
|
|
if (pfx && (get_syllable(((PfxEntry *)pfx)->getKey(),strlen(((PfxEntry *)pfx)->getKey())) > 1)) wordnum++;
|
||
|
|
}
|
||
|
|
// END of LANG_hu section
|
||
|
|
|
||
|
|
// NEXT WORD(S)
|
||
|
|
rv_first = rv;
|
||
|
|
rv = lookup((word+i)); // perhaps without prefix
|
||
|
|
|
||
|
|
// search homonym with compound flag
|
||
|
|
while ((rv) && ((pseudoroot && TESTAFF(rv->astr, pseudoroot, rv->alen)) ||
|
||
|
|
!((compoundflag && !words && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
|
||
|
|
(compoundend && !words && TESTAFF(rv->astr, compoundend, rv->alen)) ||
|
||
|
|
(numdefcpd && defcpd_check(&words, wnum + 1, rv, NULL,1))))) {
|
||
|
|
rv = rv->next_homonym;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (rv && words && words[wnum + 1]) {
|
||
|
|
strcat(*result, presult);
|
||
|
|
if (complexprefixes && rv->description) strcat(*result, rv->description);
|
||
|
|
if (rv->description && ((!rv->astr) ||
|
||
|
|
!TESTAFF(rv->astr, lemma_present, rv->alen)))
|
||
|
|
strcat(*result, rv->word);
|
||
|
|
if (!complexprefixes && rv->description) strcat(*result, rv->description);
|
||
|
|
strcat(*result, "\n");
|
||
|
|
ok = 1;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
oldnumsyllable2 = numsyllable;
|
||
|
|
oldwordnum2 = wordnum;
|
||
|
|
|
||
|
|
// LANG_hu section: spec. Hungarian rule
|
||
|
|
if ((rv) && (langnum == LANG_hu) && (TESTAFF(rv->astr, 'I', rv->alen)) && !(TESTAFF(rv->astr, 'J', rv->alen))) {
|
||
|
|
numsyllable--;
|
||
|
|
}
|
||
|
|
// END of LANG_hu section
|
||
|
|
// increment word number, if the second root has a compoundroot flag
|
||
|
|
if ((rv) && (compoundroot) &&
|
||
|
|
(TESTAFF(rv->astr, compoundroot, rv->alen))) {
|
||
|
|
wordnum++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check forbiddenwords
|
||
|
|
if ((rv) && (rv->astr) && TESTAFF(rv->astr, forbiddenword, rv->alen)) {
|
||
|
|
st[i] = ch;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// second word is acceptable, as a root?
|
||
|
|
// hungarian conventions: compounding is acceptable,
|
||
|
|
// when compound forms consist of 2 words, or if more,
|
||
|
|
// then the syllable number of root words must be 6, or lesser.
|
||
|
|
if ((rv) && (
|
||
|
|
(compoundflag && TESTAFF(rv->astr, compoundflag, rv->alen)) ||
|
||
|
|
(compoundend && TESTAFF(rv->astr, compoundend, rv->alen))
|
||
|
|
)
|
||
|
|
&& (
|
||
|
|
((cpdwordmax==0) || (wordnum+1<cpdwordmax)) ||
|
||
|
|
((cpdmaxsyllable==0) ||
|
||
|
|
(numsyllable+get_syllable(rv->word,rv->wlen)<=cpdmaxsyllable))
|
||
|
|
)
|
||
|
|
&& (
|
||
|
|
(!checkcompounddup || (rv != rv_first))
|
||
|
|
)
|
||
|
|
)
|
||
|
|
{
|
||
|
|
// bad compound word
|
||
|
|
strcat(*result, presult);
|
||
|
|
|
||
|
|
if (rv->description) {
|
||
|
|
if (complexprefixes) strcat(*result, rv->description);
|
||
|
|
if ((!rv->astr) || !TESTAFF(rv->astr, lemma_present, rv->alen))
|
||
|
|
strcat(*result, rv->word);
|
||
|
|
if (!complexprefixes) strcat(*result, rv->description);
|
||
|
|
}
|
||
|
|
strcat(*result, "\n");
|
||
|
|
ok = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
numsyllable = oldnumsyllable2 ;
|
||
|
|
wordnum = oldwordnum2;
|
||
|
|
|
||
|
|
// perhaps second word has prefix or/and suffix
|
||
|
|
sfx = NULL;
|
||
|
|
sfxflag = FLAG_NULL;
|
||
|
|
|
||
|
|
if (compoundflag) rv = affix_check((word+i),strlen(word+i), compoundflag); else rv = NULL;
|
||
|
|
|
||
|
|
if (!rv && compoundend) {
|
||
|
|
sfx = NULL;
|
||
|
|
pfx = NULL;
|
||
|
|
rv = affix_check((word+i),strlen(word+i), compoundend);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!rv && numdefcpd && words) {
|
||
|
|
rv = affix_check((word+i),strlen(word+i), 0, IN_CPD_END);
|
||
|
|
if (rv && words && defcpd_check(&words, wnum + 1, rv, NULL, 1)) {
|
||
|
|
char * m = NULL;
|
||
|
|
if (compoundflag) m = affix_check_morph((word+i),strlen(word+i), compoundflag);
|
||
|
|
if ((!m || *m == '\0') && compoundend)
|
||
|
|
m = affix_check_morph((word+i),strlen(word+i), compoundend);
|
||
|
|
strcat(*result, presult);
|
||
|
|
line_uniq(m);
|
||
|
|
if (strchr(m, '\n')) {
|
||
|
|
strcat(*result, "(");
|
||
|
|
strcat(*result, line_join(m, '|'));
|
||
|
|
strcat(*result, ")");
|
||
|
|
} else {
|
||
|
|
strcat(*result, m);
|
||
|
|
}
|
||
|
|
free(m);
|
||
|
|
strcat(*result, "\n");
|
||
|
|
ok = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// check non_compound flag in suffix and prefix
|
||
|
|
if ((rv) &&
|
||
|
|
((pfx && ((PfxEntry*)pfx)->getCont() &&
|
||
|
|
TESTAFF(((PfxEntry*)pfx)->getCont(), compoundforbidflag,
|
||
|
|
((PfxEntry*)pfx)->getContLen())) ||
|
||
|
|
(sfx && ((SfxEntry*)sfx)->getCont() &&
|
||
|
|
TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag,
|
||
|
|
((SfxEntry*)sfx)->getContLen())))) {
|
||
|
|
rv = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check forbiddenwords
|
||
|
|
if ((rv) && (rv->astr) && (TESTAFF(rv->astr,forbiddenword,rv->alen))
|
||
|
|
&& (! TESTAFF(rv->astr, pseudoroot, rv->alen))) {
|
||
|
|
st[i] = ch;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (langnum == LANG_hu) {
|
||
|
|
// calculate syllable number of the word
|
||
|
|
numsyllable += get_syllable(word + i, strlen(word + i));
|
||
|
|
|
||
|
|
// - affix syllable num.
|
||
|
|
// XXX only second suffix (inflections, not derivations)
|
||
|
|
if (sfxappnd) {
|
||
|
|
char * tmp = myrevstrdup(sfxappnd);
|
||
|
|
numsyllable -= get_syllable(tmp, strlen(tmp));
|
||
|
|
free(tmp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// + 1 word, if syllable number of the prefix > 1 (hungarian convention)
|
||
|
|
if (pfx && (get_syllable(((PfxEntry *)pfx)->getKey(),strlen(((PfxEntry *)pfx)->getKey())) > 1)) wordnum++;
|
||
|
|
|
||
|
|
// increment syllable num, if last word has a SYLLABLENUM flag
|
||
|
|
// and the suffix is beginning `s'
|
||
|
|
|
||
|
|
if (cpdsyllablenum) {
|
||
|
|
switch (sfxflag) {
|
||
|
|
case 'c': { numsyllable+=2; break; }
|
||
|
|
case 'J': { numsyllable += 1; break; }
|
||
|
|
case 'I': { if (rv && TESTAFF(rv->astr, 'J', rv->alen)) numsyllable += 1; break; }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// increment word number, if the second word has a compoundroot flag
|
||
|
|
if ((rv) && (compoundroot) &&
|
||
|
|
(TESTAFF(rv->astr, compoundroot, rv->alen))) {
|
||
|
|
wordnum++;
|
||
|
|
}
|
||
|
|
// second word is acceptable, as a word with prefix or/and suffix?
|
||
|
|
// hungarian conventions: compounding is acceptable,
|
||
|
|
// when compound forms consist 2 word, otherwise
|
||
|
|
// the syllable number of root words is 6, or lesser.
|
||
|
|
if ((rv) &&
|
||
|
|
(
|
||
|
|
((cpdwordmax==0) || (wordnum+1<cpdwordmax)) ||
|
||
|
|
((cpdmaxsyllable==0) ||
|
||
|
|
(numsyllable <= cpdmaxsyllable))
|
||
|
|
)
|
||
|
|
&& (
|
||
|
|
(!checkcompounddup || (rv != rv_first))
|
||
|
|
)) {
|
||
|
|
char * m = NULL;
|
||
|
|
if (compoundflag) m = affix_check_morph((word+i),strlen(word+i), compoundflag);
|
||
|
|
if ((!m || *m == '\0') && compoundend)
|
||
|
|
m = affix_check_morph((word+i),strlen(word+i), compoundend);
|
||
|
|
strcat(*result, presult);
|
||
|
|
line_uniq(m);
|
||
|
|
if (strchr(m, '\n')) {
|
||
|
|
strcat(*result, "(");
|
||
|
|
strcat(*result, line_join(m, '|'));
|
||
|
|
strcat(*result, ")");
|
||
|
|
} else {
|
||
|
|
strcat(*result, m);
|
||
|
|
}
|
||
|
|
free(m);
|
||
|
|
strcat(*result, "\n");
|
||
|
|
ok = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
numsyllable = oldnumsyllable2;
|
||
|
|
wordnum = oldwordnum2;
|
||
|
|
|
||
|
|
// perhaps second word is a compound word (recursive call)
|
||
|
|
if ((wordnum < maxwordnum) && (ok == 0)) {
|
||
|
|
compound_check_morph((word+i),strlen(word+i), wordnum+1,
|
||
|
|
numsyllable, maxwordnum, wnum + 1, words, 0, result, presult);
|
||
|
|
} else {
|
||
|
|
rv=NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
st[i] = ch;
|
||
|
|
wordnum = oldwordnum;
|
||
|
|
numsyllable = oldnumsyllable;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return 1 if s1 (reversed) is a leading subset of end of s2
|
||
|
|
inline int AffixMgr::isRevSubset(const char * s1, const char * end_of_s2, int len)
|
||
|
|
{
|
||
|
|
while ((len > 0) && *s1 && (*s1 == *end_of_s2)) {
|
||
|
|
s1++;
|
||
|
|
end_of_s2--;
|
||
|
|
len--;
|
||
|
|
}
|
||
|
|
return (*s1 == '\0');
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// check word for suffixes
|
||
|
|
|
||
|
|
struct hentry * AffixMgr::suffix_check (const char * word, int len,
|
||
|
|
int sfxopts, AffEntry * ppfx, char ** wlst, int maxSug, int * ns,
|
||
|
|
const FLAG cclass, const FLAG needflag, char in_compound)
|
||
|
|
{
|
||
|
|
struct hentry * rv = NULL;
|
||
|
|
char result[MAXLNLEN];
|
||
|
|
|
||
|
|
PfxEntry* ep = (PfxEntry *) ppfx;
|
||
|
|
|
||
|
|
// first handle the special case of 0 length suffixes
|
||
|
|
SfxEntry * se = (SfxEntry *) sStart[0];
|
||
|
|
|
||
|
|
while (se) {
|
||
|
|
if (!cclass || se->getCont()) {
|
||
|
|
// suffixes are not allowed in beginning of compounds
|
||
|
|
if (((((in_compound != IN_CPD_BEGIN)) || // && !cclass
|
||
|
|
// except when signed with compoundpermitflag flag
|
||
|
|
(se->getCont() && compoundpermitflag &&
|
||
|
|
TESTAFF(se->getCont(),compoundpermitflag,se->getContLen()))) && (!circumfix ||
|
||
|
|
// no circumfix flag in prefix and suffix
|
||
|
|
((!ppfx || !(ep->getCont()) || !TESTAFF(ep->getCont(),
|
||
|
|
circumfix, ep->getContLen())) &&
|
||
|
|
(!se->getCont() || !(TESTAFF(se->getCont(),circumfix,se->getContLen())))) ||
|
||
|
|
// circumfix flag in prefix AND suffix
|
||
|
|
((ppfx && (ep->getCont()) && TESTAFF(ep->getCont(),
|
||
|
|
circumfix, ep->getContLen())) &&
|
||
|
|
(se->getCont() && (TESTAFF(se->getCont(),circumfix,se->getContLen()))))) &&
|
||
|
|
// fogemorpheme
|
||
|
|
(in_compound ||
|
||
|
|
!((se->getCont() && (TESTAFF(se->getCont(), onlyincompound, se->getContLen()))))) &&
|
||
|
|
// pseudoroot on prefix or first suffix
|
||
|
|
(cclass ||
|
||
|
|
!(se->getCont() && TESTAFF(se->getCont(), pseudoroot, se->getContLen())) ||
|
||
|
|
(ppfx && !((ep->getCont()) &&
|
||
|
|
TESTAFF(ep->getCont(), pseudoroot,
|
||
|
|
ep->getContLen())))
|
||
|
|
)
|
||
|
|
) &&
|
||
|
|
(rv = se->check(word,len, sfxopts, ppfx, wlst, maxSug, ns, (FLAG) cclass, needflag))) {
|
||
|
|
sfx=(AffEntry *)se; // BUG: sfx not stateless
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
se = se->getNext();
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the general case
|
||
|
|
unsigned char sp = *((const unsigned char *)(word + len - 1));
|
||
|
|
SfxEntry * sptr = (SfxEntry *) sStart[sp];
|
||
|
|
|
||
|
|
while (sptr) {
|
||
|
|
if (isRevSubset(sptr->getKey(), word + len - 1, len)
|
||
|
|
) {
|
||
|
|
// suffixes are not allowed in beginning of compounds
|
||
|
|
if (((((in_compound != IN_CPD_BEGIN)) || // && !cclass
|
||
|
|
// except when signed with compoundpermitflag flag
|
||
|
|
(sptr->getCont() && compoundpermitflag &&
|
||
|
|
TESTAFF(sptr->getCont(),compoundpermitflag,sptr->getContLen()))) && (!circumfix ||
|
||
|
|
// no circumfix flag in prefix and suffix
|
||
|
|
((!ppfx || !(ep->getCont()) || !TESTAFF(ep->getCont(),
|
||
|
|
circumfix, ep->getContLen())) &&
|
||
|
|
(!sptr->getCont() || !(TESTAFF(sptr->getCont(),circumfix,sptr->getContLen())))) ||
|
||
|
|
// circumfix flag in prefix AND suffix
|
||
|
|
((ppfx && (ep->getCont()) && TESTAFF(ep->getCont(),
|
||
|
|
circumfix, ep->getContLen())) &&
|
||
|
|
(sptr->getCont() && (TESTAFF(sptr->getCont(),circumfix,sptr->getContLen()))))) &&
|
||
|
|
// fogemorpheme
|
||
|
|
(in_compound ||
|
||
|
|
!((sptr->getCont() && (TESTAFF(sptr->getCont(), onlyincompound, sptr->getContLen()))))) &&
|
||
|
|
// pseudoroot on prefix or first suffix
|
||
|
|
(cclass ||
|
||
|
|
!(sptr->getCont() && TESTAFF(sptr->getCont(), pseudoroot, sptr->getContLen())) ||
|
||
|
|
(ppfx && !((ep->getCont()) &&
|
||
|
|
TESTAFF(ep->getCont(), pseudoroot,
|
||
|
|
ep->getContLen())))
|
||
|
|
)
|
||
|
|
) &&
|
||
|
|
(rv = sptr->check(word,len, sfxopts, ppfx, wlst, maxSug, ns, cclass, needflag))) {
|
||
|
|
sfx=(AffEntry *)sptr; // BUG: sfx not stateless
|
||
|
|
sfxflag = sptr->getFlag(); // BUG: sfxflag not stateless
|
||
|
|
if (!sptr->getCont()) sfxappnd=sptr->getKey(); // BUG: sfxappnd not stateless
|
||
|
|
if (cclass || sptr->getCont()) {
|
||
|
|
if (!derived) {
|
||
|
|
derived = mystrdup(word);
|
||
|
|
} else {
|
||
|
|
strcpy(result, derived); // XXX check size
|
||
|
|
strcat(result, "\n");
|
||
|
|
strcat(result, word);
|
||
|
|
free(derived);
|
||
|
|
derived = mystrdup(result);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
sptr = sptr->getNextEQ();
|
||
|
|
} else {
|
||
|
|
sptr = sptr->getNextNE();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check word for two-level suffixes
|
||
|
|
|
||
|
|
struct hentry * AffixMgr::suffix_check_twosfx(const char * word, int len,
|
||
|
|
int sfxopts, AffEntry * ppfx, const FLAG needflag)
|
||
|
|
{
|
||
|
|
struct hentry * rv = NULL;
|
||
|
|
|
||
|
|
// first handle the special case of 0 length suffixes
|
||
|
|
SfxEntry * se = (SfxEntry *) sStart[0];
|
||
|
|
while (se) {
|
||
|
|
if (contclasses[se->getFlag()])
|
||
|
|
{
|
||
|
|
rv = se->check_twosfx(word,len, sfxopts, ppfx, needflag);
|
||
|
|
if (rv) return rv;
|
||
|
|
}
|
||
|
|
se = se->getNext();
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the general case
|
||
|
|
unsigned char sp = *((const unsigned char *)(word + len - 1));
|
||
|
|
SfxEntry * sptr = (SfxEntry *) sStart[sp];
|
||
|
|
|
||
|
|
while (sptr) {
|
||
|
|
if (isRevSubset(sptr->getKey(), word + len - 1, len)) {
|
||
|
|
if (contclasses[sptr->getFlag()])
|
||
|
|
{
|
||
|
|
rv = sptr->check_twosfx(word,len, sfxopts, ppfx, needflag);
|
||
|
|
if (rv) {
|
||
|
|
sfxflag = sptr->getFlag(); // BUG: sfxflag not stateless
|
||
|
|
if (!sptr->getCont()) sfxappnd=sptr->getKey(); // BUG: sfxappnd not stateless
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
sptr = sptr->getNextEQ();
|
||
|
|
} else {
|
||
|
|
sptr = sptr->getNextNE();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
char * AffixMgr::suffix_check_twosfx_morph(const char * word, int len,
|
||
|
|
int sfxopts, AffEntry * ppfx, const FLAG needflag)
|
||
|
|
{
|
||
|
|
char result[MAXLNLEN];
|
||
|
|
char result2[MAXLNLEN];
|
||
|
|
char result3[MAXLNLEN];
|
||
|
|
|
||
|
|
char * st;
|
||
|
|
|
||
|
|
result[0] = '\0';
|
||
|
|
result2[0] = '\0';
|
||
|
|
result3[0] = '\0';
|
||
|
|
|
||
|
|
// first handle the special case of 0 length suffixes
|
||
|
|
SfxEntry * se = (SfxEntry *) sStart[0];
|
||
|
|
while (se) {
|
||
|
|
if (contclasses[se->getFlag()])
|
||
|
|
{
|
||
|
|
st = se->check_twosfx_morph(word,len, sfxopts, ppfx, needflag);
|
||
|
|
if (st) {
|
||
|
|
if (ppfx) {
|
||
|
|
if (((PfxEntry *) ppfx)->getMorph()) strcat(result, ((PfxEntry *) ppfx)->getMorph());
|
||
|
|
}
|
||
|
|
strcat(result, st);
|
||
|
|
free(st);
|
||
|
|
if (se->getMorph()) strcat(result, se->getMorph());
|
||
|
|
strcat(result, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
se = se->getNext();
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the general case
|
||
|
|
unsigned char sp = *((const unsigned char *)(word + len - 1));
|
||
|
|
SfxEntry * sptr = (SfxEntry *) sStart[sp];
|
||
|
|
|
||
|
|
while (sptr) {
|
||
|
|
if (isRevSubset(sptr->getKey(), word + len - 1, len)) {
|
||
|
|
if (contclasses[sptr->getFlag()])
|
||
|
|
{
|
||
|
|
st = sptr->check_twosfx_morph(word,len, sfxopts, ppfx, needflag);
|
||
|
|
if (st) {
|
||
|
|
sfxflag = sptr->getFlag(); // BUG: sfxflag not stateless
|
||
|
|
if (!sptr->getCont()) sfxappnd=sptr->getKey(); // BUG: sfxappnd not stateless
|
||
|
|
strcpy(result2, st);
|
||
|
|
free(st);
|
||
|
|
|
||
|
|
result3[0] = '\0';
|
||
|
|
#ifdef DEBUG
|
||
|
|
unsigned short flag = sptr->getFlag();
|
||
|
|
char flagch[2] = &flag;
|
||
|
|
if (flag_mode == FLAG_NUM) {
|
||
|
|
sprintf(result3, "%d", sptr->getKey());
|
||
|
|
} else if (flag_mode == FLAG_LONG) {
|
||
|
|
sprintf(result3, "%c%c", flagch[0], flagch[1]);
|
||
|
|
} else sprintf(result3, "%c", flagch[1]);
|
||
|
|
strcat(result3, ":");
|
||
|
|
#endif
|
||
|
|
if (sptr->getMorph()) strcat(result3, sptr->getMorph());
|
||
|
|
strlinecat(result2, result3);
|
||
|
|
strcat(result2, "\n");
|
||
|
|
strcat(result, result2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
sptr = sptr->getNextEQ();
|
||
|
|
} else {
|
||
|
|
sptr = sptr->getNextNE();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (result) return mystrdup(result);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
char * AffixMgr::suffix_check_morph(const char * word, int len,
|
||
|
|
int sfxopts, AffEntry * ppfx, const FLAG cclass, const FLAG needflag, char in_compound)
|
||
|
|
{
|
||
|
|
char result[MAXLNLEN];
|
||
|
|
|
||
|
|
struct hentry * rv = NULL;
|
||
|
|
|
||
|
|
result[0] = '\0';
|
||
|
|
|
||
|
|
PfxEntry* ep = (PfxEntry *) ppfx;
|
||
|
|
|
||
|
|
// first handle the special case of 0 length suffixes
|
||
|
|
SfxEntry * se = (SfxEntry *) sStart[0];
|
||
|
|
while (se) {
|
||
|
|
if (!cclass || se->getCont()) {
|
||
|
|
// suffixes are not allowed in beginning of compounds
|
||
|
|
if (((((in_compound != IN_CPD_BEGIN)) || // && !cclass
|
||
|
|
// except when signed with compoundpermitflag flag
|
||
|
|
(se->getCont() && compoundpermitflag &&
|
||
|
|
TESTAFF(se->getCont(),compoundpermitflag,se->getContLen()))) && (!circumfix ||
|
||
|
|
// no circumfix flag in prefix and suffix
|
||
|
|
((!ppfx || !(ep->getCont()) || !TESTAFF(ep->getCont(),
|
||
|
|
circumfix, ep->getContLen())) &&
|
||
|
|
(!se->getCont() || !(TESTAFF(se->getCont(),circumfix,se->getContLen())))) ||
|
||
|
|
// circumfix flag in prefix AND suffix
|
||
|
|
((ppfx && (ep->getCont()) && TESTAFF(ep->getCont(),
|
||
|
|
circumfix, ep->getContLen())) &&
|
||
|
|
(se->getCont() && (TESTAFF(se->getCont(),circumfix,se->getContLen()))))) &&
|
||
|
|
// fogemorpheme
|
||
|
|
(in_compound ||
|
||
|
|
!((se->getCont() && (TESTAFF(se->getCont(), onlyincompound, se->getContLen()))))) &&
|
||
|
|
// pseudoroot on prefix or first suffix
|
||
|
|
(cclass ||
|
||
|
|
!(se->getCont() && TESTAFF(se->getCont(), pseudoroot, se->getContLen())) ||
|
||
|
|
(ppfx && !((ep->getCont()) &&
|
||
|
|
TESTAFF(ep->getCont(), pseudoroot,
|
||
|
|
ep->getContLen())))
|
||
|
|
)
|
||
|
|
))
|
||
|
|
rv = se->check(word,len, sfxopts, ppfx, NULL, 0, 0, cclass, needflag);
|
||
|
|
while (rv) {
|
||
|
|
if (ppfx) {
|
||
|
|
if (((PfxEntry *) ppfx)->getMorph()) strcat(result, ((PfxEntry *) ppfx)->getMorph());
|
||
|
|
}
|
||
|
|
if (complexprefixes && rv->description) strcat(result, rv->description);
|
||
|
|
if (rv->description && ((!rv->astr) ||
|
||
|
|
!TESTAFF(rv->astr, lemma_present, rv->alen)))
|
||
|
|
strcat(result, rv->word);
|
||
|
|
if (!complexprefixes && rv->description) strcat(result, rv->description);
|
||
|
|
if (se->getMorph()) strcat(result, se->getMorph());
|
||
|
|
strcat(result, "\n");
|
||
|
|
rv = se->get_next_homonym(rv, sfxopts, ppfx, cclass, needflag);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
se = se->getNext();
|
||
|
|
}
|
||
|
|
|
||
|
|
// now handle the general case
|
||
|
|
unsigned char sp = *((const unsigned char *)(word + len - 1));
|
||
|
|
SfxEntry * sptr = (SfxEntry *) sStart[sp];
|
||
|
|
|
||
|
|
while (sptr) {
|
||
|
|
if (isRevSubset(sptr->getKey(), word + len - 1, len)
|
||
|
|
) {
|
||
|
|
// suffixes are not allowed in beginning of compounds
|
||
|
|
if (((((in_compound != IN_CPD_BEGIN)) || // && !cclass
|
||
|
|
// except when signed with compoundpermitflag flag
|
||
|
|
(sptr->getCont() && compoundpermitflag &&
|
||
|
|
TESTAFF(sptr->getCont(),compoundpermitflag,sptr->getContLen()))) && (!circumfix ||
|
||
|
|
// no circumfix flag in prefix and suffix
|
||
|
|
((!ppfx || !(ep->getCont()) || !TESTAFF(ep->getCont(),
|
||
|
|
circumfix, ep->getContLen())) &&
|
||
|
|
(!sptr->getCont() || !(TESTAFF(sptr->getCont(),circumfix,sptr->getContLen())))) ||
|
||
|
|
// circumfix flag in prefix AND suffix
|
||
|
|
((ppfx && (ep->getCont()) && TESTAFF(ep->getCont(),
|
||
|
|
circumfix, ep->getContLen())) &&
|
||
|
|
(sptr->getCont() && (TESTAFF(sptr->getCont(),circumfix,sptr->getContLen()))))) &&
|
||
|
|
// fogemorpheme
|
||
|
|
(in_compound ||
|
||
|
|
!((sptr->getCont() && (TESTAFF(sptr->getCont(), onlyincompound, sptr->getContLen()))))) &&
|
||
|
|
// pseudoroot on first suffix
|
||
|
|
(cclass || !(sptr->getCont() &&
|
||
|
|
TESTAFF(sptr->getCont(), pseudoroot, sptr->getContLen())))
|
||
|
|
)) rv = sptr->check(word,len, sfxopts, ppfx, NULL, 0, 0, cclass, needflag);
|
||
|
|
while (rv) {
|
||
|
|
if (ppfx) {
|
||
|
|
if (((PfxEntry *) ppfx)->getMorph()) strcat(result, ((PfxEntry *) ppfx)->getMorph());
|
||
|
|
}
|
||
|
|
if (complexprefixes && rv->description) strcat(result, rv->description);
|
||
|
|
if (rv->description && ((!rv->astr) ||
|
||
|
|
!TESTAFF(rv->astr, lemma_present, rv->alen))) strcat(result, rv->word);
|
||
|
|
if (!complexprefixes && rv->description) strcat(result, rv->description);
|
||
|
|
#ifdef DEBUG
|
||
|
|
unsigned short flag = sptr->getKey();
|
||
|
|
char flagch[2] = &flag;
|
||
|
|
if (flag_mode == FLAG_NUM) {
|
||
|
|
sprintf(result2, "%d", sptr->getKey());
|
||
|
|
} else if (flag_mode == FLAG_LONG) {
|
||
|
|
sprintf(result2, "%c%c", flagch[0], flagch[1]);
|
||
|
|
} else sprintf(result2, "%c", flagch[1]);
|
||
|
|
strcat(result2, ":");
|
||
|
|
strcat(result, result2);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
if (sptr->getMorph()) strcat(result, sptr->getMorph());
|
||
|
|
strcat(result, "\n");
|
||
|
|
rv = sptr->get_next_homonym(rv, sfxopts, ppfx, cclass, needflag);
|
||
|
|
}
|
||
|
|
sptr = sptr->getNextEQ();
|
||
|
|
} else {
|
||
|
|
sptr = sptr->getNextNE();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*result) return mystrdup(result);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// check if word with affixes is correctly spelled
|
||
|
|
struct hentry * AffixMgr::affix_check (const char * word, int len, const FLAG needflag, char in_compound)
|
||
|
|
{
|
||
|
|
struct hentry * rv= NULL;
|
||
|
|
if (derived) free(derived);
|
||
|
|
derived = NULL;
|
||
|
|
|
||
|
|
// check all prefixes (also crossed with suffixes if allowed)
|
||
|
|
rv = prefix_check(word, len, in_compound, needflag);
|
||
|
|
if (rv) return rv;
|
||
|
|
|
||
|
|
// if still not found check all suffixes
|
||
|
|
rv = suffix_check(word, len, 0, NULL, NULL, 0, NULL, FLAG_NULL, needflag, in_compound);
|
||
|
|
|
||
|
|
if (havecontclass) {
|
||
|
|
sfx = NULL;
|
||
|
|
pfx = NULL;
|
||
|
|
if (rv) return rv;
|
||
|
|
// if still not found check all two-level suffixes
|
||
|
|
rv = suffix_check_twosfx(word, len, 0, NULL, needflag);
|
||
|
|
if (rv) return rv;
|
||
|
|
// if still not found check all two-level suffixes
|
||
|
|
rv = prefix_check_twosfx(word, len, IN_CPD_NOT, needflag);
|
||
|
|
}
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// check if word with affixes is correctly spelled
|
||
|
|
char * AffixMgr::affix_check_morph(const char * word, int len, const FLAG needflag, char in_compound)
|
||
|
|
{
|
||
|
|
char result[MAXLNLEN];
|
||
|
|
char * st = NULL;
|
||
|
|
|
||
|
|
*result = '\0';
|
||
|
|
|
||
|
|
// check all prefixes (also crossed with suffixes if allowed)
|
||
|
|
st = prefix_check_morph(word, len, in_compound);
|
||
|
|
if (st) {
|
||
|
|
strcat(result, st);
|
||
|
|
free(st);
|
||
|
|
}
|
||
|
|
|
||
|
|
// if still not found check all suffixes
|
||
|
|
st = suffix_check_morph(word, len, 0, NULL, '\0', needflag, in_compound);
|
||
|
|
if (st) {
|
||
|
|
strcat(result, st);
|
||
|
|
free(st);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (havecontclass) {
|
||
|
|
sfx = NULL;
|
||
|
|
pfx = NULL;
|
||
|
|
// if still not found check all two-level suffixes
|
||
|
|
st = suffix_check_twosfx_morph(word, len, 0, NULL, needflag);
|
||
|
|
if (st) {
|
||
|
|
strcat(result, st);
|
||
|
|
free(st);
|
||
|
|
}
|
||
|
|
|
||
|
|
// if still not found check all two-level suffixes
|
||
|
|
st = prefix_check_twosfx_morph(word, len, IN_CPD_NOT, needflag);
|
||
|
|
if (st) {
|
||
|
|
strcat(result, st);
|
||
|
|
free(st);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return mystrdup(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int AffixMgr::expand_rootword(struct guessword * wlst, int maxn, const char * ts,
|
||
|
|
int wl, const unsigned short * ap, unsigned short al, char * bad, int badl)
|
||
|
|
{
|
||
|
|
|
||
|
|
int nh=0;
|
||
|
|
|
||
|
|
// first add root word to list
|
||
|
|
if ((nh < maxn) && !(al && ((pseudoroot && TESTAFF(ap, pseudoroot, al)) ||
|
||
|
|
(onlyincompound && TESTAFF(ap, onlyincompound, al))))) {
|
||
|
|
wlst[nh].word = mystrdup(ts);
|
||
|
|
wlst[nh].allow = (1 == 0);
|
||
|
|
nh++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// handle suffixes
|
||
|
|
for (int i = 0; i < al; i++) {
|
||
|
|
unsigned short c = (unsigned short) ap[i];
|
||
|
|
SfxEntry * sptr = (SfxEntry *)sFlag[c];
|
||
|
|
while (sptr) {
|
||
|
|
if (!sptr->getKeyLen() || ((badl > sptr->getKeyLen()) &&
|
||
|
|
(strcmp(sptr->getAffix(), bad + badl - sptr->getKeyLen()) == 0)) &&
|
||
|
|
// check pseudoroot flag
|
||
|
|
!(sptr->getCont() && ((pseudoroot &&
|
||
|
|
TESTAFF(sptr->getCont(), pseudoroot, sptr->getContLen())) ||
|
||
|
|
(onlyincompound &&
|
||
|
|
TESTAFF(sptr->getCont(), onlyincompound, sptr->getContLen()))))
|
||
|
|
) {
|
||
|
|
char * newword = sptr->add(ts, wl);
|
||
|
|
if (newword) {
|
||
|
|
if (nh < maxn) {
|
||
|
|
wlst[nh].word = newword;
|
||
|
|
wlst[nh].allow = sptr->allowCross();
|
||
|
|
nh++;
|
||
|
|
} else {
|
||
|
|
free(newword);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
sptr = (SfxEntry *)sptr ->getFlgNxt();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int n = nh;
|
||
|
|
|
||
|
|
// handle cross products of prefixes and suffixes
|
||
|
|
for (int j=1;j<n ;j++)
|
||
|
|
if (wlst[j].allow) {
|
||
|
|
for (int k = 0; k < al; k++) {
|
||
|
|
unsigned short c = (unsigned short) ap[k];
|
||
|
|
PfxEntry * cptr = (PfxEntry *) pFlag[c];
|
||
|
|
while (cptr) {
|
||
|
|
if (cptr->allowCross() && (!cptr->getKeyLen() || ((badl > cptr->getKeyLen()) &&
|
||
|
|
(strncmp(cptr->getKey(), bad, cptr->getKeyLen()) == 0)))) {
|
||
|
|
int l1 = strlen(wlst[j].word);
|
||
|
|
char * newword = cptr->add(wlst[j].word, l1);
|
||
|
|
if (newword) {
|
||
|
|
if (nh < maxn) {
|
||
|
|
wlst[nh].word = newword;
|
||
|
|
wlst[nh].allow = cptr->allowCross();
|
||
|
|
nh++;
|
||
|
|
} else {
|
||
|
|
free(newword);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cptr = (PfxEntry *)cptr ->getFlgNxt();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// now handle pure prefixes
|
||
|
|
for (int m = 0; m < al; m ++) {
|
||
|
|
unsigned short c = (unsigned short) ap[m];
|
||
|
|
PfxEntry * ptr = (PfxEntry *) pFlag[c];
|
||
|
|
while (ptr) {
|
||
|
|
if (!ptr->getKeyLen() || ((badl > ptr->getKeyLen()) &&
|
||
|
|
(strncmp(ptr->getKey(), bad, ptr->getKeyLen()) == 0)) &&
|
||
|
|
// check pseudoroot flag
|
||
|
|
!(ptr->getCont() && ((pseudoroot &&
|
||
|
|
TESTAFF(ptr->getCont(), pseudoroot, ptr->getContLen())) ||
|
||
|
|
(onlyincompound &&
|
||
|
|
TESTAFF(ptr->getCont(), onlyincompound, ptr->getContLen()))))
|
||
|
|
) {
|
||
|
|
char * newword = ptr->add(ts, wl);
|
||
|
|
if (newword) {
|
||
|
|
if (nh < maxn) {
|
||
|
|
wlst[nh].word = newword;
|
||
|
|
wlst[nh].allow = ptr->allowCross();
|
||
|
|
nh++;
|
||
|
|
} else {
|
||
|
|
free(newword);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ptr = (PfxEntry *)ptr ->getFlgNxt();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return nh;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// return length of replacing table
|
||
|
|
int AffixMgr::get_numrep()
|
||
|
|
{
|
||
|
|
return numrep;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return replacing table
|
||
|
|
struct replentry * AffixMgr::get_reptable()
|
||
|
|
{
|
||
|
|
if (! reptable ) return NULL;
|
||
|
|
return reptable;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return length of character map table
|
||
|
|
int AffixMgr::get_nummap()
|
||
|
|
{
|
||
|
|
return nummap;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return character map table
|
||
|
|
struct mapentry * AffixMgr::get_maptable()
|
||
|
|
{
|
||
|
|
if (! maptable ) return NULL;
|
||
|
|
return maptable;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return length of word break table
|
||
|
|
int AffixMgr::get_numbreak()
|
||
|
|
{
|
||
|
|
return numbreak;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return character map table
|
||
|
|
char ** AffixMgr::get_breaktable()
|
||
|
|
{
|
||
|
|
if (! breaktable ) return NULL;
|
||
|
|
return breaktable;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return text encoding of dictionary
|
||
|
|
char * AffixMgr::get_encoding()
|
||
|
|
{
|
||
|
|
if (! encoding ) {
|
||
|
|
encoding = mystrdup("ISO8859-1");
|
||
|
|
}
|
||
|
|
return mystrdup(encoding);
|
||
|
|
}
|
||
|
|
|
||
|
|
// return text encoding of dictionary
|
||
|
|
int AffixMgr::get_langnum()
|
||
|
|
{
|
||
|
|
return langnum;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return UTF info table
|
||
|
|
struct unicode_info2 * AffixMgr::get_utf_conv()
|
||
|
|
{
|
||
|
|
return utf_tbl;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return double prefix option
|
||
|
|
int AffixMgr::get_complexprefixes()
|
||
|
|
{
|
||
|
|
return complexprefixes;
|
||
|
|
}
|
||
|
|
|
||
|
|
FLAG AffixMgr::get_keepcase()
|
||
|
|
{
|
||
|
|
return keepcase;
|
||
|
|
}
|
||
|
|
|
||
|
|
int AffixMgr::get_checksharps()
|
||
|
|
{
|
||
|
|
return checksharps;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the preferred try string for suggestions
|
||
|
|
char * AffixMgr::get_try_string()
|
||
|
|
{
|
||
|
|
if (! trystring ) return NULL;
|
||
|
|
return mystrdup(trystring);
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the preferred try string for suggestions
|
||
|
|
const char * AffixMgr::get_wordchars()
|
||
|
|
{
|
||
|
|
return wordchars;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned short * AffixMgr::get_wordchars_utf16(int * len)
|
||
|
|
{
|
||
|
|
*len = wordchars_utf16_len;
|
||
|
|
return wordchars_utf16;
|
||
|
|
}
|
||
|
|
|
||
|
|
// is there compounding?
|
||
|
|
int AffixMgr::get_compound()
|
||
|
|
{
|
||
|
|
return compoundflag || compoundbegin || numdefcpd;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the compound words control flag
|
||
|
|
FLAG AffixMgr::get_compoundflag()
|
||
|
|
{
|
||
|
|
return compoundflag;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the forbidden words control flag
|
||
|
|
FLAG AffixMgr::get_forbiddenword()
|
||
|
|
{
|
||
|
|
return forbiddenword;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the forbidden words control flag
|
||
|
|
FLAG AffixMgr::get_nosuggest()
|
||
|
|
{
|
||
|
|
return nosuggest;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the forbidden words flag modify flag
|
||
|
|
FLAG AffixMgr::get_pseudoroot()
|
||
|
|
{
|
||
|
|
return pseudoroot;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the onlyincompound flag
|
||
|
|
FLAG AffixMgr::get_onlyincompound()
|
||
|
|
{
|
||
|
|
return onlyincompound;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the compound word signal flag
|
||
|
|
FLAG AffixMgr::get_compoundroot()
|
||
|
|
{
|
||
|
|
return compoundroot;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the compound begin signal flag
|
||
|
|
FLAG AffixMgr::get_compoundbegin()
|
||
|
|
{
|
||
|
|
return compoundbegin;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the value of checknum
|
||
|
|
int AffixMgr::get_checknum()
|
||
|
|
{
|
||
|
|
return checknum;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the value of prefix
|
||
|
|
const char * AffixMgr::get_prefix()
|
||
|
|
{
|
||
|
|
if (pfx) return ((PfxEntry *)pfx)->getKey();
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the value of suffix
|
||
|
|
const char * AffixMgr::get_suffix()
|
||
|
|
{
|
||
|
|
return sfxappnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the value of derived form (base word with first suffix).
|
||
|
|
const char * AffixMgr::get_derived()
|
||
|
|
{
|
||
|
|
return derived;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the value of suffix
|
||
|
|
const char * AffixMgr::get_version()
|
||
|
|
{
|
||
|
|
return version;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return lemma_present flag
|
||
|
|
FLAG AffixMgr::get_lemma_present()
|
||
|
|
{
|
||
|
|
return lemma_present;
|
||
|
|
}
|
||
|
|
|
||
|
|
// utility method to look up root words in hash table
|
||
|
|
struct hentry * AffixMgr::lookup(const char * word)
|
||
|
|
{
|
||
|
|
if (! pHMgr) return NULL;
|
||
|
|
return pHMgr->lookup(word);
|
||
|
|
}
|
||
|
|
|
||
|
|
// return the value of suffix
|
||
|
|
const int AffixMgr::have_contclass()
|
||
|
|
{
|
||
|
|
return havecontclass;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return utf8
|
||
|
|
int AffixMgr::get_utf8()
|
||
|
|
{
|
||
|
|
return utf8;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return nosplitsugs
|
||
|
|
int AffixMgr::get_maxngramsugs(void)
|
||
|
|
{
|
||
|
|
return maxngramsugs;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return nosplitsugs
|
||
|
|
int AffixMgr::get_nosplitsugs(void)
|
||
|
|
{
|
||
|
|
return nosplitsugs;
|
||
|
|
}
|
||
|
|
|
||
|
|
// return sugswithdots
|
||
|
|
int AffixMgr::get_sugswithdots(void)
|
||
|
|
{
|
||
|
|
return sugswithdots;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the try string */
|
||
|
|
int AffixMgr::parse_try(char * line)
|
||
|
|
{
|
||
|
|
if (trystring) {
|
||
|
|
fprintf(stderr,"error: duplicate TRY strings\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: { trystring = mystrdup(piece); np++; break; }
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing TRY information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* parse in the name of the character set used by the .dict and .aff */
|
||
|
|
int AffixMgr::parse_set(char * line)
|
||
|
|
{
|
||
|
|
if (encoding) {
|
||
|
|
fprintf(stderr,"error: duplicate SET strings\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: { encoding = mystrdup(piece);
|
||
|
|
if (strcmp(encoding, "UTF-8") == 0) {
|
||
|
|
unicode_info * uni = get_utf_cs();
|
||
|
|
utf8 = 1;
|
||
|
|
utf_tbl = (unicode_info2 *) malloc(CONTSIZE * sizeof(unicode_info2));
|
||
|
|
if (utf_tbl) {
|
||
|
|
int j;
|
||
|
|
for (j = 0; j < CONTSIZE; j++) {
|
||
|
|
utf_tbl[j].cletter = 0;
|
||
|
|
utf_tbl[j].clower = j;
|
||
|
|
utf_tbl[j].cupper = j;
|
||
|
|
}
|
||
|
|
for (j = 0; j < get_utf_cs_len(); j++) {
|
||
|
|
utf_tbl[uni[j].c].cletter = 1;
|
||
|
|
utf_tbl[uni[j].c].clower = uni[j].clower;
|
||
|
|
utf_tbl[uni[j].c].cupper = uni[j].cupper;
|
||
|
|
}
|
||
|
|
// set Azeri, Turkish spec. lowercasing
|
||
|
|
set_spec_utf8_encoding();
|
||
|
|
} else return 1;
|
||
|
|
}
|
||
|
|
np++; break; }
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing SET information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse flag */
|
||
|
|
int AffixMgr::parse_flag(char * line, unsigned short * out, char * name)
|
||
|
|
{
|
||
|
|
if (*out) {
|
||
|
|
fprintf(stderr,"error: duplicate %s strings\n", name);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
*out = pHMgr->decode_flag(piece);
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing %s information\n", name);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse flag */
|
||
|
|
int AffixMgr::parse_num(char * line, int * out, char * name)
|
||
|
|
{
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
*out = atoi(piece);
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing %s information\n", name);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the wordchars string */
|
||
|
|
int AffixMgr::parse_wordchars(char * line)
|
||
|
|
{
|
||
|
|
if (wordchars) {
|
||
|
|
fprintf(stderr,"error: duplicate WORDCHARS strings\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
w_char w[MAXWORDLEN];
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
if (!utf8) {
|
||
|
|
wordchars = mystrdup(piece);
|
||
|
|
} else {
|
||
|
|
int n = u8_u16(w, MAXWORDLEN, piece);
|
||
|
|
if (n > 0) {
|
||
|
|
flag_qsort((unsigned short *) w, 0, n);
|
||
|
|
wordchars_utf16 = (unsigned short *) malloc(n * sizeof(unsigned short));
|
||
|
|
if (!wordchars_utf16) return 1;
|
||
|
|
memcpy(wordchars_utf16, w, n * sizeof(unsigned short));
|
||
|
|
}
|
||
|
|
wordchars_utf16_len = n;
|
||
|
|
}
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing WORDCHARS information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* parse in the max syllablecount of compound words and */
|
||
|
|
int AffixMgr::parse_cpdsyllable(char * line)
|
||
|
|
{
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
w_char w[MAXWORDLEN];
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: { cpdmaxsyllable = atoi(piece); np++; break; }
|
||
|
|
case 2: {
|
||
|
|
if (!utf8) {
|
||
|
|
cpdvowels = mystrdup(piece);
|
||
|
|
} else {
|
||
|
|
int n = u8_u16(w, MAXWORDLEN, piece);
|
||
|
|
if (n > 0) {
|
||
|
|
flag_qsort((unsigned short *) w, 0, n);
|
||
|
|
cpdvowels_utf16 = (w_char *) malloc(n * sizeof(w_char));
|
||
|
|
if (!cpdvowels_utf16) return 1;
|
||
|
|
memcpy(cpdvowels_utf16, w, n * sizeof(w_char));
|
||
|
|
}
|
||
|
|
cpdvowels_utf16_len = n;
|
||
|
|
}
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np < 2) {
|
||
|
|
fprintf(stderr,"error: missing compoundsyllable information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
if (np == 2) cpdvowels = mystrdup("aeiouAEIOU");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flags, that increments syllable number */
|
||
|
|
int AffixMgr::parse_syllablenum(char * line)
|
||
|
|
{
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: { cpdsyllablenum = mystrdup(piece); np++; break; }
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing cpdsyllablenum information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the typical fault correcting table */
|
||
|
|
int AffixMgr::parse_reptable(char * line, FILE * af)
|
||
|
|
{
|
||
|
|
if (numrep != 0) {
|
||
|
|
fprintf(stderr,"error: duplicate REP tables used\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
numrep = atoi(piece);
|
||
|
|
if (numrep < 1) {
|
||
|
|
fprintf(stderr,"incorrect number of entries in replacement table\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
reptable = (replentry *) malloc(numrep * sizeof(struct replentry));
|
||
|
|
if (!reptable) return 1;
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing replacement table information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* now parse the numrep lines to read in the remainder of the table */
|
||
|
|
char * nl = line;
|
||
|
|
for (int j=0; j < numrep; j++) {
|
||
|
|
if (!fgets(nl,MAXLNLEN,af)) return 1;
|
||
|
|
mychomp(nl);
|
||
|
|
tp = nl;
|
||
|
|
i = 0;
|
||
|
|
reptable[j].pattern = NULL;
|
||
|
|
reptable[j].pattern2 = NULL;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: {
|
||
|
|
if (strncmp(piece,"REP",3) != 0) {
|
||
|
|
fprintf(stderr,"error: replacement table is corrupt\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1: { reptable[j].pattern = mystrdup(piece); break; }
|
||
|
|
case 2: { reptable[j].pattern2 = mystrdup(piece); break; }
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if ((!(reptable[j].pattern)) || (!(reptable[j].pattern2))) {
|
||
|
|
fprintf(stderr,"error: replacement table is corrupt\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the checkcompoundpattern table */
|
||
|
|
int AffixMgr::parse_checkcpdtable(char * line, FILE * af)
|
||
|
|
{
|
||
|
|
if (numcheckcpd != 0) {
|
||
|
|
fprintf(stderr,"error: duplicate compound pattern tables used\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
numcheckcpd = atoi(piece);
|
||
|
|
if (numcheckcpd < 1) {
|
||
|
|
fprintf(stderr,"incorrect number of entries in compound pattern table\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
checkcpdtable = (replentry *) malloc(numcheckcpd * sizeof(struct replentry));
|
||
|
|
if (!checkcpdtable) return 1;
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing compound pattern table information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* now parse the numcheckcpd lines to read in the remainder of the table */
|
||
|
|
char * nl = line;
|
||
|
|
for (int j=0; j < numcheckcpd; j++) {
|
||
|
|
if (!fgets(nl,MAXLNLEN,af)) return 1;
|
||
|
|
mychomp(nl);
|
||
|
|
tp = nl;
|
||
|
|
i = 0;
|
||
|
|
checkcpdtable[j].pattern = NULL;
|
||
|
|
checkcpdtable[j].pattern2 = NULL;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: {
|
||
|
|
if (strncmp(piece,"CHECKCOMPOUNDPATTERN",20) != 0) {
|
||
|
|
fprintf(stderr,"error: compound pattern table is corrupt\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1: { checkcpdtable[j].pattern = mystrdup(piece); break; }
|
||
|
|
case 2: { checkcpdtable[j].pattern2 = mystrdup(piece); break; }
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if ((!(checkcpdtable[j].pattern)) || (!(checkcpdtable[j].pattern2))) {
|
||
|
|
fprintf(stderr,"error: compound pattern table is corrupt\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the compound rule table */
|
||
|
|
int AffixMgr::parse_defcpdtable(char * line, FILE * af)
|
||
|
|
{
|
||
|
|
if (numdefcpd != 0) {
|
||
|
|
fprintf(stderr,"error: duplicate compound rule tables used\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
numdefcpd = atoi(piece);
|
||
|
|
if (numdefcpd < 1) {
|
||
|
|
fprintf(stderr,"incorrect number of entries in compound rule table\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
defcpdtable = (flagentry *) malloc(numdefcpd * sizeof(flagentry));
|
||
|
|
if (!defcpdtable) return 1;
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing compound rule table information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* now parse the numdefcpd lines to read in the remainder of the table */
|
||
|
|
char * nl = line;
|
||
|
|
for (int j=0; j < numdefcpd; j++) {
|
||
|
|
if (!fgets(nl,MAXLNLEN,af)) return 1;
|
||
|
|
mychomp(nl);
|
||
|
|
tp = nl;
|
||
|
|
i = 0;
|
||
|
|
defcpdtable[j].def = NULL;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: {
|
||
|
|
if (strncmp(piece, "COMPOUNDRULE", 12) != 0) {
|
||
|
|
fprintf(stderr,"error: compound rule table is corrupt\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1: {
|
||
|
|
defcpdtable[j].len =
|
||
|
|
pHMgr->decode_flags(&(defcpdtable[j].def), piece);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (!defcpdtable[j].len) {
|
||
|
|
fprintf(stderr,"error: compound rule table is corrupt\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* parse in the character map table */
|
||
|
|
int AffixMgr::parse_maptable(char * line, FILE * af)
|
||
|
|
{
|
||
|
|
if (nummap != 0) {
|
||
|
|
fprintf(stderr,"error: duplicate MAP tables used\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
nummap = atoi(piece);
|
||
|
|
if (nummap < 1) {
|
||
|
|
fprintf(stderr,"incorrect number of entries in map table\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
maptable = (mapentry *) malloc(nummap * sizeof(struct mapentry));
|
||
|
|
if (!maptable) return 1;
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing map table information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* now parse the nummap lines to read in the remainder of the table */
|
||
|
|
char * nl = line;
|
||
|
|
for (int j=0; j < nummap; j++) {
|
||
|
|
if (!fgets(nl,MAXLNLEN,af)) return 1;
|
||
|
|
mychomp(nl);
|
||
|
|
tp = nl;
|
||
|
|
i = 0;
|
||
|
|
maptable[j].set = NULL;
|
||
|
|
maptable[j].len = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: {
|
||
|
|
if (strncmp(piece,"MAP",3) != 0) {
|
||
|
|
fprintf(stderr,"error: map table is corrupt\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1: {
|
||
|
|
maptable[j].len = 0;
|
||
|
|
maptable[j].set = NULL;
|
||
|
|
maptable[j].set_utf16 = NULL;
|
||
|
|
if (!utf8) {
|
||
|
|
maptable[j].set = mystrdup(piece);
|
||
|
|
maptable[j].len = strlen(maptable[j].set);
|
||
|
|
} else {
|
||
|
|
w_char w[MAXWORDLEN];
|
||
|
|
int n = u8_u16(w, MAXWORDLEN, piece);
|
||
|
|
if (n > 0) {
|
||
|
|
flag_qsort((unsigned short *) w, 0, n);
|
||
|
|
maptable[j].set_utf16 = (w_char *) malloc(n * sizeof(w_char));
|
||
|
|
if (!maptable[j].set_utf16) return 1;
|
||
|
|
memcpy(maptable[j].set_utf16, w, n * sizeof(w_char));
|
||
|
|
}
|
||
|
|
maptable[j].len = n;
|
||
|
|
}
|
||
|
|
break; }
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if ((!(maptable[j].set || maptable[j].set_utf16)) || (!(maptable[j].len))) {
|
||
|
|
fprintf(stderr,"error: map table is corrupt\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the word breakpoint table */
|
||
|
|
int AffixMgr::parse_breaktable(char * line, FILE * af)
|
||
|
|
{
|
||
|
|
if (numbreak != 0) {
|
||
|
|
fprintf(stderr,"error: duplicate word breakpoint tables used\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
numbreak = atoi(piece);
|
||
|
|
if (numbreak < 1) {
|
||
|
|
fprintf(stderr,"incorrect number of entries in BREAK table\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
breaktable = (char **) malloc(numbreak * sizeof(char *));
|
||
|
|
if (!breaktable) return 1;
|
||
|
|
np++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np != 2) {
|
||
|
|
fprintf(stderr,"error: missing word breakpoint table information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* now parse the numbreak lines to read in the remainder of the table */
|
||
|
|
char * nl = line;
|
||
|
|
for (int j=0; j < numbreak; j++) {
|
||
|
|
if (!fgets(nl,MAXLNLEN,af)) return 1;
|
||
|
|
mychomp(nl);
|
||
|
|
tp = nl;
|
||
|
|
i = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: {
|
||
|
|
if (strncmp(piece,"BREAK",5) != 0) {
|
||
|
|
fprintf(stderr,"error: BREAK table is corrupt\n");
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1: {
|
||
|
|
breaktable[j] = mystrdup(piece);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (!breaktable) {
|
||
|
|
fprintf(stderr,"error: BREAK table is corrupt\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the flag used by affix_check() */
|
||
|
|
int AffixMgr::parse_lang(char * line)
|
||
|
|
{
|
||
|
|
if (lang != NULL) {
|
||
|
|
fprintf(stderr,"error: duplicate LANG used\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
case 0: { np++; break; }
|
||
|
|
case 1: {
|
||
|
|
lang = mystrdup(piece);
|
||
|
|
langnum = get_lang_num(piece);
|
||
|
|
set_spec_utf8_encoding();
|
||
|
|
np++; break;
|
||
|
|
}
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
if (np < 2) {
|
||
|
|
fprintf(stderr,"error: missing LANG information\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* parse in the version string */
|
||
|
|
int AffixMgr::parse_version(char * line)
|
||
|
|
{
|
||
|
|
if (version) {
|
||
|
|
fprintf(stderr,"error: duplicate VERSION strings\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
char * tp = line;
|
||
|
|
char * piece = mystrsep(&tp, 0);
|
||
|
|
version = mystrdup(tp);
|
||
|
|
free(piece);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int AffixMgr::parse_affix(char * line, const char at, FILE * af, char * dupflags)
|
||
|
|
{
|
||
|
|
int numents = 0; // number of affentry structures to parse
|
||
|
|
|
||
|
|
unsigned short aflag = 0; // affix char identifier
|
||
|
|
|
||
|
|
short ff=0;
|
||
|
|
struct affentry * ptr= NULL;
|
||
|
|
struct affentry * nptr= NULL;
|
||
|
|
|
||
|
|
char * tp = line;
|
||
|
|
char * nl = line;
|
||
|
|
char * piece;
|
||
|
|
int i = 0;
|
||
|
|
|
||
|
|
// checking lines with bad syntax
|
||
|
|
int basefieldnum = 0;
|
||
|
|
|
||
|
|
// split affix header line into pieces
|
||
|
|
|
||
|
|
int np = 0;
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
// piece 1 - is type of affix
|
||
|
|
case 0: { np++; break; }
|
||
|
|
|
||
|
|
// piece 2 - is affix char
|
||
|
|
case 1: {
|
||
|
|
np++;
|
||
|
|
aflag = pHMgr->decode_flag(piece);
|
||
|
|
if (((at == 'S') && (dupflags[aflag] & dupSFX)) ||
|
||
|
|
((at == 'P') && (dupflags[aflag] & dupPFX))) {
|
||
|
|
fprintf(stderr, "error: duplicate affix flag %s in line %s\n", piece, nl);
|
||
|
|
// return 1; XXX permissive mode for bad dictionaries
|
||
|
|
}
|
||
|
|
dupflags[aflag] += ((at == 'S') ? dupSFX : dupPFX);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
// piece 3 - is cross product indicator
|
||
|
|
case 2: { np++; if (*piece == 'Y') ff = aeXPRODUCT; break; }
|
||
|
|
|
||
|
|
// piece 4 - is number of affentries
|
||
|
|
case 3: {
|
||
|
|
np++;
|
||
|
|
numents = atoi(piece);
|
||
|
|
if (numents == 0) {
|
||
|
|
char * err = pHMgr->encode_flag(aflag);
|
||
|
|
fprintf(stderr, "error: affix %s header has incorrect entry count in line %s\n",
|
||
|
|
err, nl);
|
||
|
|
free(err);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
ptr = (struct affentry *) malloc(numents * sizeof(struct affentry));
|
||
|
|
if (!ptr) return 1;
|
||
|
|
ptr->opts = ff;
|
||
|
|
if (utf8) ptr->opts += aeUTF8;
|
||
|
|
if (pHMgr->is_aliasf()) ptr->opts += aeALIASF;
|
||
|
|
if (pHMgr->is_aliasm()) ptr->opts += aeALIASM;
|
||
|
|
ptr->aflag = aflag;
|
||
|
|
}
|
||
|
|
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
// check to make sure we parsed enough pieces
|
||
|
|
if (np != 4) {
|
||
|
|
char * err = pHMgr->encode_flag(aflag);
|
||
|
|
fprintf(stderr, "error: affix %s header has insufficient data in line %s\n", err, nl);
|
||
|
|
free(err);
|
||
|
|
free(ptr);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// store away ptr to first affentry
|
||
|
|
nptr = ptr;
|
||
|
|
|
||
|
|
// now parse numents affentries for this affix
|
||
|
|
for (int j=0; j < numents; j++) {
|
||
|
|
if (!fgets(nl,MAXLNLEN,af)) return 1;
|
||
|
|
mychomp(nl);
|
||
|
|
tp = nl;
|
||
|
|
i = 0;
|
||
|
|
np = 0;
|
||
|
|
|
||
|
|
// split line into pieces
|
||
|
|
while ((piece=mystrsep(&tp, 0))) {
|
||
|
|
if (*piece != '\0') {
|
||
|
|
switch(i) {
|
||
|
|
// piece 1 - is type
|
||
|
|
case 0: {
|
||
|
|
np++;
|
||
|
|
if (nptr != ptr) nptr->opts = ptr->opts;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// piece 2 - is affix char
|
||
|
|
case 1: {
|
||
|
|
np++;
|
||
|
|
if (pHMgr->decode_flag(piece) != aflag) {
|
||
|
|
char * err = pHMgr->encode_flag(aflag);
|
||
|
|
fprintf(stderr, "error: affix %s is corrupt near line %s\n", err, nl);
|
||
|
|
fprintf(stderr, "error: possible incorrect count\n");
|
||
|
|
free(err);
|
||
|
|
free(piece);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (nptr != ptr) nptr->aflag = ptr->aflag;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// piece 3 - is string to strip or 0 for null
|
||
|
|
case 2: {
|
||
|
|
np++;
|
||
|
|
if (complexprefixes) {
|
||
|
|
if (utf8) reverseword_utf(piece); else reverseword(piece);
|
||
|
|
}
|
||
|
|
nptr->strip = mystrdup(piece);
|
||
|
|
nptr->stripl = strlen(nptr->strip);
|
||
|
|
if (strcmp(nptr->strip,"0") == 0) {
|
||
|
|
free(nptr->strip);
|
||
|
|
nptr->strip=mystrdup("");
|
||
|
|
nptr->stripl = 0;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// piece 4 - is affix string or 0 for null
|
||
|
|
case 3: {
|
||
|
|
char * dash;
|
||
|
|
nptr->morphcode = NULL;
|
||
|
|
nptr->contclass = NULL;
|
||
|
|
nptr->contclasslen = 0;
|
||
|
|
np++;
|
||
|
|
dash = strchr(piece, '/');
|
||
|
|
if (dash) {
|
||
|
|
*dash = '\0';
|
||
|
|
if (complexprefixes) {
|
||
|
|
if (utf8) reverseword_utf(piece); else reverseword(piece);
|
||
|
|
}
|
||
|
|
nptr->appnd = mystrdup(piece);
|
||
|
|
|
||
|
|
if (pHMgr->is_aliasf()) {
|
||
|
|
int index = atoi(dash + 1);
|
||
|
|
nptr->contclasslen = pHMgr->get_aliasf(index, &(nptr->contclass));
|
||
|
|
} else {
|
||
|
|
nptr->contclasslen = pHMgr->decode_flags(&(nptr->contclass), dash + 1);
|
||
|
|
flag_qsort(nptr->contclass, 0, nptr->contclasslen);
|
||
|
|
}
|
||
|
|
*dash = '/';
|
||
|
|
|
||
|
|
havecontclass = 1;
|
||
|
|
for (unsigned short i = 0; i < nptr->contclasslen; i++) {
|
||
|
|
contclasses[(nptr->contclass)[i]] = 1;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (complexprefixes) {
|
||
|
|
if (utf8) reverseword_utf(piece); else reverseword(piece);
|
||
|
|
}
|
||
|
|
nptr->appnd = mystrdup(piece);
|
||
|
|
}
|
||
|
|
|
||
|
|
nptr->appndl = strlen(nptr->appnd);
|
||
|
|
if (strcmp(nptr->appnd,"0") == 0) {
|
||
|
|
free(nptr->appnd);
|
||
|
|
nptr->appnd=mystrdup("");
|
||
|
|
nptr->appndl = 0;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// piece 5 - is the conditions descriptions
|
||
|
|
case 4: {
|
||
|
|
np++;
|
||
|
|
if (complexprefixes) {
|
||
|
|
int neg = 0;
|
||
|
|
if (utf8) reverseword_utf(piece); else reverseword(piece);
|
||
|
|
// reverse condition
|
||
|
|
for (char * k = piece + strlen(piece) - 1; k >= piece; k--) {
|
||
|
|
switch(*k) {
|
||
|
|
case '[': {
|
||
|
|
if (neg) *(k+1) = '['; else *k = ']';
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case ']': {
|
||
|
|
*k = '[';
|
||
|
|
if (neg) *(k+1) = '^';
|
||
|
|
neg = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case '^': {
|
||
|
|
if (*(k+1) == ']') neg = 1; else *(k+1) = *k;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: {
|
||
|
|
if (neg) *(k+1) = *k;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (nptr->stripl && (strcmp(piece, ".") != 0) &&
|
||
|
|
redundant_condition(at, nptr->strip, nptr->stripl, piece, nl))
|
||
|
|
strcpy(piece, ".");
|
||
|
|
if (encodeit(nptr,piece)) return 1;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case 5: {
|
||
|
|
np++;
|
||
|
|
if (pHMgr->is_aliasm()) {
|
||
|
|
int index = atoi(piece);
|
||
|
|
nptr->morphcode = pHMgr->get_aliasm(index);
|
||
|
|
} else {
|
||
|
|
if (complexprefixes) {
|
||
|
|
if (utf8) reverseword_utf(piece); else reverseword(piece);
|
||
|
|
}
|
||
|
|
nptr->morphcode = mystrdup(piece);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case 6: {
|
||
|
|
// XXX deprecated syntax
|
||
|
|
np++;
|
||
|
|
if (nptr->contclass) {
|
||
|
|
fprintf(stderr, "error: affix rule contains two contclass "
|
||
|
|
"(%s and %s by deprecated syntax).\n", nptr->contclass, piece);
|
||
|
|
} else {
|
||
|
|
if (pHMgr->is_aliasf()) {
|
||
|
|
int index = atoi(piece);
|
||
|
|
nptr->contclasslen = pHMgr->get_aliasf(index, &(nptr->contclass));
|
||
|
|
} else {
|
||
|
|
nptr->contclasslen = pHMgr->decode_flags(&(nptr->contclass), piece);
|
||
|
|
flag_qsort(nptr->contclass, 0, nptr->contclasslen);
|
||
|
|
}
|
||
|
|
havecontclass = 1;
|
||
|
|
for (unsigned short i = 0; i < nptr->contclasslen; i++) {
|
||
|
|
contclasses[(nptr->contclass)[i]] = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
free(piece);
|
||
|
|
}
|
||
|
|
// check to make sure we parsed enough pieces
|
||
|
|
if (np < 5) {
|
||
|
|
char * err = pHMgr->encode_flag(aflag);
|
||
|
|
fprintf(stderr, "error: affix %s is corrupt near line %s\n", err, nl);
|
||
|
|
free(err);
|
||
|
|
free(ptr);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if DEBUG
|
||
|
|
// detect unnecessary fields, excepting comments
|
||
|
|
if (basefieldnum) {
|
||
|
|
int fieldnum = !(nptr->morphcode) ? 5 : ((*(nptr->morphcode)=='#') ? 5 : 6);
|
||
|
|
if (fieldnum != basefieldnum)
|
||
|
|
fprintf(stderr, "warning - bad field number:\n%s\n", nl);
|
||
|
|
} else {
|
||
|
|
basefieldnum = !(nptr->morphcode) ? 5 : ((*(nptr->morphcode)=='#') ? 5 : 6);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
nptr++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// now create SfxEntry or PfxEntry objects and use links to
|
||
|
|
// build an ordered (sorted by affix string) list
|
||
|
|
nptr = ptr;
|
||
|
|
for (int k = 0; k < numents; k++) {
|
||
|
|
if (at == 'P') {
|
||
|
|
PfxEntry * pfxptr = new PfxEntry(this,nptr);
|
||
|
|
build_pfxtree((AffEntry *)pfxptr);
|
||
|
|
} else {
|
||
|
|
SfxEntry * sfxptr = new SfxEntry(this,nptr);
|
||
|
|
build_sfxtree((AffEntry *)sfxptr);
|
||
|
|
}
|
||
|
|
nptr++;
|
||
|
|
}
|
||
|
|
free(ptr);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void AffixMgr::set_spec_utf8_encoding() {
|
||
|
|
if (utf8) {
|
||
|
|
// In Azeri and Turkish, I and i dictinct letters:
|
||
|
|
// There are a dotless lower case i pair of upper `I',
|
||
|
|
// and an upper I with dot pair of lower `i'.
|
||
|
|
if ((langnum == LANG_az) || (langnum == LANG_tr)) {
|
||
|
|
utf_tbl[0x0049].clower = 0x0131;
|
||
|
|
utf_tbl[0x0069].cupper = 0x0130;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int AffixMgr::redundant_condition(char ft, char * strip, int stripl, const char * cond, char * line) {
|
||
|
|
int condl = strlen(cond);
|
||
|
|
int i;
|
||
|
|
int j;
|
||
|
|
int neg;
|
||
|
|
int in;
|
||
|
|
if (ft == 'P') { // prefix
|
||
|
|
if (strncmp(strip, cond, condl) == 0) return 1;
|
||
|
|
if (utf8) {
|
||
|
|
} else {
|
||
|
|
for (i = 0, j = 0; (i < stripl) && (j < condl); i++, j++) {
|
||
|
|
if (cond[j] != '[') {
|
||
|
|
if (cond[j] != strip[i]) {
|
||
|
|
fprintf(stderr, "warning - incompatible stripping characters and condition:\n%s\n", line);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
neg = (cond[j+1] == '^') ? 1 : 0;
|
||
|
|
in = 0;
|
||
|
|
do {
|
||
|
|
j++;
|
||
|
|
if (strip[i] == cond[j]) in = 1;
|
||
|
|
} while ((j < (condl - 1)) && (cond[j] != ']'));
|
||
|
|
if (j == (condl - 1) && (cond[j] != ']')) {
|
||
|
|
fprintf(stderr, "error - missing ] in condition:\n%s\n", line);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
if ((!neg && !in) || (neg && in)) {
|
||
|
|
fprintf(stderr, "warning - incompatible stripping characters and condition:\n%s\n", line);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (j >= condl) return 1;
|
||
|
|
}
|
||
|
|
} else { // suffix
|
||
|
|
if ((stripl >= condl) && strcmp(strip + stripl - condl, cond) == 0) return 1;
|
||
|
|
if (utf8) {
|
||
|
|
} else {
|
||
|
|
for (i = stripl - 1, j = condl - 1; (i >= 0) && (j >= 0); i--, j--) {
|
||
|
|
if (cond[j] != ']') {
|
||
|
|
if (cond[j] != strip[i]) {
|
||
|
|
fprintf(stderr, "warning - incompatible stripping characters and condition:\n%s\n", line);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
in = 0;
|
||
|
|
do {
|
||
|
|
j--;
|
||
|
|
if (strip[i] == cond[j]) in = 1;
|
||
|
|
} while ((j > 0) && (cond[j] != '['));
|
||
|
|
if ((j == 0) && (cond[j] != '[')) {
|
||
|
|
fprintf(stderr, "error - missing ] in condition:\n%s\n", line);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
neg = (cond[j+1] == '^') ? 1 : 0;
|
||
|
|
if ((!neg && !in) || (neg && in)) {
|
||
|
|
fprintf(stderr, "warning - incompatible stripping characters and condition:\n%s\n", line);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (j < 0) return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|