Fix frame height calculations with added menu bar on Windows (Bug#22105)
[emacs.git] / src / keyboard.c
blob02bc7d2a0b710dc48e05d24b35e63300223fb660
1 /* Keyboard and mouse input; editor command loop.
3 Copyright (C) 1985-1989, 1993-1997, 1999-2015 Free Software Foundation,
4 Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
23 #include <sys/stat.h>
25 #include "lisp.h"
26 #include "coding.h"
27 #include "termchar.h"
28 #include "termopts.h"
29 #include "frame.h"
30 #include "termhooks.h"
31 #include "macros.h"
32 #include "keyboard.h"
33 #include "window.h"
34 #include "commands.h"
35 #include "character.h"
36 #include "buffer.h"
37 #include "dispextern.h"
38 #include "syntax.h"
39 #include "intervals.h"
40 #include "keymap.h"
41 #include "blockinput.h"
42 #include "systime.h"
43 #include "atimer.h"
44 #include "process.h"
45 #include <errno.h>
47 #ifdef HAVE_PTHREAD
48 #include <pthread.h>
49 #endif
50 #ifdef MSDOS
51 #include "msdos.h"
52 #include <time.h>
53 #else /* not MSDOS */
54 #include <sys/ioctl.h>
55 #endif /* not MSDOS */
57 #if defined USABLE_FIONREAD && defined USG5_4
58 # include <sys/filio.h>
59 #endif
61 #include "syssignal.h"
63 #include <sys/types.h>
64 #include <unistd.h>
65 #include <fcntl.h>
67 #ifdef HAVE_WINDOW_SYSTEM
68 #include TERM_HEADER
69 #endif /* HAVE_WINDOW_SYSTEM */
71 /* Variables for blockinput.h: */
73 /* Positive if interrupt input is blocked right now. */
74 volatile int interrupt_input_blocked;
76 /* True means an input interrupt or alarm signal has arrived.
77 The QUIT macro checks this. */
78 volatile bool pending_signals;
80 #define KBD_BUFFER_SIZE 4096
82 KBOARD *initial_kboard;
83 KBOARD *current_kboard;
84 static KBOARD *all_kboards;
86 /* True in the single-kboard state, false in the any-kboard state. */
87 static bool single_kboard;
89 #define NUM_RECENT_KEYS (300)
91 /* Index for storing next element into recent_keys. */
92 static int recent_keys_index;
94 /* Total number of elements stored into recent_keys. */
95 static int total_keys;
97 /* This vector holds the last NUM_RECENT_KEYS keystrokes. */
98 static Lisp_Object recent_keys;
100 /* Vector holding the key sequence that invoked the current command.
101 It is reused for each command, and it may be longer than the current
102 sequence; this_command_key_count indicates how many elements
103 actually mean something.
104 It's easier to staticpro a single Lisp_Object than an array. */
105 Lisp_Object this_command_keys;
106 ptrdiff_t this_command_key_count;
108 /* This vector is used as a buffer to record the events that were actually read
109 by read_key_sequence. */
110 static Lisp_Object raw_keybuf;
111 static int raw_keybuf_count;
113 #define GROW_RAW_KEYBUF \
114 if (raw_keybuf_count == ASIZE (raw_keybuf)) \
115 raw_keybuf = larger_vector (raw_keybuf, 1, -1)
117 /* Number of elements of this_command_keys
118 that precede this key sequence. */
119 static ptrdiff_t this_single_command_key_start;
121 #ifdef HAVE_STACK_OVERFLOW_HANDLING
123 /* For longjmp to recover from C stack overflow. */
124 sigjmp_buf return_to_command_loop;
126 /* Message displayed by Vtop_level when recovering from C stack overflow. */
127 static Lisp_Object recover_top_level_message;
129 #endif /* HAVE_STACK_OVERFLOW_HANDLING */
131 /* Message normally displayed by Vtop_level. */
132 static Lisp_Object regular_top_level_message;
134 /* For longjmp to where kbd input is being done. */
136 static sys_jmp_buf getcjmp;
138 /* True while doing kbd input. */
139 bool waiting_for_input;
141 /* True while displaying for echoing. Delays C-g throwing. */
143 static bool echoing;
145 /* Non-null means we can start echoing at the next input pause even
146 though there is something in the echo area. */
148 static struct kboard *ok_to_echo_at_next_pause;
150 /* The kboard last echoing, or null for none. Reset to 0 in
151 cancel_echoing. If non-null, and a current echo area message
152 exists, and echo_message_buffer is eq to the current message
153 buffer, we know that the message comes from echo_kboard. */
155 struct kboard *echo_kboard;
157 /* The buffer used for echoing. Set in echo_now, reset in
158 cancel_echoing. */
160 Lisp_Object echo_message_buffer;
162 /* True means C-g should cause immediate error-signal. */
163 bool immediate_quit;
165 /* Character that causes a quit. Normally C-g.
167 If we are running on an ordinary terminal, this must be an ordinary
168 ASCII char, since we want to make it our interrupt character.
170 If we are not running on an ordinary terminal, it still needs to be
171 an ordinary ASCII char. This character needs to be recognized in
172 the input interrupt handler. At this point, the keystroke is
173 represented as a struct input_event, while the desired quit
174 character is specified as a lispy event. The mapping from struct
175 input_events to lispy events cannot run in an interrupt handler,
176 and the reverse mapping is difficult for anything but ASCII
177 keystrokes.
179 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
180 ASCII character. */
181 int quit_char;
183 /* Current depth in recursive edits. */
184 EMACS_INT command_loop_level;
186 /* If not Qnil, this is a switch-frame event which we decided to put
187 off until the end of a key sequence. This should be read as the
188 next command input, after any unread_command_events.
190 read_key_sequence uses this to delay switch-frame events until the
191 end of the key sequence; Fread_char uses it to put off switch-frame
192 events until a non-ASCII event is acceptable as input. */
193 Lisp_Object unread_switch_frame;
195 /* Last size recorded for a current buffer which is not a minibuffer. */
196 static ptrdiff_t last_non_minibuf_size;
198 /* Total number of times read_char has returned, modulo UINTMAX_MAX + 1. */
199 uintmax_t num_input_events;
201 /* Value of num_nonmacro_input_events as of last auto save. */
203 static EMACS_INT last_auto_save;
205 /* The value of point when the last command was started. */
206 static ptrdiff_t last_point_position;
208 /* The frame in which the last input event occurred, or Qmacro if the
209 last event came from a macro. We use this to determine when to
210 generate switch-frame events. This may be cleared by functions
211 like Fselect_frame, to make sure that a switch-frame event is
212 generated by the next character.
214 FIXME: This is modified by a signal handler so it should be volatile.
215 It's exported to Lisp, though, so it can't simply be marked
216 'volatile' here. */
217 Lisp_Object internal_last_event_frame;
219 /* `read_key_sequence' stores here the command definition of the
220 key sequence that it reads. */
221 static Lisp_Object read_key_sequence_cmd;
222 static Lisp_Object read_key_sequence_remapped;
224 /* File in which we write all commands we read. */
225 static FILE *dribble;
227 /* True if input is available. */
228 bool input_pending;
230 /* True if more input was available last time we read an event.
232 Since redisplay can take a significant amount of time and is not
233 indispensable to perform the user's commands, when input arrives
234 "too fast", Emacs skips redisplay. More specifically, if the next
235 command has already been input when we finish the previous command,
236 we skip the intermediate redisplay.
238 This is useful to try and make sure Emacs keeps up with fast input
239 rates, such as auto-repeating keys. But in some cases, this proves
240 too conservative: we may end up disabling redisplay for the whole
241 duration of a key repetition, even though we could afford to
242 redisplay every once in a while.
244 So we "sample" the input_pending flag before running a command and
245 use *that* value after running the command to decide whether to
246 skip redisplay or not. This way, we only skip redisplay if we
247 really can't keep up with the repeat rate.
249 This only makes a difference if the next input arrives while running the
250 command, which is very unlikely if the command is executed quickly.
251 IOW this tends to avoid skipping redisplay after a long running command
252 (which is a case where skipping redisplay is not very useful since the
253 redisplay time is small compared to the time it took to run the command).
255 A typical use case is when scrolling. Scrolling time can be split into:
256 - Time to do jit-lock on the newly displayed portion of buffer.
257 - Time to run the actual scroll command.
258 - Time to perform the redisplay.
259 Jit-lock can happen either during the command or during the redisplay.
260 In the most painful cases, the jit-lock time is the one that dominates.
261 Also jit-lock can be tweaked (via jit-lock-defer) to delay its job, at the
262 cost of temporary inaccuracy in display and scrolling.
263 So without input_was_pending, what typically happens is the following:
264 - when the command starts, there's no pending input (yet).
265 - the scroll command triggers jit-lock.
266 - during the long jit-lock time the next input arrives.
267 - at the end of the command, we check input_pending and hence decide to
268 skip redisplay.
269 - we read the next input and start over.
270 End result: all the hard work of jit-locking is "wasted" since redisplay
271 doesn't actually happens (at least not before the input rate slows down).
272 With input_was_pending redisplay is still skipped if Emacs can't keep up
273 with the input rate, but if it can keep up just enough that there's no
274 input_pending when we begin the command, then redisplay is not skipped
275 which results in better feedback to the user. */
276 static bool input_was_pending;
278 /* Circular buffer for pre-read keyboard input. */
280 static union buffered_input_event kbd_buffer[KBD_BUFFER_SIZE];
282 /* Pointer to next available character in kbd_buffer.
283 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
284 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
285 next available char is in kbd_buffer[0]. */
286 static union buffered_input_event *kbd_fetch_ptr;
288 /* Pointer to next place to store character in kbd_buffer. This
289 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
290 character should go in kbd_buffer[0]. */
291 static union buffered_input_event *volatile kbd_store_ptr;
293 /* The above pair of variables forms a "queue empty" flag. When we
294 enqueue a non-hook event, we increment kbd_store_ptr. When we
295 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
296 there is input available if the two pointers are not equal.
298 Why not just have a flag set and cleared by the enqueuing and
299 dequeuing functions? Such a flag could be screwed up by interrupts
300 at inopportune times. */
302 static void recursive_edit_unwind (Lisp_Object buffer);
303 static Lisp_Object command_loop (void);
305 static void echo_now (void);
306 static ptrdiff_t echo_length (void);
308 /* Incremented whenever a timer is run. */
309 unsigned timers_run;
311 /* Address (if not 0) of struct timespec to zero out if a SIGIO interrupt
312 happens. */
313 struct timespec *input_available_clear_time;
315 /* True means use SIGIO interrupts; false means use CBREAK mode.
316 Default is true if INTERRUPT_INPUT is defined. */
317 bool interrupt_input;
319 /* Nonzero while interrupts are temporarily deferred during redisplay. */
320 bool interrupts_deferred;
322 /* The time when Emacs started being idle. */
324 static struct timespec timer_idleness_start_time;
326 /* After Emacs stops being idle, this saves the last value
327 of timer_idleness_start_time from when it was idle. */
329 static struct timespec timer_last_idleness_start_time;
332 /* Global variable declarations. */
334 /* Flags for readable_events. */
335 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
336 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
337 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
339 /* Function for init_keyboard to call with no args (if nonzero). */
340 static void (*keyboard_init_hook) (void);
342 static bool get_input_pending (int);
343 static bool readable_events (int);
344 static Lisp_Object read_char_x_menu_prompt (Lisp_Object,
345 Lisp_Object, bool *);
346 static Lisp_Object read_char_minibuf_menu_prompt (int, Lisp_Object);
347 static Lisp_Object make_lispy_event (struct input_event *);
348 static Lisp_Object make_lispy_movement (struct frame *, Lisp_Object,
349 enum scroll_bar_part,
350 Lisp_Object, Lisp_Object,
351 Time);
352 static Lisp_Object modify_event_symbol (ptrdiff_t, int, Lisp_Object,
353 Lisp_Object, const char *const *,
354 Lisp_Object *, ptrdiff_t);
355 static Lisp_Object make_lispy_switch_frame (Lisp_Object);
356 static Lisp_Object make_lispy_focus_in (Lisp_Object);
357 #ifdef HAVE_WINDOW_SYSTEM
358 static Lisp_Object make_lispy_focus_out (Lisp_Object);
359 #endif /* HAVE_WINDOW_SYSTEM */
360 static bool help_char_p (Lisp_Object);
361 static void save_getcjmp (sys_jmp_buf);
362 static void restore_getcjmp (sys_jmp_buf);
363 static Lisp_Object apply_modifiers (int, Lisp_Object);
364 static void restore_kboard_configuration (int);
365 static void handle_interrupt (bool);
366 static _Noreturn void quit_throw_to_read_char (bool);
367 static void timer_start_idle (void);
368 static void timer_stop_idle (void);
369 static void timer_resume_idle (void);
370 static void deliver_user_signal (int);
371 static char *find_user_signal_name (int);
372 static void store_user_signal_events (void);
374 /* These setters are used only in this file, so they can be private. */
375 static void
376 kset_echo_string (struct kboard *kb, Lisp_Object val)
378 kb->echo_string_ = val;
380 static void
381 kset_echo_prompt (struct kboard *kb, Lisp_Object val)
383 kb->echo_prompt_ = val;
385 static void
386 kset_kbd_queue (struct kboard *kb, Lisp_Object val)
388 kb->kbd_queue_ = val;
390 static void
391 kset_keyboard_translate_table (struct kboard *kb, Lisp_Object val)
393 kb->Vkeyboard_translate_table_ = val;
395 static void
396 kset_last_prefix_arg (struct kboard *kb, Lisp_Object val)
398 kb->Vlast_prefix_arg_ = val;
400 static void
401 kset_last_repeatable_command (struct kboard *kb, Lisp_Object val)
403 kb->Vlast_repeatable_command_ = val;
405 static void
406 kset_local_function_key_map (struct kboard *kb, Lisp_Object val)
408 kb->Vlocal_function_key_map_ = val;
410 static void
411 kset_overriding_terminal_local_map (struct kboard *kb, Lisp_Object val)
413 kb->Voverriding_terminal_local_map_ = val;
415 static void
416 kset_real_last_command (struct kboard *kb, Lisp_Object val)
418 kb->Vreal_last_command_ = val;
420 static void
421 kset_system_key_syms (struct kboard *kb, Lisp_Object val)
423 kb->system_key_syms_ = val;
427 /* Add C to the echo string, without echoing it immediately. C can be
428 a character, which is pretty-printed, or a symbol, whose name is
429 printed. */
431 static void
432 echo_add_key (Lisp_Object c)
434 char initbuf[KEY_DESCRIPTION_SIZE + 100];
435 ptrdiff_t size = sizeof initbuf;
436 char *buffer = initbuf;
437 char *ptr = buffer;
438 Lisp_Object echo_string = KVAR (current_kboard, echo_string);
439 USE_SAFE_ALLOCA;
441 if (STRINGP (echo_string) && SCHARS (echo_string) > 0)
442 /* Add a space at the end as a separator between keys. */
443 ptr++[0] = ' ';
445 /* If someone has passed us a composite event, use its head symbol. */
446 c = EVENT_HEAD (c);
448 if (INTEGERP (c))
449 ptr = push_key_description (XINT (c), ptr);
450 else if (SYMBOLP (c))
452 Lisp_Object name = SYMBOL_NAME (c);
453 ptrdiff_t nbytes = SBYTES (name);
455 if (size - (ptr - buffer) < nbytes)
457 ptrdiff_t offset = ptr - buffer;
458 size = max (2 * size, size + nbytes);
459 buffer = SAFE_ALLOCA (size);
460 ptr = buffer + offset;
463 ptr += copy_text (SDATA (name), (unsigned char *) ptr, nbytes,
464 STRING_MULTIBYTE (name), 1);
467 if ((NILP (echo_string) || SCHARS (echo_string) == 0)
468 && help_char_p (c))
470 static const char text[] = " (Type ? for further options)";
471 int len = sizeof text - 1;
473 if (size - (ptr - buffer) < len)
475 ptrdiff_t offset = ptr - buffer;
476 size += len;
477 buffer = SAFE_ALLOCA (size);
478 ptr = buffer + offset;
481 memcpy (ptr, text, len);
482 ptr += len;
485 kset_echo_string
486 (current_kboard,
487 concat2 (echo_string, make_string (buffer, ptr - buffer)));
488 SAFE_FREE ();
491 /* Temporarily add a dash to the end of the echo string if it's not
492 empty, so that it serves as a mini-prompt for the very next
493 character. */
495 static void
496 echo_dash (void)
498 /* Do nothing if not echoing at all. */
499 if (NILP (KVAR (current_kboard, echo_string)))
500 return;
502 if (!current_kboard->immediate_echo
503 && SCHARS (KVAR (current_kboard, echo_string)) == 0)
504 return;
506 /* Do nothing if we just printed a prompt. */
507 if (STRINGP (KVAR (current_kboard, echo_prompt))
508 && (SCHARS (KVAR (current_kboard, echo_prompt))
509 == SCHARS (KVAR (current_kboard, echo_string))))
510 return;
512 /* Do nothing if we have already put a dash at the end. */
513 if (SCHARS (KVAR (current_kboard, echo_string)) > 1)
515 Lisp_Object last_char, prev_char, idx;
517 idx = make_number (SCHARS (KVAR (current_kboard, echo_string)) - 2);
518 prev_char = Faref (KVAR (current_kboard, echo_string), idx);
520 idx = make_number (SCHARS (KVAR (current_kboard, echo_string)) - 1);
521 last_char = Faref (KVAR (current_kboard, echo_string), idx);
523 if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
524 return;
527 /* Put a dash at the end of the buffer temporarily,
528 but make it go away when the next character is added. */
529 AUTO_STRING (dash, "-");
530 kset_echo_string (current_kboard,
531 concat2 (KVAR (current_kboard, echo_string), dash));
532 echo_now ();
535 static void
536 echo_update (void)
538 if (current_kboard->immediate_echo)
540 ptrdiff_t i;
541 Lisp_Object prompt = KVAR (current_kboard, echo_prompt);
542 Lisp_Object prefix = call0 (Qinternal_echo_keystrokes_prefix);
543 kset_echo_string (current_kboard,
544 NILP (prompt) ? prefix
545 : NILP (prefix) ? prompt
546 : concat2 (prompt, prefix));
548 for (i = 0; i < this_command_key_count; i++)
550 Lisp_Object c;
552 c = AREF (this_command_keys, i);
553 if (! (EVENT_HAS_PARAMETERS (c)
554 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
555 echo_add_key (c);
558 echo_now ();
562 /* Display the current echo string, and begin echoing if not already
563 doing so. */
565 static void
566 echo_now (void)
568 if (!current_kboard->immediate_echo)
570 current_kboard->immediate_echo = true;
571 echo_update ();
572 /* Put a dash at the end to invite the user to type more. */
573 echo_dash ();
576 echoing = true;
577 /* FIXME: Use call (Qmessage) so it can be advised (e.g. emacspeak). */
578 message3_nolog (KVAR (current_kboard, echo_string));
579 echoing = false;
581 /* Record in what buffer we echoed, and from which kboard. */
582 echo_message_buffer = echo_area_buffer[0];
583 echo_kboard = current_kboard;
585 if (waiting_for_input && !NILP (Vquit_flag))
586 quit_throw_to_read_char (0);
589 /* Turn off echoing, for the start of a new command. */
591 void
592 cancel_echoing (void)
594 current_kboard->immediate_echo = false;
595 kset_echo_prompt (current_kboard, Qnil);
596 kset_echo_string (current_kboard, Qnil);
597 ok_to_echo_at_next_pause = NULL;
598 echo_kboard = NULL;
599 echo_message_buffer = Qnil;
602 /* Return the length of the current echo string. */
604 static ptrdiff_t
605 echo_length (void)
607 return (STRINGP (KVAR (current_kboard, echo_string))
608 ? SCHARS (KVAR (current_kboard, echo_string))
609 : 0);
612 /* Truncate the current echo message to its first LEN chars.
613 This and echo_char get used by read_key_sequence when the user
614 switches frames while entering a key sequence. */
616 static void
617 echo_truncate (ptrdiff_t nchars)
619 if (STRINGP (KVAR (current_kboard, echo_string)))
620 kset_echo_string (current_kboard,
621 Fsubstring (KVAR (current_kboard, echo_string),
622 make_number (0), make_number (nchars)));
623 truncate_echo_area (nchars);
627 /* Functions for manipulating this_command_keys. */
628 static void
629 add_command_key (Lisp_Object key)
631 if (this_command_key_count >= ASIZE (this_command_keys))
632 this_command_keys = larger_vector (this_command_keys, 1, -1);
634 ASET (this_command_keys, this_command_key_count, key);
635 ++this_command_key_count;
639 Lisp_Object
640 recursive_edit_1 (void)
642 ptrdiff_t count = SPECPDL_INDEX ();
643 Lisp_Object val;
645 if (command_loop_level > 0)
647 specbind (Qstandard_output, Qt);
648 specbind (Qstandard_input, Qt);
651 #ifdef HAVE_WINDOW_SYSTEM
652 /* The command loop has started an hourglass timer, so we have to
653 cancel it here, otherwise it will fire because the recursive edit
654 can take some time. Do not check for display_hourglass_p here,
655 because it could already be nil. */
656 cancel_hourglass ();
657 #endif
659 /* This function may have been called from a debugger called from
660 within redisplay, for instance by Edebugging a function called
661 from fontification-functions. We want to allow redisplay in
662 the debugging session.
664 The recursive edit is left with a `(throw exit ...)'. The `exit'
665 tag is not caught anywhere in redisplay, i.e. when we leave the
666 recursive edit, the original redisplay leading to the recursive
667 edit will be unwound. The outcome should therefore be safe. */
668 specbind (Qinhibit_redisplay, Qnil);
669 redisplaying_p = 0;
671 val = command_loop ();
672 if (EQ (val, Qt))
673 Fsignal (Qquit, Qnil);
674 /* Handle throw from read_minibuf when using minibuffer
675 while it's active but we're in another window. */
676 if (STRINGP (val))
677 xsignal1 (Qerror, val);
679 return unbind_to (count, Qnil);
682 /* When an auto-save happens, record the "time", and don't do again soon. */
684 void
685 record_auto_save (void)
687 last_auto_save = num_nonmacro_input_events;
690 /* Make an auto save happen as soon as possible at command level. */
692 #ifdef SIGDANGER
693 void
694 force_auto_save_soon (void)
696 last_auto_save = - auto_save_interval - 1;
698 record_asynch_buffer_change ();
700 #endif
702 DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
703 doc: /* Invoke the editor command loop recursively.
704 To get out of the recursive edit, a command can throw to `exit' -- for
705 instance (throw \\='exit nil).
706 If you throw a value other than t, `recursive-edit' returns normally
707 to the function that called it. Throwing a t value causes
708 `recursive-edit' to quit, so that control returns to the command loop
709 one level up.
711 This function is called by the editor initialization to begin editing. */)
712 (void)
714 ptrdiff_t count = SPECPDL_INDEX ();
715 Lisp_Object buffer;
717 /* If we enter while input is blocked, don't lock up here.
718 This may happen through the debugger during redisplay. */
719 if (input_blocked_p ())
720 return Qnil;
722 if (command_loop_level >= 0
723 && current_buffer != XBUFFER (XWINDOW (selected_window)->contents))
724 buffer = Fcurrent_buffer ();
725 else
726 buffer = Qnil;
728 /* Don't do anything interesting between the increment and the
729 record_unwind_protect! Otherwise, we could get distracted and
730 never decrement the counter again. */
731 command_loop_level++;
732 update_mode_lines = 17;
733 record_unwind_protect (recursive_edit_unwind, buffer);
735 /* If we leave recursive_edit_1 below with a `throw' for instance,
736 like it is done in the splash screen display, we have to
737 make sure that we restore single_kboard as command_loop_1
738 would have done if it were left normally. */
739 if (command_loop_level > 0)
740 temporarily_switch_to_single_kboard (SELECTED_FRAME ());
742 recursive_edit_1 ();
743 return unbind_to (count, Qnil);
746 void
747 recursive_edit_unwind (Lisp_Object buffer)
749 if (BUFFERP (buffer))
750 Fset_buffer (buffer);
752 command_loop_level--;
753 update_mode_lines = 18;
757 #if 0 /* These two functions are now replaced with
758 temporarily_switch_to_single_kboard. */
759 static void
760 any_kboard_state ()
762 #if 0 /* Theory: if there's anything in Vunread_command_events,
763 it will right away be read by read_key_sequence,
764 and then if we do switch KBOARDS, it will go into the side
765 queue then. So we don't need to do anything special here -- rms. */
766 if (CONSP (Vunread_command_events))
768 current_kboard->kbd_queue
769 = nconc2 (Vunread_command_events, current_kboard->kbd_queue);
770 current_kboard->kbd_queue_has_data = true;
772 Vunread_command_events = Qnil;
773 #endif
774 single_kboard = false;
777 /* Switch to the single-kboard state, making current_kboard
778 the only KBOARD from which further input is accepted. */
780 void
781 single_kboard_state ()
783 single_kboard = true;
785 #endif
787 /* If we're in single_kboard state for kboard KBOARD,
788 get out of it. */
790 void
791 not_single_kboard_state (KBOARD *kboard)
793 if (kboard == current_kboard)
794 single_kboard = false;
797 /* Maintain a stack of kboards, so other parts of Emacs
798 can switch temporarily to the kboard of a given frame
799 and then revert to the previous status. */
801 struct kboard_stack
803 KBOARD *kboard;
804 struct kboard_stack *next;
807 static struct kboard_stack *kboard_stack;
809 void
810 push_kboard (struct kboard *k)
812 struct kboard_stack *p = xmalloc (sizeof *p);
814 p->next = kboard_stack;
815 p->kboard = current_kboard;
816 kboard_stack = p;
818 current_kboard = k;
821 void
822 pop_kboard (void)
824 struct terminal *t;
825 struct kboard_stack *p = kboard_stack;
826 bool found = false;
827 for (t = terminal_list; t; t = t->next_terminal)
829 if (t->kboard == p->kboard)
831 current_kboard = p->kboard;
832 found = true;
833 break;
836 if (!found)
838 /* The terminal we remembered has been deleted. */
839 current_kboard = FRAME_KBOARD (SELECTED_FRAME ());
840 single_kboard = false;
842 kboard_stack = p->next;
843 xfree (p);
846 /* Switch to single_kboard mode, making current_kboard the only KBOARD
847 from which further input is accepted. If F is non-nil, set its
848 KBOARD as the current keyboard.
850 This function uses record_unwind_protect_int to return to the previous
851 state later.
853 If Emacs is already in single_kboard mode, and F's keyboard is
854 locked, then this function will throw an error. */
856 void
857 temporarily_switch_to_single_kboard (struct frame *f)
859 bool was_locked = single_kboard;
860 if (was_locked)
862 if (f != NULL && FRAME_KBOARD (f) != current_kboard)
863 /* We can not switch keyboards while in single_kboard mode.
864 In rare cases, Lisp code may call `recursive-edit' (or
865 `read-minibuffer' or `y-or-n-p') after it switched to a
866 locked frame. For example, this is likely to happen
867 when server.el connects to a new terminal while Emacs is in
868 single_kboard mode. It is best to throw an error instead
869 of presenting the user with a frozen screen. */
870 error ("Terminal %d is locked, cannot read from it",
871 FRAME_TERMINAL (f)->id);
872 else
873 /* This call is unnecessary, but helps
874 `restore_kboard_configuration' discover if somebody changed
875 `current_kboard' behind our back. */
876 push_kboard (current_kboard);
878 else if (f != NULL)
879 current_kboard = FRAME_KBOARD (f);
880 single_kboard = true;
881 record_unwind_protect_int (restore_kboard_configuration, was_locked);
884 #if 0 /* This function is not needed anymore. */
885 void
886 record_single_kboard_state ()
888 if (single_kboard)
889 push_kboard (current_kboard);
890 record_unwind_protect_int (restore_kboard_configuration, single_kboard);
892 #endif
894 static void
895 restore_kboard_configuration (int was_locked)
897 single_kboard = was_locked;
898 if (was_locked)
900 struct kboard *prev = current_kboard;
901 pop_kboard ();
902 /* The pop should not change the kboard. */
903 if (single_kboard && current_kboard != prev)
904 emacs_abort ();
909 /* Handle errors that are not handled at inner levels
910 by printing an error message and returning to the editor command loop. */
912 static Lisp_Object
913 cmd_error (Lisp_Object data)
915 Lisp_Object old_level, old_length;
916 char macroerror[sizeof "After..kbd macro iterations: "
917 + INT_STRLEN_BOUND (EMACS_INT)];
919 #ifdef HAVE_WINDOW_SYSTEM
920 if (display_hourglass_p)
921 cancel_hourglass ();
922 #endif
924 if (!NILP (executing_kbd_macro))
926 if (executing_kbd_macro_iterations == 1)
927 sprintf (macroerror, "After 1 kbd macro iteration: ");
928 else
929 sprintf (macroerror, "After %"pI"d kbd macro iterations: ",
930 executing_kbd_macro_iterations);
932 else
933 *macroerror = 0;
935 Vstandard_output = Qt;
936 Vstandard_input = Qt;
937 Vexecuting_kbd_macro = Qnil;
938 executing_kbd_macro = Qnil;
939 kset_prefix_arg (current_kboard, Qnil);
940 kset_last_prefix_arg (current_kboard, Qnil);
941 cancel_echoing ();
943 /* Avoid unquittable loop if data contains a circular list. */
944 old_level = Vprint_level;
945 old_length = Vprint_length;
946 XSETFASTINT (Vprint_level, 10);
947 XSETFASTINT (Vprint_length, 10);
948 cmd_error_internal (data, macroerror);
949 Vprint_level = old_level;
950 Vprint_length = old_length;
952 Vquit_flag = Qnil;
953 Vinhibit_quit = Qnil;
955 return make_number (0);
958 /* Take actions on handling an error. DATA is the data that describes
959 the error.
961 CONTEXT is a C-string containing ASCII characters only which
962 describes the context in which the error happened. If we need to
963 generalize CONTEXT to allow multibyte characters, make it a Lisp
964 string. */
966 void
967 cmd_error_internal (Lisp_Object data, const char *context)
969 /* The immediate context is not interesting for Quits,
970 since they are asynchronous. */
971 if (EQ (XCAR (data), Qquit))
972 Vsignaling_function = Qnil;
974 Vquit_flag = Qnil;
975 Vinhibit_quit = Qt;
977 /* Use user's specified output function if any. */
978 if (!NILP (Vcommand_error_function))
979 call3 (Vcommand_error_function, data,
980 context ? build_string (context) : empty_unibyte_string,
981 Vsignaling_function);
983 Vsignaling_function = Qnil;
986 DEFUN ("command-error-default-function", Fcommand_error_default_function,
987 Scommand_error_default_function, 3, 3, 0,
988 doc: /* Produce default output for unhandled error message.
989 Default value of `command-error-function'. */)
990 (Lisp_Object data, Lisp_Object context, Lisp_Object signal)
992 struct frame *sf = SELECTED_FRAME ();
994 CHECK_STRING (context);
996 /* If the window system or terminal frame hasn't been initialized
997 yet, or we're not interactive, write the message to stderr and exit. */
998 if (!sf->glyphs_initialized_p
999 /* The initial frame is a special non-displaying frame. It
1000 will be current in daemon mode when there are no frames
1001 to display, and in non-daemon mode before the real frame
1002 has finished initializing. If an error is thrown in the
1003 latter case while creating the frame, then the frame
1004 will never be displayed, so the safest thing to do is
1005 write to stderr and quit. In daemon mode, there are
1006 many other potential errors that do not prevent frames
1007 from being created, so continuing as normal is better in
1008 that case. */
1009 || (!IS_DAEMON && FRAME_INITIAL_P (sf))
1010 || noninteractive)
1012 print_error_message (data, Qexternal_debugging_output,
1013 SSDATA (context), signal);
1014 Fterpri (Qexternal_debugging_output, Qnil);
1015 Fkill_emacs (make_number (-1));
1017 else
1019 clear_message (1, 0);
1020 Fdiscard_input ();
1021 message_log_maybe_newline ();
1022 bitch_at_user ();
1024 print_error_message (data, Qt, SSDATA (context), signal);
1026 return Qnil;
1029 static Lisp_Object command_loop_2 (Lisp_Object);
1030 static Lisp_Object top_level_1 (Lisp_Object);
1032 /* Entry to editor-command-loop.
1033 This level has the catches for exiting/returning to editor command loop.
1034 It returns nil to exit recursive edit, t to abort it. */
1036 Lisp_Object
1037 command_loop (void)
1039 #ifdef HAVE_STACK_OVERFLOW_HANDLING
1040 /* At least on GNU/Linux, saving signal mask is important here. */
1041 if (sigsetjmp (return_to_command_loop, 1) != 0)
1043 /* Comes here from handle_sigsegv (see sysdep.c) and
1044 stack_overflow_handler (see w32fns.c). */
1045 #ifdef WINDOWSNT
1046 w32_reset_stack_overflow_guard ();
1047 #endif
1048 init_eval ();
1049 Vinternal__top_level_message = recover_top_level_message;
1051 else
1052 Vinternal__top_level_message = regular_top_level_message;
1053 #endif /* HAVE_STACK_OVERFLOW_HANDLING */
1054 if (command_loop_level > 0 || minibuf_level > 0)
1056 Lisp_Object val;
1057 val = internal_catch (Qexit, command_loop_2, Qnil);
1058 executing_kbd_macro = Qnil;
1059 return val;
1061 else
1062 while (1)
1064 internal_catch (Qtop_level, top_level_1, Qnil);
1065 internal_catch (Qtop_level, command_loop_2, Qnil);
1066 executing_kbd_macro = Qnil;
1068 /* End of file in -batch run causes exit here. */
1069 if (noninteractive)
1070 Fkill_emacs (Qt);
1074 /* Here we catch errors in execution of commands within the
1075 editing loop, and reenter the editing loop.
1076 When there is an error, cmd_error runs and returns a non-nil
1077 value to us. A value of nil means that command_loop_1 itself
1078 returned due to end of file (or end of kbd macro). */
1080 static Lisp_Object
1081 command_loop_2 (Lisp_Object ignore)
1083 register Lisp_Object val;
1086 val = internal_condition_case (command_loop_1, Qerror, cmd_error);
1087 while (!NILP (val));
1089 return Qnil;
1092 static Lisp_Object
1093 top_level_2 (void)
1095 return Feval (Vtop_level, Qnil);
1098 static Lisp_Object
1099 top_level_1 (Lisp_Object ignore)
1101 /* On entry to the outer level, run the startup file. */
1102 if (!NILP (Vtop_level))
1103 internal_condition_case (top_level_2, Qerror, cmd_error);
1104 else if (!NILP (Vpurify_flag))
1105 message1 ("Bare impure Emacs (standard Lisp code not loaded)");
1106 else
1107 message1 ("Bare Emacs (standard Lisp code not loaded)");
1108 return Qnil;
1111 DEFUN ("top-level", Ftop_level, Stop_level, 0, 0, "",
1112 doc: /* Exit all recursive editing levels.
1113 This also exits all active minibuffers. */
1114 attributes: noreturn)
1115 (void)
1117 #ifdef HAVE_WINDOW_SYSTEM
1118 if (display_hourglass_p)
1119 cancel_hourglass ();
1120 #endif
1122 /* Unblock input if we enter with input blocked. This may happen if
1123 redisplay traps e.g. during tool-bar update with input blocked. */
1124 totally_unblock_input ();
1126 Fthrow (Qtop_level, Qnil);
1129 static _Noreturn void
1130 user_error (const char *msg)
1132 xsignal1 (Quser_error, build_string (msg));
1135 /* _Noreturn will be added to prototype by make-docfile. */
1136 DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
1137 doc: /* Exit from the innermost recursive edit or minibuffer. */
1138 attributes: noreturn)
1139 (void)
1141 if (command_loop_level > 0 || minibuf_level > 0)
1142 Fthrow (Qexit, Qnil);
1144 user_error ("No recursive edit is in progress");
1147 /* _Noreturn will be added to prototype by make-docfile. */
1148 DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0, 0, "",
1149 doc: /* Abort the command that requested this recursive edit or minibuffer input. */
1150 attributes: noreturn)
1151 (void)
1153 if (command_loop_level > 0 || minibuf_level > 0)
1154 Fthrow (Qexit, Qt);
1156 user_error ("No recursive edit is in progress");
1159 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1160 of this function. */
1162 static void
1163 tracking_off (Lisp_Object old_value)
1165 do_mouse_tracking = old_value;
1166 if (NILP (old_value))
1168 /* Redisplay may have been preempted because there was input
1169 available, and it assumes it will be called again after the
1170 input has been processed. If the only input available was
1171 the sort that we have just disabled, then we need to call
1172 redisplay. */
1173 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW))
1175 redisplay_preserve_echo_area (6);
1176 get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
1181 DEFUN ("internal--track-mouse", Ftrack_mouse, Strack_mouse, 1, 1, 0,
1182 doc: /* Call BODYFUN with mouse movement events enabled. */)
1183 (Lisp_Object bodyfun)
1185 ptrdiff_t count = SPECPDL_INDEX ();
1186 Lisp_Object val;
1188 record_unwind_protect (tracking_off, do_mouse_tracking);
1190 do_mouse_tracking = Qt;
1192 val = call0 (bodyfun);
1193 return unbind_to (count, val);
1196 /* If mouse has moved on some frame, return one of those frames.
1198 Return 0 otherwise.
1200 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1201 after resizing the tool-bar window. */
1203 bool ignore_mouse_drag_p;
1205 static struct frame *
1206 some_mouse_moved (void)
1208 Lisp_Object tail, frame;
1210 if (ignore_mouse_drag_p)
1212 /* ignore_mouse_drag_p = 0; */
1213 return 0;
1216 FOR_EACH_FRAME (tail, frame)
1218 if (XFRAME (frame)->mouse_moved)
1219 return XFRAME (frame);
1222 return 0;
1226 /* This is the actual command reading loop,
1227 sans error-handling encapsulation. */
1229 static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
1230 bool, bool, bool, bool);
1231 static void adjust_point_for_property (ptrdiff_t, bool);
1233 Lisp_Object
1234 command_loop_1 (void)
1236 Lisp_Object cmd;
1237 Lisp_Object keybuf[30];
1238 int i;
1239 EMACS_INT prev_modiff = 0;
1240 struct buffer *prev_buffer = NULL;
1241 bool already_adjusted = 0;
1243 kset_prefix_arg (current_kboard, Qnil);
1244 kset_last_prefix_arg (current_kboard, Qnil);
1245 Vdeactivate_mark = Qnil;
1246 waiting_for_input = false;
1247 cancel_echoing ();
1249 this_command_key_count = 0;
1250 this_single_command_key_start = 0;
1252 if (NILP (Vmemory_full))
1254 /* Make sure this hook runs after commands that get errors and
1255 throw to top level. */
1256 /* Note that the value cell will never directly contain nil
1257 if the symbol is a local variable. */
1258 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
1259 safe_run_hooks (Qpost_command_hook);
1261 /* If displaying a message, resize the echo area window to fit
1262 that message's size exactly. */
1263 if (!NILP (echo_area_buffer[0]))
1264 resize_echo_area_exactly ();
1266 /* If there are warnings waiting, process them. */
1267 if (!NILP (Vdelayed_warnings_list))
1268 safe_run_hooks (Qdelayed_warnings_hook);
1270 if (!NILP (Vdeferred_action_list))
1271 safe_run_hooks (Qdeferred_action_function);
1274 /* Do this after running Vpost_command_hook, for consistency. */
1275 kset_last_command (current_kboard, Vthis_command);
1276 kset_real_last_command (current_kboard, Vreal_this_command);
1277 if (!CONSP (last_command_event))
1278 kset_last_repeatable_command (current_kboard, Vreal_this_command);
1280 while (1)
1282 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1283 Fkill_emacs (Qnil);
1285 /* Make sure the current window's buffer is selected. */
1286 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->contents));
1288 /* Display any malloc warning that just came out. Use while because
1289 displaying one warning can cause another. */
1291 while (pending_malloc_warning)
1292 display_malloc_warning ();
1294 Vdeactivate_mark = Qnil;
1296 /* Don't ignore mouse movements for more than a single command
1297 loop. (This flag is set in xdisp.c whenever the tool bar is
1298 resized, because the resize moves text up or down, and would
1299 generate false mouse drag events if we don't ignore them.) */
1300 ignore_mouse_drag_p = 0;
1302 /* If minibuffer on and echo area in use,
1303 wait a short time and redraw minibuffer. */
1305 if (minibuf_level
1306 && !NILP (echo_area_buffer[0])
1307 && EQ (minibuf_window, echo_area_window)
1308 && NUMBERP (Vminibuffer_message_timeout))
1310 /* Bind inhibit-quit to t so that C-g gets read in
1311 rather than quitting back to the minibuffer. */
1312 ptrdiff_t count = SPECPDL_INDEX ();
1313 specbind (Qinhibit_quit, Qt);
1315 sit_for (Vminibuffer_message_timeout, 0, 2);
1317 /* Clear the echo area. */
1318 message1 (0);
1319 safe_run_hooks (Qecho_area_clear_hook);
1321 unbind_to (count, Qnil);
1323 /* If a C-g came in before, treat it as input now. */
1324 if (!NILP (Vquit_flag))
1326 Vquit_flag = Qnil;
1327 Vunread_command_events = list1 (make_number (quit_char));
1331 /* If it has changed current-menubar from previous value,
1332 really recompute the menubar from the value. */
1333 if (! NILP (Vlucid_menu_bar_dirty_flag)
1334 && !NILP (Ffboundp (Qrecompute_lucid_menubar)))
1335 call0 (Qrecompute_lucid_menubar);
1337 Vthis_command = Qnil;
1338 Vreal_this_command = Qnil;
1339 Vthis_original_command = Qnil;
1340 Vthis_command_keys_shift_translated = Qnil;
1342 /* Read next key sequence; i gets its length. */
1343 i = read_key_sequence (keybuf, ARRAYELTS (keybuf),
1344 Qnil, 0, 1, 1, 0);
1346 /* A filter may have run while we were reading the input. */
1347 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1348 Fkill_emacs (Qnil);
1349 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->contents));
1351 ++num_input_keys;
1353 /* Now we have read a key sequence of length I,
1354 or else I is 0 and we found end of file. */
1356 if (i == 0) /* End of file -- happens only in */
1357 return Qnil; /* a kbd macro, at the end. */
1358 /* -1 means read_key_sequence got a menu that was rejected.
1359 Just loop around and read another command. */
1360 if (i == -1)
1362 cancel_echoing ();
1363 this_command_key_count = 0;
1364 this_single_command_key_start = 0;
1365 goto finalize;
1368 last_command_event = keybuf[i - 1];
1370 /* If the previous command tried to force a specific window-start,
1371 forget about that, in case this command moves point far away
1372 from that position. But also throw away beg_unchanged and
1373 end_unchanged information in that case, so that redisplay will
1374 update the whole window properly. */
1375 if (XWINDOW (selected_window)->force_start)
1377 struct buffer *b;
1378 XWINDOW (selected_window)->force_start = 0;
1379 b = XBUFFER (XWINDOW (selected_window)->contents);
1380 BUF_BEG_UNCHANGED (b) = BUF_END_UNCHANGED (b) = 0;
1383 cmd = read_key_sequence_cmd;
1384 if (!NILP (Vexecuting_kbd_macro))
1386 if (!NILP (Vquit_flag))
1388 Vexecuting_kbd_macro = Qt;
1389 QUIT; /* Make some noise. */
1390 /* Will return since macro now empty. */
1394 /* Do redisplay processing after this command except in special
1395 cases identified below. */
1396 prev_buffer = current_buffer;
1397 prev_modiff = MODIFF;
1398 last_point_position = PT;
1400 /* By default, we adjust point to a boundary of a region that
1401 has such a property that should be treated intangible
1402 (e.g. composition, display). But, some commands will set
1403 this variable differently. */
1404 Vdisable_point_adjustment = Qnil;
1406 /* Process filters and timers may have messed with deactivate-mark.
1407 reset it before we execute the command. */
1408 Vdeactivate_mark = Qnil;
1410 /* Remap command through active keymaps. */
1411 Vthis_original_command = cmd;
1412 if (!NILP (read_key_sequence_remapped))
1413 cmd = read_key_sequence_remapped;
1415 /* Execute the command. */
1418 total_keys += total_keys < NUM_RECENT_KEYS;
1419 ASET (recent_keys, recent_keys_index,
1420 Fcons (Qnil, cmd));
1421 if (++recent_keys_index >= NUM_RECENT_KEYS)
1422 recent_keys_index = 0;
1424 Vthis_command = cmd;
1425 Vreal_this_command = cmd;
1426 safe_run_hooks (Qpre_command_hook);
1428 already_adjusted = 0;
1430 if (NILP (Vthis_command))
1431 /* nil means key is undefined. */
1432 call0 (Qundefined);
1433 else
1435 /* Here for a command that isn't executed directly. */
1437 #ifdef HAVE_WINDOW_SYSTEM
1438 ptrdiff_t scount = SPECPDL_INDEX ();
1440 if (display_hourglass_p
1441 && NILP (Vexecuting_kbd_macro))
1443 record_unwind_protect_void (cancel_hourglass);
1444 start_hourglass ();
1446 #endif
1448 /* Ensure that we have added appropriate undo-boundaries as a
1449 result of changes from the last command. */
1450 call0 (Qundo_auto__add_boundary);
1452 /* Record point and buffer, so we can put point into the undo
1453 information if necessary. */
1454 point_before_last_command_or_undo = PT;
1455 buffer_before_last_command_or_undo = current_buffer;
1457 call1 (Qcommand_execute, Vthis_command);
1459 #ifdef HAVE_WINDOW_SYSTEM
1460 /* Do not check display_hourglass_p here, because
1461 `command-execute' could change it, but we should cancel
1462 hourglass cursor anyway.
1463 But don't cancel the hourglass within a macro
1464 just because a command in the macro finishes. */
1465 if (NILP (Vexecuting_kbd_macro))
1466 unbind_to (scount, Qnil);
1467 #endif
1469 kset_last_prefix_arg (current_kboard, Vcurrent_prefix_arg);
1471 safe_run_hooks (Qpost_command_hook);
1473 /* If displaying a message, resize the echo area window to fit
1474 that message's size exactly. */
1475 if (!NILP (echo_area_buffer[0]))
1476 resize_echo_area_exactly ();
1478 /* If there are warnings waiting, process them. */
1479 if (!NILP (Vdelayed_warnings_list))
1480 safe_run_hooks (Qdelayed_warnings_hook);
1482 safe_run_hooks (Qdeferred_action_function);
1484 kset_last_command (current_kboard, Vthis_command);
1485 kset_real_last_command (current_kboard, Vreal_this_command);
1486 if (!CONSP (last_command_event))
1487 kset_last_repeatable_command (current_kboard, Vreal_this_command);
1489 this_command_key_count = 0;
1490 this_single_command_key_start = 0;
1492 if (current_kboard->immediate_echo
1493 && !NILP (call0 (Qinternal_echo_keystrokes_prefix)))
1495 current_kboard->immediate_echo = false;
1496 /* Refresh the echo message. */
1497 echo_now ();
1499 else
1500 cancel_echoing ();
1502 if (!NILP (BVAR (current_buffer, mark_active))
1503 && !NILP (Vrun_hooks))
1505 /* In Emacs 22, setting transient-mark-mode to `only' was a
1506 way of turning it on for just one command. This usage is
1507 obsolete, but support it anyway. */
1508 if (EQ (Vtransient_mark_mode, Qidentity))
1509 Vtransient_mark_mode = Qnil;
1510 else if (EQ (Vtransient_mark_mode, Qonly))
1511 Vtransient_mark_mode = Qidentity;
1513 if (!NILP (Vdeactivate_mark))
1514 /* If `select-active-regions' is non-nil, this call to
1515 `deactivate-mark' also sets the PRIMARY selection. */
1516 call0 (Qdeactivate_mark);
1517 else
1519 /* Even if not deactivating the mark, set PRIMARY if
1520 `select-active-regions' is non-nil. */
1521 if (!NILP (Fwindow_system (Qnil))
1522 /* Even if mark_active is non-nil, the actual buffer
1523 marker may not have been set yet (Bug#7044). */
1524 && XMARKER (BVAR (current_buffer, mark))->buffer
1525 && (EQ (Vselect_active_regions, Qonly)
1526 ? EQ (CAR_SAFE (Vtransient_mark_mode), Qonly)
1527 : (!NILP (Vselect_active_regions)
1528 && !NILP (Vtransient_mark_mode)))
1529 && NILP (Fmemq (Vthis_command,
1530 Vselection_inhibit_update_commands)))
1532 Lisp_Object txt
1533 = call1 (Fsymbol_value (Qregion_extract_function), Qnil);
1534 if (XINT (Flength (txt)) > 0)
1535 /* Don't set empty selections. */
1536 call2 (Qgui_set_selection, QPRIMARY, txt);
1539 if (current_buffer != prev_buffer || MODIFF != prev_modiff)
1540 run_hook (intern ("activate-mark-hook"));
1543 Vsaved_region_selection = Qnil;
1546 finalize:
1548 if (current_buffer == prev_buffer
1549 && XBUFFER (XWINDOW (selected_window)->contents) == current_buffer
1550 && last_point_position != PT
1551 && NILP (Vdisable_point_adjustment)
1552 && NILP (Vglobal_disable_point_adjustment))
1554 if (last_point_position > BEGV
1555 && last_point_position < ZV
1556 && (composition_adjust_point (last_point_position,
1557 last_point_position)
1558 != last_point_position))
1559 /* The last point was temporarily set within a grapheme
1560 cluster to prevent automatic composition. To recover
1561 the automatic composition, we must update the
1562 display. */
1563 windows_or_buffers_changed = 21;
1564 if (!already_adjusted)
1565 adjust_point_for_property (last_point_position,
1566 MODIFF != prev_modiff);
1569 /* Install chars successfully executed in kbd macro. */
1571 if (!NILP (KVAR (current_kboard, defining_kbd_macro))
1572 && NILP (KVAR (current_kboard, Vprefix_arg)))
1573 finalize_kbd_macro_chars ();
1577 Lisp_Object
1578 read_menu_command (void)
1580 Lisp_Object keybuf[30];
1581 ptrdiff_t count = SPECPDL_INDEX ();
1582 int i;
1584 /* We don't want to echo the keystrokes while navigating the
1585 menus. */
1586 specbind (Qecho_keystrokes, make_number (0));
1588 i = read_key_sequence (keybuf, ARRAYELTS (keybuf),
1589 Qnil, 0, 1, 1, 1);
1591 unbind_to (count, Qnil);
1593 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1594 Fkill_emacs (Qnil);
1595 if (i == 0 || i == -1)
1596 return Qt;
1598 return read_key_sequence_cmd;
1601 /* Adjust point to a boundary of a region that has such a property
1602 that should be treated intangible. For the moment, we check
1603 `composition', `display' and `invisible' properties.
1604 LAST_PT is the last position of point. */
1606 static void
1607 adjust_point_for_property (ptrdiff_t last_pt, bool modified)
1609 ptrdiff_t beg, end;
1610 Lisp_Object val, overlay, tmp;
1611 /* When called after buffer modification, we should temporarily
1612 suppress the point adjustment for automatic composition so that a
1613 user can keep inserting another character at point or keep
1614 deleting characters around point. */
1615 bool check_composition = ! modified;
1616 bool check_display = true, check_invisible = true;
1617 ptrdiff_t orig_pt = PT;
1619 eassert (XBUFFER (XWINDOW (selected_window)->contents) == current_buffer);
1621 /* FIXME: cycling is probably not necessary because these properties
1622 can't be usefully combined anyway. */
1623 while (check_composition || check_display || check_invisible)
1625 /* FIXME: check `intangible'. */
1626 if (check_composition
1627 && PT > BEGV && PT < ZV
1628 && (beg = composition_adjust_point (last_pt, PT)) != PT)
1630 SET_PT (beg);
1631 check_display = check_invisible = true;
1633 check_composition = false;
1634 if (check_display
1635 && PT > BEGV && PT < ZV
1636 && !NILP (val = get_char_property_and_overlay
1637 (make_number (PT), Qdisplay, selected_window,
1638 &overlay))
1639 && display_prop_intangible_p (val, overlay, PT, PT_BYTE)
1640 && (!OVERLAYP (overlay)
1641 ? get_property_and_range (PT, Qdisplay, &val, &beg, &end, Qnil)
1642 : (beg = OVERLAY_POSITION (OVERLAY_START (overlay)),
1643 end = OVERLAY_POSITION (OVERLAY_END (overlay))))
1644 && (beg < PT /* && end > PT <- It's always the case. */
1645 || (beg <= PT && STRINGP (val) && SCHARS (val) == 0)))
1647 eassert (end > PT);
1648 SET_PT (PT < last_pt
1649 ? (STRINGP (val) && SCHARS (val) == 0
1650 ? max (beg - 1, BEGV)
1651 : beg)
1652 : end);
1653 check_composition = check_invisible = true;
1655 check_display = false;
1656 if (check_invisible && PT > BEGV && PT < ZV)
1658 int inv;
1659 bool ellipsis = false;
1660 beg = end = PT;
1662 /* Find boundaries `beg' and `end' of the invisible area, if any. */
1663 while (end < ZV
1664 #if 0
1665 /* FIXME: We should stop if we find a spot between
1666 two runs of `invisible' where inserted text would
1667 be visible. This is important when we have two
1668 invisible boundaries that enclose an area: if the
1669 area is empty, we need this test in order to make
1670 it possible to place point in the middle rather
1671 than skip both boundaries. However, this code
1672 also stops anywhere in a non-sticky text-property,
1673 which breaks (e.g.) Org mode. */
1674 && (val = Fget_pos_property (make_number (end),
1675 Qinvisible, Qnil),
1676 TEXT_PROP_MEANS_INVISIBLE (val))
1677 #endif
1678 && !NILP (val = get_char_property_and_overlay
1679 (make_number (end), Qinvisible, Qnil, &overlay))
1680 && (inv = TEXT_PROP_MEANS_INVISIBLE (val)))
1682 ellipsis = ellipsis || inv > 1
1683 || (OVERLAYP (overlay)
1684 && (!NILP (Foverlay_get (overlay, Qafter_string))
1685 || !NILP (Foverlay_get (overlay, Qbefore_string))));
1686 tmp = Fnext_single_char_property_change
1687 (make_number (end), Qinvisible, Qnil, Qnil);
1688 end = NATNUMP (tmp) ? XFASTINT (tmp) : ZV;
1690 while (beg > BEGV
1691 #if 0
1692 && (val = Fget_pos_property (make_number (beg),
1693 Qinvisible, Qnil),
1694 TEXT_PROP_MEANS_INVISIBLE (val))
1695 #endif
1696 && !NILP (val = get_char_property_and_overlay
1697 (make_number (beg - 1), Qinvisible, Qnil, &overlay))
1698 && (inv = TEXT_PROP_MEANS_INVISIBLE (val)))
1700 ellipsis = ellipsis || inv > 1
1701 || (OVERLAYP (overlay)
1702 && (!NILP (Foverlay_get (overlay, Qafter_string))
1703 || !NILP (Foverlay_get (overlay, Qbefore_string))));
1704 tmp = Fprevious_single_char_property_change
1705 (make_number (beg), Qinvisible, Qnil, Qnil);
1706 beg = NATNUMP (tmp) ? XFASTINT (tmp) : BEGV;
1709 /* Move away from the inside area. */
1710 if (beg < PT && end > PT)
1712 SET_PT ((orig_pt == PT && (last_pt < beg || last_pt > end))
1713 /* We haven't moved yet (so we don't need to fear
1714 infinite-looping) and we were outside the range
1715 before (so either end of the range still corresponds
1716 to a move in the right direction): pretend we moved
1717 less than we actually did, so that we still have
1718 more freedom below in choosing which end of the range
1719 to go to. */
1720 ? (orig_pt = -1, PT < last_pt ? end : beg)
1721 /* We either have moved already or the last point
1722 was already in the range: we don't get to choose
1723 which end of the range we have to go to. */
1724 : (PT < last_pt ? beg : end));
1725 check_composition = check_display = true;
1727 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
1728 the point to something other than its argument, due to
1729 point-motion hooks, intangibility, etc. */
1730 eassert (PT == beg || PT == end);
1731 #endif
1733 /* Pretend the area doesn't exist if the buffer is not
1734 modified. */
1735 if (!modified && !ellipsis && beg < end)
1737 if (last_pt == beg && PT == end && end < ZV)
1738 (check_composition = check_display = true, SET_PT (end + 1));
1739 else if (last_pt == end && PT == beg && beg > BEGV)
1740 (check_composition = check_display = true, SET_PT (beg - 1));
1741 else if (PT == ((PT < last_pt) ? beg : end))
1742 /* We've already moved as far as we can. Trying to go
1743 to the other end would mean moving backwards and thus
1744 could lead to an infinite loop. */
1746 else if (val = Fget_pos_property (make_number (PT),
1747 Qinvisible, Qnil),
1748 TEXT_PROP_MEANS_INVISIBLE (val)
1749 && (val = (Fget_pos_property
1750 (make_number (PT == beg ? end : beg),
1751 Qinvisible, Qnil)),
1752 !TEXT_PROP_MEANS_INVISIBLE (val)))
1753 (check_composition = check_display = true,
1754 SET_PT (PT == beg ? end : beg));
1757 check_invisible = false;
1761 /* Subroutine for safe_run_hooks: run the hook, which is ARGS[1]. */
1763 static Lisp_Object
1764 safe_run_hooks_1 (ptrdiff_t nargs, Lisp_Object *args)
1766 eassert (nargs == 2);
1767 return call0 (args[1]);
1770 /* Subroutine for safe_run_hooks: handle an error by clearing out the function
1771 from the hook. */
1773 static Lisp_Object
1774 safe_run_hooks_error (Lisp_Object error, ptrdiff_t nargs, Lisp_Object *args)
1776 eassert (nargs == 2);
1777 AUTO_STRING (format, "Error in %s (%S): %S");
1778 Lisp_Object hook = args[0];
1779 Lisp_Object fun = args[1];
1780 CALLN (Fmessage, format, hook, fun, error);
1782 if (SYMBOLP (hook))
1784 Lisp_Object val;
1785 bool found = false;
1786 Lisp_Object newval = Qnil;
1787 for (val = find_symbol_value (hook); CONSP (val); val = XCDR (val))
1788 if (EQ (fun, XCAR (val)))
1789 found = true;
1790 else
1791 newval = Fcons (XCAR (val), newval);
1792 if (found)
1793 return Fset (hook, Fnreverse (newval));
1794 /* Not found in the local part of the hook. Let's look at the global
1795 part. */
1796 newval = Qnil;
1797 for (val = (NILP (Fdefault_boundp (hook)) ? Qnil
1798 : Fdefault_value (hook));
1799 CONSP (val); val = XCDR (val))
1800 if (EQ (fun, XCAR (val)))
1801 found = true;
1802 else
1803 newval = Fcons (XCAR (val), newval);
1804 if (found)
1805 return Fset_default (hook, Fnreverse (newval));
1807 return Qnil;
1810 static Lisp_Object
1811 safe_run_hook_funcall (ptrdiff_t nargs, Lisp_Object *args)
1813 eassert (nargs == 2);
1814 /* Yes, run_hook_with_args works with args in the other order. */
1815 internal_condition_case_n (safe_run_hooks_1,
1816 2, ((Lisp_Object []) {args[1], args[0]}),
1817 Qt, safe_run_hooks_error);
1818 return Qnil;
1821 /* If we get an error while running the hook, cause the hook variable
1822 to be nil. Also inhibit quits, so that C-g won't cause the hook
1823 to mysteriously evaporate. */
1825 void
1826 safe_run_hooks (Lisp_Object hook)
1828 ptrdiff_t count = SPECPDL_INDEX ();
1830 specbind (Qinhibit_quit, Qt);
1831 run_hook_with_args (2, ((Lisp_Object []) {hook, hook}), safe_run_hook_funcall);
1832 unbind_to (count, Qnil);
1836 /* Nonzero means polling for input is temporarily suppressed. */
1838 int poll_suppress_count;
1841 #ifdef POLL_FOR_INPUT
1843 /* Asynchronous timer for polling. */
1845 static struct atimer *poll_timer;
1847 /* Poll for input, so that we catch a C-g if it comes in. */
1848 void
1849 poll_for_input_1 (void)
1851 if (! input_blocked_p ()
1852 && !waiting_for_input)
1853 gobble_input ();
1856 /* Timer callback function for poll_timer. TIMER is equal to
1857 poll_timer. */
1859 static void
1860 poll_for_input (struct atimer *timer)
1862 if (poll_suppress_count == 0)
1863 pending_signals = true;
1866 #endif /* POLL_FOR_INPUT */
1868 /* Begin signals to poll for input, if they are appropriate.
1869 This function is called unconditionally from various places. */
1871 void
1872 start_polling (void)
1874 #ifdef POLL_FOR_INPUT
1875 /* XXX This condition was (read_socket_hook && !interrupt_input),
1876 but read_socket_hook is not global anymore. Let's pretend that
1877 it's always set. */
1878 if (!interrupt_input)
1880 /* Turn alarm handling on unconditionally. It might have
1881 been turned off in process.c. */
1882 turn_on_atimers (1);
1884 /* If poll timer doesn't exist, or we need one with
1885 a different interval, start a new one. */
1886 if (poll_timer == NULL
1887 || poll_timer->interval.tv_sec != polling_period)
1889 time_t period = max (1, min (polling_period, TYPE_MAXIMUM (time_t)));
1890 struct timespec interval = make_timespec (period, 0);
1892 if (poll_timer)
1893 cancel_atimer (poll_timer);
1895 poll_timer = start_atimer (ATIMER_CONTINUOUS, interval,
1896 poll_for_input, NULL);
1899 /* Let the timer's callback function poll for input
1900 if this becomes zero. */
1901 --poll_suppress_count;
1903 #endif
1906 /* True if we are using polling to handle input asynchronously. */
1908 bool
1909 input_polling_used (void)
1911 #ifdef POLL_FOR_INPUT
1912 /* XXX This condition was (read_socket_hook && !interrupt_input),
1913 but read_socket_hook is not global anymore. Let's pretend that
1914 it's always set. */
1915 return !interrupt_input;
1916 #else
1917 return 0;
1918 #endif
1921 /* Turn off polling. */
1923 void
1924 stop_polling (void)
1926 #ifdef POLL_FOR_INPUT
1927 /* XXX This condition was (read_socket_hook && !interrupt_input),
1928 but read_socket_hook is not global anymore. Let's pretend that
1929 it's always set. */
1930 if (!interrupt_input)
1931 ++poll_suppress_count;
1932 #endif
1935 /* Set the value of poll_suppress_count to COUNT
1936 and start or stop polling accordingly. */
1938 void
1939 set_poll_suppress_count (int count)
1941 #ifdef POLL_FOR_INPUT
1942 if (count == 0 && poll_suppress_count != 0)
1944 poll_suppress_count = 1;
1945 start_polling ();
1947 else if (count != 0 && poll_suppress_count == 0)
1949 stop_polling ();
1951 poll_suppress_count = count;
1952 #endif
1955 /* Bind polling_period to a value at least N.
1956 But don't decrease it. */
1958 void
1959 bind_polling_period (int n)
1961 #ifdef POLL_FOR_INPUT
1962 EMACS_INT new = polling_period;
1964 if (n > new)
1965 new = n;
1967 stop_other_atimers (poll_timer);
1968 stop_polling ();
1969 specbind (Qpolling_period, make_number (new));
1970 /* Start a new alarm with the new period. */
1971 start_polling ();
1972 #endif
1975 /* Apply the control modifier to CHARACTER. */
1978 make_ctrl_char (int c)
1980 /* Save the upper bits here. */
1981 int upper = c & ~0177;
1983 if (! ASCII_CHAR_P (c))
1984 return c |= ctrl_modifier;
1986 c &= 0177;
1988 /* Everything in the columns containing the upper-case letters
1989 denotes a control character. */
1990 if (c >= 0100 && c < 0140)
1992 int oc = c;
1993 c &= ~0140;
1994 /* Set the shift modifier for a control char
1995 made from a shifted letter. But only for letters! */
1996 if (oc >= 'A' && oc <= 'Z')
1997 c |= shift_modifier;
2000 /* The lower-case letters denote control characters too. */
2001 else if (c >= 'a' && c <= 'z')
2002 c &= ~0140;
2004 /* Include the bits for control and shift
2005 only if the basic ASCII code can't indicate them. */
2006 else if (c >= ' ')
2007 c |= ctrl_modifier;
2009 /* Replace the high bits. */
2010 c |= (upper & ~ctrl_modifier);
2012 return c;
2015 /* Display the help-echo property of the character after the mouse pointer.
2016 Either show it in the echo area, or call show-help-function to display
2017 it by other means (maybe in a tooltip).
2019 If HELP is nil, that means clear the previous help echo.
2021 If HELP is a string, display that string. If HELP is a function,
2022 call it with OBJECT and POS as arguments; the function should
2023 return a help string or nil for none. For all other types of HELP,
2024 evaluate it to obtain a string.
2026 WINDOW is the window in which the help was generated, if any.
2027 It is nil if not in a window.
2029 If OBJECT is a buffer, POS is the position in the buffer where the
2030 `help-echo' text property was found.
2032 If OBJECT is an overlay, that overlay has a `help-echo' property,
2033 and POS is the position in the overlay's buffer under the mouse.
2035 If OBJECT is a string (an overlay string or a string displayed with
2036 the `display' property). POS is the position in that string under
2037 the mouse.
2039 Note: this function may only be called with HELP nil or a string
2040 from X code running asynchronously. */
2042 void
2043 show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
2044 Lisp_Object pos)
2046 if (!NILP (help) && !STRINGP (help))
2048 if (FUNCTIONP (help))
2049 help = safe_call (4, help, window, object, pos);
2050 else
2051 help = safe_eval (help);
2053 if (!STRINGP (help))
2054 return;
2057 if (!noninteractive && STRINGP (help))
2059 /* The mouse-fixup-help-message Lisp function can call
2060 mouse_position_hook, which resets the mouse_moved flags.
2061 This causes trouble if we are trying to read a mouse motion
2062 event (i.e., if we are inside a `track-mouse' form), so we
2063 restore the mouse_moved flag. */
2064 struct frame *f = NILP (do_mouse_tracking) ? NULL : some_mouse_moved ();
2065 help = call1 (Qmouse_fixup_help_message, help);
2066 if (f)
2067 f->mouse_moved = true;
2070 if (STRINGP (help) || NILP (help))
2072 if (!NILP (Vshow_help_function))
2073 call1 (Vshow_help_function, Fsubstitute_command_keys (help));
2074 help_echo_showing_p = STRINGP (help);
2080 /* Input of single characters from keyboard. */
2082 static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, bool *used_mouse_menu,
2083 struct timespec *end_time);
2084 static void record_char (Lisp_Object c);
2086 static Lisp_Object help_form_saved_window_configs;
2087 static void
2088 read_char_help_form_unwind (void)
2090 Lisp_Object window_config = XCAR (help_form_saved_window_configs);
2091 help_form_saved_window_configs = XCDR (help_form_saved_window_configs);
2092 if (!NILP (window_config))
2093 Fset_window_configuration (window_config);
2096 #define STOP_POLLING \
2097 do { if (! polling_stopped_here) stop_polling (); \
2098 polling_stopped_here = true; } while (0)
2100 #define RESUME_POLLING \
2101 do { if (polling_stopped_here) start_polling (); \
2102 polling_stopped_here = false; } while (0)
2104 static Lisp_Object
2105 read_event_from_main_queue (struct timespec *end_time,
2106 sys_jmp_buf local_getcjmp,
2107 bool *used_mouse_menu)
2109 Lisp_Object c = Qnil;
2110 sys_jmp_buf save_jump;
2111 KBOARD *kb IF_LINT (= NULL);
2113 start:
2115 /* Read from the main queue, and if that gives us something we can't use yet,
2116 we put it on the appropriate side queue and try again. */
2118 if (end_time && timespec_cmp (*end_time, current_timespec ()) <= 0)
2119 return c;
2121 /* Actually read a character, waiting if necessary. */
2122 save_getcjmp (save_jump);
2123 restore_getcjmp (local_getcjmp);
2124 if (!end_time)
2125 timer_start_idle ();
2126 c = kbd_buffer_get_event (&kb, used_mouse_menu, end_time);
2127 restore_getcjmp (save_jump);
2129 if (! NILP (c) && (kb != current_kboard))
2131 Lisp_Object last = KVAR (kb, kbd_queue);
2132 if (CONSP (last))
2134 while (CONSP (XCDR (last)))
2135 last = XCDR (last);
2136 if (!NILP (XCDR (last)))
2137 emacs_abort ();
2139 if (!CONSP (last))
2140 kset_kbd_queue (kb, list1 (c));
2141 else
2142 XSETCDR (last, list1 (c));
2143 kb->kbd_queue_has_data = true;
2144 c = Qnil;
2145 if (single_kboard)
2146 goto start;
2147 current_kboard = kb;
2148 return make_number (-2);
2151 /* Terminate Emacs in batch mode if at eof. */
2152 if (noninteractive && INTEGERP (c) && XINT (c) < 0)
2153 Fkill_emacs (make_number (1));
2155 if (INTEGERP (c))
2157 /* Add in any extra modifiers, where appropriate. */
2158 if ((extra_keyboard_modifiers & CHAR_CTL)
2159 || ((extra_keyboard_modifiers & 0177) < ' '
2160 && (extra_keyboard_modifiers & 0177) != 0))
2161 XSETINT (c, make_ctrl_char (XINT (c)));
2163 /* Transfer any other modifier bits directly from
2164 extra_keyboard_modifiers to c. Ignore the actual character code
2165 in the low 16 bits of extra_keyboard_modifiers. */
2166 XSETINT (c, XINT (c) | (extra_keyboard_modifiers & ~0xff7f & ~CHAR_CTL));
2169 return c;
2174 /* Like `read_event_from_main_queue' but applies keyboard-coding-system
2175 to tty input. */
2176 static Lisp_Object
2177 read_decoded_event_from_main_queue (struct timespec *end_time,
2178 sys_jmp_buf local_getcjmp,
2179 Lisp_Object prev_event,
2180 bool *used_mouse_menu)
2182 #define MAX_ENCODED_BYTES 16
2183 #ifndef WINDOWSNT
2184 Lisp_Object events[MAX_ENCODED_BYTES];
2185 int n = 0;
2186 #endif
2187 while (true)
2189 Lisp_Object nextevt
2190 = read_event_from_main_queue (end_time, local_getcjmp,
2191 used_mouse_menu);
2192 #ifdef WINDOWSNT
2193 /* w32_console already returns decoded events. It either reads
2194 Unicode characters from the Windows keyboard input, or
2195 converts characters encoded in the current codepage into
2196 Unicode. See w32inevt.c:key_event, near its end. */
2197 return nextevt;
2198 #else
2199 struct frame *frame = XFRAME (selected_frame);
2200 struct terminal *terminal = frame->terminal;
2201 if (!((FRAME_TERMCAP_P (frame) || FRAME_MSDOS_P (frame))
2202 /* Don't apply decoding if we're just reading a raw event
2203 (e.g. reading bytes sent by the xterm to specify the position
2204 of a mouse click). */
2205 && (!EQ (prev_event, Qt))
2206 && (TERMINAL_KEYBOARD_CODING (terminal)->common_flags
2207 & CODING_REQUIRE_DECODING_MASK)))
2208 return nextevt; /* No decoding needed. */
2209 else
2211 int meta_key = terminal->display_info.tty->meta_key;
2212 eassert (n < MAX_ENCODED_BYTES);
2213 events[n++] = nextevt;
2214 if (NATNUMP (nextevt)
2215 && XINT (nextevt) < (meta_key == 1 ? 0x80 : 0x100))
2216 { /* An encoded byte sequence, let's try to decode it. */
2217 struct coding_system *coding
2218 = TERMINAL_KEYBOARD_CODING (terminal);
2220 if (raw_text_coding_system_p (coding))
2222 int i;
2223 if (meta_key != 2)
2224 for (i = 0; i < n; i++)
2225 events[i] = make_number (XINT (events[i]) & ~0x80);
2227 else
2229 unsigned char src[MAX_ENCODED_BYTES];
2230 unsigned char dest[MAX_ENCODED_BYTES * MAX_MULTIBYTE_LENGTH];
2231 int i;
2232 for (i = 0; i < n; i++)
2233 src[i] = XINT (events[i]);
2234 if (meta_key != 2)
2235 for (i = 0; i < n; i++)
2236 src[i] &= ~0x80;
2237 coding->destination = dest;
2238 coding->dst_bytes = sizeof dest;
2239 decode_coding_c_string (coding, src, n, Qnil);
2240 eassert (coding->produced_char <= n);
2241 if (coding->produced_char == 0)
2242 { /* The encoded sequence is incomplete. */
2243 if (n < MAX_ENCODED_BYTES) /* Avoid buffer overflow. */
2244 continue; /* Read on! */
2246 else
2248 const unsigned char *p = coding->destination;
2249 eassert (coding->carryover_bytes == 0);
2250 n = 0;
2251 while (n < coding->produced_char)
2252 events[n++] = make_number (STRING_CHAR_ADVANCE (p));
2256 /* Now `events' should hold decoded events.
2257 Normally, n should be equal to 1, but better not rely on it.
2258 We can only return one event here, so return the first we
2259 had and keep the others (if any) for later. */
2260 while (n > 1)
2261 Vunread_command_events
2262 = Fcons (events[--n], Vunread_command_events);
2263 return events[0];
2265 #endif
2269 static bool
2270 echo_keystrokes_p (void)
2272 return (FLOATP (Vecho_keystrokes) ? XFLOAT_DATA (Vecho_keystrokes) > 0.0
2273 : INTEGERP (Vecho_keystrokes) ? XINT (Vecho_keystrokes) > 0 : false);
2276 /* Read a character from the keyboard; call the redisplay if needed. */
2277 /* commandflag 0 means do not autosave, but do redisplay.
2278 -1 means do not redisplay, but do autosave.
2279 -2 means do neither.
2280 1 means do both.
2282 The argument MAP is a keymap for menu prompting.
2284 PREV_EVENT is the previous input event, or nil if we are reading
2285 the first event of a key sequence (or not reading a key sequence).
2286 If PREV_EVENT is t, that is a "magic" value that says
2287 not to run input methods, but in other respects to act as if
2288 not reading a key sequence.
2290 If USED_MOUSE_MENU is non-null, then set *USED_MOUSE_MENU to true
2291 if we used a mouse menu to read the input, or false otherwise. If
2292 USED_MOUSE_MENU is null, don't dereference it.
2294 Value is -2 when we find input on another keyboard. A second call
2295 to read_char will read it.
2297 If END_TIME is non-null, it is a pointer to a struct timespec
2298 specifying the maximum time to wait until. If no input arrives by
2299 that time, stop waiting and return nil.
2301 Value is t if we showed a menu and the user rejected it. */
2303 Lisp_Object
2304 read_char (int commandflag, Lisp_Object map,
2305 Lisp_Object prev_event,
2306 bool *used_mouse_menu, struct timespec *end_time)
2308 Lisp_Object c;
2309 ptrdiff_t jmpcount;
2310 sys_jmp_buf local_getcjmp;
2311 sys_jmp_buf save_jump;
2312 Lisp_Object tem, save;
2313 volatile Lisp_Object previous_echo_area_message;
2314 volatile Lisp_Object also_record;
2315 volatile bool reread, recorded;
2316 bool volatile polling_stopped_here = false;
2317 struct kboard *orig_kboard = current_kboard;
2319 also_record = Qnil;
2321 c = Qnil;
2322 previous_echo_area_message = Qnil;
2324 retry:
2326 recorded = false;
2328 if (CONSP (Vunread_post_input_method_events))
2330 c = XCAR (Vunread_post_input_method_events);
2331 Vunread_post_input_method_events
2332 = XCDR (Vunread_post_input_method_events);
2334 /* Undo what read_char_x_menu_prompt did when it unread
2335 additional keys returned by Fx_popup_menu. */
2336 if (CONSP (c)
2337 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2338 && NILP (XCDR (c)))
2339 c = XCAR (c);
2341 reread = true;
2342 goto reread_first;
2344 else
2345 reread = false;
2348 if (CONSP (Vunread_command_events))
2350 bool was_disabled = false;
2352 c = XCAR (Vunread_command_events);
2353 Vunread_command_events = XCDR (Vunread_command_events);
2355 /* Undo what sit-for did when it unread additional keys
2356 inside universal-argument. */
2358 if (CONSP (c) && EQ (XCAR (c), Qt))
2359 c = XCDR (c);
2360 else
2361 reread = true;
2363 /* Undo what read_char_x_menu_prompt did when it unread
2364 additional keys returned by Fx_popup_menu. */
2365 if (CONSP (c)
2366 && EQ (XCDR (c), Qdisabled)
2367 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c))))
2369 was_disabled = true;
2370 c = XCAR (c);
2373 /* If the queued event is something that used the mouse,
2374 set used_mouse_menu accordingly. */
2375 if (used_mouse_menu
2376 /* Also check was_disabled so last-nonmenu-event won't return
2377 a bad value when submenus are involved. (Bug#447) */
2378 && (EQ (c, Qtool_bar) || EQ (c, Qmenu_bar) || was_disabled))
2379 *used_mouse_menu = true;
2381 goto reread_for_input_method;
2384 if (CONSP (Vunread_input_method_events))
2386 c = XCAR (Vunread_input_method_events);
2387 Vunread_input_method_events = XCDR (Vunread_input_method_events);
2389 /* Undo what read_char_x_menu_prompt did when it unread
2390 additional keys returned by Fx_popup_menu. */
2391 if (CONSP (c)
2392 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2393 && NILP (XCDR (c)))
2394 c = XCAR (c);
2395 reread = true;
2396 goto reread_for_input_method;
2399 if (!NILP (Vexecuting_kbd_macro))
2401 /* We set this to Qmacro; since that's not a frame, nobody will
2402 try to switch frames on us, and the selected window will
2403 remain unchanged.
2405 Since this event came from a macro, it would be misleading to
2406 leave internal_last_event_frame set to wherever the last
2407 real event came from. Normally, a switch-frame event selects
2408 internal_last_event_frame after each command is read, but
2409 events read from a macro should never cause a new frame to be
2410 selected. */
2411 Vlast_event_frame = internal_last_event_frame = Qmacro;
2413 /* Exit the macro if we are at the end.
2414 Also, some things replace the macro with t
2415 to force an early exit. */
2416 if (EQ (Vexecuting_kbd_macro, Qt)
2417 || executing_kbd_macro_index >= XFASTINT (Flength (Vexecuting_kbd_macro)))
2419 XSETINT (c, -1);
2420 goto exit;
2423 c = Faref (Vexecuting_kbd_macro, make_number (executing_kbd_macro_index));
2424 if (STRINGP (Vexecuting_kbd_macro)
2425 && (XFASTINT (c) & 0x80) && (XFASTINT (c) <= 0xff))
2426 XSETFASTINT (c, CHAR_META | (XFASTINT (c) & ~0x80));
2428 executing_kbd_macro_index++;
2430 goto from_macro;
2433 if (!NILP (unread_switch_frame))
2435 c = unread_switch_frame;
2436 unread_switch_frame = Qnil;
2438 /* This event should make it into this_command_keys, and get echoed
2439 again, so we do not set `reread'. */
2440 goto reread_first;
2443 /* If redisplay was requested. */
2444 if (commandflag >= 0)
2446 bool echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
2448 /* If there is pending input, process any events which are not
2449 user-visible, such as X selection_request events. */
2450 if (input_pending
2451 || detect_input_pending_run_timers (0))
2452 swallow_events (false); /* May clear input_pending. */
2454 /* Redisplay if no pending input. */
2455 while (!(input_pending
2456 && (input_was_pending || !redisplay_dont_pause)))
2458 input_was_pending = input_pending;
2459 if (help_echo_showing_p && !EQ (selected_window, minibuf_window))
2460 redisplay_preserve_echo_area (5);
2461 else
2462 redisplay ();
2464 if (!input_pending)
2465 /* Normal case: no input arrived during redisplay. */
2466 break;
2468 /* Input arrived and pre-empted redisplay.
2469 Process any events which are not user-visible. */
2470 swallow_events (false);
2471 /* If that cleared input_pending, try again to redisplay. */
2474 /* Prevent the redisplay we just did
2475 from messing up echoing of the input after the prompt. */
2476 if (commandflag == 0 && echo_current)
2477 echo_message_buffer = echo_area_buffer[0];
2481 /* Message turns off echoing unless more keystrokes turn it on again.
2483 The code in 20.x for the condition was
2485 1. echo_area_glyphs && *echo_area_glyphs
2486 2. && echo_area_glyphs != current_kboard->echobuf
2487 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2489 (1) means there's a current message displayed
2491 (2) means it's not the message from echoing from the current
2492 kboard.
2494 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2495 is set to a non-null value. This is done in read_char and it is
2496 set to echo_area_glyphs. That means
2497 ok_to_echo_at_next_pause is either null or
2498 current_kboard->echobuf with the appropriate current_kboard at
2499 that time.
2501 So, condition (3) means in clear text ok_to_echo_at_next_pause
2502 must be either null, or the current message isn't from echoing at
2503 all, or it's from echoing from a different kboard than the
2504 current one. */
2506 if (/* There currently is something in the echo area. */
2507 !NILP (echo_area_buffer[0])
2508 && (/* It's an echo from a different kboard. */
2509 echo_kboard != current_kboard
2510 /* Or we explicitly allow overwriting whatever there is. */
2511 || ok_to_echo_at_next_pause == NULL))
2512 cancel_echoing ();
2513 else
2514 echo_dash ();
2516 /* Try reading a character via menu prompting in the minibuf.
2517 Try this before the sit-for, because the sit-for
2518 would do the wrong thing if we are supposed to do
2519 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2520 after a mouse event so don't try a minibuf menu. */
2521 c = Qnil;
2522 if (KEYMAPP (map) && INTERACTIVE
2523 && !NILP (prev_event) && ! EVENT_HAS_PARAMETERS (prev_event)
2524 /* Don't bring up a menu if we already have another event. */
2525 && NILP (Vunread_command_events)
2526 && !detect_input_pending_run_timers (0))
2528 c = read_char_minibuf_menu_prompt (commandflag, map);
2530 if (INTEGERP (c) && XINT (c) == -2)
2531 return c; /* wrong_kboard_jmpbuf */
2533 if (! NILP (c))
2534 goto exit;
2537 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2538 We will do that below, temporarily for short sections of code,
2539 when appropriate. local_getcjmp must be in effect
2540 around any call to sit_for or kbd_buffer_get_event;
2541 it *must not* be in effect when we call redisplay. */
2543 jmpcount = SPECPDL_INDEX ();
2544 if (sys_setjmp (local_getcjmp))
2546 /* Handle quits while reading the keyboard. */
2547 /* We must have saved the outer value of getcjmp here,
2548 so restore it now. */
2549 restore_getcjmp (save_jump);
2550 pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
2551 unbind_to (jmpcount, Qnil);
2552 XSETINT (c, quit_char);
2553 internal_last_event_frame = selected_frame;
2554 Vlast_event_frame = internal_last_event_frame;
2555 /* If we report the quit char as an event,
2556 don't do so more than once. */
2557 if (!NILP (Vinhibit_quit))
2558 Vquit_flag = Qnil;
2561 KBOARD *kb = FRAME_KBOARD (XFRAME (selected_frame));
2562 if (kb != current_kboard)
2564 Lisp_Object last = KVAR (kb, kbd_queue);
2565 /* We shouldn't get here if we were in single-kboard mode! */
2566 if (single_kboard)
2567 emacs_abort ();
2568 if (CONSP (last))
2570 while (CONSP (XCDR (last)))
2571 last = XCDR (last);
2572 if (!NILP (XCDR (last)))
2573 emacs_abort ();
2575 if (!CONSP (last))
2576 kset_kbd_queue (kb, list1 (c));
2577 else
2578 XSETCDR (last, list1 (c));
2579 kb->kbd_queue_has_data = true;
2580 current_kboard = kb;
2581 return make_number (-2); /* wrong_kboard_jmpbuf */
2584 goto non_reread;
2587 /* Start idle timers if no time limit is supplied. We don't do it
2588 if a time limit is supplied to avoid an infinite recursion in the
2589 situation where an idle timer calls `sit-for'. */
2591 if (!end_time)
2592 timer_start_idle ();
2594 /* If in middle of key sequence and minibuffer not active,
2595 start echoing if enough time elapses. */
2597 if (minibuf_level == 0
2598 && !end_time
2599 && !current_kboard->immediate_echo
2600 && (this_command_key_count > 0
2601 || !NILP (call0 (Qinternal_echo_keystrokes_prefix)))
2602 && ! noninteractive
2603 && echo_keystrokes_p ()
2604 && (/* No message. */
2605 NILP (echo_area_buffer[0])
2606 /* Or empty message. */
2607 || (BUF_BEG (XBUFFER (echo_area_buffer[0]))
2608 == BUF_Z (XBUFFER (echo_area_buffer[0])))
2609 /* Or already echoing from same kboard. */
2610 || (echo_kboard && ok_to_echo_at_next_pause == echo_kboard)
2611 /* Or not echoing before and echoing allowed. */
2612 || (!echo_kboard && ok_to_echo_at_next_pause)))
2614 /* After a mouse event, start echoing right away.
2615 This is because we are probably about to display a menu,
2616 and we don't want to delay before doing so. */
2617 if (EVENT_HAS_PARAMETERS (prev_event))
2618 echo_now ();
2619 else
2621 Lisp_Object tem0;
2623 save_getcjmp (save_jump);
2624 restore_getcjmp (local_getcjmp);
2625 tem0 = sit_for (Vecho_keystrokes, 1, 1);
2626 restore_getcjmp (save_jump);
2627 if (EQ (tem0, Qt)
2628 && ! CONSP (Vunread_command_events))
2629 echo_now ();
2633 /* Maybe auto save due to number of keystrokes. */
2635 if (commandflag != 0 && commandflag != -2
2636 && auto_save_interval > 0
2637 && num_nonmacro_input_events - last_auto_save > max (auto_save_interval, 20)
2638 && !detect_input_pending_run_timers (0))
2640 Fdo_auto_save (Qnil, Qnil);
2641 /* Hooks can actually change some buffers in auto save. */
2642 redisplay ();
2645 /* Try reading using an X menu.
2646 This is never confused with reading using the minibuf
2647 because the recursive call of read_char in read_char_minibuf_menu_prompt
2648 does not pass on any keymaps. */
2650 if (KEYMAPP (map) && INTERACTIVE
2651 && !NILP (prev_event)
2652 && EVENT_HAS_PARAMETERS (prev_event)
2653 && !EQ (XCAR (prev_event), Qmenu_bar)
2654 && !EQ (XCAR (prev_event), Qtool_bar)
2655 /* Don't bring up a menu if we already have another event. */
2656 && NILP (Vunread_command_events))
2658 c = read_char_x_menu_prompt (map, prev_event, used_mouse_menu);
2660 /* Now that we have read an event, Emacs is not idle. */
2661 if (!end_time)
2662 timer_stop_idle ();
2664 goto exit;
2667 /* Maybe autosave and/or garbage collect due to idleness. */
2669 if (INTERACTIVE && NILP (c))
2671 int delay_level;
2672 ptrdiff_t buffer_size;
2674 /* Slow down auto saves logarithmically in size of current buffer,
2675 and garbage collect while we're at it. */
2676 if (! MINI_WINDOW_P (XWINDOW (selected_window)))
2677 last_non_minibuf_size = Z - BEG;
2678 buffer_size = (last_non_minibuf_size >> 8) + 1;
2679 delay_level = 0;
2680 while (buffer_size > 64)
2681 delay_level++, buffer_size -= buffer_size >> 2;
2682 if (delay_level < 4) delay_level = 4;
2683 /* delay_level is 4 for files under around 50k, 7 at 100k,
2684 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2686 /* Auto save if enough time goes by without input. */
2687 if (commandflag != 0 && commandflag != -2
2688 && num_nonmacro_input_events > last_auto_save
2689 && INTEGERP (Vauto_save_timeout)
2690 && XINT (Vauto_save_timeout) > 0)
2692 Lisp_Object tem0;
2693 EMACS_INT timeout = XFASTINT (Vauto_save_timeout);
2695 timeout = min (timeout, MOST_POSITIVE_FIXNUM / delay_level * 4);
2696 timeout = delay_level * timeout / 4;
2697 save_getcjmp (save_jump);
2698 restore_getcjmp (local_getcjmp);
2699 tem0 = sit_for (make_number (timeout), 1, 1);
2700 restore_getcjmp (save_jump);
2702 if (EQ (tem0, Qt)
2703 && ! CONSP (Vunread_command_events))
2705 Fdo_auto_save (Qnil, Qnil);
2706 redisplay ();
2710 /* If there is still no input available, ask for GC. */
2711 if (!detect_input_pending_run_timers (0))
2712 maybe_gc ();
2715 /* Notify the caller if an autosave hook, or a timer, sentinel or
2716 filter in the sit_for calls above have changed the current
2717 kboard. This could happen if they use the minibuffer or start a
2718 recursive edit, like the fancy splash screen in server.el's
2719 filter. If this longjmp wasn't here, read_key_sequence would
2720 interpret the next key sequence using the wrong translation
2721 tables and function keymaps. */
2722 if (NILP (c) && current_kboard != orig_kboard)
2723 return make_number (-2); /* wrong_kboard_jmpbuf */
2725 /* If this has become non-nil here, it has been set by a timer
2726 or sentinel or filter. */
2727 if (CONSP (Vunread_command_events))
2729 c = XCAR (Vunread_command_events);
2730 Vunread_command_events = XCDR (Vunread_command_events);
2732 if (CONSP (c) && EQ (XCAR (c), Qt))
2733 c = XCDR (c);
2734 else
2735 reread = true;
2738 /* Read something from current KBOARD's side queue, if possible. */
2740 if (NILP (c))
2742 if (current_kboard->kbd_queue_has_data)
2744 if (!CONSP (KVAR (current_kboard, kbd_queue)))
2745 emacs_abort ();
2746 c = XCAR (KVAR (current_kboard, kbd_queue));
2747 kset_kbd_queue (current_kboard,
2748 XCDR (KVAR (current_kboard, kbd_queue)));
2749 if (NILP (KVAR (current_kboard, kbd_queue)))
2750 current_kboard->kbd_queue_has_data = false;
2751 input_pending = readable_events (0);
2752 if (EVENT_HAS_PARAMETERS (c)
2753 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qswitch_frame))
2754 internal_last_event_frame = XCAR (XCDR (c));
2755 Vlast_event_frame = internal_last_event_frame;
2759 /* If current_kboard's side queue is empty check the other kboards.
2760 If one of them has data that we have not yet seen here,
2761 switch to it and process the data waiting for it.
2763 Note: if the events queued up for another kboard
2764 have already been seen here, and therefore are not a complete command,
2765 the kbd_queue_has_data field is 0, so we skip that kboard here.
2766 That's to avoid an infinite loop switching between kboards here. */
2767 if (NILP (c) && !single_kboard)
2769 KBOARD *kb;
2770 for (kb = all_kboards; kb; kb = kb->next_kboard)
2771 if (kb->kbd_queue_has_data)
2773 current_kboard = kb;
2774 return make_number (-2); /* wrong_kboard_jmpbuf */
2778 wrong_kboard:
2780 STOP_POLLING;
2782 if (NILP (c))
2784 c = read_decoded_event_from_main_queue (end_time, local_getcjmp,
2785 prev_event, used_mouse_menu);
2786 if (NILP (c) && end_time
2787 && timespec_cmp (*end_time, current_timespec ()) <= 0)
2789 goto exit;
2792 if (EQ (c, make_number (-2)))
2793 return c;
2796 non_reread:
2798 if (!end_time)
2799 timer_stop_idle ();
2800 RESUME_POLLING;
2802 if (NILP (c))
2804 if (commandflag >= 0
2805 && !input_pending && !detect_input_pending_run_timers (0))
2806 redisplay ();
2808 goto wrong_kboard;
2811 /* Buffer switch events are only for internal wakeups
2812 so don't show them to the user.
2813 Also, don't record a key if we already did. */
2814 if (BUFFERP (c))
2815 goto exit;
2817 /* Process special events within read_char
2818 and loop around to read another event. */
2819 save = Vquit_flag;
2820 Vquit_flag = Qnil;
2821 tem = access_keymap (get_keymap (Vspecial_event_map, 0, 1), c, 0, 0, 1);
2822 Vquit_flag = save;
2824 if (!NILP (tem))
2826 struct buffer *prev_buffer = current_buffer;
2827 last_input_event = c;
2828 call4 (Qcommand_execute, tem, Qnil, Fvector (1, &last_input_event), Qt);
2830 if (CONSP (c) && EQ (XCAR (c), Qselect_window) && !end_time)
2831 /* We stopped being idle for this event; undo that. This
2832 prevents automatic window selection (under
2833 mouse_autoselect_window from acting as a real input event, for
2834 example banishing the mouse under mouse-avoidance-mode. */
2835 timer_resume_idle ();
2837 if (current_buffer != prev_buffer)
2839 /* The command may have changed the keymaps. Pretend there
2840 is input in another keyboard and return. This will
2841 recalculate keymaps. */
2842 c = make_number (-2);
2843 goto exit;
2845 else
2846 goto retry;
2849 /* Handle things that only apply to characters. */
2850 if (INTEGERP (c))
2852 /* If kbd_buffer_get_event gave us an EOF, return that. */
2853 if (XINT (c) == -1)
2854 goto exit;
2856 if ((STRINGP (KVAR (current_kboard, Vkeyboard_translate_table))
2857 && UNSIGNED_CMP (XFASTINT (c), <,
2858 SCHARS (KVAR (current_kboard,
2859 Vkeyboard_translate_table))))
2860 || (VECTORP (KVAR (current_kboard, Vkeyboard_translate_table))
2861 && UNSIGNED_CMP (XFASTINT (c), <,
2862 ASIZE (KVAR (current_kboard,
2863 Vkeyboard_translate_table))))
2864 || (CHAR_TABLE_P (KVAR (current_kboard, Vkeyboard_translate_table))
2865 && CHARACTERP (c)))
2867 Lisp_Object d;
2868 d = Faref (KVAR (current_kboard, Vkeyboard_translate_table), c);
2869 /* nil in keyboard-translate-table means no translation. */
2870 if (!NILP (d))
2871 c = d;
2875 /* If this event is a mouse click in the menu bar,
2876 return just menu-bar for now. Modify the mouse click event
2877 so we won't do this twice, then queue it up. */
2878 if (EVENT_HAS_PARAMETERS (c)
2879 && CONSP (XCDR (c))
2880 && CONSP (EVENT_START (c))
2881 && CONSP (XCDR (EVENT_START (c))))
2883 Lisp_Object posn;
2885 posn = POSN_POSN (EVENT_START (c));
2886 /* Handle menu-bar events:
2887 insert the dummy prefix event `menu-bar'. */
2888 if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
2890 /* Change menu-bar to (menu-bar) as the event "position". */
2891 POSN_SET_POSN (EVENT_START (c), list1 (posn));
2893 also_record = c;
2894 Vunread_command_events = Fcons (c, Vunread_command_events);
2895 c = posn;
2899 /* Store these characters into recent_keys, the dribble file if any,
2900 and the keyboard macro being defined, if any. */
2901 record_char (c);
2902 recorded = true;
2903 if (! NILP (also_record))
2904 record_char (also_record);
2906 /* Wipe the echo area.
2907 But first, if we are about to use an input method,
2908 save the echo area contents for it to refer to. */
2909 if (INTEGERP (c)
2910 && ! NILP (Vinput_method_function)
2911 && ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127)
2913 previous_echo_area_message = Fcurrent_message ();
2914 Vinput_method_previous_message = previous_echo_area_message;
2917 /* Now wipe the echo area, except for help events which do their
2918 own stuff with the echo area. */
2919 if (!CONSP (c)
2920 || (!(EQ (Qhelp_echo, XCAR (c)))
2921 && !(EQ (Qswitch_frame, XCAR (c)))
2922 /* Don't wipe echo area for select window events: These might
2923 get delayed via `mouse-autoselect-window' (Bug#11304). */
2924 && !(EQ (Qselect_window, XCAR (c)))))
2926 if (!NILP (echo_area_buffer[0]))
2928 safe_run_hooks (Qecho_area_clear_hook);
2929 clear_message (1, 0);
2933 reread_for_input_method:
2934 from_macro:
2935 /* Pass this to the input method, if appropriate. */
2936 if (INTEGERP (c)
2937 && ! NILP (Vinput_method_function)
2938 /* Don't run the input method within a key sequence,
2939 after the first event of the key sequence. */
2940 && NILP (prev_event)
2941 && ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127)
2943 Lisp_Object keys;
2944 ptrdiff_t key_count;
2945 ptrdiff_t command_key_start;
2946 ptrdiff_t count = SPECPDL_INDEX ();
2948 /* Save the echo status. */
2949 bool saved_immediate_echo = current_kboard->immediate_echo;
2950 struct kboard *saved_ok_to_echo = ok_to_echo_at_next_pause;
2951 Lisp_Object saved_echo_string = KVAR (current_kboard, echo_string);
2952 Lisp_Object saved_echo_prompt = KVAR (current_kboard, echo_prompt);
2954 /* Save the this_command_keys status. */
2955 key_count = this_command_key_count;
2956 command_key_start = this_single_command_key_start;
2958 if (key_count > 0)
2959 keys = Fcopy_sequence (this_command_keys);
2960 else
2961 keys = Qnil;
2963 /* Clear out this_command_keys. */
2964 this_command_key_count = 0;
2965 this_single_command_key_start = 0;
2967 /* Now wipe the echo area. */
2968 if (!NILP (echo_area_buffer[0]))
2969 safe_run_hooks (Qecho_area_clear_hook);
2970 clear_message (1, 0);
2971 echo_truncate (0);
2973 /* If we are not reading a key sequence,
2974 never use the echo area. */
2975 if (!KEYMAPP (map))
2977 specbind (Qinput_method_use_echo_area, Qt);
2980 /* Call the input method. */
2981 tem = call1 (Vinput_method_function, c);
2983 tem = unbind_to (count, tem);
2985 /* Restore the saved echoing state
2986 and this_command_keys state. */
2987 this_command_key_count = key_count;
2988 this_single_command_key_start = command_key_start;
2989 if (key_count > 0)
2990 this_command_keys = keys;
2992 cancel_echoing ();
2993 ok_to_echo_at_next_pause = saved_ok_to_echo;
2994 kset_echo_string (current_kboard, saved_echo_string);
2995 kset_echo_prompt (current_kboard, saved_echo_prompt);
2996 if (saved_immediate_echo)
2997 echo_now ();
2999 /* The input method can return no events. */
3000 if (! CONSP (tem))
3002 /* Bring back the previous message, if any. */
3003 if (! NILP (previous_echo_area_message))
3004 message_with_string ("%s", previous_echo_area_message, 0);
3005 goto retry;
3007 /* It returned one event or more. */
3008 c = XCAR (tem);
3009 Vunread_post_input_method_events
3010 = nconc2 (XCDR (tem), Vunread_post_input_method_events);
3012 /* When we consume events from the various unread-*-events lists, we
3013 bypass the code that records input, so record these events now if
3014 they were not recorded already. */
3015 if (!recorded)
3017 record_char (c);
3018 recorded = true;
3021 reread_first:
3023 /* Display help if not echoing. */
3024 if (CONSP (c) && EQ (XCAR (c), Qhelp_echo))
3026 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3027 Lisp_Object help, object, position, window, htem;
3029 htem = Fcdr (XCDR (c));
3030 help = Fcar (htem);
3031 htem = Fcdr (htem);
3032 window = Fcar (htem);
3033 htem = Fcdr (htem);
3034 object = Fcar (htem);
3035 htem = Fcdr (htem);
3036 position = Fcar (htem);
3038 show_help_echo (help, window, object, position);
3040 /* We stopped being idle for this event; undo that. */
3041 if (!end_time)
3042 timer_resume_idle ();
3043 goto retry;
3046 if ((! reread || this_command_key_count == 0)
3047 && !end_time)
3050 /* Don't echo mouse motion events. */
3051 if (! (EVENT_HAS_PARAMETERS (c)
3052 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
3053 /* Once we reread a character, echoing can happen
3054 the next time we pause to read a new one. */
3055 ok_to_echo_at_next_pause = current_kboard;
3057 /* Record this character as part of the current key. */
3058 add_command_key (c);
3059 if (! NILP (also_record))
3060 add_command_key (also_record);
3062 echo_update ();
3065 last_input_event = c;
3066 num_input_events++;
3068 /* Process the help character specially if enabled. */
3069 if (!NILP (Vhelp_form) && help_char_p (c))
3071 ptrdiff_t count = SPECPDL_INDEX ();
3073 help_form_saved_window_configs
3074 = Fcons (Fcurrent_window_configuration (Qnil),
3075 help_form_saved_window_configs);
3076 record_unwind_protect_void (read_char_help_form_unwind);
3077 call0 (Qhelp_form_show);
3079 cancel_echoing ();
3082 c = read_char (0, Qnil, Qnil, 0, NULL);
3083 if (EVENT_HAS_PARAMETERS (c)
3084 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_click))
3085 XSETCAR (help_form_saved_window_configs, Qnil);
3087 while (BUFFERP (c));
3088 /* Remove the help from the frame. */
3089 unbind_to (count, Qnil);
3091 redisplay ();
3092 if (EQ (c, make_number (040)))
3094 cancel_echoing ();
3096 c = read_char (0, Qnil, Qnil, 0, NULL);
3097 while (BUFFERP (c));
3101 exit:
3102 RESUME_POLLING;
3103 input_was_pending = input_pending;
3104 return c;
3107 /* Record a key that came from a mouse menu.
3108 Record it for echoing, for this-command-keys, and so on. */
3110 static void
3111 record_menu_key (Lisp_Object c)
3113 /* Wipe the echo area. */
3114 clear_message (1, 0);
3116 record_char (c);
3118 /* Once we reread a character, echoing can happen
3119 the next time we pause to read a new one. */
3120 ok_to_echo_at_next_pause = NULL;
3122 /* Record this character as part of the current key. */
3123 add_command_key (c);
3124 echo_update ();
3126 /* Re-reading in the middle of a command. */
3127 last_input_event = c;
3128 num_input_events++;
3131 /* Return true if should recognize C as "the help character". */
3133 static bool
3134 help_char_p (Lisp_Object c)
3136 Lisp_Object tail;
3138 if (EQ (c, Vhelp_char))
3139 return 1;
3140 for (tail = Vhelp_event_list; CONSP (tail); tail = XCDR (tail))
3141 if (EQ (c, XCAR (tail)))
3142 return 1;
3143 return 0;
3146 /* Record the input event C in various ways. */
3148 static void
3149 record_char (Lisp_Object c)
3151 int recorded = 0;
3153 if (CONSP (c) && (EQ (XCAR (c), Qhelp_echo) || EQ (XCAR (c), Qmouse_movement)))
3155 /* To avoid filling recent_keys with help-echo and mouse-movement
3156 events, we filter out repeated help-echo events, only store the
3157 first and last in a series of mouse-movement events, and don't
3158 store repeated help-echo events which are only separated by
3159 mouse-movement events. */
3161 Lisp_Object ev1, ev2, ev3;
3162 int ix1, ix2, ix3;
3164 if ((ix1 = recent_keys_index - 1) < 0)
3165 ix1 = NUM_RECENT_KEYS - 1;
3166 ev1 = AREF (recent_keys, ix1);
3168 if ((ix2 = ix1 - 1) < 0)
3169 ix2 = NUM_RECENT_KEYS - 1;
3170 ev2 = AREF (recent_keys, ix2);
3172 if ((ix3 = ix2 - 1) < 0)
3173 ix3 = NUM_RECENT_KEYS - 1;
3174 ev3 = AREF (recent_keys, ix3);
3176 if (EQ (XCAR (c), Qhelp_echo))
3178 /* Don't record `help-echo' in recent_keys unless it shows some help
3179 message, and a different help than the previously recorded
3180 event. */
3181 Lisp_Object help, last_help;
3183 help = Fcar_safe (Fcdr_safe (XCDR (c)));
3184 if (!STRINGP (help))
3185 recorded = 1;
3186 else if (CONSP (ev1) && EQ (XCAR (ev1), Qhelp_echo)
3187 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev1))), EQ (last_help, help)))
3188 recorded = 1;
3189 else if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3190 && CONSP (ev2) && EQ (XCAR (ev2), Qhelp_echo)
3191 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev2))), EQ (last_help, help)))
3192 recorded = -1;
3193 else if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3194 && CONSP (ev2) && EQ (XCAR (ev2), Qmouse_movement)
3195 && CONSP (ev3) && EQ (XCAR (ev3), Qhelp_echo)
3196 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev3))), EQ (last_help, help)))
3197 recorded = -2;
3199 else if (EQ (XCAR (c), Qmouse_movement))
3201 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3202 So additional mouse movement events replace the last element. */
3203 Lisp_Object last_window, window;
3205 window = Fcar_safe (Fcar_safe (XCDR (c)));
3206 if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3207 && (last_window = Fcar_safe (Fcar_safe (XCDR (ev1))), EQ (last_window, window))
3208 && CONSP (ev2) && EQ (XCAR (ev2), Qmouse_movement)
3209 && (last_window = Fcar_safe (Fcar_safe (XCDR (ev2))), EQ (last_window, window)))
3211 ASET (recent_keys, ix1, c);
3212 recorded = 1;
3216 else
3217 store_kbd_macro_char (c);
3219 if (!recorded)
3221 total_keys += total_keys < NUM_RECENT_KEYS;
3222 ASET (recent_keys, recent_keys_index, c);
3223 if (++recent_keys_index >= NUM_RECENT_KEYS)
3224 recent_keys_index = 0;
3226 else if (recorded < 0)
3228 /* We need to remove one or two events from recent_keys.
3229 To do this, we simply put nil at those events and move the
3230 recent_keys_index backwards over those events. Usually,
3231 users will never see those nil events, as they will be
3232 overwritten by the command keys entered to see recent_keys
3233 (e.g. C-h l). */
3235 while (recorded++ < 0 && total_keys > 0)
3237 if (total_keys < NUM_RECENT_KEYS)
3238 total_keys--;
3239 if (--recent_keys_index < 0)
3240 recent_keys_index = NUM_RECENT_KEYS - 1;
3241 ASET (recent_keys, recent_keys_index, Qnil);
3245 num_nonmacro_input_events++;
3247 /* Write c to the dribble file. If c is a lispy event, write
3248 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3249 If you, dear reader, have a better idea, you've got the source. :-) */
3250 if (dribble)
3252 block_input ();
3253 if (INTEGERP (c))
3255 if (XUINT (c) < 0x100)
3256 putc (XUINT (c), dribble);
3257 else
3258 fprintf (dribble, " 0x%"pI"x", XUINT (c));
3260 else
3262 Lisp_Object dribblee;
3264 /* If it's a structured event, take the event header. */
3265 dribblee = EVENT_HEAD (c);
3267 if (SYMBOLP (dribblee))
3269 putc ('<', dribble);
3270 fwrite (SDATA (SYMBOL_NAME (dribblee)), sizeof (char),
3271 SBYTES (SYMBOL_NAME (dribblee)),
3272 dribble);
3273 putc ('>', dribble);
3277 fflush (dribble);
3278 unblock_input ();
3282 /* Copy out or in the info on where C-g should throw to.
3283 This is used when running Lisp code from within get_char,
3284 in case get_char is called recursively.
3285 See read_process_output. */
3287 static void
3288 save_getcjmp (sys_jmp_buf temp)
3290 memcpy (temp, getcjmp, sizeof getcjmp);
3293 static void
3294 restore_getcjmp (sys_jmp_buf temp)
3296 memcpy (getcjmp, temp, sizeof getcjmp);
3299 /* Low level keyboard/mouse input.
3300 kbd_buffer_store_event places events in kbd_buffer, and
3301 kbd_buffer_get_event retrieves them. */
3303 /* Return true if there are any events in the queue that read-char
3304 would return. If this returns false, a read-char would block. */
3305 static bool
3306 readable_events (int flags)
3308 if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
3309 timer_check ();
3311 /* If the buffer contains only FOCUS_IN_EVENT events, and
3312 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3313 if (kbd_fetch_ptr != kbd_store_ptr)
3315 if (flags & (READABLE_EVENTS_FILTER_EVENTS
3316 #ifdef USE_TOOLKIT_SCROLL_BARS
3317 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3318 #endif
3321 union buffered_input_event *event = kbd_fetch_ptr;
3325 if (event == kbd_buffer + KBD_BUFFER_SIZE)
3326 event = kbd_buffer;
3327 if (!(
3328 #ifdef USE_TOOLKIT_SCROLL_BARS
3329 (flags & READABLE_EVENTS_FILTER_EVENTS) &&
3330 #endif
3331 event->kind == FOCUS_IN_EVENT)
3332 #ifdef USE_TOOLKIT_SCROLL_BARS
3333 && !((flags & READABLE_EVENTS_IGNORE_SQUEEZABLES)
3334 && (event->kind == SCROLL_BAR_CLICK_EVENT
3335 || event->kind == HORIZONTAL_SCROLL_BAR_CLICK_EVENT)
3336 && event->ie.part == scroll_bar_handle
3337 && event->ie.modifiers == 0)
3338 #endif
3339 && !((flags & READABLE_EVENTS_FILTER_EVENTS)
3340 && event->kind == BUFFER_SWITCH_EVENT))
3341 return 1;
3342 event++;
3344 while (event != kbd_store_ptr);
3346 else
3347 return 1;
3350 if (!(flags & READABLE_EVENTS_IGNORE_SQUEEZABLES)
3351 && !NILP (do_mouse_tracking) && some_mouse_moved ())
3352 return 1;
3353 if (single_kboard)
3355 if (current_kboard->kbd_queue_has_data)
3356 return 1;
3358 else
3360 KBOARD *kb;
3361 for (kb = all_kboards; kb; kb = kb->next_kboard)
3362 if (kb->kbd_queue_has_data)
3363 return 1;
3365 return 0;
3368 /* Set this for debugging, to have a way to get out */
3369 int stop_character EXTERNALLY_VISIBLE;
3371 static KBOARD *
3372 event_to_kboard (struct input_event *event)
3374 /* Not applicable for these special events. */
3375 if (event->kind == SELECTION_REQUEST_EVENT
3376 || event->kind == SELECTION_CLEAR_EVENT)
3377 return NULL;
3378 else
3380 Lisp_Object obj = event->frame_or_window;
3381 /* There are some events that set this field to nil or string. */
3382 if (WINDOWP (obj))
3383 obj = WINDOW_FRAME (XWINDOW (obj));
3384 /* Also ignore dead frames here. */
3385 return ((FRAMEP (obj) && FRAME_LIVE_P (XFRAME (obj)))
3386 ? FRAME_KBOARD (XFRAME (obj)) : NULL);
3390 #ifdef subprocesses
3391 /* Return the number of slots occupied in kbd_buffer. */
3393 static int
3394 kbd_buffer_nr_stored (void)
3396 return kbd_fetch_ptr == kbd_store_ptr
3398 : (kbd_fetch_ptr < kbd_store_ptr
3399 ? kbd_store_ptr - kbd_fetch_ptr
3400 : ((kbd_buffer + KBD_BUFFER_SIZE) - kbd_fetch_ptr
3401 + (kbd_store_ptr - kbd_buffer)));
3403 #endif /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3405 void
3406 kbd_buffer_store_event (register struct input_event *event)
3408 kbd_buffer_store_event_hold (event, 0);
3411 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3413 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3414 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3415 Else, if EVENT is a quit event, store the quit event
3416 in HOLD_QUIT, and return (thus ignoring further events).
3418 This is used to postpone the processing of the quit event until all
3419 subsequent input events have been parsed (and discarded). */
3421 void
3422 kbd_buffer_store_buffered_event (union buffered_input_event *event,
3423 struct input_event *hold_quit)
3425 if (event->kind == NO_EVENT)
3426 emacs_abort ();
3428 if (hold_quit && hold_quit->kind != NO_EVENT)
3429 return;
3431 if (event->kind == ASCII_KEYSTROKE_EVENT)
3433 int c = event->ie.code & 0377;
3435 if (event->ie.modifiers & ctrl_modifier)
3436 c = make_ctrl_char (c);
3438 c |= (event->ie.modifiers
3439 & (meta_modifier | alt_modifier
3440 | hyper_modifier | super_modifier));
3442 if (c == quit_char)
3444 KBOARD *kb = FRAME_KBOARD (XFRAME (event->ie.frame_or_window));
3446 if (single_kboard && kb != current_kboard)
3448 kset_kbd_queue
3449 (kb, list2 (make_lispy_switch_frame (event->ie.frame_or_window),
3450 make_number (c)));
3451 kb->kbd_queue_has_data = true;
3452 union buffered_input_event *sp;
3453 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
3455 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3456 sp = kbd_buffer;
3458 if (event_to_kboard (&sp->ie) == kb)
3460 sp->ie.kind = NO_EVENT;
3461 sp->ie.frame_or_window = Qnil;
3462 sp->ie.arg = Qnil;
3465 return;
3468 if (hold_quit)
3470 *hold_quit = event->ie;
3471 return;
3474 /* If this results in a quit_char being returned to Emacs as
3475 input, set Vlast_event_frame properly. If this doesn't
3476 get returned to Emacs as an event, the next event read
3477 will set Vlast_event_frame again, so this is safe to do. */
3479 Lisp_Object focus;
3481 focus = FRAME_FOCUS_FRAME (XFRAME (event->ie.frame_or_window));
3482 if (NILP (focus))
3483 focus = event->ie.frame_or_window;
3484 internal_last_event_frame = focus;
3485 Vlast_event_frame = focus;
3488 handle_interrupt (0);
3489 return;
3492 if (c && c == stop_character)
3494 sys_suspend ();
3495 return;
3498 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3499 Just ignore the second one. */
3500 else if (event->kind == BUFFER_SWITCH_EVENT
3501 && kbd_fetch_ptr != kbd_store_ptr
3502 && ((kbd_store_ptr == kbd_buffer
3503 ? kbd_buffer + KBD_BUFFER_SIZE - 1
3504 : kbd_store_ptr - 1)->kind) == BUFFER_SWITCH_EVENT)
3505 return;
3507 if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
3508 kbd_store_ptr = kbd_buffer;
3510 /* Don't let the very last slot in the buffer become full,
3511 since that would make the two pointers equal,
3512 and that is indistinguishable from an empty buffer.
3513 Discard the event if it would fill the last slot. */
3514 if (kbd_fetch_ptr - 1 != kbd_store_ptr)
3516 *kbd_store_ptr = *event;
3517 ++kbd_store_ptr;
3518 #ifdef subprocesses
3519 if (kbd_buffer_nr_stored () > KBD_BUFFER_SIZE / 2
3520 && ! kbd_on_hold_p ())
3522 /* Don't read keyboard input until we have processed kbd_buffer.
3523 This happens when pasting text longer than KBD_BUFFER_SIZE/2. */
3524 hold_keyboard_input ();
3525 unrequest_sigio ();
3526 stop_polling ();
3528 #endif /* subprocesses */
3531 /* If we're inside while-no-input, and this event qualifies
3532 as input, set quit-flag to cause an interrupt. */
3533 if (!NILP (Vthrow_on_input)
3534 && event->kind != FOCUS_IN_EVENT
3535 && event->kind != FOCUS_OUT_EVENT
3536 && event->kind != HELP_EVENT
3537 && event->kind != ICONIFY_EVENT
3538 && event->kind != DEICONIFY_EVENT)
3540 Vquit_flag = Vthrow_on_input;
3541 /* If we're inside a function that wants immediate quits,
3542 do it now. */
3543 if (immediate_quit && NILP (Vinhibit_quit))
3545 immediate_quit = false;
3546 QUIT;
3552 #ifdef HAVE_X11
3554 /* Put a selection input event back in the head of the event queue. */
3556 void
3557 kbd_buffer_unget_event (struct selection_input_event *event)
3559 if (kbd_fetch_ptr == kbd_buffer)
3560 kbd_fetch_ptr = kbd_buffer + KBD_BUFFER_SIZE;
3562 /* Don't let the very last slot in the buffer become full, */
3563 union buffered_input_event *kp = kbd_fetch_ptr - 1;
3564 if (kp != kbd_store_ptr)
3566 kp->sie = *event;
3567 kbd_fetch_ptr = kp;
3571 #endif
3573 /* Limit help event positions to this range, to avoid overflow problems. */
3574 #define INPUT_EVENT_POS_MAX \
3575 ((ptrdiff_t) min (PTRDIFF_MAX, min (TYPE_MAXIMUM (Time) / 2, \
3576 MOST_POSITIVE_FIXNUM)))
3577 #define INPUT_EVENT_POS_MIN (-1 - INPUT_EVENT_POS_MAX)
3579 /* Return a Time that encodes position POS. POS must be in range. */
3581 static Time
3582 position_to_Time (ptrdiff_t pos)
3584 eassert (INPUT_EVENT_POS_MIN <= pos && pos <= INPUT_EVENT_POS_MAX);
3585 return pos;
3588 /* Return the position that ENCODED_POS encodes.
3589 Avoid signed integer overflow. */
3591 static ptrdiff_t
3592 Time_to_position (Time encoded_pos)
3594 if (encoded_pos <= INPUT_EVENT_POS_MAX)
3595 return encoded_pos;
3596 Time encoded_pos_min = INPUT_EVENT_POS_MIN;
3597 eassert (encoded_pos_min <= encoded_pos);
3598 ptrdiff_t notpos = -1 - encoded_pos;
3599 return -1 - notpos;
3602 /* Generate a HELP_EVENT input_event and store it in the keyboard
3603 buffer.
3605 HELP is the help form.
3607 FRAME and WINDOW are the frame and window where the help is
3608 generated. OBJECT is the Lisp object where the help was found (a
3609 buffer, a string, an overlay, or nil if neither from a string nor
3610 from a buffer). POS is the position within OBJECT where the help
3611 was found. */
3613 void
3614 gen_help_event (Lisp_Object help, Lisp_Object frame, Lisp_Object window,
3615 Lisp_Object object, ptrdiff_t pos)
3617 struct input_event event;
3619 event.kind = HELP_EVENT;
3620 event.frame_or_window = frame;
3621 event.arg = object;
3622 event.x = WINDOWP (window) ? window : frame;
3623 event.y = help;
3624 event.timestamp = position_to_Time (pos);
3625 kbd_buffer_store_event (&event);
3629 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3631 void
3632 kbd_buffer_store_help_event (Lisp_Object frame, Lisp_Object help)
3634 struct input_event event;
3636 event.kind = HELP_EVENT;
3637 event.frame_or_window = frame;
3638 event.arg = Qnil;
3639 event.x = Qnil;
3640 event.y = help;
3641 event.timestamp = 0;
3642 kbd_buffer_store_event (&event);
3646 /* Discard any mouse events in the event buffer by setting them to
3647 NO_EVENT. */
3648 void
3649 discard_mouse_events (void)
3651 union buffered_input_event *sp;
3652 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
3654 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3655 sp = kbd_buffer;
3657 if (sp->kind == MOUSE_CLICK_EVENT
3658 || sp->kind == WHEEL_EVENT
3659 || sp->kind == HORIZ_WHEEL_EVENT
3660 #ifdef HAVE_GPM
3661 || sp->kind == GPM_CLICK_EVENT
3662 #endif
3663 || sp->kind == SCROLL_BAR_CLICK_EVENT
3664 || sp->kind == HORIZONTAL_SCROLL_BAR_CLICK_EVENT)
3666 sp->kind = NO_EVENT;
3672 /* Return true if there are any real events waiting in the event
3673 buffer, not counting `NO_EVENT's.
3675 Discard NO_EVENT events at the front of the input queue, possibly
3676 leaving the input queue empty if there are no real input events. */
3678 bool
3679 kbd_buffer_events_waiting (void)
3681 union buffered_input_event *sp;
3683 for (sp = kbd_fetch_ptr;
3684 sp != kbd_store_ptr && sp->kind == NO_EVENT;
3685 ++sp)
3687 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3688 sp = kbd_buffer;
3691 kbd_fetch_ptr = sp;
3692 return sp != kbd_store_ptr && sp->kind != NO_EVENT;
3696 /* Clear input event EVENT. */
3698 static void
3699 clear_event (union buffered_input_event *event)
3701 event->kind = NO_EVENT;
3705 /* Read one event from the event buffer, waiting if necessary.
3706 The value is a Lisp object representing the event.
3707 The value is nil for an event that should be ignored,
3708 or that was handled here.
3709 We always read and discard one event. */
3711 static Lisp_Object
3712 kbd_buffer_get_event (KBOARD **kbp,
3713 bool *used_mouse_menu,
3714 struct timespec *end_time)
3716 Lisp_Object obj;
3718 #ifdef subprocesses
3719 if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE / 4)
3721 /* Start reading input again because we have processed enough to
3722 be able to accept new events again. */
3723 unhold_keyboard_input ();
3724 request_sigio ();
3725 start_polling ();
3727 #endif /* subprocesses */
3729 #if !defined HAVE_DBUS && !defined USE_FILE_NOTIFY
3730 if (noninteractive
3731 /* In case we are running as a daemon, only do this before
3732 detaching from the terminal. */
3733 || (IS_DAEMON && DAEMON_RUNNING))
3735 int c = getchar ();
3736 XSETINT (obj, c);
3737 *kbp = current_kboard;
3738 return obj;
3740 #endif /* !defined HAVE_DBUS && !defined USE_FILE_NOTIFY */
3742 /* Wait until there is input available. */
3743 for (;;)
3745 /* Break loop if there's an unread command event. Needed in
3746 moused window autoselection which uses a timer to insert such
3747 events. */
3748 if (CONSP (Vunread_command_events))
3749 break;
3751 if (kbd_fetch_ptr != kbd_store_ptr)
3752 break;
3753 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3754 break;
3756 /* If the quit flag is set, then read_char will return
3757 quit_char, so that counts as "available input." */
3758 if (!NILP (Vquit_flag))
3759 quit_throw_to_read_char (0);
3761 /* One way or another, wait until input is available; then, if
3762 interrupt handlers have not read it, read it now. */
3764 #ifdef USABLE_SIGIO
3765 gobble_input ();
3766 #endif
3767 if (kbd_fetch_ptr != kbd_store_ptr)
3768 break;
3769 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3770 break;
3771 if (end_time)
3773 struct timespec now = current_timespec ();
3774 if (timespec_cmp (*end_time, now) <= 0)
3775 return Qnil; /* Finished waiting. */
3776 else
3778 struct timespec duration = timespec_sub (*end_time, now);
3779 wait_reading_process_output (min (duration.tv_sec,
3780 WAIT_READING_MAX),
3781 duration.tv_nsec,
3782 -1, 1, Qnil, NULL, 0);
3785 else
3787 bool do_display = true;
3789 if (FRAME_TERMCAP_P (SELECTED_FRAME ()))
3791 struct tty_display_info *tty = CURTTY ();
3793 /* When this TTY is displaying a menu, we must prevent
3794 any redisplay, because we modify the frame's glyph
3795 matrix behind the back of the display engine. */
3796 if (tty->showing_menu)
3797 do_display = false;
3800 wait_reading_process_output (0, 0, -1, do_display, Qnil, NULL, 0);
3803 if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
3804 gobble_input ();
3807 if (CONSP (Vunread_command_events))
3809 Lisp_Object first;
3810 first = XCAR (Vunread_command_events);
3811 Vunread_command_events = XCDR (Vunread_command_events);
3812 *kbp = current_kboard;
3813 return first;
3816 /* At this point, we know that there is a readable event available
3817 somewhere. If the event queue is empty, then there must be a
3818 mouse movement enabled and available. */
3819 if (kbd_fetch_ptr != kbd_store_ptr)
3821 union buffered_input_event *event;
3823 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
3824 ? kbd_fetch_ptr
3825 : kbd_buffer);
3827 *kbp = event_to_kboard (&event->ie);
3828 if (*kbp == 0)
3829 *kbp = current_kboard; /* Better than returning null ptr? */
3831 obj = Qnil;
3833 /* These two kinds of events get special handling
3834 and don't actually appear to the command loop.
3835 We return nil for them. */
3836 if (event->kind == SELECTION_REQUEST_EVENT
3837 || event->kind == SELECTION_CLEAR_EVENT)
3839 #ifdef HAVE_X11
3840 /* Remove it from the buffer before processing it,
3841 since otherwise swallow_events will see it
3842 and process it again. */
3843 struct selection_input_event copy = event->sie;
3844 kbd_fetch_ptr = event + 1;
3845 input_pending = readable_events (0);
3846 x_handle_selection_event (&copy);
3847 #else
3848 /* We're getting selection request events, but we don't have
3849 a window system. */
3850 emacs_abort ();
3851 #endif
3854 #if defined (HAVE_NS)
3855 else if (event->kind == NS_TEXT_EVENT)
3857 if (event->ie.code == KEY_NS_PUT_WORKING_TEXT)
3858 obj = list1 (intern ("ns-put-working-text"));
3859 else
3860 obj = list1 (intern ("ns-unput-working-text"));
3861 kbd_fetch_ptr = event + 1;
3862 if (used_mouse_menu)
3863 *used_mouse_menu = true;
3865 #endif
3867 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
3868 || defined (HAVE_NS)
3869 else if (event->kind == DELETE_WINDOW_EVENT)
3871 /* Make an event (delete-frame (FRAME)). */
3872 obj = list2 (Qdelete_frame, list1 (event->ie.frame_or_window));
3873 kbd_fetch_ptr = event + 1;
3875 #endif
3876 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
3877 || defined (HAVE_NS)
3878 else if (event->kind == ICONIFY_EVENT)
3880 /* Make an event (iconify-frame (FRAME)). */
3881 obj = list2 (Qiconify_frame, list1 (event->ie.frame_or_window));
3882 kbd_fetch_ptr = event + 1;
3884 else if (event->kind == DEICONIFY_EVENT)
3886 /* Make an event (make-frame-visible (FRAME)). */
3887 obj = list2 (Qmake_frame_visible, list1 (event->ie.frame_or_window));
3888 kbd_fetch_ptr = event + 1;
3890 #endif
3891 else if (event->kind == BUFFER_SWITCH_EVENT)
3893 /* The value doesn't matter here; only the type is tested. */
3894 XSETBUFFER (obj, current_buffer);
3895 kbd_fetch_ptr = event + 1;
3897 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
3898 || defined (HAVE_NS) || defined (USE_GTK)
3899 else if (event->kind == MENU_BAR_ACTIVATE_EVENT)
3901 kbd_fetch_ptr = event + 1;
3902 input_pending = readable_events (0);
3903 if (FRAME_LIVE_P (XFRAME (event->ie.frame_or_window)))
3904 x_activate_menubar (XFRAME (event->ie.frame_or_window));
3906 #endif
3907 #ifdef HAVE_NTGUI
3908 else if (event->kind == LANGUAGE_CHANGE_EVENT)
3910 /* Make an event (language-change FRAME CODEPAGE LANGUAGE-ID). */
3911 obj = list4 (Qlanguage_change,
3912 event->ie.frame_or_window,
3913 make_number (event->ie.code),
3914 make_number (event->ie.modifiers));
3915 kbd_fetch_ptr = event + 1;
3917 #endif
3918 #ifdef USE_FILE_NOTIFY
3919 else if (event->kind == FILE_NOTIFY_EVENT)
3921 #ifdef HAVE_W32NOTIFY
3922 /* Make an event (file-notify (DESCRIPTOR ACTION FILE) CALLBACK). */
3923 obj = list3 (Qfile_notify, event->ie.arg, event->ie.frame_or_window);
3924 #else
3925 obj = make_lispy_event (&event->ie);
3926 #endif
3927 kbd_fetch_ptr = event + 1;
3929 #endif /* USE_FILE_NOTIFY */
3930 else if (event->kind == SAVE_SESSION_EVENT)
3932 obj = list2 (Qsave_session, event->ie.arg);
3933 kbd_fetch_ptr = event + 1;
3935 /* Just discard these, by returning nil.
3936 With MULTI_KBOARD, these events are used as placeholders
3937 when we need to randomly delete events from the queue.
3938 (They shouldn't otherwise be found in the buffer,
3939 but on some machines it appears they do show up
3940 even without MULTI_KBOARD.) */
3941 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
3942 mouse events during a popup-menu call. */
3943 else if (event->kind == NO_EVENT)
3944 kbd_fetch_ptr = event + 1;
3945 else if (event->kind == HELP_EVENT)
3947 Lisp_Object object, position, help, frame, window;
3949 frame = event->ie.frame_or_window;
3950 object = event->ie.arg;
3951 position = make_number (Time_to_position (event->ie.timestamp));
3952 window = event->ie.x;
3953 help = event->ie.y;
3954 clear_event (event);
3956 kbd_fetch_ptr = event + 1;
3957 if (!WINDOWP (window))
3958 window = Qnil;
3959 obj = Fcons (Qhelp_echo,
3960 list5 (frame, help, window, object, position));
3962 else if (event->kind == FOCUS_IN_EVENT)
3964 /* Notification of a FocusIn event. The frame receiving the
3965 focus is in event->frame_or_window. Generate a
3966 switch-frame event if necessary. */
3967 Lisp_Object frame, focus;
3969 frame = event->ie.frame_or_window;
3970 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
3971 if (FRAMEP (focus))
3972 frame = focus;
3974 if (
3975 #ifdef HAVE_X11
3976 ! NILP (event->ie.arg)
3978 #endif
3979 !EQ (frame, internal_last_event_frame)
3980 && !EQ (frame, selected_frame))
3981 obj = make_lispy_switch_frame (frame);
3982 else
3983 obj = make_lispy_focus_in (frame);
3985 internal_last_event_frame = frame;
3986 kbd_fetch_ptr = event + 1;
3988 else if (event->kind == FOCUS_OUT_EVENT)
3990 #ifdef HAVE_WINDOW_SYSTEM
3992 Display_Info *di;
3993 Lisp_Object frame = event->ie.frame_or_window;
3994 bool focused = false;
3996 for (di = x_display_list; di && ! focused; di = di->next)
3997 focused = di->x_highlight_frame != 0;
3999 if (!focused)
4000 obj = make_lispy_focus_out (frame);
4002 #endif /* HAVE_WINDOW_SYSTEM */
4004 kbd_fetch_ptr = event + 1;
4006 #ifdef HAVE_DBUS
4007 else if (event->kind == DBUS_EVENT)
4009 obj = make_lispy_event (&event->ie);
4010 kbd_fetch_ptr = event + 1;
4012 #endif
4013 else if (event->kind == CONFIG_CHANGED_EVENT)
4015 obj = make_lispy_event (&event->ie);
4016 kbd_fetch_ptr = event + 1;
4018 else
4020 /* If this event is on a different frame, return a switch-frame this
4021 time, and leave the event in the queue for next time. */
4022 Lisp_Object frame;
4023 Lisp_Object focus;
4025 frame = event->ie.frame_or_window;
4026 if (CONSP (frame))
4027 frame = XCAR (frame);
4028 else if (WINDOWP (frame))
4029 frame = WINDOW_FRAME (XWINDOW (frame));
4031 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
4032 if (! NILP (focus))
4033 frame = focus;
4035 if (! EQ (frame, internal_last_event_frame)
4036 && !EQ (frame, selected_frame))
4037 obj = make_lispy_switch_frame (frame);
4038 internal_last_event_frame = frame;
4040 /* If we didn't decide to make a switch-frame event, go ahead
4041 and build a real event from the queue entry. */
4043 if (NILP (obj))
4045 obj = make_lispy_event (&event->ie);
4047 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
4048 || defined (HAVE_NS) || defined (USE_GTK)
4049 /* If this was a menu selection, then set the flag to inhibit
4050 writing to last_nonmenu_event. Don't do this if the event
4051 we're returning is (menu-bar), though; that indicates the
4052 beginning of the menu sequence, and we might as well leave
4053 that as the `event with parameters' for this selection. */
4054 if (used_mouse_menu
4055 && !EQ (event->ie.frame_or_window, event->ie.arg)
4056 && (event->kind == MENU_BAR_EVENT
4057 || event->kind == TOOL_BAR_EVENT))
4058 *used_mouse_menu = true;
4059 #endif
4060 #ifdef HAVE_NS
4061 /* Certain system events are non-key events. */
4062 if (used_mouse_menu
4063 && event->kind == NS_NONKEY_EVENT)
4064 *used_mouse_menu = true;
4065 #endif
4067 /* Wipe out this event, to catch bugs. */
4068 clear_event (event);
4069 kbd_fetch_ptr = event + 1;
4073 /* Try generating a mouse motion event. */
4074 else if (!NILP (do_mouse_tracking) && some_mouse_moved ())
4076 struct frame *f = some_mouse_moved ();
4077 Lisp_Object bar_window;
4078 enum scroll_bar_part part;
4079 Lisp_Object x, y;
4080 Time t;
4082 *kbp = current_kboard;
4083 /* Note that this uses F to determine which terminal to look at.
4084 If there is no valid info, it does not store anything
4085 so x remains nil. */
4086 x = Qnil;
4088 /* XXX Can f or mouse_position_hook be NULL here? */
4089 if (f && FRAME_TERMINAL (f)->mouse_position_hook)
4090 (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, 0, &bar_window,
4091 &part, &x, &y, &t);
4093 obj = Qnil;
4095 /* Decide if we should generate a switch-frame event. Don't
4096 generate switch-frame events for motion outside of all Emacs
4097 frames. */
4098 if (!NILP (x) && f)
4100 Lisp_Object frame;
4102 frame = FRAME_FOCUS_FRAME (f);
4103 if (NILP (frame))
4104 XSETFRAME (frame, f);
4106 if (! EQ (frame, internal_last_event_frame)
4107 && !EQ (frame, selected_frame))
4108 obj = make_lispy_switch_frame (frame);
4109 internal_last_event_frame = frame;
4112 /* If we didn't decide to make a switch-frame event, go ahead and
4113 return a mouse-motion event. */
4114 if (!NILP (x) && NILP (obj))
4115 obj = make_lispy_movement (f, bar_window, part, x, y, t);
4117 else
4118 /* We were promised by the above while loop that there was
4119 something for us to read! */
4120 emacs_abort ();
4122 input_pending = readable_events (0);
4124 Vlast_event_frame = internal_last_event_frame;
4126 return (obj);
4129 /* Process any non-user-visible events (currently X selection events),
4130 without reading any user-visible events. */
4132 static void
4133 process_special_events (void)
4135 union buffered_input_event *event;
4137 for (event = kbd_fetch_ptr; event != kbd_store_ptr; ++event)
4139 if (event == kbd_buffer + KBD_BUFFER_SIZE)
4141 event = kbd_buffer;
4142 if (event == kbd_store_ptr)
4143 break;
4146 /* If we find a stored X selection request, handle it now. */
4147 if (event->kind == SELECTION_REQUEST_EVENT
4148 || event->kind == SELECTION_CLEAR_EVENT)
4150 #ifdef HAVE_X11
4152 /* Remove the event from the fifo buffer before processing;
4153 otherwise swallow_events called recursively could see it
4154 and process it again. To do this, we move the events
4155 between kbd_fetch_ptr and EVENT one slot to the right,
4156 cyclically. */
4158 struct selection_input_event copy = event->sie;
4159 union buffered_input_event *beg
4160 = (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
4161 ? kbd_buffer : kbd_fetch_ptr;
4163 if (event > beg)
4164 memmove (beg + 1, beg, (event - beg) * sizeof *beg);
4165 else if (event < beg)
4167 if (event > kbd_buffer)
4168 memmove (kbd_buffer + 1, kbd_buffer,
4169 (event - kbd_buffer) * sizeof *kbd_buffer);
4170 *kbd_buffer = *(kbd_buffer + KBD_BUFFER_SIZE - 1);
4171 if (beg < kbd_buffer + KBD_BUFFER_SIZE - 1)
4172 memmove (beg + 1, beg,
4173 (kbd_buffer + KBD_BUFFER_SIZE - 1 - beg) * sizeof *beg);
4176 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
4177 kbd_fetch_ptr = kbd_buffer + 1;
4178 else
4179 kbd_fetch_ptr++;
4181 input_pending = readable_events (0);
4182 x_handle_selection_event (&copy);
4183 #else
4184 /* We're getting selection request events, but we don't have
4185 a window system. */
4186 emacs_abort ();
4187 #endif
4192 /* Process any events that are not user-visible, run timer events that
4193 are ripe, and return, without reading any user-visible events. */
4195 void
4196 swallow_events (bool do_display)
4198 unsigned old_timers_run;
4200 process_special_events ();
4202 old_timers_run = timers_run;
4203 get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
4205 if (!input_pending && timers_run != old_timers_run && do_display)
4206 redisplay_preserve_echo_area (7);
4209 /* Record the start of when Emacs is idle,
4210 for the sake of running idle-time timers. */
4212 static void
4213 timer_start_idle (void)
4215 /* If we are already in the idle state, do nothing. */
4216 if (timespec_valid_p (timer_idleness_start_time))
4217 return;
4219 timer_idleness_start_time = current_timespec ();
4220 timer_last_idleness_start_time = timer_idleness_start_time;
4222 /* Mark all idle-time timers as once again candidates for running. */
4223 call0 (intern ("internal-timer-start-idle"));
4226 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4228 static void
4229 timer_stop_idle (void)
4231 timer_idleness_start_time = invalid_timespec ();
4234 /* Resume idle timer from last idle start time. */
4236 static void
4237 timer_resume_idle (void)
4239 if (timespec_valid_p (timer_idleness_start_time))
4240 return;
4242 timer_idleness_start_time = timer_last_idleness_start_time;
4245 /* List of elisp functions to call, delayed because they were generated in
4246 a context where Elisp could not be safely run (e.g. redisplay, signal,
4247 ...). Each element has the form (FUN . ARGS). */
4248 Lisp_Object pending_funcalls;
4250 /* Return true if TIMER is a valid timer, placing its value into *RESULT. */
4251 static bool
4252 decode_timer (Lisp_Object timer, struct timespec *result)
4254 Lisp_Object *vec;
4256 if (! (VECTORP (timer) && ASIZE (timer) == 9))
4257 return 0;
4258 vec = XVECTOR (timer)->contents;
4259 if (! NILP (vec[0]))
4260 return 0;
4261 if (! INTEGERP (vec[2]))
4262 return false;
4264 struct lisp_time t;
4265 if (decode_time_components (vec[1], vec[2], vec[3], vec[8], &t, 0) <= 0)
4266 return false;
4267 *result = lisp_to_timespec (t);
4268 return timespec_valid_p (*result);
4272 /* Check whether a timer has fired. To prevent larger problems we simply
4273 disregard elements that are not proper timers. Do not make a circular
4274 timer list for the time being.
4276 Returns the time to wait until the next timer fires. If a
4277 timer is triggering now, return zero.
4278 If no timer is active, return -1.
4280 If a timer is ripe, we run it, with quitting turned off.
4281 In that case we return 0 to indicate that a new timer_check_2 call
4282 should be done. */
4284 static struct timespec
4285 timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
4287 struct timespec nexttime;
4288 struct timespec now;
4289 struct timespec idleness_now;
4290 Lisp_Object chosen_timer;
4292 nexttime = invalid_timespec ();
4294 chosen_timer = Qnil;
4296 /* First run the code that was delayed. */
4297 while (CONSP (pending_funcalls))
4299 Lisp_Object funcall = XCAR (pending_funcalls);
4300 pending_funcalls = XCDR (pending_funcalls);
4301 safe_call2 (Qapply, XCAR (funcall), XCDR (funcall));
4304 if (CONSP (timers) || CONSP (idle_timers))
4306 now = current_timespec ();
4307 idleness_now = (timespec_valid_p (timer_idleness_start_time)
4308 ? timespec_sub (now, timer_idleness_start_time)
4309 : make_timespec (0, 0));
4312 while (CONSP (timers) || CONSP (idle_timers))
4314 Lisp_Object timer = Qnil, idle_timer = Qnil;
4315 struct timespec timer_time, idle_timer_time;
4316 struct timespec difference;
4317 struct timespec timer_difference = invalid_timespec ();
4318 struct timespec idle_timer_difference = invalid_timespec ();
4319 bool ripe, timer_ripe = 0, idle_timer_ripe = 0;
4321 /* Set TIMER and TIMER_DIFFERENCE
4322 based on the next ordinary timer.
4323 TIMER_DIFFERENCE is the distance in time from NOW to when
4324 this timer becomes ripe.
4325 Skip past invalid timers and timers already handled. */
4326 if (CONSP (timers))
4328 timer = XCAR (timers);
4329 if (! decode_timer (timer, &timer_time))
4331 timers = XCDR (timers);
4332 continue;
4335 timer_ripe = timespec_cmp (timer_time, now) <= 0;
4336 timer_difference = (timer_ripe
4337 ? timespec_sub (now, timer_time)
4338 : timespec_sub (timer_time, now));
4341 /* Likewise for IDLE_TIMER and IDLE_TIMER_DIFFERENCE
4342 based on the next idle timer. */
4343 if (CONSP (idle_timers))
4345 idle_timer = XCAR (idle_timers);
4346 if (! decode_timer (idle_timer, &idle_timer_time))
4348 idle_timers = XCDR (idle_timers);
4349 continue;
4352 idle_timer_ripe = timespec_cmp (idle_timer_time, idleness_now) <= 0;
4353 idle_timer_difference
4354 = (idle_timer_ripe
4355 ? timespec_sub (idleness_now, idle_timer_time)
4356 : timespec_sub (idle_timer_time, idleness_now));
4359 /* Decide which timer is the next timer,
4360 and set CHOSEN_TIMER, DIFFERENCE, and RIPE accordingly.
4361 Also step down the list where we found that timer. */
4363 if (timespec_valid_p (timer_difference)
4364 && (! timespec_valid_p (idle_timer_difference)
4365 || idle_timer_ripe < timer_ripe
4366 || (idle_timer_ripe == timer_ripe
4367 && ((timer_ripe
4368 ? timespec_cmp (idle_timer_difference,
4369 timer_difference)
4370 : timespec_cmp (timer_difference,
4371 idle_timer_difference))
4372 < 0))))
4374 chosen_timer = timer;
4375 timers = XCDR (timers);
4376 difference = timer_difference;
4377 ripe = timer_ripe;
4379 else
4381 chosen_timer = idle_timer;
4382 idle_timers = XCDR (idle_timers);
4383 difference = idle_timer_difference;
4384 ripe = idle_timer_ripe;
4387 /* If timer is ripe, run it if it hasn't been run. */
4388 if (ripe)
4390 if (NILP (AREF (chosen_timer, 0)))
4392 ptrdiff_t count = SPECPDL_INDEX ();
4393 Lisp_Object old_deactivate_mark = Vdeactivate_mark;
4395 /* Mark the timer as triggered to prevent problems if the lisp
4396 code fails to reschedule it right. */
4397 ASET (chosen_timer, 0, Qt);
4399 specbind (Qinhibit_quit, Qt);
4401 call1 (Qtimer_event_handler, chosen_timer);
4402 Vdeactivate_mark = old_deactivate_mark;
4403 timers_run++;
4404 unbind_to (count, Qnil);
4406 /* Since we have handled the event,
4407 we don't need to tell the caller to wake up and do it. */
4408 /* But the caller must still wait for the next timer, so
4409 return 0 to indicate that. */
4412 nexttime = make_timespec (0, 0);
4413 break;
4415 else
4416 /* When we encounter a timer that is still waiting,
4417 return the amount of time to wait before it is ripe. */
4419 return difference;
4423 /* No timers are pending in the future. */
4424 /* Return 0 if we generated an event, and -1 if not. */
4425 return nexttime;
4429 /* Check whether a timer has fired. To prevent larger problems we simply
4430 disregard elements that are not proper timers. Do not make a circular
4431 timer list for the time being.
4433 Returns the time to wait until the next timer fires.
4434 If no timer is active, return an invalid value.
4436 As long as any timer is ripe, we run it. */
4438 struct timespec
4439 timer_check (void)
4441 struct timespec nexttime;
4442 Lisp_Object timers, idle_timers;
4444 Lisp_Object tem = Vinhibit_quit;
4445 Vinhibit_quit = Qt;
4447 /* We use copies of the timers' lists to allow a timer to add itself
4448 again, without locking up Emacs if the newly added timer is
4449 already ripe when added. */
4451 /* Always consider the ordinary timers. */
4452 timers = Fcopy_sequence (Vtimer_list);
4453 /* Consider the idle timers only if Emacs is idle. */
4454 if (timespec_valid_p (timer_idleness_start_time))
4455 idle_timers = Fcopy_sequence (Vtimer_idle_list);
4456 else
4457 idle_timers = Qnil;
4459 Vinhibit_quit = tem;
4463 nexttime = timer_check_2 (timers, idle_timers);
4465 while (nexttime.tv_sec == 0 && nexttime.tv_nsec == 0);
4467 return nexttime;
4470 DEFUN ("current-idle-time", Fcurrent_idle_time, Scurrent_idle_time, 0, 0, 0,
4471 doc: /* Return the current length of Emacs idleness, or nil.
4472 The value when Emacs is idle is a list of four integers (HIGH LOW USEC PSEC)
4473 in the same style as (current-time).
4475 The value when Emacs is not idle is nil.
4477 PSEC is a multiple of the system clock resolution. */)
4478 (void)
4480 if (timespec_valid_p (timer_idleness_start_time))
4481 return make_lisp_time (timespec_sub (current_timespec (),
4482 timer_idleness_start_time));
4484 return Qnil;
4487 /* Caches for modify_event_symbol. */
4488 static Lisp_Object accent_key_syms;
4489 static Lisp_Object func_key_syms;
4490 static Lisp_Object mouse_syms;
4491 static Lisp_Object wheel_syms;
4492 static Lisp_Object drag_n_drop_syms;
4494 /* This is a list of keysym codes for special "accent" characters.
4495 It parallels lispy_accent_keys. */
4497 static const int lispy_accent_codes[] =
4499 #ifdef XK_dead_circumflex
4500 XK_dead_circumflex,
4501 #else
4503 #endif
4504 #ifdef XK_dead_grave
4505 XK_dead_grave,
4506 #else
4508 #endif
4509 #ifdef XK_dead_tilde
4510 XK_dead_tilde,
4511 #else
4513 #endif
4514 #ifdef XK_dead_diaeresis
4515 XK_dead_diaeresis,
4516 #else
4518 #endif
4519 #ifdef XK_dead_macron
4520 XK_dead_macron,
4521 #else
4523 #endif
4524 #ifdef XK_dead_degree
4525 XK_dead_degree,
4526 #else
4528 #endif
4529 #ifdef XK_dead_acute
4530 XK_dead_acute,
4531 #else
4533 #endif
4534 #ifdef XK_dead_cedilla
4535 XK_dead_cedilla,
4536 #else
4538 #endif
4539 #ifdef XK_dead_breve
4540 XK_dead_breve,
4541 #else
4543 #endif
4544 #ifdef XK_dead_ogonek
4545 XK_dead_ogonek,
4546 #else
4548 #endif
4549 #ifdef XK_dead_caron
4550 XK_dead_caron,
4551 #else
4553 #endif
4554 #ifdef XK_dead_doubleacute
4555 XK_dead_doubleacute,
4556 #else
4558 #endif
4559 #ifdef XK_dead_abovedot
4560 XK_dead_abovedot,
4561 #else
4563 #endif
4564 #ifdef XK_dead_abovering
4565 XK_dead_abovering,
4566 #else
4568 #endif
4569 #ifdef XK_dead_iota
4570 XK_dead_iota,
4571 #else
4573 #endif
4574 #ifdef XK_dead_belowdot
4575 XK_dead_belowdot,
4576 #else
4578 #endif
4579 #ifdef XK_dead_voiced_sound
4580 XK_dead_voiced_sound,
4581 #else
4583 #endif
4584 #ifdef XK_dead_semivoiced_sound
4585 XK_dead_semivoiced_sound,
4586 #else
4588 #endif
4589 #ifdef XK_dead_hook
4590 XK_dead_hook,
4591 #else
4593 #endif
4594 #ifdef XK_dead_horn
4595 XK_dead_horn,
4596 #else
4598 #endif
4601 /* This is a list of Lisp names for special "accent" characters.
4602 It parallels lispy_accent_codes. */
4604 static const char *const lispy_accent_keys[] =
4606 "dead-circumflex",
4607 "dead-grave",
4608 "dead-tilde",
4609 "dead-diaeresis",
4610 "dead-macron",
4611 "dead-degree",
4612 "dead-acute",
4613 "dead-cedilla",
4614 "dead-breve",
4615 "dead-ogonek",
4616 "dead-caron",
4617 "dead-doubleacute",
4618 "dead-abovedot",
4619 "dead-abovering",
4620 "dead-iota",
4621 "dead-belowdot",
4622 "dead-voiced-sound",
4623 "dead-semivoiced-sound",
4624 "dead-hook",
4625 "dead-horn",
4628 #ifdef HAVE_NTGUI
4629 #define FUNCTION_KEY_OFFSET 0x0
4631 const char *const lispy_function_keys[] =
4633 0, /* 0 */
4635 0, /* VK_LBUTTON 0x01 */
4636 0, /* VK_RBUTTON 0x02 */
4637 "cancel", /* VK_CANCEL 0x03 */
4638 0, /* VK_MBUTTON 0x04 */
4640 0, 0, 0, /* 0x05 .. 0x07 */
4642 "backspace", /* VK_BACK 0x08 */
4643 "tab", /* VK_TAB 0x09 */
4645 0, 0, /* 0x0A .. 0x0B */
4647 "clear", /* VK_CLEAR 0x0C */
4648 "return", /* VK_RETURN 0x0D */
4650 0, 0, /* 0x0E .. 0x0F */
4652 0, /* VK_SHIFT 0x10 */
4653 0, /* VK_CONTROL 0x11 */
4654 0, /* VK_MENU 0x12 */
4655 "pause", /* VK_PAUSE 0x13 */
4656 "capslock", /* VK_CAPITAL 0x14 */
4657 "kana", /* VK_KANA/VK_HANGUL 0x15 */
4658 0, /* 0x16 */
4659 "junja", /* VK_JUNJA 0x17 */
4660 "final", /* VK_FINAL 0x18 */
4661 "kanji", /* VK_KANJI/VK_HANJA 0x19 */
4662 0, /* 0x1A */
4663 "escape", /* VK_ESCAPE 0x1B */
4664 "convert", /* VK_CONVERT 0x1C */
4665 "non-convert", /* VK_NONCONVERT 0x1D */
4666 "accept", /* VK_ACCEPT 0x1E */
4667 "mode-change", /* VK_MODECHANGE 0x1F */
4668 0, /* VK_SPACE 0x20 */
4669 "prior", /* VK_PRIOR 0x21 */
4670 "next", /* VK_NEXT 0x22 */
4671 "end", /* VK_END 0x23 */
4672 "home", /* VK_HOME 0x24 */
4673 "left", /* VK_LEFT 0x25 */
4674 "up", /* VK_UP 0x26 */
4675 "right", /* VK_RIGHT 0x27 */
4676 "down", /* VK_DOWN 0x28 */
4677 "select", /* VK_SELECT 0x29 */
4678 "print", /* VK_PRINT 0x2A */
4679 "execute", /* VK_EXECUTE 0x2B */
4680 "snapshot", /* VK_SNAPSHOT 0x2C */
4681 "insert", /* VK_INSERT 0x2D */
4682 "delete", /* VK_DELETE 0x2E */
4683 "help", /* VK_HELP 0x2F */
4685 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4687 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4689 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4691 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4693 0, 0, 0, 0, 0, 0, 0, 0, 0,
4694 0, 0, 0, 0, 0, 0, 0, 0, 0,
4695 0, 0, 0, 0, 0, 0, 0, 0,
4697 "lwindow", /* VK_LWIN 0x5B */
4698 "rwindow", /* VK_RWIN 0x5C */
4699 "apps", /* VK_APPS 0x5D */
4700 0, /* 0x5E */
4701 "sleep",
4702 "kp-0", /* VK_NUMPAD0 0x60 */
4703 "kp-1", /* VK_NUMPAD1 0x61 */
4704 "kp-2", /* VK_NUMPAD2 0x62 */
4705 "kp-3", /* VK_NUMPAD3 0x63 */
4706 "kp-4", /* VK_NUMPAD4 0x64 */
4707 "kp-5", /* VK_NUMPAD5 0x65 */
4708 "kp-6", /* VK_NUMPAD6 0x66 */
4709 "kp-7", /* VK_NUMPAD7 0x67 */
4710 "kp-8", /* VK_NUMPAD8 0x68 */
4711 "kp-9", /* VK_NUMPAD9 0x69 */
4712 "kp-multiply", /* VK_MULTIPLY 0x6A */
4713 "kp-add", /* VK_ADD 0x6B */
4714 "kp-separator", /* VK_SEPARATOR 0x6C */
4715 "kp-subtract", /* VK_SUBTRACT 0x6D */
4716 "kp-decimal", /* VK_DECIMAL 0x6E */
4717 "kp-divide", /* VK_DIVIDE 0x6F */
4718 "f1", /* VK_F1 0x70 */
4719 "f2", /* VK_F2 0x71 */
4720 "f3", /* VK_F3 0x72 */
4721 "f4", /* VK_F4 0x73 */
4722 "f5", /* VK_F5 0x74 */
4723 "f6", /* VK_F6 0x75 */
4724 "f7", /* VK_F7 0x76 */
4725 "f8", /* VK_F8 0x77 */
4726 "f9", /* VK_F9 0x78 */
4727 "f10", /* VK_F10 0x79 */
4728 "f11", /* VK_F11 0x7A */
4729 "f12", /* VK_F12 0x7B */
4730 "f13", /* VK_F13 0x7C */
4731 "f14", /* VK_F14 0x7D */
4732 "f15", /* VK_F15 0x7E */
4733 "f16", /* VK_F16 0x7F */
4734 "f17", /* VK_F17 0x80 */
4735 "f18", /* VK_F18 0x81 */
4736 "f19", /* VK_F19 0x82 */
4737 "f20", /* VK_F20 0x83 */
4738 "f21", /* VK_F21 0x84 */
4739 "f22", /* VK_F22 0x85 */
4740 "f23", /* VK_F23 0x86 */
4741 "f24", /* VK_F24 0x87 */
4743 0, 0, 0, 0, /* 0x88 .. 0x8B */
4744 0, 0, 0, 0, /* 0x8C .. 0x8F */
4746 "kp-numlock", /* VK_NUMLOCK 0x90 */
4747 "scroll", /* VK_SCROLL 0x91 */
4748 /* Not sure where the following block comes from.
4749 Windows headers have NEC and Fujitsu specific keys in
4750 this block, but nothing generic. */
4751 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4752 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4753 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4754 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4755 "kp-end", /* VK_NUMPAD_END 0x96 */
4756 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4757 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4758 "kp-up", /* VK_NUMPAD_UP 0x99 */
4759 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4760 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4761 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4762 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4764 0, 0, /* 0x9E .. 0x9F */
4767 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4768 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4769 * No other API or message will distinguish left and right keys this way.
4770 * 0xA0 .. 0xA5
4772 0, 0, 0, 0, 0, 0,
4774 /* Multimedia keys. These are handled as WM_APPCOMMAND, which allows us
4775 to enable them selectively, and gives access to a few more functions.
4776 See lispy_multimedia_keys below. */
4777 0, 0, 0, 0, 0, 0, 0, /* 0xA6 .. 0xAC Browser */
4778 0, 0, 0, /* 0xAD .. 0xAF Volume */
4779 0, 0, 0, 0, /* 0xB0 .. 0xB3 Media */
4780 0, 0, 0, 0, /* 0xB4 .. 0xB7 Apps */
4782 /* 0xB8 .. 0xC0 "OEM" keys - all seem to be punctuation. */
4783 0, 0, 0, 0, 0, 0, 0, 0, 0,
4785 /* 0xC1 - 0xDA unallocated, 0xDB-0xDF more OEM keys */
4786 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4787 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4789 0, /* 0xE0 */
4790 "ax", /* VK_OEM_AX 0xE1 */
4791 0, /* VK_OEM_102 0xE2 */
4792 "ico-help", /* VK_ICO_HELP 0xE3 */
4793 "ico-00", /* VK_ICO_00 0xE4 */
4794 0, /* VK_PROCESSKEY 0xE5 - used by IME */
4795 "ico-clear", /* VK_ICO_CLEAR 0xE6 */
4796 0, /* VK_PACKET 0xE7 - used to pass Unicode chars */
4797 0, /* 0xE8 */
4798 "reset", /* VK_OEM_RESET 0xE9 */
4799 "jump", /* VK_OEM_JUMP 0xEA */
4800 "oem-pa1", /* VK_OEM_PA1 0xEB */
4801 "oem-pa2", /* VK_OEM_PA2 0xEC */
4802 "oem-pa3", /* VK_OEM_PA3 0xED */
4803 "wsctrl", /* VK_OEM_WSCTRL 0xEE */
4804 "cusel", /* VK_OEM_CUSEL 0xEF */
4805 "oem-attn", /* VK_OEM_ATTN 0xF0 */
4806 "finish", /* VK_OEM_FINISH 0xF1 */
4807 "copy", /* VK_OEM_COPY 0xF2 */
4808 "auto", /* VK_OEM_AUTO 0xF3 */
4809 "enlw", /* VK_OEM_ENLW 0xF4 */
4810 "backtab", /* VK_OEM_BACKTAB 0xF5 */
4811 "attn", /* VK_ATTN 0xF6 */
4812 "crsel", /* VK_CRSEL 0xF7 */
4813 "exsel", /* VK_EXSEL 0xF8 */
4814 "ereof", /* VK_EREOF 0xF9 */
4815 "play", /* VK_PLAY 0xFA */
4816 "zoom", /* VK_ZOOM 0xFB */
4817 "noname", /* VK_NONAME 0xFC */
4818 "pa1", /* VK_PA1 0xFD */
4819 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4820 0 /* 0xFF */
4823 /* Some of these duplicate the "Media keys" on newer keyboards,
4824 but they are delivered to the application in a different way. */
4825 static const char *const lispy_multimedia_keys[] =
4828 "browser-back",
4829 "browser-forward",
4830 "browser-refresh",
4831 "browser-stop",
4832 "browser-search",
4833 "browser-favorites",
4834 "browser-home",
4835 "volume-mute",
4836 "volume-down",
4837 "volume-up",
4838 "media-next",
4839 "media-previous",
4840 "media-stop",
4841 "media-play-pause",
4842 "mail",
4843 "media-select",
4844 "app-1",
4845 "app-2",
4846 "bass-down",
4847 "bass-boost",
4848 "bass-up",
4849 "treble-down",
4850 "treble-up",
4851 "mic-volume-mute",
4852 "mic-volume-down",
4853 "mic-volume-up",
4854 "help",
4855 "find",
4856 "new",
4857 "open",
4858 "close",
4859 "save",
4860 "print",
4861 "undo",
4862 "redo",
4863 "copy",
4864 "cut",
4865 "paste",
4866 "mail-reply",
4867 "mail-forward",
4868 "mail-send",
4869 "spell-check",
4870 "toggle-dictate-command",
4871 "mic-toggle",
4872 "correction-list",
4873 "media-play",
4874 "media-pause",
4875 "media-record",
4876 "media-fast-forward",
4877 "media-rewind",
4878 "media-channel-up",
4879 "media-channel-down"
4882 #else /* not HAVE_NTGUI */
4884 /* This should be dealt with in XTread_socket now, and that doesn't
4885 depend on the client system having the Kana syms defined. See also
4886 the XK_kana_A case below. */
4887 #if 0
4888 #ifdef XK_kana_A
4889 static const char *const lispy_kana_keys[] =
4891 /* X Keysym value */
4892 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4893 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4894 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4895 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4896 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4897 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4898 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4899 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4900 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4901 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4902 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4903 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4904 "kana-i", "kana-u", "kana-e", "kana-o",
4905 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4906 "prolongedsound", "kana-A", "kana-I", "kana-U",
4907 "kana-E", "kana-O", "kana-KA", "kana-KI",
4908 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4909 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4910 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4911 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4912 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4913 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4914 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4915 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4916 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4917 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4918 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4919 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4921 #endif /* XK_kana_A */
4922 #endif /* 0 */
4924 #define FUNCTION_KEY_OFFSET 0xff00
4926 /* You'll notice that this table is arranged to be conveniently
4927 indexed by X Windows keysym values. */
4928 static const char *const lispy_function_keys[] =
4930 /* X Keysym value */
4932 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4933 "backspace", "tab", "linefeed", "clear",
4934 0, "return", 0, 0,
4935 0, 0, 0, "pause", /* 0xff10...1f */
4936 0, 0, 0, 0, 0, 0, 0, "escape",
4937 0, 0, 0, 0,
4938 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4939 "romaji", "hiragana", "katakana", "hiragana-katakana",
4940 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4941 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4942 "eisu-toggle", /* 0xff30...3f */
4943 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4944 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4946 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4947 "down", "prior", "next", "end",
4948 "begin", 0, 0, 0, 0, 0, 0, 0,
4949 "select", /* 0xff60 */ /* IsMiscFunctionKey */
4950 "print",
4951 "execute",
4952 "insert",
4953 0, /* 0xff64 */
4954 "undo",
4955 "redo",
4956 "menu",
4957 "find",
4958 "cancel",
4959 "help",
4960 "break", /* 0xff6b */
4962 0, 0, 0, 0,
4963 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
4964 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
4965 "kp-space", /* 0xff80 */ /* IsKeypadKey */
4966 0, 0, 0, 0, 0, 0, 0, 0,
4967 "kp-tab", /* 0xff89 */
4968 0, 0, 0,
4969 "kp-enter", /* 0xff8d */
4970 0, 0, 0,
4971 "kp-f1", /* 0xff91 */
4972 "kp-f2",
4973 "kp-f3",
4974 "kp-f4",
4975 "kp-home", /* 0xff95 */
4976 "kp-left",
4977 "kp-up",
4978 "kp-right",
4979 "kp-down",
4980 "kp-prior", /* kp-page-up */
4981 "kp-next", /* kp-page-down */
4982 "kp-end",
4983 "kp-begin",
4984 "kp-insert",
4985 "kp-delete",
4986 0, /* 0xffa0 */
4987 0, 0, 0, 0, 0, 0, 0, 0, 0,
4988 "kp-multiply", /* 0xffaa */
4989 "kp-add",
4990 "kp-separator",
4991 "kp-subtract",
4992 "kp-decimal",
4993 "kp-divide", /* 0xffaf */
4994 "kp-0", /* 0xffb0 */
4995 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
4996 0, /* 0xffba */
4997 0, 0,
4998 "kp-equal", /* 0xffbd */
4999 "f1", /* 0xffbe */ /* IsFunctionKey */
5000 "f2",
5001 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
5002 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
5003 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
5004 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
5005 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
5006 0, 0, 0, 0, 0, 0, 0, 0,
5007 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
5008 0, 0, 0, 0, 0, 0, 0, "delete"
5011 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
5012 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
5014 static const char *const iso_lispy_function_keys[] =
5016 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
5017 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
5018 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
5019 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
5020 "iso-lefttab", /* 0xfe20 */
5021 "iso-move-line-up", "iso-move-line-down",
5022 "iso-partial-line-up", "iso-partial-line-down",
5023 "iso-partial-space-left", "iso-partial-space-right",
5024 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
5025 "iso-release-margin-left", "iso-release-margin-right",
5026 "iso-release-both-margins",
5027 "iso-fast-cursor-left", "iso-fast-cursor-right",
5028 "iso-fast-cursor-up", "iso-fast-cursor-down",
5029 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
5030 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
5033 #endif /* not HAVE_NTGUI */
5035 static Lisp_Object Vlispy_mouse_stem;
5037 static const char *const lispy_wheel_names[] =
5039 "wheel-up", "wheel-down", "wheel-left", "wheel-right"
5042 /* drag-n-drop events are generated when a set of selected files are
5043 dragged from another application and dropped onto an Emacs window. */
5044 static const char *const lispy_drag_n_drop_names[] =
5046 "drag-n-drop"
5049 /* An array of symbol indexes of scroll bar parts, indexed by an enum
5050 scroll_bar_part value. Note that Qnil corresponds to
5051 scroll_bar_nowhere and should not appear in Lisp events. */
5052 static short const scroll_bar_parts[] = {
5053 SYMBOL_INDEX (Qnil), SYMBOL_INDEX (Qabove_handle), SYMBOL_INDEX (Qhandle),
5054 SYMBOL_INDEX (Qbelow_handle), SYMBOL_INDEX (Qup), SYMBOL_INDEX (Qdown),
5055 SYMBOL_INDEX (Qtop), SYMBOL_INDEX (Qbottom), SYMBOL_INDEX (Qend_scroll),
5056 SYMBOL_INDEX (Qratio), SYMBOL_INDEX (Qbefore_handle),
5057 SYMBOL_INDEX (Qhorizontal_handle), SYMBOL_INDEX (Qafter_handle),
5058 SYMBOL_INDEX (Qleft), SYMBOL_INDEX (Qright), SYMBOL_INDEX (Qleftmost),
5059 SYMBOL_INDEX (Qrightmost), SYMBOL_INDEX (Qend_scroll), SYMBOL_INDEX (Qratio)
5062 /* A vector, indexed by button number, giving the down-going location
5063 of currently depressed buttons, both scroll bar and non-scroll bar.
5065 The elements have the form
5066 (BUTTON-NUMBER MODIFIER-MASK . REST)
5067 where REST is the cdr of a position as it would be reported in the event.
5069 The make_lispy_event function stores positions here to tell the
5070 difference between click and drag events, and to store the starting
5071 location to be included in drag events. */
5073 static Lisp_Object button_down_location;
5075 /* Information about the most recent up-going button event: Which
5076 button, what location, and what time. */
5078 static int last_mouse_button;
5079 static int last_mouse_x;
5080 static int last_mouse_y;
5081 static Time button_down_time;
5083 /* The number of clicks in this multiple-click. */
5085 static int double_click_count;
5087 /* X and Y are frame-relative coordinates for a click or wheel event.
5088 Return a Lisp-style event list. */
5090 static Lisp_Object
5091 make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
5092 Time t)
5094 enum window_part part;
5095 Lisp_Object posn = Qnil;
5096 Lisp_Object extra_info = Qnil;
5097 /* Coordinate pixel positions to return. */
5098 int xret = 0, yret = 0;
5099 /* The window under frame pixel coordinates (x,y) */
5100 Lisp_Object window = f
5101 ? window_from_coordinates (f, XINT (x), XINT (y), &part, 0)
5102 : Qnil;
5104 if (WINDOWP (window))
5106 /* It's a click in window WINDOW at frame coordinates (X,Y) */
5107 struct window *w = XWINDOW (window);
5108 Lisp_Object string_info = Qnil;
5109 ptrdiff_t textpos = 0;
5110 int col = -1, row = -1;
5111 int dx = -1, dy = -1;
5112 int width = -1, height = -1;
5113 Lisp_Object object = Qnil;
5115 /* Pixel coordinates relative to the window corner. */
5116 int wx = XINT (x) - WINDOW_LEFT_EDGE_X (w);
5117 int wy = XINT (y) - WINDOW_TOP_EDGE_Y (w);
5119 /* For text area clicks, return X, Y relative to the corner of
5120 this text area. Note that dX, dY etc are set below, by
5121 buffer_posn_from_coords. */
5122 if (part == ON_TEXT)
5124 xret = XINT (x) - window_box_left (w, TEXT_AREA);
5125 yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
5127 /* For mode line and header line clicks, return X, Y relative to
5128 the left window edge. Use mode_line_string to look for a
5129 string on the click position. */
5130 else if (part == ON_MODE_LINE || part == ON_HEADER_LINE)
5132 Lisp_Object string;
5133 ptrdiff_t charpos;
5135 posn = (part == ON_MODE_LINE) ? Qmode_line : Qheader_line;
5136 /* Note that mode_line_string takes COL, ROW as pixels and
5137 converts them to characters. */
5138 col = wx;
5139 row = wy;
5140 string = mode_line_string (w, part, &col, &row, &charpos,
5141 &object, &dx, &dy, &width, &height);
5142 if (STRINGP (string))
5143 string_info = Fcons (string, make_number (charpos));
5144 textpos = -1;
5146 xret = wx;
5147 yret = wy;
5149 /* For fringes and margins, Y is relative to the area's (and the
5150 window's) top edge, while X is meaningless. */
5151 else if (part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
5153 Lisp_Object string;
5154 ptrdiff_t charpos;
5156 posn = (part == ON_LEFT_MARGIN) ? Qleft_margin : Qright_margin;
5157 col = wx;
5158 row = wy;
5159 string = marginal_area_string (w, part, &col, &row, &charpos,
5160 &object, &dx, &dy, &width, &height);
5161 if (STRINGP (string))
5162 string_info = Fcons (string, make_number (charpos));
5163 xret = wx;
5164 yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
5166 else if (part == ON_LEFT_FRINGE)
5168 posn = Qleft_fringe;
5169 col = 0;
5170 xret = wx;
5171 dx = wx
5172 - (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
5173 ? 0 : window_box_width (w, LEFT_MARGIN_AREA));
5174 dy = yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
5176 else if (part == ON_RIGHT_FRINGE)
5178 posn = Qright_fringe;
5179 col = 0;
5180 xret = wx;
5181 dx = wx
5182 - window_box_width (w, LEFT_MARGIN_AREA)
5183 - window_box_width (w, TEXT_AREA)
5184 - (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
5185 ? window_box_width (w, RIGHT_MARGIN_AREA)
5186 : 0);
5187 dy = yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
5189 else if (part == ON_VERTICAL_BORDER)
5191 posn = Qvertical_line;
5192 width = 1;
5193 dx = 0;
5194 xret = wx;
5195 dy = yret = wy;
5197 else if (part == ON_VERTICAL_SCROLL_BAR)
5199 posn = Qvertical_scroll_bar;
5200 width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
5201 dx = xret = wx;
5202 dy = yret = wy;
5204 else if (part == ON_HORIZONTAL_SCROLL_BAR)
5206 posn = Qhorizontal_scroll_bar;
5207 width = WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
5208 dx = xret = wx;
5209 dy = yret = wy;
5211 else if (part == ON_RIGHT_DIVIDER)
5213 posn = Qright_divider;
5214 width = WINDOW_RIGHT_DIVIDER_WIDTH (w);
5215 dx = xret = wx;
5216 dy = yret = wy;
5218 else if (part == ON_BOTTOM_DIVIDER)
5220 posn = Qbottom_divider;
5221 width = WINDOW_BOTTOM_DIVIDER_WIDTH (w);
5222 dx = xret = wx;
5223 dy = yret = wy;
5226 /* For clicks in the text area, fringes, margins, or vertical
5227 scroll bar, call buffer_posn_from_coords to extract TEXTPOS,
5228 the buffer position nearest to the click. */
5229 if (!textpos)
5231 Lisp_Object string2, object2 = Qnil;
5232 struct display_pos p;
5233 int dx2, dy2;
5234 int width2, height2;
5235 /* The pixel X coordinate passed to buffer_posn_from_coords
5236 is the X coordinate relative to the text area for clicks
5237 in text-area, right-margin/fringe and right-side vertical
5238 scroll bar, zero otherwise. */
5239 int x2
5240 = (part == ON_TEXT) ? xret
5241 : (part == ON_RIGHT_FRINGE || part == ON_RIGHT_MARGIN
5242 || (part == ON_VERTICAL_SCROLL_BAR
5243 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
5244 ? (XINT (x) - window_box_left (w, TEXT_AREA))
5245 : 0;
5246 int y2 = wy;
5248 string2 = buffer_posn_from_coords (w, &x2, &y2, &p,
5249 &object2, &dx2, &dy2,
5250 &width2, &height2);
5251 textpos = CHARPOS (p.pos);
5252 if (col < 0) col = x2;
5253 if (row < 0) row = y2;
5254 if (dx < 0) dx = dx2;
5255 if (dy < 0) dy = dy2;
5256 if (width < 0) width = width2;
5257 if (height < 0) height = height2;
5259 if (NILP (posn))
5261 posn = make_number (textpos);
5262 if (STRINGP (string2))
5263 string_info = Fcons (string2,
5264 make_number (CHARPOS (p.string_pos)));
5266 if (NILP (object))
5267 object = object2;
5270 #ifdef HAVE_WINDOW_SYSTEM
5271 if (IMAGEP (object))
5273 Lisp_Object image_map, hotspot;
5274 if ((image_map = Fplist_get (XCDR (object), QCmap),
5275 !NILP (image_map))
5276 && (hotspot = find_hot_spot (image_map, dx, dy),
5277 CONSP (hotspot))
5278 && (hotspot = XCDR (hotspot), CONSP (hotspot)))
5279 posn = XCAR (hotspot);
5281 #endif
5283 /* Object info. */
5284 extra_info
5285 = list3 (object,
5286 Fcons (make_number (dx), make_number (dy)),
5287 Fcons (make_number (width), make_number (height)));
5289 /* String info. */
5290 extra_info = Fcons (string_info,
5291 Fcons (textpos < 0 ? Qnil : make_number (textpos),
5292 Fcons (Fcons (make_number (col),
5293 make_number (row)),
5294 extra_info)));
5296 else if (f != 0)
5298 /* Return mouse pixel coordinates here. */
5299 XSETFRAME (window, f);
5300 xret = XINT (x);
5301 yret = XINT (y);
5303 else
5304 window = Qnil;
5306 return Fcons (window,
5307 Fcons (posn,
5308 Fcons (Fcons (make_number (xret),
5309 make_number (yret)),
5310 Fcons (make_number (t),
5311 extra_info))));
5314 /* Return non-zero if F is a GUI frame that uses some toolkit-managed
5315 menu bar. This really means that Emacs draws and manages the menu
5316 bar as part of its normal display, and therefore can compute its
5317 geometry. */
5318 static bool
5319 toolkit_menubar_in_use (struct frame *f)
5321 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
5322 return !(!FRAME_WINDOW_P (f));
5323 #else
5324 return false;
5325 #endif
5328 /* Build the part of Lisp event which represents scroll bar state from
5329 EV. TYPE is one of Qvertical_scroll_bar or Qhorizontal_scroll_bar. */
5331 static Lisp_Object
5332 make_scroll_bar_position (struct input_event *ev, Lisp_Object type)
5334 return list5 (ev->frame_or_window, type, Fcons (ev->x, ev->y),
5335 make_number (ev->timestamp),
5336 builtin_lisp_symbol (scroll_bar_parts[ev->part]));
5339 /* Given a struct input_event, build the lisp event which represents
5340 it. If EVENT is 0, build a mouse movement event from the mouse
5341 movement buffer, which should have a movement event in it.
5343 Note that events must be passed to this function in the order they
5344 are received; this function stores the location of button presses
5345 in order to build drag events when the button is released. */
5347 static Lisp_Object
5348 make_lispy_event (struct input_event *event)
5350 int i;
5352 switch (event->kind)
5354 /* A simple keystroke. */
5355 case ASCII_KEYSTROKE_EVENT:
5356 case MULTIBYTE_CHAR_KEYSTROKE_EVENT:
5358 Lisp_Object lispy_c;
5359 EMACS_INT c = event->code;
5360 if (event->kind == ASCII_KEYSTROKE_EVENT)
5362 c &= 0377;
5363 eassert (c == event->code);
5364 /* Turn ASCII characters into control characters
5365 when proper. */
5366 if (event->modifiers & ctrl_modifier)
5368 c = make_ctrl_char (c);
5369 event->modifiers &= ~ctrl_modifier;
5373 /* Add in the other modifier bits. The shift key was taken care
5374 of by the X code. */
5375 c |= (event->modifiers
5376 & (meta_modifier | alt_modifier
5377 | hyper_modifier | super_modifier | ctrl_modifier));
5378 /* Distinguish Shift-SPC from SPC. */
5379 if ((event->code) == 040
5380 && event->modifiers & shift_modifier)
5381 c |= shift_modifier;
5382 button_down_time = 0;
5383 XSETFASTINT (lispy_c, c);
5384 return lispy_c;
5387 #ifdef HAVE_NS
5388 /* NS_NONKEY_EVENTs are just like NON_ASCII_KEYSTROKE_EVENTs,
5389 except that they are non-key events (last-nonmenu-event is nil). */
5390 case NS_NONKEY_EVENT:
5391 #endif
5393 /* A function key. The symbol may need to have modifier prefixes
5394 tacked onto it. */
5395 case NON_ASCII_KEYSTROKE_EVENT:
5396 button_down_time = 0;
5398 for (i = 0; i < ARRAYELTS (lispy_accent_codes); i++)
5399 if (event->code == lispy_accent_codes[i])
5400 return modify_event_symbol (i,
5401 event->modifiers,
5402 Qfunction_key, Qnil,
5403 lispy_accent_keys, &accent_key_syms,
5404 ARRAYELTS (lispy_accent_keys));
5406 #if 0
5407 #ifdef XK_kana_A
5408 if (event->code >= 0x400 && event->code < 0x500)
5409 return modify_event_symbol (event->code - 0x400,
5410 event->modifiers & ~shift_modifier,
5411 Qfunction_key, Qnil,
5412 lispy_kana_keys, &func_key_syms,
5413 ARRAYELTS (lispy_kana_keys));
5414 #endif /* XK_kana_A */
5415 #endif /* 0 */
5417 #ifdef ISO_FUNCTION_KEY_OFFSET
5418 if (event->code < FUNCTION_KEY_OFFSET
5419 && event->code >= ISO_FUNCTION_KEY_OFFSET)
5420 return modify_event_symbol (event->code - ISO_FUNCTION_KEY_OFFSET,
5421 event->modifiers,
5422 Qfunction_key, Qnil,
5423 iso_lispy_function_keys, &func_key_syms,
5424 ARRAYELTS (iso_lispy_function_keys));
5425 #endif
5427 if ((FUNCTION_KEY_OFFSET <= event->code
5428 && (event->code
5429 < FUNCTION_KEY_OFFSET + ARRAYELTS (lispy_function_keys)))
5430 && lispy_function_keys[event->code - FUNCTION_KEY_OFFSET])
5431 return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
5432 event->modifiers,
5433 Qfunction_key, Qnil,
5434 lispy_function_keys, &func_key_syms,
5435 ARRAYELTS (lispy_function_keys));
5437 /* Handle system-specific or unknown keysyms.
5438 We need to use an alist rather than a vector as the cache
5439 since we can't make a vector long enough. */
5440 if (NILP (KVAR (current_kboard, system_key_syms)))
5441 kset_system_key_syms (current_kboard, Fcons (Qnil, Qnil));
5442 return modify_event_symbol (event->code,
5443 event->modifiers,
5444 Qfunction_key,
5445 KVAR (current_kboard, Vsystem_key_alist),
5446 0, &KVAR (current_kboard, system_key_syms),
5447 PTRDIFF_MAX);
5449 #ifdef HAVE_NTGUI
5450 case MULTIMEDIA_KEY_EVENT:
5451 if (event->code < ARRAYELTS (lispy_multimedia_keys)
5452 && event->code > 0 && lispy_multimedia_keys[event->code])
5454 return modify_event_symbol (event->code, event->modifiers,
5455 Qfunction_key, Qnil,
5456 lispy_multimedia_keys, &func_key_syms,
5457 ARRAYELTS (lispy_multimedia_keys));
5459 return Qnil;
5460 #endif
5462 /* A mouse click. Figure out where it is, decide whether it's
5463 a press, click or drag, and build the appropriate structure. */
5464 case MOUSE_CLICK_EVENT:
5465 #ifdef HAVE_GPM
5466 case GPM_CLICK_EVENT:
5467 #endif
5468 #ifndef USE_TOOLKIT_SCROLL_BARS
5469 case SCROLL_BAR_CLICK_EVENT:
5470 case HORIZONTAL_SCROLL_BAR_CLICK_EVENT:
5471 #endif
5473 int button = event->code;
5474 bool is_double;
5475 Lisp_Object position;
5476 Lisp_Object *start_pos_ptr;
5477 Lisp_Object start_pos;
5479 position = Qnil;
5481 /* Build the position as appropriate for this mouse click. */
5482 if (event->kind == MOUSE_CLICK_EVENT
5483 #ifdef HAVE_GPM
5484 || event->kind == GPM_CLICK_EVENT
5485 #endif
5488 struct frame *f = XFRAME (event->frame_or_window);
5489 int row, column;
5491 /* Ignore mouse events that were made on frame that
5492 have been deleted. */
5493 if (! FRAME_LIVE_P (f))
5494 return Qnil;
5496 /* EVENT->x and EVENT->y are frame-relative pixel
5497 coordinates at this place. Under old redisplay, COLUMN
5498 and ROW are set to frame relative glyph coordinates
5499 which are then used to determine whether this click is
5500 in a menu (non-toolkit version). */
5501 if (!toolkit_menubar_in_use (f))
5503 pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
5504 &column, &row, NULL, 1);
5506 /* In the non-toolkit version, clicks on the menu bar
5507 are ordinary button events in the event buffer.
5508 Distinguish them, and invoke the menu.
5510 (In the toolkit version, the toolkit handles the
5511 menu bar and Emacs doesn't know about it until
5512 after the user makes a selection.) */
5513 if (row >= 0 && row < FRAME_MENU_BAR_LINES (f)
5514 && (event->modifiers & down_modifier))
5516 Lisp_Object items, item;
5518 /* Find the menu bar item under `column'. */
5519 item = Qnil;
5520 items = FRAME_MENU_BAR_ITEMS (f);
5521 for (i = 0; i < ASIZE (items); i += 4)
5523 Lisp_Object pos, string;
5524 string = AREF (items, i + 1);
5525 pos = AREF (items, i + 3);
5526 if (NILP (string))
5527 break;
5528 if (column >= XINT (pos)
5529 && column < XINT (pos) + SCHARS (string))
5531 item = AREF (items, i);
5532 break;
5536 /* ELisp manual 2.4b says (x y) are window
5537 relative but code says they are
5538 frame-relative. */
5539 position = list4 (event->frame_or_window,
5540 Qmenu_bar,
5541 Fcons (event->x, event->y),
5542 make_number (event->timestamp));
5544 return list2 (item, position);
5548 position = make_lispy_position (f, event->x, event->y,
5549 event->timestamp);
5551 #ifndef USE_TOOLKIT_SCROLL_BARS
5552 else
5553 /* It's a scrollbar click. */
5554 position = make_scroll_bar_position (event, Qvertical_scroll_bar);
5555 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5557 if (button >= ASIZE (button_down_location))
5559 ptrdiff_t incr = button - ASIZE (button_down_location) + 1;
5560 button_down_location = larger_vector (button_down_location,
5561 incr, -1);
5562 mouse_syms = larger_vector (mouse_syms, incr, -1);
5565 start_pos_ptr = aref_addr (button_down_location, button);
5566 start_pos = *start_pos_ptr;
5567 *start_pos_ptr = Qnil;
5570 /* On window-system frames, use the value of
5571 double-click-fuzz as is. On other frames, interpret it
5572 as a multiple of 1/8 characters. */
5573 struct frame *f;
5574 int fuzz;
5576 if (WINDOWP (event->frame_or_window))
5577 f = XFRAME (XWINDOW (event->frame_or_window)->frame);
5578 else if (FRAMEP (event->frame_or_window))
5579 f = XFRAME (event->frame_or_window);
5580 else
5581 emacs_abort ();
5583 if (FRAME_WINDOW_P (f))
5584 fuzz = double_click_fuzz;
5585 else
5586 fuzz = double_click_fuzz / 8;
5588 is_double = (button == last_mouse_button
5589 && (eabs (XINT (event->x) - last_mouse_x) <= fuzz)
5590 && (eabs (XINT (event->y) - last_mouse_y) <= fuzz)
5591 && button_down_time != 0
5592 && (EQ (Vdouble_click_time, Qt)
5593 || (NATNUMP (Vdouble_click_time)
5594 && (event->timestamp - button_down_time
5595 < XFASTINT (Vdouble_click_time)))));
5598 last_mouse_button = button;
5599 last_mouse_x = XINT (event->x);
5600 last_mouse_y = XINT (event->y);
5602 /* If this is a button press, squirrel away the location, so
5603 we can decide later whether it was a click or a drag. */
5604 if (event->modifiers & down_modifier)
5606 if (is_double)
5608 double_click_count++;
5609 event->modifiers |= ((double_click_count > 2)
5610 ? triple_modifier
5611 : double_modifier);
5613 else
5614 double_click_count = 1;
5615 button_down_time = event->timestamp;
5616 *start_pos_ptr = Fcopy_alist (position);
5617 ignore_mouse_drag_p = 0;
5620 /* Now we're releasing a button - check the co-ordinates to
5621 see if this was a click or a drag. */
5622 else if (event->modifiers & up_modifier)
5624 /* If we did not see a down before this up, ignore the up.
5625 Probably this happened because the down event chose a
5626 menu item. It would be an annoyance to treat the
5627 release of the button that chose the menu item as a
5628 separate event. */
5630 if (!CONSP (start_pos))
5631 return Qnil;
5633 event->modifiers &= ~up_modifier;
5636 Lisp_Object new_down, down;
5637 EMACS_INT xdiff = double_click_fuzz, ydiff = double_click_fuzz;
5639 /* The third element of every position
5640 should be the (x,y) pair. */
5641 down = Fcar (Fcdr (Fcdr (start_pos)));
5642 new_down = Fcar (Fcdr (Fcdr (position)));
5644 if (CONSP (down)
5645 && INTEGERP (XCAR (down)) && INTEGERP (XCDR (down)))
5647 xdiff = XINT (XCAR (new_down)) - XINT (XCAR (down));
5648 ydiff = XINT (XCDR (new_down)) - XINT (XCDR (down));
5651 if (ignore_mouse_drag_p)
5653 event->modifiers |= click_modifier;
5654 ignore_mouse_drag_p = 0;
5656 else if (xdiff < double_click_fuzz && xdiff > - double_click_fuzz
5657 && ydiff < double_click_fuzz && ydiff > - double_click_fuzz
5658 /* Maybe the mouse has moved a lot, caused scrolling, and
5659 eventually ended up at the same screen position (but
5660 not buffer position) in which case it is a drag, not
5661 a click. */
5662 /* FIXME: OTOH if the buffer position has changed
5663 because of a timer or process filter rather than
5664 because of mouse movement, it should be considered as
5665 a click. But mouse-drag-region completely ignores
5666 this case and it hasn't caused any real problem, so
5667 it's probably OK to ignore it as well. */
5668 && EQ (Fcar (Fcdr (start_pos)), Fcar (Fcdr (position))))
5669 /* Mouse hasn't moved (much). */
5670 event->modifiers |= click_modifier;
5671 else
5673 button_down_time = 0;
5674 event->modifiers |= drag_modifier;
5677 /* Don't check is_double; treat this as multiple
5678 if the down-event was multiple. */
5679 if (double_click_count > 1)
5680 event->modifiers |= ((double_click_count > 2)
5681 ? triple_modifier
5682 : double_modifier);
5685 else
5686 /* Every mouse event should either have the down_modifier or
5687 the up_modifier set. */
5688 emacs_abort ();
5691 /* Get the symbol we should use for the mouse click. */
5692 Lisp_Object head;
5694 head = modify_event_symbol (button,
5695 event->modifiers,
5696 Qmouse_click, Vlispy_mouse_stem,
5697 NULL,
5698 &mouse_syms,
5699 ASIZE (mouse_syms));
5700 if (event->modifiers & drag_modifier)
5701 return list3 (head, start_pos, position);
5702 else if (event->modifiers & (double_modifier | triple_modifier))
5703 return list3 (head, position, make_number (double_click_count));
5704 else
5705 return list2 (head, position);
5709 case WHEEL_EVENT:
5710 case HORIZ_WHEEL_EVENT:
5712 Lisp_Object position;
5713 Lisp_Object head;
5715 /* Build the position as appropriate for this mouse click. */
5716 struct frame *f = XFRAME (event->frame_or_window);
5718 /* Ignore wheel events that were made on frame that have been
5719 deleted. */
5720 if (! FRAME_LIVE_P (f))
5721 return Qnil;
5723 position = make_lispy_position (f, event->x, event->y,
5724 event->timestamp);
5726 /* Set double or triple modifiers to indicate the wheel speed. */
5728 /* On window-system frames, use the value of
5729 double-click-fuzz as is. On other frames, interpret it
5730 as a multiple of 1/8 characters. */
5731 struct frame *fr;
5732 int fuzz;
5733 int symbol_num;
5734 bool is_double;
5736 if (WINDOWP (event->frame_or_window))
5737 fr = XFRAME (XWINDOW (event->frame_or_window)->frame);
5738 else if (FRAMEP (event->frame_or_window))
5739 fr = XFRAME (event->frame_or_window);
5740 else
5741 emacs_abort ();
5743 fuzz = FRAME_WINDOW_P (fr)
5744 ? double_click_fuzz : double_click_fuzz / 8;
5746 if (event->modifiers & up_modifier)
5748 /* Emit a wheel-up event. */
5749 event->modifiers &= ~up_modifier;
5750 symbol_num = 0;
5752 else if (event->modifiers & down_modifier)
5754 /* Emit a wheel-down event. */
5755 event->modifiers &= ~down_modifier;
5756 symbol_num = 1;
5758 else
5759 /* Every wheel event should either have the down_modifier or
5760 the up_modifier set. */
5761 emacs_abort ();
5763 if (event->kind == HORIZ_WHEEL_EVENT)
5764 symbol_num += 2;
5766 is_double = (last_mouse_button == - (1 + symbol_num)
5767 && (eabs (XINT (event->x) - last_mouse_x) <= fuzz)
5768 && (eabs (XINT (event->y) - last_mouse_y) <= fuzz)
5769 && button_down_time != 0
5770 && (EQ (Vdouble_click_time, Qt)
5771 || (NATNUMP (Vdouble_click_time)
5772 && (event->timestamp - button_down_time
5773 < XFASTINT (Vdouble_click_time)))));
5774 if (is_double)
5776 double_click_count++;
5777 event->modifiers |= ((double_click_count > 2)
5778 ? triple_modifier
5779 : double_modifier);
5781 else
5783 double_click_count = 1;
5784 event->modifiers |= click_modifier;
5787 button_down_time = event->timestamp;
5788 /* Use a negative value to distinguish wheel from mouse button. */
5789 last_mouse_button = - (1 + symbol_num);
5790 last_mouse_x = XINT (event->x);
5791 last_mouse_y = XINT (event->y);
5793 /* Get the symbol we should use for the wheel event. */
5794 head = modify_event_symbol (symbol_num,
5795 event->modifiers,
5796 Qmouse_click,
5797 Qnil,
5798 lispy_wheel_names,
5799 &wheel_syms,
5800 ASIZE (wheel_syms));
5803 if (event->modifiers & (double_modifier | triple_modifier))
5804 return list3 (head, position, make_number (double_click_count));
5805 else
5806 return list2 (head, position);
5810 #ifdef USE_TOOLKIT_SCROLL_BARS
5812 /* We don't have down and up events if using toolkit scroll bars,
5813 so make this always a click event. Store in the `part' of
5814 the Lisp event a symbol which maps to the following actions:
5816 `above_handle' page up
5817 `below_handle' page down
5818 `up' line up
5819 `down' line down
5820 `top' top of buffer
5821 `bottom' bottom of buffer
5822 `handle' thumb has been dragged.
5823 `end-scroll' end of interaction with scroll bar
5825 The incoming input_event contains in its `part' member an
5826 index of type `enum scroll_bar_part' which we can use as an
5827 index in scroll_bar_parts to get the appropriate symbol. */
5829 case SCROLL_BAR_CLICK_EVENT:
5831 Lisp_Object position, head;
5833 position = make_scroll_bar_position (event, Qvertical_scroll_bar);
5835 /* Always treat scroll bar events as clicks. */
5836 event->modifiers |= click_modifier;
5837 event->modifiers &= ~up_modifier;
5839 if (event->code >= ASIZE (mouse_syms))
5840 mouse_syms = larger_vector (mouse_syms,
5841 event->code - ASIZE (mouse_syms) + 1,
5842 -1);
5844 /* Get the symbol we should use for the mouse click. */
5845 head = modify_event_symbol (event->code,
5846 event->modifiers,
5847 Qmouse_click,
5848 Vlispy_mouse_stem,
5849 NULL, &mouse_syms,
5850 ASIZE (mouse_syms));
5851 return list2 (head, position);
5854 case HORIZONTAL_SCROLL_BAR_CLICK_EVENT:
5856 Lisp_Object position, head;
5858 position = make_scroll_bar_position (event, Qhorizontal_scroll_bar);
5860 /* Always treat scroll bar events as clicks. */
5861 event->modifiers |= click_modifier;
5862 event->modifiers &= ~up_modifier;
5864 if (event->code >= ASIZE (mouse_syms))
5865 mouse_syms = larger_vector (mouse_syms,
5866 event->code - ASIZE (mouse_syms) + 1,
5867 -1);
5869 /* Get the symbol we should use for the mouse click. */
5870 head = modify_event_symbol (event->code,
5871 event->modifiers,
5872 Qmouse_click,
5873 Vlispy_mouse_stem,
5874 NULL, &mouse_syms,
5875 ASIZE (mouse_syms));
5876 return list2 (head, position);
5879 #endif /* USE_TOOLKIT_SCROLL_BARS */
5881 case DRAG_N_DROP_EVENT:
5883 struct frame *f;
5884 Lisp_Object head, position;
5885 Lisp_Object files;
5887 f = XFRAME (event->frame_or_window);
5888 files = event->arg;
5890 /* Ignore mouse events that were made on frames that
5891 have been deleted. */
5892 if (! FRAME_LIVE_P (f))
5893 return Qnil;
5895 position = make_lispy_position (f, event->x, event->y,
5896 event->timestamp);
5898 head = modify_event_symbol (0, event->modifiers,
5899 Qdrag_n_drop, Qnil,
5900 lispy_drag_n_drop_names,
5901 &drag_n_drop_syms, 1);
5902 return list3 (head, position, files);
5905 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
5906 || defined (HAVE_NS) || defined (USE_GTK)
5907 case MENU_BAR_EVENT:
5908 if (EQ (event->arg, event->frame_or_window))
5909 /* This is the prefix key. We translate this to
5910 `(menu_bar)' because the code in keyboard.c for menu
5911 events, which we use, relies on this. */
5912 return list1 (Qmenu_bar);
5913 return event->arg;
5914 #endif
5916 case SELECT_WINDOW_EVENT:
5917 /* Make an event (select-window (WINDOW)). */
5918 return list2 (Qselect_window, list1 (event->frame_or_window));
5920 case TOOL_BAR_EVENT:
5921 if (EQ (event->arg, event->frame_or_window))
5922 /* This is the prefix key. We translate this to
5923 `(tool_bar)' because the code in keyboard.c for tool bar
5924 events, which we use, relies on this. */
5925 return list1 (Qtool_bar);
5926 else if (SYMBOLP (event->arg))
5927 return apply_modifiers (event->modifiers, event->arg);
5928 return event->arg;
5930 case USER_SIGNAL_EVENT:
5931 /* A user signal. */
5933 char *name = find_user_signal_name (event->code);
5934 if (!name)
5935 emacs_abort ();
5936 return intern (name);
5939 case SAVE_SESSION_EVENT:
5940 return Qsave_session;
5942 #ifdef HAVE_DBUS
5943 case DBUS_EVENT:
5945 return Fcons (Qdbus_event, event->arg);
5947 #endif /* HAVE_DBUS */
5949 #if defined HAVE_GFILENOTIFY || defined HAVE_INOTIFY
5950 case FILE_NOTIFY_EVENT:
5952 return Fcons (Qfile_notify, event->arg);
5954 #endif /* defined HAVE_GFILENOTIFY || defined HAVE_INOTIFY */
5956 case CONFIG_CHANGED_EVENT:
5957 return list3 (Qconfig_changed_event,
5958 event->arg, event->frame_or_window);
5960 /* The 'kind' field of the event is something we don't recognize. */
5961 default:
5962 emacs_abort ();
5966 static Lisp_Object
5967 make_lispy_movement (struct frame *frame, Lisp_Object bar_window, enum scroll_bar_part part,
5968 Lisp_Object x, Lisp_Object y, Time t)
5970 /* Is it a scroll bar movement? */
5971 if (frame && ! NILP (bar_window))
5973 Lisp_Object part_sym;
5975 part_sym = builtin_lisp_symbol (scroll_bar_parts[part]);
5976 return list2 (Qscroll_bar_movement,
5977 list5 (bar_window,
5978 Qvertical_scroll_bar,
5979 Fcons (x, y),
5980 make_number (t),
5981 part_sym));
5983 /* Or is it an ordinary mouse movement? */
5984 else
5986 Lisp_Object position;
5987 position = make_lispy_position (frame, x, y, t);
5988 return list2 (Qmouse_movement, position);
5992 /* Construct a switch frame event. */
5993 static Lisp_Object
5994 make_lispy_switch_frame (Lisp_Object frame)
5996 return list2 (Qswitch_frame, frame);
5999 static Lisp_Object
6000 make_lispy_focus_in (Lisp_Object frame)
6002 return list2 (Qfocus_in, frame);
6005 #ifdef HAVE_WINDOW_SYSTEM
6007 static Lisp_Object
6008 make_lispy_focus_out (Lisp_Object frame)
6010 return list2 (Qfocus_out, frame);
6013 #endif /* HAVE_WINDOW_SYSTEM */
6015 /* Manipulating modifiers. */
6017 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
6019 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
6020 SYMBOL's name of the end of the modifiers; the string from this
6021 position is the unmodified symbol name.
6023 This doesn't use any caches. */
6025 static int
6026 parse_modifiers_uncached (Lisp_Object symbol, ptrdiff_t *modifier_end)
6028 Lisp_Object name;
6029 ptrdiff_t i;
6030 int modifiers;
6032 CHECK_SYMBOL (symbol);
6034 modifiers = 0;
6035 name = SYMBOL_NAME (symbol);
6037 for (i = 0; i < SBYTES (name) - 1; )
6039 ptrdiff_t this_mod_end = 0;
6040 int this_mod = 0;
6042 /* See if the name continues with a modifier word.
6043 Check that the word appears, but don't check what follows it.
6044 Set this_mod and this_mod_end to record what we find. */
6046 switch (SREF (name, i))
6048 #define SINGLE_LETTER_MOD(BIT) \
6049 (this_mod_end = i + 1, this_mod = BIT)
6051 case 'A':
6052 SINGLE_LETTER_MOD (alt_modifier);
6053 break;
6055 case 'C':
6056 SINGLE_LETTER_MOD (ctrl_modifier);
6057 break;
6059 case 'H':
6060 SINGLE_LETTER_MOD (hyper_modifier);
6061 break;
6063 case 'M':
6064 SINGLE_LETTER_MOD (meta_modifier);
6065 break;
6067 case 'S':
6068 SINGLE_LETTER_MOD (shift_modifier);
6069 break;
6071 case 's':
6072 SINGLE_LETTER_MOD (super_modifier);
6073 break;
6075 #undef SINGLE_LETTER_MOD
6077 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6078 if (i + LEN + 1 <= SBYTES (name) \
6079 && ! memcmp (SDATA (name) + i, NAME, LEN)) \
6081 this_mod_end = i + LEN; \
6082 this_mod = BIT; \
6085 case 'd':
6086 MULTI_LETTER_MOD (drag_modifier, "drag", 4);
6087 MULTI_LETTER_MOD (down_modifier, "down", 4);
6088 MULTI_LETTER_MOD (double_modifier, "double", 6);
6089 break;
6091 case 't':
6092 MULTI_LETTER_MOD (triple_modifier, "triple", 6);
6093 break;
6095 case 'u':
6096 MULTI_LETTER_MOD (up_modifier, "up", 2);
6097 break;
6098 #undef MULTI_LETTER_MOD
6102 /* If we found no modifier, stop looking for them. */
6103 if (this_mod_end == 0)
6104 break;
6106 /* Check there is a dash after the modifier, so that it
6107 really is a modifier. */
6108 if (this_mod_end >= SBYTES (name)
6109 || SREF (name, this_mod_end) != '-')
6110 break;
6112 /* This modifier is real; look for another. */
6113 modifiers |= this_mod;
6114 i = this_mod_end + 1;
6117 /* Should we include the `click' modifier? */
6118 if (! (modifiers & (down_modifier | drag_modifier
6119 | double_modifier | triple_modifier))
6120 && i + 7 == SBYTES (name)
6121 && memcmp (SDATA (name) + i, "mouse-", 6) == 0
6122 && ('0' <= SREF (name, i + 6) && SREF (name, i + 6) <= '9'))
6123 modifiers |= click_modifier;
6125 if (! (modifiers & (double_modifier | triple_modifier))
6126 && i + 6 < SBYTES (name)
6127 && memcmp (SDATA (name) + i, "wheel-", 6) == 0)
6128 modifiers |= click_modifier;
6130 if (modifier_end)
6131 *modifier_end = i;
6133 return modifiers;
6136 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6137 prepended to the string BASE[0..BASE_LEN-1].
6138 This doesn't use any caches. */
6139 static Lisp_Object
6140 apply_modifiers_uncached (int modifiers, char *base, int base_len, int base_len_byte)
6142 /* Since BASE could contain nulls, we can't use intern here; we have
6143 to use Fintern, which expects a genuine Lisp_String, and keeps a
6144 reference to it. */
6145 char new_mods[sizeof "A-C-H-M-S-s-up-down-drag-double-triple-"];
6146 int mod_len;
6149 char *p = new_mods;
6151 /* Mouse events should not exhibit the `up' modifier once they
6152 leave the event queue only accessible to C code; `up' will
6153 always be turned into a click or drag event before being
6154 presented to lisp code. But since lisp events can be
6155 synthesized bypassing the event queue and pushed into
6156 `unread-command-events' or its companions, it's better to just
6157 deal with unexpected modifier combinations. */
6159 if (modifiers & alt_modifier) { *p++ = 'A'; *p++ = '-'; }
6160 if (modifiers & ctrl_modifier) { *p++ = 'C'; *p++ = '-'; }
6161 if (modifiers & hyper_modifier) { *p++ = 'H'; *p++ = '-'; }
6162 if (modifiers & meta_modifier) { *p++ = 'M'; *p++ = '-'; }
6163 if (modifiers & shift_modifier) { *p++ = 'S'; *p++ = '-'; }
6164 if (modifiers & super_modifier) { *p++ = 's'; *p++ = '-'; }
6165 if (modifiers & double_modifier) p = stpcpy (p, "double-");
6166 if (modifiers & triple_modifier) p = stpcpy (p, "triple-");
6167 if (modifiers & up_modifier) p = stpcpy (p, "up-");
6168 if (modifiers & down_modifier) p = stpcpy (p, "down-");
6169 if (modifiers & drag_modifier) p = stpcpy (p, "drag-");
6170 /* The click modifier is denoted by the absence of other modifiers. */
6172 *p = '\0';
6174 mod_len = p - new_mods;
6178 Lisp_Object new_name;
6180 new_name = make_uninit_multibyte_string (mod_len + base_len,
6181 mod_len + base_len_byte);
6182 memcpy (SDATA (new_name), new_mods, mod_len);
6183 memcpy (SDATA (new_name) + mod_len, base, base_len_byte);
6185 return Fintern (new_name, Qnil);
6190 static const char *const modifier_names[] =
6192 "up", "down", "drag", "click", "double", "triple", 0, 0,
6193 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6194 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6196 #define NUM_MOD_NAMES ARRAYELTS (modifier_names)
6198 static Lisp_Object modifier_symbols;
6200 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6201 static Lisp_Object
6202 lispy_modifier_list (int modifiers)
6204 Lisp_Object modifier_list;
6205 int i;
6207 modifier_list = Qnil;
6208 for (i = 0; (1<<i) <= modifiers && i < NUM_MOD_NAMES; i++)
6209 if (modifiers & (1<<i))
6210 modifier_list = Fcons (AREF (modifier_symbols, i),
6211 modifier_list);
6213 return modifier_list;
6217 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6218 where UNMODIFIED is the unmodified form of SYMBOL,
6219 MASK is the set of modifiers present in SYMBOL's name.
6220 This is similar to parse_modifiers_uncached, but uses the cache in
6221 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6222 Qevent_symbol_elements property. */
6224 #define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
6226 Lisp_Object
6227 parse_modifiers (Lisp_Object symbol)
6229 Lisp_Object elements;
6231 if (INTEGERP (symbol))
6232 return list2i (KEY_TO_CHAR (symbol), XINT (symbol) & CHAR_MODIFIER_MASK);
6233 else if (!SYMBOLP (symbol))
6234 return Qnil;
6236 elements = Fget (symbol, Qevent_symbol_element_mask);
6237 if (CONSP (elements))
6238 return elements;
6239 else
6241 ptrdiff_t end;
6242 int modifiers = parse_modifiers_uncached (symbol, &end);
6243 Lisp_Object unmodified;
6244 Lisp_Object mask;
6246 unmodified = Fintern (make_string (SSDATA (SYMBOL_NAME (symbol)) + end,
6247 SBYTES (SYMBOL_NAME (symbol)) - end),
6248 Qnil);
6250 if (modifiers & ~INTMASK)
6251 emacs_abort ();
6252 XSETFASTINT (mask, modifiers);
6253 elements = list2 (unmodified, mask);
6255 /* Cache the parsing results on SYMBOL. */
6256 Fput (symbol, Qevent_symbol_element_mask,
6257 elements);
6258 Fput (symbol, Qevent_symbol_elements,
6259 Fcons (unmodified, lispy_modifier_list (modifiers)));
6261 /* Since we know that SYMBOL is modifiers applied to unmodified,
6262 it would be nice to put that in unmodified's cache.
6263 But we can't, since we're not sure that parse_modifiers is
6264 canonical. */
6266 return elements;
6270 DEFUN ("internal-event-symbol-parse-modifiers", Fevent_symbol_parse_modifiers,
6271 Sevent_symbol_parse_modifiers, 1, 1, 0,
6272 doc: /* Parse the event symbol. For internal use. */)
6273 (Lisp_Object symbol)
6275 /* Fill the cache if needed. */
6276 parse_modifiers (symbol);
6277 /* Ignore the result (which is stored on Qevent_symbol_element_mask)
6278 and use the Lispier representation stored on Qevent_symbol_elements
6279 instead. */
6280 return Fget (symbol, Qevent_symbol_elements);
6283 /* Apply the modifiers MODIFIERS to the symbol BASE.
6284 BASE must be unmodified.
6286 This is like apply_modifiers_uncached, but uses BASE's
6287 Qmodifier_cache property, if present.
6289 apply_modifiers copies the value of BASE's Qevent_kind property to
6290 the modified symbol. */
6291 static Lisp_Object
6292 apply_modifiers (int modifiers, Lisp_Object base)
6294 Lisp_Object cache, idx, entry, new_symbol;
6296 /* Mask out upper bits. We don't know where this value's been. */
6297 modifiers &= INTMASK;
6299 if (INTEGERP (base))
6300 return make_number (XINT (base) | modifiers);
6302 /* The click modifier never figures into cache indices. */
6303 cache = Fget (base, Qmodifier_cache);
6304 XSETFASTINT (idx, (modifiers & ~click_modifier));
6305 entry = assq_no_quit (idx, cache);
6307 if (CONSP (entry))
6308 new_symbol = XCDR (entry);
6309 else
6311 /* We have to create the symbol ourselves. */
6312 new_symbol = apply_modifiers_uncached (modifiers,
6313 SSDATA (SYMBOL_NAME (base)),
6314 SCHARS (SYMBOL_NAME (base)),
6315 SBYTES (SYMBOL_NAME (base)));
6317 /* Add the new symbol to the base's cache. */
6318 entry = Fcons (idx, new_symbol);
6319 Fput (base, Qmodifier_cache, Fcons (entry, cache));
6321 /* We have the parsing info now for free, so we could add it to
6322 the caches:
6323 XSETFASTINT (idx, modifiers);
6324 Fput (new_symbol, Qevent_symbol_element_mask,
6325 list2 (base, idx));
6326 Fput (new_symbol, Qevent_symbol_elements,
6327 Fcons (base, lispy_modifier_list (modifiers)));
6328 Sadly, this is only correct if `base' is indeed a base event,
6329 which is not necessarily the case. -stef */
6332 /* Make sure this symbol is of the same kind as BASE.
6334 You'd think we could just set this once and for all when we
6335 intern the symbol above, but reorder_modifiers may call us when
6336 BASE's property isn't set right; we can't assume that just
6337 because it has a Qmodifier_cache property it must have its
6338 Qevent_kind set right as well. */
6339 if (NILP (Fget (new_symbol, Qevent_kind)))
6341 Lisp_Object kind;
6343 kind = Fget (base, Qevent_kind);
6344 if (! NILP (kind))
6345 Fput (new_symbol, Qevent_kind, kind);
6348 return new_symbol;
6352 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6353 return a symbol with the modifiers placed in the canonical order.
6354 Canonical order is alphabetical, except for down and drag, which
6355 always come last. The 'click' modifier is never written out.
6357 Fdefine_key calls this to make sure that (for example) C-M-foo
6358 and M-C-foo end up being equivalent in the keymap. */
6360 Lisp_Object
6361 reorder_modifiers (Lisp_Object symbol)
6363 /* It's hopefully okay to write the code this way, since everything
6364 will soon be in caches, and no consing will be done at all. */
6365 Lisp_Object parsed;
6367 parsed = parse_modifiers (symbol);
6368 return apply_modifiers (XFASTINT (XCAR (XCDR (parsed))),
6369 XCAR (parsed));
6373 /* For handling events, we often want to produce a symbol whose name
6374 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6375 to some base, like the name of a function key or mouse button.
6376 modify_event_symbol produces symbols of this sort.
6378 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6379 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6380 in the table.
6382 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6383 into symbol names, or a string specifying a name stem used to
6384 construct a symbol name or the form `STEM-N', where N is the decimal
6385 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6386 non-nil; otherwise NAME_TABLE is used.
6388 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6389 persist between calls to modify_event_symbol that it can use to
6390 store a cache of the symbols it's generated for this NAME_TABLE
6391 before. The object stored there may be a vector or an alist.
6393 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6395 MODIFIERS is a set of modifier bits (as given in struct input_events)
6396 whose prefixes should be applied to the symbol name.
6398 SYMBOL_KIND is the value to be placed in the event_kind property of
6399 the returned symbol.
6401 The symbols we create are supposed to have an
6402 `event-symbol-elements' property, which lists the modifiers present
6403 in the symbol's name. */
6405 static Lisp_Object
6406 modify_event_symbol (ptrdiff_t symbol_num, int modifiers, Lisp_Object symbol_kind,
6407 Lisp_Object name_alist_or_stem, const char *const *name_table,
6408 Lisp_Object *symbol_table, ptrdiff_t table_size)
6410 Lisp_Object value;
6411 Lisp_Object symbol_int;
6413 /* Get rid of the "vendor-specific" bit here. */
6414 XSETINT (symbol_int, symbol_num & 0xffffff);
6416 /* Is this a request for a valid symbol? */
6417 if (symbol_num < 0 || symbol_num >= table_size)
6418 return Qnil;
6420 if (CONSP (*symbol_table))
6421 value = Fcdr (assq_no_quit (symbol_int, *symbol_table));
6423 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6424 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6425 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6426 we've never used that symbol before. */
6427 else
6429 if (! VECTORP (*symbol_table)
6430 || ASIZE (*symbol_table) != table_size)
6432 Lisp_Object size;
6434 XSETFASTINT (size, table_size);
6435 *symbol_table = Fmake_vector (size, Qnil);
6438 value = AREF (*symbol_table, symbol_num);
6441 /* Have we already used this symbol before? */
6442 if (NILP (value))
6444 /* No; let's create it. */
6445 if (CONSP (name_alist_or_stem))
6446 value = Fcdr_safe (Fassq (symbol_int, name_alist_or_stem));
6447 else if (STRINGP (name_alist_or_stem))
6449 char *buf;
6450 ptrdiff_t len = (SBYTES (name_alist_or_stem)
6451 + sizeof "-" + INT_STRLEN_BOUND (EMACS_INT));
6452 USE_SAFE_ALLOCA;
6453 buf = SAFE_ALLOCA (len);
6454 esprintf (buf, "%s-%"pI"d", SDATA (name_alist_or_stem),
6455 XINT (symbol_int) + 1);
6456 value = intern (buf);
6457 SAFE_FREE ();
6459 else if (name_table != 0 && name_table[symbol_num])
6460 value = intern (name_table[symbol_num]);
6462 #ifdef HAVE_WINDOW_SYSTEM
6463 if (NILP (value))
6465 char *name = x_get_keysym_name (symbol_num);
6466 if (name)
6467 value = intern (name);
6469 #endif
6471 if (NILP (value))
6473 char buf[sizeof "key-" + INT_STRLEN_BOUND (EMACS_INT)];
6474 sprintf (buf, "key-%"pD"d", symbol_num);
6475 value = intern (buf);
6478 if (CONSP (*symbol_table))
6479 *symbol_table = Fcons (Fcons (symbol_int, value), *symbol_table);
6480 else
6481 ASET (*symbol_table, symbol_num, value);
6483 /* Fill in the cache entries for this symbol; this also
6484 builds the Qevent_symbol_elements property, which the user
6485 cares about. */
6486 apply_modifiers (modifiers & click_modifier, value);
6487 Fput (value, Qevent_kind, symbol_kind);
6490 /* Apply modifiers to that symbol. */
6491 return apply_modifiers (modifiers, value);
6494 /* Convert a list that represents an event type,
6495 such as (ctrl meta backspace), into the usual representation of that
6496 event type as a number or a symbol. */
6498 DEFUN ("event-convert-list", Fevent_convert_list, Sevent_convert_list, 1, 1, 0,
6499 doc: /* Convert the event description list EVENT-DESC to an event type.
6500 EVENT-DESC should contain one base event type (a character or symbol)
6501 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6502 drag, down, double or triple). The base must be last.
6503 The return value is an event type (a character or symbol) which
6504 has the same base event type and all the specified modifiers. */)
6505 (Lisp_Object event_desc)
6507 Lisp_Object base;
6508 int modifiers = 0;
6509 Lisp_Object rest;
6511 base = Qnil;
6512 rest = event_desc;
6513 while (CONSP (rest))
6515 Lisp_Object elt;
6516 int this = 0;
6518 elt = XCAR (rest);
6519 rest = XCDR (rest);
6521 /* Given a symbol, see if it is a modifier name. */
6522 if (SYMBOLP (elt) && CONSP (rest))
6523 this = parse_solitary_modifier (elt);
6525 if (this != 0)
6526 modifiers |= this;
6527 else if (!NILP (base))
6528 error ("Two bases given in one event");
6529 else
6530 base = elt;
6534 /* Let the symbol A refer to the character A. */
6535 if (SYMBOLP (base) && SCHARS (SYMBOL_NAME (base)) == 1)
6536 XSETINT (base, SREF (SYMBOL_NAME (base), 0));
6538 if (INTEGERP (base))
6540 /* Turn (shift a) into A. */
6541 if ((modifiers & shift_modifier) != 0
6542 && (XINT (base) >= 'a' && XINT (base) <= 'z'))
6544 XSETINT (base, XINT (base) - ('a' - 'A'));
6545 modifiers &= ~shift_modifier;
6548 /* Turn (control a) into C-a. */
6549 if (modifiers & ctrl_modifier)
6550 return make_number ((modifiers & ~ctrl_modifier)
6551 | make_ctrl_char (XINT (base)));
6552 else
6553 return make_number (modifiers | XINT (base));
6555 else if (SYMBOLP (base))
6556 return apply_modifiers (modifiers, base);
6557 else
6558 error ("Invalid base event");
6561 /* Try to recognize SYMBOL as a modifier name.
6562 Return the modifier flag bit, or 0 if not recognized. */
6565 parse_solitary_modifier (Lisp_Object symbol)
6567 Lisp_Object name = SYMBOL_NAME (symbol);
6569 switch (SREF (name, 0))
6571 #define SINGLE_LETTER_MOD(BIT) \
6572 if (SBYTES (name) == 1) \
6573 return BIT;
6575 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6576 if (LEN == SBYTES (name) \
6577 && ! memcmp (SDATA (name), NAME, LEN)) \
6578 return BIT;
6580 case 'A':
6581 SINGLE_LETTER_MOD (alt_modifier);
6582 break;
6584 case 'a':
6585 MULTI_LETTER_MOD (alt_modifier, "alt", 3);
6586 break;
6588 case 'C':
6589 SINGLE_LETTER_MOD (ctrl_modifier);
6590 break;
6592 case 'c':
6593 MULTI_LETTER_MOD (ctrl_modifier, "ctrl", 4);
6594 MULTI_LETTER_MOD (ctrl_modifier, "control", 7);
6595 break;
6597 case 'H':
6598 SINGLE_LETTER_MOD (hyper_modifier);
6599 break;
6601 case 'h':
6602 MULTI_LETTER_MOD (hyper_modifier, "hyper", 5);
6603 break;
6605 case 'M':
6606 SINGLE_LETTER_MOD (meta_modifier);
6607 break;
6609 case 'm':
6610 MULTI_LETTER_MOD (meta_modifier, "meta", 4);
6611 break;
6613 case 'S':
6614 SINGLE_LETTER_MOD (shift_modifier);
6615 break;
6617 case 's':
6618 MULTI_LETTER_MOD (shift_modifier, "shift", 5);
6619 MULTI_LETTER_MOD (super_modifier, "super", 5);
6620 SINGLE_LETTER_MOD (super_modifier);
6621 break;
6623 case 'd':
6624 MULTI_LETTER_MOD (drag_modifier, "drag", 4);
6625 MULTI_LETTER_MOD (down_modifier, "down", 4);
6626 MULTI_LETTER_MOD (double_modifier, "double", 6);
6627 break;
6629 case 't':
6630 MULTI_LETTER_MOD (triple_modifier, "triple", 6);
6631 break;
6633 case 'u':
6634 MULTI_LETTER_MOD (up_modifier, "up", 2);
6635 break;
6637 #undef SINGLE_LETTER_MOD
6638 #undef MULTI_LETTER_MOD
6641 return 0;
6644 /* Return true if EVENT is a list whose elements are all integers or symbols.
6645 Such a list is not valid as an event,
6646 but it can be a Lucid-style event type list. */
6648 bool
6649 lucid_event_type_list_p (Lisp_Object object)
6651 Lisp_Object tail;
6653 if (! CONSP (object))
6654 return 0;
6656 if (EQ (XCAR (object), Qhelp_echo)
6657 || EQ (XCAR (object), Qvertical_line)
6658 || EQ (XCAR (object), Qmode_line)
6659 || EQ (XCAR (object), Qheader_line))
6660 return 0;
6662 for (tail = object; CONSP (tail); tail = XCDR (tail))
6664 Lisp_Object elt;
6665 elt = XCAR (tail);
6666 if (! (INTEGERP (elt) || SYMBOLP (elt)))
6667 return 0;
6670 return NILP (tail);
6673 /* Return true if terminal input chars are available.
6674 Also, store the return value into INPUT_PENDING.
6676 Serves the purpose of ioctl (0, FIONREAD, ...)
6677 but works even if FIONREAD does not exist.
6678 (In fact, this may actually read some input.)
6680 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
6681 timer events that are ripe.
6682 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
6683 events (FOCUS_IN_EVENT).
6684 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
6685 movements and toolkit scroll bar thumb drags. */
6687 static bool
6688 get_input_pending (int flags)
6690 /* First of all, have we already counted some input? */
6691 input_pending = (!NILP (Vquit_flag) || readable_events (flags));
6693 /* If input is being read as it arrives, and we have none, there is none. */
6694 if (!input_pending && (!interrupt_input || interrupts_deferred))
6696 /* Try to read some input and see how much we get. */
6697 gobble_input ();
6698 input_pending = (!NILP (Vquit_flag) || readable_events (flags));
6701 return input_pending;
6704 /* Put a BUFFER_SWITCH_EVENT in the buffer
6705 so that read_key_sequence will notice the new current buffer. */
6707 void
6708 record_asynch_buffer_change (void)
6710 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6711 The purpose of the event is to make read_key_sequence look up the
6712 keymaps again. If we aren't in read_key_sequence, we don't need one,
6713 and the event could cause trouble by messing up (input-pending-p).
6714 Note: Fwaiting_for_user_input_p always returns nil when async
6715 subprocesses aren't supported. */
6716 if (!NILP (Fwaiting_for_user_input_p ()))
6718 struct input_event event;
6720 EVENT_INIT (event);
6721 event.kind = BUFFER_SWITCH_EVENT;
6722 event.frame_or_window = Qnil;
6723 event.arg = Qnil;
6725 /* Make sure no interrupt happens while storing the event. */
6726 #ifdef USABLE_SIGIO
6727 if (interrupt_input)
6728 kbd_buffer_store_event (&event);
6729 else
6730 #endif
6732 stop_polling ();
6733 kbd_buffer_store_event (&event);
6734 start_polling ();
6739 /* Read any terminal input already buffered up by the system
6740 into the kbd_buffer, but do not wait.
6742 Return the number of keyboard chars read, or -1 meaning
6743 this is a bad time to try to read input. */
6746 gobble_input (void)
6748 int nread = 0;
6749 bool err = false;
6750 struct terminal *t;
6752 /* Store pending user signal events, if any. */
6753 store_user_signal_events ();
6755 /* Loop through the available terminals, and call their input hooks. */
6756 t = terminal_list;
6757 while (t)
6759 struct terminal *next = t->next_terminal;
6761 if (t->read_socket_hook)
6763 int nr;
6764 struct input_event hold_quit;
6766 if (input_blocked_p ())
6768 pending_signals = true;
6769 break;
6772 EVENT_INIT (hold_quit);
6773 hold_quit.kind = NO_EVENT;
6775 /* No need for FIONREAD or fcntl; just say don't wait. */
6776 while ((nr = (*t->read_socket_hook) (t, &hold_quit)) > 0)
6777 nread += nr;
6779 if (nr == -1) /* Not OK to read input now. */
6781 err = true;
6783 else if (nr == -2) /* Non-transient error. */
6785 /* The terminal device terminated; it should be closed. */
6787 /* Kill Emacs if this was our last terminal. */
6788 if (!terminal_list->next_terminal)
6789 /* Formerly simply reported no input, but that
6790 sometimes led to a failure of Emacs to terminate.
6791 SIGHUP seems appropriate if we can't reach the
6792 terminal. */
6793 /* ??? Is it really right to send the signal just to
6794 this process rather than to the whole process
6795 group? Perhaps on systems with FIONREAD Emacs is
6796 alone in its group. */
6797 terminate_due_to_signal (SIGHUP, 10);
6799 /* XXX Is calling delete_terminal safe here? It calls delete_frame. */
6801 Lisp_Object tmp;
6802 XSETTERMINAL (tmp, t);
6803 Fdelete_terminal (tmp, Qnoelisp);
6807 /* If there was no error, make sure the pointer
6808 is visible for all frames on this terminal. */
6809 if (nr >= 0)
6811 Lisp_Object tail, frame;
6813 FOR_EACH_FRAME (tail, frame)
6815 struct frame *f = XFRAME (frame);
6816 if (FRAME_TERMINAL (f) == t)
6817 frame_make_pointer_visible (f);
6821 if (hold_quit.kind != NO_EVENT)
6822 kbd_buffer_store_event (&hold_quit);
6825 t = next;
6828 if (err && !nread)
6829 nread = -1;
6831 return nread;
6834 /* This is the tty way of reading available input.
6836 Note that each terminal device has its own `struct terminal' object,
6837 and so this function is called once for each individual termcap
6838 terminal. The first parameter indicates which terminal to read from. */
6841 tty_read_avail_input (struct terminal *terminal,
6842 struct input_event *hold_quit)
6844 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6845 the kbd_buffer can really hold. That may prevent loss
6846 of characters on some systems when input is stuffed at us. */
6847 unsigned char cbuf[KBD_BUFFER_SIZE - 1];
6848 int n_to_read, i;
6849 struct tty_display_info *tty = terminal->display_info.tty;
6850 int nread = 0;
6851 #ifdef subprocesses
6852 int buffer_free = KBD_BUFFER_SIZE - kbd_buffer_nr_stored () - 1;
6854 if (kbd_on_hold_p () || buffer_free <= 0)
6855 return 0;
6856 #endif /* subprocesses */
6858 if (!terminal->name) /* Don't read from a dead terminal. */
6859 return 0;
6861 if (terminal->type != output_termcap
6862 && terminal->type != output_msdos_raw)
6863 emacs_abort ();
6865 /* XXX I think the following code should be moved to separate hook
6866 functions in system-dependent files. */
6867 #ifdef WINDOWSNT
6868 /* FIXME: AFAIK, tty_read_avail_input is not used under w32 since the non-GUI
6869 code sets read_socket_hook to w32_console_read_socket instead! */
6870 return 0;
6871 #else /* not WINDOWSNT */
6872 if (! tty->term_initted) /* In case we get called during bootstrap. */
6873 return 0;
6875 if (! tty->input)
6876 return 0; /* The terminal is suspended. */
6878 #ifdef MSDOS
6879 n_to_read = dos_keysns ();
6880 if (n_to_read == 0)
6881 return 0;
6883 cbuf[0] = dos_keyread ();
6884 nread = 1;
6886 #else /* not MSDOS */
6887 #ifdef HAVE_GPM
6888 if (gpm_tty == tty)
6890 Gpm_Event event;
6891 struct input_event gpm_hold_quit;
6892 int gpm, fd = gpm_fd;
6894 EVENT_INIT (gpm_hold_quit);
6895 gpm_hold_quit.kind = NO_EVENT;
6897 /* gpm==1 if event received.
6898 gpm==0 if the GPM daemon has closed the connection, in which case
6899 Gpm_GetEvent closes gpm_fd and clears it to -1, which is why
6900 we save it in `fd' so close_gpm can remove it from the
6901 select masks.
6902 gpm==-1 if a protocol error or EWOULDBLOCK; the latter is normal. */
6903 while (gpm = Gpm_GetEvent (&event), gpm == 1) {
6904 nread += handle_one_term_event (tty, &event, &gpm_hold_quit);
6906 if (gpm == 0)
6907 /* Presumably the GPM daemon has closed the connection. */
6908 close_gpm (fd);
6909 if (gpm_hold_quit.kind != NO_EVENT)
6910 kbd_buffer_store_event (&gpm_hold_quit);
6911 if (nread)
6912 return nread;
6914 #endif /* HAVE_GPM */
6916 /* Determine how many characters we should *try* to read. */
6917 #ifdef USABLE_FIONREAD
6918 /* Find out how much input is available. */
6919 if (ioctl (fileno (tty->input), FIONREAD, &n_to_read) < 0)
6921 if (! noninteractive)
6922 return -2; /* Close this terminal. */
6923 else
6924 n_to_read = 0;
6926 if (n_to_read == 0)
6927 return 0;
6928 if (n_to_read > sizeof cbuf)
6929 n_to_read = sizeof cbuf;
6930 #elif defined USG || defined CYGWIN
6931 /* Read some input if available, but don't wait. */
6932 n_to_read = sizeof cbuf;
6933 fcntl (fileno (tty->input), F_SETFL, O_NONBLOCK);
6934 #else
6935 # error "Cannot read without possibly delaying"
6936 #endif
6938 #ifdef subprocesses
6939 /* Don't read more than we can store. */
6940 if (n_to_read > buffer_free)
6941 n_to_read = buffer_free;
6942 #endif /* subprocesses */
6944 /* Now read; for one reason or another, this will not block.
6945 NREAD is set to the number of chars read. */
6948 nread = emacs_read (fileno (tty->input), (char *) cbuf, n_to_read);
6949 /* POSIX infers that processes which are not in the session leader's
6950 process group won't get SIGHUPs at logout time. BSDI adheres to
6951 this part standard and returns -1 from read (0) with errno==EIO
6952 when the control tty is taken away.
6953 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
6954 if (nread == -1 && errno == EIO)
6955 return -2; /* Close this terminal. */
6956 #if defined (AIX) && defined (_BSD)
6957 /* The kernel sometimes fails to deliver SIGHUP for ptys.
6958 This looks incorrect, but it isn't, because _BSD causes
6959 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
6960 and that causes a value other than 0 when there is no input. */
6961 if (nread == 0)
6962 return -2; /* Close this terminal. */
6963 #endif
6965 while (
6966 /* We used to retry the read if it was interrupted.
6967 But this does the wrong thing when O_NONBLOCK causes
6968 an EAGAIN error. Does anybody know of a situation
6969 where a retry is actually needed? */
6970 #if 0
6971 nread < 0 && (errno == EAGAIN || errno == EFAULT
6972 #ifdef EBADSLT
6973 || errno == EBADSLT
6974 #endif
6976 #else
6978 #endif
6981 #ifndef USABLE_FIONREAD
6982 #if defined (USG) || defined (CYGWIN)
6983 fcntl (fileno (tty->input), F_SETFL, 0);
6984 #endif /* USG or CYGWIN */
6985 #endif /* no FIONREAD */
6987 if (nread <= 0)
6988 return nread;
6990 #endif /* not MSDOS */
6991 #endif /* not WINDOWSNT */
6993 for (i = 0; i < nread; i++)
6995 struct input_event buf;
6996 EVENT_INIT (buf);
6997 buf.kind = ASCII_KEYSTROKE_EVENT;
6998 buf.modifiers = 0;
6999 if (tty->meta_key == 1 && (cbuf[i] & 0x80))
7000 buf.modifiers = meta_modifier;
7001 if (tty->meta_key != 2)
7002 cbuf[i] &= ~0x80;
7004 buf.code = cbuf[i];
7005 /* Set the frame corresponding to the active tty. Note that the
7006 value of selected_frame is not reliable here, redisplay tends
7007 to temporarily change it. */
7008 buf.frame_or_window = tty->top_frame;
7009 buf.arg = Qnil;
7011 kbd_buffer_store_event (&buf);
7012 /* Don't look at input that follows a C-g too closely.
7013 This reduces lossage due to autorepeat on C-g. */
7014 if (buf.kind == ASCII_KEYSTROKE_EVENT
7015 && buf.code == quit_char)
7016 break;
7019 return nread;
7022 static void
7023 handle_async_input (void)
7025 #ifdef USABLE_SIGIO
7026 while (1)
7028 int nread = gobble_input ();
7029 /* -1 means it's not ok to read the input now.
7030 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7031 0 means there was no keyboard input available. */
7032 if (nread <= 0)
7033 break;
7035 #endif
7038 void
7039 process_pending_signals (void)
7041 pending_signals = false;
7042 handle_async_input ();
7043 do_pending_atimers ();
7046 /* Undo any number of BLOCK_INPUT calls down to level LEVEL,
7047 and reinvoke any pending signal if the level is now 0 and
7048 a fatal error is not already in progress. */
7050 void
7051 unblock_input_to (int level)
7053 interrupt_input_blocked = level;
7054 if (level == 0)
7056 if (pending_signals && !fatal_error_in_progress)
7057 process_pending_signals ();
7059 else if (level < 0)
7060 emacs_abort ();
7063 /* End critical section.
7065 If doing signal-driven input, and a signal came in when input was
7066 blocked, reinvoke the signal handler now to deal with it.
7068 It will also process queued input, if it was not read before.
7069 When a longer code sequence does not use block/unblock input
7070 at all, the whole input gathered up to the next call to
7071 unblock_input will be processed inside that call. */
7073 void
7074 unblock_input (void)
7076 unblock_input_to (interrupt_input_blocked - 1);
7079 /* Undo any number of BLOCK_INPUT calls,
7080 and also reinvoke any pending signal. */
7082 void
7083 totally_unblock_input (void)
7085 unblock_input_to (0);
7088 #ifdef USABLE_SIGIO
7090 void
7091 handle_input_available_signal (int sig)
7093 pending_signals = true;
7095 if (input_available_clear_time)
7096 *input_available_clear_time = make_timespec (0, 0);
7099 static void
7100 deliver_input_available_signal (int sig)
7102 deliver_process_signal (sig, handle_input_available_signal);
7104 #endif /* USABLE_SIGIO */
7107 /* User signal events. */
7109 struct user_signal_info
7111 /* Signal number. */
7112 int sig;
7114 /* Name of the signal. */
7115 char *name;
7117 /* Number of pending signals. */
7118 int npending;
7120 struct user_signal_info *next;
7123 /* List of user signals. */
7124 static struct user_signal_info *user_signals = NULL;
7126 void
7127 add_user_signal (int sig, const char *name)
7129 struct sigaction action;
7130 struct user_signal_info *p;
7132 for (p = user_signals; p; p = p->next)
7133 if (p->sig == sig)
7134 /* Already added. */
7135 return;
7137 p = xmalloc (sizeof *p);
7138 p->sig = sig;
7139 p->name = xstrdup (name);
7140 p->npending = 0;
7141 p->next = user_signals;
7142 user_signals = p;
7144 emacs_sigaction_init (&action, deliver_user_signal);
7145 sigaction (sig, &action, 0);
7148 static void
7149 handle_user_signal (int sig)
7151 struct user_signal_info *p;
7152 const char *special_event_name = NULL;
7154 if (SYMBOLP (Vdebug_on_event))
7155 special_event_name = SSDATA (SYMBOL_NAME (Vdebug_on_event));
7157 for (p = user_signals; p; p = p->next)
7158 if (p->sig == sig)
7160 if (special_event_name
7161 && strcmp (special_event_name, p->name) == 0)
7163 /* Enter the debugger in many ways. */
7164 debug_on_next_call = true;
7165 debug_on_quit = true;
7166 Vquit_flag = Qt;
7167 Vinhibit_quit = Qnil;
7169 /* Eat the event. */
7170 break;
7173 p->npending++;
7174 #ifdef USABLE_SIGIO
7175 if (interrupt_input)
7176 handle_input_available_signal (sig);
7177 else
7178 #endif
7180 /* Tell wait_reading_process_output that it needs to wake
7181 up and look around. */
7182 if (input_available_clear_time)
7183 *input_available_clear_time = make_timespec (0, 0);
7185 break;
7189 static void
7190 deliver_user_signal (int sig)
7192 deliver_process_signal (sig, handle_user_signal);
7195 static char *
7196 find_user_signal_name (int sig)
7198 struct user_signal_info *p;
7200 for (p = user_signals; p; p = p->next)
7201 if (p->sig == sig)
7202 return p->name;
7204 return NULL;
7207 static void
7208 store_user_signal_events (void)
7210 struct user_signal_info *p;
7211 struct input_event buf;
7212 bool buf_initialized = false;
7214 for (p = user_signals; p; p = p->next)
7215 if (p->npending > 0)
7217 if (! buf_initialized)
7219 memset (&buf, 0, sizeof buf);
7220 buf.kind = USER_SIGNAL_EVENT;
7221 buf.frame_or_window = selected_frame;
7222 buf_initialized = true;
7227 buf.code = p->sig;
7228 kbd_buffer_store_event (&buf);
7229 p->npending--;
7231 while (p->npending > 0);
7236 static void menu_bar_item (Lisp_Object, Lisp_Object, Lisp_Object, void *);
7237 static Lisp_Object menu_bar_one_keymap_changed_items;
7239 /* These variables hold the vector under construction within
7240 menu_bar_items and its subroutines, and the current index
7241 for storing into that vector. */
7242 static Lisp_Object menu_bar_items_vector;
7243 static int menu_bar_items_index;
7246 static const char *separator_names[] = {
7247 "space",
7248 "no-line",
7249 "single-line",
7250 "double-line",
7251 "single-dashed-line",
7252 "double-dashed-line",
7253 "shadow-etched-in",
7254 "shadow-etched-out",
7255 "shadow-etched-in-dash",
7256 "shadow-etched-out-dash",
7257 "shadow-double-etched-in",
7258 "shadow-double-etched-out",
7259 "shadow-double-etched-in-dash",
7260 "shadow-double-etched-out-dash",
7264 /* Return true if LABEL specifies a separator. */
7266 bool
7267 menu_separator_name_p (const char *label)
7269 if (!label)
7270 return 0;
7271 else if (strlen (label) > 3
7272 && memcmp (label, "--", 2) == 0
7273 && label[2] != '-')
7275 int i;
7276 label += 2;
7277 for (i = 0; separator_names[i]; ++i)
7278 if (strcmp (label, separator_names[i]) == 0)
7279 return 1;
7281 else
7283 /* It's a separator if it contains only dashes. */
7284 while (*label == '-')
7285 ++label;
7286 return (*label == 0);
7289 return 0;
7293 /* Return a vector of menu items for a menu bar, appropriate
7294 to the current buffer. Each item has three elements in the vector:
7295 KEY STRING MAPLIST.
7297 OLD is an old vector we can optionally reuse, or nil. */
7299 Lisp_Object
7300 menu_bar_items (Lisp_Object old)
7302 /* The number of keymaps we're scanning right now, and the number of
7303 keymaps we have allocated space for. */
7304 ptrdiff_t nmaps;
7306 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7307 in the current keymaps, or nil where it is not a prefix. */
7308 Lisp_Object *maps;
7310 Lisp_Object mapsbuf[3];
7311 Lisp_Object def, tail;
7313 ptrdiff_t mapno;
7314 Lisp_Object oquit;
7316 USE_SAFE_ALLOCA;
7318 /* In order to build the menus, we need to call the keymap
7319 accessors. They all call QUIT. But this function is called
7320 during redisplay, during which a quit is fatal. So inhibit
7321 quitting while building the menus.
7322 We do this instead of specbind because (1) errors will clear it anyway
7323 and (2) this avoids risk of specpdl overflow. */
7324 oquit = Vinhibit_quit;
7325 Vinhibit_quit = Qt;
7327 if (!NILP (old))
7328 menu_bar_items_vector = old;
7329 else
7330 menu_bar_items_vector = Fmake_vector (make_number (24), Qnil);
7331 menu_bar_items_index = 0;
7333 /* Build our list of keymaps.
7334 If we recognize a function key and replace its escape sequence in
7335 keybuf with its symbol, or if the sequence starts with a mouse
7336 click and we need to switch buffers, we jump back here to rebuild
7337 the initial keymaps from the current buffer. */
7339 Lisp_Object *tmaps;
7341 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7342 if (!NILP (Voverriding_local_map_menu_flag)
7343 && !NILP (Voverriding_local_map))
7345 /* Yes, use them (if non-nil) as well as the global map. */
7346 maps = mapsbuf;
7347 nmaps = 0;
7348 if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
7349 maps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
7350 if (!NILP (Voverriding_local_map))
7351 maps[nmaps++] = Voverriding_local_map;
7353 else
7355 /* No, so use major and minor mode keymaps and keymap property.
7356 Note that menu-bar bindings in the local-map and keymap
7357 properties may not work reliable, as they are only
7358 recognized when the menu-bar (or mode-line) is updated,
7359 which does not normally happen after every command. */
7360 ptrdiff_t nminor = current_minor_maps (NULL, &tmaps);
7361 SAFE_NALLOCA (maps, 1, nminor + 4);
7362 nmaps = 0;
7363 Lisp_Object tem = KVAR (current_kboard, Voverriding_terminal_local_map);
7364 if (!NILP (tem) && !NILP (Voverriding_local_map_menu_flag))
7365 maps[nmaps++] = tem;
7366 if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
7367 maps[nmaps++] = tem;
7368 if (nminor != 0)
7370 memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
7371 nmaps += nminor;
7373 maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
7375 maps[nmaps++] = current_global_map;
7378 /* Look up in each map the dummy prefix key `menu-bar'. */
7380 for (mapno = nmaps - 1; mapno >= 0; mapno--)
7381 if (!NILP (maps[mapno]))
7383 def = get_keymap (access_keymap (maps[mapno], Qmenu_bar, 1, 0, 1),
7384 0, 1);
7385 if (CONSP (def))
7387 menu_bar_one_keymap_changed_items = Qnil;
7388 map_keymap_canonical (def, menu_bar_item, Qnil, NULL);
7392 /* Move to the end those items that should be at the end. */
7394 for (tail = Vmenu_bar_final_items; CONSP (tail); tail = XCDR (tail))
7396 int i;
7397 int end = menu_bar_items_index;
7399 for (i = 0; i < end; i += 4)
7400 if (EQ (XCAR (tail), AREF (menu_bar_items_vector, i)))
7402 Lisp_Object tem0, tem1, tem2, tem3;
7403 /* Move the item at index I to the end,
7404 shifting all the others forward. */
7405 tem0 = AREF (menu_bar_items_vector, i + 0);
7406 tem1 = AREF (menu_bar_items_vector, i + 1);
7407 tem2 = AREF (menu_bar_items_vector, i + 2);
7408 tem3 = AREF (menu_bar_items_vector, i + 3);
7409 if (end > i + 4)
7410 memmove (aref_addr (menu_bar_items_vector, i),
7411 aref_addr (menu_bar_items_vector, i + 4),
7412 (end - i - 4) * word_size);
7413 ASET (menu_bar_items_vector, end - 4, tem0);
7414 ASET (menu_bar_items_vector, end - 3, tem1);
7415 ASET (menu_bar_items_vector, end - 2, tem2);
7416 ASET (menu_bar_items_vector, end - 1, tem3);
7417 break;
7421 /* Add nil, nil, nil, nil at the end. */
7423 int i = menu_bar_items_index;
7424 if (i + 4 > ASIZE (menu_bar_items_vector))
7425 menu_bar_items_vector
7426 = larger_vector (menu_bar_items_vector, 4, -1);
7427 /* Add this item. */
7428 ASET (menu_bar_items_vector, i, Qnil); i++;
7429 ASET (menu_bar_items_vector, i, Qnil); i++;
7430 ASET (menu_bar_items_vector, i, Qnil); i++;
7431 ASET (menu_bar_items_vector, i, Qnil); i++;
7432 menu_bar_items_index = i;
7435 Vinhibit_quit = oquit;
7436 SAFE_FREE ();
7437 return menu_bar_items_vector;
7440 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7441 If there's already an item for KEY, add this DEF to it. */
7443 Lisp_Object item_properties;
7445 static void
7446 menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dummy2)
7448 int i;
7449 bool parsed;
7450 Lisp_Object tem;
7452 if (EQ (item, Qundefined))
7454 /* If a map has an explicit `undefined' as definition,
7455 discard any previously made menu bar item. */
7457 for (i = 0; i < menu_bar_items_index; i += 4)
7458 if (EQ (key, AREF (menu_bar_items_vector, i)))
7460 if (menu_bar_items_index > i + 4)
7461 memmove (aref_addr (menu_bar_items_vector, i),
7462 aref_addr (menu_bar_items_vector, i + 4),
7463 (menu_bar_items_index - i - 4) * word_size);
7464 menu_bar_items_index -= 4;
7468 /* If this keymap has already contributed to this KEY,
7469 don't contribute to it a second time. */
7470 tem = Fmemq (key, menu_bar_one_keymap_changed_items);
7471 if (!NILP (tem) || NILP (item))
7472 return;
7474 menu_bar_one_keymap_changed_items
7475 = Fcons (key, menu_bar_one_keymap_changed_items);
7477 /* We add to menu_bar_one_keymap_changed_items before doing the
7478 parse_menu_item, so that if it turns out it wasn't a menu item,
7479 it still correctly hides any further menu item. */
7480 parsed = parse_menu_item (item, 1);
7481 if (!parsed)
7482 return;
7484 item = AREF (item_properties, ITEM_PROPERTY_DEF);
7486 /* Find any existing item for this KEY. */
7487 for (i = 0; i < menu_bar_items_index; i += 4)
7488 if (EQ (key, AREF (menu_bar_items_vector, i)))
7489 break;
7491 /* If we did not find this KEY, add it at the end. */
7492 if (i == menu_bar_items_index)
7494 /* If vector is too small, get a bigger one. */
7495 if (i + 4 > ASIZE (menu_bar_items_vector))
7496 menu_bar_items_vector = larger_vector (menu_bar_items_vector, 4, -1);
7497 /* Add this item. */
7498 ASET (menu_bar_items_vector, i, key); i++;
7499 ASET (menu_bar_items_vector, i,
7500 AREF (item_properties, ITEM_PROPERTY_NAME)); i++;
7501 ASET (menu_bar_items_vector, i, list1 (item)); i++;
7502 ASET (menu_bar_items_vector, i, make_number (0)); i++;
7503 menu_bar_items_index = i;
7505 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7506 else
7508 Lisp_Object old;
7509 old = AREF (menu_bar_items_vector, i + 2);
7510 /* If the new and the old items are not both keymaps,
7511 the lookup will only find `item'. */
7512 item = Fcons (item, KEYMAPP (item) && KEYMAPP (XCAR (old)) ? old : Qnil);
7513 ASET (menu_bar_items_vector, i + 2, item);
7517 /* This is used as the handler when calling menu_item_eval_property. */
7518 static Lisp_Object
7519 menu_item_eval_property_1 (Lisp_Object arg)
7521 /* If we got a quit from within the menu computation,
7522 quit all the way out of it. This takes care of C-] in the debugger. */
7523 if (CONSP (arg) && EQ (XCAR (arg), Qquit))
7524 Fsignal (Qquit, Qnil);
7526 return Qnil;
7529 static Lisp_Object
7530 eval_dyn (Lisp_Object form)
7532 return Feval (form, Qnil);
7535 /* Evaluate an expression and return the result (or nil if something
7536 went wrong). Used to evaluate dynamic parts of menu items. */
7537 Lisp_Object
7538 menu_item_eval_property (Lisp_Object sexpr)
7540 ptrdiff_t count = SPECPDL_INDEX ();
7541 Lisp_Object val;
7542 specbind (Qinhibit_redisplay, Qt);
7543 val = internal_condition_case_1 (eval_dyn, sexpr, Qerror,
7544 menu_item_eval_property_1);
7545 return unbind_to (count, val);
7548 /* This function parses a menu item and leaves the result in the
7549 vector item_properties.
7550 ITEM is a key binding, a possible menu item.
7551 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7552 top level.
7553 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7554 parse_menu_item returns true if the item is a menu item and false
7555 otherwise. */
7557 bool
7558 parse_menu_item (Lisp_Object item, int inmenubar)
7560 Lisp_Object def, tem, item_string, start;
7561 Lisp_Object filter;
7562 Lisp_Object keyhint;
7563 int i;
7565 filter = Qnil;
7566 keyhint = Qnil;
7568 if (!CONSP (item))
7569 return 0;
7571 /* Create item_properties vector if necessary. */
7572 if (NILP (item_properties))
7573 item_properties
7574 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE + 1), Qnil);
7576 /* Initialize optional entries. */
7577 for (i = ITEM_PROPERTY_DEF; i < ITEM_PROPERTY_ENABLE; i++)
7578 ASET (item_properties, i, Qnil);
7579 ASET (item_properties, ITEM_PROPERTY_ENABLE, Qt);
7581 /* Save the item here to protect it from GC. */
7582 ASET (item_properties, ITEM_PROPERTY_ITEM, item);
7584 item_string = XCAR (item);
7586 start = item;
7587 item = XCDR (item);
7588 if (STRINGP (item_string))
7590 /* Old format menu item. */
7591 ASET (item_properties, ITEM_PROPERTY_NAME, item_string);
7593 /* Maybe help string. */
7594 if (CONSP (item) && STRINGP (XCAR (item)))
7596 ASET (item_properties, ITEM_PROPERTY_HELP,
7597 Fsubstitute_command_keys (XCAR (item)));
7598 start = item;
7599 item = XCDR (item);
7602 /* Maybe an obsolete key binding cache. */
7603 if (CONSP (item) && CONSP (XCAR (item))
7604 && (NILP (XCAR (XCAR (item)))
7605 || VECTORP (XCAR (XCAR (item)))))
7606 item = XCDR (item);
7608 /* This is the real definition--the function to run. */
7609 ASET (item_properties, ITEM_PROPERTY_DEF, item);
7611 /* Get enable property, if any. */
7612 if (SYMBOLP (item))
7614 tem = Fget (item, Qmenu_enable);
7615 if (!NILP (Venable_disabled_menus_and_buttons))
7616 ASET (item_properties, ITEM_PROPERTY_ENABLE, Qt);
7617 else if (!NILP (tem))
7618 ASET (item_properties, ITEM_PROPERTY_ENABLE, tem);
7621 else if (EQ (item_string, Qmenu_item) && CONSP (item))
7623 /* New format menu item. */
7624 ASET (item_properties, ITEM_PROPERTY_NAME, XCAR (item));
7625 start = XCDR (item);
7626 if (CONSP (start))
7628 /* We have a real binding. */
7629 ASET (item_properties, ITEM_PROPERTY_DEF, XCAR (start));
7631 item = XCDR (start);
7632 /* Is there an obsolete cache list with key equivalences. */
7633 if (CONSP (item) && CONSP (XCAR (item)))
7634 item = XCDR (item);
7636 /* Parse properties. */
7637 while (CONSP (item) && CONSP (XCDR (item)))
7639 tem = XCAR (item);
7640 item = XCDR (item);
7642 if (EQ (tem, QCenable))
7644 if (!NILP (Venable_disabled_menus_and_buttons))
7645 ASET (item_properties, ITEM_PROPERTY_ENABLE, Qt);
7646 else
7647 ASET (item_properties, ITEM_PROPERTY_ENABLE, XCAR (item));
7649 else if (EQ (tem, QCvisible))
7651 /* If got a visible property and that evaluates to nil
7652 then ignore this item. */
7653 tem = menu_item_eval_property (XCAR (item));
7654 if (NILP (tem))
7655 return 0;
7657 else if (EQ (tem, QChelp))
7659 Lisp_Object help = XCAR (item);
7660 if (STRINGP (help))
7661 help = Fsubstitute_command_keys (help);
7662 ASET (item_properties, ITEM_PROPERTY_HELP, help);
7664 else if (EQ (tem, QCfilter))
7665 filter = item;
7666 else if (EQ (tem, QCkey_sequence))
7668 tem = XCAR (item);
7669 if (SYMBOLP (tem) || STRINGP (tem) || VECTORP (tem))
7670 /* Be GC protected. Set keyhint to item instead of tem. */
7671 keyhint = item;
7673 else if (EQ (tem, QCkeys))
7675 tem = XCAR (item);
7676 if (CONSP (tem) || STRINGP (tem))
7677 ASET (item_properties, ITEM_PROPERTY_KEYEQ, tem);
7679 else if (EQ (tem, QCbutton) && CONSP (XCAR (item)))
7681 Lisp_Object type;
7682 tem = XCAR (item);
7683 type = XCAR (tem);
7684 if (EQ (type, QCtoggle) || EQ (type, QCradio))
7686 ASET (item_properties, ITEM_PROPERTY_SELECTED,
7687 XCDR (tem));
7688 ASET (item_properties, ITEM_PROPERTY_TYPE, type);
7691 item = XCDR (item);
7694 else if (inmenubar || !NILP (start))
7695 return 0;
7697 else
7698 return 0; /* not a menu item */
7700 /* If item string is not a string, evaluate it to get string.
7701 If we don't get a string, skip this item. */
7702 item_string = AREF (item_properties, ITEM_PROPERTY_NAME);
7703 if (!(STRINGP (item_string)))
7705 item_string = menu_item_eval_property (item_string);
7706 if (!STRINGP (item_string))
7707 return 0;
7708 ASET (item_properties, ITEM_PROPERTY_NAME, item_string);
7711 /* If got a filter apply it on definition. */
7712 def = AREF (item_properties, ITEM_PROPERTY_DEF);
7713 if (!NILP (filter))
7715 def = menu_item_eval_property (list2 (XCAR (filter),
7716 list2 (Qquote, def)));
7718 ASET (item_properties, ITEM_PROPERTY_DEF, def);
7721 /* Enable or disable selection of item. */
7722 tem = AREF (item_properties, ITEM_PROPERTY_ENABLE);
7723 if (!EQ (tem, Qt))
7725 tem = menu_item_eval_property (tem);
7726 if (inmenubar && NILP (tem))
7727 return 0; /* Ignore disabled items in menu bar. */
7728 ASET (item_properties, ITEM_PROPERTY_ENABLE, tem);
7731 /* If we got no definition, this item is just unselectable text which
7732 is OK in a submenu but not in the menubar. */
7733 if (NILP (def))
7734 return (!inmenubar);
7736 /* See if this is a separate pane or a submenu. */
7737 def = AREF (item_properties, ITEM_PROPERTY_DEF);
7738 tem = get_keymap (def, 0, 1);
7739 /* For a subkeymap, just record its details and exit. */
7740 if (CONSP (tem))
7742 ASET (item_properties, ITEM_PROPERTY_MAP, tem);
7743 ASET (item_properties, ITEM_PROPERTY_DEF, tem);
7744 return 1;
7747 /* At the top level in the menu bar, do likewise for commands also.
7748 The menu bar does not display equivalent key bindings anyway.
7749 ITEM_PROPERTY_DEF is already set up properly. */
7750 if (inmenubar > 0)
7751 return 1;
7753 { /* This is a command. See if there is an equivalent key binding. */
7754 Lisp_Object keyeq = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
7755 AUTO_STRING (space_space, " ");
7757 /* The previous code preferred :key-sequence to :keys, so we
7758 preserve this behavior. */
7759 if (STRINGP (keyeq) && !CONSP (keyhint))
7760 keyeq = concat2 (space_space, Fsubstitute_command_keys (keyeq));
7761 else
7763 Lisp_Object prefix = keyeq;
7764 Lisp_Object keys = Qnil;
7766 if (CONSP (prefix))
7768 def = XCAR (prefix);
7769 prefix = XCDR (prefix);
7771 else
7772 def = AREF (item_properties, ITEM_PROPERTY_DEF);
7774 if (CONSP (keyhint) && !NILP (XCAR (keyhint)))
7776 keys = XCAR (keyhint);
7777 tem = Fkey_binding (keys, Qnil, Qnil, Qnil);
7779 /* We have a suggested key. Is it bound to the command? */
7780 if (NILP (tem)
7781 || (!EQ (tem, def)
7782 /* If the command is an alias for another
7783 (such as lmenu.el set it up), check if the
7784 original command matches the cached command. */
7785 && !(SYMBOLP (def)
7786 && EQ (tem, XSYMBOL (def)->function))))
7787 keys = Qnil;
7790 if (NILP (keys))
7791 keys = Fwhere_is_internal (def, Qnil, Qt, Qnil, Qnil);
7793 if (!NILP (keys))
7795 tem = Fkey_description (keys, Qnil);
7796 if (CONSP (prefix))
7798 if (STRINGP (XCAR (prefix)))
7799 tem = concat2 (XCAR (prefix), tem);
7800 if (STRINGP (XCDR (prefix)))
7801 tem = concat2 (tem, XCDR (prefix));
7803 keyeq = concat2 (space_space, tem);
7805 else
7806 keyeq = Qnil;
7809 /* If we have an equivalent key binding, use that. */
7810 ASET (item_properties, ITEM_PROPERTY_KEYEQ, keyeq);
7813 /* Include this when menu help is implemented.
7814 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7815 if (!(NILP (tem) || STRINGP (tem)))
7817 tem = menu_item_eval_property (tem);
7818 if (!STRINGP (tem))
7819 tem = Qnil;
7820 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7824 /* Handle radio buttons or toggle boxes. */
7825 tem = AREF (item_properties, ITEM_PROPERTY_SELECTED);
7826 if (!NILP (tem))
7827 ASET (item_properties, ITEM_PROPERTY_SELECTED,
7828 menu_item_eval_property (tem));
7830 return 1;
7835 /***********************************************************************
7836 Tool-bars
7837 ***********************************************************************/
7839 /* A vector holding tool bar items while they are parsed in function
7840 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7841 in the vector. */
7843 static Lisp_Object tool_bar_items_vector;
7845 /* A vector holding the result of parse_tool_bar_item. Layout is like
7846 the one for a single item in tool_bar_items_vector. */
7848 static Lisp_Object tool_bar_item_properties;
7850 /* Next free index in tool_bar_items_vector. */
7852 static int ntool_bar_items;
7854 /* Function prototypes. */
7856 static void init_tool_bar_items (Lisp_Object);
7857 static void process_tool_bar_item (Lisp_Object, Lisp_Object, Lisp_Object,
7858 void *);
7859 static bool parse_tool_bar_item (Lisp_Object, Lisp_Object);
7860 static void append_tool_bar_item (void);
7863 /* Return a vector of tool bar items for keymaps currently in effect.
7864 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7865 tool bar items found. */
7867 Lisp_Object
7868 tool_bar_items (Lisp_Object reuse, int *nitems)
7870 Lisp_Object *maps;
7871 Lisp_Object mapsbuf[3];
7872 ptrdiff_t nmaps, i;
7873 Lisp_Object oquit;
7874 Lisp_Object *tmaps;
7875 USE_SAFE_ALLOCA;
7877 *nitems = 0;
7879 /* In order to build the menus, we need to call the keymap
7880 accessors. They all call QUIT. But this function is called
7881 during redisplay, during which a quit is fatal. So inhibit
7882 quitting while building the menus. We do this instead of
7883 specbind because (1) errors will clear it anyway and (2) this
7884 avoids risk of specpdl overflow. */
7885 oquit = Vinhibit_quit;
7886 Vinhibit_quit = Qt;
7888 /* Initialize tool_bar_items_vector and protect it from GC. */
7889 init_tool_bar_items (reuse);
7891 /* Build list of keymaps in maps. Set nmaps to the number of maps
7892 to process. */
7894 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7895 if (!NILP (Voverriding_local_map_menu_flag)
7896 && !NILP (Voverriding_local_map))
7898 /* Yes, use them (if non-nil) as well as the global map. */
7899 maps = mapsbuf;
7900 nmaps = 0;
7901 if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
7902 maps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
7903 if (!NILP (Voverriding_local_map))
7904 maps[nmaps++] = Voverriding_local_map;
7906 else
7908 /* No, so use major and minor mode keymaps and keymap property.
7909 Note that tool-bar bindings in the local-map and keymap
7910 properties may not work reliable, as they are only
7911 recognized when the tool-bar (or mode-line) is updated,
7912 which does not normally happen after every command. */
7913 ptrdiff_t nminor = current_minor_maps (NULL, &tmaps);
7914 SAFE_NALLOCA (maps, 1, nminor + 4);
7915 nmaps = 0;
7916 Lisp_Object tem = KVAR (current_kboard, Voverriding_terminal_local_map);
7917 if (!NILP (tem) && !NILP (Voverriding_local_map_menu_flag))
7918 maps[nmaps++] = tem;
7919 if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
7920 maps[nmaps++] = tem;
7921 if (nminor != 0)
7923 memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
7924 nmaps += nminor;
7926 maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
7929 /* Add global keymap at the end. */
7930 maps[nmaps++] = current_global_map;
7932 /* Process maps in reverse order and look up in each map the prefix
7933 key `tool-bar'. */
7934 for (i = nmaps - 1; i >= 0; --i)
7935 if (!NILP (maps[i]))
7937 Lisp_Object keymap;
7939 keymap = get_keymap (access_keymap (maps[i], Qtool_bar, 1, 0, 1), 0, 1);
7940 if (CONSP (keymap))
7941 map_keymap (keymap, process_tool_bar_item, Qnil, NULL, 1);
7944 Vinhibit_quit = oquit;
7945 *nitems = ntool_bar_items / TOOL_BAR_ITEM_NSLOTS;
7946 SAFE_FREE ();
7947 return tool_bar_items_vector;
7951 /* Process the definition of KEY which is DEF. */
7953 static void
7954 process_tool_bar_item (Lisp_Object key, Lisp_Object def, Lisp_Object data, void *args)
7956 int i;
7958 if (EQ (def, Qundefined))
7960 /* If a map has an explicit `undefined' as definition,
7961 discard any previously made item. */
7962 for (i = 0; i < ntool_bar_items; i += TOOL_BAR_ITEM_NSLOTS)
7964 Lisp_Object *v = XVECTOR (tool_bar_items_vector)->contents + i;
7966 if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
7968 if (ntool_bar_items > i + TOOL_BAR_ITEM_NSLOTS)
7969 memmove (v, v + TOOL_BAR_ITEM_NSLOTS,
7970 ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
7971 * word_size));
7972 ntool_bar_items -= TOOL_BAR_ITEM_NSLOTS;
7973 break;
7977 else if (parse_tool_bar_item (key, def))
7978 /* Append a new tool bar item to tool_bar_items_vector. Accept
7979 more than one definition for the same key. */
7980 append_tool_bar_item ();
7983 /* Access slot with index IDX of vector tool_bar_item_properties. */
7984 #define PROP(IDX) AREF (tool_bar_item_properties, (IDX))
7985 static void
7986 set_prop (ptrdiff_t idx, Lisp_Object val)
7988 ASET (tool_bar_item_properties, idx, val);
7992 /* Parse a tool bar item specification ITEM for key KEY and return the
7993 result in tool_bar_item_properties. Value is false if ITEM is
7994 invalid.
7996 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
7998 CAPTION is the caption of the item, If it's not a string, it is
7999 evaluated to get a string.
8001 BINDING is the tool bar item's binding. Tool-bar items with keymaps
8002 as binding are currently ignored.
8004 The following properties are recognized:
8006 - `:enable FORM'.
8008 FORM is evaluated and specifies whether the tool bar item is
8009 enabled or disabled.
8011 - `:visible FORM'
8013 FORM is evaluated and specifies whether the tool bar item is visible.
8015 - `:filter FUNCTION'
8017 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8018 result is stored as the new binding.
8020 - `:button (TYPE SELECTED)'
8022 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8023 and specifies whether the button is selected (pressed) or not.
8025 - `:image IMAGES'
8027 IMAGES is either a single image specification or a vector of four
8028 image specifications. See enum tool_bar_item_images.
8030 - `:help HELP-STRING'.
8032 Gives a help string to display for the tool bar item.
8034 - `:label LABEL-STRING'.
8036 A text label to show with the tool bar button if labels are enabled. */
8038 static bool
8039 parse_tool_bar_item (Lisp_Object key, Lisp_Object item)
8041 Lisp_Object filter = Qnil;
8042 Lisp_Object caption;
8043 int i;
8044 bool have_label = false;
8046 /* Definition looks like `(menu-item CAPTION BINDING PROPS...)'.
8047 Rule out items that aren't lists, don't start with
8048 `menu-item' or whose rest following `tool-bar-item' is not a
8049 list. */
8050 if (!CONSP (item))
8051 return 0;
8053 /* As an exception, allow old-style menu separators. */
8054 if (STRINGP (XCAR (item)))
8055 item = list1 (XCAR (item));
8056 else if (!EQ (XCAR (item), Qmenu_item)
8057 || (item = XCDR (item), !CONSP (item)))
8058 return 0;
8060 /* Create tool_bar_item_properties vector if necessary. Reset it to
8061 defaults. */
8062 if (VECTORP (tool_bar_item_properties))
8064 for (i = 0; i < TOOL_BAR_ITEM_NSLOTS; ++i)
8065 set_prop (i, Qnil);
8067 else
8068 tool_bar_item_properties
8069 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS), Qnil);
8071 /* Set defaults. */
8072 set_prop (TOOL_BAR_ITEM_KEY, key);
8073 set_prop (TOOL_BAR_ITEM_ENABLED_P, Qt);
8075 /* Get the caption of the item. If the caption is not a string,
8076 evaluate it to get a string. If we don't get a string, skip this
8077 item. */
8078 caption = XCAR (item);
8079 if (!STRINGP (caption))
8081 caption = menu_item_eval_property (caption);
8082 if (!STRINGP (caption))
8083 return 0;
8085 set_prop (TOOL_BAR_ITEM_CAPTION, caption);
8087 /* If the rest following the caption is not a list, the menu item is
8088 either a separator, or invalid. */
8089 item = XCDR (item);
8090 if (!CONSP (item))
8092 if (menu_separator_name_p (SSDATA (caption)))
8094 set_prop (TOOL_BAR_ITEM_TYPE, Qt);
8095 #if !defined (USE_GTK) && !defined (HAVE_NS)
8096 /* If we use build_desired_tool_bar_string to render the
8097 tool bar, the separator is rendered as an image. */
8098 set_prop (TOOL_BAR_ITEM_IMAGES,
8099 (menu_item_eval_property
8100 (Vtool_bar_separator_image_expression)));
8101 set_prop (TOOL_BAR_ITEM_ENABLED_P, Qnil);
8102 set_prop (TOOL_BAR_ITEM_SELECTED_P, Qnil);
8103 set_prop (TOOL_BAR_ITEM_CAPTION, Qnil);
8104 #endif
8105 return 1;
8107 return 0;
8110 /* Store the binding. */
8111 set_prop (TOOL_BAR_ITEM_BINDING, XCAR (item));
8112 item = XCDR (item);
8114 /* Ignore cached key binding, if any. */
8115 if (CONSP (item) && CONSP (XCAR (item)))
8116 item = XCDR (item);
8118 /* Process the rest of the properties. */
8119 for (; CONSP (item) && CONSP (XCDR (item)); item = XCDR (XCDR (item)))
8121 Lisp_Object ikey, value;
8123 ikey = XCAR (item);
8124 value = XCAR (XCDR (item));
8126 if (EQ (ikey, QCenable))
8128 /* `:enable FORM'. */
8129 if (!NILP (Venable_disabled_menus_and_buttons))
8130 set_prop (TOOL_BAR_ITEM_ENABLED_P, Qt);
8131 else
8132 set_prop (TOOL_BAR_ITEM_ENABLED_P, value);
8134 else if (EQ (ikey, QCvisible))
8136 /* `:visible FORM'. If got a visible property and that
8137 evaluates to nil then ignore this item. */
8138 if (NILP (menu_item_eval_property (value)))
8139 return 0;
8141 else if (EQ (ikey, QChelp))
8142 /* `:help HELP-STRING'. */
8143 set_prop (TOOL_BAR_ITEM_HELP, value);
8144 else if (EQ (ikey, QCvert_only))
8145 /* `:vert-only t/nil'. */
8146 set_prop (TOOL_BAR_ITEM_VERT_ONLY, value);
8147 else if (EQ (ikey, QClabel))
8149 const char *bad_label = "!!?GARBLED ITEM?!!";
8150 /* `:label LABEL-STRING'. */
8151 set_prop (TOOL_BAR_ITEM_LABEL,
8152 STRINGP (value) ? value : build_string (bad_label));
8153 have_label = true;
8155 else if (EQ (ikey, QCfilter))
8156 /* ':filter FORM'. */
8157 filter = value;
8158 else if (EQ (ikey, QCbutton) && CONSP (value))
8160 /* `:button (TYPE . SELECTED)'. */
8161 Lisp_Object type, selected;
8163 type = XCAR (value);
8164 selected = XCDR (value);
8165 if (EQ (type, QCtoggle) || EQ (type, QCradio))
8167 set_prop (TOOL_BAR_ITEM_SELECTED_P, selected);
8168 set_prop (TOOL_BAR_ITEM_TYPE, type);
8171 else if (EQ (ikey, QCimage)
8172 && (CONSP (value)
8173 || (VECTORP (value) && ASIZE (value) == 4)))
8174 /* Value is either a single image specification or a vector
8175 of 4 such specifications for the different button states. */
8176 set_prop (TOOL_BAR_ITEM_IMAGES, value);
8177 else if (EQ (ikey, QCrtl))
8178 /* ':rtl STRING' */
8179 set_prop (TOOL_BAR_ITEM_RTL_IMAGE, value);
8183 if (!have_label)
8185 /* Try to make one from caption and key. */
8186 Lisp_Object tkey = PROP (TOOL_BAR_ITEM_KEY);
8187 Lisp_Object tcapt = PROP (TOOL_BAR_ITEM_CAPTION);
8188 const char *label = SYMBOLP (tkey) ? SSDATA (SYMBOL_NAME (tkey)) : "";
8189 const char *capt = STRINGP (tcapt) ? SSDATA (tcapt) : "";
8190 ptrdiff_t max_lbl =
8191 2 * max (0, min (tool_bar_max_label_size, STRING_BYTES_BOUND / 2));
8192 char *buf = xmalloc (max_lbl + 1);
8193 Lisp_Object new_lbl;
8194 ptrdiff_t caption_len = strlen (capt);
8196 if (caption_len <= max_lbl && capt[0] != '\0')
8198 strcpy (buf, capt);
8199 while (caption_len > 0 && buf[caption_len - 1] == '.')
8200 caption_len--;
8201 buf[caption_len] = '\0';
8202 label = capt = buf;
8205 if (strlen (label) <= max_lbl && label[0] != '\0')
8207 ptrdiff_t j;
8208 if (label != buf)
8209 strcpy (buf, label);
8211 for (j = 0; buf[j] != '\0'; ++j)
8212 if (buf[j] == '-')
8213 buf[j] = ' ';
8214 label = buf;
8216 else
8217 label = "";
8219 new_lbl = Fupcase_initials (build_string (label));
8220 if (SCHARS (new_lbl) <= tool_bar_max_label_size)
8221 set_prop (TOOL_BAR_ITEM_LABEL, new_lbl);
8222 else
8223 set_prop (TOOL_BAR_ITEM_LABEL, empty_unibyte_string);
8224 xfree (buf);
8227 /* If got a filter apply it on binding. */
8228 if (!NILP (filter))
8229 set_prop (TOOL_BAR_ITEM_BINDING,
8230 (menu_item_eval_property
8231 (list2 (filter,
8232 list2 (Qquote,
8233 PROP (TOOL_BAR_ITEM_BINDING))))));
8235 /* See if the binding is a keymap. Give up if it is. */
8236 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING), 0, 1)))
8237 return 0;
8239 /* Enable or disable selection of item. */
8240 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P), Qt))
8241 set_prop (TOOL_BAR_ITEM_ENABLED_P,
8242 menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P)));
8244 /* Handle radio buttons or toggle boxes. */
8245 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P)))
8246 set_prop (TOOL_BAR_ITEM_SELECTED_P,
8247 menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P)));
8249 return 1;
8251 #undef PROP
8255 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8256 that can be reused. */
8258 static void
8259 init_tool_bar_items (Lisp_Object reuse)
8261 if (VECTORP (reuse))
8262 tool_bar_items_vector = reuse;
8263 else
8264 tool_bar_items_vector = Fmake_vector (make_number (64), Qnil);
8265 ntool_bar_items = 0;
8269 /* Append parsed tool bar item properties from
8270 tool_bar_item_properties */
8272 static void
8273 append_tool_bar_item (void)
8275 ptrdiff_t incr
8276 = (ntool_bar_items
8277 - (ASIZE (tool_bar_items_vector) - TOOL_BAR_ITEM_NSLOTS));
8279 /* Enlarge tool_bar_items_vector if necessary. */
8280 if (incr > 0)
8281 tool_bar_items_vector = larger_vector (tool_bar_items_vector, incr, -1);
8283 /* Append entries from tool_bar_item_properties to the end of
8284 tool_bar_items_vector. */
8285 vcopy (tool_bar_items_vector, ntool_bar_items,
8286 XVECTOR (tool_bar_item_properties)->contents, TOOL_BAR_ITEM_NSLOTS);
8287 ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
8294 /* Read a character using menus based on the keymap MAP.
8295 Return nil if there are no menus in the maps.
8296 Return t if we displayed a menu but the user rejected it.
8298 PREV_EVENT is the previous input event, or nil if we are reading
8299 the first event of a key sequence.
8301 If USED_MOUSE_MENU is non-null, set *USED_MOUSE_MENU to true
8302 if we used a mouse menu to read the input, or false otherwise. If
8303 USED_MOUSE_MENU is null, don't dereference it.
8305 The prompting is done based on the prompt-string of the map
8306 and the strings associated with various map elements.
8308 This can be done with X menus or with menus put in the minibuf.
8309 These are done in different ways, depending on how the input will be read.
8310 Menus using X are done after auto-saving in read-char, getting the input
8311 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8312 and do auto-saving in the inner call of read_char. */
8314 static Lisp_Object
8315 read_char_x_menu_prompt (Lisp_Object map,
8316 Lisp_Object prev_event, bool *used_mouse_menu)
8318 if (used_mouse_menu)
8319 *used_mouse_menu = false;
8321 /* Use local over global Menu maps. */
8323 if (! menu_prompting)
8324 return Qnil;
8326 /* If we got to this point via a mouse click,
8327 use a real menu for mouse selection. */
8328 if (EVENT_HAS_PARAMETERS (prev_event)
8329 && !EQ (XCAR (prev_event), Qmenu_bar)
8330 && !EQ (XCAR (prev_event), Qtool_bar))
8332 /* Display the menu and get the selection. */
8333 Lisp_Object value;
8335 value = Fx_popup_menu (prev_event, get_keymap (map, 0, 1));
8336 if (CONSP (value))
8338 Lisp_Object tem;
8340 record_menu_key (XCAR (value));
8342 /* If we got multiple events, unread all but
8343 the first.
8344 There is no way to prevent those unread events
8345 from showing up later in last_nonmenu_event.
8346 So turn symbol and integer events into lists,
8347 to indicate that they came from a mouse menu,
8348 so that when present in last_nonmenu_event
8349 they won't confuse things. */
8350 for (tem = XCDR (value); CONSP (tem); tem = XCDR (tem))
8352 record_menu_key (XCAR (tem));
8353 if (SYMBOLP (XCAR (tem))
8354 || INTEGERP (XCAR (tem)))
8355 XSETCAR (tem, Fcons (XCAR (tem), Qdisabled));
8358 /* If we got more than one event, put all but the first
8359 onto this list to be read later.
8360 Return just the first event now. */
8361 Vunread_command_events
8362 = nconc2 (XCDR (value), Vunread_command_events);
8363 value = XCAR (value);
8365 else if (NILP (value))
8366 value = Qt;
8367 if (used_mouse_menu)
8368 *used_mouse_menu = true;
8369 return value;
8371 return Qnil ;
8374 static Lisp_Object
8375 read_char_minibuf_menu_prompt (int commandflag,
8376 Lisp_Object map)
8378 Lisp_Object name;
8379 ptrdiff_t nlength;
8380 /* FIXME: Use the minibuffer's frame width. */
8381 ptrdiff_t width = FRAME_COLS (SELECTED_FRAME ()) - 4;
8382 ptrdiff_t idx = -1;
8383 bool nobindings = true;
8384 Lisp_Object rest, vector;
8385 Lisp_Object prompt_strings = Qnil;
8387 vector = Qnil;
8389 if (! menu_prompting)
8390 return Qnil;
8392 map = get_keymap (map, 0, 1);
8393 name = Fkeymap_prompt (map);
8395 /* If we don't have any menus, just read a character normally. */
8396 if (!STRINGP (name))
8397 return Qnil;
8399 #define PUSH_C_STR(str, listvar) \
8400 listvar = Fcons (build_unibyte_string (str), listvar)
8402 /* Prompt string always starts with map's prompt, and a space. */
8403 prompt_strings = Fcons (name, prompt_strings);
8404 PUSH_C_STR (": ", prompt_strings);
8405 nlength = SCHARS (name) + 2;
8407 rest = map;
8409 /* Present the documented bindings, a line at a time. */
8410 while (1)
8412 bool notfirst = false;
8413 Lisp_Object menu_strings = prompt_strings;
8414 ptrdiff_t i = nlength;
8415 Lisp_Object obj;
8416 Lisp_Object orig_defn_macro;
8418 /* Loop over elements of map. */
8419 while (i < width)
8421 Lisp_Object elt;
8423 /* FIXME: Use map_keymap to handle new keymap formats. */
8425 /* At end of map, wrap around if just starting,
8426 or end this line if already have something on it. */
8427 if (NILP (rest))
8429 if (notfirst || nobindings)
8430 break;
8431 else
8432 rest = map;
8435 /* Look at the next element of the map. */
8436 if (idx >= 0)
8437 elt = AREF (vector, idx);
8438 else
8439 elt = Fcar_safe (rest);
8441 if (idx < 0 && VECTORP (elt))
8443 /* If we found a dense table in the keymap,
8444 advanced past it, but start scanning its contents. */
8445 rest = Fcdr_safe (rest);
8446 vector = elt;
8447 idx = 0;
8449 else
8451 /* An ordinary element. */
8452 Lisp_Object event, tem;
8454 if (idx < 0)
8456 event = Fcar_safe (elt); /* alist */
8457 elt = Fcdr_safe (elt);
8459 else
8461 XSETINT (event, idx); /* vector */
8464 /* Ignore the element if it has no prompt string. */
8465 if (INTEGERP (event) && parse_menu_item (elt, -1))
8467 /* True if the char to type matches the string. */
8468 bool char_matches;
8469 Lisp_Object upcased_event, downcased_event;
8470 Lisp_Object desc = Qnil;
8471 Lisp_Object s
8472 = AREF (item_properties, ITEM_PROPERTY_NAME);
8474 upcased_event = Fupcase (event);
8475 downcased_event = Fdowncase (event);
8476 char_matches = (XINT (upcased_event) == SREF (s, 0)
8477 || XINT (downcased_event) == SREF (s, 0));
8478 if (! char_matches)
8479 desc = Fsingle_key_description (event, Qnil);
8481 #if 0 /* It is redundant to list the equivalent key bindings because
8482 the prefix is what the user has already typed. */
8484 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
8485 if (!NILP (tem))
8486 /* Insert equivalent keybinding. */
8487 s = concat2 (s, tem);
8488 #endif
8490 = AREF (item_properties, ITEM_PROPERTY_TYPE);
8491 if (EQ (tem, QCradio) || EQ (tem, QCtoggle))
8493 /* Insert button prefix. */
8494 Lisp_Object selected
8495 = AREF (item_properties, ITEM_PROPERTY_SELECTED);
8496 AUTO_STRING (radio_yes, "(*) ");
8497 AUTO_STRING (radio_no , "( ) ");
8498 AUTO_STRING (check_yes, "[X] ");
8499 AUTO_STRING (check_no , "[ ] ");
8500 if (EQ (tem, QCradio))
8501 tem = NILP (selected) ? radio_yes : radio_no;
8502 else
8503 tem = NILP (selected) ? check_yes : check_no;
8504 s = concat2 (tem, s);
8508 /* If we have room for the prompt string, add it to this line.
8509 If this is the first on the line, always add it. */
8510 if ((SCHARS (s) + i + 2
8511 + (char_matches ? 0 : SCHARS (desc) + 3))
8512 < width
8513 || !notfirst)
8515 ptrdiff_t thiswidth;
8517 /* Punctuate between strings. */
8518 if (notfirst)
8520 PUSH_C_STR (", ", menu_strings);
8521 i += 2;
8523 notfirst = true;
8524 nobindings = false;
8526 /* If the char to type doesn't match the string's
8527 first char, explicitly show what char to type. */
8528 if (! char_matches)
8530 /* Add as much of string as fits. */
8531 thiswidth = min (SCHARS (desc), width - i);
8532 menu_strings
8533 = Fcons (Fsubstring (desc, make_number (0),
8534 make_number (thiswidth)),
8535 menu_strings);
8536 i += thiswidth;
8537 PUSH_C_STR (" = ", menu_strings);
8538 i += 3;
8541 /* Add as much of string as fits. */
8542 thiswidth = min (SCHARS (s), width - i);
8543 menu_strings
8544 = Fcons (Fsubstring (s, make_number (0),
8545 make_number (thiswidth)),
8546 menu_strings);
8547 i += thiswidth;
8549 else
8551 /* If this element does not fit, end the line now,
8552 and save the element for the next line. */
8553 PUSH_C_STR ("...", menu_strings);
8554 break;
8558 /* Move past this element. */
8559 if (idx >= 0 && idx + 1 >= ASIZE (vector))
8560 /* Handle reaching end of dense table. */
8561 idx = -1;
8562 if (idx >= 0)
8563 idx++;
8564 else
8565 rest = Fcdr_safe (rest);
8569 /* Prompt with that and read response. */
8570 message3_nolog (apply1 (intern ("concat"), Fnreverse (menu_strings)));
8572 /* Make believe it's not a keyboard macro in case the help char
8573 is pressed. Help characters are not recorded because menu prompting
8574 is not used on replay. */
8575 orig_defn_macro = KVAR (current_kboard, defining_kbd_macro);
8576 kset_defining_kbd_macro (current_kboard, Qnil);
8578 obj = read_char (commandflag, Qnil, Qt, 0, NULL);
8579 while (BUFFERP (obj));
8580 kset_defining_kbd_macro (current_kboard, orig_defn_macro);
8582 if (!INTEGERP (obj) || XINT (obj) == -2
8583 || (! EQ (obj, menu_prompt_more_char)
8584 && (!INTEGERP (menu_prompt_more_char)
8585 || ! EQ (obj, make_number (Ctl (XINT (menu_prompt_more_char)))))))
8587 if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
8588 store_kbd_macro_char (obj);
8589 return obj;
8591 /* Help char - go round again. */
8595 /* Reading key sequences. */
8597 static Lisp_Object
8598 follow_key (Lisp_Object keymap, Lisp_Object key)
8600 return access_keymap (get_keymap (keymap, 0, 1),
8601 key, 1, 0, 1);
8604 static Lisp_Object
8605 active_maps (Lisp_Object first_event)
8607 Lisp_Object position
8608 = CONSP (first_event) ? CAR_SAFE (XCDR (first_event)) : Qnil;
8609 return Fcons (Qkeymap, Fcurrent_active_maps (Qt, position));
8612 /* Structure used to keep track of partial application of key remapping
8613 such as Vfunction_key_map and Vkey_translation_map. */
8614 typedef struct keyremap
8616 /* This is the map originally specified for this use. */
8617 Lisp_Object parent;
8618 /* This is a submap reached by looking up, in PARENT,
8619 the events from START to END. */
8620 Lisp_Object map;
8621 /* Positions [START, END) in the key sequence buffer
8622 are the key that we have scanned so far.
8623 Those events are the ones that we will replace
8624 if PARENT maps them into a key sequence. */
8625 int start, end;
8626 } keyremap;
8628 /* Lookup KEY in MAP.
8629 MAP is a keymap mapping keys to key vectors or functions.
8630 If the mapping is a function and DO_FUNCALL is true,
8631 the function is called with PROMPT as parameter and its return
8632 value is used as the return value of this function (after checking
8633 that it is indeed a vector). */
8635 static Lisp_Object
8636 access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
8637 bool do_funcall)
8639 Lisp_Object next;
8641 next = access_keymap (map, key, 1, 0, 1);
8643 /* Handle a symbol whose function definition is a keymap
8644 or an array. */
8645 if (SYMBOLP (next) && !NILP (Ffboundp (next))
8646 && (ARRAYP (XSYMBOL (next)->function)
8647 || KEYMAPP (XSYMBOL (next)->function)))
8648 next = Fautoload_do_load (XSYMBOL (next)->function, next, Qnil);
8650 /* If the keymap gives a function, not an
8651 array, then call the function with one arg and use
8652 its value instead. */
8653 if (do_funcall && FUNCTIONP (next))
8655 Lisp_Object tem;
8656 tem = next;
8658 next = call1 (next, prompt);
8659 /* If the function returned something invalid,
8660 barf--don't ignore it. */
8661 if (! (NILP (next) || VECTORP (next) || STRINGP (next)))
8662 error ("Function %s returns invalid key sequence",
8663 SSDATA (SYMBOL_NAME (tem)));
8665 return next;
8668 /* Do one step of the key remapping used for function-key-map and
8669 key-translation-map:
8670 KEYBUF is the buffer holding the input events.
8671 BUFSIZE is its maximum size.
8672 FKEY is a pointer to the keyremap structure to use.
8673 INPUT is the index of the last element in KEYBUF.
8674 DOIT if true says that the remapping can actually take place.
8675 DIFF is used to return the number of keys added/removed by the remapping.
8676 PARENT is the root of the keymap.
8677 PROMPT is the prompt to use if the remapping happens through a function.
8678 Return true if the remapping actually took place. */
8680 static bool
8681 keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
8682 int input, bool doit, int *diff, Lisp_Object prompt)
8684 Lisp_Object next, key;
8686 key = keybuf[fkey->end++];
8688 if (KEYMAPP (fkey->parent))
8689 next = access_keymap_keyremap (fkey->map, key, prompt, doit);
8690 else
8691 next = Qnil;
8693 /* If keybuf[fkey->start..fkey->end] is bound in the
8694 map and we're in a position to do the key remapping, replace it with
8695 the binding and restart with fkey->start at the end. */
8696 if ((VECTORP (next) || STRINGP (next)) && doit)
8698 int len = XFASTINT (Flength (next));
8699 int i;
8701 *diff = len - (fkey->end - fkey->start);
8703 if (bufsize - input <= *diff)
8704 error ("Key sequence too long");
8706 /* Shift the keys that follow fkey->end. */
8707 if (*diff < 0)
8708 for (i = fkey->end; i < input; i++)
8709 keybuf[i + *diff] = keybuf[i];
8710 else if (*diff > 0)
8711 for (i = input - 1; i >= fkey->end; i--)
8712 keybuf[i + *diff] = keybuf[i];
8713 /* Overwrite the old keys with the new ones. */
8714 for (i = 0; i < len; i++)
8715 keybuf[fkey->start + i]
8716 = Faref (next, make_number (i));
8718 fkey->start = fkey->end += *diff;
8719 fkey->map = fkey->parent;
8721 return 1;
8724 fkey->map = get_keymap (next, 0, 1);
8726 /* If we no longer have a bound suffix, try a new position for
8727 fkey->start. */
8728 if (!CONSP (fkey->map))
8730 fkey->end = ++fkey->start;
8731 fkey->map = fkey->parent;
8733 return 0;
8736 static bool
8737 test_undefined (Lisp_Object binding)
8739 return (NILP (binding)
8740 || EQ (binding, Qundefined)
8741 || (SYMBOLP (binding)
8742 && EQ (Fcommand_remapping (binding, Qnil, Qnil), Qundefined)));
8745 /* Read a sequence of keys that ends with a non prefix character,
8746 storing it in KEYBUF, a buffer of size BUFSIZE.
8747 Prompt with PROMPT.
8748 Return the length of the key sequence stored.
8749 Return -1 if the user rejected a command menu.
8751 Echo starting immediately unless `prompt' is 0.
8753 If PREVENT_REDISPLAY is non-zero, avoid redisplay by calling
8754 read_char with a suitable COMMANDFLAG argument.
8756 Where a key sequence ends depends on the currently active keymaps.
8757 These include any minor mode keymaps active in the current buffer,
8758 the current buffer's local map, and the global map.
8760 If a key sequence has no other bindings, we check Vfunction_key_map
8761 to see if some trailing subsequence might be the beginning of a
8762 function key's sequence. If so, we try to read the whole function
8763 key, and substitute its symbolic name into the key sequence.
8765 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
8766 `double-' events into similar click events, if that would make them
8767 bound. We try to turn `triple-' events first into `double-' events,
8768 then into clicks.
8770 If we get a mouse click in a mode line, vertical divider, or other
8771 non-text area, we treat the click as if it were prefixed by the
8772 symbol denoting that area - `mode-line', `vertical-line', or
8773 whatever.
8775 If the sequence starts with a mouse click, we read the key sequence
8776 with respect to the buffer clicked on, not the current buffer.
8778 If the user switches frames in the midst of a key sequence, we put
8779 off the switch-frame event until later; the next call to
8780 read_char will return it.
8782 If FIX_CURRENT_BUFFER, we restore current_buffer
8783 from the selected window's buffer. */
8785 static int
8786 read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
8787 bool dont_downcase_last, bool can_return_switch_frame,
8788 bool fix_current_buffer, bool prevent_redisplay)
8790 ptrdiff_t count = SPECPDL_INDEX ();
8792 /* How many keys there are in the current key sequence. */
8793 int t;
8795 /* The length of the echo buffer when we started reading, and
8796 the length of this_command_keys when we started reading. */
8797 ptrdiff_t echo_start IF_LINT (= 0);
8798 ptrdiff_t keys_start;
8800 Lisp_Object current_binding = Qnil;
8801 Lisp_Object first_event = Qnil;
8803 /* Index of the first key that has no binding.
8804 It is useless to try fkey.start larger than that. */
8805 int first_unbound;
8807 /* If t < mock_input, then KEYBUF[t] should be read as the next
8808 input key.
8810 We use this to recover after recognizing a function key. Once we
8811 realize that a suffix of the current key sequence is actually a
8812 function key's escape sequence, we replace the suffix with the
8813 function key's binding from Vfunction_key_map. Now keybuf
8814 contains a new and different key sequence, so the echo area,
8815 this_command_keys, and the submaps and defs arrays are wrong. In
8816 this situation, we set mock_input to t, set t to 0, and jump to
8817 restart_sequence; the loop will read keys from keybuf up until
8818 mock_input, thus rebuilding the state; and then it will resume
8819 reading characters from the keyboard. */
8820 int mock_input = 0;
8822 /* If the sequence is unbound in submaps[], then
8823 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
8824 and fkey.map is its binding.
8826 These might be > t, indicating that all function key scanning
8827 should hold off until t reaches them. We do this when we've just
8828 recognized a function key, to avoid searching for the function
8829 key's again in Vfunction_key_map. */
8830 keyremap fkey;
8832 /* Likewise, for key_translation_map and input-decode-map. */
8833 keyremap keytran, indec;
8835 /* True if we are trying to map a key by changing an upper-case
8836 letter to lower case, or a shifted function key to an unshifted
8837 one. */
8838 bool shift_translated = false;
8840 /* If we receive a `switch-frame' or `select-window' event in the middle of
8841 a key sequence, we put it off for later.
8842 While we're reading, we keep the event here. */
8843 Lisp_Object delayed_switch_frame;
8845 Lisp_Object original_uppercase IF_LINT (= Qnil);
8846 int original_uppercase_position = -1;
8848 /* Gets around Microsoft compiler limitations. */
8849 bool dummyflag = false;
8851 struct buffer *starting_buffer;
8853 /* List of events for which a fake prefix key has been generated. */
8854 Lisp_Object fake_prefixed_keys = Qnil;
8856 raw_keybuf_count = 0;
8858 last_nonmenu_event = Qnil;
8860 delayed_switch_frame = Qnil;
8862 if (INTERACTIVE)
8864 if (!NILP (prompt))
8866 /* Install the string PROMPT as the beginning of the string
8867 of echoing, so that it serves as a prompt for the next
8868 character. */
8869 kset_echo_prompt (current_kboard, prompt);
8870 current_kboard->immediate_echo = false;
8871 echo_now ();
8873 else if (cursor_in_echo_area
8874 && echo_keystrokes_p ())
8875 /* This doesn't put in a dash if the echo buffer is empty, so
8876 you don't always see a dash hanging out in the minibuffer. */
8877 echo_dash ();
8880 /* Record the initial state of the echo area and this_command_keys;
8881 we will need to restore them if we replay a key sequence. */
8882 if (INTERACTIVE)
8883 echo_start = echo_length ();
8884 keys_start = this_command_key_count;
8885 this_single_command_key_start = keys_start;
8887 /* We jump here when we need to reinitialize fkey and keytran; this
8888 happens if we switch keyboards between rescans. */
8889 replay_entire_sequence:
8891 indec.map = indec.parent = KVAR (current_kboard, Vinput_decode_map);
8892 fkey.map = fkey.parent = KVAR (current_kboard, Vlocal_function_key_map);
8893 keytran.map = keytran.parent = Vkey_translation_map;
8894 indec.start = indec.end = 0;
8895 fkey.start = fkey.end = 0;
8896 keytran.start = keytran.end = 0;
8898 /* We jump here when the key sequence has been thoroughly changed, and
8899 we need to rescan it starting from the beginning. When we jump here,
8900 keybuf[0..mock_input] holds the sequence we should reread. */
8901 replay_sequence:
8903 starting_buffer = current_buffer;
8904 first_unbound = bufsize + 1;
8906 /* Build our list of keymaps.
8907 If we recognize a function key and replace its escape sequence in
8908 keybuf with its symbol, or if the sequence starts with a mouse
8909 click and we need to switch buffers, we jump back here to rebuild
8910 the initial keymaps from the current buffer. */
8911 current_binding = active_maps (first_event);
8913 /* Start from the beginning in keybuf. */
8914 t = 0;
8916 /* These are no-ops the first time through, but if we restart, they
8917 revert the echo area and this_command_keys to their original state. */
8918 this_command_key_count = keys_start;
8919 if (INTERACTIVE && t < mock_input)
8920 echo_truncate (echo_start);
8922 /* If the best binding for the current key sequence is a keymap, or
8923 we may be looking at a function key's escape sequence, keep on
8924 reading. */
8925 while (!NILP (current_binding)
8926 /* Keep reading as long as there's a prefix binding. */
8927 ? KEYMAPP (current_binding)
8928 /* Don't return in the middle of a possible function key sequence,
8929 if the only bindings we found were via case conversion.
8930 Thus, if ESC O a has a function-key-map translation
8931 and ESC o has a binding, don't return after ESC O,
8932 so that we can translate ESC O plus the next character. */
8933 : (/* indec.start < t || fkey.start < t || */ keytran.start < t))
8935 Lisp_Object key;
8936 bool used_mouse_menu = false;
8938 /* Where the last real key started. If we need to throw away a
8939 key that has expanded into more than one element of keybuf
8940 (say, a mouse click on the mode line which is being treated
8941 as [mode-line (mouse-...)], then we backtrack to this point
8942 of keybuf. */
8943 int last_real_key_start;
8945 /* These variables are analogous to echo_start and keys_start;
8946 while those allow us to restart the entire key sequence,
8947 echo_local_start and keys_local_start allow us to throw away
8948 just one key. */
8949 ptrdiff_t echo_local_start IF_LINT (= 0);
8950 int keys_local_start;
8951 Lisp_Object new_binding;
8953 eassert (indec.end == t || (indec.end > t && indec.end <= mock_input));
8954 eassert (indec.start <= indec.end);
8955 eassert (fkey.start <= fkey.end);
8956 eassert (keytran.start <= keytran.end);
8957 /* key-translation-map is applied *after* function-key-map
8958 which is itself applied *after* input-decode-map. */
8959 eassert (fkey.end <= indec.start);
8960 eassert (keytran.end <= fkey.start);
8962 if (/* first_unbound < indec.start && first_unbound < fkey.start && */
8963 first_unbound < keytran.start)
8964 { /* The prefix upto first_unbound has no binding and has
8965 no translation left to do either, so we know it's unbound.
8966 If we don't stop now, we risk staying here indefinitely
8967 (if the user keeps entering fkey or keytran prefixes
8968 like C-c ESC ESC ESC ESC ...) */
8969 int i;
8970 for (i = first_unbound + 1; i < t; i++)
8971 keybuf[i - first_unbound - 1] = keybuf[i];
8972 mock_input = t - first_unbound - 1;
8973 indec.end = indec.start -= first_unbound + 1;
8974 indec.map = indec.parent;
8975 fkey.end = fkey.start -= first_unbound + 1;
8976 fkey.map = fkey.parent;
8977 keytran.end = keytran.start -= first_unbound + 1;
8978 keytran.map = keytran.parent;
8979 goto replay_sequence;
8982 if (t >= bufsize)
8983 error ("Key sequence too long");
8985 if (INTERACTIVE)
8986 echo_local_start = echo_length ();
8987 keys_local_start = this_command_key_count;
8989 replay_key:
8990 /* These are no-ops, unless we throw away a keystroke below and
8991 jumped back up to replay_key; in that case, these restore the
8992 variables to their original state, allowing us to replay the
8993 loop. */
8994 if (INTERACTIVE && t < mock_input)
8995 echo_truncate (echo_local_start);
8996 this_command_key_count = keys_local_start;
8998 /* By default, assume each event is "real". */
8999 last_real_key_start = t;
9001 /* Does mock_input indicate that we are re-reading a key sequence? */
9002 if (t < mock_input)
9004 key = keybuf[t];
9005 add_command_key (key);
9006 if (current_kboard->immediate_echo)
9008 /* Set immediate_echo to false so as to force echo_now to
9009 redisplay (it will set immediate_echo right back to true). */
9010 current_kboard->immediate_echo = false;
9011 echo_now ();
9015 /* If not, we should actually read a character. */
9016 else
9019 KBOARD *interrupted_kboard = current_kboard;
9020 struct frame *interrupted_frame = SELECTED_FRAME ();
9021 /* Calling read_char with COMMANDFLAG = -2 avoids
9022 redisplay in read_char and its subroutines. */
9023 key = read_char (prevent_redisplay ? -2 : NILP (prompt),
9024 current_binding, last_nonmenu_event,
9025 &used_mouse_menu, NULL);
9026 if ((INTEGERP (key) && XINT (key) == -2) /* wrong_kboard_jmpbuf */
9027 /* When switching to a new tty (with a new keyboard),
9028 read_char returns the new buffer, rather than -2
9029 (Bug#5095). This is because `terminal-init-xterm'
9030 calls read-char, which eats the wrong_kboard_jmpbuf
9031 return. Any better way to fix this? -- cyd */
9032 || (interrupted_kboard != current_kboard))
9034 bool found = false;
9035 struct kboard *k;
9037 for (k = all_kboards; k; k = k->next_kboard)
9038 if (k == interrupted_kboard)
9039 found = true;
9041 if (!found)
9043 /* Don't touch interrupted_kboard when it's been
9044 deleted. */
9045 delayed_switch_frame = Qnil;
9046 goto replay_entire_sequence;
9049 if (!NILP (delayed_switch_frame))
9051 kset_kbd_queue
9052 (interrupted_kboard,
9053 Fcons (delayed_switch_frame,
9054 KVAR (interrupted_kboard, kbd_queue)));
9055 delayed_switch_frame = Qnil;
9058 while (t > 0)
9059 kset_kbd_queue
9060 (interrupted_kboard,
9061 Fcons (keybuf[--t], KVAR (interrupted_kboard, kbd_queue)));
9063 /* If the side queue is non-empty, ensure it begins with a
9064 switch-frame, so we'll replay it in the right context. */
9065 if (CONSP (KVAR (interrupted_kboard, kbd_queue))
9066 && (key = XCAR (KVAR (interrupted_kboard, kbd_queue)),
9067 !(EVENT_HAS_PARAMETERS (key)
9068 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)),
9069 Qswitch_frame))))
9071 Lisp_Object frame;
9072 XSETFRAME (frame, interrupted_frame);
9073 kset_kbd_queue
9074 (interrupted_kboard,
9075 Fcons (make_lispy_switch_frame (frame),
9076 KVAR (interrupted_kboard, kbd_queue)));
9078 mock_input = 0;
9079 goto replay_entire_sequence;
9083 /* read_char returns t when it shows a menu and the user rejects it.
9084 Just return -1. */
9085 if (EQ (key, Qt))
9087 unbind_to (count, Qnil);
9088 return -1;
9091 /* read_char returns -1 at the end of a macro.
9092 Emacs 18 handles this by returning immediately with a
9093 zero, so that's what we'll do. */
9094 if (INTEGERP (key) && XINT (key) == -1)
9096 t = 0;
9097 /* The Microsoft C compiler can't handle the goto that
9098 would go here. */
9099 dummyflag = true;
9100 break;
9103 /* If the current buffer has been changed from under us, the
9104 keymap may have changed, so replay the sequence. */
9105 if (BUFFERP (key))
9107 timer_resume_idle ();
9109 mock_input = t;
9110 /* Reset the current buffer from the selected window
9111 in case something changed the former and not the latter.
9112 This is to be more consistent with the behavior
9113 of the command_loop_1. */
9114 if (fix_current_buffer)
9116 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
9117 Fkill_emacs (Qnil);
9118 if (XBUFFER (XWINDOW (selected_window)->contents)
9119 != current_buffer)
9120 Fset_buffer (XWINDOW (selected_window)->contents);
9123 goto replay_sequence;
9126 /* If we have a quit that was typed in another frame, and
9127 quit_throw_to_read_char switched buffers,
9128 replay to get the right keymap. */
9129 if (INTEGERP (key)
9130 && XINT (key) == quit_char
9131 && current_buffer != starting_buffer)
9133 GROW_RAW_KEYBUF;
9134 ASET (raw_keybuf, raw_keybuf_count, key);
9135 raw_keybuf_count++;
9136 keybuf[t++] = key;
9137 mock_input = t;
9138 Vquit_flag = Qnil;
9139 goto replay_sequence;
9142 Vquit_flag = Qnil;
9144 if (EVENT_HAS_PARAMETERS (key)
9145 /* Either a `switch-frame' or a `select-window' event. */
9146 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)), Qswitch_frame))
9148 /* If we're at the beginning of a key sequence, and the caller
9149 says it's okay, go ahead and return this event. If we're
9150 in the midst of a key sequence, delay it until the end. */
9151 if (t > 0 || !can_return_switch_frame)
9153 delayed_switch_frame = key;
9154 goto replay_key;
9158 if (NILP (first_event))
9160 first_event = key;
9161 /* Even if first_event does not specify a particular
9162 window/position, it's important to recompute the maps here
9163 since a long time might have passed since we entered
9164 read_key_sequence, and a timer (or process-filter or
9165 special-event-map, ...) might have switched the current buffer
9166 or the selected window from under us in the mean time. */
9167 if (fix_current_buffer
9168 && (XBUFFER (XWINDOW (selected_window)->contents)
9169 != current_buffer))
9170 Fset_buffer (XWINDOW (selected_window)->contents);
9171 current_binding = active_maps (first_event);
9174 GROW_RAW_KEYBUF;
9175 ASET (raw_keybuf, raw_keybuf_count, key);
9176 raw_keybuf_count++;
9179 /* Clicks in non-text areas get prefixed by the symbol
9180 in their CHAR-ADDRESS field. For example, a click on
9181 the mode line is prefixed by the symbol `mode-line'.
9183 Furthermore, key sequences beginning with mouse clicks
9184 are read using the keymaps of the buffer clicked on, not
9185 the current buffer. So we may have to switch the buffer
9186 here.
9188 When we turn one event into two events, we must make sure
9189 that neither of the two looks like the original--so that,
9190 if we replay the events, they won't be expanded again.
9191 If not for this, such reexpansion could happen either here
9192 or when user programs play with this-command-keys. */
9193 if (EVENT_HAS_PARAMETERS (key))
9195 Lisp_Object kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
9196 if (EQ (kind, Qmouse_click))
9198 Lisp_Object window = POSN_WINDOW (EVENT_START (key));
9199 Lisp_Object posn = POSN_POSN (EVENT_START (key));
9201 if (CONSP (posn)
9202 || (!NILP (fake_prefixed_keys)
9203 && !NILP (Fmemq (key, fake_prefixed_keys))))
9205 /* We're looking a second time at an event for which
9206 we generated a fake prefix key. Set
9207 last_real_key_start appropriately. */
9208 if (t > 0)
9209 last_real_key_start = t - 1;
9212 if (last_real_key_start == 0)
9214 /* Key sequences beginning with mouse clicks are
9215 read using the keymaps in the buffer clicked on,
9216 not the current buffer. If we're at the
9217 beginning of a key sequence, switch buffers. */
9218 if (WINDOWP (window)
9219 && BUFFERP (XWINDOW (window)->contents)
9220 && XBUFFER (XWINDOW (window)->contents) != current_buffer)
9222 ASET (raw_keybuf, raw_keybuf_count, key);
9223 raw_keybuf_count++;
9224 keybuf[t] = key;
9225 mock_input = t + 1;
9227 /* Arrange to go back to the original buffer once we're
9228 done reading the key sequence. Note that we can't
9229 use save_excursion_{save,restore} here, because they
9230 save point as well as the current buffer; we don't
9231 want to save point, because redisplay may change it,
9232 to accommodate a Fset_window_start or something. We
9233 don't want to do this at the top of the function,
9234 because we may get input from a subprocess which
9235 wants to change the selected window and stuff (say,
9236 emacsclient). */
9237 record_unwind_current_buffer ();
9239 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
9240 Fkill_emacs (Qnil);
9241 set_buffer_internal (XBUFFER (XWINDOW (window)->contents));
9242 goto replay_sequence;
9246 /* Expand mode-line and scroll-bar events into two events:
9247 use posn as a fake prefix key. */
9248 if (SYMBOLP (posn)
9249 && (NILP (fake_prefixed_keys)
9250 || NILP (Fmemq (key, fake_prefixed_keys))))
9252 if (bufsize - t <= 1)
9253 error ("Key sequence too long");
9255 keybuf[t] = posn;
9256 keybuf[t + 1] = key;
9257 mock_input = t + 2;
9259 /* Record that a fake prefix key has been generated
9260 for KEY. Don't modify the event; this would
9261 prevent proper action when the event is pushed
9262 back into unread-command-events. */
9263 fake_prefixed_keys = Fcons (key, fake_prefixed_keys);
9264 goto replay_key;
9267 else if (CONSP (XCDR (key))
9268 && CONSP (EVENT_START (key))
9269 && CONSP (XCDR (EVENT_START (key))))
9271 Lisp_Object posn;
9273 posn = POSN_POSN (EVENT_START (key));
9274 /* Handle menu-bar events:
9275 insert the dummy prefix event `menu-bar'. */
9276 if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
9278 if (bufsize - t <= 1)
9279 error ("Key sequence too long");
9280 keybuf[t] = posn;
9281 keybuf[t + 1] = key;
9283 /* Zap the position in key, so we know that we've
9284 expanded it, and don't try to do so again. */
9285 POSN_SET_POSN (EVENT_START (key), list1 (posn));
9287 mock_input = t + 2;
9288 goto replay_sequence;
9290 else if (CONSP (posn))
9292 /* We're looking at the second event of a
9293 sequence which we expanded before. Set
9294 last_real_key_start appropriately. */
9295 if (last_real_key_start == t && t > 0)
9296 last_real_key_start = t - 1;
9301 /* We have finally decided that KEY is something we might want
9302 to look up. */
9303 new_binding = follow_key (current_binding, key);
9305 /* If KEY wasn't bound, we'll try some fallbacks. */
9306 if (!NILP (new_binding))
9307 /* This is needed for the following scenario:
9308 event 0: a down-event that gets dropped by calling replay_key.
9309 event 1: some normal prefix like C-h.
9310 After event 0, first_unbound is 0, after event 1 indec.start,
9311 fkey.start, and keytran.start are all 1, so when we see that
9312 C-h is bound, we need to update first_unbound. */
9313 first_unbound = max (t + 1, first_unbound);
9314 else
9316 Lisp_Object head;
9318 /* Remember the position to put an upper bound on indec.start. */
9319 first_unbound = min (t, first_unbound);
9321 head = EVENT_HEAD (key);
9323 if (SYMBOLP (head))
9325 Lisp_Object breakdown;
9326 int modifiers;
9328 breakdown = parse_modifiers (head);
9329 modifiers = XINT (XCAR (XCDR (breakdown)));
9330 /* Attempt to reduce an unbound mouse event to a simpler
9331 event that is bound:
9332 Drags reduce to clicks.
9333 Double-clicks reduce to clicks.
9334 Triple-clicks reduce to double-clicks, then to clicks.
9335 Up/Down-clicks are eliminated.
9336 Double-downs reduce to downs, then are eliminated.
9337 Triple-downs reduce to double-downs, then to downs,
9338 then are eliminated. */
9339 if (modifiers & (up_modifier | down_modifier
9340 | drag_modifier
9341 | double_modifier | triple_modifier))
9343 while (modifiers & (up_modifier | down_modifier
9344 | drag_modifier
9345 | double_modifier | triple_modifier))
9347 Lisp_Object new_head, new_click;
9348 if (modifiers & triple_modifier)
9349 modifiers ^= (double_modifier | triple_modifier);
9350 else if (modifiers & double_modifier)
9351 modifiers &= ~double_modifier;
9352 else if (modifiers & drag_modifier)
9353 modifiers &= ~drag_modifier;
9354 else
9356 /* Dispose of this `up/down' event by simply jumping
9357 back to replay_key, to get another event.
9359 Note that if this event came from mock input,
9360 then just jumping back to replay_key will just
9361 hand it to us again. So we have to wipe out any
9362 mock input.
9364 We could delete keybuf[t] and shift everything
9365 after that to the left by one spot, but we'd also
9366 have to fix up any variable that points into
9367 keybuf, and shifting isn't really necessary
9368 anyway.
9370 Adding prefixes for non-textual mouse clicks
9371 creates two characters of mock input, and both
9372 must be thrown away. If we're only looking at
9373 the prefix now, we can just jump back to
9374 replay_key. On the other hand, if we've already
9375 processed the prefix, and now the actual click
9376 itself is giving us trouble, then we've lost the
9377 state of the keymaps we want to backtrack to, and
9378 we need to replay the whole sequence to rebuild
9381 Beyond that, only function key expansion could
9382 create more than two keys, but that should never
9383 generate mouse events, so it's okay to zero
9384 mock_input in that case too.
9386 FIXME: The above paragraph seems just plain
9387 wrong, if you consider things like
9388 xterm-mouse-mode. -stef
9390 Isn't this just the most wonderful code ever? */
9392 /* If mock_input > t + 1, the above simplification
9393 will actually end up dropping keys on the floor.
9394 This is probably OK for now, but even
9395 if mock_input <= t + 1, we need to adjust indec,
9396 fkey, and keytran.
9397 Typical case [header-line down-mouse-N]:
9398 mock_input = 2, t = 1, fkey.end = 1,
9399 last_real_key_start = 0. */
9400 if (indec.end > last_real_key_start)
9402 indec.end = indec.start
9403 = min (last_real_key_start, indec.start);
9404 indec.map = indec.parent;
9405 if (fkey.end > last_real_key_start)
9407 fkey.end = fkey.start
9408 = min (last_real_key_start, fkey.start);
9409 fkey.map = fkey.parent;
9410 if (keytran.end > last_real_key_start)
9412 keytran.end = keytran.start
9413 = min (last_real_key_start, keytran.start);
9414 keytran.map = keytran.parent;
9418 if (t == last_real_key_start)
9420 mock_input = 0;
9421 goto replay_key;
9423 else
9425 mock_input = last_real_key_start;
9426 goto replay_sequence;
9430 new_head
9431 = apply_modifiers (modifiers, XCAR (breakdown));
9432 new_click = list2 (new_head, EVENT_START (key));
9434 /* Look for a binding for this new key. */
9435 new_binding = follow_key (current_binding, new_click);
9437 /* If that click is bound, go for it. */
9438 if (!NILP (new_binding))
9440 current_binding = new_binding;
9441 key = new_click;
9442 break;
9444 /* Otherwise, we'll leave key set to the drag event. */
9449 current_binding = new_binding;
9451 keybuf[t++] = key;
9452 /* Normally, last_nonmenu_event gets the previous key we read.
9453 But when a mouse popup menu is being used,
9454 we don't update last_nonmenu_event; it continues to hold the mouse
9455 event that preceded the first level of menu. */
9456 if (!used_mouse_menu)
9457 last_nonmenu_event = key;
9459 /* Record what part of this_command_keys is the current key sequence. */
9460 this_single_command_key_start = this_command_key_count - t;
9461 /* When 'input-method-function' called above causes events to be
9462 put on 'unread-post-input-method-events', and as result
9463 'reread' is set to 'true', the value of 't' can become larger
9464 than 'this_command_key_count', because 'add_command_key' is
9465 not called to update 'this_command_key_count'. If this
9466 happens, 'this_single_command_key_start' will become negative
9467 above, and any call to 'this-single-command-keys' will return
9468 a garbled vector. See bug #20223 for one such situation.
9469 Here we force 'this_single_command_key_start' to never become
9470 negative, to avoid that. */
9471 if (this_single_command_key_start < 0)
9472 this_single_command_key_start = 0;
9474 /* Look for this sequence in input-decode-map.
9475 Scan from indec.end until we find a bound suffix. */
9476 while (indec.end < t)
9478 bool done;
9479 int diff;
9481 done = keyremap_step (keybuf, bufsize, &indec, max (t, mock_input),
9482 1, &diff, prompt);
9483 if (done)
9485 mock_input = diff + max (t, mock_input);
9486 goto replay_sequence;
9490 if (!KEYMAPP (current_binding)
9491 && !test_undefined (current_binding)
9492 && indec.start >= t)
9493 /* There is a binding and it's not a prefix.
9494 (and it doesn't have any input-decode-map translation pending).
9495 There is thus no function-key in this sequence.
9496 Moving fkey.start is important in this case to allow keytran.start
9497 to go over the sequence before we return (since we keep the
9498 invariant that keytran.end <= fkey.start). */
9500 if (fkey.start < t)
9501 (fkey.start = fkey.end = t, fkey.map = fkey.parent);
9503 else
9504 /* If the sequence is unbound, see if we can hang a function key
9505 off the end of it. */
9506 /* Continue scan from fkey.end until we find a bound suffix. */
9507 while (fkey.end < indec.start)
9509 bool done;
9510 int diff;
9512 done = keyremap_step (keybuf, bufsize, &fkey,
9513 max (t, mock_input),
9514 /* If there's a binding (i.e.
9515 first_binding >= nmaps) we don't want
9516 to apply this function-key-mapping. */
9517 fkey.end + 1 == t
9518 && (test_undefined (current_binding)),
9519 &diff, prompt);
9520 if (done)
9522 mock_input = diff + max (t, mock_input);
9523 /* Adjust the input-decode-map counters. */
9524 indec.end += diff;
9525 indec.start += diff;
9527 goto replay_sequence;
9531 /* Look for this sequence in key-translation-map.
9532 Scan from keytran.end until we find a bound suffix. */
9533 while (keytran.end < fkey.start)
9535 bool done;
9536 int diff;
9538 done = keyremap_step (keybuf, bufsize, &keytran, max (t, mock_input),
9539 1, &diff, prompt);
9540 if (done)
9542 mock_input = diff + max (t, mock_input);
9543 /* Adjust the function-key-map and input-decode-map counters. */
9544 indec.end += diff;
9545 indec.start += diff;
9546 fkey.end += diff;
9547 fkey.start += diff;
9549 goto replay_sequence;
9553 /* If KEY is not defined in any of the keymaps,
9554 and cannot be part of a function key or translation,
9555 and is an upper case letter
9556 use the corresponding lower-case letter instead. */
9557 if (NILP (current_binding)
9558 && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t
9559 && INTEGERP (key)
9560 && ((CHARACTERP (make_number (XINT (key) & ~CHAR_MODIFIER_MASK))
9561 && uppercasep (XINT (key) & ~CHAR_MODIFIER_MASK))
9562 || (XINT (key) & shift_modifier)))
9564 Lisp_Object new_key;
9566 original_uppercase = key;
9567 original_uppercase_position = t - 1;
9569 if (XINT (key) & shift_modifier)
9570 XSETINT (new_key, XINT (key) & ~shift_modifier);
9571 else
9572 XSETINT (new_key, (downcase (XINT (key) & ~CHAR_MODIFIER_MASK)
9573 | (XINT (key) & CHAR_MODIFIER_MASK)));
9575 /* We have to do this unconditionally, regardless of whether
9576 the lower-case char is defined in the keymaps, because they
9577 might get translated through function-key-map. */
9578 keybuf[t - 1] = new_key;
9579 mock_input = max (t, mock_input);
9580 shift_translated = true;
9582 goto replay_sequence;
9585 if (NILP (current_binding)
9586 && help_char_p (EVENT_HEAD (key)) && t > 1)
9588 read_key_sequence_cmd = Vprefix_help_command;
9589 /* The Microsoft C compiler can't handle the goto that
9590 would go here. */
9591 dummyflag = true;
9592 break;
9595 /* If KEY is not defined in any of the keymaps,
9596 and cannot be part of a function key or translation,
9597 and is a shifted function key,
9598 use the corresponding unshifted function key instead. */
9599 if (NILP (current_binding)
9600 && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t)
9602 Lisp_Object breakdown = parse_modifiers (key);
9603 int modifiers
9604 = CONSP (breakdown) ? (XINT (XCAR (XCDR (breakdown)))) : 0;
9606 if (modifiers & shift_modifier
9607 /* Treat uppercase keys as shifted. */
9608 || (INTEGERP (key)
9609 && (KEY_TO_CHAR (key)
9610 < XCHAR_TABLE (BVAR (current_buffer, downcase_table))->header.size)
9611 && uppercasep (KEY_TO_CHAR (key))))
9613 Lisp_Object new_key
9614 = (modifiers & shift_modifier
9615 ? apply_modifiers (modifiers & ~shift_modifier,
9616 XCAR (breakdown))
9617 : make_number (downcase (KEY_TO_CHAR (key)) | modifiers));
9619 original_uppercase = key;
9620 original_uppercase_position = t - 1;
9622 /* We have to do this unconditionally, regardless of whether
9623 the lower-case char is defined in the keymaps, because they
9624 might get translated through function-key-map. */
9625 keybuf[t - 1] = new_key;
9626 mock_input = max (t, mock_input);
9627 /* Reset fkey (and consequently keytran) to apply
9628 function-key-map on the result, so that S-backspace is
9629 correctly mapped to DEL (via backspace). OTOH,
9630 input-decode-map doesn't need to go through it again. */
9631 fkey.start = fkey.end = 0;
9632 keytran.start = keytran.end = 0;
9633 shift_translated = true;
9635 goto replay_sequence;
9639 if (!dummyflag)
9640 read_key_sequence_cmd = current_binding;
9641 read_key_sequence_remapped
9642 /* Remap command through active keymaps.
9643 Do the remapping here, before the unbind_to so it uses the keymaps
9644 of the appropriate buffer. */
9645 = SYMBOLP (read_key_sequence_cmd)
9646 ? Fcommand_remapping (read_key_sequence_cmd, Qnil, Qnil)
9647 : Qnil;
9649 unread_switch_frame = delayed_switch_frame;
9650 unbind_to (count, Qnil);
9652 /* Don't downcase the last character if the caller says don't.
9653 Don't downcase it if the result is undefined, either. */
9654 if ((dont_downcase_last || NILP (current_binding))
9655 && t > 0
9656 && t - 1 == original_uppercase_position)
9658 keybuf[t - 1] = original_uppercase;
9659 shift_translated = false;
9662 if (shift_translated)
9663 Vthis_command_keys_shift_translated = Qt;
9665 /* Occasionally we fabricate events, perhaps by expanding something
9666 according to function-key-map, or by adding a prefix symbol to a
9667 mouse click in the scroll bar or modeline. In this cases, return
9668 the entire generated key sequence, even if we hit an unbound
9669 prefix or a definition before the end. This means that you will
9670 be able to push back the event properly, and also means that
9671 read-key-sequence will always return a logical unit.
9673 Better ideas? */
9674 for (; t < mock_input; t++)
9675 add_command_key (keybuf[t]);
9676 echo_update ();
9678 return t;
9681 static Lisp_Object
9682 read_key_sequence_vs (Lisp_Object prompt, Lisp_Object continue_echo,
9683 Lisp_Object dont_downcase_last,
9684 Lisp_Object can_return_switch_frame,
9685 Lisp_Object cmd_loop, bool allow_string)
9687 Lisp_Object keybuf[30];
9688 int i;
9689 ptrdiff_t count = SPECPDL_INDEX ();
9691 if (!NILP (prompt))
9692 CHECK_STRING (prompt);
9693 QUIT;
9695 specbind (Qinput_method_exit_on_first_char,
9696 (NILP (cmd_loop) ? Qt : Qnil));
9697 specbind (Qinput_method_use_echo_area,
9698 (NILP (cmd_loop) ? Qt : Qnil));
9700 if (NILP (continue_echo))
9702 this_command_key_count = 0;
9703 this_single_command_key_start = 0;
9706 #ifdef HAVE_WINDOW_SYSTEM
9707 if (display_hourglass_p)
9708 cancel_hourglass ();
9709 #endif
9711 i = read_key_sequence (keybuf, ARRAYELTS (keybuf),
9712 prompt, ! NILP (dont_downcase_last),
9713 ! NILP (can_return_switch_frame), 0, 0);
9715 #if 0 /* The following is fine for code reading a key sequence and
9716 then proceeding with a lengthy computation, but it's not good
9717 for code reading keys in a loop, like an input method. */
9718 #ifdef HAVE_WINDOW_SYSTEM
9719 if (display_hourglass_p)
9720 start_hourglass ();
9721 #endif
9722 #endif
9724 if (i == -1)
9726 Vquit_flag = Qt;
9727 QUIT;
9730 return unbind_to (count,
9731 ((allow_string ? make_event_array : Fvector)
9732 (i, keybuf)));
9735 DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 5, 0,
9736 doc: /* Read a sequence of keystrokes and return as a string or vector.
9737 The sequence is sufficient to specify a non-prefix command in the
9738 current local and global maps.
9740 First arg PROMPT is a prompt string. If nil, do not prompt specially.
9741 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
9742 as a continuation of the previous key.
9744 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
9745 convert the last event to lower case. (Normally any upper case event
9746 is converted to lower case if the original event is undefined and the lower
9747 case equivalent is defined.) A non-nil value is appropriate for reading
9748 a key sequence to be defined.
9750 A C-g typed while in this function is treated like any other character,
9751 and `quit-flag' is not set.
9753 If the key sequence starts with a mouse click, then the sequence is read
9754 using the keymaps of the buffer of the window clicked in, not the buffer
9755 of the selected window as normal.
9757 `read-key-sequence' drops unbound button-down events, since you normally
9758 only care about the click or drag events which follow them. If a drag
9759 or multi-click event is unbound, but the corresponding click event would
9760 be bound, `read-key-sequence' turns the event into a click event at the
9761 drag's starting position. This means that you don't have to distinguish
9762 between click and drag, double, or triple events unless you want to.
9764 `read-key-sequence' prefixes mouse events on mode lines, the vertical
9765 lines separating windows, and scroll bars with imaginary keys
9766 `mode-line', `vertical-line', and `vertical-scroll-bar'.
9768 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
9769 function will process a switch-frame event if the user switches frames
9770 before typing anything. If the user switches frames in the middle of a
9771 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
9772 is nil, then the event will be put off until after the current key sequence.
9774 `read-key-sequence' checks `function-key-map' for function key
9775 sequences, where they wouldn't conflict with ordinary bindings. See
9776 `function-key-map' for more details.
9778 The optional fifth argument CMD-LOOP, if non-nil, means
9779 that this key sequence is being read by something that will
9780 read commands one after another. It should be nil if the caller
9781 will read just one key sequence. */)
9782 (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object cmd_loop)
9784 return read_key_sequence_vs (prompt, continue_echo, dont_downcase_last,
9785 can_return_switch_frame, cmd_loop, true);
9788 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
9789 Sread_key_sequence_vector, 1, 5, 0,
9790 doc: /* Like `read-key-sequence' but always return a vector. */)
9791 (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object cmd_loop)
9793 return read_key_sequence_vs (prompt, continue_echo, dont_downcase_last,
9794 can_return_switch_frame, cmd_loop, false);
9797 /* Return true if input events are pending. */
9799 bool
9800 detect_input_pending (void)
9802 return input_pending || get_input_pending (0);
9805 /* Return true if input events other than mouse movements are
9806 pending. */
9808 bool
9809 detect_input_pending_ignore_squeezables (void)
9811 return input_pending || get_input_pending (READABLE_EVENTS_IGNORE_SQUEEZABLES);
9814 /* Return true if input events are pending, and run any pending timers. */
9816 bool
9817 detect_input_pending_run_timers (bool do_display)
9819 unsigned old_timers_run = timers_run;
9821 if (!input_pending)
9822 get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
9824 if (old_timers_run != timers_run && do_display)
9825 redisplay_preserve_echo_area (8);
9827 return input_pending;
9830 /* This is called in some cases before a possible quit.
9831 It cases the next call to detect_input_pending to recompute input_pending.
9832 So calling this function unnecessarily can't do any harm. */
9834 void
9835 clear_input_pending (void)
9837 input_pending = false;
9840 /* Return true if there are pending requeued events.
9841 This isn't used yet. The hope is to make wait_reading_process_output
9842 call it, and return if it runs Lisp code that unreads something.
9843 The problem is, kbd_buffer_get_event needs to be fixed to know what
9844 to do in that case. It isn't trivial. */
9846 bool
9847 requeued_events_pending_p (void)
9849 return (!NILP (Vunread_command_events));
9852 DEFUN ("input-pending-p", Finput_pending_p, Sinput_pending_p, 0, 1, 0,
9853 doc: /* Return t if command input is currently available with no wait.
9854 Actually, the value is nil only if we can be sure that no input is available;
9855 if there is a doubt, the value is t.
9857 If CHECK-TIMERS is non-nil, timers that are ready to run will do so. */)
9858 (Lisp_Object check_timers)
9860 if (!NILP (Vunread_command_events)
9861 || !NILP (Vunread_post_input_method_events)
9862 || !NILP (Vunread_input_method_events))
9863 return (Qt);
9865 /* Process non-user-visible events (Bug#10195). */
9866 process_special_events ();
9868 return (get_input_pending ((NILP (check_timers)
9869 ? 0 : READABLE_EVENTS_DO_TIMERS_NOW)
9870 | READABLE_EVENTS_FILTER_EVENTS)
9871 ? Qt : Qnil);
9874 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 1, 0,
9875 doc: /* Return vector of last few events, not counting those from keyboard macros.
9876 If INCLUDE-CMDS is non-nil, include the commands that were run,
9877 represented as events of the form (nil . COMMAND). */)
9878 (Lisp_Object include_cmds)
9880 bool cmds = !NILP (include_cmds);
9882 if (!total_keys
9883 || (cmds && total_keys < NUM_RECENT_KEYS))
9884 return Fvector (total_keys,
9885 XVECTOR (recent_keys)->contents);
9886 else
9888 Lisp_Object es = Qnil;
9889 int i = (total_keys < NUM_RECENT_KEYS
9890 ? 0 : recent_keys_index);
9891 eassert (recent_keys_index < NUM_RECENT_KEYS);
9894 Lisp_Object e = AREF (recent_keys, i);
9895 if (cmds || !CONSP (e) || !NILP (XCAR (e)))
9896 es = Fcons (e, es);
9897 if (++i >= NUM_RECENT_KEYS)
9898 i = 0;
9899 } while (i != recent_keys_index);
9900 es = Fnreverse (es);
9901 return Fvconcat (1, &es);
9905 DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0,
9906 doc: /* Return the key sequence that invoked this command.
9907 However, if the command has called `read-key-sequence', it returns
9908 the last key sequence that has been read.
9909 The value is a string or a vector.
9911 See also `this-command-keys-vector'. */)
9912 (void)
9914 return make_event_array (this_command_key_count,
9915 XVECTOR (this_command_keys)->contents);
9918 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
9919 doc: /* Return the key sequence that invoked this command, as a vector.
9920 However, if the command has called `read-key-sequence', it returns
9921 the last key sequence that has been read.
9923 See also `this-command-keys'. */)
9924 (void)
9926 return Fvector (this_command_key_count,
9927 XVECTOR (this_command_keys)->contents);
9930 DEFUN ("this-single-command-keys", Fthis_single_command_keys,
9931 Sthis_single_command_keys, 0, 0, 0,
9932 doc: /* Return the key sequence that invoked this command.
9933 More generally, it returns the last key sequence read, either by
9934 the command loop or by `read-key-sequence'.
9935 Unlike `this-command-keys', this function's value
9936 does not include prefix arguments.
9937 The value is always a vector. */)
9938 (void)
9940 return Fvector (this_command_key_count
9941 - this_single_command_key_start,
9942 (XVECTOR (this_command_keys)->contents
9943 + this_single_command_key_start));
9946 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys,
9947 Sthis_single_command_raw_keys, 0, 0, 0,
9948 doc: /* Return the raw events that were read for this command.
9949 More generally, it returns the last key sequence read, either by
9950 the command loop or by `read-key-sequence'.
9951 Unlike `this-single-command-keys', this function's value
9952 shows the events before all translations (except for input methods).
9953 The value is always a vector. */)
9954 (void)
9956 return Fvector (raw_keybuf_count, XVECTOR (raw_keybuf)->contents);
9959 DEFUN ("clear-this-command-keys", Fclear_this_command_keys,
9960 Sclear_this_command_keys, 0, 1, 0,
9961 doc: /* Clear out the vector that `this-command-keys' returns.
9962 Also clear the record of the last 100 events, unless optional arg
9963 KEEP-RECORD is non-nil. */)
9964 (Lisp_Object keep_record)
9966 int i;
9968 this_command_key_count = 0;
9970 if (NILP (keep_record))
9972 for (i = 0; i < ASIZE (recent_keys); ++i)
9973 ASET (recent_keys, i, Qnil);
9974 total_keys = 0;
9975 recent_keys_index = 0;
9977 return Qnil;
9980 DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
9981 doc: /* Return the current depth in recursive edits. */)
9982 (void)
9984 Lisp_Object temp;
9985 /* Wrap around reliably on integer overflow. */
9986 EMACS_INT sum = (command_loop_level & INTMASK) + (minibuf_level & INTMASK);
9987 XSETINT (temp, sum);
9988 return temp;
9991 DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
9992 "FOpen dribble file: ",
9993 doc: /* Start writing all keyboard characters to a dribble file called FILE.
9994 If FILE is nil, close any open dribble file.
9995 The file will be closed when Emacs exits.
9997 Be aware that this records ALL characters you type!
9998 This may include sensitive information such as passwords. */)
9999 (Lisp_Object file)
10001 if (dribble)
10003 block_input ();
10004 fclose (dribble);
10005 unblock_input ();
10006 dribble = 0;
10008 if (!NILP (file))
10010 int fd;
10011 Lisp_Object encfile;
10013 file = Fexpand_file_name (file, Qnil);
10014 encfile = ENCODE_FILE (file);
10015 fd = emacs_open (SSDATA (encfile), O_WRONLY | O_CREAT | O_EXCL, 0600);
10016 if (fd < 0 && errno == EEXIST && unlink (SSDATA (encfile)) == 0)
10017 fd = emacs_open (SSDATA (encfile), O_WRONLY | O_CREAT | O_EXCL, 0600);
10018 dribble = fd < 0 ? 0 : fdopen (fd, "w");
10019 if (dribble == 0)
10020 report_file_error ("Opening dribble", file);
10022 return Qnil;
10025 DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
10026 doc: /* Discard the contents of the terminal input buffer.
10027 Also end any kbd macro being defined. */)
10028 (void)
10030 if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
10032 /* Discard the last command from the macro. */
10033 Fcancel_kbd_macro_events ();
10034 end_kbd_macro ();
10037 Vunread_command_events = Qnil;
10039 discard_tty_input ();
10041 kbd_fetch_ptr = kbd_store_ptr;
10042 input_pending = false;
10044 return Qnil;
10047 DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "",
10048 doc: /* Stop Emacs and return to superior process. You can resume later.
10049 If `cannot-suspend' is non-nil, or if the system doesn't support job
10050 control, run a subshell instead.
10052 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10053 to be read as terminal input by Emacs's parent, after suspension.
10055 Before suspending, run the normal hook `suspend-hook'.
10056 After resumption run the normal hook `suspend-resume-hook'.
10058 Some operating systems cannot stop the Emacs process and resume it later.
10059 On such systems, Emacs starts a subshell instead of suspending. */)
10060 (Lisp_Object stuffstring)
10062 ptrdiff_t count = SPECPDL_INDEX ();
10063 int old_height, old_width;
10064 int width, height;
10066 if (tty_list && tty_list->next)
10067 error ("There are other tty frames open; close them before suspending Emacs");
10069 if (!NILP (stuffstring))
10070 CHECK_STRING (stuffstring);
10072 run_hook (intern ("suspend-hook"));
10074 get_tty_size (fileno (CURTTY ()->input), &old_width, &old_height);
10075 reset_all_sys_modes ();
10076 /* sys_suspend can get an error if it tries to fork a subshell
10077 and the system resources aren't available for that. */
10078 record_unwind_protect_void (init_all_sys_modes);
10079 stuff_buffered_input (stuffstring);
10080 if (cannot_suspend)
10081 sys_subshell ();
10082 else
10083 sys_suspend ();
10084 unbind_to (count, Qnil);
10086 /* Check if terminal/window size has changed.
10087 Note that this is not useful when we are running directly
10088 with a window system; but suspend should be disabled in that case. */
10089 get_tty_size (fileno (CURTTY ()->input), &width, &height);
10090 if (width != old_width || height != old_height)
10091 change_frame_size (SELECTED_FRAME (), width,
10092 height - FRAME_MENU_BAR_LINES (SELECTED_FRAME ()),
10093 0, 0, 0, 0);
10095 run_hook (intern ("suspend-resume-hook"));
10097 return Qnil;
10100 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10101 Then in any case stuff anything Emacs has read ahead and not used. */
10103 void
10104 stuff_buffered_input (Lisp_Object stuffstring)
10106 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
10107 register unsigned char *p;
10109 if (STRINGP (stuffstring))
10111 register ptrdiff_t count;
10113 p = SDATA (stuffstring);
10114 count = SBYTES (stuffstring);
10115 while (count-- > 0)
10116 stuff_char (*p++);
10117 stuff_char ('\n');
10120 /* Anything we have read ahead, put back for the shell to read. */
10121 /* ?? What should this do when we have multiple keyboards??
10122 Should we ignore anything that was typed in at the "wrong" kboard?
10124 rms: we should stuff everything back into the kboard
10125 it came from. */
10126 for (; kbd_fetch_ptr != kbd_store_ptr; kbd_fetch_ptr++)
10129 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
10130 kbd_fetch_ptr = kbd_buffer;
10131 if (kbd_fetch_ptr->kind == ASCII_KEYSTROKE_EVENT)
10132 stuff_char (kbd_fetch_ptr->ie.code);
10134 clear_event (kbd_fetch_ptr);
10137 input_pending = false;
10138 #endif /* SIGTSTP */
10141 void
10142 set_waiting_for_input (struct timespec *time_to_clear)
10144 input_available_clear_time = time_to_clear;
10146 /* Tell handle_interrupt to throw back to read_char, */
10147 waiting_for_input = true;
10149 /* If handle_interrupt was called before and buffered a C-g,
10150 make it run again now, to avoid timing error. */
10151 if (!NILP (Vquit_flag))
10152 quit_throw_to_read_char (0);
10155 void
10156 clear_waiting_for_input (void)
10158 /* Tell handle_interrupt not to throw back to read_char, */
10159 waiting_for_input = false;
10160 input_available_clear_time = 0;
10163 /* The SIGINT handler.
10165 If we have a frame on the controlling tty, we assume that the
10166 SIGINT was generated by C-g, so we call handle_interrupt.
10167 Otherwise, tell QUIT to kill Emacs. */
10169 static void
10170 handle_interrupt_signal (int sig)
10172 /* See if we have an active terminal on our controlling tty. */
10173 struct terminal *terminal = get_named_terminal ("/dev/tty");
10174 if (!terminal)
10176 /* If there are no frames there, let's pretend that we are a
10177 well-behaving UN*X program and quit. We must not call Lisp
10178 in a signal handler, so tell QUIT to exit when it is
10179 safe. */
10180 Vquit_flag = Qkill_emacs;
10182 else
10184 /* Otherwise, the SIGINT was probably generated by C-g. */
10186 /* Set internal_last_event_frame to the top frame of the
10187 controlling tty, if we have a frame there. We disable the
10188 interrupt key on secondary ttys, so the SIGINT must have come
10189 from the controlling tty. */
10190 internal_last_event_frame = terminal->display_info.tty->top_frame;
10192 handle_interrupt (1);
10196 static void
10197 deliver_interrupt_signal (int sig)
10199 deliver_process_signal (sig, handle_interrupt_signal);
10203 /* If Emacs is stuck because `inhibit-quit' is true, then keep track
10204 of the number of times C-g has been requested. If C-g is pressed
10205 enough times, then quit anyway. See bug#6585. */
10206 static int volatile force_quit_count;
10208 /* This routine is called at interrupt level in response to C-g.
10210 It is called from the SIGINT handler or kbd_buffer_store_event.
10212 If `waiting_for_input' is non zero, then unless `echoing' is
10213 nonzero, immediately throw back to read_char.
10215 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10216 eval to throw, when it gets a chance. If quit-flag is already
10217 non-nil, it stops the job right away. */
10219 static void
10220 handle_interrupt (bool in_signal_handler)
10222 char c;
10224 cancel_echoing ();
10226 /* XXX This code needs to be revised for multi-tty support. */
10227 if (!NILP (Vquit_flag) && get_named_terminal ("/dev/tty"))
10229 if (! in_signal_handler)
10231 /* If SIGINT isn't blocked, don't let us be interrupted by
10232 a SIGINT. It might be harmful due to non-reentrancy
10233 in I/O functions. */
10234 sigset_t blocked;
10235 sigemptyset (&blocked);
10236 sigaddset (&blocked, SIGINT);
10237 pthread_sigmask (SIG_BLOCK, &blocked, 0);
10240 fflush (stdout);
10241 reset_all_sys_modes ();
10243 #ifdef SIGTSTP
10245 * On systems which can suspend the current process and return to the original
10246 * shell, this command causes the user to end up back at the shell.
10247 * The "Auto-save" and "Abort" questions are not asked until
10248 * the user elects to return to emacs, at which point he can save the current
10249 * job and either dump core or continue.
10251 sys_suspend ();
10252 #else
10253 /* Perhaps should really fork an inferior shell?
10254 But that would not provide any way to get back
10255 to the original shell, ever. */
10256 printf ("No support for stopping a process on this operating system;\n");
10257 printf ("you can continue or abort.\n");
10258 #endif /* not SIGTSTP */
10259 #ifdef MSDOS
10260 /* We must remain inside the screen area when the internal terminal
10261 is used. Note that [Enter] is not echoed by dos. */
10262 cursor_to (SELECTED_FRAME (), 0, 0);
10263 #endif
10264 /* It doesn't work to autosave while GC is in progress;
10265 the code used for auto-saving doesn't cope with the mark bit. */
10266 if (!gc_in_progress)
10268 printf ("Auto-save? (y or n) ");
10269 fflush (stdout);
10270 if (((c = getchar ()) & ~040) == 'Y')
10272 Fdo_auto_save (Qt, Qnil);
10273 #ifdef MSDOS
10274 printf ("\r\nAuto-save done");
10275 #else /* not MSDOS */
10276 printf ("Auto-save done\n");
10277 #endif /* not MSDOS */
10279 while (c != '\n') c = getchar ();
10281 else
10283 /* During GC, it must be safe to reenable quitting again. */
10284 Vinhibit_quit = Qnil;
10285 #ifdef MSDOS
10286 printf ("\r\n");
10287 #endif /* not MSDOS */
10288 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10289 printf ("but will instead do a real quit after garbage collection ends\r\n");
10290 fflush (stdout);
10293 #ifdef MSDOS
10294 printf ("\r\nAbort? (y or n) ");
10295 #else /* not MSDOS */
10296 printf ("Abort (and dump core)? (y or n) ");
10297 #endif /* not MSDOS */
10298 fflush (stdout);
10299 if (((c = getchar ()) & ~040) == 'Y')
10300 emacs_abort ();
10301 while (c != '\n') c = getchar ();
10302 #ifdef MSDOS
10303 printf ("\r\nContinuing...\r\n");
10304 #else /* not MSDOS */
10305 printf ("Continuing...\n");
10306 #endif /* not MSDOS */
10307 fflush (stdout);
10308 init_all_sys_modes ();
10310 else
10312 /* If executing a function that wants to be interrupted out of
10313 and the user has not deferred quitting by binding `inhibit-quit'
10314 then quit right away. */
10315 if (immediate_quit && NILP (Vinhibit_quit))
10317 struct gl_state_s saved;
10319 immediate_quit = false;
10320 pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
10321 saved = gl_state;
10322 Fsignal (Qquit, Qnil);
10323 gl_state = saved;
10325 else
10326 { /* Else request quit when it's safe. */
10327 int count = NILP (Vquit_flag) ? 1 : force_quit_count + 1;
10328 force_quit_count = count;
10329 if (count == 3)
10331 immediate_quit = true;
10332 Vinhibit_quit = Qnil;
10334 Vquit_flag = Qt;
10338 pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
10340 /* TODO: The longjmp in this call throws the NS event loop integration off,
10341 and it seems to do fine without this. Probably some attention
10342 needs to be paid to the setting of waiting_for_input in
10343 wait_reading_process_output() under HAVE_NS because of the call
10344 to ns_select there (needed because otherwise events aren't picked up
10345 outside of polling since we don't get SIGIO like X and we don't have a
10346 separate event loop thread like W32. */
10347 #ifndef HAVE_NS
10348 if (waiting_for_input && !echoing)
10349 quit_throw_to_read_char (in_signal_handler);
10350 #endif
10353 /* Handle a C-g by making read_char return C-g. */
10355 static void
10356 quit_throw_to_read_char (bool from_signal)
10358 /* When not called from a signal handler it is safe to call
10359 Lisp. */
10360 if (!from_signal && EQ (Vquit_flag, Qkill_emacs))
10361 Fkill_emacs (Qnil);
10363 /* Prevent another signal from doing this before we finish. */
10364 clear_waiting_for_input ();
10365 input_pending = false;
10367 Vunread_command_events = Qnil;
10369 if (FRAMEP (internal_last_event_frame)
10370 && !EQ (internal_last_event_frame, selected_frame))
10371 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame),
10372 0, 0, Qnil);
10374 sys_longjmp (getcjmp, 1);
10377 DEFUN ("set-input-interrupt-mode", Fset_input_interrupt_mode,
10378 Sset_input_interrupt_mode, 1, 1, 0,
10379 doc: /* Set interrupt mode of reading keyboard input.
10380 If INTERRUPT is non-nil, Emacs will use input interrupts;
10381 otherwise Emacs uses CBREAK mode.
10383 See also `current-input-mode'. */)
10384 (Lisp_Object interrupt)
10386 bool new_interrupt_input;
10387 #ifdef USABLE_SIGIO
10388 #ifdef HAVE_X_WINDOWS
10389 if (x_display_list != NULL)
10391 /* When using X, don't give the user a real choice,
10392 because we haven't implemented the mechanisms to support it. */
10393 new_interrupt_input = true;
10395 else
10396 #endif /* HAVE_X_WINDOWS */
10397 new_interrupt_input = !NILP (interrupt);
10398 #else /* not USABLE_SIGIO */
10399 new_interrupt_input = false;
10400 #endif /* not USABLE_SIGIO */
10402 if (new_interrupt_input != interrupt_input)
10404 #ifdef POLL_FOR_INPUT
10405 stop_polling ();
10406 #endif
10407 #ifndef DOS_NT
10408 /* this causes startup screen to be restored and messes with the mouse */
10409 reset_all_sys_modes ();
10410 interrupt_input = new_interrupt_input;
10411 init_all_sys_modes ();
10412 #else
10413 interrupt_input = new_interrupt_input;
10414 #endif
10416 #ifdef POLL_FOR_INPUT
10417 poll_suppress_count = 1;
10418 start_polling ();
10419 #endif
10421 return Qnil;
10424 DEFUN ("set-output-flow-control", Fset_output_flow_control, Sset_output_flow_control, 1, 2, 0,
10425 doc: /* Enable or disable ^S/^Q flow control for output to TERMINAL.
10426 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
10427 C-q in key sequences.
10429 This setting only has an effect on tty terminals and only when
10430 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
10432 See also `current-input-mode'. */)
10433 (Lisp_Object flow, Lisp_Object terminal)
10435 struct terminal *t = decode_tty_terminal (terminal);
10436 struct tty_display_info *tty;
10438 if (!t)
10439 return Qnil;
10440 tty = t->display_info.tty;
10442 if (tty->flow_control != !NILP (flow))
10444 #ifndef DOS_NT
10445 /* This causes startup screen to be restored and messes with the mouse. */
10446 reset_sys_modes (tty);
10447 #endif
10449 tty->flow_control = !NILP (flow);
10451 #ifndef DOS_NT
10452 init_sys_modes (tty);
10453 #endif
10455 return Qnil;
10458 DEFUN ("set-input-meta-mode", Fset_input_meta_mode, Sset_input_meta_mode, 1, 2, 0,
10459 doc: /* Enable or disable 8-bit input on TERMINAL.
10460 If META is t, Emacs will accept 8-bit input, and interpret the 8th
10461 bit as the Meta modifier.
10463 If META is nil, Emacs will ignore the top bit, on the assumption it is
10464 parity.
10466 Otherwise, Emacs will accept and pass through 8-bit input without
10467 specially interpreting the top bit.
10469 This setting only has an effect on tty terminal devices.
10471 Optional parameter TERMINAL specifies the tty terminal device to use.
10472 It may be a terminal object, a frame, or nil for the terminal used by
10473 the currently selected frame.
10475 See also `current-input-mode'. */)
10476 (Lisp_Object meta, Lisp_Object terminal)
10478 struct terminal *t = decode_tty_terminal (terminal);
10479 struct tty_display_info *tty;
10480 int new_meta;
10482 if (!t)
10483 return Qnil;
10484 tty = t->display_info.tty;
10486 if (NILP (meta))
10487 new_meta = 0;
10488 else if (EQ (meta, Qt))
10489 new_meta = 1;
10490 else
10491 new_meta = 2;
10493 if (tty->meta_key != new_meta)
10495 #ifndef DOS_NT
10496 /* this causes startup screen to be restored and messes with the mouse */
10497 reset_sys_modes (tty);
10498 #endif
10500 tty->meta_key = new_meta;
10502 #ifndef DOS_NT
10503 init_sys_modes (tty);
10504 #endif
10506 return Qnil;
10509 DEFUN ("set-quit-char", Fset_quit_char, Sset_quit_char, 1, 1, 0,
10510 doc: /* Specify character used for quitting.
10511 QUIT must be an ASCII character.
10513 This function only has an effect on the controlling tty of the Emacs
10514 process.
10516 See also `current-input-mode'. */)
10517 (Lisp_Object quit)
10519 struct terminal *t = get_named_terminal ("/dev/tty");
10520 struct tty_display_info *tty;
10522 if (!t)
10523 return Qnil;
10524 tty = t->display_info.tty;
10526 if (NILP (quit) || !INTEGERP (quit) || XINT (quit) < 0 || XINT (quit) > 0400)
10527 error ("QUIT must be an ASCII character");
10529 #ifndef DOS_NT
10530 /* this causes startup screen to be restored and messes with the mouse */
10531 reset_sys_modes (tty);
10532 #endif
10534 /* Don't let this value be out of range. */
10535 quit_char = XINT (quit) & (tty->meta_key == 0 ? 0177 : 0377);
10537 #ifndef DOS_NT
10538 init_sys_modes (tty);
10539 #endif
10541 return Qnil;
10544 DEFUN ("set-input-mode", Fset_input_mode, Sset_input_mode, 3, 4, 0,
10545 doc: /* Set mode of reading keyboard input.
10546 First arg INTERRUPT non-nil means use input interrupts;
10547 nil means use CBREAK mode.
10548 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
10549 (no effect except in CBREAK mode).
10550 Third arg META t means accept 8-bit input (for a Meta key).
10551 META nil means ignore the top bit, on the assumption it is parity.
10552 Otherwise, accept 8-bit input and don't use the top bit for Meta.
10553 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
10554 See also `current-input-mode'. */)
10555 (Lisp_Object interrupt, Lisp_Object flow, Lisp_Object meta, Lisp_Object quit)
10557 Fset_input_interrupt_mode (interrupt);
10558 Fset_output_flow_control (flow, Qnil);
10559 Fset_input_meta_mode (meta, Qnil);
10560 if (!NILP (quit))
10561 Fset_quit_char (quit);
10562 return Qnil;
10565 DEFUN ("current-input-mode", Fcurrent_input_mode, Scurrent_input_mode, 0, 0, 0,
10566 doc: /* Return information about the way Emacs currently reads keyboard input.
10567 The value is a list of the form (INTERRUPT FLOW META QUIT), where
10568 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
10569 nil, Emacs is using CBREAK mode.
10570 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
10571 terminal; this does not apply if Emacs uses interrupt-driven input.
10572 META is t if accepting 8-bit input with 8th bit as Meta flag.
10573 META nil means ignoring the top bit, on the assumption it is parity.
10574 META is neither t nor nil if accepting 8-bit input and using
10575 all 8 bits as the character code.
10576 QUIT is the character Emacs currently uses to quit.
10577 The elements of this list correspond to the arguments of
10578 `set-input-mode'. */)
10579 (void)
10581 struct frame *sf = XFRAME (selected_frame);
10583 Lisp_Object interrupt = interrupt_input ? Qt : Qnil;
10584 Lisp_Object flow, meta;
10585 if (FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
10587 flow = FRAME_TTY (sf)->flow_control ? Qt : Qnil;
10588 meta = (FRAME_TTY (sf)->meta_key == 2
10589 ? make_number (0)
10590 : (CURTTY ()->meta_key == 1 ? Qt : Qnil));
10592 else
10594 flow = Qnil;
10595 meta = Qt;
10597 Lisp_Object quit = make_number (quit_char);
10599 return list4 (interrupt, flow, meta, quit);
10602 DEFUN ("posn-at-x-y", Fposn_at_x_y, Sposn_at_x_y, 2, 4, 0,
10603 doc: /* Return position information for pixel coordinates X and Y.
10604 By default, X and Y are relative to text area of the selected window.
10605 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
10606 If optional fourth arg WHOLE is non-nil, X is relative to the left
10607 edge of the window.
10609 The return value is similar to a mouse click position:
10610 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
10611 IMAGE (DX . DY) (WIDTH . HEIGHT))
10612 The `posn-' functions access elements of such lists. */)
10613 (Lisp_Object x, Lisp_Object y, Lisp_Object frame_or_window, Lisp_Object whole)
10615 CHECK_NUMBER (x);
10616 /* We allow X of -1, for the newline in a R2L line that overflowed
10617 into the left fringe. */
10618 if (XINT (x) != -1)
10619 CHECK_NATNUM (x);
10620 CHECK_NATNUM (y);
10622 if (NILP (frame_or_window))
10623 frame_or_window = selected_window;
10625 if (WINDOWP (frame_or_window))
10627 struct window *w = decode_live_window (frame_or_window);
10629 XSETINT (x, (XINT (x)
10630 + WINDOW_LEFT_EDGE_X (w)
10631 + (NILP (whole)
10632 ? window_box_left_offset (w, TEXT_AREA)
10633 : 0)));
10634 XSETINT (y, WINDOW_TO_FRAME_PIXEL_Y (w, XINT (y)));
10635 frame_or_window = w->frame;
10638 CHECK_LIVE_FRAME (frame_or_window);
10640 return make_lispy_position (XFRAME (frame_or_window), x, y, 0);
10643 DEFUN ("posn-at-point", Fposn_at_point, Sposn_at_point, 0, 2, 0,
10644 doc: /* Return position information for buffer POS in WINDOW.
10645 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
10647 Return nil if position is not visible in window. Otherwise,
10648 the return value is similar to that returned by `event-start' for
10649 a mouse click at the upper left corner of the glyph corresponding
10650 to the given buffer position:
10651 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
10652 IMAGE (DX . DY) (WIDTH . HEIGHT))
10653 The `posn-' functions access elements of such lists. */)
10654 (Lisp_Object pos, Lisp_Object window)
10656 Lisp_Object tem;
10658 if (NILP (window))
10659 window = selected_window;
10661 tem = Fpos_visible_in_window_p (pos, window, Qt);
10662 if (!NILP (tem))
10664 Lisp_Object x = XCAR (tem);
10665 Lisp_Object y = XCAR (XCDR (tem));
10667 /* Point invisible due to hscrolling? X can be -1 when a
10668 newline in a R2L line overflows into the left fringe. */
10669 if (XINT (x) < -1)
10670 return Qnil;
10671 tem = Fposn_at_x_y (x, y, window, Qnil);
10674 return tem;
10677 /* Set up a new kboard object with reasonable initial values.
10678 TYPE is a window system for which this keyboard is used. */
10680 static void
10681 init_kboard (KBOARD *kb, Lisp_Object type)
10683 kset_overriding_terminal_local_map (kb, Qnil);
10684 kset_last_command (kb, Qnil);
10685 kset_real_last_command (kb, Qnil);
10686 kset_keyboard_translate_table (kb, Qnil);
10687 kset_last_repeatable_command (kb, Qnil);
10688 kset_prefix_arg (kb, Qnil);
10689 kset_last_prefix_arg (kb, Qnil);
10690 kset_kbd_queue (kb, Qnil);
10691 kb->kbd_queue_has_data = false;
10692 kb->immediate_echo = false;
10693 kset_echo_string (kb, Qnil);
10694 kset_echo_prompt (kb, Qnil);
10695 kb->kbd_macro_buffer = 0;
10696 kb->kbd_macro_bufsize = 0;
10697 kset_defining_kbd_macro (kb, Qnil);
10698 kset_last_kbd_macro (kb, Qnil);
10699 kb->reference_count = 0;
10700 kset_system_key_alist (kb, Qnil);
10701 kset_system_key_syms (kb, Qnil);
10702 kset_window_system (kb, type);
10703 kset_input_decode_map (kb, Fmake_sparse_keymap (Qnil));
10704 kset_local_function_key_map (kb, Fmake_sparse_keymap (Qnil));
10705 Fset_keymap_parent (KVAR (kb, Vlocal_function_key_map), Vfunction_key_map);
10706 kset_default_minibuffer_frame (kb, Qnil);
10709 /* Allocate and basically initialize keyboard
10710 object to use with window system TYPE. */
10712 KBOARD *
10713 allocate_kboard (Lisp_Object type)
10715 KBOARD *kb = xmalloc (sizeof *kb);
10717 init_kboard (kb, type);
10718 kb->next_kboard = all_kboards;
10719 all_kboards = kb;
10720 return kb;
10724 * Destroy the contents of a kboard object, but not the object itself.
10725 * We use this just before deleting it, or if we're going to initialize
10726 * it a second time.
10728 static void
10729 wipe_kboard (KBOARD *kb)
10731 xfree (kb->kbd_macro_buffer);
10734 /* Free KB and memory referenced from it. */
10736 void
10737 delete_kboard (KBOARD *kb)
10739 KBOARD **kbp;
10741 for (kbp = &all_kboards; *kbp != kb; kbp = &(*kbp)->next_kboard)
10742 if (*kbp == NULL)
10743 emacs_abort ();
10744 *kbp = kb->next_kboard;
10746 /* Prevent a dangling reference to KB. */
10747 if (kb == current_kboard
10748 && FRAMEP (selected_frame)
10749 && FRAME_LIVE_P (XFRAME (selected_frame)))
10751 current_kboard = FRAME_KBOARD (XFRAME (selected_frame));
10752 single_kboard = false;
10753 if (current_kboard == kb)
10754 emacs_abort ();
10757 wipe_kboard (kb);
10758 xfree (kb);
10761 void
10762 init_keyboard (void)
10764 /* This is correct before outermost invocation of the editor loop. */
10765 command_loop_level = -1;
10766 immediate_quit = false;
10767 quit_char = Ctl ('g');
10768 Vunread_command_events = Qnil;
10769 timer_idleness_start_time = invalid_timespec ();
10770 total_keys = 0;
10771 recent_keys_index = 0;
10772 kbd_fetch_ptr = kbd_buffer;
10773 kbd_store_ptr = kbd_buffer;
10774 do_mouse_tracking = Qnil;
10775 input_pending = false;
10776 interrupt_input_blocked = 0;
10777 pending_signals = false;
10779 /* This means that command_loop_1 won't try to select anything the first
10780 time through. */
10781 internal_last_event_frame = Qnil;
10782 Vlast_event_frame = internal_last_event_frame;
10784 current_kboard = initial_kboard;
10785 /* Re-initialize the keyboard again. */
10786 wipe_kboard (current_kboard);
10787 /* A value of nil for Vwindow_system normally means a tty, but we also use
10788 it for the initial terminal since there is no window system there. */
10789 init_kboard (current_kboard, Qnil);
10791 if (!noninteractive)
10793 /* Before multi-tty support, these handlers used to be installed
10794 only if the current session was a tty session. Now an Emacs
10795 session may have multiple display types, so we always handle
10796 SIGINT. There is special code in handle_interrupt_signal to exit
10797 Emacs on SIGINT when there are no termcap frames on the
10798 controlling terminal. */
10799 struct sigaction action;
10800 emacs_sigaction_init (&action, deliver_interrupt_signal);
10801 sigaction (SIGINT, &action, 0);
10802 #ifndef DOS_NT
10803 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
10804 SIGQUIT and we can't tell which one it will give us. */
10805 sigaction (SIGQUIT, &action, 0);
10806 #endif /* not DOS_NT */
10808 #ifdef USABLE_SIGIO
10809 if (!noninteractive)
10811 struct sigaction action;
10812 emacs_sigaction_init (&action, deliver_input_available_signal);
10813 sigaction (SIGIO, &action, 0);
10815 #endif
10817 /* Use interrupt input by default, if it works and noninterrupt input
10818 has deficiencies. */
10820 #ifdef INTERRUPT_INPUT
10821 interrupt_input = 1;
10822 #else
10823 interrupt_input = 0;
10824 #endif
10826 pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
10827 dribble = 0;
10829 if (keyboard_init_hook)
10830 (*keyboard_init_hook) ();
10832 #ifdef POLL_FOR_INPUT
10833 poll_timer = NULL;
10834 poll_suppress_count = 1;
10835 start_polling ();
10836 #endif
10839 /* This type's only use is in syms_of_keyboard, to put properties on the
10840 event header symbols. */
10841 struct event_head
10843 short var;
10844 short kind;
10847 static const struct event_head head_table[] = {
10848 {SYMBOL_INDEX (Qmouse_movement), SYMBOL_INDEX (Qmouse_movement)},
10849 {SYMBOL_INDEX (Qscroll_bar_movement), SYMBOL_INDEX (Qmouse_movement)},
10851 /* Some of the event heads. */
10852 {SYMBOL_INDEX (Qswitch_frame), SYMBOL_INDEX (Qswitch_frame)},
10854 {SYMBOL_INDEX (Qfocus_in), SYMBOL_INDEX (Qfocus_in)},
10855 {SYMBOL_INDEX (Qfocus_out), SYMBOL_INDEX (Qfocus_out)},
10856 {SYMBOL_INDEX (Qdelete_frame), SYMBOL_INDEX (Qdelete_frame)},
10857 {SYMBOL_INDEX (Qiconify_frame), SYMBOL_INDEX (Qiconify_frame)},
10858 {SYMBOL_INDEX (Qmake_frame_visible), SYMBOL_INDEX (Qmake_frame_visible)},
10859 /* `select-window' should be handled just like `switch-frame'
10860 in read_key_sequence. */
10861 {SYMBOL_INDEX (Qselect_window), SYMBOL_INDEX (Qswitch_frame)}
10864 void
10865 syms_of_keyboard (void)
10867 pending_funcalls = Qnil;
10868 staticpro (&pending_funcalls);
10870 Vlispy_mouse_stem = build_pure_c_string ("mouse");
10871 staticpro (&Vlispy_mouse_stem);
10873 regular_top_level_message = build_pure_c_string ("Back to top level");
10874 #ifdef HAVE_STACK_OVERFLOW_HANDLING
10875 recover_top_level_message
10876 = build_pure_c_string ("Re-entering top level after C stack overflow");
10877 #endif
10878 DEFVAR_LISP ("internal--top-level-message", Vinternal__top_level_message,
10879 doc: /* Message displayed by `normal-top-level'. */);
10880 Vinternal__top_level_message = regular_top_level_message;
10882 /* Tool-bars. */
10883 DEFSYM (QCimage, ":image");
10884 DEFSYM (Qhelp_echo, "help-echo");
10885 DEFSYM (QCrtl, ":rtl");
10887 staticpro (&item_properties);
10888 item_properties = Qnil;
10890 staticpro (&tool_bar_item_properties);
10891 tool_bar_item_properties = Qnil;
10892 staticpro (&tool_bar_items_vector);
10893 tool_bar_items_vector = Qnil;
10895 DEFSYM (Qtimer_event_handler, "timer-event-handler");
10897 /* Non-nil disable property on a command means do not execute it;
10898 call disabled-command-function's value instead. */
10899 DEFSYM (Qdisabled, "disabled");
10901 DEFSYM (Qundefined, "undefined");
10903 /* Hooks to run before and after each command. */
10904 DEFSYM (Qpre_command_hook, "pre-command-hook");
10905 DEFSYM (Qpost_command_hook, "post-command-hook");
10907 DEFSYM (Qundo_auto__add_boundary, "undo-auto--add-boundary");
10909 DEFSYM (Qdeferred_action_function, "deferred-action-function");
10910 DEFSYM (Qdelayed_warnings_hook, "delayed-warnings-hook");
10911 DEFSYM (Qfunction_key, "function-key");
10913 /* The values of Qevent_kind properties. */
10914 DEFSYM (Qmouse_click, "mouse-click");
10916 DEFSYM (Qdrag_n_drop, "drag-n-drop");
10917 DEFSYM (Qsave_session, "save-session");
10918 DEFSYM (Qconfig_changed_event, "config-changed-event");
10920 /* Menu and tool bar item parts. */
10921 DEFSYM (Qmenu_enable, "menu-enable");
10923 #ifdef HAVE_NTGUI
10924 DEFSYM (Qlanguage_change, "language-change");
10925 #endif
10927 #ifdef HAVE_DBUS
10928 DEFSYM (Qdbus_event, "dbus-event");
10929 #endif
10931 #ifdef USE_FILE_NOTIFY
10932 DEFSYM (Qfile_notify, "file-notify");
10933 #endif /* USE_FILE_NOTIFY */
10935 /* Menu and tool bar item parts. */
10936 DEFSYM (QCenable, ":enable");
10937 DEFSYM (QCvisible, ":visible");
10938 DEFSYM (QChelp, ":help");
10939 DEFSYM (QCfilter, ":filter");
10940 DEFSYM (QCbutton, ":button");
10941 DEFSYM (QCkeys, ":keys");
10942 DEFSYM (QCkey_sequence, ":key-sequence");
10944 /* Non-nil disable property on a command means
10945 do not execute it; call disabled-command-function's value instead. */
10946 DEFSYM (QCtoggle, ":toggle");
10947 DEFSYM (QCradio, ":radio");
10948 DEFSYM (QClabel, ":label");
10949 DEFSYM (QCvert_only, ":vert-only");
10951 /* Symbols to use for parts of windows. */
10952 DEFSYM (Qvertical_line, "vertical-line");
10953 DEFSYM (Qright_divider, "right-divider");
10954 DEFSYM (Qbottom_divider, "bottom-divider");
10956 DEFSYM (Qmouse_fixup_help_message, "mouse-fixup-help-message");
10958 DEFSYM (Qabove_handle, "above-handle");
10959 DEFSYM (Qhandle, "handle");
10960 DEFSYM (Qbelow_handle, "below-handle");
10961 DEFSYM (Qup, "up");
10962 DEFSYM (Qdown, "down");
10963 DEFSYM (Qtop, "top");
10964 DEFSYM (Qbottom, "bottom");
10965 DEFSYM (Qend_scroll, "end-scroll");
10966 DEFSYM (Qratio, "ratio");
10967 DEFSYM (Qbefore_handle, "before-handle");
10968 DEFSYM (Qhorizontal_handle, "horizontal-handle");
10969 DEFSYM (Qafter_handle, "after-handle");
10970 DEFSYM (Qleft, "left");
10971 DEFSYM (Qright, "right");
10972 DEFSYM (Qleftmost, "leftmost");
10973 DEFSYM (Qrightmost, "rightmost");
10975 /* Properties of event headers. */
10976 DEFSYM (Qevent_kind, "event-kind");
10977 DEFSYM (Qevent_symbol_elements, "event-symbol-elements");
10979 /* An event header symbol HEAD may have a property named
10980 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
10981 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
10982 mask of modifiers applied to it. If present, this is used to help
10983 speed up parse_modifiers. */
10984 DEFSYM (Qevent_symbol_element_mask, "event-symbol-element-mask");
10986 /* An unmodified event header BASE may have a property named
10987 Qmodifier_cache, which is an alist mapping modifier masks onto
10988 modified versions of BASE. If present, this helps speed up
10989 apply_modifiers. */
10990 DEFSYM (Qmodifier_cache, "modifier-cache");
10992 DEFSYM (Qrecompute_lucid_menubar, "recompute-lucid-menubar");
10993 DEFSYM (Qactivate_menubar_hook, "activate-menubar-hook");
10995 DEFSYM (Qpolling_period, "polling-period");
10997 DEFSYM (Qgui_set_selection, "gui-set-selection");
10999 /* The primary selection. */
11000 DEFSYM (QPRIMARY, "PRIMARY");
11002 DEFSYM (Qhandle_switch_frame, "handle-switch-frame");
11003 DEFSYM (Qhandle_select_window, "handle-select-window");
11005 DEFSYM (Qinput_method_exit_on_first_char, "input-method-exit-on-first-char");
11006 DEFSYM (Qinput_method_use_echo_area, "input-method-use-echo-area");
11008 DEFSYM (Qhelp_form_show, "help-form-show");
11010 DEFSYM (Qecho_keystrokes, "echo-keystrokes");
11012 Fset (Qinput_method_exit_on_first_char, Qnil);
11013 Fset (Qinput_method_use_echo_area, Qnil);
11015 /* Symbols to head events. */
11016 DEFSYM (Qmouse_movement, "mouse-movement");
11017 DEFSYM (Qscroll_bar_movement, "scroll-bar-movement");
11018 DEFSYM (Qswitch_frame, "switch-frame");
11019 DEFSYM (Qfocus_in, "focus-in");
11020 DEFSYM (Qfocus_out, "focus-out");
11021 DEFSYM (Qdelete_frame, "delete-frame");
11022 DEFSYM (Qiconify_frame, "iconify-frame");
11023 DEFSYM (Qmake_frame_visible, "make-frame-visible");
11024 DEFSYM (Qselect_window, "select-window");
11026 int i;
11028 for (i = 0; i < ARRAYELTS (head_table); i++)
11030 const struct event_head *p = &head_table[i];
11031 Lisp_Object var = builtin_lisp_symbol (p->var);
11032 Lisp_Object kind = builtin_lisp_symbol (p->kind);
11033 Fput (var, Qevent_kind, kind);
11034 Fput (var, Qevent_symbol_elements, list1 (var));
11038 button_down_location = Fmake_vector (make_number (5), Qnil);
11039 staticpro (&button_down_location);
11040 mouse_syms = Fmake_vector (make_number (5), Qnil);
11041 staticpro (&mouse_syms);
11042 wheel_syms = Fmake_vector (make_number (ARRAYELTS (lispy_wheel_names)),
11043 Qnil);
11044 staticpro (&wheel_syms);
11047 int i;
11048 int len = ARRAYELTS (modifier_names);
11050 modifier_symbols = Fmake_vector (make_number (len), Qnil);
11051 for (i = 0; i < len; i++)
11052 if (modifier_names[i])
11053 ASET (modifier_symbols, i, intern_c_string (modifier_names[i]));
11054 staticpro (&modifier_symbols);
11057 recent_keys = Fmake_vector (make_number (NUM_RECENT_KEYS), Qnil);
11058 staticpro (&recent_keys);
11060 this_command_keys = Fmake_vector (make_number (40), Qnil);
11061 staticpro (&this_command_keys);
11063 raw_keybuf = Fmake_vector (make_number (30), Qnil);
11064 staticpro (&raw_keybuf);
11066 DEFSYM (Qcommand_execute, "command-execute");
11067 DEFSYM (Qinternal_echo_keystrokes_prefix, "internal-echo-keystrokes-prefix");
11069 accent_key_syms = Qnil;
11070 staticpro (&accent_key_syms);
11072 func_key_syms = Qnil;
11073 staticpro (&func_key_syms);
11075 drag_n_drop_syms = Qnil;
11076 staticpro (&drag_n_drop_syms);
11078 unread_switch_frame = Qnil;
11079 staticpro (&unread_switch_frame);
11081 internal_last_event_frame = Qnil;
11082 staticpro (&internal_last_event_frame);
11084 read_key_sequence_cmd = Qnil;
11085 staticpro (&read_key_sequence_cmd);
11086 read_key_sequence_remapped = Qnil;
11087 staticpro (&read_key_sequence_remapped);
11089 menu_bar_one_keymap_changed_items = Qnil;
11090 staticpro (&menu_bar_one_keymap_changed_items);
11092 menu_bar_items_vector = Qnil;
11093 staticpro (&menu_bar_items_vector);
11095 help_form_saved_window_configs = Qnil;
11096 staticpro (&help_form_saved_window_configs);
11098 defsubr (&Scurrent_idle_time);
11099 defsubr (&Sevent_symbol_parse_modifiers);
11100 defsubr (&Sevent_convert_list);
11101 defsubr (&Sread_key_sequence);
11102 defsubr (&Sread_key_sequence_vector);
11103 defsubr (&Srecursive_edit);
11104 defsubr (&Strack_mouse);
11105 defsubr (&Sinput_pending_p);
11106 defsubr (&Srecent_keys);
11107 defsubr (&Sthis_command_keys);
11108 defsubr (&Sthis_command_keys_vector);
11109 defsubr (&Sthis_single_command_keys);
11110 defsubr (&Sthis_single_command_raw_keys);
11111 defsubr (&Sclear_this_command_keys);
11112 defsubr (&Ssuspend_emacs);
11113 defsubr (&Sabort_recursive_edit);
11114 defsubr (&Sexit_recursive_edit);
11115 defsubr (&Srecursion_depth);
11116 defsubr (&Scommand_error_default_function);
11117 defsubr (&Stop_level);
11118 defsubr (&Sdiscard_input);
11119 defsubr (&Sopen_dribble_file);
11120 defsubr (&Sset_input_interrupt_mode);
11121 defsubr (&Sset_output_flow_control);
11122 defsubr (&Sset_input_meta_mode);
11123 defsubr (&Sset_quit_char);
11124 defsubr (&Sset_input_mode);
11125 defsubr (&Scurrent_input_mode);
11126 defsubr (&Sposn_at_point);
11127 defsubr (&Sposn_at_x_y);
11129 DEFVAR_LISP ("last-command-event", last_command_event,
11130 doc: /* Last input event that was part of a command. */);
11132 DEFVAR_LISP ("last-nonmenu-event", last_nonmenu_event,
11133 doc: /* Last input event in a command, except for mouse menu events.
11134 Mouse menus give back keys that don't look like mouse events;
11135 this variable holds the actual mouse event that led to the menu,
11136 so that you can determine whether the command was run by mouse or not. */);
11138 DEFVAR_LISP ("last-input-event", last_input_event,
11139 doc: /* Last input event. */);
11141 DEFVAR_LISP ("unread-command-events", Vunread_command_events,
11142 doc: /* List of events to be read as the command input.
11143 These events are processed first, before actual keyboard input.
11144 Events read from this list are not normally added to `this-command-keys',
11145 as they will already have been added once as they were read for the first time.
11146 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
11147 Vunread_command_events = Qnil;
11149 DEFVAR_LISP ("unread-post-input-method-events", Vunread_post_input_method_events,
11150 doc: /* List of events to be processed as input by input methods.
11151 These events are processed before `unread-command-events'
11152 and actual keyboard input, but are not given to `input-method-function'. */);
11153 Vunread_post_input_method_events = Qnil;
11155 DEFVAR_LISP ("unread-input-method-events", Vunread_input_method_events,
11156 doc: /* List of events to be processed as input by input methods.
11157 These events are processed after `unread-command-events', but
11158 before actual keyboard input.
11159 If there's an active input method, the events are given to
11160 `input-method-function'. */);
11161 Vunread_input_method_events = Qnil;
11163 DEFVAR_LISP ("meta-prefix-char", meta_prefix_char,
11164 doc: /* Meta-prefix character code.
11165 Meta-foo as command input turns into this character followed by foo. */);
11166 XSETINT (meta_prefix_char, 033);
11168 DEFVAR_KBOARD ("last-command", Vlast_command,
11169 doc: /* The last command executed.
11170 Normally a symbol with a function definition, but can be whatever was found
11171 in the keymap, or whatever the variable `this-command' was set to by that
11172 command.
11174 The value `mode-exit' is special; it means that the previous command
11175 read an event that told it to exit, and it did so and unread that event.
11176 In other words, the present command is the event that made the previous
11177 command exit.
11179 The value `kill-region' is special; it means that the previous command
11180 was a kill command.
11182 `last-command' has a separate binding for each terminal device.
11183 See Info node `(elisp)Multiple Terminals'. */);
11185 DEFVAR_KBOARD ("real-last-command", Vreal_last_command,
11186 doc: /* Same as `last-command', but never altered by Lisp code.
11187 Taken from the previous value of `real-this-command'. */);
11189 DEFVAR_KBOARD ("last-repeatable-command", Vlast_repeatable_command,
11190 doc: /* Last command that may be repeated.
11191 The last command executed that was not bound to an input event.
11192 This is the command `repeat' will try to repeat.
11193 Taken from a previous value of `real-this-command'. */);
11195 DEFVAR_LISP ("this-command", Vthis_command,
11196 doc: /* The command now being executed.
11197 The command can set this variable; whatever is put here
11198 will be in `last-command' during the following command. */);
11199 Vthis_command = Qnil;
11201 DEFVAR_LISP ("real-this-command", Vreal_this_command,
11202 doc: /* This is like `this-command', except that commands should never modify it. */);
11203 Vreal_this_command = Qnil;
11205 DEFVAR_LISP ("this-command-keys-shift-translated",
11206 Vthis_command_keys_shift_translated,
11207 doc: /* Non-nil if the key sequence activating this command was shift-translated.
11208 Shift-translation occurs when there is no binding for the key sequence
11209 as entered, but a binding was found by changing an upper-case letter
11210 to lower-case, or a shifted function key to an unshifted one. */);
11211 Vthis_command_keys_shift_translated = Qnil;
11213 DEFVAR_LISP ("this-original-command", Vthis_original_command,
11214 doc: /* The command bound to the current key sequence before remapping.
11215 It equals `this-command' if the original command was not remapped through
11216 any of the active keymaps. Otherwise, the value of `this-command' is the
11217 result of looking up the original command in the active keymaps. */);
11218 Vthis_original_command = Qnil;
11220 DEFVAR_INT ("auto-save-interval", auto_save_interval,
11221 doc: /* Number of input events between auto-saves.
11222 Zero means disable autosaving due to number of characters typed. */);
11223 auto_save_interval = 300;
11225 DEFVAR_LISP ("auto-save-timeout", Vauto_save_timeout,
11226 doc: /* Number of seconds idle time before auto-save.
11227 Zero or nil means disable auto-saving due to idleness.
11228 After auto-saving due to this many seconds of idle time,
11229 Emacs also does a garbage collection if that seems to be warranted. */);
11230 XSETFASTINT (Vauto_save_timeout, 30);
11232 DEFVAR_LISP ("echo-keystrokes", Vecho_keystrokes,
11233 doc: /* Nonzero means echo unfinished commands after this many seconds of pause.
11234 The value may be integer or floating point.
11235 If the value is zero, don't echo at all. */);
11236 Vecho_keystrokes = make_number (1);
11238 DEFVAR_INT ("polling-period", polling_period,
11239 doc: /* Interval between polling for input during Lisp execution.
11240 The reason for polling is to make C-g work to stop a running program.
11241 Polling is needed only when using X windows and SIGIO does not work.
11242 Polling is automatically disabled in all other cases. */);
11243 polling_period = 2;
11245 DEFVAR_LISP ("double-click-time", Vdouble_click_time,
11246 doc: /* Maximum time between mouse clicks to make a double-click.
11247 Measured in milliseconds. The value nil means disable double-click
11248 recognition; t means double-clicks have no time limit and are detected
11249 by position only. */);
11250 Vdouble_click_time = make_number (500);
11252 DEFVAR_INT ("double-click-fuzz", double_click_fuzz,
11253 doc: /* Maximum mouse movement between clicks to make a double-click.
11254 On window-system frames, value is the number of pixels the mouse may have
11255 moved horizontally or vertically between two clicks to make a double-click.
11256 On non window-system frames, value is interpreted in units of 1/8 characters
11257 instead of pixels.
11259 This variable is also the threshold for motion of the mouse
11260 to count as a drag. */);
11261 double_click_fuzz = 3;
11263 DEFVAR_INT ("num-input-keys", num_input_keys,
11264 doc: /* Number of complete key sequences read as input so far.
11265 This includes key sequences read from keyboard macros.
11266 The number is effectively the number of interactive command invocations. */);
11267 num_input_keys = 0;
11269 DEFVAR_INT ("num-nonmacro-input-events", num_nonmacro_input_events,
11270 doc: /* Number of input events read from the keyboard so far.
11271 This does not include events generated by keyboard macros. */);
11272 num_nonmacro_input_events = 0;
11274 DEFVAR_LISP ("last-event-frame", Vlast_event_frame,
11275 doc: /* The frame in which the most recently read event occurred.
11276 If the last event came from a keyboard macro, this is set to `macro'. */);
11277 Vlast_event_frame = Qnil;
11279 /* This variable is set up in sysdep.c. */
11280 DEFVAR_LISP ("tty-erase-char", Vtty_erase_char,
11281 doc: /* The ERASE character as set by the user with stty. */);
11283 DEFVAR_LISP ("help-char", Vhelp_char,
11284 doc: /* Character to recognize as meaning Help.
11285 When it is read, do `(eval help-form)', and display result if it's a string.
11286 If the value of `help-form' is nil, this char can be read normally. */);
11287 XSETINT (Vhelp_char, Ctl ('H'));
11289 DEFVAR_LISP ("help-event-list", Vhelp_event_list,
11290 doc: /* List of input events to recognize as meaning Help.
11291 These work just like the value of `help-char' (see that). */);
11292 Vhelp_event_list = Qnil;
11294 DEFVAR_LISP ("help-form", Vhelp_form,
11295 doc: /* Form to execute when character `help-char' is read.
11296 If the form returns a string, that string is displayed.
11297 If `help-form' is nil, the help char is not recognized. */);
11298 Vhelp_form = Qnil;
11300 DEFVAR_LISP ("prefix-help-command", Vprefix_help_command,
11301 doc: /* Command to run when `help-char' character follows a prefix key.
11302 This command is used only when there is no actual binding
11303 for that character after that prefix key. */);
11304 Vprefix_help_command = Qnil;
11306 DEFVAR_LISP ("top-level", Vtop_level,
11307 doc: /* Form to evaluate when Emacs starts up.
11308 Useful to set before you dump a modified Emacs. */);
11309 Vtop_level = Qnil;
11310 XSYMBOL (Qtop_level)->declared_special = false;
11312 DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table,
11313 doc: /* Translate table for local keyboard input, or nil.
11314 If non-nil, the value should be a char-table. Each character read
11315 from the keyboard is looked up in this char-table. If the value found
11316 there is non-nil, then it is used instead of the actual input character.
11318 The value can also be a string or vector, but this is considered obsolete.
11319 If it is a string or vector of length N, character codes N and up are left
11320 untranslated. In a vector, an element which is nil means "no translation".
11322 This is applied to the characters supplied to input methods, not their
11323 output. See also `translation-table-for-input'.
11325 This variable has a separate binding for each terminal.
11326 See Info node `(elisp)Multiple Terminals'. */);
11328 DEFVAR_BOOL ("cannot-suspend", cannot_suspend,
11329 doc: /* Non-nil means to always spawn a subshell instead of suspending.
11330 (Even if the operating system has support for stopping a process.) */);
11331 cannot_suspend = false;
11333 DEFVAR_BOOL ("menu-prompting", menu_prompting,
11334 doc: /* Non-nil means prompt with menus when appropriate.
11335 This is done when reading from a keymap that has a prompt string,
11336 for elements that have prompt strings.
11337 The menu is displayed on the screen
11338 if X menus were enabled at configuration
11339 time and the previous event was a mouse click prefix key.
11340 Otherwise, menu prompting uses the echo area. */);
11341 menu_prompting = true;
11343 DEFVAR_LISP ("menu-prompt-more-char", menu_prompt_more_char,
11344 doc: /* Character to see next line of menu prompt.
11345 Type this character while in a menu prompt to rotate around the lines of it. */);
11346 XSETINT (menu_prompt_more_char, ' ');
11348 DEFVAR_INT ("extra-keyboard-modifiers", extra_keyboard_modifiers,
11349 doc: /* A mask of additional modifier keys to use with every keyboard character.
11350 Emacs applies the modifiers of the character stored here to each keyboard
11351 character it reads. For example, after evaluating the expression
11352 (setq extra-keyboard-modifiers ?\\C-x)
11353 all input characters will have the control modifier applied to them.
11355 Note that the character ?\\C-@, equivalent to the integer zero, does
11356 not count as a control character; rather, it counts as a character
11357 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
11358 cancels any modification. */);
11359 extra_keyboard_modifiers = 0;
11361 DEFSYM (Qdeactivate_mark, "deactivate-mark");
11362 DEFVAR_LISP ("deactivate-mark", Vdeactivate_mark,
11363 doc: /* If an editing command sets this to t, deactivate the mark afterward.
11364 The command loop sets this to nil before each command,
11365 and tests the value when the command returns.
11366 Buffer modification stores t in this variable. */);
11367 Vdeactivate_mark = Qnil;
11368 Fmake_variable_buffer_local (Qdeactivate_mark);
11370 DEFVAR_LISP ("pre-command-hook", Vpre_command_hook,
11371 doc: /* Normal hook run before each command is executed.
11372 If an unhandled error happens in running this hook,
11373 the function in which the error occurred is unconditionally removed, since
11374 otherwise the error might happen repeatedly and make Emacs nonfunctional.
11376 See also `post-command-hook'. */);
11377 Vpre_command_hook = Qnil;
11379 DEFVAR_LISP ("post-command-hook", Vpost_command_hook,
11380 doc: /* Normal hook run after each command is executed.
11381 If an unhandled error happens in running this hook,
11382 the function in which the error occurred is unconditionally removed, since
11383 otherwise the error might happen repeatedly and make Emacs nonfunctional.
11385 It is a bad idea to use this hook for expensive processing. If
11386 unavoidable, wrap your code in `(while-no-input (redisplay) CODE)' to
11387 avoid making Emacs unresponsive while the user types.
11389 See also `pre-command-hook'. */);
11390 Vpost_command_hook = Qnil;
11392 #if 0
11393 DEFVAR_LISP ("echo-area-clear-hook", ...,
11394 doc: /* Normal hook run when clearing the echo area. */);
11395 #endif
11396 DEFSYM (Qecho_area_clear_hook, "echo-area-clear-hook");
11397 Fset (Qecho_area_clear_hook, Qnil);
11399 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", Vlucid_menu_bar_dirty_flag,
11400 doc: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
11401 Vlucid_menu_bar_dirty_flag = Qnil;
11403 DEFVAR_LISP ("menu-bar-final-items", Vmenu_bar_final_items,
11404 doc: /* List of menu bar items to move to the end of the menu bar.
11405 The elements of the list are event types that may have menu bar bindings. */);
11406 Vmenu_bar_final_items = Qnil;
11408 DEFVAR_LISP ("tool-bar-separator-image-expression", Vtool_bar_separator_image_expression,
11409 doc: /* Expression evaluating to the image spec for a tool-bar separator.
11410 This is used internally by graphical displays that do not render
11411 tool-bar separators natively. Otherwise it is unused (e.g. on GTK). */);
11412 Vtool_bar_separator_image_expression = Qnil;
11414 DEFVAR_KBOARD ("overriding-terminal-local-map",
11415 Voverriding_terminal_local_map,
11416 doc: /* Per-terminal keymap that takes precedence over all other keymaps.
11417 This variable is intended to let commands such as `universal-argument'
11418 set up a different keymap for reading the next command.
11420 `overriding-terminal-local-map' has a separate binding for each
11421 terminal device. See Info node `(elisp)Multiple Terminals'. */);
11423 DEFVAR_LISP ("overriding-local-map", Voverriding_local_map,
11424 doc: /* Keymap that replaces (overrides) local keymaps.
11425 If this variable is non-nil, Emacs looks up key bindings in this
11426 keymap INSTEAD OF the keymap char property, minor mode maps, and the
11427 buffer's local map. Hence, the only active keymaps would be
11428 `overriding-terminal-local-map', this keymap, and `global-keymap', in
11429 order of precedence. */);
11430 Voverriding_local_map = Qnil;
11432 DEFVAR_LISP ("overriding-local-map-menu-flag", Voverriding_local_map_menu_flag,
11433 doc: /* Non-nil means `overriding-local-map' applies to the menu bar.
11434 Otherwise, the menu bar continues to reflect the buffer's local map
11435 and the minor mode maps regardless of `overriding-local-map'. */);
11436 Voverriding_local_map_menu_flag = Qnil;
11438 DEFVAR_LISP ("special-event-map", Vspecial_event_map,
11439 doc: /* Keymap defining bindings for special events to execute at low level. */);
11440 Vspecial_event_map = list1 (Qkeymap);
11442 DEFVAR_LISP ("track-mouse", do_mouse_tracking,
11443 doc: /* Non-nil means generate motion events for mouse motion. */);
11445 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist,
11446 doc: /* Alist of system-specific X windows key symbols.
11447 Each element should have the form (N . SYMBOL) where N is the
11448 numeric keysym code (sans the \"system-specific\" bit 1<<28)
11449 and SYMBOL is its name.
11451 `system-key-alist' has a separate binding for each terminal device.
11452 See Info node `(elisp)Multiple Terminals'. */);
11454 DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map,
11455 doc: /* Keymap that translates key sequences to key sequences during input.
11456 This is used mainly for mapping key sequences into some preferred
11457 key events (symbols).
11459 The `read-key-sequence' function replaces any subsequence bound by
11460 `local-function-key-map' with its binding. More precisely, when the
11461 active keymaps have no binding for the current key sequence but
11462 `local-function-key-map' binds a suffix of the sequence to a vector or
11463 string, `read-key-sequence' replaces the matching suffix with its
11464 binding, and continues with the new sequence.
11466 If the binding is a function, it is called with one argument (the prompt)
11467 and its return value (a key sequence) is used.
11469 The events that come from bindings in `local-function-key-map' are not
11470 themselves looked up in `local-function-key-map'.
11472 For example, suppose `local-function-key-map' binds `ESC O P' to [f1].
11473 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
11474 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix key,
11475 typing `ESC O P x' would return [f1 x].
11477 `local-function-key-map' has a separate binding for each terminal
11478 device. See Info node `(elisp)Multiple Terminals'. If you need to
11479 define a binding on all terminals, change `function-key-map'
11480 instead. Initially, `local-function-key-map' is an empty keymap that
11481 has `function-key-map' as its parent on all terminal devices. */);
11483 DEFVAR_KBOARD ("input-decode-map", Vinput_decode_map,
11484 doc: /* Keymap that decodes input escape sequences.
11485 This is used mainly for mapping ASCII function key sequences into
11486 real Emacs function key events (symbols).
11488 The `read-key-sequence' function replaces any subsequence bound by
11489 `input-decode-map' with its binding. Contrary to `function-key-map',
11490 this map applies its rebinding regardless of the presence of an ordinary
11491 binding. So it is more like `key-translation-map' except that it applies
11492 before `function-key-map' rather than after.
11494 If the binding is a function, it is called with one argument (the prompt)
11495 and its return value (a key sequence) is used.
11497 The events that come from bindings in `input-decode-map' are not
11498 themselves looked up in `input-decode-map'. */);
11500 DEFVAR_LISP ("function-key-map", Vfunction_key_map,
11501 doc: /* The parent keymap of all `local-function-key-map' instances.
11502 Function key definitions that apply to all terminal devices should go
11503 here. If a mapping is defined in both the current
11504 `local-function-key-map' binding and this variable, then the local
11505 definition will take precedence. */);
11506 Vfunction_key_map = Fmake_sparse_keymap (Qnil);
11508 DEFVAR_LISP ("key-translation-map", Vkey_translation_map,
11509 doc: /* Keymap of key translations that can override keymaps.
11510 This keymap works like `input-decode-map', but comes after `function-key-map'.
11511 Another difference is that it is global rather than terminal-local. */);
11512 Vkey_translation_map = Fmake_sparse_keymap (Qnil);
11514 DEFVAR_LISP ("deferred-action-list", Vdeferred_action_list,
11515 doc: /* List of deferred actions to be performed at a later time.
11516 The precise format isn't relevant here; we just check whether it is nil. */);
11517 Vdeferred_action_list = Qnil;
11519 DEFVAR_LISP ("deferred-action-function", Vdeferred_action_function,
11520 doc: /* Function to call to handle deferred actions, after each command.
11521 This function is called with no arguments after each command
11522 whenever `deferred-action-list' is non-nil. */);
11523 Vdeferred_action_function = Qnil;
11525 DEFVAR_LISP ("delayed-warnings-list", Vdelayed_warnings_list,
11526 doc: /* List of warnings to be displayed after this command.
11527 Each element must be a list (TYPE MESSAGE [LEVEL [BUFFER-NAME]]),
11528 as per the args of `display-warning' (which see).
11529 If this variable is non-nil, `delayed-warnings-hook' will be run
11530 immediately after running `post-command-hook'. */);
11531 Vdelayed_warnings_list = Qnil;
11533 DEFVAR_LISP ("timer-list", Vtimer_list,
11534 doc: /* List of active absolute time timers in order of increasing time. */);
11535 Vtimer_list = Qnil;
11537 DEFVAR_LISP ("timer-idle-list", Vtimer_idle_list,
11538 doc: /* List of active idle-time timers in order of increasing time. */);
11539 Vtimer_idle_list = Qnil;
11541 DEFVAR_LISP ("input-method-function", Vinput_method_function,
11542 doc: /* If non-nil, the function that implements the current input method.
11543 It's called with one argument, a printing character that was just read.
11544 (That means a character with code 040...0176.)
11545 Typically this function uses `read-event' to read additional events.
11546 When it does so, it should first bind `input-method-function' to nil
11547 so it will not be called recursively.
11549 The function should return a list of zero or more events
11550 to be used as input. If it wants to put back some events
11551 to be reconsidered, separately, by the input method,
11552 it can add them to the beginning of `unread-command-events'.
11554 The input method function can find in `input-method-previous-message'
11555 the previous echo area message.
11557 The input method function should refer to the variables
11558 `input-method-use-echo-area' and `input-method-exit-on-first-char'
11559 for guidance on what to do. */);
11560 Vinput_method_function = Qlist;
11562 DEFVAR_LISP ("input-method-previous-message",
11563 Vinput_method_previous_message,
11564 doc: /* When `input-method-function' is called, hold the previous echo area message.
11565 This variable exists because `read-event' clears the echo area
11566 before running the input method. It is nil if there was no message. */);
11567 Vinput_method_previous_message = Qnil;
11569 DEFVAR_LISP ("show-help-function", Vshow_help_function,
11570 doc: /* If non-nil, the function that implements the display of help.
11571 It's called with one argument, the help string to display. */);
11572 Vshow_help_function = Qnil;
11574 DEFVAR_LISP ("disable-point-adjustment", Vdisable_point_adjustment,
11575 doc: /* If non-nil, suppress point adjustment after executing a command.
11577 After a command is executed, if point is moved into a region that has
11578 special properties (e.g. composition, display), we adjust point to
11579 the boundary of the region. But, when a command sets this variable to
11580 non-nil, we suppress the point adjustment.
11582 This variable is set to nil before reading a command, and is checked
11583 just after executing the command. */);
11584 Vdisable_point_adjustment = Qnil;
11586 DEFVAR_LISP ("global-disable-point-adjustment",
11587 Vglobal_disable_point_adjustment,
11588 doc: /* If non-nil, always suppress point adjustment.
11590 The default value is nil, in which case, point adjustment are
11591 suppressed only after special commands that set
11592 `disable-point-adjustment' (which see) to non-nil. */);
11593 Vglobal_disable_point_adjustment = Qnil;
11595 DEFVAR_LISP ("minibuffer-message-timeout", Vminibuffer_message_timeout,
11596 doc: /* How long to display an echo-area message when the minibuffer is active.
11597 If the value is not a number, such messages don't time out. */);
11598 Vminibuffer_message_timeout = make_number (2);
11600 DEFVAR_LISP ("throw-on-input", Vthrow_on_input,
11601 doc: /* If non-nil, any keyboard input throws to this symbol.
11602 The value of that variable is passed to `quit-flag' and later causes a
11603 peculiar kind of quitting. */);
11604 Vthrow_on_input = Qnil;
11606 DEFVAR_LISP ("command-error-function", Vcommand_error_function,
11607 doc: /* Function to output error messages.
11608 Called with three arguments:
11609 - the error data, a list of the form (SIGNALED-CONDITION . SIGNAL-DATA)
11610 such as what `condition-case' would bind its variable to,
11611 - the context (a string which normally goes at the start of the message),
11612 - the Lisp function within which the error was signaled. */);
11613 Vcommand_error_function = intern ("command-error-default-function");
11615 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
11616 Venable_disabled_menus_and_buttons,
11617 doc: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
11619 Help functions bind this to allow help on disabled menu items
11620 and tool-bar buttons. */);
11621 Venable_disabled_menus_and_buttons = Qnil;
11623 DEFVAR_LISP ("select-active-regions",
11624 Vselect_active_regions,
11625 doc: /* If non-nil, an active region automatically sets the primary selection.
11626 If the value is `only', only temporarily active regions (usually made
11627 by mouse-dragging or shift-selection) set the window selection.
11629 This takes effect only when Transient Mark mode is enabled. */);
11630 Vselect_active_regions = Qt;
11632 DEFVAR_LISP ("saved-region-selection",
11633 Vsaved_region_selection,
11634 doc: /* Contents of active region prior to buffer modification.
11635 If `select-active-regions' is non-nil, Emacs sets this to the
11636 text in the region before modifying the buffer. The next call to
11637 the function `deactivate-mark' uses this to set the window selection. */);
11638 Vsaved_region_selection = Qnil;
11640 DEFVAR_LISP ("selection-inhibit-update-commands",
11641 Vselection_inhibit_update_commands,
11642 doc: /* List of commands which should not update the selection.
11643 Normally, if `select-active-regions' is non-nil and the mark remains
11644 active after a command (i.e. the mark was not deactivated), the Emacs
11645 command loop sets the selection to the text in the region. However,
11646 if the command is in this list, the selection is not updated. */);
11647 Vselection_inhibit_update_commands
11648 = list2 (Qhandle_switch_frame, Qhandle_select_window);
11650 DEFVAR_LISP ("debug-on-event",
11651 Vdebug_on_event,
11652 doc: /* Enter debugger on this event. When Emacs
11653 receives the special event specified by this variable, it will try to
11654 break into the debugger as soon as possible instead of processing the
11655 event normally through `special-event-map'.
11657 Currently, the only supported values for this
11658 variable are `sigusr1' and `sigusr2'. */);
11659 Vdebug_on_event = intern_c_string ("sigusr2");
11661 /* Create the initial keyboard. Qt means 'unset'. */
11662 initial_kboard = allocate_kboard (Qt);
11665 void
11666 keys_of_keyboard (void)
11668 initial_define_key (global_map, Ctl ('Z'), "suspend-emacs");
11669 initial_define_key (control_x_map, Ctl ('Z'), "suspend-emacs");
11670 initial_define_key (meta_map, Ctl ('C'), "exit-recursive-edit");
11671 initial_define_key (global_map, Ctl (']'), "abort-recursive-edit");
11672 initial_define_key (meta_map, 'x', "execute-extended-command");
11674 initial_define_lispy_key (Vspecial_event_map, "delete-frame",
11675 "handle-delete-frame");
11676 initial_define_lispy_key (Vspecial_event_map, "ns-put-working-text",
11677 "ns-put-working-text");
11678 initial_define_lispy_key (Vspecial_event_map, "ns-unput-working-text",
11679 "ns-unput-working-text");
11680 /* Here we used to use `ignore-event' which would simple set prefix-arg to
11681 current-prefix-arg, as is done in `handle-switch-frame'.
11682 But `handle-switch-frame is not run from the special-map.
11683 Commands from that map are run in a special way that automatically
11684 preserves the prefix-arg. Restoring the prefix arg here is not just
11685 redundant but harmful:
11686 - C-u C-x v =
11687 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
11688 - after the first prompt, the exit-minibuffer-hook is run which may
11689 iconify a frame and thus push a `iconify-frame' event.
11690 - after running exit-minibuffer-hook, current-prefix-arg is
11691 restored to the non-nil value it had before the prompt.
11692 - we enter the second prompt.
11693 current-prefix-arg is non-nil, prefix-arg is nil.
11694 - before running the first real event, we run the special iconify-frame
11695 event, but we pass the `special' arg to command-execute so
11696 current-prefix-arg and prefix-arg are left untouched.
11697 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
11698 - the next key event will have a spuriously non-nil current-prefix-arg. */
11699 initial_define_lispy_key (Vspecial_event_map, "iconify-frame",
11700 "ignore");
11701 initial_define_lispy_key (Vspecial_event_map, "make-frame-visible",
11702 "ignore");
11703 /* Handling it at such a low-level causes read_key_sequence to get
11704 * confused because it doesn't realize that the current_buffer was
11705 * changed by read_char.
11707 * initial_define_lispy_key (Vspecial_event_map, "select-window",
11708 * "handle-select-window"); */
11709 initial_define_lispy_key (Vspecial_event_map, "save-session",
11710 "handle-save-session");
11712 #ifdef HAVE_DBUS
11713 /* Define a special event which is raised for dbus callback
11714 functions. */
11715 initial_define_lispy_key (Vspecial_event_map, "dbus-event",
11716 "dbus-handle-event");
11717 #endif
11719 #ifdef USE_FILE_NOTIFY
11720 /* Define a special event which is raised for notification callback
11721 functions. */
11722 initial_define_lispy_key (Vspecial_event_map, "file-notify",
11723 "file-notify-handle-event");
11724 #endif /* USE_FILE_NOTIFY */
11726 initial_define_lispy_key (Vspecial_event_map, "config-changed-event",
11727 "ignore");
11728 #if defined (WINDOWSNT)
11729 initial_define_lispy_key (Vspecial_event_map, "language-change",
11730 "ignore");
11731 #endif
11732 initial_define_lispy_key (Vspecial_event_map, "focus-in",
11733 "handle-focus-in");
11734 initial_define_lispy_key (Vspecial_event_map, "focus-out",
11735 "handle-focus-out");
11738 /* Mark the pointers in the kboard objects.
11739 Called by Fgarbage_collect. */
11740 void
11741 mark_kboards (void)
11743 KBOARD *kb;
11744 Lisp_Object *p;
11745 for (kb = all_kboards; kb; kb = kb->next_kboard)
11747 if (kb->kbd_macro_buffer)
11748 for (p = kb->kbd_macro_buffer; p < kb->kbd_macro_ptr; p++)
11749 mark_object (*p);
11750 mark_object (KVAR (kb, Voverriding_terminal_local_map));
11751 mark_object (KVAR (kb, Vlast_command));
11752 mark_object (KVAR (kb, Vreal_last_command));
11753 mark_object (KVAR (kb, Vkeyboard_translate_table));
11754 mark_object (KVAR (kb, Vlast_repeatable_command));
11755 mark_object (KVAR (kb, Vprefix_arg));
11756 mark_object (KVAR (kb, Vlast_prefix_arg));
11757 mark_object (KVAR (kb, kbd_queue));
11758 mark_object (KVAR (kb, defining_kbd_macro));
11759 mark_object (KVAR (kb, Vlast_kbd_macro));
11760 mark_object (KVAR (kb, Vsystem_key_alist));
11761 mark_object (KVAR (kb, system_key_syms));
11762 mark_object (KVAR (kb, Vwindow_system));
11763 mark_object (KVAR (kb, Vinput_decode_map));
11764 mark_object (KVAR (kb, Vlocal_function_key_map));
11765 mark_object (KVAR (kb, Vdefault_minibuffer_frame));
11766 mark_object (KVAR (kb, echo_string));
11767 mark_object (KVAR (kb, echo_prompt));
11770 union buffered_input_event *event;
11771 for (event = kbd_fetch_ptr; event != kbd_store_ptr; event++)
11773 if (event == kbd_buffer + KBD_BUFFER_SIZE)
11774 event = kbd_buffer;
11775 /* These two special event types has no Lisp_Objects to mark. */
11776 if (event->kind != SELECTION_REQUEST_EVENT
11777 && event->kind != SELECTION_CLEAR_EVENT)
11779 mark_object (event->ie.x);
11780 mark_object (event->ie.y);
11781 mark_object (event->ie.frame_or_window);
11782 mark_object (event->ie.arg);