/* 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 #include #include #include #include #ifndef HAVE_SCM_T_OFF typedef off_t scm_t_off; #endif /* General-purpose eval handlers */ struct apply_data { SCM proc; SCM arg; }; SCM apply_catch_body(void *data) { struct apply_data *xp = data; return scm_apply_0(xp->proc, xp->arg); } static SCM eval_catch_handler(void *data, SCM tag, SCM throw_args) { scm_handle_by_message_noexit("dico", tag, throw_args); longjmp(*(jmp_buf*)data, 1); } struct scheme_exec_data { SCM (*handler)(void *data); void *data; SCM result; }; static SCM scheme_safe_exec_body(void *data) { struct scheme_exec_data *ed = data; ed->result = ed->handler(ed->data); return SCM_BOOL_F; } static int guile_safe_exec(SCM (*handler)(void *data), void *data, SCM *result) { jmp_buf jmp_env; struct scheme_exec_data ed; if (setjmp(jmp_env)) return 1; ed.handler = handler; ed.data = data; scm_c_with_throw_handler(SCM_BOOL_T, scheme_safe_exec_body, (void*)&ed, eval_catch_handler, &jmp_env, 0); if (result) *result = ed.result; return 0; } struct load_closure { char *filename; int argc; char **argv; }; static SCM load_path_handler(void *data) { struct load_closure *lp = data; scm_set_program_arguments(lp->argc, lp->argv, lp->filename); scm_primitive_load_path(scm_from_locale_string(lp->filename)); return SCM_UNDEFINED; } static int guile_load(char *filename, char *args) { struct load_closure lc; if (args) { struct wordsplit ws; if (wordsplit(args, &ws, WRDSF_DEFFLAGS)) { dico_log(L_ERR, 0, "wordsplit: %s", wordsplit_strerror(&ws)); return 1; } lc.argc = ws.ws_wordc; lc.argv = ws.ws_wordv; wordsplit_free(&ws); } else { lc.argc = 0; lc.argv = NULL; } lc.filename = filename; return guile_safe_exec(load_path_handler, &lc, NULL); } static void _add_load_path(char *path) { SCM scm, path_scm; SCM *pscm; path_scm = SCM_VARIABLE_REF(scm_c_lookup("%load-path")); for (scm = path_scm; scm != SCM_EOL; scm = SCM_CDR(scm)) { SCM val = SCM_CAR(scm); if (scm_is_string(val)) { char *s = scm_to_locale_string(val); int res = strcmp(s, path); free(s); if (res == 0) return; } } pscm = SCM_VARIABLE_LOC(scm_c_lookup("%load-path")); *pscm = scm_append(scm_list_3(path_scm, scm_list_1(scm_from_locale_string(path)), SCM_EOL)); } static void memerr(const char *fname) { dico_log(L_ERR, 0, _("%s: not enough memory"), fname); } static char * proc_name(SCM proc) { return scm_to_locale_string( scm_symbol_to_string(scm_procedure_name(proc))); } static void str_rettype_error(const char *name) { dico_log(L_ERR, 0, _("%s: invalid return type"), name); } static void rettype_error(SCM proc) { char *name = proc_name(proc); str_rettype_error(name); free(name); } static int guile_call_proc(SCM *result, SCM proc, SCM arglist) { jmp_buf jmp_env; struct apply_data adata; if (setjmp(jmp_env)) { char *name = proc_name(proc); dico_log(L_NOTICE, 0, _("procedure `%s' failed: see error output for details"), name); free(name); return 1; } adata.proc = proc; adata.arg = arglist; *result = scm_c_with_throw_handler(SCM_BOOL_T, apply_catch_body, &adata, eval_catch_handler, &jmp_env, 0); return 0; } scm_t_bits _guile_dico_key_tag; static SCM dico_new_scm_key(struct dico_key **pkey) { struct dico_key *kptr; kptr = scm_gc_malloc (sizeof (*kptr), "Dico key"); *pkey = kptr; SCM_RETURN_NEWSMOB(_guile_dico_key_tag, kptr); } static size_t _guile_dico_key_free(SCM message_smob) { struct dico_key *kp = (struct dico_key *) SCM_CDR (message_smob); dico_key_deinit(kp); return 0; } static int _guile_dico_key_print(SCM message_smob, SCM port, scm_print_state *pstate) { struct dico_key *kp = (struct dico_key *) SCM_CDR (message_smob); scm_puts("#strat->name, port); scm_puts(" (", port); scm_puts(kp->word, port); scm_puts(")>", port); return 1; } static void _guile_init_dico_key(void) { _guile_dico_key_tag = scm_make_smob_type("Dico key", sizeof (struct dico_key)); scm_set_smob_free(_guile_dico_key_tag, _guile_dico_key_free); scm_set_smob_print(_guile_dico_key_tag, _guile_dico_key_print); } #define CELL_IS_KEY(s) \ (!SCM_IMP(s) && SCM_CELL_TYPE(s) == _guile_dico_key_tag) SCM_DEFINE_PUBLIC(scm_dico_key_p, "dico-key?", 1, 0, 0, (SCM obj), "Return @samp{#t} if @var{obj} is a selection key.") #define FUNC_NAME s_scm_dico_key_p { return CELL_IS_KEY(obj) ? SCM_BOOL_T : SCM_BOOL_F; } #undef FUNC_NAME SCM_DEFINE_PUBLIC(scm_dico_key__word, "dico-key->word", 1, 0, 0, (SCM key), "Return search word from the @var{key}.") #define FUNC_NAME s_scm_dico_key__word { struct dico_key *kp; SCM_ASSERT(CELL_IS_KEY(key), key, SCM_ARG1, FUNC_NAME); kp = (struct dico_key *) SCM_CDR(key); return scm_from_locale_string(kp->word); } #undef FUNC_NAME scm_t_bits _guile_strategy_tag; struct _guile_strategy { dico_strategy_t strat; }; static SCM _make_strategy(const dico_strategy_t strat) { struct _guile_strategy *sp; sp = scm_gc_malloc (sizeof (struct _guile_strategy), "strategy"); sp->strat = strat; SCM_RETURN_NEWSMOB(_guile_strategy_tag, sp); } static size_t _guile_strategy_free(SCM message_smob) { /* Nothing to free in struct _guile_strategy: the strat member is constant */ return 0; } static int _guile_strategy_print(SCM message_smob, SCM port, scm_print_state * pstate) { struct _guile_strategy *sp = (struct _guile_strategy *) SCM_CDR(message_smob); scm_puts("#strat->name, port); scm_puts(" [", port); scm_puts(sp->strat->descr, port); scm_puts("]>", port); return 1; } static void _guile_init_strategy(void) { _guile_strategy_tag = scm_make_smob_type("strategy", sizeof (struct _guile_strategy)); scm_set_smob_free(_guile_strategy_tag, _guile_strategy_free); scm_set_smob_print(_guile_strategy_tag, _guile_strategy_print); } #define CELL_IS_STRAT(s) \ (!SCM_IMP(s) && SCM_CELL_TYPE(s) == _guile_strategy_tag) SCM_DEFINE_PUBLIC(scm_dico_strat_selector_p, "dico-strat-selector?", 1, 0, 0, (SCM strat), "Return true if @var{strat} has a selector.") #define FUNC_NAME s_scm_dico_strat_selector_p { struct _guile_strategy *sp; SCM_ASSERT(CELL_IS_STRAT(strat), strat, SCM_ARG1, FUNC_NAME); sp = (struct _guile_strategy *) SCM_CDR(strat); return sp->strat->sel ? SCM_BOOL_T : SCM_BOOL_F; } #undef FUNC_NAME SCM_DEFINE_PUBLIC(scm_dico_strat_select_p, "dico-strat-select?", 3, 0, 0, (SCM strat, SCM word, SCM key), "Return true if @var{key} matches @var{word} as per strategy selector @var{strat}.") #define FUNC_NAME s_scm_dico_strat_select_p { struct _guile_strategy *sp; struct dico_strategy *stratp; char *wordstr; int rc; SCM_ASSERT(CELL_IS_STRAT(strat), strat, SCM_ARG1, FUNC_NAME); SCM_ASSERT(scm_is_string(word), word, SCM_ARG2, FUNC_NAME); sp = (struct _guile_strategy *) SCM_CDR(strat); stratp = sp->strat; wordstr = scm_to_locale_string(word); if (scm_is_string(key)) { char *keystr = scm_to_locale_string(key); struct dico_key skey; rc = dico_key_init(&skey, stratp, keystr); free(keystr); if (rc) { free(wordstr); scm_misc_error(FUNC_NAME, "key initialization failed: ~S", scm_list_1(key)); } rc = dico_key_match(&skey, wordstr); dico_key_deinit(&skey); } else { struct dico_key *kptr; SCM_ASSERT(CELL_IS_KEY(key), key, SCM_ARG3, FUNC_NAME); kptr = (struct dico_key *) SCM_CDR(key); rc = dico_key_match(kptr, wordstr); } free(wordstr); return rc ? SCM_BOOL_T : SCM_BOOL_F; } #undef FUNC_NAME SCM_DEFINE_PUBLIC(scm_dico_strat_name, "dico-strat-name", 1, 0, 0, (SCM strat), "Return the name of the strategy @var{strat}.") #define FUNC_NAME s_scm_dico_strat_name { struct _guile_strategy *sp; SCM_ASSERT(CELL_IS_STRAT(strat), strat, SCM_ARG1, FUNC_NAME); sp = (struct _guile_strategy *) SCM_CDR(strat); return scm_from_locale_string(sp->strat->name); } #undef FUNC_NAME SCM_DEFINE_PUBLIC(scm_dico_strat_description, "dico-strat-description", 1, 0, 0, (SCM strat), "Return a textual description of the strategy @var{strat}.") #define FUNC_NAME s_scm_dico_strat_description { struct _guile_strategy *sp; SCM_ASSERT(CELL_IS_STRAT(strat), strat, SCM_ARG1, FUNC_NAME); sp = (struct _guile_strategy *) SCM_CDR(strat); return scm_from_locale_string(sp->strat->descr); } #undef FUNC_NAME SCM_DEFINE_PUBLIC(scm_dico_strat_default_p, "dico-strat-default?", 1, 0, 0, (SCM strat), "Return true if @var{strat} is a default strategy.") #define FUNC_NAME s_scm_dico_strat_default_p { struct _guile_strategy *sp; SCM_ASSERT(CELL_IS_STRAT(strat), strat, SCM_ARG1, FUNC_NAME); sp = (struct _guile_strategy *) SCM_CDR(strat); return dico_strategy_is_default_p(sp->strat) ? SCM_BOOL_T : SCM_BOOL_F; } #undef FUNC_NAME SCM_DEFINE_PUBLIC(scm_dico_make_key, "dico-make-key", 2, 0, 0, (SCM strat, SCM word), "Make a key for given @var{word} and strategy @var{strat}.") #define FUNC_NAME s_scm_dico_make_key { SCM ret; struct dico_key *key; struct _guile_strategy *sp; char *wordstr; int rc; SCM_ASSERT(CELL_IS_STRAT(strat), strat, SCM_ARG1, FUNC_NAME); SCM_ASSERT(scm_is_string(word), word, SCM_ARG2, FUNC_NAME); sp = (struct _guile_strategy *) SCM_CDR(strat); wordstr = scm_to_locale_string(word); ret = dico_new_scm_key(&key); rc = dico_key_init(key, sp->strat, wordstr); free(wordstr); if (rc) scm_misc_error(FUNC_NAME, "key initialization failed: ~S", scm_list_1(ret)); return ret; } #undef FUNC_NAME static int _guile_selector(int cmd, struct dico_key *key, const char *dict_word) { SCM result; SCM list = scm_list_4((SCM)key->strat->closure, scm_from_int (cmd), scm_from_locale_string(key->word), scm_from_locale_string(dict_word)); if (guile_safe_exec(apply_catch_body, list, &result)) return 0; return result != SCM_BOOL_F; } SCM_DEFINE_PUBLIC(scm_dico_register_strat, "dico-register-strat", 2, 1, 0, (SCM strat, SCM descr, SCM fun), "Register a new strategy.") #define FUNC_NAME s_scm_dico_register_strat { struct dico_strategy strategy; SCM_ASSERT(scm_is_string(strat), strat, SCM_ARG1, FUNC_NAME); SCM_ASSERT(scm_is_string(descr), descr, SCM_ARG2, FUNC_NAME); if (!SCM_UNBNDP(fun)) SCM_ASSERT(scm_procedure_p(fun), fun, SCM_ARG3, FUNC_NAME); strategy.name = scm_to_locale_string(strat); strategy.descr = scm_to_locale_string(descr); if (SCM_UNBNDP(fun)) { strategy.sel = NULL; strategy.closure = NULL; } else { strategy.sel = _guile_selector; strategy.closure = fun; } dico_strategy_add(&strategy); free(strategy.name); free(strategy.descr); return SCM_UNSPECIFIED; } #undef FUNC_NAME SCM_DEFINE_PUBLIC(scm_dico_register_markup, "dico-register-markup", 1, 0, 0, (SCM type), "Register new markup type.") #define FUNC_NAME s_scm_dico_register_markup { int rc; char *str; SCM_ASSERT(scm_is_string(type), type, SCM_ARG1, FUNC_NAME); str = scm_to_locale_string(type); rc = dico_markup_register(str); free(str); switch (rc) { case 0: break; case ENOMEM: scm_report_out_of_memory (); break; case EINVAL: scm_misc_error(FUNC_NAME, "Invalid markup name: ~S", scm_list_1(type)); default: scm_misc_error(FUNC_NAME, "Unexpected error: ~S", scm_list_1(scm_from_int(rc))); } return SCM_UNSPECIFIED; } #undef FUNC_NAME SCM_DEFINE_PUBLIC(scm_dico_current_markup, "dico-current-markup", 0, 0, 0, (), "Return current dico markup type.") #define FUNC_NAME s_scm_dico_current_markup { return scm_from_locale_string(dico_markup_type); } #undef FUNC_NAME static scm_t_port_type *scm_dico_port_type; struct _guile_dico_port { dico_stream_t str; }; static SCM _make_dico_port(dico_stream_t str) { struct _guile_dico_port *dp; dp = scm_gc_typed_calloc (struct _guile_dico_port); dp->str = str; return scm_c_make_port (scm_dico_port_type, SCM_BUF0 | SCM_WRTNG, (scm_t_bits) dp); } #define DICO_PORT(x) ((struct _guile_dico_port *) SCM_STREAM (x)) static void _dico_port_close(SCM port) { struct _guile_dico_port *dp = DICO_PORT(port); if (dp && dp->str) dico_stream_flush(dp->str); } static size_t _dico_port_write(SCM port, SCM src, size_t start, size_t count) { struct _guile_dico_port *dp = DICO_PORT(port); dico_stream_write(dp->str, SCM_BYTEVECTOR_CONTENTS (src) + start, count); return count; } static scm_t_off _dico_port_seek (SCM port, scm_t_off offset, int whence) { struct _guile_dico_port *dp = DICO_PORT(port); return (scm_t_off) dico_stream_seek(dp->str, (off_t) offset, whence); } static int _dico_port_print(SCM exp, SCM port, scm_print_state *pstate) { scm_puts ("#", port); return 1; } static void _guile_init_dico_port(void) { scm_dico_port_type = scm_make_port_type("dico-port", NULL, _dico_port_write); scm_set_port_print (scm_dico_port_type, _dico_port_print); scm_set_port_needs_close_on_gc (scm_dico_port_type, 1); scm_set_port_close (scm_dico_port_type, _dico_port_close); scm_set_port_seek (scm_dico_port_type, _dico_port_seek); } static scm_t_port_type *scm_dico_log_port_type; static SCM _make_dico_log_port(int level) { dico_stream_t str = dico_log_stream_create(level); return str ? _make_dico_port(str) : SCM_BOOL_F; } static int _dico_log_port_print(SCM exp, SCM port, scm_print_state *pstate) { scm_puts ("#", port); return 1; } static void _guile_init_dico_log_port(void) { scm_dico_log_port_type = scm_make_port_type("dico-log-port", NULL, _dico_port_write); scm_set_port_print (scm_dico_log_port_type, _dico_log_port_print); scm_set_port_close (scm_dico_log_port_type, _dico_port_close); scm_set_port_needs_close_on_gc (scm_dico_log_port_type, 1); scm_set_port_seek (scm_dico_log_port_type, _dico_port_seek); } static void _guile_init_funcs (void) { #include } static int guile_debug; static char *guile_init_script; static char *guile_init_args; static char *guile_init_fun; enum guile_proc_ind { open_proc, close_proc, info_proc, descr_proc, lang_proc, match_proc, define_proc, output_proc, result_count_proc, compare_count_proc, free_result_proc, result_headers_proc, db_mime_header_proc, MAX_PROC }; static char *guile_proc_name[] = { "open", "close", "info", "descr", "lang", "match", "define", "output", "result-count", "compare-count", "free-result", "result-headers", "db-mime-header" }; typedef SCM guile_vtab[MAX_PROC]; static guile_vtab global_vtab; struct _guile_database { const char *dbname; guile_vtab vtab; int argc; char **argv; SCM handle; }; static int proc_name_to_index(const char *name) { int i; for (i = 0; i < MAX_PROC; i++) if (strcmp(guile_proc_name[i], name) == 0) break; return i; } struct init_struct { const char *init_fun; const char *db_name; }; static SCM call_init_handler(void *data) { struct init_struct *p = (struct init_struct *)data; SCM procsym = SCM_VARIABLE_REF(scm_c_lookup(p->init_fun)); SCM arg; if (p->db_name) arg = scm_from_locale_string(p->db_name); else arg = SCM_BOOL_F; return scm_apply_0(procsym, scm_list_1(arg)); } static int init_vtab(const char *init_fun, const char *dbname, guile_vtab vtab) { SCM res; struct init_struct istr; istr.init_fun = init_fun; istr.db_name = dbname; if (guile_safe_exec(call_init_handler, &istr, &res)) return 1; if (!scm_list_p(res) && res != SCM_EOL) { str_rettype_error(init_fun); return 1; } for (; res != SCM_EOL; res = SCM_CDR(res)) { int idx; char *ident; SCM name, proc; SCM car = SCM_CAR(res); if (!scm_list_p(res) || !scm_is_string(name = SCM_CAR(car)) || !scm_procedure_p(proc = SCM_CDR(car))) { str_rettype_error(init_fun); return 1; } ident = scm_to_locale_string(name); idx = proc_name_to_index(ident); if (idx == MAX_PROC) { dico_log(L_ERR, 0, _("%s: %s: unknown virtual function"), init_fun, ident); free(ident); return 1; } free(ident); vtab[idx] = proc; } return 0; } static int set_load_path(struct dico_option *opt, const char *val) { char *p; char *tmp = strdup(val); if (!tmp) return 1; for (p = strtok(tmp, ":"); p; p = strtok(NULL, ":")) _add_load_path(p); free(tmp); return 0; } static struct dico_option init_option[] = { { DICO_OPTSTR(debug), dico_opt_bool, &guile_debug }, { DICO_OPTSTR(init-script), dico_opt_string, &guile_init_script }, { DICO_OPTSTR(init-args), dico_opt_string, &guile_init_args }, { DICO_OPTSTR(load-path), dico_opt_null, NULL, { 0 }, set_load_path }, { DICO_OPTSTR(init-fun), dico_opt_string, &guile_init_fun }, { NULL } }; static int mod_init(int argc, char **argv) { SCM port; scm_init_guile(); scm_load_goops(); if (dico_parseopt(init_option, argc, argv, 0, NULL)) return 1; _guile_init_strategy(); _guile_init_dico_key(); _guile_init_dico_port(); _guile_init_dico_log_port(); _guile_init_funcs(); #ifdef GUILE_DEBUG_MACROS if (guile_debug) { SCM_DEVAL_P = 1; SCM_BACKTRACE_P = 1; SCM_RECORD_POSITIONS_P = 1; SCM_RESET_DEBUG_MODE; } #endif port = _make_dico_log_port(L_ERR); if (port == SCM_BOOL_F) { dico_log(L_ERR, 0, _("mod_init: cannot initialize error port")); return 1; } scm_set_current_output_port(port); scm_set_current_error_port(port); if (guile_init_script && guile_load(guile_init_script, guile_init_args)) { dico_log(L_ERR, 0, _("mod_init: cannot load init script %s"), guile_init_script); return 1; } if (guile_init_fun && init_vtab(guile_init_fun, NULL, global_vtab)) return 1; return 0; } static dico_handle_t mod_init_db(const char *dbname, int argc, char **argv) { struct _guile_database *db; int i; int err = 0; char *init_script = NULL; char *init_args = NULL; char *init_fun = guile_init_fun; struct dico_option db_option[] = { { DICO_OPTSTR(init-script), dico_opt_string, &init_script }, { DICO_OPTSTR(init-args), dico_opt_string, &init_args }, { DICO_OPTSTR(init-fun), dico_opt_string, &init_fun }, { NULL } }; if (dico_parseopt(db_option, argc, argv, DICO_PARSEOPT_PERMUTE, &i)) return NULL; argc -= i; argv += i; if (init_script && guile_load(init_script, init_args)) { dico_log(L_ERR, 0, _("mod_init: cannot load init script %s"), init_script); return NULL; } db = malloc(sizeof(*db)); if (!db) { memerr("mod_init_db"); return NULL; } db->dbname = dbname; memcpy(db->vtab, global_vtab, sizeof(db->vtab)); if (init_fun && init_vtab(init_fun, dbname, db->vtab)) { free(db); return NULL; } for (i = 0; i < MAX_PROC; i++) { if (!db->vtab[i]) { switch (i) { case open_proc: case match_proc: case define_proc: case output_proc: case result_count_proc: dico_log(L_ERR, 0, _("%s: %s: void virtual function"), argv[0], guile_proc_name[i]); err++; default: break; } } } if (err) { free(db); return NULL; } db->argc = argc; db->argv = argv; return (dico_handle_t)db; } static int mod_free_db(dico_handle_t hp) { struct _guile_database *db = (struct _guile_database *)hp; free(db); return 0; } static int mod_close(dico_handle_t hp) { struct _guile_database *db = (struct _guile_database *)hp; SCM res; if (db->vtab[close_proc]) if (guile_call_proc(&res, db->vtab[close_proc], scm_list_1(db->handle))) return 1; scm_gc_unprotect_object(db->handle); return 0; } static SCM argv_to_scm(int argc, char **argv) { SCM scm_first = SCM_EOL, scm_last; for (; argc; argc--, argv++) { SCM new = scm_cons(scm_from_locale_string(*argv), SCM_EOL); if (scm_first == SCM_EOL) scm_last = scm_first = new; else { SCM_SETCDR(scm_last, new); scm_last = new; } } return scm_first; } static SCM assoc_to_scm(dico_assoc_list_t assoc) { SCM scm_first = SCM_EOL, scm_last; dico_iterator_t itr; struct dico_assoc *p; itr = dico_assoc_iterator(assoc); for (p = dico_iterator_first(itr); p; p = dico_iterator_next(itr)) { SCM new = scm_cons(scm_cons(scm_from_locale_string(p->key), scm_from_locale_string(p->value)), SCM_EOL); if (scm_first == SCM_EOL) scm_last = scm_first = new; else { SCM_SETCDR(scm_last, new); scm_last = new; } } dico_iterator_destroy(&itr); return scm_first; } static void scm_to_assoc(dico_assoc_list_t assoc, SCM scm) { dico_assoc_clear(assoc); for (; scm != SCM_EOL && scm_list_p(scm); scm = SCM_CDR(scm)) { SCM elt = SCM_CAR(scm); if (!scm_is_pair(elt)) { scm_misc_error(NULL, "Wrong element type: ~S", scm_list_1(elt)); } dico_assoc_append(assoc, scm_to_locale_string(SCM_CAR(elt)), scm_to_locale_string(SCM_CDR(elt))); } } static int mod_open(dico_handle_t dp) { struct _guile_database *db = (struct _guile_database *)dp; if (guile_call_proc(&db->handle, db->vtab[open_proc], scm_cons(scm_from_locale_string(db->dbname), argv_to_scm(db->argc, db->argv)))) return 1; if (db->handle == SCM_EOL || db->handle == SCM_BOOL_F) return 1; scm_gc_protect_object(db->handle); return 0; } static char * mod_get_text(struct _guile_database *db, int n) { if (db->vtab[n]) { SCM res; if (guile_call_proc(&res, db->vtab[n], scm_list_1(db->handle))) return NULL; if (scm_is_string(res)) return scm_to_locale_string(res); else { rettype_error(db->vtab[n]); return NULL; } } return NULL; } static char * mod_info(dico_handle_t hp) { struct _guile_database *db = (struct _guile_database *)hp; return mod_get_text(db, info_proc); } static char * mod_descr(dico_handle_t hp) { struct _guile_database *db = (struct _guile_database *)hp; return mod_get_text(db, descr_proc); } static dico_list_t scm_to_langlist(SCM scm, SCM procsym) { dico_list_t list = NULL; if (scm == SCM_EOL) return NULL; else if (scm_is_string(scm)) { list = dico_list_create(); dico_list_append(list, scm_to_locale_string(scm)); } else if (scm_list_p(scm)) { list = dico_list_create(); for (; scm != SCM_EOL && scm_list_p(scm); scm = SCM_CDR(scm)) dico_list_append(list, scm_to_locale_string(SCM_CAR(scm))); } else rettype_error(procsym); return list; } static int mod_lang(dico_handle_t hp, dico_list_t list[2]) { struct _guile_database *db = (struct _guile_database *)hp; SCM proc = db->vtab[lang_proc]; list[0] = list[1] = NULL; if (proc) { SCM res; if (guile_call_proc(&res, proc, scm_list_1(db->handle))) return 1; if (res == SCM_EOL) /* ok, nothing */; else if (scm_is_string(res)) { list[0] = dico_list_create(); dico_list_append(list[0], scm_to_locale_string(res)); } else if (scm_is_pair(res)) { list[0] = scm_to_langlist(SCM_CAR(res), proc); list[1] = scm_to_langlist(SCM_CDR(res), proc); } else { rettype_error(proc); return 1; } } return 0; } struct guile_result { struct _guile_database *db; SCM result; }; static dico_result_t make_guile_result(struct _guile_database *db, SCM res) { struct guile_result *rp = malloc(sizeof(*rp)); if (rp) { rp->db = db; rp->result = res; } return (dico_result_t) rp; } static dico_result_t mod_match(dico_handle_t hp, const dico_strategy_t strat, const char *word) { struct _guile_database *db = (struct _guile_database *)hp; SCM scm_strat = _make_strategy(strat); SCM res; struct dico_key *key; SCM scm_key; scm_key = dico_new_scm_key(&key); if (dico_key_init(key, strat, word)) { dico_log(L_ERR, 0, _("mod_match: key initialization failed")); return NULL; } if (guile_call_proc(&res, db->vtab[match_proc], scm_list_3(db->handle, scm_strat, scm_key))) return NULL; dico_key_deinit(key); if (res == SCM_BOOL_F || res == SCM_EOL) return NULL; scm_gc_protect_object(res); return make_guile_result(db, res); } static dico_result_t mod_define(dico_handle_t hp, const char *word) { struct _guile_database *db = (struct _guile_database *)hp; SCM res; if (guile_call_proc(&res, db->vtab[define_proc], scm_list_2(db->handle, scm_from_locale_string(word)))) return NULL; if (res == SCM_BOOL_F || res == SCM_EOL) return NULL; scm_gc_protect_object(res); return make_guile_result(db, res); } static int mod_output_result (dico_result_t rp, size_t n, dico_stream_t str) { int rc; struct guile_result *gres = (struct guile_result *)rp; SCM res; SCM oport = scm_current_output_port(); SCM port = _make_dico_port(str); scm_set_current_output_port(port); rc = guile_call_proc(&res, gres->db->vtab[output_proc], scm_list_2(gres->result, scm_from_int(n))); scm_set_current_output_port(oport); _dico_port_close(port); if (rc) return 1; return 0; } static size_t mod_result_count (dico_result_t rp) { struct guile_result *gres = (struct guile_result *)rp; SCM res; if (guile_call_proc(&res, gres->db->vtab[result_count_proc], scm_list_1(gres->result))) return 0; if (scm_is_integer(res)) return scm_to_int32(res); else rettype_error(gres->db->vtab[result_count_proc]); return 0; } static size_t mod_compare_count (dico_result_t rp) { struct guile_result *gres = (struct guile_result *)rp; if (gres->db->vtab[compare_count_proc]) { SCM res; if (guile_call_proc(&res, gres->db->vtab[compare_count_proc], scm_list_1(gres->result))) return 0; if (scm_is_integer(res)) return scm_to_int32(res); else rettype_error(gres->db->vtab[compare_count_proc]); } return 0; } static void mod_free_result(dico_result_t rp) { struct guile_result *gres = (struct guile_result *)rp; if (gres->db->vtab[free_result_proc]) { SCM res; guile_call_proc(&res, gres->db->vtab[free_result_proc], scm_list_1(gres->result)); } scm_gc_unprotect_object(gres->result); free(gres); } static int mod_result_headers (dico_result_t rp, dico_assoc_list_t hdr) { struct guile_result *gres = (struct guile_result *)rp; SCM proc = gres->db->vtab[result_headers_proc]; if (proc) { SCM res; if (guile_call_proc(&res, proc, scm_list_2(gres->result, assoc_to_scm(hdr)))) return 1; if (!scm_list_p(res)) { rettype_error(proc); return 1; } scm_to_assoc(hdr, res); } return 0; } static char * mod_db_mime_header(dico_handle_t hp) { struct _guile_database *db = (struct _guile_database *)hp; return mod_get_text(db, db_mime_header_proc); } struct dico_database_module DICO_EXPORT(guile, module) = { .dico_version = DICO_MODULE_VERSION, .dico_capabilities = DICO_CAPA_NONE, .dico_init = mod_init, .dico_init_db = mod_init_db, .dico_free_db = mod_free_db, .dico_open = mod_open, .dico_close = mod_close, .dico_db_info = mod_info, .dico_db_descr = mod_descr, .dico_db_lang = mod_lang, .dico_match = mod_match, .dico_define = mod_define, .dico_output_result = mod_output_result, .dico_result_count = mod_result_count, .dico_compare_count = mod_compare_count, .dico_free_result = mod_free_result, .dico_result_headers = mod_result_headers, .dico_db_mime_header = mod_db_mime_header };