/* 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 . */ /* This module provides support for databases in Emacs outline format. It is intended to work as a testbed for Dico's database module system. Do not use it in production environment. An outline database has the following structure: * Description * Info * Languages [...] [: [...]] * MIME
: [
: ...] * Dictionary ** [any number of entries follows] Any other text is ignored. To use this module, add the following to your dictd.conf file: handler outline { type loadable; command "outline"; } database { handler "outline "; ... } */ #include #include #include #include #include #include #include #include #include static size_t compare_count; struct entry { char *word; /* Word */ size_t length; /* Its length in bytes */ size_t wordlen; /* Its length in characters */ off_t offset; /* Offset of the corresponding article in file */ size_t size; /* Size of the article */ struct entry *peer; }; struct outline_file { char *name; FILE *fp; size_t count; struct entry *index; struct entry *suf_index; struct entry *info_entry, *descr_entry, *lang_entry, *mime_entry; }; #define STATE_INITIAL 0 #define STATE_DICT 1 static size_t trimnl(char *buf) { size_t len = strlen(buf); if (len > 0 && buf[len - 1] == '\n') buf[--len] = 0; return len; } static size_t trimws(char *buf) { size_t len = strlen(buf); while (len > 0 && isspace(buf[len - 1])) buf[--len] = 0; return len; } static int find_header(struct outline_file *file, char *buf, size_t size, size_t *pread) { while (fgets(buf, size, file->fp)) { size_t rdbytes = strlen(buf); size_t len = trimnl(buf); if (len > 0) { int level; for (level = 0; buf[level] == '*' && level < len; level++) ; if (level) { *pread = rdbytes; return level; } } } return 0; } static off_t skipws(struct outline_file *file, char *buf, size_t size) { while (fgets(buf, size, file->fp)) { size_t len = strlen(buf); if (!(len == 1 && buf[0] == '\n')) { fseek(file->fp, -(off_t)len, SEEK_CUR); break; } } return ftell(file->fp); } static struct entry * alloc_entry(const char *text, size_t len) { struct entry *ep = malloc(sizeof(*ep)); if (ep) { memset(ep, 0, sizeof(*ep)); ep->word = malloc(len + 1); if (!ep->word) { free(ep); return NULL; } memcpy(ep->word, text, len); ep->word[len] = 0; ep->length = len; ep->wordlen = utf8_strlen(ep->word); } return ep; } static struct entry * read_entry(struct outline_file *file, int *plevel) { char buf[128], *p; struct entry *ep; int level; size_t rdbytes, len; level = find_header(file, buf, sizeof(buf), &rdbytes); if (level == 0) return NULL; *plevel = level; for (p = buf + level; *p && isspace(*p); p++) ; len = trimws(p); ep = alloc_entry(p, len); if (!ep) return NULL; ep->offset = skipws(file, buf, sizeof(buf)); find_header(file, buf, sizeof(buf), &rdbytes); fseek(file->fp, -(off_t)rdbytes, SEEK_CUR); ep->size = ftell(file->fp) - ep->offset; return ep; } enum result_type { result_match, result_match_list, result_define }; struct result { struct outline_file *file; enum result_type type; size_t count; size_t compare_count; union { const struct entry *ep; dico_list_t list; } v; }; typedef int (*entry_match_t) (struct outline_file *file, const char *word, struct result *res); struct strategy_def { struct dico_strategy strat; entry_match_t match; }; static int exact_match(struct outline_file *, const char *, struct result *); static int prefix_match(struct outline_file *, const char *, struct result *); static int suffix_match(struct outline_file *file, const char *word, struct result *res); static struct strategy_def strat_tab[] = { { { "exact", "Match words exactly" }, exact_match }, { { "prefix", "Match word prefixes" }, prefix_match }, { { "suffix", "Match word suffixes" }, suffix_match } }; static entry_match_t find_matcher(const char *strat) { int i; for (i = 0; i < DICO_ARRAY_SIZE(strat_tab); i++) if (strcmp(strat, strat_tab[i].strat.name) == 0) return strat_tab[i].match; return NULL; } static int outline_init(int argc, char **argv) { int i; for (i = 0; i < DICO_ARRAY_SIZE(strat_tab); i++) dico_strategy_add(&strat_tab[i].strat); return 0; } static int compare_entry(const void *a, const void *b) { const struct entry *epa = a; const struct entry *epb = b; compare_count++; return utf8_strcasecmp(epa->word, epb->word); } static void revert_word(char *dst, const char *src, size_t len) { struct utf8_iterator itr; char *p = dst + len; *p = 0; for (utf8_iter_init(&itr, (char *)src, len); !utf8_iter_end_p(&itr); utf8_iter_next(&itr)) { p -= itr.curwidth; if (p < dst) break; memcpy(p, itr.curptr, itr.curwidth); } } static int init_suffix_index(struct outline_file *file) { if (!file->suf_index) { size_t i; file->suf_index = calloc(file->count, sizeof(file->suf_index[0])); if (!file->suf_index) return 1; for (i = 0; i < file->count; i++) { char *p = malloc(file->index[i].length + 1); if (!p) { while (i > 0) free(file->suf_index[--i].word); free(file->suf_index); return 1; } revert_word(p, file->index[i].word, file->index[i].length); file->suf_index[i] = file->index[i]; file->suf_index[i].word = p; file->suf_index[i].peer = &file->index[i]; } } qsort(file->suf_index, file->count, sizeof(file->suf_index[0]), compare_entry); compare_count = 0; return 0; } static int exact_match(struct outline_file *file, const char *word, struct result *res) { struct entry x, *ep; x.word = (char*) word; x.length = strlen(word); x.wordlen = utf8_strlen(word); ep = bsearch(&x, file->index, file->count, sizeof(file->index[0]), compare_entry); if (ep) { res->type = result_match; res->v.ep = ep; res->count = 1; return 0; } return 1; } static int compare_prefix(const void *a, const void *b) { const struct entry *pkey = a; const struct entry *pelt = b; size_t wordlen = pkey->wordlen; if (pelt->wordlen < wordlen) wordlen = pelt->wordlen; compare_count++; return utf8_strncasecmp(pkey->word, pelt->word, wordlen); } static int prefix_match(struct outline_file *file, const char *word, struct result *res) { struct entry x, *ep; x.word = (char*) word; x.length = strlen(word); x.wordlen = utf8_strlen(word); ep = bsearch(&x, file->index, file->count, sizeof(file->index[0]), compare_prefix); if (ep) { size_t count = 1; struct entry *p; for (p = ep - 1; p > file->index && compare_prefix(&x, p) == 0; p--) count++; for (ep++; ep < file->index + file->count && compare_prefix(&x, ep) == 0; ep++) count++; res->type = result_match; res->v.ep = p + 1; res->count = count; return 0; } return 1; } static int compare_entry_ptr(const void *a, const void *b) { struct entry *const *epa = a; struct entry *const *epb = b; compare_count++; return utf8_strcasecmp((*epa)->word, (*epb)->word); } static int suffix_match(struct outline_file *file, const char *word, struct result *res) { struct entry x, *ep; int rc; if (init_suffix_index(file)) { dico_log(L_ERR, 0, "not enough memory"); return 1; } x.length = strlen(word); x.word = malloc(x.length + 1); if (!x.word) { dico_log(L_ERR, 0, "not enough memory"); return 1; } x.wordlen = utf8_strlen(word); revert_word(x.word, word, x.length); ep = bsearch(&x, file->suf_index, file->count, sizeof(file->suf_index[0]), compare_prefix); if (ep) { struct entry *p, **epp; size_t count = 1; for (p = ep - 1; p > file->suf_index && compare_prefix(&x, p) == 0; p--) count++; for (ep++; ep < file->suf_index + file->count && compare_prefix(&x, ep) == 0; ep++) count++; p++; epp = calloc(count, sizeof(*epp)); if (!epp) { dico_log(L_ERR, 0, "not enough memory"); rc = 1; } else { res->type = result_match_list; res->v.list = dico_list_create(); if (!res->v.list) { dico_log(L_ERR, 0, "not enough memory"); rc = 1; } else { size_t i; for (i = 0; i < count; i++) epp[i] = p[i].peer; qsort(epp, count, sizeof(epp[0]), compare_entry_ptr); for (i = 0; i < count; i++) dico_list_append(res->v.list, epp[i]); res->count = dico_list_count(res->v.list); rc = 0; } free(epp); } } else rc = 1; free(x.word); return rc; } static int outline_free_db (dico_handle_t hp) { size_t i; struct outline_file *file = (struct outline_file *) hp; fclose(file->fp); free(file->name); free(file->info_entry); free(file->descr_entry); free(file->lang_entry); free(file->mime_entry); for (i = 0; i < file->count; i++) { free(file->index[i].word); if (file->suf_index) free(file->suf_index[i].word); } free(file->index); free(file->suf_index); free(file); return 0; } static dico_handle_t outline_init_db(const char *dbname, int argc, char **argv) { FILE *fp; struct outline_file *file; dico_list_t list; struct entry *ep; int level; int state; size_t i, count; dico_iterator_t itr; if (argc != 2) { dico_log(L_ERR, 0, _("outline_open: wrong number of arguments")); return NULL; } fp = fopen(argv[1], "r"); if (!fp) { dico_log(L_ERR, errno, _("cannot open file %s"), argv[1]); return NULL; } file = malloc(sizeof(*file)); if (!file) { dico_log(L_ERR, 0, "not enough memory"); fclose(fp); return NULL; } memset(file, 0, sizeof(*file)); file->name = strdup(argv[1]); file->fp = fp; list = dico_list_create(); if (!list) { dico_log(L_ERR, 0, "not enough memory"); fclose(fp); free(file); return NULL; } state = STATE_INITIAL; while ((ep = read_entry(file, &level))) { switch (state) { case STATE_DICT: if (level == 2) { dico_list_append(list, ep); break; } else if (level == 1) { state = STATE_INITIAL; /* FALL THROUGH */ } else { free(ep); break; } case STATE_INITIAL: if (level == 1) { if (strcasecmp(ep->word, "info") == 0) { file->info_entry = ep; break; } else if (strcasecmp(ep->word, "description") == 0) { file->descr_entry = ep; break; } else if (strcasecmp(ep->word, "languages") == 0) { file->lang_entry = ep; break; } else if (strcasecmp(ep->word, "mime") == 0) { file->mime_entry = ep; break; } else if (strcasecmp(ep->word, "dictionary") == 0) state = STATE_DICT; } free(ep); break; } } file->count = count = dico_list_count(list); file->index = calloc(count, sizeof(file->index[0])); if (!file->index) { dico_log(L_ERR, 0, "not enough memory"); outline_free_db((dico_handle_t)file); return NULL; } itr = dico_list_iterator(list); for (i = 0, ep = dico_iterator_first(itr); ep; i++, ep = dico_iterator_next(itr)) { file->index[i] = *ep; free(ep); } dico_iterator_destroy(&itr); dico_list_destroy(&list); qsort(file->index, count, sizeof(file->index[0]), compare_entry); return (dico_handle_t) file; } static inline int isws(int c) { return c == ' ' || c == '\t' || c == '\r' || c == '\f'; } static char * read_buf(struct outline_file *file, struct entry *ep, int trim) { size_t size; char *buf = malloc(ep->size + 1); if (!buf) return NULL; fseek(file->fp, ep->offset, SEEK_SET); size = fread(buf, 1, ep->size, file->fp); if (trim && size > 0 && buf[size-1] == '\n') { while (size > 0 && buf[size-1] == '\n') { --size; while (size > 0 && isws(buf[size-1])) --size; } buf[size++] = '\n'; } buf[size] = 0; return buf; } static char * outline_info(dico_handle_t hp) { struct outline_file *file = (struct outline_file *) hp; if (file->info_entry) return read_buf(file, file->info_entry, 0); return NULL; } static char * outline_descr(dico_handle_t hp) { struct outline_file *file = (struct outline_file *) hp; if (file->descr_entry) { char *buf = read_buf(file, file->descr_entry, 0); char *p = strchr(buf, '\n'); if (p) *p = 0; return buf; } return NULL; } static int outline_lang(dico_handle_t hp, dico_list_t list[2]) { struct outline_file *file = (struct outline_file *) hp; list[0] = list[1] = NULL; if (file->lang_entry) { int n = 0; struct wordsplit ws; char *buf = read_buf(file, file->lang_entry, 0); ws.ws_delim = "\n"; if (wordsplit(buf, &ws, WRDSF_DEFFLAGS|WRDSF_DELIM) == 0) { if (ws.ws_wordc) { int i; for (i = 0; i < ws.ws_wordc; i++) { if (n == 0 && strcmp(ws.ws_wordv[i], ":") == 0) { n = 1; free(ws.ws_wordv[i]); } else { if (!list[n]) list[n] = dico_list_create(); dico_list_append(list[n], ws.ws_wordv[i]); } } } ws.ws_wordc = 0; wordsplit_free(&ws); } else { dico_log(L_ERR, 0, _("outline_lang: not enough memory")); return 1; } } return 0; } static dico_result_t outline_match0(dico_handle_t hp, entry_match_t match, const char *word) { struct outline_file *file = (struct outline_file *) hp; struct result *res; compare_count = 0; res = malloc(sizeof(*res)); if (!res) return NULL; res->file = file; if (match(file, word, res)) { free(res); res = NULL; } else res->compare_count = compare_count; return (dico_result_t) res; } static dico_result_t outline_match_all(dico_handle_t hp, dico_strategy_t strat, const char *word) { struct outline_file *file = (struct outline_file *) hp; dico_list_t list; size_t count, i; struct result *res; struct dico_key key; list = dico_list_create(); if (!list) { dico_log(L_ERR, 0, _("outline_match_all: not enough memory")); return NULL; } if (dico_key_init(&key, strat, word)) { dico_log(L_ERR, 0, _("outline_match_all: key initialization failed")); return NULL; } for (i = 0; i < file->count; i++) { if (dico_key_match(&key, file->index[i].word)) dico_list_append(list, &file->index[i]); } dico_key_deinit(&key); compare_count = file->count; count = dico_list_count(list); if (count == 0) { dico_list_destroy(&list); return NULL; } res = malloc(sizeof(*res)); if (!res) return NULL; res->file = file; res->type = result_match_list; res->count = count; res->v.list = list; res->compare_count = compare_count; return (dico_result_t) res; } static dico_result_t outline_match(dico_handle_t hp, const dico_strategy_t strat, const char *word) { entry_match_t match = find_matcher(strat->name); if (match) return outline_match0(hp, match, word); else if (strat->sel) return outline_match_all(hp, strat, word); return NULL; } static dico_result_t outline_define(dico_handle_t hp, const char *word) { struct outline_file *file = (struct outline_file *) hp; struct result *res; compare_count = 0; res = malloc(sizeof(*res)); if (!res) return NULL; res->file = file; if (exact_match(file, word, res)) { free(res); res = NULL; } else { res->type = result_define; res->compare_count = compare_count; } return (dico_result_t) res; } static void printdef(dico_stream_t str, struct outline_file *file, const struct entry *ep) { FILE *fp = file->fp; size_t size = ep->size; char buf[128]; fseek(fp, ep->offset, SEEK_SET); while (size) { size_t rdsize = size; if (rdsize > sizeof(buf)) rdsize = sizeof(buf); rdsize = fread(buf, 1, rdsize, fp); if (rdsize == 0) break; dico_stream_write(str, buf, rdsize); size -= rdsize; } } static int outline_output_result (dico_result_t rp, size_t n, dico_stream_t str) { struct result *res = (struct result *) rp; const struct entry *ep; switch (res->type) { case result_match: ep = res->v.ep + n; dico_stream_write(str, ep->word, strlen(ep->word)); break; case result_match_list: ep = dico_list_item(res->v.list, n); dico_stream_write(str, ep->word, strlen(ep->word)); break; case result_define: ep = res->v.ep + n; printdef(str, res->file, ep); } return 0; } static size_t outline_result_count (dico_result_t rp) { struct result *res = (struct result *) rp; return res->count; } static size_t outline_compare_count (dico_result_t rp) { struct result *res = (struct result *) rp; return res->compare_count; } static void outline_free_result(dico_result_t rp) { struct result *res = (struct result *) rp; if (res->type == result_match_list) dico_list_destroy(&res->v.list); free(rp); } static char * outline_db_mime_header(dico_handle_t hp) { struct outline_file *file = (struct outline_file *) hp; if (file->mime_entry) return read_buf(file, file->mime_entry, 1); return NULL; } struct dico_database_module DICO_EXPORT(outline, module) = { .dico_version = DICO_MODULE_VERSION, .dico_capabilities = DICO_CAPA_NONE, .dico_init = outline_init, .dico_init_db = outline_init_db, .dico_free_db = outline_free_db, .dico_db_info = outline_info, .dico_db_descr = outline_descr, .dico_db_lang = outline_lang, .dico_match = outline_match, .dico_define = outline_define, .dico_output_result = outline_output_result, .dico_result_count = outline_result_count, .dico_compare_count = outline_compare_count, .dico_free_result = outline_free_result, .dico_db_mime_header = outline_db_mime_header };