PageRenderTime 139ms CodeModel.GetById 3ms RepoModel.GetById 0ms app.codeStats 0ms

/ext/hunspell/affixmgr.cxx

https://github.com/csware/test
C++ | 3976 lines | 3145 code | 418 blank | 413 comment | 1291 complexity | 1cd26bf8aa3cdc888a4490b61d8d99f2 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, GPL-3.0, LGPL-3.0, MPL-2.0-no-copyleft-exception 
    

  1. #include "license.hunspell"

    2. 

  2. #include "license.myspell"

    3. 

  3. 

    4. 

  4. #ifndef MOZILLA_CLIENT

    5. 

  5. #include <cstdlib>

    6. 

  6. #include <cstring>

    7. 

  7. #include <cctype>

    8. 

  8. #include <cstdio>

    9. 

  9. #else

    10. 

  10. #include <stdlib.h> 

    11. 

  11. #include <string.h>

    12. 

  12. #include <stdio.h> 

    13. 

  13. #include <ctype.h>

    14. 

  14. #endif

    15. 

  15. 

    16. 

  16. #include "affixmgr.hxx"

    17. 

  17. #include "affentry.hxx"

    18. 

  18. #include "langnum.hxx"

    19. 

  19. 

    20. 

  20. #include "csutil.hxx"

    21. 

  21. 

    22. 

  22. #ifndef MOZILLA_CLIENT

    23. 

  23. #ifndef W32

    24. 

  24. using namespace std;

    25. 

  25. #endif

    26. 

  26. #endif

    27. 

  27. 

    28. 

  28. AffixMgr::AffixMgr(const char * affpath, HashMgr* ptr) 

    29. 

  29. {

    30. 

  30.   // register hash manager and load affix data from aff file

    31. 

  31.   pHMgr = ptr;

    32. 

  32.   trystring = NULL;

    33. 

  33.   encoding=NULL;

    34. 

  34.   utf8 = 0;

    35. 

  35.   complexprefixes = 0;

    36. 

  36.   maptable = NULL;

    37. 

  37.   nummap = 0;

    38. 

  38.   breaktable = NULL;

    39. 

  39.   numbreak = 0;

    40. 

  40.   reptable = NULL;

    41. 

  41.   numrep = 0;

    42. 

  42.   checkcpdtable = NULL;

    43. 

  43.   numcheckcpd = 0;

    44. 

  44.   defcpdtable = NULL;

    45. 

  45.   numdefcpd = 0;

    46. 

  46.   compoundflag = FLAG_NULL; // permits word in compound forms

    47. 

  47.   compoundbegin = FLAG_NULL; // may be first word in compound forms

    48. 

  48.   compoundmiddle = FLAG_NULL; // may be middle word in compound forms

    49. 

  49.   compoundend = FLAG_NULL; // may be last word in compound forms

    50. 

  50.   compoundroot = FLAG_NULL; // compound word signing flag

    51. 

  51.   compoundpermitflag = FLAG_NULL; // compound permitting flag for suffixed word

    52. 

  52.   compoundforbidflag = FLAG_NULL; // compound fordidden flag for suffixed word

    53. 

  53.   checkcompounddup = 0; // forbid double words in compounds

    54. 

  54.   checkcompoundrep = 0; // forbid bad compounds (may be non compound word with a REP substitution)

    55. 

  55.   checkcompoundcase = 0; // forbid upper and lowercase combinations at word bounds

    56. 

  56.   checkcompoundtriple = 0; // forbid compounds with triple letters

    57. 

  57.   forbiddenword = FLAG_NULL; // forbidden word signing flag

    58. 

  58.   nosuggest = FLAG_NULL; // don't suggest words signed with NOSUGGEST flag

    59. 

  59.   lang = NULL; // language

    60. 

  60.   langnum = 0; // language code (see http://l10n.openoffice.org/languages.html)

    61. 

  61.   pseudoroot = FLAG_NULL; // forbidden root, allowed only with suffixes

    62. 

  62.   cpdwordmax = -1; // default: unlimited wordcount in compound words

    63. 

  63.   cpdmin = -1;  // undefined

    64. 

  64.   cpdmaxsyllable = 0; // default: unlimited syllablecount in compound words

    65. 

  65.   cpdvowels=NULL; // vowels (for calculating of Hungarian compounding limit, O(n) search! XXX)

    66. 

  66.   cpdvowels_utf16=NULL; // vowels for UTF-8 encoding (bsearch instead of O(n) search)

    67. 

  67.   cpdvowels_utf16_len=0; // vowels

    68. 

  68.   pfxappnd=NULL; // previous prefix for counting the syllables of prefix BUG

    69. 

  69.   sfxappnd=NULL; // previous suffix for counting a special syllables BUG

    70. 

  70.   cpdsyllablenum=NULL; // syllable count incrementing flag

    71. 

  71.   checknum=0; // checking numbers, and word with numbers

    72. 

  72.   wordchars=NULL; // letters + spec. word characters

    73. 

  73.   wordchars_utf16=NULL; // letters + spec. word characters

    74. 

  74.   wordchars_utf16_len=0; // letters + spec. word characters

    75. 

  75.   ignorechars=NULL; // letters + spec. word characters

    76. 

  76.   ignorechars_utf16=NULL; // letters + spec. word characters

    77. 

  77.   ignorechars_utf16_len=0; // letters + spec. word characters

    78. 

  78.   version=NULL; // affix and dictionary file version string

    79. 

  79.   havecontclass=0; // flags of possible continuing classes (double affix)

    80. 

  80.   // LEMMA_PRESENT: not put root into the morphological output. Lemma presents

    81. 

  81.   // in morhological description in dictionary file. It's often combined with PSEUDOROOT.

    82. 

  82.   lemma_present = FLAG_NULL; 

    83. 

  83.   circumfix = FLAG_NULL; 

    84. 

  84.   onlyincompound = FLAG_NULL; 

    85. 

  85.   flag_mode = FLAG_CHAR; // default one-character flags in affix and dic file

    86. 

  86.   maxngramsugs = -1; // undefined

    87. 

  87.   nosplitsugs = 0;

    88. 

  88.   sugswithdots = 0;

    89. 

  89.   keepcase = 0;

    90. 

  90.   checksharps = 0;

    91. 

  91. 

    92. 

  92.   derived = NULL; // XXX not threadsafe variable for experimental stemming

    93. 

  93.   sfx = NULL;

    94. 

  94.   pfx = NULL;

    95. 

  95. 

    96. 

  96.   for (int i=0; i < SETSIZE; i++) {

    97. 

  97.      pStart[i] = NULL;

    98. 

  98.      sStart[i] = NULL;

    99. 

  99.      pFlag[i] = NULL;

    100. 

  100.      sFlag[i] = NULL;

    101. 

  101.   }

    102. 

  102. 

    103. 

  103.   for (int j=0; j < CONTSIZE; j++) {

    104. 

  104.     contclasses[j] = 0;

    105. 

  105.   }

    106. 

  106. 

    107. 

  107.   if (parse_file(affpath)) {

    108. 

  108.      HUNSPELL_WARNING(stderr, "Failure loading aff file %s\n",affpath);

    109. 

  109.      wordchars = mystrdup("qwertzuiopasdfghjklyxcvbnmQWERTZUIOPASDFGHJKLYXCVBNM");

    110. 

  110.   }

    111. 

  111.   

    112. 

  112.   if (cpdmin == -1) cpdmin = MINCPDLEN;

    113. 

  113. 

    114. 

  114. }

    115. 

  115. 

    116. 

  116. 

    117. 

  117. AffixMgr::~AffixMgr() 

    118. 

  118. {

    119. 

  119.  

    120. 

  120.   // pass through linked prefix entries and clean up

    121. 

  121.   for (int i=0; i < SETSIZE ;i++) {

    122. 

  122.        pFlag[i] = NULL;

    123. 

  123.        PfxEntry * ptr = (PfxEntry *)pStart[i];

    124. 

  124.        PfxEntry * nptr = NULL;

    125. 

  125.        while (ptr) {

    126. 

  126.             nptr = ptr->getNext();

    127. 

  127.             delete(ptr);

    128. 

  128.             ptr = nptr;

    129. 

  129.             nptr = NULL;

    130. 

  130.        }  

    131. 

  131.   }

    132. 

  132. 

    133. 

  133.   // pass through linked suffix entries and clean up

    134. 

  134.   for (int j=0; j < SETSIZE ; j++) {

    135. 

  135.        sFlag[j] = NULL;

    136. 

  136.        SfxEntry * ptr = (SfxEntry *)sStart[j];

    137. 

  137.        SfxEntry * nptr = NULL;

    138. 

  138.        while (ptr) {

    139. 

  139.             nptr = ptr->getNext();

    140. 

  140.             delete(ptr);

    141. 

  141.             ptr = nptr;

    142. 

  142.             nptr = NULL;

    143. 

  143.        }

    144. 

  144.        sStart[j] = NULL;

    145. 

  145.   }

    146. 

  146. 

    147. 

  147.   if (trystring) free(trystring);

    148. 

  148.   trystring=NULL;

    149. 

  149.   if (encoding) free(encoding);

    150. 

  150.   encoding=NULL;

    151. 

  151.   if (maptable) {  

    152. 

  152.      for (int j=0; j < nummap; j++) {

    153. 

  153.         if (maptable[j].set) free(maptable[j].set);

    154. 

  154.         if (maptable[j].set_utf16) free(maptable[j].set_utf16);

    155. 

  155.         maptable[j].set = NULL;

    156. 

  156.         maptable[j].len = 0;

    157. 

  157.      }

    158. 

  158.      free(maptable);  

    159. 

  159.      maptable = NULL;

    160. 

  160.   }

    161. 

  161.   nummap = 0;

    162. 

  162.   if (breaktable) {

    163. 

  163.      for (int j=0; j < numbreak; j++) {

    164. 

  164.         if (breaktable[j]) free(breaktable[j]);

    165. 

  165.         breaktable[j] = NULL;

    166. 

  166.      }

    167. 

  167.      free(breaktable);  

    168. 

  168.      breaktable = NULL;

    169. 

  169.   }

    170. 

  170.   numbreak = 0;

    171. 

  171.   if (reptable) {  

    172. 

  172.      for (int j=0; j < numrep; j++) {

    173. 

  173.         free(reptable[j].pattern);

    174. 

  174.         free(reptable[j].pattern2);

    175. 

  175.         reptable[j].pattern = NULL;

    176. 

  176.         reptable[j].pattern2 = NULL;

    177. 

  177.      }

    178. 

  178.      free(reptable);  

    179. 

  179.      reptable = NULL;

    180. 

  180.   }

    181. 

  181.   if (defcpdtable) {  

    182. 

  182.      for (int j=0; j < numdefcpd; j++) {

    183. 

  183.         free(defcpdtable[j].def);

    184. 

  184.         defcpdtable[j].def = NULL;

    185. 

  185.      }

    186. 

  186.      free(defcpdtable);  

    187. 

  187.      defcpdtable = NULL;

    188. 

  188.   }

    189. 

  189.   numrep = 0;

    190. 

  190.   if (checkcpdtable) {  

    191. 

  191.      for (int j=0; j < numcheckcpd; j++) {

    192. 

  192.         free(checkcpdtable[j].pattern);

    193. 

  193.         free(checkcpdtable[j].pattern2);

    194. 

  194.         checkcpdtable[j].pattern = NULL;

    195. 

  195.         checkcpdtable[j].pattern2 = NULL;

    196. 

  196.      }

    197. 

  197.      free(checkcpdtable);  

    198. 

  198.      checkcpdtable = NULL;

    199. 

  199.   }

    200. 

  200.   numcheckcpd = 0;

    201. 

  201.   FREE_FLAG(compoundflag);

    202. 

  202.   FREE_FLAG(compoundbegin);

    203. 

  203.   FREE_FLAG(compoundmiddle);

    204. 

  204.   FREE_FLAG(compoundend);

    205. 

  205.   FREE_FLAG(compoundpermitflag);

    206. 

  206.   FREE_FLAG(compoundforbidflag);

    207. 

  207.   FREE_FLAG(compoundroot);

    208. 

  208.   FREE_FLAG(forbiddenword);

    209. 

  209.   FREE_FLAG(nosuggest);

    210. 

  210.   FREE_FLAG(pseudoroot);

    211. 

  211.   FREE_FLAG(lemma_present);

    212. 

  212.   FREE_FLAG(circumfix);

    213. 

  213.   FREE_FLAG(onlyincompound);

    214. 

  214.   

    215. 

  215.   cpdwordmax = 0;

    216. 

  216.   pHMgr = NULL;

    217. 

  217.   cpdmin = 0;

    218. 

  218.   cpdmaxsyllable = 0;

    219. 

  219.   if (cpdvowels) free(cpdvowels);

    220. 

  220.   if (cpdvowels_utf16) free(cpdvowels_utf16);

    221. 

  221.   if (cpdsyllablenum) free(cpdsyllablenum);

    222. 

  222.   free_utf_tbl();

    223. 

  223.   if (lang) free(lang);

    224. 

  224.   if (wordchars) free(wordchars);

    225. 

  225.   if (wordchars_utf16) free(wordchars_utf16);

    226. 

  226.   if (ignorechars) free(ignorechars);

    227. 

  227.   if (ignorechars_utf16) free(ignorechars_utf16);

    228. 

  228.   if (version) free(version);

    229. 

  229.   if (derived) free(derived);

    230. 

  230.   checknum=0;

    231. 

  231. }

    232. 

  232. 

    233. 

  233. 

    234. 

  234. // read in aff file and build up prefix and suffix entry objects 

    235. 

  235. int  AffixMgr::parse_file(const char * affpath)

    236. 

  236. {

    237. 

  237. 

    238. 

  238.   // io buffers

    239. 

  239.   char line[MAXLNLEN+1];

    240. 

  240.  

    241. 

  241.   // affix type

    242. 

  242.   char ft;

    243. 

  243.   

    244. 

  244.   // checking flag duplication

    245. 

  245.   char dupflags[CONTSIZE];

    246. 

  246.   char dupflags_ini = 1;

    247. 

  247. 

    248. 

  248.   // first line indicator for removing byte order mark

    249. 

  249.   int firstline = 1;

    250. 

  250.   

    251. 

  251.   // open the affix file

    252. 

  252.   FILE * afflst;

    253. 

  253.   afflst = fopen(affpath,"r");

    254. 

  254.   if (!afflst) {

    255. 

  255.     HUNSPELL_WARNING(stderr, "error: could not open affix description file %s\n",affpath);

    256. 

  256.     return 1;

    257. 

  257.   }

    258. 

  258. 

    259. 

  259.   // step one is to parse the affix file building up the internal

    260. 

  260.   // affix data structures

    261. 

  261. 

    262. 

  262. 

    263. 

  263.     // read in each line ignoring any that do not

    264. 

  264.     // start with a known line type indicator

    265. 

  265.     while (fgets(line,MAXLNLEN,afflst)) {

    266. 

  266.        mychomp(line);

    267. 

  267. 

    268. 

  268.        /* remove byte order mark */

    269. 

  269.        if (firstline) {

    270. 

  270.          firstline = 0;

    271. 

  271.          if (strncmp(line,"",3) == 0) {

    272. 

  272.             memmove(line, line+3, strlen(line+3)+1);

    273. 

  273.             HUNSPELL_WARNING(stderr, "warning: affix file begins with byte order mark: possible incompatibility with old Hunspell versions\n");

    274. 

  274.          }

    275. 

  275.        }

    276. 

  276. 

    277. 

  277.        /* parse in the try string */

    278. 

  278.        if (strncmp(line,"TRY",3) == 0) {

    279. 

  279.           if (parse_string(line, &trystring, "TRY")) {

    280. 

  280.              fclose(afflst);

    281. 

  281.              return 1;

    282. 

  282.           }

    283. 

  283.        }

    284. 

  284. 

    285. 

  285.        /* parse in the name of the character set used by the .dict and .aff */

    286. 

  286.        if (strncmp(line,"SET",3) == 0) {

    287. 

  287.           if (parse_string(line, &encoding, "SET")) {

    288. 

  288.              fclose(afflst);

    289. 

  289.              return 1;

    290. 

  290.           }

    291. 

  291.           if (strcmp(encoding, "UTF-8") == 0) {

    292. 

  292.              utf8 = 1;

    293. 

  293. #ifndef OPENOFFICEORG

    294. 

  294. #ifndef MOZILLA_CLIENT

    295. 

  295.              if (initialize_utf_tbl()) {

    296. 

  296.                fclose(afflst);

    297. 

  297.                return 1;

    298. 

  298.              }

    299. 

  299. #endif

    300. 

  300. #endif

    301. 

  301.           }

    302. 

  302.        }

    303. 

  303. 

    304. 

  304.        /* parse COMPLEXPREFIXES for agglutinative languages with right-to-left writing system */

    305. 

  305.        if (strncmp(line,"COMPLEXPREFIXES",15) == 0)

    306. 

  306.                    complexprefixes = 1;

    307. 

  307. 

    308. 

  308.        /* parse in the flag used by the controlled compound words */

    309. 

  309.        if (strncmp(line,"COMPOUNDFLAG",12) == 0) {

    310. 

  310.           if (parse_flag(line, &compoundflag, "COMPOUNDFLAG")) {

    311. 

  311.              fclose(afflst);

    312. 

  312.              return 1;

    313. 

  313.           }

    314. 

  314.        }

    315. 

  315. 

    316. 

  316.        /* parse in the flag used by compound words */

    317. 

  317.        if (strncmp(line,"COMPOUNDBEGIN",13) == 0) {

    318. 

  318.           if (complexprefixes) {

    319. 

  319.             if (parse_flag(line, &compoundend, "COMPOUNDBEGIN")) {

    320. 

  320.               fclose(afflst);

    321. 

  321.               return 1;

    322. 

  322.             }

    323. 

  323.           } else {

    324. 

  324.             if (parse_flag(line, &compoundbegin, "COMPOUNDBEGIN")) {

    325. 

  325.               fclose(afflst);

    326. 

  326.               return 1;

    327. 

  327.             }

    328. 

  328.           }

    329. 

  329.        }

    330. 

  330. 

    331. 

  331.        /* parse in the flag used by compound words */

    332. 

  332.        if (strncmp(line,"COMPOUNDMIDDLE",14) == 0) {

    333. 

  333.           if (parse_flag(line, &compoundmiddle, "COMPOUNDMIDDLE")) {

    334. 

  334.              fclose(afflst);

    335. 

  335.              return 1;

    336. 

  336.           }

    337. 

  337.        }

    338. 

  338.        /* parse in the flag used by compound words */

    339. 

  339.        if (strncmp(line,"COMPOUNDEND",11) == 0) {

    340. 

  340.           if (complexprefixes) {

    341. 

  341.             if (parse_flag(line, &compoundbegin, "COMPOUNDEND")) {

    342. 

  342.               fclose(afflst);

    343. 

  343.               return 1;

    344. 

  344.             }

    345. 

  345.           } else {

    346. 

  346.             if (parse_flag(line, &compoundend, "COMPOUNDEND")) {

    347. 

  347.               fclose(afflst);

    348. 

  348.               return 1;

    349. 

  349.             }

    350. 

  350.           }

    351. 

  351.        }

    352. 

  352. 

    353. 

  353.        /* parse in the data used by compound_check() method */

    354. 

  354.        if (strncmp(line,"COMPOUNDWORDMAX",15) == 0) {

    355. 

  355.           if (parse_num(line, &cpdwordmax, "COMPOUNDWORDMAX")) {

    356. 

  356.              fclose(afflst);

    357. 

  357.              return 1;

    358. 

  358.           }

    359. 

  359.        }

    360. 

  360. 

    361. 

  361.        /* parse in the flag sign compounds in dictionary */

    362. 

  362.        if (strncmp(line,"COMPOUNDROOT",12) == 0) {

    363. 

  363.           if (parse_flag(line, &compoundroot, "COMPOUNDROOT")) {

    364. 

  364.              fclose(afflst);

    365. 

  365.              return 1;

    366. 

  366.           }

    367. 

  367.        }

    368. 

  368. 

    369. 

  369.        /* parse in the flag used by compound_check() method */

    370. 

  370.        if (strncmp(line,"COMPOUNDPERMITFLAG",18) == 0) {

    371. 

  371.           if (parse_flag(line, &compoundpermitflag, "COMPOUNDPERMITFLAG")) {

    372. 

  372.              fclose(afflst);

    373. 

  373.              return 1;

    374. 

  374.           }

    375. 

  375.        }

    376. 

  376. 

    377. 

  377.        /* parse in the flag used by compound_check() method */

    378. 

  378.        if (strncmp(line,"COMPOUNDFORBIDFLAG",18) == 0) {

    379. 

  379.           if (parse_flag(line, &compoundforbidflag, "COMPOUNDFORBIDFLAG")) {

    380. 

  380.              fclose(afflst);

    381. 

  381.              return 1;

    382. 

  382.           }

    383. 

  383.        }

    384. 

  384. 

    385. 

  385.        if (strncmp(line,"CHECKCOMPOUNDDUP",16) == 0) {

    386. 

  386.                    checkcompounddup = 1;

    387. 

  387.        }

    388. 

  388. 

    389. 

  389.        if (strncmp(line,"CHECKCOMPOUNDREP",16) == 0) {

    390. 

  390.                    checkcompoundrep = 1;

    391. 

  391.        }

    392. 

  392. 

    393. 

  393.        if (strncmp(line,"CHECKCOMPOUNDTRIPLE",19) == 0) {

    394. 

  394.                    checkcompoundtriple = 1;

    395. 

  395.        }

    396. 

  396. 

    397. 

  397.        if (strncmp(line,"CHECKCOMPOUNDCASE",17) == 0) {

    398. 

  398.                    checkcompoundcase = 1;

    399. 

  399.        }

    400. 

  400. 

    401. 

  401.        if (strncmp(line,"NOSUGGEST",9) == 0) {

    402. 

  402.           if (parse_flag(line, &nosuggest, "NOSUGGEST")) {

    403. 

  403.              fclose(afflst);

    404. 

  404.              return 1;

    405. 

  405.           }

    406. 

  406.        }

    407. 

  407. 

    408. 

  408.        /* parse in the flag used by forbidden words */

    409. 

  409.        if (strncmp(line,"FORBIDDENWORD",13) == 0) {

    410. 

  410.           if (parse_flag(line, &forbiddenword, "FORBIDDENWORD")) {

    411. 

  411.              fclose(afflst);

    412. 

  412.              return 1;

    413. 

  413.           }

    414. 

  414.        }

    415. 

  415. 

    416. 

  416.        /* parse in the flag used by forbidden words */

    417. 

  417.        if (strncmp(line,"LEMMA_PRESENT",13) == 0) {

    418. 

  418.           if (parse_flag(line, &lemma_present, "LEMMA_PRESENT")) {

    419. 

  419.              fclose(afflst);

    420. 

  420.              return 1;

    421. 

  421.           }

    422. 

  422.        }

    423. 

  423. 

    424. 

  424.        /* parse in the flag used by circumfixes */

    425. 

  425.        if (strncmp(line,"CIRCUMFIX",9) == 0) {

    426. 

  426.           if (parse_flag(line, &circumfix, "CIRCUMFIX")) {

    427. 

  427.              fclose(afflst);

    428. 

  428.              return 1;

    429. 

  429.           }

    430. 

  430.        }

    431. 

  431. 

    432. 

  432.        /* parse in the flag used by fogemorphemes */

    433. 

  433.        if (strncmp(line,"ONLYINCOMPOUND",14) == 0) {

    434. 

  434.           if (parse_flag(line, &onlyincompound, "ONLYINCOMPOUND")) {

    435. 

  435.              fclose(afflst);

    436. 

  436.              return 1;

    437. 

  437.           }

    438. 

  438.        }

    439. 

  439. 

    440. 

  440.        /* parse in the flag used by `pseudoroots' */

    441. 

  441.        if (strncmp(line,"PSEUDOROOT",10) == 0) {

    442. 

  442.           if (parse_flag(line, &pseudoroot, "PSEUDOROOT")) {

    443. 

  443.              fclose(afflst);

    444. 

  444.              return 1;

    445. 

  445.           }

    446. 

  446.        }

    447. 

  447. 

    448. 

  448.        /* parse in the flag used by `pseudoroots' */

    449. 

  449.        if (strncmp(line,"NEEDAFFIX",9) == 0) {

    450. 

  450.           if (parse_flag(line, &pseudoroot, "NEEDAFFIX")) {

    451. 

  451.              fclose(afflst);

    452. 

  452.              return 1;

    453. 

  453.           }

    454. 

  454.        }

    455. 

  455. 

    456. 

  456.        /* parse in the minimal length for words in compounds */

    457. 

  457.        if (strncmp(line,"COMPOUNDMIN",11) == 0) {

    458. 

  458.           if (parse_num(line, &cpdmin, "COMPOUNDMIN")) {

    459. 

  459.              fclose(afflst);

    460. 

  460.              return 1;

    461. 

  461.           }

    462. 

  462.           if (cpdmin < 1) cpdmin = 1;

    463. 

  463.        }

    464. 

  464. 

    465. 

  465.        /* parse in the max. words and syllables in compounds */

    466. 

  466.        if (strncmp(line,"COMPOUNDSYLLABLE",16) == 0) {

    467. 

  467.           if (parse_cpdsyllable(line)) {

    468. 

  468.              fclose(afflst);

    469. 

  469.              return 1;

    470. 

  470.           }

    471. 

  471.        }

    472. 

  472. 

    473. 

  473.        /* parse in the flag used by compound_check() method */

    474. 

  474.        if (strncmp(line,"SYLLABLENUM",11) == 0) {

    475. 

  475.           if (parse_string(line, &cpdsyllablenum, "SYLLABLENUM")) {

    476. 

  476.              fclose(afflst);

    477. 

  477.              return 1;

    478. 

  478.           }

    479. 

  479.        }

    480. 

  480. 

    481. 

  481.        /* parse in the flag used by the controlled compound words */

    482. 

  482.        if (strncmp(line,"CHECKNUM",8) == 0) {

    483. 

  483.            checknum=1;

    484. 

  484.        }

    485. 

  485. 

    486. 

  486.        /* parse in the extra word characters */

    487. 

  487.        if (strncmp(line,"WORDCHARS",9) == 0) {

    488. 

  488.           if (parse_array(line, &wordchars, &wordchars_utf16, &wordchars_utf16_len, "WORDCHARS", utf8)) {

    489. 

  489.              fclose(afflst);

    490. 

  490.              return 1;

    491. 

  491.           }

    492. 

  492.        }

    493. 

  493. 

    494. 

  494.        /* parse in the ignored characters (for example, Arabic optional diacretics charachters */

    495. 

  495.        if (strncmp(line,"IGNORE",6) == 0) {

    496. 

  496.           if (parse_array(line, &ignorechars, &ignorechars_utf16, &ignorechars_utf16_len, "IGNORE", utf8)) {

    497. 

  497.              fclose(afflst);

    498. 

  498.              return 1;

    499. 

  499.           }

    500. 

  500.        }

    501. 

  501. 

    502. 

  502.        /* parse in the typical fault correcting table */

    503. 

  503.        if (strncmp(line,"REP",3) == 0) {

    504. 

  504.           if (parse_reptable(line, afflst)) {

    505. 

  505.              fclose(afflst);

    506. 

  506.              return 1;

    507. 

  507.           }

    508. 

  508.        }

    509. 

  509. 

    510. 

  510.        /* parse in the checkcompoundpattern table */

    511. 

  511.        if (strncmp(line,"CHECKCOMPOUNDPATTERN",20) == 0) {

    512. 

  512.           if (parse_checkcpdtable(line, afflst)) {

    513. 

  513.              fclose(afflst);

    514. 

  514.              return 1;

    515. 

  515.           }

    516. 

  516.        }

    517. 

  517. 

    518. 

  518.        /* parse in the defcompound table */

    519. 

  519.        if (strncmp(line,"COMPOUNDRULE",12) == 0) {

    520. 

  520.           if (parse_defcpdtable(line, afflst)) {

    521. 

  521.              fclose(afflst);

    522. 

  522.              return 1;

    523. 

  523.           }

    524. 

  524.        }

    525. 

  525. 

    526. 

  526.        /* parse in the related character map table */

    527. 

  527.        if (strncmp(line,"MAP",3) == 0) {

    528. 

  528.           if (parse_maptable(line, afflst)) {

    529. 

  529.              fclose(afflst);

    530. 

  530.              return 1;

    531. 

  531.           }

    532. 

  532.        }

    533. 

  533. 

    534. 

  534.        /* parse in the word breakpoints table */

    535. 

  535.        if (strncmp(line,"BREAK",5) == 0) {

    536. 

  536.           if (parse_breaktable(line, afflst)) {

    537. 

  537.              fclose(afflst);

    538. 

  538.              return 1;

    539. 

  539.           }

    540. 

  540.        }

    541. 

  541. 

    542. 

  542.        /* parse in the language for language specific codes */

    543. 

  543.        if (strncmp(line,"LANG",4) == 0) {

    544. 

  544.           if (parse_string(line, &lang, "LANG")) {

    545. 

  545.              fclose(afflst);

    546. 

  546.              return 1;

    547. 

  547.           }

    548. 

  548.           langnum = get_lang_num(lang);

    549. 

  549.        }

    550. 

  550. 

    551. 

  551.        if (strncmp(line,"VERSION",7) == 0) {

    552. 

  552.           if (parse_string(line, &version, "VERSION")) {

    553. 

  553.              fclose(afflst);

    554. 

  554.              return 1;

    555. 

  555.           }

    556. 

  556.        }

    557. 

  557. 

    558. 

  558.        if (strncmp(line,"MAXNGRAMSUGS",12) == 0) {

    559. 

  559.           if (parse_num(line, &maxngramsugs, "MAXNGRAMSUGS")) {

    560. 

  560.              fclose(afflst);

    561. 

  561.              return 1;

    562. 

  562.           }

    563. 

  563.        }

    564. 

  564. 

    565. 

  565.        if (strncmp(line,"NOSPLITSUGS",11) == 0) {

    566. 

  566.                    nosplitsugs=1;

    567. 

  567.        }

    568. 

  568. 

    569. 

  569.        if (strncmp(line,"SUGSWITHDOTS",12) == 0) {

    570. 

  570.                    sugswithdots=1;

    571. 

  571.        }

    572. 

  572. 

    573. 

  573.        /* parse in the flag used by forbidden words */

    574. 

  574.        if (strncmp(line,"KEEPCASE",8) == 0) {

    575. 

  575.           if (parse_flag(line, &keepcase, "KEEPCASE")) {

    576. 

  576.              fclose(afflst);

    577. 

  577.              return 1;

    578. 

  578.           }

    579. 

  579.        }

    580. 

  580. 

    581. 

  581.        if (strncmp(line,"CHECKSHARPS",11) == 0) {

    582. 

  582.                    checksharps=1;

    583. 

  583.        }

    584. 

  584. 

    585. 

  585.        /* parse this affix: P - prefix, S - suffix */

    586. 

  586.        ft = ' ';

    587. 

  587.        if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';

    588. 

  588.        if (strncmp(line,"SFX",3) == 0) ft = complexprefixes ? 'P' : 'S';

    589. 

  589.        if (ft != ' ') {

    590. 

  590.           if (dupflags_ini) {

    591. 

  591.             for (int i = 0; i < CONTSIZE; i++) dupflags[i] = 0;

    592. 

  592.             dupflags_ini = 0;

    593. 

  593.           }

    594. 

  594.           if (parse_affix(line, ft, afflst, dupflags)) {

    595. 

  595.              fclose(afflst);

    596. 

  596.              process_pfx_tree_to_list();

    597. 

  597.              process_sfx_tree_to_list();

    598. 

  598.              return 1;

    599. 

  599.           }

    600. 

  600.        }

    601. 

  601. 

    602. 

  602.     }

    603. 

  603.     fclose(afflst);

    604. 

  604. 

    605. 

  605.     // convert affix trees to sorted list

    606. 

  606.     process_pfx_tree_to_list();

    607. 

  607.     process_sfx_tree_to_list();

    608. 

  608. 

    609. 

  609.     // now we can speed up performance greatly taking advantage of the 

    610. 

  610.     // relationship between the affixes and the idea of "subsets".

    611. 

  611. 

    612. 

  612.     // View each prefix as a potential leading subset of another and view

    613. 

  613.     // each suffix (reversed) as a potential trailing subset of another.

    614. 

  614. 

    615. 

  615.     // To illustrate this relationship if we know the prefix "ab" is found in the

    616. 

  616.     // word to examine, only prefixes that "ab" is a leading subset of need be examined.

    617. 

  617.     // Furthermore is "ab" is not present then none of the prefixes that "ab" is

    618. 

  618.     // is a subset need be examined.

    619. 

  619.     // The same argument goes for suffix string that are reversed.

    620. 

  620. 

    621. 

  621.     // Then to top this off why not examine the first char of the word to quickly

    622. 

  622.     // limit the set of prefixes to examine (i.e. the prefixes to examine must 

    623. 

  623.     // be leading supersets of the first character of the word (if they exist)

    624. 

  624.  

    625. 

  625.     // To take advantage of this "subset" relationship, we need to add two links

    626. 

  626.     // from entry.  One to take next if the current prefix is found (call it nexteq)

    627. 

  627.     // and one to take next if the current prefix is not found (call it nextne).

    628. 

  628. 

    629. 

  629.     // Since we have built ordered lists, all that remains is to properly intialize 

    630. 

  630.     // the nextne and nexteq pointers that relate them

    631. 

  631. 

    632. 

  632.     process_pfx_order();

    633. 

  633.     process_sfx_order();

    634. 

  634. 

    635. 

  635.     // expand wordchars string, based on csutil (for external tokenization)

    636. 

  636. 

    637. 

  637.     char * enc = get_encoding();

    638. 

  638.     csconv = get_current_cs(enc);

    639. 

  639.     free(enc);

    640. 

  640.     enc = NULL;

    641. 

  641. 

    642. 

  642.     char expw[MAXLNLEN];

    643. 

  643.     if (wordchars) {

    644. 

  644.         strcpy(expw, wordchars);

    645. 

  645.         free(wordchars);

    646. 

  646.     } else *expw = '\0';

    647. 

  647. 

    648. 

  648.     for (int i = 0; i <= 255; i++) {

    649. 

  649.         if ( (csconv[i].cupper != csconv[i].clower) &&

    650. 

  650.             (! strchr(expw, (char) i))) {

    651. 

  651.                 *(expw + strlen(expw) + 1) = '\0';

    652. 

  652.                 *(expw + strlen(expw)) = (char) i;

    653. 

  653.         }

    654. 

  654.     }

    655. 

  655. 

    656. 

  656.     wordchars = mystrdup(expw);

    657. 

  657. 

    658. 

  658.     // temporary BREAK definition for German dash handling (OOo issue 64400)

    659. 

  659.     if ((langnum == LANG_de) && (!breaktable)) {

    660. 

  660.         breaktable = (char **) malloc(sizeof(char *));

    661. 

  661.         if (!breaktable) return 1;

    662. 

  662.         breaktable[0] = mystrdup("-");

    663. 

  663.         numbreak = 1;

    664. 

  664.     }

    665. 

  665.     return 0;

    666. 

  666. }

    667. 

  667. 

    668. 

  668. 

    669. 

  669. // we want to be able to quickly access prefix information

    670. 

  670. // both by prefix flag, and sorted by prefix string itself 

    671. 

  671. // so we need to set up two indexes

    672. 

  672. 

    673. 

  673. int AffixMgr::build_pfxtree(AffEntry* pfxptr)

    674. 

  674. {

    675. 

  675.   PfxEntry * ptr;

    676. 

  676.   PfxEntry * pptr;

    677. 

  677.   PfxEntry * ep = (PfxEntry*) pfxptr;

    678. 

  678. 

    679. 

  679.   // get the right starting points

    680. 

  680.   const char * key = ep->getKey();

    681. 

  681.   const unsigned char flg = (unsigned char) (ep->getFlag() & 0x00FF);

    682. 

  682. 

    683. 

  683.   // first index by flag which must exist

    684. 

  684.   ptr = (PfxEntry*)pFlag[flg];

    685. 

  685.   ep->setFlgNxt(ptr);

    686. 

  686.   pFlag[flg] = (AffEntry *) ep;

    687. 

  687. 

    688. 

  688. 

    689. 

  689.   // handle the special case of null affix string

    690. 

  690.   if (strlen(key) == 0) {

    691. 

  691.     // always inset them at head of list at element 0

    692. 

  692.      ptr = (PfxEntry*)pStart[0];

    693. 

  693.      ep->setNext(ptr);

    694. 

  694.      pStart[0] = (AffEntry*)ep;

    695. 

  695.      return 0;

    696. 

  696.   }

    697. 

  697. 

    698. 

  698.   // now handle the normal case

    699. 

  699.   ep->setNextEQ(NULL);

    700. 

  700.   ep->setNextNE(NULL);

    701. 

  701. 

    702. 

  702.   unsigned char sp = *((const unsigned char *)key);

    703. 

  703.   ptr = (PfxEntry*)pStart[sp];

    704. 

  704.   

    705. 

  705.   // handle the first insert 

    706. 

  706.   if (!ptr) {

    707. 

  707.      pStart[sp] = (AffEntry*)ep;

    708. 

  708.      return 0;

    709. 

  709.   }

    710. 

  710. 

    711. 

  711. 

    712. 

  712.   // otherwise use binary tree insertion so that a sorted

    713. 

  713.   // list can easily be generated later

    714. 

  714.   pptr = NULL;

    715. 

  715.   for (;;) {

    716. 

  716.     pptr = ptr;

    717. 

  717.     if (strcmp(ep->getKey(), ptr->getKey() ) <= 0) {

    718. 

  718.        ptr = ptr->getNextEQ();

    719. 

  719.        if (!ptr) {

    720. 

  720.           pptr->setNextEQ(ep);

    721. 

  721.           break;

    722. 

  722.        }

    723. 

  723.     } else {

    724. 

  724.        ptr = ptr->getNextNE();

    725. 

  725.        if (!ptr) {

    726. 

  726.           pptr->setNextNE(ep);

    727. 

  727.           break;

    728. 

  728.        }

    729. 

  729.     }

    730. 

  730.   }

    731. 

  731.   return 0;

    732. 

  732. }

    733. 

  733. 

    734. 

  734. // we want to be able to quickly access suffix information

    735. 

  735. // both by suffix flag, and sorted by the reverse of the

    736. 

  736. // suffix string itself; so we need to set up two indexes

    737. 

  737. int AffixMgr::build_sfxtree(AffEntry* sfxptr)

    738. 

  738. {

    739. 

  739.   SfxEntry * ptr;

    740. 

  740.   SfxEntry * pptr;

    741. 

  741.   SfxEntry * ep = (SfxEntry *) sfxptr;

    742. 

  742. 

    743. 

  743.   /* get the right starting point */

    744. 

  744.   const char * key = ep->getKey();

    745. 

  745.   const unsigned char flg = (unsigned char) (ep->getFlag() & 0x00FF);

    746. 

  746. 

    747. 

  747.   // first index by flag which must exist

    748. 

  748.   ptr = (SfxEntry*)sFlag[flg];

    749. 

  749.   ep->setFlgNxt(ptr);

    750. 

  750.   sFlag[flg] = (AffEntry *) ep;

    751. 

  751. 

    752. 

  752.   // next index by affix string

    753. 

  753. 

    754. 

  754.   // handle the special case of null affix string

    755. 

  755.   if (strlen(key) == 0) {

    756. 

  756.     // always inset them at head of list at element 0

    757. 

  757.      ptr = (SfxEntry*)sStart[0];

    758. 

  758.      ep->setNext(ptr);

    759. 

  759.      sStart[0] = (AffEntry*)ep;

    760. 

  760.      return 0;

    761. 

  761.   }

    762. 

  762. 

    763. 

  763.   // now handle the normal case

    764. 

  764.   ep->setNextEQ(NULL);

    765. 

  765.   ep->setNextNE(NULL);

    766. 

  766. 

    767. 

  767.   unsigned char sp = *((const unsigned char *)key);

    768. 

  768.   ptr = (SfxEntry*)sStart[sp];

    769. 

  769.   

    770. 

  770.   // handle the first insert 

    771. 

  771.   if (!ptr) {

    772. 

  772.      sStart[sp] = (AffEntry*)ep;

    773. 

  773.      return 0;

    774. 

  774.   }

    775. 

  775. 

    776. 

  776.   // otherwise use binary tree insertion so that a sorted

    777. 

  777.   // list can easily be generated later

    778. 

  778.   pptr = NULL;

    779. 

  779.   for (;;) {

    780. 

  780.     pptr = ptr;

    781. 

  781.     if (strcmp(ep->getKey(), ptr->getKey() ) <= 0) {

    782. 

  782.        ptr = ptr->getNextEQ();

    783. 

  783.        if (!ptr) {

    784. 

  784.           pptr->setNextEQ(ep);

    785. 

  785.           break;

    786. 

  786.        }

    787. 

  787.     } else {

    788. 

  788.        ptr = ptr->getNextNE();

    789. 

  789.        if (!ptr) {

    790. 

  790.           pptr->setNextNE(ep);

    791. 

  791.           break;

    792. 

  792.        }

    793. 

  793.     }

    794. 

  794.   }

    795. 

  795.   return 0;

    796. 

  796. }

    797. 

  797. 

    798. 

  798. // convert from binary tree to sorted list

    799. 

  799. int AffixMgr::process_pfx_tree_to_list()

    800. 

  800. {

    801. 

  801.   for (int i=1; i< SETSIZE; i++) {

    802. 

  802.     pStart[i] = process_pfx_in_order(pStart[i],NULL);

    803. 

  803.   }

    804. 

  804.   return 0;

    805. 

  805. }

    806. 

  806. 

    807. 

  807. 

    808. 

  808. AffEntry* AffixMgr::process_pfx_in_order(AffEntry* ptr, AffEntry* nptr)

    809. 

  809. {

    810. 

  810.   if (ptr) {

    811. 

  811.     nptr = process_pfx_in_order(((PfxEntry*) ptr)->getNextNE(), nptr);

    812. 

  812.     ((PfxEntry*) ptr)->setNext((PfxEntry*) nptr);

    813. 

  813.     nptr = process_pfx_in_order(((PfxEntry*) ptr)->getNextEQ(), ptr);

    814. 

  814.   }

    815. 

  815.   return nptr;

    816. 

  816. }

    817. 

  817. 

    818. 

  818. 

    819. 

  819. // convert from binary tree to sorted list

    820. 

  820. int AffixMgr:: process_sfx_tree_to_list()

    821. 

  821. {

    822. 

  822.   for (int i=1; i< SETSIZE; i++) {

    823. 

  823.     sStart[i] = process_sfx_in_order(sStart[i],NULL);

    824. 

  824.   }

    825. 

  825.   return 0;

    826. 

  826. }

    827. 

  827. 

    828. 

  828. AffEntry* AffixMgr::process_sfx_in_order(AffEntry* ptr, AffEntry* nptr)

    829. 

  829. {

    830. 

  830.   if (ptr) {

    831. 

  831.     nptr = process_sfx_in_order(((SfxEntry*) ptr)->getNextNE(), nptr);

    832. 

  832.     ((SfxEntry*) ptr)->setNext((SfxEntry*) nptr);

    833. 

  833.     nptr = process_sfx_in_order(((SfxEntry*) ptr)->getNextEQ(), ptr);

    834. 

  834.   }

    835. 

  835.   return nptr;

    836. 

  836. }

    837. 

  837. 

    838. 

  838. 

    839. 

  839. // reinitialize the PfxEntry links NextEQ and NextNE to speed searching

    840. 

  840. // using the idea of leading subsets this time

    841. 

  841. int AffixMgr::process_pfx_order()

    842. 

  842. {

    843. 

  843.     PfxEntry* ptr;

    844. 

  844. 

    845. 

  845.     // loop through each prefix list starting point

    846. 

  846.     for (int i=1; i < SETSIZE; i++) {

    847. 

  847. 

    848. 

  848.          ptr = (PfxEntry*)pStart[i];

    849. 

  849. 

    850. 

  850.          // look through the remainder of the list

    851. 

  851.          //  and find next entry with affix that 

    852. 

  852.          // the current one is not a subset of

    853. 

  853.          // mark that as destination for NextNE

    854. 

  854.          // use next in list that you are a subset

    855. 

  855.          // of as NextEQ

    856. 

  856. 

    857. 

  857.          for (; ptr != NULL; ptr = ptr->getNext()) {

    858. 

  858. 

    859. 

  859.              PfxEntry * nptr = ptr->getNext();

    860. 

  860.              for (; nptr != NULL; nptr = nptr->getNext()) {

    861. 

  861.                  if (! isSubset( ptr->getKey() , nptr->getKey() )) break;

    862. 

  862.              }

    863. 

  863.              ptr->setNextNE(nptr);

    864. 

  864.              ptr->setNextEQ(NULL);

    865. 

  865.              if ((ptr->getNext()) && isSubset(ptr->getKey() , (ptr->getNext())->getKey())) 

    866. 

  866.                  ptr->setNextEQ(ptr->getNext());

    867. 

  867.          }

    868. 

  868. 

    869. 

  869.          // now clean up by adding smart search termination strings:

    870. 

  870.          // if you are already a superset of the previous prefix

    871. 

  871.          // but not a subset of the next, search can end here

    872. 

  872.          // so set NextNE properly

    873. 

  873. 

    874. 

  874.          ptr = (PfxEntry *) pStart[i];

    875. 

  875.          for (; ptr != NULL; ptr = ptr->getNext()) {

    876. 

  876.              PfxEntry * nptr = ptr->getNext();

    877. 

  877.              PfxEntry * mptr = NULL;

    878. 

  878.              for (; nptr != NULL; nptr = nptr->getNext()) {

    879. 

  879.                  if (! isSubset(ptr->getKey(),nptr->getKey())) break;

    880. 

  880.                  mptr = nptr;

    881. 

  881.              }

    882. 

  882.              if (mptr) mptr->setNextNE(NULL);

    883. 

  883.          }

    884. 

  884.     }

    885. 

  885.     return 0;

    886. 

  886. }

    887. 

  887. 

    888. 

  888. // initialize the SfxEntry links NextEQ and NextNE to speed searching

    889. 

  889. // using the idea of leading subsets this time

    890. 

  890. int AffixMgr::process_sfx_order()

    891. 

  891. {

    892. 

  892.     SfxEntry* ptr;

    893. 

  893. 

    894. 

  894.     // loop through each prefix list starting point

    895. 

  895.     for (int i=1; i < SETSIZE; i++) {

    896. 

  896. 

    897. 

  897.          ptr = (SfxEntry *) sStart[i];

    898. 

  898. 

    899. 

  899.          // look through the remainder of the list

    900. 

  900.          //  and find next entry with affix that 

    901. 

  901.          // the current one is not a subset of

    902. 

  902.          // mark that as destination for NextNE

    903. 

  903.          // use next in list that you are a subset

    904. 

  904.          // of as NextEQ

    905. 

  905. 

    906. 

  906.          for (; ptr != NULL; ptr = ptr->getNext()) {

    907. 

  907.              SfxEntry * nptr = ptr->getNext();

    908. 

  908.              for (; nptr != NULL; nptr = nptr->getNext()) {

    909. 

  909.                  if (! isSubset(ptr->getKey(),nptr->getKey())) break;

    910. 

  910.              }

    911. 

  911.              ptr->setNextNE(nptr);

    912. 

  912.              ptr->setNextEQ(NULL);

    913. 

  913.              if ((ptr->getNext()) && isSubset(ptr->getKey(),(ptr->getNext())->getKey())) 

    914. 

  914.                  ptr->setNextEQ(ptr->getNext());

    915. 

  915.          }

    916. 

  916. 

    917. 

  917. 

    918. 

  918.          // now clean up by adding smart search termination strings:

    919. 

  919.          // if you are already a superset of the previous suffix

    920. 

  920.          // but not a subset of the next, search can end here

    921. 

  921.          // so set NextNE properly

    922. 

  922. 

    923. 

  923.          ptr = (SfxEntry *) sStart[i];

    924. 

  924.          for (; ptr != NULL; ptr = ptr->getNext()) {

    925. 

  925.              SfxEntry * nptr = ptr->getNext();

    926. 

  926.              SfxEntry * mptr = NULL;

    927. 

  927.              for (; nptr != NULL; nptr = nptr->getNext()) {

    928. 

  928.                  if (! isSubset(ptr->getKey(),nptr->getKey())) break;

    929. 

  929.                  mptr = nptr;

    930. 

  930.              }

    931. 

  931.              if (mptr) mptr->setNextNE(NULL);

    932. 

  932.          }

    933. 

  933.     }

    934. 

  934.     return 0;

    935. 

  935. }

    936. 

  936. 

    937. 

  937. 

    938. 

  938. 

    939. 

  939. // takes aff file condition string and creates the

    940. 

  940. // conds array - please see the appendix at the end of the

    941. 

  941. // file affentry.cxx which describes what is going on here

    942. 

  942. // in much more detail

    943. 

  943. 

    944. 

  944. int AffixMgr::encodeit(struct affentry * ptr, char * cs)

    945. 

  945. {

    946. 

  946.   unsigned char c;

    947. 

  947.   int i, j, k;

    948. 

  948.   unsigned char mbr[MAXLNLEN];

    949. 

  949.   w_char wmbr[MAXLNLEN];

    950. 

  950.   w_char * wpos = wmbr;

    951. 

  951. 

    952. 

  952.   // now clear the conditions array */

    953. 

  953.   for (i=0;i<SETSIZE;i++) ptr->conds.base[i] = (unsigned char) 0;

    954. 

  954. 

    955. 

  955.   // now parse the string to create the conds array */

    956. 

  956.   int nc = strlen(cs);

    957. 

  957.   unsigned char neg = 0;   // complement indicator

    958. 

  958.   int grp = 0;   // group indicator

    959. 

  959.   unsigned char n = 0;     // number of conditions

    960. 

  960.   int ec = 0;    // end condition indicator

    961. 

  961.   int nm = 0;    // number of member in group

    962. 

  962. 

    963. 

  963.   // if no condition just return

    964. 

  964.   if (strcmp(cs,".")==0) {

    965. 

  965.     ptr->numconds = 0;

    966. 

  966.     return 0;

    967. 

  967.   }

    968. 

  968. 

    969. 

  969.   i = 0;

    970. 

  970.   while (i < nc) {

    971. 

  971.     c = *((unsigned char *)(cs + i));

    972. 

  972. 

    973. 

  973.     // start group indicator

    974. 

  974.     if (c == '[') {

    975. 

  975.        grp = 1;

    976. 

  976.        c = 0;

    977. 

  977.     }

    978. 

  978. 

    979. 

  979.     // complement flag

    980. 

  980.     if ((grp == 1) && (c == '^')) {

    981. 

  981.        neg = 1;

    982. 

  982.        c = 0;

    983. 

  983.     }

    984. 

  984. 

    985. 

  985.     // end goup indicator

    986. 

  986.     if (c == ']') {

    987. 

  987.        ec = 1;

    988. 

  988.        c = 0;

    989. 

  989.     }

    990. 

  990. 

    991. 

  991.     // add character of group to list

    992. 

  992.     if ((grp == 1) && (c != 0)) {

    993. 

  993.       *(mbr + nm) = c;

    994. 

  994.       nm++;

    995. 

  995.       c = 0;

    996. 

  996.     }

    997. 

  997. 

    998. 

  998.     // end of condition 

    999. 

  999.     if (c != 0) {

    1000. 

  1000.        ec = 1;

    1001. 

  1001.     }

    1002. 

  1002. 

    1003. 

  1003.   if (ec) {    

    1004. 

  1004.     if (!utf8) {

    1005. 

  1005.       if (grp == 1) {

    1006. 

  1006.         if (neg == 0) {

    1007. 

  1007.           // set the proper bits in the condition array vals for those chars

    1008. 

  1008.           for (j=0;j<nm;j++) {

    1009. 

  1009.              k = (unsigned int) mbr[j];

    1010. 

  1010.              ptr->conds.base[k] = ptr->conds.base[k] | ((unsigned char)1 << n);

    1011. 

  1011.           }

    1012. 

  1012.         } else {

    1013. 

  1013.           // complement so set all of them and then unset indicated ones

    1014. 

  1014.            for (j=0;j<SETSIZE;j++) ptr->conds.base[j] = ptr->conds.base[j] | ((unsigned char)1 << n);

    1015. 

  1015.            for (j=0;j<nm;j++) {

    1016. 

  1016.              k = (unsigned int) mbr[j];

    1017. 

  1017.              ptr->conds.base[k] = ptr->conds.base[k] & ~((unsigned char)1 << n);

    1018. 

  1018.            }

    1019. 

  1019.         }

    1020. 

  1020.         neg = 0;

    1021. 

  1021.         grp = 0;   

    1022. 

  1022.         nm = 0;

    1023. 

  1023.       } else {

    1024. 

  1024.          // not a group so just set the proper bit for this char

    1025. 

  1025.          // but first handle special case of . inside condition

    1026. 

  1026.          if (c == '.') {

    1027. 

  1027.             // wild card character so set them all

    1028. 

  1028.             for (j=0;j<SETSIZE;j++) ptr->conds.base[j] = ptr->conds.base[j] | ((unsigned char)1 << n);

    1029. 

  1029.          } else {  

    1030. 

  1030.             ptr->conds.base[(unsigned int) c] = ptr->conds.base[(unsigned int)c] | ((unsigned char)1 << n);

    1031. 

  1031.          }

    1032. 

  1032.       }

    1033. 

  1033.       n++;

    1034. 

  1034.       ec = 0;

    1035. 

  1035.     } else { // UTF-8 character set

    1036. 

  1036.       if (grp == 1) {

    1037. 

  1037.         ptr->conds.utf8.neg[n] = neg;

    1038. 

  1038.         if (neg == 0) {

    1039. 

  1039.           // set the proper bits in the condition array vals for those chars

    1040. 

  1040.           for (j=0;j<nm;j++) {

    1041. 

  1041.              k = (unsigned int) mbr[j];

    1042. 

  1042.              if (k >> 7) {

    1043. 

  1043.                 u8_u16(wpos, 1, (char *) mbr + j);

    1044. 

  1044.                 wpos++;

    1045. 

  1045.                 if ((k & 0xe0) == 0xe0) j+=2; else j++; // 3-byte UTF-8 character

    1046. 

  1046.              } else {

    1047. 

  1047.                 ptr->conds.utf8.ascii[k] = ptr->conds.utf8.ascii[k] | ((unsigned char)1 << n);

    1048. 

  1048.              }

    1049. 

  1049.           }

    1050. 

  1050.         } else { // neg == 1

    1051. 

  1051.           // complement so set all of them and then unset indicated ones

    1052. 

  1052.            for (j=0;j<(SETSIZE/2);j++) ptr->conds.utf8.ascii[j] = ptr->conds.utf8.ascii[j] | ((unsigned char)1 << n);

    1053. 

  1053.            for (j=0;j<nm;j++) {

    1054. 

  1054.              k = (unsigned int) mbr[j];

    1055. 

  1055.              if (k >> 7) {

    1056. 

  1056.                 u8_u16(wpos, 1, (char *) mbr + j);

    1057. 

  1057.                 wpos++;

    1058. 

  1058.                 if ((k & 0xe0) == 0xe0) j+=2; else j++; // 3-byte UTF-8 character

    1059. 

  1059.              } else {

    1060. 

  1060.                 ptr->conds.utf8.ascii[k] = ptr->conds.utf8.ascii[k] & ~((unsigned char)1 << n);

    1061. 

  1061.              }

    1062. 

  1062.            }

    1063. 

  1063.         }

    1064. 

  1064.         neg = 0;

    1065. 

  1065.         grp = 0;   

    1066. 

  1066.         nm = 0;

    1067. 

  1067.         ptr->conds.utf8.wlen[n] = wpos - wmbr;

    1068. 

  1068.         if ((wpos - wmbr) != 0) {

    1069. 

  1069.             ptr->conds.utf8.wchars[n] = (w_char *) malloc(sizeof(w_char) * (wpos - wmbr));

    1070. 

  1070.             if (!ptr->conds.utf8.wchars[n]) return 1;

    1071. 

  1071.             memcpy(ptr->conds.utf8.wchars[n], wmbr, sizeof(w_char) * (wpos - wmbr));

    1072. 

  1072.             flag_qsort((unsigned short *) ptr->conds.utf8.wchars[n], 0, ptr->conds.utf8.wlen[n]);

    1073. 

  1073.             wpos = wmbr;

    1074. 

  1074.         }

    1075. 

  1075.       } else { // grp == 0

    1076. 

  1076.          // is UTF-8 character?

    1077. 

  1077.          if (c >> 7) {

    1078. 

  1078.             ptr->conds.utf8.wchars[n] = (w_char *) malloc(sizeof(w_char));

    1079. 

  1079.             if (!ptr->conds.utf8.wchars[n]) return 1;

    1080. 

  1080.             ptr->conds.utf8.wlen[n] = 1;

    1081. 

  1081.             u8_u16(ptr->conds.utf8.wchars[n], 1, cs + i);

    1082. 

  1082.             if ((c & 0xe0) == 0xe0) i+=2; else i++; // 3-byte UFT-8 character

    1083. 

  1083.          } else {

    1084. 

  1084.             ptr->conds.utf8.wchars[n] = NULL;

    1085. 

  1085.             // not a group so just set the proper bit for this char

    1086. 

  1086.             // but first handle special case of . inside condition

    1087. 

  1087.             if (c == '.') {

    1088. 

  1088.                 ptr->conds.utf8.all[n] = 1;

    1089. 

  1089.                 // wild card character so set them all

    1090. 

  1090.                 for (j=0;j<(SETSIZE/2);j++) ptr->conds.utf8.ascii[j] = ptr->conds.utf8.ascii[j] | ((unsigned char)1 << n);

    1091. 

  1091.             } else {

    1092. 

  1092.                 ptr->conds.utf8.all[n] = 0;

    1093. 

  1093.                 ptr->conds.utf8.ascii[(unsigned int) c] = ptr->conds.utf8.ascii[(unsigned int)c] | ((unsigned char)1 << n);

    1094. 

  1094.             }

    1095. 

  1095.          }

    1096. 

  1096.          neg = 0;

    1097. 

  1097.       }

    1098. 

  1098.       n++;

    1099. 

  1099.       ec = 0;

    1100. 

  1100.       neg = 0;

    1101. 

  1101.     }  

    1102. 

  1102.   }

    1103. 

  1103. 

    1104. 

  1104.     i++;

    1105. 

  1105.   }

    1106. 

  1106.   ptr->numconds = n;

    1107. 

  1107.   return 0;

    1108. 

  1108. }

    1109. 

  1109. 

    1110. 

  1110.  // return 1 if s1 is a leading subset of s2

    1111. 

  1111. /* inline int AffixMgr::isSubset(const char * s1, const char * s2)

    1112. 

  1112.  {

    1113. 

  1113.     while ((*s1 == *s2) && *s1) {

    1114. 

  1114.         s1++;

    1115. 

  1115.         s2++;

    1116. 

  1116.     }

    1117. 

  1117.     return (*s1 == '\0');

    1118. 

  1118.  }

    1119. 

  1119. */

    1120. 

  1120. 

    1121. 

  1121.  // return 1 if s1 is a leading subset of s2 (dots are for infixes)

    1122. 

  1122. inline int AffixMgr::isSubset(const char * s1, const char * s2)

    1123. 

  1123.  {

    1124. 

  1124.     while (((*s1 == *s2) || (*s1 == '.')) && (*s1 != '\0')) {

    1125. 

  1125.         s1++;

    1126. 

  1126.         s2++;

    1127. 

  1127.     }

    1128. 

  1128.     return (*s1 == '\0');

    1129. 

  1129.  }

    1130. 

  1130. 

    1131. 

  1131. 

    1132. 

  1132. // check word for prefixes

    1133. 

  1133. struct hentry * AffixMgr::prefix_check(const char * word, int len, char in_compound,

    1134. 

  1134.     const FLAG needflag)

    1135. 

  1135. {

    1136. 

  1136.     struct hentry * rv= NULL;

    1137. 

  1137. 

    1138. 

  1138.     pfx = NULL;

    1139. 

  1139.     pfxappnd = NULL;

    1140. 

  1140.     sfxappnd = NULL;

    1141. 

  1141.     

    1142. 

  1142.     // first handle the special case of 0 length prefixes

    1143. 

  1143.     PfxEntry * pe = (PfxEntry *) pStart[0];

    1144. 

  1144.     while (pe) {

    1145. 

  1145.         if (

    1146. 

  1146.             // fogemorpheme

    1147. 

  1147.               ((in_compound != IN_CPD_NOT) || !(pe->getCont() &&

    1148. 

  1148.                   (TESTAFF(pe->getCont(), onlyincompound, pe->getContLen())))) &&

    1149. 

  1149.             // permit prefixes in compounds

    1150. 

  1150.               ((in_compound != IN_CPD_END) || (pe->getCont() &&

    1151. 

  1151.                   (TESTAFF(pe->getCont(), compoundpermitflag, pe->getContLen()))))

    1152. 

  1152.               ) {

    1153. 

  1153.                     // check prefix

    1154. 

  1154.                     rv = pe->checkword(word, len, in_compound, needflag);

    1155. 

  1155.                     if (rv) {

    1156. 

  1156.                         pfx=(AffEntry *)pe; // BUG: pfx not stateless

    1157. 

  1157.                         return rv;

    1158. 

  1158.                     }

    1159. 

  1159.              }

    1160. 

  1160.        pe = pe->getNext();

    1161. 

  1161.     }

    1162. 

  1162.   

    1163. 

  1163.     // now handle the general case

    1164. 

  1164.     unsigned char sp = *((const unsigned char *)word);

    1165. 

  1165.     PfxEntry * pptr = (PfxEntry *)pStart[sp];

    1166. 

  1166. 

    1167. 

  1167.     while (pptr) {

    1168. 

  1168.         if (isSubset(pptr->getKey(),word)) {

    1169. 

  1169.              if (

    1170. 

  1170.             // fogemorpheme

    1171. 

  1171.               ((in_compound != IN_CPD_NOT) || !(pptr->getCont() &&

    1172. 

  1172.                   (TESTAFF(pptr->getCont(), onlyincompound, pptr->getContLen())))) &&

    1173. 

  1173.             // permit prefixes in compounds

    1174. 

  1174.               ((in_compound != IN_CPD_END) || (pptr->getCont() &&

    1175. 

  1175.                   (TESTAFF(pptr->getCont(), compoundpermitflag, pptr->getContLen()))))

    1176. 

  1176.               ) {

    1177. 

  1177.             // check prefix

    1178. 

  1178.                   rv = pptr->checkword(word, len, in_compound, needflag);

    1179. 

  1179.                   if (rv) {

    1180. 

  1180.                     pfx=(AffEntry *)pptr; // BUG: pfx not stateless

    1181. 

  1181.                     return rv;

    1182. 

  1182.                   }

    1183. 

  1183.              }

    1184. 

  1184.              pptr = pptr->getNextEQ();

    1185. 

  1185.         } else {

    1186. 

  1186.              pptr = pptr->getNextNE();

    1187. 

  1187.         }

    1188. 

  1188.     }

    1189. 

  1189.     

    1190. 

  1190.     return NULL;

    1191. 

  1191. }

    1192. 

  1192. 

    1193. 

  1193. // check word for prefixes

    1194. 

  1194. struct hentry * AffixMgr::prefix_check_twosfx(const char * word, int len,

    1195. 

  1195.     char in_compound, const FLAG needflag)

    1196. 

  1196. {

    1197. 

  1197.     struct hentry * rv= NULL;

    1198. 

  1198. 

    1199. 

  1199.     pfx = NULL;

    1200. 

  1200.     sfxappnd = NULL;

    1201. 

  1201.     

    1202. 

  1202.     // first handle the special case of 0 length prefixes

    1203. 

  1203.     PfxEntry * pe = (PfxEntry *) pStart[0];

    1204. 

  1204.     

    1205. 

  1205.     while (pe) {

    1206. 

  1206.         rv = pe->check_twosfx(word, len, in_compound, needflag);

    1207. 

  1207.         if (rv) return rv;

    1208. 

  1208.         pe = pe->getNext();

    1209. 

  1209.     }

    1210. 

  1210.   

    1211. 

  1211.     // now handle the general case

    1212. 

  1212.     unsigned char sp = *((const unsigned char *)word);

    1213. 

  1213.     PfxEntry * pptr = (PfxEntry *)pStart[sp];

    1214. 

  1214. 

    1215. 

  1215.     while (pptr) {

    1216. 

  1216.         if (isSubset(pptr->getKey(),word)) {

    1217. 

  1217.             rv = pptr->check_twosfx(word, len, in_compound, needflag);

    1218. 

  1218.             if (rv) {

    1219. 

  1219.                 pfx = (AffEntry *)pptr;

    1220. 

  1220.                 return rv;

    1221. 

  1221.             }

    1222. 

  1222.             pptr = pptr->getNextEQ();

    1223. 

  1223.         } else {

    1224. 

  1224.              pptr = pptr->getNextNE();

    1225. 

  1225.         }

    1226. 

  1226.     }

    1227. 

  1227.     

    1228. 

  1228.     return NULL;

    1229. 

  1229. }

    1230. 

  1230. 

    1231. 

  1231. #ifdef HUNSPELL_EXPERIMENTAL

    1232. 

  1232. // check word for prefixes

    1233. 

  1233. char * AffixMgr::prefix_check_morph(const char * word, int len, char in_compound,

    1234. 

  1234.     const FLAG needflag)

    1235. 

  1235. {

    1236. 

  1236.     char * st;

    1237. 

  1237. 

    1238. 

  1238.     char result[MAXLNLEN];

    1239. 

  1239.     result[0] = '\0';

    1240. 

  1240. 

    1241. 

  1241.     pfx = NULL;

    1242. 

  1242.     sfxappnd = NULL;

    1243. 

  1243.     

    1244. 

  1244.     // first handle the special case of 0 length prefixes

    1245. 

  1245.     PfxEntry * pe = (PfxEntry *) pStart[0];

    1246. 

  1246.     while (pe) {

    1247. 

  1247.        st = pe->check_morph(word,len,in_compound, needflag);

    1248. 

  1248.        if (st) {

    1249. 

  1249.             strcat(result, st);

    1250. 

  1250.             free(st);

    1251. 

  1251.        }

    1252. 

  1252.        // if (rv) return rv;

    1253. 

  1253.        pe = pe->getNext();

    1254. 

  1254.     }

    1255. 

  1255.   

    1256. 

  1256.     // now handle the general case

    1257. 

  1257.     unsigned char sp = *((const unsigned char *)word);

    1258. 

  1258.     PfxEntry * pptr = (PfxEntry *)pStart[sp];

    1259. 

  1259. 

    1260. 

  1260.     while (pptr) {

    1261. 

  1261.         if (isSubset(pptr->getKey(),word)) {

    1262. 

  1262.             st = pptr->check_morph(word,len,in_compound, needflag);

    1263. 

  1263.             if (st) {

    1264. 

  1264.               // fogemorpheme

    1265. 

  1265.               if ((in_compound != IN_CPD_NOT) || !((pptr->getCont() && 

    1266. 

  1266.                         (TESTAFF(pptr->getCont(), onlyincompound, pptr->getContLen()))))) {

    1267. 

  1267.                     strcat(result, st);

    1268. 

  1268.                     pfx = (AffEntry *)pptr;

    1269. 

  1269.                 }

    1270. 

  1270.                 free(st);

    1271. 

  1271.             }

    1272. 

  1272.             pptr = pptr->getNextEQ();

    1273. 

  1273.         } else {

    1274. 

  1274.             pptr = pptr->getNextNE();

    1275. 

  1275.         }

    1276. 

  1276.     }

    1277. 

  1277.     

    1278. 

  1278.     if (*result) return mystrdup(result);

    1279. 

  1279.     return NULL;

    1280. 

  1280. }

    1281. 

  1281. 

    1282. 

  1282. 

    1283. 

  1283. // check word for prefixes

    1284. 

  1284. char * AffixMgr::prefix_check_twosfx_morph(const char * word, int len,

    1285. 

  1285.     char in_compound, const FLAG needflag)

    1286. 

  1286. {

    1287. 

  1287.     char * st;

    1288. 

  1288. 

    1289. 

  1289.     char result[MAXLNLEN];

    1290. 

  1290.     result[0] = '\0';

    1291. 

  1291. 

    1292. 

  1292.     pfx = NULL;

    1293. 

  1293.     sfxappnd = NULL;

    1294. 

  1294.     

    1295. 

  1295.     // first handle the special case of 0 length prefixes

    1296. 

  1296.     PfxEntry * pe = (PfxEntry *) pStart[0];

    1297. 

  1297.     while (pe) {

    1298. 

  1298.         st = pe->check_twosfx_morph(word,len,in_compound, needflag);

    1299. 

  1299.         if (st) {

    1300. 

  1300.             strcat(result, st);

    1301. 

  1301.             free(st);

    1302. 

  1302.         }

    1303. 

  1303.         pe = pe->getNext();

    1304. 

  1304.     }

    1305. 

  1305.   

    1306. 

  1306.     // now handle the general case

    1307. 

  1307.     unsigned char sp = *((const unsigned char *)word);

    1308. 

  1308.     PfxEntry * pptr = (PfxEntry *)pStart[sp];

    1309. 

  1309. 

    1310. 

  1310.     while (pptr) {

    1311. 

  1311.         if (isSubset(pptr->getKey(),word)) {

    1312. 

  1312.             st = pptr->check_twosfx_morph(word, len, in_compound, needflag);

    1313. 

  1313.             if (st) {

    1314. 

  1314.                 strcat(result, st);

    1315. 

  1315.                 free(st);

    1316. 

  1316.                 pfx = (AffEntry *)pptr;

    1317. 

  1317.             }

    1318. 

  1318.             pptr = pptr->getNextEQ();

    1319. 

  1319.         } else {

    1320. 

  1320.             pptr = pptr->getNextNE();

    1321. 

  1321.         }

    1322. 

  1322.     }

    1323. 

  1323.     

    1324. 

  1324.     if (*result) return mystrdup(result);

    1325. 

  1325.     return NULL;

    1326. 

  1326. }

    1327. 

  1327. #endif // END OF HUNSPELL_EXPERIMENTAL CODE

    1328. 

  1328. 

    1329. 

  1329. 

    1330. 

  1330. // Is word a non compound with a REP substitution (see checkcompoundrep)?

    1331. 

  1331. int AffixMgr::cpdrep_check(const char * word, int wl)

    1332. 

  1332. {

    1333. 

  1333.   char candidate[MAXLNLEN];

    1334. 

  1334.   const char * r;

    1335. 

  1335.   int lenr, lenp;

    1336. 

  1336. 

    1337. 

  1337.   if ((wl < 2) || !numrep) return 0;

    1338. 

  1338. 

    1339. 

  1339.   for (int i=0; i < numrep; i++ ) {

    1340. 

  1340.       r = word;

    1341. 

  1341.       lenr = strlen(reptable[i].pattern2);

    1342. 

  1342.       lenp = strlen(reptable[i].pattern);

    1343. 

  1343.       // search every occurence of the pattern in the word

    1344. 

  1344.       while ((r=strstr(r, reptable[i].pattern)) != NULL) {

    1345. 

  1345.           strcpy(candidate, word);

    1346. 

  1346.           if (r-word + lenr + strlen(r+lenp) >= MAXLNLEN) break;

    1347. 

  1347.           strcpy(candidate+(r-word),reptable[i].pattern2);

    1348. 

  1348.           strcpy(candidate+(r-word)+lenr, r+lenp);

    1349. 

  1349.           if (candidate_check(candidate,strlen(candidate))) return 1;

    1350. 

  1350.           r++; // search for the next letter

    1351. 

  1351.       }

    1352. 

  1352.    }

    1353. 

  1353.    return 0;

    1354. 

  1354. }

    1355. 

  1355. 

    1356. 

  1356. // forbid compoundings when there are special patterns at word bound

    1357. 

  1357. int AffixMgr::cpdpat_check(const char * word, int pos)

    1358. 

  1358. {

    1359. 

  1359.   int len;

    1360. 

  1360.   for (int i = 0; i < numcheckcpd; i++) {

    1361. 

  1361.       if (isSubset(checkcpdtable[i].pattern2, word + pos) &&

    1362. 

  1362.         (len = strlen(checkcpdtable[i].pattern)) && (pos > len) &&

    1363. 

  1363.         (strncmp(word + pos - len, checkcpdtable[i].pattern, len) == 0)) return 1;

    1364. 

  1364.   }

    1365. 

  1365.   return 0;

    1366. 

  1366. }

    1367. 

  1367. 

    1368. 

  1368. // forbid compounding with neighbouring upper and lower case characters at word bounds

    1369. 

  1369. int AffixMgr::cpdcase_check(const char * word, int pos)

    1370. 

  1370. {

    1371. 

  1371.   if (utf8) {

    1372. 

  1372.       w_char u, w;

    1373. 

  1373.       const char * p;

    1374. 

  1374.       u8_u16(&u, 1, word + pos);

    1375. 

  1375.       for (p = word + pos - 1; (*p & 0xc0) == 0x80; p--);

    1376. 

  1376.       u8_u16(&w, 1, p);

    1377. 

  1377.       unsigned short a = (u.h << 8) + u.l;

    1378. 

  1378.       unsigned short b = (w.h << 8) + w.l;

    1379. 

  1379.       if (((unicodetoupper(a, langnum) == a) || (unicodetoupper(b, langnum) == b))) return 1;

    1380. 

  1380.   } else {

    1381. 

  1381.       unsigned char a = *(word + pos - 1);

    1382. 

  1382.       unsigned char b = *(word + pos);

    1383. 

  1383.       if ((csconv[a].ccase || csconv[b].ccase) && (a != '-') && (b != '-')) return 1;

    1384. 

  1384.   }

    1385. 

  1385.   return 0;

    1386. 

  1386. }

    1387. 

  1387. 

    1388. 

  1388. // check compound patterns

    1389. 

  1389. int AffixMgr::defcpd_check(hentry *** words, short wnum, hentry * rv, hentry ** def, char all)

    1390. 

  1390. {

    1391. 

  1391.   signed short btpp[MAXWORDLEN]; // metacharacter (*, ?) positions for backtracking

    1392. 

  1392.   signed short btwp[MAXWORDLEN]; // word positions for metacharacters

    1393. 

  1393.   int btnum[MAXWORDLEN]; // number of matched characters in metacharacter positions

    1394. 

  1394.   short bt = 0;  

    1395. 

  1395.   int i;

    1396. 

  1396.   int ok;

    1397. 

  1397.   int w = 0;

    1398. 

  1398.   if (!*words) {

    1399. 

  1399.     w = 1;

    1400. 

  1400.     *words = def;

    1401. 

  1401.   }

    1402. 

  1402.   (*words)[wnum] = rv;

    1403. 

  1403. 

    1404. 

  1404.   for (i = 0; i < numdefcpd; i++) {

    1405. 

  1405.     signed short pp = 0; // pattern position

    1406. 

  1406.     signed short wp = 0; // "words" position

    1407. 

  1407.     int ok2;

    1408. 

  1408.     ok = 1;

    1409. 

  1409.     ok2 = 1;

    1410. 

  1410.     do {

    1411. 

  1411.       while ((pp < defcpdtable[i].len) && (wp <= wnum)) {

    1412. 

  1412.         if (((pp+1) < defcpdtable[i].len) &&

    1413. 

  1413.           ((defcpdtable[i].def[pp+1] == '*') || (defcpdtable[i].def[pp+1] == '?'))) {

    1414. 

  1414.             int wend = (defcpdtable[i].def[pp+1] == '?') ? wp : wnum;

    1415. 

  1415.             ok2 = 1;

    1416. 

  1416.             pp+=2;

    1417. 

  1417.             btpp[bt] = pp;

    1418. 

  1418.             btwp[bt] = wp;

    1419. 

  1419.             while (wp <= wend) {

    1420. 

  1420.                 if (!(*words)[wp]->alen || 

    1421. 

  1421.                   !TESTAFF((*words)[wp]->astr, defcpdtable[i].def[pp-2], (*words)[wp]->alen)) {

    1422. 

  1422.                     ok2 = 0;

    1423. 

  1423.                     break;

    1424. 

  1424.                 }

    1425. 

  1425.                 wp++;

    1426. 

  1426.             }

    1427. 

  1427.             if (wp <= wnum) ok2 = 0;

    1428. 

  1428.             btnum[bt] = wp - btwp[bt];

    1429. 

  1429.             if (btnum[bt] > 0) bt++;

    1430. 

  1430.             if (ok2) break;

    1431. 

  1431.         } else {

    1432. 

  1432.             ok2 = 1;

    1433. 

  1433.             if (!(*words)[wp] || !(*words)[wp]->alen || 

    1434. 

  1434.               !TESTAFF((*words)[wp]->astr, defcpdtable[i].def[pp], (*words)[wp]->alen)) {

    1435. 

  1435.                 ok = 0;

    1436. 

  1436.                 break;

    1437. 

  1437.             }

    1438. 

  1438.             pp++;

    1439. 

  1439.             wp++;

    1440. 

  1440.             if ((defcpdtable[i].len == pp) && !(wp > wnum)) ok = 0;

    1441. 

  1441.         }

    1442. 

  1442.       }

    1443. 

  1443.     if (ok && ok2) { 

    1444. 

  1444.         int r = pp;

    1445. 

  1445.         while ((defcpdtable[i].len > r) && ((r+1) < defcpdtable[i].len) &&

    1446. 

  1446.             ((defcpdtable[i].def[r+1] == '*') || (defcpdtable[i].def[r+1] == '?'))) r+=2;

    1447. 

  1447.         if (defcpdtable[i].len <= r) return 1;

    1448. 

  1448.     }    

    1449. 

  1449.     // backtrack

    1450. 

  1450.     if (bt) do {

    1451. 

  1451.         ok = 1;

    1452. 

  1452.         btnum[bt - 1]--;

    1453. 

  1453.         pp = btpp[bt - 1];

    1454. 

  1454.         wp = btwp[bt - 1] + btnum[bt - 1];

    1455. 

  1455.     } while ((btnum[bt - 1] < 0) && --bt);

    1456. 

  1456.   } while (bt);

    1457. 

  1457. 

    1458. 

  1458.   if (ok && ok2 && (!all || (defcpdtable[i].len <= pp))) return 1; 

    1459. 

  1459.   // check zero ending

    1460. 

  1460.   while (ok && ok2 && (defcpdtable[i].len > pp) && ((pp+1) < defcpdtable[i].len) &&

    1461. 

  1461.     ((defcpdtable[i].def[pp+1] == '*') || (defcpdtable[i].def[pp+1] == '?'))) pp+=2;

    1462. 

  1462.   if (ok && ok2 && (defcpdtable[i].len <= pp)) return 1;

    1463. 

  1463.   }

    1464. 

  1464.   (*words)[wnum] = NULL;

    1465. 

  1465.   if (w) *words = NULL;

    1466. 

  1466.   return 0;

    1467. 

  1467. }

    1468. 

  1468. 

    1469. 

  1469. inline int AffixMgr::candidate_check(const char * word, int len)

    1470. 

  1470. {

    1471. 

  1471.   struct hentry * rv=NULL;

    1472. 

  1472.   

    1473. 

  1473.   rv = lookup(word);

    1474. 

  1474.   if (rv) return 1;

    1475. 

  1475. 

    1476. 

  1476. //  rv = prefix_check(word,len,1);

    1477. 

  1477. //  if (rv) return 1;

    1478. 

  1478.   

    1479. 

  1479.   rv = affix_check(word,len);

    1480. 

  1480.   if (rv) return 1;

    1481. 

  1481.   return 0;

    1482. 

  1482. }

    1483. 

  1483. 

    1484. 

  1484. // calculate number of syllable for compound-checking

    1485. 

  1485. short AffixMgr::get_syllable(const char * word, int wlen)

    1486. 

  1486. {

    1487. 

  1487.     if (cpdmaxsyllable==0) return 0;

    1488. 

  1488.     

    1489. 

  1489.     short num=0;

    1490. 

  1490. 

    1491. 

  1491.     if (!utf8) {

    1492. 

  1492.         for (int i=0; i<wlen; i++) {

    1493. 

  1493.             if (strchr(cpdvowels, word[i])) num++;

    1494. 

  1494.         }

    1495. 

  1495.     } else if (cpdvowels_utf16) {

    1496. 

  1496.         w_char w[MAXWORDUTF8LEN];

    1497. 

  1497.         int i = u8_u16(w, MAXWORDUTF8LEN, word);

    1498. 

  1498.         for (; i; i--) {

    1499. 

  1499.             if (flag_bsearch((unsigned short *) cpdvowels_utf16,

    1500. 

  1500.                 ((unsigned short *) w)[i - 1], cpdvowels_utf16_len)) num++;

    1501. 

  1501.         }

    1502. 

  1502.     }

    1503. 

  1503.     return num;

    1504. 

  1504. }

    1505. 

  1505. 

    1506. 

  1506. // check if compound word is correctly spelled

    1507. 

  1507. // hu_mov_rule = spec. Hungarian rule (XXX)

    1508. 

  1508. struct hentry * AffixMgr::compound_check(const char * word, int len, 

    1509. 

  1509.     short wordnum, short numsyllable, short maxwordnum, short wnum, hentry ** words = NULL,

    1510. 

  1510.     char hu_mov_rule = 0, int * cmpdstemnum = NULL, int * cmpdstem = NULL, char is_sug = 0)

    1511. 

  1511. {

    1512. 

  1512.     int i; 

    1513. 

  1513.     short oldnumsyllable, oldnumsyllable2, oldwordnum, oldwordnum2;

    1514. 

  1514.     int oldcmpdstemnum = 0;

    1515. 

  1515.     struct hentry * rv = NULL;

    1516. 

  1516.     struct hentry * rv_first;

    1517. 

  1517.     struct hentry * rwords[MAXWORDLEN]; // buffer for COMPOUND pattern checking

    1518. 

  1518.     char st [MAXWORDUTF8LEN + 4];

    1519. 

  1519.     char ch;

    1520. 

  1520.     int cmin;

    1521. 

  1521.     int cmax;

    1522. 

  1522.     

    1523. 

  1523.     int checked_prefix;

    1524. 

  1524. 

    1525. 

  1525. #ifdef HUNSTEM

    1526. 

  1526.     if (cmpdstemnum) {

    1527. 

  1527.         if (wordnum == 0) {

    1528. 

  1528.             *cmpdstemnum = 1;

    1529. 

  1529.         } else {

    1530. 

  1530.             (*cmpdstemnum)++;

    1531. 

  1531.         }

    1532. 

  1532.     }

    1533. 

  1533. #endif

    1534. 

  1534.     if (utf8) {

    1535. 

  1535.         for (cmin = 0, i = 0; (i < cpdmin) && word[cmin]; i++) {

    1536. 

  1536.           cmin++;

    1537. 

  1537.           for (; (word[cmin] & 0xc0) == 0x80; cmin++);

    1538. 

  1538.         }

    1539. 

  1539.         for (cmax = len, i = 0; (i < (cpdmin - 1)) && cmax; i++) {

    1540. 

  1540.           cmax--;

    1541. 

  1541.           for (; (word[cmax] & 0xc0) == 0x80; cmax--);

    1542. 

  1542.         }

    1543. 

  1543.     } else {

    1544. 

  1544.         cmin = cpdmin;

    1545. 

  1545.         cmax = len - cpdmin + 1;

    1546. 

  1546.     }

    1547. 

  1547. 

    1548. 

  1548.     strcpy(st, word);

    1549. 

  1549. 

    1550. 

  1550.     for (i = cmin; i < cmax; i++) {

    1551. 

  1551. 

    1552. 

  1552.         oldnumsyllable = numsyllable;

    1553. 

  1553.         oldwordnum = wordnum;

    1554. 

  1554.         checked_prefix = 0;

    1555. 

  1555. 

    1556. 

  1556.         // go to end of the UTF-8 character

    1557. 

  1557.         if (utf8) {

    1558. 

  1558.             for (; (st[i] & 0xc0) == 0x80; i++);

    1559. 

  1559.             if (i >= cmax) return NULL;

    1560. 

  1560.         }

    1561. 

  1561. 

    1562. 

  1562.         

    1563. 

  1563.         ch = st[i];

    1564. 

  1564.         st[i] = '\0';

    1565. 

  1565. 

    1566. 

  1566.         sfx = NULL;

    1567. 

  1567.         pfx = NULL;

    1568. 

  1568.         

    1569. 

  1569.         // FIRST WORD

    1570. 

  1570.         

    1571. 

  1571.         rv = lookup(st); // perhaps without prefix

    1572. 

  1572. 

    1573. 

  1573.         // search homonym with compound flag

    1574. 

  1574.         while ((rv) && !hu_mov_rule &&

    1575. 

  1575.             ((pseudoroot && TESTAFF(rv->astr, pseudoroot, rv->alen)) ||

    1576. 

  1576.                 !((compoundflag && !words && TESTAFF(rv->astr, compoundflag, rv->alen)) ||

    1577. 

  1577.                   (compoundbegin && !wordnum &&

    1578. 

  1578.                         TESTAFF(rv->astr, compoundbegin, rv->alen)) ||

    1579. 

  1579.                   (compoundmiddle && wordnum && !words &&

    1580. 

  1580.                     TESTAFF(rv->astr, compoundmiddle, rv->alen)) ||

    1581. 

  1581.                   (numdefcpd &&

    1582. 

  1582.                     ((!words && !wordnum && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0)) ||

    1583. 

  1583.                     (words && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0))))

    1584. 

  1584.                   ))) {

    1585. 

  1585.             rv = rv->next_homonym;

    1586. 

  1586.         }

    1587. 

  1587. 

    1588. 

  1588.         if (!rv) {

    1589. 

  1589.             if (compoundflag && 

    1590. 

  1590.              !(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundflag))) {

    1591. 

  1591.                 if ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL,

    1592. 

  1592.                         FLAG_NULL, compoundflag, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) && !hu_mov_rule &&

    1593. 

  1593.                     ((SfxEntry*)sfx)->getCont() &&

    1594. 

  1594.                         ((compoundforbidflag && TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag, 

    1595. 

  1595.                             ((SfxEntry*)sfx)->getContLen())) || (compoundend &&

    1596. 

  1596.                         TESTAFF(((SfxEntry*)sfx)->getCont(), compoundend, 

    1597. 

  1597.                             ((SfxEntry*)sfx)->getContLen())))) {

    1598. 

  1598.                         rv = NULL;

    1599. 

  1599.                 }

    1600. 

  1600.             }

    1601. 

  1601.             if (rv ||

    1602. 

  1602.               (((wordnum == 0) && compoundbegin &&

    1603. 

  1603.                 ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundbegin, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||

    1604. 

  1604.                 (rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundbegin)))) ||

    1605. 

  1605.               ((wordnum > 0) && compoundmiddle &&

    1606. 

  1606.                 ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundmiddle, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||

    1607. 

  1607.                 (rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundmiddle)))))

    1608. 

  1608.               ) checked_prefix = 1;

    1609. 

  1609.         // else check forbiddenwords and pseudoroot

    1610. 

  1610.         } else if (rv->astr && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||

    1611. 

  1611.             TESTAFF(rv->astr, pseudoroot, rv->alen) || 

    1612. 

  1612.             (is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen))

    1613. 

  1613.              )) {

    1614. 

  1614.                 st[i] = ch;

    1615. 

  1615.                 continue;

    1616. 

  1616.         }

    1617. 

  1617. 

    1618. 

  1618.             // check non_compound flag in suffix and prefix

    1619. 

  1619.             if ((rv) && !hu_mov_rule &&

    1620. 

  1620.                 ((pfx && ((PfxEntry*)pfx)->getCont() &&

    1621. 

  1621.                     TESTAFF(((PfxEntry*)pfx)->getCont(), compoundforbidflag, 

    1622. 

  1622.                         ((PfxEntry*)pfx)->getContLen())) ||

    1623. 

  1623.                 (sfx && ((SfxEntry*)sfx)->getCont() &&

    1624. 

  1624.                     TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag, 

    1625. 

  1625.                         ((SfxEntry*)sfx)->getContLen())))) {

    1626. 

  1626.                     rv = NULL;

    1627. 

  1627.             }

    1628. 

  1628. 

    1629. 

  1629.             // check compoundend flag in suffix and prefix

    1630. 

  1630.             if ((rv) && !checked_prefix && compoundend && !hu_mov_rule &&

    1631. 

  1631.                 ((pfx && ((PfxEntry*)pfx)->getCont() &&

    1632. 

  1632.                     TESTAFF(((PfxEntry*)pfx)->getCont(), compoundend, 

    1633. 

  1633.                         ((PfxEntry*)pfx)->getContLen())) ||

    1634. 

  1634.                 (sfx && ((SfxEntry*)sfx)->getCont() &&

    1635. 

  1635.                     TESTAFF(((SfxEntry*)sfx)->getCont(), compoundend, 

    1636. 

  1636.                         ((SfxEntry*)sfx)->getContLen())))) {

    1637. 

  1637.                     rv = NULL;

    1638. 

  1638.             }

    1639. 

  1639.             

    1640. 

  1640.             // check compoundmiddle flag in suffix and prefix

    1641. 

  1641.             if ((rv) && !checked_prefix && (wordnum==0) && compoundmiddle && !hu_mov_rule &&

    1642. 

  1642.                 ((pfx && ((PfxEntry*)pfx)->getCont() &&

    1643. 

  1643.                     TESTAFF(((PfxEntry*)pfx)->getCont(), compoundmiddle, 

    1644. 

  1644.                         ((PfxEntry*)pfx)->getContLen())) ||

    1645. 

  1645.                 (sfx && ((SfxEntry*)sfx)->getCont() &&

    1646. 

  1646.                     TESTAFF(((SfxEntry*)sfx)->getCont(), compoundmiddle, 

    1647. 

  1647.                         ((SfxEntry*)sfx)->getContLen())))) {

    1648. 

  1648.                     rv = NULL;

    1649. 

  1649.             }       

    1650. 

  1650. 

    1651. 

  1651.         // check forbiddenwords

    1652. 

  1652.         if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||

    1653. 

  1653.             (is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) {

    1654. 

  1654.                 return NULL;

    1655. 

  1655.             }

    1656. 

  1656. 

    1657. 

  1657.         // increment word number, if the second root has a compoundroot flag

    1658. 

  1658.         if ((rv) && compoundroot && 

    1659. 

  1659.             (TESTAFF(rv->astr, compoundroot, rv->alen))) {

    1660. 

  1660.                 wordnum++;

    1661. 

  1661.         }

    1662. 

  1662. 

    1663. 

  1663.         // first word is acceptable in compound words?

    1664. 

  1664.         if (((rv) && 

    1665. 

  1665.           ( checked_prefix || (words && words[wnum]) ||

    1666. 

  1666.             (compoundflag && TESTAFF(rv->astr, compoundflag, rv->alen)) ||

    1667. 

  1667.             ((oldwordnum == 0) && compoundbegin && TESTAFF(rv->astr, compoundbegin, rv->alen)) ||

    1668. 

  1668.             ((oldwordnum > 0) && compoundmiddle && TESTAFF(rv->astr, compoundmiddle, rv->alen))// ||

    1669. 

  1669. //            (numdefcpd && )

    1670. 

  1670. 

    1671. 

  1671. // LANG_hu section: spec. Hungarian rule

    1672. 

  1672.             || ((langnum == LANG_hu) && hu_mov_rule && (

    1673. 

  1673.                     TESTAFF(rv->astr, 'F', rv->alen) || // XXX hardwired Hungarian dictionary codes

    1674. 

  1674.                     TESTAFF(rv->astr, 'G', rv->alen) ||

    1675. 

  1675.                     TESTAFF(rv->astr, 'H', rv->alen)

    1676. 

  1676.                 )

    1677. 

  1677.               )

    1678. 

  1678. // END of LANG_hu section

    1679. 

  1679.           )

    1680. 

  1680.           && ! (( checkcompoundtriple && // test triple letters

    1681. 

  1681.                    (word[i-1]==word[i]) && (

    1682. 

  1682.                       ((i>1) && (word[i-1]==word[i-2])) || 

    1683. 

  1683.                       ((word[i-1]==word[i+1])) // may be word[i+1] == '\0'

    1684. 

  1684.                    )

    1685. 

  1685.                ) ||

    1686. 

  1686.                ( 

    1687. 

  1687.                  // test CHECKCOMPOUNDPATTERN

    1688. 

  1688.                  numcheckcpd && cpdpat_check(word, i)

    1689. 

  1689.                ) ||

    1690. 

  1690.                ( 

    1691. 

  1691.                  checkcompoundcase && cpdcase_check(word, i)

    1692. 

  1692.                ))

    1693. 

  1693.          )

    1694. 

  1694. // LANG_hu section: spec. Hungarian rule

    1695. 

  1695.          || ((!rv) && (langnum == LANG_hu) && hu_mov_rule && (rv = affix_check(st,i)) &&

    1696. 

  1696.               (sfx && ((SfxEntry*)sfx)->getCont() && ( // XXX hardwired Hungarian dic. codes

    1697. 

  1697.                         TESTAFF(((SfxEntry*)sfx)->getCont(), (unsigned short) 'x', ((SfxEntry*)sfx)->getContLen()) ||

    1698. 

  1698.                         TESTAFF(((SfxEntry*)sfx)->getCont(), (unsigned short) '%', ((SfxEntry*)sfx)->getContLen())

    1699. 

  1699.                     )                

    1700. 

  1700.                )

    1701. 

  1701.              )

    1702. 

  1702. // END of LANG_hu section

    1703. 

  1703.          ) {

    1704. 

  1704. 

    1705. 

  1705. // LANG_hu section: spec. Hungarian rule

    1706. 

  1706.             if (langnum == LANG_hu) {

    1707. 

  1707.                 // calculate syllable number of the word            

    1708. 

  1708.                 numsyllable += get_syllable(st, i);

    1709. 

  1709. 

    1710. 

  1710.                 // + 1 word, if syllable number of the prefix > 1 (hungarian convention)

    1711. 

  1711.                 if (pfx && (get_syllable(((PfxEntry *)pfx)->getKey(),strlen(((PfxEntry *)pfx)->getKey())) > 1)) wordnum++;

    1712. 

  1712.             }

    1713. 

  1713. // END of LANG_hu section

    1714. 

  1714. 

    1715. 

  1715. #ifdef HUNSTEM

    1716. 

  1716.             if (cmpdstem) cmpdstem[*cmpdstemnum - 1] = i;

    1717. 

  1717. #endif

    1718. 

  1718. 

    1719. 

  1719.             // NEXT WORD(S)

    1720. 

  1720.             rv_first = rv;

    1721. 

  1721.             rv = lookup((word+i)); // perhaps without prefix

    1722. 

  1722. 

    1723. 

  1723.         // search homonym with compound flag

    1724. 

  1724.         while ((rv) && ((pseudoroot && TESTAFF(rv->astr, pseudoroot, rv->alen)) ||

    1725. 

  1725.                         !((compoundflag && !words && TESTAFF(rv->astr, compoundflag, rv->alen)) ||

    1726. 

  1726.                           (compoundend && !words && TESTAFF(rv->astr, compoundend, rv->alen)) ||

    1727. 

  1727.                            (numdefcpd && words && defcpd_check(&words, wnum + 1, rv, NULL,1))))) {

    1728. 

  1728.             rv = rv->next_homonym;

    1729. 

  1729.         }

    1730. 

  1730. 

    1731. 

  1731.             if (rv && words && words[wnum + 1]) return rv;

    1732. 

  1732. 

    1733. 

  1733.             oldnumsyllable2 = numsyllable;

    1734. 

  1734.             oldwordnum2 = wordnum;

    1735. 

  1735. 

    1736. 

  1736. // LANG_hu section: spec. Hungarian rule, XXX hardwired dictionary code

    1737. 

  1737.             if ((rv) && (langnum == LANG_hu) && (TESTAFF(rv->astr, 'I', rv->alen)) && !(TESTAFF(rv->astr, 'J', rv->alen))) {

    1738. 

  1738.                 numsyllable--;

    1739. 

  1739.             }

    1740. 

  1740. // END of LANG_hu section

    1741. 

  1741. 

    1742. 

  1742.             // increment word number, if the second root has a compoundroot flag

    1743. 

  1743.             if ((rv) && (compoundroot) && 

    1744. 

  1744.                 (TESTAFF(rv->astr, compoundroot, rv->alen))) {

    1745. 

  1745.                     wordnum++;

    1746. 

  1746.             }

    1747. 

  1747. 

    1748. 

  1748.             // check forbiddenwords

    1749. 

  1749.             if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||

    1750. 

  1750.                (is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) return NULL;

    1751. 

  1751. 

    1752. 

  1752.             // second word is acceptable, as a root?

    1753. 

  1753.             // hungarian conventions: compounding is acceptable,

    1754. 

  1754.             // when compound forms consist of 2 words, or if more,

    1755. 

  1755.             // then the syllable number of root words must be 6, or lesser.

    1756. 

  1756. 

    1757. 

  1757.             if ((rv) && (

    1758. 

  1758.                       (compoundflag && TESTAFF(rv->astr, compoundflag, rv->alen)) ||

    1759. 

  1759.                       (compoundend && TESTAFF(rv->astr, compoundend, rv->alen))

    1760. 

  1760.                     )

    1761. 

  1761.                 && (

    1762. 

  1762.                       ((cpdwordmax==-1) || (wordnum+1<cpdwordmax)) || 

    1763. 

  1763.                       ((cpdmaxsyllable==0) || 

    1764. 

  1764.                           (numsyllable + get_syllable(rv->word,rv->wlen)<=cpdmaxsyllable))

    1765. 

  1765.                     )

    1766. 

  1766.                 && (

    1767. 

  1767.                      (!checkcompounddup || (rv != rv_first))

    1768. 

  1768.                    )

    1769. 

  1769.                 )

    1770. 

  1770.                  {

    1771. 

  1771.                       // forbid compound word, if it is a non compound word with typical fault

    1772. 

  1772.                       if (checkcompoundrep && cpdrep_check(word,len)) return NULL;

    1773. 

  1773.                       return rv;

    1774. 

  1774.             }

    1775. 

  1775. 

    1776. 

  1776.             numsyllable = oldnumsyllable2 ;

    1777. 

  1777.             wordnum = oldwordnum2;

    1778. 

  1778. 

    1779. 

  1779.             // perhaps second word has prefix or/and suffix

    1780. 

  1780.             sfx = NULL;

    1781. 

  1781.             sfxflag = FLAG_NULL;

    1782. 

  1782.             rv = (compoundflag) ? affix_check((word+i),strlen(word+i), compoundflag, IN_CPD_END) : NULL;

    1783. 

  1783.             if (!rv && compoundend) {

    1784. 

  1784.                 sfx = NULL;

    1785. 

  1785.                 pfx = NULL;

    1786. 

  1786.                 rv = affix_check((word+i),strlen(word+i), compoundend, IN_CPD_END);

    1787. 

  1787.             }

    1788. 

  1788.             

    1789. 

  1789.             if (!rv && numdefcpd && words) {

    1790. 

  1790.                 rv = affix_check((word+i),strlen(word+i), 0, IN_CPD_END);

    1791. 

  1791.                 if (rv && defcpd_check(&words, wnum + 1, rv, NULL, 1)) return rv;

    1792. 

  1792.             }

    1793. 

  1793. 

    1794. 

  1794.             // check non_compound flag in suffix and prefix

    1795. 

  1795.             if ((rv) && 

    1796. 

  1796.                 ((pfx && ((PfxEntry*)pfx)->getCont() &&

    1797. 

  1797.                     TESTAFF(((PfxEntry*)pfx)->getCont(), compoundforbidflag, 

    1798. 

  1798.                         ((PfxEntry*)pfx)->getContLen())) ||

    1799. 

  1799.                 (sfx && ((SfxEntry*)sfx)->getCont() &&

    1800. 

  1800.                     TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag, 

    1801. 

  1801.                         ((SfxEntry*)sfx)->getContLen())))) {

    1802. 

  1802.                     rv = NULL;

    1803. 

  1803.             }

    1804. 

  1804. 

    1805. 

  1805.             // check forbiddenwords

    1806. 

  1806.             if ((rv) && (rv->astr) && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||

    1807. 

  1807.                (is_sug && nosuggest && TESTAFF(rv->astr, nosuggest, rv->alen)))) return NULL;

    1808. 

  1808. 

    1809. 

  1809.             // pfxappnd = prefix of word+i, or NULL

    1810. 

  1810.             // calculate syllable number of prefix.

    1811. 

  1811.             // hungarian convention: when syllable number of prefix is more,

    1812. 

  1812.             // than 1, the prefix+word counts as two words.

    1813. 

  1813. 

    1814. 

  1814.             if (langnum == LANG_hu) {

    1815. 

  1815.                 // calculate syllable number of the word

    1816. 

  1816.                 numsyllable += get_syllable(word + i, strlen(word + i));

    1817. 

  1817.                 

    1818. 

  1818.                 // - affix syllable num.

    1819. 

  1819.                 // XXX only second suffix (inflections, not derivations)

    1820. 

  1820.                 if (sfxappnd) {

    1821. 

  1821.                     char * tmp = myrevstrdup(sfxappnd);

    1822. 

  1822.                     numsyllable -= get_syllable(tmp, strlen(tmp));

    1823. 

  1823.                     free(tmp);

    1824. 

  1824.                 }

    1825. 

  1825.                 

    1826. 

  1826.                 // + 1 word, if syllable number of the prefix > 1 (hungarian convention)

    1827. 

  1827.                 if (pfx && (get_syllable(((PfxEntry *)pfx)->getKey(),strlen(((PfxEntry *)pfx)->getKey())) > 1)) wordnum++;

    1828. 

  1828. 

    1829. 

  1829.                 // increment syllable num, if last word has a SYLLABLENUM flag

    1830. 

  1830.                 // and the suffix is beginning `s'

    1831. 

  1831.             

    1832. 

  1832.                 if (cpdsyllablenum) {

    1833. 

  1833.                     switch (sfxflag) {

    1834. 

  1834.                         case 'c': { numsyllable+=2; break; }

    1835. 

  1835.                         case 'J': { numsyllable += 1; break; }

    1836. 

  1836.                         case 'I': { if (TESTAFF(rv->astr, 'J', rv->alen)) numsyllable += 1; break; }

    1837. 

  1837.                     }

    1838. 

  1838.                 }

    1839. 

  1839.             }

    1840. 

  1840.             

    1841. 

  1841.             // increment word number, if the second word has a compoundroot flag

    1842. 

  1842.             if ((rv) && (compoundroot) && 

    1843. 

  1843.                 (TESTAFF(rv->astr, compoundroot, rv->alen))) {

    1844. 

  1844.                     wordnum++;

    1845. 

  1845.             }

    1846. 

  1846. 

    1847. 

  1847.             // second word is acceptable, as a word with prefix or/and suffix?

    1848. 

  1848.             // hungarian conventions: compounding is acceptable,

    1849. 

  1849.             // when compound forms consist 2 word, otherwise

    1850. 

  1850.             // the syllable number of root words is 6, or lesser.

    1851. 

  1851.             if ((rv) && 

    1852. 

  1852.                     (

    1853. 

  1853.                       ((cpdwordmax == -1) || (wordnum + 1 < cpdwordmax)) || 

    1854. 

  1854.                       ((cpdmaxsyllable == 0) || 

    1855. 

  1855.                           (numsyllable <= cpdmaxsyllable))

    1856. 

  1856.                     )

    1857. 

  1857.                 && (

    1858. 

  1858.                    (!checkcompounddup || (rv != rv_first))

    1859. 

  1859.                    )) {

    1860. 

  1860.                     // forbid compound word, if it is a non compound word with typical fault

    1861. 

  1861.                     if (checkcompoundrep && cpdrep_check(word, len)) return NULL;

    1862. 

  1862.                     return rv;

    1863. 

  1863.             }

    1864. 

  1864. 

    1865. 

  1865.             numsyllable = oldnumsyllable2;

    1866. 

  1866.             wordnum = oldwordnum2;

    1867. 

  1867. #ifdef HUNSTEM

    1868. 

  1868.             if (cmpdstemnum) oldcmpdstemnum = *cmpdstemnum;

    1869. 

  1869. #endif

    1870. 

  1870.             // perhaps second word is a compound word (recursive call)

    1871. 

  1871.             if (wordnum < maxwordnum) {

    1872. 

  1872.                 rv = compound_check((word+i),strlen(word+i), wordnum+1,

    1873. 

  1873.                      numsyllable, maxwordnum, wnum + 1, words,

    1874. 

  1874.                      0, cmpdstemnum, cmpdstem, is_sug);

    1875. 

  1875.             } else {

    1876. 

  1876.                 rv=NULL;

    1877. 

  1877.             }

    1878. 

  1878.             if (rv) {

    1879. 

  1879.                 // forbid compound word, if it is a non compound word with typical fault

    1880. 

  1880.                 if (checkcompoundrep && cpdrep_check(word, len)) return NULL;

    1881. 

  1881.                 return rv;

    1882. 

  1882.             } else {

    1883. 

  1883. #ifdef HUNSTEM

    1884. 

  1884.             if (cmpdstemnum) *cmpdstemnum = oldcmpdstemnum;

    1885. 

  1885. #endif

    1886. 

  1886.             }

    1887. 

  1887.         }

    1888. 

  1888.         st[i] = ch;

    1889. 

  1889.         wordnum = oldwordnum;

    1890. 

  1890.         numsyllable = oldnumsyllable;

    1891. 

  1891.     }

    1892. 

  1892.     

    1893. 

  1893.     return NULL;

    1894. 

  1894. }    

    1895. 

  1895. 

    1896. 

  1896. #ifdef HUNSPELL_EXPERIMENTAL

    1897. 

  1897. // check if compound word is correctly spelled

    1898. 

  1898. // hu_mov_rule = spec. Hungarian rule (XXX)

    1899. 

  1899. int AffixMgr::compound_check_morph(const char * word, int len, 

    1900. 

  1900.     short wordnum, short numsyllable, short maxwordnum, short wnum, hentry ** words,

    1901. 

  1901.     char hu_mov_rule = 0, char ** result = NULL, char * partresult = NULL)

    1902. 

  1902. {

    1903. 

  1903.     int i;

    1904. 

  1904.     short oldnumsyllable, oldnumsyllable2, oldwordnum, oldwordnum2;

    1905. 

  1905.     int ok = 0;

    1906. 

  1906. 

    1907. 

  1907.     struct hentry * rv = NULL;

    1908. 

  1908.     struct hentry * rv_first;

    1909. 

  1909.     struct hentry * rwords[MAXWORDLEN]; // buffer for COMPOUND pattern checking

    1910. 

  1910.     char st [MAXWORDUTF8LEN + 4];

    1911. 

  1911.     char ch;

    1912. 

  1912.     

    1913. 

  1913.     int checked_prefix;

    1914. 

  1914.     char presult[MAXLNLEN];

    1915. 

  1915. 

    1916. 

  1916.     int cmin;

    1917. 

  1917.     int cmax;

    1918. 

  1918.     

    1919. 

  1919.     if (utf8) {

    1920. 

  1920.         for (cmin = 0, i = 0; (i < cpdmin) && word[cmin]; i++) {

    1921. 

  1921.           cmin++;

    1922. 

  1922.           for (; (word[cmin] & 0xc0) == 0x80; cmin++);

    1923. 

  1923.         }

    1924. 

  1924.         for (cmax = len, i = 0; (i < (cpdmin - 1)) && cmax; i++) {

    1925. 

  1925.           cmax--;

    1926. 

  1926.           for (; (word[cmax] & 0xc0) == 0x80; cmax--);

    1927. 

  1927.         }

    1928. 

  1928.     } else {

    1929. 

  1929.         cmin = cpdmin;

    1930. 

  1930.         cmax = len - cpdmin + 1;

    1931. 

  1931.     }

    1932. 

  1932. 

    1933. 

  1933.     strcpy(st, word);

    1934. 

  1934. 

    1935. 

  1935.     for (i = cmin; i < cmax; i++) {

    1936. 

  1936.         oldnumsyllable = numsyllable;

    1937. 

  1937.         oldwordnum = wordnum;

    1938. 

  1938.         checked_prefix = 0;

    1939. 

  1939. 

    1940. 

  1940.         // go to end of the UTF-8 character

    1941. 

  1941.         if (utf8) {

    1942. 

  1942.             for (; (st[i] & 0xc0) == 0x80; i++);

    1943. 

  1943.             if (i >= cmax) return 0;

    1944. 

  1944.         }

    1945. 

  1945.         

    1946. 

  1946.         ch = st[i];

    1947. 

  1947.         st[i] = '\0';

    1948. 

  1948.         sfx = NULL;

    1949. 

  1949. 

    1950. 

  1950.         // FIRST WORD

    1951. 

  1951.         *presult = '\0';

    1952. 

  1952.         if (partresult) strcat(presult, partresult);

    1953. 

  1953.         

    1954. 

  1954.         rv = lookup(st); // perhaps without prefix

    1955. 

  1955. 

    1956. 

  1956.         // search homonym with compound flag

    1957. 

  1957.         while ((rv) && !hu_mov_rule && 

    1958. 

  1958.             ((pseudoroot && TESTAFF(rv->astr, pseudoroot, rv->alen)) ||

    1959. 

  1959.                 !((compoundflag && !words && TESTAFF(rv->astr, compoundflag, rv->alen)) ||

    1960. 

  1960.                 (compoundbegin && !wordnum &&

    1961. 

  1961.                         TESTAFF(rv->astr, compoundbegin, rv->alen)) ||

    1962. 

  1962.                 (compoundmiddle && wordnum && !words &&

    1963. 

  1963.                     TESTAFF(rv->astr, compoundmiddle, rv->alen)) ||

    1964. 

  1964.                   (numdefcpd &&

    1965. 

  1965.                     ((!words && !wordnum && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0)) ||

    1966. 

  1966.                     (words && defcpd_check(&words, wnum, rv, (hentry **) &rwords, 0))))

    1967. 

  1967.                   ))) {

    1968. 

  1968.             rv = rv->next_homonym;

    1969. 

  1969.         }

    1970. 

  1970. 

    1971. 

  1971.         if (rv)  {

    1972. 

  1972.             if (rv->description) {

    1973. 

  1973.                 if ((!rv->astr) || !TESTAFF(rv->astr, lemma_present, rv->alen))

    1974. 

  1974.                                         strcat(presult, st);

    1975. 

  1975.                 strcat(presult, rv->description);

    1976. 

  1976.             }

    1977. 

  1977.         }

    1978. 

  1978.         

    1979. 

  1979.         if (!rv) {

    1980. 

  1980.             if (compoundflag && 

    1981. 

  1981.              !(rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundflag))) {

    1982. 

  1982.                 if ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL,

    1983. 

  1983.                         FLAG_NULL, compoundflag, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) && !hu_mov_rule &&

    1984. 

  1984.                     ((SfxEntry*)sfx)->getCont() &&

    1985. 

  1985.                         ((compoundforbidflag && TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag, 

    1986. 

  1986.                             ((SfxEntry*)sfx)->getContLen())) || (compoundend &&

    1987. 

  1987.                         TESTAFF(((SfxEntry*)sfx)->getCont(), compoundend, 

    1988. 

  1988.                             ((SfxEntry*)sfx)->getContLen())))) {

    1989. 

  1989.                         rv = NULL;

    1990. 

  1990.                 }

    1991. 

  1991.             }

    1992. 

  1992.             

    1993. 

  1993.             if (rv ||

    1994. 

  1994.               (((wordnum == 0) && compoundbegin &&

    1995. 

  1995.                 ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundbegin, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||

    1996. 

  1996.                 (rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundbegin)))) ||

    1997. 

  1997.               ((wordnum > 0) && compoundmiddle &&

    1998. 

  1998.                 ((rv = suffix_check(st, i, 0, NULL, NULL, 0, NULL, FLAG_NULL, compoundmiddle, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN)) ||

    1999. 

  1999.                 (rv = prefix_check(st, i, hu_mov_rule ? IN_CPD_OTHER : IN_CPD_BEGIN, compoundmiddle)))))

    2000. 

  2000.               ) {

    2001. 

  2001.                 //char * p = prefix_check_morph(st, i, 0, compound);

    2002. 

  2002.                 char * p = NULL;

    2003. 

  2003.                 if (compoundflag) p = affix_check_morph(st, i, compoundflag);

    2004. 

  2004.                 if (!p || (*p == '\0')) {

    2005. 

  2005.                    if ((wordnum == 0) && compoundbegin) {

    2006. 

  2006.                      p = affix_check_morph(st, i, compoundbegin);

    2007. 

  2007.                    } else if ((wordnum > 0) && compoundmiddle) {

    2008. 

  2008.                      p = affix_check_morph(st, i, compoundmiddle);                   

    2009. 

  2009.                    }

    2010. 

  2010.                 }

    2011. 

  2011.                 if (*p != '\0') {

    2012. 

  2012.                     line_uniq(p);

    2013. 

  2013.                     if (strchr(p, '\n')) {

    2014. 

  2014.                         strcat(presult, "(");

    2015. 

  2015.                         strcat(presult, line_join(p, '|'));

    2016. 

  2016.                         strcat(presult, ")");

    2017. 

  2017.                       } else {

    2018. 

  2018.                         strcat(presult, p);

    2019. 

  2019.                       }

    2020. 

  2020.                 }

    2021. 

  2021.                 if (presult[strlen(presult) - 1] == '\n') {

    2022. 

  2022.                     presult[strlen(presult) - 1] = '\0';

    2023. 

  2023.                 }

    2024. 

  2024.                 checked_prefix = 1;

    2025. 

  2025.                 //strcat(presult, "+");

    2026. 

  2026.             }

    2027. 

  2027.         // else check forbiddenwords

    2028. 

  2028.         } else if (rv->astr && (TESTAFF(rv->astr, forbiddenword, rv->alen) ||

    2029. 

  2029.             TESTAFF(rv->astr, pseudoroot, rv->alen))) {

    2030. 

  2030.                 st[i] = ch;

    2031. 

  2031.                 continue;

    2032. 

  2032.         }

    2033. 

  2033. 

    2034. 

  2034.             // check non_compound flag in suffix and prefix

    2035. 

  2035.             if ((rv) && !hu_mov_rule &&

    2036. 

  2036.                 ((pfx && ((PfxEntry*)pfx)->getCont() &&

    2037. 

  2037.                     TESTAFF(((PfxEntry*)pfx)->getCont(), compoundforbidflag, 

    2038. 

  2038.                         ((PfxEntry*)pfx)->getContLen())) ||

    2039. 

  2039.                 (sfx && ((SfxEntry*)sfx)->getCont() &&

    2040. 

  2040.                     TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag, 

    2041. 

  2041.                         ((SfxEntry*)sfx)->getContLen())))) {

    2042. 

  2042.                     continue;

    2043. 

  2043.             }

    2044. 

  2044. 

    2045. 

  2045.             // check compoundend flag in suffix and prefix

    2046. 

  2046.             if ((rv) && !checked_prefix && compoundend && !hu_mov_rule &&

    2047. 

  2047.                 ((pfx && ((PfxEntry*)pfx)->getCont() &&

    2048. 

  2048.                     TESTAFF(((PfxEntry*)pfx)->getCont(), compoundend, 

    2049. 

  2049.                         ((PfxEntry*)pfx)->getContLen())) ||

    2050. 

  2050.                 (sfx && ((SfxEntry*)sfx)->getCont() &&

    2051. 

  2051.                     TESTAFF(((SfxEntry*)sfx)->getCont(), compoundend, 

    2052. 

  2052.                         ((SfxEntry*)sfx)->getContLen())))) {

    2053. 

  2053.                     continue;

    2054. 

  2054.             }

    2055. 

  2055. 

    2056. 

  2056.             // check compoundmiddle flag in suffix and prefix

    2057. 

  2057.             if ((rv) && !checked_prefix && (wordnum==0) && compoundmiddle && !hu_mov_rule &&

    2058. 

  2058.                 ((pfx && ((PfxEntry*)pfx)->getCont() &&

    2059. 

  2059.                     TESTAFF(((PfxEntry*)pfx)->getCont(), compoundmiddle, 

    2060. 

  2060.                         ((PfxEntry*)pfx)->getContLen())) ||

    2061. 

  2061.                 (sfx && ((SfxEntry*)sfx)->getCont() &&

    2062. 

  2062.                     TESTAFF(((SfxEntry*)sfx)->getCont(), compoundmiddle, 

    2063. 

  2063.                         ((SfxEntry*)sfx)->getContLen())))) {

    2064. 

  2064.                     rv = NULL;

    2065. 

  2065.             }       

    2066. 

  2066. 

    2067. 

  2067.         // check forbiddenwords

    2068. 

  2068.         if ((rv) && (rv->astr) && TESTAFF(rv->astr, forbiddenword, rv->alen)) continue;

    2069. 

  2069. 

    2070. 

  2070.         // increment word number, if the second root has a compoundroot flag

    2071. 

  2071.         if ((rv) && (compoundroot) && 

    2072. 

  2072.             (TESTAFF(rv->astr, compoundroot, rv->alen))) {

    2073. 

  2073.                 wordnum++;

    2074. 

  2074.         }

    2075. 

  2075. 

    2076. 

  2076.         // first word is acceptable in compound words?

    2077. 

  2077.         if (((rv) && 

    2078. 

  2078.           ( checked_prefix || (words && words[wnum]) ||

    2079. 

  2079.             (compoundflag && TESTAFF(rv->astr, compoundflag, rv->alen)) ||

    2080. 

  2080.             ((oldwordnum == 0) && compoundbegin && TESTAFF(rv->astr, compoundbegin, rv->alen)) ||

    2081. 

  2081.             ((oldwordnum > 0) && compoundmiddle && TESTAFF(rv->astr, compoundmiddle, rv->alen)) 

    2082. 

  2082. // LANG_hu section: spec. Hungarian rule

    2083. 

  2083.             || ((langnum == LANG_hu) && // hu_mov_rule

    2084. 

  2084.                 hu_mov_rule && (

    2085. 

  2085.                     TESTAFF(rv->astr, 'F', rv->alen) ||

    2086. 

  2086.                     TESTAFF(rv->astr, 'G', rv->alen) ||

    2087. 

  2087.                     TESTAFF(rv->astr, 'H', rv->alen)

    2088. 

  2088.                 )

    2089. 

  2089.               )

    2090. 

  2090. // END of LANG_hu section

    2091. 

  2091.           )

    2092. 

  2092.           && ! (( checkcompoundtriple && // test triple letters

    2093. 

  2093.                    (word[i-1]==word[i]) && (

    2094. 

  2094.                       ((i>1) && (word[i-1]==word[i-2])) || 

    2095. 

  2095.                       ((word[i-1]==word[i+1])) // may be word[i+1] == '\0'

    2096. 

  2096.                    )

    2097. 

  2097.                ) ||

    2098. 

  2098.                (

    2099. 

  2099.                    // test CHECKCOMPOUNDPATTERN

    2100. 

  2100.                    numcheckcpd && cpdpat_check(word, i)

    2101. 

  2101.                ) ||

    2102. 

  2102.                ( 

    2103. 

  2103.                  checkcompoundcase && cpdcase_check(word, i)

    2104. 

  2104.                ))

    2105. 

  2105.          )

    2106. 

  2106. // LANG_hu section: spec. Hungarian rule

    2107. 

  2107.          || ((!rv) && (langnum == LANG_hu) && hu_mov_rule && (rv = affix_check(st,i)) &&

    2108. 

  2108.               (sfx && ((SfxEntry*)sfx)->getCont() && (

    2109. 

  2109.                         TESTAFF(((SfxEntry*)sfx)->getCont(), (unsigned short) 'x', ((SfxEntry*)sfx)->getContLen()) ||

    2110. 

  2110.                         TESTAFF(((SfxEntry*)sfx)->getCont(), (unsigned short) '%', ((SfxEntry*)sfx)->getContLen())

    2111. 

  2111.                     )                

    2112. 

  2112.                )

    2113. 

  2113.              )

    2114. 

  2114. // END of LANG_hu section

    2115. 

  2115.          ) {

    2116. 

  2116. 

    2117. 

  2117. // LANG_hu section: spec. Hungarian rule

    2118. 

  2118.             if (langnum == LANG_hu) {

    2119. 

  2119.                 // calculate syllable number of the word

    2120. 

  2120.                 numsyllable += get_syllable(st, i);

    2121. 

  2121. 

    2122. 

  2122.                 // + 1 word, if syllable number of the prefix > 1 (hungarian convention)

    2123. 

  2123.                 if (pfx && (get_syllable(((PfxEntry *)pfx)->getKey(),strlen(((PfxEntry *)pfx)->getKey())) > 1)) wordnum++;

    2124. 

  2124.             }

    2125. 

  2125. // END of LANG_hu section

    2126. 

  2126. 

    2127. 

  2127.             // NEXT WORD(S)

    2128. 

  2128.             rv_first = rv;

    2129. 

  2129.             rv = lookup((word+i)); // perhaps without prefix

    2130. 

  2130. 

    2131. 

  2131.         // search homonym with compound flag

    2132. 

  2132.         while ((rv) && ((pseudoroot && TESTAFF(rv->astr, pseudoroot, rv->alen)) ||

    2133. 

  2133.                         !((compoundflag && !words && TESTAFF(rv->astr, compoundflag, rv->alen)) ||

    2134. 

  2134.                           (compoundend && !words && TESTAFF(rv->astr, compoundend, rv->alen)) ||

    2135. 

  2135.                            (numdefcpd && defcpd_check(&words, wnum + 1, rv, NULL,1))))) {

    2136. 

  2136.             rv = rv->next_homonym;

    2137. 

  2137.         }

    2138. 

  2138. 

    2139. 

  2139.             if (rv && words && words[wnum + 1]) {

    2140. 

  2140.                   strcat(*result, presult);

    2141. 

  2141.                   if (complexprefixes && rv->description) strcat(*result, rv->description);

    2142. 

  2142.                   if (rv->description && ((!rv->astr) || 

    2143. 

  2143.                      !TESTAFF(rv->astr, lemma_present, rv->alen)))

    2144. 

  2144.                         strcat(*result, rv->word);

    2145. 

  2145.                   if (!complexprefixes && rv->description) strcat(*result, rv->description);

    2146. 

  2146.                   strcat(*result, "\n");

    2147. 

  2147.                   ok = 1;

    2148. 

  2148.                   return 0;

    2149. 

  2149.             }

    2150. 

  2150. 

    2151. 

  2151.             oldnumsyllable2 = numsyllable;

    2152. 

  2152.             oldwordnum2 = wordnum;

    2153. 

  2153. 

    2154. 

  2154. // LANG_hu section: spec. Hungarian rule

    2155. 

  2155.             if ((rv) && (langnum == LANG_hu) && (TESTAFF(rv->astr, 'I', rv->alen)) && !(TESTAFF(rv->astr, 'J', rv->alen))) {

    2156. 

  2156.                 numsyllable--;

    2157. 

  2157.             }

    2158. 

  2158. // END of LANG_hu section

    2159. 

  2159.             // increment word number, if the second root has a compoundroot flag

    2160. 

  2160.             if ((rv) && (compoundroot) && 

    2161. 

  2161.                 (TESTAFF(rv->astr, compoundroot, rv->alen))) {

    2162. 

  2162.                     wordnum++;

    2163. 

  2163.             }

    2164. 

  2164. 

    2165. 

  2165.             // check forbiddenwords

    2166. 

  2166.             if ((rv) && (rv->astr) && TESTAFF(rv->astr, forbiddenword, rv->alen)) {

    2167. 

  2167.                 st[i] = ch;

    2168. 

  2168.                 continue;

    2169. 

  2169.             }

    2170. 

  2170.                     

    2171. 

  2171.             // second word is acceptable, as a root?

    2172. 

  2172.             // hungarian conventions: compounding is acceptable,

    2173. 

  2173.             // when compound forms consist of 2 words, or if more,

    2174. 

  2174.             // then the syllable number of root words must be 6, or lesser.

    2175. 

  2175.             if ((rv) && (

    2176. 

  2176.                       (compoundflag && TESTAFF(rv->astr, compoundflag, rv->alen)) ||

    2177. 

  2177.                       (compoundend && TESTAFF(rv->astr, compoundend, rv->alen))

    2178. 

  2178.                     )

    2179. 

  2179.                 && (

    2180. 

  2180.                       ((cpdwordmax==-1) || (wordnum+1<cpdwordmax)) || 

    2181. 

  2181.                       ((cpdmaxsyllable==0) || 

    2182. 

  2182.                           (numsyllable+get_syllable(rv->word,rv->wlen)<=cpdmaxsyllable))

    2183. 

  2183.                     )

    2184. 

  2184.                 && (

    2185. 

  2185.                      (!checkcompounddup || (rv != rv_first))

    2186. 

  2186.                    )

    2187. 

  2187.                 )

    2188. 

  2188.                  {

    2189. 

  2189.                       // bad compound word

    2190. 

  2190.                       strcat(*result, presult);

    2191. 

  2191.                                           

    2192. 

  2192.                       if (rv->description) {

    2193. 

  2193.                         if (complexprefixes) strcat(*result, rv->description);

    2194. 

  2194.                         if ((!rv->astr) || !TESTAFF(rv->astr, lemma_present, rv->alen))

    2195. 

  2195.                                                strcat(*result, rv->word);

    2196. 

  2196.                         if (!complexprefixes) strcat(*result, rv->description);

    2197. 

  2197.                       }

    2198. 

  2198.                       strcat(*result, "\n");

    2199. 

  2199.                               ok = 1;

    2200. 

  2200.             }

    2201. 

  2201. 

    2202. 

  2202.             numsyllable = oldnumsyllable2 ;

    2203. 

  2203.             wordnum = oldwordnum2;

    2204. 

  2204. 

    2205. 

  2205.             // perhaps second word has prefix or/and suffix

    2206. 

  2206.             sfx = NULL;

    2207. 

  2207.             sfxflag = FLAG_NULL;

    2208. 

  2208. 

    2209. 

  2209.             if (compoundflag) rv = affix_check((word+i),strlen(word+i), compoundflag); else rv = NULL;

    2210. 

  2210. 

    2211. 

  2211.             if (!rv && compoundend) {

    2212. 

  2212.                 sfx = NULL;

    2213. 

  2213.                 pfx = NULL;

    2214. 

  2214.                 rv = affix_check((word+i),strlen(word+i), compoundend);

    2215. 

  2215.             }

    2216. 

  2216. 

    2217. 

  2217.             if (!rv && numdefcpd && words) {

    2218. 

  2218.                 rv = affix_check((word+i),strlen(word+i), 0, IN_CPD_END);

    2219. 

  2219.                 if (rv && words && defcpd_check(&words, wnum + 1, rv, NULL, 1)) {

    2220. 

  2220.                       char * m = NULL;

    2221. 

  2221.                       if (compoundflag) m = affix_check_morph((word+i),strlen(word+i), compoundflag);

    2222. 

  2222.                       if ((!m || *m == '\0') && compoundend)

    2223. 

  2223.                             m = affix_check_morph((word+i),strlen(word+i), compoundend);

    2224. 

  2224.                       strcat(*result, presult);

    2225. 

  2225.                       if (m) {

    2226. 

  2226.                         line_uniq(m);

    2227. 

  2227.                         if (strchr(m, '\n')) {

    2228. 

  2228.                             strcat(*result, "(");

    2229. 

  2229.                             strcat(*result, line_join(m, '|'));

    2230. 

  2230.                             strcat(*result, ")");

    2231. 

  2231.                         } else {

    2232. 

  2232.                             strcat(*result, m);

    2233. 

  2233.                         }

    2234. 

  2234.                         free(m);

    2235. 

  2235.                       }

    2236. 

  2236.                       strcat(*result, "\n");

    2237. 

  2237.                       ok = 1;

    2238. 

  2238.                 }

    2239. 

  2239.             }

    2240. 

  2240. 

    2241. 

  2241.             // check non_compound flag in suffix and prefix

    2242. 

  2242.             if ((rv) && 

    2243. 

  2243.                 ((pfx && ((PfxEntry*)pfx)->getCont() &&

    2244. 

  2244.                     TESTAFF(((PfxEntry*)pfx)->getCont(), compoundforbidflag, 

    2245. 

  2245.                         ((PfxEntry*)pfx)->getContLen())) ||

    2246. 

  2246.                 (sfx && ((SfxEntry*)sfx)->getCont() &&

    2247. 

  2247.                     TESTAFF(((SfxEntry*)sfx)->getCont(), compoundforbidflag, 

    2248. 

  2248.                         ((SfxEntry*)sfx)->getContLen())))) {

    2249. 

  2249.                     rv = NULL;

    2250. 

  2250.             }

    2251. 

  2251. 

    2252. 

  2252.             // check forbiddenwords

    2253. 

  2253.             if ((rv) && (rv->astr) && (TESTAFF(rv->astr,forbiddenword,rv->alen))

    2254. 

  2254.                     && (! TESTAFF(rv->astr, pseudoroot, rv->alen))) {

    2255. 

  2255.                         st[i] = ch;

    2256. 

  2256.                         continue;

    2257. 

  2257.                     }

    2258. 

  2258. 

    2259. 

  2259.             if (langnum == LANG_hu) {

    2260. 

  2260.                 // calculate syllable number of the word

    2261. 

  2261.                 numsyllable += get_syllable(word + i, strlen(word + i));

    2262. 

  2262. 

    2263. 

  2263.                 // - affix syllable num.

    2264. 

  2264.                 // XXX only second suffix (inflections, not derivations)

    2265. 

  2265.                 if (sfxappnd) {

    2266. 

  2266.                     char * tmp = myrevstrdup(sfxappnd);

    2267. 

  2267.                     numsyllable -= get_syllable(tmp, strlen(tmp));

    2268. 

  2268.                     free(tmp);

    2269. 

  2269.                 }

    2270. 

  2270. 

    2271. 

  2271.                 // + 1 word, if syllable number of the prefix > 1 (hungarian convention)

    2272. 

  2272.                 if (pfx && (get_syllable(((PfxEntry *)pfx)->getKey(),strlen(((PfxEntry *)pfx)->getKey())) > 1)) wordnum++;

    2273. 

  2273. 

    2274. 

  2274.                 // increment syllable num, if last word has a SYLLABLENUM flag

    2275. 

  2275.                 // and the suffix is beginning `s'

    2276. 

  2276. 

    2277. 

  2277.                 if (cpdsyllablenum) {

    2278. 

  2278.                     switch (sfxflag) {

    2279. 

  2279.                         case 'c': { numsyllable+=2; break; }

    2280. 

  2280.                         case 'J': { numsyllable += 1; break; }

    2281. 

  2281.                         case 'I': { if (rv && TESTAFF(rv->astr, 'J', rv->alen)) numsyllable += 1; break; }

    2282. 

  2282.                     }

    2283. 

  2283.                 }

    2284. 

  2284.             }

    2285. 

  2285. 

    2286. 

  2286.             // increment word number, if the second word has a compoundroot flag

    2287. 

  2287.             if ((rv) && (compoundroot) && 

    2288. 

  2288.                 (TESTAFF(rv->astr, compoundroot, rv->alen))) {

    2289. 

  2289.                     wordnum++;

    2290. 

  2290.             }

    2291. 

  2291.             // second word is acceptable, as a word with prefix or/and suffix?

    2292. 

  2292.             // hungarian conventions: compounding is acceptable,

    2293. 

  2293.             // when compound forms consist 2 word, otherwise

    2294. 

  2294.             // the syllable number of root words is 6, or lesser.

    2295. 

  2295.             if ((rv) && 

    2296. 

  2296.                     (

    2297. 

  2297.                       ((cpdwordmax==-1) || (wordnum+1<cpdwordmax)) || 

    2298. 

  2298.                       ((cpdmaxsyllable==0) || 

    2299. 

  2299.                           (numsyllable <= cpdmaxsyllable))

    2300. 

  2300.                     )

    2301. 

  2301.                 && (

    2302. 

  2302.                    (!checkcompounddup || (rv != rv_first))

    2303. 

  2303.                    )) {

    2304. 

  2304.                       char * m = NULL;

    2305. 

  2305.                       if (compoundflag) m = affix_check_morph((word+i),strlen(word+i), compoundflag);

    2306. 

  2306.                       if ((!m || *m == '\0') && compoundend)

    2307. 

  2307.                             m = affix_check_morph((word+i),strlen(word+i), compoundend);

    2308. 

  2308.                       strcat(*result, presult);

    2309. 

  2309.                       if (m) {

    2310. 

  2310.                         line_uniq(m);

    2311. 

  2311.                         if (strchr(m, '\n')) {

    2312. 

  2312.                             strcat(*result, "(");

    2313. 

  2313.                             strcat(*result, line_join(m, '|'));

    2314. 

  2314.                             strcat(*result, ")");

    2315. 

  2315.                         } else {

    2316. 

  2316.                             strcat(*result, m);

    2317. 

  2317.                         }

    2318. 

  2318.                         free(m);

    2319. 

  2319.                       }

    2320. 

  2320.                       strcat(*result, "\n");

    2321. 

  2321.                       ok = 1;

    2322. 

  2322.             }

    2323. 

  2323. 

    2324. 

  2324.             numsyllable = oldnumsyllable2;

    2325. 

  2325.             wordnum = oldwordnum2;

    2326. 

  2326. 

    2327. 

  2327.             // perhaps second word is a compound word (recursive call)

    2328. 

  2328.             if ((wordnum < maxwordnum) && (ok == 0)) {

    2329. 

  2329.                         compound_check_morph((word+i),strlen(word+i), wordnum+1, 

    2330. 

  2330.                              numsyllable, maxwordnum, wnum + 1, words, 0, result, presult);

    2331. 

  2331.             } else {

    2332. 

  2332.                 rv=NULL;

    2333. 

  2333.             }

    2334. 

  2334.         }

    2335. 

  2335.         st[i] = ch;

    2336. 

  2336.         wordnum = oldwordnum;

    2337. 

  2337.         numsyllable = oldnumsyllable;

    2338. 

  2338.     }

    2339. 

  2339.     return 0;

    2340. 

  2340. }    

    2341. 

  2341. #endif // END OF HUNSPELL_EXPERIMENTAL CODE

    2342. 

  2342. 

    2343. 

  2343.  // return 1 if s1 (reversed) is a leading subset of end of s2

    2344. 

  2344. /* inline int AffixMgr::isRevSubset(const char * s1, const char * end_of_s2, int len)

    2345. 

  2345.  {

    2346. 

  2346.     while ((len > 0) && *s1 && (*s1 == *end_of_s2)) {

    2347. 

  2347.         s1++;

    2348. 

  2348.         end_of_s2--;

    2349. 

  2349.         len--;

    2350. 

  2350.     }

    2351. 

  2351.     return (*s1 == '\0');

    2352. 

  2352.  }

    2353. 

  2353.  */

    2354. 

  2354. 

    2355. 

  2355. inline int AffixMgr::isRevSubset(const char * s1, const char * end_of_s2, int len)

    2356. 

  2356.  {

    2357. 

  2357.     while ((len > 0) && (*s1 != '\0') && ((*s1 == *end_of_s2) || (*s1 == '.'))) {

    2358. 

  2358.         s1++;

    2359. 

  2359.         end_of_s2--;

    2360. 

  2360.         len--;

    2361. 

  2361.     }

    2362. 

  2362.     return (*s1 == '\0');

    2363. 

  2363.  }

    2364. 

  2364. 

    2365. 

  2365. // check word for suffixes

    2366. 

  2366. 

    2367. 

  2367. struct hentry * AffixMgr::suffix_check (const char * word, int len, 

    2368. 

  2368.        int sfxopts, AffEntry * ppfx, char ** wlst, int maxSug, int * ns, 

    2369. 

  2369.        const FLAG cclass, const FLAG needflag, char in_compound)

    2370. 

  2370. {

    2371. 

  2371.     struct hentry * rv = NULL;

    2372. 

  2372.     char result[MAXLNLEN];

    2373. 

  2373. 

    2374. 

  2374.     PfxEntry* ep = (PfxEntry *) ppfx;

    2375. 

  2375. 

    2376. 

  2376.     // first handle the special case of 0 length suffixes

    2377. 

  2377.     SfxEntry * se = (SfxEntry *) sStart[0];

    2378. 

  2378. 

    2379. 

  2379.     while (se) {

    2380. 

  2380.         if (!cclass || se->getCont()) {

    2381. 

  2381.             // suffixes are not allowed in beginning of compounds

    2382. 

  2382.             if ((((in_compound != IN_CPD_BEGIN)) || // && !cclass

    2383. 

  2383.              // except when signed with compoundpermitflag flag

    2384. 

  2384.              (se->getCont() && compoundpermitflag &&

    2385. 

  2385.                 TESTAFF(se->getCont(),compoundpermitflag,se->getContLen()))) && (!circumfix ||

    2386. 

  2386.               // no circumfix flag in prefix and suffix

    2387. 

  2387.               ((!ppfx || !(ep->getCont()) || !TESTAFF(ep->getCont(),

    2388. 

  2388.                    circumfix, ep->getContLen())) &&

    2389. 

  2389.                (!se->getCont() || !(TESTAFF(se->getCont(),circumfix,se->getContLen())))) ||

    2390. 

  2390.               // circumfix flag in prefix AND suffix

    2391. 

  2391.               ((ppfx && (ep->getCont()) && TESTAFF(ep->getCont(),

    2392. 

  2392.                    circumfix, ep->getContLen())) &&

    2393. 

  2393.                (se->getCont() && (TESTAFF(se->getCont(),circumfix,se->getContLen())))))  &&

    2394. 

  2394.             // fogemorpheme

    2395. 

  2395.               (in_compound || 

    2396. 

  2396.                  !((se->getCont() && (TESTAFF(se->getCont(), onlyincompound, se->getContLen()))))) &&

    2397. 

  2397.             // pseudoroot on prefix or first suffix

    2398. 

  2398.               (cclass || 

    2399. 

  2399.                    !(se->getCont() && TESTAFF(se->getCont(), pseudoroot, se->getContLen())) ||

    2400. 

  2400.                    (ppfx && !((ep->getCont()) &&

    2401. 

  2401.                      TESTAFF(ep->getCont(), pseudoroot,

    2402. 

  2402.                        ep->getContLen())))

    2403. 

  2403.               )

    2404. 

  2404.             ) {

    2405. 

  2405.                 rv = se->checkword(word,len, sfxopts, ppfx, wlst, maxSug, ns, (FLAG) cclass, 

    2406. 

  2406.                     needflag, (in_compound ? 0 : onlyincompound));

    2407. 

  2407.                 if (rv) {

    2408. 

  2408.                     sfx=(AffEntry *)se; // BUG: sfx not stateless

    2409. 

  2409.                     return rv;

    2410. 

  2410.                 }

    2411. 

  2411.             }

    2412. 

  2412.         }

    2413. 

  2413.        se = se->getNext();

    2414. 

  2414.     }

    2415. 

  2415.   

    2416. 

  2416.     // now handle the general case

    2417. 

  2417.     unsigned char sp = *((const unsigned char *)(word + len - 1));

    2418. 

  2418.     SfxEntry * sptr = (SfxEntry *) sStart[sp];

    2419. 

  2419. 

    2420. 

  2420.     while (sptr) {

    2421. 

  2421.         if (isRevSubset(sptr->getKey(), word + len - 1, len)

    2422. 

  2422.         ) {

    2423. 

  2423.             // suffixes are not allowed in beginning of compounds

    2424. 

  2424.             if ((((in_compound != IN_CPD_BEGIN)) || // && !cclass

    2425. 

  2425.              // except when signed with compoundpermitflag flag

    2426. 

  2426.              (sptr->getCont() && compoundpermitflag &&

    2427. 

  2427.                 TESTAFF(sptr->getCont(),compoundpermitflag,sptr->getContLen()))) && (!circumfix ||

    2428. 

  2428.               // no circumfix flag in prefix and suffix

    2429. 

  2429.               ((!ppfx || !(ep->getCont()) || !TESTAFF(ep->getCont(),

    2430. 

  2430.                    circumfix, ep->getContLen())) &&

    2431. 

  2431.                (!sptr->getCont() || !(TESTAFF(sptr->getCont(),circumfix,sptr->getContLen())))) ||

    2432. 

  2432.               // circumfix flag in prefix AND suffix

    2433. 

  2433.               ((ppfx && (ep->getCont()) && TESTAFF(ep->getCont(),

    2434. 

  2434.                    circumfix, ep->getContLen())) &&

    2435. 

  2435.                (sptr->getCont() && (TESTAFF(sptr->getCont(),circumfix,sptr->getContLen())))))  &&

    2436. 

  2436.             // fogemorpheme

    2437. 

  2437.               (in_compound || 

    2438. 

  2438.                  !((sptr->getCont() && (TESTAFF(sptr->getCont(), onlyincompound, sptr->getContLen()))))) &&

    2439. 

  2439.             // pseudoroot on prefix or first suffix

    2440. 

  2440.               (cclass || 

    2441. 

  2441.                   !(sptr->getCont() && TESTAFF(sptr->getCont(), pseudoroot, sptr->getContLen())) ||

    2442. 

  2442.                   (ppfx && !((ep->getCont()) &&

    2443. 

  2443.                      TESTAFF(ep->getCont(), pseudoroot,

    2444. 

  2444.                        ep->getContLen())))

    2445. 

  2445.               )

    2446. 

  2446.             ) {

    2447. 

  2447.                 rv = sptr->checkword(word,len, sfxopts, ppfx, wlst,

    2448. 

  2448.                     maxSug, ns, cclass, needflag, (in_compound ? 0 : onlyincompound));

    2449. 

  2449.                 if (rv) {

    2450. 

  2450.                     sfx=(AffEntry *)sptr; // BUG: sfx not stateless

    2451. 

  2451.                     sfxflag = sptr->getFlag(); // BUG: sfxflag not stateless

    2452. 

  2452.                     if (!sptr->getCont()) sfxappnd=sptr->getKey(); // BUG: sfxappnd not stateless

    2453. 

  2453.                     if (cclass || sptr->getCont()) {

    2454. 

  2454.                                 if (!derived) {

    2455. 

  2455.                                         derived = mystrdup(word);

    2456. 

  2456.                                 } else {

    2457. 

  2457.                                         strcpy(result, derived); // XXX check size

    2458. 

  2458.                                         strcat(result, "\n");

    2459. 

  2459.                                         strcat(result, word);

    2460. 

  2460.                                         free(derived);

    2461. 

  2461.                                         derived = mystrdup(result);

    2462. 

  2462.                                 }

    2463. 

  2463.                     }

    2464. 

  2464.                     return rv;

    2465. 

  2465.                 }

    2466. 

  2466.              }

    2467. 

  2467.              sptr = sptr->getNextEQ();

    2468. 

  2468.         } else {

    2469. 

  2469.              sptr = sptr->getNextNE();

    2470. 

  2470.         }

    2471. 

  2471.     }

    2472. 

  2472. 

    2473. 

  2473.     return NULL;

    2474. 

  2474. }

    2475. 

  2475. 

    2476. 

  2476. // check word for two-level suffixes

    2477. 

  2477. 

    2478. 

  2478. struct hentry * AffixMgr::suffix_check_twosfx(const char * word, int len, 

    2479. 

  2479.        int sfxopts, AffEntry * ppfx, const FLAG needflag)

    2480. 

  2480. {

    2481. 

  2481.     struct hentry * rv = NULL;

    2482. 

  2482. 

    2483. 

  2483.     // first handle the special case of 0 length suffixes

    2484. 

  2484.     SfxEntry * se = (SfxEntry *) sStart[0];

    2485. 

  2485.     while (se) {

    2486. 

  2486.         if (contclasses[se->getFlag()])

    2487. 

  2487.         {

    2488. 

  2488.             rv = se->check_twosfx(word,len, sfxopts, ppfx, needflag);

    2489. 

  2489.             if (rv) return rv;

    2490. 

  2490.         }

    2491. 

  2491.         se = se->getNext();

    2492. 

  2492.     }

    2493. 

  2493.   

    2494. 

  2494.     // now handle the general case

    2495. 

  2495.     unsigned char sp = *((const unsigned char *)(word + len - 1));

    2496. 

  2496.     SfxEntry * sptr = (SfxEntry *) sStart[sp];

    2497. 

  2497. 

    2498. 

  2498.     while (sptr) {

    2499. 

  2499.         if (isRevSubset(sptr->getKey(), word + len - 1, len)) {

    2500. 

  2500.             if (contclasses[sptr->getFlag()])

    2501. 

  2501.             {

    2502. 

  2502.                 rv = sptr->check_twosfx(word,len, sfxopts, ppfx, needflag);

    2503. 

  2503.                 if (rv) {

    2504. 

  2504.                     sfxflag = sptr->getFlag(); // BUG: sfxflag not stateless

    2505. 

  2505.                     if (!sptr->getCont()) sfxappnd=sptr->getKey(); // BUG: sfxappnd not stateless

    2506. 

  2506.                     return rv;

    2507. 

  2507.                 }

    2508. 

  2508.             }

    2509. 

  2509.             sptr = sptr->getNextEQ();

    2510. 

  2510.         } else {

    2511. 

  2511.              sptr = sptr->getNextNE();

    2512. 

  2512.         }

    2513. 

  2513.     }

    2514. 

  2514. 

    2515. 

  2515.     return NULL;

    2516. 

  2516. }

    2517. 

  2517. 

    2518. 

  2518. #ifdef HUNSPELL_EXPERIMENTAL

    2519. 

  2519. char * AffixMgr::suffix_check_twosfx_morph(const char * word, int len, 

    2520. 

  2520.        int sfxopts, AffEntry * ppfx, const FLAG needflag)

    2521. 

  2521. {

    2522. 

  2522.     char result[MAXLNLEN];

    2523. 

  2523.     char result2[MAXLNLEN];

    2524. 

  2524.     char result3[MAXLNLEN];

    2525. 

  2525.     

    2526. 

  2526.     char * st;

    2527. 

  2527. 

    2528. 

  2528.     result[0] = '\0';

    2529. 

  2529.     result2[0] = '\0';

    2530. 

  2530.     result3[0] = '\0';

    2531. 

  2531. 

    2532. 

  2532.     // first handle the special case of 0 length suffixes

    2533. 

  2533.     SfxEntry * se = (SfxEntry *) sStart[0];

    2534. 

  2534.     while (se) {

    2535. 

  2535.         if (contclasses[se->getFlag()])

    2536. 

  2536.         {

    2537. 

  2537.             st = se->check_twosfx_morph(word,len, sfxopts, ppfx, needflag);

    2538. 

  2538.             if (st) {

    2539. 

  2539.                 if (ppfx) {

    2540. 

  2540.                     if (((PfxEntry *) ppfx)->getMorph()) strcat(result, ((PfxEntry *) ppfx)->getMorph());

    2541. 

  2541.                 }

    2542. 

  2542.                 strcat(result, st);

    2543. 

  2543.                 free(st);

    2544. 

  2544.                 if (se->getMorph()) strcat(result, se->getMorph());

    2545. 

  2545.                 strcat(result, "\n");

    2546. 

  2546.             }

    2547. 

  2547.         }

    2548. 

  2548.         se = se->getNext();

    2549. 

  2549.     }

    2550. 

  2550.   

    2551. 

  2551.     // now handle the general case

    2552. 

  2552.     unsigned char sp = *((const unsigned char *)(word + len - 1));

    2553. 

  2553.     SfxEntry * sptr = (SfxEntry *) sStart[sp];

    2554. 

  2554. 

    2555. 

  2555.     while (sptr) {

    2556. 

  2556.         if (isRevSubset(sptr->getKey(), word + len - 1, len)) {

    2557. 

  2557.             if (contclasses[sptr->getFlag()]) 

    2558. 

  2558.             {

    2559. 

  2559.                 st = sptr->check_twosfx_morph(word,len, sfxopts, ppfx, needflag);

    2560. 

  2560.                 if (st) {

    2561. 

  2561.                     sfxflag = sptr->getFlag(); // BUG: sfxflag not stateless

    2562. 

  2562.                     if (!sptr->getCont()) sfxappnd=sptr->getKey(); // BUG: sfxappnd not stateless

    2563. 

  2563.                     strcpy(result2, st);

    2564. 

  2564.                     free(st);

    2565. 

  2565. 

    2566. 

  2566.                 result3[0] = '\0';

    2567. 

  2567. #ifdef DEBUG

    2568. 

  2568.                 unsigned short flag = sptr->getFlag();

    2569. 

  2569.                 if (flag_mode == FLAG_NUM) {

    2570. 

  2570.                     sprintf(result3, "<%d>", sptr->getKey());

    2571. 

  2571.                 } else if (flag_mode == FLAG_LONG) {

    2572. 

  2572.                     sprintf(result3, "<%c%c>", flag >> 8, (flag << 8) >>8);

    2573. 

  2573.                 } else sprintf(result3, "<%c>", flag);

    2574. 

  2574.                 strcat(result3, ":");

    2575. 

  2575. #endif

    2576. 

  2576.                 if (sptr->getMorph()) strcat(result3, sptr->getMorph());

    2577. 

  2577.                 strlinecat(result2, result3);

    2578. 

  2578.                 strcat(result2, "\n");

    2579. 

  2579.                 strcat(result,  result2);

    2580. 

  2580.                 }

    2581. 

  2581.             }

    2582. 

  2582.             sptr = sptr->getNextEQ();

    2583. 

  2583.         } else {

    2584. 

  2584.              sptr = sptr->getNextNE();

    2585. 

  2585.         }

    2586. 

  2586.     }

    2587. 

  2587.     if (result) return mystrdup(result);

    2588. 

  2588.     return NULL;

    2589. 

  2589. }

    2590. 

  2590. 

    2591. 

  2591. char * AffixMgr::suffix_check_morph(const char * word, int len, 

    2592. 

  2592.        int sfxopts, AffEntry * ppfx, const FLAG cclass, const FLAG needflag, char in_compound)

    2593. 

  2593. {

    2594. 

  2594.     char result[MAXLNLEN];

    2595. 

  2595.     

    2596. 

  2596.     struct hentry * rv = NULL;

    2597. 

  2597. 

    2598. 

  2598.     result[0] = '\0';

    2599. 

  2599. 

    2600. 

  2600.     PfxEntry* ep = (PfxEntry *) ppfx;

    2601. 

  2601. 

    2602. 

  2602.     // first handle the special case of 0 length suffixes

    2603. 

  2603.     SfxEntry * se = (SfxEntry *) sStart[0];

    2604. 

  2604.     while (se) {

    2605. 

  2605.         if (!cclass || se->getCont()) {

    2606. 

  2606.             // suffixes are not allowed in beginning of compounds

    2607. 

  2607.             if (((((in_compound != IN_CPD_BEGIN)) || // && !cclass

    2608. 

  2608.              // except when signed with compoundpermitflag flag

    2609. 

  2609.              (se->getCont() && compoundpermitflag &&

    2610. 

  2610.                 TESTAFF(se->getCont(),compoundpermitflag,se->getContLen()))) && (!circumfix ||

    2611. 

  2611.               // no circumfix flag in prefix and suffix

    2612. 

  2612.               ((!ppfx || !(ep->getCont()) || !TESTAFF(ep->getCont(),

    2613. 

  2613.                    circumfix, ep->getContLen())) &&

    2614. 

  2614.                (!se->getCont() || !(TESTAFF(se->getCont(),circumfix,se->getContLen())))) ||

    2615. 

  2615.               // circumfix flag in prefix AND suffix

    2616. 

  2616.               ((ppfx && (ep->getCont()) && TESTAFF(ep->getCont(),

    2617. 

  2617.                    circumfix, ep->getContLen())) &&

    2618. 

  2618.                (se->getCont() && (TESTAFF(se->getCont(),circumfix,se->getContLen())))))  &&

    2619. 

  2619.             // fogemorpheme

    2620. 

  2620.               (in_compound || 

    2621. 

  2621.                  !((se->getCont() && (TESTAFF(se->getCont(), onlyincompound, se->getContLen()))))) &&

    2622. 

  2622.             // pseudoroot on prefix or first suffix

    2623. 

  2623.               (cclass || 

    2624. 

  2624.                    !(se->getCont() && TESTAFF(se->getCont(), pseudoroot, se->getContLen())) ||

    2625. 

  2625.                    (ppfx && !((ep->getCont()) &&

    2626. 

  2626.                      TESTAFF(ep->getCont(), pseudoroot,

    2627. 

  2627.                        ep->getContLen())))

    2628. 

  2628.               )

    2629. 

  2629.             ))

    2630. 

  2630.             rv = se->checkword(word,len, sfxopts, ppfx, NULL, 0, 0, cclass, needflag);

    2631. 

  2631.          while (rv) {

    2632. 

  2632.            if (ppfx) {

    2633. 

  2633.                 if (((PfxEntry *) ppfx)->getMorph()) strcat(result, ((PfxEntry *) ppfx)->getMorph());

    2634. 

  2634.             }

    2635. 

  2635.             if (complexprefixes && rv->description) strcat(result, rv->description);

    2636. 

  2636.             if (rv->description && ((!rv->astr) || 

    2637. 

  2637.                                         !TESTAFF(rv->astr, lemma_present, rv->alen)))

    2638. 

  2638.                                                strcat(result, rv->word);

    2639. 

  2639.             if (!complexprefixes && rv->description) strcat(result, rv->description);

    2640. 

  2640.             if (se->getMorph()) strcat(result, se->getMorph());

    2641. 

  2641.             strcat(result, "\n");

    2642. 

  2642.             rv = se->get_next_homonym(rv, sfxopts, ppfx, cclass, needflag);

    2643. 

  2643.          }

    2644. 

  2644.        }

    2645. 

  2645.        se = se->getNext();

    2646. 

  2646.     }

    2647. 

  2647.   

    2648. 

  2648.     // now handle the general case

    2649. 

  2649.     unsigned char sp = *((const unsigned char *)(word + len - 1));

    2650. 

  2650.     SfxEntry * sptr = (SfxEntry *) sStart[sp];

    2651. 

  2651. 

    2652. 

  2652.     while (sptr) {

    2653. 

  2653.         if (isRevSubset(sptr->getKey(), word + len - 1, len)

    2654. 

  2654.         ) {

    2655. 

  2655.             // suffixes are not allowed in beginning of compounds

    2656. 

  2656.             if (((((in_compound != IN_CPD_BEGIN)) || // && !cclass

    2657. 

  2657.              // except when signed with compoundpermitflag flag

    2658. 

  2658.              (sptr->getCont() && compoundpermitflag &&

    2659. 

  2659.                 TESTAFF(sptr->getCont(),compoundpermitflag,sptr->getContLen()))) && (!circumfix ||

    2660. 

  2660.               // no circumfix flag in prefix and suffix

    2661. 

  2661.               ((!ppfx || !(ep->getCont()) || !TESTAFF(ep->getCont(),

    2662. 

  2662.                    circumfix, ep->getContLen())) &&

    2663. 

  2663.                (!sptr->getCont() || !(TESTAFF(sptr->getCont(),circumfix,sptr->getContLen())))) ||

    2664. 

  2664.               // circumfix flag in prefix AND suffix

    2665. 

  2665.               ((ppfx && (ep->getCont()) && TESTAFF(ep->getCont(),

    2666. 

  2666.                    circumfix, ep->getContLen())) &&

    2667. 

  2667.                (sptr->getCont() && (TESTAFF(sptr->getCont(),circumfix,sptr->getContLen())))))  &&

    2668. 

  2668.             // fogemorpheme

    2669. 

  2669.               (in_compound || 

    2670. 

  2670.                  !((sptr->getCont() && (TESTAFF(sptr->getCont(), onlyincompound, sptr->getContLen()))))) &&

    2671. 

  2671.             // pseudoroot on first suffix

    2672. 

  2672.               (cclass || !(sptr->getCont() && 

    2673. 

  2673.                    TESTAFF(sptr->getCont(), pseudoroot, sptr->getContLen())))

    2674. 

  2674.             )) rv = sptr->checkword(word,len, sfxopts, ppfx, NULL, 0, 0, cclass, needflag);

    2675. 

  2675.             while (rv) {

    2676. 

  2676.                     if (ppfx) {

    2677. 

  2677.                         if (((PfxEntry *) ppfx)->getMorph()) strcat(result, ((PfxEntry *) ppfx)->getMorph());

    2678. 

  2678.                     }    

    2679. 

  2679.                     if (complexprefixes && rv->description) strcat(result, rv->description);

    2680. 

  2680.                     if (rv->description && ((!rv->astr) || 

    2681. 

  2681.                         !TESTAFF(rv->astr, lemma_present, rv->alen))) strcat(result, rv->word);

    2682. 

  2682.                     if (!complexprefixes && rv->description) strcat(result, rv->description);

    2683. 

  2683. #ifdef DEBUG

    2684. 

  2684.                 unsigned short flag = sptr->getFlag();

    2685. 

  2685.                 if (flag_mode == FLAG_NUM) {

    2686. 

  2686.                     sprintf(result, "<%d>", sptr->getKey());

    2687. 

  2687.                 } else if (flag_mode == FLAG_LONG) {

    2688. 

  2688.                     sprintf(result, "<%c%c>", flag >> 8, (flag << 8) >>8);

    2689. 

  2689.                 } else sprintf(result, "<%c>", flag);

    2690. 

  2690.                 strcat(result, ":");

    2691. 

  2691. #endif

    2692. 

  2692. 

    2693. 

  2693.                 if (sptr->getMorph()) strcat(result, sptr->getMorph());

    2694. 

  2694.                 strcat(result, "\n");

    2695. 

  2695.                 rv = sptr->get_next_homonym(rv, sfxopts, ppfx, cclass, needflag);

    2696. 

  2696.             }

    2697. 

  2697.              sptr = sptr->getNextEQ();

    2698. 

  2698.         } else {

    2699. 

  2699.              sptr = sptr->getNextNE();

    2700. 

  2700.         }

    2701. 

  2701.     }

    2702. 

  2702. 

    2703. 

  2703.     if (*result) return mystrdup(result);

    2704. 

  2704.     return NULL;

    2705. 

  2705. }

    2706. 

  2706. #endif // END OF HUNSPELL_EXPERIMENTAL CODE

    2707. 

  2707. 

    2708. 

  2708. 

    2709. 

  2709. // check if word with affixes is correctly spelled

    2710. 

  2710. struct hentry * AffixMgr::affix_check (const char * word, int len, const FLAG needflag, char in_compound)

    2711. 

  2711. {

    2712. 

  2712.     struct hentry * rv= NULL;

    2713. 

  2713.     if (derived) free(derived);

    2714. 

  2714.     derived =  NULL;

    2715. 

  2715. 

    2716. 

  2716.     // check all prefixes (also crossed with suffixes if allowed) 

    2717. 

  2717.     rv = prefix_check(word, len, in_compound, needflag);

    2718. 

  2718.     if (rv) return rv;

    2719. 

  2719. 

    2720. 

  2720.     // if still not found check all suffixes

    2721. 

  2721.     rv = suffix_check(word, len, 0, NULL, NULL, 0, NULL, FLAG_NULL, needflag, in_compound);

    2722. 

  2722. 

    2723. 

  2723.     if (havecontclass) {

    2724. 

  2724.         sfx = NULL;

    2725. 

  2725.         pfx = NULL;

    2726. 

  2726.         if (rv) return rv;

    2727. 

  2727.         // if still not found check all two-level suffixes

    2728. 

  2728.         rv = suffix_check_twosfx(word, len, 0, NULL, needflag);

    2729. 

  2729.         if (rv) return rv;

    2730. 

  2730.         // if still not found check all two-level suffixes

    2731. 

  2731.         rv = prefix_check_twosfx(word, len, IN_CPD_NOT, needflag);

    2732. 

  2732.     }

    2733. 

  2733.     return rv;

    2734. 

  2734. }

    2735. 

  2735. 

    2736. 

  2736. #ifdef HUNSPELL_EXPERIMENTAL

    2737. 

  2737. // check if word with affixes is correctly spelled

    2738. 

  2738. char * AffixMgr::affix_check_morph(const char * word, int len, const FLAG needflag, char in_compound)

    2739. 

  2739. {

    2740. 

  2740.     char result[MAXLNLEN];

    2741. 

  2741.     char * st = NULL;

    2742. 

  2742. 

    2743. 

  2743.     *result = '\0';

    2744. 

  2744.     

    2745. 

  2745.     // check all prefixes (also crossed with suffixes if allowed) 

    2746. 

  2746.     st = prefix_check_morph(word, len, in_compound);

    2747. 

  2747.     if (st) {

    2748. 

  2748.         strcat(result, st);

    2749. 

  2749.         free(st);

    2750. 

  2750.     }

    2751. 

  2751. 

    2752. 

  2752.     // if still not found check all suffixes    

    2753. 

  2753.     st = suffix_check_morph(word, len, 0, NULL, '\0', needflag, in_compound);

    2754. 

  2754.     if (st) {

    2755. 

  2755.         strcat(result, st);

    2756. 

  2756.         free(st);

    2757. 

  2757.     }

    2758. 

  2758. 

    2759. 

  2759.     if (havecontclass) {

    2760. 

  2760.         sfx = NULL;

    2761. 

  2761.         pfx = NULL;

    2762. 

  2762.         // if still not found check all two-level suffixes

    2763. 

  2763.         st = suffix_check_twosfx_morph(word, len, 0, NULL, needflag);

    2764. 

  2764.         if (st) {

    2765. 

  2765.             strcat(result, st);

    2766. 

  2766.             free(st);

    2767. 

  2767.         }

    2768. 

  2768. 

    2769. 

  2769.         // if still not found check all two-level suffixes

    2770. 

  2770.         st = prefix_check_twosfx_morph(word, len, IN_CPD_NOT, needflag);

    2771. 

  2771.         if (st) {

    2772. 

  2772.             strcat(result, st);

    2773. 

  2773.             free(st);

    2774. 

  2774.         }

    2775. 

  2775.     }

    2776. 

  2776.     

    2777. 

  2777.     return mystrdup(result);

    2778. 

  2778. }

    2779. 

  2779. #endif // END OF HUNSPELL_EXPERIMENTAL CODE

    2780. 

  2780. 

    2781. 

  2781. 

    2782. 

  2782. int AffixMgr::expand_rootword(struct guessword * wlst, int maxn, const char * ts,

    2783. 

  2783.     int wl, const unsigned short * ap, unsigned short al, char * bad, int badl)

    2784. 

  2784. {

    2785. 

  2785. 

    2786. 

  2786.     int nh=0;

    2787. 

  2787. 

    2788. 

  2788.     // first add root word to list

    2789. 

  2789.     if ((nh < maxn) && !(al && ((pseudoroot && TESTAFF(ap, pseudoroot, al)) ||

    2790. 

  2790.          (onlyincompound && TESTAFF(ap, onlyincompound, al))))) {

    2791. 

  2791.        wlst[nh].word = mystrdup(ts);

    2792. 

  2792.        wlst[nh].allow = (1 == 0);

    2793. 

  2793.        nh++;

    2794. 

  2794.     }

    2795. 

  2795. 

    2796. 

  2796.     // handle suffixes

    2797. 

  2797.     for (int i = 0; i < al; i++) {

    2798. 

  2798.        unsigned short c = (unsigned short) ap[i];

    2799. 

  2799.        SfxEntry * sptr = (SfxEntry *)sFlag[c];

    2800. 

  2800.        while (sptr) {

    2801. 

  2801.          if (!sptr->getKeyLen() || ((badl > sptr->getKeyLen()) &&

    2802. 

  2802.                 (strcmp(sptr->getAffix(), bad + badl - sptr->getKeyLen()) == 0)) &&

    2803. 

  2803.                 // check pseudoroot flag

    2804. 

  2804.                 !(sptr->getCont() && ((pseudoroot && 

    2805. 

  2805.                       TESTAFF(sptr->getCont(), pseudoroot, sptr->getContLen())) ||

    2806. 

  2806.                   (circumfix && 

    2807. 

  2807.                       TESTAFF(sptr->getCont(), circumfix, sptr->getContLen())) ||

    2808. 

  2808.                   (onlyincompound && 

    2809. 

  2809.                       TESTAFF(sptr->getCont(), onlyincompound, sptr->getContLen()))))

    2810. 

  2810.                 ) {

    2811. 

  2811.             char * newword = sptr->add(ts, wl);

    2812. 

  2812.             if (newword) {

    2813. 

  2813.                 if (nh < maxn) {

    2814. 

  2814.                     wlst[nh].word = newword;

    2815. 

  2815.                     wlst[nh].allow = sptr->allowCross();              

    2816. 

  2816.                 nh++;

    2817. 

  2817.                 } else {

    2818. 

  2818.                     free(newword);

    2819. 

  2819.                 }

    2820. 

  2820.             }

    2821. 

  2821.          }

    2822. 

  2822.          sptr = (SfxEntry *)sptr ->getFlgNxt();

    2823. 

  2823.        }

    2824. 

  2824.     }

    2825. 

  2825. 

    2826. 

  2826.     int n = nh;

    2827. 

  2827. 

    2828. 

  2828.     // handle cross products of prefixes and suffixes

    2829. 

  2829.     for (int j=1;j<n ;j++)

    2830. 

  2830.        if (wlst[j].allow) {

    2831. 

  2831.           for (int k = 0; k < al; k++) {

    2832. 

  2832.              unsigned short c = (unsigned short) ap[k];

    2833. 

  2833.              PfxEntry * cptr = (PfxEntry *) pFlag[c];

    2834. 

  2834.              while (cptr) {

    2835. 

  2835.                 if (cptr->allowCross() && (!cptr->getKeyLen() || ((badl > cptr->getKeyLen()) &&

    2836. 

  2836.                         (strncmp(cptr->getKey(), bad, cptr->getKeyLen()) == 0)))) {

    2837. 

  2837.                     int l1 = strlen(wlst[j].word);

    2838. 

  2838.                     char * newword = cptr->add(wlst[j].word, l1);

    2839. 

  2839.                     if (newword) {

    2840. 

  2840.                        if (nh < maxn) {

    2841. 

  2841.                           wlst[nh].word = newword;

    2842. 

  2842.                           wlst[nh].allow = cptr->allowCross();

    2843. 

  2843.                           nh++;

    2844. 

  2844.                        } else {

    2845. 

  2845.                           free(newword);

    2846. 

  2846.                        }

    2847. 

  2847.                     }

    2848. 

  2848.                 }

    2849. 

  2849.                 cptr = (PfxEntry *)cptr ->getFlgNxt();

    2850. 

  2850.              }

    2851. 

  2851.           }

    2852. 

  2852.        }

    2853. 

  2853. 

    2854. 

  2854. 

    2855. 

  2855.     // now handle pure prefixes

    2856. 

  2856.     for (int m = 0; m < al; m ++) {

    2857. 

  2857.        unsigned short c = (unsigned short) ap[m];

    2858. 

  2858.        PfxEntry * ptr = (PfxEntry *) pFlag[c];

    2859. 

  2859.        while (ptr) {

    2860. 

  2860.          if (!ptr->getKeyLen() || ((badl > ptr->getKeyLen()) &&

    2861. 

  2861.                 (strncmp(ptr->getKey(), bad, ptr->getKeyLen()) == 0)) &&

    2862. 

  2862.                 // check pseudoroot flag

    2863. 

  2863.                 !(ptr->getCont() && ((pseudoroot && 

    2864. 

  2864.                       TESTAFF(ptr->getCont(), pseudoroot, ptr->getContLen())) ||

    2865. 

  2865.                      (circumfix && 

    2866. 

  2866.                       TESTAFF(ptr->getCont(), circumfix, ptr->getContLen())) ||                      

    2867. 

  2867.                   (onlyincompound && 

    2868. 

  2868.                       TESTAFF(ptr->getCont(), onlyincompound, ptr->getContLen()))))

    2869. 

  2869.                 ) {

    2870. 

  2870.             char * newword = ptr->add(ts, wl);

    2871. 

  2871.             if (newword) {

    2872. 

  2872.                 if (nh < maxn) {

    2873. 

  2873.                     wlst[nh].word = newword;

    2874. 

  2874.                     wlst[nh].allow = ptr->allowCross();

    2875. 

  2875.                     nh++;

    2876. 

  2876.                 } else {

    2877. 

  2877.                     free(newword);

    2878. 

  2878.                 } 

    2879. 

  2879.             }

    2880. 

  2880.          }

    2881. 

  2881.          ptr = (PfxEntry *)ptr ->getFlgNxt();

    2882. 

  2882.        }

    2883. 

  2883.     }

    2884. 

  2884. 

    2885. 

  2885.     return nh;

    2886. 

  2886. }

    2887. 

  2887. 

    2888. 

  2888. 

    2889. 

  2889. 

    2890. 

  2890. // return length of replacing table

    2891. 

  2891. int AffixMgr::get_numrep()

    2892. 

  2892. {

    2893. 

  2893.   return numrep;

    2894. 

  2894. }

    2895. 

  2895. 

    2896. 

  2896. // return replacing table

    2897. 

  2897. struct replentry * AffixMgr::get_reptable()

    2898. 

  2898. {

    2899. 

  2899.   if (! reptable ) return NULL;

    2900. 

  2900.   return reptable;

    2901. 

  2901. }

    2902. 

  2902. 

    2903. 

  2903. // return length of character map table

    2904. 

  2904. int AffixMgr::get_nummap()

    2905. 

  2905. {

    2906. 

  2906.   return nummap;

    2907. 

  2907. }

    2908. 

  2908. 

    2909. 

  2909. // return character map table

    2910. 

  2910. struct mapentry * AffixMgr::get_maptable()

    2911. 

  2911. {

    2912. 

  2912.   if (! maptable ) return NULL;

    2913. 

  2913.   return maptable;

    2914. 

  2914. }

    2915. 

  2915. 

    2916. 

  2916. // return length of word break table

    2917. 

  2917. int AffixMgr::get_numbreak()

    2918. 

  2918. {

    2919. 

  2919.   return numbreak;

    2920. 

  2920. }

    2921. 

  2921. 

    2922. 

  2922. // return character map table

    2923. 

  2923. char ** AffixMgr::get_breaktable()

    2924. 

  2924. {

    2925. 

  2925.   if (! breaktable ) return NULL;

    2926. 

  2926.   return breaktable;

    2927. 

  2927. }

    2928. 

  2928. 

    2929. 

  2929. // return text encoding of dictionary

    2930. 

  2930. char * AffixMgr::get_encoding()

    2931. 

  2931. {

    2932. 

  2932.   if (! encoding ) {

    2933. 

  2933.       encoding = mystrdup("ISO8859-1");

    2934. 

  2934.   }

    2935. 

  2935.   return mystrdup(encoding);

    2936. 

  2936. }

    2937. 

  2937. 

    2938. 

  2938. // return text encoding of dictionary

    2939. 

  2939. int AffixMgr::get_langnum()

    2940. 

  2940. {

    2941. 

  2941.   return langnum;

    2942. 

  2942. }

    2943. 

  2943. 

    2944. 

  2944. // return double prefix option

    2945. 

  2945. int AffixMgr::get_complexprefixes()

    2946. 

  2946. {

    2947. 

  2947.   return complexprefixes;

    2948. 

  2948. }

    2949. 

  2949. 

    2950. 

  2950. FLAG AffixMgr::get_keepcase()

    2951. 

  2951. {

    2952. 

  2952.   return keepcase;

    2953. 

  2953. }

    2954. 

  2954. 

    2955. 

  2955. int AffixMgr::get_checksharps()

    2956. 

  2956. {

    2957. 

  2957.   return checksharps;

    2958. 

  2958. }

    2959. 

  2959. 

    2960. 

  2960. // return the preferred ignore string for suggestions

    2961. 

  2961. char * AffixMgr::get_ignore()

    2962. 

  2962. {

    2963. 

  2963.   if (!ignorechars) return NULL;

    2964. 

  2964.   return mystrdup(ignorechars);

    2965. 

  2965. }

    2966. 

  2966. 

    2967. 

  2967. // return the preferred ignore string for suggestions

    2968. 

  2968. unsigned short * AffixMgr::get_ignore_utf16(int * len)

    2969. 

  2969. {

    2970. 

  2970.   *len = ignorechars_utf16_len;

    2971. 

  2971.   return ignorechars_utf16;

    2972. 

  2972. }

    2973. 

  2973. 

    2974. 

  2974. // return the preferred try string for suggestions

    2975. 

  2975. char * AffixMgr::get_try_string()

    2976. 

  2976. {

    2977. 

  2977.   if (! trystring ) return NULL;

    2978. 

  2978.   return mystrdup(trystring);

    2979. 

  2979. }

    2980. 

  2980. 

    2981. 

  2981. // return the preferred try string for suggestions

    2982. 

  2982. const char * AffixMgr::get_wordchars()

    2983. 

  2983. {

    2984. 

  2984.   return wordchars;

    2985. 

  2985. }

    2986. 

  2986. 

    2987. 

  2987. unsigned short * AffixMgr::get_wordchars_utf16(int * len)

    2988. 

  2988. {

    2989. 

  2989.   *len = wordchars_utf16_len;

    2990. 

  2990.   return wordchars_utf16;

    2991. 

  2991. }

    2992. 

  2992. 

    2993. 

  2993. // is there compounding?

    2994. 

  2994. int AffixMgr::get_compound()

    2995. 

  2995. {

    2996. 

  2996.   return compoundflag || compoundbegin || numdefcpd;

    2997. 

  2997. }

    2998. 

  2998. 

    2999. 

  2999. // return the compound words control flag

    3000. 

  3000. FLAG AffixMgr::get_compoundflag()

    3001. 

  3001. {

    3002. 

  3002.   return compoundflag;

    3003. 

  3003. }

    3004. 

  3004. 

    3005. 

  3005. // return the forbidden words control flag

    3006. 

  3006. FLAG AffixMgr::get_forbiddenword()

    3007. 

  3007. {

    3008. 

  3008.   return forbiddenword;

    3009. 

  3009. }

    3010. 

  3010. 

    3011. 

  3011. // return the forbidden words control flag

    3012. 

  3012. FLAG AffixMgr::get_nosuggest()

    3013. 

  3013. {

    3014. 

  3014.   return nosuggest;

    3015. 

  3015. }

    3016. 

  3016. 

    3017. 

  3017. // return the forbidden words flag modify flag

    3018. 

  3018. FLAG AffixMgr::get_pseudoroot()

    3019. 

  3019. {

    3020. 

  3020.   return pseudoroot;

    3021. 

  3021. }

    3022. 

  3022. 

    3023. 

  3023. // return the onlyincompound flag

    3024. 

  3024. FLAG AffixMgr::get_onlyincompound()

    3025. 

  3025. {

    3026. 

  3026.   return onlyincompound;

    3027. 

  3027. }

    3028. 

  3028. 

    3029. 

  3029. // return the compound word signal flag

    3030. 

  3030. FLAG AffixMgr::get_compoundroot()

    3031. 

  3031. {

    3032. 

  3032.   return compoundroot;

    3033. 

  3033. }

    3034. 

  3034. 

    3035. 

  3035. // return the compound begin signal flag

    3036. 

  3036. FLAG AffixMgr::get_compoundbegin()

    3037. 

  3037. {

    3038. 

  3038.   return compoundbegin;

    3039. 

  3039. }

    3040. 

  3040. 

    3041. 

  3041. // return the value of checknum

    3042. 

  3042. int AffixMgr::get_checknum()

    3043. 

  3043. {

    3044. 

  3044.   return checknum;

    3045. 

  3045. }

    3046. 

  3046. 

    3047. 

  3047. // return the value of prefix

    3048. 

  3048. const char * AffixMgr::get_prefix()

    3049. 

  3049. {

    3050. 

  3050.   if (pfx) return ((PfxEntry *)pfx)->getKey();

    3051. 

  3051.   return NULL;

    3052. 

  3052. }

    3053. 

  3053. 

    3054. 

  3054. // return the value of suffix

    3055. 

  3055. const char * AffixMgr::get_suffix()

    3056. 

  3056. {

    3057. 

  3057.   return sfxappnd;

    3058. 

  3058. }

    3059. 

  3059. 

    3060. 

  3060. // return the value of derived form (base word with first suffix).

    3061. 

  3061. const char * AffixMgr::get_derived()

    3062. 

  3062. {

    3063. 

  3063.   return derived;

    3064. 

  3064. }

    3065. 

  3065. 

    3066. 

  3066. // return the value of suffix

    3067. 

  3067. const char * AffixMgr::get_version()

    3068. 

  3068. {

    3069. 

  3069.   return version;

    3070. 

  3070. }

    3071. 

  3071. 

    3072. 

  3072. // return lemma_present flag

    3073. 

  3073. FLAG AffixMgr::get_lemma_present()

    3074. 

  3074. {

    3075. 

  3075.   return lemma_present;

    3076. 

  3076. }

    3077. 

  3077. 

    3078. 

  3078. // utility method to look up root words in hash table

    3079. 

  3079. struct hentry * AffixMgr::lookup(const char * word)

    3080. 

  3080. {

    3081. 

  3081.   if (! pHMgr) return NULL;

    3082. 

  3082.   return pHMgr->lookup(word);

    3083. 

  3083. }

    3084. 

  3084. 

    3085. 

  3085. // return the value of suffix

    3086. 

  3086. const int AffixMgr::have_contclass()

    3087. 

  3087. {

    3088. 

  3088.   return havecontclass;

    3089. 

  3089. }

    3090. 

  3090. 

    3091. 

  3091. // return utf8

    3092. 

  3092. int AffixMgr::get_utf8()

    3093. 

  3093. {

    3094. 

  3094.   return utf8;

    3095. 

  3095. }

    3096. 

  3096. 

    3097. 

  3097. // return nosplitsugs

    3098. 

  3098. int AffixMgr::get_maxngramsugs(void)

    3099. 

  3099. {

    3100. 

  3100.   return maxngramsugs;

    3101. 

  3101. }

    3102. 

  3102. 

    3103. 

  3103. // return nosplitsugs

    3104. 

  3104. int AffixMgr::get_nosplitsugs(void)

    3105. 

  3105. {

    3106. 

  3106.   return nosplitsugs;

    3107. 

  3107. }

    3108. 

  3108. 

    3109. 

  3109. // return sugswithdots

    3110. 

  3110. int AffixMgr::get_sugswithdots(void)

    3111. 

  3111. {

    3112. 

  3112.   return sugswithdots;

    3113. 

  3113. }

    3114. 

  3114. 

    3115. 

  3115. /* parse flag */

    3116. 

  3116. int AffixMgr::parse_flag(char * line, unsigned short * out, const char * name) {

    3117. 

  3117.    char * s = NULL;

    3118. 

  3118.    if (*out != FLAG_NULL) {

    3119. 

  3119.       HUNSPELL_WARNING(stderr, "error: duplicate %s line\n", name);

    3120. 

  3120.       return 1;

    3121. 

  3121.    }

    3122. 

  3122.    if (parse_string(line, &s, name)) return 1;

    3123. 

  3123.    *out = pHMgr->decode_flag(s);

    3124. 

  3124.    free(s);

    3125. 

  3125.    return 0;

    3126. 

  3126. }

    3127. 

  3127. 

    3128. 

  3128. /* parse num */

    3129. 

  3129. int AffixMgr::parse_num(char * line, int * out, const char * name) {

    3130. 

  3130.    char * s = NULL;

    3131. 

  3131.    if (*out != -1) {

    3132. 

  3132.       HUNSPELL_WARNING(stderr, "error: duplicate %s line\n", name);

    3133. 

  3133.       return 1;

    3134. 

  3134.    }

    3135. 

  3135.    if (parse_string(line, &s, name)) return 1;

    3136. 

  3136.    *out = atoi(s);

    3137. 

  3137.    free(s);

    3138. 

  3138.    return 0;

    3139. 

  3139. }

    3140. 

  3140. 

    3141. 

  3141. /* parse in the max syllablecount of compound words and  */

    3142. 

  3142. int  AffixMgr::parse_cpdsyllable(char * line)

    3143. 

  3143. {

    3144. 

  3144.    char * tp = line;

    3145. 

  3145.    char * piece;

    3146. 

  3146.    int i = 0;

    3147. 

  3147.    int np = 0;

    3148. 

  3148.    w_char w[MAXWORDLEN];

    3149. 

  3149.    piece = mystrsep(&tp, 0);

    3150. 

  3150.    while (piece) {

    3151. 

  3151.       if (*piece != '\0') {

    3152. 

  3152.           switch(i) {

    3153. 

  3153.              case 0: { np++; break; }

    3154. 

  3154.              case 1: { cpdmaxsyllable = atoi(piece); np++; break; }

    3155. 

  3155.              case 2: {

    3156. 

  3156.                 if (!utf8) {

    3157. 

  3157.                     cpdvowels = mystrdup(piece);

    3158. 

  3158.                 } else {

    3159. 

  3159.                     int n = u8_u16(w, MAXWORDLEN, piece);

    3160. 

  3160.                     if (n > 0) {

    3161. 

  3161.                         flag_qsort((unsigned short *) w, 0, n);

    3162. 

  3162.                         cpdvowels_utf16 = (w_char *) malloc(n * sizeof(w_char));

    3163. 

  3163.                         if (!cpdvowels_utf16) return 1;

    3164. 

  3164.                         memcpy(cpdvowels_utf16, w, n * sizeof(w_char));

    3165. 

  3165.                     }

    3166. 

  3166.                     cpdvowels_utf16_len = n;

    3167. 

  3167.                 }

    3168. 

  3168.                 np++;

    3169. 

  3169.                 break;

    3170. 

  3170.              }

    3171. 

  3171.              default: break;

    3172. 

  3172.           }

    3173. 

  3173.           i++;

    3174. 

  3174.       }

    3175. 

  3175.       free(piece);

    3176. 

  3176.       piece = mystrsep(&tp, 0);

    3177. 

  3177.    }

    3178. 

  3178.    if (np < 2) {

    3179. 

  3179.       HUNSPELL_WARNING(stderr, "error: missing compoundsyllable information\n");

    3180. 

  3180.       return 1;

    3181. 

  3181.    }

    3182. 

  3182.    if (np == 2) cpdvowels = mystrdup("aeiouAEIOU");

    3183. 

  3183.    return 0;

    3184. 

  3184. }

    3185. 

  3185. 

    3186. 

  3186. /* parse in the typical fault correcting table */

    3187. 

  3187. int  AffixMgr::parse_reptable(char * line, FILE * af)

    3188. 

  3188. {

    3189. 

  3189.    if (numrep != 0) {

    3190. 

  3190.       HUNSPELL_WARNING(stderr, "error: duplicate REP tables used\n");

    3191. 

  3191.       return 1;

    3192. 

  3192.    }

    3193. 

  3193.    char * tp = line;

    3194. 

  3194.    char * piece;

    3195. 

  3195.    int i = 0;

    3196. 

  3196.    int np = 0;

    3197. 

  3197.    piece = mystrsep(&tp, 0);

    3198. 

  3198.    while (piece) {

    3199. 

  3199.        if (*piece != '\0') {

    3200. 

  3200.           switch(i) {

    3201. 

  3201.              case 0: { np++; break; }

    3202. 

  3202.              case 1: { 

    3203. 

  3203.                        numrep = atoi(piece);

    3204. 

  3204.                        if (numrep < 1) {

    3205. 

  3205.                           HUNSPELL_WARNING(stderr, "incorrect number of entries in replacement table\n");

    3206. 

  3206.                           free(piece);

    3207. 

  3207.                           return 1;

    3208. 

  3208.                        }

    3209. 

  3209.                        reptable = (replentry *) malloc(numrep * sizeof(struct replentry));

    3210. 

  3210.                        if (!reptable) {

    3211. 

  3211.                          free(piece);

    3212. 

  3212.                          return 1;

    3213. 

  3213.                        }

    3214. 

  3214.                        np++;

    3215. 

  3215.                        break;

    3216. 

  3216.                      }

    3217. 

  3217.              default: break;

    3218. 

  3218.           }

    3219. 

  3219.           i++;

    3220. 

  3220.        }

    3221. 

  3221.        free(piece);

    3222. 

  3222.        piece = mystrsep(&tp, 0);

    3223. 

  3223.    }

    3224. 

  3224.    if (np != 2) {

    3225. 

  3225.       HUNSPELL_WARNING(stderr, "error: missing replacement table information\n");

    3226. 

  3226.       return 1;

    3227. 

  3227.    } 

    3228. 

  3228.  

    3229. 

  3229.    /* now parse the numrep lines to read in the remainder of the table */

    3230. 

  3230.    char * nl = line;

    3231. 

  3231.    for (int j=0; j < numrep; j++) {

    3232. 

  3232.         if (!fgets(nl,MAXLNLEN,af)) return 1;

    3233. 

  3233.         mychomp(nl);

    3234. 

  3234.         tp = nl;

    3235. 

  3235.         i = 0;

    3236. 

  3236.         reptable[j].pattern = NULL;

    3237. 

  3237.         reptable[j].pattern2 = NULL;

    3238. 

  3238.         piece = mystrsep(&tp, 0);

    3239. 

  3239.         while (piece) {

    3240. 

  3240.            if (*piece != '\0') {

    3241. 

  3241.                switch(i) {

    3242. 

  3242.                   case 0: {

    3243. 

  3243.                              if (strncmp(piece,"REP",3) != 0) {

    3244. 

  3244.                                  HUNSPELL_WARNING(stderr, "error: replacement table is corrupt\n");

    3245. 

  3245.                                  free(piece);

    3246. 

  3246.                                  return 1;

    3247. 

  3247.                              }

    3248. 

  3248.                              break;

    3249. 

  3249.                           }

    3250. 

  3250.                   case 1: { reptable[j].pattern = mystrrep(mystrdup(piece),"_"," "); break; }

    3251. 

  3251.                   case 2: { reptable[j].pattern2 = mystrrep(mystrdup(piece),"_"," "); break; }

    3252. 

  3252.                   default: break;

    3253. 

  3253.                }

    3254. 

  3254.                i++;

    3255. 

  3255.            }

    3256. 

  3256.            free(piece);

    3257. 

  3257.            piece = mystrsep(&tp, 0);

    3258. 

  3258.         }

    3259. 

  3259.         if ((!(reptable[j].pattern)) || (!(reptable[j].pattern2))) {

    3260. 

  3260.              HUNSPELL_WARNING(stderr, "error: replacement table is corrupt\n");

    3261. 

  3261.              return 1;

    3262. 

  3262.         }

    3263. 

  3263.    }

    3264. 

  3264.    return 0;

    3265. 

  3265. }

    3266. 

  3266. 

    3267. 

  3267. /* parse in the checkcompoundpattern table */

    3268. 

  3268. int  AffixMgr::parse_checkcpdtable(char * line, FILE * af)

    3269. 

  3269. {

    3270. 

  3270.    if (numcheckcpd != 0) {

    3271. 

  3271.       HUNSPELL_WARNING(stderr, "error: duplicate compound pattern tables used\n");

    3272. 

  3272.       return 1;

    3273. 

  3273.    }

    3274. 

  3274.    char * tp = line;

    3275. 

  3275.    char * piece;

    3276. 

  3276.    int i = 0;

    3277. 

  3277.    int np = 0;

    3278. 

  3278.    piece = mystrsep(&tp, 0);

    3279. 

  3279.    while (piece) {

    3280. 

  3280.        if (*piece != '\0') {

    3281. 

  3281.           switch(i) {

    3282. 

  3282.              case 0: { np++; break; }

    3283. 

  3283.              case 1: { 

    3284. 

  3284.                        numcheckcpd = atoi(piece);

    3285. 

  3285.                        if (numcheckcpd < 1) {

    3286. 

  3286.                           HUNSPELL_WARNING(stderr, "incorrect number of entries in compound pattern table\n");

    3287. 

  3287.                           free(piece);

    3288. 

  3288.                           return 1;

    3289. 

  3289.                        }

    3290. 

  3290.                        checkcpdtable = (replentry *) malloc(numcheckcpd * sizeof(struct replentry));

    3291. 

  3291.                        if (!checkcpdtable) {

    3292. 

  3292.                          free(piece);

    3293. 

  3293.                          return 1;

    3294. 

  3294.                        }

    3295. 

  3295.                        np++;

    3296. 

  3296.                        break;

    3297. 

  3297.                      }

    3298. 

  3298.              default: break;

    3299. 

  3299.           }

    3300. 

  3300.           i++;

    3301. 

  3301.        }

    3302. 

  3302.        free(piece);

    3303. 

  3303.        piece = mystrsep(&tp, 0);

    3304. 

  3304.    }

    3305. 

  3305.    if (np != 2) {

    3306. 

  3306.       HUNSPELL_WARNING(stderr, "error: missing compound pattern table information\n");

    3307. 

  3307.       return 1;

    3308. 

  3308.    } 

    3309. 

  3309.  

    3310. 

  3310.    /* now parse the numcheckcpd lines to read in the remainder of the table */

    3311. 

  3311.    char * nl = line;

    3312. 

  3312.    for (int j=0; j < numcheckcpd; j++) {

    3313. 

  3313.         if (!fgets(nl,MAXLNLEN,af)) return 1;

    3314. 

  3314.         mychomp(nl);

    3315. 

  3315.         tp = nl;

    3316. 

  3316.         i = 0;

    3317. 

  3317.         checkcpdtable[j].pattern = NULL;

    3318. 

  3318.         checkcpdtable[j].pattern2 = NULL;

    3319. 

  3319.         piece = mystrsep(&tp, 0);

    3320. 

  3320.         while (piece) {

    3321. 

  3321.            if (*piece != '\0') {

    3322. 

  3322.                switch(i) {

    3323. 

  3323.                   case 0: {

    3324. 

  3324.                              if (strncmp(piece,"CHECKCOMPOUNDPATTERN",20) != 0) {

    3325. 

  3325.                                  HUNSPELL_WARNING(stderr, "error: compound pattern table is corrupt\n");

    3326. 

  3326.                                  free(piece);

    3327. 

  3327.                                  return 1;

    3328. 

  3328.                              }

    3329. 

  3329.                              break;

    3330. 

  3330.                           }

    3331. 

  3331.                   case 1: { checkcpdtable[j].pattern = mystrdup(piece); break; }

    3332. 

  3332.                   case 2: { checkcpdtable[j].pattern2 = mystrdup(piece); break; }

    3333. 

  3333.                   default: break;

    3334. 

  3334.                }

    3335. 

  3335.                i++;

    3336. 

  3336.            }

    3337. 

  3337.            free(piece);

    3338. 

  3338.            piece = mystrsep(&tp, 0);

    3339. 

  3339.         }

    3340. 

  3340.         if ((!(checkcpdtable[j].pattern)) || (!(checkcpdtable[j].pattern2))) {

    3341. 

  3341.              HUNSPELL_WARNING(stderr, "error: compound pattern table is corrupt\n");

    3342. 

  3342.              return 1;

    3343. 

  3343.         }

    3344. 

  3344.    }

    3345. 

  3345.    return 0;

    3346. 

  3346. }

    3347. 

  3347. 

    3348. 

  3348. /* parse in the compound rule table */

    3349. 

  3349. int  AffixMgr::parse_defcpdtable(char * line, FILE * af)

    3350. 

  3350. {

    3351. 

  3351.    if (numdefcpd != 0) {

    3352. 

  3352.       HUNSPELL_WARNING(stderr, "error: duplicate compound rule tables used\n");

    3353. 

  3353.       return 1;

    3354. 

  3354.    }

    3355. 

  3355.    char * tp = line;

    3356. 

  3356.    char * piece;

    3357. 

  3357.    int i = 0;

    3358. 

  3358.    int np = 0;

    3359. 

  3359.    piece = mystrsep(&tp, 0);

    3360. 

  3360.    while (piece) {

    3361. 

  3361.        if (*piece != '\0') {

    3362. 

  3362.           switch(i) {

    3363. 

  3363.              case 0: { np++; break; }

    3364. 

  3364.              case 1: { 

    3365. 

  3365.                        numdefcpd = atoi(piece);

    3366. 

  3366.                        if (numdefcpd < 1) {

    3367. 

  3367.                           HUNSPELL_WARNING(stderr, "incorrect number of entries in compound rule table\n");

    3368. 

  3368.                           free(piece);

    3369. 

  3369.                           return 1;

    3370. 

  3370.                        }

    3371. 

  3371.                        defcpdtable = (flagentry *) malloc(numdefcpd * sizeof(flagentry));

    3372. 

  3372.                        if (!defcpdtable) {

    3373. 

  3373.                            free(piece);

    3374. 

  3374.                            return 1;

    3375. 

  3375.                        }

    3376. 

  3376.                        np++;

    3377. 

  3377.                        break;

    3378. 

  3378.                      }

    3379. 

  3379.              default: break;

    3380. 

  3380.           }

    3381. 

  3381.           i++;

    3382. 

  3382.        }

    3383. 

  3383.        free(piece);

    3384. 

  3384.        piece = mystrsep(&tp, 0);

    3385. 

  3385.    }

    3386. 

  3386.    if (np != 2) {

    3387. 

  3387.       HUNSPELL_WARNING(stderr, "error: missing compound rule table information\n");

    3388. 

  3388.       return 1;

    3389. 

  3389.    } 

    3390. 

  3390.  

    3391. 

  3391.    /* now parse the numdefcpd lines to read in the remainder of the table */

    3392. 

  3392.    char * nl = line;

    3393. 

  3393.    for (int j=0; j < numdefcpd; j++) {

    3394. 

  3394.         if (!fgets(nl,MAXLNLEN,af)) return 1;

    3395. 

  3395.         mychomp(nl);

    3396. 

  3396.         tp = nl;

    3397. 

  3397.         i = 0;

    3398. 

  3398.         defcpdtable[j].def = NULL;

    3399. 

  3399.         piece = mystrsep(&tp, 0);

    3400. 

  3400.         while (piece) {

    3401. 

  3401.            if (*piece != '\0') {

    3402. 

  3402.                switch(i) {

    3403. 

  3403.                   case 0: {

    3404. 

  3404.                              if (strncmp(piece, "COMPOUNDRULE", 12) != 0) {

    3405. 

  3405.                                  HUNSPELL_WARNING(stderr, "error: compound rule table is corrupt\n");

    3406. 

  3406.                                  free(piece);

    3407. 

  3407.                                  return 1;

    3408. 

  3408.                              }

    3409. 

  3409.                              break;

    3410. 

  3410.                           }

    3411. 

  3411.                   case 1: { 

    3412. 

  3412.                             defcpdtable[j].len = 

    3413. 

  3413.                                 pHMgr->decode_flags(&(defcpdtable[j].def), piece);

    3414. 

  3414.                             break; 

    3415. 

  3415.                            }

    3416. 

  3416.                   default: break;

    3417. 

  3417.                }

    3418. 

  3418.                i++;

    3419. 

  3419.            }

    3420. 

  3420.            free(piece);

    3421. 

  3421.            piece = mystrsep(&tp, 0);

    3422. 

  3422.         }

    3423. 

  3423.         if (!defcpdtable[j].len) {

    3424. 

  3424.              HUNSPELL_WARNING(stderr, "error: compound rule table is corrupt\n");

    3425. 

  3425.              return 1;

    3426. 

  3426.         }

    3427. 

  3427.    }

    3428. 

  3428.    return 0;

    3429. 

  3429. }

    3430. 

  3430. 

    3431. 

  3431. 

    3432. 

  3432. /* parse in the character map table */

    3433. 

  3433. int  AffixMgr::parse_maptable(char * line, FILE * af)

    3434. 

  3434. {

    3435. 

  3435.    if (nummap != 0) {

    3436. 

  3436.       HUNSPELL_WARNING(stderr, "error: duplicate MAP tables used\n");

    3437. 

  3437.       return 1;

    3438. 

  3438.    }

    3439. 

  3439.    char * tp = line;

    3440. 

  3440.    char * piece;

    3441. 

  3441.    int i = 0;

    3442. 

  3442.    int np = 0;

    3443. 

  3443.    piece = mystrsep(&tp, 0);

    3444. 

  3444.    while (piece) {

    3445. 

  3445.        if (*piece != '\0') {

    3446. 

  3446.           switch(i) {

    3447. 

  3447.              case 0: { np++; break; }

    3448. 

  3448.              case 1: { 

    3449. 

  3449.                        nummap = atoi(piece);

    3450. 

  3450.                        if (nummap < 1) {

    3451. 

  3451.                           HUNSPELL_WARNING(stderr, "incorrect number of entries in map table\n");

    3452. 

  3452.                           free(piece);

    3453. 

  3453.                           return 1;

    3454. 

  3454.                        }

    3455. 

  3455.                        maptable = (mapentry *) malloc(nummap * sizeof(struct mapentry));

    3456. 

  3456.                        if (!maptable) {

    3457. 

  3457.                          free(piece);

    3458. 

  3458.                          return 1;

    3459. 

  3459.                        }

    3460. 

  3460.                        np++;

    3461. 

  3461.                        break;

    3462. 

  3462.                      }

    3463. 

  3463.              default: break;

    3464. 

  3464.           }

    3465. 

  3465.           i++;

    3466. 

  3466.        }

    3467. 

  3467.        free(piece);

    3468. 

  3468.        piece = mystrsep(&tp, 0);

    3469. 

  3469.    }

    3470. 

  3470.    if (np != 2) {

    3471. 

  3471.       HUNSPELL_WARNING(stderr, "error: missing map table information\n");

    3472. 

  3472.       return 1;

    3473. 

  3473.    } 

    3474. 

  3474.  

    3475. 

  3475.    /* now parse the nummap lines to read in the remainder of the table */

    3476. 

  3476.    char * nl = line;

    3477. 

  3477.    for (int j=0; j < nummap; j++) {

    3478. 

  3478.         if (!fgets(nl,MAXLNLEN,af)) return 1;

    3479. 

  3479.         mychomp(nl);

    3480. 

  3480.         tp = nl;

    3481. 

  3481.         i = 0;

    3482. 

  3482.         maptable[j].set = NULL;

    3483. 

  3483.         maptable[j].len = 0;

    3484. 

  3484.         piece = mystrsep(&tp, 0);

    3485. 

  3485.         while (piece) {

    3486. 

  3486.            if (*piece != '\0') {

    3487. 

  3487.                switch(i) {

    3488. 

  3488.                   case 0: {

    3489. 

  3489.                              if (strncmp(piece,"MAP",3) != 0) {

    3490. 

  3490.                                  HUNSPELL_WARNING(stderr, "error: map table is corrupt\n");

    3491. 

  3491.                                  free(piece);

    3492. 

  3492.                                  return 1;

    3493. 

  3493.                              }

    3494. 

  3494.                              break;

    3495. 

  3495.                           }

    3496. 

  3496.                   case 1: {

    3497. 

  3497.                             maptable[j].len = 0;

    3498. 

  3498.                             maptable[j].set = NULL;

    3499. 

  3499.                             maptable[j].set_utf16 = NULL;

    3500. 

  3500.                             if (!utf8) {

    3501. 

  3501.                                 maptable[j].set = mystrdup(piece); 

    3502. 

  3502.                                 maptable[j].len = strlen(maptable[j].set);

    3503. 

  3503.                             } else {

    3504. 

  3504.                                 w_char w[MAXWORDLEN];

    3505. 

  3505.                                 int n = u8_u16(w, MAXWORDLEN, piece);

    3506. 

  3506.                                 if (n > 0) {

    3507. 

  3507.                                     flag_qsort((unsigned short *) w, 0, n);

    3508. 

  3508.                                     maptable[j].set_utf16 = (w_char *) malloc(n * sizeof(w_char));

    3509. 

  3509.                                     if (!maptable[j].set_utf16) return 1;

    3510. 

  3510.                                     memcpy(maptable[j].set_utf16, w, n * sizeof(w_char));

    3511. 

  3511.                                 }

    3512. 

  3512.                                 maptable[j].len = n;

    3513. 

  3513.                             }

    3514. 

  3514.                             break; }

    3515. 

  3515.                   default: break;

    3516. 

  3516.                }

    3517. 

  3517.                i++;

    3518. 

  3518.            }

    3519. 

  3519.            free(piece);

    3520. 

  3520.            piece = mystrsep(&tp, 0);

    3521. 

  3521.         }

    3522. 

  3522.         if ((!(maptable[j].set || maptable[j].set_utf16)) || (!(maptable[j].len))) {

    3523. 

  3523.              HUNSPELL_WARNING(stderr, "error: map table is corrupt\n");

    3524. 

  3524.              return 1;

    3525. 

  3525.         }

    3526. 

  3526.    }

    3527. 

  3527.    return 0;

    3528. 

  3528. }

    3529. 

  3529. 

    3530. 

  3530. /* parse in the word breakpoint table */

    3531. 

  3531. int  AffixMgr::parse_breaktable(char * line, FILE * af)

    3532. 

  3532. {

    3533. 

  3533.    if (numbreak != 0) {

    3534. 

  3534.       HUNSPELL_WARNING(stderr, "error: duplicate word breakpoint tables used\n");

    3535. 

  3535.       return 1;

    3536. 

  3536.    }

    3537. 

  3537.    char * tp = line;

    3538. 

  3538.    char * piece;

    3539. 

  3539.    int i = 0;

    3540. 

  3540.    int np = 0;

    3541. 

  3541.    piece = mystrsep(&tp, 0);

    3542. 

  3542.    while (piece) {

    3543. 

  3543.        if (*piece != '\0') {

    3544. 

  3544.           switch(i) {

    3545. 

  3545.              case 0: { np++; break; }

    3546. 

  3546.              case 1: { 

    3547. 

  3547.                        numbreak = atoi(piece);

    3548. 

  3548.                        if (numbreak < 1) {

    3549. 

  3549.                           HUNSPELL_WARNING(stderr, "incorrect number of entries in BREAK table\n");

    3550. 

  3550.                           free(piece);

    3551. 

  3551.                           return 1;

    3552. 

  3552.                        }

    3553. 

  3553.                        breaktable = (char **) malloc(numbreak * sizeof(char *));

    3554. 

  3554.                        if (!breaktable) {

    3555. 

  3555.                          free(piece);

    3556. 

  3556.                          return 1;

    3557. 

  3557.                        }

    3558. 

  3558.                        np++;

    3559. 

  3559.                        break;

    3560. 

  3560.                      }

    3561. 

  3561.              default: break;

    3562. 

  3562.           }

    3563. 

  3563.           i++;

    3564. 

  3564.        }

    3565. 

  3565.        free(piece);

    3566. 

  3566.        piece = mystrsep(&tp, 0);

    3567. 

  3567.    }

    3568. 

  3568.    if (np != 2) {

    3569. 

  3569.       HUNSPELL_WARNING(stderr, "error: missing word breakpoint table information\n");

    3570. 

  3570.       return 1;

    3571. 

  3571.    } 

    3572. 

  3572.  

    3573. 

  3573.    /* now parse the numbreak lines to read in the remainder of the table */

    3574. 

  3574.    char * nl = line;

    3575. 

  3575.    for (int j=0; j < numbreak; j++) {

    3576. 

  3576.         if (!fgets(nl,MAXLNLEN,af)) return 1;

    3577. 

  3577.         mychomp(nl);

    3578. 

  3578.         tp = nl;

    3579. 

  3579.         i = 0;

    3580. 

  3580.         piece = mystrsep(&tp, 0);

    3581. 

  3581.         while (piece) {

    3582. 

  3582.            if (*piece != '\0') {

    3583. 

  3583.                switch(i) {

    3584. 

  3584.                   case 0: {

    3585. 

  3585.                              if (strncmp(piece,"BREAK",5) != 0) {

    3586. 

  3586.                                  HUNSPELL_WARNING(stderr, "error: BREAK table is corrupt\n");

    3587. 

  3587.                                  free(piece);

    3588. 

  3588.                                  return 1;

    3589. 

  3589.                              }

    3590. 

  3590.                              break;

    3591. 

  3591.                           }

    3592. 

  3592.                   case 1: {

    3593. 

  3593.                             breaktable[j] = mystrdup(piece);

    3594. 

  3594.                             break;

    3595. 

  3595.                           }

    3596. 

  3596.                   default: break;

    3597. 

  3597.                }

    3598. 

  3598.                i++;

    3599. 

  3599.            }

    3600. 

  3600.            free(piece);

    3601. 

  3601.            piece = mystrsep(&tp, 0);

    3602. 

  3602.         }

    3603. 

  3603.         if (!breaktable) {

    3604. 

  3604.              HUNSPELL_WARNING(stderr, "error: BREAK table is corrupt\n");

    3605. 

  3605.              return 1;

    3606. 

  3606.         }

    3607. 

  3607.    }

    3608. 

  3608.    return 0;

    3609. 

  3609. }

    3610. 

  3610. 

    3611. 

  3611. int  AffixMgr::parse_affix(char * line, const char at, FILE * af, char * dupflags)

    3612. 

  3612. {

    3613. 

  3613.    int numents = 0;      // number of affentry structures to parse

    3614. 

  3614. 

    3615. 

  3615.    unsigned short aflag = 0;      // affix char identifier

    3616. 

  3616. 

    3617. 

  3617.    char ff=0;

    3618. 

  3618.    struct affentry * ptr= NULL;

    3619. 

  3619.    struct affentry * nptr= NULL;

    3620. 

  3620. 

    3621. 

  3621.    char * tp = line;

    3622. 

  3622.    char * nl = line;

    3623. 

  3623.    char * piece;

    3624. 

  3624.    int i = 0;

    3625. 

  3625. 

    3626. 

  3626.    // checking lines with bad syntax

    3627. 

  3627. #ifdef DEBUG

    3628. 

  3628.    int basefieldnum = 0;

    3629. 

  3629. #endif

    3630. 

  3630. 

    3631. 

  3631.    // split affix header line into pieces

    3632. 

  3632. 

    3633. 

  3633.    int np = 0;

    3634. 

  3634.    piece = mystrsep(&tp, 0);

    3635. 

  3635.    while (piece) {

    3636. 

  3636.       if (*piece != '\0') {

    3637. 

  3637.           switch(i) {

    3638. 

  3638.              // piece 1 - is type of affix

    3639. 

  3639.              case 0: { np++; break; }

    3640. 

  3640.           

    3641. 

  3641.              // piece 2 - is affix char

    3642. 

  3642.              case 1: { 

    3643. 

  3643.                     np++;

    3644. 

  3644.                     aflag = pHMgr->decode_flag(piece);

    3645. 

  3645.                     if (((at == 'S') && (dupflags[aflag] & dupSFX)) ||

    3646. 

  3646.                         ((at == 'P') && (dupflags[aflag] & dupPFX))) {

    3647. 

  3647.                         HUNSPELL_WARNING(stderr, "error: duplicate affix flag %s in line %s\n", piece, nl);

    3648. 

  3648.                         // return 1; XXX permissive mode for bad dictionaries

    3649. 

  3649.                     }

    3650. 

  3650.                     dupflags[aflag] += ((at == 'S') ? dupSFX : dupPFX);

    3651. 

  3651.                     break; 

    3652. 

  3652.                     }

    3653. 

  3653.              // piece 3 - is cross product indicator 

    3654. 

  3654.              case 2: { np++; if (*piece == 'Y') ff = aeXPRODUCT; break; }

    3655. 

  3655. 

    3656. 

  3656.              // piece 4 - is number of affentries

    3657. 

  3657.              case 3: { 

    3658. 

  3658.                        np++;

    3659. 

  3659.                        numents = atoi(piece); 

    3660. 

  3660.                        if (numents == 0) {

    3661. 

  3661.                            char * err = pHMgr->encode_flag(aflag);

    3662. 

  3662.                            HUNSPELL_WARNING(stderr, "error: affix %s header has incorrect entry count in line %s\n",

    3663. 

  3663.                                    err, nl);

    3664. 

  3664.                            free(err);

    3665. 

  3665.                            return 1;

    3666. 

  3666.                        }

    3667. 

  3667.                        ptr = (struct affentry *) malloc(numents * sizeof(struct affentry));

    3668. 

  3668.                        if (!ptr) return 1;

    3669. 

  3669.                        ptr->opts = ff;

    3670. 

  3670.                        if (utf8) ptr->opts += aeUTF8;

    3671. 

  3671.                        if (pHMgr->is_aliasf()) ptr->opts += aeALIASF;

    3672. 

  3672. #ifdef HUNSPELL_EXPERIMENTAL

    3673. 

  3673.                        if (pHMgr->is_aliasm()) ptr->opts += aeALIASM;

    3674. 

  3674. #endif

    3675. 

  3675.                        ptr->aflag = aflag;

    3676. 

  3676.                      }

    3677. 

  3677. 

    3678. 

  3678.              default: break;

    3679. 

  3679.           }

    3680. 

  3680.           i++;

    3681. 

  3681.       }

    3682. 

  3682.       free(piece);

    3683. 

  3683.       piece = mystrsep(&tp, 0);

    3684. 

  3684.    }

    3685. 

  3685.    // check to make sure we parsed enough pieces

    3686. 

  3686.    if (np != 4) {

    3687. 

  3687.        char * err = pHMgr->encode_flag(aflag); 

    3688. 

  3688.        HUNSPELL_WARNING(stderr, "error: affix %s header has insufficient data in line %s\n", err, nl);

    3689. 

  3689.        free(err);

    3690. 

  3690.        free(ptr);

    3691. 

  3691.        return 1;

    3692. 

  3692.    }

    3693. 

  3693.  

    3694. 

  3694.    // store away ptr to first affentry

    3695. 

  3695.    nptr = ptr;

    3696. 

  3696. 

    3697. 

  3697.    // now parse numents affentries for this affix

    3698. 

  3698.    for (int j=0; j < numents; j++) {

    3699. 

  3699.       if (!fgets(nl,MAXLNLEN,af)) return 1;

    3700. 

  3700.       mychomp(nl);

    3701. 

  3701.       tp = nl;

    3702. 

  3702.       i = 0;

    3703. 

  3703.       np = 0;

    3704. 

  3704. 

    3705. 

  3705.       // split line into pieces

    3706. 

  3706.       piece = mystrsep(&tp, 0);

    3707. 

  3707.       while (piece) {

    3708. 

  3708.          if (*piece != '\0') {

    3709. 

  3709.              switch(i) {

    3710. 

  3710.                 // piece 1 - is type

    3711. 

  3711.                 case 0: { 

    3712. 

  3712.                           np++;

    3713. 

  3713.                           if (nptr != ptr) nptr->opts = ptr->opts;

    3714. 

  3714.                           break;

    3715. 

  3715.                         }

    3716. 

  3716. 

    3717. 

  3717.                 // piece 2 - is affix char

    3718. 

  3718.                 case 1: { 

    3719. 

  3719.                           np++;

    3720. 

  3720.                           if (pHMgr->decode_flag(piece) != aflag) {

    3721. 

  3721.                               char * err = pHMgr->encode_flag(aflag);

    3722. 

  3722.                               HUNSPELL_WARNING(stderr, "error: affix %s is corrupt near line %s\n", err, nl);

    3723. 

  3723.                               HUNSPELL_WARNING(stderr, "error: possible incorrect count\n");

    3724. 

  3724.                               free(err);

    3725. 

  3725.                               free(piece);

    3726. 

  3726.                               return 1;

    3727. 

  3727.                           }

    3728. 

  3728. 

    3729. 

  3729.                           if (nptr != ptr) nptr->aflag = ptr->aflag;

    3730. 

  3730.                           break;

    3731. 

  3731.                         }

    3732. 

  3732. 

    3733. 

  3733.                 // piece 3 - is string to strip or 0 for null 

    3734. 

  3734.                 case 2: { 

    3735. 

  3735.                           np++;

    3736. 

  3736.                           if (complexprefixes) {

    3737. 

  3737.                             if (utf8) reverseword_utf(piece); else reverseword(piece);

    3738. 

  3738.                           }

    3739. 

  3739.                           nptr->strip = mystrdup(piece);

    3740. 

  3740.                           nptr->stripl = (unsigned char) strlen(nptr->strip);

    3741. 

  3741.                           if (strcmp(nptr->strip,"0") == 0) {

    3742. 

  3742.                               free(nptr->strip);

    3743. 

  3743.                               nptr->strip=mystrdup("");

    3744. 

  3744.                               nptr->stripl = 0;

    3745. 

  3745.                           }   

    3746. 

  3746.                           break; 

    3747. 

  3747.                         }

    3748. 

  3748. 

    3749. 

  3749.                 // piece 4 - is affix string or 0 for null

    3750. 

  3750.                 case 3: { 

    3751. 

  3751.                           char * dash;  

    3752. 

  3752. #ifdef HUNSPELL_EXPERIMENTAL

    3753. 

  3753.                           nptr->morphcode = NULL;

    3754. 

  3754. #endif

    3755. 

  3755.                           nptr->contclass = NULL;

    3756. 

  3756.                           nptr->contclasslen = 0;

    3757. 

  3757.                           np++;

    3758. 

  3758.                           dash = strchr(piece, '/');

    3759. 

  3759.                           if (dash) {

    3760. 

  3760.                             *dash = '\0';

    3761. 

  3761. 

    3762. 

  3762.                             if (ignorechars) {

    3763. 

  3763.                               if (utf8) {

    3764. 

  3764.                                 remove_ignored_chars_utf(piece, ignorechars_utf16, ignorechars_utf16_len);

    3765. 

  3765.                               } else {

    3766. 

  3766.                                 remove_ignored_chars(piece,ignorechars);

    3767. 

  3767.                               }

    3768. 

  3768.                             }

    3769. 

  3769.                             

    3770. 

  3770.                             if (complexprefixes) {

    3771. 

  3771.                                 if (utf8) reverseword_utf(piece); else reverseword(piece);

    3772. 

  3772.                             }

    3773. 

  3773.                             nptr->appnd = mystrdup(piece);

    3774. 

  3774.                             

    3775. 

  3775.                             if (pHMgr->is_aliasf()) {

    3776. 

  3776.                                 int index = atoi(dash + 1);

    3777. 

  3777.                                 nptr->contclasslen = (unsigned short) pHMgr->get_aliasf(index, &(nptr->contclass));

    3778. 

  3778.                             } else {

    3779. 

  3779.                                 nptr->contclasslen = (unsigned short) pHMgr->decode_flags(&(nptr->contclass), dash + 1);

    3780. 

  3780.                                 flag_qsort(nptr->contclass, 0, nptr->contclasslen);

    3781. 

  3781.                             }

    3782. 

  3782.                             *dash = '/';

    3783. 

  3783. 

    3784. 

  3784.                             havecontclass = 1;

    3785. 

  3785.                             for (unsigned short _i = 0; _i < nptr->contclasslen; _i++) {

    3786. 

  3786.                               contclasses[(nptr->contclass)[_i]] = 1;

    3787. 

  3787.                             }

    3788. 

  3788.                           } else {

    3789. 

  3789.                             if (ignorechars) {

    3790. 

  3790.                               if (utf8) {

    3791. 

  3791.                                 remove_ignored_chars_utf(piece, ignorechars_utf16, ignorechars_utf16_len);

    3792. 

  3792.                               } else {

    3793. 

  3793.                                 remove_ignored_chars(piece,ignorechars);

    3794. 

  3794.                               }

    3795. 

  3795.                             }

    3796. 

  3796. 

    3797. 

  3797.                             if (complexprefixes) {

    3798. 

  3798.                                 if (utf8) reverseword_utf(piece); else reverseword(piece);

    3799. 

  3799.                             }

    3800. 

  3800.                             nptr->appnd = mystrdup(piece);       

    3801. 

  3801.                           }

    3802. 

  3802.                           

    3803. 

  3803.                           nptr->appndl = (unsigned char) strlen(nptr->appnd);

    3804. 

  3804.                           if (strcmp(nptr->appnd,"0") == 0) {

    3805. 

  3805.                               free(nptr->appnd);

    3806. 

  3806.                               nptr->appnd=mystrdup("");

    3807. 

  3807.                               nptr->appndl = 0;

    3808. 

  3808.                           }   

    3809. 

  3809.                           break; 

    3810. 

  3810.                         }

    3811. 

  3811. 

    3812. 

  3812.                 // piece 5 - is the conditions descriptions

    3813. 

  3813.                 case 4: { 

    3814. 

  3814.                           np++;

    3815. 

  3815.                           if (complexprefixes) {

    3816. 

  3816.                             int neg = 0;

    3817. 

  3817.                             if (utf8) reverseword_utf(piece); else reverseword(piece);

    3818. 

  3818.                             // reverse condition

    3819. 

  3819.                             for (char * k = piece + strlen(piece) - 1; k >= piece; k--) {

    3820. 

  3820.                                 switch(*k) {

    3821. 

  3821.                                   case '[': {

    3822. 

  3822.                                         if (neg) *(k+1) = '['; else *k = ']';

    3823. 

  3823.                                         break;

    3824. 

  3824.                                     }

    3825. 

  3825.                                   case ']': {

    3826. 

  3826.                                         *k = '[';

    3827. 

  3827.                                         if (neg) *(k+1) = '^';

    3828. 

  3828.                                         neg = 0;

    3829. 

  3829.                                         break;

    3830. 

  3830.                                     }

    3831. 

  3831.                                   case '^': {

    3832. 

  3832.                                        if (*(k+1) == ']') neg = 1; else *(k+1) = *k;

    3833. 

  3833.                                        break;

    3834. 

  3834.                                     }

    3835. 

  3835.                                   default: {

    3836. 

  3836.                                     if (neg) *(k+1) = *k;

    3837. 

  3837.                                   }

    3838. 

  3838.                                }

    3839. 

  3839.                             }

    3840. 

  3840.                           }

    3841. 

  3841.                           if (nptr->stripl && (strcmp(piece, ".") != 0) &&

    3842. 

  3842.                             redundant_condition(at, nptr->strip, nptr->stripl, piece, nl))

    3843. 

  3843.                                 strcpy(piece, ".");

    3844. 

  3844.                           if (encodeit(nptr,piece)) return 1;

    3845. 

  3845.                          break;

    3846. 

  3846.                 }

    3847. 

  3847.                 

    3848. 

  3848. #ifdef HUNSPELL_EXPERIMENTAL

    3849. 

  3849.                 case 5: {

    3850. 

  3850.                           np++;

    3851. 

  3851.                           if (pHMgr->is_aliasm()) {

    3852. 

  3852.                             int index = atoi(piece);

    3853. 

  3853.                             nptr->morphcode = pHMgr->get_aliasm(index);

    3854. 

  3854.                           } else {

    3855. 

  3855.                             if (complexprefixes) {

    3856. 

  3856.                                 if (utf8) reverseword_utf(piece); else reverseword(piece);

    3857. 

  3857.                             }

    3858. 

  3858.                             nptr->morphcode = mystrdup(piece);

    3859. 

  3859.                           }

    3860. 

  3860.                           break; 

    3861. 

  3861.                 }

    3862. 

  3862. #endif

    3863. 

  3863. 

    3864. 

  3864.                 default: break;

    3865. 

  3865.              }

    3866. 

  3866.              i++;

    3867. 

  3867.          }

    3868. 

  3868.          free(piece);

    3869. 

  3869.          piece = mystrsep(&tp, 0);

    3870. 

  3870.       }

    3871. 

  3871.       // check to make sure we parsed enough pieces

    3872. 

  3872.       if (np < 4) {

    3873. 

  3873.           char * err = pHMgr->encode_flag(aflag);

    3874. 

  3874.           HUNSPELL_WARNING(stderr, "error: affix %s is corrupt near line %s\n", err, nl);

    3875. 

  3875.           free(err);

    3876. 

  3876.           free(ptr);

    3877. 

  3877.           return 1;

    3878. 

  3878.       }

    3879. 

  3879. 

    3880. 

  3880. #ifdef DEBUG

    3881. 

  3881. #ifdef HUNSPELL_EXPERIMENTAL

    3882. 

  3882.       // detect unnecessary fields, excepting comments

    3883. 

  3883.       if (basefieldnum) {

    3884. 

  3884.         int fieldnum = !(nptr->morphcode) ? 5 : ((*(nptr->morphcode)=='#') ? 5 : 6);

    3885. 

  3885.           if (fieldnum != basefieldnum) 

    3886. 

  3886.             HUNSPELL_WARNING(stderr, "warning: bad field number:\n%s\n", nl);

    3887. 

  3887.       } else {

    3888. 

  3888.         basefieldnum = !(nptr->morphcode) ? 5 : ((*(nptr->morphcode)=='#') ? 5 : 6);

    3889. 

  3889.       }

    3890. 

  3890. #endif

    3891. 

  3891. #endif

    3892. 

  3892.       nptr++;

    3893. 

  3893.    }

    3894. 

  3894.  

    3895. 

  3895.    // now create SfxEntry or PfxEntry objects and use links to

    3896. 

  3896.    // build an ordered (sorted by affix string) list

    3897. 

  3897.    nptr = ptr;

    3898. 

  3898.    for (int k = 0; k < numents; k++) {

    3899. 

  3899.       if (at == 'P') {

    3900. 

  3900.           PfxEntry * pfxptr = new PfxEntry(this,nptr);

    3901. 

  3901.           build_pfxtree((AffEntry *)pfxptr);

    3902. 

  3902.       } else {

    3903. 

  3903.           SfxEntry * sfxptr = new SfxEntry(this,nptr);

    3904. 

  3904.           build_sfxtree((AffEntry *)sfxptr); 

    3905. 

  3905.       }

    3906. 

  3906.       nptr++;

    3907. 

  3907.    }      

    3908. 

  3908.    free(ptr);

    3909. 

  3909.    return 0;

    3910. 

  3910. }

    3911. 

  3911. 

    3912. 

  3912. int AffixMgr::redundant_condition(char ft, char * strip, int stripl, const char * cond, char * line) {

    3913. 

  3913.   int condl = strlen(cond);

    3914. 

  3914.   int i;

    3915. 

  3915.   int j;

    3916. 

  3916.   int neg;

    3917. 

  3917.   int in;

    3918. 

  3918.   if (ft == 'P') { // prefix

    3919. 

  3919.     if (strncmp(strip, cond, condl) == 0) return 1;

    3920. 

  3920.     if (utf8) {

    3921. 

  3921.     } else {

    3922. 

  3922.       for (i = 0, j = 0; (i < stripl) && (j < condl); i++, j++) {

    3923. 

  3923.         if (cond[j] != '[') {

    3924. 

  3924.           if (cond[j] != strip[i]) {

    3925. 

  3925.             HUNSPELL_WARNING(stderr, "warning: incompatible stripping characters and condition:\n%s\n", line);

    3926. 

  3926.           }

    3927. 

  3927.         } else {

    3928. 

  3928.           neg = (cond[j+1] == '^') ? 1 : 0;

    3929. 

  3929.           in = 0;

    3930. 

  3930.           do {

    3931. 

  3931.             j++;

    3932. 

  3932.             if (strip[i] == cond[j]) in = 1;

    3933. 

  3933.           } while ((j < (condl - 1)) && (cond[j] != ']'));

    3934. 

  3934.           if (j == (condl - 1) && (cond[j] != ']')) {

    3935. 

  3935.             HUNSPELL_WARNING(stderr, "error: missing ] in condition:\n%s\n", line);

    3936. 

  3936.             return 0;

    3937. 

  3937.           }

    3938. 

  3938.           if ((!neg && !in) || (neg && in)) {

    3939. 

  3939.             HUNSPELL_WARNING(stderr, "warning: incompatible stripping characters and condition:\n%s\n", line);

    3940. 

  3940.             return 0;          

    3941. 

  3941.           }

    3942. 

  3942.         }

    3943. 

  3943.       }

    3944. 

  3944.       if (j >= condl) return 1;

    3945. 

  3945.     }

    3946. 

  3946.   } else { // suffix

    3947. 

  3947.     if ((stripl >= condl) && strcmp(strip + stripl - condl, cond) == 0) return 1;

    3948. 

  3948.     if (utf8) {

    3949. 

  3949.     } else {

    3950. 

  3950.       for (i = stripl - 1, j = condl - 1; (i >= 0) && (j >= 0); i--, j--) {

    3951. 

  3951.         if (cond[j] != ']') {

    3952. 

  3952.           if (cond[j] != strip[i]) {

    3953. 

  3953.             HUNSPELL_WARNING(stderr, "warning: incompatible stripping characters and condition:\n%s\n", line);

    3954. 

  3954.           }

    3955. 

  3955.         } else {

    3956. 

  3956.           in = 0;

    3957. 

  3957.           do {

    3958. 

  3958.             j--;

    3959. 

  3959.             if (strip[i] == cond[j]) in = 1;

    3960. 

  3960.           } while ((j > 0) && (cond[j] != '['));

    3961. 

  3961.           if ((j == 0) && (cond[j] != '[')) {

    3962. 

  3962.             HUNSPELL_WARNING(stderr, "error: missing ] in condition:\n%s\n", line);

    3963. 

  3963.             return 0;

    3964. 

  3964.           }

    3965. 

  3965.           neg = (cond[j+1] == '^') ? 1 : 0;

    3966. 

  3966.           if ((!neg && !in) || (neg && in)) {

    3967. 

  3967.             HUNSPELL_WARNING(stderr, "warning: incompatible stripping characters and condition:\n%s\n", line);

    3968. 

  3968.             return 0;          

    3969. 

  3969.           }

    3970. 

  3970.         }

    3971. 

  3971.       }

    3972. 

  3972.       if (j < 0) return 1;

    3973. 

  3973.     }    

    3974. 

  3974.   }

    3975. 

  3975.   return 0;

    3976. 

  3976. }

    3977. 

  3977.