PageRenderTime 68ms CodeModel.GetById 26ms RepoModel.GetById 0ms app.codeStats 1ms

/main/src/com/google/refine/clustering/binning/Metaphone3.java

http://google-refine.googlecode.com/
Java | 7460 lines | 4716 code | 652 blank | 2092 comment | 2026 complexity | 8774dc1d2a94526d600a7cc2d818d021 MD5 | raw file
Possible License(s): JSON, LGPL-2.1, MIT, Apache-2.0, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /*

    2. 

  2. 

    3. 

  3. Copyright 2010, Lawrence Philips

    4. 

  4. All rights reserved.

    5. 

  5. 

    6. 

  6. Redistribution and use in source and binary forms, with or without

    7. 

  7. modification, are permitted provided that the following conditions are

    8. 

  8. met:

    9. 

  9. 

    10. 

  10.     * Redistributions of source code must retain the above copyright

    11. 

  11. notice, this list of conditions and the following disclaimer.

    12. 

  12.     * Redistributions in binary form must reproduce the above

    13. 

  13. copyright notice, this list of conditions and the following disclaimer

    14. 

  14. in the documentation and/or other materials provided with the

    15. 

  15. distribution.

    16. 

  16.     * Neither the name of Google Inc. nor the names of its

    17. 

  17. contributors may be used to endorse or promote products derived from

    18. 

  18. this software without specific prior written permission.

    19. 

  19. 

    20. 

  20. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    21. 

  21. "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    22. 

  22. LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    23. 

  23. A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

    24. 

  24. OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    25. 

  25. SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

    26. 

  26. LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,           

    27. 

  27. DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY           

    28. 

  28. THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    29. 

  29. (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    30. 

  30. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    31. 

  31. 

    32. 

  32. */

    33. 

  33. 

    34. 

  34. /*

    35. 

  35.  * A request from the author: Please comment and sign any changes you make to 

    36. 

  36.  * the Metaphone 3 reference implementation.

    37. 

  37.  * <br>

    38. 

  38.  * Please do NOT reformat this module to Google Refine's coding standard,

    39. 

  39.  * but instead keep the original format so that it can be more easily compare

    40. 

  40.  * to any modified fork of the original.

    41. 

  41.  */

    42. 

  42. 

    43. 

  43. /**

    44. 

  44.  * Metaphone 3<br>

    45. 

  45.  * VERSION 2.1.3

    46. 

  46.  * 

    47. 

  47.  * by Lawrence Philips<br>

    48. 

  48.  * 

    49. 

  49.  * Metaphone 3 is designed to return an *approximate* phonetic key (and an alternate

    50. 

  50.  * approximate phonetic key when appropriate) that should be the same for English

    51. 

  51.  * words, and most names familiar in the United States, that are pronounced *similarly*.

    52. 

  52.  * The key value is *not* intended to be an *exact* phonetic, or even phonemic,

    53. 

  53.  * representation of the word. This is because a certain degree of 'fuzziness' has

    54. 

  54.  * proven to be useful in compensating for variations in pronunciation, as well as

    55. 

  55.  * misheard pronunciations. For example, although americans are not usually aware of it,

    56. 

  56.  * the letter 's' is normally pronounced 'z' at the end of words such as "sounds".<br><br>

    57. 

  57.  * 

    58. 

  58.  * The 'approximate' aspect of the encoding is implemented according to the following rules:<br><br>

    59. 

  59.  * 

    60. 

  60.  * (1) All vowels are encoded to the same value - 'A'. If the parameter encodeVowels

    61. 

  61.  * is set to false, only *initial* vowels will be encoded at all. If encodeVowels is set

    62. 

  62.  * to true, 'A' will be encoded at all places in the word that any vowels are normally

    63. 

  63.  * pronounced. 'W' as well as 'Y' are treated as vowels. Although there are differences in

    64. 

  64.  * the pronunciation of 'W' and 'Y' in different circumstances that lead to their being

    65. 

  65.  * classified as vowels under some circumstances and as consonants in others, for the purposes

    66. 

  66.  * of the 'fuzziness' component of the Soundex and Metaphone family of algorithms they will

    67. 

  67.  * be always be treated here as vowels.<br><br>

    68. 

  68.  *

    69. 

  69.  * (2) Voiced and un-voiced consonant pairs are mapped to the same encoded value. This

    70. 

  70.  * means that:<br>

    71. 

  71.  * 'D' and 'T' -> 'T'<br>

    72. 

  72.  * 'B' and 'P' -> 'P'<br>

    73. 

  73.  * 'G' and 'K' -> 'K'<br>

    74. 

  74.  * 'Z' and 'S' -> 'S'<br>

    75. 

  75.  * 'V' and 'F' -> 'F'<br><br>

    76. 

  76.  *

    77. 

  77.  * - In addition to the above voiced/unvoiced rules, 'CH' and 'SH' -> 'X', where 'X'

    78. 

  78.  * represents the "-SH-" and "-CH-" sounds in Metaphone 3 encoding.<br><br>

    79. 

  79.  *

    80. 

  80.  * - Also, the sound that is spelled as "TH" in English is encoded to '0' (zero symbol). (Although

    81. 

  81.  * Americans are not usually aware of it, "TH" is pronounced in a voiced (e.g. "that") as

    82. 

  82.  * well as an unvoiced (e.g. "theater") form, which are naturally mapped to the same encoding.)<br><br>

    83. 

  83.  * 

    84. 

  84.  * The encodings in this version of Metaphone 3 are according to pronunciations common in the

    85. 

  85.  * United States. This means that they will be inaccurate for consonant pronunciations that

    86. 

  86.  * are different in the United Kingdom, for example "tube" -> "CHOOBE" -> XAP rather than american TAP.<br><br>

    87. 

  87.  *

    88. 

  88.  * Metaphone 3 was preceded by by Soundex, patented in 1919, and Metaphone and Double Metaphone,

    89. 

  89.  * developed by Lawrence Philips. All of these algorithms resulted in a significant number of

    90. 

  90.  * incorrect encodings. Metaphone3 was tested against a database of about 100 thousand English words,

    91. 

  91.  * names common in the United States, and non-English words found in publications in the United States,

    92. 

  92.  * with an emphasis on words that are commonly mispronounced, prepared by the Moby Words website,

    93. 

  93.  * but with the Moby Words 'phonetic' encodings algorithmically mapped to Double Metaphone encodings.

    94. 

  94.  * Metaphone3 increases the accuracy of encoding of english words, common names, and non-English

    95. 

  95.  * words found in american publications from the 89% for Double Metaphone, to over 98%.<br><br>

    96. 

  96.  *

    97. 

  97.  * DISCLAIMER:

    98. 

  98.  * Anthropomorphic Software LLC claims only that Metaphone 3 will return correct encodings,

    99. 

  99.  * within the 'fuzzy' definition of correct as above, for a very high percentage of correctly

    100. 

  100.  * spelled English and commonly recognized non-English words. Anthropomorphic Software LLC

    101. 

  101.  * warns the user that a number of words remain incorrectly encoded, that misspellings may not

    102. 

  102.  * be encoded 'properly', and that people often have differing ideas about the pronunciation

    103. 

  103.  * of a word. Therefore, Metaphone 3 is not guaranteed to return correct results every time, and

    104. 

  104.  * so a desired target word may very well be missed. Creators of commercial products should

    105. 

  105.  * keep in mind that systems like Metaphone 3 produce a 'best guess' result, and should

    106. 

  106.  * condition the expectations of end users accordingly.<br><br>

    107. 

  107.  *

    108. 

  108.  * METAPHONE3 IS PROVIDED "AS IS" WITHOUT

    109. 

  109.  * WARRANTY OF ANY KIND. LAWRENCE PHILIPS AND ANTHROPOMORPHIC SOFTWARE LLC

    110. 

  110.  * MAKE NO WARRANTIES, EXPRESS OR IMPLIED, THAT IT IS FREE OF ERROR,

    111. 

  111.  * OR ARE CONSISTENT WITH ANY PARTICULAR STANDARD OF MERCHANTABILITY, 

    112. 

  112.  * OR THAT IT WILL MEET YOUR REQUIREMENTS FOR ANY PARTICULAR APPLICATION.

    113. 

  113.  * LAWRENCE PHILIPS AND ANTHROPOMORPHIC SOFTWARE LLC DISCLAIM ALL LIABILITY

    114. 

  114.  * FOR DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES RESULTING FROM USE 

    115. 

  115.  * OF THIS SOFTWARE. 

    116. 

  116.  *

    117. 

  117.  * @author Lawrence Philips

    118. 

  118.  * 

    119. 

  119.  * Metaphone 3 is designed to return an <i>approximate</i> phonetic key (and an alternate

    120. 

  120.  * approximate phonetic key when appropriate) that should be the same for English

    121. 

  121.  * words, and most names familiar in the United States, that are pronounced "similarly".

    122. 

  122.  * The key value is <i>not</i> intended to be an exact phonetic, or even phonemic,

    123. 

  123.  * representation of the word. This is because a certain degree of 'fuzziness' has

    124. 

  124.  * proven to be useful in compensating for variations in pronunciation, as well as

    125. 

  125.  * misheard pronunciations. For example, although americans are not usually aware of it,

    126. 

  126.  * the letter 's' is normally pronounced 'z' at the end of words such as "sounds".<br><br>

    127. 

  127.  * 

    128. 

  128.  * The 'approximate' aspect of the encoding is implemented according to the following rules:<br><br>

    129. 

  129.  * 

    130. 

  130.  * (1) All vowels are encoded to the same value - 'A'. If the parameter encodeVowels

    131. 

  131.  * is set to false, only *initial* vowels will be encoded at all. If encodeVowels is set

    132. 

  132.  * to true, 'A' will be encoded at all places in the word that any vowels are normally

    133. 

  133.  * pronounced. 'W' as well as 'Y' are treated as vowels. Although there are differences in

    134. 

  134.  * the pronunciation of 'W' and 'Y' in different circumstances that lead to their being

    135. 

  135.  * classified as vowels under some circumstances and as consonants in others, for the purposes

    136. 

  136.  * of the 'fuzziness' component of the Soundex and Metaphone family of algorithms they will

    137. 

  137.  * be always be treated here as vowels.<br><br>

    138. 

  138.  *

    139. 

  139.  * (2) Voiced and un-voiced consonant pairs are mapped to the same encoded value. This

    140. 

  140.  * means that:<br>

    141. 

  141.  * 'D' and 'T' -> 'T'<br>

    142. 

  142.  * 'B' and 'P' -> 'P'<br>

    143. 

  143.  * 'G' and 'K' -> 'K'<br>

    144. 

  144.  * 'Z' and 'S' -> 'S'<br>

    145. 

  145.  * 'V' and 'F' -> 'F'<br><br>

    146. 

  146.  *

    147. 

  147.  * - In addition to the above voiced/unvoiced rules, 'CH' and 'SH' -> 'X', where 'X'

    148. 

  148.  * represents the "-SH-" and "-CH-" sounds in Metaphone 3 encoding.<br><br>

    149. 

  149.  *

    150. 

  150.  * - Also, the sound that is spelled as "TH" in English is encoded to '0' (zero symbol). (Although

    151. 

  151.  * americans are not usually aware of it, "TH" is pronounced in a voiced (e.g. "that") as

    152. 

  152.  * well as an unvoiced (e.g. "theater") form, which are naturally mapped to the same encoding.)<br><br>

    153. 

  153.  *

    154. 

  154.  * In the "Exact" encoding, voiced/unvoiced pairs are <i>not</i> mapped to the same encoding, except

    155. 

  155.  * for the voiced and unvoiced versions of 'TH', sounds such as 'CH' and 'SH', and for 'S' and 'Z',

    156. 

  156.  * so that the words whose metaph keys match will in fact be closer in pronunciation that with the

    157. 

  157.  * more approximate setting. Keep in mind that encoding settings for search strings should always

    158. 

  158.  * be exactly the same as the encoding settings of the stored metaph keys in your database!

    159. 

  159.  * Because of the considerably increased accuracy of Metaphone3, it is now possible to use this

    160. 

  160.  * setting and have a very good chance of getting a correct encoding.

    161. 

  161.  * <br><br>

    162. 

  162.  * In the Encode Vowels encoding, all non-initial vowels and diphthongs will be encoded to

    163. 

  163.  * 'A', and there will only be one such vowel encoding character between any two consonants.

    164. 

  164.  * It turns out that there are some surprising wrinkles to encoding non-initial vowels in

    165. 

  165.  * practice, pre-eminently in inversions between spelling and pronunciation such as e.g.

    166. 

  166.  * "wrinkle" => 'RANKAL', where the last two sounds are inverted when spelled.

    167. 

  167.  * <br><br>

    168. 

  168.  * The encodings in this version of Metaphone 3 are according to pronunciations common in the

    169. 

  169.  * United States. This means that they will be inaccurate for consonant pronunciations that

    170. 

  170.  * are different in the United Kingdom, for example "tube" -> "CHOOBE" -> XAP rather than american TAP.

    171. 

  171.  * <br><br>

    172. 

  172.  * 

    173. 

  173.  */

    174. 

  174. 

    175. 

  175. package com.google.refine.clustering.binning;

    176. 

  176. 

    177. 

  177. public class Metaphone3 {

    178. 

  178. 

    179. 

  179.     /** Length of word sent in to be encoded, as 

    180. 

  180. 	* measured at beginning of encoding. */

    181. 

  181. 	int  m_length;

    182. 

  182. 

    183. 

  183.     /** Length of encoded key string. */

    184. 

  184.     int m_metaphLength;

    185. 

  185. 

    186. 

  186.     /** Flag whether or not to encode non-initial vowels. */

    187. 

  187.     boolean m_encodeVowels;

    188. 

  188. 

    189. 

  189.     /** Flag whether or not to encode consonants as exactly 

    190. 

  190. 	* as possible. */

    191. 

  191. 	boolean m_encodeExact;

    192. 

  192. 

    193. 

  193. 	/** Internal copy of word to be encoded, allocated separately

    194. 

  194. 	* from string pointed to in incoming parameter. */

    195. 

  195. 	String m_inWord;

    196. 

  196.     

    197. 

  197. 	/** Running copy of primary key. */

    198. 

  198.     StringBuffer m_primary;

    199. 

  199. 

    200. 

  200.     /** Running copy of secondary key. */

    201. 

  201.     StringBuffer m_secondary;

    202. 

  202. 

    203. 

  203.     /** Index of character in m_inWord currently being

    204. 

  204. 	* encoded. */

    205. 

  205.     int m_current;

    206. 

  206. 

    207. 

  207.     /** Index of last character in m_inWord. */

    208. 

  208. 	int m_last;

    209. 

  209. 

    210. 

  210. 	/** Flag that an AL inversion has already been done. */

    211. 

  211. 	boolean flag_AL_inversion;

    212. 

  212. 	

    213. 

  213. 	/** Default size of key storage allocation */

    214. 

  214. 	int MAX_KEY_ALLOCATION = 32;

    215. 

  215. 	

    216. 

  216. 	/** Default maximum length of encoded key. */

    217. 

  217. 	int DEFAULT_MAX_KEY_LENGTH = 8;

    218. 

  218. 	

    219. 

  219. 	////////////////////////////////////////////////////////////////////////////////

    220. 

  220. 	// Metaphone3 class definition

    221. 

  221. 	////////////////////////////////////////////////////////////////////////////////

    222. 

  222. 

    223. 

  223. 	/**

    224. 

  224. 	 * Constructor, default. This constructor is most convenient when

    225. 

  225. 	 * encoding more than one word at a time. New words to encode can

    226. 

  226. 	 * be set using SetWord(char *).

    227. 

  227. 	 *

    228. 

  228. 	 */

    229. 

  229. 	Metaphone3()

    230. 

  230. 	{

    231. 

  231. 	    m_primary = new StringBuffer();

    232. 

  232. 	    m_secondary = new StringBuffer();

    233. 

  233. 

    234. 

  234. 	    m_metaphLength = DEFAULT_MAX_KEY_LENGTH;

    235. 

  235. 	    m_encodeVowels = false;

    236. 

  236. 		m_encodeExact = false;

    237. 

  237. 	}

    238. 

  238. 

    239. 

  239. 	/**

    240. 

  240. 	 * Constructor, parameterized. The Metaphone3 object will

    241. 

  241. 	 * be initialized with the incoming string, and can be called

    242. 

  242. 	 * on to encode this string. This constructor is most convenient

    243. 

  243. 	 * when only one word needs to be encoded.

    244. 

  244. 	 * 

    245. 

  245. 	 * @param in pointer to char string of word to be encoded.

    246. 

  246. 	 *

    247. 

  247. 	 */

    248. 

  248. 	Metaphone3(String in)

    249. 

  249. 	{

    250. 

  250. 		this();

    251. 

  251. 		

    252. 

  252. 		SetWord(in);

    253. 

  253. 	}

    254. 

  254. 

    255. 

  255. 	/**

    256. 

  256. 	 * Sets word to be encoded.

    257. 

  257. 	 * 

    258. 

  258. 	 * @param in pointer to EXTERNALLY ALLOCATED char string of 

    259. 

  259. 	 * the word to be encoded.

    260. 

  260. 	 *

    261. 

  261. 	 */

    262. 

  262. 	void SetWord(String in)

    263. 

  263. 	{

    264. 

  264. 		m_inWord = in.toUpperCase();;

    265. 

  265. 		m_length = m_inWord.length();

    266. 

  266. 	}

    267. 

  267. 

    268. 

  268. 	/**

    269. 

  269. 	 * Sets length allocated for output keys.

    270. 

  270. 	 * If incoming number is greater than maximum allowable 

    271. 

  271. 	 * length returned by GetMaximumKeyLength(), set key length

    272. 

  272. 	 * to maximum key length and return false;  otherwise, set key 

    273. 

  273. 	 * length to parameter value and return true.

    274. 

  274. 	 * 

    275. 

  275. 	 * @param inKeyLength new length of key.

    276. 

  276. 	 * @return true if able to set key length to requested value.

    277. 

  277. 	 *

    278. 

  278. 	*/

    279. 

  279. 	boolean SetKeyLength(int inKeyLength)

    280. 

  280. 	{

    281. 

  281. 	    if(inKeyLength < 1)

    282. 

  282. 		{

    283. 

  283. 			// can't have that -

    284. 

  284. 			// no room for terminating null

    285. 

  285. 			inKeyLength = 1;

    286. 

  286. 		}

    287. 

  287. 

    288. 

  288. 		if(inKeyLength > MAX_KEY_ALLOCATION)

    289. 

  289. 	    {

    290. 

  290. 	        m_metaphLength = MAX_KEY_ALLOCATION;

    291. 

  291. 	        return false;

    292. 

  292. 	    }

    293. 

  293. 

    294. 

  294. 	     m_metaphLength = inKeyLength;

    295. 

  295. 	     return true;

    296. 

  296. 	}

    297. 

  297. 

    298. 

  298.     /**

    299. 

  299.      * Adds an encoding character to the encoded key value string - one parameter version.

    300. 

  300.      * 

    301. 

  301.      * @param main primary encoding character to be added to encoded key string.

    302. 

  302.      */

    303. 

  303.     void MetaphAdd(String in)

    304. 

  304.     {

    305. 

  305.     	if(!(in.equals("A") 

    306. 

  306.     			&& (m_primary.length() > 0) 

    307. 

  307.     			&& (m_primary.charAt(m_primary.length() - 1) == 'A')))

    308. 

  308.     	{

    309. 

  309.     		m_primary.append(in);

    310. 

  310.     	}

    311. 

  311.     	

    312. 

  312.     	if(!(in.equals("A") 

    313. 

  313.     			&& (m_secondary.length() > 0) 

    314. 

  314.     			&& (m_secondary.charAt(m_secondary.length() - 1) == 'A')))

    315. 

  315.     	{

    316. 

  316.     		m_secondary.append(in);

    317. 

  317.     	}

    318. 

  318.     }

    319. 

  319.     

    320. 

  320. 	/**

    321. 

  321. 	 * Adds an encoding character to the encoded key value string - two parameter version

    322. 

  322. 	 * 

    323. 

  323. 	 * @param main primary encoding character to be added to encoded key string

    324. 

  324. 	 * @param alt alternative encoding character to be added to encoded alternative key string

    325. 

  325. 	 *

    326. 

  326. 	 */

    327. 

  327. 	void MetaphAdd(String main, String alt)

    328. 

  328. 	{

    329. 

  329.     	if(!(main.equals("A") 

    330. 

  330.     			&& (m_primary.length() > 0) 

    331. 

  331.     			&& (m_primary.charAt(m_primary.length() - 1) == 'A')))

    332. 

  332.     	{

    333. 

  333.     		m_primary.append(main);

    334. 

  334.     	}

    335. 

  335.     	

    336. 

  336.     	if(!(alt.equals("A") 

    337. 

  337.     			&& (m_secondary.length() > 0) 

    338. 

  338.     			&& (m_secondary.charAt(m_secondary.length() - 1) == 'A')))

    339. 

  339.     	{

    340. 

  340. 			if(!alt.isEmpty())

    341. 

  341. 			{

    342. 

  342. 				m_secondary.append(alt);

    343. 

  343. 			}

    344. 

  344.     	}

    345. 

  345. 	}

    346. 

  346. 

    347. 

  347. 	/**

    348. 

  348. 	 * Adds an encoding character to the encoded key value string - Exact/Approx version

    349. 

  349. 	 * 

    350. 

  350. 	 * @param mainExact primary encoding character to be added to encoded key string if 

    351. 

  351. 	 * m_encodeExact is set

    352. 

  352. 	 *

    353. 

  353. 	 * @param altExact alternative encoding character to be added to encoded alternative 

    354. 

  354. 	 * key string if m_encodeExact is set

    355. 

  355. 	 *

    356. 

  356. 	 * @param main primary encoding character to be added to encoded key string

    357. 

  357. 	 *

    358. 

  358. 	 * @param alt alternative encoding character to be added to encoded alternative key string

    359. 

  359. 	 *

    360. 

  360. 	 */	

    361. 

  361. 	void MetaphAddExactApprox(String mainExact, String altExact, String main, String alt)

    362. 

  362. 	{

    363. 

  363. 		if(m_encodeExact)

    364. 

  364. 		{

    365. 

  365. 			MetaphAdd(mainExact, altExact);

    366. 

  366. 		}

    367. 

  367. 		else

    368. 

  368. 		{

    369. 

  369. 			MetaphAdd(main, alt);

    370. 

  370. 		}

    371. 

  371. 	}

    372. 

  372. 

    373. 

  373. 	/**

    374. 

  374. 	 * Adds an encoding character to the encoded key value string - Exact/Approx version

    375. 

  375. 	 * 

    376. 

  376. 	 * @param mainExact primary encoding character to be added to encoded key string if 

    377. 

  377. 	 * m_encodeExact is set

    378. 

  378. 	 *

    379. 

  379. 	 * @param main primary encoding character to be added to encoded key string

    380. 

  380. 	 *

    381. 

  381. 	 */	

    382. 

  382. 	void MetaphAddExactApprox(String mainExact, String main)

    383. 

  383. 	{

    384. 

  384. 		if(m_encodeExact)

    385. 

  385. 		{

    386. 

  386. 			MetaphAdd(mainExact);

    387. 

  387. 		}

    388. 

  388. 		else

    389. 

  389. 		{

    390. 

  390. 			MetaphAdd(main);

    391. 

  391. 		}

    392. 

  392. 	}	 

    393. 

  393. 	/** Retrieves maximum number of characters currently allocated for encoded key. 

    394. 

  394. 	 *

    395. 

  395. 	 * @return short integer representing the length allowed for the key.

    396. 

  396. 	 */

    397. 

  397.    int GetKeyLength(){return m_metaphLength;}

    398. 

  398. 

    399. 

  399. 	/** Retrieves maximum number of characters allowed for encoded key. 

    400. 

  400. 	 *

    401. 

  401. 	 * @return short integer representing the length of allocated storage for the key.

    402. 

  402. 	 */

    403. 

  403.    int GetMaximumKeyLength(){return (int)MAX_KEY_ALLOCATION;}

    404. 

  404. 

    405. 

  405. 	/** Sets flag that causes Metaphone3 to encode non-initial vowels. However, even 

    406. 

  406. 	 * if there are more than one vowel sound in a vowel sequence (i.e. 

    407. 

  407. 	 * vowel diphthong, etc.), only one 'A' will be encoded before the next consonant or the

    408. 

  408. 	 * end of the word.

    409. 

  409. 	 *

    410. 

  410. 	 * @param inEncodeVowels Non-initial vowels encoded if true, not if false. 

    411. 

  411. 	 */

    412. 

  412.    void SetEncodeVowels(boolean inEncodeVowels){m_encodeVowels = inEncodeVowels;}

    413. 

  413. 

    414. 

  414. 	/** Retrieves setting determining whether or not non-initial vowels will be encoded. 

    415. 

  415. 	 *

    416. 

  416. 	 * @return true if the Metaphone3 object has been set to encode non-initial vowels, false if not.

    417. 

  417. 	 */

    418. 

  418.    boolean GetEncodeVowels(){return m_encodeVowels;}

    419. 

  419. 

    420. 

  420. 	/** Sets flag that causes Metaphone3 to encode consonants as exactly as possible.

    421. 

  421. 	 * This does not include 'S' vs. 'Z', since americans will pronounce 'S' at the

    422. 

  422. 	 * at the end of many words as 'Z', nor does it include "CH" vs. "SH". It does cause

    423. 

  423. 	 * a distinction to be made between 'B' and 'P', 'D' and 'T', 'G' and 'K', and 'V'

    424. 

  424. 	 * and 'F'.

    425. 

  425. 	 *

    426. 

  426. 	 * @param inEncodeExact consonants to be encoded "exactly" if true, not if false. 

    427. 

  427. 	 */

    428. 

  428.    void SetEncodeExact(boolean inEncodeExact){m_encodeExact = inEncodeExact;}

    429. 

  429. 

    430. 

  430. 	/** Retrieves setting determining whether or not consonants will be encoded "exactly".

    431. 

  431. 	 *

    432. 

  432. 	 * @return true if the Metaphone3 object has been set to encode "exactly", false if not.

    433. 

  433. 	 */

    434. 

  434.    boolean GetEncodeExact(){return m_encodeExact;}

    435. 

  435. 

    436. 

  436. 	/** Retrieves primary encoded key.

    437. 

  437. 	 *

    438. 

  438. 	 * @return a character pointer to the primary encoded key

    439. 

  439. 	 */

    440. 

  440. 	String GetMetaph()

    441. 

  441. 	{

    442. 

  442. 		String primary = new String(m_primary);

    443. 

  443. 		return primary;

    444. 

  444. 	}

    445. 

  445. 

    446. 

  446. 	/** Retrieves alternate encoded key, if any. 

    447. 

  447. 	 *

    448. 

  448. 	 * @return a character pointer to the alternate encoded key

    449. 

  449. 	 */

    450. 

  450. 	String GetAlternateMetaph()

    451. 

  451. 	{

    452. 

  452. 		String secondary = new String(m_secondary);

    453. 

  453. 		return secondary;

    454. 

  454. 	}

    455. 

  455. 

    456. 

  456. 	/**

    457. 

  457. 	 * Test for close front vowels

    458. 

  458. 	 *

    459. 

  459. 	 * @return true if close front vowel

    460. 

  460. 	 */

    461. 

  461. 	boolean Front_Vowel(int at)

    462. 

  462. 	{

    463. 

  463. 		if(((CharAt(at) == 'E') || (CharAt(at) == 'I') || (CharAt(at) == 'Y')))

    464. 

  464. 		{

    465. 

  465. 			return true;

    466. 

  466. 		}

    467. 

  467. 

    468. 

  468. 		return false;

    469. 

  469. 	}

    470. 

  470. 

    471. 

  471. 	/**

    472. 

  472. 	 * Detect names or words that begin with spellings

    473. 

  473. 	 * typical of german or slavic words, for the purpose

    474. 

  474. 	 * of choosing alternate pronunciations correctly

    475. 

  475. 	 *

    476. 

  476. 	 */

    477. 

  477. 	boolean SlavoGermanic()

    478. 

  478. 	{

    479. 

  479. 		if(StringAt(0, 3, "SCH", "")

    480. 

  480. 			|| StringAt(0, 2, "SW", "")

    481. 

  481. 			|| (CharAt(0) == 'J')

    482. 

  482. 			|| (CharAt(0) == 'W'))

    483. 

  483. 		{

    484. 

  484. 			return true;

    485. 

  485. 		}

    486. 

  486. 

    487. 

  487. 		return false;

    488. 

  488. 	}	

    489. 

  489. 	/**

    490. 

  490. 	 * Tests if character is a vowel

    491. 

  491. 	 * 

    492. 

  492. 	 * @param inChar character to be tested in string to be encoded

    493. 

  493. 	 * @return true if character is a vowel, false if not

    494. 

  494. 	 *

    495. 

  495. 	 */

    496. 

  496. 	boolean IsVowel(char inChar)

    497. 

  497. 	{

    498. 

  498. 	    if((inChar == 'A') 

    499. 

  499. 			|| (inChar == 'E') 

    500. 

  500. 			|| (inChar == 'I') 

    501. 

  501. 			|| (inChar == 'O') 

    502. 

  502. 			|| (inChar == 'U') 

    503. 

  503. 			|| (inChar == 'Y') 

    504. 

  504. 			|| (inChar == 'Ŕ')

    505. 

  505. 			|| (inChar == 'Á')

    506. 

  506. 			|| (inChar == 'Â')

    507. 

  507. 			|| (inChar == 'Ă')

    508. 

  508. 			|| (inChar == 'Ä')

    509. 

  509. 			|| (inChar == 'Ĺ')

    510. 

  510. 			|| (inChar == 'Ć')

    511. 

  511. 			|| (inChar == 'Č')

    512. 

  512. 			|| (inChar == 'É')

    513. 

  513. 	 		|| (inChar == 'Ę')

    514. 

  514. 			|| (inChar == 'Ë')

    515. 

  515. 			|| (inChar == 'Ě')

    516. 

  516. 			|| (inChar == 'Í')

    517. 

  517. 			|| (inChar == 'Î')

    518. 

  518. 	 		|| (inChar == 'Ď')

    519. 

  519. 			|| (inChar == 'Ň')

    520. 

  520. 			|| (inChar == 'Ó')

    521. 

  521. 			|| (inChar == 'Ô')

    522. 

  522. 			|| (inChar == 'Ő')

    523. 

  523. 			|| (inChar == 'Ö')

    524. 

  524. 			|| (inChar == '?')

    525. 

  525. 			|| (inChar == 'Ř')

    526. 

  526. 			|| (inChar == 'Ů')

    527. 

  527. 			|| (inChar == 'Ú')

    528. 

  528. 			|| (inChar == 'Ű')

    529. 

  529. 			|| (inChar == 'Ü')

    530. 

  530. 			|| (inChar == 'Ý')

    531. 

  531. 			|| (inChar == '?'))

    532. 

  532. 		{

    533. 

  533. 	        return true;

    534. 

  534. 		}

    535. 

  535. 

    536. 

  536. 	    return false;

    537. 

  537. 	}

    538. 

  538. 

    539. 

  539. 	/**

    540. 

  540. 	 * Tests if character in the input string is a vowel

    541. 

  541. 	 * 

    542. 

  542. 	 * @param at position of character to be tested in string to be encoded

    543. 

  543. 	 * @return true if character is a vowel, false if not

    544. 

  544. 	 *

    545. 

  545. 	 */

    546. 

  546. 	boolean IsVowel(int at)

    547. 

  547. 	{

    548. 

  548. 	    if((at < 0) || (at >= m_length))

    549. 

  549. 		{

    550. 

  550. 	        return false;

    551. 

  551. 		}

    552. 

  552. 

    553. 

  553. 	    char it = CharAt(at);

    554. 

  554. 

    555. 

  555. 	    if(IsVowel(it))

    556. 

  556. 		{

    557. 

  557. 	        return true;

    558. 

  558. 		}

    559. 

  559. 

    560. 

  560. 	    return false;

    561. 

  561. 	}

    562. 

  562. 

    563. 

  563. 	/**

    564. 

  564. 	 * Skips over vowels in a string. Has exceptions for skipping consonants that

    565. 

  565. 	 * will not be encoded.

    566. 

  566. 	 *

    567. 

  567. 	 * @param at position, in string to be encoded, of character to start skipping from

    568. 

  568. 	 *

    569. 

  569. 	 * @return position of next consonant in string to be encoded 

    570. 

  570. 	 */

    571. 

  571. 	int SkipVowels(int at)

    572. 

  572. 	{

    573. 

  573. 	    if(at < 0)

    574. 

  574. 		{

    575. 

  575. 	        return 0;

    576. 

  576. 		}

    577. 

  577. 

    578. 

  578. 	    if(at >= m_length)

    579. 

  579. 		{

    580. 

  580. 	        return m_length;

    581. 

  581. 		}

    582. 

  582. 

    583. 

  583. 	    char it = CharAt(at);

    584. 

  584. 

    585. 

  585. 	    while(IsVowel(it) || (it == 'W'))

    586. 

  586. 	    {

    587. 

  587. 	        if(StringAt(at, 4, "WICZ", "WITZ", "WIAK", "")

    588. 

  588. 				|| StringAt((at - 1), 5, "EWSKI", "EWSKY", "OWSKI", "OWSKY", "")

    589. 

  589. 				|| (StringAt(at, 5, "WICKI", "WACKI", "") && ((at + 4) == m_last)))

    590. 

  590. 	        {

    591. 

  591. 	            break;

    592. 

  592. 	        }

    593. 

  593. 

    594. 

  594. 	        at++;

    595. 

  595. 	        if(((CharAt(at - 1) == 'W') && (CharAt(at) == 'H'))

    596. 

  596. 	            && !(StringAt(at, 3, "HOP", "")

    597. 

  597. 	                  || StringAt(at, 4, "HIDE", "HARD", "HEAD", "HAWK", "HERD", "HOOK", "HAND", "HOLE", "")

    598. 

  598. 	                  || StringAt(at, 5, "HEART", "HOUSE", "HOUND", "")

    599. 

  599. 	                  || StringAt(at, 6, "HAMMER", "")))

    600. 

  600. 			{

    601. 

  601. 	            at++;

    602. 

  602. 			}

    603. 

  603. 	        

    604. 

  604. 	        if(at > (m_length - 1))

    605. 

  605. 	        {

    606. 

  606. 	        	break;

    607. 

  607. 	        }

    608. 

  608. 	        it = CharAt(at);

    609. 

  609. 	    }

    610. 

  610. 

    611. 

  611. 	    return at;

    612. 

  612. 	}

    613. 

  613. 

    614. 

  614. 	/**

    615. 

  615. 	 * Advanced counter m_current so that it indexes the next character to be encoded

    616. 

  616. 	 *

    617. 

  617. 	 * @param ifNotEncodeVowels number of characters to advance if not encoding internal vowels

    618. 

  618. 	 * @param ifEncodeVowels number of characters to advance if encoding internal vowels

    619. 

  619. 	 *

    620. 

  620. 	 */

    621. 

  621. 	void AdvanceCounter(int ifNotEncodeVowels, int ifEncodeVowels)

    622. 

  622. 	{

    623. 

  623. 		if(!m_encodeVowels)

    624. 

  624. 		{

    625. 

  625. 			m_current += ifNotEncodeVowels;

    626. 

  626. 		}

    627. 

  627. 		else

    628. 

  628. 		{

    629. 

  629. 			m_current += ifEncodeVowels;

    630. 

  630. 		}

    631. 

  631. 	}

    632. 

  632. 	

    633. 

  633. 	

    634. 

  634.     /**

    635. 

  635.      * Subscript safe .charAt()

    636. 

  636.      * 

    637. 

  637. 	 * @param at index of character to access

    638. 

  638. 	 * @return null if index out of bounds, .charAt() otherwise

    639. 

  639. 	 */

    640. 

  640. 	char CharAt(int at)

    641. 

  641. 	{

    642. 

  642. 	    // check substring bounds

    643. 

  643. 		if((at < 0)

    644. 

  644. 	    	|| (at > (m_length - 1)))

    645. 

  645. 	    {

    646. 

  646. 	    	return '\0';

    647. 

  647. 	    }

    648. 

  648. 

    649. 

  649. 	    return m_inWord.charAt(at);

    650. 

  650. 	}

    651. 

  651. 	

    652. 

  652. 	/**

    653. 

  653. 	 * Tests whether the word is the root or a regular english inflection

    654. 

  654. 	 * of it, e.g. "ache", "achy", "aches", "ached", "aching", "achingly"

    655. 

  655. 	 * This is for cases where we want to match only the root and corresponding

    656. 

  656. 	 * inflected forms, and not completely different words which may have the

    657. 

  657. 	 * same substring in them.

    658. 

  658. 	 */

    659. 

  659. 	boolean RootOrInflections(String inWord, String root)

    660. 

  660. 	{

    661. 

  661. 		int len = root.length();

    662. 

  662. 		String test;

    663. 

  663. 

    664. 

  664. 		test = root + "S";

    665. 

  665. 		if((inWord.equals(root))

    666. 

  666. 				|| (inWord.equals(test)))

    667. 

  667. 		{

    668. 

  668. 			return true;

    669. 

  669. 		}

    670. 

  670. 

    671. 

  671. 		if(root.charAt(len - 1) != 'E')

    672. 

  672. 		{

    673. 

  673. 			test = root + "ES";

    674. 

  674. 		}

    675. 

  675. 		

    676. 

  676. 		if(inWord.equals(test))

    677. 

  677. 		{

    678. 

  678. 			return true;

    679. 

  679. 		}

    680. 

  680. 

    681. 

  681. 		if(root.charAt(len - 1) != 'E')

    682. 

  682. 		{

    683. 

  683. 			test = root + "ED";

    684. 

  684. 		}

    685. 

  685. 		else

    686. 

  686. 		{

    687. 

  687. 			test = root + "D";

    688. 

  688. 		}

    689. 

  689. 		

    690. 

  690. 		if(inWord.equals(test))

    691. 

  691. 		{

    692. 

  692. 			return true;

    693. 

  693. 		}

    694. 

  694. 

    695. 

  695. 		if(root.charAt(len - 1) == 'E')

    696. 

  696. 		{

    697. 

  697. 			root = root.substring(0, len - 1);

    698. 

  698. 		}

    699. 

  699. 

    700. 

  700. 		test = root + "ING";

    701. 

  701. 		if(inWord.equals(test))

    702. 

  702. 		{

    703. 

  703. 			return true;

    704. 

  704. 		}

    705. 

  705. 

    706. 

  706. 		test = root + "INGLY";

    707. 

  707. 		if(inWord.equals(test))

    708. 

  708. 		{

    709. 

  709. 			return true;

    710. 

  710. 		}

    711. 

  711. 

    712. 

  712. 		test = root + "Y";

    713. 

  713. 		if(inWord.equals(test))

    714. 

  714. 		{

    715. 

  715. 			return true;

    716. 

  716. 		}

    717. 

  717. 

    718. 

  718. 		return false;

    719. 

  719. 	}

    720. 

  720. 	

    721. 

  721.     /**

    722. 

  722. 	 * Determines if one of the substrings sent in is the same as

    723. 

  723. 	 * what is at the specified position in the string being encoded.

    724. 

  724. 	 * 

    725. 

  725. 	 * @param start

    726. 

  726. 	 * @param length

    727. 

  727. 	 * @param compareStrings

    728. 

  728. 	 * @return

    729. 

  729. 	 */

    730. 

  730. 	boolean StringAt(int start, int length, String... compareStrings)

    731. 

  731. 	{

    732. 

  732. 	    // check substring bounds

    733. 

  733. 		if((start < 0)

    734. 

  734. 	    	|| (start > (m_length - 1))

    735. 

  735. 	    	|| ((start + length - 1) > (m_length - 1)))

    736. 

  736. 	    {

    737. 

  737. 	    	return false;

    738. 

  738. 	    }

    739. 

  739. 

    740. 

  740. 	    String target = m_inWord.substring(start, (start + length));

    741. 

  741. 	      

    742. 

  742. 		for(String strFragment : compareStrings)

    743. 

  743. 		{

    744. 

  744. 			if(target.equals(strFragment))

    745. 

  745. 			{

    746. 

  746. 				return true;

    747. 

  747. 			}			

    748. 

  748. 		}

    749. 

  749. 	    return false;

    750. 

  750. 	}

    751. 

  751. 	

    752. 

  752. 	/**

    753. 

  753. 	 * Encodes input string to one or two key values according to Metaphone 3 rules.

    754. 

  754. 	 *

    755. 

  755. 	 */

    756. 

  756. 	void Encode()

    757. 

  757. 	{

    758. 

  758. 	    flag_AL_inversion = false;

    759. 

  759. 

    760. 

  760. 	    m_current = 0;

    761. 

  761. 

    762. 

  762. 		m_primary.setLength(0);

    763. 

  763. 	    m_secondary.setLength(0);

    764. 

  764. 

    765. 

  765. 	    if(m_length < 1)

    766. 

  766. 		{

    767. 

  767. 	        return;

    768. 

  768. 		}

    769. 

  769. 

    770. 

  770. 	    //zero based index

    771. 

  771. 		m_last = m_length - 1;

    772. 

  772. 

    773. 

  773. 	    ///////////main loop//////////////////////////

    774. 

  774. 		while(!(m_primary.length() > m_metaphLength) && !(m_secondary.length() > m_metaphLength))

    775. 

  775. 	    {

    776. 

  776.  	        if(m_current >= m_length)

    777. 

  777. 			{

    778. 

  778. 	            break;

    779. 

  779. 			}

    780. 

  780. 

    781. 

  781.  	        switch(CharAt(m_current))

    782. 

  782. 	        {	                        

    783. 

  783. 	            case 'B':

    784. 

  784. 

    785. 

  785. 					Encode_B();

    786. 

  786. 	                break;

    787. 

  787. 	                        

    788. 

  788. 	            case 'ß':

    789. 

  789. 				case 'Ç':

    790. 

  790. 

    791. 

  791. 	                MetaphAdd("S");

    792. 

  792. 	                m_current++;

    793. 

  793. 	                break;

    794. 

  794. 

    795. 

  795. 	            case 'C':

    796. 

  796. 

    797. 

  797. 					Encode_C();

    798. 

  798. 	                break;

    799. 

  799. 

    800. 

  800. 	            case 'D':

    801. 

  801. 

    802. 

  802. 					Encode_D();

    803. 

  803. 	                break;

    804. 

  804. 

    805. 

  805. 	            case 'F':

    806. 

  806. 	                    

    807. 

  807. 					Encode_F();

    808. 

  808. 	                break;

    809. 

  809. 

    810. 

  810. 	            case 'G':

    811. 

  811. 

    812. 

  812. 					Encode_G();

    813. 

  813. 	                break;

    814. 

  814. 

    815. 

  815. 	            case 'H':

    816. 

  816. 

    817. 

  817. 					Encode_H();

    818. 

  818. 	                break;

    819. 

  819. 	                

    820. 

  820. 	            case 'J':

    821. 

  821. 

    822. 

  822. 					Encode_J();

    823. 

  823. 	                break;

    824. 

  824. 

    825. 

  825. 	            case 'K':

    826. 

  826. 

    827. 

  827. 					Encode_K();

    828. 

  828. 	                break;

    829. 

  829. 

    830. 

  830. 	            case 'L':

    831. 

  831. 

    832. 

  832. 					Encode_L();

    833. 

  833. 	                break;

    834. 

  834. 

    835. 

  835. 	            case 'M':

    836. 

  836. 

    837. 

  837. 					Encode_M();

    838. 

  838. 	                break;

    839. 

  839. 

    840. 

  840. 	            case 'N':

    841. 

  841. 

    842. 

  842. 					Encode_N();

    843. 

  843. 	                break;

    844. 

  844. 

    845. 

  845. 	            case 'Ń':

    846. 

  846. 	                

    847. 

  847. 	                MetaphAdd("N");

    848. 

  848. 	                m_current++;

    849. 

  849. 	                break;

    850. 

  850. 

    851. 

  851. 	            case 'P':

    852. 

  852. 

    853. 

  853. 					Encode_P();

    854. 

  854. 	                break;

    855. 

  855. 

    856. 

  856. 	            case 'Q':

    857. 

  857. 

    858. 

  858. 					Encode_Q();

    859. 

  859. 	                break;

    860. 

  860. 

    861. 

  861. 	            case 'R':

    862. 

  862. 

    863. 

  863. 					Encode_R();

    864. 

  864. 					break;

    865. 

  865. 

    866. 

  866. 	            case 'S':

    867. 

  867. 

    868. 

  868. 					Encode_S();

    869. 

  869. 	                break;

    870. 

  870. 

    871. 

  871. 	            case 'T':

    872. 

  872. 

    873. 

  873. 					Encode_T();

    874. 

  874. 	                break;

    875. 

  875. 

    876. 

  876. 	            case 'Đ': // eth

    877. 

  877. 				case 'Ţ': // thorn

    878. 

  878. 

    879. 

  879. 	                MetaphAdd("0");

    880. 

  880. 	                m_current++;

    881. 

  881. 	                break;

    882. 

  882. 

    883. 

  883. 	           case 'V':

    884. 

  884. 

    885. 

  885. 					Encode_V();

    886. 

  886. 	                break;

    887. 

  887. 

    888. 

  888. 	            case 'W':

    889. 

  889. 

    890. 

  890. 					Encode_W();

    891. 

  891. 	                break;

    892. 

  892. 

    893. 

  893. 	            case 'X':

    894. 

  894. 

    895. 

  895. 					Encode_X();

    896. 

  896. 	                break;

    897. 

  897. 

    898. 

  898. 	            case '?':

    899. 

  899. 

    900. 

  900. 	                MetaphAdd("X");

    901. 

  901. 	                m_current++;

    902. 

  902. 	                break;

    903. 

  903. 

    904. 

  904. 				case '?':

    905. 

  905. 

    906. 

  906. 	                MetaphAdd("S");

    907. 

  907. 	                m_current++;

    908. 

  908. 	                break;

    909. 

  909. 

    910. 

  910. 	            case 'Z':

    911. 

  911. 					

    912. 

  912. 	                Encode_Z();

    913. 

  913. 	                break;

    914. 

  914. 

    915. 

  915. 	            default:

    916. 

  916. 	            	

    917. 

  917. 					if(IsVowel(CharAt(m_current)))

    918. 

  918. 					{

    919. 

  919. 						Encode_Vowels();

    920. 

  920. 						break;

    921. 

  921. 					}

    922. 

  922. 	            

    923. 

  923. 	                m_current++;

    924. 

  924. 	                

    925. 

  925. 	        }

    926. 

  926. 	    }

    927. 

  927. 

    928. 

  928. 	    //only give back m_metaphLength number of chars in m_metaph

    929. 

  929. 		if(m_primary.length() > m_metaphLength)

    930. 

  930. 	    {

    931. 

  931. 			m_primary.setLength(m_metaphLength);

    932. 

  932. 	    }

    933. 

  933. 

    934. 

  934. 		if(m_secondary.length() > m_metaphLength)

    935. 

  935. 	    {

    936. 

  936. 			m_secondary.setLength(m_metaphLength);

    937. 

  937. 	    }

    938. 

  938. 

    939. 

  939. 		// it is possible for the two metaphs to be the same 

    940. 

  940. 		// after truncation. lose the second one if so

    941. 

  941. 		if((m_primary.toString()).equals(m_secondary.toString()))

    942. 

  942. 		{

    943. 

  943. 			m_secondary.setLength(0);

    944. 

  944. 		}

    945. 

  945. 	}

    946. 

  946. 

    947. 

  947. 	/**

    948. 

  948. 	 * Encodes all initial vowels to A.

    949. 

  949. 	 *

    950. 

  950. 	 * Encodes non-initial vowels to A if m_encodeVowels is true

    951. 

  951. 	 * 

    952. 

  952. 	 * 

    953. 

  953. 	*/

    954. 

  954. 	void Encode_Vowels()

    955. 

  955. 	{

    956. 

  956. 		if(m_current == 0)

    957. 

  957. 		{

    958. 

  958. 			// all init vowels map to 'A' 

    959. 

  959. 			// as of Double Metaphone

    960. 

  960. 			MetaphAdd("A"); 

    961. 

  961. 		}

    962. 

  962. 		else if(m_encodeVowels)

    963. 

  963. 		{

    964. 

  964. 			if(CharAt(m_current) != 'E')

    965. 

  965. 			{

    966. 

  966. 				if(Skip_Silent_UE())

    967. 

  967. 				{

    968. 

  968. 					return;

    969. 

  969. 				}

    970. 

  970. 

    971. 

  971.                 if (O_Silent())

    972. 

  972.                 {

    973. 

  973.                     m_current++;

    974. 

  974.                     return;

    975. 

  975.                 }

    976. 

  976. 

    977. 

  977. 				// encode all vowels and

    978. 

  978. 				// diphthongs to the same value

    979. 

  979. 				MetaphAdd("A"); 

    980. 

  980. 			}

    981. 

  981. 			else

    982. 

  982. 			{

    983. 

  983. 				Encode_E_Pronounced();

    984. 

  984. 			}

    985. 

  985. 		}

    986. 

  986. 

    987. 

  987. 		if(!(!IsVowel(m_current - 2) && StringAt((m_current - 1), 4, "LEWA", "LEWO", "LEWI", "")))

    988. 

  988. 		{

    989. 

  989. 			m_current = SkipVowels(m_current);

    990. 

  990. 		}

    991. 

  991. 		else

    992. 

  992. 		{

    993. 

  993. 			m_current++;

    994. 

  994. 		}

    995. 

  995. 	}

    996. 

  996. 	

    997. 

  997. 	/**

    998. 

  998. 	 * Encodes cases where non-initial 'e' is pronounced, taking

    999. 

  999. 	 * care to detect unusual cases from the greek.

    1000. 

  1000. 	 *

    1001. 

  1001. 	 * Only executed if non initial vowel encoding is turned on

    1002. 

  1002. 	 * 

    1003. 

  1003. 	 * 

    1004. 

  1004. 	 */

    1005. 

  1005. 	void Encode_E_Pronounced()

    1006. 

  1006. 	{

    1007. 

  1007. 		// special cases with two pronunciations

    1008. 

  1008. 		// 'agape' 'lame' 'resume'

    1009. 

  1009. 		if((StringAt(0, 4, "LAME", "SAKE", "PATE", "") && (m_length == 4))

    1010. 

  1010. 			|| (StringAt(0, 5, "AGAPE", "") && (m_length == 5))

    1011. 

  1011. 			|| ((m_current == 5) && StringAt(0, 6, "RESUME", "")))

    1012. 

  1012. 		{

    1013. 

  1013. 			MetaphAdd("", "A");

    1014. 

  1014. 			return;

    1015. 

  1015. 		}

    1016. 

  1016. 		

    1017. 

  1017. 		// special case "inge" => 'INGA', 'INJ'

    1018. 

  1018. 		if(StringAt(0, 4, "INGE", "")

    1019. 

  1019. 			&& (m_length == 4))

    1020. 

  1020. 		{

    1021. 

  1021. 			MetaphAdd("A", "");

    1022. 

  1022. 			return;

    1023. 

  1023. 		}

    1024. 

  1024. 		

    1025. 

  1025. 		// special cases with two pronunciations

    1026. 

  1026. 		// special handling due to the difference in

    1027. 

  1027. 		// the pronunciation of the '-D'

    1028. 

  1028. 		if((m_current == 5) && StringAt(0, 7, "BLESSED", "LEARNED", ""))

    1029. 

  1029. 		{

    1030. 

  1030. 			MetaphAddExactApprox("D", "AD", "T", "AT");

    1031. 

  1031. 			m_current += 2;

    1032. 

  1032. 			return;

    1033. 

  1033. 		}

    1034. 

  1034. 		

    1035. 

  1035. 		// encode all vowels and diphthongs to the same value

    1036. 

  1036. 		if((!E_Silent() 

    1037. 

  1037. 				&& !flag_AL_inversion 

    1038. 

  1038. 				&& !Silent_Internal_E())

    1039. 

  1039. 				|| E_Pronounced_Exceptions())

    1040. 

  1040. 		{

    1041. 

  1041. 			MetaphAdd("A"); 

    1042. 

  1042. 		}

    1043. 

  1043. 		

    1044. 

  1044. 		// now that we've visited the vowel in question

    1045. 

  1045. 		flag_AL_inversion = false;

    1046. 

  1046. 	}

    1047. 

  1047. 

    1048. 

  1048.     /**

    1049. 

  1049.      * Tests for cases where non-initial 'o' is not pronounced

    1050. 

  1050.      * Only executed if non initial vowel encoding is turned on

    1051. 

  1051.      * 

    1052. 

  1052.      * @return true if encoded as silent - no addition to m_metaph key

    1053. 

  1053.      *

    1054. 

  1054.     */

    1055. 

  1055.     boolean O_Silent()

    1056. 

  1056.     {

    1057. 

  1057.         // if "iron" at beginning or end of word and not "irony"

    1058. 

  1058.         if ((CharAt(m_current) == 'O') 

    1059. 

  1059.             && StringAt((m_current - 2), 4, "IRON", ""))

    1060. 

  1060.         {

    1061. 

  1061.             if ((StringAt(0, 4, "IRON", "")

    1062. 

  1062.                 || (StringAt((m_current - 2), 4, "IRON", "")

    1063. 

  1063.                     && (m_last == (m_current + 1))))

    1064. 

  1064.                 && !StringAt((m_current - 2), 6, "IRONIC", ""))

    1065. 

  1065.             {

    1066. 

  1066.                 return true;

    1067. 

  1067.             }

    1068. 

  1068.         }

    1069. 

  1069. 

    1070. 

  1070.         return false;

    1071. 

  1071.     }

    1072. 

  1072.     

    1073. 

  1073. 	/**

    1074. 

  1074. 	 * Tests and encodes cases where non-initial 'e' is never pronounced

    1075. 

  1075. 	 * Only executed if non initial vowel encoding is turned on

    1076. 

  1076. 	 * 

    1077. 

  1077. 	 * @return true if encoded as silent - no addition to m_metaph key

    1078. 

  1078. 	 *

    1079. 

  1079. 	*/

    1080. 

  1080. 	boolean E_Silent()

    1081. 

  1081. 	{	

    1082. 

  1082. 		if(E_Pronounced_At_End())

    1083. 

  1083. 		{

    1084. 

  1084. 			return false;

    1085. 

  1085. 		}

    1086. 

  1086. 

    1087. 

  1087. 		// 'e' silent when last letter, altho

    1088. 

  1088. 		if((m_current == m_last)

    1089. 

  1089. 			// also silent if before plural 's'

    1090. 

  1090. 			// or past tense or participle 'd', e.g.

    1091. 

  1091. 			// 'grapes' and 'banished' => PNXT

    1092. 

  1092. 			|| ((StringAt(m_last, 1, "S", "D", "")

    1093. 

  1093. 				&& (m_current > 1)

    1094. 

  1094. 				&& ((m_current + 1) == m_last)

    1095. 

  1095. 					// and not e.g. "nested", "rises", or "pieces" => RASAS

    1096. 

  1096. 					&& !(StringAt((m_current - 1), 3, "TED", "SES", "CES", "")

    1097. 

  1097. 						|| StringAt(0, 9, "ANTIPODES", "ANOPHELES", "")

    1098. 

  1098. 						|| StringAt(0, 8, "MOHAMMED", "MUHAMMED", "MOUHAMED", "")

    1099. 

  1099. 						|| StringAt(0, 7, "MOHAMED", "")

    1100. 

  1100. 						|| StringAt(0, 6, "NORRED", "MEDVED", "MERCED", "ALLRED", "KHALED", "RASHED", "MASJED", "")	

    1101. 

  1101. 						|| StringAt(0, 5, "JARED", "AHMED", "HAMED", "JAVED", "") 

    1102. 

  1102. 						|| StringAt(0, 4, "ABED", "IMED", ""))))

    1103. 

  1103. 				// e.g.  'wholeness', 'boneless', 'barely'

    1104. 

  1104. 				|| (StringAt((m_current + 1), 4, "NESS", "LESS", "") && ((m_current + 4) == m_last))

    1105. 

  1105. 				|| (StringAt((m_current + 1), 2, "LY", "") && ((m_current + 2) == m_last)

    1106. 

  1106. 						&& !StringAt(0, 6, "CICELY", "")))

    1107. 

  1107. 		{

    1108. 

  1108. 			return true;

    1109. 

  1109. 		}

    1110. 

  1110. 

    1111. 

  1111. 		return false;

    1112. 

  1112. 	}

    1113. 

  1113. 

    1114. 

  1114. 	/**

    1115. 

  1115. 	 * Tests for words where an 'E' at the end of the word

    1116. 

  1116. 	 * is pronounced

    1117. 

  1117. 	 *

    1118. 

  1118. 	 * special cases, mostly from the greek, spanish, japanese, 

    1119. 

  1119. 	 * italian, and french words normally having an acute accent. 

    1120. 

  1120. 	 * also, pronouns and articles

    1121. 

  1121. 	 * 

    1122. 

  1122. 	 * Many Thanks to ali, QuentinCompson, JeffCO, ToonScribe, Xan,

    1123. 

  1123. 	 * Trafalz, and VictorLaszlo, all of them atriots from the Eschaton, 

    1124. 

  1124. 	 * for all their fine contributions!

    1125. 

  1125. 	 * 

    1126. 

  1126. 	 * @return true if 'E' at end is pronounced

    1127. 

  1127. 	 * 

    1128. 

  1128. 	*/

    1129. 

  1129. 	boolean E_Pronounced_At_End()

    1130. 

  1130. 	{

    1131. 

  1131. 		if((m_current == m_last)

    1132. 

  1132. 			&& (StringAt((m_current - 6), 7, "STROPHE", "")

    1133. 

  1133. 			// if a vowel is before the 'E', vowel eater will have eaten it. 

    1134. 

  1134. 			//otherwise, consonant + 'E' will need 'E' pronounced

    1135. 

  1135. 			|| (m_length == 2)

    1136. 

  1136. 			|| ((m_length == 3) && !IsVowel(0))

    1137. 

  1137. 			// these german name endings can be relied on to have the 'e' pronounced

    1138. 

  1138. 			|| (StringAt((m_last - 2), 3, "BKE", "DKE", "FKE", "KKE", "LKE", 

    1139. 

  1139. 										 "NKE", "MKE", "PKE", "TKE", "VKE", "ZKE", "")

    1140. 

  1140. 				&& !StringAt(0, 5, "FINKE", "FUNKE", "")

    1141. 

  1141. 				&& !StringAt(0, 6, "FRANKE", ""))

    1142. 

  1142. 			|| StringAt((m_last - 4), 5, "SCHKE", "")

    1143. 

  1143. 			|| (StringAt(0, 4, "ACME", "NIKE", "CAFE", "RENE", "LUPE", "JOSE", "ESME", "") && (m_length == 4))

    1144. 

  1144. 			|| (StringAt(0, 5, "LETHE", "CADRE", "TILDE", "SIGNE", "POSSE", "LATTE", "ANIME", "DOLCE", "CROCE", 

    1145. 

  1145. 								"ADOBE", "OUTRE", "JESSE", "JAIME", "JAFFE", "BENGE", "RUNGE", 

    1146. 

  1146. 								"CHILE", "DESME", "CONDE", "URIBE", "LIBRE", "ANDRE", "") && (m_length == 5))

    1147. 

  1147. 			|| (StringAt(0, 6, "HECATE", "PSYCHE", "DAPHNE", "PENSKE", "CLICHE", "RECIPE", 

    1148. 

  1148. 							   "TAMALE", "SESAME", "SIMILE", "FINALE", "KARATE", "RENATE", "SHANTE",  

    1149. 

  1149. 							   "OBERLE", "COYOTE", "KRESGE", "STONGE", "STANGE", "SWAYZE", "FUENTE", 

    1150. 

  1150. 							   "SALOME", "URRIBE", "") && (m_length == 6))

    1151. 

  1151. 			|| (StringAt(0, 7, "ECHIDNE", "ARIADNE", "MEINEKE", "PORSCHE", "ANEMONE", "EPITOME", 

    1152. 

  1152. 								"SYNCOPE", "SOUFFLE", "ATTACHE", "MACHETE", "KARAOKE", "BUKKAKE", 

    1153. 

  1153. 								"VICENTE", "ELLERBE", "VERSACE", "") && (m_length == 7))

    1154. 

  1154. 			|| (StringAt(0, 8, "PENELOPE", "CALLIOPE", "CHIPOTLE", "ANTIGONE", "KAMIKAZE", "EURIDICE", 

    1155. 

  1155. 							   "YOSEMITE", "FERRANTE", "") && (m_length == 8))

    1156. 

  1156. 			|| (StringAt(0, 9, "HYPERBOLE", "GUACAMOLE", "XANTHIPPE", "") && (m_length == 9))

    1157. 

  1157. 			|| (StringAt(0, 10, "SYNECDOCHE", "") && (m_length == 10))))

    1158. 

  1158. 		{

    1159. 

  1159. 			return true;

    1160. 

  1160. 		}

    1161. 

  1161. 

    1162. 

  1162. 		return false;

    1163. 

  1163. 	}

    1164. 

  1164. 	

    1165. 

  1165. 	/**

    1166. 

  1166. 	 * Detect internal silent 'E's e.g. "roseman",

    1167. 

  1167. 	 * "firestone"

    1168. 

  1168. 	 * 

    1169. 

  1169. 	 */

    1170. 

  1170. 	boolean Silent_Internal_E()

    1171. 

  1171. 	{

    1172. 

  1172. 		// 'olesen' but not 'olen'	RAKE BLAKE 

    1173. 

  1173. 		if((StringAt(0, 3, "OLE", "") 

    1174. 

  1174. 				&& E_Silent_Suffix(3) && !E_Pronouncing_Suffix(3))

    1175. 

  1175. 		   || (StringAt(0, 4, "BARE", "FIRE", "FORE", "GATE", "HAGE", "HAVE",

    1176. 

  1176. 				             "HAZE", "HOLE", "CAPE", "HUSE", "LACE", "LINE", 

    1177. 

  1177. 				             "LIVE", "LOVE", "MORE", "MOSE", "MORE", "NICE", 

    1178. 

  1178. 				             "RAKE", "ROBE", "ROSE", "SISE", "SIZE", "WARE", 

    1179. 

  1179. 				             "WAKE", "WISE", "WINE", "") 

    1180. 

  1180. 				&& E_Silent_Suffix(4) && !E_Pronouncing_Suffix(4))

    1181. 

  1181. 		   || (StringAt(0, 5, "BLAKE", "BRAKE", "BRINE", "CARLE", "CLEVE", "DUNNE",

    1182. 

  1182. 				   			 "HEDGE", "HOUSE", "JEFFE", "LUNCE", "STOKE", "STONE", 

    1183. 

  1183. 				   			 "THORE", "WEDGE", "WHITE", "") 

    1184. 

  1184. 				 &&  E_Silent_Suffix(5) && !E_Pronouncing_Suffix(5))

    1185. 

  1185. 		   || (StringAt(0, 6, "BRIDGE", "CHEESE", "") 

    1186. 

  1186. 				 && E_Silent_Suffix(6) && !E_Pronouncing_Suffix(6))

    1187. 

  1187. 		   || StringAt((m_current - 5), 7, "CHARLES", ""))

    1188. 

  1188. 		{

    1189. 

  1189. 			return true;

    1190. 

  1190. 		}

    1191. 

  1191. 		

    1192. 

  1192. 		return false;

    1193. 

  1193. 	}

    1194. 

  1194. 

    1195. 

  1195. 	/**

    1196. 

  1196. 	 * Detect conditions required

    1197. 

  1197. 	 * for the 'E' not to be pronounced

    1198. 

  1198. 	 * 

    1199. 

  1199. 	 */

    1200. 

  1200. 	boolean E_Silent_Suffix(int at)

    1201. 

  1201. 	{

    1202. 

  1202. 		if((m_current == (at - 1)) 

    1203. 

  1203. 				&& (m_length > (at + 1)) 

    1204. 

  1204. 				&& (IsVowel((at + 1)) 

    1205. 

  1205. 				|| (StringAt(at, 2, "ST", "SL", "") 

    1206. 

  1206. 					&& (m_length > (at + 2)))))

    1207. 

  1207. 		{

    1208. 

  1208. 			return true;	

    1209. 

  1209. 		}

    1210. 

  1210. 		

    1211. 

  1211. 		return false;

    1212. 

  1212. 	}

    1213. 

  1213. 	

    1214. 

  1214. 	/**

    1215. 

  1215. 	 * Detect endings that will

    1216. 

  1216. 	 * cause the 'e' to be pronounced

    1217. 

  1217. 	 * 

    1218. 

  1218. 	 */

    1219. 

  1219. 	boolean E_Pronouncing_Suffix(int at)

    1220. 

  1220. 	{		

    1221. 

  1221. 		// e.g. 'bridgewood' - the other vowels will get eaten

    1222. 

  1222. 		// up so we need to put one in here

    1223. 

  1223. 		if((m_length == (at + 4)) && StringAt(at, 4, "WOOD", ""))

    1224. 

  1224. 		{

    1225. 

  1225. 			return true;

    1226. 

  1226. 		}

    1227. 

  1227. 		

    1228. 

  1228. 		// same as above

    1229. 

  1229. 		if((m_length == (at + 5)) && StringAt(at, 5, "WATER", "WORTH", ""))

    1230. 

  1230. 		{

    1231. 

  1231. 			return true;

    1232. 

  1232. 		}

    1233. 

  1233. 				

    1234. 

  1234. 		// e.g. 'bridgette'

    1235. 

  1235. 		if((m_length == (at + 3)) && StringAt(at, 3, "TTE", "LIA", "NOW", "ROS", "RAS", ""))

    1236. 

  1236. 		{

    1237. 

  1237. 			return true;

    1238. 

  1238. 		}

    1239. 

  1239. 		

    1240. 

  1240. 		// e.g. 'olena'

    1241. 

  1241. 		if((m_length == (at + 2)) && StringAt(at, 2, "TA", "TT", "NA", "NO", "NE",

    1242. 

  1242. 													 "RS", "RE", "LA", "AU", "RO", "RA", ""))

    1243. 

  1243. 		{

    1244. 

  1244. 			return true;

    1245. 

  1245. 		}

    1246. 

  1246. 		

    1247. 

  1247. 		// e.g. 'bridget'

    1248. 

  1248. 		if((m_length == (at + 1)) && StringAt(at, 1, "T", "R", ""))

    1249. 

  1249. 		{

    1250. 

  1250. 			return true;

    1251. 

  1251. 		}

    1252. 

  1252. 		

    1253. 

  1253. 		return false;

    1254. 

  1254. 	}

    1255. 

  1255. 

    1256. 

  1256. 	/**

    1257. 

  1257. 	 * Exceptions where 'E' is pronounced where it

    1258. 

  1258. 	 * usually wouldn't be, and also some cases

    1259. 

  1259. 	 * where 'LE' transposition rules don't apply

    1260. 

  1260. 	 * and the vowel needs to be encoded here

    1261. 

  1261. 	 *

    1262. 

  1262. 	 * @return true if 'E' pronounced 

    1263. 

  1263. 	 *  

    1264. 

  1264. 	 */

    1265. 

  1265. 	boolean E_Pronounced_Exceptions()

    1266. 

  1266. 	{

    1267. 

  1267. 		// greek names e.g. "herakles" or hispanic names e.g. "robles", where 'e' is pronounced, other exceptions

    1268. 

  1268. 		if((((m_current + 1) == m_last) 

    1269. 

  1269. 				&& (StringAt((m_current - 3), 5, "OCLES", "ACLES", "AKLES", "")

    1270. 

  1270. 					|| StringAt(0, 4, "INES", "")

    1271. 

  1271. 					|| StringAt(0, 5, "LOPES", "ESTES", "GOMES", "NUNES", "ALVES", "ICKES", 

    1272. 

  1272. 							          "INNES", "PERES", "WAGES", "NEVES", "BENES", "DONES", "")

    1273. 

  1273. 					|| StringAt(0, 6, "CORTES", "CHAVES", "VALDES", "ROBLES", "TORRES", "FLORES", "BORGES", 

    1274. 

  1274. 									  "NIEVES", "MONTES", "SOARES", "VALLES", "GEDDES", "ANDRES", "VIAJES", 

    1275. 

  1275. 									  "CALLES", "FONTES", "HERMES", "ACEVES", "BATRES", "MATHES", "")

    1276. 

  1276. 					|| StringAt(0, 7, "DELORES", "MORALES", "DOLORES", "ANGELES", "ROSALES", "MIRELES", "LINARES", 

    1277. 

  1277. 							          "PERALES", "PAREDES", "BRIONES", "SANCHES", "CAZARES", "REVELES", "ESTEVES", 

    1278. 

  1278. 									  "ALVARES", "MATTHES", "SOLARES", "CASARES", "CACERES", "STURGES", "RAMIRES", 

    1279. 

  1279. 									  "FUNCHES", "BENITES", "FUENTES", "PUENTES", "TABARES", "HENTGES", "VALORES", "")

    1280. 

  1280. 					|| StringAt(0, 8, "GONZALES", "MERCEDES", "FAGUNDES", "JOHANNES", "GONSALES", "BERMUDES", 

    1281. 

  1281. 									  "CESPEDES", "BETANCES", "TERRONES", "DIOGENES", "CORRALES", "CABRALES", 

    1282. 

  1282. 									  "MARTINES", "GRAJALES", "")

    1283. 

  1283. 					|| StringAt(0, 9, "CERVANTES", "FERNANDES", "GONCALVES", "BENEVIDES", "CIFUENTES", "SIFUENTES",

    1284. 

  1284. 							  		  "SERVANTES", "HERNANDES", "BENAVIDES", "")

    1285. 

  1285. 					|| StringAt(0, 10, "ARCHIMEDES", "CARRIZALES", "MAGALLANES", "")))

    1286. 

  1286. 			|| StringAt(m_current - 2, 4, "FRED", "DGES", "DRED", "GNES", "")

    1287. 

  1287. 			|| StringAt((m_current - 5), 7, "PROBLEM", "RESPLEN", "")

    1288. 

  1288. 			|| StringAt((m_current - 4), 6, "REPLEN", "")

    1289. 

  1289. 			|| StringAt((m_current - 3), 4, "SPLE", ""))

    1290. 

  1290. 		{

    1291. 

  1291. 			return true;

    1292. 

  1292. 		}

    1293. 

  1293. 		

    1294. 

  1294. 		return false;

    1295. 

  1295. 	}

    1296. 

  1296. 

    1297. 

  1297. 	/**

    1298. 

  1298. 	 * Encodes "-UE".

    1299. 

  1299. 	 * 

    1300. 

  1300. 	 * @return true if encoding handled in this routine, false if not

    1301. 

  1301. 	 */

    1302. 

  1302. 	boolean Skip_Silent_UE()

    1303. 

  1303. 	{

    1304. 

  1304. 		// always silent except for cases listed below

    1305. 

  1305. 		if((StringAt((m_current - 1), 3, "QUE", "GUE", "") 

    1306. 

  1306. 			&& !StringAt(0, 8, "BARBEQUE", "PALENQUE", "APPLIQUE", "")

    1307. 

  1307. 			// '-que' cases usually french but missing the acute accent

    1308. 

  1308. 			&& !StringAt(0, 6, "RISQUE", "")

    1309. 

  1309. 			&& !StringAt((m_current - 3), 5, "ARGUE", "SEGUE", "")

    1310. 

  1310. 			&& !StringAt(0, 7, "PIROGUE", "ENRIQUE", "")

    1311. 

  1311. 			&& !StringAt(0, 10, "COMMUNIQUE", ""))

    1312. 

  1312. 			&& (m_current > 1) 

    1313. 

  1313. 				&& (((m_current + 1) == m_last) 

    1314. 

  1314. 					|| StringAt(0, 7, "JACQUES", "")))

    1315. 

  1315. 		{

    1316. 

  1316. 			m_current = SkipVowels(m_current);

    1317. 

  1317. 			return true;

    1318. 

  1318. 		}

    1319. 

  1319. 

    1320. 

  1320. 		return false;

    1321. 

  1321. 	}

    1322. 

  1322. 

    1323. 

  1323. 	/**

    1324. 

  1324. 	 * Encodes 'B'

    1325. 

  1325. 	 * 

    1326. 

  1326. 	 *

    1327. 

  1327. 	 */

    1328. 

  1328. 	void Encode_B()

    1329. 

  1329. 	{

    1330. 

  1330. 		if(Encode_Silent_B())

    1331. 

  1331. 		{

    1332. 

  1332. 			return;

    1333. 

  1333. 		}

    1334. 

  1334. 

    1335. 

  1335. 		// "-mb", e.g", "dumb", already skipped over under

    1336. 

  1336. 		// 'M', altho it should really be handled here...

    1337. 

  1337. 		MetaphAddExactApprox("B", "P");

    1338. 

  1338. 

    1339. 

  1339. 		if((CharAt(m_current + 1) == 'B')

    1340. 

  1340. 			|| ((CharAt(m_current + 1) == 'P')

    1341. 

  1341. 			&& ((m_current + 1 < m_last) && (CharAt(m_current + 2) != 'H'))))

    1342. 

  1342. 		{

    1343. 

  1343. 			m_current += 2;

    1344. 

  1344. 		}

    1345. 

  1345. 		else

    1346. 

  1346. 		{

    1347. 

  1347. 			m_current++;

    1348. 

  1348. 		}

    1349. 

  1349. 	}

    1350. 

  1350. 

    1351. 

  1351. 	/**

    1352. 

  1352. 	 * Encodes silent 'B' for cases not covered under "-mb-"

    1353. 

  1353. 	 * 

    1354. 

  1354. 	 * 

    1355. 

  1355. 	 * @return true if encoding handled in this routine, false if not

    1356. 

  1356. 	 *

    1357. 

  1357. 	*/

    1358. 

  1358. 	boolean Encode_Silent_B()

    1359. 

  1359. 	{

    1360. 

  1360. 		//'debt', 'doubt', 'subtle'

    1361. 

  1361. 		if(StringAt((m_current - 2), 4, "DEBT", "") 

    1362. 

  1362. 			|| StringAt((m_current - 2), 5, "SUBTL", "") 

    1363. 

  1363. 			|| StringAt((m_current - 2), 6, "SUBTIL", "") 

    1364. 

  1364. 			|| StringAt((m_current - 3), 5, "DOUBT", ""))

    1365. 

  1365. 		{

    1366. 

  1366. 			MetaphAdd("T");

    1367. 

  1367. 			m_current += 2;

    1368. 

  1368. 			return true;

    1369. 

  1369. 		}

    1370. 

  1370. 

    1371. 

  1371. 		return false;

    1372. 

  1372. 	}

    1373. 

  1373. 

    1374. 

  1374. 	/**

    1375. 

  1375. 	 * Encodes 'C'

    1376. 

  1376. 	 * 

    1377. 

  1377. 	 */

    1378. 

  1378. 	void Encode_C()

    1379. 

  1379. 	{

    1380. 

  1380. 

    1381. 

  1381. 		if(Encode_Silent_C_At_Beginning()

    1382. 

  1382. 			|| Encode_CA_To_S()

    1383. 

  1383. 			|| Encode_CO_To_S()

    1384. 

  1384. 			|| Encode_CH()

    1385. 

  1385. 			|| Encode_CCIA()

    1386. 

  1386. 			|| Encode_CC()

    1387. 

  1387. 			|| Encode_CK_CG_CQ()

    1388. 

  1388. 			|| Encode_C_Front_Vowel()

    1389. 

  1389. 			|| Encode_Silent_C()

    1390. 

  1390. 			|| Encode_CZ()

    1391. 

  1391. 			|| Encode_CS())

    1392. 

  1392. 		{

    1393. 

  1393. 			return;

    1394. 

  1394. 		}

    1395. 

  1395. 

    1396. 

  1396. 		//else

    1397. 

  1397. 		if(!StringAt((m_current - 1), 1, "C", "K", "G", "Q", ""))

    1398. 

  1398. 		{

    1399. 

  1399. 			MetaphAdd("K");

    1400. 

  1400. 		}

    1401. 

  1401. 

    1402. 

  1402. 		//name sent in 'mac caffrey', 'mac gregor

    1403. 

  1403. 		if(StringAt((m_current + 1), 2, " C", " Q", " G", ""))

    1404. 

  1404. 		{

    1405. 

  1405. 			m_current += 2;

    1406. 

  1406. 		}

    1407. 

  1407. 		else

    1408. 

  1408. 		{

    1409. 

  1409. 			if(StringAt((m_current + 1), 1, "C", "K", "Q", "") 

    1410. 

  1410. 				&& !StringAt((m_current + 1), 2, "CE", "CI", ""))

    1411. 

  1411. 			{

    1412. 

  1412. 				m_current += 2;

    1413. 

  1413. 				// account for combinations such as Ro-ckc-liffe

    1414. 

  1414. 				if(StringAt((m_current), 1, "C", "K", "Q", "") 

    1415. 

  1415. 					&& !StringAt((m_current + 1), 2, "CE", "CI", ""))

    1416. 

  1416. 				{

    1417. 

  1417. 					m_current++;

    1418. 

  1418. 				}

    1419. 

  1419. 			}

    1420. 

  1420. 			else

    1421. 

  1421. 			{

    1422. 

  1422. 				m_current++;

    1423. 

  1423. 			}

    1424. 

  1424. 		}

    1425. 

  1425. 	}

    1426. 

  1426. 

    1427. 

  1427. 	/**

    1428. 

  1428. 	 * Encodes cases where 'C' is silent at beginning of word

    1429. 

  1429. 	 * 

    1430. 

  1430. 	 * @return true if encoding handled in this routine, false if not

    1431. 

  1431. 	 * 

    1432. 

  1432. 	 */

    1433. 

  1433. 	boolean Encode_Silent_C_At_Beginning()

    1434. 

  1434. 	{

    1435. 

  1435. 	    //skip these when at start of word

    1436. 

  1436. 	    if((m_current == 0)

    1437. 

  1437. 			&& StringAt(m_current, 2, "CT", "CN", ""))

    1438. 

  1438. 		{

    1439. 

  1439. 	        m_current += 1;

    1440. 

  1440. 			return true;

    1441. 

  1441. 		}

    1442. 

  1442. 

    1443. 

  1443. 		return false;

    1444. 

  1444. 	}

    1445. 

  1445. 

    1446. 

  1446. 

    1447. 

  1447. 	/**

    1448. 

  1448. 	 * Encodes exceptions where "-CA-" should encode to S

    1449. 

  1449. 	 * instead of K including cases where the cedilla has not been used

    1450. 

  1450. 	 * 

    1451. 

  1451. 	 * @return true if encoding handled in this routine, false if not

    1452. 

  1452. 	 * 

    1453. 

  1453. 	 */

    1454. 

  1454. 	boolean Encode_CA_To_S()

    1455. 

  1455. 	{

    1456. 

  1456. 		// Special case: 'caesar'. 

    1457. 

  1457. 		// Also, where cedilla not used, as in "linguica" => LNKS

    1458. 

  1458. 		if(((m_current == 0) && StringAt(m_current, 4, "CAES", "CAEC", "CAEM", ""))

    1459. 

  1459. 			|| StringAt(0, 8, "FRANCAIS", "FRANCAIX", "LINGUICA", "")

    1460. 

  1460. 			|| StringAt(0, 6, "FACADE", "")

    1461. 

  1461. 			|| StringAt(0, 9, "GONCALVES", "PROVENCAL", ""))

    1462. 

  1462. 		{

    1463. 

  1463. 			MetaphAdd("S");

    1464. 

  1464. 			AdvanceCounter(2, 1);

    1465. 

  1465. 			return true;

    1466. 

  1466. 		}

    1467. 

  1467. 

    1468. 

  1468. 		return false;

    1469. 

  1469. 	}

    1470. 

  1470. 

    1471. 

  1471. 	/**

    1472. 

  1472. 	 * Encodes exceptions where "-CO-" encodes to S instead of K

    1473. 

  1473. 	 * including cases where the cedilla has not been used

    1474. 

  1474. 	 * 

    1475. 

  1475. 	 * @return true if encoding handled in this routine, false if not

    1476. 

  1476. 	 * 

    1477. 

  1477. 	 */

    1478. 

  1478. 	boolean Encode_CO_To_S()

    1479. 

  1479. 	{

    1480. 

  1480. 		// e.g. 'coelecanth' => SLKN0

    1481. 

  1481. 		if((StringAt(m_current, 4, "COEL", "") 

    1482. 

  1482. 				&& (IsVowel(m_current + 4) || ((m_current + 3) == m_last)))

    1483. 

  1483. 			|| StringAt(m_current, 5, "COENA", "COENO", "")

    1484. 

  1484. 			|| StringAt(0, 8, "FRANCOIS", "MELANCON", "")

    1485. 

  1485. 			|| StringAt(0, 6, "GARCON", ""))

    1486. 

  1486. 		{

    1487. 

  1487. 			MetaphAdd("S");

    1488. 

  1488. 			AdvanceCounter(3, 1);

    1489. 

  1489. 			return true;

    1490. 

  1490. 		}

    1491. 

  1491. 

    1492. 

  1492. 		return false;

    1493. 

  1493. 	}

    1494. 

  1494. 

    1495. 

  1495. 	/**

    1496. 

  1496. 	 * Encode "-CH-"

    1497. 

  1497. 	 * 

    1498. 

  1498. 	 * @return true if encoding handled in this routine, false if not

    1499. 

  1499. 	 * 

    1500. 

  1500. 	 */

    1501. 

  1501. 	boolean Encode_CH()

    1502. 

  1502. 	{

    1503. 

  1503. 		if(StringAt(m_current, 2, "CH", ""))

    1504. 

  1504. 		{       

    1505. 

  1505. 			if(Encode_CHAE()

    1506. 

  1506. 				|| Encode_CH_To_H()

    1507. 

  1507. 				|| Encode_Silent_CH()

    1508. 

  1508. 				|| Encode_ARCH()

    1509. 

  1509. 				// Encode_CH_To_X() should be

    1510. 

  1510. 				// called before the germanic

    1511. 

  1511. 				// and greek encoding functions

    1512. 

  1512. 				|| Encode_CH_To_X()

    1513. 

  1513. 				|| Encode_English_CH_To_K()

    1514. 

  1514. 				|| Encode_Germanic_CH_To_K()

    1515. 

  1515. 				|| Encode_Greek_CH_Initial()

    1516. 

  1516. 				|| Encode_Greek_CH_Non_Initial())

    1517. 

  1517. 			{

    1518. 

  1518. 				return true;

    1519. 

  1519. 			}

    1520. 

  1520. 

    1521. 

  1521. 			if(m_current > 0)

    1522. 

  1522. 			{

    1523. 

  1523. 				if(StringAt(0, 2, "MC", "") 

    1524. 

  1524. 						&& (m_current == 1))

    1525. 

  1525. 				{

    1526. 

  1526. 					//e.g., "McHugh"

    1527. 

  1527. 					MetaphAdd("K");

    1528. 

  1528. 				}

    1529. 

  1529. 				else

    1530. 

  1530. 				{

    1531. 

  1531. 					MetaphAdd("X", "K");

    1532. 

  1532. 				}

    1533. 

  1533. 			}

    1534. 

  1534. 			else

    1535. 

  1535. 			{

    1536. 

  1536. 				MetaphAdd("X");

    1537. 

  1537. 			}

    1538. 

  1538. 			m_current += 2;

    1539. 

  1539. 			return true;

    1540. 

  1540. 		}

    1541. 

  1541. 

    1542. 

  1542. 		return false;

    1543. 

  1543. 	}

    1544. 

  1544. 

    1545. 

  1545. 	/**

    1546. 

  1546. 	 * Encodes "-CHAE-"

    1547. 

  1547. 	 * 

    1548. 

  1548. 	 * @return true if encoding handled in this routine, false if not

    1549. 

  1549. 	 * 

    1550. 

  1550. 	 */

    1551. 

  1551. 	boolean Encode_CHAE()

    1552. 

  1552. 	{

    1553. 

  1553. 		// e.g. 'michael'

    1554. 

  1554. 		if(((m_current > 0) && StringAt((m_current + 2), 2, "AE", "")))

    1555. 

  1555. 		{

    1556. 

  1556. 			if(StringAt(0, 7, "RACHAEL", ""))

    1557. 

  1557. 			{

    1558. 

  1558. 				MetaphAdd("X");

    1559. 

  1559. 			}

    1560. 

  1560. 			else if(!StringAt((m_current - 1), 1, "C", "K", "G", "Q", ""))

    1561. 

  1561. 			{

    1562. 

  1562. 				MetaphAdd("K");

    1563. 

  1563. 			}

    1564. 

  1564. 

    1565. 

  1565. 			AdvanceCounter(4, 2);

    1566. 

  1566. 			return true;

    1567. 

  1567. 		}

    1568. 

  1568. 

    1569. 

  1569. 		return false;

    1570. 

  1570. 	}

    1571. 

  1571. 

    1572. 

  1572. 	/**

    1573. 

  1573. 	 * Encdoes transliterations from the hebrew where the

    1574. 

  1574. 	 * sound 'kh' is represented as "-CH-". The normal pronounciation

    1575. 

  1575. 	 * of this in english is either 'h' or 'kh', and alternate

    1576. 

  1576. 	 * spellings most often use "-H-"

    1577. 

  1577. 	 *

    1578. 

  1578. 	 * @return true if encoding handled in this routine, false if not

    1579. 

  1579. 	 * 

    1580. 

  1580. 	 */

    1581. 

  1581. 	boolean Encode_CH_To_H()

    1582. 

  1582. 	{

    1583. 

  1583. 		// hebrew => 'H', e.g. 'channukah', 'chabad'

    1584. 

  1584. 		if(((m_current == 0) 

    1585. 

  1585. 			&& (StringAt((m_current + 2), 3, "AIM", "ETH", "ELM", "")

    1586. 

  1586. 			|| StringAt((m_current + 2), 4, "ASID", "AZAN", "")

    1587. 

  1587. 			|| StringAt((m_current + 2), 5, "UPPAH", "UTZPA", "ALLAH", "ALUTZ", "AMETZ", "")

    1588. 

  1588. 			|| StringAt((m_current + 2), 6, "ESHVAN", "ADARIM", "ANUKAH", "")

    1589. 

  1589. 			|| StringAt((m_current + 2), 7, "ALLLOTH", "ANNUKAH", "AROSETH", "")))

    1590. 

  1590. 			// and an irish name with the same encoding

    1591. 

  1591. 			|| StringAt((m_current - 3), 7, "CLACHAN", ""))

    1592. 

  1592. 		{

    1593. 

  1593. 			MetaphAdd("H");

    1594. 

  1594. 			AdvanceCounter(3, 2);

    1595. 

  1595. 			return true;

    1596. 

  1596. 		}

    1597. 

  1597. 

    1598. 

  1598. 		return false;

    1599. 

  1599. 	}

    1600. 

  1600. 

    1601. 

  1601. 	/**

    1602. 

  1602. 	 * Encodes cases where "-CH-" is not pronounced

    1603. 

  1603. 	 * 

    1604. 

  1604. 	 * @return true if encoding handled in this routine, false if not

    1605. 

  1605. 	 * 

    1606. 

  1606. 	 */

    1607. 

  1607. 	boolean Encode_Silent_CH()

    1608. 

  1608. 	{

    1609. 

  1609. 		// '-ch-' not pronounced

    1610. 

  1610. 		if(StringAt((m_current - 2), 7, "FUCHSIA", "")

    1611. 

  1611. 			|| StringAt((m_current - 2), 5, "YACHT", "")

    1612. 

  1612. 			|| StringAt(0, 8, "STRACHAN", "")

    1613. 

  1613. 			|| StringAt(0, 8, "CRICHTON", "")

    1614. 

  1614. 			|| (StringAt((m_current - 3), 6, "DRACHM", ""))

    1615. 

  1615. 				&& !StringAt((m_current - 3), 7, "DRACHMA", ""))

    1616. 

  1616. 		{

    1617. 

  1617. 			m_current += 2;

    1618. 

  1618. 			return true;

    1619. 

  1619. 		}

    1620. 

  1620. 

    1621. 

  1621. 		return false;

    1622. 

  1622. 	}

    1623. 

  1623. 

    1624. 

  1624. 	/**

    1625. 

  1625. 	 * Encodes "-CH-" to X

    1626. 

  1626. 	 * English language patterns

    1627. 

  1627. 	 * 

    1628. 

  1628. 	 * @return true if encoding handled in this routine, false if not

    1629. 

  1629. 	 * 

    1630. 

  1630. 	 */

    1631. 

  1631. 	boolean Encode_CH_To_X()

    1632. 

  1632. 	{

    1633. 

  1633. 		// e.g. 'approach', 'beach'

    1634. 

  1634. 		if((StringAt((m_current - 2), 4, "OACH", "EACH", "EECH", "OUCH", "OOCH", "MUCH", "SUCH", "")

    1635. 

  1635. 				&& !StringAt((m_current - 3), 5, "JOACH", ""))

    1636. 

  1636. 			// e.g. 'dacha', 'macho'

    1637. 

  1637. 			|| (((m_current + 2) == m_last ) && StringAt((m_current - 1), 4, "ACHA", "ACHO", ""))

    1638. 

  1638. 			|| (StringAt(m_current, 4, "CHOT", "CHOD", "CHAT", "") && ((m_current + 3) == m_last))

    1639. 

  1639. 			|| ((StringAt((m_current - 1), 4, "OCHE", "") && ((m_current + 2) == m_last))

    1640. 

  1640. 					&& !StringAt((m_current - 2), 5, "DOCHE", ""))		

    1641. 

  1641. 			|| StringAt((m_current - 4), 6, "ATTACH", "DETACH", "KOVACH", "")

    1642. 

  1642. 			|| StringAt((m_current - 5), 7, "SPINACH", "")

    1643. 

  1643. 			|| StringAt(0, 6, "MACHAU", "")

    1644. 

  1644. 			|| StringAt((m_current - 4), 8, "PARACHUT", "")

    1645. 

  1645. 			|| StringAt((m_current - 5), 8, "MASSACHU", "")

    1646. 

  1646. 			|| (StringAt((m_current - 3), 5, "THACH", "") && !StringAt((m_current - 1), 4, "ACHE", ""))

    1647. 

  1647. 			|| StringAt((m_current - 2), 6, "VACHON", "") )

    1648. 

  1648. 		{

    1649. 

  1649. 			MetaphAdd("X");

    1650. 

  1650. 			m_current += 2;

    1651. 

  1651. 			return true;

    1652. 

  1652. 		}

    1653. 

  1653. 

    1654. 

  1654. 		return false;

    1655. 

  1655. 	}

    1656. 

  1656. 

    1657. 

  1657. 	/**

    1658. 

  1658. 	 * Encodes "-CH-" to K in contexts of

    1659. 

  1659. 	 * initial "A" or "E" follwed by "CH"

    1660. 

  1660. 	 * 

    1661. 

  1661. 	 * @return true if encoding handled in this routine, false if not

    1662. 

  1662. 	 * 

    1663. 

  1663. 	 */

    1664. 

  1664. 	boolean Encode_English_CH_To_K()

    1665. 

  1665. 	{

    1666. 

  1666. 		//'ache', 'echo', alternate spelling of 'michael'

    1667. 

  1667. 		if(((m_current == 1) && RootOrInflections(m_inWord, "ACHE"))

    1668. 

  1668. 			|| (((m_current > 3) && RootOrInflections(m_inWord.substring(m_current - 1), "ACHE"))

    1669. 

  1669. 				&& (StringAt(0, 3, "EAR", "")

    1670. 

  1670. 					|| StringAt(0, 4, "HEAD", "BACK", "")

    1671. 

  1671. 					|| StringAt(0, 5, "HEART", "BELLY", "TOOTH", "")))

    1672. 

  1672. 			|| StringAt((m_current - 1), 4, "ECHO", "")

    1673. 

  1673. 			|| StringAt((m_current - 2), 7, "MICHEAL", "")

    1674. 

  1674. 			|| StringAt((m_current - 4), 7, "JERICHO", "")

    1675. 

  1675. 			|| StringAt((m_current - 5), 7, "LEPRECH", ""))

    1676. 

  1676. 		{

    1677. 

  1677. 			MetaphAdd("K", "X");

    1678. 

  1678. 			m_current += 2;

    1679. 

  1679. 			return true;

    1680. 

  1680. 		}

    1681. 

  1681. 

    1682. 

  1682. 		return false;

    1683. 

  1683. 	}

    1684. 

  1684. 

    1685. 

  1685. 	/**

    1686. 

  1686. 	 * Encodes "-CH-" to K in mostly germanic context

    1687. 

  1687. 	 * of internal "-ACH-", with exceptions

    1688. 

  1688. 	 * 

    1689. 

  1689. 	 * @return true if encoding handled in this routine, false if not

    1690. 

  1690. 	 * 

    1691. 

  1691. 	 */

    1692. 

  1692. 	boolean Encode_Germanic_CH_To_K()

    1693. 

  1693. 	{

    1694. 

  1694. 		// various germanic

    1695. 

  1695. 		// "<consonant><vowel>CH-"implies a german word where 'ch' => K

    1696. 

  1696. 		if(((m_current > 1)

    1697. 

  1697. 			&& !IsVowel(m_current - 2) 

    1698. 

  1698. 			&& StringAt((m_current - 1), 3, "ACH", "")

    1699. 

  1699. 			&& !StringAt((m_current - 2), 7, "MACHADO", "MACHUCA", "LACHANC", "LACHAPE", "KACHATU", "")

    1700. 

  1700. 			&& !StringAt((m_current - 3), 7, "KHACHAT", "")

    1701. 

  1701. 			&& ((CharAt(m_current + 2) != 'I') 

    1702. 

  1702. 				&& ((CharAt(m_current + 2) != 'E')

    1703. 

  1703. 				|| StringAt((m_current - 2), 6, "BACHER", "MACHER", "MACHEN", "LACHER", "")) )

    1704. 

  1704. 						// e.g. 'brecht', 'fuchs'

    1705. 

  1705. 				|| (StringAt((m_current + 2), 1, "T", "S", "") 

    1706. 

  1706. 						&& !(StringAt(0, 11, "WHICHSOEVER", "") || StringAt(0, 9, "LUNCHTIME", "") ))

    1707. 

  1707. 						// e.g. 'andromache'

    1708. 

  1708. 				|| StringAt(0, 4, "SCHR", "")

    1709. 

  1709. 				|| ((m_current > 2) && StringAt((m_current - 2), 5, "MACHE", ""))

    1710. 

  1710. 				|| ((m_current == 2) && StringAt((m_current - 2), 4, "ZACH", ""))

    1711. 

  1711. 				|| StringAt((m_current - 4), 6, "SCHACH", "")

    1712. 

  1712. 				|| StringAt((m_current - 1), 5, "ACHEN", "")

    1713. 

  1713. 				|| StringAt((m_current - 3), 5, "SPICH", "ZURCH", "BUECH", "")

    1714. 

  1714. 				|| (StringAt((m_current - 3), 5, "KIRCH", "JOACH", "BLECH", "MALCH", "")

    1715. 

  1715. 						// "kirch" and "blech" both get 'X'

    1716. 

  1716. 						&& !(StringAt((m_current - 3), …
    1717.

Large files files are truncated, but you can click here to view the full file