1 |
/* Metaphone Conversion Notes |
2 |
|
3 |
When I found this Algorithm, in article, there were discrepancies between |
4 |
the BASIC code and the verbal description. The discrepances look like they |
5 |
could have been caused by typing errors in the article. |
6 |
|
7 |
I have included the BASIC code from this article for the specific purpose |
8 |
of presenting the Algorithm the way it was originally described. |
9 |
I have tried to reproduce the BASIC EXACTLY the way it appeared. So when |
10 |
you see "ENAM" with nothing behind it, that is how it was presented. |
11 |
|
12 |
Lawrence Philips has no doubt spent a lot of time in the development of |
13 |
this algorithm. I am trusting that the algorithm described has been |
14 |
throughly tested to the best of his ability. |
15 |
|
16 |
It was my intention to reproduce it using his rules as best as I could |
17 |
discern them. |
18 |
|
19 |
It looks like it works better than Soundex. Thank You Lawrence. |
20 |
|
21 |
To anyone passing this along. Please include all of the notes they |
22 |
are part of the documentation and credits. Thanks |
23 |
|
24 |
Mike Kuhn (mkuhn@rhlab.com) |
25 |
|
26 |
Michael J. Kuhn Computer Systems Consultant |
27 |
5916 Glenoak Ave. |
28 |
Baltimore, MD 21214-2009 |
29 |
410-254-7060 |
30 |
|
31 |
P.S. |
32 |
A version of this routine in the Informix Archive was done by: |
33 |
|
34 |
Sadru Fidai Munics Information Systems |
35 |
50 Mount Prospect Ave |
36 |
Clifton NJ 07013 (201)778-7753 |
37 |
aol.com!SFidai |
38 |
|
39 |
Sadru called me to discuss this and said the following: |
40 |
|
41 |
His routine was NOT done from the article published in "Computer Language". |
42 |
He started with a working version from a PICK system that was using this. |
43 |
He had 2,000+ names with metaphone from the PICK system that he used |
44 |
to test the C code with. |
45 |
|
46 |
You might want to check this routine out. |
47 |
|
48 |
I did not use his routine at the time because there was no verbal |
49 |
explanation of the transformations. Also my intent was to be able |
50 |
to easily modify the transformation rules with some of my own. |
51 |
|
52 |
I did a mod 100 of my 20,726 test names and got 221 scattered names. |
53 |
I then computed Metaphone for Sadru version and mine. There were 14 |
54 |
differences. Excluding the trailing S's in his, which I eliminated. |
55 |
I also changed his code so that O was a ZERO. The differences account |
56 |
for changes I MADE and interpretation of transformation rules. |
57 |
|
58 |
At this point I have no need to do a more comprehensive analysis. |
59 |
|
60 |
lastname Mike Kuhn Sadru Fidai |
61 |
|
62 |
ANASTHA ANS0 ANSX |
63 |
DAVIS-CARTER TFSKRTR TFXKRTR |
64 |
ESCARMANT ESKRMNT EXKRMNT |
65 |
MCCALL MCL MKKL |
66 |
MCCROREY MCRR MKKRR |
67 |
MERSEAL MRSL MRXL |
68 |
PIEURISSAINT PRSNT PRXNT |
69 |
ROTMAN RTMN RXMN |
70 |
SCHEVEL SXFL SKFL |
71 |
SCHROM SXRM SKRM |
72 |
SEAL SL XL |
73 |
SPARR SPR XPR |
74 |
STARLEPER STRLPR XTRLPR |
75 |
THRASH TRX 0RX |
76 |
*/ |
77 |
|
78 |
|
79 |
/*************************************************************** |
80 |
|
81 |
Metaphone Algorithm |
82 |
|
83 |
Created by Lawrence Philips (location unknown). Metaphone presented |
84 |
in article in "Computer Language" December 1990 issue. |
85 |
|
86 |
Converted from Pick BASIC, as demonstrated in article, to C by |
87 |
Michael J. Kuhn (Baltimore, Maryland) |
88 |
|
89 |
My original intention was to replace SOUNDEX with METAPHONE in |
90 |
order to get lists of similar sounding names that were more precise. |
91 |
SOUNDEX maps "William" and "Williams" to the same values. METAPHONE |
92 |
as it turns out DOES THE SAME. There are going to be problems |
93 |
that you need to resolve with your own set of data. |
94 |
|
95 |
Basically, for my problem with S's I think that if |
96 |
|
97 |
IF metaphone[strlen(metaphone)] == "S" |
98 |
AND strlen(metaphone) >= 4 THEN |
99 |
|
100 |
metaphone[strlen(metaphone)] = "" |
101 |
|
102 |
You can add you own rules as required. |
103 |
|
104 |
Also, Lawrence Philips suggests that for practical reasons only the |
105 |
first 4 characters of the metaphone be used. This happens to be the |
106 |
number of characters that Soundex produces. This is indeed practical |
107 |
if you already have reserved exactly 4 characters in your database. |
108 |
|
109 |
In addition an analysis of your data may show that names are split |
110 |
into undesirable "metaphone groups" as the number of metaphone characters |
111 |
increases. |
112 |
|
113 |
*********** BEGIN METAPHONE RULES *********** |
114 |
|
115 |
Lawrence Philips' RULES follow: |
116 |
|
117 |
The 16 consonant sounds: |
118 |
|--- ZERO represents "th" |
119 |
| |
120 |
B X S K J T F H L M N P R 0 W Y |
121 |
|
122 |
Exceptions: |
123 |
|
124 |
Beginning of word: "ae-", "gn", "kn-", "pn-", "wr-" ----> drop first letter |
125 |
"Aebersold", "Gnagy", "Knuth", "Pniewski", "Wright" |
126 |
|
127 |
Beginning of word: "x" ----> change to "s" |
128 |
as in "Deng Xiaopeng" |
129 |
|
130 |
Beginning of word: "wh-" ----> change to "w" |
131 |
as in "Whalen" |
132 |
|
133 |
Transformations: |
134 |
|
135 |
B ----> B unless at the end of word after "m", as in "dumb", "McComb" |
136 |
|
137 |
C ----> X (sh) if "-cia-" or "-ch-" |
138 |
S if "-ci-", "-ce-", or "-cy-" |
139 |
SILENT if "-sci-", "-sce-", or "-scy-" |
140 |
K otherwise, including in "-sch-" |
141 |
|
142 |
D ----> J if in "-dge-", "-dgy-", or "-dgi-" |
143 |
T otherwise |
144 |
|
145 |
F ----> F |
146 |
|
147 |
G ----> SILENT if in "-gh-" and not at end or before a vowel |
148 |
in "-gn" or "-gned" |
149 |
in "-dge-" etc., as in above rule |
150 |
J if before "i", or "e", or "y" if not double "gg" |
151 |
K otherwise |
152 |
|
153 |
H ----> SILENT if after vowel and no vowel follows |
154 |
or after "-ch-", "-sh-", "-ph-", "-th-", "-gh-" |
155 |
H otherwise |
156 |
|
157 |
J ----> J |
158 |
|
159 |
K ----> SILENT if after "c" |
160 |
K otherwise |
161 |
|
162 |
L ----> L |
163 |
|
164 |
M ----> M |
165 |
|
166 |
N ----> N |
167 |
|
168 |
P ----> F if before "h" |
169 |
P otherwise |
170 |
|
171 |
Q ----> K |
172 |
|
173 |
R ----> R |
174 |
|
175 |
S ----> X (sh) if before "h" or in "-sio-" or "-sia-" |
176 |
S otherwise |
177 |
|
178 |
T ----> X (sh) if "-tia-" or "-tio-" |
179 |
0 (th) if before "h" |
180 |
silent if in "-tch-" |
181 |
T otherwise |
182 |
|
183 |
V ----> F |
184 |
|
185 |
W ----> SILENT if not followed by a vowel |
186 |
W if followed by a vowel |
187 |
|
188 |
X ----> KS |
189 |
|
190 |
Y ----> SILENT if not followed by a vowel |
191 |
Y if followed by a vowel |
192 |
|
193 |
Z ----> S |
194 |
|
195 |
**************************************************************/ |
196 |
|
197 |
/* |
198 |
|
199 |
NOTE: This list turned out to be various issues that I passed over |
200 |
while trying to discern this algorithm. The final outcome |
201 |
of these items may or may not be reflected in the code. |
202 |
|
203 |
There where some discrepancies between the Pick BASIC code in the |
204 |
original article and the verbal discription of the transformations: |
205 |
|
206 |
1. CASE SYMB = "G" |
207 |
|
208 |
AND ENAME[N +3] = "D" AND (N + 3) = L)) and ENAM |
209 |
^ |
210 |
this was cut off in the magazine listing | |
211 |
|
212 |
I used the verbal discription in the transformation list |
213 |
to add the appropriate code. |
214 |
|
215 |
2. H ----> SILENT if after vowel and no vowel follows |
216 |
H otherwise |
217 |
|
218 |
This is the transformation description, however, the BASIC |
219 |
routine HAS code do this: |
220 |
|
221 |
SILENT if after "ch-", "sh-", "ph-", "th", "gh" |
222 |
|
223 |
which is the correct behaviour if you look at c,s,p,t,g |
224 |
|
225 |
If did not, however, have "after vowel" coded even though this |
226 |
was in the description. I added it. |
227 |
|
228 |
3. The BASIC code appears to skip double letters except "C" yet |
229 |
the transformation code for "G" looks at previous letter to |
230 |
see if we have "GG". This is inconsistent. |
231 |
|
232 |
I am making the assumption that "C" was a typo in the BASIC |
233 |
code. It should have been "G". |
234 |
|
235 |
4. Transformation notation. "-..-" where .. are letters; means that |
236 |
the letters indicated are bounded by other letters. So "-gned" |
237 |
means at the end and "ch-" means at the beginning. I have noticed |
238 |
that the later is not explicity stated in the verbal description |
239 |
but it is coded in the BASIC. |
240 |
|
241 |
5. case 'C' K otherwise, including in "-sch-" |
242 |
this implies that "sch" be bounded by other letters. The BASIC |
243 |
code, however, has: N > 1 |
244 |
It should have N > 2 for this to be correct. |
245 |
SCH- |
246 |
123 greater than 1 means that C can be 2nd letter |
247 |
|
248 |
I coded it as per the verbal description and not what was in |
249 |
the code. |
250 |
|
251 |
6. as of 11-20-95 I am still trying to understand "H". The BASIC |
252 |
code seems to indicate that if "-.h" is at the end it is not |
253 |
silent. But if it is at the end there is no way a vowel could |
254 |
follow the "h". I am looking for examples. |
255 |
|
256 |
7. ok now I am really confused. Case "T". There is code in BASIC |
257 |
that says if next = "H" and previous != "T" . There is no |
258 |
way that a double T goes through the code. Double letters |
259 |
are dumped in the beginning. |
260 |
|
261 |
MATTHEW, MATTHIES, etc |
262 |
|
263 |
The first T goes through the second is skipped so the |
264 |
"th" is never detected. |
265 |
|
266 |
Modified routine to allow "G,T" duplicates through the switch. |
267 |
|
268 |
8. case "D" -dge- is indicated in transformation |
269 |
-dge- or -dge is coded. |
270 |
|
271 |
STEMBRIDGE should have "j" on end and not "t" |
272 |
|
273 |
I am leaving the code as is, verbal must be wrong. |
274 |
|
275 |
9. Regarding duplicate letters. "C" must be allowed through |
276 |
as in all of the McC... names. |
277 |
|
278 |
The way to handle "GG and "TT" I think is to pass over the |
279 |
first duplicate. The transformation rules would then handle |
280 |
duplicates of themselves by looking at the PREVIOUS letter. |
281 |
|
282 |
This solves the problems of "TTH" where you want the "th" |
283 |
sound. |
284 |
|
285 |
10. Change "CC" so that the metaphone character is "C", they |
286 |
way it is now for McComb and such you get "MKK", which |
287 |
unnecessiarly eats up and extra metaphone character. |
288 |
|
289 |
11. "TH" at the beginning as in Thomas. The verbal was not |
290 |
clear about this. I think is should be "T" and not "0" |
291 |
so I am changing code. |
292 |
|
293 |
After the first test I think that "THvowel" should be |
294 |
"0" and "TH(!vowel)" should be "T" |
295 |
|
296 |
12. I think throwing away 1 "S" and the end would be good. |
297 |
Since I am doing this anyway after the fact. If I |
298 |
do it before then names like. .. |
299 |
BURROUGHS & BURROUGH would be the same |
300 |
because the GH would map to the same value in |
301 |
both cases. |
302 |
|
303 |
13. Case "Y", Brian and Bryan give different codes |
304 |
Don't know how to handle this yet. |
305 |
|
306 |
14. Comments on metaphone groups. Metaphone actually |
307 |
makes groups bigger. Names like: |
308 |
|
309 |
C...R... G...R... K...R... Q...R... |
310 |
|
311 |
will map to "KR". Soundex would have produced for example |
312 |
|
313 |
C600,C620,G600,G620,K600,K620,Q600,Q620 |
314 |
|
315 |
the names from these 8 groups would have been collapsed into 1. |
316 |
|
317 |
Another way to look at this is for a more exact initial |
318 |
guess of a name Soundex would give you a smaller list of |
319 |
posibilities. If you don't know how to spell it at all |
320 |
however, your success at finding the right match with |
321 |
Metaphone is much greater than with Soundex. |
322 |
|
323 |
15. After some tests decided to leave S's at the end of the |
324 |
Metaphone. #12 takes care of my problems with plurals and |
325 |
then S gets used to help make distinct metaphone. |
326 |
|
327 |
Lawrence Philips is no longer at the company indicated in the |
328 |
article. So I was unable to verify these items. |
329 |
*/ |
330 |
|
331 |
|
332 |
#ifdef __cplusplus |
333 |
extern "C" { |
334 |
#endif |
335 |
#include "EXTERN.h" |
336 |
#include "perl.h" |
337 |
#include "XSUB.h" |
338 |
#ifdef __cplusplus |
339 |
} |
340 |
#endif |
341 |
#include "WAIT.h" |
342 |
#define TRUE (1) |
343 |
#define FALSE (0) |
344 |
#define NULLCHAR (char *) 0 |
345 |
|
346 |
char *FRONTV = "EIY"; /* special cases for |
347 |
letters in FRONT of |
348 |
these */ |
349 |
char *VARSON = "CSPTG"; /* variable sound--those |
350 |
modified by adding an "h" */ |
351 |
char *DOUBLE = "."; /* let these double |
352 |
letters through */ |
353 |
char *excpPAIR = "AGKPW"; /* exceptions "ae-", |
354 |
"gn-", "kn-", "pn-", |
355 |
"wr-" */ |
356 |
char *nextLTR = "ENNNR"; |
357 |
char *chrptr, *chrptr1; |
358 |
|
359 |
void |
360 |
phonetic(name, metaph, metalen) |
361 |
char *name, *metaph; |
362 |
int metalen; |
363 |
{ |
364 |
|
365 |
int ii, jj, silent, hard, Lng, lastChr; |
366 |
char curLtr, prevLtr, nextLtr, nextLtr2, nextLtr3; |
367 |
int vowelAfter, vowelBefore, frontvAfter; |
368 |
char wname[60]; |
369 |
char *ename = wname; |
370 |
|
371 |
jj = 0; |
372 |
for (ii = 0; name[ii] != '\0'; ii++) { |
373 |
ename[jj] = ToUpper(name[ii]); |
374 |
jj++; |
375 |
} |
376 |
ename[jj] = '\0'; |
377 |
|
378 |
if (!*ename) return; |
379 |
|
380 |
/* if ae, gn, kn, pn, wr then drop the first letter */ |
381 |
if ((chrptr = strchr(excpPAIR, ename[0])) != NULLCHAR) { |
382 |
chrptr1 = nextLTR + (chrptr - excpPAIR); |
383 |
if (*chrptr1 == ename[1]) |
384 |
strcpy(ename, &ename[1]); |
385 |
} |
386 |
/* change x to s */ |
387 |
if (ename[0] == 'X') |
388 |
ename[0] = 'S'; |
389 |
/* get rid of the "h" in "wh" */ |
390 |
if ((ename[0] == 'W') && (ename[1] == 'H')) |
391 |
strcpy(&ename[1], &ename[2]); |
392 |
|
393 |
Lng = strlen(ename); |
394 |
lastChr = Lng - 1; /* index to last character in string makes code easier */ |
395 |
|
396 |
/* Remove an S from the end of the string */ |
397 |
if ((ename[lastChr] == 'S') || (ename[lastChr] == 'ß')) { |
398 |
ename[lastChr] = '\0'; |
399 |
Lng = strlen(ename); |
400 |
lastChr = Lng - 1; |
401 |
} |
402 |
for (ii = 0; ((strlen(metaph) < metalen) && (ii < Lng)); ii++) { |
403 |
|
404 |
curLtr = ename[ii]; |
405 |
|
406 |
vowelBefore = FALSE; |
407 |
prevLtr = ' '; |
408 |
if (ii > 0) { |
409 |
prevLtr = ename[ii - 1]; |
410 |
if (IsVowel(prevLtr)) |
411 |
vowelBefore = TRUE; |
412 |
} |
413 |
/* if first letter is a vowel KEEP it */ |
414 |
if (ii == 0 && (IsVowel(curLtr))) { |
415 |
strncat(metaph, &curLtr, 1); |
416 |
continue; |
417 |
} |
418 |
vowelAfter = FALSE; |
419 |
frontvAfter = FALSE; |
420 |
nextLtr = ' '; |
421 |
if (ii < lastChr) { |
422 |
nextLtr = ename[ii + 1]; |
423 |
if (IsVowel(nextLtr)) |
424 |
vowelAfter = TRUE; |
425 |
if (strchr(FRONTV, nextLtr) != NULLCHAR) |
426 |
frontvAfter = TRUE; |
427 |
} |
428 |
/* skip double letters except ones in list */ |
429 |
if (curLtr == nextLtr && (strchr(DOUBLE, nextLtr) == NULLCHAR)) |
430 |
continue; |
431 |
|
432 |
nextLtr2 = ' '; |
433 |
if (ii < (lastChr - 1)) |
434 |
nextLtr2 = ename[ii + 2]; |
435 |
|
436 |
nextLtr3 = ' '; |
437 |
if (ii < (lastChr - 2)) |
438 |
nextLtr3 = ename[ii + 3]; |
439 |
|
440 |
switch (curLtr) { |
441 |
|
442 |
case 'B': |
443 |
silent = FALSE; |
444 |
if (ii == lastChr && prevLtr == 'M') |
445 |
silent = TRUE; |
446 |
if (!silent) |
447 |
strncat(metaph, &curLtr, 1); |
448 |
break; |
449 |
|
450 |
/*silent -sci-,-sce-,-scy-; sci-, etc OK */ |
451 |
case 'C': |
452 |
if (!(ii > 1 && prevLtr == 'S' && frontvAfter)) |
453 |
if (ii > 0 && nextLtr == 'I' && nextLtr2 == 'A') |
454 |
strncat(metaph, "X", 1); |
455 |
else if (frontvAfter) |
456 |
strncat(metaph, "S", 1); |
457 |
else if (ii > 1 && prevLtr == 'S' && nextLtr == 'H') |
458 |
strncat(metaph, "K", 1); |
459 |
else if (nextLtr == 'H') |
460 |
if (ii == 0 && (!IsVowel(nextLtr2))) |
461 |
strncat(metaph, "K", 1); |
462 |
else |
463 |
strncat(metaph, "X", 1); |
464 |
else if (prevLtr == 'C') |
465 |
strncat(metaph, "C", 1); |
466 |
else |
467 |
strncat(metaph, "K", 1); |
468 |
break; |
469 |
|
470 |
case 'D': |
471 |
if (nextLtr == 'G' && (strchr(FRONTV, nextLtr2) != NULLCHAR)) |
472 |
strncat(metaph, "J", 1); |
473 |
else |
474 |
strncat(metaph, "T", 1); |
475 |
break; |
476 |
|
477 |
case 'G': |
478 |
silent = FALSE; |
479 |
/* SILENT -gh- except for -gh and no vowel after h */ |
480 |
if ((ii < (lastChr - 1) && nextLtr == 'H') |
481 |
&& (!IsVowel(nextLtr2))) |
482 |
silent = TRUE; |
483 |
|
484 |
if ((ii == (lastChr - 3)) |
485 |
&& nextLtr == 'N' && nextLtr2 == 'E' && nextLtr3 == 'D') |
486 |
silent = TRUE; |
487 |
else if ((ii == (lastChr - 1)) && nextLtr == 'N') |
488 |
silent = TRUE; |
489 |
|
490 |
if (prevLtr == 'D' && frontvAfter) |
491 |
silent = TRUE; |
492 |
|
493 |
if (prevLtr == 'G') |
494 |
hard = TRUE; |
495 |
else |
496 |
hard = FALSE; |
497 |
|
498 |
if (!silent) |
499 |
if (frontvAfter && (!hard)) |
500 |
strncat(metaph, "J", 1); |
501 |
else |
502 |
strncat(metaph, "K", 1); |
503 |
break; |
504 |
|
505 |
case 'H': |
506 |
silent = FALSE; |
507 |
if (strchr(VARSON, prevLtr) != NULLCHAR) |
508 |
silent = TRUE; |
509 |
|
510 |
if (vowelBefore && !vowelAfter) |
511 |
silent = TRUE; |
512 |
|
513 |
if (!silent) |
514 |
strncat(metaph, &curLtr, 1); |
515 |
break; |
516 |
|
517 |
case 'F': |
518 |
case 'J': |
519 |
case 'L': |
520 |
case 'M': |
521 |
case 'N': |
522 |
case 'R': |
523 |
strncat(metaph, &curLtr, 1); |
524 |
break; |
525 |
|
526 |
case 'K': |
527 |
if (prevLtr != 'C') |
528 |
strncat(metaph, &curLtr, 1); |
529 |
break; |
530 |
|
531 |
case 'P': |
532 |
if (nextLtr == 'H') |
533 |
strncat(metaph, "F", 1); |
534 |
else |
535 |
strncat(metaph, "P", 1); |
536 |
break; |
537 |
|
538 |
case 'Q': |
539 |
strncat(metaph, "K", 1); |
540 |
break; |
541 |
|
542 |
case 'S': |
543 |
if (ii > 1 && nextLtr == 'I' |
544 |
&& (nextLtr2 == 'O' || nextLtr2 == 'A')) |
545 |
strncat(metaph, "X", 1); |
546 |
else if (nextLtr == 'H') |
547 |
strncat(metaph, "X", 1); |
548 |
else |
549 |
strncat(metaph, "S", 1); |
550 |
break; |
551 |
|
552 |
case 'T': |
553 |
if (ii > 1 && nextLtr == 'I' |
554 |
&& (nextLtr2 == 'O' || nextLtr2 == 'A')) |
555 |
strncat(metaph, "X", 1); |
556 |
else if (nextLtr == 'H') /* The=0, Tho=T, Withrow=0 */ |
557 |
if (ii > 0 || (IsVowel(nextLtr2))) |
558 |
strncat(metaph, "0", 1); |
559 |
else |
560 |
strncat(metaph, "T", 1); |
561 |
else if (!(ii < (lastChr - 2) && nextLtr == 'C' && nextLtr2 == 'H')) |
562 |
strncat(metaph, "T", 1); |
563 |
break; |
564 |
|
565 |
case 'V': |
566 |
strncat(metaph, "F", 1); |
567 |
break; |
568 |
|
569 |
case 'W': |
570 |
case 'Y': |
571 |
if (ii < lastChr && vowelAfter) |
572 |
strncat(metaph, &curLtr, 1); |
573 |
break; |
574 |
|
575 |
case 'X': |
576 |
strncat(metaph, "KS", 2); |
577 |
break; |
578 |
|
579 |
case 'Z': |
580 |
strncat(metaph, "S", 1); |
581 |
break; |
582 |
} |
583 |
|
584 |
} |
585 |
|
586 |
/* DON'T DO THIS NOW, REMOVING "S" IN BEGINNING HAS the same effect |
587 |
with plurals, in addition imbedded S's in the Metaphone are included |
588 |
Lng = strlen(metaph); |
589 |
lastChr = Lng -1; |
590 |
if ( metaph[lastChr] == 'S' && Lng >= 3 ) metaph[lastChr] = '\0'; |
591 |
*/ |
592 |
|
593 |
return; |
594 |
} |
595 |
|
596 |
#if 0 |
597 |
int |
598 |
metaphone(argc) |
599 |
int argc; |
600 |
{ |
601 |
|
602 |
char name[128]; |
603 |
char metaph[50]; |
604 |
|
605 |
if (argc != 1) { |
606 |
fprintf(stderr, "metaphone: argc != 1\n"); |
607 |
retquote(""); |
608 |
return (1); |
609 |
} |
610 |
popquote(name, sizeof(name)); |
611 |
|
612 |
metaph[0] = '\0'; |
613 |
phonetic(name, metaph, 20); |
614 |
|
615 |
retquote(metaph); |
616 |
return (1); |
617 |
} |
618 |
|
619 |
int |
620 |
main(argc, argv) |
621 |
int argc; |
622 |
char *argv[]; |
623 |
{ |
624 |
char metaph[50]; |
625 |
|
626 |
if (argc != 2) { |
627 |
fprintf(stderr, "metaphone: argc == %d\n", argc); |
628 |
exit(1); |
629 |
} |
630 |
metaph[0] = '\0'; |
631 |
fprintf(stderr, "%s\n", argv[1]); |
632 |
phonetic(argv[1], metaph, 20); |
633 |
fprintf(stderr, "%s => %s\n", argv[1], metaph); |
634 |
exit(0); |
635 |
} |
636 |
#endif |