/* This file is part of GNU Dico.
Copyright (C) 2012-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
#include
#include
#include
#define WNDB_MERGE_DEFS 0x01
struct wndb {
char *dbname;
int flags;
int pos;
int optc;
struct wn_option **optv;
};
static int
_dico_display_message(char *msg)
{
dico_log(L_ERR, 0, "WordNet: %s", msg);
return -1;
}
static int
wn_free_db(dico_handle_t hp)
{
struct wndb *wndb = (struct wndb *)hp;
free(wndb->dbname);
free(wndb->optv);
free(wndb);
return 0;
}
static void wn_register_strategies(void);
static void wn_free_result(dico_result_t rp);
static int
wn_init(int argc, char **argv)
{
char *wnsearchdir = NULL;
char *wnhome = NULL;
struct dico_option init_option[] = {
{ DICO_OPTSTR(wnsearchdir), dico_opt_string, &wnsearchdir },
{ DICO_OPTSTR(wnhome), dico_opt_string, &wnhome },
{ NULL }
};
if (dico_parseopt(init_option, argc, argv, 0, NULL))
return 1;
display_message = _dico_display_message;
/* FIXME: Control lengths! libWN does not bother to check boundaries */
if (wnhome)
setenv("WNHOME", wnhome, 1);
if (wnsearchdir)
setenv("WNSEARCHDIR", wnsearchdir, 1);
if (wninit()) {
dico_log(L_ERR, 0, _("cannot open wordnet database"));
return 1;
}
wn_register_strategies();
return 0;
}
static const char *pos_choice[] = {
"all",
"noun",
"verb",
"adj",
"adjective",
"adv",
"adverb",
"satellite",
"adjsat",
NULL
};
static int pos_trans[] = {
ALL_POS,
NOUN,
VERB,
ADJ,
ADJ,
ADV,
ADV,
ADJSAT,
ADJSAT
};
/* Forward declarations */
struct result;
static void _wn_print_overview(struct wn_option *, SynsetPtr,
struct result *res, dico_stream_t);
static void _wn_print_definition(struct wn_option *opt, SynsetPtr sp,
struct result *res, dico_stream_t str);
static void _wn_print_hypernym(struct wn_option *, SynsetPtr,
struct result *res, dico_stream_t);
struct wn_option {
char *option; /* user's search request */
int search; /* search to pass findtheinfo() */
int posmask; /* for what parts of speech it is defined */
char *label; /* text for search header message */
void (*tracer) (SynsetPtr);
void (*printer) (struct wn_option *, SynsetPtr, struct result *,
dico_stream_t);
};
#define POS_MASK(n) bit(n)
#define PM_ALL 0xffffffff
static struct wn_option wn_optlist[] = {
{ "hypernym", HYPERPTR, POS_MASK(NOUN)|POS_MASK(VERB),
"Synonyms/Hypernyms (Ordered by Estimated Frequency)",
NULL, _wn_print_hypernym },
{ "synonym", },
#if 0
/* These are some thoughts only */
{ "similar", SIMPTR, POS_MASK(ADJ), "Similarity" },
{ "synonym", SYNS, POS_MASK(ADV), "Synonyms" },
{ "antonym", ANTPTR, PM_ALL, "Antonyms" },
{ "pertainym", PERTPTR, POS_MASK(ADV)|POS_MASK(ADV), "Pertainyms" },
{ "attribute", ATTRIBUTE, POS_MASK(NOUN)|POS_MASK(ADJ), "Attributes" },
{ "domain", CLASSIFICATION, PM_ALL, "Domain" },
{ "class", CLASS, PM_ALL, "Domain Terms" },
{ "familarity", FREQ, PM_ALL, "Familiarity" },
{ "hypernym", HYPERPTR, POS_MASK(NOUN)|POS_MASK(VERB),
"Synonyms/Hypernyms (Ordered by Estimated Frequency)" },
{ "hypernym/rec", -HYPERPTR, POS_MASK(NOUN)|POS_MASK(VERB),
"Synonyms/Hypernyms (Ordered by Estimated Frequency)" },
{ "hyponym", HYPOPTR, POS_MASK(NOUN)|POS_MASK(VERB), "Hyponyms" },
{ "hyponym/rec", -HYPOPTR, POS_MASK(NOUN), "Hyponyms" },
{ "holonym", HOLONYM, POS_MASK(NOUN), "Holonyms" },
{ "holonym/rec", -HHOLONYM, POS_MASK(NOUN), "Holonyms" },
{ "holonym/part", ISPARTPTR, POS_MASK(NOUN), "Part Holonyms" },
{ "holonym/member", ISMEMBERPTR, POS_MASK(NOUN), "Member Holonyms" },
{ "holonym/substance", ISSTUFFPTR, POS_MASK(NOUN), "Substance Holonyms" },
{ "meronym", MERONYM, POS_MASK(NOUN), "Meronyms" },
{ "meronym/rec", -HMERONYM, POS_MASK(NOUN), "Meronyms" },
{ "meronym/substance", HASSTUFFPTR, POS_MASK(NOUN), "Substance Meronyms" },
{ "meronym/part", HASPARTPTR, POS_MASK(NOUN), "Part Meronyms" },
{ "meronym/member", HASMEMBERPTR, POS_MASK(NOUN), "Member Meronyms" },
{ "derivation", DERIVATION, POS_MASK(NOUN)|POS_MASK(VERB),
"Derived Forms" },
{ "relatives", RELATIVES, POS_MASK(VERB),
"Synonyms (Grouped by Similarity of Meaning)" },
{ "coords", COORDS, POS_MASK(NOUN)|POS_MASK(VERB),
"Coordinate Terms (sisters)" },
{ "entail", ENTAILPTR, POS_MASK(VERB), "Entailment" },
{ "cause", CAUSETO, POS_MASK(VERB), "\'Cause To\'" },
{ "frames", FRAMES, POS_MASK(VERB), "Sample Sentences" },
#endif
{ NULL }
};
static struct wn_option *
find_option(const char *text)
{
struct wn_option *p;
for (p = wn_optlist; p->option; p++) {
if (strcmp(p->option, text) == 0)
return p;
}
return NULL;
}
static dico_handle_t
wn_init_db(const char *dbname, int argc, char **argv)
{
struct wndb *wndb;
int pos = 0;
int idx, i, j;
struct wn_option **optv;
int optc;
int flags = 0;
static struct wn_option overview[2] = {
{ "overview", OVERVIEW, PM_ALL, "Overview", NULL, _wn_print_overview },
{ "overview", OVERVIEW, PM_ALL, "Overview", NULL, _wn_print_definition }
};
struct dico_option init_db_option[] = {
{ DICO_OPTSTR(pos), dico_opt_enum, &pos, { .enumstr = pos_choice } },
{ DICO_OPTSTR(merge-defs), dico_opt_bool, &flags,
{ .value = WNDB_MERGE_DEFS } },
{ NULL }
};
if (dico_parseopt(init_db_option, argc, argv, DICO_PARSEOPT_PERMUTE,
&idx))
return NULL;
argc -= idx;
argv += idx;
optc = argc + 1;
optv = calloc(optc, sizeof(optv[0]));
if (!optv) {
DICO_LOG_ERRNO();
return NULL;
}
optv[0] = overview + ((flags & WNDB_MERGE_DEFS) ? 1 : 0);
for (i = 0, j = 1; i < argc; i++) {
struct wn_option *p;
if ((p = find_option(argv[i])) == NULL) {
dico_log(L_ERR, 0, _("wordnet: unknown option %s"), argv[i]);
free(optv);
return NULL;
}
while (p->search == 0 && p > wn_optlist)
p--;
if (!p->printer) {
dico_log(L_WARN, 0, _("wordnet: option %s is not yet supported"),
argv[i]);
continue;
}
optv[j] = p;
}
wndb = calloc(1, sizeof(*wndb));
if (!wndb) {
DICO_LOG_ERRNO();
free(optv);
return NULL;
}
wndb->dbname = strdup(dbname);
if (!wndb->dbname) {
DICO_LOG_ERRNO();
free(wndb);
return NULL;
}
wndb->flags = flags;
wndb->pos = pos_trans[pos];
wndb->optc = optc;
wndb->optv = optv;
return (dico_handle_t)wndb;
}
static char *
wn_descr(dico_handle_t hp)
{
return strdup("WordNet dictionary");
}
static char *
wn_info(dico_handle_t hp)
{
return strdup(license);
}
static int
wn_lang(dico_handle_t hp, dico_list_t list[2])
{
if ((list[0] = dico_list_create()) == NULL)
return -1;
if ((list[1] = dico_list_create()) == NULL) {
dico_list_destroy(&list[0]);
return -1;
}
dico_list_append(list[0], strdup("en"));
dico_list_append(list[1], strdup("en"));
return 0;
}
struct wordbuf {
char *word;
size_t len;
size_t size;
};
#define WORDBUFINC 16
#define INIT_WORDBUF { NULL, 0, 0 }
#define wordbuf_start(wb) ((wb)->len=0)
static int
wordbuf_expand(struct wordbuf *wb, size_t len)
{
if (len >= wb->size) {
size_t size = ((len + WORDBUFINC - 1) / WORDBUFINC ) * WORDBUFINC;
char *newword = realloc(wb->word, size);
if (!newword) {
DICO_LOG_ERRNO();
return 1;
}
wb->word = newword;
wb->size = size;
}
return 0;
}
static int
wordbuf_grow(struct wordbuf *wb, int c)
{
if (wordbuf_expand(wb, wb->len + 1))
return 1;
wb->word[wb->len++] = c;
return 0;
}
static int
wordbuf_finish(struct wordbuf *wb)
{
if (wordbuf_expand(wb, wb->len + 1))
return 1;
wb->word[wb->len] = 0;
return 0;
}
static void
wordbuf_reverse(struct wordbuf *wb)
{
int i, j;
if (wb->len == 0)
return;
for (i = 0, j = wb->len - 1; i < j; i++, j--) {
int c = wb->word[j];
wb->word[j] = wb->word[i];
wb->word[i] = c;
}
}
enum result_type {
result_match,
result_define
};
struct defn {
int pos; /* Part of speach */
SynsetPtr *synset; /* wndb->optc elements, first one always being
the overview. */
};
struct result {
enum result_type type;
size_t compare_count;
struct wndb *wndb;
dico_list_t list;
dico_iterator_t itr;
/* For definitions only: */
char *searchword;
dico_list_t rootlist; /* List of root synsets */
};
static int
free_defn(void *item, void *data)
{
struct defn *dp = item;
free(dp->synset);
free(dp);
return 0;
}
static int
free_root_synset(void *item, void *data)
{
free_syns(item);
return 0;
}
static int
free_string(void *item, void *data)
{
free(item);
return 0;
}
static int
compare_words(const void *a, const void *b, void *closure)
{
return utf8_strcasecmp((char*)a, (char*)b);
}
static struct result *
wn_create_match_result(struct wndb *wndb)
{
struct result *res;
res = calloc(1, sizeof(*res));
if (!res) {
DICO_LOG_ERRNO();
return NULL;
}
res->type = result_match;
res->wndb = wndb;
res->list = dico_list_create();
if (!res) {
DICO_LOG_ERRNO();
free(res);
return NULL;
}
dico_list_set_free_item(res->list, free_string, NULL);
dico_list_set_comparator(res->list, compare_words, NULL);
dico_list_set_flags(res->list, DICO_LIST_COMPARE_TAIL);
return res;
}
static struct result *
wn_create_define_result(struct wndb *wndb, const char *searchword)
{
struct result *res;
res = calloc(1, sizeof(*res));
if (!res) {
DICO_LOG_ERRNO();
return NULL;
}
res->type = result_define;
res->wndb = wndb;
res->list = dico_list_create();
if (!res) {
DICO_LOG_ERRNO();
free(res);
return NULL;
}
dico_list_set_free_item(res->list, free_defn, NULL);
res->searchword = strdup(searchword);
if (!res->searchword) {
DICO_LOG_ERRNO();
wn_free_result((dico_result_t) res);
}
res->rootlist = dico_list_create();
if (!res->rootlist) {
DICO_LOG_ERRNO();
wn_free_result((dico_result_t) res);
}
dico_list_set_free_item(res->rootlist, free_root_synset, NULL);
return res;
}
static int
wn_match_result_add(struct result *res, const char *hw)
{
int rc;
char *s = strdup(hw);
if (!s) {
DICO_LOG_ERRNO();
return -1;
}
rc = dico_list_insert_sorted(res->list, s);
if (rc) {
free(s);
if (rc != EEXIST) {
DICO_LOG_MEMERR();
return -1;
}
}
return 0;
}
static void
skipeol(FILE *fp)
{
int c;
while ((c = getc(fp)) != '\n' && c != EOF)
;
}
static void
skipheader(FILE *fp)
{
int c;
while ((c = getc(fp)) == ' ')
skipeol(fp);
ungetc(c, fp);
}
static int
getword(FILE *fp, struct wordbuf *wb)
{
int c;
size_t i;
wordbuf_start(wb);
while ((c = getc(fp)) != EOF) {
if (c == ' ')
break;
if (wordbuf_grow(wb, c))
return -1;
}
if (wb->len == 0 && c == EOF)
return -1;
if (wordbuf_finish(wb))
return -1;
for (i = 0; wb->word[i]; i++)
if (wb->word[i] == '_')
wb->word[i] = ' ';
return 0;
}
static int
lineback(FILE *fp, struct wordbuf *wb)
{
int c, i;
wordbuf_start(wb);
while (fseek(fp, -2, SEEK_CUR) == 0) {
if ((c = getc(fp)) == '\n')
break;
if (wordbuf_grow(wb, c))
return -1;
}
if (wordbuf_finish(wb))
return -1;
wordbuf_reverse(wb);
for (i = 0; wb->word[i]; i++) {
if (wb->word[i] == ' ')
break;
else if (wb->word[i] == '_')
wb->word[i] = ' ';
}
return 0;
}
static int
wn_is_defined(struct wndb *wndb, char *searchword)
{
int i, j;
unsigned int search;
for (i = 1; i <= NUMPARTS; i++) {
if ((search = is_defined(searchword, i)) != 0) {
for (j = 0; j < wndb->optc; j++) {
int n;
if (!(POS_MASK(i) & wndb->optv[j]->posmask))
continue;
n = wndb->optv[j]->search;
if (n < 0)
n = -n;
if (bit(n) & search)
return 1;
}
}
}
return 0;
}
static void
wn_foreach_db(struct wndb *wndb, int dbn, char *searchword,
struct dico_key *key, struct result *res)
{
FILE *fp = indexfps[dbn];
struct wordbuf wb = INIT_WORDBUF;
dico_iterator_t itr;
char *word;
fseek(fp, 0, SEEK_SET);
for (skipheader(fp); getword(fp, &wb) == 0; skipeol(fp)) {
res->compare_count++;
if (dico_key_match(key, wb.word)) {
if (wn_match_result_add(res, wb.word))
break;
}
}
free(wb.word);
itr = dico_list_iterator(res->list);
for (word = dico_iterator_first(itr); word;
word = dico_iterator_next(itr)) {
if (!wn_is_defined(wndb, word))
dico_iterator_remove_current(itr, NULL);
}
dico_iterator_destroy(&itr);
}
static struct result *
wn_foreach(struct wndb *wndb, const dico_strategy_t strat, const char *word)
{
struct result *res = wn_create_match_result(wndb);
struct dico_key key;
char *searchword;
searchword = strdup(word);
strtolower(strsubst(searchword, ' ', '_'));
if (!searchword) {
DICO_LOG_MEMERR();
wn_free_result((dico_result_t) res);
return NULL;
}
if (dico_key_init(&key, strat, word)) {
dico_log(L_ERR, 0, _("%s: key initialization failed"), __func__);
wn_free_result((dico_result_t) res);
free(searchword);
return NULL;
}
if (wndb->pos == ALL_POS) {
int i;
for (i = 1; i <= NUMPARTS; i++)
wn_foreach_db(wndb, i, searchword, &key, res);
} else
wn_foreach_db(wndb, wndb->pos, searchword, &key, res);
dico_key_deinit(&key);
free(searchword);
if (dico_list_count(res->list) == 0) {
wn_free_result((dico_result_t) res);
return NULL;
}
return res;
}
static off_t
wn_bsearch(FILE *fp, void *key, int (*cmp)(const char *a, void *b))
{
long top, mid, bot, diff;
struct wordbuf wb = INIT_WORDBUF;
off_t last_match = -1;
fseek(fp, 0L, SEEK_END);
top = 0;
bot = ftell(fp);
mid = (bot - top) / 2;
do {
fseek(fp, mid - 1, SEEK_SET);
if (mid != 1)
skipeol(fp);
if (getword(fp, &wb))
break;
if (cmp(wb.word, key) < 0) {
top = mid;
diff = (bot - top) / 2;
mid = top + diff;
} else if (cmp(wb.word, key) > 0) {
bot = mid;
diff = (bot - top) / 2;
mid = top + diff;
} else {
/* Move back until first non-matching headword is found */
do
last_match = ftell(fp);
while (lineback(fp, &wb) == 0 && cmp(wb.word, key) == 0);
break;
}
} while (diff);
free(wb.word);
return last_match;
}
static struct result *
wn_exact_match(struct wndb *db, const char *hw)
{
struct result *res;
if (!wn_is_defined(db, (char*)hw))
return NULL;
res = wn_create_match_result(db);
dico_list_append(res->list, strdup(hw));
return res;
}
struct prefix {
const char *str;
size_t len;
};
static int
cmp_pref(const char *hw, void *key)
{
struct prefix *pref = key;
return strncasecmp(hw, pref->str, pref->len);
}
static struct result *
wn_prefix_match(struct wndb *db, const char *hw)
{
struct result *res;
int i;
struct prefix pfx;
struct wordbuf wb = INIT_WORDBUF;
res = wn_create_match_result(db);
if (!res)
return NULL;
pfx.str = hw;
pfx.len = strlen(hw);
for (i = 1; i <= NUMPARTS; i++) {
FILE *fp = indexfps[i];
off_t off;
off = wn_bsearch(fp, &pfx, cmp_pref);
if (off != -1) {
fseek(fp, off, SEEK_SET);
for (;getword(fp, &wb) == 0 && cmp_pref(wb.word, &pfx) == 0;
skipeol(fp)) {
if (wn_match_result_add(res, wb.word))
break;
}
}
}
free(wb.word);
if (dico_list_count(res->list) == 0) {
wn_free_result((dico_result_t) res);
return NULL;
}
return res;
}
typedef struct result *(*wn_matcher_t)(struct wndb *db, const char *hw);
struct strategy_def {
struct dico_strategy strat;
wn_matcher_t matcher;
};
static struct strategy_def stratdef[] = {
{ { "exact", "Match words exactly" }, wn_exact_match },
{ { "prefix", "Match word prefixes" }, wn_prefix_match },
};
static wn_matcher_t
wn_find_matcher(const char *strat)
{
int i;
for (i = 0; i < DICO_ARRAY_SIZE(stratdef); i++)
if (strcmp(strat, stratdef[i].strat.name) == 0)
return stratdef[i].matcher;
return NULL;
}
static void
wn_register_strategies(void)
{
int i;
for (i = 0; i < DICO_ARRAY_SIZE(stratdef); i++)
dico_strategy_add(&stratdef[i].strat);
}
#define ISSPACE(c) ((c) == ' ' || (c) == '\t')
static char *
nornmalize_search_word(const char *word)
{
char *copy = NULL;
char *p;
const char *q;
copy = malloc(strlen(word) + 1);
if (!copy) {
DICO_LOG_ERRNO();
return NULL;
}
for (p = copy, q = word; *q; ) {
if (ISSPACE(*q)) {
*p++ = '_';
do
q++;
while (*q && ISSPACE(*q));
} else
*p++ = *q++;
}
*p = 0;
strtolower(copy);
return copy;
}
static dico_result_t
wn_match(dico_handle_t hp, const dico_strategy_t strat, const char *word)
{
struct wndb *wndb = (struct wndb *)hp;
wn_matcher_t match = wn_find_matcher(strat->name);
if (match)
return (dico_result_t) match(wndb, word);
else if (strat->sel)
return (dico_result_t) wn_foreach(wndb, strat, word);
return NULL;
}
static struct defn *
create_defn(struct wndb *wndb, int pos)
{
struct defn *p = malloc(sizeof(*p));
if (!p) {
DICO_LOG_ERRNO();
return NULL;
}
p->synset = calloc(wndb->optc, sizeof(p->synset[0]));
if (!p->synset) {
DICO_LOG_ERRNO();
free(p);
return NULL;
}
p->pos = pos;
return p;
}
static int
search_defns(struct wndb *wndb, int pos, struct result *res,
const char *searchword)
{
SynsetPtr sp;
int i;
struct defn *dp;
int sense = 0;
sp = findtheinfo_ds((char*)searchword, pos, OVERVIEW, ALLSENSES);
if (!sp)
return 0;
dico_list_append(res->rootlist, sp);
do {
dp = create_defn(wndb, pos);
if (!dp)
return 0;
dp->synset[0] = sp;
++sense;
for (i = 1; i < wndb->optc; i++) {
SynsetPtr ssp;
if (!(POS_MASK(pos) & wndb->optv[i]->posmask))
continue;
ssp = findtheinfo_ds((char*)searchword, pos, wndb->optv[i]->search,
sense);
if (ssp)
dp->synset[i] = ssp;
}
dico_list_append(res->list, dp);
} while ((sp = sp->nextss));
return 1;
}
static dico_result_t
wn_define(dico_handle_t hp, const char *word)
{
struct wndb *wndb = (struct wndb *)hp;
struct result *res;
int i;
int found = 0;
char *copy;
res = wn_create_define_result(wndb, word);
copy = nornmalize_search_word(word);
if (!copy) {
wn_free_result((dico_result_t) res);
return NULL;
}
res->wndb = wndb;
res->type = result_define;
if (wndb->pos == ALL_POS) {
for (i = 1; i <= NUMPARTS; i++)
found += search_defns(wndb, i, res, copy);
} else
found = search_defns(wndb, wndb->pos, res, copy);
if (!found) {
free(copy);
wn_free_result((dico_result_t) res);
return NULL;
}
free(copy);
return (dico_result_t)res;
}
static void
format_word(const char *word, dico_stream_t str)
{
for (;;) {
size_t len = strcspn(word, "_");
dico_stream_write(str, word, len);
if (word[len] == 0)
break;
dico_stream_write(str, " ", 1);
word += len + 1;
}
}
static void
format_defn_string(const char *defn, dico_stream_t str)
{
size_t len = strlen(defn);
if (len == 0)
return;
if (defn[0] == '(' && defn[len-1] == ')') {
defn++;
len -= 2;
}
dico_stream_write(str, defn, len);
dico_stream_write(str, "\n", 1);
}
static void
_wn_print_overview(struct wn_option *opt, SynsetPtr sp, struct result *res,
dico_stream_t str)
{
int i;
/* Print words: */
for (i = 0; i < sp->wcount; i++) {
if (i)
dico_stream_write(str, ", ", 2);
format_word(sp->words[i], str);
}
/* Print pos */
dico_stream_write(str, "; ", 2);
dico_stream_write(str, sp->pos, strlen(sp->pos));
dico_stream_write(str, ".\n\n", 3);
/* Print definition */
format_defn_string(sp->defn, str);
}
static void
_wn_print_definition(struct wn_option *opt, SynsetPtr sp, struct result *res,
dico_stream_t str)
{
/* Print definition */
format_defn_string(sp->defn, str);
if (sp->wcount > 1) {
int i, j;
static char const *sym = "Synonyms: ";
dico_stream_write(str, sym, strlen(sym));
for (i = j = 0; i < sp->wcount; i++) {
if (strcmp(sp->words[i], res->searchword) == 0)
continue;
if (j)
dico_stream_write(str, ", ", 2);
dico_stream_write(str, "{", 1);
format_word(sp->words[i], str);
dico_stream_write(str, "}", 1);
j++;
}
dico_stream_write(str, "\n", 1);
}
}
static void
_wn_print_hypernym(struct wn_option *opt, SynsetPtr ptr, struct result *res,
dico_stream_t str)
{
int i;
SynsetPtr sp;
dico_stream_write(str, opt->label, strlen(opt->label));
dico_stream_write(str, ":\n\n", 3);
for (sp = ptr->ptrlist; sp; sp = sp->nextss) {
for (i = 0; i < sp->wcount; i++) {
if (i)
dico_stream_write(str, ", ", 2);
format_word(sp->words[i], str);
}
dico_stream_write(str, "\n", 1);
}
}
static int
format_defn(struct defn *defn, struct result *res, dico_stream_t str)
{
int i;
struct wndb *wndb = res->wndb;
for (i = 0; i < wndb->optc; i++)
wndb->optv[i]->printer(wndb->optv[i], defn->synset[i], res, str);
return 0;
}
static void
print_num(dico_stream_t str, unsigned num)
{
char buf[128];
char *p = buf + sizeof(buf);
*--p = 0;
while (p > buf && num) {
*--p = num % 10 + '0';
num /= 10;
}
dico_stream_write(str, p, strlen(p));
dico_stream_write(str, ". ", 2);
}
static void
format_all_defns(struct result *res, dico_stream_t str)
{
struct defn *defn;
int pos = 0;
unsigned num;
format_word(res->searchword, str);
dico_stream_write(str, "\n", 1);
for (defn = dico_iterator_first(res->itr); defn;
defn = dico_iterator_next(res->itr)) {
if (defn->pos != pos) {
pos = defn->pos;
num = 1;
dico_stream_write(str, defn->synset[0]->pos,
strlen(defn->synset[0]->pos));
dico_stream_write(str, ". ", 2);
}
print_num(str, num);
format_defn(defn, res, str);
num++;
}
}
int
wn_output_result(dico_result_t rp, size_t n, dico_stream_t str)
{
struct result *res = (struct result *) rp;
void *item;
if (!res->itr) {
res->itr = dico_list_iterator(res->list);
if (!res->itr)
return 1;
}
item = dico_iterator_item(res->itr, n);
switch (res->type) {
case result_match:
dico_stream_write(str, item, strlen((char*)item));
break;
case result_define:
if (res->wndb->flags & WNDB_MERGE_DEFS)
format_all_defns(res, str);
else
format_defn(item, res, str);
break;
default:
return 1;
}
return 0;
}
static size_t
wn_result_count (dico_result_t rp)
{
struct result *res = (struct result *) rp;
if (res->type == result_define && (res->wndb->flags & WNDB_MERGE_DEFS))
return 1;
return dico_list_count(res->list);
}
static size_t
wn_compare_count (dico_result_t rp)
{
struct result *res = (struct result *) rp;
return res->compare_count;
}
static void
wn_free_result(dico_result_t rp)
{
struct result *res = (struct result *) rp;
dico_list_destroy(&res->list);
dico_iterator_destroy(&res->itr);
dico_list_destroy(&res->rootlist);
free(res->searchword);
free(res);
}
struct dico_database_module DICO_EXPORT(wordnet, module) = {
DICO_MODULE_VERSION,
DICO_CAPA_NONE,
wn_init,
wn_init_db,
wn_free_db,
NULL,
NULL,
wn_info,
wn_descr,
wn_lang,
wn_match,
wn_define,
wn_output_result,
wn_result_count,
wn_compare_count,
wn_free_result
};