Re-organize the set of database function calls.

8 files changed, 308 insertions, 236 deletions

diff --git a/dicod/Makefile.am b/dicod/Makefile.am
index 2cde352..d21d2bc 100644
--- a/dicod/Makefile.am
+++ b/dicod/Makefile.am
@@ -25,6 +25,7 @@ dicod_SOURCES=\
  ckpass.c\
  cmdline.c\
  commands.c\
+ database.c\
  dbtext.c\
  dicod.c\
  gsasl.c\
diff --git a/dicod/commands.c b/dicod/commands.c
index 605d1f0..1fa7655 100644
--- a/dicod/commands.c
+++ b/dicod/commands.c
@@ -65,12 +65,12 @@ dicod_show_info(dico_stream_t str, int argc, char **argv)
 	stream_writez(str, "550 invalid database, use SHOW DB for a list\n");
     else {
 	dico_stream_t ostr;
-	char *info = dicod_get_database_info(dict);
+	char *info = dicod_database_get_info(dict);
 	stream_printf(str, "112 information for %s\n", dbname);
 	ostr = dicod_ostream_create(str, NULL);
 	if (info) {
 	    stream_write_multiline(ostr, info);
-	    dicod_free_database_info(dict, info);
+	    dicod_database_free_info(dict, info);
 	} else
 	    stream_writez(ostr, "No information available.\n");
 	stream_writez(ostr, "\n");
@@ -87,13 +87,13 @@ _show_database(void *item, void *data)
 {
     dicod_database_t *dict = item;
     dico_stream_t str = data;
-    char *descr = dicod_get_database_descr(dict);
+    char *descr = dicod_database_get_descr(dict);
     char *pdescr;
 
     if (utf8_quote(descr ? descr : "", &pdescr))
 	xalloc_die();
     stream_printf(str, "%s \"%s\"\n", dict->name, pdescr);
-    dicod_free_database_descr(dict, descr);
+    dicod_database_free_descr(dict, descr);
     free(pdescr);
     return 0;
 }
diff --git a/dicod/database.c b/dicod/database.c
new file mode 100644
index 0000000..0c9dc66
--- /dev/null
+++ b/dicod/database.c
@@ -0,0 +1,230 @@
+/* This file is part of GNU Dico.
+   Copyright (C) 1998-2018 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 <http://www.gnu.org/licenses/>. */
+
+#include <dicod.h>
+
+int
+dicod_database_init(dicod_database_t *db)
+{
+    dicod_module_instance_t *inst = db->instance;
+
+    if (inst->module->dico_capabilities & DICO_CAPA_NODB) {
+	dico_log(L_ERR, 0, _("cannot initialize database `%s': "
+			     "module `%s' does not support databases"),
+		 db->command, inst->ident);
+	return 1;
+    }
+    
+    if (inst->module->dico_init_db) {
+	db->mod_handle = inst->module->dico_init_db(db->name,
+						     db->argc,
+						     db->argv);
+	if (!db->mod_handle) {
+	    dico_log(L_ERR, 0, _("cannot initialize database `%s'"),
+		     db->command);
+	    return 1;
+	}
+    }
+    return 0;
+}
+
+int
+dicod_database_open(dicod_database_t *db)
+{
+    dicod_module_instance_t *inst = db->instance;
+
+    if (inst->module->dico_open) {
+	if (inst->module->dico_open(db->mod_handle)) {
+	    dico_log(L_ERR, 0, _("cannot open database `%s'"),
+		     db->command);
+	    return 1;
+	}
+    }
+
+    if (!db->mime_headers
+	&& inst->module->dico_version > 2
+	&& inst->module->dico_db_mime_header) {
+	char *str = inst->module->dico_db_mime_header(db->mod_handle);
+	if (str) {
+	    if (dico_header_parse(&db->mime_headers, str)) {
+		dico_log(L_WARN, errno,
+			 "database %s: can't parse mime headers \"%s\"",
+			 db->name,
+			 str);
+	    }
+	    free(str);
+	}
+    }
+
+    return 0;
+}
+
+int
+dicod_database_close(dicod_database_t *db)
+{
+    int rc = 0;
+    
+    if (db->mod_handle) {
+	dicod_module_instance_t *inst = db->instance;
+	if (inst->module->dico_close) 
+	    rc = inst->module->dico_close(db->mod_handle);
+    }
+    return rc;
+}
+
+int
+dicod_database_deinit(dicod_database_t *db)
+{
+    int rc = 0;
+    
+    if (db->mod_handle) {
+	dicod_module_instance_t *inst = db->instance;
+	if (inst->module->dico_free_db) {
+	    rc = inst->module->dico_free_db(db->mod_handle);
+	    db->mod_handle = NULL;
+	}
+    }
+    return rc;
+}
+
+char *
+dicod_database_get_descr(dicod_database_t *db)
+{
+    if (db->descr)
+	return db->descr;
+    else {
+	dicod_module_instance_t *inst = db->instance;
+	if (inst->module->dico_db_descr)
+	    return inst->module->dico_db_descr(db->mod_handle);
+    }
+    return NULL;
+}
+
+void
+dicod_database_free_descr(dicod_database_t *db, char *descr)
+{
+    if (descr && descr != db->descr)
+	free(descr);
+}
+
+char *
+dicod_database_get_info(dicod_database_t *db)
+{
+    if (db->info)
+	return db->info;
+    else {
+	dicod_module_instance_t *inst = db->instance;
+	if (inst->module->dico_db_info)
+	    return inst->module->dico_db_info(db->mod_handle);
+    }
+    return NULL;
+}
+
+void
+dicod_database_free_info(dicod_database_t *db, char *info)
+{
+    if (info && info != db->info)
+	free(info);
+}
+
+void
+dicod_database_get_languages(dicod_database_t *db, dico_list_t dlist[])
+{
+    if (!(db->flags & DICOD_DBF_LANG)) {
+	dicod_module_instance_t *inst = db->instance;
+	if (inst->module->dico_db_lang) {
+	    /* FIXME: Return code? */
+	    inst->module->dico_db_lang(db->mod_handle, db->langlist);
+	    if (db->langlist[0] || db->langlist[1]) {		
+		if (!db->langlist[0])
+		    db->langlist[0] = dicod_langlist_copy(db->langlist[1]);
+		else if (!db->langlist[1])
+		    db->langlist[1] = dicod_langlist_copy(db->langlist[0]);
+	    }
+	    if (dicod_any_lang_list_p(db->langlist[0]))
+		dico_list_destroy(&db->langlist[0]);
+	    if (dicod_any_lang_list_p(db->langlist[1]))
+		dico_list_destroy(&db->langlist[1]);
+	}
+	db->flags |= DICOD_DBF_LANG;
+    }
+    dlist[0] = db->langlist[0];
+    dlist[1] = db->langlist[1];
+}
+
+dico_result_t
+dicod_database_match(dicod_database_t *db, const dico_strategy_t strat,
+		     const char *word)
+{
+    struct dico_database_module *mod = db->instance->module;
+    return mod->dico_match(db->mod_handle, strat, word);
+}
+
+dico_result_t
+dicod_database_define(dicod_database_t *db, const char *word)
+{
+    struct dico_database_module *mod = db->instance->module;
+    return mod->dico_define(db->mod_handle, word);
+}
+
+// FIXME: dico_result_t should contain a pointer to db
+size_t
+dicod_database_result_count(dicod_database_t *db, dico_result_t res)
+{
+    return db->instance->module->dico_result_count(res);
+}
+
+// FIXME: See above
+size_t
+dicod_database_compare_count(dicod_database_t *db, dico_result_t res)
+{
+    struct dico_database_module *mod = db->instance->module;
+    return mod->dico_compare_count ? mod->dico_compare_count(res) : 0;
+}
+
+// FIXME: See above
+void
+dicod_database_result_free(dicod_database_t *db, dico_result_t res)
+{
+    struct dico_database_module *mod = db->instance->module;
+    mod->dico_free_result(res);
+}
+
+// FIXME: See above
+int
+dicod_database_result_output(dicod_database_t *db, dico_result_t res,
+			     size_t n, dico_stream_t str)
+{
+    struct dico_database_module *mod = db->instance->module;
+    return mod->dico_output_result(res, n, str);
+}
+
+dico_assoc_list_t
+dicod_database_mime_header(dicod_database_t *db, dico_result_t res)
+{
+    dico_assoc_list_t hdr = NULL;
+    struct dico_database_module *mod = db->instance->module;
+
+    if (db->mime_headers)
+	hdr = dico_assoc_dup(db->mime_headers);
+    else
+	dico_header_parse(&hdr, NULL);
+    
+    if (mod->dico_result_headers)
+	mod->dico_result_headers(res, hdr);
+
+    return hdr;
+}
diff --git a/dicod/dicod.c b/dicod/dicod.c
index 1d745a2..0f509be 100644
--- a/dicod/dicod.c
+++ b/dicod/dicod.c
@@ -115,7 +115,7 @@ init_databases(void)
     dicod_database_t *dp;
 
     for (dp = dico_iterator_first(itr); dp; dp = dico_iterator_next(itr)) {
-	if (dicod_init_database(dp)) {
+	if (dicod_database_init(dp)) {
 	    dico_log(L_NOTICE, 0, _("removing database %s"), dp->name);
 	    dico_iterator_remove_current(itr, NULL);
 	    dicod_database_free(dp);
@@ -131,7 +131,7 @@ open_databases(void)
     dicod_database_t *dp;
 
     for (dp = dico_iterator_first(itr); dp; dp = dico_iterator_next(itr)) {
-	if (dicod_open_database(dp)) {
+	if (dicod_database_open(dp)) {
 	    dico_log(L_NOTICE, 0, _("removing database %s"), dp->name);
 	    dico_iterator_remove_current(itr, NULL);
 	    dicod_database_free(dp);
@@ -147,7 +147,7 @@ close_databases(void)
     dicod_database_t *dp;
 
     for (dp = dico_iterator_first(itr); dp; dp = dico_iterator_next(itr)) {
-	if (dicod_close_database(dp))
+	if (dicod_database_close(dp))
 	    dico_log(L_NOTICE, 0, _("error closing database %s"), dp->name);
     }
     dico_iterator_destroy(&itr);
@@ -285,7 +285,7 @@ dicod_server_cleanup(void)
     dicod_database_t *dp;
 
     for (dp = dico_iterator_first(itr); dp; dp = dico_iterator_next(itr)) {
-	if (dicod_free_database(dp)) 
+	if (dicod_database_deinit(dp)) 
 	    dico_log(L_NOTICE, 0, _("error freeing database %s"), dp->name);
     }
     dico_iterator_destroy(&itr);
diff --git a/dicod/dicod.h b/dicod/dicod.h
index 2598d80..90ff520 100644
--- a/dicod/dicod.h
+++ b/dicod/dicod.h
@@ -196,7 +196,6 @@ int get_input_line(dico_stream_t str, char **buf, size_t *size,
 
 dicod_database_t *find_database(const char *name);
 void database_remove_dependent(dicod_module_instance_t *inst);
-void dicod_database_free(dicod_database_t *dp);
 size_t database_count(void);
 int database_iterate(dico_list_iterator_t fun, void *data);
 int show_sys_info_p(void);
@@ -273,18 +272,7 @@ void init_auth_data(void);
 /* loader.c */
 void dicod_loader_init(void);
 int dicod_load_module(dicod_module_instance_t *hptr);
-int dicod_init_database(dicod_database_t *dp);
-int dicod_open_database(dicod_database_t *dp);
-int dicod_close_database(dicod_database_t *dp);
-int dicod_free_database(dicod_database_t *dp);
-
-int dicod_database_get_strats(dicod_database_t *dp);
-
-char *dicod_get_database_descr(dicod_database_t *db);
-void dicod_free_database_descr(dicod_database_t *db, char *descr);
-char *dicod_get_database_info(dicod_database_t *db);
-void dicod_free_database_info(dicod_database_t *db, char *info);
-void dicod_get_database_languages(dicod_database_t *db, dico_list_t list[]);
+
 dico_list_t dicod_langlist_copy(dico_list_t src);
 
 void dicod_match_word_db(dicod_database_t *db, dico_stream_t stream,
@@ -300,6 +288,40 @@ void dicod_define_word_all(dico_stream_t stream, const char *word);
 
 int dicod_module_test(int argc, char **argv);
 
+/* database.c */
+int dicod_database_init(dicod_database_t *dp);
+int dicod_database_open(dicod_database_t *dp);
+int dicod_database_close(dicod_database_t *dp);
+int dicod_database_deinit(dicod_database_t *dp);
+
+void dicod_database_free(dicod_database_t *dp);
+
+char *dicod_database_get_descr(dicod_database_t *db);
+void dicod_database_free_descr(dicod_database_t *db, char *descr);
+char *dicod_database_get_info(dicod_database_t *db);
+void dicod_database_free_info(dicod_database_t *db, char *info);
+void dicod_database_get_languages(dicod_database_t *db, dico_list_t list[]);
+
+size_t dicod_database_result_count(dicod_database_t *db, dico_result_t res);
+size_t dicod_database_compare_count(dicod_database_t *db, dico_result_t res);
+void dicod_database_result_free(dicod_database_t *db, dico_result_t res);
+int dicod_database_result_output(dicod_database_t *db, dico_result_t res,
+				 size_t n, dico_stream_t str);
+    
+dico_result_t dicod_database_match(dicod_database_t *db,
+				   const dico_strategy_t strat,
+				   const char *word);
+dico_result_t dicod_database_define(dicod_database_t *db, const char *word);
+
+char *dicod_database_get_info(dicod_database_t *db);
+void dicod_database_free_info(dicod_database_t *db, char *info);
+
+char *dicod_database_get_descr(dicod_database_t *db);
+void dicod_database_free_descr(dicod_database_t *db, char *descr);
+
+dico_assoc_list_t dicod_database_mime_header(dicod_database_t *db,
+					     dico_result_t res);
+
 /* ostream.c */
 extern off_t total_bytes_out;
 dico_stream_t dicod_ostream_create(dico_stream_t str,
diff --git a/dicod/lang.c b/dicod/lang.c
index 95102e8..bb0b441 100644
--- a/dicod/lang.c
+++ b/dicod/lang.c
@@ -120,7 +120,7 @@ dicod_show_lang_info(dico_stream_t str, int argc, char **argv)
     } else {
 	dico_list_t langlist[2];
 
-	dicod_get_database_languages(db, langlist);
+	dicod_database_get_languages(db, langlist);
 	stream_writez(str, "280");
 	show_lang_lists(str, langlist);
     }
@@ -132,7 +132,7 @@ _show_database_lang(void *item, void *data)
     dicod_database_t *db = item;
     dico_stream_t str = data;
     dico_list_t langlist[2];
-    dicod_get_database_languages(db, langlist);
+    dicod_database_get_languages(db, langlist);
     stream_printf(str, "%s", db->name);
     show_lang_lists(str, langlist);
     return 0;
diff --git a/dicod/loader.c b/dicod/loader.c
index dc20f7c..89a40a1 100644
--- a/dicod/loader.c
+++ b/dicod/loader.c
@@ -113,131 +113,6 @@ dicod_load_module(dicod_module_instance_t *inst)
     return rc;
 }
 
-int
-dicod_init_database(dicod_database_t *dp)
-{
-    dicod_module_instance_t *inst = dp->instance;
-
-    if (inst->module->dico_capabilities & DICO_CAPA_NODB) {
-	dico_log(L_ERR, 0, _("cannot initialize database `%s': "
-			     "module `%s' does not support databases"),
-		 dp->command, inst->ident);
-	return 1;
-    }
-    
-    if (inst->module->dico_init_db) {
-	dp->mod_handle = inst->module->dico_init_db(dp->name,
-						    dp->argc, dp->argv);
-	if (!dp->mod_handle) {
-	    dico_log(L_ERR, 0, _("cannot initialize database `%s'"),
-		     dp->command);
-	    return 1;
-	}
-    }
-
-    return 0;
-}
-
-int
-dicod_open_database(dicod_database_t *dp)
-{
-    dicod_module_instance_t *inst = dp->instance;
-
-    if (inst->module->dico_open) {
-	if (inst->module->dico_open(dp->mod_handle)) {
-	    dico_log(L_ERR, 0, _("cannot open database `%s'"),
-		     dp->command);
-	    return 1;
-	}
-	
-    }
-
-    if (!dp->mime_headers
-	&& inst->module->dico_version > 2
-	&& inst->module->dico_db_mime_header) {
-	char *str = inst->module->dico_db_mime_header(dp->mod_handle);
-	if (str) {
-	    if (dico_header_parse(&dp->mime_headers, str)) {
-		dico_log(L_WARN, errno,
-			 "database %s: can't parse mime headers \"%s\"",
-			 dp->name,
-			 str);
-	    }
-	    free(str);
-	}
-    }
-
-    return 0;
-}
-
-int
-dicod_close_database(dicod_database_t *dp)
-{
-    int rc = 0;
-    
-    if (dp->mod_handle) {
-	dicod_module_instance_t *inst = dp->instance;
-	if (inst->module->dico_close) 
-	    rc = inst->module->dico_close(dp->mod_handle);
-    }
-    return rc;
-}
-
-int
-dicod_free_database(dicod_database_t *dp)
-{
-    int rc = 0;
-    
-    if (dp->mod_handle) {
-	dicod_module_instance_t *inst = dp->instance;
-	if (inst->module->dico_free_db) {
-	    rc = inst->module->dico_free_db(dp->mod_handle);
-	    dp->mod_handle = NULL;
-	}
-    }
-    return rc;
-}
-
-char *
-dicod_get_database_descr(dicod_database_t *db)
-{
-    if (db->descr)
-	return db->descr;
-    else {
-	dicod_module_instance_t *inst = db->instance;
-	if (inst->module->dico_db_descr)
-	    return inst->module->dico_db_descr(db->mod_handle);
-    }
-    return NULL;
-}
-
-void
-dicod_free_database_descr(dicod_database_t *db, char *descr)
-{
-    if (descr && descr != db->descr)
-	free(descr);
-}
-
-char *
-dicod_get_database_info(dicod_database_t *db)
-{
-    if (db->info)
-	return db->info;
-    else {
-	dicod_module_instance_t *inst = db->instance;
-	if (inst->module->dico_db_info)
-	    return inst->module->dico_db_info(db->mod_handle);
-    }
-    return NULL;
-}
-
-void
-dicod_free_database_info(dicod_database_t *db, char *info)
-{
-    if (info && info != db->info)
-	free(info);
-}
-
 static int
 _dup_lang_item(void *item, void *data)
 {
@@ -264,32 +139,6 @@ dicod_any_lang_list_p(dico_list_t list)
 	   || (dico_list_count(list) == 1
 	       && strcmp (dico_list_item(list, 0), "*") == 0);
 }
-
-void
-dicod_get_database_languages(dicod_database_t *db, dico_list_t dlist[])
-{
-    if (!(db->flags & DICOD_DBF_LANG)) {
-	dicod_module_instance_t *inst = db->instance;
-	if (inst->module->dico_db_lang) {
-	    /* FIXME: Return code? */
-	    inst->module->dico_db_lang(db->mod_handle, db->langlist);
-	    if (db->langlist[0] || db->langlist[1]) {		
-		if (!db->langlist[0])
-		    db->langlist[0] = dicod_langlist_copy(db->langlist[1]);
-		else if (!db->langlist[1])
-		    db->langlist[1] = dicod_langlist_copy(db->langlist[0]);
-	    }
-	    if (dicod_any_lang_list_p(db->langlist[0]))
-		dico_list_destroy(&db->langlist[0]);
-	    if (dicod_any_lang_list_p(db->langlist[1]))
-		dico_list_destroy(&db->langlist[1]);
-	}
-	db->flags |= DICOD_DBF_LANG;
-    }
-    dlist[0] = db->langlist[0];
-    dlist[1] = db->langlist[1];
-}
-
 
 static char nomatch[] = "552 No match";
 static size_t nomatch_len = (sizeof(nomatch)-1);
@@ -320,33 +169,31 @@ dicod_word_first(dico_stream_t stream, const char *word,
     itr = xdico_list_iterator(database_list);
     for (db = dico_iterator_first(itr); db; db = dico_iterator_next(itr)) {
 	if (database_is_visible(db)) {
-	    struct dico_database_module *mp = db->instance->module;
-	    dico_result_t res = strat ?
-		            mp->dico_match(db->mod_handle, strat, word) :
-		            mp->dico_define(db->mod_handle, word);
+	    dico_result_t res = strat
+		? dicod_database_match(db, strat, word)
+		: dicod_database_define(db, word);
 	    size_t count;
 	    
 	    if (!res)
 		continue;
-	    count = mp->dico_result_count(res);
+	    count = dicod_database_result_count(db, res);
 	    
 	    if (count) {
 		if (strat)
 		    current_stat.matches = count;
 		else
 		    current_stat.defines = count;
-		if (mp->dico_compare_count)
-		    current_stat.compares = mp->dico_compare_count(res);
+		current_stat.compares = dicod_database_compare_count(db, res);
 		stream_printf(stream, begfmt, (unsigned long) count);
 		proc(db, res, word, stream, data, count);
 		stream_writez(stream, (char*) endmsg);
 		report_current_timing(stream, tid);
 		dico_stream_write(stream, "\n", 1);
 		access_log_status(begfmt, endmsg);
-		mp->dico_free_result(res);
+		dicod_database_result_free(db, res);
 		break;
 	    } else
-		mp->dico_free_result(res);
+		dicod_database_result_free(db, res);
 	}
     }
     dico_iterator_destroy(&itr);
@@ -385,23 +232,21 @@ dicod_word_all(dico_stream_t stream, const char *word,
     itr = xdico_list_iterator(database_list);
     for (db = dico_iterator_first(itr); db; db = dico_iterator_next(itr)) {
 	if (database_is_visible(db)) {
-	    struct dico_database_module *mp = db->instance->module;
-	    dico_result_t res = strat ?
-		              mp->dico_match(db->mod_handle, strat, word) :
-		              mp->dico_define(db->mod_handle, word);
+	    dico_result_t res = strat
+		? dicod_database_match(db, strat, word)
+		: dicod_database_define(db, word);
 	    size_t count;
 	
 	    if (!res)
 		continue;
-	    count = mp->dico_result_count(res);
+	    count = dicod_database_result_count(db, res);
 	    if (!count) {
-		mp->dico_free_result(res);
+		dicod_database_result_free(db, res);
 		continue;
 	    }
 
 	    total += count;
-	    if (mp->dico_compare_count)
-		current_stat.compares += mp->dico_compare_count(res);
+	    current_stat.compares += dicod_database_compare_count(db, res);
 	    rp = xmalloc(sizeof(*rp));
 	    rp->db = db;
 	    rp->res = res;
@@ -425,7 +270,7 @@ dicod_word_all(dico_stream_t stream, const char *word,
 	stream_printf(stream, begfmt, (unsigned long) total);
 	for (rp = dico_iterator_first(itr); rp; rp = dico_iterator_next(itr)) {
 	    proc(rp->db, rp->res, word, stream, data, rp->count);
-	    rp->db->instance->module->dico_free_result(rp->res);
+	    dicod_database_result_free(rp->db, rp->res);
 	    free(rp);
 	}
 	stream_writez(stream, (char*) endmsg);
@@ -443,13 +288,12 @@ print_matches(dicod_database_t *db, dico_result_t res,
 	      dico_stream_t stream, void *data, size_t count)
 {
     size_t i;
-    struct dico_database_module *mp = db->instance->module;
     dico_stream_t ostr = data;
     
     for (i = 0; i < count; i++) {
 	stream_writez(ostr, db->name);
 	dico_stream_write(ostr, " \"", 2);
-	mp->dico_output_result(res, i, ostr);
+	dicod_database_result_output(db, res, i, ostr);
 	dico_stream_write(ostr, "\"\n", 2);
     }
 }
@@ -458,12 +302,12 @@ void
 dicod_match_word_db(dicod_database_t *db, dico_stream_t stream,
 		    const dico_strategy_t strat, const char *word)
 {
-    struct dico_database_module *mp = db->instance->module;
     dico_result_t res;
     size_t count;
     
     begin_timing("match");
-    res = mp->dico_match(db->mod_handle, strat, word);
+    
+    res = dicod_database_match(db, strat, word);
     
     if (!res) {
 	access_log_status(nomatch, nomatch);
@@ -471,7 +315,7 @@ dicod_match_word_db(dicod_database_t *db, dico_stream_t stream,
 	return;
     }
 
-    count = mp->dico_result_count(res);
+    count = dicod_database_result_count(db, res);
     if (count == 0) {
 	access_log_status(nomatch, nomatch);
 	dico_stream_writeln(stream, nomatch, nomatch_len);
@@ -479,8 +323,7 @@ dicod_match_word_db(dicod_database_t *db, dico_stream_t stream,
 	dico_stream_t ostr;
 	
 	current_stat.matches = count;
-	if (mp->dico_compare_count)
-	    current_stat.compares = mp->dico_compare_count(res);
+	current_stat.compares = dicod_database_compare_count(db, res);
 	stream_printf(stream, "152 %lu matches found: list follows\n",
 		      (unsigned long) count);
 	ostr = dicod_ostream_create(stream, NULL);
@@ -495,7 +338,7 @@ dicod_match_word_db(dicod_database_t *db, dico_stream_t stream,
 	access_log_status("152", "250");
     }
     
-    mp->dico_free_result(res);
+    dicod_database_result_free(db, res);
 }
 
 void
@@ -534,74 +377,50 @@ print_definitions(dicod_database_t *db, dico_result_t res,
 		  dico_stream_t stream, void *data, size_t count)
 {
     size_t i;
-    char *descr = dicod_get_database_descr(db);
-    struct dico_database_module *mp = db->instance->module;
+    char *descr = dicod_database_get_descr(db);
+
     for (i = 0; i < count; i++) {
 	dico_stream_t ostr;
-	dico_assoc_list_t hdr = NULL;
+	dico_assoc_list_t hdr;
 	
 	stream_printf(stream, "151 \"%s\" %s \"%s\"\n",
 		      word, db->name, descr ? descr : "");
 
-	if (!db->mime_headers
-	    && mp->dico_version > 2
-	    && mp->dico_db_mime_header) {
-	    char *str = mp->dico_db_mime_header(db->mod_handle);
-	    if (str) {
-		if (dico_header_parse(&db->mime_headers, str)) {
-		    dico_log(L_WARN, errno,
-			     "database %s: can't parse mime headers \"%s\"",
-			     db->name,
-			     str);
-		}
-		free(str);
-	    }
-	}
-
-	if (mp->dico_result_headers) {
-	    if (db->mime_headers)
-		hdr = dico_assoc_dup(db->mime_headers);
-	    else
-		dico_header_parse(&hdr, NULL);
-	    mp->dico_result_headers(res, hdr);
-	    ostr = dicod_ostream_create(stream, hdr);
-	} else
-	    ostr = dicod_ostream_create(stream, db->mime_headers);
-	mp->dico_output_result(res, i, ostr);
+	hdr = dicod_database_mime_header(db, res);
+	ostr = dicod_ostream_create(stream, hdr);
+	dicod_database_result_output(db, res, i, ostr);
 	total_bytes_out += dico_stream_bytes_out(ostr);
 	dico_stream_close(ostr);
 	dico_stream_destroy(&ostr);
 	dico_stream_write(stream, "\n.\n", 3);
 	dico_assoc_destroy(&hdr);
     }
-    dicod_free_database_descr(db, descr);
+    dicod_database_free_descr(db, descr);
 }
 
 void
 dicod_define_word_db(dicod_database_t *db, dico_stream_t stream,
 		     const char *word)
 {
-    struct dico_database_module *mp = db->instance->module;
     dico_result_t res;
     size_t count;
     
     begin_timing("define");
 
-    res = mp->dico_define(db->mod_handle, word);
+    res = dicod_database_define(db, word);
     if (!res) {
 	access_log_status(nomatch, nomatch);
 	dico_stream_writeln(stream, nomatch, nomatch_len);
 	return;
     }
 
-    count = mp->dico_result_count(res);
+    count = dicod_database_result_count(db, res);
     if (count == 0) {
 	access_log_status(nomatch, nomatch);
 	dico_stream_writeln(stream, nomatch, nomatch_len);
     } else {
 	current_stat.defines = count;
-	if (mp->dico_compare_count)
-	    current_stat.compares = mp->dico_compare_count(res);
+	current_stat.compares = dicod_database_compare_count(db, res);
 	stream_printf(stream, "150 %lu definitions found: list follows\n",
 		      (unsigned long) count);
 	print_definitions(db, res, word, stream, NULL, count);
@@ -611,7 +430,7 @@ dicod_define_word_db(dicod_database_t *db, dico_stream_t stream,
 	access_log_status("150", "250");
     }
     
-    mp->dico_free_result(res);
+    dicod_database_result_free(db, res);
 }
 
 void
diff --git a/dicod/main.c b/dicod/main.c
index 425f0d5..341de5d 100644
--- a/dicod/main.c
+++ b/dicod/main.c
@@ -1419,7 +1419,7 @@ check_db_visibility(void)
 	    db->session_visible = 0;
 	else {
 	    dico_list_t list[2];
-	    dicod_get_database_languages(db, list);
+	    dicod_database_get_languages(db, list);
 	    db->session_visible = dicod_lang_check(list);
 	}
     }