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_);
}
