diacr->diacr, diacr->base, diacr->result);

    }

    while (i < 256) {

        printf("        { 0x00, 0x00, 0x00 },\n");

        ++i;

    }

    printf("    }\n");

    printf("};\n");

}

#endif /* DUMP_ACCENTS */

​

#ifdef DUMP_KEYMAP

static void SDL_EVDEV_dump_keymap(SDL_EVDEV_keyboard_state *kbd)

{

    int i, j;

​

    for (i = 0; i < MAX_NR_KEYMAPS; ++i) {

        if (kbd->key_maps[i]) {

            printf("static unsigned short default_key_map_%d[NR_KEYS] = {", i);

            for (j = 0; j < NR_KEYS; ++j) {

                if ((j % 8) == 0) {

                    printf("\n    ");

                }

                printf("0x%.4x, ", kbd->key_maps[i][j]);

            }

            printf("\n};\n");

        }

    }

    printf("\n");

    printf("static unsigned short *default_key_maps[MAX_NR_KEYMAPS] = {\n");

    for (i = 0; i < MAX_NR_KEYMAPS; ++i) {

        if (kbd->key_maps[i]) {

            printf("    default_key_map_%d,\n", i);

        } else {

            printf("    NULL,\n");

        }

    }

    printf("};\n");

}

#endif /* DUMP_KEYMAP */

​

static SDL_EVDEV_keyboard_state *kbd_cleanup_state = NULL;

static int kbd_cleanup_sigactions_installed = 0;

static int kbd_cleanup_atexit_installed = 0;

​

static struct sigaction old_sigaction[NSIG];

​

static int fatal_signals[] = {

    /* Handlers for SIGTERM and SIGINT are installed in SDL_InitQuit. */

    SIGHUP, SIGQUIT, SIGILL, SIGABRT,

    SIGFPE, SIGSEGV, SIGPIPE, SIGBUS,

    SIGSYS

};

​

static void kbd_cleanup(void)

{

    SDL_EVDEV_keyboard_state *kbd = kbd_cleanup_state;

    if (!kbd) {

        return;

    }

    kbd_cleanup_state = NULL;

​

    ioctl(kbd->console_fd, KDSKBMODE, kbd->old_kbd_mode);

}

​

static void SDL_EVDEV_kbd_reraise_signal(int sig)

{

    (void)raise(sig);

}

​

static siginfo_t *SDL_EVDEV_kdb_cleanup_siginfo = NULL;

static void *SDL_EVDEV_kdb_cleanup_ucontext = NULL;

​

static void kbd_cleanup_signal_action(int signum, siginfo_t *info, void *ucontext)

{

    struct sigaction *old_action_p = &(old_sigaction[signum]);

    sigset_t sigset;

​

    /* Restore original signal handler before going any further. */

    sigaction(signum, old_action_p, NULL);

​

    /* Unmask current signal. */

    sigemptyset(&sigset);

    sigaddset(&sigset, signum);

    sigprocmask(SIG_UNBLOCK, &sigset, NULL);

​

    /* Save original signal info and context for archeologists. */

    SDL_EVDEV_kdb_cleanup_siginfo = info;

    SDL_EVDEV_kdb_cleanup_ucontext = ucontext;

​

    /* Restore keyboard. */

    kbd_cleanup();

​

    /* Reraise signal. */

    SDL_EVDEV_kbd_reraise_signal(signum);

}

​

static void kbd_unregister_emerg_cleanup(void)

{

    int tabidx;

​

    kbd_cleanup_state = NULL;

​

    if (!kbd_cleanup_sigactions_installed) {

        return;

    }

    kbd_cleanup_sigactions_installed = 0;

​

    for (tabidx = 0; tabidx < sizeof(fatal_signals) / sizeof(fatal_signals[0]); ++tabidx) {

        struct sigaction *old_action_p;

        struct sigaction cur_action;

        int signum = fatal_signals[tabidx];

        old_action_p = &(old_sigaction[signum]);

​

        /* Examine current signal action */

        if (sigaction(signum, NULL, &cur_action)) {

            continue;

        }

​

        /* Check if action installed and not modified */

        if (!(cur_action.sa_flags & SA_SIGINFO) || cur_action.sa_sigaction != &kbd_cleanup_signal_action) {

            continue;

        }

​

        /* Restore original action */

        sigaction(signum, old_action_p, NULL);

    }

}

​

static void kbd_cleanup_atexit(void)

{

    /* Restore keyboard. */

    kbd_cleanup();

​

    /* Try to restore signal handlers in case shared library is being unloaded */

    kbd_unregister_emerg_cleanup();

}

​

static void kbd_register_emerg_cleanup(SDL_EVDEV_keyboard_state *kbd)

{

    int tabidx;

​

    if (kbd_cleanup_state) {

        return;

    }

    kbd_cleanup_state = kbd;

​

    if (!kbd_cleanup_atexit_installed) {

        /* Since glibc 2.2.3, atexit() (and on_exit(3)) can be used within a shared library to establish

         * functions that are called when the shared library is unloaded.

         * -- man atexit(3)

         */

        (void)atexit(kbd_cleanup_atexit);

        kbd_cleanup_atexit_installed = 1;

    }

​

    if (kbd_cleanup_sigactions_installed) {

        return;

    }

    kbd_cleanup_sigactions_installed = 1;

​

    for (tabidx = 0; tabidx < sizeof(fatal_signals) / sizeof(fatal_signals[0]); ++tabidx) {

        struct sigaction *old_action_p;

        struct sigaction new_action;

        int signum = fatal_signals[tabidx];

        old_action_p = &(old_sigaction[signum]);

        if (sigaction(signum, NULL, old_action_p)) {

            continue;

        }

​

        /* Skip SIGHUP and SIGPIPE if handler is already installed

         * - assume the handler will do the cleanup

         */

        if ((signum == SIGHUP || signum == SIGPIPE) && (old_action_p->sa_handler != SIG_DFL || (void (*)(int))old_action_p->sa_sigaction != SIG_DFL)) {

            continue;

        }

​

        new_action = *old_action_p;

        new_action.sa_flags |= SA_SIGINFO;

        new_action.sa_sigaction = &kbd_cleanup_signal_action;

        sigaction(signum, &new_action, NULL);

    }

}

​

enum {

    VT_SIGNAL_NONE,

    VT_SIGNAL_RELEASE,

    VT_SIGNAL_ACQUIRE,

};

static int vt_release_signal;

static int vt_acquire_signal;

static SDL_AtomicInt vt_signal_pending;

​

typedef void (*signal_handler)(int signum);

​

static void kbd_vt_release_signal_action(int signum)

{

    SDL_AtomicSet(&vt_signal_pending, VT_SIGNAL_RELEASE);

}

​

static void kbd_vt_acquire_signal_action(int signum)

{

    SDL_AtomicSet(&vt_signal_pending, VT_SIGNAL_ACQUIRE);

}

​

static SDL_bool setup_vt_signal(int signum, signal_handler handler)

{

    struct sigaction *old_action_p;

    struct sigaction new_action;

    old_action_p = &(old_sigaction[signum]);

    SDL_zero(new_action);

    new_action.sa_handler = handler;

    new_action.sa_flags = SA_RESTART;

    if (sigaction(signum, &new_action, old_action_p) < 0) {

        return SDL_FALSE;

    }

    if (old_action_p->sa_handler != SIG_DFL) {

        /* This signal is already in use */

        sigaction(signum, old_action_p, NULL);