xref: /PHP-5.6/ext/standard/metaphone.c (revision 49493a2d)
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 5                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2016 The PHP Group                                |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 3.01 of the PHP license,      |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.php.net/license/3_01.txt                                  |
11    | If you did not receive a copy of the PHP license and are unable to   |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@php.net so we can mail you a copy immediately.               |
14    +----------------------------------------------------------------------+
15    | Author: Thies C. Arntzen <thies@thieso.net>                          |
16    +----------------------------------------------------------------------+
17 */
18 
19 /* $Id$ */
20 
21 /*
22 	Based on CPANs "Text-Metaphone-1.96" by Michael G Schwern <schwern@pobox.com>
23 */
24 
25 #include "php.h"
26 #include "php_metaphone.h"
27 
28 static int metaphone(unsigned char *word, int word_len, long max_phonemes, char **phoned_word, int traditional);
29 
30 /* {{{ proto string metaphone(string text[, int phones])
31    Break english phrases down into their phonemes */
PHP_FUNCTION(metaphone)32 PHP_FUNCTION(metaphone)
33 {
34 	char *str;
35 	char *result = 0;
36 	int str_len;
37 	long phones = 0;
38 
39 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len,
40 							  &phones) == FAILURE) {
41 		return;
42 	}
43 
44 	if (metaphone((unsigned char *)str, str_len, phones, &result, 1) == 0) {
45 		RETVAL_STRING(result, 0);
46 	} else {
47 		if (result) {
48 			efree(result);
49 		}
50 		RETURN_FALSE;
51 	}
52 }
53 /* }}} */
54 
55 /*
56    this is now the original code by Michael G Schwern:
57    i've changed it just a slightly bit (use emalloc,
58    get rid of includes etc)
59 	- thies - 13.09.1999
60 */
61 
62 /*-----------------------------  */
63 /* this used to be "metaphone.h" */
64 /*-----------------------------  */
65 
66 /* Special encodings */
67 #define  SH 	'X'
68 #define  TH		'0'
69 
70 /*-----------------------------  */
71 /* end of "metaphone.h"          */
72 /*-----------------------------  */
73 
74 /*----------------------------- */
75 /* this used to be "metachar.h" */
76 /*----------------------------- */
77 
78 /* Metachar.h ... little bits about characters for metaphone */
79 /*-- Character encoding array & accessing macros --*/
80 /* Stolen directly out of the book... */
81 char _codes[26] =
82 {
83 	1, 16, 4, 16, 9, 2, 4, 16, 9, 2, 0, 2, 2, 2, 1, 4, 0, 2, 4, 4, 1, 0, 0, 0, 8, 0
84 /*  a  b c  d e f g  h i j k l m n o p q r s t u v w x y z */
85 };
86 
87 
88 #define ENCODE(c) (isalpha(c) ? _codes[((toupper(c)) - 'A')] : 0)
89 
90 #define isvowel(c)  (ENCODE(c) & 1)		/* AEIOU */
91 
92 /* These letters are passed through unchanged */
93 #define NOCHANGE(c) (ENCODE(c) & 2)		/* FJMNR */
94 
95 /* These form dipthongs when preceding H */
96 #define AFFECTH(c)  (ENCODE(c) & 4)		/* CGPST */
97 
98 /* These make C and G soft */
99 #define MAKESOFT(c) (ENCODE(c) & 8)		/* EIY */
100 
101 /* These prevent GH from becoming F */
102 #define NOGHTOF(c)  (ENCODE(c) & 16)	/* BDH */
103 
104 /*----------------------------- */
105 /* end of "metachar.h"          */
106 /*----------------------------- */
107 
108 /* I suppose I could have been using a character pointer instead of
109  * accesssing the array directly... */
110 
111 /* Look at the next letter in the word */
112 #define Next_Letter (toupper(word[w_idx+1]))
113 /* Look at the current letter in the word */
114 #define Curr_Letter (toupper(word[w_idx]))
115 /* Go N letters back. */
116 #define Look_Back_Letter(n)	(w_idx >= n ? toupper(word[w_idx-n]) : '\0')
117 /* Previous letter.  I dunno, should this return null on failure? */
118 #define Prev_Letter (Look_Back_Letter(1))
119 /* Look two letters down.  It makes sure you don't walk off the string. */
120 #define After_Next_Letter	(Next_Letter != '\0' ? toupper(word[w_idx+2]) \
121 											     : '\0')
122 #define Look_Ahead_Letter(n) (toupper(Lookahead(word+w_idx, n)))
123 
124 
125 /* Allows us to safely look ahead an arbitrary # of letters */
126 /* I probably could have just used strlen... */
Lookahead(char * word,int how_far)127 static char Lookahead(char *word, int how_far)
128 {
129 	char letter_ahead = '\0';	/* null by default */
130 	int idx;
131 	for (idx = 0; word[idx] != '\0' && idx < how_far; idx++);
132 	/* Edge forward in the string... */
133 
134 	letter_ahead = word[idx];	/* idx will be either == to how_far or
135 								 * at the end of the string
136 								 */
137 	return letter_ahead;
138 }
139 
140 
141 /* phonize one letter
142  * We don't know the buffers size in advance. On way to solve this is to just
143  * re-allocate the buffer size. We're using an extra of 2 characters (this
144  * could be one though; or more too). */
145 #define Phonize(c)	{ \
146 						if (p_idx >= max_buffer_len) { \
147 							*phoned_word = safe_erealloc(*phoned_word, 2, sizeof(char), max_buffer_len); \
148 							max_buffer_len += 2; \
149 						} \
150 						(*phoned_word)[p_idx++] = c; \
151 					}
152 /* Slap a null character on the end of the phoned word */
153 #define End_Phoned_Word	{ \
154 							if (p_idx == max_buffer_len) { \
155 								*phoned_word = safe_erealloc(*phoned_word, 1, sizeof(char), max_buffer_len); \
156 							} \
157 							(*phoned_word)[p_idx] = '\0'; \
158 						}
159 /* How long is the phoned word? */
160 #define Phone_Len	(p_idx)
161 
162 /* Note is a letter is a 'break' in the word */
163 #define Isbreak(c)  (!isalpha(c))
164 
165 /* {{{ metaphone
166  */
metaphone(unsigned char * word,int word_len,long max_phonemes,char ** phoned_word,int traditional)167 static int metaphone(unsigned char *word, int word_len, long max_phonemes, char **phoned_word, int traditional)
168 {
169 	int w_idx = 0;				/* point in the phonization we're at. */
170 	int p_idx = 0;				/* end of the phoned phrase */
171 	int max_buffer_len = 0;		/* maximum length of the destination buffer */
172 
173 /*-- Parameter checks --*/
174 	/* Negative phoneme length is meaningless */
175 
176 	if (max_phonemes < 0)
177 		return -1;
178 
179 	/* Empty/null string is meaningless */
180 	/* Overly paranoid */
181 	/* assert(word != NULL && word[0] != '\0'); */
182 
183 	if (word == NULL)
184 		return -1;
185 
186 /*-- Allocate memory for our phoned_phrase --*/
187 	if (max_phonemes == 0) {	/* Assume largest possible */
188 		max_buffer_len = word_len;
189 		*phoned_word = safe_emalloc(sizeof(char), word_len, 1);
190 	} else {
191 		max_buffer_len = max_phonemes;
192 		*phoned_word = safe_emalloc(sizeof(char), max_phonemes, 1);
193 	}
194 
195 
196 /*-- The first phoneme has to be processed specially. --*/
197 	/* Find our first letter */
198 	for (; !isalpha(Curr_Letter); w_idx++) {
199 		/* On the off chance we were given nothing but crap... */
200 		if (Curr_Letter == '\0') {
201 			End_Phoned_Word
202 				return SUCCESS;	/* For testing */
203 		}
204 	}
205 
206 	switch (Curr_Letter) {
207 		/* AE becomes E */
208 	case 'A':
209 		if (Next_Letter == 'E') {
210 			Phonize('E');
211 			w_idx += 2;
212 		}
213 		/* Remember, preserve vowels at the beginning */
214 		else {
215 			Phonize('A');
216 			w_idx++;
217 		}
218 		break;
219 		/* [GKP]N becomes N */
220 	case 'G':
221 	case 'K':
222 	case 'P':
223 		if (Next_Letter == 'N') {
224 			Phonize('N');
225 			w_idx += 2;
226 		}
227 		break;
228 		/* WH becomes W,
229 		   WR becomes R
230 		   W if followed by a vowel */
231 	case 'W':
232 		if (Next_Letter == 'R') {
233 			Phonize(Next_Letter);
234 			w_idx += 2;
235 		} else if (Next_Letter == 'H' || isvowel(Next_Letter)) {
236 			Phonize('W');
237 			w_idx += 2;
238 		}
239 		/* else ignore */
240 		break;
241 		/* X becomes S */
242 	case 'X':
243 		Phonize('S');
244 		w_idx++;
245 		break;
246 		/* Vowels are kept */
247 		/* We did A already
248 		   case 'A':
249 		   case 'a':
250 		 */
251 	case 'E':
252 	case 'I':
253 	case 'O':
254 	case 'U':
255 		Phonize(Curr_Letter);
256 		w_idx++;
257 		break;
258 	default:
259 		/* do nothing */
260 		break;
261 	}
262 
263 
264 
265 	/* On to the metaphoning */
266 	for (; Curr_Letter != '\0' &&
267 		 (max_phonemes == 0 || Phone_Len < max_phonemes);
268 		 w_idx++) {
269 		/* How many letters to skip because an eariler encoding handled
270 		 * multiple letters */
271 		unsigned short int skip_letter = 0;
272 
273 
274 		/* THOUGHT:  It would be nice if, rather than having things like...
275 		 * well, SCI.  For SCI you encode the S, then have to remember
276 		 * to skip the C.  So the phonome SCI invades both S and C.  It would
277 		 * be better, IMHO, to skip the C from the S part of the encoding.
278 		 * Hell, I'm trying it.
279 		 */
280 
281 		/* Ignore non-alphas */
282 		if (!isalpha(Curr_Letter))
283 			continue;
284 
285 		/* Drop duplicates, except CC */
286 		if (Curr_Letter == Prev_Letter &&
287 			Curr_Letter != 'C')
288 			continue;
289 
290 		switch (Curr_Letter) {
291 			/* B -> B unless in MB */
292 		case 'B':
293 			if (Prev_Letter != 'M')
294 				Phonize('B');
295 			break;
296 			/* 'sh' if -CIA- or -CH, but not SCH, except SCHW.
297 			 * (SCHW is handled in S)
298 			 *  S if -CI-, -CE- or -CY-
299 			 *  dropped if -SCI-, SCE-, -SCY- (handed in S)
300 			 *  else K
301 			 */
302 		case 'C':
303 			if (MAKESOFT(Next_Letter)) {	/* C[IEY] */
304 				if (After_Next_Letter == 'A' &&
305 					Next_Letter == 'I') {	/* CIA */
306 					Phonize(SH);
307 				}
308 				/* SC[IEY] */
309 				else if (Prev_Letter == 'S') {
310 					/* Dropped */
311 				} else {
312 					Phonize('S');
313 				}
314 			} else if (Next_Letter == 'H') {
315 				if ((!traditional) && (After_Next_Letter == 'R' || Prev_Letter == 'S')) {	/* Christ, School */
316 					Phonize('K');
317 				} else {
318 					Phonize(SH);
319 				}
320 				skip_letter++;
321 			} else {
322 				Phonize('K');
323 			}
324 			break;
325 			/* J if in -DGE-, -DGI- or -DGY-
326 			 * else T
327 			 */
328 		case 'D':
329 			if (Next_Letter == 'G' &&
330 				MAKESOFT(After_Next_Letter)) {
331 				Phonize('J');
332 				skip_letter++;
333 			} else
334 				Phonize('T');
335 			break;
336 			/* F if in -GH and not B--GH, D--GH, -H--GH, -H---GH
337 			 * else dropped if -GNED, -GN,
338 			 * else dropped if -DGE-, -DGI- or -DGY- (handled in D)
339 			 * else J if in -GE-, -GI, -GY and not GG
340 			 * else K
341 			 */
342 		case 'G':
343 			if (Next_Letter == 'H') {
344 				if (!(NOGHTOF(Look_Back_Letter(3)) ||
345 					  Look_Back_Letter(4) == 'H')) {
346 					Phonize('F');
347 					skip_letter++;
348 				} else {
349 					/* silent */
350 				}
351 			} else if (Next_Letter == 'N') {
352 				if (Isbreak(After_Next_Letter) ||
353 					(After_Next_Letter == 'E' &&
354 					 Look_Ahead_Letter(3) == 'D')) {
355 					/* dropped */
356 				} else
357 					Phonize('K');
358 			} else if (MAKESOFT(Next_Letter) &&
359 					   Prev_Letter != 'G') {
360 				Phonize('J');
361 			} else {
362 				Phonize('K');
363 			}
364 			break;
365 			/* H if before a vowel and not after C,G,P,S,T */
366 		case 'H':
367 			if (isvowel(Next_Letter) &&
368 				!AFFECTH(Prev_Letter))
369 				Phonize('H');
370 			break;
371 			/* dropped if after C
372 			 * else K
373 			 */
374 		case 'K':
375 			if (Prev_Letter != 'C')
376 				Phonize('K');
377 			break;
378 			/* F if before H
379 			 * else P
380 			 */
381 		case 'P':
382 			if (Next_Letter == 'H') {
383 				Phonize('F');
384 			} else {
385 				Phonize('P');
386 			}
387 			break;
388 			/* K
389 			 */
390 		case 'Q':
391 			Phonize('K');
392 			break;
393 			/* 'sh' in -SH-, -SIO- or -SIA- or -SCHW-
394 			 * else S
395 			 */
396 		case 'S':
397 			if (Next_Letter == 'I' &&
398 				(After_Next_Letter == 'O' ||
399 				 After_Next_Letter == 'A')) {
400 				Phonize(SH);
401 			} else if (Next_Letter == 'H') {
402 				Phonize(SH);
403 				skip_letter++;
404 			} else if ((!traditional) && (Next_Letter == 'C' && Look_Ahead_Letter(2) == 'H' && Look_Ahead_Letter(3) == 'W')) {
405 				Phonize(SH);
406 				skip_letter += 2;
407 			} else {
408 				Phonize('S');
409 			}
410 			break;
411 			/* 'sh' in -TIA- or -TIO-
412 			 * else 'th' before H
413 			 * else T
414 			 */
415 		case 'T':
416 			if (Next_Letter == 'I' &&
417 				(After_Next_Letter == 'O' ||
418 				 After_Next_Letter == 'A')) {
419 				Phonize(SH);
420 			} else if (Next_Letter == 'H') {
421 				Phonize(TH);
422 				skip_letter++;
423 			} else if (!(Next_Letter == 'C' && After_Next_Letter == 'H')) {
424 				Phonize('T');
425 			}
426 			break;
427 			/* F */
428 		case 'V':
429 			Phonize('F');
430 			break;
431 			/* W before a vowel, else dropped */
432 		case 'W':
433 			if (isvowel(Next_Letter))
434 				Phonize('W');
435 			break;
436 			/* KS */
437 		case 'X':
438 			Phonize('K');
439 			Phonize('S');
440 			break;
441 			/* Y if followed by a vowel */
442 		case 'Y':
443 			if (isvowel(Next_Letter))
444 				Phonize('Y');
445 			break;
446 			/* S */
447 		case 'Z':
448 			Phonize('S');
449 			break;
450 			/* No transformation */
451 		case 'F':
452 		case 'J':
453 		case 'L':
454 		case 'M':
455 		case 'N':
456 		case 'R':
457 			Phonize(Curr_Letter);
458 			break;
459 		default:
460 			/* nothing */
461 			break;
462 		}						/* END SWITCH */
463 
464 		w_idx += skip_letter;
465 	}							/* END FOR */
466 
467 	End_Phoned_Word;
468 
469 	return 0;
470 }								/* END metaphone */
471 /* }}} */
472 
473 /*
474  * Local variables:
475  * tab-width: 4
476  * c-basic-offset: 4
477  * End:
478  * vim600: sw=4 ts=4 fdm=marker
479  * vim<600: sw=4 ts=4
480  */
481