void init_modifier_keys() { int i, k = 0; int min_keycode, max_keycode, keysyms_per_keycode = 0; std::list<KeySym> Mod1MaskSyms, Mod2MaskSyms, Mod3MaskSyms, Mod4MaskSyms, Mod5MaskSyms; gXNumLockMask = 0; XModifierKeymap *map = XGetModifierMapping(XimServer::gDpy); XDisplayKeycodes(XimServer::gDpy, &min_keycode, &max_keycode); KeySym *sym = XGetKeyboardMapping(XimServer::gDpy, static_cast<KeyCode>(min_keycode), (max_keycode - min_keycode + 1), &keysyms_per_keycode); for (i = 0; i < 8; i++) { int j; for (j = 0; j < map->max_keypermod; j++) { if (map->modifiermap[k]) { KeySym ks; int index = 0; do { ks = XkbKeycodeToKeysym(XimServer::gDpy, map->modifiermap[k], 0, index); index++; } while (!ks && index < keysyms_per_keycode); switch (i) { case ShiftMapIndex: break; case LockMapIndex: break; case ControlMapIndex: break; case Mod1MapIndex: Mod1MaskSyms.push_back(ks); break; case Mod2MapIndex: Mod2MaskSyms.push_back(ks); break; case Mod3MapIndex: Mod3MaskSyms.push_back(ks); break; case Mod4MapIndex: Mod4MaskSyms.push_back(ks); break; case Mod5MapIndex: Mod5MaskSyms.push_back(ks); break; default: break; } // Check NumLock key if (ks == XK_Num_Lock) gXNumLockMask |= (1 << i); } k++; } } XFreeModifiermap(map); XFree(sym); gMod1Mask = check_modifier(Mod1MaskSyms); gMod2Mask = check_modifier(Mod2MaskSyms); gMod3Mask = check_modifier(Mod3MaskSyms); gMod4Mask = check_modifier(Mod4MaskSyms); gMod5Mask = check_modifier(Mod5MaskSyms); if (uim_scm_c_bool(uim_scm_callf("require-dynlib", "s", "xkb"))) uim_scm_callf("%xkb-set-display", "p", XimServer::gDpy); #if UIM_XIM_USE_JAPANESE_KANA_KEYBOARD_HACK // Init at here to sync with proper update timing although not a modifier. uim_x_kana_input_hack_init(XimServer::gDpy); #endif }
int main(int argc, char *argv[]) { uim_lisp args, exit_status_; int exit_status; /* TODO: be able to suppress ordinary initialization process */ uim_init(); uim_scm_require_file("uim-sh.scm"); args = uim_scm_null(); exit_status_ = uim_scm_f(); uim_scm_gc_protect(&args); uim_scm_gc_protect(&exit_status_); args = uim_scm_array2list((void **)argv, argc, (uim_lisp (*)(void *))uim_scm_make_str); exit_status_ = uim_scm_callf("uim-sh", "o", args); exit_status = uim_scm_c_int(exit_status_); uim_quit(); return exit_status; }
static uim_lisp create_context(uim_lisp encoding_) { anthy_context_t ac; uim_lisp ac_; int encoding; /* 0: compiled, 1: EUC-JP, 2: UTF-8 */ encoding = C_INT(encoding_); if (!iconv_cd_e2u) iconv_cd_e2u = uim_iconv->create("UTF-8", "EUC-JP"); if (!iconv_cd_u2e) iconv_cd_u2e = uim_iconv->create("EUC-JP", "UTF-8"); ac = anthy_create_context(); if (!ac) uim_fatal_error("anthy_create_context() failed"); anthy_context_set_encoding(ac, encoding); ac_ = MAKE_PTR(ac); context_list = uim_scm_callf("cons", "oo", ac_, context_list); return ac_; }
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_); }
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 long verbose_level(void) { uim_lisp vlevel; vlevel = uim_scm_callf("verbose", ""); return C_INT(vlevel); }
static void save_default_im_internal(const char *im) { uim_scm_callf("custom-set-value!", "yy", "custom-preserved-default-im-name", im); uim_custom_save_custom("custom-preserved-default-im-name"); }
static uim_lisp release_context(uim_lisp ac_) { anthy_context_t ac; context_list = uim_scm_callf("delete!", "oo", ac_, context_list); ac = get_anthy_context(ac_); anthy_release_context(ac); uim_scm_nullify_c_ptr(ac_); 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 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_); }
void uim_init_intl_subrs(void) { intl_init_locale(); uim_scm_init_proc0("gettext-package", intl_gettext_package); uim_scm_init_proc1("textdomain", intl_textdomain); uim_scm_init_proc2("bindtextdomain", intl_bindtextdomain); uim_scm_init_proc2("bind-textdomain-codeset", intl_bind_textdomain_codeset); uim_scm_init_proc1("gettext", intl_gettext); uim_scm_init_proc2("dgettext", intl_dgettext); uim_scm_init_proc3("dcgettext", intl_dcgettext); uim_scm_init_proc3("ngettext", intl_ngettext); uim_scm_init_proc4("dngettext", intl_dngettext); uim_scm_init_proc5("dcngettext", intl_dcngettext); #if ENABLE_NLS uim_scm_callf("provide", "s", "nls"); #endif }
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_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_); }
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_); }