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_);
}
const char *
create_context(const char *args)
{
char *method;
char *lang;
ic_t *ic;
if (!vp_iobuf_get_args(iobuf, args, "ss", &method, &lang))
return vp_iobuf_return(iobuf);
ic = malloc(sizeof(ic_t));
if (ic == NULL)
return "malloc error";
ic->cand_index = 0;
ic->cand_nr = 0;
ic->cand_limit = 0;
ic->cx = uim_create_context(ic, "UTF-8", lang, method, NULL, commit_cb);
if (ic->cx == NULL) {
free(ic);
return "uim_create_context error";
}
/* Install callback functions */
uim_set_preedit_cb(ic->cx,
preedit_clear_cb,
preedit_pushback_cb,
preedit_update_cb);
uim_set_candidate_selector_cb(ic->cx,
candidate_activate_cb,
candidate_select_cb,
candidate_shift_page_cb,
candidate_deactivate_cb);
uim_set_prop_list_update_cb(ic->cx, property_list_update_cb);
/*
* Turn on Input Mode.
* TODO: Use proper method. "action" can be used?
*/
uim_scm_call_with_gc_ready_stack(
(uim_gc_gate_func_ptr)uim_scm_eval_c_string,
(void*)
"(if (and (symbol-bound? 'generic-on-key) generic-on-key)"
" (let* ((id (context-id (car context-list)))"
" (parsed (parse-key-str (car generic-on-key) () -1 0))"
" (key (list-ref parsed 2))"
" (mod (list-ref parsed 3)))"
" (key-press-handler id key mod)"
" (key-release-handler id key mod)"
" ))"
);
vp_iobuf_put_str(iobuf, "create_context");
vp_iobuf_put_ptr(iobuf, ic);
return vp_iobuf_return(iobuf);
}
static uim_lisp
uim_curl_post(uim_lisp url_, uim_lisp post_)
{
struct uim_curl_post_args args;
args.url = url_;
args.post = post_;
return (uim_lisp)uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)uim_curl_post_internal,
&args);
}
static uim_lisp
uim_xml_parse(uim_lisp ctx_, uim_lisp s_, uim_lisp isFinal_)
{
struct uim_xml_parse_args args;
args.ctx_ = ctx_;
args.s_ = s_;
args.isFinal_ = isFinal_;
return uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)uim_xml_parse_internal, (void *)&args);
}
static uim_lisp
dynlib_unbind(uim_lisp lib_ptr,
uim_lisp init_proc,
uim_lisp quit_proc)
{
struct dynlib_unbind_args args;
args.lib_ptr = lib_ptr;
args.init_proc = init_proc;
args.quit_proc = quit_proc;
return uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)dynlib_unbind_internal, (void *)&args);
}
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_;
}
static void
xml_start_element_handler(void *userData, const XML_Char *name, const XML_Char *atts[])
{
uim_xml_userdata *data = (uim_xml_userdata *)userData;
if (data && data->start_) {
uim_lisp atts_;
atts_ = (uim_lisp)uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)xml_start_element_handler_internal,
(void *)atts);
atts_ = uim_scm_callf("reverse", "o", atts_);
uim_scm_call(data->start_, LIST2(MAKE_STR(name), atts_));
}
}
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
c_file_read(uim_lisp d_, uim_lisp nbytes_)
{
unsigned char *buf;
uim_lisp ret_;
int nbytes = C_INT(nbytes_);
int nr;
struct c_file_read_args args;
buf = uim_malloc(nbytes);
if ((nr = read(C_INT(d_), buf, nbytes)) == 0)
return uim_scm_eof();
if (nr < 0)
return uim_scm_f();
args.buf = buf;
args.nr = nr;
ret_ = (uim_lisp)uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)c_file_read_internal,
(void *)&args);
free(buf);
return uim_scm_callf("reverse", "o", ret_);
}
static void
save_default_im(const char *im)
{
if (custom_enabled)
uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)save_default_im_internal, (void *)im);
}
static uim_lisp
dynlib_unbind_all(uim_lisp plugin_alist_)
{
return uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)dynlib_unbind_all_internal, plugin_alist_);
}
static uim_lisp
dynlib_bind(uim_lisp name)
{
return uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)dynlib_bind_internal, (void *)name);
}
static uim_lisp
uim_curl_url_unescape(uim_lisp url_)
{
return (uim_lisp)uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)uim_curl_url_unescape_internal,
(void *)url_);
}
static uim_lisp
notify_get_plugins(void)
{
return (uim_lisp)uim_scm_call_with_gc_ready_stack((uim_gc_gate_func_ptr)notify_get_plugins_internal,
NULL);
}
