1 /* Keyboard and mouse input; editor command loop.
3 Copyright (C) 1985-1989, 1993-1997, 1999-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
28 #include "termhooks.h"
33 #include "character.h"
36 #include "dispextern.h"
38 #include "intervals.h"
40 #include "blockinput.h"
54 #include <sys/ioctl.h>
55 #endif /* not MSDOS */
57 #include "syssignal.h"
59 #include <sys/types.h>
63 /* This is to get the definitions of the XK_ symbols. */
70 #endif /* HAVE_NTGUI */
76 /* Variables for blockinput.h: */
78 /* Non-zero if interrupt input is blocked right now. */
79 volatile int interrupt_input_blocked
;
81 /* Nonzero means an input interrupt has arrived
82 during the current critical section. */
83 int interrupt_input_pending
;
85 /* This var should be (interrupt_input_pending || pending_atimers).
86 The QUIT macro checks this instead of interrupt_input_pending and
87 pending_atimers separately, to reduce code size. So, any code that
88 changes interrupt_input_pending or pending_atimers should update
94 #define KBD_BUFFER_SIZE 4096
96 KBOARD
*initial_kboard
;
97 KBOARD
*current_kboard
;
100 /* Nonzero in the single-kboard state, 0 in the any-kboard state. */
101 static int single_kboard
;
103 /* Non-nil disable property on a command means
104 do not execute it; call disabled-command-function's value instead. */
105 Lisp_Object Qdisabled
;
106 static Lisp_Object Qdisabled_command_function
;
108 #define NUM_RECENT_KEYS (300)
110 /* Index for storing next element into recent_keys. */
111 static int recent_keys_index
;
113 /* Total number of elements stored into recent_keys. */
114 static int total_keys
;
116 /* This vector holds the last NUM_RECENT_KEYS keystrokes. */
117 static Lisp_Object recent_keys
;
119 /* Vector holding the key sequence that invoked the current command.
120 It is reused for each command, and it may be longer than the current
121 sequence; this_command_key_count indicates how many elements
122 actually mean something.
123 It's easier to staticpro a single Lisp_Object than an array. */
124 Lisp_Object this_command_keys
;
125 ptrdiff_t this_command_key_count
;
127 /* 1 after calling Freset_this_command_lengths.
129 static int this_command_key_count_reset
;
131 /* This vector is used as a buffer to record the events that were actually read
132 by read_key_sequence. */
133 static Lisp_Object raw_keybuf
;
134 static int raw_keybuf_count
;
136 #define GROW_RAW_KEYBUF \
137 if (raw_keybuf_count == ASIZE (raw_keybuf)) \
138 raw_keybuf = larger_vector (raw_keybuf, 1, -1)
140 /* Number of elements of this_command_keys
141 that precede this key sequence. */
142 static ptrdiff_t this_single_command_key_start
;
144 /* Record values of this_command_key_count and echo_length ()
145 before this command was read. */
146 static ptrdiff_t before_command_key_count
;
147 static ptrdiff_t before_command_echo_length
;
149 /* For longjmp to where kbd input is being done. */
151 static jmp_buf getcjmp
;
153 /* True while doing kbd input. */
154 int waiting_for_input
;
156 /* True while displaying for echoing. Delays C-g throwing. */
160 /* Non-null means we can start echoing at the next input pause even
161 though there is something in the echo area. */
163 static struct kboard
*ok_to_echo_at_next_pause
;
165 /* The kboard last echoing, or null for none. Reset to 0 in
166 cancel_echoing. If non-null, and a current echo area message
167 exists, and echo_message_buffer is eq to the current message
168 buffer, we know that the message comes from echo_kboard. */
170 struct kboard
*echo_kboard
;
172 /* The buffer used for echoing. Set in echo_now, reset in
175 Lisp_Object echo_message_buffer
;
177 /* Nonzero means C-g should cause immediate error-signal. */
180 /* Character that causes a quit. Normally C-g.
182 If we are running on an ordinary terminal, this must be an ordinary
183 ASCII char, since we want to make it our interrupt character.
185 If we are not running on an ordinary terminal, it still needs to be
186 an ordinary ASCII char. This character needs to be recognized in
187 the input interrupt handler. At this point, the keystroke is
188 represented as a struct input_event, while the desired quit
189 character is specified as a lispy event. The mapping from struct
190 input_events to lispy events cannot run in an interrupt handler,
191 and the reverse mapping is difficult for anything but ASCII
194 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
198 /* Current depth in recursive edits. */
199 EMACS_INT command_loop_level
;
201 /* If not Qnil, this is a switch-frame event which we decided to put
202 off until the end of a key sequence. This should be read as the
203 next command input, after any unread_command_events.
205 read_key_sequence uses this to delay switch-frame events until the
206 end of the key sequence; Fread_char uses it to put off switch-frame
207 events until a non-ASCII event is acceptable as input. */
208 Lisp_Object unread_switch_frame
;
210 /* Last size recorded for a current buffer which is not a minibuffer. */
211 static ptrdiff_t last_non_minibuf_size
;
213 /* Total number of times read_char has returned, modulo UINTMAX_MAX + 1. */
214 uintmax_t num_input_events
;
216 /* Value of num_nonmacro_input_events as of last auto save. */
218 static EMACS_INT last_auto_save
;
220 /* The value of point when the last command was started. */
221 static ptrdiff_t last_point_position
;
223 /* The buffer that was current when the last command was started. */
224 static Lisp_Object last_point_position_buffer
;
226 /* The window that was selected when the last command was started. */
227 static Lisp_Object last_point_position_window
;
229 /* The frame in which the last input event occurred, or Qmacro if the
230 last event came from a macro. We use this to determine when to
231 generate switch-frame events. This may be cleared by functions
232 like Fselect_frame, to make sure that a switch-frame event is
233 generated by the next character. */
234 Lisp_Object internal_last_event_frame
;
236 /* The timestamp of the last input event we received from the X server.
237 X Windows wants this for selection ownership. */
238 Time last_event_timestamp
;
240 static Lisp_Object Qx_set_selection
, Qhandle_switch_frame
;
241 static Lisp_Object Qhandle_select_window
;
242 Lisp_Object QPRIMARY
;
244 static Lisp_Object Qself_insert_command
;
245 static Lisp_Object Qforward_char
;
246 static Lisp_Object Qbackward_char
;
247 Lisp_Object Qundefined
;
248 static Lisp_Object Qtimer_event_handler
;
250 /* read_key_sequence stores here the command definition of the
251 key sequence that it reads. */
252 static Lisp_Object read_key_sequence_cmd
;
253 static Lisp_Object read_key_sequence_remapped
;
255 static Lisp_Object Qinput_method_function
;
257 static Lisp_Object Qdeactivate_mark
;
259 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
261 static Lisp_Object Qecho_area_clear_hook
;
263 /* Hooks to run before and after each command. */
264 static Lisp_Object Qpre_command_hook
;
265 static Lisp_Object Qpost_command_hook
;
267 static Lisp_Object Qdeferred_action_function
;
269 static Lisp_Object Qdelayed_warnings_hook
;
271 static Lisp_Object Qinput_method_exit_on_first_char
;
272 static Lisp_Object Qinput_method_use_echo_area
;
274 static Lisp_Object Qhelp_form_show
;
276 /* File in which we write all commands we read. */
277 static FILE *dribble
;
279 /* Nonzero if input is available. */
282 /* Circular buffer for pre-read keyboard input. */
284 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
286 /* Pointer to next available character in kbd_buffer.
287 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
288 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
289 next available char is in kbd_buffer[0]. */
290 static struct input_event
*kbd_fetch_ptr
;
292 /* Pointer to next place to store character in kbd_buffer. This
293 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
294 character should go in kbd_buffer[0]. */
295 static struct input_event
* volatile kbd_store_ptr
;
297 /* The above pair of variables forms a "queue empty" flag. When we
298 enqueue a non-hook event, we increment kbd_store_ptr. When we
299 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
300 there is input available if the two pointers are not equal.
302 Why not just have a flag set and cleared by the enqueuing and
303 dequeuing functions? Such a flag could be screwed up by interrupts
304 at inopportune times. */
306 /* Symbols to head events. */
307 static Lisp_Object Qmouse_movement
;
308 static Lisp_Object Qscroll_bar_movement
;
309 Lisp_Object Qswitch_frame
;
310 static Lisp_Object Qdelete_frame
;
311 static Lisp_Object Qiconify_frame
;
312 static Lisp_Object Qmake_frame_visible
;
313 static Lisp_Object Qselect_window
;
314 Lisp_Object Qhelp_echo
;
316 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
317 static Lisp_Object Qmouse_fixup_help_message
;
320 /* Symbols to denote kinds of events. */
321 static Lisp_Object Qfunction_key
;
322 Lisp_Object Qmouse_click
;
323 #if defined (WINDOWSNT)
324 Lisp_Object Qlanguage_change
;
326 static Lisp_Object Qdrag_n_drop
;
327 static Lisp_Object Qsave_session
;
329 static Lisp_Object Qdbus_event
;
331 static Lisp_Object Qconfig_changed_event
;
333 /* Lisp_Object Qmouse_movement; - also an event header */
335 /* Properties of event headers. */
336 Lisp_Object Qevent_kind
;
337 static Lisp_Object Qevent_symbol_elements
;
339 /* Menu and tool bar item parts. */
340 static Lisp_Object Qmenu_enable
;
341 static Lisp_Object QCenable
, QCvisible
, QChelp
, QCkeys
, QCkey_sequence
;
342 Lisp_Object QCfilter
;
344 /* Non-nil disable property on a command means
345 do not execute it; call disabled-command-function's value instead. */
346 Lisp_Object QCtoggle
, QCradio
;
347 static Lisp_Object QCbutton
, QClabel
;
349 static Lisp_Object QCvert_only
;
351 /* An event header symbol HEAD may have a property named
352 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
353 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
354 mask of modifiers applied to it. If present, this is used to help
355 speed up parse_modifiers. */
356 Lisp_Object Qevent_symbol_element_mask
;
358 /* An unmodified event header BASE may have a property named
359 Qmodifier_cache, which is an alist mapping modifier masks onto
360 modified versions of BASE. If present, this helps speed up
362 static Lisp_Object Qmodifier_cache
;
364 /* Symbols to use for parts of windows. */
365 Lisp_Object Qmode_line
;
366 Lisp_Object Qvertical_line
;
367 static Lisp_Object Qvertical_scroll_bar
;
368 Lisp_Object Qmenu_bar
;
370 static Lisp_Object
recursive_edit_unwind (Lisp_Object buffer
);
371 static Lisp_Object
command_loop (void);
372 static Lisp_Object Qextended_command_history
;
373 EMACS_TIME
timer_check (void);
375 static void record_menu_key (Lisp_Object c
);
376 static void echo_now (void);
377 static ptrdiff_t echo_length (void);
379 static Lisp_Object Qpolling_period
;
381 /* Incremented whenever a timer is run. */
384 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
386 EMACS_TIME
*input_available_clear_time
;
388 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
389 Default is 1 if INTERRUPT_INPUT is defined. */
392 /* Nonzero while interrupts are temporarily deferred during redisplay. */
393 int interrupts_deferred
;
395 /* Allow m- file to inhibit use of FIONREAD. */
396 #ifdef BROKEN_FIONREAD
400 /* We are unable to use interrupts if FIONREAD is not available,
401 so flush SIGIO so we won't try. */
402 #if !defined (FIONREAD)
408 /* If we support a window system, turn on the code to poll periodically
409 to detect C-g. It isn't actually used when doing interrupt input. */
410 #if defined (HAVE_WINDOW_SYSTEM) && !defined (USE_ASYNC_EVENTS)
411 #define POLL_FOR_INPUT
414 /* The time when Emacs started being idle. */
416 static EMACS_TIME timer_idleness_start_time
;
418 /* After Emacs stops being idle, this saves the last value
419 of timer_idleness_start_time from when it was idle. */
421 static EMACS_TIME timer_last_idleness_start_time
;
424 /* Global variable declarations. */
426 /* Flags for readable_events. */
427 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
428 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
429 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
431 /* Function for init_keyboard to call with no args (if nonzero). */
432 static void (*keyboard_init_hook
) (void);
434 static int read_avail_input (int);
435 static void get_input_pending (int *, int);
436 static int readable_events (int);
437 static Lisp_Object
read_char_x_menu_prompt (ptrdiff_t, Lisp_Object
*,
439 static Lisp_Object
read_char_minibuf_menu_prompt (int, ptrdiff_t,
441 static Lisp_Object
make_lispy_event (struct input_event
*);
442 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
443 static Lisp_Object
make_lispy_movement (struct frame
*, Lisp_Object
,
444 enum scroll_bar_part
,
445 Lisp_Object
, Lisp_Object
,
448 static Lisp_Object
modify_event_symbol (ptrdiff_t, int, Lisp_Object
,
449 Lisp_Object
, const char *const *,
450 Lisp_Object
*, ptrdiff_t);
451 static Lisp_Object
make_lispy_switch_frame (Lisp_Object
);
452 static int help_char_p (Lisp_Object
);
453 static void save_getcjmp (jmp_buf);
454 static void restore_getcjmp (jmp_buf);
455 static Lisp_Object
apply_modifiers (int, Lisp_Object
);
456 static void clear_event (struct input_event
*);
457 static Lisp_Object
restore_kboard_configuration (Lisp_Object
);
458 static void interrupt_signal (int signalnum
);
460 static void input_available_signal (int signo
);
462 static void handle_interrupt (void);
463 static _Noreturn
void quit_throw_to_read_char (int);
464 static void process_special_events (void);
465 static void timer_start_idle (void);
466 static void timer_stop_idle (void);
467 static void timer_resume_idle (void);
468 static void handle_user_signal (int);
469 static char *find_user_signal_name (int);
470 static int store_user_signal_events (void);
473 /* Add C to the echo string, if echoing is going on.
474 C can be a character, which is printed prettily ("M-C-x" and all that
475 jazz), or a symbol, whose name is printed. */
478 echo_char (Lisp_Object c
)
480 if (current_kboard
->immediate_echo
)
482 int size
= KEY_DESCRIPTION_SIZE
+ 100;
483 char *buffer
= alloca (size
);
485 Lisp_Object echo_string
;
487 echo_string
= KVAR (current_kboard
, echo_string
);
489 /* If someone has passed us a composite event, use its head symbol. */
494 ptr
= push_key_description (XINT (c
), ptr
, 1);
496 else if (SYMBOLP (c
))
498 Lisp_Object name
= SYMBOL_NAME (c
);
499 int nbytes
= SBYTES (name
);
501 if (size
- (ptr
- buffer
) < nbytes
)
503 int offset
= ptr
- buffer
;
504 size
= max (2 * size
, size
+ nbytes
);
505 buffer
= alloca (size
);
506 ptr
= buffer
+ offset
;
509 ptr
+= copy_text (SDATA (name
), (unsigned char *) ptr
, nbytes
,
510 STRING_MULTIBYTE (name
), 1);
513 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
516 const char *text
= " (Type ? for further options)";
517 int len
= strlen (text
);
519 if (size
- (ptr
- buffer
) < len
)
521 int offset
= ptr
- buffer
;
523 buffer
= alloca (size
);
524 ptr
= buffer
+ offset
;
527 memcpy (ptr
, text
, len
);
531 /* Replace a dash from echo_dash with a space, otherwise
532 add a space at the end as a separator between keys. */
533 if (STRINGP (echo_string
)
534 && SCHARS (echo_string
) > 1)
536 Lisp_Object last_char
, prev_char
, idx
;
538 idx
= make_number (SCHARS (echo_string
) - 2);
539 prev_char
= Faref (echo_string
, idx
);
541 idx
= make_number (SCHARS (echo_string
) - 1);
542 last_char
= Faref (echo_string
, idx
);
544 /* We test PREV_CHAR to make sure this isn't the echoing
546 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
547 Faset (echo_string
, idx
, make_number (' '));
549 echo_string
= concat2 (echo_string
, build_string (" "));
551 else if (STRINGP (echo_string
))
552 echo_string
= concat2 (echo_string
, build_string (" "));
554 KVAR (current_kboard
, echo_string
)
555 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
561 /* Temporarily add a dash to the end of the echo string if it's not
562 empty, so that it serves as a mini-prompt for the very next character. */
567 /* Do nothing if not echoing at all. */
568 if (NILP (KVAR (current_kboard
, echo_string
)))
571 if (this_command_key_count
== 0)
574 if (!current_kboard
->immediate_echo
575 && SCHARS (KVAR (current_kboard
, echo_string
)) == 0)
578 /* Do nothing if we just printed a prompt. */
579 if (current_kboard
->echo_after_prompt
580 == SCHARS (KVAR (current_kboard
, echo_string
)))
583 /* Do nothing if we have already put a dash at the end. */
584 if (SCHARS (KVAR (current_kboard
, echo_string
)) > 1)
586 Lisp_Object last_char
, prev_char
, idx
;
588 idx
= make_number (SCHARS (KVAR (current_kboard
, echo_string
)) - 2);
589 prev_char
= Faref (KVAR (current_kboard
, echo_string
), idx
);
591 idx
= make_number (SCHARS (KVAR (current_kboard
, echo_string
)) - 1);
592 last_char
= Faref (KVAR (current_kboard
, echo_string
), idx
);
594 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
598 /* Put a dash at the end of the buffer temporarily,
599 but make it go away when the next character is added. */
600 KVAR (current_kboard
, echo_string
) = concat2 (KVAR (current_kboard
, echo_string
),
605 /* Display the current echo string, and begin echoing if not already
611 if (!current_kboard
->immediate_echo
)
614 current_kboard
->immediate_echo
= 1;
616 for (i
= 0; i
< this_command_key_count
; i
++)
620 /* Set before_command_echo_length to the value that would
621 have been saved before the start of this subcommand in
622 command_loop_1, if we had already been echoing then. */
623 if (i
== this_single_command_key_start
)
624 before_command_echo_length
= echo_length ();
626 c
= AREF (this_command_keys
, i
);
627 if (! (EVENT_HAS_PARAMETERS (c
)
628 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
632 /* Set before_command_echo_length to the value that would
633 have been saved before the start of this subcommand in
634 command_loop_1, if we had already been echoing then. */
635 if (this_command_key_count
== this_single_command_key_start
)
636 before_command_echo_length
= echo_length ();
638 /* Put a dash at the end to invite the user to type more. */
643 message3_nolog (KVAR (current_kboard
, echo_string
),
644 SBYTES (KVAR (current_kboard
, echo_string
)),
645 STRING_MULTIBYTE (KVAR (current_kboard
, echo_string
)));
648 /* Record in what buffer we echoed, and from which kboard. */
649 echo_message_buffer
= echo_area_buffer
[0];
650 echo_kboard
= current_kboard
;
652 if (waiting_for_input
&& !NILP (Vquit_flag
))
653 quit_throw_to_read_char (0);
656 /* Turn off echoing, for the start of a new command. */
659 cancel_echoing (void)
661 current_kboard
->immediate_echo
= 0;
662 current_kboard
->echo_after_prompt
= -1;
663 KVAR (current_kboard
, echo_string
) = Qnil
;
664 ok_to_echo_at_next_pause
= NULL
;
666 echo_message_buffer
= Qnil
;
669 /* Return the length of the current echo string. */
674 return (STRINGP (KVAR (current_kboard
, echo_string
))
675 ? SCHARS (KVAR (current_kboard
, echo_string
))
679 /* Truncate the current echo message to its first LEN chars.
680 This and echo_char get used by read_key_sequence when the user
681 switches frames while entering a key sequence. */
684 echo_truncate (ptrdiff_t nchars
)
686 if (STRINGP (KVAR (current_kboard
, echo_string
)))
687 KVAR (current_kboard
, echo_string
)
688 = Fsubstring (KVAR (current_kboard
, echo_string
),
689 make_number (0), make_number (nchars
));
690 truncate_echo_area (nchars
);
694 /* Functions for manipulating this_command_keys. */
696 add_command_key (Lisp_Object key
)
698 #if 0 /* Not needed after we made Freset_this_command_lengths
699 do the job immediately. */
700 /* If reset-this-command-length was called recently, obey it now.
701 See the doc string of that function for an explanation of why. */
702 if (before_command_restore_flag
)
704 this_command_key_count
= before_command_key_count_1
;
705 if (this_command_key_count
< this_single_command_key_start
)
706 this_single_command_key_start
= this_command_key_count
;
707 echo_truncate (before_command_echo_length_1
);
708 before_command_restore_flag
= 0;
712 if (this_command_key_count
>= ASIZE (this_command_keys
))
713 this_command_keys
= larger_vector (this_command_keys
, 1, -1);
715 ASET (this_command_keys
, this_command_key_count
, key
);
716 ++this_command_key_count
;
721 recursive_edit_1 (void)
723 ptrdiff_t count
= SPECPDL_INDEX ();
726 if (command_loop_level
> 0)
728 specbind (Qstandard_output
, Qt
);
729 specbind (Qstandard_input
, Qt
);
732 #ifdef HAVE_WINDOW_SYSTEM
733 /* The command loop has started an hourglass timer, so we have to
734 cancel it here, otherwise it will fire because the recursive edit
735 can take some time. Do not check for display_hourglass_p here,
736 because it could already be nil. */
740 /* This function may have been called from a debugger called from
741 within redisplay, for instance by Edebugging a function called
742 from fontification-functions. We want to allow redisplay in
743 the debugging session.
745 The recursive edit is left with a `(throw exit ...)'. The `exit'
746 tag is not caught anywhere in redisplay, i.e. when we leave the
747 recursive edit, the original redisplay leading to the recursive
748 edit will be unwound. The outcome should therefore be safe. */
749 specbind (Qinhibit_redisplay
, Qnil
);
752 val
= command_loop ();
754 Fsignal (Qquit
, Qnil
);
755 /* Handle throw from read_minibuf when using minibuffer
756 while it's active but we're in another window. */
758 xsignal1 (Qerror
, val
);
760 return unbind_to (count
, Qnil
);
763 /* When an auto-save happens, record the "time", and don't do again soon. */
766 record_auto_save (void)
768 last_auto_save
= num_nonmacro_input_events
;
771 /* Make an auto save happen as soon as possible at command level. */
775 force_auto_save_soon (void)
777 last_auto_save
= - auto_save_interval
- 1;
779 record_asynch_buffer_change ();
783 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
784 doc
: /* Invoke the editor command loop recursively.
785 To get out of the recursive edit, a command can do `(throw 'exit nil)';
786 that tells this function to return.
787 Alternatively, `(throw 'exit t)' makes this function signal an error.
788 This function is called by the editor initialization to begin editing. */)
791 ptrdiff_t count
= SPECPDL_INDEX ();
794 /* If we enter while input is blocked, don't lock up here.
795 This may happen through the debugger during redisplay. */
799 command_loop_level
++;
800 update_mode_lines
= 1;
802 if (command_loop_level
803 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
804 buffer
= Fcurrent_buffer ();
808 /* If we leave recursive_edit_1 below with a `throw' for instance,
809 like it is done in the splash screen display, we have to
810 make sure that we restore single_kboard as command_loop_1
811 would have done if it were left normally. */
812 if (command_loop_level
> 0)
813 temporarily_switch_to_single_kboard (SELECTED_FRAME ());
814 record_unwind_protect (recursive_edit_unwind
, buffer
);
817 return unbind_to (count
, Qnil
);
821 recursive_edit_unwind (Lisp_Object buffer
)
823 if (BUFFERP (buffer
))
824 Fset_buffer (buffer
);
826 command_loop_level
--;
827 update_mode_lines
= 1;
832 #if 0 /* These two functions are now replaced with
833 temporarily_switch_to_single_kboard. */
837 #if 0 /* Theory: if there's anything in Vunread_command_events,
838 it will right away be read by read_key_sequence,
839 and then if we do switch KBOARDS, it will go into the side
840 queue then. So we don't need to do anything special here -- rms. */
841 if (CONSP (Vunread_command_events
))
843 current_kboard
->kbd_queue
844 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
845 current_kboard
->kbd_queue_has_data
= 1;
847 Vunread_command_events
= Qnil
;
852 /* Switch to the single-kboard state, making current_kboard
853 the only KBOARD from which further input is accepted. */
856 single_kboard_state ()
862 /* If we're in single_kboard state for kboard KBOARD,
866 not_single_kboard_state (KBOARD
*kboard
)
868 if (kboard
== current_kboard
)
872 /* Maintain a stack of kboards, so other parts of Emacs
873 can switch temporarily to the kboard of a given frame
874 and then revert to the previous status. */
879 struct kboard_stack
*next
;
882 static struct kboard_stack
*kboard_stack
;
885 push_kboard (struct kboard
*k
)
887 struct kboard_stack
*p
= xmalloc (sizeof *p
);
889 p
->next
= kboard_stack
;
890 p
->kboard
= current_kboard
;
900 struct kboard_stack
*p
= kboard_stack
;
902 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
904 if (t
->kboard
== p
->kboard
)
906 current_kboard
= p
->kboard
;
913 /* The terminal we remembered has been deleted. */
914 current_kboard
= FRAME_KBOARD (SELECTED_FRAME ());
917 kboard_stack
= p
->next
;
921 /* Switch to single_kboard mode, making current_kboard the only KBOARD
922 from which further input is accepted. If F is non-nil, set its
923 KBOARD as the current keyboard.
925 This function uses record_unwind_protect to return to the previous
928 If Emacs is already in single_kboard mode, and F's keyboard is
929 locked, then this function will throw an error. */
932 temporarily_switch_to_single_kboard (struct frame
*f
)
934 int was_locked
= single_kboard
;
937 if (f
!= NULL
&& FRAME_KBOARD (f
) != current_kboard
)
938 /* We can not switch keyboards while in single_kboard mode.
939 In rare cases, Lisp code may call `recursive-edit' (or
940 `read-minibuffer' or `y-or-n-p') after it switched to a
941 locked frame. For example, this is likely to happen
942 when server.el connects to a new terminal while Emacs is in
943 single_kboard mode. It is best to throw an error instead
944 of presenting the user with a frozen screen. */
945 error ("Terminal %d is locked, cannot read from it",
946 FRAME_TERMINAL (f
)->id
);
948 /* This call is unnecessary, but helps
949 `restore_kboard_configuration' discover if somebody changed
950 `current_kboard' behind our back. */
951 push_kboard (current_kboard
);
954 current_kboard
= FRAME_KBOARD (f
);
956 record_unwind_protect (restore_kboard_configuration
,
957 (was_locked
? Qt
: Qnil
));
960 #if 0 /* This function is not needed anymore. */
962 record_single_kboard_state ()
965 push_kboard (current_kboard
);
966 record_unwind_protect (restore_kboard_configuration
,
967 (single_kboard
? Qt
: Qnil
));
972 restore_kboard_configuration (Lisp_Object was_locked
)
974 if (NILP (was_locked
))
978 struct kboard
*prev
= current_kboard
;
981 /* The pop should not change the kboard. */
982 if (single_kboard
&& current_kboard
!= prev
)
989 /* Handle errors that are not handled at inner levels
990 by printing an error message and returning to the editor command loop. */
993 cmd_error (Lisp_Object data
)
995 Lisp_Object old_level
, old_length
;
996 char macroerror
[sizeof "After..kbd macro iterations: "
997 + INT_STRLEN_BOUND (EMACS_INT
)];
999 #ifdef HAVE_WINDOW_SYSTEM
1000 if (display_hourglass_p
)
1001 cancel_hourglass ();
1004 if (!NILP (executing_kbd_macro
))
1006 if (executing_kbd_macro_iterations
== 1)
1007 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1009 sprintf (macroerror
, "After %"pI
"d kbd macro iterations: ",
1010 executing_kbd_macro_iterations
);
1015 Vstandard_output
= Qt
;
1016 Vstandard_input
= Qt
;
1017 Vexecuting_kbd_macro
= Qnil
;
1018 executing_kbd_macro
= Qnil
;
1019 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
1020 KVAR (current_kboard
, Vlast_prefix_arg
) = Qnil
;
1023 /* Avoid unquittable loop if data contains a circular list. */
1024 old_level
= Vprint_level
;
1025 old_length
= Vprint_length
;
1026 XSETFASTINT (Vprint_level
, 10);
1027 XSETFASTINT (Vprint_length
, 10);
1028 cmd_error_internal (data
, macroerror
);
1029 Vprint_level
= old_level
;
1030 Vprint_length
= old_length
;
1034 Vinhibit_quit
= Qnil
;
1035 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1036 if (command_loop_level
== 0 && minibuf_level
== 0)
1037 any_kboard_state ();
1040 return make_number (0);
1043 /* Take actions on handling an error. DATA is the data that describes
1046 CONTEXT is a C-string containing ASCII characters only which
1047 describes the context in which the error happened. If we need to
1048 generalize CONTEXT to allow multibyte characters, make it a Lisp
1052 cmd_error_internal (Lisp_Object data
, const char *context
)
1054 struct frame
*sf
= SELECTED_FRAME ();
1056 /* The immediate context is not interesting for Quits,
1057 since they are asynchronous. */
1058 if (EQ (XCAR (data
), Qquit
))
1059 Vsignaling_function
= Qnil
;
1064 /* Use user's specified output function if any. */
1065 if (!NILP (Vcommand_error_function
))
1066 call3 (Vcommand_error_function
, data
,
1067 context
? build_string (context
) : empty_unibyte_string
,
1068 Vsignaling_function
);
1069 /* If the window system or terminal frame hasn't been initialized
1070 yet, or we're not interactive, write the message to stderr and exit. */
1071 else if (!sf
->glyphs_initialized_p
1072 /* The initial frame is a special non-displaying frame. It
1073 will be current in daemon mode when there are no frames
1074 to display, and in non-daemon mode before the real frame
1075 has finished initializing. If an error is thrown in the
1076 latter case while creating the frame, then the frame
1077 will never be displayed, so the safest thing to do is
1078 write to stderr and quit. In daemon mode, there are
1079 many other potential errors that do not prevent frames
1080 from being created, so continuing as normal is better in
1082 || (!IS_DAEMON
&& FRAME_INITIAL_P (sf
))
1085 print_error_message (data
, Qexternal_debugging_output
,
1086 context
, Vsignaling_function
);
1087 Fterpri (Qexternal_debugging_output
);
1088 Fkill_emacs (make_number (-1));
1092 clear_message (1, 0);
1094 message_log_maybe_newline ();
1097 print_error_message (data
, Qt
, context
, Vsignaling_function
);
1100 Vsignaling_function
= Qnil
;
1103 Lisp_Object
command_loop_1 (void);
1104 static Lisp_Object
command_loop_2 (Lisp_Object
);
1105 static Lisp_Object
top_level_1 (Lisp_Object
);
1107 /* Entry to editor-command-loop.
1108 This level has the catches for exiting/returning to editor command loop.
1109 It returns nil to exit recursive edit, t to abort it. */
1114 if (command_loop_level
> 0 || minibuf_level
> 0)
1117 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1118 executing_kbd_macro
= Qnil
;
1124 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1125 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1126 /* Reset single_kboard in case top-level set it while
1127 evaluating an -f option, or we are stuck there for some
1129 any_kboard_state ();
1131 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1132 executing_kbd_macro
= Qnil
;
1134 /* End of file in -batch run causes exit here. */
1140 /* Here we catch errors in execution of commands within the
1141 editing loop, and reenter the editing loop.
1142 When there is an error, cmd_error runs and returns a non-nil
1143 value to us. A value of nil means that command_loop_1 itself
1144 returned due to end of file (or end of kbd macro). */
1147 command_loop_2 (Lisp_Object ignore
)
1149 register Lisp_Object val
;
1152 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1153 while (!NILP (val
));
1161 return Feval (Vtop_level
, Qnil
);
1165 top_level_1 (Lisp_Object ignore
)
1167 /* On entry to the outer level, run the startup file */
1168 if (!NILP (Vtop_level
))
1169 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1170 else if (!NILP (Vpurify_flag
))
1171 message ("Bare impure Emacs (standard Lisp code not loaded)");
1173 message ("Bare Emacs (standard Lisp code not loaded)");
1177 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1178 doc
: /* Exit all recursive editing levels.
1179 This also exits all active minibuffers. */)
1182 #ifdef HAVE_WINDOW_SYSTEM
1183 if (display_hourglass_p
)
1184 cancel_hourglass ();
1187 /* Unblock input if we enter with input blocked. This may happen if
1188 redisplay traps e.g. during tool-bar update with input blocked. */
1189 while (INPUT_BLOCKED_P
)
1192 Fthrow (Qtop_level
, Qnil
);
1195 static _Noreturn
void
1196 user_error (const char *msg
)
1198 xsignal1 (Quser_error
, build_string (msg
));
1202 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1203 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1206 if (command_loop_level
> 0 || minibuf_level
> 0)
1207 Fthrow (Qexit
, Qnil
);
1209 user_error ("No recursive edit is in progress");
1213 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1214 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1217 if (command_loop_level
> 0 || minibuf_level
> 0)
1220 user_error ("No recursive edit is in progress");
1223 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1225 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1226 of this function. */
1229 tracking_off (Lisp_Object old_value
)
1231 do_mouse_tracking
= old_value
;
1232 if (NILP (old_value
))
1234 /* Redisplay may have been preempted because there was input
1235 available, and it assumes it will be called again after the
1236 input has been processed. If the only input available was
1237 the sort that we have just disabled, then we need to call
1239 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW
))
1241 redisplay_preserve_echo_area (6);
1242 get_input_pending (&input_pending
,
1243 READABLE_EVENTS_DO_TIMERS_NOW
);
1249 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
1250 doc
: /* Evaluate BODY with mouse movement events enabled.
1251 Within a `track-mouse' form, mouse motion generates input events that
1252 you can read with `read-event'.
1253 Normally, mouse motion is ignored.
1254 usage: (track-mouse BODY...) */)
1257 ptrdiff_t count
= SPECPDL_INDEX ();
1260 record_unwind_protect (tracking_off
, do_mouse_tracking
);
1262 do_mouse_tracking
= Qt
;
1264 val
= Fprogn (args
);
1265 return unbind_to (count
, val
);
1268 /* If mouse has moved on some frame, return one of those frames.
1272 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1273 after resizing the tool-bar window. */
1275 #if !defined HAVE_WINDOW_SYSTEM || defined USE_GTK || defined HAVE_NS
1278 int ignore_mouse_drag_p
;
1281 some_mouse_moved (void)
1283 Lisp_Object tail
, frame
;
1285 if (ignore_mouse_drag_p
)
1287 /* ignore_mouse_drag_p = 0; */
1291 FOR_EACH_FRAME (tail
, frame
)
1293 if (XFRAME (frame
)->mouse_moved
)
1294 return XFRAME (frame
);
1300 #endif /* HAVE_MOUSE || HAVE_GPM */
1302 /* This is the actual command reading loop,
1303 sans error-handling encapsulation. */
1305 static int read_key_sequence (Lisp_Object
*, int, Lisp_Object
,
1307 void safe_run_hooks (Lisp_Object
);
1308 static void adjust_point_for_property (ptrdiff_t, int);
1310 /* Cancel hourglass from protect_unwind.
1312 #ifdef HAVE_WINDOW_SYSTEM
1314 cancel_hourglass_unwind (Lisp_Object arg
)
1316 cancel_hourglass ();
1321 /* FIXME: This is wrong rather than test window-system, we should call
1322 a new set-selection, which will then dispatch to x-set-selection, or
1323 tty-set-selection, or w32-set-selection, ... */
1326 command_loop_1 (void)
1329 Lisp_Object keybuf
[30];
1331 EMACS_INT prev_modiff
= 0;
1332 struct buffer
*prev_buffer
= NULL
;
1333 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1334 int was_locked
= single_kboard
;
1336 int already_adjusted
= 0;
1338 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
1339 KVAR (current_kboard
, Vlast_prefix_arg
) = Qnil
;
1340 Vdeactivate_mark
= Qnil
;
1341 waiting_for_input
= 0;
1344 this_command_key_count
= 0;
1345 this_command_key_count_reset
= 0;
1346 this_single_command_key_start
= 0;
1348 if (NILP (Vmemory_full
))
1350 /* Make sure this hook runs after commands that get errors and
1351 throw to top level. */
1352 /* Note that the value cell will never directly contain nil
1353 if the symbol is a local variable. */
1354 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1355 safe_run_hooks (Qpost_command_hook
);
1357 /* If displaying a message, resize the echo area window to fit
1358 that message's size exactly. */
1359 if (!NILP (echo_area_buffer
[0]))
1360 resize_echo_area_exactly ();
1362 /* If there are warnings waiting, process them. */
1363 if (!NILP (Vdelayed_warnings_list
))
1364 safe_run_hooks (Qdelayed_warnings_hook
);
1366 if (!NILP (Vdeferred_action_list
))
1367 safe_run_hooks (Qdeferred_action_function
);
1370 /* Do this after running Vpost_command_hook, for consistency. */
1371 KVAR (current_kboard
, Vlast_command
) = Vthis_command
;
1372 KVAR (current_kboard
, Vreal_last_command
) = Vreal_this_command
;
1373 if (!CONSP (last_command_event
))
1374 KVAR (current_kboard
, Vlast_repeatable_command
) = Vreal_this_command
;
1378 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1381 /* Make sure the current window's buffer is selected. */
1382 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1383 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1385 /* Display any malloc warning that just came out. Use while because
1386 displaying one warning can cause another. */
1388 while (pending_malloc_warning
)
1389 display_malloc_warning ();
1391 Vdeactivate_mark
= Qnil
;
1393 /* If minibuffer on and echo area in use,
1394 wait a short time and redraw minibuffer. */
1397 && !NILP (echo_area_buffer
[0])
1398 && EQ (minibuf_window
, echo_area_window
)
1399 && NUMBERP (Vminibuffer_message_timeout
))
1401 /* Bind inhibit-quit to t so that C-g gets read in
1402 rather than quitting back to the minibuffer. */
1403 ptrdiff_t count
= SPECPDL_INDEX ();
1404 specbind (Qinhibit_quit
, Qt
);
1406 sit_for (Vminibuffer_message_timeout
, 0, 2);
1408 /* Clear the echo area. */
1410 safe_run_hooks (Qecho_area_clear_hook
);
1412 unbind_to (count
, Qnil
);
1414 /* If a C-g came in before, treat it as input now. */
1415 if (!NILP (Vquit_flag
))
1418 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1423 /* Select the frame that the last event came from. Usually,
1424 switch-frame events will take care of this, but if some lisp
1425 code swallows a switch-frame event, we'll fix things up here.
1426 Is this a good idea? */
1427 if (FRAMEP (internal_last_event_frame
)
1428 && !EQ (internal_last_event_frame
, selected_frame
))
1429 Fselect_frame (internal_last_event_frame
, Qnil
);
1431 /* If it has changed current-menubar from previous value,
1432 really recompute the menubar from the value. */
1433 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1434 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1435 call0 (Qrecompute_lucid_menubar
);
1437 before_command_key_count
= this_command_key_count
;
1438 before_command_echo_length
= echo_length ();
1440 Vthis_command
= Qnil
;
1441 Vreal_this_command
= Qnil
;
1442 Vthis_original_command
= Qnil
;
1443 Vthis_command_keys_shift_translated
= Qnil
;
1445 /* Read next key sequence; i gets its length. */
1446 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1449 /* A filter may have run while we were reading the input. */
1450 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1452 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1453 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1457 /* Now we have read a key sequence of length I,
1458 or else I is 0 and we found end of file. */
1460 if (i
== 0) /* End of file -- happens only in */
1461 return Qnil
; /* a kbd macro, at the end. */
1462 /* -1 means read_key_sequence got a menu that was rejected.
1463 Just loop around and read another command. */
1467 this_command_key_count
= 0;
1468 this_command_key_count_reset
= 0;
1469 this_single_command_key_start
= 0;
1473 last_command_event
= keybuf
[i
- 1];
1475 /* If the previous command tried to force a specific window-start,
1476 forget about that, in case this command moves point far away
1477 from that position. But also throw away beg_unchanged and
1478 end_unchanged information in that case, so that redisplay will
1479 update the whole window properly. */
1480 if (XWINDOW (selected_window
)->force_start
)
1483 XWINDOW (selected_window
)->force_start
= 0;
1484 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1485 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1488 cmd
= read_key_sequence_cmd
;
1489 if (!NILP (Vexecuting_kbd_macro
))
1491 if (!NILP (Vquit_flag
))
1493 Vexecuting_kbd_macro
= Qt
;
1494 QUIT
; /* Make some noise. */
1495 /* Will return since macro now empty. */
1499 /* Do redisplay processing after this command except in special
1500 cases identified below. */
1501 prev_buffer
= current_buffer
;
1502 prev_modiff
= MODIFF
;
1503 last_point_position
= PT
;
1504 last_point_position_window
= selected_window
;
1505 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1507 /* By default, we adjust point to a boundary of a region that
1508 has such a property that should be treated intangible
1509 (e.g. composition, display). But, some commands will set
1510 this variable differently. */
1511 Vdisable_point_adjustment
= Qnil
;
1513 /* Process filters and timers may have messed with deactivate-mark.
1514 reset it before we execute the command. */
1515 Vdeactivate_mark
= Qnil
;
1517 /* Remap command through active keymaps. */
1518 Vthis_original_command
= cmd
;
1519 if (!NILP (read_key_sequence_remapped
))
1520 cmd
= read_key_sequence_remapped
;
1522 /* Execute the command. */
1524 Vthis_command
= cmd
;
1525 Vreal_this_command
= cmd
;
1526 safe_run_hooks (Qpre_command_hook
);
1528 already_adjusted
= 0;
1530 if (NILP (Vthis_command
))
1532 /* nil means key is undefined. */
1533 Lisp_Object keys
= Fvector (i
, keybuf
);
1534 keys
= Fkey_description (keys
, Qnil
);
1536 message_with_string ("%s is undefined", keys
, 0);
1537 KVAR (current_kboard
, defining_kbd_macro
) = Qnil
;
1538 update_mode_lines
= 1;
1539 /* If this is a down-mouse event, don't reset prefix-arg;
1540 pass it to the command run by the up event. */
1541 if (EVENT_HAS_PARAMETERS (last_command_event
))
1543 Lisp_Object breakdown
1544 = parse_modifiers (EVENT_HEAD (last_command_event
));
1545 int modifiers
= XINT (XCAR (XCDR (breakdown
)));
1546 if (!(modifiers
& down_modifier
))
1547 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
1550 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
1554 /* Here for a command that isn't executed directly. */
1556 #ifdef HAVE_WINDOW_SYSTEM
1557 ptrdiff_t scount
= SPECPDL_INDEX ();
1559 if (display_hourglass_p
1560 && NILP (Vexecuting_kbd_macro
))
1562 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1567 if (NILP (KVAR (current_kboard
, Vprefix_arg
))) /* FIXME: Why? --Stef */
1569 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1571 #ifdef HAVE_WINDOW_SYSTEM
1572 /* Do not check display_hourglass_p here, because
1573 Fcommand_execute could change it, but we should cancel
1574 hourglass cursor anyway.
1575 But don't cancel the hourglass within a macro
1576 just because a command in the macro finishes. */
1577 if (NILP (Vexecuting_kbd_macro
))
1578 unbind_to (scount
, Qnil
);
1581 KVAR (current_kboard
, Vlast_prefix_arg
) = Vcurrent_prefix_arg
;
1583 safe_run_hooks (Qpost_command_hook
);
1585 /* If displaying a message, resize the echo area window to fit
1586 that message's size exactly. */
1587 if (!NILP (echo_area_buffer
[0]))
1588 resize_echo_area_exactly ();
1590 /* If there are warnings waiting, process them. */
1591 if (!NILP (Vdelayed_warnings_list
))
1592 safe_run_hooks (Qdelayed_warnings_hook
);
1594 safe_run_hooks (Qdeferred_action_function
);
1596 /* If there is a prefix argument,
1597 1) We don't want Vlast_command to be ``universal-argument''
1598 (that would be dumb), so don't set Vlast_command,
1599 2) we want to leave echoing on so that the prefix will be
1600 echoed as part of this key sequence, so don't call
1602 3) we want to leave this_command_key_count non-zero, so that
1603 read_char will realize that it is re-reading a character, and
1604 not echo it a second time.
1606 If the command didn't actually create a prefix arg,
1607 but is merely a frame event that is transparent to prefix args,
1608 then the above doesn't apply. */
1609 if (NILP (KVAR (current_kboard
, Vprefix_arg
))
1610 || CONSP (last_command_event
))
1612 KVAR (current_kboard
, Vlast_command
) = Vthis_command
;
1613 KVAR (current_kboard
, Vreal_last_command
) = Vreal_this_command
;
1614 if (!CONSP (last_command_event
))
1615 KVAR (current_kboard
, Vlast_repeatable_command
)
1616 = Vreal_this_command
;
1618 this_command_key_count
= 0;
1619 this_command_key_count_reset
= 0;
1620 this_single_command_key_start
= 0;
1623 if (!NILP (BVAR (current_buffer
, mark_active
))
1624 && !NILP (Vrun_hooks
))
1626 /* In Emacs 22, setting transient-mark-mode to `only' was a
1627 way of turning it on for just one command. This usage is
1628 obsolete, but support it anyway. */
1629 if (EQ (Vtransient_mark_mode
, Qidentity
))
1630 Vtransient_mark_mode
= Qnil
;
1631 else if (EQ (Vtransient_mark_mode
, Qonly
))
1632 Vtransient_mark_mode
= Qidentity
;
1634 if (!NILP (Vdeactivate_mark
))
1635 /* If `select-active-regions' is non-nil, this call to
1636 `deactivate-mark' also sets the PRIMARY selection. */
1637 call0 (Qdeactivate_mark
);
1640 /* Even if not deactivating the mark, set PRIMARY if
1641 `select-active-regions' is non-nil. */
1642 if (!NILP (Fwindow_system (Qnil
))
1643 /* Even if mark_active is non-nil, the actual buffer
1644 marker may not have been set yet (Bug#7044). */
1645 && XMARKER (BVAR (current_buffer
, mark
))->buffer
1646 && (EQ (Vselect_active_regions
, Qonly
)
1647 ? EQ (CAR_SAFE (Vtransient_mark_mode
), Qonly
)
1648 : (!NILP (Vselect_active_regions
)
1649 && !NILP (Vtransient_mark_mode
)))
1650 && NILP (Fmemq (Vthis_command
,
1651 Vselection_inhibit_update_commands
)))
1654 XINT (Fmarker_position (BVAR (current_buffer
, mark
)));
1657 call2 (Qx_set_selection
, QPRIMARY
,
1658 make_buffer_string (beg
, end
, 0));
1660 call2 (Qx_set_selection
, QPRIMARY
,
1661 make_buffer_string (end
, beg
, 0));
1662 /* Don't set empty selections. */
1665 if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1667 Lisp_Object hook
= intern ("activate-mark-hook");
1668 Frun_hooks (1, &hook
);
1672 Vsaved_region_selection
= Qnil
;
1677 if (current_buffer
== prev_buffer
1678 && last_point_position
!= PT
1679 && NILP (Vdisable_point_adjustment
)
1680 && NILP (Vglobal_disable_point_adjustment
))
1682 if (last_point_position
> BEGV
1683 && last_point_position
< ZV
1684 && (composition_adjust_point (last_point_position
,
1685 last_point_position
)
1686 != last_point_position
))
1687 /* The last point was temporarily set within a grapheme
1688 cluster to prevent automatic composition. To recover
1689 the automatic composition, we must update the
1691 windows_or_buffers_changed
++;
1692 if (!already_adjusted
)
1693 adjust_point_for_property (last_point_position
,
1694 MODIFF
!= prev_modiff
);
1697 /* Install chars successfully executed in kbd macro. */
1699 if (!NILP (KVAR (current_kboard
, defining_kbd_macro
))
1700 && NILP (KVAR (current_kboard
, Vprefix_arg
)))
1701 finalize_kbd_macro_chars ();
1702 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1704 any_kboard_state ();
1709 /* Adjust point to a boundary of a region that has such a property
1710 that should be treated intangible. For the moment, we check
1711 `composition', `display' and `invisible' properties.
1712 LAST_PT is the last position of point. */
1715 adjust_point_for_property (ptrdiff_t last_pt
, int modified
)
1718 Lisp_Object val
, overlay
, tmp
;
1719 /* When called after buffer modification, we should temporarily
1720 suppress the point adjustment for automatic composition so that a
1721 user can keep inserting another character at point or keep
1722 deleting characters around point. */
1723 int check_composition
= ! modified
, check_display
= 1, check_invisible
= 1;
1724 ptrdiff_t orig_pt
= PT
;
1726 /* FIXME: cycling is probably not necessary because these properties
1727 can't be usefully combined anyway. */
1728 while (check_composition
|| check_display
|| check_invisible
)
1730 /* FIXME: check `intangible'. */
1731 if (check_composition
1732 && PT
> BEGV
&& PT
< ZV
1733 && (beg
= composition_adjust_point (last_pt
, PT
)) != PT
)
1736 check_display
= check_invisible
= 1;
1738 check_composition
= 0;
1740 && PT
> BEGV
&& PT
< ZV
1741 && !NILP (val
= get_char_property_and_overlay
1742 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
1743 && display_prop_intangible_p (val
, overlay
, PT
, PT_BYTE
)
1744 && (!OVERLAYP (overlay
)
1745 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
1746 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
1747 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
1748 && (beg
< PT
/* && end > PT <- It's always the case. */
1749 || (beg
<= PT
&& STRINGP (val
) && SCHARS (val
) == 0)))
1752 SET_PT (PT
< last_pt
1753 ? (STRINGP (val
) && SCHARS (val
) == 0
1754 ? max (beg
- 1, BEGV
)
1757 check_composition
= check_invisible
= 1;
1760 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
1762 int inv
, ellipsis
= 0;
1765 /* Find boundaries `beg' and `end' of the invisible area, if any. */
1768 /* FIXME: We should stop if we find a spot between
1769 two runs of `invisible' where inserted text would
1770 be visible. This is important when we have two
1771 invisible boundaries that enclose an area: if the
1772 area is empty, we need this test in order to make
1773 it possible to place point in the middle rather
1774 than skip both boundaries. However, this code
1775 also stops anywhere in a non-sticky text-property,
1776 which breaks (e.g.) Org mode. */
1777 && (val
= get_pos_property (make_number (end
),
1779 TEXT_PROP_MEANS_INVISIBLE (val
))
1781 && !NILP (val
= get_char_property_and_overlay
1782 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
1783 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1785 ellipsis
= ellipsis
|| inv
> 1
1786 || (OVERLAYP (overlay
)
1787 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1788 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1789 tmp
= Fnext_single_char_property_change
1790 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
1791 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
1795 && (val
= get_pos_property (make_number (beg
),
1797 TEXT_PROP_MEANS_INVISIBLE (val
))
1799 && !NILP (val
= get_char_property_and_overlay
1800 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
1801 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1803 ellipsis
= ellipsis
|| inv
> 1
1804 || (OVERLAYP (overlay
)
1805 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1806 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1807 tmp
= Fprevious_single_char_property_change
1808 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
1809 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
1812 /* Move away from the inside area. */
1813 if (beg
< PT
&& end
> PT
)
1815 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
1816 /* We haven't moved yet (so we don't need to fear
1817 infinite-looping) and we were outside the range
1818 before (so either end of the range still corresponds
1819 to a move in the right direction): pretend we moved
1820 less than we actually did, so that we still have
1821 more freedom below in choosing which end of the range
1823 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
1824 /* We either have moved already or the last point
1825 was already in the range: we don't get to choose
1826 which end of the range we have to go to. */
1827 : (PT
< last_pt
? beg
: end
));
1828 check_composition
= check_display
= 1;
1830 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
1831 the point to something other than its argument, due to
1832 point-motion hooks, intangibility, etc. */
1833 eassert (PT
== beg
|| PT
== end
);
1836 /* Pretend the area doesn't exist if the buffer is not
1838 if (!modified
&& !ellipsis
&& beg
< end
)
1840 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
1841 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
1842 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
1843 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
1844 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
1845 /* We've already moved as far as we can. Trying to go
1846 to the other end would mean moving backwards and thus
1847 could lead to an infinite loop. */
1849 else if (val
= get_pos_property (make_number (PT
),
1851 TEXT_PROP_MEANS_INVISIBLE (val
)
1852 && (val
= get_pos_property
1853 (make_number (PT
== beg
? end
: beg
),
1855 !TEXT_PROP_MEANS_INVISIBLE (val
)))
1856 (check_composition
= check_display
= 1,
1857 SET_PT (PT
== beg
? end
: beg
));
1860 check_invisible
= 0;
1864 /* Subroutine for safe_run_hooks: run the hook HOOK. */
1867 safe_run_hooks_1 (void)
1869 eassert (CONSP (Vinhibit_quit
));
1870 return call0 (XCDR (Vinhibit_quit
));
1873 /* Subroutine for safe_run_hooks: handle an error by clearing out the function
1877 safe_run_hooks_error (Lisp_Object error_data
)
1880 = CONSP (Vinhibit_quit
) ? XCAR (Vinhibit_quit
) : Vinhibit_quit
;
1881 Lisp_Object fun
= CONSP (Vinhibit_quit
) ? XCDR (Vinhibit_quit
) : Qnil
;
1882 Lisp_Object args
[4];
1883 args
[0] = build_string ("Error in %s (%s): %S");
1886 args
[3] = error_data
;
1892 Lisp_Object newval
= Qnil
;
1893 for (val
= find_symbol_value (hook
); CONSP (val
); val
= XCDR (val
))
1894 if (EQ (fun
, XCAR (val
)))
1897 newval
= Fcons (XCAR (val
), newval
);
1899 return Fset (hook
, Fnreverse (newval
));
1900 /* Not found in the local part of the hook. Let's look at the global
1903 for (val
= (NILP (Fdefault_boundp (hook
)) ? Qnil
1904 : Fdefault_value (hook
));
1905 CONSP (val
); val
= XCDR (val
))
1906 if (EQ (fun
, XCAR (val
)))
1909 newval
= Fcons (XCAR (val
), newval
);
1911 return Fset_default (hook
, Fnreverse (newval
));
1917 safe_run_hook_funcall (ptrdiff_t nargs
, Lisp_Object
*args
)
1919 eassert (nargs
== 1);
1920 if (CONSP (Vinhibit_quit
))
1921 XSETCDR (Vinhibit_quit
, args
[0]);
1923 Vinhibit_quit
= Fcons (Vinhibit_quit
, args
[0]);
1925 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
1929 /* If we get an error while running the hook, cause the hook variable
1930 to be nil. Also inhibit quits, so that C-g won't cause the hook
1931 to mysteriously evaporate. */
1934 safe_run_hooks (Lisp_Object hook
)
1936 /* FIXME: our `internal_condition_case' does not provide any way to pass data
1937 to its body or to its handlers other than via globals such as
1938 dynamically-bound variables ;-) */
1939 ptrdiff_t count
= SPECPDL_INDEX ();
1940 specbind (Qinhibit_quit
, hook
);
1942 run_hook_with_args (1, &hook
, safe_run_hook_funcall
);
1944 unbind_to (count
, Qnil
);
1948 /* Nonzero means polling for input is temporarily suppressed. */
1950 int poll_suppress_count
;
1952 /* Asynchronous timer for polling. */
1954 static struct atimer
*poll_timer
;
1957 #ifdef POLL_FOR_INPUT
1959 /* Poll for input, so that we catch a C-g if it comes in. This
1960 function is called from x_make_frame_visible, see comment
1964 poll_for_input_1 (void)
1966 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
1967 doing anything dangerous. */
1971 if (interrupt_input_blocked
== 0
1972 && !waiting_for_input
)
1973 read_avail_input (0);
1979 /* Timer callback function for poll_timer. TIMER is equal to
1983 poll_for_input (struct atimer
*timer
)
1985 if (poll_suppress_count
== 0)
1988 interrupt_input_pending
= 1;
1989 pending_signals
= 1;
1991 poll_for_input_1 ();
1996 #endif /* POLL_FOR_INPUT */
1998 /* Begin signals to poll for input, if they are appropriate.
1999 This function is called unconditionally from various places. */
2002 start_polling (void)
2004 #ifdef POLL_FOR_INPUT
2005 /* XXX This condition was (read_socket_hook && !interrupt_input),
2006 but read_socket_hook is not global anymore. Let's pretend that
2008 if (!interrupt_input
)
2010 /* Turn alarm handling on unconditionally. It might have
2011 been turned off in process.c. */
2012 turn_on_atimers (1);
2014 /* If poll timer doesn't exist, are we need one with
2015 a different interval, start a new one. */
2016 if (poll_timer
== NULL
2017 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2019 time_t period
= max (1, min (polling_period
, TYPE_MAXIMUM (time_t)));
2020 EMACS_TIME interval
= make_emacs_time (period
, 0);
2023 cancel_atimer (poll_timer
);
2025 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2026 poll_for_input
, NULL
);
2029 /* Let the timer's callback function poll for input
2030 if this becomes zero. */
2031 --poll_suppress_count
;
2036 /* Nonzero if we are using polling to handle input asynchronously. */
2039 input_polling_used (void)
2041 #ifdef POLL_FOR_INPUT
2042 /* XXX This condition was (read_socket_hook && !interrupt_input),
2043 but read_socket_hook is not global anymore. Let's pretend that
2045 return !interrupt_input
;
2051 /* Turn off polling. */
2056 #ifdef POLL_FOR_INPUT
2057 /* XXX This condition was (read_socket_hook && !interrupt_input),
2058 but read_socket_hook is not global anymore. Let's pretend that
2060 if (!interrupt_input
)
2061 ++poll_suppress_count
;
2065 /* Set the value of poll_suppress_count to COUNT
2066 and start or stop polling accordingly. */
2069 set_poll_suppress_count (int count
)
2071 #ifdef POLL_FOR_INPUT
2072 if (count
== 0 && poll_suppress_count
!= 0)
2074 poll_suppress_count
= 1;
2077 else if (count
!= 0 && poll_suppress_count
== 0)
2081 poll_suppress_count
= count
;
2085 /* Bind polling_period to a value at least N.
2086 But don't decrease it. */
2089 bind_polling_period (int n
)
2091 #ifdef POLL_FOR_INPUT
2092 EMACS_INT
new = polling_period
;
2097 stop_other_atimers (poll_timer
);
2099 specbind (Qpolling_period
, make_number (new));
2100 /* Start a new alarm with the new period. */
2105 /* Apply the control modifier to CHARACTER. */
2108 make_ctrl_char (int c
)
2110 /* Save the upper bits here. */
2111 int upper
= c
& ~0177;
2113 if (! ASCII_BYTE_P (c
))
2114 return c
|= ctrl_modifier
;
2118 /* Everything in the columns containing the upper-case letters
2119 denotes a control character. */
2120 if (c
>= 0100 && c
< 0140)
2124 /* Set the shift modifier for a control char
2125 made from a shifted letter. But only for letters! */
2126 if (oc
>= 'A' && oc
<= 'Z')
2127 c
|= shift_modifier
;
2130 /* The lower-case letters denote control characters too. */
2131 else if (c
>= 'a' && c
<= 'z')
2134 /* Include the bits for control and shift
2135 only if the basic ASCII code can't indicate them. */
2139 /* Replace the high bits. */
2140 c
|= (upper
& ~ctrl_modifier
);
2145 /* Display the help-echo property of the character after the mouse pointer.
2146 Either show it in the echo area, or call show-help-function to display
2147 it by other means (maybe in a tooltip).
2149 If HELP is nil, that means clear the previous help echo.
2151 If HELP is a string, display that string. If HELP is a function,
2152 call it with OBJECT and POS as arguments; the function should
2153 return a help string or nil for none. For all other types of HELP,
2154 evaluate it to obtain a string.
2156 WINDOW is the window in which the help was generated, if any.
2157 It is nil if not in a window.
2159 If OBJECT is a buffer, POS is the position in the buffer where the
2160 `help-echo' text property was found.
2162 If OBJECT is an overlay, that overlay has a `help-echo' property,
2163 and POS is the position in the overlay's buffer under the mouse.
2165 If OBJECT is a string (an overlay string or a string displayed with
2166 the `display' property). POS is the position in that string under
2169 Note: this function may only be called with HELP nil or a string
2170 from X code running asynchronously. */
2173 show_help_echo (Lisp_Object help
, Lisp_Object window
, Lisp_Object object
,
2176 if (!NILP (help
) && !STRINGP (help
))
2178 if (FUNCTIONP (help
))
2180 Lisp_Object args
[4];
2185 help
= safe_call (4, args
);
2188 help
= safe_eval (help
);
2190 if (!STRINGP (help
))
2194 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
2195 if (!noninteractive
&& STRINGP (help
))
2197 /* The mouse-fixup-help-message Lisp function can call
2198 mouse_position_hook, which resets the mouse_moved flags.
2199 This causes trouble if we are trying to read a mouse motion
2200 event (i.e., if we are inside a `track-mouse' form), so we
2201 restore the mouse_moved flag. */
2202 FRAME_PTR f
= NILP (do_mouse_tracking
) ? NULL
: some_mouse_moved ();
2203 help
= call1 (Qmouse_fixup_help_message
, help
);
2209 if (STRINGP (help
) || NILP (help
))
2211 if (!NILP (Vshow_help_function
))
2212 call1 (Vshow_help_function
, help
);
2213 help_echo_showing_p
= STRINGP (help
);
2219 /* Input of single characters from keyboard */
2221 static Lisp_Object
kbd_buffer_get_event (KBOARD
**kbp
, int *used_mouse_menu
,
2222 EMACS_TIME
*end_time
);
2223 static void record_char (Lisp_Object c
);
2225 static Lisp_Object help_form_saved_window_configs
;
2227 read_char_help_form_unwind (Lisp_Object arg
)
2229 Lisp_Object window_config
= XCAR (help_form_saved_window_configs
);
2230 help_form_saved_window_configs
= XCDR (help_form_saved_window_configs
);
2231 if (!NILP (window_config
))
2232 Fset_window_configuration (window_config
);
2236 #define STOP_POLLING \
2237 do { if (! polling_stopped_here) stop_polling (); \
2238 polling_stopped_here = 1; } while (0)
2240 #define RESUME_POLLING \
2241 do { if (polling_stopped_here) start_polling (); \
2242 polling_stopped_here = 0; } while (0)
2244 /* read a character from the keyboard; call the redisplay if needed */
2245 /* commandflag 0 means do not autosave, but do redisplay.
2246 -1 means do not redisplay, but do autosave.
2249 /* The arguments MAPS and NMAPS are for menu prompting.
2250 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2252 PREV_EVENT is the previous input event, or nil if we are reading
2253 the first event of a key sequence (or not reading a key sequence).
2254 If PREV_EVENT is t, that is a "magic" value that says
2255 not to run input methods, but in other respects to act as if
2256 not reading a key sequence.
2258 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2259 if we used a mouse menu to read the input, or zero otherwise. If
2260 USED_MOUSE_MENU is null, we don't dereference it.
2262 Value is -2 when we find input on another keyboard. A second call
2263 to read_char will read it.
2265 If END_TIME is non-null, it is a pointer to an EMACS_TIME
2266 specifying the maximum time to wait until. If no input arrives by
2267 that time, stop waiting and return nil.
2269 Value is t if we showed a menu and the user rejected it. */
2272 read_char (int commandflag
, ptrdiff_t nmaps
, Lisp_Object
*maps
,
2273 Lisp_Object prev_event
,
2274 int *used_mouse_menu
, EMACS_TIME
*end_time
)
2276 volatile Lisp_Object c
;
2278 jmp_buf local_getcjmp
;
2280 volatile int key_already_recorded
= 0;
2281 Lisp_Object tem
, save
;
2282 volatile Lisp_Object previous_echo_area_message
;
2283 volatile Lisp_Object also_record
;
2284 volatile int reread
;
2285 struct gcpro gcpro1
, gcpro2
;
2286 int volatile polling_stopped_here
= 0;
2287 struct kboard
*orig_kboard
= current_kboard
;
2291 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2292 before_command_key_count
= this_command_key_count
;
2293 before_command_echo_length
= echo_length ();
2296 previous_echo_area_message
= Qnil
;
2298 GCPRO2 (c
, previous_echo_area_message
);
2303 if (CONSP (Vunread_post_input_method_events
))
2305 c
= XCAR (Vunread_post_input_method_events
);
2306 Vunread_post_input_method_events
2307 = XCDR (Vunread_post_input_method_events
);
2309 /* Undo what read_char_x_menu_prompt did when it unread
2310 additional keys returned by Fx_popup_menu. */
2312 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2320 if (unread_command_char
!= -1)
2322 XSETINT (c
, unread_command_char
);
2323 unread_command_char
= -1;
2329 if (CONSP (Vunread_command_events
))
2331 int was_disabled
= 0;
2333 c
= XCAR (Vunread_command_events
);
2334 Vunread_command_events
= XCDR (Vunread_command_events
);
2338 /* Undo what sit-for did when it unread additional keys
2339 inside universal-argument. */
2342 && EQ (XCAR (c
), Qt
))
2348 /* Undo what read_char_x_menu_prompt did when it unread
2349 additional keys returned by Fx_popup_menu. */
2351 && EQ (XCDR (c
), Qdisabled
)
2352 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2358 /* If the queued event is something that used the mouse,
2359 set used_mouse_menu accordingly. */
2361 /* Also check was_disabled so last-nonmenu-event won't return
2362 a bad value when submenus are involved. (Bug#447) */
2363 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
) || was_disabled
))
2364 *used_mouse_menu
= 1;
2366 goto reread_for_input_method
;
2369 if (CONSP (Vunread_input_method_events
))
2371 c
= XCAR (Vunread_input_method_events
);
2372 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2374 /* Undo what read_char_x_menu_prompt did when it unread
2375 additional keys returned by Fx_popup_menu. */
2377 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2381 goto reread_for_input_method
;
2384 this_command_key_count_reset
= 0;
2386 if (!NILP (Vexecuting_kbd_macro
))
2388 /* We set this to Qmacro; since that's not a frame, nobody will
2389 try to switch frames on us, and the selected window will
2392 Since this event came from a macro, it would be misleading to
2393 leave internal_last_event_frame set to wherever the last
2394 real event came from. Normally, a switch-frame event selects
2395 internal_last_event_frame after each command is read, but
2396 events read from a macro should never cause a new frame to be
2398 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2400 /* Exit the macro if we are at the end.
2401 Also, some things replace the macro with t
2402 to force an early exit. */
2403 if (EQ (Vexecuting_kbd_macro
, Qt
)
2404 || executing_kbd_macro_index
>= XFASTINT (Flength (Vexecuting_kbd_macro
)))
2410 c
= Faref (Vexecuting_kbd_macro
, make_number (executing_kbd_macro_index
));
2411 if (STRINGP (Vexecuting_kbd_macro
)
2412 && (XFASTINT (c
) & 0x80) && (XFASTINT (c
) <= 0xff))
2413 XSETFASTINT (c
, CHAR_META
| (XFASTINT (c
) & ~0x80));
2415 executing_kbd_macro_index
++;
2420 if (!NILP (unread_switch_frame
))
2422 c
= unread_switch_frame
;
2423 unread_switch_frame
= Qnil
;
2425 /* This event should make it into this_command_keys, and get echoed
2426 again, so we do not set `reread'. */
2430 /* if redisplay was requested */
2431 if (commandflag
>= 0)
2433 int echo_current
= EQ (echo_message_buffer
, echo_area_buffer
[0]);
2435 /* If there is pending input, process any events which are not
2436 user-visible, such as X selection_request events. */
2438 || detect_input_pending_run_timers (0))
2439 swallow_events (0); /* may clear input_pending */
2441 /* Redisplay if no pending input. */
2442 while (!input_pending
)
2444 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2445 redisplay_preserve_echo_area (5);
2450 /* Normal case: no input arrived during redisplay. */
2453 /* Input arrived and pre-empted redisplay.
2454 Process any events which are not user-visible. */
2456 /* If that cleared input_pending, try again to redisplay. */
2459 /* Prevent the redisplay we just did
2460 from messing up echoing of the input after the prompt. */
2461 if (commandflag
== 0 && echo_current
)
2462 echo_message_buffer
= echo_area_buffer
[0];
2466 /* Message turns off echoing unless more keystrokes turn it on again.
2468 The code in 20.x for the condition was
2470 1. echo_area_glyphs && *echo_area_glyphs
2471 2. && echo_area_glyphs != current_kboard->echobuf
2472 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2474 (1) means there's a current message displayed
2476 (2) means it's not the message from echoing from the current
2479 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2480 is set to a non-null value. This is done in read_char and it is
2481 set to echo_area_glyphs after a call to echo_char. That means
2482 ok_to_echo_at_next_pause is either null or
2483 current_kboard->echobuf with the appropriate current_kboard at
2486 So, condition (3) means in clear text ok_to_echo_at_next_pause
2487 must be either null, or the current message isn't from echoing at
2488 all, or it's from echoing from a different kboard than the
2491 if (/* There currently is something in the echo area. */
2492 !NILP (echo_area_buffer
[0])
2493 && (/* And it's either not from echoing. */
2494 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2495 /* Or it's an echo from a different kboard. */
2496 || echo_kboard
!= current_kboard
2497 /* Or we explicitly allow overwriting whatever there is. */
2498 || ok_to_echo_at_next_pause
== NULL
))
2503 /* Try reading a character via menu prompting in the minibuf.
2504 Try this before the sit-for, because the sit-for
2505 would do the wrong thing if we are supposed to do
2506 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2507 after a mouse event so don't try a minibuf menu. */
2509 if (nmaps
> 0 && INTERACTIVE
2510 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2511 /* Don't bring up a menu if we already have another event. */
2512 && NILP (Vunread_command_events
)
2513 && unread_command_char
< 0
2514 && !detect_input_pending_run_timers (0))
2516 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2518 if (INTEGERP (c
) && XINT (c
) == -2)
2519 return c
; /* wrong_kboard_jmpbuf */
2523 key_already_recorded
= 1;
2528 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2529 We will do that below, temporarily for short sections of code,
2530 when appropriate. local_getcjmp must be in effect
2531 around any call to sit_for or kbd_buffer_get_event;
2532 it *must not* be in effect when we call redisplay. */
2534 jmpcount
= SPECPDL_INDEX ();
2535 if (_setjmp (local_getcjmp
))
2537 /* Handle quits while reading the keyboard. */
2538 /* We must have saved the outer value of getcjmp here,
2539 so restore it now. */
2540 restore_getcjmp (save_jump
);
2541 unbind_to (jmpcount
, Qnil
);
2542 XSETINT (c
, quit_char
);
2543 internal_last_event_frame
= selected_frame
;
2544 Vlast_event_frame
= internal_last_event_frame
;
2545 /* If we report the quit char as an event,
2546 don't do so more than once. */
2547 if (!NILP (Vinhibit_quit
))
2551 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2552 if (kb
!= current_kboard
)
2554 Lisp_Object last
= KVAR (kb
, kbd_queue
);
2555 /* We shouldn't get here if we were in single-kboard mode! */
2560 while (CONSP (XCDR (last
)))
2562 if (!NILP (XCDR (last
)))
2566 KVAR (kb
, kbd_queue
) = Fcons (c
, Qnil
);
2568 XSETCDR (last
, Fcons (c
, Qnil
));
2569 kb
->kbd_queue_has_data
= 1;
2570 current_kboard
= kb
;
2571 /* This is going to exit from read_char
2572 so we had better get rid of this frame's stuff. */
2574 return make_number (-2); /* wrong_kboard_jmpbuf */
2580 /* Start idle timers if no time limit is supplied. We don't do it
2581 if a time limit is supplied to avoid an infinite recursion in the
2582 situation where an idle timer calls `sit-for'. */
2585 timer_start_idle ();
2587 /* If in middle of key sequence and minibuffer not active,
2588 start echoing if enough time elapses. */
2590 if (minibuf_level
== 0
2592 && !current_kboard
->immediate_echo
2593 && this_command_key_count
> 0
2595 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2596 && NILP (Fzerop (Vecho_keystrokes
))
2597 && (/* No message. */
2598 NILP (echo_area_buffer
[0])
2599 /* Or empty message. */
2600 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2601 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2602 /* Or already echoing from same kboard. */
2603 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2604 /* Or not echoing before and echoing allowed. */
2605 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2607 /* After a mouse event, start echoing right away.
2608 This is because we are probably about to display a menu,
2609 and we don't want to delay before doing so. */
2610 if (EVENT_HAS_PARAMETERS (prev_event
))
2616 save_getcjmp (save_jump
);
2617 restore_getcjmp (local_getcjmp
);
2618 tem0
= sit_for (Vecho_keystrokes
, 1, 1);
2619 restore_getcjmp (save_jump
);
2621 && ! CONSP (Vunread_command_events
))
2626 /* Maybe auto save due to number of keystrokes. */
2628 if (commandflag
!= 0
2629 && auto_save_interval
> 0
2630 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2631 && !detect_input_pending_run_timers (0))
2633 Fdo_auto_save (Qnil
, Qnil
);
2634 /* Hooks can actually change some buffers in auto save. */
2638 /* Try reading using an X menu.
2639 This is never confused with reading using the minibuf
2640 because the recursive call of read_char in read_char_minibuf_menu_prompt
2641 does not pass on any keymaps. */
2643 if (nmaps
> 0 && INTERACTIVE
2644 && !NILP (prev_event
)
2645 && EVENT_HAS_PARAMETERS (prev_event
)
2646 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2647 && !EQ (XCAR (prev_event
), Qtool_bar
)
2648 /* Don't bring up a menu if we already have another event. */
2649 && NILP (Vunread_command_events
)
2650 && unread_command_char
< 0)
2652 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2654 /* Now that we have read an event, Emacs is not idle. */
2661 /* Maybe autosave and/or garbage collect due to idleness. */
2663 if (INTERACTIVE
&& NILP (c
))
2666 ptrdiff_t buffer_size
;
2668 /* Slow down auto saves logarithmically in size of current buffer,
2669 and garbage collect while we're at it. */
2670 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2671 last_non_minibuf_size
= Z
- BEG
;
2672 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2674 while (buffer_size
> 64)
2675 delay_level
++, buffer_size
-= buffer_size
>> 2;
2676 if (delay_level
< 4) delay_level
= 4;
2677 /* delay_level is 4 for files under around 50k, 7 at 100k,
2678 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2680 /* Auto save if enough time goes by without input. */
2681 if (commandflag
!= 0
2682 && num_nonmacro_input_events
> last_auto_save
2683 && INTEGERP (Vauto_save_timeout
)
2684 && XINT (Vauto_save_timeout
) > 0)
2687 EMACS_INT timeout
= (delay_level
2688 * min (XFASTINT (Vauto_save_timeout
) / 4,
2689 MOST_POSITIVE_FIXNUM
/ delay_level
));
2690 save_getcjmp (save_jump
);
2691 restore_getcjmp (local_getcjmp
);
2692 tem0
= sit_for (make_number (timeout
), 1, 1);
2693 restore_getcjmp (save_jump
);
2696 && ! CONSP (Vunread_command_events
))
2698 Fdo_auto_save (Qnil
, Qnil
);
2700 /* If we have auto-saved and there is still no input
2701 available, garbage collect if there has been enough
2702 consing going on to make it worthwhile. */
2703 if (!detect_input_pending_run_timers (0)
2704 && consing_since_gc
> gc_cons_threshold
/ 2)
2705 Fgarbage_collect ();
2712 /* Notify the caller if an autosave hook, or a timer, sentinel or
2713 filter in the sit_for calls above have changed the current
2714 kboard. This could happen if they use the minibuffer or start a
2715 recursive edit, like the fancy splash screen in server.el's
2716 filter. If this longjmp wasn't here, read_key_sequence would
2717 interpret the next key sequence using the wrong translation
2718 tables and function keymaps. */
2719 if (NILP (c
) && current_kboard
!= orig_kboard
)
2722 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
);
2733 /* Read something from current KBOARD's side queue, if possible. */
2737 if (current_kboard
->kbd_queue_has_data
)
2739 if (!CONSP (KVAR (current_kboard
, kbd_queue
)))
2741 c
= XCAR (KVAR (current_kboard
, kbd_queue
));
2742 KVAR (current_kboard
, kbd_queue
)
2743 = XCDR (KVAR (current_kboard
, kbd_queue
));
2744 if (NILP (KVAR (current_kboard
, kbd_queue
)))
2745 current_kboard
->kbd_queue_has_data
= 0;
2746 input_pending
= readable_events (0);
2747 if (EVENT_HAS_PARAMETERS (c
)
2748 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2749 internal_last_event_frame
= XCAR (XCDR (c
));
2750 Vlast_event_frame
= internal_last_event_frame
;
2754 /* If current_kboard's side queue is empty check the other kboards.
2755 If one of them has data that we have not yet seen here,
2756 switch to it and process the data waiting for it.
2758 Note: if the events queued up for another kboard
2759 have already been seen here, and therefore are not a complete command,
2760 the kbd_queue_has_data field is 0, so we skip that kboard here.
2761 That's to avoid an infinite loop switching between kboards here. */
2762 if (NILP (c
) && !single_kboard
)
2765 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2766 if (kb
->kbd_queue_has_data
)
2768 current_kboard
= kb
;
2769 /* This is going to exit from read_char
2770 so we had better get rid of this frame's stuff. */
2772 return make_number (-2); /* wrong_kboard_jmpbuf */
2780 /* Finally, we read from the main queue,
2781 and if that gives us something we can't use yet, we put it on the
2782 appropriate side queue and try again. */
2786 KBOARD
*kb
IF_LINT (= NULL
);
2788 if (end_time
&& EMACS_TIME_LE (*end_time
, current_emacs_time ()))
2791 /* Actually read a character, waiting if necessary. */
2792 save_getcjmp (save_jump
);
2793 restore_getcjmp (local_getcjmp
);
2795 timer_start_idle ();
2796 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
, end_time
);
2797 restore_getcjmp (save_jump
);
2799 if (! NILP (c
) && (kb
!= current_kboard
))
2801 Lisp_Object last
= KVAR (kb
, kbd_queue
);
2804 while (CONSP (XCDR (last
)))
2806 if (!NILP (XCDR (last
)))
2810 KVAR (kb
, kbd_queue
) = Fcons (c
, Qnil
);
2812 XSETCDR (last
, Fcons (c
, Qnil
));
2813 kb
->kbd_queue_has_data
= 1;
2817 current_kboard
= kb
;
2818 /* This is going to exit from read_char
2819 so we had better get rid of this frame's stuff. */
2821 return make_number (-2);
2825 /* Terminate Emacs in batch mode if at eof. */
2826 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
2827 Fkill_emacs (make_number (1));
2831 /* Add in any extra modifiers, where appropriate. */
2832 if ((extra_keyboard_modifiers
& CHAR_CTL
)
2833 || ((extra_keyboard_modifiers
& 0177) < ' '
2834 && (extra_keyboard_modifiers
& 0177) != 0))
2835 XSETINT (c
, make_ctrl_char (XINT (c
)));
2837 /* Transfer any other modifier bits directly from
2838 extra_keyboard_modifiers to c. Ignore the actual character code
2839 in the low 16 bits of extra_keyboard_modifiers. */
2840 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
2851 if (commandflag
>= 0
2852 && !input_pending
&& !detect_input_pending_run_timers (0))
2860 /* Buffer switch events are only for internal wakeups
2861 so don't show them to the user.
2862 Also, don't record a key if we already did. */
2863 if (BUFFERP (c
) || key_already_recorded
)
2866 /* Process special events within read_char
2867 and loop around to read another event. */
2870 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
2875 struct buffer
*prev_buffer
= current_buffer
;
2876 #if 0 /* This shouldn't be necessary anymore. --lorentey */
2877 int was_locked
= single_kboard
;
2878 ptrdiff_t count
= SPECPDL_INDEX ();
2879 record_single_kboard_state ();
2882 last_input_event
= c
;
2883 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_event
), Qt
);
2885 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
) && !end_time
)
2886 /* We stopped being idle for this event; undo that. This
2887 prevents automatic window selection (under
2888 mouse_autoselect_window from acting as a real input event, for
2889 example banishing the mouse under mouse-avoidance-mode. */
2890 timer_resume_idle ();
2892 #if 0 /* This shouldn't be necessary anymore. --lorentey */
2893 /* Resume allowing input from any kboard, if that was true before. */
2895 any_kboard_state ();
2896 unbind_to (count
, Qnil
);
2899 if (current_buffer
!= prev_buffer
)
2901 /* The command may have changed the keymaps. Pretend there
2902 is input in another keyboard and return. This will
2903 recalculate keymaps. */
2904 c
= make_number (-2);
2911 /* Handle things that only apply to characters. */
2914 /* If kbd_buffer_get_event gave us an EOF, return that. */
2918 if ((STRINGP (KVAR (current_kboard
, Vkeyboard_translate_table
))
2919 && UNSIGNED_CMP (XFASTINT (c
), <,
2920 SCHARS (KVAR (current_kboard
,
2921 Vkeyboard_translate_table
))))
2922 || (VECTORP (KVAR (current_kboard
, Vkeyboard_translate_table
))
2923 && UNSIGNED_CMP (XFASTINT (c
), <,
2924 ASIZE (KVAR (current_kboard
,
2925 Vkeyboard_translate_table
))))
2926 || (CHAR_TABLE_P (KVAR (current_kboard
, Vkeyboard_translate_table
))
2930 d
= Faref (KVAR (current_kboard
, Vkeyboard_translate_table
), c
);
2931 /* nil in keyboard-translate-table means no translation. */
2937 /* If this event is a mouse click in the menu bar,
2938 return just menu-bar for now. Modify the mouse click event
2939 so we won't do this twice, then queue it up. */
2940 if (EVENT_HAS_PARAMETERS (c
)
2942 && CONSP (EVENT_START (c
))
2943 && CONSP (XCDR (EVENT_START (c
))))
2947 posn
= POSN_POSN (EVENT_START (c
));
2948 /* Handle menu-bar events:
2949 insert the dummy prefix event `menu-bar'. */
2950 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
2952 /* Change menu-bar to (menu-bar) as the event "position". */
2953 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
2956 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
2961 /* Store these characters into recent_keys, the dribble file if any,
2962 and the keyboard macro being defined, if any. */
2964 if (! NILP (also_record
))
2965 record_char (also_record
);
2967 /* Wipe the echo area.
2968 But first, if we are about to use an input method,
2969 save the echo area contents for it to refer to. */
2971 && ! NILP (Vinput_method_function
)
2972 && ' ' <= XINT (c
) && XINT (c
) < 256 && XINT (c
) != 127)
2974 previous_echo_area_message
= Fcurrent_message ();
2975 Vinput_method_previous_message
= previous_echo_area_message
;
2978 /* Now wipe the echo area, except for help events which do their
2979 own stuff with the echo area. */
2981 || (!(EQ (Qhelp_echo
, XCAR (c
)))
2982 && !(EQ (Qswitch_frame
, XCAR (c
)))
2983 /* Don't wipe echo area for select window events: These might
2984 get delayed via `mouse-autoselect-window' (Bug#11304). */
2985 && !(EQ (Qselect_window
, XCAR (c
)))))
2987 if (!NILP (echo_area_buffer
[0]))
2989 safe_run_hooks (Qecho_area_clear_hook
);
2990 clear_message (1, 0);
2994 reread_for_input_method
:
2996 /* Pass this to the input method, if appropriate. */
2998 && ! NILP (Vinput_method_function
)
2999 /* Don't run the input method within a key sequence,
3000 after the first event of the key sequence. */
3001 && NILP (prev_event
)
3002 && ' ' <= XINT (c
) && XINT (c
) < 256 && XINT (c
) != 127)
3005 ptrdiff_t key_count
;
3006 int key_count_reset
;
3007 struct gcpro gcpro1
;
3008 ptrdiff_t count
= SPECPDL_INDEX ();
3010 /* Save the echo status. */
3011 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3012 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3013 Lisp_Object saved_echo_string
= KVAR (current_kboard
, echo_string
);
3014 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3017 if (before_command_restore_flag
)
3019 this_command_key_count
= before_command_key_count_1
;
3020 if (this_command_key_count
< this_single_command_key_start
)
3021 this_single_command_key_start
= this_command_key_count
;
3022 echo_truncate (before_command_echo_length_1
);
3023 before_command_restore_flag
= 0;
3027 /* Save the this_command_keys status. */
3028 key_count
= this_command_key_count
;
3029 key_count_reset
= this_command_key_count_reset
;
3032 keys
= Fcopy_sequence (this_command_keys
);
3037 /* Clear out this_command_keys. */
3038 this_command_key_count
= 0;
3039 this_command_key_count_reset
= 0;
3041 /* Now wipe the echo area. */
3042 if (!NILP (echo_area_buffer
[0]))
3043 safe_run_hooks (Qecho_area_clear_hook
);
3044 clear_message (1, 0);
3047 /* If we are not reading a key sequence,
3048 never use the echo area. */
3051 specbind (Qinput_method_use_echo_area
, Qt
);
3054 /* Call the input method. */
3055 tem
= call1 (Vinput_method_function
, c
);
3057 tem
= unbind_to (count
, tem
);
3059 /* Restore the saved echoing state
3060 and this_command_keys state. */
3061 this_command_key_count
= key_count
;
3062 this_command_key_count_reset
= key_count_reset
;
3064 this_command_keys
= keys
;
3067 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3068 KVAR (current_kboard
, echo_string
) = saved_echo_string
;
3069 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3070 if (saved_immediate_echo
)
3075 /* The input method can return no events. */
3078 /* Bring back the previous message, if any. */
3079 if (! NILP (previous_echo_area_message
))
3080 message_with_string ("%s", previous_echo_area_message
, 0);
3083 /* It returned one event or more. */
3085 Vunread_post_input_method_events
3086 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3091 /* Display help if not echoing. */
3092 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3094 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3095 Lisp_Object help
, object
, position
, window
, htem
;
3097 htem
= Fcdr (XCDR (c
));
3100 window
= Fcar (htem
);
3102 object
= Fcar (htem
);
3104 position
= Fcar (htem
);
3106 show_help_echo (help
, window
, object
, position
);
3108 /* We stopped being idle for this event; undo that. */
3110 timer_resume_idle ();
3114 if ((! reread
|| this_command_key_count
== 0
3115 || this_command_key_count_reset
)
3119 /* Don't echo mouse motion events. */
3120 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3121 && NILP (Fzerop (Vecho_keystrokes
))
3122 && ! (EVENT_HAS_PARAMETERS (c
)
3123 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3126 if (! NILP (also_record
))
3127 echo_char (also_record
);
3128 /* Once we reread a character, echoing can happen
3129 the next time we pause to read a new one. */
3130 ok_to_echo_at_next_pause
= current_kboard
;
3133 /* Record this character as part of the current key. */
3134 add_command_key (c
);
3135 if (! NILP (also_record
))
3136 add_command_key (also_record
);
3139 last_input_event
= c
;
3142 /* Process the help character specially if enabled */
3143 if (!NILP (Vhelp_form
) && help_char_p (c
))
3145 ptrdiff_t count
= SPECPDL_INDEX ();
3147 help_form_saved_window_configs
3148 = Fcons (Fcurrent_window_configuration (Qnil
),
3149 help_form_saved_window_configs
);
3150 record_unwind_protect (read_char_help_form_unwind
, Qnil
);
3151 call0 (Qhelp_form_show
);
3156 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3157 if (EVENT_HAS_PARAMETERS (c
)
3158 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_click
))
3159 XSETCAR (help_form_saved_window_configs
, Qnil
);
3161 while (BUFFERP (c
));
3162 /* Remove the help from the frame */
3163 unbind_to (count
, Qnil
);
3166 if (EQ (c
, make_number (040)))
3170 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3171 while (BUFFERP (c
));
3180 /* Record a key that came from a mouse menu.
3181 Record it for echoing, for this-command-keys, and so on. */
3184 record_menu_key (Lisp_Object c
)
3186 /* Wipe the echo area. */
3187 clear_message (1, 0);
3192 before_command_key_count
= this_command_key_count
;
3193 before_command_echo_length
= echo_length ();
3196 /* Don't echo mouse motion events. */
3197 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3198 && NILP (Fzerop (Vecho_keystrokes
)))
3202 /* Once we reread a character, echoing can happen
3203 the next time we pause to read a new one. */
3204 ok_to_echo_at_next_pause
= 0;
3207 /* Record this character as part of the current key. */
3208 add_command_key (c
);
3210 /* Re-reading in the middle of a command */
3211 last_input_event
= c
;
3215 /* Return 1 if should recognize C as "the help character". */
3218 help_char_p (Lisp_Object c
)
3222 if (EQ (c
, Vhelp_char
))
3224 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3225 if (EQ (c
, XCAR (tail
)))
3230 /* Record the input event C in various ways. */
3233 record_char (Lisp_Object c
)
3237 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3239 /* To avoid filling recent_keys with help-echo and mouse-movement
3240 events, we filter out repeated help-echo events, only store the
3241 first and last in a series of mouse-movement events, and don't
3242 store repeated help-echo events which are only separated by
3243 mouse-movement events. */
3245 Lisp_Object ev1
, ev2
, ev3
;
3248 if ((ix1
= recent_keys_index
- 1) < 0)
3249 ix1
= NUM_RECENT_KEYS
- 1;
3250 ev1
= AREF (recent_keys
, ix1
);
3252 if ((ix2
= ix1
- 1) < 0)
3253 ix2
= NUM_RECENT_KEYS
- 1;
3254 ev2
= AREF (recent_keys
, ix2
);
3256 if ((ix3
= ix2
- 1) < 0)
3257 ix3
= NUM_RECENT_KEYS
- 1;
3258 ev3
= AREF (recent_keys
, ix3
);
3260 if (EQ (XCAR (c
), Qhelp_echo
))
3262 /* Don't record `help-echo' in recent_keys unless it shows some help
3263 message, and a different help than the previously recorded
3265 Lisp_Object help
, last_help
;
3267 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3268 if (!STRINGP (help
))
3270 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3271 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3273 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3274 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3275 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3277 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3278 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3279 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3280 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3283 else if (EQ (XCAR (c
), Qmouse_movement
))
3285 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3286 So additional mouse movement events replace the last element. */
3287 Lisp_Object last_window
, window
;
3289 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3290 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3291 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3292 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3293 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3295 ASET (recent_keys
, ix1
, c
);
3301 store_kbd_macro_char (c
);
3305 total_keys
+= total_keys
< NUM_RECENT_KEYS
;
3306 ASET (recent_keys
, recent_keys_index
, c
);
3307 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3308 recent_keys_index
= 0;
3310 else if (recorded
< 0)
3312 /* We need to remove one or two events from recent_keys.
3313 To do this, we simply put nil at those events and move the
3314 recent_keys_index backwards over those events. Usually,
3315 users will never see those nil events, as they will be
3316 overwritten by the command keys entered to see recent_keys
3319 while (recorded
++ < 0 && total_keys
> 0)
3321 if (total_keys
< NUM_RECENT_KEYS
)
3323 if (--recent_keys_index
< 0)
3324 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3325 ASET (recent_keys
, recent_keys_index
, Qnil
);
3329 num_nonmacro_input_events
++;
3331 /* Write c to the dribble file. If c is a lispy event, write
3332 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3333 If you, dear reader, have a better idea, you've got the source. :-) */
3339 if (XUINT (c
) < 0x100)
3340 putc (XUINT (c
), dribble
);
3342 fprintf (dribble
, " 0x%"pI
"x", XUINT (c
));
3346 Lisp_Object dribblee
;
3348 /* If it's a structured event, take the event header. */
3349 dribblee
= EVENT_HEAD (c
);
3351 if (SYMBOLP (dribblee
))
3353 putc ('<', dribble
);
3354 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3355 SBYTES (SYMBOL_NAME (dribblee
)),
3357 putc ('>', dribble
);
3366 /* Copy out or in the info on where C-g should throw to.
3367 This is used when running Lisp code from within get_char,
3368 in case get_char is called recursively.
3369 See read_process_output. */
3372 save_getcjmp (jmp_buf temp
)
3374 memcpy (temp
, getcjmp
, sizeof getcjmp
);
3378 restore_getcjmp (jmp_buf temp
)
3380 memcpy (getcjmp
, temp
, sizeof getcjmp
);
3383 /* Low level keyboard/mouse input.
3384 kbd_buffer_store_event places events in kbd_buffer, and
3385 kbd_buffer_get_event retrieves them. */
3387 /* Return true if there are any events in the queue that read-char
3388 would return. If this returns false, a read-char would block. */
3390 readable_events (int flags
)
3392 if (flags
& READABLE_EVENTS_DO_TIMERS_NOW
)
3395 /* If the buffer contains only FOCUS_IN_EVENT events, and
3396 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3397 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3399 if (flags
& (READABLE_EVENTS_FILTER_EVENTS
3400 #ifdef USE_TOOLKIT_SCROLL_BARS
3401 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3405 struct input_event
*event
;
3407 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3414 #ifdef USE_TOOLKIT_SCROLL_BARS
3415 (flags
& READABLE_EVENTS_FILTER_EVENTS
) &&
3417 event
->kind
== FOCUS_IN_EVENT
)
3418 #ifdef USE_TOOLKIT_SCROLL_BARS
3419 && !((flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3420 && event
->kind
== SCROLL_BAR_CLICK_EVENT
3421 && event
->part
== scroll_bar_handle
3422 && event
->modifiers
== 0)
3427 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3430 while (event
!= kbd_store_ptr
);
3436 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3437 if (!(flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3438 && !NILP (do_mouse_tracking
) && some_mouse_moved ())
3443 if (current_kboard
->kbd_queue_has_data
)
3449 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3450 if (kb
->kbd_queue_has_data
)
3456 /* Set this for debugging, to have a way to get out */
3457 int stop_character EXTERNALLY_VISIBLE
;
3460 event_to_kboard (struct input_event
*event
)
3463 frame
= event
->frame_or_window
;
3465 frame
= XCAR (frame
);
3466 else if (WINDOWP (frame
))
3467 frame
= WINDOW_FRAME (XWINDOW (frame
));
3469 /* There are still some events that don't set this field.
3470 For now, just ignore the problem.
3471 Also ignore dead frames here. */
3472 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3475 return FRAME_KBOARD (XFRAME (frame
));
3479 /* Return the number of slots occupied in kbd_buffer. */
3482 kbd_buffer_nr_stored (void)
3484 return kbd_fetch_ptr
== kbd_store_ptr
3486 : (kbd_fetch_ptr
< kbd_store_ptr
3487 ? kbd_store_ptr
- kbd_fetch_ptr
3488 : ((kbd_buffer
+ KBD_BUFFER_SIZE
) - kbd_fetch_ptr
3489 + (kbd_store_ptr
- kbd_buffer
)));
3491 #endif /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3494 kbd_buffer_store_event (register struct input_event
*event
)
3496 kbd_buffer_store_event_hold (event
, 0);
3499 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3501 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3502 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3503 Else, if EVENT is a quit event, store the quit event
3504 in HOLD_QUIT, and return (thus ignoring further events).
3506 This is used in read_avail_input to postpone the processing
3507 of the quit event until all subsequent input events have been
3508 parsed (and discarded).
3512 kbd_buffer_store_event_hold (register struct input_event
*event
,
3513 struct input_event
*hold_quit
)
3515 if (event
->kind
== NO_EVENT
)
3518 if (hold_quit
&& hold_quit
->kind
!= NO_EVENT
)
3521 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3523 register int c
= event
->code
& 0377;
3525 if (event
->modifiers
& ctrl_modifier
)
3526 c
= make_ctrl_char (c
);
3528 c
|= (event
->modifiers
3529 & (meta_modifier
| alt_modifier
3530 | hyper_modifier
| super_modifier
));
3534 KBOARD
*kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
));
3535 struct input_event
*sp
;
3537 if (single_kboard
&& kb
!= current_kboard
)
3539 KVAR (kb
, kbd_queue
)
3540 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3541 Fcons (make_number (c
), Qnil
));
3542 kb
->kbd_queue_has_data
= 1;
3543 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3545 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3548 if (event_to_kboard (sp
) == kb
)
3550 sp
->kind
= NO_EVENT
;
3551 sp
->frame_or_window
= Qnil
;
3560 memcpy (hold_quit
, event
, sizeof (*event
));
3564 /* If this results in a quit_char being returned to Emacs as
3565 input, set Vlast_event_frame properly. If this doesn't
3566 get returned to Emacs as an event, the next event read
3567 will set Vlast_event_frame again, so this is safe to do. */
3571 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3573 focus
= event
->frame_or_window
;
3574 internal_last_event_frame
= focus
;
3575 Vlast_event_frame
= focus
;
3578 last_event_timestamp
= event
->timestamp
;
3579 handle_interrupt ();
3583 if (c
&& c
== stop_character
)
3589 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3590 Just ignore the second one. */
3591 else if (event
->kind
== BUFFER_SWITCH_EVENT
3592 && kbd_fetch_ptr
!= kbd_store_ptr
3593 && ((kbd_store_ptr
== kbd_buffer
3594 ? kbd_buffer
+ KBD_BUFFER_SIZE
- 1
3595 : kbd_store_ptr
- 1)->kind
) == BUFFER_SWITCH_EVENT
)
3598 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3599 kbd_store_ptr
= kbd_buffer
;
3601 /* Don't let the very last slot in the buffer become full,
3602 since that would make the two pointers equal,
3603 and that is indistinguishable from an empty buffer.
3604 Discard the event if it would fill the last slot. */
3605 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3607 *kbd_store_ptr
= *event
;
3610 if (kbd_buffer_nr_stored () > KBD_BUFFER_SIZE
/2 && ! kbd_on_hold_p ())
3612 /* Don't read keyboard input until we have processed kbd_buffer.
3613 This happens when pasting text longer than KBD_BUFFER_SIZE/2. */
3614 hold_keyboard_input ();
3616 if (!noninteractive
)
3617 signal (SIGIO
, SIG_IGN
);
3621 #endif /* subprocesses */
3624 /* If we're inside while-no-input, and this event qualifies
3625 as input, set quit-flag to cause an interrupt. */
3626 if (!NILP (Vthrow_on_input
)
3627 && event
->kind
!= FOCUS_IN_EVENT
3628 && event
->kind
!= HELP_EVENT
3629 && event
->kind
!= DEICONIFY_EVENT
)
3631 Vquit_flag
= Vthrow_on_input
;
3632 /* If we're inside a function that wants immediate quits,
3634 if (immediate_quit
&& NILP (Vinhibit_quit
))
3644 /* Put an input event back in the head of the event queue. */
3647 kbd_buffer_unget_event (register struct input_event
*event
)
3649 if (kbd_fetch_ptr
== kbd_buffer
)
3650 kbd_fetch_ptr
= kbd_buffer
+ KBD_BUFFER_SIZE
;
3652 /* Don't let the very last slot in the buffer become full, */
3653 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3656 *kbd_fetch_ptr
= *event
;
3661 /* Generate a HELP_EVENT input_event and store it in the keyboard
3664 HELP is the help form.
3666 FRAME and WINDOW are the frame and window where the help is
3667 generated. OBJECT is the Lisp object where the help was found (a
3668 buffer, a string, an overlay, or nil if neither from a string nor
3669 from a buffer). POS is the position within OBJECT where the help
3673 gen_help_event (Lisp_Object help
, Lisp_Object frame
, Lisp_Object window
,
3674 Lisp_Object object
, ptrdiff_t pos
)
3676 struct input_event event
;
3680 event
.kind
= HELP_EVENT
;
3681 event
.frame_or_window
= frame
;
3683 event
.x
= WINDOWP (window
) ? window
: frame
;
3686 kbd_buffer_store_event (&event
);
3690 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3693 kbd_buffer_store_help_event (Lisp_Object frame
, Lisp_Object help
)
3695 struct input_event event
;
3697 event
.kind
= HELP_EVENT
;
3698 event
.frame_or_window
= frame
;
3703 kbd_buffer_store_event (&event
);
3707 /* Discard any mouse events in the event buffer by setting them to
3710 discard_mouse_events (void)
3712 struct input_event
*sp
;
3713 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3715 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3718 if (sp
->kind
== MOUSE_CLICK_EVENT
3719 || sp
->kind
== WHEEL_EVENT
3720 || sp
->kind
== HORIZ_WHEEL_EVENT
3722 || sp
->kind
== GPM_CLICK_EVENT
3724 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
3726 sp
->kind
= NO_EVENT
;
3732 /* Return non-zero if there are any real events waiting in the event
3733 buffer, not counting `NO_EVENT's.
3735 If DISCARD is non-zero, discard NO_EVENT events at the front of
3736 the input queue, possibly leaving the input queue empty if there
3737 are no real input events. */
3740 kbd_buffer_events_waiting (int discard
)
3742 struct input_event
*sp
;
3744 for (sp
= kbd_fetch_ptr
;
3745 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
3748 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3755 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
3759 /* Clear input event EVENT. */
3762 clear_event (struct input_event
*event
)
3764 event
->kind
= NO_EVENT
;
3768 /* Read one event from the event buffer, waiting if necessary.
3769 The value is a Lisp object representing the event.
3770 The value is nil for an event that should be ignored,
3771 or that was handled here.
3772 We always read and discard one event. */
3775 kbd_buffer_get_event (KBOARD
**kbp
,
3776 int *used_mouse_menu
,
3777 EMACS_TIME
*end_time
)
3782 if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE
/4)
3784 /* Start reading input again, we have processed enough so we can
3785 accept new events again. */
3786 unhold_keyboard_input ();
3788 if (!noninteractive
)
3789 signal (SIGIO
, input_available_signal
);
3793 #endif /* subprocesses */
3795 #ifndef HAVE_DBUS /* We want to read D-Bus events in batch mode. */
3797 /* In case we are running as a daemon, only do this before
3798 detaching from the terminal. */
3799 || (IS_DAEMON
&& daemon_pipe
[1] >= 0))
3803 *kbp
= current_kboard
;
3806 #endif /* ! HAVE_DBUS */
3808 /* Wait until there is input available. */
3811 /* Break loop if there's an unread command event. Needed in
3812 moused window autoselection which uses a timer to insert such
3814 if (CONSP (Vunread_command_events
))
3817 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3819 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3820 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3824 /* If the quit flag is set, then read_char will return
3825 quit_char, so that counts as "available input." */
3826 if (!NILP (Vquit_flag
))
3827 quit_throw_to_read_char (0);
3829 /* One way or another, wait until input is available; then, if
3830 interrupt handlers have not read it, read it now. */
3832 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3836 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3838 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3839 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3844 EMACS_TIME now
= current_emacs_time ();
3845 if (EMACS_TIME_LE (*end_time
, now
))
3846 return Qnil
; /* Finished waiting. */
3849 EMACS_TIME duration
= sub_emacs_time (*end_time
, now
);
3850 wait_reading_process_output (min (EMACS_SECS (duration
),
3852 EMACS_NSECS (duration
),
3853 -1, 1, Qnil
, NULL
, 0);
3857 wait_reading_process_output (0, 0, -1, 1, Qnil
, NULL
, 0);
3859 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
3860 /* Pass 1 for EXPECT since we just waited to have input. */
3861 read_avail_input (1);
3864 if (CONSP (Vunread_command_events
))
3867 first
= XCAR (Vunread_command_events
);
3868 Vunread_command_events
= XCDR (Vunread_command_events
);
3869 *kbp
= current_kboard
;
3873 /* At this point, we know that there is a readable event available
3874 somewhere. If the event queue is empty, then there must be a
3875 mouse movement enabled and available. */
3876 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3878 struct input_event
*event
;
3880 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3884 last_event_timestamp
= event
->timestamp
;
3886 *kbp
= event_to_kboard (event
);
3888 *kbp
= current_kboard
; /* Better than returning null ptr? */
3892 /* These two kinds of events get special handling
3893 and don't actually appear to the command loop.
3894 We return nil for them. */
3895 if (event
->kind
== SELECTION_REQUEST_EVENT
3896 || event
->kind
== SELECTION_CLEAR_EVENT
)
3899 struct input_event copy
;
3901 /* Remove it from the buffer before processing it,
3902 since otherwise swallow_events will see it
3903 and process it again. */
3905 kbd_fetch_ptr
= event
+ 1;
3906 input_pending
= readable_events (0);
3907 x_handle_selection_event (©
);
3909 /* We're getting selection request events, but we don't have
3915 #if defined (HAVE_NS)
3916 else if (event
->kind
== NS_TEXT_EVENT
)
3918 if (event
->code
== KEY_NS_PUT_WORKING_TEXT
)
3919 obj
= Fcons (intern ("ns-put-working-text"), Qnil
);
3921 obj
= Fcons (intern ("ns-unput-working-text"), Qnil
);
3922 kbd_fetch_ptr
= event
+ 1;
3923 if (used_mouse_menu
)
3924 *used_mouse_menu
= 1;
3928 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
3929 || defined (HAVE_NS)
3930 else if (event
->kind
== DELETE_WINDOW_EVENT
)
3932 /* Make an event (delete-frame (FRAME)). */
3933 obj
= Fcons (event
->frame_or_window
, Qnil
);
3934 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
3935 kbd_fetch_ptr
= event
+ 1;
3938 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
3939 || defined (HAVE_NS)
3940 else if (event
->kind
== ICONIFY_EVENT
)
3942 /* Make an event (iconify-frame (FRAME)). */
3943 obj
= Fcons (event
->frame_or_window
, Qnil
);
3944 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
3945 kbd_fetch_ptr
= event
+ 1;
3947 else if (event
->kind
== DEICONIFY_EVENT
)
3949 /* Make an event (make-frame-visible (FRAME)). */
3950 obj
= Fcons (event
->frame_or_window
, Qnil
);
3951 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
3952 kbd_fetch_ptr
= event
+ 1;
3955 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
3957 /* The value doesn't matter here; only the type is tested. */
3958 XSETBUFFER (obj
, current_buffer
);
3959 kbd_fetch_ptr
= event
+ 1;
3961 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
3962 || defined (HAVE_NS) || defined (USE_GTK)
3963 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
3965 kbd_fetch_ptr
= event
+ 1;
3966 input_pending
= readable_events (0);
3967 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
3968 x_activate_menubar (XFRAME (event
->frame_or_window
));
3971 #if defined (WINDOWSNT)
3972 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
3974 /* Make an event (language-change (FRAME CODEPAGE LANGUAGE-ID)). */
3975 obj
= Fcons (Qlanguage_change
,
3976 list3 (event
->frame_or_window
,
3977 make_number (event
->code
),
3978 make_number (event
->modifiers
)));
3979 kbd_fetch_ptr
= event
+ 1;
3982 else if (event
->kind
== SAVE_SESSION_EVENT
)
3984 obj
= Fcons (Qsave_session
, Fcons (event
->arg
, Qnil
));
3985 kbd_fetch_ptr
= event
+ 1;
3987 /* Just discard these, by returning nil.
3988 With MULTI_KBOARD, these events are used as placeholders
3989 when we need to randomly delete events from the queue.
3990 (They shouldn't otherwise be found in the buffer,
3991 but on some machines it appears they do show up
3992 even without MULTI_KBOARD.) */
3993 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
3994 mouse events during a popup-menu call. */
3995 else if (event
->kind
== NO_EVENT
)
3996 kbd_fetch_ptr
= event
+ 1;
3997 else if (event
->kind
== HELP_EVENT
)
3999 Lisp_Object object
, position
, help
, frame
, window
;
4001 frame
= event
->frame_or_window
;
4002 object
= event
->arg
;
4003 position
= make_number (event
->code
);
4006 clear_event (event
);
4008 kbd_fetch_ptr
= event
+ 1;
4009 if (!WINDOWP (window
))
4011 obj
= Fcons (Qhelp_echo
,
4012 list5 (frame
, help
, window
, object
, position
));
4014 else if (event
->kind
== FOCUS_IN_EVENT
)
4016 /* Notification of a FocusIn event. The frame receiving the
4017 focus is in event->frame_or_window. Generate a
4018 switch-frame event if necessary. */
4019 Lisp_Object frame
, focus
;
4021 frame
= event
->frame_or_window
;
4022 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4026 if (!EQ (frame
, internal_last_event_frame
)
4027 && !EQ (frame
, selected_frame
))
4028 obj
= make_lispy_switch_frame (frame
);
4029 internal_last_event_frame
= frame
;
4030 kbd_fetch_ptr
= event
+ 1;
4033 else if (event
->kind
== DBUS_EVENT
)
4035 obj
= make_lispy_event (event
);
4036 kbd_fetch_ptr
= event
+ 1;
4039 else if (event
->kind
== CONFIG_CHANGED_EVENT
)
4041 obj
= make_lispy_event (event
);
4042 kbd_fetch_ptr
= event
+ 1;
4046 /* If this event is on a different frame, return a switch-frame this
4047 time, and leave the event in the queue for next time. */
4051 frame
= event
->frame_or_window
;
4053 frame
= XCAR (frame
);
4054 else if (WINDOWP (frame
))
4055 frame
= WINDOW_FRAME (XWINDOW (frame
));
4057 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4061 if (! EQ (frame
, internal_last_event_frame
)
4062 && !EQ (frame
, selected_frame
))
4063 obj
= make_lispy_switch_frame (frame
);
4064 internal_last_event_frame
= frame
;
4066 /* If we didn't decide to make a switch-frame event, go ahead
4067 and build a real event from the queue entry. */
4071 obj
= make_lispy_event (event
);
4073 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
4074 || defined (HAVE_NS) || defined (USE_GTK)
4075 /* If this was a menu selection, then set the flag to inhibit
4076 writing to last_nonmenu_event. Don't do this if the event
4077 we're returning is (menu-bar), though; that indicates the
4078 beginning of the menu sequence, and we might as well leave
4079 that as the `event with parameters' for this selection. */
4081 && !EQ (event
->frame_or_window
, event
->arg
)
4082 && (event
->kind
== MENU_BAR_EVENT
4083 || event
->kind
== TOOL_BAR_EVENT
))
4084 *used_mouse_menu
= 1;
4087 /* certain system events are non-key events */
4089 && event
->kind
== NS_NONKEY_EVENT
)
4090 *used_mouse_menu
= 1;
4093 /* Wipe out this event, to catch bugs. */
4094 clear_event (event
);
4095 kbd_fetch_ptr
= event
+ 1;
4099 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4100 /* Try generating a mouse motion event. */
4101 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4103 FRAME_PTR f
= some_mouse_moved ();
4104 Lisp_Object bar_window
;
4105 enum scroll_bar_part part
;
4109 *kbp
= current_kboard
;
4110 /* Note that this uses F to determine which terminal to look at.
4111 If there is no valid info, it does not store anything
4112 so x remains nil. */
4115 /* XXX Can f or mouse_position_hook be NULL here? */
4116 if (f
&& FRAME_TERMINAL (f
)->mouse_position_hook
)
4117 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, 0, &bar_window
,
4122 /* Decide if we should generate a switch-frame event. Don't
4123 generate switch-frame events for motion outside of all Emacs
4129 frame
= FRAME_FOCUS_FRAME (f
);
4131 XSETFRAME (frame
, f
);
4133 if (! EQ (frame
, internal_last_event_frame
)
4134 && !EQ (frame
, selected_frame
))
4135 obj
= make_lispy_switch_frame (frame
);
4136 internal_last_event_frame
= frame
;
4139 /* If we didn't decide to make a switch-frame event, go ahead and
4140 return a mouse-motion event. */
4141 if (!NILP (x
) && NILP (obj
))
4142 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, t
);
4144 #endif /* HAVE_MOUSE || HAVE GPM */
4146 /* We were promised by the above while loop that there was
4147 something for us to read! */
4150 input_pending
= readable_events (0);
4152 Vlast_event_frame
= internal_last_event_frame
;
4157 /* Process any non-user-visible events (currently X selection events),
4158 without reading any user-visible events. */
4161 process_special_events (void)
4163 struct input_event
*event
;
4165 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; ++event
)
4167 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
4170 if (event
== kbd_store_ptr
)
4174 /* If we find a stored X selection request, handle it now. */
4175 if (event
->kind
== SELECTION_REQUEST_EVENT
4176 || event
->kind
== SELECTION_CLEAR_EVENT
)
4180 /* Remove the event from the fifo buffer before processing;
4181 otherwise swallow_events called recursively could see it
4182 and process it again. To do this, we move the events
4183 between kbd_fetch_ptr and EVENT one slot to the right,
4186 struct input_event copy
= *event
;
4187 struct input_event
*beg
4188 = (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
4189 ? kbd_buffer
: kbd_fetch_ptr
;
4192 memmove (beg
+ 1, beg
, (event
- beg
) * sizeof (struct input_event
));
4193 else if (event
< beg
)
4195 if (event
> kbd_buffer
)
4196 memmove (kbd_buffer
+ 1, kbd_buffer
,
4197 (event
- kbd_buffer
) * sizeof (struct input_event
));
4198 *kbd_buffer
= *(kbd_buffer
+ KBD_BUFFER_SIZE
- 1);
4199 if (beg
< kbd_buffer
+ KBD_BUFFER_SIZE
- 1)
4200 memmove (beg
+ 1, beg
,
4201 (kbd_buffer
+ KBD_BUFFER_SIZE
- 1 - beg
)
4202 * sizeof (struct input_event
));
4205 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
4206 kbd_fetch_ptr
= kbd_buffer
+ 1;
4210 /* X wants last_event_timestamp for selection ownership. */
4211 last_event_timestamp
= copy
.timestamp
;
4212 input_pending
= readable_events (0);
4213 x_handle_selection_event (©
);
4215 /* We're getting selection request events, but we don't have
4223 /* Process any events that are not user-visible, run timer events that
4224 are ripe, and return, without reading any user-visible events. */
4227 swallow_events (int do_display
)
4231 process_special_events ();
4233 old_timers_run
= timers_run
;
4234 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
4236 if (timers_run
!= old_timers_run
&& do_display
)
4237 redisplay_preserve_echo_area (7);
4240 /* Record the start of when Emacs is idle,
4241 for the sake of running idle-time timers. */
4244 timer_start_idle (void)
4248 /* If we are already in the idle state, do nothing. */
4249 if (EMACS_TIME_VALID_P (timer_idleness_start_time
))
4252 timer_idleness_start_time
= current_emacs_time ();
4253 timer_last_idleness_start_time
= timer_idleness_start_time
;
4255 /* Mark all idle-time timers as once again candidates for running. */
4256 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4260 timer
= XCAR (timers
);
4262 if (!VECTORP (timer
) || ASIZE (timer
) != 9)
4264 ASET (timer
, 0, Qnil
);
4268 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4271 timer_stop_idle (void)
4273 timer_idleness_start_time
= invalid_emacs_time ();
4276 /* Resume idle timer from last idle start time. */
4279 timer_resume_idle (void)
4281 if (EMACS_TIME_VALID_P (timer_idleness_start_time
))
4284 timer_idleness_start_time
= timer_last_idleness_start_time
;
4287 /* This is only for debugging. */
4288 struct input_event last_timer_event EXTERNALLY_VISIBLE
;
4290 /* List of elisp functions to call, delayed because they were generated in
4291 a context where Elisp could not be safely run (e.g. redisplay, signal,
4292 ...). Each element has the form (FUN . ARGS). */
4293 Lisp_Object pending_funcalls
;
4295 /* If TIMER is a valid timer, return nonzero and place its value into
4296 *RESULT. Otherwise return zero. */
4298 decode_timer (Lisp_Object timer
, EMACS_TIME
*result
)
4300 Lisp_Object
*vector
;
4302 if (! (VECTORP (timer
) && ASIZE (timer
) == 9))
4304 vector
= XVECTOR (timer
)->contents
;
4305 if (! NILP (vector
[0]))
4308 return decode_time_components (vector
[1], vector
[2], vector
[3], vector
[4],
4313 /* Check whether a timer has fired. To prevent larger problems we simply
4314 disregard elements that are not proper timers. Do not make a circular
4315 timer list for the time being.
4317 Returns the time to wait until the next timer fires. If a
4318 timer is triggering now, return zero.
4319 If no timer is active, return -1.
4321 If a timer is ripe, we run it, with quitting turned off.
4322 In that case we return 0 to indicate that a new timer_check_2 call
4326 timer_check_2 (void)
4328 EMACS_TIME nexttime
;
4330 EMACS_TIME idleness_now
;
4331 Lisp_Object timers
, idle_timers
, chosen_timer
;
4332 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4334 nexttime
= invalid_emacs_time ();
4336 /* Always consider the ordinary timers. */
4337 timers
= Vtimer_list
;
4338 /* Consider the idle timers only if Emacs is idle. */
4339 if (EMACS_TIME_VALID_P (timer_idleness_start_time
))
4340 idle_timers
= Vtimer_idle_list
;
4343 chosen_timer
= Qnil
;
4344 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4346 /* First run the code that was delayed. */
4347 while (CONSP (pending_funcalls
))
4349 Lisp_Object funcall
= XCAR (pending_funcalls
);
4350 pending_funcalls
= XCDR (pending_funcalls
);
4351 safe_call2 (Qapply
, XCAR (funcall
), XCDR (funcall
));
4354 if (CONSP (timers
) || CONSP (idle_timers
))
4356 now
= current_emacs_time ();
4357 idleness_now
= (EMACS_TIME_VALID_P (timer_idleness_start_time
)
4358 ? sub_emacs_time (now
, timer_idleness_start_time
)
4359 : make_emacs_time (0, 0));
4362 while (CONSP (timers
) || CONSP (idle_timers
))
4364 Lisp_Object
*vector
;
4365 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4366 EMACS_TIME timer_time
, idle_timer_time
;
4367 EMACS_TIME difference
;
4368 EMACS_TIME timer_difference
= invalid_emacs_time ();
4369 EMACS_TIME idle_timer_difference
= invalid_emacs_time ();
4370 int ripe
, timer_ripe
= 0, idle_timer_ripe
= 0;
4372 /* Set TIMER and TIMER_DIFFERENCE
4373 based on the next ordinary timer.
4374 TIMER_DIFFERENCE is the distance in time from NOW to when
4375 this timer becomes ripe (negative if it's already ripe).
4376 Skip past invalid timers and timers already handled. */
4379 timer
= XCAR (timers
);
4380 if (! decode_timer (timer
, &timer_time
))
4382 timers
= XCDR (timers
);
4386 timer_ripe
= EMACS_TIME_LE (timer_time
, now
);
4387 timer_difference
= (timer_ripe
4388 ? sub_emacs_time (now
, timer_time
)
4389 : sub_emacs_time (timer_time
, now
));
4392 /* Likewise for IDLE_TIMER and IDLE_TIMER_DIFFERENCE
4393 based on the next idle timer. */
4394 if (CONSP (idle_timers
))
4396 idle_timer
= XCAR (idle_timers
);
4397 if (! decode_timer (idle_timer
, &idle_timer_time
))
4399 idle_timers
= XCDR (idle_timers
);
4403 idle_timer_ripe
= EMACS_TIME_LE (idle_timer_time
, idleness_now
);
4404 idle_timer_difference
=
4406 ? sub_emacs_time (idleness_now
, idle_timer_time
)
4407 : sub_emacs_time (idle_timer_time
, idleness_now
));
4410 /* Decide which timer is the next timer,
4411 and set CHOSEN_TIMER, DIFFERENCE, and RIPE accordingly.
4412 Also step down the list where we found that timer. */
4414 if (EMACS_TIME_VALID_P (timer_difference
)
4415 && (! EMACS_TIME_VALID_P (idle_timer_difference
)
4416 || idle_timer_ripe
< timer_ripe
4417 || (idle_timer_ripe
== timer_ripe
4419 ? EMACS_TIME_LT (idle_timer_difference
,
4421 : EMACS_TIME_LT (timer_difference
,
4422 idle_timer_difference
)))))
4424 chosen_timer
= timer
;
4425 timers
= XCDR (timers
);
4426 difference
= timer_difference
;
4431 chosen_timer
= idle_timer
;
4432 idle_timers
= XCDR (idle_timers
);
4433 difference
= idle_timer_difference
;
4434 ripe
= idle_timer_ripe
;
4437 /* If timer is ripe, run it if it hasn't been run. */
4440 vector
= XVECTOR (chosen_timer
)->contents
;
4441 if (NILP (vector
[0]))
4443 ptrdiff_t count
= SPECPDL_INDEX ();
4444 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4446 /* Mark the timer as triggered to prevent problems if the lisp
4447 code fails to reschedule it right. */
4450 specbind (Qinhibit_quit
, Qt
);
4452 call1 (Qtimer_event_handler
, chosen_timer
);
4453 Vdeactivate_mark
= old_deactivate_mark
;
4455 unbind_to (count
, Qnil
);
4457 /* Since we have handled the event,
4458 we don't need to tell the caller to wake up and do it. */
4459 /* But the caller must still wait for the next timer, so
4460 return 0 to indicate that. */
4463 nexttime
= make_emacs_time (0, 0);
4466 /* When we encounter a timer that is still waiting,
4467 return the amount of time to wait before it is ripe. */
4474 /* No timers are pending in the future. */
4475 /* Return 0 if we generated an event, and -1 if not. */
4481 /* Check whether a timer has fired. To prevent larger problems we simply
4482 disregard elements that are not proper timers. Do not make a circular
4483 timer list for the time being.
4485 Returns the time to wait until the next timer fires.
4486 If no timer is active, return an invalid value.
4488 As long as any timer is ripe, we run it. */
4493 EMACS_TIME nexttime
;
4497 nexttime
= timer_check_2 ();
4499 while (EMACS_SECS (nexttime
) == 0 && EMACS_NSECS (nexttime
) == 0);
4504 DEFUN ("current-idle-time", Fcurrent_idle_time
, Scurrent_idle_time
, 0, 0, 0,
4505 doc
: /* Return the current length of Emacs idleness, or nil.
4506 The value when Emacs is idle is a list of four integers (HIGH LOW USEC PSEC)
4507 in the same style as (current-time).
4509 The value when Emacs is not idle is nil.
4511 NSEC is a multiple of the system clock resolution. */)
4514 if (EMACS_TIME_VALID_P (timer_idleness_start_time
))
4515 return make_lisp_time (sub_emacs_time (current_emacs_time (),
4516 timer_idleness_start_time
));
4521 /* Caches for modify_event_symbol. */
4522 static Lisp_Object accent_key_syms
;
4523 static Lisp_Object func_key_syms
;
4524 static Lisp_Object mouse_syms
;
4525 static Lisp_Object wheel_syms
;
4526 static Lisp_Object drag_n_drop_syms
;
4528 /* This is a list of keysym codes for special "accent" characters.
4529 It parallels lispy_accent_keys. */
4531 static const int lispy_accent_codes
[] =
4533 #ifdef XK_dead_circumflex
4538 #ifdef XK_dead_grave
4543 #ifdef XK_dead_tilde
4548 #ifdef XK_dead_diaeresis
4553 #ifdef XK_dead_macron
4558 #ifdef XK_dead_degree
4563 #ifdef XK_dead_acute
4568 #ifdef XK_dead_cedilla
4573 #ifdef XK_dead_breve
4578 #ifdef XK_dead_ogonek
4583 #ifdef XK_dead_caron
4588 #ifdef XK_dead_doubleacute
4589 XK_dead_doubleacute
,
4593 #ifdef XK_dead_abovedot
4598 #ifdef XK_dead_abovering
4608 #ifdef XK_dead_belowdot
4613 #ifdef XK_dead_voiced_sound
4614 XK_dead_voiced_sound
,
4618 #ifdef XK_dead_semivoiced_sound
4619 XK_dead_semivoiced_sound
,
4635 /* This is a list of Lisp names for special "accent" characters.
4636 It parallels lispy_accent_codes. */
4638 static const char *const lispy_accent_keys
[] =
4656 "dead-voiced-sound",
4657 "dead-semivoiced-sound",
4663 #define FUNCTION_KEY_OFFSET 0x0
4665 const char *const lispy_function_keys
[] =
4669 0, /* VK_LBUTTON 0x01 */
4670 0, /* VK_RBUTTON 0x02 */
4671 "cancel", /* VK_CANCEL 0x03 */
4672 0, /* VK_MBUTTON 0x04 */
4674 0, 0, 0, /* 0x05 .. 0x07 */
4676 "backspace", /* VK_BACK 0x08 */
4677 "tab", /* VK_TAB 0x09 */
4679 0, 0, /* 0x0A .. 0x0B */
4681 "clear", /* VK_CLEAR 0x0C */
4682 "return", /* VK_RETURN 0x0D */
4684 0, 0, /* 0x0E .. 0x0F */
4686 0, /* VK_SHIFT 0x10 */
4687 0, /* VK_CONTROL 0x11 */
4688 0, /* VK_MENU 0x12 */
4689 "pause", /* VK_PAUSE 0x13 */
4690 "capslock", /* VK_CAPITAL 0x14 */
4691 "kana", /* VK_KANA/VK_HANGUL 0x15 */
4693 "junja", /* VK_JUNJA 0x17 */
4694 "final", /* VK_FINAL 0x18 */
4695 "kanji", /* VK_KANJI/VK_HANJA 0x19 */
4697 "escape", /* VK_ESCAPE 0x1B */
4698 "convert", /* VK_CONVERT 0x1C */
4699 "non-convert", /* VK_NONCONVERT 0x1D */
4700 "accept", /* VK_ACCEPT 0x1E */
4701 "mode-change", /* VK_MODECHANGE 0x1F */
4702 0, /* VK_SPACE 0x20 */
4703 "prior", /* VK_PRIOR 0x21 */
4704 "next", /* VK_NEXT 0x22 */
4705 "end", /* VK_END 0x23 */
4706 "home", /* VK_HOME 0x24 */
4707 "left", /* VK_LEFT 0x25 */
4708 "up", /* VK_UP 0x26 */
4709 "right", /* VK_RIGHT 0x27 */
4710 "down", /* VK_DOWN 0x28 */
4711 "select", /* VK_SELECT 0x29 */
4712 "print", /* VK_PRINT 0x2A */
4713 "execute", /* VK_EXECUTE 0x2B */
4714 "snapshot", /* VK_SNAPSHOT 0x2C */
4715 "insert", /* VK_INSERT 0x2D */
4716 "delete", /* VK_DELETE 0x2E */
4717 "help", /* VK_HELP 0x2F */
4719 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4721 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4723 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4725 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4727 0, 0, 0, 0, 0, 0, 0, 0, 0,
4728 0, 0, 0, 0, 0, 0, 0, 0, 0,
4729 0, 0, 0, 0, 0, 0, 0, 0,
4731 "lwindow", /* VK_LWIN 0x5B */
4732 "rwindow", /* VK_RWIN 0x5C */
4733 "apps", /* VK_APPS 0x5D */
4736 "kp-0", /* VK_NUMPAD0 0x60 */
4737 "kp-1", /* VK_NUMPAD1 0x61 */
4738 "kp-2", /* VK_NUMPAD2 0x62 */
4739 "kp-3", /* VK_NUMPAD3 0x63 */
4740 "kp-4", /* VK_NUMPAD4 0x64 */
4741 "kp-5", /* VK_NUMPAD5 0x65 */
4742 "kp-6", /* VK_NUMPAD6 0x66 */
4743 "kp-7", /* VK_NUMPAD7 0x67 */
4744 "kp-8", /* VK_NUMPAD8 0x68 */
4745 "kp-9", /* VK_NUMPAD9 0x69 */
4746 "kp-multiply", /* VK_MULTIPLY 0x6A */
4747 "kp-add", /* VK_ADD 0x6B */
4748 "kp-separator", /* VK_SEPARATOR 0x6C */
4749 "kp-subtract", /* VK_SUBTRACT 0x6D */
4750 "kp-decimal", /* VK_DECIMAL 0x6E */
4751 "kp-divide", /* VK_DIVIDE 0x6F */
4752 "f1", /* VK_F1 0x70 */
4753 "f2", /* VK_F2 0x71 */
4754 "f3", /* VK_F3 0x72 */
4755 "f4", /* VK_F4 0x73 */
4756 "f5", /* VK_F5 0x74 */
4757 "f6", /* VK_F6 0x75 */
4758 "f7", /* VK_F7 0x76 */
4759 "f8", /* VK_F8 0x77 */
4760 "f9", /* VK_F9 0x78 */
4761 "f10", /* VK_F10 0x79 */
4762 "f11", /* VK_F11 0x7A */
4763 "f12", /* VK_F12 0x7B */
4764 "f13", /* VK_F13 0x7C */
4765 "f14", /* VK_F14 0x7D */
4766 "f15", /* VK_F15 0x7E */
4767 "f16", /* VK_F16 0x7F */
4768 "f17", /* VK_F17 0x80 */
4769 "f18", /* VK_F18 0x81 */
4770 "f19", /* VK_F19 0x82 */
4771 "f20", /* VK_F20 0x83 */
4772 "f21", /* VK_F21 0x84 */
4773 "f22", /* VK_F22 0x85 */
4774 "f23", /* VK_F23 0x86 */
4775 "f24", /* VK_F24 0x87 */
4777 0, 0, 0, 0, /* 0x88 .. 0x8B */
4778 0, 0, 0, 0, /* 0x8C .. 0x8F */
4780 "kp-numlock", /* VK_NUMLOCK 0x90 */
4781 "scroll", /* VK_SCROLL 0x91 */
4782 /* Not sure where the following block comes from.
4783 Windows headers have NEC and Fujitsu specific keys in
4784 this block, but nothing generic. */
4785 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4786 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4787 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4788 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4789 "kp-end", /* VK_NUMPAD_END 0x96 */
4790 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4791 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4792 "kp-up", /* VK_NUMPAD_UP 0x99 */
4793 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4794 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4795 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4796 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4798 0, 0, /* 0x9E .. 0x9F */
4801 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4802 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4803 * No other API or message will distinguish left and right keys this way.
4808 /* Multimedia keys. These are handled as WM_APPCOMMAND, which allows us
4809 to enable them selectively, and gives access to a few more functions.
4810 See lispy_multimedia_keys below. */
4811 0, 0, 0, 0, 0, 0, 0, /* 0xA6 .. 0xAC Browser */
4812 0, 0, 0, /* 0xAD .. 0xAF Volume */
4813 0, 0, 0, 0, /* 0xB0 .. 0xB3 Media */
4814 0, 0, 0, 0, /* 0xB4 .. 0xB7 Apps */
4816 /* 0xB8 .. 0xC0 "OEM" keys - all seem to be punctuation. */
4817 0, 0, 0, 0, 0, 0, 0, 0, 0,
4819 /* 0xC1 - 0xDA unallocated, 0xDB-0xDF more OEM keys */
4820 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4821 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4824 "ax", /* VK_OEM_AX 0xE1 */
4825 0, /* VK_OEM_102 0xE2 */
4826 "ico-help", /* VK_ICO_HELP 0xE3 */
4827 "ico-00", /* VK_ICO_00 0xE4 */
4828 0, /* VK_PROCESSKEY 0xE5 - used by IME */
4829 "ico-clear", /* VK_ICO_CLEAR 0xE6 */
4830 0, /* VK_PACKET 0xE7 - used to pass Unicode chars */
4832 "reset", /* VK_OEM_RESET 0xE9 */
4833 "jump", /* VK_OEM_JUMP 0xEA */
4834 "oem-pa1", /* VK_OEM_PA1 0xEB */
4835 "oem-pa2", /* VK_OEM_PA2 0xEC */
4836 "oem-pa3", /* VK_OEM_PA3 0xED */
4837 "wsctrl", /* VK_OEM_WSCTRL 0xEE */
4838 "cusel", /* VK_OEM_CUSEL 0xEF */
4839 "oem-attn", /* VK_OEM_ATTN 0xF0 */
4840 "finish", /* VK_OEM_FINISH 0xF1 */
4841 "copy", /* VK_OEM_COPY 0xF2 */
4842 "auto", /* VK_OEM_AUTO 0xF3 */
4843 "enlw", /* VK_OEM_ENLW 0xF4 */
4844 "backtab", /* VK_OEM_BACKTAB 0xF5 */
4845 "attn", /* VK_ATTN 0xF6 */
4846 "crsel", /* VK_CRSEL 0xF7 */
4847 "exsel", /* VK_EXSEL 0xF8 */
4848 "ereof", /* VK_EREOF 0xF9 */
4849 "play", /* VK_PLAY 0xFA */
4850 "zoom", /* VK_ZOOM 0xFB */
4851 "noname", /* VK_NONAME 0xFC */
4852 "pa1", /* VK_PA1 0xFD */
4853 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4857 /* Some of these duplicate the "Media keys" on newer keyboards,
4858 but they are delivered to the application in a different way. */
4859 static const char *const lispy_multimedia_keys
[] =
4867 "browser-favorites",
4904 "toggle-dictate-command",
4910 "media-fast-forward",
4913 "media-channel-down"
4916 #else /* not HAVE_NTGUI */
4918 /* This should be dealt with in XTread_socket now, and that doesn't
4919 depend on the client system having the Kana syms defined. See also
4920 the XK_kana_A case below. */
4923 static const char *const lispy_kana_keys
[] =
4925 /* X Keysym value */
4926 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4927 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4928 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4929 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4930 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4931 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4932 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4933 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4934 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4935 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4936 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4937 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4938 "kana-i", "kana-u", "kana-e", "kana-o",
4939 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4940 "prolongedsound", "kana-A", "kana-I", "kana-U",
4941 "kana-E", "kana-O", "kana-KA", "kana-KI",
4942 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4943 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4944 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4945 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4946 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4947 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4948 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4949 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4950 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4951 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4952 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4953 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4955 #endif /* XK_kana_A */
4958 #define FUNCTION_KEY_OFFSET 0xff00
4960 /* You'll notice that this table is arranged to be conveniently
4961 indexed by X Windows keysym values. */
4962 static const char *const lispy_function_keys
[] =
4964 /* X Keysym value */
4966 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4967 "backspace", "tab", "linefeed", "clear",
4969 0, 0, 0, "pause", /* 0xff10...1f */
4970 0, 0, 0, 0, 0, 0, 0, "escape",
4972 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4973 "romaji", "hiragana", "katakana", "hiragana-katakana",
4974 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4975 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4976 "eisu-toggle", /* 0xff30...3f */
4977 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4978 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4980 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4981 "down", "prior", "next", "end",
4982 "begin", 0, 0, 0, 0, 0, 0, 0,
4983 "select", /* 0xff60 */ /* IsMiscFunctionKey */
4994 "break", /* 0xff6b */
4997 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
4998 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
4999 "kp-space", /* 0xff80 */ /* IsKeypadKey */
5000 0, 0, 0, 0, 0, 0, 0, 0,
5001 "kp-tab", /* 0xff89 */
5003 "kp-enter", /* 0xff8d */
5005 "kp-f1", /* 0xff91 */
5009 "kp-home", /* 0xff95 */
5014 "kp-prior", /* kp-page-up */
5015 "kp-next", /* kp-page-down */
5021 0, 0, 0, 0, 0, 0, 0, 0, 0,
5022 "kp-multiply", /* 0xffaa */
5027 "kp-divide", /* 0xffaf */
5028 "kp-0", /* 0xffb0 */
5029 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
5032 "kp-equal", /* 0xffbd */
5033 "f1", /* 0xffbe */ /* IsFunctionKey */
5035 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
5036 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
5037 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
5038 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
5039 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
5040 0, 0, 0, 0, 0, 0, 0, 0,
5041 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
5042 0, 0, 0, 0, 0, 0, 0, "delete"
5045 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
5046 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
5048 static const char *const iso_lispy_function_keys
[] =
5050 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
5051 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
5052 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
5053 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
5054 "iso-lefttab", /* 0xfe20 */
5055 "iso-move-line-up", "iso-move-line-down",
5056 "iso-partial-line-up", "iso-partial-line-down",
5057 "iso-partial-space-left", "iso-partial-space-right",
5058 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
5059 "iso-release-margin-left", "iso-release-margin-right",
5060 "iso-release-both-margins",
5061 "iso-fast-cursor-left", "iso-fast-cursor-right",
5062 "iso-fast-cursor-up", "iso-fast-cursor-down",
5063 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
5064 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
5067 #endif /* not HAVE_NTGUI */
5069 static Lisp_Object Vlispy_mouse_stem
;
5071 static const char *const lispy_wheel_names
[] =
5073 "wheel-up", "wheel-down", "wheel-left", "wheel-right"
5076 /* drag-n-drop events are generated when a set of selected files are
5077 dragged from another application and dropped onto an Emacs window. */
5078 static const char *const lispy_drag_n_drop_names
[] =
5083 /* Scroll bar parts. */
5084 static Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
5085 Lisp_Object Qup
, Qdown
, Qbottom
;
5086 static Lisp_Object Qend_scroll
;
5088 static Lisp_Object Qratio
;
5090 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
5091 static Lisp_Object
*const scroll_bar_parts
[] = {
5092 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
5093 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
5096 /* A vector, indexed by button number, giving the down-going location
5097 of currently depressed buttons, both scroll bar and non-scroll bar.
5099 The elements have the form
5100 (BUTTON-NUMBER MODIFIER-MASK . REST)
5101 where REST is the cdr of a position as it would be reported in the event.
5103 The make_lispy_event function stores positions here to tell the
5104 difference between click and drag events, and to store the starting
5105 location to be included in drag events. */
5107 static Lisp_Object button_down_location
;
5109 /* Information about the most recent up-going button event: Which
5110 button, what location, and what time. */
5112 static int last_mouse_button
;
5113 static int last_mouse_x
;
5114 static int last_mouse_y
;
5115 static Time button_down_time
;
5117 /* The number of clicks in this multiple-click. */
5119 static int double_click_count
;
5121 /* X and Y are frame-relative coordinates for a click or wheel event.
5122 Return a Lisp-style event list. */
5125 make_lispy_position (struct frame
*f
, Lisp_Object x
, Lisp_Object y
,
5128 enum window_part part
;
5129 Lisp_Object posn
= Qnil
;
5130 Lisp_Object extra_info
= Qnil
;
5131 /* Coordinate pixel positions to return. */
5132 int xret
= 0, yret
= 0;
5133 /* The window under frame pixel coordinates (x,y) */
5134 Lisp_Object window
= f
5135 ? window_from_coordinates (f
, XINT (x
), XINT (y
), &part
, 0)
5138 if (WINDOWP (window
))
5140 /* It's a click in window WINDOW at frame coordinates (X,Y) */
5141 struct window
*w
= XWINDOW (window
);
5142 Lisp_Object string_info
= Qnil
;
5143 ptrdiff_t textpos
= -1;
5144 int col
= -1, row
= -1;
5145 int dx
= -1, dy
= -1;
5146 int width
= -1, height
= -1;
5147 Lisp_Object object
= Qnil
;
5149 /* Pixel coordinates relative to the window corner. */
5150 int wx
= XINT (x
) - WINDOW_LEFT_EDGE_X (w
);
5151 int wy
= XINT (y
) - WINDOW_TOP_EDGE_Y (w
);
5153 /* For text area clicks, return X, Y relative to the corner of
5154 this text area. Note that dX, dY etc are set below, by
5155 buffer_posn_from_coords. */
5156 if (part
== ON_TEXT
)
5158 xret
= XINT (x
) - window_box_left (w
, TEXT_AREA
);
5159 yret
= wy
- WINDOW_HEADER_LINE_HEIGHT (w
);
5161 /* For mode line and header line clicks, return X, Y relative to
5162 the left window edge. Use mode_line_string to look for a
5163 string on the click position. */
5164 else if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
5169 posn
= (part
== ON_MODE_LINE
) ? Qmode_line
: Qheader_line
;
5170 /* Note that mode_line_string takes COL, ROW as pixels and
5171 converts them to characters. */
5174 string
= mode_line_string (w
, part
, &col
, &row
, &charpos
,
5175 &object
, &dx
, &dy
, &width
, &height
);
5176 if (STRINGP (string
))
5177 string_info
= Fcons (string
, make_number (charpos
));
5178 textpos
= (w
== XWINDOW (selected_window
)
5179 && current_buffer
== XBUFFER (w
->buffer
))
5180 ? PT
: XMARKER (w
->pointm
)->charpos
;
5185 /* For fringes and margins, Y is relative to the area's (and the
5186 window's) top edge, while X is meaningless. */
5187 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5192 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5195 string
= marginal_area_string (w
, part
, &col
, &row
, &charpos
,
5196 &object
, &dx
, &dy
, &width
, &height
);
5197 if (STRINGP (string
))
5198 string_info
= Fcons (string
, make_number (charpos
));
5199 yret
= wy
- WINDOW_HEADER_LINE_HEIGHT (w
);
5201 else if (part
== ON_LEFT_FRINGE
)
5203 posn
= Qleft_fringe
;
5206 - (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5207 ? 0 : window_box_width (w
, LEFT_MARGIN_AREA
));
5208 dy
= yret
= wy
- WINDOW_HEADER_LINE_HEIGHT (w
);
5210 else if (part
== ON_RIGHT_FRINGE
)
5212 posn
= Qright_fringe
;
5215 - window_box_width (w
, LEFT_MARGIN_AREA
)
5216 - window_box_width (w
, TEXT_AREA
)
5217 - (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5218 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5220 dy
= yret
= wy
- WINDOW_HEADER_LINE_HEIGHT (w
);
5222 else if (part
== ON_VERTICAL_BORDER
)
5224 posn
= Qvertical_line
;
5229 /* Nothing special for part == ON_SCROLL_BAR. */
5231 /* For clicks in the text area, fringes, or margins, call
5232 buffer_posn_from_coords to extract TEXTPOS, the buffer
5233 position nearest to the click. */
5236 Lisp_Object string2
, object2
= Qnil
;
5237 struct display_pos p
;
5239 int width2
, height2
;
5240 /* The pixel X coordinate passed to buffer_posn_from_coords
5241 is the X coordinate relative to the text area for
5242 text-area and right-margin clicks, zero otherwise. */
5244 = (part
== ON_TEXT
) ? xret
5245 : (part
== ON_RIGHT_FRINGE
|| part
== ON_RIGHT_MARGIN
)
5246 ? (XINT (x
) - window_box_left (w
, TEXT_AREA
))
5250 string2
= buffer_posn_from_coords (w
, &x2
, &y2
, &p
,
5251 &object2
, &dx2
, &dy2
,
5253 textpos
= CHARPOS (p
.pos
);
5254 if (col
< 0) col
= x2
;
5255 if (row
< 0) row
= y2
;
5256 if (dx
< 0) dx
= dx2
;
5257 if (dy
< 0) dy
= dy2
;
5258 if (width
< 0) width
= width2
;
5259 if (height
< 0) height
= height2
;
5263 posn
= make_number (textpos
);
5264 if (STRINGP (string2
))
5265 string_info
= Fcons (string2
,
5266 make_number (CHARPOS (p
.string_pos
)));
5272 #ifdef HAVE_WINDOW_SYSTEM
5273 if (IMAGEP (object
))
5275 Lisp_Object image_map
, hotspot
;
5276 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5278 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5280 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5281 posn
= XCAR (hotspot
);
5288 Fcons (make_number (dx
), make_number (dy
)),
5289 Fcons (make_number (width
), make_number (height
)));
5292 extra_info
= Fcons (string_info
,
5293 Fcons (make_number (textpos
),
5294 Fcons (Fcons (make_number (col
),
5299 XSETFRAME (window
, f
);
5303 return Fcons (window
,
5305 Fcons (Fcons (make_number (xret
),
5306 make_number (yret
)),
5307 Fcons (make_number (t
),
5311 /* Given a struct input_event, build the lisp event which represents
5312 it. If EVENT is 0, build a mouse movement event from the mouse
5313 movement buffer, which should have a movement event in it.
5315 Note that events must be passed to this function in the order they
5316 are received; this function stores the location of button presses
5317 in order to build drag events when the button is released. */
5320 make_lispy_event (struct input_event
*event
)
5324 switch (SWITCH_ENUM_CAST (event
->kind
))
5326 /* A simple keystroke. */
5327 case ASCII_KEYSTROKE_EVENT
:
5328 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5330 Lisp_Object lispy_c
;
5331 EMACS_INT c
= event
->code
;
5332 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
5335 eassert (c
== event
->code
);
5336 /* Turn ASCII characters into control characters
5338 if (event
->modifiers
& ctrl_modifier
)
5340 c
= make_ctrl_char (c
);
5341 event
->modifiers
&= ~ctrl_modifier
;
5345 /* Add in the other modifier bits. The shift key was taken care
5346 of by the X code. */
5347 c
|= (event
->modifiers
5348 & (meta_modifier
| alt_modifier
5349 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5350 /* Distinguish Shift-SPC from SPC. */
5351 if ((event
->code
) == 040
5352 && event
->modifiers
& shift_modifier
)
5353 c
|= shift_modifier
;
5354 button_down_time
= 0;
5355 XSETFASTINT (lispy_c
, c
);
5360 /* NS_NONKEY_EVENTs are just like NON_ASCII_KEYSTROKE_EVENTs,
5361 except that they are non-key events (last-nonmenu-event is nil). */
5362 case NS_NONKEY_EVENT
:
5365 /* A function key. The symbol may need to have modifier prefixes
5367 case NON_ASCII_KEYSTROKE_EVENT
:
5368 button_down_time
= 0;
5370 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5371 if (event
->code
== lispy_accent_codes
[i
])
5372 return modify_event_symbol (i
,
5374 Qfunction_key
, Qnil
,
5375 lispy_accent_keys
, &accent_key_syms
,
5376 (sizeof (lispy_accent_keys
)
5377 / sizeof (lispy_accent_keys
[0])));
5381 if (event
->code
>= 0x400 && event
->code
< 0x500)
5382 return modify_event_symbol (event
->code
- 0x400,
5383 event
->modifiers
& ~shift_modifier
,
5384 Qfunction_key
, Qnil
,
5385 lispy_kana_keys
, &func_key_syms
,
5386 (sizeof (lispy_kana_keys
)
5387 / sizeof (lispy_kana_keys
[0])));
5388 #endif /* XK_kana_A */
5391 #ifdef ISO_FUNCTION_KEY_OFFSET
5392 if (event
->code
< FUNCTION_KEY_OFFSET
5393 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5394 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5396 Qfunction_key
, Qnil
,
5397 iso_lispy_function_keys
, &func_key_syms
,
5398 (sizeof (iso_lispy_function_keys
)
5399 / sizeof (iso_lispy_function_keys
[0])));
5402 /* Handle system-specific or unknown keysyms. */
5403 if (event
->code
& (1 << 28)
5404 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5405 || (event
->code
- FUNCTION_KEY_OFFSET
5406 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5407 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5409 /* We need to use an alist rather than a vector as the cache
5410 since we can't make a vector long enough. */
5411 if (NILP (KVAR (current_kboard
, system_key_syms
)))
5412 KVAR (current_kboard
, system_key_syms
) = Fcons (Qnil
, Qnil
);
5413 return modify_event_symbol (event
->code
,
5416 KVAR (current_kboard
, Vsystem_key_alist
),
5417 0, &KVAR (current_kboard
, system_key_syms
),
5421 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5423 Qfunction_key
, Qnil
,
5424 lispy_function_keys
, &func_key_syms
,
5425 (sizeof (lispy_function_keys
)
5426 / sizeof (lispy_function_keys
[0])));
5429 case MULTIMEDIA_KEY_EVENT
:
5430 if (event
->code
< (sizeof (lispy_multimedia_keys
)
5431 / sizeof (lispy_multimedia_keys
[0]))
5432 && event
->code
> 0 && lispy_multimedia_keys
[event
->code
])
5434 return modify_event_symbol (event
->code
, event
->modifiers
,
5435 Qfunction_key
, Qnil
,
5436 lispy_multimedia_keys
, &func_key_syms
,
5437 (sizeof (lispy_multimedia_keys
)
5438 / sizeof (lispy_multimedia_keys
[0])));
5444 /* A mouse click. Figure out where it is, decide whether it's
5445 a press, click or drag, and build the appropriate structure. */
5446 case MOUSE_CLICK_EVENT
:
5447 #ifndef USE_TOOLKIT_SCROLL_BARS
5448 case SCROLL_BAR_CLICK_EVENT
:
5451 int button
= event
->code
;
5453 Lisp_Object position
;
5454 Lisp_Object
*start_pos_ptr
;
5455 Lisp_Object start_pos
;
5459 /* Build the position as appropriate for this mouse click. */
5460 if (event
->kind
== MOUSE_CLICK_EVENT
)
5462 struct frame
*f
= XFRAME (event
->frame_or_window
);
5463 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5467 /* Ignore mouse events that were made on frame that
5468 have been deleted. */
5469 if (! FRAME_LIVE_P (f
))
5472 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5473 /* EVENT->x and EVENT->y are frame-relative pixel
5474 coordinates at this place. Under old redisplay, COLUMN
5475 and ROW are set to frame relative glyph coordinates
5476 which are then used to determine whether this click is
5477 in a menu (non-toolkit version). */
5478 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5479 &column
, &row
, NULL
, 1);
5481 /* In the non-toolkit version, clicks on the menu bar
5482 are ordinary button events in the event buffer.
5483 Distinguish them, and invoke the menu.
5485 (In the toolkit version, the toolkit handles the menu bar
5486 and Emacs doesn't know about it until after the user
5487 makes a selection.) */
5488 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5489 && (event
->modifiers
& down_modifier
))
5491 Lisp_Object items
, item
;
5493 /* Find the menu bar item under `column'. */
5495 items
= FRAME_MENU_BAR_ITEMS (f
);
5496 for (i
= 0; i
< ASIZE (items
); i
+= 4)
5498 Lisp_Object pos
, string
;
5499 string
= AREF (items
, i
+ 1);
5500 pos
= AREF (items
, i
+ 3);
5503 if (column
>= XINT (pos
)
5504 && column
< XINT (pos
) + SCHARS (string
))
5506 item
= AREF (items
, i
);
5511 /* ELisp manual 2.4b says (x y) are window relative but
5512 code says they are frame-relative. */
5514 = Fcons (event
->frame_or_window
,
5516 Fcons (Fcons (event
->x
, event
->y
),
5517 Fcons (make_number (event
->timestamp
),
5520 return Fcons (item
, Fcons (position
, Qnil
));
5522 #endif /* not USE_X_TOOLKIT && not USE_GTK && not HAVE_NS */
5524 position
= make_lispy_position (f
, event
->x
, event
->y
,
5527 #ifndef USE_TOOLKIT_SCROLL_BARS
5530 /* It's a scrollbar click. */
5532 Lisp_Object portion_whole
;
5535 window
= event
->frame_or_window
;
5536 portion_whole
= Fcons (event
->x
, event
->y
);
5537 part
= *scroll_bar_parts
[(int) event
->part
];
5541 Fcons (Qvertical_scroll_bar
,
5542 Fcons (portion_whole
,
5543 Fcons (make_number (event
->timestamp
),
5544 Fcons (part
, Qnil
)))));
5546 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5548 if (button
>= ASIZE (button_down_location
))
5550 ptrdiff_t incr
= button
- ASIZE (button_down_location
) + 1;
5551 button_down_location
= larger_vector (button_down_location
,
5553 mouse_syms
= larger_vector (mouse_syms
, incr
, -1);
5556 start_pos_ptr
= &AREF (button_down_location
, button
);
5557 start_pos
= *start_pos_ptr
;
5558 *start_pos_ptr
= Qnil
;
5561 /* On window-system frames, use the value of
5562 double-click-fuzz as is. On other frames, interpret it
5563 as a multiple of 1/8 characters. */
5567 if (WINDOWP (event
->frame_or_window
))
5568 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5569 else if (FRAMEP (event
->frame_or_window
))
5570 f
= XFRAME (event
->frame_or_window
);
5574 if (FRAME_WINDOW_P (f
))
5575 fuzz
= double_click_fuzz
;
5577 fuzz
= double_click_fuzz
/ 8;
5579 is_double
= (button
== last_mouse_button
5580 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5581 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5582 && button_down_time
!= 0
5583 && (EQ (Vdouble_click_time
, Qt
)
5584 || (NATNUMP (Vdouble_click_time
)
5585 && (event
->timestamp
- button_down_time
5586 < XFASTINT (Vdouble_click_time
)))));
5589 last_mouse_button
= button
;
5590 last_mouse_x
= XINT (event
->x
);
5591 last_mouse_y
= XINT (event
->y
);
5593 /* If this is a button press, squirrel away the location, so
5594 we can decide later whether it was a click or a drag. */
5595 if (event
->modifiers
& down_modifier
)
5599 double_click_count
++;
5600 event
->modifiers
|= ((double_click_count
> 2)
5605 double_click_count
= 1;
5606 button_down_time
= event
->timestamp
;
5607 *start_pos_ptr
= Fcopy_alist (position
);
5608 ignore_mouse_drag_p
= 0;
5611 /* Now we're releasing a button - check the co-ordinates to
5612 see if this was a click or a drag. */
5613 else if (event
->modifiers
& up_modifier
)
5615 /* If we did not see a down before this up, ignore the up.
5616 Probably this happened because the down event chose a
5617 menu item. It would be an annoyance to treat the
5618 release of the button that chose the menu item as a
5621 if (!CONSP (start_pos
))
5624 event
->modifiers
&= ~up_modifier
;
5627 Lisp_Object new_down
, down
;
5628 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5630 /* The third element of every position
5631 should be the (x,y) pair. */
5632 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5633 new_down
= Fcar (Fcdr (Fcdr (position
)));
5636 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5638 xdiff
= XINT (XCAR (new_down
)) - XINT (XCAR (down
));
5639 ydiff
= XINT (XCDR (new_down
)) - XINT (XCDR (down
));
5642 if (ignore_mouse_drag_p
)
5644 event
->modifiers
|= click_modifier
;
5645 ignore_mouse_drag_p
= 0;
5647 else if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5648 && ydiff
< double_click_fuzz
&& ydiff
> - double_click_fuzz
5649 /* Maybe the mouse has moved a lot, caused scrolling, and
5650 eventually ended up at the same screen position (but
5651 not buffer position) in which case it is a drag, not
5653 /* FIXME: OTOH if the buffer position has changed
5654 because of a timer or process filter rather than
5655 because of mouse movement, it should be considered as
5656 a click. But mouse-drag-region completely ignores
5657 this case and it hasn't caused any real problem, so
5658 it's probably OK to ignore it as well. */
5659 && EQ (Fcar (Fcdr (start_pos
)), Fcar (Fcdr (position
))))
5660 /* Mouse hasn't moved (much). */
5661 event
->modifiers
|= click_modifier
;
5664 button_down_time
= 0;
5665 event
->modifiers
|= drag_modifier
;
5668 /* Don't check is_double; treat this as multiple
5669 if the down-event was multiple. */
5670 if (double_click_count
> 1)
5671 event
->modifiers
|= ((double_click_count
> 2)
5677 /* Every mouse event should either have the down_modifier or
5678 the up_modifier set. */
5682 /* Get the symbol we should use for the mouse click. */
5685 head
= modify_event_symbol (button
,
5687 Qmouse_click
, Vlispy_mouse_stem
,
5690 ASIZE (mouse_syms
));
5691 if (event
->modifiers
& drag_modifier
)
5696 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5699 Fcons (make_number (double_click_count
),
5709 case HORIZ_WHEEL_EVENT
:
5711 Lisp_Object position
;
5714 /* Build the position as appropriate for this mouse click. */
5715 struct frame
*f
= XFRAME (event
->frame_or_window
);
5717 /* Ignore wheel events that were made on frame that have been
5719 if (! FRAME_LIVE_P (f
))
5722 position
= make_lispy_position (f
, event
->x
, event
->y
,
5725 /* Set double or triple modifiers to indicate the wheel speed. */
5727 /* On window-system frames, use the value of
5728 double-click-fuzz as is. On other frames, interpret it
5729 as a multiple of 1/8 characters. */
5735 if (WINDOWP (event
->frame_or_window
))
5736 fr
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5737 else if (FRAMEP (event
->frame_or_window
))
5738 fr
= XFRAME (event
->frame_or_window
);
5742 fuzz
= FRAME_WINDOW_P (fr
)
5743 ? double_click_fuzz
: double_click_fuzz
/ 8;
5745 if (event
->modifiers
& up_modifier
)
5747 /* Emit a wheel-up event. */
5748 event
->modifiers
&= ~up_modifier
;
5751 else if (event
->modifiers
& down_modifier
)
5753 /* Emit a wheel-down event. */
5754 event
->modifiers
&= ~down_modifier
;
5758 /* Every wheel event should either have the down_modifier or
5759 the up_modifier set. */
5762 if (event
->kind
== HORIZ_WHEEL_EVENT
)
5765 is_double
= (last_mouse_button
== - (1 + symbol_num
)
5766 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5767 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5768 && button_down_time
!= 0
5769 && (EQ (Vdouble_click_time
, Qt
)
5770 || (NATNUMP (Vdouble_click_time
)
5771 && (event
->timestamp
- button_down_time
5772 < XFASTINT (Vdouble_click_time
)))));
5775 double_click_count
++;
5776 event
->modifiers
|= ((double_click_count
> 2)
5782 double_click_count
= 1;
5783 event
->modifiers
|= click_modifier
;
5786 button_down_time
= event
->timestamp
;
5787 /* Use a negative value to distinguish wheel from mouse button. */
5788 last_mouse_button
= - (1 + symbol_num
);
5789 last_mouse_x
= XINT (event
->x
);
5790 last_mouse_y
= XINT (event
->y
);
5792 /* Get the symbol we should use for the wheel event. */
5793 head
= modify_event_symbol (symbol_num
,
5799 ASIZE (wheel_syms
));
5802 if (event
->modifiers
& (double_modifier
| triple_modifier
))
5805 Fcons (make_number (double_click_count
),
5814 #ifdef USE_TOOLKIT_SCROLL_BARS
5816 /* We don't have down and up events if using toolkit scroll bars,
5817 so make this always a click event. Store in the `part' of
5818 the Lisp event a symbol which maps to the following actions:
5820 `above_handle' page up
5821 `below_handle' page down
5825 `bottom' bottom of buffer
5826 `handle' thumb has been dragged.
5827 `end-scroll' end of interaction with scroll bar
5829 The incoming input_event contains in its `part' member an
5830 index of type `enum scroll_bar_part' which we can use as an
5831 index in scroll_bar_parts to get the appropriate symbol. */
5833 case SCROLL_BAR_CLICK_EVENT
:
5835 Lisp_Object position
, head
, window
, portion_whole
, part
;
5837 window
= event
->frame_or_window
;
5838 portion_whole
= Fcons (event
->x
, event
->y
);
5839 part
= *scroll_bar_parts
[(int) event
->part
];
5843 Fcons (Qvertical_scroll_bar
,
5844 Fcons (portion_whole
,
5845 Fcons (make_number (event
->timestamp
),
5846 Fcons (part
, Qnil
)))));
5848 /* Always treat scroll bar events as clicks. */
5849 event
->modifiers
|= click_modifier
;
5850 event
->modifiers
&= ~up_modifier
;
5852 if (event
->code
>= ASIZE (mouse_syms
))
5853 mouse_syms
= larger_vector (mouse_syms
,
5854 event
->code
- ASIZE (mouse_syms
) + 1,
5857 /* Get the symbol we should use for the mouse click. */
5858 head
= modify_event_symbol (event
->code
,
5863 ASIZE (mouse_syms
));
5864 return Fcons (head
, Fcons (position
, Qnil
));
5867 #endif /* USE_TOOLKIT_SCROLL_BARS */
5869 case DRAG_N_DROP_EVENT
:
5872 Lisp_Object head
, position
;
5875 f
= XFRAME (event
->frame_or_window
);
5878 /* Ignore mouse events that were made on frames that
5879 have been deleted. */
5880 if (! FRAME_LIVE_P (f
))
5883 position
= make_lispy_position (f
, event
->x
, event
->y
,
5886 head
= modify_event_symbol (0, event
->modifiers
,
5888 lispy_drag_n_drop_names
,
5889 &drag_n_drop_syms
, 1);
5895 #endif /* HAVE_MOUSE */
5897 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
5898 || defined (HAVE_NS) || defined (USE_GTK)
5899 case MENU_BAR_EVENT
:
5900 if (EQ (event
->arg
, event
->frame_or_window
))
5901 /* This is the prefix key. We translate this to
5902 `(menu_bar)' because the code in keyboard.c for menu
5903 events, which we use, relies on this. */
5904 return Fcons (Qmenu_bar
, Qnil
);
5908 case SELECT_WINDOW_EVENT
:
5909 /* Make an event (select-window (WINDOW)). */
5910 return Fcons (Qselect_window
,
5911 Fcons (Fcons (event
->frame_or_window
, Qnil
),
5914 case TOOL_BAR_EVENT
:
5915 if (EQ (event
->arg
, event
->frame_or_window
))
5916 /* This is the prefix key. We translate this to
5917 `(tool_bar)' because the code in keyboard.c for tool bar
5918 events, which we use, relies on this. */
5919 return Fcons (Qtool_bar
, Qnil
);
5920 else if (SYMBOLP (event
->arg
))
5921 return apply_modifiers (event
->modifiers
, event
->arg
);
5924 case USER_SIGNAL_EVENT
:
5925 /* A user signal. */
5927 char *name
= find_user_signal_name (event
->code
);
5930 return intern (name
);
5933 case SAVE_SESSION_EVENT
:
5934 return Qsave_session
;
5939 return Fcons (Qdbus_event
, event
->arg
);
5941 #endif /* HAVE_DBUS */
5943 case CONFIG_CHANGED_EVENT
:
5944 return Fcons (Qconfig_changed_event
,
5946 Fcons (event
->frame_or_window
, Qnil
)));
5948 case GPM_CLICK_EVENT
:
5950 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
5951 Lisp_Object head
, position
;
5952 Lisp_Object
*start_pos_ptr
;
5953 Lisp_Object start_pos
;
5954 int button
= event
->code
;
5956 if (button
>= ASIZE (button_down_location
))
5958 ptrdiff_t incr
= button
- ASIZE (button_down_location
) + 1;
5959 button_down_location
= larger_vector (button_down_location
,
5961 mouse_syms
= larger_vector (mouse_syms
, incr
, -1);
5964 start_pos_ptr
= &AREF (button_down_location
, button
);
5965 start_pos
= *start_pos_ptr
;
5967 position
= make_lispy_position (f
, event
->x
, event
->y
,
5970 if (event
->modifiers
& down_modifier
)
5971 *start_pos_ptr
= Fcopy_alist (position
);
5972 else if (event
->modifiers
& (up_modifier
| drag_modifier
))
5974 if (!CONSP (start_pos
))
5976 event
->modifiers
&= ~up_modifier
;
5979 head
= modify_event_symbol (button
,
5981 Qmouse_click
, Vlispy_mouse_stem
,
5984 ASIZE (mouse_syms
));
5986 if (event
->modifiers
& drag_modifier
)
5991 else if (event
->modifiers
& double_modifier
)
5994 Fcons (make_number (2),
5996 else if (event
->modifiers
& triple_modifier
)
5999 Fcons (make_number (3),
6006 #endif /* HAVE_GPM */
6008 /* The 'kind' field of the event is something we don't recognize. */
6014 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
6017 make_lispy_movement (FRAME_PTR frame
, Lisp_Object bar_window
, enum scroll_bar_part part
,
6018 Lisp_Object x
, Lisp_Object y
, Time t
)
6020 /* Is it a scroll bar movement? */
6021 if (frame
&& ! NILP (bar_window
))
6023 Lisp_Object part_sym
;
6025 part_sym
= *scroll_bar_parts
[(int) part
];
6026 return Fcons (Qscroll_bar_movement
,
6027 Fcons (list5 (bar_window
,
6028 Qvertical_scroll_bar
,
6034 /* Or is it an ordinary mouse movement? */
6037 Lisp_Object position
;
6038 position
= make_lispy_position (frame
, x
, y
, t
);
6039 return list2 (Qmouse_movement
, position
);
6043 #endif /* HAVE_MOUSE || HAVE GPM */
6045 /* Construct a switch frame event. */
6047 make_lispy_switch_frame (Lisp_Object frame
)
6049 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
6052 /* Manipulating modifiers. */
6054 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
6056 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
6057 SYMBOL's name of the end of the modifiers; the string from this
6058 position is the unmodified symbol name.
6060 This doesn't use any caches. */
6063 parse_modifiers_uncached (Lisp_Object symbol
, ptrdiff_t *modifier_end
)
6069 CHECK_SYMBOL (symbol
);
6072 name
= SYMBOL_NAME (symbol
);
6074 for (i
= 0; i
< SBYTES (name
) - 1; )
6076 ptrdiff_t this_mod_end
= 0;
6079 /* See if the name continues with a modifier word.
6080 Check that the word appears, but don't check what follows it.
6081 Set this_mod and this_mod_end to record what we find. */
6083 switch (SREF (name
, i
))
6085 #define SINGLE_LETTER_MOD(BIT) \
6086 (this_mod_end = i + 1, this_mod = BIT)
6089 SINGLE_LETTER_MOD (alt_modifier
);
6093 SINGLE_LETTER_MOD (ctrl_modifier
);
6097 SINGLE_LETTER_MOD (hyper_modifier
);
6101 SINGLE_LETTER_MOD (meta_modifier
);
6105 SINGLE_LETTER_MOD (shift_modifier
);
6109 SINGLE_LETTER_MOD (super_modifier
);
6112 #undef SINGLE_LETTER_MOD
6114 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6115 if (i + LEN + 1 <= SBYTES (name) \
6116 && ! memcmp (SDATA (name) + i, NAME, LEN)) \
6118 this_mod_end = i + LEN; \
6123 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6124 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6125 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6129 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6131 #undef MULTI_LETTER_MOD
6135 /* If we found no modifier, stop looking for them. */
6136 if (this_mod_end
== 0)
6139 /* Check there is a dash after the modifier, so that it
6140 really is a modifier. */
6141 if (this_mod_end
>= SBYTES (name
)
6142 || SREF (name
, this_mod_end
) != '-')
6145 /* This modifier is real; look for another. */
6146 modifiers
|= this_mod
;
6147 i
= this_mod_end
+ 1;
6150 /* Should we include the `click' modifier? */
6151 if (! (modifiers
& (down_modifier
| drag_modifier
6152 | double_modifier
| triple_modifier
))
6153 && i
+ 7 == SBYTES (name
)
6154 && memcmp (SDATA (name
) + i
, "mouse-", 6) == 0
6155 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
6156 modifiers
|= click_modifier
;
6158 if (! (modifiers
& (double_modifier
| triple_modifier
))
6159 && i
+ 6 < SBYTES (name
)
6160 && memcmp (SDATA (name
) + i
, "wheel-", 6) == 0)
6161 modifiers
|= click_modifier
;
6169 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6170 prepended to the string BASE[0..BASE_LEN-1].
6171 This doesn't use any caches. */
6173 apply_modifiers_uncached (int modifiers
, char *base
, int base_len
, int base_len_byte
)
6175 /* Since BASE could contain nulls, we can't use intern here; we have
6176 to use Fintern, which expects a genuine Lisp_String, and keeps a
6178 char new_mods
[sizeof "A-C-H-M-S-s-down-drag-double-triple-"];
6184 /* Only the event queue may use the `up' modifier; it should always
6185 be turned into a click or drag event before presented to lisp code. */
6186 if (modifiers
& up_modifier
)
6189 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
6190 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
6191 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
6192 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
6193 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
6194 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
6195 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
6196 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
6197 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
6198 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
6199 /* The click modifier is denoted by the absence of other modifiers. */
6203 mod_len
= p
- new_mods
;
6207 Lisp_Object new_name
;
6209 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
6210 mod_len
+ base_len_byte
);
6211 memcpy (SDATA (new_name
), new_mods
, mod_len
);
6212 memcpy (SDATA (new_name
) + mod_len
, base
, base_len_byte
);
6214 return Fintern (new_name
, Qnil
);
6219 static const char *const modifier_names
[] =
6221 "up", "down", "drag", "click", "double", "triple", 0, 0,
6222 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6223 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6225 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6227 static Lisp_Object modifier_symbols
;
6229 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6231 lispy_modifier_list (int modifiers
)
6233 Lisp_Object modifier_list
;
6236 modifier_list
= Qnil
;
6237 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6238 if (modifiers
& (1<<i
))
6239 modifier_list
= Fcons (AREF (modifier_symbols
, i
),
6242 return modifier_list
;
6246 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6247 where UNMODIFIED is the unmodified form of SYMBOL,
6248 MASK is the set of modifiers present in SYMBOL's name.
6249 This is similar to parse_modifiers_uncached, but uses the cache in
6250 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6251 Qevent_symbol_elements property. */
6253 #define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
6256 parse_modifiers (Lisp_Object symbol
)
6258 Lisp_Object elements
;
6260 if (INTEGERP (symbol
))
6261 return (Fcons (make_number (KEY_TO_CHAR (symbol
)),
6262 Fcons (make_number (XINT (symbol
) & CHAR_MODIFIER_MASK
),
6264 else if (!SYMBOLP (symbol
))
6267 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6268 if (CONSP (elements
))
6273 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6274 Lisp_Object unmodified
;
6277 unmodified
= Fintern (make_string (SSDATA (SYMBOL_NAME (symbol
)) + end
,
6278 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6281 if (modifiers
& ~INTMASK
)
6283 XSETFASTINT (mask
, modifiers
);
6284 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6286 /* Cache the parsing results on SYMBOL. */
6287 Fput (symbol
, Qevent_symbol_element_mask
,
6289 Fput (symbol
, Qevent_symbol_elements
,
6290 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6292 /* Since we know that SYMBOL is modifiers applied to unmodified,
6293 it would be nice to put that in unmodified's cache.
6294 But we can't, since we're not sure that parse_modifiers is
6301 DEFUN ("internal-event-symbol-parse-modifiers", Fevent_symbol_parse_modifiers
,
6302 Sevent_symbol_parse_modifiers
, 1, 1, 0,
6303 doc
: /* Parse the event symbol. For internal use. */)
6304 (Lisp_Object symbol
)
6306 /* Fill the cache if needed. */
6307 parse_modifiers (symbol
);
6308 /* Ignore the result (which is stored on Qevent_symbol_element_mask)
6309 and use the Lispier representation stored on Qevent_symbol_elements
6311 return Fget (symbol
, Qevent_symbol_elements
);
6314 /* Apply the modifiers MODIFIERS to the symbol BASE.
6315 BASE must be unmodified.
6317 This is like apply_modifiers_uncached, but uses BASE's
6318 Qmodifier_cache property, if present. It also builds
6319 Qevent_symbol_elements properties, since it has that info anyway.
6321 apply_modifiers copies the value of BASE's Qevent_kind property to
6322 the modified symbol. */
6324 apply_modifiers (int modifiers
, Lisp_Object base
)
6326 Lisp_Object cache
, idx
, entry
, new_symbol
;
6328 /* Mask out upper bits. We don't know where this value's been. */
6329 modifiers
&= INTMASK
;
6331 if (INTEGERP (base
))
6332 return make_number (XINT (base
) | modifiers
);
6334 /* The click modifier never figures into cache indices. */
6335 cache
= Fget (base
, Qmodifier_cache
);
6336 XSETFASTINT (idx
, (modifiers
& ~click_modifier
));
6337 entry
= assq_no_quit (idx
, cache
);
6340 new_symbol
= XCDR (entry
);
6343 /* We have to create the symbol ourselves. */
6344 new_symbol
= apply_modifiers_uncached (modifiers
,
6345 SSDATA (SYMBOL_NAME (base
)),
6346 SCHARS (SYMBOL_NAME (base
)),
6347 SBYTES (SYMBOL_NAME (base
)));
6349 /* Add the new symbol to the base's cache. */
6350 entry
= Fcons (idx
, new_symbol
);
6351 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6353 /* We have the parsing info now for free, so we could add it to
6355 XSETFASTINT (idx, modifiers);
6356 Fput (new_symbol, Qevent_symbol_element_mask,
6357 Fcons (base, Fcons (idx, Qnil)));
6358 Fput (new_symbol, Qevent_symbol_elements,
6359 Fcons (base, lispy_modifier_list (modifiers)));
6360 Sadly, this is only correct if `base' is indeed a base event,
6361 which is not necessarily the case. -stef */
6364 /* Make sure this symbol is of the same kind as BASE.
6366 You'd think we could just set this once and for all when we
6367 intern the symbol above, but reorder_modifiers may call us when
6368 BASE's property isn't set right; we can't assume that just
6369 because it has a Qmodifier_cache property it must have its
6370 Qevent_kind set right as well. */
6371 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6375 kind
= Fget (base
, Qevent_kind
);
6377 Fput (new_symbol
, Qevent_kind
, kind
);
6384 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6385 return a symbol with the modifiers placed in the canonical order.
6386 Canonical order is alphabetical, except for down and drag, which
6387 always come last. The 'click' modifier is never written out.
6389 Fdefine_key calls this to make sure that (for example) C-M-foo
6390 and M-C-foo end up being equivalent in the keymap. */
6393 reorder_modifiers (Lisp_Object symbol
)
6395 /* It's hopefully okay to write the code this way, since everything
6396 will soon be in caches, and no consing will be done at all. */
6399 parsed
= parse_modifiers (symbol
);
6400 return apply_modifiers (XFASTINT (XCAR (XCDR (parsed
))),
6405 /* For handling events, we often want to produce a symbol whose name
6406 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6407 to some base, like the name of a function key or mouse button.
6408 modify_event_symbol produces symbols of this sort.
6410 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6411 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6414 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6415 into symbol names, or a string specifying a name stem used to
6416 construct a symbol name or the form `STEM-N', where N is the decimal
6417 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6418 non-nil; otherwise NAME_TABLE is used.
6420 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6421 persist between calls to modify_event_symbol that it can use to
6422 store a cache of the symbols it's generated for this NAME_TABLE
6423 before. The object stored there may be a vector or an alist.
6425 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6427 MODIFIERS is a set of modifier bits (as given in struct input_events)
6428 whose prefixes should be applied to the symbol name.
6430 SYMBOL_KIND is the value to be placed in the event_kind property of
6431 the returned symbol.
6433 The symbols we create are supposed to have an
6434 `event-symbol-elements' property, which lists the modifiers present
6435 in the symbol's name. */
6438 modify_event_symbol (ptrdiff_t symbol_num
, int modifiers
, Lisp_Object symbol_kind
,
6439 Lisp_Object name_alist_or_stem
, const char *const *name_table
,
6440 Lisp_Object
*symbol_table
, ptrdiff_t table_size
)
6443 Lisp_Object symbol_int
;
6445 /* Get rid of the "vendor-specific" bit here. */
6446 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6448 /* Is this a request for a valid symbol? */
6449 if (symbol_num
< 0 || symbol_num
>= table_size
)
6452 if (CONSP (*symbol_table
))
6453 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6455 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6456 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6457 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6458 we've never used that symbol before. */
6461 if (! VECTORP (*symbol_table
)
6462 || ASIZE (*symbol_table
) != table_size
)
6466 XSETFASTINT (size
, table_size
);
6467 *symbol_table
= Fmake_vector (size
, Qnil
);
6470 value
= AREF (*symbol_table
, symbol_num
);
6473 /* Have we already used this symbol before? */
6476 /* No; let's create it. */
6477 if (CONSP (name_alist_or_stem
))
6478 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6479 else if (STRINGP (name_alist_or_stem
))
6482 ptrdiff_t len
= (SBYTES (name_alist_or_stem
)
6483 + sizeof "-" + INT_STRLEN_BOUND (EMACS_INT
));
6485 SAFE_ALLOCA (buf
, char *, len
);
6486 esprintf (buf
, "%s-%"pI
"d", SDATA (name_alist_or_stem
),
6487 XINT (symbol_int
) + 1);
6488 value
= intern (buf
);
6491 else if (name_table
!= 0 && name_table
[symbol_num
])
6492 value
= intern (name_table
[symbol_num
]);
6494 #ifdef HAVE_WINDOW_SYSTEM
6497 char *name
= x_get_keysym_name (symbol_num
);
6499 value
= intern (name
);
6505 char buf
[sizeof "key-" + INT_STRLEN_BOUND (EMACS_INT
)];
6506 sprintf (buf
, "key-%"pD
"d", symbol_num
);
6507 value
= intern (buf
);
6510 if (CONSP (*symbol_table
))
6511 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6513 ASET (*symbol_table
, symbol_num
, value
);
6515 /* Fill in the cache entries for this symbol; this also
6516 builds the Qevent_symbol_elements property, which the user
6518 apply_modifiers (modifiers
& click_modifier
, value
);
6519 Fput (value
, Qevent_kind
, symbol_kind
);
6522 /* Apply modifiers to that symbol. */
6523 return apply_modifiers (modifiers
, value
);
6526 /* Convert a list that represents an event type,
6527 such as (ctrl meta backspace), into the usual representation of that
6528 event type as a number or a symbol. */
6530 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6531 doc
: /* Convert the event description list EVENT-DESC to an event type.
6532 EVENT-DESC should contain one base event type (a character or symbol)
6533 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6534 drag, down, double or triple). The base must be last.
6535 The return value is an event type (a character or symbol) which
6536 has the same base event type and all the specified modifiers. */)
6537 (Lisp_Object event_desc
)
6545 while (CONSP (rest
))
6553 /* Given a symbol, see if it is a modifier name. */
6554 if (SYMBOLP (elt
) && CONSP (rest
))
6555 this = parse_solitary_modifier (elt
);
6559 else if (!NILP (base
))
6560 error ("Two bases given in one event");
6566 /* Let the symbol A refer to the character A. */
6567 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6568 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6570 if (INTEGERP (base
))
6572 /* Turn (shift a) into A. */
6573 if ((modifiers
& shift_modifier
) != 0
6574 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6576 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6577 modifiers
&= ~shift_modifier
;
6580 /* Turn (control a) into C-a. */
6581 if (modifiers
& ctrl_modifier
)
6582 return make_number ((modifiers
& ~ctrl_modifier
)
6583 | make_ctrl_char (XINT (base
)));
6585 return make_number (modifiers
| XINT (base
));
6587 else if (SYMBOLP (base
))
6588 return apply_modifiers (modifiers
, base
);
6591 error ("Invalid base event");
6596 /* Try to recognize SYMBOL as a modifier name.
6597 Return the modifier flag bit, or 0 if not recognized. */
6600 parse_solitary_modifier (Lisp_Object symbol
)
6602 Lisp_Object name
= SYMBOL_NAME (symbol
);
6604 switch (SREF (name
, 0))
6606 #define SINGLE_LETTER_MOD(BIT) \
6607 if (SBYTES (name) == 1) \
6610 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6611 if (LEN == SBYTES (name) \
6612 && ! memcmp (SDATA (name), NAME, LEN)) \
6616 SINGLE_LETTER_MOD (alt_modifier
);
6620 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6624 SINGLE_LETTER_MOD (ctrl_modifier
);
6628 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6629 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6633 SINGLE_LETTER_MOD (hyper_modifier
);
6637 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6641 SINGLE_LETTER_MOD (meta_modifier
);
6645 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6649 SINGLE_LETTER_MOD (shift_modifier
);
6653 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6654 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6655 SINGLE_LETTER_MOD (super_modifier
);
6659 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6660 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6661 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6665 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6668 #undef SINGLE_LETTER_MOD
6669 #undef MULTI_LETTER_MOD
6675 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6676 Such a list is not valid as an event,
6677 but it can be a Lucid-style event type list. */
6680 lucid_event_type_list_p (Lisp_Object object
)
6684 if (! CONSP (object
))
6687 if (EQ (XCAR (object
), Qhelp_echo
)
6688 || EQ (XCAR (object
), Qvertical_line
)
6689 || EQ (XCAR (object
), Qmode_line
)
6690 || EQ (XCAR (object
), Qheader_line
))
6693 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6697 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6704 /* Store into *addr a value nonzero if terminal input chars are available.
6705 Serves the purpose of ioctl (0, FIONREAD, addr)
6706 but works even if FIONREAD does not exist.
6707 (In fact, this may actually read some input.)
6709 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
6710 timer events that are ripe.
6711 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
6712 events (FOCUS_IN_EVENT).
6713 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
6714 movements and toolkit scroll bar thumb drags. */
6717 get_input_pending (int *addr
, int flags
)
6719 /* First of all, have we already counted some input? */
6720 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6722 /* If input is being read as it arrives, and we have none, there is none. */
6723 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6726 /* Try to read some input and see how much we get. */
6728 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6731 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6734 gobble_input (int expected
)
6737 if (interrupt_input
)
6740 mask
= sigblock (sigmask (SIGIO
));
6741 read_avail_input (expected
);
6745 #ifdef POLL_FOR_INPUT
6746 /* XXX This condition was (read_socket_hook && !interrupt_input),
6747 but read_socket_hook is not global anymore. Let's pretend that
6749 if (!interrupt_input
&& poll_suppress_count
== 0)
6752 mask
= sigblock (sigmask (SIGALRM
));
6753 read_avail_input (expected
);
6759 read_avail_input (expected
);
6762 /* Put a BUFFER_SWITCH_EVENT in the buffer
6763 so that read_key_sequence will notice the new current buffer. */
6766 record_asynch_buffer_change (void)
6768 struct input_event event
;
6772 event
.kind
= BUFFER_SWITCH_EVENT
;
6773 event
.frame_or_window
= Qnil
;
6776 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6777 The purpose of the event is to make read_key_sequence look up the
6778 keymaps again. If we aren't in read_key_sequence, we don't need one,
6779 and the event could cause trouble by messing up (input-pending-p).
6780 Note: Fwaiting_for_user_input_p always returns nil when async
6781 subprocesses aren't supported. */
6782 tem
= Fwaiting_for_user_input_p ();
6786 /* Make sure no interrupt happens while storing the event. */
6788 if (interrupt_input
)
6791 mask
= sigblock (sigmask (SIGIO
));
6792 kbd_buffer_store_event (&event
);
6799 kbd_buffer_store_event (&event
);
6804 /* Read any terminal input already buffered up by the system
6805 into the kbd_buffer, but do not wait.
6807 EXPECTED should be nonzero if the caller knows there is some input.
6809 Returns the number of keyboard chars read, or -1 meaning
6810 this is a bad time to try to read input. */
6813 read_avail_input (int expected
)
6819 /* Store pending user signal events, if any. */
6820 if (store_user_signal_events ())
6823 /* Loop through the available terminals, and call their input hooks. */
6827 struct terminal
*next
= t
->next_terminal
;
6829 if (t
->read_socket_hook
)
6832 struct input_event hold_quit
;
6834 EVENT_INIT (hold_quit
);
6835 hold_quit
.kind
= NO_EVENT
;
6837 /* No need for FIONREAD or fcntl; just say don't wait. */
6838 while (nr
= (*t
->read_socket_hook
) (t
, expected
, &hold_quit
), nr
> 0)
6844 if (nr
== -1) /* Not OK to read input now. */
6848 else if (nr
== -2) /* Non-transient error. */
6850 /* The terminal device terminated; it should be closed. */
6852 /* Kill Emacs if this was our last terminal. */
6853 if (!terminal_list
->next_terminal
)
6854 /* Formerly simply reported no input, but that
6855 sometimes led to a failure of Emacs to terminate.
6856 SIGHUP seems appropriate if we can't reach the
6858 /* ??? Is it really right to send the signal just to
6859 this process rather than to the whole process
6860 group? Perhaps on systems with FIONREAD Emacs is
6861 alone in its group. */
6862 kill (getpid (), SIGHUP
);
6864 /* XXX Is calling delete_terminal safe here? It calls delete_frame. */
6867 XSETTERMINAL (tmp
, t
);
6868 Fdelete_terminal (tmp
, Qnoelisp
);
6872 if (hold_quit
.kind
!= NO_EVENT
)
6873 kbd_buffer_store_event (&hold_quit
);
6882 frame_make_pointer_visible ();
6888 decode_keyboard_code (struct tty_display_info
*tty
,
6889 struct coding_system
*coding
,
6890 unsigned char *buf
, int nbytes
)
6892 unsigned char *src
= buf
;
6893 const unsigned char *p
;
6898 if (tty
->meta_key
!= 2)
6899 for (i
= 0; i
< nbytes
; i
++)
6901 if (coding
->carryover_bytes
> 0)
6903 src
= alloca (coding
->carryover_bytes
+ nbytes
);
6904 memcpy (src
, coding
->carryover
, coding
->carryover_bytes
);
6905 memcpy (src
+ coding
->carryover_bytes
, buf
, nbytes
);
6906 nbytes
+= coding
->carryover_bytes
;
6908 coding
->destination
= alloca (nbytes
* 4);
6909 coding
->dst_bytes
= nbytes
* 4;
6910 decode_coding_c_string (coding
, src
, nbytes
, Qnil
);
6911 if (coding
->produced_char
== 0)
6913 for (i
= 0, p
= coding
->destination
; i
< coding
->produced_char
; i
++)
6915 struct input_event event_buf
;
6917 EVENT_INIT (event_buf
);
6918 event_buf
.code
= STRING_CHAR_ADVANCE (p
);
6920 (ASCII_CHAR_P (event_buf
.code
)
6921 ? ASCII_KEYSTROKE_EVENT
: MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6922 /* See the comment in tty_read_avail_input. */
6923 event_buf
.frame_or_window
= tty
->top_frame
;
6924 event_buf
.arg
= Qnil
;
6925 kbd_buffer_store_event (&event_buf
);
6929 /* This is the tty way of reading available input.
6931 Note that each terminal device has its own `struct terminal' object,
6932 and so this function is called once for each individual termcap
6933 terminal. The first parameter indicates which terminal to read from. */
6936 tty_read_avail_input (struct terminal
*terminal
,
6938 struct input_event
*hold_quit
)
6940 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6941 the kbd_buffer can really hold. That may prevent loss
6942 of characters on some systems when input is stuffed at us. */
6943 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
6945 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
6948 int buffer_free
= KBD_BUFFER_SIZE
- kbd_buffer_nr_stored () - 1;
6950 if (kbd_on_hold_p () || buffer_free
<= 0)
6952 #endif /* subprocesses */
6954 if (!terminal
->name
) /* Don't read from a dead terminal. */
6957 if (terminal
->type
!= output_termcap
6958 && terminal
->type
!= output_msdos_raw
)
6961 /* XXX I think the following code should be moved to separate hook
6962 functions in system-dependent files. */
6965 #else /* not WINDOWSNT */
6966 if (! tty
->term_initted
) /* In case we get called during bootstrap. */
6970 return 0; /* The terminal is suspended. */
6973 n_to_read
= dos_keysns ();
6977 cbuf
[0] = dos_keyread ();
6980 #else /* not MSDOS */
6985 struct input_event gpm_hold_quit
;
6986 int gpm
, fd
= gpm_fd
;
6988 EVENT_INIT (gpm_hold_quit
);
6989 gpm_hold_quit
.kind
= NO_EVENT
;
6991 /* gpm==1 if event received.
6992 gpm==0 if the GPM daemon has closed the connection, in which case
6993 Gpm_GetEvent closes gpm_fd and clears it to -1, which is why
6994 we save it in `fd' so close_gpm can remove it from the
6996 gpm==-1 if a protocol error or EWOULDBLOCK; the latter is normal. */
6997 while (gpm
= Gpm_GetEvent (&event
), gpm
== 1) {
6998 nread
+= handle_one_term_event (tty
, &event
, &gpm_hold_quit
);
7001 /* Presumably the GPM daemon has closed the connection. */
7003 if (gpm_hold_quit
.kind
!= NO_EVENT
)
7004 kbd_buffer_store_event (&gpm_hold_quit
);
7008 #endif /* HAVE_GPM */
7010 /* Determine how many characters we should *try* to read. */
7012 /* Find out how much input is available. */
7013 if (ioctl (fileno (tty
->input
), FIONREAD
, &n_to_read
) < 0)
7015 if (! noninteractive
)
7016 return -2; /* Close this terminal. */
7022 if (n_to_read
> sizeof cbuf
)
7023 n_to_read
= sizeof cbuf
;
7024 #else /* no FIONREAD */
7025 #if defined (USG) || defined (CYGWIN)
7026 /* Read some input if available, but don't wait. */
7027 n_to_read
= sizeof cbuf
;
7028 fcntl (fileno (tty
->input
), F_SETFL
, O_NDELAY
);
7035 /* Don't read more than we can store. */
7036 if (n_to_read
> buffer_free
)
7037 n_to_read
= buffer_free
;
7038 #endif /* subprocesses */
7040 /* Now read; for one reason or another, this will not block.
7041 NREAD is set to the number of chars read. */
7044 nread
= emacs_read (fileno (tty
->input
), (char *) cbuf
, n_to_read
);
7045 /* POSIX infers that processes which are not in the session leader's
7046 process group won't get SIGHUP's at logout time. BSDI adheres to
7047 this part standard and returns -1 from read (0) with errno==EIO
7048 when the control tty is taken away.
7049 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
7050 if (nread
== -1 && errno
== EIO
)
7051 return -2; /* Close this terminal. */
7052 #if defined (AIX) && defined (_BSD)
7053 /* The kernel sometimes fails to deliver SIGHUP for ptys.
7054 This looks incorrect, but it isn't, because _BSD causes
7055 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
7056 and that causes a value other than 0 when there is no input. */
7058 return -2; /* Close this terminal. */
7062 /* We used to retry the read if it was interrupted.
7063 But this does the wrong thing when O_NDELAY causes
7064 an EAGAIN error. Does anybody know of a situation
7065 where a retry is actually needed? */
7067 nread
< 0 && (errno
== EAGAIN
7081 #if defined (USG) || defined (CYGWIN)
7082 fcntl (fileno (tty
->input
), F_SETFL
, 0);
7083 #endif /* USG or CYGWIN */
7084 #endif /* no FIONREAD */
7089 #endif /* not MSDOS */
7090 #endif /* not WINDOWSNT */
7092 if (TERMINAL_KEYBOARD_CODING (terminal
)->common_flags
7093 & CODING_REQUIRE_DECODING_MASK
)
7095 struct coding_system
*coding
= TERMINAL_KEYBOARD_CODING (terminal
);
7098 /* Decode the key sequence except for those with meta
7100 for (i
= from
= 0; ; i
++)
7101 if (i
== nread
|| (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80)))
7103 struct input_event buf
;
7105 decode_keyboard_code (tty
, coding
, cbuf
+ from
, i
- from
);
7110 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7111 buf
.modifiers
= meta_modifier
;
7112 buf
.code
= cbuf
[i
] & ~0x80;
7113 /* See the comment below. */
7114 buf
.frame_or_window
= tty
->top_frame
;
7116 kbd_buffer_store_event (&buf
);
7122 for (i
= 0; i
< nread
; i
++)
7124 struct input_event buf
;
7126 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7128 if (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80))
7129 buf
.modifiers
= meta_modifier
;
7130 if (tty
->meta_key
!= 2)
7134 /* Set the frame corresponding to the active tty. Note that the
7135 value of selected_frame is not reliable here, redisplay tends
7136 to temporarily change it. */
7137 buf
.frame_or_window
= tty
->top_frame
;
7140 kbd_buffer_store_event (&buf
);
7141 /* Don't look at input that follows a C-g too closely.
7142 This reduces lossage due to autorepeat on C-g. */
7143 if (buf
.kind
== ASCII_KEYSTROKE_EVENT
7144 && buf
.code
== quit_char
)
7151 #if defined SYNC_INPUT || defined SIGIO
7153 handle_async_input (void)
7155 interrupt_input_pending
= 0;
7157 pending_signals
= pending_atimers
;
7159 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
7160 doing anything dangerous. */
7167 nread
= read_avail_input (1);
7168 /* -1 means it's not ok to read the input now.
7169 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7170 0 means there was no keyboard input available. */
7178 #endif /* SYNC_INPUT || SIGIO */
7182 process_pending_signals (void)
7184 if (interrupt_input_pending
)
7185 handle_async_input ();
7186 do_pending_atimers ();
7190 #ifdef SIGIO /* for entire page */
7191 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7194 input_available_signal (int signo
)
7196 /* Must preserve main program's value of errno. */
7197 int old_errno
= errno
;
7198 SIGNAL_THREAD_CHECK (signo
);
7201 interrupt_input_pending
= 1;
7202 pending_signals
= 1;
7205 if (input_available_clear_time
)
7206 *input_available_clear_time
= make_emacs_time (0, 0);
7209 handle_async_input ();
7216 /* Send ourselves a SIGIO.
7218 This function exists so that the UNBLOCK_INPUT macro in
7219 blockinput.h can have some way to take care of input we put off
7220 dealing with, without assuming that every file which uses
7221 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
7223 reinvoke_input_signal (void)
7226 handle_async_input ();
7232 /* User signal events. */
7234 struct user_signal_info
7236 /* Signal number. */
7239 /* Name of the signal. */
7242 /* Number of pending signals. */
7245 struct user_signal_info
*next
;
7248 /* List of user signals. */
7249 static struct user_signal_info
*user_signals
= NULL
;
7252 add_user_signal (int sig
, const char *name
)
7254 struct user_signal_info
*p
;
7256 for (p
= user_signals
; p
; p
= p
->next
)
7258 /* Already added. */
7261 p
= xmalloc (sizeof *p
);
7263 p
->name
= xstrdup (name
);
7265 p
->next
= user_signals
;
7268 signal (sig
, handle_user_signal
);
7272 handle_user_signal (int sig
)
7274 int old_errno
= errno
;
7275 struct user_signal_info
*p
;
7276 const char *special_event_name
= NULL
;
7278 SIGNAL_THREAD_CHECK (sig
);
7280 if (SYMBOLP (Vdebug_on_event
))
7281 special_event_name
= SSDATA (SYMBOL_NAME (Vdebug_on_event
));
7283 for (p
= user_signals
; p
; p
= p
->next
)
7286 if (special_event_name
7287 && strcmp (special_event_name
, p
->name
) == 0)
7289 /* Enter the debugger in many ways. */
7290 debug_on_next_call
= 1;
7293 Vinhibit_quit
= Qnil
;
7295 /* Eat the event. */
7301 if (interrupt_input
)
7302 kill (getpid (), SIGIO
);
7306 /* Tell wait_reading_process_output that it needs to wake
7307 up and look around. */
7308 if (input_available_clear_time
)
7309 *input_available_clear_time
= make_emacs_time (0, 0);
7318 find_user_signal_name (int sig
)
7320 struct user_signal_info
*p
;
7322 for (p
= user_signals
; p
; p
= p
->next
)
7330 store_user_signal_events (void)
7332 struct user_signal_info
*p
;
7333 struct input_event buf
;
7336 for (p
= user_signals
; p
; p
= p
->next
)
7337 if (p
->npending
> 0)
7343 memset (&buf
, 0, sizeof buf
);
7344 buf
.kind
= USER_SIGNAL_EVENT
;
7345 buf
.frame_or_window
= selected_frame
;
7347 nstored
+= p
->npending
;
7349 mask
= sigblock (sigmask (p
->sig
));
7353 kbd_buffer_store_event (&buf
);
7356 while (p
->npending
> 0);
7364 static void menu_bar_item (Lisp_Object
, Lisp_Object
, Lisp_Object
, void*);
7365 static Lisp_Object menu_bar_one_keymap_changed_items
;
7367 /* These variables hold the vector under construction within
7368 menu_bar_items and its subroutines, and the current index
7369 for storing into that vector. */
7370 static Lisp_Object menu_bar_items_vector
;
7371 static int menu_bar_items_index
;
7374 static const char* separator_names
[] = {
7379 "single-dashed-line",
7380 "double-dashed-line",
7382 "shadow-etched-out",
7383 "shadow-etched-in-dash",
7384 "shadow-etched-out-dash",
7385 "shadow-double-etched-in",
7386 "shadow-double-etched-out",
7387 "shadow-double-etched-in-dash",
7388 "shadow-double-etched-out-dash",
7392 /* Return non-zero if LABEL specifies a separator. */
7395 menu_separator_name_p (const char *label
)
7399 else if (strlen (label
) > 3
7400 && memcmp (label
, "--", 2) == 0
7405 for (i
= 0; separator_names
[i
]; ++i
)
7406 if (strcmp (label
, separator_names
[i
]) == 0)
7411 /* It's a separator if it contains only dashes. */
7412 while (*label
== '-')
7414 return (*label
== 0);
7421 /* Return a vector of menu items for a menu bar, appropriate
7422 to the current buffer. Each item has three elements in the vector:
7425 OLD is an old vector we can optionally reuse, or nil. */
7428 menu_bar_items (Lisp_Object old
)
7430 /* The number of keymaps we're scanning right now, and the number of
7431 keymaps we have allocated space for. */
7434 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7435 in the current keymaps, or nil where it is not a prefix. */
7438 Lisp_Object def
, tail
;
7443 /* In order to build the menus, we need to call the keymap
7444 accessors. They all call QUIT. But this function is called
7445 during redisplay, during which a quit is fatal. So inhibit
7446 quitting while building the menus.
7447 We do this instead of specbind because (1) errors will clear it anyway
7448 and (2) this avoids risk of specpdl overflow. */
7449 oquit
= Vinhibit_quit
;
7453 menu_bar_items_vector
= old
;
7455 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
7456 menu_bar_items_index
= 0;
7458 /* Build our list of keymaps.
7459 If we recognize a function key and replace its escape sequence in
7460 keybuf with its symbol, or if the sequence starts with a mouse
7461 click and we need to switch buffers, we jump back here to rebuild
7462 the initial keymaps from the current buffer. */
7466 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7467 if (!NILP (Voverriding_local_map_menu_flag
))
7469 /* Yes, use them (if non-nil) as well as the global map. */
7470 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7472 if (!NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
7473 maps
[nmaps
++] = KVAR (current_kboard
, Voverriding_terminal_local_map
);
7474 if (!NILP (Voverriding_local_map
))
7475 maps
[nmaps
++] = Voverriding_local_map
;
7479 /* No, so use major and minor mode keymaps and keymap property.
7480 Note that menu-bar bindings in the local-map and keymap
7481 properties may not work reliable, as they are only
7482 recognized when the menu-bar (or mode-line) is updated,
7483 which does not normally happen after every command. */
7486 nminor
= current_minor_maps (NULL
, &tmaps
);
7487 maps
= alloca ((nminor
+ 3) * sizeof *maps
);
7489 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7490 maps
[nmaps
++] = tem
;
7491 memcpy (maps
+ nmaps
, tmaps
, nminor
* sizeof (maps
[0]));
7493 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7495 maps
[nmaps
++] = current_global_map
;
7498 /* Look up in each map the dummy prefix key `menu-bar'. */
7500 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
7501 if (!NILP (maps
[mapno
]))
7503 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
7507 menu_bar_one_keymap_changed_items
= Qnil
;
7508 map_keymap_canonical (def
, menu_bar_item
, Qnil
, NULL
);
7512 /* Move to the end those items that should be at the end. */
7514 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
7517 int end
= menu_bar_items_index
;
7519 for (i
= 0; i
< end
; i
+= 4)
7520 if (EQ (XCAR (tail
), AREF (menu_bar_items_vector
, i
)))
7522 Lisp_Object tem0
, tem1
, tem2
, tem3
;
7523 /* Move the item at index I to the end,
7524 shifting all the others forward. */
7525 tem0
= AREF (menu_bar_items_vector
, i
+ 0);
7526 tem1
= AREF (menu_bar_items_vector
, i
+ 1);
7527 tem2
= AREF (menu_bar_items_vector
, i
+ 2);
7528 tem3
= AREF (menu_bar_items_vector
, i
+ 3);
7530 memmove (&AREF (menu_bar_items_vector
, i
),
7531 &AREF (menu_bar_items_vector
, i
+ 4),
7532 (end
- i
- 4) * sizeof (Lisp_Object
));
7533 ASET (menu_bar_items_vector
, end
- 4, tem0
);
7534 ASET (menu_bar_items_vector
, end
- 3, tem1
);
7535 ASET (menu_bar_items_vector
, end
- 2, tem2
);
7536 ASET (menu_bar_items_vector
, end
- 1, tem3
);
7541 /* Add nil, nil, nil, nil at the end. */
7543 int i
= menu_bar_items_index
;
7544 if (i
+ 4 > ASIZE (menu_bar_items_vector
))
7545 menu_bar_items_vector
=
7546 larger_vector (menu_bar_items_vector
, 4, -1);
7547 /* Add this item. */
7548 ASET (menu_bar_items_vector
, i
, Qnil
); i
++;
7549 ASET (menu_bar_items_vector
, i
, Qnil
); i
++;
7550 ASET (menu_bar_items_vector
, i
, Qnil
); i
++;
7551 ASET (menu_bar_items_vector
, i
, Qnil
); i
++;
7552 menu_bar_items_index
= i
;
7555 Vinhibit_quit
= oquit
;
7556 return menu_bar_items_vector
;
7559 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7560 If there's already an item for KEY, add this DEF to it. */
7562 Lisp_Object item_properties
;
7565 menu_bar_item (Lisp_Object key
, Lisp_Object item
, Lisp_Object dummy1
, void *dummy2
)
7567 struct gcpro gcpro1
;
7571 if (EQ (item
, Qundefined
))
7573 /* If a map has an explicit `undefined' as definition,
7574 discard any previously made menu bar item. */
7576 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7577 if (EQ (key
, AREF (menu_bar_items_vector
, i
)))
7579 if (menu_bar_items_index
> i
+ 4)
7580 memmove (&AREF (menu_bar_items_vector
, i
),
7581 &AREF (menu_bar_items_vector
, i
+ 4),
7582 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7583 menu_bar_items_index
-= 4;
7587 /* If this keymap has already contributed to this KEY,
7588 don't contribute to it a second time. */
7589 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7590 if (!NILP (tem
) || NILP (item
))
7593 menu_bar_one_keymap_changed_items
7594 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7596 /* We add to menu_bar_one_keymap_changed_items before doing the
7597 parse_menu_item, so that if it turns out it wasn't a menu item,
7598 it still correctly hides any further menu item. */
7600 i
= parse_menu_item (item
, 1);
7605 item
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7607 /* Find any existing item for this KEY. */
7608 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7609 if (EQ (key
, AREF (menu_bar_items_vector
, i
)))
7612 /* If we did not find this KEY, add it at the end. */
7613 if (i
== menu_bar_items_index
)
7615 /* If vector is too small, get a bigger one. */
7616 if (i
+ 4 > ASIZE (menu_bar_items_vector
))
7617 menu_bar_items_vector
= larger_vector (menu_bar_items_vector
, 4, -1);
7618 /* Add this item. */
7619 ASET (menu_bar_items_vector
, i
, key
); i
++;
7620 ASET (menu_bar_items_vector
, i
,
7621 AREF (item_properties
, ITEM_PROPERTY_NAME
)); i
++;
7622 ASET (menu_bar_items_vector
, i
, Fcons (item
, Qnil
)); i
++;
7623 ASET (menu_bar_items_vector
, i
, make_number (0)); i
++;
7624 menu_bar_items_index
= i
;
7626 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7630 old
= AREF (menu_bar_items_vector
, i
+ 2);
7631 /* If the new and the old items are not both keymaps,
7632 the lookup will only find `item'. */
7633 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7634 ASET (menu_bar_items_vector
, i
+ 2, item
);
7638 /* This is used as the handler when calling menu_item_eval_property. */
7640 menu_item_eval_property_1 (Lisp_Object arg
)
7642 /* If we got a quit from within the menu computation,
7643 quit all the way out of it. This takes care of C-] in the debugger. */
7644 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7645 Fsignal (Qquit
, Qnil
);
7651 eval_dyn (Lisp_Object form
)
7653 return Feval (form
, Qnil
);
7656 /* Evaluate an expression and return the result (or nil if something
7657 went wrong). Used to evaluate dynamic parts of menu items. */
7659 menu_item_eval_property (Lisp_Object sexpr
)
7661 ptrdiff_t count
= SPECPDL_INDEX ();
7663 specbind (Qinhibit_redisplay
, Qt
);
7664 val
= internal_condition_case_1 (eval_dyn
, sexpr
, Qerror
,
7665 menu_item_eval_property_1
);
7666 return unbind_to (count
, val
);
7669 /* This function parses a menu item and leaves the result in the
7670 vector item_properties.
7671 ITEM is a key binding, a possible menu item.
7672 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7674 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7675 parse_menu_item returns true if the item is a menu item and false
7679 parse_menu_item (Lisp_Object item
, int inmenubar
)
7681 Lisp_Object def
, tem
, item_string
, start
;
7683 Lisp_Object keyhint
;
7692 /* Create item_properties vector if necessary. */
7693 if (NILP (item_properties
))
7695 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7697 /* Initialize optional entries. */
7698 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7699 ASET (item_properties
, i
, Qnil
);
7700 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7702 /* Save the item here to protect it from GC. */
7703 ASET (item_properties
, ITEM_PROPERTY_ITEM
, item
);
7705 item_string
= XCAR (item
);
7709 if (STRINGP (item_string
))
7711 /* Old format menu item. */
7712 ASET (item_properties
, ITEM_PROPERTY_NAME
, item_string
);
7714 /* Maybe help string. */
7715 if (CONSP (item
) && STRINGP (XCAR (item
)))
7717 ASET (item_properties
, ITEM_PROPERTY_HELP
, XCAR (item
));
7722 /* Maybe an obsolete key binding cache. */
7723 if (CONSP (item
) && CONSP (XCAR (item
))
7724 && (NILP (XCAR (XCAR (item
)))
7725 || VECTORP (XCAR (XCAR (item
)))))
7728 /* This is the real definition--the function to run. */
7729 ASET (item_properties
, ITEM_PROPERTY_DEF
, item
);
7731 /* Get enable property, if any. */
7734 tem
= Fget (item
, Qmenu_enable
);
7735 if (!NILP (Venable_disabled_menus_and_buttons
))
7736 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7737 else if (!NILP (tem
))
7738 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, tem
);
7741 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7743 /* New format menu item. */
7744 ASET (item_properties
, ITEM_PROPERTY_NAME
, XCAR (item
));
7745 start
= XCDR (item
);
7748 /* We have a real binding. */
7749 ASET (item_properties
, ITEM_PROPERTY_DEF
, XCAR (start
));
7751 item
= XCDR (start
);
7752 /* Is there an obsolete cache list with key equivalences. */
7753 if (CONSP (item
) && CONSP (XCAR (item
)))
7756 /* Parse properties. */
7757 while (CONSP (item
) && CONSP (XCDR (item
)))
7762 if (EQ (tem
, QCenable
))
7764 if (!NILP (Venable_disabled_menus_and_buttons
))
7765 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7767 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, XCAR (item
));
7769 else if (EQ (tem
, QCvisible
))
7771 /* If got a visible property and that evaluates to nil
7772 then ignore this item. */
7773 tem
= menu_item_eval_property (XCAR (item
));
7777 else if (EQ (tem
, QChelp
))
7778 ASET (item_properties
, ITEM_PROPERTY_HELP
, XCAR (item
));
7779 else if (EQ (tem
, QCfilter
))
7781 else if (EQ (tem
, QCkey_sequence
))
7784 if (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
))
7785 /* Be GC protected. Set keyhint to item instead of tem. */
7788 else if (EQ (tem
, QCkeys
))
7791 if (CONSP (tem
) || STRINGP (tem
))
7792 ASET (item_properties
, ITEM_PROPERTY_KEYEQ
, tem
);
7794 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7799 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7801 ASET (item_properties
, ITEM_PROPERTY_SELECTED
,
7803 ASET (item_properties
, ITEM_PROPERTY_TYPE
, type
);
7809 else if (inmenubar
|| !NILP (start
))
7813 return 0; /* not a menu item */
7815 /* If item string is not a string, evaluate it to get string.
7816 If we don't get a string, skip this item. */
7817 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7818 if (!(STRINGP (item_string
)))
7820 item_string
= menu_item_eval_property (item_string
);
7821 if (!STRINGP (item_string
))
7823 ASET (item_properties
, ITEM_PROPERTY_NAME
, item_string
);
7826 /* If got a filter apply it on definition. */
7827 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7830 def
= menu_item_eval_property (list2 (XCAR (filter
),
7831 list2 (Qquote
, def
)));
7833 ASET (item_properties
, ITEM_PROPERTY_DEF
, def
);
7836 /* Enable or disable selection of item. */
7837 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7840 tem
= menu_item_eval_property (tem
);
7841 if (inmenubar
&& NILP (tem
))
7842 return 0; /* Ignore disabled items in menu bar. */
7843 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, tem
);
7846 /* If we got no definition, this item is just unselectable text which
7847 is OK in a submenu but not in the menubar. */
7849 return (!inmenubar
);
7851 /* See if this is a separate pane or a submenu. */
7852 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7853 tem
= get_keymap (def
, 0, 1);
7854 /* For a subkeymap, just record its details and exit. */
7857 ASET (item_properties
, ITEM_PROPERTY_MAP
, tem
);
7858 ASET (item_properties
, ITEM_PROPERTY_DEF
, tem
);
7862 /* At the top level in the menu bar, do likewise for commands also.
7863 The menu bar does not display equivalent key bindings anyway.
7864 ITEM_PROPERTY_DEF is already set up properly. */
7868 { /* This is a command. See if there is an equivalent key binding. */
7869 Lisp_Object keyeq
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7871 /* The previous code preferred :key-sequence to :keys, so we
7872 preserve this behavior. */
7873 if (STRINGP (keyeq
) && !CONSP (keyhint
))
7874 keyeq
= concat2 (build_string (" "), Fsubstitute_command_keys (keyeq
));
7877 Lisp_Object prefix
= keyeq
;
7878 Lisp_Object keys
= Qnil
;
7882 def
= XCAR (prefix
);
7883 prefix
= XCDR (prefix
);
7886 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7888 if (CONSP (keyhint
) && !NILP (XCAR (keyhint
)))
7890 keys
= XCAR (keyhint
);
7891 tem
= Fkey_binding (keys
, Qnil
, Qnil
, Qnil
);
7893 /* We have a suggested key. Is it bound to the command? */
7896 /* If the command is an alias for another
7897 (such as lmenu.el set it up), check if the
7898 original command matches the cached command. */
7899 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
7904 keys
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qnil
);
7908 tem
= Fkey_description (keys
, Qnil
);
7911 if (STRINGP (XCAR (prefix
)))
7912 tem
= concat2 (XCAR (prefix
), tem
);
7913 if (STRINGP (XCDR (prefix
)))
7914 tem
= concat2 (tem
, XCDR (prefix
));
7916 keyeq
= concat2 (build_string (" "), tem
);
7917 /* keyeq = concat3(build_string(" ("),tem,build_string(")")); */
7923 /* If we have an equivalent key binding, use that. */
7924 ASET (item_properties
, ITEM_PROPERTY_KEYEQ
, keyeq
);
7927 /* Include this when menu help is implemented.
7928 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7929 if (!(NILP (tem) || STRINGP (tem)))
7931 tem = menu_item_eval_property (tem);
7934 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7938 /* Handle radio buttons or toggle boxes. */
7939 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
7941 ASET (item_properties
, ITEM_PROPERTY_SELECTED
,
7942 menu_item_eval_property (tem
));
7949 /***********************************************************************
7951 ***********************************************************************/
7953 /* A vector holding tool bar items while they are parsed in function
7954 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7957 static Lisp_Object tool_bar_items_vector
;
7959 /* A vector holding the result of parse_tool_bar_item. Layout is like
7960 the one for a single item in tool_bar_items_vector. */
7962 static Lisp_Object tool_bar_item_properties
;
7964 /* Next free index in tool_bar_items_vector. */
7966 static int ntool_bar_items
;
7968 /* The symbols `:image' and `:rtl'. */
7970 static Lisp_Object QCimage
;
7971 static Lisp_Object QCrtl
;
7973 /* Function prototypes. */
7975 static void init_tool_bar_items (Lisp_Object
);
7976 static void process_tool_bar_item (Lisp_Object
, Lisp_Object
, Lisp_Object
, void*);
7977 static int parse_tool_bar_item (Lisp_Object
, Lisp_Object
);
7978 static void append_tool_bar_item (void);
7981 /* Return a vector of tool bar items for keymaps currently in effect.
7982 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7983 tool bar items found. */
7986 tool_bar_items (Lisp_Object reuse
, int *nitems
)
7995 /* In order to build the menus, we need to call the keymap
7996 accessors. They all call QUIT. But this function is called
7997 during redisplay, during which a quit is fatal. So inhibit
7998 quitting while building the menus. We do this instead of
7999 specbind because (1) errors will clear it anyway and (2) this
8000 avoids risk of specpdl overflow. */
8001 oquit
= Vinhibit_quit
;
8004 /* Initialize tool_bar_items_vector and protect it from GC. */
8005 init_tool_bar_items (reuse
);
8007 /* Build list of keymaps in maps. Set nmaps to the number of maps
8010 /* Should overriding-terminal-local-map and overriding-local-map apply? */
8011 if (!NILP (Voverriding_local_map_menu_flag
))
8013 /* Yes, use them (if non-nil) as well as the global map. */
8014 maps
= alloca (3 * sizeof *maps
);
8016 if (!NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
8017 maps
[nmaps
++] = KVAR (current_kboard
, Voverriding_terminal_local_map
);
8018 if (!NILP (Voverriding_local_map
))
8019 maps
[nmaps
++] = Voverriding_local_map
;
8023 /* No, so use major and minor mode keymaps and keymap property.
8024 Note that tool-bar bindings in the local-map and keymap
8025 properties may not work reliable, as they are only
8026 recognized when the tool-bar (or mode-line) is updated,
8027 which does not normally happen after every command. */
8030 nminor
= current_minor_maps (NULL
, &tmaps
);
8031 maps
= alloca ((nminor
+ 3) * sizeof *maps
);
8033 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
8034 maps
[nmaps
++] = tem
;
8035 memcpy (maps
+ nmaps
, tmaps
, nminor
* sizeof (maps
[0]));
8037 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
8040 /* Add global keymap at the end. */
8041 maps
[nmaps
++] = current_global_map
;
8043 /* Process maps in reverse order and look up in each map the prefix
8045 for (i
= nmaps
- 1; i
>= 0; --i
)
8046 if (!NILP (maps
[i
]))
8050 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
8052 map_keymap (keymap
, process_tool_bar_item
, Qnil
, NULL
, 1);
8055 Vinhibit_quit
= oquit
;
8056 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
8057 return tool_bar_items_vector
;
8061 /* Process the definition of KEY which is DEF. */
8064 process_tool_bar_item (Lisp_Object key
, Lisp_Object def
, Lisp_Object data
, void *args
)
8067 struct gcpro gcpro1
, gcpro2
;
8069 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
8073 if (EQ (def
, Qundefined
))
8075 /* If a map has an explicit `undefined' as definition,
8076 discard any previously made item. */
8077 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
8079 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
8081 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
8083 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
8084 memmove (v
, v
+ TOOL_BAR_ITEM_NSLOTS
,
8085 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
8086 * sizeof (Lisp_Object
)));
8087 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
8092 else if (parse_tool_bar_item (key
, def
))
8093 /* Append a new tool bar item to tool_bar_items_vector. Accept
8094 more than one definition for the same key. */
8095 append_tool_bar_item ();
8101 /* Parse a tool bar item specification ITEM for key KEY and return the
8102 result in tool_bar_item_properties. Value is zero if ITEM is
8105 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
8107 CAPTION is the caption of the item, If it's not a string, it is
8108 evaluated to get a string.
8110 BINDING is the tool bar item's binding. Tool-bar items with keymaps
8111 as binding are currently ignored.
8113 The following properties are recognized:
8117 FORM is evaluated and specifies whether the tool bar item is
8118 enabled or disabled.
8122 FORM is evaluated and specifies whether the tool bar item is visible.
8124 - `:filter FUNCTION'
8126 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8127 result is stored as the new binding.
8129 - `:button (TYPE SELECTED)'
8131 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8132 and specifies whether the button is selected (pressed) or not.
8136 IMAGES is either a single image specification or a vector of four
8137 image specifications. See enum tool_bar_item_images.
8139 - `:help HELP-STRING'.
8141 Gives a help string to display for the tool bar item.
8143 - `:label LABEL-STRING'.
8145 A text label to show with the tool bar button if labels are enabled. */
8148 parse_tool_bar_item (Lisp_Object key
, Lisp_Object item
)
8150 /* Access slot with index IDX of vector tool_bar_item_properties. */
8151 #define PROP(IDX) AREF (tool_bar_item_properties, (IDX))
8153 Lisp_Object filter
= Qnil
;
8154 Lisp_Object caption
;
8155 int i
, have_label
= 0;
8157 /* Definition looks like `(menu-item CAPTION BINDING PROPS...)'.
8158 Rule out items that aren't lists, don't start with
8159 `menu-item' or whose rest following `tool-bar-item' is not a
8164 /* As an exception, allow old-style menu separators. */
8165 if (STRINGP (XCAR (item
)))
8166 item
= Fcons (XCAR (item
), Qnil
);
8167 else if (!EQ (XCAR (item
), Qmenu_item
)
8168 || (item
= XCDR (item
), !CONSP (item
)))
8171 /* Create tool_bar_item_properties vector if necessary. Reset it to
8173 if (VECTORP (tool_bar_item_properties
))
8175 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
8179 tool_bar_item_properties
8180 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
8183 PROP (TOOL_BAR_ITEM_KEY
) = key
;
8184 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8186 /* Get the caption of the item. If the caption is not a string,
8187 evaluate it to get a string. If we don't get a string, skip this
8189 caption
= XCAR (item
);
8190 if (!STRINGP (caption
))
8192 caption
= menu_item_eval_property (caption
);
8193 if (!STRINGP (caption
))
8196 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
8198 /* If the rest following the caption is not a list, the menu item is
8199 either a separator, or invalid. */
8203 if (menu_separator_name_p (SSDATA (caption
)))
8205 PROP (TOOL_BAR_ITEM_TYPE
) = Qt
;
8206 #if !defined (USE_GTK) && !defined (HAVE_NS)
8207 /* If we use build_desired_tool_bar_string to render the
8208 tool bar, the separator is rendered as an image. */
8209 PROP (TOOL_BAR_ITEM_IMAGES
)
8210 = menu_item_eval_property (Vtool_bar_separator_image_expression
);
8211 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qnil
;
8212 PROP (TOOL_BAR_ITEM_SELECTED_P
) = Qnil
;
8213 PROP (TOOL_BAR_ITEM_CAPTION
) = Qnil
;
8220 /* Store the binding. */
8221 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
8224 /* Ignore cached key binding, if any. */
8225 if (CONSP (item
) && CONSP (XCAR (item
)))
8228 /* Process the rest of the properties. */
8229 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
8231 Lisp_Object ikey
, value
;
8234 value
= XCAR (XCDR (item
));
8236 if (EQ (ikey
, QCenable
))
8238 /* `:enable FORM'. */
8239 if (!NILP (Venable_disabled_menus_and_buttons
))
8240 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8242 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
8244 else if (EQ (ikey
, QCvisible
))
8246 /* `:visible FORM'. If got a visible property and that
8247 evaluates to nil then ignore this item. */
8248 if (NILP (menu_item_eval_property (value
)))
8251 else if (EQ (ikey
, QChelp
))
8252 /* `:help HELP-STRING'. */
8253 PROP (TOOL_BAR_ITEM_HELP
) = value
;
8254 else if (EQ (ikey
, QCvert_only
))
8255 /* `:vert-only t/nil'. */
8256 PROP (TOOL_BAR_ITEM_VERT_ONLY
) = value
;
8257 else if (EQ (ikey
, QClabel
))
8259 const char *bad_label
= "!!?GARBLED ITEM?!!";
8260 /* `:label LABEL-STRING'. */
8261 PROP (TOOL_BAR_ITEM_LABEL
) = STRINGP (value
)
8263 : build_string (bad_label
);
8266 else if (EQ (ikey
, QCfilter
))
8267 /* ':filter FORM'. */
8269 else if (EQ (ikey
, QCbutton
) && CONSP (value
))
8271 /* `:button (TYPE . SELECTED)'. */
8272 Lisp_Object type
, selected
;
8274 type
= XCAR (value
);
8275 selected
= XCDR (value
);
8276 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
8278 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
8279 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
8282 else if (EQ (ikey
, QCimage
)
8284 || (VECTORP (value
) && ASIZE (value
) == 4)))
8285 /* Value is either a single image specification or a vector
8286 of 4 such specifications for the different button states. */
8287 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
8288 else if (EQ (ikey
, QCrtl
))
8290 PROP (TOOL_BAR_ITEM_RTL_IMAGE
) = value
;
8296 /* Try to make one from caption and key. */
8297 Lisp_Object tkey
= PROP (TOOL_BAR_ITEM_KEY
);
8298 Lisp_Object tcapt
= PROP (TOOL_BAR_ITEM_CAPTION
);
8299 const char *label
= SYMBOLP (tkey
) ? SSDATA (SYMBOL_NAME (tkey
)) : "";
8300 const char *capt
= STRINGP (tcapt
) ? SSDATA (tcapt
) : "";
8302 2 * max (0, min (tool_bar_max_label_size
, STRING_BYTES_BOUND
/ 2));
8303 char *buf
= xmalloc (max_lbl
+ 1);
8304 Lisp_Object new_lbl
;
8305 ptrdiff_t caption_len
= strlen (capt
);
8307 if (caption_len
<= max_lbl
&& capt
[0] != '\0')
8310 while (caption_len
> 0 && buf
[caption_len
- 1] == '.')
8312 buf
[caption_len
] = '\0';
8316 if (strlen (label
) <= max_lbl
&& label
[0] != '\0')
8320 strcpy (buf
, label
);
8322 for (j
= 0; buf
[j
] != '\0'; ++j
)
8330 new_lbl
= Fupcase_initials (build_string (label
));
8331 if (SCHARS (new_lbl
) <= tool_bar_max_label_size
)
8332 PROP (TOOL_BAR_ITEM_LABEL
) = new_lbl
;
8334 PROP (TOOL_BAR_ITEM_LABEL
) = empty_unibyte_string
;
8338 /* If got a filter apply it on binding. */
8340 PROP (TOOL_BAR_ITEM_BINDING
)
8341 = menu_item_eval_property (list2 (filter
,
8343 PROP (TOOL_BAR_ITEM_BINDING
))));
8345 /* See if the binding is a keymap. Give up if it is. */
8346 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
8349 /* Enable or disable selection of item. */
8350 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
8351 PROP (TOOL_BAR_ITEM_ENABLED_P
)
8352 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
8354 /* Handle radio buttons or toggle boxes. */
8355 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
8356 PROP (TOOL_BAR_ITEM_SELECTED_P
)
8357 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
8365 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8366 that can be reused. */
8369 init_tool_bar_items (Lisp_Object reuse
)
8371 if (VECTORP (reuse
))
8372 tool_bar_items_vector
= reuse
;
8374 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
8375 ntool_bar_items
= 0;
8379 /* Append parsed tool bar item properties from
8380 tool_bar_item_properties */
8383 append_tool_bar_item (void)
8385 Lisp_Object
*to
, *from
;
8388 - (ASIZE (tool_bar_items_vector
) - TOOL_BAR_ITEM_NSLOTS
));
8390 /* Enlarge tool_bar_items_vector if necessary. */
8392 tool_bar_items_vector
8393 = larger_vector (tool_bar_items_vector
, incr
, -1);
8395 /* Append entries from tool_bar_item_properties to the end of
8396 tool_bar_items_vector. */
8397 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
8398 from
= XVECTOR (tool_bar_item_properties
)->contents
;
8399 memcpy (to
, from
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
8400 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
8407 /* Read a character using menus based on maps in the array MAPS.
8408 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
8409 Return t if we displayed a menu but the user rejected it.
8411 PREV_EVENT is the previous input event, or nil if we are reading
8412 the first event of a key sequence.
8414 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
8415 if we used a mouse menu to read the input, or zero otherwise. If
8416 USED_MOUSE_MENU is null, we don't dereference it.
8418 The prompting is done based on the prompt-string of the map
8419 and the strings associated with various map elements.
8421 This can be done with X menus or with menus put in the minibuf.
8422 These are done in different ways, depending on how the input will be read.
8423 Menus using X are done after auto-saving in read-char, getting the input
8424 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8425 and do auto-saving in the inner call of read_char. */
8428 read_char_x_menu_prompt (ptrdiff_t nmaps
, Lisp_Object
*maps
,
8429 Lisp_Object prev_event
, int *used_mouse_menu
)
8433 if (used_mouse_menu
)
8434 *used_mouse_menu
= 0;
8436 /* Use local over global Menu maps */
8438 if (! menu_prompting
)
8441 /* Optionally disregard all but the global map. */
8442 if (inhibit_local_menu_bar_menus
)
8444 maps
+= (nmaps
- 1);
8449 /* If we got to this point via a mouse click,
8450 use a real menu for mouse selection. */
8451 if (EVENT_HAS_PARAMETERS (prev_event
)
8452 && !EQ (XCAR (prev_event
), Qmenu_bar
)
8453 && !EQ (XCAR (prev_event
), Qtool_bar
))
8455 /* Display the menu and get the selection. */
8456 Lisp_Object
*realmaps
= alloca (nmaps
* sizeof *realmaps
);
8458 ptrdiff_t nmaps1
= 0;
8460 /* Use the maps that are not nil. */
8461 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8462 if (!NILP (maps
[mapno
]))
8463 realmaps
[nmaps1
++] = maps
[mapno
];
8465 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
8470 record_menu_key (XCAR (value
));
8472 /* If we got multiple events, unread all but
8474 There is no way to prevent those unread events
8475 from showing up later in last_nonmenu_event.
8476 So turn symbol and integer events into lists,
8477 to indicate that they came from a mouse menu,
8478 so that when present in last_nonmenu_event
8479 they won't confuse things. */
8480 for (tem
= XCDR (value
); CONSP (tem
); tem
= XCDR (tem
))
8482 record_menu_key (XCAR (tem
));
8483 if (SYMBOLP (XCAR (tem
))
8484 || INTEGERP (XCAR (tem
)))
8485 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
8488 /* If we got more than one event, put all but the first
8489 onto this list to be read later.
8490 Return just the first event now. */
8491 Vunread_command_events
8492 = nconc2 (XCDR (value
), Vunread_command_events
);
8493 value
= XCAR (value
);
8495 else if (NILP (value
))
8497 if (used_mouse_menu
)
8498 *used_mouse_menu
= 1;
8501 #endif /* HAVE_MENUS */
8505 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8506 We make this bigger when necessary, and never free it. */
8507 static char *read_char_minibuf_menu_text
;
8508 /* Size of that buffer. */
8509 static ptrdiff_t read_char_minibuf_menu_width
;
8512 read_char_minibuf_menu_prompt (int commandflag
,
8513 ptrdiff_t nmaps
, Lisp_Object
*maps
)
8516 register Lisp_Object name
;
8518 /* FIXME: Use the minibuffer's frame width. */
8519 ptrdiff_t width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8522 Lisp_Object rest
, vector
;
8528 if (! menu_prompting
)
8531 /* Get the menu name from the first map that has one (a prompt string). */
8532 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8534 name
= Fkeymap_prompt (maps
[mapno
]);
8539 /* If we don't have any menus, just read a character normally. */
8540 if (!STRINGP (name
))
8543 /* Make sure we have a big enough buffer for the menu text. */
8544 width
= max (width
, SBYTES (name
));
8545 if (STRING_BYTES_BOUND
- 4 < width
)
8546 memory_full (SIZE_MAX
);
8547 if (width
+ 4 > read_char_minibuf_menu_width
)
8549 read_char_minibuf_menu_text
8550 = xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8551 read_char_minibuf_menu_width
= width
+ 4;
8553 menu
= read_char_minibuf_menu_text
;
8555 /* Prompt string always starts with map's prompt, and a space. */
8556 strcpy (menu
, SSDATA (name
));
8557 nlength
= SBYTES (name
);
8558 menu
[nlength
++] = ':';
8559 menu
[nlength
++] = ' ';
8562 /* Start prompting at start of first map. */
8566 /* Present the documented bindings, a line at a time. */
8570 ptrdiff_t i
= nlength
;
8572 Lisp_Object orig_defn_macro
;
8574 /* Loop over elements of map. */
8579 /* If reached end of map, start at beginning of next map. */
8583 /* At end of last map, wrap around to first map if just starting,
8584 or end this line if already have something on it. */
8588 if (notfirst
|| nobindings
) break;
8593 /* Look at the next element of the map. */
8595 elt
= AREF (vector
, idx
);
8597 elt
= Fcar_safe (rest
);
8599 if (idx
< 0 && VECTORP (elt
))
8601 /* If we found a dense table in the keymap,
8602 advanced past it, but start scanning its contents. */
8603 rest
= Fcdr_safe (rest
);
8609 /* An ordinary element. */
8610 Lisp_Object event
, tem
;
8614 event
= Fcar_safe (elt
); /* alist */
8615 elt
= Fcdr_safe (elt
);
8619 XSETINT (event
, idx
); /* vector */
8622 /* Ignore the element if it has no prompt string. */
8623 if (INTEGERP (event
) && parse_menu_item (elt
, -1))
8625 /* 1 if the char to type matches the string. */
8627 Lisp_Object upcased_event
, downcased_event
;
8628 Lisp_Object desc
= Qnil
;
8630 = AREF (item_properties
, ITEM_PROPERTY_NAME
);
8632 upcased_event
= Fupcase (event
);
8633 downcased_event
= Fdowncase (event
);
8634 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8635 || XINT (downcased_event
) == SREF (s
, 0));
8637 desc
= Fsingle_key_description (event
, Qnil
);
8639 #if 0 /* It is redundant to list the equivalent key bindings because
8640 the prefix is what the user has already typed. */
8642 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8644 /* Insert equivalent keybinding. */
8645 s
= concat2 (s
, tem
);
8648 = AREF (item_properties
, ITEM_PROPERTY_TYPE
);
8649 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8651 /* Insert button prefix. */
8652 Lisp_Object selected
8653 = AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
8654 if (EQ (tem
, QCradio
))
8655 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8657 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8658 s
= concat2 (tem
, s
);
8662 /* If we have room for the prompt string, add it to this line.
8663 If this is the first on the line, always add it. */
8664 if ((SCHARS (s
) + i
+ 2
8665 + (char_matches
? 0 : SCHARS (desc
) + 3))
8669 ptrdiff_t thiswidth
;
8671 /* Punctuate between strings. */
8674 strcpy (menu
+ i
, ", ");
8680 /* If the char to type doesn't match the string's
8681 first char, explicitly show what char to type. */
8684 /* Add as much of string as fits. */
8685 thiswidth
= min (SCHARS (desc
), width
- i
);
8686 memcpy (menu
+ i
, SDATA (desc
), thiswidth
);
8688 strcpy (menu
+ i
, " = ");
8692 /* Add as much of string as fits. */
8693 thiswidth
= min (SCHARS (s
), width
- i
);
8694 memcpy (menu
+ i
, SDATA (s
), thiswidth
);
8700 /* If this element does not fit, end the line now,
8701 and save the element for the next line. */
8702 strcpy (menu
+ i
, "...");
8707 /* Move past this element. */
8708 if (idx
>= 0 && idx
+ 1 >= ASIZE (vector
))
8709 /* Handle reaching end of dense table. */
8714 rest
= Fcdr_safe (rest
);
8718 /* Prompt with that and read response. */
8719 message2_nolog (menu
, strlen (menu
),
8720 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
8722 /* Make believe its not a keyboard macro in case the help char
8723 is pressed. Help characters are not recorded because menu prompting
8724 is not used on replay.
8726 orig_defn_macro
= KVAR (current_kboard
, defining_kbd_macro
);
8727 KVAR (current_kboard
, defining_kbd_macro
) = Qnil
;
8729 obj
= read_char (commandflag
, 0, 0, Qt
, 0, NULL
);
8730 while (BUFFERP (obj
));
8731 KVAR (current_kboard
, defining_kbd_macro
) = orig_defn_macro
;
8733 if (!INTEGERP (obj
))
8735 else if (XINT (obj
) == -2)
8738 if (! EQ (obj
, menu_prompt_more_char
)
8739 && (!INTEGERP (menu_prompt_more_char
)
8740 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8742 if (!NILP (KVAR (current_kboard
, defining_kbd_macro
)))
8743 store_kbd_macro_char (obj
);
8746 /* Help char - go round again */
8750 /* Reading key sequences. */
8752 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8753 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8754 keymap, or nil otherwise. Return the index of the first keymap in
8755 which KEY has any binding, or NMAPS if no map has a binding.
8757 If KEY is a meta ASCII character, treat it like meta-prefix-char
8758 followed by the corresponding non-meta character. Keymaps in
8759 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8762 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8765 NEXT may be the same array as CURRENT. */
8768 follow_key (Lisp_Object key
, ptrdiff_t nmaps
, Lisp_Object
*current
,
8769 Lisp_Object
*defs
, Lisp_Object
*next
)
8771 ptrdiff_t i
, first_binding
;
8773 first_binding
= nmaps
;
8774 for (i
= nmaps
- 1; i
>= 0; i
--)
8776 if (! NILP (current
[i
]))
8778 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8779 if (! NILP (defs
[i
]))
8786 /* Given the set of bindings we've found, produce the next set of maps. */
8787 if (first_binding
< nmaps
)
8788 for (i
= 0; i
< nmaps
; i
++)
8789 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8791 return first_binding
;
8794 /* Structure used to keep track of partial application of key remapping
8795 such as Vfunction_key_map and Vkey_translation_map. */
8796 typedef struct keyremap
8798 /* This is the map originally specified for this use. */
8800 /* This is a submap reached by looking up, in PARENT,
8801 the events from START to END. */
8803 /* Positions [START, END) in the key sequence buffer
8804 are the key that we have scanned so far.
8805 Those events are the ones that we will replace
8806 if PARENT maps them into a key sequence. */
8810 /* Lookup KEY in MAP.
8811 MAP is a keymap mapping keys to key vectors or functions.
8812 If the mapping is a function and DO_FUNCTION is non-zero, then
8813 the function is called with PROMPT as parameter and its return
8814 value is used as the return value of this function (after checking
8815 that it is indeed a vector). */
8818 access_keymap_keyremap (Lisp_Object map
, Lisp_Object key
, Lisp_Object prompt
,
8823 next
= access_keymap (map
, key
, 1, 0, 1);
8825 /* Handle symbol with autoload definition. */
8826 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8827 && CONSP (XSYMBOL (next
)->function
)
8828 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8829 do_autoload (XSYMBOL (next
)->function
, next
);
8831 /* Handle a symbol whose function definition is a keymap
8833 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8834 && (ARRAYP (XSYMBOL (next
)->function
)
8835 || KEYMAPP (XSYMBOL (next
)->function
)))
8836 next
= XSYMBOL (next
)->function
;
8838 /* If the keymap gives a function, not an
8839 array, then call the function with one arg and use
8840 its value instead. */
8841 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8846 next
= call1 (next
, prompt
);
8847 /* If the function returned something invalid,
8848 barf--don't ignore it.
8849 (To ignore it safely, we would need to gcpro a bunch of
8850 other variables.) */
8851 if (! (VECTORP (next
) || STRINGP (next
)))
8852 error ("Function %s returns invalid key sequence",
8853 SSDATA (SYMBOL_NAME (tem
)));
8858 /* Do one step of the key remapping used for function-key-map and
8859 key-translation-map:
8860 KEYBUF is the buffer holding the input events.
8861 BUFSIZE is its maximum size.
8862 FKEY is a pointer to the keyremap structure to use.
8863 INPUT is the index of the last element in KEYBUF.
8864 DOIT if non-zero says that the remapping can actually take place.
8865 DIFF is used to return the number of keys added/removed by the remapping.
8866 PARENT is the root of the keymap.
8867 PROMPT is the prompt to use if the remapping happens through a function.
8868 The return value is non-zero if the remapping actually took place. */
8871 keyremap_step (Lisp_Object
*keybuf
, int bufsize
, volatile keyremap
*fkey
,
8872 int input
, int doit
, int *diff
, Lisp_Object prompt
)
8874 Lisp_Object next
, key
;
8876 key
= keybuf
[fkey
->end
++];
8878 if (KEYMAPP (fkey
->parent
))
8879 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
8883 /* If keybuf[fkey->start..fkey->end] is bound in the
8884 map and we're in a position to do the key remapping, replace it with
8885 the binding and restart with fkey->start at the end. */
8886 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
8888 int len
= XFASTINT (Flength (next
));
8891 *diff
= len
- (fkey
->end
- fkey
->start
);
8893 if (bufsize
- input
<= *diff
)
8894 error ("Key sequence too long");
8896 /* Shift the keys that follow fkey->end. */
8898 for (i
= fkey
->end
; i
< input
; i
++)
8899 keybuf
[i
+ *diff
] = keybuf
[i
];
8901 for (i
= input
- 1; i
>= fkey
->end
; i
--)
8902 keybuf
[i
+ *diff
] = keybuf
[i
];
8903 /* Overwrite the old keys with the new ones. */
8904 for (i
= 0; i
< len
; i
++)
8905 keybuf
[fkey
->start
+ i
]
8906 = Faref (next
, make_number (i
));
8908 fkey
->start
= fkey
->end
+= *diff
;
8909 fkey
->map
= fkey
->parent
;
8914 fkey
->map
= get_keymap (next
, 0, 1);
8916 /* If we no longer have a bound suffix, try a new position for
8918 if (!CONSP (fkey
->map
))
8920 fkey
->end
= ++fkey
->start
;
8921 fkey
->map
= fkey
->parent
;
8927 test_undefined (Lisp_Object binding
)
8929 return (EQ (binding
, Qundefined
)
8930 || (!NILP (binding
) && SYMBOLP (binding
)
8931 && EQ (Fcommand_remapping (binding
, Qnil
, Qnil
), Qundefined
)));
8934 /* Read a sequence of keys that ends with a non prefix character,
8935 storing it in KEYBUF, a buffer of size BUFSIZE.
8937 Return the length of the key sequence stored.
8938 Return -1 if the user rejected a command menu.
8940 Echo starting immediately unless `prompt' is 0.
8942 Where a key sequence ends depends on the currently active keymaps.
8943 These include any minor mode keymaps active in the current buffer,
8944 the current buffer's local map, and the global map.
8946 If a key sequence has no other bindings, we check Vfunction_key_map
8947 to see if some trailing subsequence might be the beginning of a
8948 function key's sequence. If so, we try to read the whole function
8949 key, and substitute its symbolic name into the key sequence.
8951 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
8952 `double-' events into similar click events, if that would make them
8953 bound. We try to turn `triple-' events first into `double-' events,
8956 If we get a mouse click in a mode line, vertical divider, or other
8957 non-text area, we treat the click as if it were prefixed by the
8958 symbol denoting that area - `mode-line', `vertical-line', or
8961 If the sequence starts with a mouse click, we read the key sequence
8962 with respect to the buffer clicked on, not the current buffer.
8964 If the user switches frames in the midst of a key sequence, we put
8965 off the switch-frame event until later; the next call to
8966 read_char will return it.
8968 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
8969 from the selected window's buffer. */
8972 read_key_sequence (Lisp_Object
*keybuf
, int bufsize
, Lisp_Object prompt
,
8973 int dont_downcase_last
, int can_return_switch_frame
,
8974 int fix_current_buffer
)
8976 Lisp_Object from_string
;
8977 ptrdiff_t count
= SPECPDL_INDEX ();
8979 /* How many keys there are in the current key sequence. */
8982 /* The length of the echo buffer when we started reading, and
8983 the length of this_command_keys when we started reading. */
8984 ptrdiff_t echo_start
IF_LINT (= 0);
8985 ptrdiff_t keys_start
;
8987 /* The number of keymaps we're scanning right now, and the number of
8988 keymaps we have allocated space for. */
8990 ptrdiff_t nmaps_allocated
= 0;
8992 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
8993 the current keymaps. */
8994 Lisp_Object
*defs
= NULL
;
8996 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
8997 in the current keymaps, or nil where it is not a prefix. */
8998 Lisp_Object
*submaps
= NULL
;
9000 /* The local map to start out with at start of key sequence. */
9001 Lisp_Object orig_local_map
;
9003 /* The map from the `keymap' property to start out with at start of
9005 Lisp_Object orig_keymap
;
9007 /* 1 if we have already considered switching to the local-map property
9008 of the place where a mouse click occurred. */
9009 int localized_local_map
= 0;
9011 /* The index in submaps[] of the first keymap that has a binding for
9012 this key sequence. In other words, the lowest i such that
9013 submaps[i] is non-nil. */
9014 ptrdiff_t first_binding
;
9015 /* Index of the first key that has no binding.
9016 It is useless to try fkey.start larger than that. */
9019 /* If t < mock_input, then KEYBUF[t] should be read as the next
9022 We use this to recover after recognizing a function key. Once we
9023 realize that a suffix of the current key sequence is actually a
9024 function key's escape sequence, we replace the suffix with the
9025 function key's binding from Vfunction_key_map. Now keybuf
9026 contains a new and different key sequence, so the echo area,
9027 this_command_keys, and the submaps and defs arrays are wrong. In
9028 this situation, we set mock_input to t, set t to 0, and jump to
9029 restart_sequence; the loop will read keys from keybuf up until
9030 mock_input, thus rebuilding the state; and then it will resume
9031 reading characters from the keyboard. */
9034 /* If the sequence is unbound in submaps[], then
9035 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
9036 and fkey.map is its binding.
9038 These might be > t, indicating that all function key scanning
9039 should hold off until t reaches them. We do this when we've just
9040 recognized a function key, to avoid searching for the function
9041 key's again in Vfunction_key_map. */
9044 /* Likewise, for key_translation_map and input-decode-map. */
9045 keyremap keytran
, indec
;
9047 /* Non-zero if we are trying to map a key by changing an upper-case
9048 letter to lower case, or a shifted function key to an unshifted
9050 int shift_translated
= 0;
9052 /* If we receive a `switch-frame' or `select-window' event in the middle of
9053 a key sequence, we put it off for later.
9054 While we're reading, we keep the event here. */
9055 Lisp_Object delayed_switch_frame
;
9057 /* See the comment below... */
9058 #if defined (GOBBLE_FIRST_EVENT)
9059 Lisp_Object first_event
;
9062 Lisp_Object original_uppercase
IF_LINT (= Qnil
);
9063 int original_uppercase_position
= -1;
9065 /* Gets around Microsoft compiler limitations. */
9068 struct buffer
*starting_buffer
;
9070 /* List of events for which a fake prefix key has been generated. */
9071 Lisp_Object fake_prefixed_keys
= Qnil
;
9073 #if defined (GOBBLE_FIRST_EVENT)
9077 struct gcpro gcpro1
;
9079 GCPRO1 (fake_prefixed_keys
);
9080 raw_keybuf_count
= 0;
9082 last_nonmenu_event
= Qnil
;
9084 delayed_switch_frame
= Qnil
;
9090 /* Install the string STR as the beginning of the string of
9091 echoing, so that it serves as a prompt for the next
9093 KVAR (current_kboard
, echo_string
) = prompt
;
9094 current_kboard
->echo_after_prompt
= SCHARS (prompt
);
9097 else if (cursor_in_echo_area
9098 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9099 && NILP (Fzerop (Vecho_keystrokes
)))
9100 /* This doesn't put in a dash if the echo buffer is empty, so
9101 you don't always see a dash hanging out in the minibuffer. */
9105 /* Record the initial state of the echo area and this_command_keys;
9106 we will need to restore them if we replay a key sequence. */
9108 echo_start
= echo_length ();
9109 keys_start
= this_command_key_count
;
9110 this_single_command_key_start
= keys_start
;
9112 #if defined (GOBBLE_FIRST_EVENT)
9113 /* This doesn't quite work, because some of the things that read_char
9114 does cannot safely be bypassed. It seems too risky to try to make
9117 /* Read the first char of the sequence specially, before setting
9118 up any keymaps, in case a filter runs and switches buffers on us. */
9119 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
9121 #endif /* GOBBLE_FIRST_EVENT */
9123 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9124 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9127 /* We jump here when we need to reinitialize fkey and keytran; this
9128 happens if we switch keyboards between rescans. */
9129 replay_entire_sequence
:
9131 indec
.map
= indec
.parent
= KVAR (current_kboard
, Vinput_decode_map
);
9132 fkey
.map
= fkey
.parent
= KVAR (current_kboard
, Vlocal_function_key_map
);
9133 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
9134 indec
.start
= indec
.end
= 0;
9135 fkey
.start
= fkey
.end
= 0;
9136 keytran
.start
= keytran
.end
= 0;
9138 /* We jump here when the key sequence has been thoroughly changed, and
9139 we need to rescan it starting from the beginning. When we jump here,
9140 keybuf[0..mock_input] holds the sequence we should reread. */
9143 starting_buffer
= current_buffer
;
9144 first_unbound
= bufsize
+ 1;
9146 /* Build our list of keymaps.
9147 If we recognize a function key and replace its escape sequence in
9148 keybuf with its symbol, or if the sequence starts with a mouse
9149 click and we need to switch buffers, we jump back here to rebuild
9150 the initial keymaps from the current buffer. */
9153 if (!NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
9155 if (2 > nmaps_allocated
)
9157 submaps
= alloca (2 * sizeof *submaps
);
9158 defs
= alloca (2 * sizeof *defs
);
9159 nmaps_allocated
= 2;
9161 submaps
[nmaps
++] = KVAR (current_kboard
, Voverriding_terminal_local_map
);
9163 else if (!NILP (Voverriding_local_map
))
9165 if (2 > nmaps_allocated
)
9167 submaps
= alloca (2 * sizeof *submaps
);
9168 defs
= alloca (2 * sizeof *defs
);
9169 nmaps_allocated
= 2;
9171 submaps
[nmaps
++] = Voverriding_local_map
;
9179 nminor
= current_minor_maps (0, &maps
);
9180 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
9182 if (total
> nmaps_allocated
)
9184 submaps
= alloca (total
* sizeof *submaps
);
9185 defs
= alloca (total
* sizeof *defs
);
9186 nmaps_allocated
= total
;
9189 if (!NILP (orig_keymap
))
9190 submaps
[nmaps
++] = orig_keymap
;
9192 memcpy (submaps
+ nmaps
, maps
, nminor
* sizeof (submaps
[0]));
9196 submaps
[nmaps
++] = orig_local_map
;
9198 submaps
[nmaps
++] = current_global_map
;
9200 /* Find an accurate initial value for first_binding. */
9201 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
9202 if (! NILP (submaps
[first_binding
]))
9205 /* Start from the beginning in keybuf. */
9208 /* These are no-ops the first time through, but if we restart, they
9209 revert the echo area and this_command_keys to their original state. */
9210 this_command_key_count
= keys_start
;
9211 if (INTERACTIVE
&& t
< mock_input
)
9212 echo_truncate (echo_start
);
9214 /* If the best binding for the current key sequence is a keymap, or
9215 we may be looking at a function key's escape sequence, keep on
9217 while (first_binding
< nmaps
9218 /* Keep reading as long as there's a prefix binding. */
9219 ? !NILP (submaps
[first_binding
])
9220 /* Don't return in the middle of a possible function key sequence,
9221 if the only bindings we found were via case conversion.
9222 Thus, if ESC O a has a function-key-map translation
9223 and ESC o has a binding, don't return after ESC O,
9224 so that we can translate ESC O plus the next character. */
9225 : (/* indec.start < t || fkey.start < t || */ keytran
.start
< t
))
9228 int used_mouse_menu
= 0;
9230 /* Where the last real key started. If we need to throw away a
9231 key that has expanded into more than one element of keybuf
9232 (say, a mouse click on the mode line which is being treated
9233 as [mode-line (mouse-...)], then we backtrack to this point
9235 int last_real_key_start
;
9237 /* These variables are analogous to echo_start and keys_start;
9238 while those allow us to restart the entire key sequence,
9239 echo_local_start and keys_local_start allow us to throw away
9241 ptrdiff_t echo_local_start
IF_LINT (= 0);
9242 int keys_local_start
;
9243 ptrdiff_t local_first_binding
;
9245 eassert (indec
.end
== t
|| (indec
.end
> t
&& indec
.end
<= mock_input
));
9246 eassert (indec
.start
<= indec
.end
);
9247 eassert (fkey
.start
<= fkey
.end
);
9248 eassert (keytran
.start
<= keytran
.end
);
9249 /* key-translation-map is applied *after* function-key-map
9250 which is itself applied *after* input-decode-map. */
9251 eassert (fkey
.end
<= indec
.start
);
9252 eassert (keytran
.end
<= fkey
.start
);
9254 if (/* first_unbound < indec.start && first_unbound < fkey.start && */
9255 first_unbound
< keytran
.start
)
9256 { /* The prefix upto first_unbound has no binding and has
9257 no translation left to do either, so we know it's unbound.
9258 If we don't stop now, we risk staying here indefinitely
9259 (if the user keeps entering fkey or keytran prefixes
9260 like C-c ESC ESC ESC ESC ...) */
9262 for (i
= first_unbound
+ 1; i
< t
; i
++)
9263 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
9264 mock_input
= t
- first_unbound
- 1;
9265 indec
.end
= indec
.start
-= first_unbound
+ 1;
9266 indec
.map
= indec
.parent
;
9267 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
9268 fkey
.map
= fkey
.parent
;
9269 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
9270 keytran
.map
= keytran
.parent
;
9271 goto replay_sequence
;
9275 error ("Key sequence too long");
9278 echo_local_start
= echo_length ();
9279 keys_local_start
= this_command_key_count
;
9280 local_first_binding
= first_binding
;
9283 /* These are no-ops, unless we throw away a keystroke below and
9284 jumped back up to replay_key; in that case, these restore the
9285 variables to their original state, allowing us to replay the
9287 if (INTERACTIVE
&& t
< mock_input
)
9288 echo_truncate (echo_local_start
);
9289 this_command_key_count
= keys_local_start
;
9290 first_binding
= local_first_binding
;
9292 /* By default, assume each event is "real". */
9293 last_real_key_start
= t
;
9295 /* Does mock_input indicate that we are re-reading a key sequence? */
9299 add_command_key (key
);
9300 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9301 && NILP (Fzerop (Vecho_keystrokes
)))
9305 /* If not, we should actually read a character. */
9309 KBOARD
*interrupted_kboard
= current_kboard
;
9310 struct frame
*interrupted_frame
= SELECTED_FRAME ();
9311 key
= read_char (NILP (prompt
), nmaps
,
9312 (Lisp_Object
*) submaps
, last_nonmenu_event
,
9313 &used_mouse_menu
, NULL
);
9314 if ((INTEGERP (key
) && XINT (key
) == -2) /* wrong_kboard_jmpbuf */
9315 /* When switching to a new tty (with a new keyboard),
9316 read_char returns the new buffer, rather than -2
9317 (Bug#5095). This is because `terminal-init-xterm'
9318 calls read-char, which eats the wrong_kboard_jmpbuf
9319 return. Any better way to fix this? -- cyd */
9320 || (interrupted_kboard
!= current_kboard
))
9325 for (k
= all_kboards
; k
; k
= k
->next_kboard
)
9326 if (k
== interrupted_kboard
)
9331 /* Don't touch interrupted_kboard when it's been
9333 delayed_switch_frame
= Qnil
;
9334 goto replay_entire_sequence
;
9337 if (!NILP (delayed_switch_frame
))
9339 KVAR (interrupted_kboard
, kbd_queue
)
9340 = Fcons (delayed_switch_frame
,
9341 KVAR (interrupted_kboard
, kbd_queue
));
9342 delayed_switch_frame
= Qnil
;
9346 KVAR (interrupted_kboard
, kbd_queue
)
9347 = Fcons (keybuf
[--t
], KVAR (interrupted_kboard
, kbd_queue
));
9349 /* If the side queue is non-empty, ensure it begins with a
9350 switch-frame, so we'll replay it in the right context. */
9351 if (CONSP (KVAR (interrupted_kboard
, kbd_queue
))
9352 && (key
= XCAR (KVAR (interrupted_kboard
, kbd_queue
)),
9353 !(EVENT_HAS_PARAMETERS (key
)
9354 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
9358 XSETFRAME (frame
, interrupted_frame
);
9359 KVAR (interrupted_kboard
, kbd_queue
)
9360 = Fcons (make_lispy_switch_frame (frame
),
9361 KVAR (interrupted_kboard
, kbd_queue
));
9364 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9365 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9366 goto replay_entire_sequence
;
9370 /* read_char returns t when it shows a menu and the user rejects it.
9374 unbind_to (count
, Qnil
);
9379 /* read_char returns -1 at the end of a macro.
9380 Emacs 18 handles this by returning immediately with a
9381 zero, so that's what we'll do. */
9382 if (INTEGERP (key
) && XINT (key
) == -1)
9385 /* The Microsoft C compiler can't handle the goto that
9391 /* If the current buffer has been changed from under us, the
9392 keymap may have changed, so replay the sequence. */
9395 timer_resume_idle ();
9398 /* Reset the current buffer from the selected window
9399 in case something changed the former and not the latter.
9400 This is to be more consistent with the behavior
9401 of the command_loop_1. */
9402 if (fix_current_buffer
)
9404 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9406 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
9407 Fset_buffer (XWINDOW (selected_window
)->buffer
);
9410 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9411 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9412 goto replay_sequence
;
9415 /* If we have a quit that was typed in another frame, and
9416 quit_throw_to_read_char switched buffers,
9417 replay to get the right keymap. */
9419 && XINT (key
) == quit_char
9420 && current_buffer
!= starting_buffer
)
9423 ASET (raw_keybuf
, raw_keybuf_count
, key
);
9428 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9429 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9430 goto replay_sequence
;
9435 if (EVENT_HAS_PARAMETERS (key
)
9436 /* Either a `switch-frame' or a `select-window' event. */
9437 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
9439 /* If we're at the beginning of a key sequence, and the caller
9440 says it's okay, go ahead and return this event. If we're
9441 in the midst of a key sequence, delay it until the end. */
9442 if (t
> 0 || !can_return_switch_frame
)
9444 delayed_switch_frame
= key
;
9450 ASET (raw_keybuf
, raw_keybuf_count
, key
);
9454 /* Clicks in non-text areas get prefixed by the symbol
9455 in their CHAR-ADDRESS field. For example, a click on
9456 the mode line is prefixed by the symbol `mode-line'.
9458 Furthermore, key sequences beginning with mouse clicks
9459 are read using the keymaps of the buffer clicked on, not
9460 the current buffer. So we may have to switch the buffer
9463 When we turn one event into two events, we must make sure
9464 that neither of the two looks like the original--so that,
9465 if we replay the events, they won't be expanded again.
9466 If not for this, such reexpansion could happen either here
9467 or when user programs play with this-command-keys. */
9468 if (EVENT_HAS_PARAMETERS (key
))
9473 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
9474 if (EQ (kind
, Qmouse_click
))
9476 Lisp_Object window
, posn
;
9478 window
= POSN_WINDOW (EVENT_START (key
));
9479 posn
= POSN_POSN (EVENT_START (key
));
9482 || (!NILP (fake_prefixed_keys
)
9483 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
9485 /* We're looking a second time at an event for which
9486 we generated a fake prefix key. Set
9487 last_real_key_start appropriately. */
9489 last_real_key_start
= t
- 1;
9492 if (last_real_key_start
== 0)
9494 /* Key sequences beginning with mouse clicks are
9495 read using the keymaps in the buffer clicked on,
9496 not the current buffer. If we're at the
9497 beginning of a key sequence, switch buffers. */
9498 if (WINDOWP (window
)
9499 && BUFFERP (XWINDOW (window
)->buffer
)
9500 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
9502 ASET (raw_keybuf
, raw_keybuf_count
, key
);
9507 /* Arrange to go back to the original buffer once we're
9508 done reading the key sequence. Note that we can't
9509 use save_excursion_{save,restore} here, because they
9510 save point as well as the current buffer; we don't
9511 want to save point, because redisplay may change it,
9512 to accommodate a Fset_window_start or something. We
9513 don't want to do this at the top of the function,
9514 because we may get input from a subprocess which
9515 wants to change the selected window and stuff (say,
9517 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
9519 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9521 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
9522 orig_local_map
= get_local_map (PT
, current_buffer
,
9524 orig_keymap
= get_local_map (PT
, current_buffer
,
9526 goto replay_sequence
;
9529 /* For a mouse click, get the local text-property keymap
9530 of the place clicked on, rather than point. */
9531 if (CONSP (XCDR (key
))
9532 && ! localized_local_map
)
9534 Lisp_Object map_here
, start
, pos
;
9536 localized_local_map
= 1;
9537 start
= EVENT_START (key
);
9539 if (CONSP (start
) && POSN_INBUFFER_P (start
))
9541 pos
= POSN_BUFFER_POSN (start
);
9543 && XINT (pos
) >= BEGV
9544 && XINT (pos
) <= ZV
)
9546 map_here
= get_local_map (XINT (pos
),
9549 if (!EQ (map_here
, orig_local_map
))
9551 orig_local_map
= map_here
;
9552 ++localized_local_map
;
9555 map_here
= get_local_map (XINT (pos
),
9558 if (!EQ (map_here
, orig_keymap
))
9560 orig_keymap
= map_here
;
9561 ++localized_local_map
;
9564 if (localized_local_map
> 1)
9569 goto replay_sequence
;
9576 /* Expand mode-line and scroll-bar events into two events:
9577 use posn as a fake prefix key. */
9579 && (NILP (fake_prefixed_keys
)
9580 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9582 if (bufsize
- t
<= 1)
9583 error ("Key sequence too long");
9586 keybuf
[t
+ 1] = key
;
9589 /* Record that a fake prefix key has been generated
9590 for KEY. Don't modify the event; this would
9591 prevent proper action when the event is pushed
9592 back into unread-command-events. */
9593 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9595 /* If on a mode line string with a local keymap,
9596 reconsider the key sequence with that keymap. */
9597 if (string
= POSN_STRING (EVENT_START (key
)),
9598 (CONSP (string
) && STRINGP (XCAR (string
))))
9600 Lisp_Object pos
, map
, map2
;
9602 pos
= XCDR (string
);
9603 string
= XCAR (string
);
9605 && XINT (pos
) < SCHARS (string
))
9607 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9609 orig_local_map
= map
;
9610 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9613 if (!NILP (map
) || !NILP (map2
))
9614 goto replay_sequence
;
9620 else if (NILP (from_string
)
9621 && (string
= POSN_STRING (EVENT_START (key
)),
9622 (CONSP (string
) && STRINGP (XCAR (string
)))))
9624 /* For a click on a string, i.e. overlay string or a
9625 string displayed via the `display' property,
9626 consider `local-map' and `keymap' properties of
9628 Lisp_Object pos
, map
, map2
;
9630 pos
= XCDR (string
);
9631 string
= XCAR (string
);
9633 && XINT (pos
) < SCHARS (string
))
9635 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9637 orig_local_map
= map
;
9638 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9642 if (!NILP (map
) || !NILP (map2
))
9644 from_string
= string
;
9647 goto replay_sequence
;
9652 else if (CONSP (XCDR (key
))
9653 && CONSP (EVENT_START (key
))
9654 && CONSP (XCDR (EVENT_START (key
))))
9658 posn
= POSN_POSN (EVENT_START (key
));
9659 /* Handle menu-bar events:
9660 insert the dummy prefix event `menu-bar'. */
9661 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9663 if (bufsize
- t
<= 1)
9664 error ("Key sequence too long");
9668 /* Zap the position in key, so we know that we've
9669 expanded it, and don't try to do so again. */
9670 POSN_SET_POSN (EVENT_START (key
),
9671 Fcons (posn
, Qnil
));
9674 goto replay_sequence
;
9676 else if (CONSP (posn
))
9678 /* We're looking at the second event of a
9679 sequence which we expanded before. Set
9680 last_real_key_start appropriately. */
9681 if (last_real_key_start
== t
&& t
> 0)
9682 last_real_key_start
= t
- 1;
9687 /* We have finally decided that KEY is something we might want
9689 first_binding
= (follow_key (key
,
9690 nmaps
- first_binding
,
9691 submaps
+ first_binding
,
9692 defs
+ first_binding
,
9693 submaps
+ first_binding
)
9696 /* If KEY wasn't bound, we'll try some fallbacks. */
9697 if (first_binding
< nmaps
)
9698 /* This is needed for the following scenario:
9699 event 0: a down-event that gets dropped by calling replay_key.
9700 event 1: some normal prefix like C-h.
9701 After event 0, first_unbound is 0, after event 1 indec.start,
9702 fkey.start, and keytran.start are all 1, so when we see that
9703 C-h is bound, we need to update first_unbound. */
9704 first_unbound
= max (t
+ 1, first_unbound
);
9709 /* Remember the position to put an upper bound on indec.start. */
9710 first_unbound
= min (t
, first_unbound
);
9712 head
= EVENT_HEAD (key
);
9713 if (help_char_p (head
) && t
> 0)
9715 read_key_sequence_cmd
= Vprefix_help_command
;
9717 last_nonmenu_event
= key
;
9718 /* The Microsoft C compiler can't handle the goto that
9726 Lisp_Object breakdown
;
9729 breakdown
= parse_modifiers (head
);
9730 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9731 /* Attempt to reduce an unbound mouse event to a simpler
9732 event that is bound:
9733 Drags reduce to clicks.
9734 Double-clicks reduce to clicks.
9735 Triple-clicks reduce to double-clicks, then to clicks.
9736 Down-clicks are eliminated.
9737 Double-downs reduce to downs, then are eliminated.
9738 Triple-downs reduce to double-downs, then to downs,
9739 then are eliminated. */
9740 if (modifiers
& (down_modifier
| drag_modifier
9741 | double_modifier
| triple_modifier
))
9743 while (modifiers
& (down_modifier
| drag_modifier
9744 | double_modifier
| triple_modifier
))
9746 Lisp_Object new_head
, new_click
;
9747 if (modifiers
& triple_modifier
)
9748 modifiers
^= (double_modifier
| triple_modifier
);
9749 else if (modifiers
& double_modifier
)
9750 modifiers
&= ~double_modifier
;
9751 else if (modifiers
& drag_modifier
)
9752 modifiers
&= ~drag_modifier
;
9755 /* Dispose of this `down' event by simply jumping
9756 back to replay_key, to get another event.
9758 Note that if this event came from mock input,
9759 then just jumping back to replay_key will just
9760 hand it to us again. So we have to wipe out any
9763 We could delete keybuf[t] and shift everything
9764 after that to the left by one spot, but we'd also
9765 have to fix up any variable that points into
9766 keybuf, and shifting isn't really necessary
9769 Adding prefixes for non-textual mouse clicks
9770 creates two characters of mock input, and both
9771 must be thrown away. If we're only looking at
9772 the prefix now, we can just jump back to
9773 replay_key. On the other hand, if we've already
9774 processed the prefix, and now the actual click
9775 itself is giving us trouble, then we've lost the
9776 state of the keymaps we want to backtrack to, and
9777 we need to replay the whole sequence to rebuild
9780 Beyond that, only function key expansion could
9781 create more than two keys, but that should never
9782 generate mouse events, so it's okay to zero
9783 mock_input in that case too.
9785 FIXME: The above paragraph seems just plain
9786 wrong, if you consider things like
9787 xterm-mouse-mode. -stef
9789 Isn't this just the most wonderful code ever? */
9791 /* If mock_input > t + 1, the above simplification
9792 will actually end up dropping keys on the floor.
9793 This is probably OK for now, but even
9794 if mock_input <= t + 1, we need to adjust indec,
9796 Typical case [header-line down-mouse-N]:
9797 mock_input = 2, t = 1, fkey.end = 1,
9798 last_real_key_start = 0. */
9799 if (indec
.end
> last_real_key_start
)
9801 indec
.end
= indec
.start
9802 = min (last_real_key_start
, indec
.start
);
9803 indec
.map
= indec
.parent
;
9804 if (fkey
.end
> last_real_key_start
)
9806 fkey
.end
= fkey
.start
9807 = min (last_real_key_start
, fkey
.start
);
9808 fkey
.map
= fkey
.parent
;
9809 if (keytran
.end
> last_real_key_start
)
9811 keytran
.end
= keytran
.start
9812 = min (last_real_key_start
, keytran
.start
);
9813 keytran
.map
= keytran
.parent
;
9817 if (t
== last_real_key_start
)
9824 mock_input
= last_real_key_start
;
9825 goto replay_sequence
;
9830 = apply_modifiers (modifiers
, XCAR (breakdown
));
9832 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9834 /* Look for a binding for this new key. follow_key
9835 promises that it didn't munge submaps the
9836 last time we called it, since key was unbound. */
9838 = (follow_key (new_click
,
9839 nmaps
- local_first_binding
,
9840 submaps
+ local_first_binding
,
9841 defs
+ local_first_binding
,
9842 submaps
+ local_first_binding
)
9843 + local_first_binding
);
9845 /* If that click is bound, go for it. */
9846 if (first_binding
< nmaps
)
9851 /* Otherwise, we'll leave key set to the drag event. */
9858 /* Normally, last_nonmenu_event gets the previous key we read.
9859 But when a mouse popup menu is being used,
9860 we don't update last_nonmenu_event; it continues to hold the mouse
9861 event that preceded the first level of menu. */
9862 if (!used_mouse_menu
)
9863 last_nonmenu_event
= key
;
9865 /* Record what part of this_command_keys is the current key sequence. */
9866 this_single_command_key_start
= this_command_key_count
- t
;
9868 /* Look for this sequence in input-decode-map.
9869 Scan from indec.end until we find a bound suffix. */
9870 while (indec
.end
< t
)
9872 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9875 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9876 done
= keyremap_step (keybuf
, bufsize
, &indec
, max (t
, mock_input
),
9881 mock_input
= diff
+ max (t
, mock_input
);
9882 goto replay_sequence
;
9886 if (first_binding
< nmaps
9887 && NILP (submaps
[first_binding
])
9888 && !test_undefined (defs
[first_binding
])
9889 && indec
.start
>= t
)
9890 /* There is a binding and it's not a prefix.
9891 (and it doesn't have any input-decode-map translation pending).
9892 There is thus no function-key in this sequence.
9893 Moving fkey.start is important in this case to allow keytran.start
9894 to go over the sequence before we return (since we keep the
9895 invariant that keytran.end <= fkey.start). */
9898 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
9901 /* If the sequence is unbound, see if we can hang a function key
9902 off the end of it. */
9903 /* Continue scan from fkey.end until we find a bound suffix. */
9904 while (fkey
.end
< indec
.start
)
9906 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9909 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9910 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
9911 max (t
, mock_input
),
9912 /* If there's a binding (i.e.
9913 first_binding >= nmaps) we don't want
9914 to apply this function-key-mapping. */
9916 && (first_binding
>= nmaps
9917 || test_undefined (defs
[first_binding
])),
9922 mock_input
= diff
+ max (t
, mock_input
);
9923 /* Adjust the input-decode-map counters. */
9925 indec
.start
+= diff
;
9927 goto replay_sequence
;
9931 /* Look for this sequence in key-translation-map.
9932 Scan from keytran.end until we find a bound suffix. */
9933 while (keytran
.end
< fkey
.start
)
9935 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9938 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9939 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
9944 mock_input
= diff
+ max (t
, mock_input
);
9945 /* Adjust the function-key-map and input-decode-map counters. */
9947 indec
.start
+= diff
;
9951 goto replay_sequence
;
9955 /* If KEY is not defined in any of the keymaps,
9956 and cannot be part of a function key or translation,
9957 and is an upper case letter
9958 use the corresponding lower-case letter instead. */
9959 if (first_binding
>= nmaps
9960 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
9962 && ((CHARACTERP (make_number (XINT (key
) & ~CHAR_MODIFIER_MASK
))
9963 && uppercasep (XINT (key
) & ~CHAR_MODIFIER_MASK
))
9964 || (XINT (key
) & shift_modifier
)))
9966 Lisp_Object new_key
;
9968 original_uppercase
= key
;
9969 original_uppercase_position
= t
- 1;
9971 if (XINT (key
) & shift_modifier
)
9972 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
9974 XSETINT (new_key
, (downcase (XINT (key
) & ~CHAR_MODIFIER_MASK
)
9975 | (XINT (key
) & CHAR_MODIFIER_MASK
)));
9977 /* We have to do this unconditionally, regardless of whether
9978 the lower-case char is defined in the keymaps, because they
9979 might get translated through function-key-map. */
9980 keybuf
[t
- 1] = new_key
;
9981 mock_input
= max (t
, mock_input
);
9982 shift_translated
= 1;
9984 goto replay_sequence
;
9986 /* If KEY is not defined in any of the keymaps,
9987 and cannot be part of a function key or translation,
9988 and is a shifted function key,
9989 use the corresponding unshifted function key instead. */
9990 if (first_binding
>= nmaps
9991 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
)
9993 Lisp_Object breakdown
= parse_modifiers (key
);
9995 = CONSP (breakdown
) ? (XINT (XCAR (XCDR (breakdown
)))) : 0;
9997 if (modifiers
& shift_modifier
9998 /* Treat uppercase keys as shifted. */
10000 && (KEY_TO_CHAR (key
)
10001 < XCHAR_TABLE (BVAR (current_buffer
, downcase_table
))->header
.size
)
10002 && uppercasep (KEY_TO_CHAR (key
))))
10004 Lisp_Object new_key
10005 = (modifiers
& shift_modifier
10006 ? apply_modifiers (modifiers
& ~shift_modifier
,
10008 : make_number (downcase (KEY_TO_CHAR (key
)) | modifiers
));
10010 original_uppercase
= key
;
10011 original_uppercase_position
= t
- 1;
10013 /* We have to do this unconditionally, regardless of whether
10014 the lower-case char is defined in the keymaps, because they
10015 might get translated through function-key-map. */
10016 keybuf
[t
- 1] = new_key
;
10017 mock_input
= max (t
, mock_input
);
10018 /* Reset fkey (and consequently keytran) to apply
10019 function-key-map on the result, so that S-backspace is
10020 correctly mapped to DEL (via backspace). OTOH,
10021 input-decode-map doesn't need to go through it again. */
10022 fkey
.start
= fkey
.end
= 0;
10023 keytran
.start
= keytran
.end
= 0;
10024 shift_translated
= 1;
10026 goto replay_sequence
;
10031 read_key_sequence_cmd
= (first_binding
< nmaps
10032 ? defs
[first_binding
]
10034 read_key_sequence_remapped
10035 /* Remap command through active keymaps.
10036 Do the remapping here, before the unbind_to so it uses the keymaps
10037 of the appropriate buffer. */
10038 = SYMBOLP (read_key_sequence_cmd
)
10039 ? Fcommand_remapping (read_key_sequence_cmd
, Qnil
, Qnil
)
10042 unread_switch_frame
= delayed_switch_frame
;
10043 unbind_to (count
, Qnil
);
10045 /* Don't downcase the last character if the caller says don't.
10046 Don't downcase it if the result is undefined, either. */
10047 if ((dont_downcase_last
|| first_binding
>= nmaps
)
10049 && t
- 1 == original_uppercase_position
)
10051 keybuf
[t
- 1] = original_uppercase
;
10052 shift_translated
= 0;
10055 if (shift_translated
)
10056 Vthis_command_keys_shift_translated
= Qt
;
10058 /* Occasionally we fabricate events, perhaps by expanding something
10059 according to function-key-map, or by adding a prefix symbol to a
10060 mouse click in the scroll bar or modeline. In this cases, return
10061 the entire generated key sequence, even if we hit an unbound
10062 prefix or a definition before the end. This means that you will
10063 be able to push back the event properly, and also means that
10064 read-key-sequence will always return a logical unit.
10067 for (; t
< mock_input
; t
++)
10069 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
10070 && NILP (Fzerop (Vecho_keystrokes
)))
10071 echo_char (keybuf
[t
]);
10072 add_command_key (keybuf
[t
]);
10079 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
10080 doc
: /* Read a sequence of keystrokes and return as a string or vector.
10081 The sequence is sufficient to specify a non-prefix command in the
10082 current local and global maps.
10084 First arg PROMPT is a prompt string. If nil, do not prompt specially.
10085 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
10086 as a continuation of the previous key.
10088 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
10089 convert the last event to lower case. (Normally any upper case event
10090 is converted to lower case if the original event is undefined and the lower
10091 case equivalent is defined.) A non-nil value is appropriate for reading
10092 a key sequence to be defined.
10094 A C-g typed while in this function is treated like any other character,
10095 and `quit-flag' is not set.
10097 If the key sequence starts with a mouse click, then the sequence is read
10098 using the keymaps of the buffer of the window clicked in, not the buffer
10099 of the selected window as normal.
10101 `read-key-sequence' drops unbound button-down events, since you normally
10102 only care about the click or drag events which follow them. If a drag
10103 or multi-click event is unbound, but the corresponding click event would
10104 be bound, `read-key-sequence' turns the event into a click event at the
10105 drag's starting position. This means that you don't have to distinguish
10106 between click and drag, double, or triple events unless you want to.
10108 `read-key-sequence' prefixes mouse events on mode lines, the vertical
10109 lines separating windows, and scroll bars with imaginary keys
10110 `mode-line', `vertical-line', and `vertical-scroll-bar'.
10112 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
10113 function will process a switch-frame event if the user switches frames
10114 before typing anything. If the user switches frames in the middle of a
10115 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
10116 is nil, then the event will be put off until after the current key sequence.
10118 `read-key-sequence' checks `function-key-map' for function key
10119 sequences, where they wouldn't conflict with ordinary bindings. See
10120 `function-key-map' for more details.
10122 The optional fifth argument CMD-LOOP, if non-nil, means
10123 that this key sequence is being read by something that will
10124 read commands one after another. It should be nil if the caller
10125 will read just one key sequence. */)
10126 (Lisp_Object prompt
, Lisp_Object continue_echo
, Lisp_Object dont_downcase_last
, Lisp_Object can_return_switch_frame
, Lisp_Object cmd_loop
)
10128 Lisp_Object keybuf
[30];
10130 struct gcpro gcpro1
;
10131 ptrdiff_t count
= SPECPDL_INDEX ();
10133 if (!NILP (prompt
))
10134 CHECK_STRING (prompt
);
10137 specbind (Qinput_method_exit_on_first_char
,
10138 (NILP (cmd_loop
) ? Qt
: Qnil
));
10139 specbind (Qinput_method_use_echo_area
,
10140 (NILP (cmd_loop
) ? Qt
: Qnil
));
10142 memset (keybuf
, 0, sizeof keybuf
);
10143 GCPRO1 (keybuf
[0]);
10144 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10146 if (NILP (continue_echo
))
10148 this_command_key_count
= 0;
10149 this_command_key_count_reset
= 0;
10150 this_single_command_key_start
= 0;
10153 #ifdef HAVE_WINDOW_SYSTEM
10154 if (display_hourglass_p
)
10155 cancel_hourglass ();
10158 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10159 prompt
, ! NILP (dont_downcase_last
),
10160 ! NILP (can_return_switch_frame
), 0);
10162 #if 0 /* The following is fine for code reading a key sequence and
10163 then proceeding with a lengthy computation, but it's not good
10164 for code reading keys in a loop, like an input method. */
10165 #ifdef HAVE_WINDOW_SYSTEM
10166 if (display_hourglass_p
)
10167 start_hourglass ();
10177 return unbind_to (count
, make_event_array (i
, keybuf
));
10180 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
10181 Sread_key_sequence_vector
, 1, 5, 0,
10182 doc
: /* Like `read-key-sequence' but always return a vector. */)
10183 (Lisp_Object prompt
, Lisp_Object continue_echo
, Lisp_Object dont_downcase_last
, Lisp_Object can_return_switch_frame
, Lisp_Object cmd_loop
)
10185 Lisp_Object keybuf
[30];
10187 struct gcpro gcpro1
;
10188 ptrdiff_t count
= SPECPDL_INDEX ();
10190 if (!NILP (prompt
))
10191 CHECK_STRING (prompt
);
10194 specbind (Qinput_method_exit_on_first_char
,
10195 (NILP (cmd_loop
) ? Qt
: Qnil
));
10196 specbind (Qinput_method_use_echo_area
,
10197 (NILP (cmd_loop
) ? Qt
: Qnil
));
10199 memset (keybuf
, 0, sizeof keybuf
);
10200 GCPRO1 (keybuf
[0]);
10201 gcpro1
.nvars
= (sizeof keybuf
/ sizeof (keybuf
[0]));
10203 if (NILP (continue_echo
))
10205 this_command_key_count
= 0;
10206 this_command_key_count_reset
= 0;
10207 this_single_command_key_start
= 0;
10210 #ifdef HAVE_WINDOW_SYSTEM
10211 if (display_hourglass_p
)
10212 cancel_hourglass ();
10215 i
= read_key_sequence (keybuf
, (sizeof keybuf
/ sizeof (keybuf
[0])),
10216 prompt
, ! NILP (dont_downcase_last
),
10217 ! NILP (can_return_switch_frame
), 0);
10219 #ifdef HAVE_WINDOW_SYSTEM
10220 if (display_hourglass_p
)
10221 start_hourglass ();
10230 return unbind_to (count
, Fvector (i
, keybuf
));
10233 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
10234 doc
: /* Execute CMD as an editor command.
10235 CMD must be a symbol that satisfies the `commandp' predicate.
10236 Optional second arg RECORD-FLAG non-nil
10237 means unconditionally put this command in `command-history'.
10238 Otherwise, that is done only if an arg is read using the minibuffer.
10239 The argument KEYS specifies the value to use instead of (this-command-keys)
10240 when reading the arguments; if it is nil, (this-command-keys) is used.
10241 The argument SPECIAL, if non-nil, means that this command is executing
10242 a special event, so ignore the prefix argument and don't clear it. */)
10243 (Lisp_Object cmd
, Lisp_Object record_flag
, Lisp_Object keys
, Lisp_Object special
)
10245 register Lisp_Object final
;
10246 register Lisp_Object tem
;
10247 Lisp_Object prefixarg
;
10249 debug_on_next_call
= 0;
10251 if (NILP (special
))
10253 prefixarg
= KVAR (current_kboard
, Vprefix_arg
);
10254 Vcurrent_prefix_arg
= prefixarg
;
10255 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
10262 tem
= Fget (cmd
, Qdisabled
);
10265 tem
= Fsymbol_value (Qdisabled_command_function
);
10267 return Frun_hooks (1, &Qdisabled_command_function
);
10273 final
= Findirect_function (cmd
, Qnil
);
10275 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
10277 struct gcpro gcpro1
, gcpro2
;
10279 GCPRO2 (cmd
, prefixarg
);
10280 do_autoload (final
, cmd
);
10287 if (STRINGP (final
) || VECTORP (final
))
10289 /* If requested, place the macro in the command history. For
10290 other sorts of commands, call-interactively takes care of
10292 if (!NILP (record_flag
))
10295 = Fcons (Fcons (Qexecute_kbd_macro
,
10296 Fcons (final
, Fcons (prefixarg
, Qnil
))),
10299 /* Don't keep command history around forever. */
10300 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
10302 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
10304 XSETCDR (tem
, Qnil
);
10308 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
10311 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
10312 /* Don't call Fcall_interactively directly because we want to make
10313 sure the backtrace has an entry for `call-interactively'.
10314 For the same reason, pass `cmd' rather than `final'. */
10315 return call3 (Qcall_interactively
, cmd
, record_flag
, keys
);
10322 /* Return nonzero if input events are pending. */
10325 detect_input_pending (void)
10327 if (!input_pending
)
10328 get_input_pending (&input_pending
, 0);
10330 return input_pending
;
10333 /* Return nonzero if input events other than mouse movements are
10337 detect_input_pending_ignore_squeezables (void)
10339 if (!input_pending
)
10340 get_input_pending (&input_pending
, READABLE_EVENTS_IGNORE_SQUEEZABLES
);
10342 return input_pending
;
10345 /* Return nonzero if input events are pending, and run any pending timers. */
10348 detect_input_pending_run_timers (int do_display
)
10350 int old_timers_run
= timers_run
;
10352 if (!input_pending
)
10353 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
10355 if (old_timers_run
!= timers_run
&& do_display
)
10357 redisplay_preserve_echo_area (8);
10358 /* The following fixes a bug when using lazy-lock with
10359 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
10360 from an idle timer function. The symptom of the bug is that
10361 the cursor sometimes doesn't become visible until the next X
10362 event is processed. --gerd. */
10364 Lisp_Object tail
, frame
;
10365 FOR_EACH_FRAME (tail
, frame
)
10366 if (FRAME_RIF (XFRAME (frame
)))
10367 FRAME_RIF (XFRAME (frame
))->flush_display (XFRAME (frame
));
10371 return input_pending
;
10374 /* This is called in some cases before a possible quit.
10375 It cases the next call to detect_input_pending to recompute input_pending.
10376 So calling this function unnecessarily can't do any harm. */
10379 clear_input_pending (void)
10384 /* Return nonzero if there are pending requeued events.
10385 This isn't used yet. The hope is to make wait_reading_process_output
10386 call it, and return if it runs Lisp code that unreads something.
10387 The problem is, kbd_buffer_get_event needs to be fixed to know what
10388 to do in that case. It isn't trivial. */
10391 requeued_events_pending_p (void)
10393 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
10397 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
10398 doc
: /* Return t if command input is currently available with no wait.
10399 Actually, the value is nil only if we can be sure that no input is available;
10400 if there is a doubt, the value is t. */)
10403 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1
10404 || !NILP (Vunread_post_input_method_events
)
10405 || !NILP (Vunread_input_method_events
))
10408 /* Process non-user-visible events (Bug#10195). */
10409 process_special_events ();
10411 get_input_pending (&input_pending
,
10412 READABLE_EVENTS_DO_TIMERS_NOW
10413 | READABLE_EVENTS_FILTER_EVENTS
);
10414 return input_pending
> 0 ? Qt
: Qnil
;
10417 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
10418 doc
: /* Return vector of last 300 events, not counting those from keyboard macros. */)
10421 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
10424 if (total_keys
< NUM_RECENT_KEYS
)
10425 return Fvector (total_keys
, keys
);
10428 val
= Fvector (NUM_RECENT_KEYS
, keys
);
10429 memcpy (XVECTOR (val
)->contents
, keys
+ recent_keys_index
,
10430 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
10431 memcpy (XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
10432 keys
, recent_keys_index
* sizeof (Lisp_Object
));
10437 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
10438 doc
: /* Return the key sequence that invoked this command.
10439 However, if the command has called `read-key-sequence', it returns
10440 the last key sequence that has been read.
10441 The value is a string or a vector.
10443 See also `this-command-keys-vector'. */)
10446 return make_event_array (this_command_key_count
,
10447 XVECTOR (this_command_keys
)->contents
);
10450 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
10451 doc
: /* Return the key sequence that invoked this command, as a vector.
10452 However, if the command has called `read-key-sequence', it returns
10453 the last key sequence that has been read.
10455 See also `this-command-keys'. */)
10458 return Fvector (this_command_key_count
,
10459 XVECTOR (this_command_keys
)->contents
);
10462 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
10463 Sthis_single_command_keys
, 0, 0, 0,
10464 doc
: /* Return the key sequence that invoked this command.
10465 More generally, it returns the last key sequence read, either by
10466 the command loop or by `read-key-sequence'.
10467 Unlike `this-command-keys', this function's value
10468 does not include prefix arguments.
10469 The value is always a vector. */)
10472 return Fvector (this_command_key_count
10473 - this_single_command_key_start
,
10474 (XVECTOR (this_command_keys
)->contents
10475 + this_single_command_key_start
));
10478 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
10479 Sthis_single_command_raw_keys
, 0, 0, 0,
10480 doc
: /* Return the raw events that were read for this command.
10481 More generally, it returns the last key sequence read, either by
10482 the command loop or by `read-key-sequence'.
10483 Unlike `this-single-command-keys', this function's value
10484 shows the events before all translations (except for input methods).
10485 The value is always a vector. */)
10488 return Fvector (raw_keybuf_count
,
10489 (XVECTOR (raw_keybuf
)->contents
));
10492 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10493 Sreset_this_command_lengths
, 0, 0, 0,
10494 doc
: /* Make the unread events replace the last command and echo.
10495 Used in `universal-argument-other-key'.
10497 `universal-argument-other-key' rereads the event just typed.
10498 It then gets translated through `function-key-map'.
10499 The translated event has to replace the real events,
10500 both in the value of (this-command-keys) and in echoing.
10501 To achieve this, `universal-argument-other-key' calls
10502 `reset-this-command-lengths', which discards the record of reading
10503 these events the first time. */)
10506 this_command_key_count
= before_command_key_count
;
10507 if (this_command_key_count
< this_single_command_key_start
)
10508 this_single_command_key_start
= this_command_key_count
;
10510 echo_truncate (before_command_echo_length
);
10512 /* Cause whatever we put into unread-command-events
10513 to echo as if it were being freshly read from the keyboard. */
10514 this_command_key_count_reset
= 1;
10519 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10520 Sclear_this_command_keys
, 0, 1, 0,
10521 doc
: /* Clear out the vector that `this-command-keys' returns.
10522 Also clear the record of the last 100 events, unless optional arg
10523 KEEP-RECORD is non-nil. */)
10524 (Lisp_Object keep_record
)
10528 this_command_key_count
= 0;
10529 this_command_key_count_reset
= 0;
10531 if (NILP (keep_record
))
10533 for (i
= 0; i
< ASIZE (recent_keys
); ++i
)
10534 ASET (recent_keys
, i
, Qnil
);
10536 recent_keys_index
= 0;
10541 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10542 doc
: /* Return the current depth in recursive edits. */)
10546 /* Wrap around reliably on integer overflow. */
10547 EMACS_INT sum
= (command_loop_level
& INTMASK
) + (minibuf_level
& INTMASK
);
10548 XSETINT (temp
, sum
);
10552 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10553 "FOpen dribble file: ",
10554 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10555 If FILE is nil, close any open dribble file.
10556 The file will be closed when Emacs exits. */)
10568 file
= Fexpand_file_name (file
, Qnil
);
10569 dribble
= fopen (SSDATA (file
), "w");
10571 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10576 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10577 doc
: /* Discard the contents of the terminal input buffer.
10578 Also end any kbd macro being defined. */)
10581 if (!NILP (KVAR (current_kboard
, defining_kbd_macro
)))
10583 /* Discard the last command from the macro. */
10584 Fcancel_kbd_macro_events ();
10588 update_mode_lines
++;
10590 Vunread_command_events
= Qnil
;
10591 unread_command_char
= -1;
10593 discard_tty_input ();
10595 kbd_fetch_ptr
= kbd_store_ptr
;
10601 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10602 doc
: /* Stop Emacs and return to superior process. You can resume later.
10603 If `cannot-suspend' is non-nil, or if the system doesn't support job
10604 control, run a subshell instead.
10606 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10607 to be read as terminal input by Emacs's parent, after suspension.
10609 Before suspending, run the normal hook `suspend-hook'.
10610 After resumption run the normal hook `suspend-resume-hook'.
10612 Some operating systems cannot stop the Emacs process and resume it later.
10613 On such systems, Emacs starts a subshell instead of suspending. */)
10614 (Lisp_Object stuffstring
)
10616 ptrdiff_t count
= SPECPDL_INDEX ();
10617 int old_height
, old_width
;
10619 struct gcpro gcpro1
;
10622 if (tty_list
&& tty_list
->next
)
10623 error ("There are other tty frames open; close them before suspending Emacs");
10625 if (!NILP (stuffstring
))
10626 CHECK_STRING (stuffstring
);
10628 /* Run the functions in suspend-hook. */
10629 hook
= intern ("suspend-hook");
10630 Frun_hooks (1, &hook
);
10632 GCPRO1 (stuffstring
);
10633 get_tty_size (fileno (CURTTY ()->input
), &old_width
, &old_height
);
10634 reset_all_sys_modes ();
10635 /* sys_suspend can get an error if it tries to fork a subshell
10636 and the system resources aren't available for that. */
10637 record_unwind_protect ((Lisp_Object (*) (Lisp_Object
)) init_all_sys_modes
,
10639 stuff_buffered_input (stuffstring
);
10640 if (cannot_suspend
)
10644 unbind_to (count
, Qnil
);
10646 /* Check if terminal/window size has changed.
10647 Note that this is not useful when we are running directly
10648 with a window system; but suspend should be disabled in that case. */
10649 get_tty_size (fileno (CURTTY ()->input
), &width
, &height
);
10650 if (width
!= old_width
|| height
!= old_height
)
10651 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10653 /* Run suspend-resume-hook. */
10654 hook
= intern ("suspend-resume-hook");
10655 Frun_hooks (1, &hook
);
10661 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10662 Then in any case stuff anything Emacs has read ahead and not used. */
10665 stuff_buffered_input (Lisp_Object stuffstring
)
10667 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
10668 register unsigned char *p
;
10670 if (STRINGP (stuffstring
))
10672 register ptrdiff_t count
;
10674 p
= SDATA (stuffstring
);
10675 count
= SBYTES (stuffstring
);
10676 while (count
-- > 0)
10681 /* Anything we have read ahead, put back for the shell to read. */
10682 /* ?? What should this do when we have multiple keyboards??
10683 Should we ignore anything that was typed in at the "wrong" kboard?
10685 rms: we should stuff everything back into the kboard
10687 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10690 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10691 kbd_fetch_ptr
= kbd_buffer
;
10692 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10693 stuff_char (kbd_fetch_ptr
->code
);
10695 clear_event (kbd_fetch_ptr
);
10699 #endif /* SIGTSTP */
10703 set_waiting_for_input (EMACS_TIME
*time_to_clear
)
10705 input_available_clear_time
= time_to_clear
;
10707 /* Tell handle_interrupt to throw back to read_char, */
10708 waiting_for_input
= 1;
10710 /* If handle_interrupt was called before and buffered a C-g,
10711 make it run again now, to avoid timing error. */
10712 if (!NILP (Vquit_flag
))
10713 quit_throw_to_read_char (0);
10717 clear_waiting_for_input (void)
10719 /* Tell handle_interrupt not to throw back to read_char, */
10720 waiting_for_input
= 0;
10721 input_available_clear_time
= 0;
10724 /* The SIGINT handler.
10726 If we have a frame on the controlling tty, we assume that the
10727 SIGINT was generated by C-g, so we call handle_interrupt.
10728 Otherwise, tell QUIT to kill Emacs. */
10731 interrupt_signal (int signalnum
) /* If we don't have an argument, some */
10732 /* compilers complain in signal calls. */
10734 /* Must preserve main program's value of errno. */
10735 int old_errno
= errno
;
10736 struct terminal
*terminal
;
10738 SIGNAL_THREAD_CHECK (signalnum
);
10740 /* See if we have an active terminal on our controlling tty. */
10741 terminal
= get_named_tty ("/dev/tty");
10744 /* If there are no frames there, let's pretend that we are a
10745 well-behaving UN*X program and quit. We must not call Lisp
10746 in a signal handler, so tell QUIT to exit when it is
10748 Vquit_flag
= Qkill_emacs
;
10752 /* Otherwise, the SIGINT was probably generated by C-g. */
10754 /* Set internal_last_event_frame to the top frame of the
10755 controlling tty, if we have a frame there. We disable the
10756 interrupt key on secondary ttys, so the SIGINT must have come
10757 from the controlling tty. */
10758 internal_last_event_frame
= terminal
->display_info
.tty
->top_frame
;
10760 handle_interrupt ();
10766 /* If Emacs is stuck because `inhibit-quit' is true, then keep track
10767 of the number of times C-g has been requested. If C-g is pressed
10768 enough times, then quit anyway. See bug#6585. */
10769 static int force_quit_count
;
10771 /* This routine is called at interrupt level in response to C-g.
10773 It is called from the SIGINT handler or kbd_buffer_store_event.
10775 If `waiting_for_input' is non zero, then unless `echoing' is
10776 nonzero, immediately throw back to read_char.
10778 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10779 eval to throw, when it gets a chance. If quit-flag is already
10780 non-nil, it stops the job right away. */
10783 handle_interrupt (void)
10789 /* XXX This code needs to be revised for multi-tty support. */
10790 if (!NILP (Vquit_flag
) && get_named_tty ("/dev/tty"))
10792 /* If SIGINT isn't blocked, don't let us be interrupted by
10793 another SIGINT, it might be harmful due to non-reentrancy
10794 in I/O functions. */
10795 sigblock (sigmask (SIGINT
));
10798 reset_all_sys_modes ();
10800 #ifdef SIGTSTP /* Support possible in later USG versions */
10802 * On systems which can suspend the current process and return to the original
10803 * shell, this command causes the user to end up back at the shell.
10804 * The "Auto-save" and "Abort" questions are not asked until
10805 * the user elects to return to emacs, at which point he can save the current
10806 * job and either dump core or continue.
10810 /* Perhaps should really fork an inferior shell?
10811 But that would not provide any way to get back
10812 to the original shell, ever. */
10813 printf ("No support for stopping a process on this operating system;\n");
10814 printf ("you can continue or abort.\n");
10815 #endif /* not SIGTSTP */
10817 /* We must remain inside the screen area when the internal terminal
10818 is used. Note that [Enter] is not echoed by dos. */
10819 cursor_to (SELECTED_FRAME (), 0, 0);
10821 /* It doesn't work to autosave while GC is in progress;
10822 the code used for auto-saving doesn't cope with the mark bit. */
10823 if (!gc_in_progress
)
10825 printf ("Auto-save? (y or n) ");
10827 if (((c
= getchar ()) & ~040) == 'Y')
10829 Fdo_auto_save (Qt
, Qnil
);
10831 printf ("\r\nAuto-save done");
10832 #else /* not MSDOS */
10833 printf ("Auto-save done\n");
10834 #endif /* not MSDOS */
10836 while (c
!= '\n') c
= getchar ();
10840 /* During GC, it must be safe to reenable quitting again. */
10841 Vinhibit_quit
= Qnil
;
10844 #endif /* not MSDOS */
10845 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10846 printf ("but will instead do a real quit after garbage collection ends\r\n");
10851 printf ("\r\nAbort? (y or n) ");
10852 #else /* not MSDOS */
10853 printf ("Abort (and dump core)? (y or n) ");
10854 #endif /* not MSDOS */
10856 if (((c
= getchar ()) & ~040) == 'Y')
10858 while (c
!= '\n') c
= getchar ();
10860 printf ("\r\nContinuing...\r\n");
10861 #else /* not MSDOS */
10862 printf ("Continuing...\n");
10863 #endif /* not MSDOS */
10865 init_all_sys_modes ();
10870 /* If executing a function that wants to be interrupted out of
10871 and the user has not deferred quitting by binding `inhibit-quit'
10872 then quit right away. */
10873 if (immediate_quit
&& NILP (Vinhibit_quit
))
10875 struct gl_state_s saved
;
10876 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10878 immediate_quit
= 0;
10881 GCPRO4 (saved
.object
, saved
.global_code
,
10882 saved
.current_syntax_table
, saved
.old_prop
);
10883 Fsignal (Qquit
, Qnil
);
10884 /* FIXME: AFAIK, `quit' can never return, so this code is dead! */
10889 { /* Else request quit when it's safe. */
10890 if (NILP (Vquit_flag
))
10891 force_quit_count
= 0;
10892 if (++force_quit_count
== 3)
10894 immediate_quit
= 1;
10895 Vinhibit_quit
= Qnil
;
10901 /* TODO: The longjmp in this call throws the NS event loop integration off,
10902 and it seems to do fine without this. Probably some attention
10903 needs to be paid to the setting of waiting_for_input in
10904 wait_reading_process_output() under HAVE_NS because of the call
10905 to ns_select there (needed because otherwise events aren't picked up
10906 outside of polling since we don't get SIGIO like X and we don't have a
10907 separate event loop thread like W32. */
10909 if (waiting_for_input
&& !echoing
)
10910 quit_throw_to_read_char (1);
10914 /* Handle a C-g by making read_char return C-g. */
10917 quit_throw_to_read_char (int from_signal
)
10919 /* When not called from a signal handler it is safe to call
10921 if (!from_signal
&& EQ (Vquit_flag
, Qkill_emacs
))
10922 Fkill_emacs (Qnil
);
10925 /* Prevent another signal from doing this before we finish. */
10926 clear_waiting_for_input ();
10929 Vunread_command_events
= Qnil
;
10930 unread_command_char
= -1;
10932 #if 0 /* Currently, sit_for is called from read_char without turning
10933 off polling. And that can call set_waiting_for_input.
10934 It seems to be harmless. */
10935 #ifdef POLL_FOR_INPUT
10936 /* May be > 1 if in recursive minibuffer. */
10937 if (poll_suppress_count
== 0)
10941 if (FRAMEP (internal_last_event_frame
)
10942 && !EQ (internal_last_event_frame
, selected_frame
))
10943 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
10946 _longjmp (getcjmp
, 1);
10949 DEFUN ("set-input-interrupt-mode", Fset_input_interrupt_mode
,
10950 Sset_input_interrupt_mode
, 1, 1, 0,
10951 doc
: /* Set interrupt mode of reading keyboard input.
10952 If INTERRUPT is non-nil, Emacs will use input interrupts;
10953 otherwise Emacs uses CBREAK mode.
10955 See also `current-input-mode'. */)
10956 (Lisp_Object interrupt
)
10958 int new_interrupt_input
;
10960 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10961 #ifdef HAVE_X_WINDOWS
10962 if (x_display_list
!= NULL
)
10964 /* When using X, don't give the user a real choice,
10965 because we haven't implemented the mechanisms to support it. */
10966 new_interrupt_input
= 1;
10969 #endif /* HAVE_X_WINDOWS */
10970 new_interrupt_input
= !NILP (interrupt
);
10971 #else /* not SIGIO */
10972 new_interrupt_input
= 0;
10973 #endif /* not SIGIO */
10975 if (new_interrupt_input
!= interrupt_input
)
10977 #ifdef POLL_FOR_INPUT
10981 /* this causes startup screen to be restored and messes with the mouse */
10982 reset_all_sys_modes ();
10983 interrupt_input
= new_interrupt_input
;
10984 init_all_sys_modes ();
10986 interrupt_input
= new_interrupt_input
;
10989 #ifdef POLL_FOR_INPUT
10990 poll_suppress_count
= 1;
10997 DEFUN ("set-output-flow-control", Fset_output_flow_control
, Sset_output_flow_control
, 1, 2, 0,
10998 doc
: /* Enable or disable ^S/^Q flow control for output to TERMINAL.
10999 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
11000 C-q in key sequences.
11002 This setting only has an effect on tty terminals and only when
11003 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
11005 See also `current-input-mode'. */)
11006 (Lisp_Object flow
, Lisp_Object terminal
)
11008 struct terminal
*t
= get_terminal (terminal
, 1);
11009 struct tty_display_info
*tty
;
11010 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11012 tty
= t
->display_info
.tty
;
11014 if (tty
->flow_control
!= !NILP (flow
))
11017 /* this causes startup screen to be restored and messes with the mouse */
11018 reset_sys_modes (tty
);
11021 tty
->flow_control
= !NILP (flow
);
11024 init_sys_modes (tty
);
11030 DEFUN ("set-input-meta-mode", Fset_input_meta_mode
, Sset_input_meta_mode
, 1, 2, 0,
11031 doc
: /* Enable or disable 8-bit input on TERMINAL.
11032 If META is t, Emacs will accept 8-bit input, and interpret the 8th
11033 bit as the Meta modifier.
11035 If META is nil, Emacs will ignore the top bit, on the assumption it is
11038 Otherwise, Emacs will accept and pass through 8-bit input without
11039 specially interpreting the top bit.
11041 This setting only has an effect on tty terminal devices.
11043 Optional parameter TERMINAL specifies the tty terminal device to use.
11044 It may be a terminal object, a frame, or nil for the terminal used by
11045 the currently selected frame.
11047 See also `current-input-mode'. */)
11048 (Lisp_Object meta
, Lisp_Object terminal
)
11050 struct terminal
*t
= get_terminal (terminal
, 1);
11051 struct tty_display_info
*tty
;
11054 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11056 tty
= t
->display_info
.tty
;
11060 else if (EQ (meta
, Qt
))
11065 if (tty
->meta_key
!= new_meta
)
11068 /* this causes startup screen to be restored and messes with the mouse */
11069 reset_sys_modes (tty
);
11072 tty
->meta_key
= new_meta
;
11075 init_sys_modes (tty
);
11081 DEFUN ("set-quit-char", Fset_quit_char
, Sset_quit_char
, 1, 1, 0,
11082 doc
: /* Specify character used for quitting.
11083 QUIT must be an ASCII character.
11085 This function only has an effect on the controlling tty of the Emacs
11088 See also `current-input-mode'. */)
11091 struct terminal
*t
= get_named_tty ("/dev/tty");
11092 struct tty_display_info
*tty
;
11093 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11095 tty
= t
->display_info
.tty
;
11097 if (NILP (quit
) || !INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400)
11098 error ("QUIT must be an ASCII character");
11101 /* this causes startup screen to be restored and messes with the mouse */
11102 reset_sys_modes (tty
);
11105 /* Don't let this value be out of range. */
11106 quit_char
= XINT (quit
) & (tty
->meta_key
== 0 ? 0177 : 0377);
11109 init_sys_modes (tty
);
11115 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
11116 doc
: /* Set mode of reading keyboard input.
11117 First arg INTERRUPT non-nil means use input interrupts;
11118 nil means use CBREAK mode.
11119 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
11120 (no effect except in CBREAK mode).
11121 Third arg META t means accept 8-bit input (for a Meta key).
11122 META nil means ignore the top bit, on the assumption it is parity.
11123 Otherwise, accept 8-bit input and don't use the top bit for Meta.
11124 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
11125 See also `current-input-mode'. */)
11126 (Lisp_Object interrupt
, Lisp_Object flow
, Lisp_Object meta
, Lisp_Object quit
)
11128 Fset_input_interrupt_mode (interrupt
);
11129 Fset_output_flow_control (flow
, Qnil
);
11130 Fset_input_meta_mode (meta
, Qnil
);
11132 Fset_quit_char (quit
);
11136 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
11137 doc
: /* Return information about the way Emacs currently reads keyboard input.
11138 The value is a list of the form (INTERRUPT FLOW META QUIT), where
11139 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
11140 nil, Emacs is using CBREAK mode.
11141 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
11142 terminal; this does not apply if Emacs uses interrupt-driven input.
11143 META is t if accepting 8-bit input with 8th bit as Meta flag.
11144 META nil means ignoring the top bit, on the assumption it is parity.
11145 META is neither t nor nil if accepting 8-bit input and using
11146 all 8 bits as the character code.
11147 QUIT is the character Emacs currently uses to quit.
11148 The elements of this list correspond to the arguments of
11149 `set-input-mode'. */)
11152 Lisp_Object val
[4];
11153 struct frame
*sf
= XFRAME (selected_frame
);
11155 val
[0] = interrupt_input
? Qt
: Qnil
;
11156 if (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
11158 val
[1] = FRAME_TTY (sf
)->flow_control
? Qt
: Qnil
;
11159 val
[2] = (FRAME_TTY (sf
)->meta_key
== 2
11161 : (CURTTY ()->meta_key
== 1 ? Qt
: Qnil
));
11168 XSETFASTINT (val
[3], quit_char
);
11170 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
11173 DEFUN ("posn-at-x-y", Fposn_at_x_y
, Sposn_at_x_y
, 2, 4, 0,
11174 doc
: /* Return position information for pixel coordinates X and Y.
11175 By default, X and Y are relative to text area of the selected window.
11176 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
11177 If optional fourth arg WHOLE is non-nil, X is relative to the left
11178 edge of the window.
11180 The return value is similar to a mouse click position:
11181 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11182 IMAGE (DX . DY) (WIDTH . HEIGHT))
11183 The `posn-' functions access elements of such lists. */)
11184 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame_or_window
, Lisp_Object whole
)
11189 if (NILP (frame_or_window
))
11190 frame_or_window
= selected_window
;
11192 if (WINDOWP (frame_or_window
))
11196 CHECK_LIVE_WINDOW (frame_or_window
);
11198 w
= XWINDOW (frame_or_window
);
11199 XSETINT (x
, (XINT (x
)
11200 + WINDOW_LEFT_EDGE_X (w
)
11202 ? window_box_left_offset (w
, TEXT_AREA
)
11204 XSETINT (y
, WINDOW_TO_FRAME_PIXEL_Y (w
, XINT (y
)));
11205 frame_or_window
= w
->frame
;
11208 CHECK_LIVE_FRAME (frame_or_window
);
11210 return make_lispy_position (XFRAME (frame_or_window
), x
, y
, 0);
11213 DEFUN ("posn-at-point", Fposn_at_point
, Sposn_at_point
, 0, 2, 0,
11214 doc
: /* Return position information for buffer POS in WINDOW.
11215 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
11217 Return nil if position is not visible in window. Otherwise,
11218 the return value is similar to that returned by `event-start' for
11219 a mouse click at the upper left corner of the glyph corresponding
11220 to the given buffer position:
11221 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11222 IMAGE (DX . DY) (WIDTH . HEIGHT))
11223 The `posn-' functions access elements of such lists. */)
11224 (Lisp_Object pos
, Lisp_Object window
)
11229 window
= selected_window
;
11231 tem
= Fpos_visible_in_window_p (pos
, window
, Qt
);
11234 Lisp_Object x
= XCAR (tem
);
11235 Lisp_Object y
= XCAR (XCDR (tem
));
11237 /* Point invisible due to hscrolling? */
11240 tem
= Fposn_at_x_y (x
, y
, window
, Qnil
);
11248 * Set up a new kboard object with reasonable initial values.
11251 init_kboard (KBOARD
*kb
)
11253 KVAR (kb
, Voverriding_terminal_local_map
) = Qnil
;
11254 KVAR (kb
, Vlast_command
) = Qnil
;
11255 KVAR (kb
, Vreal_last_command
) = Qnil
;
11256 KVAR (kb
, Vkeyboard_translate_table
) = Qnil
;
11257 KVAR (kb
, Vlast_repeatable_command
) = Qnil
;
11258 KVAR (kb
, Vprefix_arg
) = Qnil
;
11259 KVAR (kb
, Vlast_prefix_arg
) = Qnil
;
11260 KVAR (kb
, kbd_queue
) = Qnil
;
11261 kb
->kbd_queue_has_data
= 0;
11262 kb
->immediate_echo
= 0;
11263 KVAR (kb
, echo_string
) = Qnil
;
11264 kb
->echo_after_prompt
= -1;
11265 kb
->kbd_macro_buffer
= 0;
11266 kb
->kbd_macro_bufsize
= 0;
11267 KVAR (kb
, defining_kbd_macro
) = Qnil
;
11268 KVAR (kb
, Vlast_kbd_macro
) = Qnil
;
11269 kb
->reference_count
= 0;
11270 KVAR (kb
, Vsystem_key_alist
) = Qnil
;
11271 KVAR (kb
, system_key_syms
) = Qnil
;
11272 KVAR (kb
, Vwindow_system
) = Qt
; /* Unset. */
11273 KVAR (kb
, Vinput_decode_map
) = Fmake_sparse_keymap (Qnil
);
11274 KVAR (kb
, Vlocal_function_key_map
) = Fmake_sparse_keymap (Qnil
);
11275 Fset_keymap_parent (KVAR (kb
, Vlocal_function_key_map
), Vfunction_key_map
);
11276 KVAR (kb
, Vdefault_minibuffer_frame
) = Qnil
;
11280 * Destroy the contents of a kboard object, but not the object itself.
11281 * We use this just before deleting it, or if we're going to initialize
11282 * it a second time.
11285 wipe_kboard (KBOARD
*kb
)
11287 xfree (kb
->kbd_macro_buffer
);
11290 /* Free KB and memory referenced from it. */
11293 delete_kboard (KBOARD
*kb
)
11297 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
11300 *kbp
= kb
->next_kboard
;
11302 /* Prevent a dangling reference to KB. */
11303 if (kb
== current_kboard
11304 && FRAMEP (selected_frame
)
11305 && FRAME_LIVE_P (XFRAME (selected_frame
)))
11307 current_kboard
= FRAME_KBOARD (XFRAME (selected_frame
));
11309 if (current_kboard
== kb
)
11318 init_keyboard (void)
11320 /* This is correct before outermost invocation of the editor loop */
11321 command_loop_level
= -1;
11322 immediate_quit
= 0;
11323 quit_char
= Ctl ('g');
11324 Vunread_command_events
= Qnil
;
11325 unread_command_char
= -1;
11326 timer_idleness_start_time
= invalid_emacs_time ();
11328 recent_keys_index
= 0;
11329 kbd_fetch_ptr
= kbd_buffer
;
11330 kbd_store_ptr
= kbd_buffer
;
11331 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11332 do_mouse_tracking
= Qnil
;
11335 interrupt_input_blocked
= 0;
11336 interrupt_input_pending
= 0;
11338 pending_signals
= 0;
11341 /* This means that command_loop_1 won't try to select anything the first
11343 internal_last_event_frame
= Qnil
;
11344 Vlast_event_frame
= internal_last_event_frame
;
11346 current_kboard
= initial_kboard
;
11347 /* Re-initialize the keyboard again. */
11348 wipe_kboard (current_kboard
);
11349 init_kboard (current_kboard
);
11350 /* A value of nil for Vwindow_system normally means a tty, but we also use
11351 it for the initial terminal since there is no window system there. */
11352 KVAR (current_kboard
, Vwindow_system
) = Qnil
;
11354 if (!noninteractive
)
11356 /* Before multi-tty support, these handlers used to be installed
11357 only if the current session was a tty session. Now an Emacs
11358 session may have multiple display types, so we always handle
11359 SIGINT. There is special code in interrupt_signal to exit
11360 Emacs on SIGINT when there are no termcap frames on the
11361 controlling terminal. */
11362 signal (SIGINT
, interrupt_signal
);
11364 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
11365 SIGQUIT and we can't tell which one it will give us. */
11366 signal (SIGQUIT
, interrupt_signal
);
11367 #endif /* not DOS_NT */
11369 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11371 if (!noninteractive
)
11372 signal (SIGIO
, input_available_signal
);
11375 /* Use interrupt input by default, if it works and noninterrupt input
11376 has deficiencies. */
11378 #ifdef INTERRUPT_INPUT
11379 interrupt_input
= 1;
11381 interrupt_input
= 0;
11387 if (keyboard_init_hook
)
11388 (*keyboard_init_hook
) ();
11390 #ifdef POLL_FOR_INPUT
11392 poll_suppress_count
= 1;
11397 /* This type's only use is in syms_of_keyboard, to initialize the
11398 event header symbols and put properties on them. */
11399 struct event_head
{
11405 static const struct event_head head_table
[] = {
11406 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
11407 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
11408 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
11409 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
11410 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
11411 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
11412 /* `select-window' should be handled just like `switch-frame'
11413 in read_key_sequence. */
11414 {&Qselect_window
, "select-window", &Qswitch_frame
}
11418 syms_of_keyboard (void)
11420 pending_funcalls
= Qnil
;
11421 staticpro (&pending_funcalls
);
11423 Vlispy_mouse_stem
= build_pure_c_string ("mouse");
11424 staticpro (&Vlispy_mouse_stem
);
11427 DEFSYM (QCimage
, ":image");
11428 DEFSYM (Qhelp_echo
, "help-echo");
11429 DEFSYM (QCrtl
, ":rtl");
11431 staticpro (&item_properties
);
11432 item_properties
= Qnil
;
11434 staticpro (&tool_bar_item_properties
);
11435 tool_bar_item_properties
= Qnil
;
11436 staticpro (&tool_bar_items_vector
);
11437 tool_bar_items_vector
= Qnil
;
11439 DEFSYM (Qtimer_event_handler
, "timer-event-handler");
11440 DEFSYM (Qdisabled_command_function
, "disabled-command-function");
11441 DEFSYM (Qself_insert_command
, "self-insert-command");
11442 DEFSYM (Qforward_char
, "forward-char");
11443 DEFSYM (Qbackward_char
, "backward-char");
11444 DEFSYM (Qdisabled
, "disabled");
11445 DEFSYM (Qundefined
, "undefined");
11446 DEFSYM (Qpre_command_hook
, "pre-command-hook");
11447 DEFSYM (Qpost_command_hook
, "post-command-hook");
11448 DEFSYM (Qdeferred_action_function
, "deferred-action-function");
11449 DEFSYM (Qdelayed_warnings_hook
, "delayed-warnings-hook");
11450 DEFSYM (Qfunction_key
, "function-key");
11451 DEFSYM (Qmouse_click
, "mouse-click");
11452 DEFSYM (Qdrag_n_drop
, "drag-n-drop");
11453 DEFSYM (Qsave_session
, "save-session");
11454 DEFSYM (Qconfig_changed_event
, "config-changed-event");
11455 DEFSYM (Qmenu_enable
, "menu-enable");
11457 #if defined (WINDOWSNT)
11458 DEFSYM (Qlanguage_change
, "language-change");
11462 DEFSYM (Qdbus_event
, "dbus-event");
11465 DEFSYM (QCenable
, ":enable");
11466 DEFSYM (QCvisible
, ":visible");
11467 DEFSYM (QChelp
, ":help");
11468 DEFSYM (QCfilter
, ":filter");
11469 DEFSYM (QCbutton
, ":button");
11470 DEFSYM (QCkeys
, ":keys");
11471 DEFSYM (QCkey_sequence
, ":key-sequence");
11472 DEFSYM (QCtoggle
, ":toggle");
11473 DEFSYM (QCradio
, ":radio");
11474 DEFSYM (QClabel
, ":label");
11475 DEFSYM (QCvert_only
, ":vert-only");
11477 DEFSYM (Qmode_line
, "mode-line");
11478 DEFSYM (Qvertical_line
, "vertical-line");
11479 DEFSYM (Qvertical_scroll_bar
, "vertical-scroll-bar");
11480 DEFSYM (Qmenu_bar
, "menu-bar");
11482 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11483 DEFSYM (Qmouse_fixup_help_message
, "mouse-fixup-help-message");
11486 DEFSYM (Qabove_handle
, "above-handle");
11487 DEFSYM (Qhandle
, "handle");
11488 DEFSYM (Qbelow_handle
, "below-handle");
11489 DEFSYM (Qup
, "up");
11490 DEFSYM (Qdown
, "down");
11491 DEFSYM (Qtop
, "top");
11492 DEFSYM (Qbottom
, "bottom");
11493 DEFSYM (Qend_scroll
, "end-scroll");
11494 DEFSYM (Qratio
, "ratio");
11496 DEFSYM (Qevent_kind
, "event-kind");
11497 DEFSYM (Qevent_symbol_elements
, "event-symbol-elements");
11498 DEFSYM (Qevent_symbol_element_mask
, "event-symbol-element-mask");
11499 DEFSYM (Qmodifier_cache
, "modifier-cache");
11501 DEFSYM (Qrecompute_lucid_menubar
, "recompute-lucid-menubar");
11502 DEFSYM (Qactivate_menubar_hook
, "activate-menubar-hook");
11504 DEFSYM (Qpolling_period
, "polling-period");
11506 DEFSYM (Qx_set_selection
, "x-set-selection");
11507 DEFSYM (QPRIMARY
, "PRIMARY");
11508 DEFSYM (Qhandle_switch_frame
, "handle-switch-frame");
11509 DEFSYM (Qhandle_select_window
, "handle-select-window");
11511 DEFSYM (Qinput_method_function
, "input-method-function");
11512 DEFSYM (Qinput_method_exit_on_first_char
, "input-method-exit-on-first-char");
11513 DEFSYM (Qinput_method_use_echo_area
, "input-method-use-echo-area");
11515 DEFSYM (Qhelp_form_show
, "help-form-show");
11517 Fset (Qinput_method_exit_on_first_char
, Qnil
);
11518 Fset (Qinput_method_use_echo_area
, Qnil
);
11520 last_point_position_buffer
= Qnil
;
11521 last_point_position_window
= Qnil
;
11525 int len
= sizeof (head_table
) / sizeof (head_table
[0]);
11527 for (i
= 0; i
< len
; i
++)
11529 const struct event_head
*p
= &head_table
[i
];
11530 *p
->var
= intern_c_string (p
->name
);
11531 staticpro (p
->var
);
11532 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
11533 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
11537 button_down_location
= Fmake_vector (make_number (5), Qnil
);
11538 staticpro (&button_down_location
);
11539 mouse_syms
= Fmake_vector (make_number (5), Qnil
);
11540 staticpro (&mouse_syms
);
11541 wheel_syms
= Fmake_vector (make_number (sizeof (lispy_wheel_names
)
11542 / sizeof (lispy_wheel_names
[0])),
11544 staticpro (&wheel_syms
);
11548 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
11550 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
11551 for (i
= 0; i
< len
; i
++)
11552 if (modifier_names
[i
])
11553 ASET (modifier_symbols
, i
, intern_c_string (modifier_names
[i
]));
11554 staticpro (&modifier_symbols
);
11557 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
11558 staticpro (&recent_keys
);
11560 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
11561 staticpro (&this_command_keys
);
11563 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
11564 staticpro (&raw_keybuf
);
11566 DEFSYM (Qextended_command_history
, "extended-command-history");
11567 Fset (Qextended_command_history
, Qnil
);
11569 accent_key_syms
= Qnil
;
11570 staticpro (&accent_key_syms
);
11572 func_key_syms
= Qnil
;
11573 staticpro (&func_key_syms
);
11575 drag_n_drop_syms
= Qnil
;
11576 staticpro (&drag_n_drop_syms
);
11578 unread_switch_frame
= Qnil
;
11579 staticpro (&unread_switch_frame
);
11581 internal_last_event_frame
= Qnil
;
11582 staticpro (&internal_last_event_frame
);
11584 read_key_sequence_cmd
= Qnil
;
11585 staticpro (&read_key_sequence_cmd
);
11586 read_key_sequence_remapped
= Qnil
;
11587 staticpro (&read_key_sequence_remapped
);
11589 menu_bar_one_keymap_changed_items
= Qnil
;
11590 staticpro (&menu_bar_one_keymap_changed_items
);
11592 menu_bar_items_vector
= Qnil
;
11593 staticpro (&menu_bar_items_vector
);
11595 help_form_saved_window_configs
= Qnil
;
11596 staticpro (&help_form_saved_window_configs
);
11598 defsubr (&Scurrent_idle_time
);
11599 defsubr (&Sevent_symbol_parse_modifiers
);
11600 defsubr (&Sevent_convert_list
);
11601 defsubr (&Sread_key_sequence
);
11602 defsubr (&Sread_key_sequence_vector
);
11603 defsubr (&Srecursive_edit
);
11604 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11605 defsubr (&Strack_mouse
);
11607 defsubr (&Sinput_pending_p
);
11608 defsubr (&Scommand_execute
);
11609 defsubr (&Srecent_keys
);
11610 defsubr (&Sthis_command_keys
);
11611 defsubr (&Sthis_command_keys_vector
);
11612 defsubr (&Sthis_single_command_keys
);
11613 defsubr (&Sthis_single_command_raw_keys
);
11614 defsubr (&Sreset_this_command_lengths
);
11615 defsubr (&Sclear_this_command_keys
);
11616 defsubr (&Ssuspend_emacs
);
11617 defsubr (&Sabort_recursive_edit
);
11618 defsubr (&Sexit_recursive_edit
);
11619 defsubr (&Srecursion_depth
);
11620 defsubr (&Stop_level
);
11621 defsubr (&Sdiscard_input
);
11622 defsubr (&Sopen_dribble_file
);
11623 defsubr (&Sset_input_interrupt_mode
);
11624 defsubr (&Sset_output_flow_control
);
11625 defsubr (&Sset_input_meta_mode
);
11626 defsubr (&Sset_quit_char
);
11627 defsubr (&Sset_input_mode
);
11628 defsubr (&Scurrent_input_mode
);
11629 defsubr (&Sposn_at_point
);
11630 defsubr (&Sposn_at_x_y
);
11632 DEFVAR_LISP ("last-command-event", last_command_event
,
11633 doc
: /* Last input event that was part of a command. */);
11635 DEFVAR_LISP ("last-nonmenu-event", last_nonmenu_event
,
11636 doc
: /* Last input event in a command, except for mouse menu events.
11637 Mouse menus give back keys that don't look like mouse events;
11638 this variable holds the actual mouse event that led to the menu,
11639 so that you can determine whether the command was run by mouse or not. */);
11641 DEFVAR_LISP ("last-input-event", last_input_event
,
11642 doc
: /* Last input event. */);
11644 DEFVAR_LISP ("unread-command-events", Vunread_command_events
,
11645 doc
: /* List of events to be read as the command input.
11646 These events are processed first, before actual keyboard input.
11647 Events read from this list are not normally added to `this-command-keys',
11648 as they will already have been added once as they were read for the first time.
11649 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
11650 Vunread_command_events
= Qnil
;
11652 DEFVAR_INT ("unread-command-char", unread_command_char
,
11653 doc
: /* If not -1, an object to be read as next command input event. */);
11655 DEFVAR_LISP ("unread-post-input-method-events", Vunread_post_input_method_events
,
11656 doc
: /* List of events to be processed as input by input methods.
11657 These events are processed before `unread-command-events'
11658 and actual keyboard input, but are not given to `input-method-function'. */);
11659 Vunread_post_input_method_events
= Qnil
;
11661 DEFVAR_LISP ("unread-input-method-events", Vunread_input_method_events
,
11662 doc
: /* List of events to be processed as input by input methods.
11663 These events are processed after `unread-command-events', but
11664 before actual keyboard input.
11665 If there's an active input method, the events are given to
11666 `input-method-function'. */);
11667 Vunread_input_method_events
= Qnil
;
11669 DEFVAR_LISP ("meta-prefix-char", meta_prefix_char
,
11670 doc
: /* Meta-prefix character code.
11671 Meta-foo as command input turns into this character followed by foo. */);
11672 XSETINT (meta_prefix_char
, 033);
11674 DEFVAR_KBOARD ("last-command", Vlast_command
,
11675 doc
: /* The last command executed.
11676 Normally a symbol with a function definition, but can be whatever was found
11677 in the keymap, or whatever the variable `this-command' was set to by that
11680 The value `mode-exit' is special; it means that the previous command
11681 read an event that told it to exit, and it did so and unread that event.
11682 In other words, the present command is the event that made the previous
11685 The value `kill-region' is special; it means that the previous command
11686 was a kill command.
11688 `last-command' has a separate binding for each terminal device.
11689 See Info node `(elisp)Multiple Terminals'. */);
11691 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
11692 doc
: /* Same as `last-command', but never altered by Lisp code.
11693 Taken from the previous value of `real-this-command'. */);
11695 DEFVAR_KBOARD ("last-repeatable-command", Vlast_repeatable_command
,
11696 doc
: /* Last command that may be repeated.
11697 The last command executed that was not bound to an input event.
11698 This is the command `repeat' will try to repeat.
11699 Taken from a previous value of `real-this-command'. */);
11701 DEFVAR_LISP ("this-command", Vthis_command
,
11702 doc
: /* The command now being executed.
11703 The command can set this variable; whatever is put here
11704 will be in `last-command' during the following command. */);
11705 Vthis_command
= Qnil
;
11707 DEFVAR_LISP ("real-this-command", Vreal_this_command
,
11708 doc
: /* This is like `this-command', except that commands should never modify it. */);
11709 Vreal_this_command
= Qnil
;
11711 DEFVAR_LISP ("this-command-keys-shift-translated",
11712 Vthis_command_keys_shift_translated
,
11713 doc
: /* Non-nil if the key sequence activating this command was shift-translated.
11714 Shift-translation occurs when there is no binding for the key sequence
11715 as entered, but a binding was found by changing an upper-case letter
11716 to lower-case, or a shifted function key to an unshifted one. */);
11717 Vthis_command_keys_shift_translated
= Qnil
;
11719 DEFVAR_LISP ("this-original-command", Vthis_original_command
,
11720 doc
: /* The command bound to the current key sequence before remapping.
11721 It equals `this-command' if the original command was not remapped through
11722 any of the active keymaps. Otherwise, the value of `this-command' is the
11723 result of looking up the original command in the active keymaps. */);
11724 Vthis_original_command
= Qnil
;
11726 DEFVAR_INT ("auto-save-interval", auto_save_interval
,
11727 doc
: /* Number of input events between auto-saves.
11728 Zero means disable autosaving due to number of characters typed. */);
11729 auto_save_interval
= 300;
11731 DEFVAR_LISP ("auto-save-timeout", Vauto_save_timeout
,
11732 doc
: /* Number of seconds idle time before auto-save.
11733 Zero or nil means disable auto-saving due to idleness.
11734 After auto-saving due to this many seconds of idle time,
11735 Emacs also does a garbage collection if that seems to be warranted. */);
11736 XSETFASTINT (Vauto_save_timeout
, 30);
11738 DEFVAR_LISP ("echo-keystrokes", Vecho_keystrokes
,
11739 doc
: /* Nonzero means echo unfinished commands after this many seconds of pause.
11740 The value may be integer or floating point.
11741 If the value is zero, don't echo at all. */);
11742 Vecho_keystrokes
= make_number (1);
11744 DEFVAR_INT ("polling-period", polling_period
,
11745 doc
: /* Interval between polling for input during Lisp execution.
11746 The reason for polling is to make C-g work to stop a running program.
11747 Polling is needed only when using X windows and SIGIO does not work.
11748 Polling is automatically disabled in all other cases. */);
11749 polling_period
= 2;
11751 DEFVAR_LISP ("double-click-time", Vdouble_click_time
,
11752 doc
: /* Maximum time between mouse clicks to make a double-click.
11753 Measured in milliseconds. The value nil means disable double-click
11754 recognition; t means double-clicks have no time limit and are detected
11755 by position only. */);
11756 Vdouble_click_time
= make_number (500);
11758 DEFVAR_INT ("double-click-fuzz", double_click_fuzz
,
11759 doc
: /* Maximum mouse movement between clicks to make a double-click.
11760 On window-system frames, value is the number of pixels the mouse may have
11761 moved horizontally or vertically between two clicks to make a double-click.
11762 On non window-system frames, value is interpreted in units of 1/8 characters
11765 This variable is also the threshold for motion of the mouse
11766 to count as a drag. */);
11767 double_click_fuzz
= 3;
11769 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", inhibit_local_menu_bar_menus
,
11770 doc
: /* Non-nil means inhibit local map menu bar menus. */);
11771 inhibit_local_menu_bar_menus
= 0;
11773 DEFVAR_INT ("num-input-keys", num_input_keys
,
11774 doc
: /* Number of complete key sequences read as input so far.
11775 This includes key sequences read from keyboard macros.
11776 The number is effectively the number of interactive command invocations. */);
11777 num_input_keys
= 0;
11779 DEFVAR_INT ("num-nonmacro-input-events", num_nonmacro_input_events
,
11780 doc
: /* Number of input events read from the keyboard so far.
11781 This does not include events generated by keyboard macros. */);
11782 num_nonmacro_input_events
= 0;
11784 DEFVAR_LISP ("last-event-frame", Vlast_event_frame
,
11785 doc
: /* The frame in which the most recently read event occurred.
11786 If the last event came from a keyboard macro, this is set to `macro'. */);
11787 Vlast_event_frame
= Qnil
;
11789 /* This variable is set up in sysdep.c. */
11790 DEFVAR_LISP ("tty-erase-char", Vtty_erase_char
,
11791 doc
: /* The ERASE character as set by the user with stty. */);
11793 DEFVAR_LISP ("help-char", Vhelp_char
,
11794 doc
: /* Character to recognize as meaning Help.
11795 When it is read, do `(eval help-form)', and display result if it's a string.
11796 If the value of `help-form' is nil, this char can be read normally. */);
11797 XSETINT (Vhelp_char
, Ctl ('H'));
11799 DEFVAR_LISP ("help-event-list", Vhelp_event_list
,
11800 doc
: /* List of input events to recognize as meaning Help.
11801 These work just like the value of `help-char' (see that). */);
11802 Vhelp_event_list
= Qnil
;
11804 DEFVAR_LISP ("help-form", Vhelp_form
,
11805 doc
: /* Form to execute when character `help-char' is read.
11806 If the form returns a string, that string is displayed.
11807 If `help-form' is nil, the help char is not recognized. */);
11810 DEFVAR_LISP ("prefix-help-command", Vprefix_help_command
,
11811 doc
: /* Command to run when `help-char' character follows a prefix key.
11812 This command is used only when there is no actual binding
11813 for that character after that prefix key. */);
11814 Vprefix_help_command
= Qnil
;
11816 DEFVAR_LISP ("top-level", Vtop_level
,
11817 doc
: /* Form to evaluate when Emacs starts up.
11818 Useful to set before you dump a modified Emacs. */);
11821 DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table
,
11822 doc
: /* Translate table for local keyboard input, or nil.
11823 If non-nil, the value should be a char-table. Each character read
11824 from the keyboard is looked up in this char-table. If the value found
11825 there is non-nil, then it is used instead of the actual input character.
11827 The value can also be a string or vector, but this is considered obsolete.
11828 If it is a string or vector of length N, character codes N and up are left
11829 untranslated. In a vector, an element which is nil means "no translation".
11831 This is applied to the characters supplied to input methods, not their
11832 output. See also `translation-table-for-input'.
11834 This variable has a separate binding for each terminal.
11835 See Info node `(elisp)Multiple Terminals'. */);
11837 DEFVAR_BOOL ("cannot-suspend", cannot_suspend
,
11838 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
11839 \(Even if the operating system has support for stopping a process.\) */);
11840 cannot_suspend
= 0;
11842 DEFVAR_BOOL ("menu-prompting", menu_prompting
,
11843 doc
: /* Non-nil means prompt with menus when appropriate.
11844 This is done when reading from a keymap that has a prompt string,
11845 for elements that have prompt strings.
11846 The menu is displayed on the screen
11847 if X menus were enabled at configuration
11848 time and the previous event was a mouse click prefix key.
11849 Otherwise, menu prompting uses the echo area. */);
11850 menu_prompting
= 1;
11852 DEFVAR_LISP ("menu-prompt-more-char", menu_prompt_more_char
,
11853 doc
: /* Character to see next line of menu prompt.
11854 Type this character while in a menu prompt to rotate around the lines of it. */);
11855 XSETINT (menu_prompt_more_char
, ' ');
11857 DEFVAR_INT ("extra-keyboard-modifiers", extra_keyboard_modifiers
,
11858 doc
: /* A mask of additional modifier keys to use with every keyboard character.
11859 Emacs applies the modifiers of the character stored here to each keyboard
11860 character it reads. For example, after evaluating the expression
11861 (setq extra-keyboard-modifiers ?\\C-x)
11862 all input characters will have the control modifier applied to them.
11864 Note that the character ?\\C-@, equivalent to the integer zero, does
11865 not count as a control character; rather, it counts as a character
11866 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
11867 cancels any modification. */);
11868 extra_keyboard_modifiers
= 0;
11870 DEFVAR_LISP ("deactivate-mark", Vdeactivate_mark
,
11871 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
11872 The command loop sets this to nil before each command,
11873 and tests the value when the command returns.
11874 Buffer modification stores t in this variable. */);
11875 Vdeactivate_mark
= Qnil
;
11876 DEFSYM (Qdeactivate_mark
, "deactivate-mark");
11878 DEFVAR_LISP ("pre-command-hook", Vpre_command_hook
,
11879 doc
: /* Normal hook run before each command is executed.
11880 If an unhandled error happens in running this hook,
11881 the function in which the error occurred is unconditionally removed, since
11882 otherwise the error might happen repeatedly and make Emacs nonfunctional. */);
11883 Vpre_command_hook
= Qnil
;
11885 DEFVAR_LISP ("post-command-hook", Vpost_command_hook
,
11886 doc
: /* Normal hook run after each command is executed.
11887 If an unhandled error happens in running this hook,
11888 the function in which the error occurred is unconditionally removed, since
11889 otherwise the error might happen repeatedly and make Emacs nonfunctional. */);
11890 Vpost_command_hook
= Qnil
;
11893 DEFVAR_LISP ("echo-area-clear-hook", ...,
11894 doc
: /* Normal hook run when clearing the echo area. */);
11896 DEFSYM (Qecho_area_clear_hook
, "echo-area-clear-hook");
11897 Fset (Qecho_area_clear_hook
, Qnil
);
11899 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", Vlucid_menu_bar_dirty_flag
,
11900 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
11901 Vlucid_menu_bar_dirty_flag
= Qnil
;
11903 DEFVAR_LISP ("menu-bar-final-items", Vmenu_bar_final_items
,
11904 doc
: /* List of menu bar items to move to the end of the menu bar.
11905 The elements of the list are event types that may have menu bar bindings. */);
11906 Vmenu_bar_final_items
= Qnil
;
11908 DEFVAR_LISP ("tool-bar-separator-image-expression", Vtool_bar_separator_image_expression
,
11909 doc
: /* Expression evaluating to the image spec for a tool-bar separator.
11910 This is used internally by graphical displays that do not render
11911 tool-bar separators natively. Otherwise it is unused (e.g. on GTK). */);
11912 Vtool_bar_separator_image_expression
= Qnil
;
11914 DEFVAR_KBOARD ("overriding-terminal-local-map",
11915 Voverriding_terminal_local_map
,
11916 doc
: /* Per-terminal keymap that overrides all other local keymaps.
11917 If this variable is non-nil, it is used as a keymap instead of the
11918 buffer's local map, and the minor mode keymaps and text property keymaps.
11919 It also replaces `overriding-local-map'.
11921 This variable is intended to let commands such as `universal-argument'
11922 set up a different keymap for reading the next command.
11924 `overriding-terminal-local-map' has a separate binding for each
11926 See Info node `(elisp)Multiple Terminals'. */);
11928 DEFVAR_LISP ("overriding-local-map", Voverriding_local_map
,
11929 doc
: /* Keymap that overrides all other local keymaps.
11930 If this variable is non-nil, it is used as a keymap--replacing the
11931 buffer's local map, the minor mode keymaps, and char property keymaps. */);
11932 Voverriding_local_map
= Qnil
;
11934 DEFVAR_LISP ("overriding-local-map-menu-flag", Voverriding_local_map_menu_flag
,
11935 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
11936 Otherwise, the menu bar continues to reflect the buffer's local map
11937 and the minor mode maps regardless of `overriding-local-map'. */);
11938 Voverriding_local_map_menu_flag
= Qnil
;
11940 DEFVAR_LISP ("special-event-map", Vspecial_event_map
,
11941 doc
: /* Keymap defining bindings for special events to execute at low level. */);
11942 Vspecial_event_map
= Fcons (intern_c_string ("keymap"), Qnil
);
11944 DEFVAR_LISP ("track-mouse", do_mouse_tracking
,
11945 doc
: /* Non-nil means generate motion events for mouse motion. */);
11947 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
11948 doc
: /* Alist of system-specific X windows key symbols.
11949 Each element should have the form (N . SYMBOL) where N is the
11950 numeric keysym code (sans the \"system-specific\" bit 1<<28)
11951 and SYMBOL is its name.
11953 `system-key-alist' has a separate binding for each terminal device.
11954 See Info node `(elisp)Multiple Terminals'. */);
11956 DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map
,
11957 doc
: /* Keymap that translates key sequences to key sequences during input.
11958 This is used mainly for mapping key sequences into some preferred
11959 key events (symbols).
11961 The `read-key-sequence' function replaces any subsequence bound by
11962 `local-function-key-map' with its binding. More precisely, when the
11963 active keymaps have no binding for the current key sequence but
11964 `local-function-key-map' binds a suffix of the sequence to a vector or
11965 string, `read-key-sequence' replaces the matching suffix with its
11966 binding, and continues with the new sequence.
11968 If the binding is a function, it is called with one argument (the prompt)
11969 and its return value (a key sequence) is used.
11971 The events that come from bindings in `local-function-key-map' are not
11972 themselves looked up in `local-function-key-map'.
11974 For example, suppose `local-function-key-map' binds `ESC O P' to [f1].
11975 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
11976 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix key,
11977 typing `ESC O P x' would return [f1 x].
11979 `local-function-key-map' has a separate binding for each terminal
11980 device. See Info node `(elisp)Multiple Terminals'. If you need to
11981 define a binding on all terminals, change `function-key-map'
11982 instead. Initially, `local-function-key-map' is an empty keymap that
11983 has `function-key-map' as its parent on all terminal devices. */);
11985 DEFVAR_KBOARD ("input-decode-map", Vinput_decode_map
,
11986 doc
: /* Keymap that decodes input escape sequences.
11987 This is used mainly for mapping ASCII function key sequences into
11988 real Emacs function key events (symbols).
11990 The `read-key-sequence' function replaces any subsequence bound by
11991 `input-decode-map' with its binding. Contrary to `function-key-map',
11992 this map applies its rebinding regardless of the presence of an ordinary
11993 binding. So it is more like `key-translation-map' except that it applies
11994 before `function-key-map' rather than after.
11996 If the binding is a function, it is called with one argument (the prompt)
11997 and its return value (a key sequence) is used.
11999 The events that come from bindings in `input-decode-map' are not
12000 themselves looked up in `input-decode-map'.
12002 This variable is keyboard-local. */);
12004 DEFVAR_LISP ("function-key-map", Vfunction_key_map
,
12005 doc
: /* The parent keymap of all `local-function-key-map' instances.
12006 Function key definitions that apply to all terminal devices should go
12007 here. If a mapping is defined in both the current
12008 `local-function-key-map' binding and this variable, then the local
12009 definition will take precedence. */);
12010 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
12012 DEFVAR_LISP ("key-translation-map", Vkey_translation_map
,
12013 doc
: /* Keymap of key translations that can override keymaps.
12014 This keymap works like `function-key-map', but comes after that,
12015 and its non-prefix bindings override ordinary bindings.
12016 Another difference is that it is global rather than keyboard-local. */);
12017 Vkey_translation_map
= Fmake_sparse_keymap (Qnil
);
12019 DEFVAR_LISP ("deferred-action-list", Vdeferred_action_list
,
12020 doc
: /* List of deferred actions to be performed at a later time.
12021 The precise format isn't relevant here; we just check whether it is nil. */);
12022 Vdeferred_action_list
= Qnil
;
12024 DEFVAR_LISP ("deferred-action-function", Vdeferred_action_function
,
12025 doc
: /* Function to call to handle deferred actions, after each command.
12026 This function is called with no arguments after each command
12027 whenever `deferred-action-list' is non-nil. */);
12028 Vdeferred_action_function
= Qnil
;
12030 DEFVAR_LISP ("delayed-warnings-list", Vdelayed_warnings_list
,
12031 doc
: /* List of warnings to be displayed after this command.
12032 Each element must be a list (TYPE MESSAGE [LEVEL [BUFFER-NAME]]),
12033 as per the args of `display-warning' (which see).
12034 If this variable is non-nil, `delayed-warnings-hook' will be run
12035 immediately after running `post-command-hook'. */);
12036 Vdelayed_warnings_list
= Qnil
;
12038 DEFVAR_LISP ("timer-list", Vtimer_list
,
12039 doc
: /* List of active absolute time timers in order of increasing time. */);
12040 Vtimer_list
= Qnil
;
12042 DEFVAR_LISP ("timer-idle-list", Vtimer_idle_list
,
12043 doc
: /* List of active idle-time timers in order of increasing time. */);
12044 Vtimer_idle_list
= Qnil
;
12046 DEFVAR_LISP ("input-method-function", Vinput_method_function
,
12047 doc
: /* If non-nil, the function that implements the current input method.
12048 It's called with one argument, a printing character that was just read.
12049 \(That means a character with code 040...0176.)
12050 Typically this function uses `read-event' to read additional events.
12051 When it does so, it should first bind `input-method-function' to nil
12052 so it will not be called recursively.
12054 The function should return a list of zero or more events
12055 to be used as input. If it wants to put back some events
12056 to be reconsidered, separately, by the input method,
12057 it can add them to the beginning of `unread-command-events'.
12059 The input method function can find in `input-method-previous-message'
12060 the previous echo area message.
12062 The input method function should refer to the variables
12063 `input-method-use-echo-area' and `input-method-exit-on-first-char'
12064 for guidance on what to do. */);
12065 Vinput_method_function
= Qnil
;
12067 DEFVAR_LISP ("input-method-previous-message",
12068 Vinput_method_previous_message
,
12069 doc
: /* When `input-method-function' is called, hold the previous echo area message.
12070 This variable exists because `read-event' clears the echo area
12071 before running the input method. It is nil if there was no message. */);
12072 Vinput_method_previous_message
= Qnil
;
12074 DEFVAR_LISP ("show-help-function", Vshow_help_function
,
12075 doc
: /* If non-nil, the function that implements the display of help.
12076 It's called with one argument, the help string to display. */);
12077 Vshow_help_function
= Qnil
;
12079 DEFVAR_LISP ("disable-point-adjustment", Vdisable_point_adjustment
,
12080 doc
: /* If non-nil, suppress point adjustment after executing a command.
12082 After a command is executed, if point is moved into a region that has
12083 special properties (e.g. composition, display), we adjust point to
12084 the boundary of the region. But, when a command sets this variable to
12085 non-nil, we suppress the point adjustment.
12087 This variable is set to nil before reading a command, and is checked
12088 just after executing the command. */);
12089 Vdisable_point_adjustment
= Qnil
;
12091 DEFVAR_LISP ("global-disable-point-adjustment",
12092 Vglobal_disable_point_adjustment
,
12093 doc
: /* If non-nil, always suppress point adjustment.
12095 The default value is nil, in which case, point adjustment are
12096 suppressed only after special commands that set
12097 `disable-point-adjustment' (which see) to non-nil. */);
12098 Vglobal_disable_point_adjustment
= Qnil
;
12100 DEFVAR_LISP ("minibuffer-message-timeout", Vminibuffer_message_timeout
,
12101 doc
: /* How long to display an echo-area message when the minibuffer is active.
12102 If the value is not a number, such messages don't time out. */);
12103 Vminibuffer_message_timeout
= make_number (2);
12105 DEFVAR_LISP ("throw-on-input", Vthrow_on_input
,
12106 doc
: /* If non-nil, any keyboard input throws to this symbol.
12107 The value of that variable is passed to `quit-flag' and later causes a
12108 peculiar kind of quitting. */);
12109 Vthrow_on_input
= Qnil
;
12111 DEFVAR_LISP ("command-error-function", Vcommand_error_function
,
12112 doc
: /* If non-nil, function to output error messages.
12113 The arguments are the error data, a list of the form
12114 (SIGNALED-CONDITIONS . SIGNAL-DATA)
12115 such as just as `condition-case' would bind its variable to,
12116 the context (a string which normally goes at the start of the message),
12117 and the Lisp function within which the error was signaled. */);
12118 Vcommand_error_function
= Qnil
;
12120 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
12121 Venable_disabled_menus_and_buttons
,
12122 doc
: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
12124 Help functions bind this to allow help on disabled menu items
12125 and tool-bar buttons. */);
12126 Venable_disabled_menus_and_buttons
= Qnil
;
12128 DEFVAR_LISP ("select-active-regions",
12129 Vselect_active_regions
,
12130 doc
: /* If non-nil, an active region automatically sets the primary selection.
12131 If the value is `only', only temporarily active regions (usually made
12132 by mouse-dragging or shift-selection) set the window selection.
12134 This takes effect only when Transient Mark mode is enabled. */);
12135 Vselect_active_regions
= Qt
;
12137 DEFVAR_LISP ("saved-region-selection",
12138 Vsaved_region_selection
,
12139 doc
: /* Contents of active region prior to buffer modification.
12140 If `select-active-regions' is non-nil, Emacs sets this to the
12141 text in the region before modifying the buffer. The next
12142 `deactivate-mark' call uses this to set the window selection. */);
12143 Vsaved_region_selection
= Qnil
;
12145 DEFVAR_LISP ("selection-inhibit-update-commands",
12146 Vselection_inhibit_update_commands
,
12147 doc
: /* List of commands which should not update the selection.
12148 Normally, if `select-active-regions' is non-nil and the mark remains
12149 active after a command (i.e. the mark was not deactivated), the Emacs
12150 command loop sets the selection to the text in the region. However,
12151 if the command is in this list, the selection is not updated. */);
12152 Vselection_inhibit_update_commands
12153 = list2 (Qhandle_switch_frame
, Qhandle_select_window
);
12155 DEFVAR_LISP ("debug-on-event",
12157 doc
: /* Enter debugger on this event. When Emacs
12158 receives the special event specified by this variable, it will try to
12159 break into the debugger as soon as possible instead of processing the
12160 event normally through `special-event-map'.
12162 Currently, the only supported values for this
12163 variable are `sigusr1' and `sigusr2'. */);
12164 Vdebug_on_event
= intern_c_string ("sigusr2");
12166 /* Create the initial keyboard. */
12167 initial_kboard
= xmalloc (sizeof *initial_kboard
);
12168 init_kboard (initial_kboard
);
12169 /* Vwindow_system is left at t for now. */
12170 initial_kboard
->next_kboard
= all_kboards
;
12171 all_kboards
= initial_kboard
;
12175 keys_of_keyboard (void)
12177 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
12178 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
12179 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
12180 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
12181 initial_define_key (meta_map
, 'x', "execute-extended-command");
12183 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
12184 "handle-delete-frame");
12185 initial_define_lispy_key (Vspecial_event_map
, "ns-put-working-text",
12186 "ns-put-working-text");
12187 initial_define_lispy_key (Vspecial_event_map
, "ns-unput-working-text",
12188 "ns-unput-working-text");
12189 /* Here we used to use `ignore-event' which would simple set prefix-arg to
12190 current-prefix-arg, as is done in `handle-switch-frame'.
12191 But `handle-switch-frame is not run from the special-map.
12192 Commands from that map are run in a special way that automatically
12193 preserves the prefix-arg. Restoring the prefix arg here is not just
12194 redundant but harmful:
12196 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
12197 - after the first prompt, the exit-minibuffer-hook is run which may
12198 iconify a frame and thus push a `iconify-frame' event.
12199 - after running exit-minibuffer-hook, current-prefix-arg is
12200 restored to the non-nil value it had before the prompt.
12201 - we enter the second prompt.
12202 current-prefix-arg is non-nil, prefix-arg is nil.
12203 - before running the first real event, we run the special iconify-frame
12204 event, but we pass the `special' arg to execute-command so
12205 current-prefix-arg and prefix-arg are left untouched.
12206 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
12207 - the next key event will have a spuriously non-nil current-prefix-arg. */
12208 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
12210 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
12212 /* Handling it at such a low-level causes read_key_sequence to get
12213 * confused because it doesn't realize that the current_buffer was
12214 * changed by read_char.
12216 * initial_define_lispy_key (Vspecial_event_map, "select-window",
12217 * "handle-select-window"); */
12218 initial_define_lispy_key (Vspecial_event_map
, "save-session",
12219 "handle-save-session");
12222 /* Define a special event which is raised for dbus callback
12224 initial_define_lispy_key (Vspecial_event_map
, "dbus-event",
12225 "dbus-handle-event");
12228 initial_define_lispy_key (Vspecial_event_map
, "config-changed-event",
12232 /* Mark the pointers in the kboard objects.
12233 Called by Fgarbage_collect. */
12235 mark_kboards (void)
12239 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
12241 if (kb
->kbd_macro_buffer
)
12242 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
12244 mark_object (KVAR (kb
, Voverriding_terminal_local_map
));
12245 mark_object (KVAR (kb
, Vlast_command
));
12246 mark_object (KVAR (kb
, Vreal_last_command
));
12247 mark_object (KVAR (kb
, Vkeyboard_translate_table
));
12248 mark_object (KVAR (kb
, Vlast_repeatable_command
));
12249 mark_object (KVAR (kb
, Vprefix_arg
));
12250 mark_object (KVAR (kb
, Vlast_prefix_arg
));
12251 mark_object (KVAR (kb
, kbd_queue
));
12252 mark_object (KVAR (kb
, defining_kbd_macro
));
12253 mark_object (KVAR (kb
, Vlast_kbd_macro
));
12254 mark_object (KVAR (kb
, Vsystem_key_alist
));
12255 mark_object (KVAR (kb
, system_key_syms
));
12256 mark_object (KVAR (kb
, Vwindow_system
));
12257 mark_object (KVAR (kb
, Vinput_decode_map
));
12258 mark_object (KVAR (kb
, Vlocal_function_key_map
));
12259 mark_object (KVAR (kb
, Vdefault_minibuffer_frame
));
12260 mark_object (KVAR (kb
, echo_string
));
12263 struct input_event
*event
;
12264 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
12266 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
12267 event
= kbd_buffer
;
12268 if (event
->kind
!= SELECTION_REQUEST_EVENT
12269 && event
->kind
!= SELECTION_CLEAR_EVENT
)
12271 mark_object (event
->x
);
12272 mark_object (event
->y
);
12274 mark_object (event
->frame_or_window
);
12275 mark_object (event
->arg
);