![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to metaphone.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / standard|
Return to metaphone.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / standard |
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 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:
1.1.1.2 ! misho 19: /* $Id$ */
1.1 misho 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 */
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... */
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: */
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: */