static uim_lisp
c_getaddrinfo(uim_lisp hostname_, uim_lisp servname_, uim_lisp hint_)
{
const char *hostname;
char *servname = NULL;
struct addrinfo *hints = C_PTR(hint_);
struct addrinfo *res, *res0;
uim_lisp ret_ = uim_scm_null();
int error;
if (INTP(servname_)) {
uim_asprintf(&servname, "%d", C_INT(servname_));
} else {
servname = C_STR(servname_);
}
if (FALSEP(hostname_))
hostname = NULL;
else
hostname = REFER_C_STR(hostname_);
error = getaddrinfo(hostname, servname, hints, &res0);
if (error) {
const char *errstr = gai_strerror(error);
uim_notify_fatal("getaddrinfo: %s", errstr);
free(servname);
return uim_scm_f();
}
free(servname);
for (res = res0; res; res = res->ai_next) {
ret_ = CONS(MAKE_PTR(res) , ret_);
}
return uim_scm_callf("reverse", "o", ret_);
}
void
uim_anthy_utf8_plugin_instance_init(void)
#endif
{
context_list = uim_scm_null();
uim_scm_gc_protect(&context_list);
uim_scm_eval_c_string("(require-extension (srfi 1))"); /* for delete! */
uim_scm_init_proc0("anthy-utf8-lib-init", init_anthy_lib);
uim_scm_init_proc1("anthy-utf8-lib-alloc-context", create_context);
uim_scm_init_proc1("anthy-utf8-lib-free-context", release_context);
uim_scm_init_proc2("anthy-utf8-lib-set-string", set_string);
uim_scm_init_proc1("anthy-utf8-lib-get-nr-segments",get_nr_segments);
uim_scm_init_proc2("anthy-utf8-lib-get-nr-candidates", get_nr_candidates);
uim_scm_init_proc3("anthy-utf8-lib-get-nth-candidate", get_nth_candidate);
uim_scm_init_proc2("anthy-utf8-lib-get-unconv-candidate", get_unconv_candidate);
uim_scm_init_proc2("anthy-utf8-lib-get-segment-length", get_segment_length);
uim_scm_init_proc3("anthy-utf8-lib-resize-segment", resize_segment);
uim_scm_init_proc3("anthy-utf8-lib-commit-segment", commit_segment);
uim_scm_init_proc0("anthy-utf8-lib-get-anthy-version", anthy_version);
uim_scm_init_proc2("anthy-utf8-lib-set-prediction-src-string", set_prediction_src_string);
uim_scm_init_proc1("anthy-utf8-lib-get-nr-predictions", get_nr_predictions);
uim_scm_init_proc2("anthy-utf8-lib-get-nth-prediction", get_nth_prediction);
uim_scm_init_proc2("anthy-utf8-lib-commit-nth-prediction",
commit_nth_prediction);
uim_scm_init_proc1("anthy-utf8-lib-eucjp-to-utf8", eucjp_to_utf8);
uim_scm_init_proc1("anthy-utf8-lib-utf8-to-eucjp", utf8_to_eucjp);
}
static uim_lisp
c_file_poll(uim_lisp fds_, uim_lisp timeout_)
{
struct pollfd *fds;
int timeout = C_INT(timeout_);
int nfds = uim_scm_length(fds_);
uim_lisp fd_ = uim_scm_f();
int i;
int ret;
uim_lisp ret_;
struct c_file_poll_args args;
fds = uim_calloc(nfds, sizeof(struct pollfd));
for (i = 0; i < nfds; i++) {
fd_ = CAR(fds_);
fds[i].fd = C_INT(CAR(fd_));
fds[i].events = C_INT(CDR(fd_));
fds_ = CDR(fds_);
}
ret = poll(fds, nfds, timeout);
if (ret == -1)
return uim_scm_f();
else if (ret == 0)
return uim_scm_null();
args.fds = fds;
args.nfds = nfds;
ret_ = (uim_lisp)uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)c_file_poll_internal,
(void *)&args);
free(fds);
return uim_scm_callf("reverse", "o", ret_);
}
static uim_lisp
xml_start_element_handler_internal(const XML_Char *atts[])
{
uim_lisp atts_ = uim_scm_null();
while (*atts != '\0') {
atts_ = CONS(CONS(MAKE_STR(*atts), MAKE_STR(*(atts + 1))), atts_);
atts += 2;
}
return atts_;
}
static uim_lisp
im_acquire_text(uim_lisp uc_, uim_lisp text_id_, uim_lisp origin_,
uim_lisp former_len_, uim_lisp latter_len_)
{
uim_context uc;
int err, former_len, latter_len;
enum UTextArea text_id;
enum UTextOrigin origin;
char *former, *latter, *cv_former, *cv_latter;
uim_lisp former_, latter_;
uc = retrieve_uim_context(uc_);
if (!uc->acquire_text_cb)
return uim_scm_f();
text_id = C_INT(text_id_);
origin = C_INT(origin_);
former_len = C_INT(former_len_);
latter_len = C_INT(latter_len_);
err = uc->acquire_text_cb(uc->ptr, text_id, origin,
former_len, latter_len, &former, &latter);
if (err)
return uim_scm_f();
/* FIXME: string->list is not applied here for each text part. This
* interface should be revised when SigScheme has been introduced to
* uim. Until then, perform character separation by each input methods if
* needed. -- YamaKen 2006-10-07 */
cv_former = uc->conv_if->convert(uc->inbound_conv, former);
cv_latter = uc->conv_if->convert(uc->inbound_conv, latter);
free(former);
free(latter);
former_
= (TEXT_EMPTYP(cv_former)) ? uim_scm_null() : LIST1(MAKE_STR_DIRECTLY(cv_former));
latter_
= (TEXT_EMPTYP(cv_latter)) ? uim_scm_null() : LIST1(MAKE_STR_DIRECTLY(cv_latter));
return uim_scm_callf("ustr-new", "oo", former_, latter_);
}
static uim_lisp
c_file_poll_internal(struct c_file_poll_args *args)
{
int i;
uim_lisp ret_ = uim_scm_null();
struct pollfd *fds = args->fds;
for (i = 0; i < args->nfds; i++)
if (fds[i].revents != 0)
ret_ = CONS(CONS(MAKE_INT(fds[i].fd), MAKE_INT(fds[i].revents)), ret_);
return ret_;
}
static uim_lisp
make_arg_list(const opt_args *list)
{
uim_lisp ret_;
int i = 0;
ret_ = uim_scm_null();
while (list[i].arg != 0) {
ret_ = CONS((uim_lisp)uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)make_arg_cons,
(void *)&list[i]), ret_);
i++;
}
return ret_;
}
/*
* returns possible next characters
* (rk-lib-expect-seq '("k" "y") ja-rk-rule) -> ("o" "e" "u" "i" "a")
*/
static uim_lisp
rk_expect_seq(uim_lisp seq, uim_lisp rules)
{
uim_lisp cur, res = uim_scm_null();
for (cur = rules; !uim_scm_nullp(cur); cur = uim_scm_cdr(cur)) {
uim_lisp rule = uim_scm_car(cur);
uim_lisp key = CAR(CAR(rule));
uim_lisp e = str_seq_partial(seq, key);
if (TRUEP(e)) {
res = uim_scm_cons(e, res);
}
}
return res; /* don't return uim_scm_f() */
}
static uim_lisp
rk_find_partial_seqs(uim_lisp seq, uim_lisp rules)
{
uim_lisp ret = uim_scm_null();
for (; !uim_scm_nullp(rules); rules = uim_scm_cdr(rules)) {
uim_lisp rule = uim_scm_car(rules);
uim_lisp key = uim_scm_car(uim_scm_car(rule));
if (TRUEP(str_seq_partial(seq, key))) {
ret = uim_scm_cons(rule, ret);
}
}
return uim_scm_callf("reverse", "o", ret);
}
static uim_lisp
c_process_waitpid(uim_lisp pid_, uim_lisp options_)
{
uim_lisp ret_ = uim_scm_null();
int status;
ret_ = MAKE_INT(waitpid(C_INT(pid_), &status, C_INT(options_)));
if (WIFEXITED(status))
return LIST5(ret_, uim_scm_t(), uim_scm_f(), uim_scm_f(), MAKE_INT(WEXITSTATUS(status)));
else if (WIFSIGNALED(status))
return LIST5(ret_, uim_scm_f(), uim_scm_t(), uim_scm_f(), MAKE_INT(WTERMSIG(status)));
#ifdef WIFSTOPPED
else if (WIFSTOPPED(status))
return LIST5(ret_, uim_scm_f(), uim_scm_f(), uim_scm_t(), MAKE_INT(WSTOPSIG(status)));
#endif
return LIST5(ret_, uim_scm_f(), uim_scm_f(), uim_scm_f(), MAKE_INT(status));
}
static uim_lisp
uim_look_look(uim_lisp isdict_, uim_lisp iscase_, uim_lisp words_, uim_lisp dict_, uim_lisp str_)
{
const char *dict = REFER_C_STR(dict_);
const char *str = REFER_C_STR(str_);
uim_look_ctx *ctx;
char *dict_str;
uim_lisp ret_ = uim_scm_f();
int words = -1;
ctx = uim_look_init();
uim_look_set_option_dictionary_order(C_BOOL(isdict_), ctx);
uim_look_set_option_ignore_case(C_BOOL(iscase_), ctx);
if (!ctx)
uim_fatal_error("uim_look_init() failed");
if (!uim_look_open_dict(dict, ctx))
return ret_;
dict_str = uim_strdup(str);
if (INTP(words_))
words = C_INT(words_);
ret_ = uim_scm_null();
if (uim_look(dict_str, ctx) != 0) {
struct uim_look_look_internal_args args;
uim_look_set(ctx);
args.ctx = ctx;
args.dict_str = dict_str;
args.words = words;
ret_ = (uim_lisp)uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)uim_look_look_internal,
(void *)&args);
}
uim_look_finish(ctx);
free(dict_str);
return uim_scm_callf("reverse", "o", ret_);
}
static uim_lisp
uim_look_look_internal(struct uim_look_look_internal_args *args)
{
uim_lisp ret_ = uim_scm_null();
int words = args->words;
char buf[8192];
size_t len = strlen(args->dict_str);
while (uim_look_get(args->dict_str, buf, sizeof(buf), args->ctx) != 0) {
/* don't use the word itself */
if (strcasecmp(buf, args->dict_str) == 0)
continue;
if (len < strlen(buf))
ret_ = CONS(MAKE_STR(buf + len), ret_);
if (words != -1) {
words--;
if (words == 0)
break;
}
}
return ret_;
}
void
uim_anthy_utf8_plugin_instance_quit(void)
#endif
{
if (initialized) {
uim_scm_callf("for-each", "vo",
"anthy-utf8-lib-free-context", context_list);
context_list = uim_scm_null();
uim_scm_gc_unprotect(&context_list);
anthy_quit();
initialized = UIM_FALSE;
if (iconv_cd_e2u) {
uim_iconv->release(iconv_cd_e2u);
iconv_cd_e2u = NULL;
}
if (iconv_cd_u2e) {
uim_iconv->release(iconv_cd_u2e);
iconv_cd_u2e = NULL;
}
}
}
/*
* Scheme interfaces
*/
static uim_lisp
notify_get_plugins_internal(void)
{
uim_lisp ret_;
DIR *dirp;
struct dirent *dp;
size_t plen, slen;
const uim_notify_desc *desc;
void *handle;
uim_notify_desc *(*desc_func)(void);
const char *str;
plen = sizeof(NOTIFY_PLUGIN_PREFIX);
slen = sizeof(NOTIFY_PLUGIN_SUFFIX);
desc = uim_notify_stderr_get_desc();
ret_ = CONS(LIST3(MAKE_SYM(desc->name),
MAKE_STR(desc->name),
MAKE_STR(desc->desc)),
uim_scm_null());
if (getenv("UIM_DISABLE_NOTIFY") != NULL)
return uim_scm_callf("reverse", "o", ret_);
dirp = opendir(NOTIFY_PLUGIN_PATH);
if (dirp) {
while ((dp = readdir(dirp)) != NULL) {
size_t len = strlen(dp->d_name);
char path[PATH_MAX];
if ((len < plen + slen - 1) ||
(PATH_MAX < (sizeof(NOTIFY_PLUGIN_PATH "/") + len)) ||
(strcmp(dp->d_name, NOTIFY_PLUGIN_PREFIX) <= 0) ||
(strcmp(dp->d_name + len + 1 - slen, NOTIFY_PLUGIN_SUFFIX) != 0))
continue;
snprintf(path, sizeof(path), "%s/%s", NOTIFY_PLUGIN_PATH, dp->d_name);
handle = dlopen(path, RTLD_NOW);
if ((str = dlerror()) != NULL) {
fprintf(stderr, "load failed %s(%s)\n", path, str);
continue;
}
desc_func = (uim_notify_desc *(*)(void))dlfunc(handle, "uim_notify_plugin_get_desc");
if (!desc_func) {
fprintf(stderr, "cannot found 'uim_notify_get_desc()' in %s\n", path);
dlclose(handle);
continue;
}
desc = desc_func();
ret_ = CONS(LIST3(MAKE_SYM(desc->name),
MAKE_STR(desc->name),
MAKE_STR(desc->desc)),
ret_);
dlclose(handle);
}
(void)closedir(dirp);
}
return uim_scm_callf("reverse", "o", ret_);
}
