/* This file is part of GNU Dico. Copyright (C) 2008-2024 Sergey Poznyakoff GNU Dico is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GNU Dico is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Dico. If not, see . */ #include #include #include #include #include #include #define METAPH_SEGM_SIZE 16 struct metaph_segment { char segm[METAPH_SEGM_SIZE]; struct metaph_segment *next; }; struct metaph_code { size_t length; size_t nsegm; struct metaph_segment *segm_head, *segm_tail; }; static size_t metaph_code_length(struct metaph_code *code) { return code ? code->length : 0; } static void metaph_code_trim(struct metaph_code *code, size_t length) { if (code && code->length > length) code->length = length; } static struct metaph_code * metaph_code_create(void) { struct metaph_code *code = malloc(sizeof *code); if (code) { code->length = 0; code->nsegm = 0; code->segm_head = code->segm_tail = NULL; } return code; } static struct metaph_segment * metaph_code_alloc_segment(struct metaph_code *code) { struct metaph_segment *newseg = malloc(sizeof newseg[0]); if (!newseg) return NULL; newseg->next = NULL; memset(newseg->segm, 0, METAPH_SEGM_SIZE); if (code->segm_tail) code->segm_tail->next = newseg; else code->segm_head = newseg; code->segm_tail = newseg; code->nsegm++; return newseg; } static struct metaph_code * metaph_code_dup(struct metaph_code *src) { struct metaph_code *dst = metaph_code_create(); struct metaph_segment *src_segm, *dst_segm; if (!dst) return NULL; for (src_segm = src->segm_head; src_segm; src_segm = src_segm->next) { dst_segm = metaph_code_alloc_segment(dst); memcpy(dst_segm->segm, src_segm->segm, METAPH_SEGM_SIZE); } dst->length = src->length; return dst; } static void metaph_code_free(struct metaph_code *code) { if (code) { struct metaph_segment *s = code->segm_head; while (s) { struct metaph_segment *next = s->next; free(s); s = next; } free(code); } } static int metaph_code_eq(struct metaph_code *a, struct metaph_code *b) { struct metaph_segment *sa, *sb; size_t length; if (a == NULL || b == NULL) return 0; if (a->length != b->length) return 0; length = a->length; sa = a->segm_head; sb = b->segm_head; while (length) { size_t segm_length = length < METAPH_SEGM_SIZE ? length : METAPH_SEGM_SIZE; if (memcmp(sa->segm, sb->segm, segm_length)) return 0; length -= segm_length; sa = sa->next; sb = sb->next; } return 1; } static int metaph_code_get_buffer(struct metaph_code *code, char **ret_ptr, size_t *ret_size) { size_t s = code->nsegm * METAPH_SEGM_SIZE - code->length; if (s == 0) { if (!metaph_code_alloc_segment(code)) return -1; s = METAPH_SEGM_SIZE; } *ret_ptr = code->segm_tail->segm + code->length % METAPH_SEGM_SIZE; *ret_size = s; return 0; } static int metaph_code_add(struct metaph_code *code, char const *str) { if (str) { size_t length = strlen(str); while (length) { char *p; size_t n; if (metaph_code_get_buffer(code, &p, &n)) return -1; if (n > length) n = length; memcpy(p, str, n); str += n; code->length += n; length -= n; } } return 0; } static void metaph_code_dump(struct metaph_code *code) { if (!code) printf("%s\n", "NULL"); else { struct metaph_segment *s; size_t length; printf("length = %zu\n", code->length); printf("nsegm = %zu\n", code->nsegm); length = code->length; for (s = code->segm_head; s; s = s->next) { size_t i; putchar('\''); for (i = 0; length > 0 && i < METAPH_SEGM_SIZE; i++, length--) putchar(s->segm[i]); printf("'\n"); } } } static void metaph_code_print(struct metaph_code *code) { if (!code) printf("%s\n", "NULL"); else { struct metaph_segment *s; size_t length; length = code->length; for (s = code->segm_head; s; s = s->next) { size_t i; for (i = 0; length > 0 && i < METAPH_SEGM_SIZE; i++, length--) putchar(s->segm[i]); } } } typedef struct metaph_code *double_metaphone_code[2]; static int double_metaphone_add(double_metaphone_code code, char const *primary, char const *secondary) { if (secondary) { if (!code[1]) { code[1] = metaph_code_dup(code[0]); if (!code[1]) { DICO_LOG_MEMERR(); return -1; } } if (metaph_code_add(code[1], secondary)) return -1; } else if (code[1]) { if (metaph_code_add(code[1], primary)) return -1; } metaph_code_add(code[0], primary); return 0; } /* Return true if POS + OFF is within the STR and the substring at STR[POS + OFF] matches one of the alternatives in PAT. Alternatives are delimited by | characters. */ static int looking_at(unsigned const *str, size_t pos, int off, char const *pat) { size_t i; if (off < 0 && pos < -off) return 0; pos += off; i = pos; while (*pat) { if (*pat == str[i]) { ++i; ++pat; if (!*pat || *pat == '|') return 1; } else { /* reset */ while (*pat && *pat != '|') ++pat; if (*pat) ++pat; i = pos; } } return 0; } static void double_metaphone_free(double_metaphone_code code) { metaph_code_free(code[0]); metaph_code_free(code[1]); } #define ISVOWEL(s,p,i) looking_at(s, p, i, "A|E|I|O|U|Y") static int is_slavo_germanic(unsigned const *str) { static unsigned pat[] = { 'W', 0, 'K', 0, 'C', 'Z', 0, 'W', 'I', 'T', 'Z', 0, 0 }; int i; for (i = 0; pat[i]; i++) { if (utf8_wc_strstr(str, pat)) return 1; while (pat[i]) ++i; } return 0; } static int double_metaphone_encode(double_metaphone_code code, char const *str, size_t max_length) { unsigned *buf; /* STR converted to UTF */ size_t current = 0; /* Current position */ size_t length, last; #define DMETAPH_ADD(c,a,b) \ do { \ if (double_metaphone_add(c,a,b)) \ goto err; \ } while (0) int slavo_germanic = -1; #define IS_SLAVO_GERMANIC() \ ((slavo_germanic == -1) \ ? (slavo_germanic = is_slavo_germanic(buf)) : slavo_germanic) if (utf8_mbstr_to_wc(str, &buf, NULL)) { dico_log(L_ERR, errno, "%s: cannot convert \"%s\"", __func__, str); return -1; } length = utf8_wc_strlen(buf); last = length - 1; code[0] = metaph_code_create(); if (!code[0]) { dico_log(L_ERR, 0, _("%s: not enough memory"), __func__); free(buf); return -1; } code[1] = NULL; utf8_wc_strupper(buf); current = 0; if (looking_at(buf, current, 0, "GN|KN|PN|WR|PS")) ++current; while (current < length && (max_length == 0 || metaph_code_length(code[0]) < max_length || metaph_code_length(code[1]) < max_length)) { switch (buf[current]) { case 'A': case 'E': case 'I': case 'O': case 'U': case 'Y': if (current == 0) /* Map initial vowel to A */ DMETAPH_ADD(code, "A", NULL); current++; break; case 'B': DMETAPH_ADD(code, "P", NULL); ++current; if (buf[current] == 'B') ++current; break; case L'Ç': DMETAPH_ADD(code, "S", NULL); ++current; break; case 'C': /* Various Germanic */ if (current > 1 && !ISVOWEL(buf, current, -2) && looking_at(buf, current, -1, "ACH") && buf[current + 2] != 'I' && (buf[current + 2] != 'E' || looking_at(buf, current, -2, "BACHER|MACHER"))) { DMETAPH_ADD(code, "K", NULL); current += 2; break; } /* Special case 'caesar' */ if (current == 0 && looking_at(buf, current, 0, "CAESAR")) { DMETAPH_ADD(code, "S", NULL); current += 2; break; } /* Italian 'chianti' */ if (looking_at(buf, current, 0, "CHIA")) { DMETAPH_ADD(code, "K", NULL); current += 2; break; } if (looking_at(buf, current, 0, "CH")) { /* 'michael'? */ if (current > 0 && looking_at(buf, current, 0, "CHAE")) { DMETAPH_ADD(code, "K", "X"); current += 2; break; } /* Greek roots e.g. 'chemistry', 'chorus' */ if (current == 0 && (looking_at(buf, current, 1, "HARAC|HARIS|HOR|HYM|HIA|HEM")) && !looking_at(buf, 0, 0, "CHORE")) { DMETAPH_ADD(code, "K", NULL); current += 2; break; } /* Germanic, greek, or otherwise 'ch' for 'kh' sound */ if ((looking_at(buf, 0, 0, "VAN |VON ") || looking_at(buf, 0, 0, "SCH")) /* 'architect but not 'arch', 'orchestra', 'orchid' */ || looking_at(buf, current, -2, "ORCHES|ARCHIT|ORCHID") || looking_at(buf, current, +2, "T|S") || ((looking_at(buf, current, -1, "A|O|U|E") || current == 0) /* e.g., 'wachtler', 'wechsler', but not 'tichner' */ && looking_at(buf, current, +2, "L|R|N|M|B|H|F|V|W| "))) { DMETAPH_ADD(code, "K", NULL); } else { if (current > 0) { if (looking_at(buf, 0, 0, "MC")) /* e.g., "McHugh" */ DMETAPH_ADD(code, "K", NULL); else DMETAPH_ADD(code, "X", "K"); } else DMETAPH_ADD(code, "X", NULL); } current += 2; break; } /* E.g, 'czerny' */ if (looking_at(buf, current, 0, "CZ") && !looking_at(buf, current, -2, "WICZ")) { DMETAPH_ADD(code, "S", "X"); current += 2; break; } /* E.g., 'focaccia' */ if (looking_at(buf, current, +1, "CIA")) { DMETAPH_ADD(code, "X", NULL); current += 3; break; } /* Double 'C', but not if e.g. 'McClellan' */ if (looking_at(buf, current, 0, "CC") && !(current == 1 && buf[0] == 'M')) { /* 'bellocchio' but not 'bacchus' */ if (looking_at(buf, current, +2, "I|E|H") && !looking_at(buf, current, +2, "HU")) { /* 'accident', 'accede' 'succeed' */ if ((current == 1 && buf[current - 1] == 'A') || looking_at(buf, current, -1, "UCCEE|UCCES")) DMETAPH_ADD(code, "KS", NULL); /* 'bacci', 'bertucci', other italian */ else DMETAPH_ADD(code, "X", NULL); current += 3; break; } else { /* Pierce's rule */ DMETAPH_ADD(code, "K", NULL); current += 2; break; } } if (looking_at(buf, current, 0, "CK|CG|CQ")) { DMETAPH_ADD(code, "K", NULL); current += 2; break; } if (looking_at(buf, current, 0, "CI|CE|CY")) { /* Italian vs. english */ if (looking_at(buf, current, 0, "CIO|CIE|CIA")) DMETAPH_ADD(code, "S", "X"); else DMETAPH_ADD(code, "S", NULL); current += 2; break; } DMETAPH_ADD(code, "K", NULL); /* Name sent in 'mac caffrey', 'mac gregor' */ if (looking_at(buf, current, +1, " C| Q| G")) current += 3; else if (looking_at(buf, current, +1, "C|K|Q") && !looking_at(buf, current, +1, "CE|CI")) current += 2; else current++; break; case 'D': if (looking_at(buf, current, 0, "DG")) { if (looking_at(buf, current, +2, "I|E|Y")) { /* E.g. 'edge' */ DMETAPH_ADD(code, "J", NULL); current += 3; break; } else { /* E.g. 'edgar' */ DMETAPH_ADD(code, "TK", NULL); current += 2; break; } } if (looking_at(buf, current, 0, "DT|DD")) { DMETAPH_ADD(code, "T", NULL); current += 2; break; } DMETAPH_ADD(code, "T", NULL); current++; break; case 'F': ++current; if (buf[current] == 'F') ++current; DMETAPH_ADD(code, "F", NULL); break; case 'G': if (buf[current + 1] == 'H') { if ((current > 0) && !ISVOWEL(buf, current, -1)) { DMETAPH_ADD(code, "K", NULL); current += 2; break; } if (current < 3) { /* 'ghislane', 'ghiradelli' */ if (current == 0) { if (buf[current + 2] == 'I') DMETAPH_ADD(code, "J", NULL); else DMETAPH_ADD(code, "K", NULL); current += 2; break; } } /* Parker's rule (with some further refinements) - e.g., 'hugh' */ if ((current > 1 && looking_at(buf, current, -2, "B|H|D")) /* e.g., 'bough' */ || (current > 2 && looking_at(buf, current, -3, "B|H|D")) /* e.g., 'broughton' */ || (current > 3 && looking_at(buf, current, -4, "B|H"))) { current += 2; break; } else { /* e.g., 'laugh', 'McLaughlin', 'cough', 'gough', 'rough', 'tough' */ if (current > 2 && buf[current - 1] == 'U' && looking_at(buf, current, -3, "C|G|L|R|T")) { DMETAPH_ADD(code, "F", NULL); } else if (current > 0 && buf[current - 1] != 'I') DMETAPH_ADD(code, "K", NULL); current += 2; break; } } if (buf[current + 1] == 'N') { if (current == 1 && ISVOWEL(buf, 0, 0) && !IS_SLAVO_GERMANIC()) { DMETAPH_ADD(code, "KN", "N"); } else /* not e.g. 'cagney' */ if (!looking_at(buf, current, +2, "EY") && (buf[current + 1] != 'Y') && !IS_SLAVO_GERMANIC()) { DMETAPH_ADD(code, "N", "KN"); } else DMETAPH_ADD(code, "KN", NULL); current += 2; break; } /* 'tagliaro' */ if (looking_at(buf, current, +1, "LI") && !IS_SLAVO_GERMANIC()) { DMETAPH_ADD(code, "KL", "L"); current += 2; break; } /* -ges-,-gep-,-gel-, -gie- at the beginning */ if (current == 0 && (buf[current + 1] == 'Y' || looking_at(buf, current, +1, "ES|EP|EB|EL|EY|IB|IL|IN|IE|EI|ER"))) { DMETAPH_ADD(code, "K", "J"); current += 2; break; } /* -ger-, -gy- */ if ((looking_at(buf, current, +1, "ER") || (buf[current + 1] == 'Y')) && !looking_at(buf, 0, 0, "DANGER|RANGER|MANGER") && !looking_at(buf, current, -1, "E|I|RGY|OGY")) { DMETAPH_ADD(code, "K", "J"); current += 2; break; } /* italian e.g, 'biaggi' */ if (looking_at(buf, current, +1, "E|I|Y") || looking_at(buf, current, -1, "AGGI|OGGI")) { /* obvious germanic */ if ((looking_at(buf, 0, 0, "VAN |VON ") || looking_at(buf, 0, 0, "SCH")) || looking_at(buf, current, +1, "ET")) DMETAPH_ADD(code, "K", NULL); else /* always soft if french ending */ if (looking_at(buf, current, +1, "IER ")) DMETAPH_ADD(code, "J", NULL); else DMETAPH_ADD(code, "J", "K"); current += 2; break; } ++current; if (buf[current] == 'G') ++current; DMETAPH_ADD(code, "K", NULL); break; case 'H': /* only keep if first & before vowel or btw. 2 vowels */ if ((current == 0 || ISVOWEL(buf, current, -1)) && ISVOWEL(buf, current, +1)) { DMETAPH_ADD(code, "H", NULL); current += 2; } else /* also takes care of 'HH' */ current++; break; case 'J': /* obvious spanish, 'jose', 'san jacinto' */ if (looking_at(buf, current, 0, "JOSE") || looking_at(buf, 0, 0, "SAN ")) { if ((current == 0 && buf[current + 4] == ' ') || looking_at(buf, 0, 0, "SAN ")) DMETAPH_ADD(code, "H", NULL); else DMETAPH_ADD(code, "J", "H"); current++; break; } if (current == 0 && !looking_at(buf, current, 0, "JOSE")) DMETAPH_ADD(code, "J", "A"); /* Yankelovich | Jankelowicz */ else /* spanish pron. of e.g. 'bajador' */ if (ISVOWEL(buf, current, -1) && !IS_SLAVO_GERMANIC() && (buf[current + 1] == 'A' || buf[current + 1] == 'O')) DMETAPH_ADD(code, "J", "H"); else if (current == last) DMETAPH_ADD(code, "J", " "); else if (!looking_at(buf, current, +1, "L|T|K|S|N|M|B|Z") && !looking_at(buf, current, -1, "S|K|L")) DMETAPH_ADD(code, "J", NULL); ++current; if (buf[current] == 'J') ++current; break; case 'K': ++current; if (buf[current] == 'K') ++current; DMETAPH_ADD(code, "K", NULL); break; case 'L': if (buf[current + 1] == 'L') { /* spanish e.g. 'cabrillo', 'gallegos' */ if ((current == length - 3 && looking_at(buf, current, -1, "ILLO|ILLA|ALLE")) || ((looking_at(buf, last, -1, "AS|OS") || looking_at(buf, last, 0, "A|O")) && looking_at(buf, current, -1, "ALLE"))) { DMETAPH_ADD(code, "L", " "); current += 2; break; } current += 2; } else current++; DMETAPH_ADD(code, "L", NULL); break; case 'M': if ((looking_at(buf, current, -1, "UMB") && (current + 1 == last || looking_at(buf, current, +2, "ER"))) /* 'dumb','thumb' */ || (buf[current + 1] == 'M')) current += 2; else current++; DMETAPH_ADD(code, "M", NULL); break; case 'N': ++current; if (buf[current] == 'N') ++current; DMETAPH_ADD(code, "N", NULL); break; case L'Ń': case L'Ñ': current++; DMETAPH_ADD(code, "N", NULL); break; case 'P': if (buf[current + 1] == 'H') { DMETAPH_ADD(code, "F", NULL); current += 2; break; } /* also account for "campbell", "raspberry" */ if (looking_at(buf, current, +1, "P|B")) current += 2; else current++; DMETAPH_ADD(code, "P", NULL); break; case 'Q': ++current; if (buf[current] == 'Q') ++current; DMETAPH_ADD(code, "K", NULL); break; case 'R': /* french e.g. 'rogier', but exclude 'hochmeier' */ if (current == last && !IS_SLAVO_GERMANIC() && looking_at(buf, current, -2, "IE") && !looking_at(buf, current, -4, "ME|MA")) DMETAPH_ADD(code, NULL, "R"); else DMETAPH_ADD(code, "R", NULL); ++current; if (buf[current] == 'R') ++current; break; case 'S': /* special cases 'island', 'isle', 'carlisle', 'carlysle' */ if (looking_at(buf, current, -1, "ISL|YSL")) { current++; break; } /* special case 'sugar-' */ if (current == 0 && looking_at(buf, current, 0, "SUGAR")) { DMETAPH_ADD(code, "X", "S"); current++; break; } if (looking_at(buf, current, 0, "SH")) { /* germanic */ if (looking_at(buf, current, +1, "HEIM|HOEK|HOLM|HOLZ")) DMETAPH_ADD(code, "S", NULL); else DMETAPH_ADD(code, "X", NULL); current += 2; break; } /* italian & armenian */ if (looking_at(buf, current, 0, "SIO|SIA") || looking_at(buf, current, 0, "SIAN")) { if (!IS_SLAVO_GERMANIC()) DMETAPH_ADD(code, "S", "X"); else DMETAPH_ADD(code, "S", NULL); current += 3; break; } /* german & anglicisations, e.g. 'smith' match 'schmidt', 'snider' match 'schneider' */ /* also, -sz- in slavic language altho in hungarian it is pronounced 's' */ if ((current == 0 && looking_at(buf, current, +1, "M|N|L|W")) || looking_at(buf, current, +1, "Z")) { DMETAPH_ADD(code, "S", "X"); if (looking_at(buf, current, +1, "Z")) current += 2; else current++; break; } if (looking_at(buf, current, 0, "SC")) { /* Schlesinger's rule */ if (buf[current + 2] == 'H') { /* Dutch origin, e.g. 'school', 'schooner' */ if (looking_at(buf, current, +3, "OO|ER|EN|UY|ED|EM")) { /* 'schermerhorn', 'schenker' */ if (looking_at(buf, current, +3, "ER|EN")) DMETAPH_ADD(code, "X", "SK"); else DMETAPH_ADD(code, "SK", NULL); current += 3; break; } else { if (current == 0 && !ISVOWEL(buf, 3, 0) && buf[3] != 'W') DMETAPH_ADD(code, "X", "S"); else DMETAPH_ADD(code, "X", NULL); current += 3; break; } } if (looking_at(buf, current, +2, "I|E|Y")) { DMETAPH_ADD(code, "S", NULL); current += 3; break; } DMETAPH_ADD(code, "SK", NULL); current += 3; break; } /* french e.g. 'resnais', 'artois' */ if (current == last && looking_at(buf, current, -2, "AI|OI")) DMETAPH_ADD(code, NULL, "S"); else DMETAPH_ADD(code, "S", NULL); if (looking_at(buf, current, +1, "S|Z")) current += 2; else current++; break; case 'T': if (looking_at(buf, current, 0, "TION")) { DMETAPH_ADD(code, "X", NULL); current += 3; break; } if (looking_at(buf, current, 0, "TIA|TCH")) { DMETAPH_ADD(code, "X", NULL); current += 3; break; } if (looking_at(buf, current, 0, "TH|TTH")) { /* special case 'thomas', 'thames' or germanic */ if (looking_at(buf, current, +2, "OM|AM") || looking_at(buf, 0, 0, "VAN |VON |SCH")) { DMETAPH_ADD(code, "T", NULL); } else { DMETAPH_ADD(code, "0", "T"); } current += 2; break; } if (looking_at(buf, current, +1, "T|D")) current += 2; else current++; DMETAPH_ADD(code, "T", NULL); break; case 'V': if (buf[current + 1] == 'V') current += 2; else current++; DMETAPH_ADD(code, "F", NULL); break; case 'W': /* can also be in middle of word */ if (looking_at(buf, current, 0, "WR")) { DMETAPH_ADD(code, "R", NULL); current += 2; break; } if (current == 0 && (ISVOWEL(buf, current, +1) || looking_at(buf, current, 0, "WH"))) { /* Wasserman should match Vasserman */ if (ISVOWEL(buf, current, +1)) DMETAPH_ADD(code, "A", "F"); else /* need Uomo to match Womo */ DMETAPH_ADD(code, "A", NULL); } /* Arnow should match Arnoff */ if ((current == last && ISVOWEL(buf, current, -1)) || looking_at(buf, current, -1, "EWSKI|EWSKY|OWSKI|OWSKY") || looking_at(buf, 0, 0, "SCH")) { DMETAPH_ADD(code, NULL, "F"); current++; break; } /* polish e.g. 'filipowicz' */ if (looking_at(buf, current, 0, "WICZ|WITZ")) { DMETAPH_ADD(code, "TS", "FX"); current += 4; break; } /* else skip it */ current++; break; case 'X': /* french e.g. breaux */ if (!(current == last && (looking_at(buf, current, -3, "IAU|EAU") || looking_at(buf, current, -2, "AU|OU")))) DMETAPH_ADD(code, "KS", NULL); if (looking_at(buf, current, +1, "C|X")) current += 2; else current++; break; case 'Z': /* chinese pinyin e.g. 'zhao' */ if (buf[current + 1] == 'H') { DMETAPH_ADD(code, "J", NULL); current += 2; break; } else if (looking_at(buf, current, +1, "ZO|ZI|ZA") || (IS_SLAVO_GERMANIC() && (current > 0 && buf[current - 1] != 'T'))) { DMETAPH_ADD(code, "S", "TS"); } else DMETAPH_ADD(code, "S", NULL); ++current; if (buf[current] == 'Z') ++current; break; default: ++current; } } free(buf); if (max_length) { /* Trim returned codes */ metaph_code_trim(code[0], max_length); metaph_code_trim(code[1], max_length); } return 0; err: free(buf); double_metaphone_free(code); return -1; } static int double_metaphone_eq(double_metaphone_code a, double_metaphone_code b) { return metaph_code_eq(a[0], b[0]) || metaph_code_eq(a[1], b[1]) || metaph_code_eq(a[0], b[1]) || metaph_code_eq(a[1], b[0]); } static size_t double_metaphone_length = 4; static int metaphone2_sel(int cmd, struct dico_key *key, const char *dict_word) { double_metaphone_code code; int res; switch (cmd) { case DICO_SELECT_BEGIN: if (double_metaphone_encode(code, key->word, double_metaphone_length)) return 1; key->call_data = malloc(sizeof code); if (!key->call_data) return 1; memcpy(key->call_data, code, sizeof(code)); break; case DICO_SELECT_RUN: if (double_metaphone_encode(code, dict_word, double_metaphone_length)) return 1; res = double_metaphone_eq(*(double_metaphone_code*)key->call_data, code); double_metaphone_free(code); return res; case DICO_SELECT_END: double_metaphone_free(*(double_metaphone_code*)key->call_data); free(key->call_data); break; } return 0; } static struct dico_strategy metaphone2_strat = { "metaphone2", "Match Double Metaphone encodings", metaphone2_sel }; static int metaphone2_init(int argc, char **argv) { long size = 0; struct dico_option metaphone2_option[] = { { DICO_OPTSTR(size), dico_opt_long, &size }, { NULL } }; if (dico_parseopt(metaphone2_option, argc, argv, 0, NULL)) return 1; if (size > 0) double_metaphone_length = size; dico_strategy_add(&metaphone2_strat); return 0; } static int metaphone2_run_test(int argc, char **argv) { char *modname, *cmd; argc--; modname = *argv++; dico_set_program_name(modname); if (argc == 0) { dico_log(L_ERR, 0, "bad argument list"); return 1; } argc--; cmd = *argv++; if (strcmp(cmd, "build") == 0) { struct metaph_code *code; code = metaph_code_create(); assert(code != NULL); while (argc--) { int res = metaph_code_add(code, *argv++); assert(res == 0); } metaph_code_dump(code); metaph_code_free(code); } else if (strcmp(cmd, "compare") == 0) { struct metaph_code *a, *b; int res; a = metaph_code_create(); assert(a != NULL); while (argc--) { char *arg = *argv++; if (strcmp(arg, ":") == 0) break; else { res = metaph_code_add(a, arg); assert(res == 0); } } if (argc <= 0) { dico_log(L_ERR, 0, "bad argument list"); return 1; } b = metaph_code_create(); assert(b != NULL); while (argc--) { res = metaph_code_add(b, *argv++); assert(res == 0); } res = metaph_code_eq(a, b); metaph_code_free(a); metaph_code_free(b); printf("%d\n", res); } else if (strcmp(cmd, "encode") == 0) { unsigned long len = 0; if (strncmp(*argv, "-length=", 8) == 0) { char *p; len = strtoul(*argv + 8, &p, 10); assert(*p == 0); --argc; ++argv; } while (argc--) { char *arg = *argv++; double_metaphone_code code; if (double_metaphone_encode(code, arg, len)) dico_log(L_ERR, errno, "can't encode"); else { printf("%s: ", arg); if (code[0]) { printf("'"); metaph_code_print(code[0]); printf("'"); } else { printf("NULL"); } printf(" -- "); if (code[1]) { printf("'"); metaph_code_print(code[1]); printf("'"); } else { printf("NULL"); } putchar('\n'); double_metaphone_free(code); } } } else { dico_log(L_ERR, 0, "unrecognized unit test: %s", cmd); dico_log(L_INFO, 0, "usage:"); printf("usage: %s build SEQ [SEQ...]\n" " build a metaphone code block from the sequence of letters\n", modname); printf(" %s compare SEQ [SEQ...] : SEQ [SEQ...]\n" " build two blocks and compare them\n", modname); printf(" %s encode [-length=N] WORD [WORD...]\n" " encode the supplied words\n", modname); return 1; } return 0; } struct dico_database_module DICO_EXPORT(metaphone2, module) = { .dico_version = DICO_MODULE_VERSION, .dico_capabilities = DICO_CAPA_NODB, .dico_init = metaphone2_init, .dico_run_test = metaphone2_run_test };