1 /* Keyboard and mouse input; editor command loop.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994, 1995,
3 1996, 1997, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
30 #include "termhooks.h"
38 #include "dispextern.h"
40 #include "intervals.h"
42 #include "blockinput.h"
49 #ifdef HAVE_GTK_AND_PTHREAD
57 #include <sys/ioctl.h>
59 #endif /* not MSDOS */
61 #include "syssignal.h"
63 #include <sys/types.h>
72 /* This is to get the definitions of the XK_ symbols. */
79 #endif /* HAVE_NTGUI */
89 /* Variables for blockinput.h: */
91 /* Non-zero if interrupt input is blocked right now. */
92 volatile int interrupt_input_blocked
;
94 /* Nonzero means an input interrupt has arrived
95 during the current critical section. */
96 int interrupt_input_pending
;
99 #ifdef HAVE_WINDOW_SYSTEM
100 /* Make all keyboard buffers much bigger when using X windows. */
102 /* But not too big (local data > 32K error) if on Mac OS Classic. */
103 #define KBD_BUFFER_SIZE 512
105 #define KBD_BUFFER_SIZE 4096
107 #else /* No X-windows, character input */
108 #define KBD_BUFFER_SIZE 4096
109 #endif /* No X-windows */
111 #define abs(x) ((x) >= 0 ? (x) : -(x))
113 /* Following definition copied from eval.c */
117 struct backtrace
*next
;
118 Lisp_Object
*function
;
119 Lisp_Object
*args
; /* Points to vector of args. */
120 int nargs
; /* length of vector. If nargs is UNEVALLED,
121 args points to slot holding list of
124 /* Nonzero means call value of debugger when done with this operation. */
129 KBOARD
*initial_kboard
;
130 KBOARD
*current_kboard
;
134 KBOARD the_only_kboard
;
137 /* Non-nil disable property on a command means
138 do not execute it; call disabled-command-function's value instead. */
139 Lisp_Object Qdisabled
, Qdisabled_command_function
;
141 #define NUM_RECENT_KEYS (300)
142 int recent_keys_index
; /* Index for storing next element into recent_keys */
143 int total_keys
; /* Total number of elements stored into recent_keys */
144 Lisp_Object recent_keys
; /* Vector holds the last NUM_RECENT_KEYS keystrokes */
146 /* Vector holding the key sequence that invoked the current command.
147 It is reused for each command, and it may be longer than the current
148 sequence; this_command_key_count indicates how many elements
149 actually mean something.
150 It's easier to staticpro a single Lisp_Object than an array. */
151 Lisp_Object this_command_keys
;
152 int this_command_key_count
;
154 /* 1 after calling Freset_this_command_lengths.
156 int this_command_key_count_reset
;
158 /* This vector is used as a buffer to record the events that were actually read
159 by read_key_sequence. */
160 Lisp_Object raw_keybuf
;
161 int raw_keybuf_count
;
163 #define GROW_RAW_KEYBUF \
164 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
166 int newsize = 2 * XVECTOR (raw_keybuf)->size; \
168 new = Fmake_vector (make_number (newsize), Qnil); \
169 bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
170 raw_keybuf_count * sizeof (Lisp_Object)); \
174 /* Number of elements of this_command_keys
175 that precede this key sequence. */
176 int this_single_command_key_start
;
178 /* Record values of this_command_key_count and echo_length ()
179 before this command was read. */
180 static int before_command_key_count
;
181 static int before_command_echo_length
;
183 extern int minbuf_level
;
185 extern int message_enable_multibyte
;
187 extern struct backtrace
*backtrace_list
;
189 /* If non-nil, the function that implements the display of help.
190 It's called with one argument, the help string to display. */
192 Lisp_Object Vshow_help_function
;
194 /* If a string, the message displayed before displaying a help-echo
197 Lisp_Object Vpre_help_message
;
199 /* Nonzero means do menu prompting. */
201 static int menu_prompting
;
203 /* Character to see next line of menu prompt. */
205 static Lisp_Object menu_prompt_more_char
;
207 /* For longjmp to where kbd input is being done. */
209 static jmp_buf getcjmp
;
211 /* True while doing kbd input. */
212 int waiting_for_input
;
214 /* True while displaying for echoing. Delays C-g throwing. */
218 /* Non-null means we can start echoing at the next input pause even
219 though there is something in the echo area. */
221 static struct kboard
*ok_to_echo_at_next_pause
;
223 /* The kboard last echoing, or null for none. Reset to 0 in
224 cancel_echoing. If non-null, and a current echo area message
225 exists, and echo_message_buffer is eq to the current message
226 buffer, we know that the message comes from echo_kboard. */
228 struct kboard
*echo_kboard
;
230 /* The buffer used for echoing. Set in echo_now, reset in
233 Lisp_Object echo_message_buffer
;
235 /* Nonzero means disregard local maps for the menu bar. */
236 static int inhibit_local_menu_bar_menus
;
238 /* Nonzero means C-g should cause immediate error-signal. */
241 /* The user's hook function for outputting an error message. */
242 Lisp_Object Vcommand_error_function
;
244 /* The user's ERASE setting. */
245 Lisp_Object Vtty_erase_char
;
247 /* Character to recognize as the help char. */
248 Lisp_Object Vhelp_char
;
250 /* List of other event types to recognize as meaning "help". */
251 Lisp_Object Vhelp_event_list
;
253 /* Form to execute when help char is typed. */
254 Lisp_Object Vhelp_form
;
256 /* Command to run when the help character follows a prefix key. */
257 Lisp_Object Vprefix_help_command
;
259 /* List of items that should move to the end of the menu bar. */
260 Lisp_Object Vmenu_bar_final_items
;
262 /* Non-nil means show the equivalent key-binding for
263 any M-x command that has one.
264 The value can be a length of time to show the message for.
265 If the value is non-nil and not a number, we wait 2 seconds. */
266 Lisp_Object Vsuggest_key_bindings
;
268 /* How long to display an echo-area message when the minibuffer is active.
269 If the value is not a number, such messages don't time out. */
270 Lisp_Object Vminibuffer_message_timeout
;
272 /* Character that causes a quit. Normally C-g.
274 If we are running on an ordinary terminal, this must be an ordinary
275 ASCII char, since we want to make it our interrupt character.
277 If we are not running on an ordinary terminal, it still needs to be
278 an ordinary ASCII char. This character needs to be recognized in
279 the input interrupt handler. At this point, the keystroke is
280 represented as a struct input_event, while the desired quit
281 character is specified as a lispy event. The mapping from struct
282 input_events to lispy events cannot run in an interrupt handler,
283 and the reverse mapping is difficult for anything but ASCII
286 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
290 extern Lisp_Object current_global_map
;
291 extern int minibuf_level
;
293 /* If non-nil, this is a map that overrides all other local maps. */
294 Lisp_Object Voverriding_local_map
;
296 /* If non-nil, Voverriding_local_map applies to the menu bar. */
297 Lisp_Object Voverriding_local_map_menu_flag
;
299 /* Keymap that defines special misc events that should
300 be processed immediately at a low level. */
301 Lisp_Object Vspecial_event_map
;
303 /* Current depth in recursive edits. */
304 int command_loop_level
;
306 /* Total number of times command_loop has read a key sequence. */
307 EMACS_INT num_input_keys
;
309 /* Last input character read as a command. */
310 Lisp_Object last_command_char
;
312 /* Last input character read as a command, not counting menus
313 reached by the mouse. */
314 Lisp_Object last_nonmenu_event
;
316 /* Last input character read for any purpose. */
317 Lisp_Object last_input_char
;
319 /* If not Qnil, a list of objects to be read as subsequent command input. */
320 Lisp_Object Vunread_command_events
;
322 /* If not Qnil, a list of objects to be read as subsequent command input
323 including input method processing. */
324 Lisp_Object Vunread_input_method_events
;
326 /* If not Qnil, a list of objects to be read as subsequent command input
327 but NOT including input method processing. */
328 Lisp_Object Vunread_post_input_method_events
;
330 /* If not -1, an event to be read as subsequent command input. */
331 EMACS_INT unread_command_char
;
333 /* If not Qnil, this is a switch-frame event which we decided to put
334 off until the end of a key sequence. This should be read as the
335 next command input, after any unread_command_events.
337 read_key_sequence uses this to delay switch-frame events until the
338 end of the key sequence; Fread_char uses it to put off switch-frame
339 events until a non-ASCII event is acceptable as input. */
340 Lisp_Object unread_switch_frame
;
342 /* A mask of extra modifier bits to put into every keyboard char. */
343 EMACS_INT extra_keyboard_modifiers
;
345 /* Char to use as prefix when a meta character is typed in.
346 This is bound on entry to minibuffer in case ESC is changed there. */
348 Lisp_Object meta_prefix_char
;
350 /* Last size recorded for a current buffer which is not a minibuffer. */
351 static int last_non_minibuf_size
;
353 /* Number of idle seconds before an auto-save and garbage collection. */
354 static Lisp_Object Vauto_save_timeout
;
356 /* Total number of times read_char has returned. */
357 int num_input_events
;
359 /* Total number of times read_char has returned, outside of macros. */
360 EMACS_INT num_nonmacro_input_events
;
362 /* Auto-save automatically when this many characters have been typed
363 since the last time. */
365 static EMACS_INT auto_save_interval
;
367 /* Value of num_nonmacro_input_events as of last auto save. */
371 /* The command being executed by the command loop.
372 Commands may set this, and the value set will be copied into
373 current_kboard->Vlast_command instead of the actual command. */
374 Lisp_Object Vthis_command
;
376 /* This is like Vthis_command, except that commands never set it. */
377 Lisp_Object real_this_command
;
379 /* If the lookup of the command returns a binding, the original
380 command is stored in this-original-command. It is nil otherwise. */
381 Lisp_Object Vthis_original_command
;
383 /* The value of point when the last command was started. */
384 int last_point_position
;
386 /* The buffer that was current when the last command was started. */
387 Lisp_Object last_point_position_buffer
;
389 /* The window that was selected when the last command was started. */
390 Lisp_Object last_point_position_window
;
392 /* The frame in which the last input event occurred, or Qmacro if the
393 last event came from a macro. We use this to determine when to
394 generate switch-frame events. This may be cleared by functions
395 like Fselect_frame, to make sure that a switch-frame event is
396 generated by the next character. */
397 Lisp_Object internal_last_event_frame
;
399 /* A user-visible version of the above, intended to allow users to
400 figure out where the last event came from, if the event doesn't
401 carry that information itself (i.e. if it was a character). */
402 Lisp_Object Vlast_event_frame
;
404 /* The timestamp of the last input event we received from the X server.
405 X Windows wants this for selection ownership. */
406 unsigned long last_event_timestamp
;
408 Lisp_Object Qself_insert_command
;
409 Lisp_Object Qforward_char
;
410 Lisp_Object Qbackward_char
;
411 Lisp_Object Qundefined
;
412 Lisp_Object Qtimer_event_handler
;
414 /* read_key_sequence stores here the command definition of the
415 key sequence that it reads. */
416 Lisp_Object read_key_sequence_cmd
;
418 /* Echo unfinished commands after this many seconds of pause. */
419 Lisp_Object Vecho_keystrokes
;
421 /* Form to evaluate (if non-nil) when Emacs is started. */
422 Lisp_Object Vtop_level
;
424 /* If non-nil, this implements the current input method. */
425 Lisp_Object Vinput_method_function
;
426 Lisp_Object Qinput_method_function
;
428 /* When we call Vinput_method_function,
429 this holds the echo area message that was just erased. */
430 Lisp_Object Vinput_method_previous_message
;
432 /* Non-nil means deactivate the mark at end of this command. */
433 Lisp_Object Vdeactivate_mark
;
435 /* Menu bar specified in Lucid Emacs fashion. */
437 Lisp_Object Vlucid_menu_bar_dirty_flag
;
438 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
440 Lisp_Object Qecho_area_clear_hook
;
442 /* Hooks to run before and after each command. */
443 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
444 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
445 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
447 /* Parent keymap of terminal-local function-key-map instances. */
448 Lisp_Object Vfunction_key_map
;
450 /* Parent keymap of terminal-local key-translation-map instances. */
451 Lisp_Object Vkey_translation_map
;
453 /* List of deferred actions to be performed at a later time.
454 The precise format isn't relevant here; we just check whether it is nil. */
455 Lisp_Object Vdeferred_action_list
;
457 /* Function to call to handle deferred actions, when there are any. */
458 Lisp_Object Vdeferred_action_function
;
459 Lisp_Object Qdeferred_action_function
;
461 Lisp_Object Qinput_method_exit_on_first_char
;
462 Lisp_Object Qinput_method_use_echo_area
;
464 /* File in which we write all commands we read. */
467 /* Nonzero if input is available. */
470 extern char *pending_malloc_warning
;
472 /* Circular buffer for pre-read keyboard input. */
474 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
476 /* Pointer to next available character in kbd_buffer.
477 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
478 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
479 next available char is in kbd_buffer[0]. */
480 static struct input_event
*kbd_fetch_ptr
;
482 /* Pointer to next place to store character in kbd_buffer. This
483 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
484 character should go in kbd_buffer[0]. */
485 static struct input_event
* volatile kbd_store_ptr
;
487 /* The above pair of variables forms a "queue empty" flag. When we
488 enqueue a non-hook event, we increment kbd_store_ptr. When we
489 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
490 there is input available if the two pointers are not equal.
492 Why not just have a flag set and cleared by the enqueuing and
493 dequeuing functions? Such a flag could be screwed up by interrupts
494 at inopportune times. */
496 /* If this flag is non-nil, we check mouse_moved to see when the
497 mouse moves, and motion events will appear in the input stream.
498 Otherwise, mouse motion is ignored. */
499 Lisp_Object do_mouse_tracking
;
501 /* Symbols to head events. */
502 Lisp_Object Qmouse_movement
;
503 Lisp_Object Qscroll_bar_movement
;
504 Lisp_Object Qswitch_frame
;
505 Lisp_Object Qdelete_frame
;
506 Lisp_Object Qiconify_frame
;
507 Lisp_Object Qmake_frame_visible
;
508 Lisp_Object Qselect_window
;
509 Lisp_Object Qhelp_echo
;
511 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
512 Lisp_Object Qmouse_fixup_help_message
;
515 /* Symbols to denote kinds of events. */
516 Lisp_Object Qfunction_key
;
517 Lisp_Object Qmouse_click
;
518 #if defined (WINDOWSNT) || defined (MAC_OS)
519 Lisp_Object Qlanguage_change
;
521 Lisp_Object Qdrag_n_drop
;
522 Lisp_Object Qsave_session
;
524 Lisp_Object Qmac_apple_event
;
527 /* Lisp_Object Qmouse_movement; - also an event header */
529 /* Properties of event headers. */
530 Lisp_Object Qevent_kind
;
531 Lisp_Object Qevent_symbol_elements
;
533 /* menu item parts */
534 Lisp_Object Qmenu_alias
;
535 Lisp_Object Qmenu_enable
;
536 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
537 Lisp_Object QCbutton
, QCtoggle
, QCradio
;
538 extern Lisp_Object Vdefine_key_rebound_commands
;
539 extern Lisp_Object Qmenu_item
;
541 /* An event header symbol HEAD may have a property named
542 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
543 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
544 mask of modifiers applied to it. If present, this is used to help
545 speed up parse_modifiers. */
546 Lisp_Object Qevent_symbol_element_mask
;
548 /* An unmodified event header BASE may have a property named
549 Qmodifier_cache, which is an alist mapping modifier masks onto
550 modified versions of BASE. If present, this helps speed up
552 Lisp_Object Qmodifier_cache
;
554 /* Symbols to use for parts of windows. */
555 Lisp_Object Qmode_line
;
556 Lisp_Object Qvertical_line
;
557 Lisp_Object Qvertical_scroll_bar
;
558 Lisp_Object Qmenu_bar
;
559 extern Lisp_Object Qleft_margin
, Qright_margin
;
560 extern Lisp_Object Qleft_fringe
, Qright_fringe
;
561 extern Lisp_Object QCmap
;
563 Lisp_Object
recursive_edit_unwind (), command_loop ();
564 Lisp_Object
Fthis_command_keys ();
565 Lisp_Object Qextended_command_history
;
566 EMACS_TIME
timer_check ();
568 extern Lisp_Object Vhistory_length
, Vtranslation_table_for_input
;
570 extern char *x_get_keysym_name ();
572 static void record_menu_key ();
573 static int echo_length ();
575 Lisp_Object Qpolling_period
;
577 /* List of absolute timers. Appears in order of next scheduled event. */
578 Lisp_Object Vtimer_list
;
580 /* List of idle time timers. Appears in order of next scheduled event. */
581 Lisp_Object Vtimer_idle_list
;
583 /* Incremented whenever a timer is run. */
586 extern Lisp_Object Vprint_level
, Vprint_length
;
588 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
590 EMACS_TIME
*input_available_clear_time
;
592 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
593 Default is 1 if INTERRUPT_INPUT is defined. */
596 /* Nonzero while interrupts are temporarily deferred during redisplay. */
597 int interrupts_deferred
;
599 /* Allow m- file to inhibit use of FIONREAD. */
600 #ifdef BROKEN_FIONREAD
604 /* We are unable to use interrupts if FIONREAD is not available,
605 so flush SIGIO so we won't try. */
606 #if !defined (FIONREAD)
612 /* If we support a window system, turn on the code to poll periodically
613 to detect C-g. It isn't actually used when doing interrupt input. */
614 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
615 #define POLL_FOR_INPUT
618 /* After a command is executed, if point is moved into a region that
619 has specific properties (e.g. composition, display), we adjust
620 point to the boundary of the region. But, if a command sets this
621 variable to non-nil, we suppress this point adjustment. This
622 variable is set to nil before reading a command. */
624 Lisp_Object Vdisable_point_adjustment
;
626 /* If non-nil, always disable point adjustment. */
628 Lisp_Object Vglobal_disable_point_adjustment
;
630 /* The time when Emacs started being idle. */
632 static EMACS_TIME timer_idleness_start_time
;
634 /* After Emacs stops being idle, this saves the last value
635 of timer_idleness_start_time from when it was idle. */
637 static EMACS_TIME timer_last_idleness_start_time
;
639 /* If non-nil, events produced by disabled menu items and tool-bar
640 buttons are not ignored. Help functions bind this to allow help on
641 those items and buttons. */
642 Lisp_Object Venable_disabled_menus_and_buttons
;
645 /* Global variable declarations. */
647 /* Flags for readable_events. */
648 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
649 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
650 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
652 /* Function for init_keyboard to call with no args (if nonzero). */
653 void (*keyboard_init_hook
) ();
655 static int read_avail_input
P_ ((int));
656 static void get_input_pending
P_ ((int *, int));
657 static int readable_events
P_ ((int));
658 static Lisp_Object read_char_x_menu_prompt
P_ ((int, Lisp_Object
*,
659 Lisp_Object
, int *));
660 static Lisp_Object
read_char_x_menu_prompt ();
661 static Lisp_Object read_char_minibuf_menu_prompt
P_ ((int, int,
663 static Lisp_Object make_lispy_event
P_ ((struct input_event
*));
664 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
665 static Lisp_Object make_lispy_movement
P_ ((struct frame
*, Lisp_Object
,
666 enum scroll_bar_part
,
667 Lisp_Object
, Lisp_Object
,
670 static Lisp_Object modify_event_symbol
P_ ((int, unsigned, Lisp_Object
,
671 Lisp_Object
, char **,
672 Lisp_Object
*, unsigned));
673 static Lisp_Object make_lispy_switch_frame
P_ ((Lisp_Object
));
674 static int parse_solitary_modifier
P_ ((Lisp_Object
));
675 static int parse_solitary_modifier ();
676 static void save_getcjmp
P_ ((jmp_buf));
677 static void save_getcjmp ();
678 static void restore_getcjmp
P_ ((jmp_buf));
679 static Lisp_Object apply_modifiers
P_ ((int, Lisp_Object
));
680 static void clear_event
P_ ((struct input_event
*));
682 static Lisp_Object restore_kboard_configuration
P_ ((Lisp_Object
));
684 static SIGTYPE interrupt_signal
P_ ((int signalnum
));
685 static void handle_interrupt
P_ ((void));
686 static void timer_start_idle
P_ ((void));
687 static void timer_stop_idle
P_ ((void));
688 static void timer_resume_idle
P_ ((void));
689 static SIGTYPE handle_user_signal
P_ ((int));
690 static char *find_user_signal_name
P_ ((int));
691 static int store_user_signal_events
P_ ((void));
693 /* Nonzero means don't try to suspend even if the operating system seems
695 static int cannot_suspend
;
697 extern Lisp_Object Qidentity
, Qonly
;
699 /* Install the string STR as the beginning of the string of echoing,
700 so that it serves as a prompt for the next character.
701 Also start echoing. */
707 current_kboard
->echo_string
= str
;
708 current_kboard
->echo_after_prompt
= SCHARS (str
);
712 /* Add C to the echo string, if echoing is going on.
713 C can be a character, which is printed prettily ("M-C-x" and all that
714 jazz), or a symbol, whose name is printed. */
720 if (current_kboard
->immediate_echo
)
722 int size
= KEY_DESCRIPTION_SIZE
+ 100;
723 char *buffer
= (char *) alloca (size
);
725 Lisp_Object echo_string
;
727 echo_string
= current_kboard
->echo_string
;
729 /* If someone has passed us a composite event, use its head symbol. */
734 ptr
= push_key_description (XINT (c
), ptr
, 1);
736 else if (SYMBOLP (c
))
738 Lisp_Object name
= SYMBOL_NAME (c
);
739 int nbytes
= SBYTES (name
);
741 if (size
- (ptr
- buffer
) < nbytes
)
743 int offset
= ptr
- buffer
;
744 size
= max (2 * size
, size
+ nbytes
);
745 buffer
= (char *) alloca (size
);
746 ptr
= buffer
+ offset
;
749 ptr
+= copy_text (SDATA (name
), ptr
, nbytes
,
750 STRING_MULTIBYTE (name
), 1);
753 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
756 const char *text
= " (Type ? for further options)";
757 int len
= strlen (text
);
759 if (size
- (ptr
- buffer
) < len
)
761 int offset
= ptr
- buffer
;
763 buffer
= (char *) alloca (size
);
764 ptr
= buffer
+ offset
;
767 bcopy (text
, ptr
, len
);
771 /* Replace a dash from echo_dash with a space, otherwise
772 add a space at the end as a separator between keys. */
773 if (STRINGP (echo_string
)
774 && SCHARS (echo_string
) > 1)
776 Lisp_Object last_char
, prev_char
, idx
;
778 idx
= make_number (SCHARS (echo_string
) - 2);
779 prev_char
= Faref (echo_string
, idx
);
781 idx
= make_number (SCHARS (echo_string
) - 1);
782 last_char
= Faref (echo_string
, idx
);
784 /* We test PREV_CHAR to make sure this isn't the echoing
786 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
787 Faset (echo_string
, idx
, make_number (' '));
789 echo_string
= concat2 (echo_string
, build_string (" "));
791 else if (STRINGP (echo_string
))
792 echo_string
= concat2 (echo_string
, build_string (" "));
794 current_kboard
->echo_string
795 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
801 /* Temporarily add a dash to the end of the echo string if it's not
802 empty, so that it serves as a mini-prompt for the very next character. */
807 /* Do nothing if not echoing at all. */
808 if (NILP (current_kboard
->echo_string
))
811 if (!current_kboard
->immediate_echo
812 && SCHARS (current_kboard
->echo_string
) == 0)
815 /* Do nothing if we just printed a prompt. */
816 if (current_kboard
->echo_after_prompt
817 == SCHARS (current_kboard
->echo_string
))
820 /* Do nothing if we have already put a dash at the end. */
821 if (SCHARS (current_kboard
->echo_string
) > 1)
823 Lisp_Object last_char
, prev_char
, idx
;
825 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 2);
826 prev_char
= Faref (current_kboard
->echo_string
, idx
);
828 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 1);
829 last_char
= Faref (current_kboard
->echo_string
, idx
);
831 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
835 /* Put a dash at the end of the buffer temporarily,
836 but make it go away when the next character is added. */
837 current_kboard
->echo_string
= concat2 (current_kboard
->echo_string
,
842 /* Display the current echo string, and begin echoing if not already
848 if (!current_kboard
->immediate_echo
)
851 current_kboard
->immediate_echo
= 1;
853 for (i
= 0; i
< this_command_key_count
; i
++)
857 /* Set before_command_echo_length to the value that would
858 have been saved before the start of this subcommand in
859 command_loop_1, if we had already been echoing then. */
860 if (i
== this_single_command_key_start
)
861 before_command_echo_length
= echo_length ();
863 c
= XVECTOR (this_command_keys
)->contents
[i
];
864 if (! (EVENT_HAS_PARAMETERS (c
)
865 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
869 /* Set before_command_echo_length to the value that would
870 have been saved before the start of this subcommand in
871 command_loop_1, if we had already been echoing then. */
872 if (this_command_key_count
== this_single_command_key_start
)
873 before_command_echo_length
= echo_length ();
875 /* Put a dash at the end to invite the user to type more. */
880 message3_nolog (current_kboard
->echo_string
,
881 SBYTES (current_kboard
->echo_string
),
882 STRING_MULTIBYTE (current_kboard
->echo_string
));
885 /* Record in what buffer we echoed, and from which kboard. */
886 echo_message_buffer
= echo_area_buffer
[0];
887 echo_kboard
= current_kboard
;
889 if (waiting_for_input
&& !NILP (Vquit_flag
))
890 quit_throw_to_read_char ();
893 /* Turn off echoing, for the start of a new command. */
898 current_kboard
->immediate_echo
= 0;
899 current_kboard
->echo_after_prompt
= -1;
900 current_kboard
->echo_string
= Qnil
;
901 ok_to_echo_at_next_pause
= NULL
;
903 echo_message_buffer
= Qnil
;
906 /* Return the length of the current echo string. */
911 return (STRINGP (current_kboard
->echo_string
)
912 ? SCHARS (current_kboard
->echo_string
)
916 /* Truncate the current echo message to its first LEN chars.
917 This and echo_char get used by read_key_sequence when the user
918 switches frames while entering a key sequence. */
921 echo_truncate (nchars
)
924 if (STRINGP (current_kboard
->echo_string
))
925 current_kboard
->echo_string
926 = Fsubstring (current_kboard
->echo_string
,
927 make_number (0), make_number (nchars
));
928 truncate_echo_area (nchars
);
932 /* Functions for manipulating this_command_keys. */
934 add_command_key (key
)
937 #if 0 /* Not needed after we made Freset_this_command_lengths
938 do the job immediately. */
939 /* If reset-this-command-length was called recently, obey it now.
940 See the doc string of that function for an explanation of why. */
941 if (before_command_restore_flag
)
943 this_command_key_count
= before_command_key_count_1
;
944 if (this_command_key_count
< this_single_command_key_start
)
945 this_single_command_key_start
= this_command_key_count
;
946 echo_truncate (before_command_echo_length_1
);
947 before_command_restore_flag
= 0;
951 if (this_command_key_count
>= ASIZE (this_command_keys
))
952 this_command_keys
= larger_vector (this_command_keys
,
953 2 * ASIZE (this_command_keys
),
956 AREF (this_command_keys
, this_command_key_count
) = key
;
957 ++this_command_key_count
;
964 int count
= SPECPDL_INDEX ();
967 if (command_loop_level
> 0)
969 specbind (Qstandard_output
, Qt
);
970 specbind (Qstandard_input
, Qt
);
973 #ifdef HAVE_X_WINDOWS
974 /* The command loop has started an hourglass timer, so we have to
975 cancel it here, otherwise it will fire because the recursive edit
976 can take some time. Do not check for display_hourglass_p here,
977 because it could already be nil. */
981 /* This function may have been called from a debugger called from
982 within redisplay, for instance by Edebugging a function called
983 from fontification-functions. We want to allow redisplay in
984 the debugging session.
986 The recursive edit is left with a `(throw exit ...)'. The `exit'
987 tag is not caught anywhere in redisplay, i.e. when we leave the
988 recursive edit, the original redisplay leading to the recursive
989 edit will be unwound. The outcome should therefore be safe. */
990 specbind (Qinhibit_redisplay
, Qnil
);
993 val
= command_loop ();
995 Fsignal (Qquit
, Qnil
);
996 /* Handle throw from read_minibuf when using minibuffer
997 while it's active but we're in another window. */
999 xsignal1 (Qerror
, val
);
1001 return unbind_to (count
, Qnil
);
1004 /* When an auto-save happens, record the "time", and don't do again soon. */
1009 last_auto_save
= num_nonmacro_input_events
;
1012 /* Make an auto save happen as soon as possible at command level. */
1015 force_auto_save_soon ()
1017 last_auto_save
= - auto_save_interval
- 1;
1019 record_asynch_buffer_change ();
1022 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
1023 doc
: /* Invoke the editor command loop recursively.
1024 To get out of the recursive edit, a command can do `(throw 'exit nil)';
1025 that tells this function to return.
1026 Alternatively, `(throw 'exit t)' makes this function signal an error.
1027 This function is called by the editor initialization to begin editing. */)
1030 int count
= SPECPDL_INDEX ();
1033 /* If we enter while input is blocked, don't lock up here.
1034 This may happen through the debugger during redisplay. */
1035 if (INPUT_BLOCKED_P
)
1038 command_loop_level
++;
1039 update_mode_lines
= 1;
1041 if (command_loop_level
1042 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
1043 buffer
= Fcurrent_buffer ();
1047 /* If we leave recursive_edit_1 below with a `throw' for instance,
1048 like it is done in the splash screen display, we have to
1049 make sure that we restore single_kboard as command_loop_1
1050 would have done if it were left normally. */
1051 if (command_loop_level
> 0)
1052 temporarily_switch_to_single_kboard (SELECTED_FRAME ());
1053 record_unwind_protect (recursive_edit_unwind
, buffer
);
1055 recursive_edit_1 ();
1056 return unbind_to (count
, Qnil
);
1060 recursive_edit_unwind (buffer
)
1063 if (BUFFERP (buffer
))
1064 Fset_buffer (buffer
);
1066 command_loop_level
--;
1067 update_mode_lines
= 1;
1072 #if 0 /* These two functions are now replaced with
1073 temporarily_switch_to_single_kboard. */
1078 #if 0 /* Theory: if there's anything in Vunread_command_events,
1079 it will right away be read by read_key_sequence,
1080 and then if we do switch KBOARDS, it will go into the side
1081 queue then. So we don't need to do anything special here -- rms. */
1082 if (CONSP (Vunread_command_events
))
1084 current_kboard
->kbd_queue
1085 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1086 current_kboard
->kbd_queue_has_data
= 1;
1088 Vunread_command_events
= Qnil
;
1094 /* Switch to the single-kboard state, making current_kboard
1095 the only KBOARD from which further input is accepted. */
1098 single_kboard_state ()
1106 /* If we're in single_kboard state for kboard KBOARD,
1110 not_single_kboard_state (kboard
)
1114 if (kboard
== current_kboard
)
1119 /* Maintain a stack of kboards, so other parts of Emacs
1120 can switch temporarily to the kboard of a given frame
1121 and then revert to the previous status. */
1126 struct kboard_stack
*next
;
1129 static struct kboard_stack
*kboard_stack
;
1136 struct kboard_stack
*p
1137 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1139 p
->next
= kboard_stack
;
1140 p
->kboard
= current_kboard
;
1152 struct kboard_stack
*p
= kboard_stack
;
1154 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
1156 if (t
->kboard
== p
->kboard
)
1158 current_kboard
= p
->kboard
;
1165 /* The terminal we remembered has been deleted. */
1166 current_kboard
= FRAME_KBOARD (SELECTED_FRAME ());
1169 kboard_stack
= p
->next
;
1174 /* Switch to single_kboard mode, making current_kboard the only KBOARD
1175 from which further input is accepted. If F is non-nil, set its
1176 KBOARD as the current keyboard.
1178 This function uses record_unwind_protect to return to the previous
1181 If Emacs is already in single_kboard mode, and F's keyboard is
1182 locked, then this function will throw an errow. */
1185 temporarily_switch_to_single_kboard (f
)
1189 int was_locked
= single_kboard
;
1192 if (f
!= NULL
&& FRAME_KBOARD (f
) != current_kboard
)
1193 /* We can not switch keyboards while in single_kboard mode.
1194 In rare cases, Lisp code may call `recursive-edit' (or
1195 `read-minibuffer' or `y-or-n-p') after it switched to a
1196 locked frame. For example, this is likely to happen
1197 when server.el connects to a new terminal while Emacs is in
1198 single_kboard mode. It is best to throw an error instead
1199 of presenting the user with a frozen screen. */
1200 error ("Terminal %d is locked, cannot read from it",
1201 FRAME_TERMINAL (f
)->id
);
1203 /* This call is unnecessary, but helps
1204 `restore_kboard_configuration' discover if somebody changed
1205 `current_kboard' behind our back. */
1206 push_kboard (current_kboard
);
1209 current_kboard
= FRAME_KBOARD (f
);
1211 record_unwind_protect (restore_kboard_configuration
,
1212 (was_locked
? Qt
: Qnil
));
1216 #if 0 /* This function is not needed anymore. */
1218 record_single_kboard_state ()
1221 push_kboard (current_kboard
);
1222 record_unwind_protect (restore_kboard_configuration
,
1223 (single_kboard
? Qt
: Qnil
));
1229 restore_kboard_configuration (was_locked
)
1230 Lisp_Object was_locked
;
1232 if (NILP (was_locked
))
1236 struct kboard
*prev
= current_kboard
;
1239 /* The pop should not change the kboard. */
1240 if (single_kboard
&& current_kboard
!= prev
)
1248 /* Handle errors that are not handled at inner levels
1249 by printing an error message and returning to the editor command loop. */
1255 Lisp_Object old_level
, old_length
;
1256 char macroerror
[50];
1258 #ifdef HAVE_X_WINDOWS
1259 if (display_hourglass_p
)
1260 cancel_hourglass ();
1263 if (!NILP (executing_kbd_macro
))
1265 if (executing_kbd_macro_iterations
== 1)
1266 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1268 sprintf (macroerror
, "After %d kbd macro iterations: ",
1269 executing_kbd_macro_iterations
);
1274 Vstandard_output
= Qt
;
1275 Vstandard_input
= Qt
;
1276 Vexecuting_kbd_macro
= Qnil
;
1277 executing_kbd_macro
= Qnil
;
1278 current_kboard
->Vprefix_arg
= Qnil
;
1279 current_kboard
->Vlast_prefix_arg
= Qnil
;
1282 /* Avoid unquittable loop if data contains a circular list. */
1283 old_level
= Vprint_level
;
1284 old_length
= Vprint_length
;
1285 XSETFASTINT (Vprint_level
, 10);
1286 XSETFASTINT (Vprint_length
, 10);
1287 cmd_error_internal (data
, macroerror
);
1288 Vprint_level
= old_level
;
1289 Vprint_length
= old_length
;
1293 Vinhibit_quit
= Qnil
;
1294 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1296 if (command_loop_level
== 0 && minibuf_level
== 0)
1297 any_kboard_state ();
1301 return make_number (0);
1304 /* Take actions on handling an error. DATA is the data that describes
1307 CONTEXT is a C-string containing ASCII characters only which
1308 describes the context in which the error happened. If we need to
1309 generalize CONTEXT to allow multibyte characters, make it a Lisp
1313 cmd_error_internal (data
, context
)
1317 struct frame
*sf
= SELECTED_FRAME ();
1319 /* The immediate context is not interesting for Quits,
1320 since they are asyncronous. */
1321 if (EQ (XCAR (data
), Qquit
))
1322 Vsignaling_function
= Qnil
;
1327 /* Use user's specified output function if any. */
1328 if (!NILP (Vcommand_error_function
))
1329 call3 (Vcommand_error_function
, data
,
1330 context
? build_string (context
) : empty_unibyte_string
,
1331 Vsignaling_function
);
1332 /* If the window system or terminal frame hasn't been initialized
1333 yet, or we're not interactive, write the message to stderr and exit. */
1334 else if (!sf
->glyphs_initialized_p
1335 || FRAME_INITIAL_P (sf
)
1338 print_error_message (data
, Qexternal_debugging_output
,
1339 context
, Vsignaling_function
);
1340 Fterpri (Qexternal_debugging_output
);
1341 Fkill_emacs (make_number (-1));
1345 clear_message (1, 0);
1347 message_log_maybe_newline ();
1350 print_error_message (data
, Qt
, context
, Vsignaling_function
);
1353 Vsignaling_function
= Qnil
;
1356 Lisp_Object
command_loop_1 ();
1357 Lisp_Object
command_loop_2 ();
1358 Lisp_Object
top_level_1 ();
1360 /* Entry to editor-command-loop.
1361 This level has the catches for exiting/returning to editor command loop.
1362 It returns nil to exit recursive edit, t to abort it. */
1367 if (command_loop_level
> 0 || minibuf_level
> 0)
1370 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1371 executing_kbd_macro
= Qnil
;
1377 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1378 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1379 /* Reset single_kboard in case top-level set it while
1380 evaluating an -f option, or we are stuck there for some
1382 any_kboard_state ();
1384 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1385 executing_kbd_macro
= Qnil
;
1387 /* End of file in -batch run causes exit here. */
1393 /* Here we catch errors in execution of commands within the
1394 editing loop, and reenter the editing loop.
1395 When there is an error, cmd_error runs and returns a non-nil
1396 value to us. A value of nil means that command_loop_1 itself
1397 returned due to end of file (or end of kbd macro). */
1402 register Lisp_Object val
;
1405 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1406 while (!NILP (val
));
1414 return Feval (Vtop_level
);
1420 /* On entry to the outer level, run the startup file */
1421 if (!NILP (Vtop_level
))
1422 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1423 else if (!NILP (Vpurify_flag
))
1424 message ("Bare impure Emacs (standard Lisp code not loaded)");
1426 message ("Bare Emacs (standard Lisp code not loaded)");
1430 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1431 doc
: /* Exit all recursive editing levels. */)
1434 #ifdef HAVE_X_WINDOWS
1435 if (display_hourglass_p
)
1436 cancel_hourglass ();
1439 /* Unblock input if we enter with input blocked. This may happen if
1440 redisplay traps e.g. during tool-bar update with input blocked. */
1441 while (INPUT_BLOCKED_P
)
1444 return Fthrow (Qtop_level
, Qnil
);
1447 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1448 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1451 if (command_loop_level
> 0 || minibuf_level
> 0)
1452 Fthrow (Qexit
, Qnil
);
1454 error ("No recursive edit is in progress");
1458 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1459 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1462 if (command_loop_level
> 0 || minibuf_level
> 0)
1465 error ("No recursive edit is in progress");
1469 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1471 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1472 of this function. */
1475 tracking_off (old_value
)
1476 Lisp_Object old_value
;
1478 do_mouse_tracking
= old_value
;
1479 if (NILP (old_value
))
1481 /* Redisplay may have been preempted because there was input
1482 available, and it assumes it will be called again after the
1483 input has been processed. If the only input available was
1484 the sort that we have just disabled, then we need to call
1486 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW
))
1488 redisplay_preserve_echo_area (6);
1489 get_input_pending (&input_pending
,
1490 READABLE_EVENTS_DO_TIMERS_NOW
);
1496 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
1497 doc
: /* Evaluate BODY with mouse movement events enabled.
1498 Within a `track-mouse' form, mouse motion generates input events that
1499 you can read with `read-event'.
1500 Normally, mouse motion is ignored.
1501 usage: (track-mouse BODY...) */)
1505 int count
= SPECPDL_INDEX ();
1508 record_unwind_protect (tracking_off
, do_mouse_tracking
);
1510 do_mouse_tracking
= Qt
;
1512 val
= Fprogn (args
);
1513 return unbind_to (count
, val
);
1516 /* If mouse has moved on some frame, return one of those frames.
1520 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1521 after resizing the tool-bar window. */
1523 int ignore_mouse_drag_p
;
1528 Lisp_Object tail
, frame
;
1530 if (ignore_mouse_drag_p
)
1532 /* ignore_mouse_drag_p = 0; */
1536 FOR_EACH_FRAME (tail
, frame
)
1538 if (XFRAME (frame
)->mouse_moved
)
1539 return XFRAME (frame
);
1545 #endif /* HAVE_MOUSE || HAVE_GPM */
1547 /* This is the actual command reading loop,
1548 sans error-handling encapsulation. */
1550 static int read_key_sequence
P_ ((Lisp_Object
*, int, Lisp_Object
,
1552 void safe_run_hooks
P_ ((Lisp_Object
));
1553 static void adjust_point_for_property
P_ ((int, int));
1555 /* Cancel hourglass from protect_unwind.
1557 #ifdef HAVE_X_WINDOWS
1559 cancel_hourglass_unwind (arg
)
1562 cancel_hourglass ();
1573 Lisp_Object keybuf
[30];
1576 int prev_modiff
= 0;
1577 struct buffer
*prev_buffer
= NULL
;
1578 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1580 int was_locked
= single_kboard
;
1583 int already_adjusted
= 0;
1585 current_kboard
->Vprefix_arg
= Qnil
;
1586 current_kboard
->Vlast_prefix_arg
= Qnil
;
1587 Vdeactivate_mark
= Qnil
;
1588 waiting_for_input
= 0;
1592 this_command_key_count
= 0;
1593 this_command_key_count_reset
= 0;
1594 this_single_command_key_start
= 0;
1596 if (NILP (Vmemory_full
))
1598 /* Make sure this hook runs after commands that get errors and
1599 throw to top level. */
1600 /* Note that the value cell will never directly contain nil
1601 if the symbol is a local variable. */
1602 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1603 safe_run_hooks (Qpost_command_hook
);
1605 /* If displaying a message, resize the echo area window to fit
1606 that message's size exactly. */
1607 if (!NILP (echo_area_buffer
[0]))
1608 resize_echo_area_exactly ();
1610 if (!NILP (Vdeferred_action_list
))
1611 safe_run_hooks (Qdeferred_action_function
);
1614 /* Do this after running Vpost_command_hook, for consistency. */
1615 current_kboard
->Vlast_command
= Vthis_command
;
1616 current_kboard
->Vreal_last_command
= real_this_command
;
1620 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1623 /* Make sure the current window's buffer is selected. */
1624 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1625 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1627 /* Display any malloc warning that just came out. Use while because
1628 displaying one warning can cause another. */
1630 while (pending_malloc_warning
)
1631 display_malloc_warning ();
1635 Vdeactivate_mark
= Qnil
;
1637 /* If minibuffer on and echo area in use,
1638 wait a short time and redraw minibuffer. */
1641 && !NILP (echo_area_buffer
[0])
1642 && EQ (minibuf_window
, echo_area_window
))
1644 /* Bind inhibit-quit to t so that C-g gets read in
1645 rather than quitting back to the minibuffer. */
1646 int count
= SPECPDL_INDEX ();
1647 specbind (Qinhibit_quit
, Qt
);
1649 if (NUMBERP (Vminibuffer_message_timeout
))
1650 sit_for (Vminibuffer_message_timeout
, 0, 2);
1654 /* Clear the echo area. */
1656 safe_run_hooks (Qecho_area_clear_hook
);
1658 unbind_to (count
, Qnil
);
1660 /* If a C-g came in before, treat it as input now. */
1661 if (!NILP (Vquit_flag
))
1664 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1669 alloca (0); /* Cause a garbage collection now */
1670 /* Since we can free the most stuff here. */
1671 #endif /* C_ALLOCA */
1674 /* Select the frame that the last event came from. Usually,
1675 switch-frame events will take care of this, but if some lisp
1676 code swallows a switch-frame event, we'll fix things up here.
1677 Is this a good idea? */
1678 if (FRAMEP (internal_last_event_frame
)
1679 && !EQ (internal_last_event_frame
, selected_frame
))
1680 Fselect_frame (internal_last_event_frame
);
1682 /* If it has changed current-menubar from previous value,
1683 really recompute the menubar from the value. */
1684 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1685 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1686 call0 (Qrecompute_lucid_menubar
);
1688 before_command_key_count
= this_command_key_count
;
1689 before_command_echo_length
= echo_length ();
1691 Vthis_command
= Qnil
;
1692 real_this_command
= Qnil
;
1693 Vthis_original_command
= Qnil
;
1695 /* Read next key sequence; i gets its length. */
1696 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1699 /* A filter may have run while we were reading the input. */
1700 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1702 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1703 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1707 /* Now we have read a key sequence of length I,
1708 or else I is 0 and we found end of file. */
1710 if (i
== 0) /* End of file -- happens only in */
1711 return Qnil
; /* a kbd macro, at the end. */
1712 /* -1 means read_key_sequence got a menu that was rejected.
1713 Just loop around and read another command. */
1717 this_command_key_count
= 0;
1718 this_command_key_count_reset
= 0;
1719 this_single_command_key_start
= 0;
1723 last_command_char
= keybuf
[i
- 1];
1725 /* If the previous command tried to force a specific window-start,
1726 forget about that, in case this command moves point far away
1727 from that position. But also throw away beg_unchanged and
1728 end_unchanged information in that case, so that redisplay will
1729 update the whole window properly. */
1730 if (!NILP (XWINDOW (selected_window
)->force_start
))
1733 XWINDOW (selected_window
)->force_start
= Qnil
;
1734 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1735 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1738 cmd
= read_key_sequence_cmd
;
1739 if (!NILP (Vexecuting_kbd_macro
))
1741 if (!NILP (Vquit_flag
))
1743 Vexecuting_kbd_macro
= Qt
;
1744 QUIT
; /* Make some noise. */
1745 /* Will return since macro now empty. */
1749 /* Do redisplay processing after this command except in special
1750 cases identified below. */
1751 prev_buffer
= current_buffer
;
1752 prev_modiff
= MODIFF
;
1753 last_point_position
= PT
;
1754 last_point_position_window
= selected_window
;
1755 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1757 /* By default, we adjust point to a boundary of a region that
1758 has such a property that should be treated intangible
1759 (e.g. composition, display). But, some commands will set
1760 this variable differently. */
1761 Vdisable_point_adjustment
= Qnil
;
1763 /* Process filters and timers may have messed with deactivate-mark.
1764 reset it before we execute the command. */
1765 Vdeactivate_mark
= Qnil
;
1767 /* Remap command through active keymaps */
1768 Vthis_original_command
= cmd
;
1772 if (cmd1
= Fcommand_remapping (cmd
, Qnil
, Qnil
), !NILP (cmd1
))
1776 /* Execute the command. */
1778 Vthis_command
= cmd
;
1779 real_this_command
= cmd
;
1780 /* Note that the value cell will never directly contain nil
1781 if the symbol is a local variable. */
1782 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1783 safe_run_hooks (Qpre_command_hook
);
1785 already_adjusted
= 0;
1787 if (NILP (Vthis_command
))
1789 /* nil means key is undefined. */
1790 Lisp_Object keys
= Fvector (i
, keybuf
);
1791 keys
= Fkey_description (keys
, Qnil
);
1793 message_with_string ("%s is undefined", keys
, 0);
1794 current_kboard
->defining_kbd_macro
= Qnil
;
1795 update_mode_lines
= 1;
1796 current_kboard
->Vprefix_arg
= Qnil
;
1800 if (NILP (current_kboard
->Vprefix_arg
) && ! no_direct
)
1802 /* In case we jump to directly_done. */
1803 Vcurrent_prefix_arg
= current_kboard
->Vprefix_arg
;
1805 /* Recognize some common commands in common situations and
1806 do them directly. */
1807 if (EQ (Vthis_command
, Qforward_char
) && PT
< ZV
)
1809 struct Lisp_Char_Table
*dp
1810 = window_display_table (XWINDOW (selected_window
));
1811 lose
= FETCH_CHAR (PT_BYTE
);
1813 if (! NILP (Vpost_command_hook
))
1814 /* Put this before calling adjust_point_for_property
1815 so it will only get called once in any case. */
1817 if (current_buffer
== prev_buffer
1818 && last_point_position
!= PT
1819 && NILP (Vdisable_point_adjustment
)
1820 && NILP (Vglobal_disable_point_adjustment
))
1821 adjust_point_for_property (last_point_position
, 0);
1822 already_adjusted
= 1;
1823 if (PT
== last_point_position
+ 1
1825 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1826 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1827 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1828 && (lose
>= 0x20 && lose
< 0x7f)))
1829 : (lose
>= 0x20 && lose
< 0x7f))
1830 /* To extract the case of continuation on
1831 wide-column characters. */
1832 && (WIDTH_BY_CHAR_HEAD (FETCH_BYTE (PT_BYTE
)) == 1)
1833 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1835 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1837 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1839 && !windows_or_buffers_changed
1840 && EQ (current_buffer
->selective_display
, Qnil
)
1841 && !detect_input_pending ()
1842 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1843 && NILP (Vexecuting_kbd_macro
))
1844 direct_output_forward_char (1);
1847 else if (EQ (Vthis_command
, Qbackward_char
) && PT
> BEGV
)
1849 struct Lisp_Char_Table
*dp
1850 = window_display_table (XWINDOW (selected_window
));
1852 lose
= FETCH_CHAR (PT_BYTE
);
1853 if (! NILP (Vpost_command_hook
))
1855 if (current_buffer
== prev_buffer
1856 && last_point_position
!= PT
1857 && NILP (Vdisable_point_adjustment
)
1858 && NILP (Vglobal_disable_point_adjustment
))
1859 adjust_point_for_property (last_point_position
, 0);
1860 already_adjusted
= 1;
1861 if (PT
== last_point_position
- 1
1863 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1864 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1865 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1866 && (lose
>= 0x20 && lose
< 0x7f)))
1867 : (lose
>= 0x20 && lose
< 0x7f))
1868 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1870 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1872 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1874 && !windows_or_buffers_changed
1875 && EQ (current_buffer
->selective_display
, Qnil
)
1876 && !detect_input_pending ()
1877 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1878 && NILP (Vexecuting_kbd_macro
))
1879 direct_output_forward_char (-1);
1882 else if (EQ (Vthis_command
, Qself_insert_command
)
1883 /* Try this optimization only on char keystrokes. */
1884 && NATNUMP (last_command_char
)
1885 && CHAR_VALID_P (XFASTINT (last_command_char
), 0))
1888 = translate_char (Vtranslation_table_for_input
,
1889 XFASTINT (last_command_char
), 0, 0, 0);
1891 if (NILP (Vexecuting_kbd_macro
)
1892 && !EQ (minibuf_window
, selected_window
))
1894 if (!nonundocount
|| nonundocount
>= 20)
1902 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1904 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1906 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1908 || MODIFF
<= SAVE_MODIFF
1909 || windows_or_buffers_changed
1910 || !EQ (current_buffer
->selective_display
, Qnil
)
1911 || detect_input_pending ()
1912 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1913 || !NILP (Vexecuting_kbd_macro
));
1915 value
= internal_self_insert (c
, 0);
1920 if (! NILP (Vpost_command_hook
))
1921 /* Put this before calling adjust_point_for_property
1922 so it will only get called once in any case. */
1925 /* VALUE == 1 when AFTER-CHANGE functions are
1926 installed which is the case most of the time
1927 because FONT-LOCK installs one. */
1928 if (!lose
&& !value
)
1929 direct_output_for_insert (c
);
1934 /* Here for a command that isn't executed directly */
1937 #ifdef HAVE_X_WINDOWS
1938 int scount
= SPECPDL_INDEX ();
1940 if (display_hourglass_p
1941 && NILP (Vexecuting_kbd_macro
))
1943 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1949 if (NILP (current_kboard
->Vprefix_arg
))
1951 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1953 #ifdef HAVE_X_WINDOWS
1954 /* Do not check display_hourglass_p here, because
1955 Fcommand_execute could change it, but we should cancel
1956 hourglass cursor anyway.
1957 But don't cancel the hourglass within a macro
1958 just because a command in the macro finishes. */
1959 if (NILP (Vexecuting_kbd_macro
))
1960 unbind_to (scount
, Qnil
);
1965 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1967 /* Note that the value cell will never directly contain nil
1968 if the symbol is a local variable. */
1969 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1970 safe_run_hooks (Qpost_command_hook
);
1972 /* If displaying a message, resize the echo area window to fit
1973 that message's size exactly. */
1974 if (!NILP (echo_area_buffer
[0]))
1975 resize_echo_area_exactly ();
1977 if (!NILP (Vdeferred_action_list
))
1978 safe_run_hooks (Qdeferred_action_function
);
1980 /* If there is a prefix argument,
1981 1) We don't want Vlast_command to be ``universal-argument''
1982 (that would be dumb), so don't set Vlast_command,
1983 2) we want to leave echoing on so that the prefix will be
1984 echoed as part of this key sequence, so don't call
1986 3) we want to leave this_command_key_count non-zero, so that
1987 read_char will realize that it is re-reading a character, and
1988 not echo it a second time.
1990 If the command didn't actually create a prefix arg,
1991 but is merely a frame event that is transparent to prefix args,
1992 then the above doesn't apply. */
1993 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_char
))
1995 current_kboard
->Vlast_command
= Vthis_command
;
1996 current_kboard
->Vreal_last_command
= real_this_command
;
1998 this_command_key_count
= 0;
1999 this_command_key_count_reset
= 0;
2000 this_single_command_key_start
= 0;
2003 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
2005 /* Setting transient-mark-mode to `only' is a way of
2006 turning it on for just one command. */
2008 if (EQ (Vtransient_mark_mode
, Qidentity
))
2009 Vtransient_mark_mode
= Qnil
;
2010 if (EQ (Vtransient_mark_mode
, Qonly
))
2011 Vtransient_mark_mode
= Qidentity
;
2013 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
2015 /* We could also call `deactivate'mark'. */
2016 if (EQ (Vtransient_mark_mode
, Qlambda
))
2017 Vtransient_mark_mode
= Qnil
;
2020 current_buffer
->mark_active
= Qnil
;
2021 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
2024 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
2025 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
2030 if (current_buffer
== prev_buffer
2031 && last_point_position
!= PT
2032 && NILP (Vdisable_point_adjustment
)
2033 && NILP (Vglobal_disable_point_adjustment
)
2034 && !already_adjusted
)
2035 adjust_point_for_property (last_point_position
, MODIFF
!= prev_modiff
);
2037 /* Install chars successfully executed in kbd macro. */
2039 if (!NILP (current_kboard
->defining_kbd_macro
)
2040 && NILP (current_kboard
->Vprefix_arg
))
2041 finalize_kbd_macro_chars ();
2042 #if 0 /* This shouldn't be necessary anymore. --lorentey */
2045 any_kboard_state ();
2051 extern Lisp_Object Qcomposition
, Qdisplay
;
2053 /* Adjust point to a boundary of a region that has such a property
2054 that should be treated intangible. For the moment, we check
2055 `composition', `display' and `invisible' properties.
2056 LAST_PT is the last position of point. */
2058 extern Lisp_Object Qafter_string
, Qbefore_string
;
2059 extern Lisp_Object get_pos_property
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
2062 adjust_point_for_property (last_pt
, modified
)
2067 Lisp_Object val
, overlay
, tmp
;
2068 int check_composition
= 1, check_display
= 1, check_invisible
= 1;
2071 /* FIXME: cycling is probably not necessary because these properties
2072 can't be usefully combined anyway. */
2073 while (check_composition
|| check_display
|| check_invisible
)
2075 if (check_composition
2076 && PT
> BEGV
&& PT
< ZV
2077 && get_property_and_range (PT
, Qcomposition
, &val
, &beg
, &end
, Qnil
)
2078 && COMPOSITION_VALID_P (beg
, end
, val
)
2079 && beg
< PT
/* && end > PT <- It's always the case. */
2080 && (last_pt
<= beg
|| last_pt
>= end
))
2083 SET_PT (PT
< last_pt
? beg
: end
);
2084 check_display
= check_invisible
= 1;
2086 check_composition
= 0;
2088 && PT
> BEGV
&& PT
< ZV
2089 && !NILP (val
= get_char_property_and_overlay
2090 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
2091 && display_prop_intangible_p (val
)
2092 && (!OVERLAYP (overlay
)
2093 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
2094 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
2095 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
2096 && (beg
< PT
/* && end > PT <- It's always the case. */
2097 || (beg
<= PT
&& STRINGP (val
) && SCHARS (val
) == 0)))
2100 SET_PT (PT
< last_pt
2101 ? (STRINGP (val
) && SCHARS (val
) == 0 ? beg
- 1 : beg
)
2103 check_composition
= check_invisible
= 1;
2106 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
2108 int inv
, ellipsis
= 0;
2111 /* Find boundaries `beg' and `end' of the invisible area, if any. */
2113 && !NILP (val
= get_char_property_and_overlay
2114 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
2115 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
2117 ellipsis
= ellipsis
|| inv
> 1
2118 || (OVERLAYP (overlay
)
2119 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
2120 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
2121 tmp
= Fnext_single_char_property_change
2122 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
2123 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
2126 && !NILP (val
= get_char_property_and_overlay
2127 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
2128 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
2130 ellipsis
= ellipsis
|| inv
> 1
2131 || (OVERLAYP (overlay
)
2132 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
2133 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
2134 tmp
= Fprevious_single_char_property_change
2135 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
2136 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
2139 /* Move away from the inside area. */
2140 if (beg
< PT
&& end
> PT
)
2142 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
2143 /* We haven't moved yet (so we don't need to fear
2144 infinite-looping) and we were outside the range
2145 before (so either end of the range still corresponds
2146 to a move in the right direction): pretend we moved
2147 less than we actually did, so that we still have
2148 more freedom below in choosing which end of the range
2150 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
2151 /* We either have moved already or the last point
2152 was already in the range: we don't get to choose
2153 which end of the range we have to go to. */
2154 : (PT
< last_pt
? beg
: end
));
2155 check_composition
= check_display
= 1;
2157 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
2158 the point to something other than its argument, due to
2159 point-motion hooks, intangibility, etc. */
2160 xassert (PT
== beg
|| PT
== end
);
2163 /* Pretend the area doesn't exist if the buffer is not
2165 if (!modified
&& !ellipsis
&& beg
< end
)
2167 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
2168 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
2169 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
2170 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
2171 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
2172 /* We've already moved as far as we can. Trying to go
2173 to the other end would mean moving backwards and thus
2174 could lead to an infinite loop. */
2176 else if (val
= get_pos_property (make_number (PT
),
2178 TEXT_PROP_MEANS_INVISIBLE (val
)
2179 && (val
= get_pos_property
2180 (make_number (PT
== beg
? end
: beg
),
2182 !TEXT_PROP_MEANS_INVISIBLE (val
)))
2183 (check_composition
= check_display
= 1,
2184 SET_PT (PT
== beg
? end
: beg
));
2187 check_invisible
= 0;
2191 /* Subroutine for safe_run_hooks: run the hook HOOK. */
2194 safe_run_hooks_1 (hook
)
2197 if (NILP (Vrun_hooks
))
2199 return call1 (Vrun_hooks
, Vinhibit_quit
);
2202 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
2205 safe_run_hooks_error (data
)
2208 Lisp_Object args
[3];
2209 args
[0] = build_string ("Error in %s: %s");
2210 args
[1] = Vinhibit_quit
;
2213 return Fset (Vinhibit_quit
, Qnil
);
2216 /* If we get an error while running the hook, cause the hook variable
2217 to be nil. Also inhibit quits, so that C-g won't cause the hook
2218 to mysteriously evaporate. */
2221 safe_run_hooks (hook
)
2224 int count
= SPECPDL_INDEX ();
2225 specbind (Qinhibit_quit
, hook
);
2227 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
2229 unbind_to (count
, Qnil
);
2233 /* Number of seconds between polling for input. This is a Lisp
2234 variable that can be bound. */
2236 EMACS_INT polling_period
;
2238 /* Nonzero means polling for input is temporarily suppressed. */
2240 int poll_suppress_count
;
2242 /* Asynchronous timer for polling. */
2244 struct atimer
*poll_timer
;
2247 #ifdef POLL_FOR_INPUT
2249 /* Poll for input, so what we catch a C-g if it comes in. This
2250 function is called from x_make_frame_visible, see comment
2256 if (interrupt_input_blocked
== 0
2257 && !waiting_for_input
)
2258 read_avail_input (0);
2261 /* Timer callback function for poll_timer. TIMER is equal to
2265 poll_for_input (timer
)
2266 struct atimer
*timer
;
2268 if (poll_suppress_count
== 0)
2270 interrupt_input_pending
= 1;
2272 poll_for_input_1 ();
2276 #endif /* POLL_FOR_INPUT */
2278 /* Begin signals to poll for input, if they are appropriate.
2279 This function is called unconditionally from various places. */
2284 #ifdef POLL_FOR_INPUT
2285 /* XXX This condition was (read_socket_hook && !interrupt_input),
2286 but read_socket_hook is not global anymore. Let's pretend that
2288 if (!interrupt_input
)
2290 /* Turn alarm handling on unconditionally. It might have
2291 been turned off in process.c. */
2292 turn_on_atimers (1);
2294 /* If poll timer doesn't exist, are we need one with
2295 a different interval, start a new one. */
2296 if (poll_timer
== NULL
2297 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2299 EMACS_TIME interval
;
2302 cancel_atimer (poll_timer
);
2304 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
2305 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2306 poll_for_input
, NULL
);
2309 /* Let the timer's callback function poll for input
2310 if this becomes zero. */
2311 --poll_suppress_count
;
2316 /* Nonzero if we are using polling to handle input asynchronously. */
2319 input_polling_used ()
2321 #ifdef POLL_FOR_INPUT
2322 /* XXX This condition was (read_socket_hook && !interrupt_input),
2323 but read_socket_hook is not global anymore. Let's pretend that
2325 return !interrupt_input
;
2331 /* Turn off polling. */
2336 #ifdef POLL_FOR_INPUT
2337 /* XXX This condition was (read_socket_hook && !interrupt_input),
2338 but read_socket_hook is not global anymore. Let's pretend that
2340 if (!interrupt_input
)
2341 ++poll_suppress_count
;
2345 /* Set the value of poll_suppress_count to COUNT
2346 and start or stop polling accordingly. */
2349 set_poll_suppress_count (count
)
2352 #ifdef POLL_FOR_INPUT
2353 if (count
== 0 && poll_suppress_count
!= 0)
2355 poll_suppress_count
= 1;
2358 else if (count
!= 0 && poll_suppress_count
== 0)
2362 poll_suppress_count
= count
;
2366 /* Bind polling_period to a value at least N.
2367 But don't decrease it. */
2370 bind_polling_period (n
)
2373 #ifdef POLL_FOR_INPUT
2374 int new = polling_period
;
2379 stop_other_atimers (poll_timer
);
2381 specbind (Qpolling_period
, make_number (new));
2382 /* Start a new alarm with the new period. */
2387 /* Apply the control modifier to CHARACTER. */
2393 /* Save the upper bits here. */
2394 int upper
= c
& ~0177;
2398 /* Everything in the columns containing the upper-case letters
2399 denotes a control character. */
2400 if (c
>= 0100 && c
< 0140)
2404 /* Set the shift modifier for a control char
2405 made from a shifted letter. But only for letters! */
2406 if (oc
>= 'A' && oc
<= 'Z')
2407 c
|= shift_modifier
;
2410 /* The lower-case letters denote control characters too. */
2411 else if (c
>= 'a' && c
<= 'z')
2414 /* Include the bits for control and shift
2415 only if the basic ASCII code can't indicate them. */
2419 /* Replace the high bits. */
2420 c
|= (upper
& ~ctrl_modifier
);
2425 /* Display the help-echo property of the character after the mouse pointer.
2426 Either show it in the echo area, or call show-help-function to display
2427 it by other means (maybe in a tooltip).
2429 If HELP is nil, that means clear the previous help echo.
2431 If HELP is a string, display that string. If HELP is a function,
2432 call it with OBJECT and POS as arguments; the function should
2433 return a help string or nil for none. For all other types of HELP,
2434 evaluate it to obtain a string.
2436 WINDOW is the window in which the help was generated, if any.
2437 It is nil if not in a window.
2439 If OBJECT is a buffer, POS is the position in the buffer where the
2440 `help-echo' text property was found.
2442 If OBJECT is an overlay, that overlay has a `help-echo' property,
2443 and POS is the position in the overlay's buffer under the mouse.
2445 If OBJECT is a string (an overlay string or a string displayed with
2446 the `display' property). POS is the position in that string under
2449 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2450 echo overwrites a keystroke echo currently displayed in the echo
2453 Note: this function may only be called with HELP nil or a string
2454 from X code running asynchronously. */
2457 show_help_echo (help
, window
, object
, pos
, ok_to_overwrite_keystroke_echo
)
2458 Lisp_Object help
, window
, object
, pos
;
2459 int ok_to_overwrite_keystroke_echo
;
2461 if (!NILP (help
) && !STRINGP (help
))
2463 if (FUNCTIONP (help
))
2465 Lisp_Object args
[4];
2470 help
= safe_call (4, args
);
2473 help
= safe_eval (help
);
2475 if (!STRINGP (help
))
2479 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
2480 if (!noninteractive
&& STRINGP (help
))
2482 /* The mouse-fixup-help-message Lisp function can call
2483 mouse_position_hook, which resets the mouse_moved flags.
2484 This causes trouble if we are trying to read a mouse motion
2485 event (i.e., if we are inside a `track-mouse' form), so we
2486 restore the mouse_moved flag. */
2487 FRAME_PTR f
= NILP (do_mouse_tracking
) ? NULL
: some_mouse_moved ();
2488 help
= call1 (Qmouse_fixup_help_message
, help
);
2494 if (STRINGP (help
) || NILP (help
))
2496 if (!NILP (Vshow_help_function
))
2497 call1 (Vshow_help_function
, help
);
2498 else if (/* Don't overwrite minibuffer contents. */
2499 !MINI_WINDOW_P (XWINDOW (selected_window
))
2500 /* Don't overwrite a keystroke echo. */
2501 && (NILP (echo_message_buffer
)
2502 || ok_to_overwrite_keystroke_echo
)
2503 /* Don't overwrite a prompt. */
2504 && !cursor_in_echo_area
)
2508 int count
= SPECPDL_INDEX ();
2510 if (!help_echo_showing_p
)
2511 Vpre_help_message
= current_message ();
2513 specbind (Qmessage_truncate_lines
, Qt
);
2514 message3_nolog (help
, SBYTES (help
),
2515 STRING_MULTIBYTE (help
));
2516 unbind_to (count
, Qnil
);
2518 else if (STRINGP (Vpre_help_message
))
2520 message3_nolog (Vpre_help_message
,
2521 SBYTES (Vpre_help_message
),
2522 STRING_MULTIBYTE (Vpre_help_message
));
2523 Vpre_help_message
= Qnil
;
2529 help_echo_showing_p
= STRINGP (help
);
2535 /* Input of single characters from keyboard */
2537 Lisp_Object
print_help ();
2538 static Lisp_Object
kbd_buffer_get_event ();
2539 static void record_char ();
2541 static Lisp_Object help_form_saved_window_configs
;
2543 read_char_help_form_unwind (arg
)
2545 Lisp_Object window_config
= XCAR (help_form_saved_window_configs
);
2546 help_form_saved_window_configs
= XCDR (help_form_saved_window_configs
);
2547 if (!NILP (window_config
))
2548 Fset_window_configuration (window_config
);
2552 #define STOP_POLLING \
2553 do { if (! polling_stopped_here) stop_polling (); \
2554 polling_stopped_here = 1; } while (0)
2556 #define RESUME_POLLING \
2557 do { if (polling_stopped_here) start_polling (); \
2558 polling_stopped_here = 0; } while (0)
2560 /* read a character from the keyboard; call the redisplay if needed */
2561 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2562 -1 means do not do redisplay, but do do autosaving.
2565 /* The arguments MAPS and NMAPS are for menu prompting.
2566 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2568 PREV_EVENT is the previous input event, or nil if we are reading
2569 the first event of a key sequence (or not reading a key sequence).
2570 If PREV_EVENT is t, that is a "magic" value that says
2571 not to run input methods, but in other respects to act as if
2572 not reading a key sequence.
2574 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2575 if we used a mouse menu to read the input, or zero otherwise. If
2576 USED_MOUSE_MENU is null, we don't dereference it.
2578 Value is -2 when we find input on another keyboard. A second call
2579 to read_char will read it.
2581 If END_TIME is non-null, it is a pointer to an EMACS_TIME
2582 specifying the maximum time to wait until. If no input arrives by
2583 that time, stop waiting and return nil.
2585 Value is t if we showed a menu and the user rejected it. */
2588 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
, end_time
)
2592 Lisp_Object prev_event
;
2593 int *used_mouse_menu
;
2594 EMACS_TIME
*end_time
;
2596 volatile Lisp_Object c
;
2597 int count
, jmpcount
;
2598 jmp_buf local_getcjmp
;
2600 volatile int key_already_recorded
= 0;
2601 Lisp_Object tem
, save
;
2602 volatile Lisp_Object previous_echo_area_message
;
2603 volatile Lisp_Object also_record
;
2604 volatile int reread
;
2605 struct gcpro gcpro1
, gcpro2
;
2606 int polling_stopped_here
= 0;
2607 struct kboard
*orig_kboard
= current_kboard
;
2611 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2612 before_command_key_count
= this_command_key_count
;
2613 before_command_echo_length
= echo_length ();
2616 previous_echo_area_message
= Qnil
;
2618 GCPRO2 (c
, previous_echo_area_message
);
2623 if (CONSP (Vunread_post_input_method_events
))
2625 c
= XCAR (Vunread_post_input_method_events
);
2626 Vunread_post_input_method_events
2627 = XCDR (Vunread_post_input_method_events
);
2629 /* Undo what read_char_x_menu_prompt did when it unread
2630 additional keys returned by Fx_popup_menu. */
2632 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2640 if (unread_command_char
!= -1)
2642 XSETINT (c
, unread_command_char
);
2643 unread_command_char
= -1;
2649 if (CONSP (Vunread_command_events
))
2651 c
= XCAR (Vunread_command_events
);
2652 Vunread_command_events
= XCDR (Vunread_command_events
);
2656 /* Undo what sit-for did when it unread additional keys
2657 inside universal-argument. */
2660 && EQ (XCAR (c
), Qt
))
2666 /* Undo what read_char_x_menu_prompt did when it unread
2667 additional keys returned by Fx_popup_menu. */
2669 && EQ (XCDR (c
), Qdisabled
)
2670 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2673 /* If the queued event is something that used the mouse,
2674 set used_mouse_menu accordingly. */
2676 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
)))
2677 *used_mouse_menu
= 1;
2679 goto reread_for_input_method
;
2682 if (CONSP (Vunread_input_method_events
))
2684 c
= XCAR (Vunread_input_method_events
);
2685 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2687 /* Undo what read_char_x_menu_prompt did when it unread
2688 additional keys returned by Fx_popup_menu. */
2690 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2694 goto reread_for_input_method
;
2697 this_command_key_count_reset
= 0;
2699 if (!NILP (Vexecuting_kbd_macro
))
2701 /* We set this to Qmacro; since that's not a frame, nobody will
2702 try to switch frames on us, and the selected window will
2705 Since this event came from a macro, it would be misleading to
2706 leave internal_last_event_frame set to wherever the last
2707 real event came from. Normally, a switch-frame event selects
2708 internal_last_event_frame after each command is read, but
2709 events read from a macro should never cause a new frame to be
2711 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2713 /* Exit the macro if we are at the end.
2714 Also, some things replace the macro with t
2715 to force an early exit. */
2716 if (EQ (Vexecuting_kbd_macro
, Qt
)
2717 || executing_kbd_macro_index
>= XFASTINT (Flength (Vexecuting_kbd_macro
)))
2723 c
= Faref (Vexecuting_kbd_macro
, make_number (executing_kbd_macro_index
));
2724 if (STRINGP (Vexecuting_kbd_macro
)
2725 && (XINT (c
) & 0x80) && (XUINT (c
) <= 0xff))
2726 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2728 executing_kbd_macro_index
++;
2733 if (!NILP (unread_switch_frame
))
2735 c
= unread_switch_frame
;
2736 unread_switch_frame
= Qnil
;
2738 /* This event should make it into this_command_keys, and get echoed
2739 again, so we do not set `reread'. */
2743 /* if redisplay was requested */
2744 if (commandflag
>= 0)
2746 /* If there is pending input, process any events which are not
2747 user-visible, such as X selection_request events. */
2749 || detect_input_pending_run_timers (0))
2750 swallow_events (0); /* may clear input_pending */
2752 /* Redisplay if no pending input. */
2753 while (!input_pending
)
2755 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2756 redisplay_preserve_echo_area (5);
2761 /* Normal case: no input arrived during redisplay. */
2764 /* Input arrived and pre-empted redisplay.
2765 Process any events which are not user-visible. */
2767 /* If that cleared input_pending, try again to redisplay. */
2771 /* Message turns off echoing unless more keystrokes turn it on again.
2773 The code in 20.x for the condition was
2775 1. echo_area_glyphs && *echo_area_glyphs
2776 2. && echo_area_glyphs != current_kboard->echobuf
2777 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2779 (1) means there's a current message displayed
2781 (2) means it's not the message from echoing from the current
2784 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2785 is set to a non-null value. This is done in read_char and it is
2786 set to echo_area_glyphs after a call to echo_char. That means
2787 ok_to_echo_at_next_pause is either null or
2788 current_kboard->echobuf with the appropriate current_kboard at
2791 So, condition (3) means in clear text ok_to_echo_at_next_pause
2792 must be either null, or the current message isn't from echoing at
2793 all, or it's from echoing from a different kboard than the
2796 if (/* There currently is something in the echo area. */
2797 !NILP (echo_area_buffer
[0])
2798 && (/* And it's either not from echoing. */
2799 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2800 /* Or it's an echo from a different kboard. */
2801 || echo_kboard
!= current_kboard
2802 /* Or we explicitly allow overwriting whatever there is. */
2803 || ok_to_echo_at_next_pause
== NULL
))
2808 /* Try reading a character via menu prompting in the minibuf.
2809 Try this before the sit-for, because the sit-for
2810 would do the wrong thing if we are supposed to do
2811 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2812 after a mouse event so don't try a minibuf menu. */
2814 if (nmaps
> 0 && INTERACTIVE
2815 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2816 /* Don't bring up a menu if we already have another event. */
2817 && NILP (Vunread_command_events
)
2818 && unread_command_char
< 0
2819 && !detect_input_pending_run_timers (0))
2821 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2823 if (INTEGERP (c
) && XINT (c
) == -2)
2824 return c
; /* wrong_kboard_jmpbuf */
2828 key_already_recorded
= 1;
2833 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2834 We will do that below, temporarily for short sections of code,
2835 when appropriate. local_getcjmp must be in effect
2836 around any call to sit_for or kbd_buffer_get_event;
2837 it *must not* be in effect when we call redisplay. */
2839 jmpcount
= SPECPDL_INDEX ();
2840 if (_setjmp (local_getcjmp
))
2842 /* Handle quits while reading the keyboard. */
2843 /* We must have saved the outer value of getcjmp here,
2844 so restore it now. */
2845 restore_getcjmp (save_jump
);
2846 unbind_to (jmpcount
, Qnil
);
2847 XSETINT (c
, quit_char
);
2848 internal_last_event_frame
= selected_frame
;
2849 Vlast_event_frame
= internal_last_event_frame
;
2850 /* If we report the quit char as an event,
2851 don't do so more than once. */
2852 if (!NILP (Vinhibit_quit
))
2857 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2858 if (kb
!= current_kboard
)
2860 Lisp_Object link
= kb
->kbd_queue
;
2861 /* We shouldn't get here if we were in single-kboard mode! */
2866 while (CONSP (XCDR (link
)))
2868 if (!NILP (XCDR (link
)))
2872 kb
->kbd_queue
= Fcons (c
, Qnil
);
2874 XSETCDR (link
, Fcons (c
, Qnil
));
2875 kb
->kbd_queue_has_data
= 1;
2876 current_kboard
= kb
;
2877 /* This is going to exit from read_char
2878 so we had better get rid of this frame's stuff. */
2880 return make_number (-2); /* wrong_kboard_jmpbuf */
2887 /* Start idle timers if no time limit is supplied. We don't do it
2888 if a time limit is supplied to avoid an infinite recursion in the
2889 situation where an idle timer calls `sit-for'. */
2892 timer_start_idle ();
2894 /* If in middle of key sequence and minibuffer not active,
2895 start echoing if enough time elapses. */
2897 if (minibuf_level
== 0
2899 && !current_kboard
->immediate_echo
2900 && this_command_key_count
> 0
2902 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2903 && NILP (Fzerop (Vecho_keystrokes
))
2904 && (/* No message. */
2905 NILP (echo_area_buffer
[0])
2906 /* Or empty message. */
2907 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2908 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2909 /* Or already echoing from same kboard. */
2910 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2911 /* Or not echoing before and echoing allowed. */
2912 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2914 /* After a mouse event, start echoing right away.
2915 This is because we are probably about to display a menu,
2916 and we don't want to delay before doing so. */
2917 if (EVENT_HAS_PARAMETERS (prev_event
))
2923 save_getcjmp (save_jump
);
2924 restore_getcjmp (local_getcjmp
);
2925 tem0
= sit_for (Vecho_keystrokes
, 1, 1);
2926 restore_getcjmp (save_jump
);
2928 && ! CONSP (Vunread_command_events
))
2933 /* Maybe auto save due to number of keystrokes. */
2935 if (commandflag
!= 0
2936 && auto_save_interval
> 0
2937 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2938 && !detect_input_pending_run_timers (0))
2940 Fdo_auto_save (Qnil
, Qnil
);
2941 /* Hooks can actually change some buffers in auto save. */
2945 /* Try reading using an X menu.
2946 This is never confused with reading using the minibuf
2947 because the recursive call of read_char in read_char_minibuf_menu_prompt
2948 does not pass on any keymaps. */
2950 if (nmaps
> 0 && INTERACTIVE
2951 && !NILP (prev_event
)
2952 && EVENT_HAS_PARAMETERS (prev_event
)
2953 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2954 && !EQ (XCAR (prev_event
), Qtool_bar
)
2955 /* Don't bring up a menu if we already have another event. */
2956 && NILP (Vunread_command_events
)
2957 && unread_command_char
< 0)
2959 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2961 /* Now that we have read an event, Emacs is not idle. */
2968 /* Maybe autosave and/or garbage collect due to idleness. */
2970 if (INTERACTIVE
&& NILP (c
))
2972 int delay_level
, buffer_size
;
2974 /* Slow down auto saves logarithmically in size of current buffer,
2975 and garbage collect while we're at it. */
2976 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2977 last_non_minibuf_size
= Z
- BEG
;
2978 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2980 while (buffer_size
> 64)
2981 delay_level
++, buffer_size
-= buffer_size
>> 2;
2982 if (delay_level
< 4) delay_level
= 4;
2983 /* delay_level is 4 for files under around 50k, 7 at 100k,
2984 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2986 /* Auto save if enough time goes by without input. */
2987 if (commandflag
!= 0
2988 && num_nonmacro_input_events
> last_auto_save
2989 && INTEGERP (Vauto_save_timeout
)
2990 && XINT (Vauto_save_timeout
) > 0)
2993 int timeout
= delay_level
* XFASTINT (Vauto_save_timeout
) / 4;
2995 save_getcjmp (save_jump
);
2996 restore_getcjmp (local_getcjmp
);
2997 tem0
= sit_for (make_number (timeout
), 1, 1);
2998 restore_getcjmp (save_jump
);
3001 && ! CONSP (Vunread_command_events
))
3003 Fdo_auto_save (Qnil
, Qnil
);
3005 /* If we have auto-saved and there is still no input
3006 available, garbage collect if there has been enough
3007 consing going on to make it worthwhile. */
3008 if (!detect_input_pending_run_timers (0)
3009 && consing_since_gc
> gc_cons_threshold
/ 2)
3010 Fgarbage_collect ();
3017 /* Notify the caller if an autosave hook, or a timer, sentinel or
3018 filter in the sit_for calls above have changed the current
3019 kboard. This could happen if they use the minibuffer or start a
3020 recursive edit, like the fancy splash screen in server.el's
3021 filter. If this longjmp wasn't here, read_key_sequence would
3022 interpret the next key sequence using the wrong translation
3023 tables and function keymaps. */
3024 if (NILP (c
) && current_kboard
!= orig_kboard
)
3027 return make_number (-2); /* wrong_kboard_jmpbuf */
3030 /* If this has become non-nil here, it has been set by a timer
3031 or sentinel or filter. */
3032 if (CONSP (Vunread_command_events
))
3034 c
= XCAR (Vunread_command_events
);
3035 Vunread_command_events
= XCDR (Vunread_command_events
);
3038 /* Read something from current KBOARD's side queue, if possible. */
3042 if (current_kboard
->kbd_queue_has_data
)
3044 if (!CONSP (current_kboard
->kbd_queue
))
3046 c
= XCAR (current_kboard
->kbd_queue
);
3047 current_kboard
->kbd_queue
3048 = XCDR (current_kboard
->kbd_queue
);
3049 if (NILP (current_kboard
->kbd_queue
))
3050 current_kboard
->kbd_queue_has_data
= 0;
3051 input_pending
= readable_events (0);
3052 if (EVENT_HAS_PARAMETERS (c
)
3053 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
3054 internal_last_event_frame
= XCAR (XCDR (c
));
3055 Vlast_event_frame
= internal_last_event_frame
;
3060 /* If current_kboard's side queue is empty check the other kboards.
3061 If one of them has data that we have not yet seen here,
3062 switch to it and process the data waiting for it.
3064 Note: if the events queued up for another kboard
3065 have already been seen here, and therefore are not a complete command,
3066 the kbd_queue_has_data field is 0, so we skip that kboard here.
3067 That's to avoid an infinite loop switching between kboards here. */
3068 if (NILP (c
) && !single_kboard
)
3071 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3072 if (kb
->kbd_queue_has_data
)
3074 current_kboard
= kb
;
3075 /* This is going to exit from read_char
3076 so we had better get rid of this frame's stuff. */
3078 return make_number (-2); /* wrong_kboard_jmpbuf */
3087 /* Finally, we read from the main queue,
3088 and if that gives us something we can't use yet, we put it on the
3089 appropriate side queue and try again. */
3098 EMACS_GET_TIME (now
);
3099 if (EMACS_TIME_GE (now
, *end_time
))
3103 /* Actually read a character, waiting if necessary. */
3104 save_getcjmp (save_jump
);
3105 restore_getcjmp (local_getcjmp
);
3107 timer_start_idle ();
3108 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
, end_time
);
3109 restore_getcjmp (save_jump
);
3112 if (! NILP (c
) && (kb
!= current_kboard
))
3114 Lisp_Object link
= kb
->kbd_queue
;
3117 while (CONSP (XCDR (link
)))
3119 if (!NILP (XCDR (link
)))
3123 kb
->kbd_queue
= Fcons (c
, Qnil
);
3125 XSETCDR (link
, Fcons (c
, Qnil
));
3126 kb
->kbd_queue_has_data
= 1;
3130 current_kboard
= kb
;
3131 /* This is going to exit from read_char
3132 so we had better get rid of this frame's stuff. */
3134 return make_number (-2);
3139 /* Terminate Emacs in batch mode if at eof. */
3140 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
3141 Fkill_emacs (make_number (1));
3145 /* Add in any extra modifiers, where appropriate. */
3146 if ((extra_keyboard_modifiers
& CHAR_CTL
)
3147 || ((extra_keyboard_modifiers
& 0177) < ' '
3148 && (extra_keyboard_modifiers
& 0177) != 0))
3149 XSETINT (c
, make_ctrl_char (XINT (c
)));
3151 /* Transfer any other modifier bits directly from
3152 extra_keyboard_modifiers to c. Ignore the actual character code
3153 in the low 16 bits of extra_keyboard_modifiers. */
3154 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
3165 if (commandflag
>= 0
3166 && !input_pending
&& !detect_input_pending_run_timers (0))
3174 /* Buffer switch events are only for internal wakeups
3175 so don't show them to the user.
3176 Also, don't record a key if we already did. */
3177 if (BUFFERP (c
) || key_already_recorded
)
3180 /* Process special events within read_char
3181 and loop around to read another event. */
3184 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
3189 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3190 int was_locked
= single_kboard
;
3191 int count
= SPECPDL_INDEX ();
3192 record_single_kboard_state ();
3195 last_input_char
= c
;
3196 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_char
), Qt
);
3198 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
) && !end_time
)
3199 /* We stopped being idle for this event; undo that. This
3200 prevents automatic window selection (under
3201 mouse_autoselect_window from acting as a real input event, for
3202 example banishing the mouse under mouse-avoidance-mode. */
3203 timer_resume_idle ();
3205 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3206 /* Resume allowing input from any kboard, if that was true before. */
3208 any_kboard_state ();
3209 unbind_to (count
, Qnil
);
3215 /* Handle things that only apply to characters. */
3218 /* If kbd_buffer_get_event gave us an EOF, return that. */
3222 if ((STRINGP (current_kboard
->Vkeyboard_translate_table
)
3223 && SCHARS (current_kboard
->Vkeyboard_translate_table
) > (unsigned) XFASTINT (c
))
3224 || (VECTORP (current_kboard
->Vkeyboard_translate_table
)
3225 && XVECTOR (current_kboard
->Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
3226 || (CHAR_TABLE_P (current_kboard
->Vkeyboard_translate_table
)
3227 && CHAR_VALID_P (XINT (c
), 0)))
3230 d
= Faref (current_kboard
->Vkeyboard_translate_table
, c
);
3231 /* nil in keyboard-translate-table means no translation. */
3237 /* If this event is a mouse click in the menu bar,
3238 return just menu-bar for now. Modify the mouse click event
3239 so we won't do this twice, then queue it up. */
3240 if (EVENT_HAS_PARAMETERS (c
)
3242 && CONSP (EVENT_START (c
))
3243 && CONSP (XCDR (EVENT_START (c
))))
3247 posn
= POSN_POSN (EVENT_START (c
));
3248 /* Handle menu-bar events:
3249 insert the dummy prefix event `menu-bar'. */
3250 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
3252 /* Change menu-bar to (menu-bar) as the event "position". */
3253 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
3256 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
3261 /* Store these characters into recent_keys, the dribble file if any,
3262 and the keyboard macro being defined, if any. */
3264 if (! NILP (also_record
))
3265 record_char (also_record
);
3267 /* Wipe the echo area.
3268 But first, if we are about to use an input method,
3269 save the echo area contents for it to refer to. */
3271 && ! NILP (Vinput_method_function
)
3272 && (unsigned) XINT (c
) >= ' '
3273 && (unsigned) XINT (c
) != 127
3274 && (unsigned) XINT (c
) < 256)
3276 previous_echo_area_message
= Fcurrent_message ();
3277 Vinput_method_previous_message
= previous_echo_area_message
;
3280 /* Now wipe the echo area, except for help events which do their
3281 own stuff with the echo area. */
3283 || (!(EQ (Qhelp_echo
, XCAR (c
)))
3284 && !(EQ (Qswitch_frame
, XCAR (c
)))))
3286 if (!NILP (echo_area_buffer
[0]))
3287 safe_run_hooks (Qecho_area_clear_hook
);
3288 clear_message (1, 0);
3291 reread_for_input_method
:
3293 /* Pass this to the input method, if appropriate. */
3295 && ! NILP (Vinput_method_function
)
3296 /* Don't run the input method within a key sequence,
3297 after the first event of the key sequence. */
3298 && NILP (prev_event
)
3299 && (unsigned) XINT (c
) >= ' '
3300 && (unsigned) XINT (c
) != 127
3301 && (unsigned) XINT (c
) < 256)
3304 int key_count
, key_count_reset
;
3305 struct gcpro gcpro1
;
3306 int count
= SPECPDL_INDEX ();
3308 /* Save the echo status. */
3309 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3310 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3311 Lisp_Object saved_echo_string
= current_kboard
->echo_string
;
3312 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3315 if (before_command_restore_flag
)
3317 this_command_key_count
= before_command_key_count_1
;
3318 if (this_command_key_count
< this_single_command_key_start
)
3319 this_single_command_key_start
= this_command_key_count
;
3320 echo_truncate (before_command_echo_length_1
);
3321 before_command_restore_flag
= 0;
3325 /* Save the this_command_keys status. */
3326 key_count
= this_command_key_count
;
3327 key_count_reset
= this_command_key_count_reset
;
3330 keys
= Fcopy_sequence (this_command_keys
);
3335 /* Clear out this_command_keys. */
3336 this_command_key_count
= 0;
3337 this_command_key_count_reset
= 0;
3339 /* Now wipe the echo area. */
3340 if (!NILP (echo_area_buffer
[0]))
3341 safe_run_hooks (Qecho_area_clear_hook
);
3342 clear_message (1, 0);
3345 /* If we are not reading a key sequence,
3346 never use the echo area. */
3349 specbind (Qinput_method_use_echo_area
, Qt
);
3352 /* Call the input method. */
3353 tem
= call1 (Vinput_method_function
, c
);
3355 tem
= unbind_to (count
, tem
);
3357 /* Restore the saved echoing state
3358 and this_command_keys state. */
3359 this_command_key_count
= key_count
;
3360 this_command_key_count_reset
= key_count_reset
;
3362 this_command_keys
= keys
;
3365 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3366 current_kboard
->echo_string
= saved_echo_string
;
3367 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3368 if (saved_immediate_echo
)
3373 /* The input method can return no events. */
3376 /* Bring back the previous message, if any. */
3377 if (! NILP (previous_echo_area_message
))
3378 message_with_string ("%s", previous_echo_area_message
, 0);
3381 /* It returned one event or more. */
3383 Vunread_post_input_method_events
3384 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3389 /* Display help if not echoing. */
3390 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3392 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3393 Lisp_Object help
, object
, position
, window
, tem
;
3395 tem
= Fcdr (XCDR (c
));
3398 window
= Fcar (tem
);
3400 object
= Fcar (tem
);
3402 position
= Fcar (tem
);
3404 show_help_echo (help
, window
, object
, position
, 0);
3406 /* We stopped being idle for this event; undo that. */
3408 timer_resume_idle ();
3412 if ((! reread
|| this_command_key_count
== 0
3413 || this_command_key_count_reset
)
3417 /* Don't echo mouse motion events. */
3418 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3419 && NILP (Fzerop (Vecho_keystrokes
))
3420 && ! (EVENT_HAS_PARAMETERS (c
)
3421 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3424 if (! NILP (also_record
))
3425 echo_char (also_record
);
3426 /* Once we reread a character, echoing can happen
3427 the next time we pause to read a new one. */
3428 ok_to_echo_at_next_pause
= current_kboard
;
3431 /* Record this character as part of the current key. */
3432 add_command_key (c
);
3433 if (! NILP (also_record
))
3434 add_command_key (also_record
);
3437 last_input_char
= c
;
3440 /* Process the help character specially if enabled */
3441 if (!NILP (Vhelp_form
) && help_char_p (c
))
3444 count
= SPECPDL_INDEX ();
3446 help_form_saved_window_configs
3447 = Fcons (Fcurrent_window_configuration (Qnil
),
3448 help_form_saved_window_configs
);
3449 record_unwind_protect (read_char_help_form_unwind
, Qnil
);
3451 tem0
= Feval (Vhelp_form
);
3453 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3458 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3459 if (EVENT_HAS_PARAMETERS (c
)
3460 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_click
))
3461 XSETCAR (help_form_saved_window_configs
, Qnil
);
3463 while (BUFFERP (c
));
3464 /* Remove the help from the frame */
3465 unbind_to (count
, Qnil
);
3468 if (EQ (c
, make_number (040)))
3472 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3473 while (BUFFERP (c
));
3482 /* Record a key that came from a mouse menu.
3483 Record it for echoing, for this-command-keys, and so on. */
3489 /* Wipe the echo area. */
3490 clear_message (1, 0);
3495 before_command_key_count
= this_command_key_count
;
3496 before_command_echo_length
= echo_length ();
3499 /* Don't echo mouse motion events. */
3500 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3501 && NILP (Fzerop (Vecho_keystrokes
)))
3505 /* Once we reread a character, echoing can happen
3506 the next time we pause to read a new one. */
3507 ok_to_echo_at_next_pause
= 0;
3510 /* Record this character as part of the current key. */
3511 add_command_key (c
);
3513 /* Re-reading in the middle of a command */
3514 last_input_char
= c
;
3518 /* Return 1 if should recognize C as "the help character". */
3526 if (EQ (c
, Vhelp_char
))
3528 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3529 if (EQ (c
, XCAR (tail
)))
3534 /* Record the input event C in various ways. */
3542 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3544 /* To avoid filling recent_keys with help-echo and mouse-movement
3545 events, we filter out repeated help-echo events, only store the
3546 first and last in a series of mouse-movement events, and don't
3547 store repeated help-echo events which are only separated by
3548 mouse-movement events. */
3550 Lisp_Object ev1
, ev2
, ev3
;
3553 if ((ix1
= recent_keys_index
- 1) < 0)
3554 ix1
= NUM_RECENT_KEYS
- 1;
3555 ev1
= AREF (recent_keys
, ix1
);
3557 if ((ix2
= ix1
- 1) < 0)
3558 ix2
= NUM_RECENT_KEYS
- 1;
3559 ev2
= AREF (recent_keys
, ix2
);
3561 if ((ix3
= ix2
- 1) < 0)
3562 ix3
= NUM_RECENT_KEYS
- 1;
3563 ev3
= AREF (recent_keys
, ix3
);
3565 if (EQ (XCAR (c
), Qhelp_echo
))
3567 /* Don't record `help-echo' in recent_keys unless it shows some help
3568 message, and a different help than the previously recorded
3570 Lisp_Object help
, last_help
;
3572 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3573 if (!STRINGP (help
))
3575 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3576 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3578 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3579 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3580 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3582 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3583 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3584 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3585 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3588 else if (EQ (XCAR (c
), Qmouse_movement
))
3590 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3591 So additional mouse movement events replace the last element. */
3592 Lisp_Object last_window
, window
;
3594 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3595 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3596 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3597 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3598 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3600 ASET (recent_keys
, ix1
, c
);
3606 store_kbd_macro_char (c
);
3611 ASET (recent_keys
, recent_keys_index
, c
);
3612 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3613 recent_keys_index
= 0;
3615 else if (recorded
< 0)
3617 /* We need to remove one or two events from recent_keys.
3618 To do this, we simply put nil at those events and move the
3619 recent_keys_index backwards over those events. Usually,
3620 users will never see those nil events, as they will be
3621 overwritten by the command keys entered to see recent_keys
3624 while (recorded
++ < 0 && total_keys
> 0)
3626 if (total_keys
< NUM_RECENT_KEYS
)
3628 if (--recent_keys_index
< 0)
3629 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3630 ASET (recent_keys
, recent_keys_index
, Qnil
);
3634 num_nonmacro_input_events
++;
3636 /* Write c to the dribble file. If c is a lispy event, write
3637 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3638 If you, dear reader, have a better idea, you've got the source. :-) */
3644 if (XUINT (c
) < 0x100)
3645 putc (XINT (c
), dribble
);
3647 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3651 Lisp_Object dribblee
;
3653 /* If it's a structured event, take the event header. */
3654 dribblee
= EVENT_HEAD (c
);
3656 if (SYMBOLP (dribblee
))
3658 putc ('<', dribble
);
3659 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3660 SBYTES (SYMBOL_NAME (dribblee
)),
3662 putc ('>', dribble
);
3675 struct buffer
*old
= current_buffer
;
3676 Fprinc (object
, Qnil
);
3677 set_buffer_internal (XBUFFER (Vstandard_output
));
3678 call0 (intern ("help-mode"));
3679 set_buffer_internal (old
);
3683 /* Copy out or in the info on where C-g should throw to.
3684 This is used when running Lisp code from within get_char,
3685 in case get_char is called recursively.
3686 See read_process_output. */
3692 bcopy (getcjmp
, temp
, sizeof getcjmp
);
3696 restore_getcjmp (temp
)
3699 bcopy (temp
, getcjmp
, sizeof getcjmp
);
3702 /* Low level keyboard/mouse input.
3703 kbd_buffer_store_event places events in kbd_buffer, and
3704 kbd_buffer_get_event retrieves them. */
3706 /* Return true if there are any events in the queue that read-char
3707 would return. If this returns false, a read-char would block. */
3709 readable_events (flags
)
3712 if (flags
& READABLE_EVENTS_DO_TIMERS_NOW
)
3715 /* If the buffer contains only FOCUS_IN_EVENT events, and
3716 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3717 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3719 if (flags
& (READABLE_EVENTS_FILTER_EVENTS
3720 #ifdef USE_TOOLKIT_SCROLL_BARS
3721 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3725 struct input_event
*event
;
3727 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3734 #ifdef USE_TOOLKIT_SCROLL_BARS
3735 (flags
& READABLE_EVENTS_FILTER_EVENTS
) &&
3737 event
->kind
== FOCUS_IN_EVENT
)
3738 #ifdef USE_TOOLKIT_SCROLL_BARS
3739 && !((flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3740 && event
->kind
== SCROLL_BAR_CLICK_EVENT
3741 && event
->part
== scroll_bar_handle
3742 && event
->modifiers
== 0)
3747 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3750 while (event
!= kbd_store_ptr
);
3756 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3757 if (!(flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3758 && !NILP (do_mouse_tracking
) && some_mouse_moved ())
3763 if (current_kboard
->kbd_queue_has_data
)
3769 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3770 if (kb
->kbd_queue_has_data
)
3776 /* Set this for debugging, to have a way to get out */
3781 event_to_kboard (event
)
3782 struct input_event
*event
;
3785 frame
= event
->frame_or_window
;
3787 frame
= XCAR (frame
);
3788 else if (WINDOWP (frame
))
3789 frame
= WINDOW_FRAME (XWINDOW (frame
));
3791 /* There are still some events that don't set this field.
3792 For now, just ignore the problem.
3793 Also ignore dead frames here. */
3794 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3797 return FRAME_KBOARD (XFRAME (frame
));
3802 Lisp_Object Vthrow_on_input
;
3804 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3807 kbd_buffer_store_event (event
)
3808 register struct input_event
*event
;
3810 kbd_buffer_store_event_hold (event
, 0);
3813 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3815 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3816 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3817 Else, if EVENT is a quit event, store the quit event
3818 in HOLD_QUIT, and return (thus ignoring further events).
3820 This is used in read_avail_input to postpone the processing
3821 of the quit event until all subsequent input events have been
3822 parsed (and discarded).
3826 kbd_buffer_store_event_hold (event
, hold_quit
)
3827 register struct input_event
*event
;
3828 struct input_event
*hold_quit
;
3830 if (event
->kind
== NO_EVENT
)
3833 if (hold_quit
&& hold_quit
->kind
!= NO_EVENT
)
3836 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3838 register int c
= event
->code
& 0377;
3840 if (event
->modifiers
& ctrl_modifier
)
3841 c
= make_ctrl_char (c
);
3843 c
|= (event
->modifiers
3844 & (meta_modifier
| alt_modifier
3845 | hyper_modifier
| super_modifier
));
3850 KBOARD
*kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
));
3851 struct input_event
*sp
;
3853 if (single_kboard
&& kb
!= current_kboard
)
3856 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3857 Fcons (make_number (c
), Qnil
));
3858 kb
->kbd_queue_has_data
= 1;
3859 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3861 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3864 if (event_to_kboard (sp
) == kb
)
3866 sp
->kind
= NO_EVENT
;
3867 sp
->frame_or_window
= Qnil
;
3877 bcopy (event
, (char *) hold_quit
, sizeof (*event
));
3881 /* If this results in a quit_char being returned to Emacs as
3882 input, set Vlast_event_frame properly. If this doesn't
3883 get returned to Emacs as an event, the next event read
3884 will set Vlast_event_frame again, so this is safe to do. */
3888 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3890 focus
= event
->frame_or_window
;
3891 internal_last_event_frame
= focus
;
3892 Vlast_event_frame
= focus
;
3895 last_event_timestamp
= event
->timestamp
;
3896 handle_interrupt ();
3900 if (c
&& c
== stop_character
)
3906 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3907 Just ignore the second one. */
3908 else if (event
->kind
== BUFFER_SWITCH_EVENT
3909 && kbd_fetch_ptr
!= kbd_store_ptr
3910 && ((kbd_store_ptr
== kbd_buffer
3911 ? kbd_buffer
+ KBD_BUFFER_SIZE
- 1
3912 : kbd_store_ptr
- 1)->kind
) == BUFFER_SWITCH_EVENT
)
3915 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3916 kbd_store_ptr
= kbd_buffer
;
3918 /* Don't let the very last slot in the buffer become full,
3919 since that would make the two pointers equal,
3920 and that is indistinguishable from an empty buffer.
3921 Discard the event if it would fill the last slot. */
3922 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3924 *kbd_store_ptr
= *event
;
3928 /* If we're inside while-no-input, and this event qualifies
3929 as input, set quit-flag to cause an interrupt. */
3930 if (!NILP (Vthrow_on_input
)
3931 && event
->kind
!= FOCUS_IN_EVENT
3932 && event
->kind
!= HELP_EVENT
3933 && event
->kind
!= DEICONIFY_EVENT
)
3935 Vquit_flag
= Vthrow_on_input
;
3936 /* If we're inside a function that wants immediate quits,
3938 if (immediate_quit
&& NILP (Vinhibit_quit
))
3948 /* Put an input event back in the head of the event queue. */
3951 kbd_buffer_unget_event (event
)
3952 register struct input_event
*event
;
3954 if (kbd_fetch_ptr
== kbd_buffer
)
3955 kbd_fetch_ptr
= kbd_buffer
+ KBD_BUFFER_SIZE
;
3957 /* Don't let the very last slot in the buffer become full, */
3958 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3961 *kbd_fetch_ptr
= *event
;
3966 /* Generate HELP_EVENT input_events in BUFP which has room for
3967 SIZE events. If there's not enough room in BUFP, ignore this
3970 HELP is the help form.
3972 FRAME is the frame on which the help is generated. OBJECT is the
3973 Lisp object where the help was found (a buffer, a string, an
3974 overlay, or nil if neither from a string nor from a buffer. POS is
3975 the position within OBJECT where the help was found.
3977 Value is the number of input_events generated. */
3980 gen_help_event (help
, frame
, window
, object
, pos
)
3981 Lisp_Object help
, frame
, object
, window
;
3984 struct input_event event
;
3988 event
.kind
= HELP_EVENT
;
3989 event
.frame_or_window
= frame
;
3991 event
.x
= WINDOWP (window
) ? window
: frame
;
3994 kbd_buffer_store_event (&event
);
3998 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
4001 kbd_buffer_store_help_event (frame
, help
)
4002 Lisp_Object frame
, help
;
4004 struct input_event event
;
4006 event
.kind
= HELP_EVENT
;
4007 event
.frame_or_window
= frame
;
4012 kbd_buffer_store_event (&event
);
4016 /* Discard any mouse events in the event buffer by setting them to
4019 discard_mouse_events ()
4021 struct input_event
*sp
;
4022 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
4024 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
4027 if (sp
->kind
== MOUSE_CLICK_EVENT
4028 || sp
->kind
== WHEEL_EVENT
4029 || sp
->kind
== HORIZ_WHEEL_EVENT
4031 || sp
->kind
== W32_SCROLL_BAR_CLICK_EVENT
4034 || sp
->kind
== GPM_CLICK_EVENT
4036 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
4038 sp
->kind
= NO_EVENT
;
4044 /* Return non-zero if there are any real events waiting in the event
4045 buffer, not counting `NO_EVENT's.
4047 If DISCARD is non-zero, discard NO_EVENT events at the front of
4048 the input queue, possibly leaving the input queue empty if there
4049 are no real input events. */
4052 kbd_buffer_events_waiting (discard
)
4055 struct input_event
*sp
;
4057 for (sp
= kbd_fetch_ptr
;
4058 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
4061 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
4068 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
4072 /* Clear input event EVENT. */
4076 struct input_event
*event
;
4078 event
->kind
= NO_EVENT
;
4082 /* Read one event from the event buffer, waiting if necessary.
4083 The value is a Lisp object representing the event.
4084 The value is nil for an event that should be ignored,
4085 or that was handled here.
4086 We always read and discard one event. */
4089 kbd_buffer_get_event (kbp
, used_mouse_menu
, end_time
)
4091 int *used_mouse_menu
;
4092 EMACS_TIME
*end_time
;
4101 *kbp
= current_kboard
;
4105 /* Wait until there is input available. */
4108 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4110 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4111 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4115 /* If the quit flag is set, then read_char will return
4116 quit_char, so that counts as "available input." */
4117 if (!NILP (Vquit_flag
))
4118 quit_throw_to_read_char ();
4120 /* One way or another, wait until input is available; then, if
4121 interrupt handlers have not read it, read it now. */
4124 wait_for_kbd_input ();
4126 /* Note SIGIO has been undef'd if FIONREAD is missing. */
4130 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4132 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4133 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4138 EMACS_TIME duration
;
4139 EMACS_GET_TIME (duration
);
4140 if (EMACS_TIME_GE (duration
, *end_time
))
4141 return Qnil
; /* finished waiting */
4144 EMACS_SUB_TIME (duration
, *end_time
, duration
);
4145 wait_reading_process_output (EMACS_SECS (duration
),
4146 EMACS_USECS (duration
),
4147 -1, 1, Qnil
, NULL
, 0);
4151 wait_reading_process_output (0, 0, -1, 1, Qnil
, NULL
, 0);
4153 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
4154 /* Pass 1 for EXPECT since we just waited to have input. */
4155 read_avail_input (1);
4156 #endif /* not VMS */
4159 if (CONSP (Vunread_command_events
))
4162 first
= XCAR (Vunread_command_events
);
4163 Vunread_command_events
= XCDR (Vunread_command_events
);
4164 *kbp
= current_kboard
;
4168 /* At this point, we know that there is a readable event available
4169 somewhere. If the event queue is empty, then there must be a
4170 mouse movement enabled and available. */
4171 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4173 struct input_event
*event
;
4175 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4179 last_event_timestamp
= event
->timestamp
;
4182 *kbp
= event_to_kboard (event
);
4184 *kbp
= current_kboard
; /* Better than returning null ptr? */
4186 *kbp
= &the_only_kboard
;
4191 /* These two kinds of events get special handling
4192 and don't actually appear to the command loop.
4193 We return nil for them. */
4194 if (event
->kind
== SELECTION_REQUEST_EVENT
4195 || event
->kind
== SELECTION_CLEAR_EVENT
)
4198 struct input_event copy
;
4200 /* Remove it from the buffer before processing it,
4201 since otherwise swallow_events will see it
4202 and process it again. */
4204 kbd_fetch_ptr
= event
+ 1;
4205 input_pending
= readable_events (0);
4206 x_handle_selection_event (©
);
4208 /* We're getting selection request events, but we don't have
4214 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
4215 else if (event
->kind
== DELETE_WINDOW_EVENT
)
4217 /* Make an event (delete-frame (FRAME)). */
4218 obj
= Fcons (event
->frame_or_window
, Qnil
);
4219 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
4220 kbd_fetch_ptr
= event
+ 1;
4223 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
4224 else if (event
->kind
== ICONIFY_EVENT
)
4226 /* Make an event (iconify-frame (FRAME)). */
4227 obj
= Fcons (event
->frame_or_window
, Qnil
);
4228 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
4229 kbd_fetch_ptr
= event
+ 1;
4231 else if (event
->kind
== DEICONIFY_EVENT
)
4233 /* Make an event (make-frame-visible (FRAME)). */
4234 obj
= Fcons (event
->frame_or_window
, Qnil
);
4235 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
4236 kbd_fetch_ptr
= event
+ 1;
4239 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
4241 /* The value doesn't matter here; only the type is tested. */
4242 XSETBUFFER (obj
, current_buffer
);
4243 kbd_fetch_ptr
= event
+ 1;
4245 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
4246 || defined (USE_GTK)
4247 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
4249 kbd_fetch_ptr
= event
+ 1;
4250 input_pending
= readable_events (0);
4251 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
4252 x_activate_menubar (XFRAME (event
->frame_or_window
));
4255 #if defined (WINDOWSNT) || defined (MAC_OS)
4256 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
4259 /* Make an event (language-change (KEY_SCRIPT)). */
4260 obj
= Fcons (make_number (event
->code
), Qnil
);
4262 /* Make an event (language-change (FRAME CHARSET LCID)). */
4263 obj
= Fcons (event
->frame_or_window
, Qnil
);
4265 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
4266 kbd_fetch_ptr
= event
+ 1;
4269 else if (event
->kind
== SAVE_SESSION_EVENT
)
4271 obj
= Fcons (Qsave_session
, Qnil
);
4272 kbd_fetch_ptr
= event
+ 1;
4274 /* Just discard these, by returning nil.
4275 With MULTI_KBOARD, these events are used as placeholders
4276 when we need to randomly delete events from the queue.
4277 (They shouldn't otherwise be found in the buffer,
4278 but on some machines it appears they do show up
4279 even without MULTI_KBOARD.) */
4280 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
4281 mouse events during a popup-menu call. */
4282 else if (event
->kind
== NO_EVENT
)
4283 kbd_fetch_ptr
= event
+ 1;
4284 else if (event
->kind
== HELP_EVENT
)
4286 Lisp_Object object
, position
, help
, frame
, window
;
4288 frame
= event
->frame_or_window
;
4289 object
= event
->arg
;
4290 position
= make_number (event
->code
);
4293 clear_event (event
);
4295 kbd_fetch_ptr
= event
+ 1;
4296 if (!WINDOWP (window
))
4298 obj
= Fcons (Qhelp_echo
,
4299 list5 (frame
, help
, window
, object
, position
));
4301 else if (event
->kind
== FOCUS_IN_EVENT
)
4303 /* Notification of a FocusIn event. The frame receiving the
4304 focus is in event->frame_or_window. Generate a
4305 switch-frame event if necessary. */
4306 Lisp_Object frame
, focus
;
4308 frame
= event
->frame_or_window
;
4309 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4313 if (!EQ (frame
, internal_last_event_frame
)
4314 && !EQ (frame
, selected_frame
))
4315 obj
= make_lispy_switch_frame (frame
);
4316 internal_last_event_frame
= frame
;
4317 kbd_fetch_ptr
= event
+ 1;
4321 /* If this event is on a different frame, return a switch-frame this
4322 time, and leave the event in the queue for next time. */
4326 frame
= event
->frame_or_window
;
4328 frame
= XCAR (frame
);
4329 else if (WINDOWP (frame
))
4330 frame
= WINDOW_FRAME (XWINDOW (frame
));
4332 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4336 if (! EQ (frame
, internal_last_event_frame
)
4337 && !EQ (frame
, selected_frame
))
4338 obj
= make_lispy_switch_frame (frame
);
4339 internal_last_event_frame
= frame
;
4341 /* If we didn't decide to make a switch-frame event, go ahead
4342 and build a real event from the queue entry. */
4346 obj
= make_lispy_event (event
);
4348 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined(MAC_OS) \
4349 || defined (USE_GTK)
4350 /* If this was a menu selection, then set the flag to inhibit
4351 writing to last_nonmenu_event. Don't do this if the event
4352 we're returning is (menu-bar), though; that indicates the
4353 beginning of the menu sequence, and we might as well leave
4354 that as the `event with parameters' for this selection. */
4356 && !EQ (event
->frame_or_window
, event
->arg
)
4357 && (event
->kind
== MENU_BAR_EVENT
4358 || event
->kind
== TOOL_BAR_EVENT
))
4359 *used_mouse_menu
= 1;
4362 /* Wipe out this event, to catch bugs. */
4363 clear_event (event
);
4364 kbd_fetch_ptr
= event
+ 1;
4368 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4369 /* Try generating a mouse motion event. */
4370 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4372 FRAME_PTR f
= some_mouse_moved ();
4373 Lisp_Object bar_window
;
4374 enum scroll_bar_part part
;
4378 *kbp
= current_kboard
;
4379 /* Note that this uses F to determine which terminal to look at.
4380 If there is no valid info, it does not store anything
4381 so x remains nil. */
4384 /* XXX Can f or mouse_position_hook be NULL here? */
4385 if (f
&& FRAME_TERMINAL (f
)->mouse_position_hook
)
4386 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, 0, &bar_window
,
4387 &part
, &x
, &y
, &time
);
4391 /* Decide if we should generate a switch-frame event. Don't
4392 generate switch-frame events for motion outside of all Emacs
4398 frame
= FRAME_FOCUS_FRAME (f
);
4400 XSETFRAME (frame
, f
);
4402 if (! EQ (frame
, internal_last_event_frame
)
4403 && !EQ (frame
, selected_frame
))
4404 obj
= make_lispy_switch_frame (frame
);
4405 internal_last_event_frame
= frame
;
4408 /* If we didn't decide to make a switch-frame event, go ahead and
4409 return a mouse-motion event. */
4410 if (!NILP (x
) && NILP (obj
))
4411 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
4413 #endif /* HAVE_MOUSE || HAVE GPM */
4415 /* We were promised by the above while loop that there was
4416 something for us to read! */
4419 input_pending
= readable_events (0);
4421 Vlast_event_frame
= internal_last_event_frame
;
4426 /* Process any events that are not user-visible,
4427 then return, without reading any user-visible events. */
4430 swallow_events (do_display
)
4435 while (kbd_fetch_ptr
!= kbd_store_ptr
)
4437 struct input_event
*event
;
4439 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4443 last_event_timestamp
= event
->timestamp
;
4445 /* These two kinds of events get special handling
4446 and don't actually appear to the command loop. */
4447 if (event
->kind
== SELECTION_REQUEST_EVENT
4448 || event
->kind
== SELECTION_CLEAR_EVENT
)
4451 struct input_event copy
;
4453 /* Remove it from the buffer before processing it,
4454 since otherwise swallow_events called recursively could see it
4455 and process it again. */
4457 kbd_fetch_ptr
= event
+ 1;
4458 input_pending
= readable_events (0);
4459 x_handle_selection_event (©
);
4461 /* We're getting selection request events, but we don't have
4470 old_timers_run
= timers_run
;
4471 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
4473 if (timers_run
!= old_timers_run
&& do_display
)
4474 redisplay_preserve_echo_area (7);
4477 /* Record the start of when Emacs is idle,
4478 for the sake of running idle-time timers. */
4485 /* If we are already in the idle state, do nothing. */
4486 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4489 EMACS_GET_TIME (timer_idleness_start_time
);
4491 timer_last_idleness_start_time
= timer_idleness_start_time
;
4493 /* Mark all idle-time timers as once again candidates for running. */
4494 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4498 timer
= XCAR (timers
);
4500 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4502 XVECTOR (timer
)->contents
[0] = Qnil
;
4506 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4511 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
4514 /* Resume idle timer from last idle start time. */
4517 timer_resume_idle ()
4519 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4522 timer_idleness_start_time
= timer_last_idleness_start_time
;
4525 /* This is only for debugging. */
4526 struct input_event last_timer_event
;
4528 /* Check whether a timer has fired. To prevent larger problems we simply
4529 disregard elements that are not proper timers. Do not make a circular
4530 timer list for the time being.
4532 Returns the number of seconds to wait until the next timer fires. If a
4533 timer is triggering now, return zero seconds.
4534 If no timer is active, return -1 seconds.
4536 If a timer is ripe, we run it, with quitting turned off.
4538 DO_IT_NOW is now ignored. It used to mean that we should
4539 run the timer directly instead of queueing a timer-event.
4540 Now we always run timers directly. */
4543 timer_check (do_it_now
)
4546 EMACS_TIME nexttime
;
4547 EMACS_TIME now
, idleness_now
;
4548 Lisp_Object timers
, idle_timers
, chosen_timer
;
4549 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4551 EMACS_SET_SECS (nexttime
, -1);
4552 EMACS_SET_USECS (nexttime
, -1);
4554 /* Always consider the ordinary timers. */
4555 timers
= Vtimer_list
;
4556 /* Consider the idle timers only if Emacs is idle. */
4557 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4558 idle_timers
= Vtimer_idle_list
;
4561 chosen_timer
= Qnil
;
4562 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4564 if (CONSP (timers
) || CONSP (idle_timers
))
4566 EMACS_GET_TIME (now
);
4567 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4568 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4571 while (CONSP (timers
) || CONSP (idle_timers
))
4573 Lisp_Object
*vector
;
4574 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4575 EMACS_TIME timer_time
, idle_timer_time
;
4576 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4578 /* Skip past invalid timers and timers already handled. */
4581 timer
= XCAR (timers
);
4582 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4584 timers
= XCDR (timers
);
4587 vector
= XVECTOR (timer
)->contents
;
4589 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4590 || !INTEGERP (vector
[3])
4591 || ! NILP (vector
[0]))
4593 timers
= XCDR (timers
);
4597 if (!NILP (idle_timers
))
4599 timer
= XCAR (idle_timers
);
4600 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4602 idle_timers
= XCDR (idle_timers
);
4605 vector
= XVECTOR (timer
)->contents
;
4607 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4608 || !INTEGERP (vector
[3])
4609 || ! NILP (vector
[0]))
4611 idle_timers
= XCDR (idle_timers
);
4616 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4617 based on the next ordinary timer.
4618 TIMER_DIFFERENCE is the distance in time from NOW to when
4619 this timer becomes ripe (negative if it's already ripe). */
4622 timer
= XCAR (timers
);
4623 vector
= XVECTOR (timer
)->contents
;
4624 EMACS_SET_SECS (timer_time
,
4625 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4626 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4627 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4630 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4631 based on the next idle timer. */
4632 if (!NILP (idle_timers
))
4634 idle_timer
= XCAR (idle_timers
);
4635 vector
= XVECTOR (idle_timer
)->contents
;
4636 EMACS_SET_SECS (idle_timer_time
,
4637 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4638 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4639 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4642 /* Decide which timer is the next timer,
4643 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4644 Also step down the list where we found that timer. */
4646 if (! NILP (timers
) && ! NILP (idle_timers
))
4649 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4650 if (EMACS_TIME_NEG_P (temp
))
4652 chosen_timer
= timer
;
4653 timers
= XCDR (timers
);
4654 difference
= timer_difference
;
4658 chosen_timer
= idle_timer
;
4659 idle_timers
= XCDR (idle_timers
);
4660 difference
= idle_timer_difference
;
4663 else if (! NILP (timers
))
4665 chosen_timer
= timer
;
4666 timers
= XCDR (timers
);
4667 difference
= timer_difference
;
4671 chosen_timer
= idle_timer
;
4672 idle_timers
= XCDR (idle_timers
);
4673 difference
= idle_timer_difference
;
4675 vector
= XVECTOR (chosen_timer
)->contents
;
4677 /* If timer is ripe, run it if it hasn't been run. */
4678 if (EMACS_TIME_NEG_P (difference
)
4679 || (EMACS_SECS (difference
) == 0
4680 && EMACS_USECS (difference
) == 0))
4682 if (NILP (vector
[0]))
4684 int count
= SPECPDL_INDEX ();
4685 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4687 #if 0 /* This shouldn't be necessary anymore. --lorentey */
4688 /* On unbind_to, resume allowing input from any kboard, if that
4690 record_single_kboard_state ();
4692 /* Mark the timer as triggered to prevent problems if the lisp
4693 code fails to reschedule it right. */
4696 specbind (Qinhibit_quit
, Qt
);
4698 call1 (Qtimer_event_handler
, chosen_timer
);
4699 Vdeactivate_mark
= old_deactivate_mark
;
4701 unbind_to (count
, Qnil
);
4703 /* Since we have handled the event,
4704 we don't need to tell the caller to wake up and do it. */
4708 /* When we encounter a timer that is still waiting,
4709 return the amount of time to wait before it is ripe. */
4716 /* No timers are pending in the future. */
4717 /* Return 0 if we generated an event, and -1 if not. */
4722 DEFUN ("current-idle-time", Fcurrent_idle_time
, Scurrent_idle_time
, 0, 0, 0,
4723 doc
: /* Return the current length of Emacs idleness.
4724 The value is returned as a list of three integers. The first has the
4725 most significant 16 bits of the seconds, while the second has the
4726 least significant 16 bits. The third integer gives the microsecond
4729 The microsecond count is zero on systems that do not provide
4730 resolution finer than a second. */)
4733 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4735 EMACS_TIME now
, idleness_now
;
4737 EMACS_GET_TIME (now
);
4738 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4740 return list3 (make_number ((EMACS_SECS (idleness_now
) >> 16) & 0xffff),
4741 make_number ((EMACS_SECS (idleness_now
) >> 0) & 0xffff),
4742 make_number (EMACS_USECS (idleness_now
)));
4748 /* Caches for modify_event_symbol. */
4749 static Lisp_Object accent_key_syms
;
4750 static Lisp_Object func_key_syms
;
4751 static Lisp_Object mouse_syms
;
4752 static Lisp_Object wheel_syms
;
4753 static Lisp_Object drag_n_drop_syms
;
4755 /* This is a list of keysym codes for special "accent" characters.
4756 It parallels lispy_accent_keys. */
4758 static int lispy_accent_codes
[] =
4760 #ifdef XK_dead_circumflex
4765 #ifdef XK_dead_grave
4770 #ifdef XK_dead_tilde
4775 #ifdef XK_dead_diaeresis
4780 #ifdef XK_dead_macron
4785 #ifdef XK_dead_degree
4790 #ifdef XK_dead_acute
4795 #ifdef XK_dead_cedilla
4800 #ifdef XK_dead_breve
4805 #ifdef XK_dead_ogonek
4810 #ifdef XK_dead_caron
4815 #ifdef XK_dead_doubleacute
4816 XK_dead_doubleacute
,
4820 #ifdef XK_dead_abovedot
4825 #ifdef XK_dead_abovering
4835 #ifdef XK_dead_belowdot
4840 #ifdef XK_dead_voiced_sound
4841 XK_dead_voiced_sound
,
4845 #ifdef XK_dead_semivoiced_sound
4846 XK_dead_semivoiced_sound
,
4862 /* This is a list of Lisp names for special "accent" characters.
4863 It parallels lispy_accent_codes. */
4865 static char *lispy_accent_keys
[] =
4883 "dead-voiced-sound",
4884 "dead-semivoiced-sound",
4890 #define FUNCTION_KEY_OFFSET 0x0
4892 char *lispy_function_keys
[] =
4896 0, /* VK_LBUTTON 0x01 */
4897 0, /* VK_RBUTTON 0x02 */
4898 "cancel", /* VK_CANCEL 0x03 */
4899 0, /* VK_MBUTTON 0x04 */
4901 0, 0, 0, /* 0x05 .. 0x07 */
4903 "backspace", /* VK_BACK 0x08 */
4904 "tab", /* VK_TAB 0x09 */
4906 0, 0, /* 0x0A .. 0x0B */
4908 "clear", /* VK_CLEAR 0x0C */
4909 "return", /* VK_RETURN 0x0D */
4911 0, 0, /* 0x0E .. 0x0F */
4913 0, /* VK_SHIFT 0x10 */
4914 0, /* VK_CONTROL 0x11 */
4915 0, /* VK_MENU 0x12 */
4916 "pause", /* VK_PAUSE 0x13 */
4917 "capslock", /* VK_CAPITAL 0x14 */
4919 0, 0, 0, 0, 0, 0, /* 0x15 .. 0x1A */
4921 "escape", /* VK_ESCAPE 0x1B */
4923 0, 0, 0, 0, /* 0x1C .. 0x1F */
4925 0, /* VK_SPACE 0x20 */
4926 "prior", /* VK_PRIOR 0x21 */
4927 "next", /* VK_NEXT 0x22 */
4928 "end", /* VK_END 0x23 */
4929 "home", /* VK_HOME 0x24 */
4930 "left", /* VK_LEFT 0x25 */
4931 "up", /* VK_UP 0x26 */
4932 "right", /* VK_RIGHT 0x27 */
4933 "down", /* VK_DOWN 0x28 */
4934 "select", /* VK_SELECT 0x29 */
4935 "print", /* VK_PRINT 0x2A */
4936 "execute", /* VK_EXECUTE 0x2B */
4937 "snapshot", /* VK_SNAPSHOT 0x2C */
4938 "insert", /* VK_INSERT 0x2D */
4939 "delete", /* VK_DELETE 0x2E */
4940 "help", /* VK_HELP 0x2F */
4942 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4944 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4946 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4948 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4950 0, 0, 0, 0, 0, 0, 0, 0, 0,
4951 0, 0, 0, 0, 0, 0, 0, 0, 0,
4952 0, 0, 0, 0, 0, 0, 0, 0,
4954 "lwindow", /* VK_LWIN 0x5B */
4955 "rwindow", /* VK_RWIN 0x5C */
4956 "apps", /* VK_APPS 0x5D */
4958 0, 0, /* 0x5E .. 0x5F */
4960 "kp-0", /* VK_NUMPAD0 0x60 */
4961 "kp-1", /* VK_NUMPAD1 0x61 */
4962 "kp-2", /* VK_NUMPAD2 0x62 */
4963 "kp-3", /* VK_NUMPAD3 0x63 */
4964 "kp-4", /* VK_NUMPAD4 0x64 */
4965 "kp-5", /* VK_NUMPAD5 0x65 */
4966 "kp-6", /* VK_NUMPAD6 0x66 */
4967 "kp-7", /* VK_NUMPAD7 0x67 */
4968 "kp-8", /* VK_NUMPAD8 0x68 */
4969 "kp-9", /* VK_NUMPAD9 0x69 */
4970 "kp-multiply", /* VK_MULTIPLY 0x6A */
4971 "kp-add", /* VK_ADD 0x6B */
4972 "kp-separator", /* VK_SEPARATOR 0x6C */
4973 "kp-subtract", /* VK_SUBTRACT 0x6D */
4974 "kp-decimal", /* VK_DECIMAL 0x6E */
4975 "kp-divide", /* VK_DIVIDE 0x6F */
4976 "f1", /* VK_F1 0x70 */
4977 "f2", /* VK_F2 0x71 */
4978 "f3", /* VK_F3 0x72 */
4979 "f4", /* VK_F4 0x73 */
4980 "f5", /* VK_F5 0x74 */
4981 "f6", /* VK_F6 0x75 */
4982 "f7", /* VK_F7 0x76 */
4983 "f8", /* VK_F8 0x77 */
4984 "f9", /* VK_F9 0x78 */
4985 "f10", /* VK_F10 0x79 */
4986 "f11", /* VK_F11 0x7A */
4987 "f12", /* VK_F12 0x7B */
4988 "f13", /* VK_F13 0x7C */
4989 "f14", /* VK_F14 0x7D */
4990 "f15", /* VK_F15 0x7E */
4991 "f16", /* VK_F16 0x7F */
4992 "f17", /* VK_F17 0x80 */
4993 "f18", /* VK_F18 0x81 */
4994 "f19", /* VK_F19 0x82 */
4995 "f20", /* VK_F20 0x83 */
4996 "f21", /* VK_F21 0x84 */
4997 "f22", /* VK_F22 0x85 */
4998 "f23", /* VK_F23 0x86 */
4999 "f24", /* VK_F24 0x87 */
5001 0, 0, 0, 0, /* 0x88 .. 0x8B */
5002 0, 0, 0, 0, /* 0x8C .. 0x8F */
5004 "kp-numlock", /* VK_NUMLOCK 0x90 */
5005 "scroll", /* VK_SCROLL 0x91 */
5007 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
5008 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
5009 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
5010 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
5011 "kp-end", /* VK_NUMPAD_END 0x96 */
5012 "kp-home", /* VK_NUMPAD_HOME 0x97 */
5013 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
5014 "kp-up", /* VK_NUMPAD_UP 0x99 */
5015 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
5016 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
5017 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
5018 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
5020 0, 0, /* 0x9E .. 0x9F */
5023 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
5024 * Used only as parameters to GetAsyncKeyState and GetKeyState.
5025 * No other API or message will distinguish left and right keys this way.
5029 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5030 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5031 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5032 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5033 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5039 "attn", /* VK_ATTN 0xF6 */
5040 "crsel", /* VK_CRSEL 0xF7 */
5041 "exsel", /* VK_EXSEL 0xF8 */
5042 "ereof", /* VK_EREOF 0xF9 */
5043 "play", /* VK_PLAY 0xFA */
5044 "zoom", /* VK_ZOOM 0xFB */
5045 "noname", /* VK_NONAME 0xFC */
5046 "pa1", /* VK_PA1 0xFD */
5047 "oem_clear", /* VK_OEM_CLEAR 0xFE */
5051 #else /* not HAVE_NTGUI */
5053 /* This should be dealt with in XTread_socket now, and that doesn't
5054 depend on the client system having the Kana syms defined. See also
5055 the XK_kana_A case below. */
5058 static char *lispy_kana_keys
[] =
5060 /* X Keysym value */
5061 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
5062 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
5063 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
5064 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
5065 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
5066 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
5067 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
5068 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
5069 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
5070 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
5071 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
5072 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
5073 "kana-i", "kana-u", "kana-e", "kana-o",
5074 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
5075 "prolongedsound", "kana-A", "kana-I", "kana-U",
5076 "kana-E", "kana-O", "kana-KA", "kana-KI",
5077 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
5078 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
5079 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
5080 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
5081 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
5082 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
5083 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
5084 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
5085 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
5086 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
5087 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
5088 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
5090 #endif /* XK_kana_A */
5093 #define FUNCTION_KEY_OFFSET 0xff00
5095 /* You'll notice that this table is arranged to be conveniently
5096 indexed by X Windows keysym values. */
5097 static char *lispy_function_keys
[] =
5099 /* X Keysym value */
5101 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
5102 "backspace", "tab", "linefeed", "clear",
5104 0, 0, 0, "pause", /* 0xff10...1f */
5105 0, 0, 0, 0, 0, 0, 0, "escape",
5107 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
5108 "romaji", "hiragana", "katakana", "hiragana-katakana",
5109 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
5110 "massyo", "kana-lock", "kana-shift", "eisu-shift",
5111 "eisu-toggle", /* 0xff30...3f */
5112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
5115 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
5116 "down", "prior", "next", "end",
5117 "begin", 0, 0, 0, 0, 0, 0, 0,
5118 "select", /* 0xff60 */ /* IsMiscFunctionKey */
5129 "break", /* 0xff6b */
5132 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
5133 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
5134 "kp-space", /* 0xff80 */ /* IsKeypadKey */
5135 0, 0, 0, 0, 0, 0, 0, 0,
5136 "kp-tab", /* 0xff89 */
5138 "kp-enter", /* 0xff8d */
5140 "kp-f1", /* 0xff91 */
5144 "kp-home", /* 0xff95 */
5149 "kp-prior", /* kp-page-up */
5150 "kp-next", /* kp-page-down */
5156 0, 0, 0, 0, 0, 0, 0, 0, 0,
5157 "kp-multiply", /* 0xffaa */
5162 "kp-divide", /* 0xffaf */
5163 "kp-0", /* 0xffb0 */
5164 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
5167 "kp-equal", /* 0xffbd */
5168 "f1", /* 0xffbe */ /* IsFunctionKey */
5170 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
5171 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
5172 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
5173 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
5174 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
5175 0, 0, 0, 0, 0, 0, 0, 0,
5176 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
5177 0, 0, 0, 0, 0, 0, 0, "delete"
5180 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
5181 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
5183 static char *iso_lispy_function_keys
[] =
5185 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
5186 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
5187 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
5188 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
5189 "iso-lefttab", /* 0xfe20 */
5190 "iso-move-line-up", "iso-move-line-down",
5191 "iso-partial-line-up", "iso-partial-line-down",
5192 "iso-partial-space-left", "iso-partial-space-right",
5193 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
5194 "iso-release-margin-left", "iso-release-margin-right",
5195 "iso-release-both-margins",
5196 "iso-fast-cursor-left", "iso-fast-cursor-right",
5197 "iso-fast-cursor-up", "iso-fast-cursor-down",
5198 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
5199 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
5202 #endif /* not HAVE_NTGUI */
5204 Lisp_Object Vlispy_mouse_stem
;
5206 static char *lispy_wheel_names
[] =
5208 "wheel-up", "wheel-down", "wheel-left", "wheel-right"
5211 /* drag-n-drop events are generated when a set of selected files are
5212 dragged from another application and dropped onto an Emacs window. */
5213 static char *lispy_drag_n_drop_names
[] =
5218 /* Scroll bar parts. */
5219 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
5220 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
5221 Lisp_Object Qtop
, Qratio
;
5223 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
5224 Lisp_Object
*scroll_bar_parts
[] = {
5225 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
5226 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
5229 /* A vector, indexed by button number, giving the down-going location
5230 of currently depressed buttons, both scroll bar and non-scroll bar.
5232 The elements have the form
5233 (BUTTON-NUMBER MODIFIER-MASK . REST)
5234 where REST is the cdr of a position as it would be reported in the event.
5236 The make_lispy_event function stores positions here to tell the
5237 difference between click and drag events, and to store the starting
5238 location to be included in drag events. */
5240 static Lisp_Object button_down_location
;
5242 /* Information about the most recent up-going button event: Which
5243 button, what location, and what time. */
5245 static int last_mouse_button
;
5246 static int last_mouse_x
;
5247 static int last_mouse_y
;
5248 static unsigned long button_down_time
;
5250 /* The maximum time between clicks to make a double-click, or Qnil to
5251 disable double-click detection, or Qt for no time limit. */
5253 Lisp_Object Vdouble_click_time
;
5255 /* Maximum number of pixels the mouse may be moved between clicks
5256 to make a double-click. */
5258 EMACS_INT double_click_fuzz
;
5260 /* The number of clicks in this multiple-click. */
5262 int double_click_count
;
5264 /* Return position of a mouse click or wheel event */
5267 make_lispy_position (f
, x
, y
, time
)
5273 enum window_part part
;
5274 Lisp_Object posn
= Qnil
;
5275 Lisp_Object extra_info
= Qnil
;
5278 /* Set `window' to the window under frame pixel coordinates (x,y) */
5280 window
= window_from_coordinates (f
, XINT (*x
), XINT (*y
),
5281 &part
, &wx
, &wy
, 0);
5285 if (WINDOWP (window
))
5287 /* It's a click in window window at frame coordinates (x,y) */
5288 struct window
*w
= XWINDOW (window
);
5289 Lisp_Object string_info
= Qnil
;
5290 int textpos
= -1, rx
= -1, ry
= -1;
5291 int dx
= -1, dy
= -1;
5292 int width
= -1, height
= -1;
5293 Lisp_Object object
= Qnil
;
5295 /* Set event coordinates to window-relative coordinates
5296 for constructing the Lisp event below. */
5300 if (part
== ON_TEXT
)
5302 wx
+= WINDOW_LEFT_MARGIN_WIDTH (w
);
5304 else if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
5306 /* Mode line or header line. Look for a string under
5307 the mouse that may have a `local-map' property. */
5311 posn
= part
== ON_MODE_LINE
? Qmode_line
: Qheader_line
;
5313 string
= mode_line_string (w
, part
, &rx
, &ry
, &charpos
,
5314 &object
, &dx
, &dy
, &width
, &height
);
5315 if (STRINGP (string
))
5316 string_info
= Fcons (string
, make_number (charpos
));
5317 if (w
== XWINDOW (selected_window
))
5320 textpos
= XMARKER (w
->pointm
)->charpos
;
5322 else if (part
== ON_VERTICAL_BORDER
)
5324 posn
= Qvertical_line
;
5329 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5334 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5336 string
= marginal_area_string (w
, part
, &rx
, &ry
, &charpos
,
5337 &object
, &dx
, &dy
, &width
, &height
);
5338 if (STRINGP (string
))
5339 string_info
= Fcons (string
, make_number (charpos
));
5340 if (part
== ON_LEFT_MARGIN
)
5343 wx
= window_box_right_offset (w
, TEXT_AREA
) - 1;
5345 else if (part
== ON_LEFT_FRINGE
)
5347 posn
= Qleft_fringe
;
5350 wx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5352 : window_box_width (w
, LEFT_MARGIN_AREA
));
5355 else if (part
== ON_RIGHT_FRINGE
)
5357 posn
= Qright_fringe
;
5360 wx
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5361 + window_box_width (w
, TEXT_AREA
)
5362 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5363 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5369 /* Note: We have no special posn for part == ON_SCROLL_BAR. */
5370 wx
= max (WINDOW_LEFT_MARGIN_WIDTH (w
), wx
);
5375 Lisp_Object string2
, object2
= Qnil
;
5376 struct display_pos p
;
5378 int width2
, height2
;
5379 string2
= buffer_posn_from_coords (w
, &wx
, &wy
, &p
,
5380 &object2
, &dx2
, &dy2
,
5382 textpos
= CHARPOS (p
.pos
);
5383 if (rx
< 0) rx
= wx
;
5384 if (ry
< 0) ry
= wy
;
5385 if (dx
< 0) dx
= dx2
;
5386 if (dy
< 0) dy
= dy2
;
5387 if (width
< 0) width
= width2
;
5388 if (height
< 0) height
= height2
;
5392 posn
= make_number (textpos
);
5393 if (STRINGP (string2
))
5394 string_info
= Fcons (string2
,
5395 make_number (CHARPOS (p
.string_pos
)));
5401 #ifdef HAVE_WINDOW_SYSTEM
5402 if (IMAGEP (object
))
5404 Lisp_Object image_map
, hotspot
;
5405 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5407 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5409 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5410 posn
= XCAR (hotspot
);
5415 extra_info
= Fcons (object
,
5416 Fcons (Fcons (make_number (dx
),
5418 Fcons (Fcons (make_number (width
),
5419 make_number (height
)),
5423 extra_info
= Fcons (string_info
,
5424 Fcons (make_number (textpos
),
5425 Fcons (Fcons (make_number (rx
),
5431 XSETFRAME (window
, f
);
5436 XSETFASTINT (*x
, 0);
5437 XSETFASTINT (*y
, 0);
5440 return Fcons (window
,
5442 Fcons (Fcons (*x
, *y
),
5443 Fcons (make_number (time
),
5447 /* Given a struct input_event, build the lisp event which represents
5448 it. If EVENT is 0, build a mouse movement event from the mouse
5449 movement buffer, which should have a movement event in it.
5451 Note that events must be passed to this function in the order they
5452 are received; this function stores the location of button presses
5453 in order to build drag events when the button is released. */
5456 make_lispy_event (event
)
5457 struct input_event
*event
;
5461 switch (SWITCH_ENUM_CAST (event
->kind
))
5463 /* A simple keystroke. */
5464 case ASCII_KEYSTROKE_EVENT
:
5466 Lisp_Object lispy_c
;
5467 int c
= event
->code
& 0377;
5468 /* Turn ASCII characters into control characters
5470 if (event
->modifiers
& ctrl_modifier
)
5471 c
= make_ctrl_char (c
);
5473 /* Add in the other modifier bits. We took care of ctrl_modifier
5474 just above, and the shift key was taken care of by the X code,
5475 and applied to control characters by make_ctrl_char. */
5476 c
|= (event
->modifiers
5477 & (meta_modifier
| alt_modifier
5478 | hyper_modifier
| super_modifier
));
5479 /* Distinguish Shift-SPC from SPC. */
5480 if ((event
->code
& 0377) == 040
5481 && event
->modifiers
& shift_modifier
)
5482 c
|= shift_modifier
;
5483 button_down_time
= 0;
5484 XSETFASTINT (lispy_c
, c
);
5488 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5490 Lisp_Object lispy_c
;
5491 int c
= event
->code
;
5493 /* Add in the other modifier bits. We took care of ctrl_modifier
5494 just above, and the shift key was taken care of by the X code,
5495 and applied to control characters by make_ctrl_char. */
5496 c
|= (event
->modifiers
5497 & (meta_modifier
| alt_modifier
5498 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5499 /* What about the `shift' modifier ? */
5500 button_down_time
= 0;
5501 XSETFASTINT (lispy_c
, c
);
5505 /* A function key. The symbol may need to have modifier prefixes
5507 case NON_ASCII_KEYSTROKE_EVENT
:
5508 button_down_time
= 0;
5510 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5511 if (event
->code
== lispy_accent_codes
[i
])
5512 return modify_event_symbol (i
,
5514 Qfunction_key
, Qnil
,
5515 lispy_accent_keys
, &accent_key_syms
,
5516 (sizeof (lispy_accent_keys
)
5517 / sizeof (lispy_accent_keys
[0])));
5521 if (event
->code
>= 0x400 && event
->code
< 0x500)
5522 return modify_event_symbol (event
->code
- 0x400,
5523 event
->modifiers
& ~shift_modifier
,
5524 Qfunction_key
, Qnil
,
5525 lispy_kana_keys
, &func_key_syms
,
5526 (sizeof (lispy_kana_keys
)
5527 / sizeof (lispy_kana_keys
[0])));
5528 #endif /* XK_kana_A */
5531 #ifdef ISO_FUNCTION_KEY_OFFSET
5532 if (event
->code
< FUNCTION_KEY_OFFSET
5533 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5534 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5536 Qfunction_key
, Qnil
,
5537 iso_lispy_function_keys
, &func_key_syms
,
5538 (sizeof (iso_lispy_function_keys
)
5539 / sizeof (iso_lispy_function_keys
[0])));
5542 /* Handle system-specific or unknown keysyms. */
5543 if (event
->code
& (1 << 28)
5544 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5545 || (event
->code
- FUNCTION_KEY_OFFSET
5546 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5547 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5549 /* We need to use an alist rather than a vector as the cache
5550 since we can't make a vector long enuf. */
5551 if (NILP (current_kboard
->system_key_syms
))
5552 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
5553 return modify_event_symbol (event
->code
,
5556 current_kboard
->Vsystem_key_alist
,
5557 0, ¤t_kboard
->system_key_syms
,
5561 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5563 Qfunction_key
, Qnil
,
5564 lispy_function_keys
, &func_key_syms
,
5565 (sizeof (lispy_function_keys
)
5566 / sizeof (lispy_function_keys
[0])));
5569 /* A mouse click. Figure out where it is, decide whether it's
5570 a press, click or drag, and build the appropriate structure. */
5571 case MOUSE_CLICK_EVENT
:
5572 #ifndef USE_TOOLKIT_SCROLL_BARS
5573 case SCROLL_BAR_CLICK_EVENT
:
5576 int button
= event
->code
;
5578 Lisp_Object position
;
5579 Lisp_Object
*start_pos_ptr
;
5580 Lisp_Object start_pos
;
5584 /* Build the position as appropriate for this mouse click. */
5585 if (event
->kind
== MOUSE_CLICK_EVENT
)
5587 struct frame
*f
= XFRAME (event
->frame_or_window
);
5588 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5592 /* Ignore mouse events that were made on frame that
5593 have been deleted. */
5594 if (! FRAME_LIVE_P (f
))
5597 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5598 /* EVENT->x and EVENT->y are frame-relative pixel
5599 coordinates at this place. Under old redisplay, COLUMN
5600 and ROW are set to frame relative glyph coordinates
5601 which are then used to determine whether this click is
5602 in a menu (non-toolkit version). */
5603 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5604 &column
, &row
, NULL
, 1);
5606 /* In the non-toolkit version, clicks on the menu bar
5607 are ordinary button events in the event buffer.
5608 Distinguish them, and invoke the menu.
5610 (In the toolkit version, the toolkit handles the menu bar
5611 and Emacs doesn't know about it until after the user
5612 makes a selection.) */
5613 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5614 && (event
->modifiers
& down_modifier
))
5616 Lisp_Object items
, item
;
5621 /* Activate the menu bar on the down event. If the
5622 up event comes in before the menu code can deal with it,
5624 if (! (event
->modifiers
& down_modifier
))
5628 /* Find the menu bar item under `column'. */
5630 items
= FRAME_MENU_BAR_ITEMS (f
);
5631 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5633 Lisp_Object pos
, string
;
5634 string
= AREF (items
, i
+ 1);
5635 pos
= AREF (items
, i
+ 3);
5638 if (column
>= XINT (pos
)
5639 && column
< XINT (pos
) + SCHARS (string
))
5641 item
= AREF (items
, i
);
5646 /* ELisp manual 2.4b says (x y) are window relative but
5647 code says they are frame-relative. */
5649 = Fcons (event
->frame_or_window
,
5651 Fcons (Fcons (event
->x
, event
->y
),
5652 Fcons (make_number (event
->timestamp
),
5655 return Fcons (item
, Fcons (position
, Qnil
));
5657 #endif /* not USE_X_TOOLKIT && not USE_GTK */
5659 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5662 #ifndef USE_TOOLKIT_SCROLL_BARS
5665 /* It's a scrollbar click. */
5667 Lisp_Object portion_whole
;
5670 window
= event
->frame_or_window
;
5671 portion_whole
= Fcons (event
->x
, event
->y
);
5672 part
= *scroll_bar_parts
[(int) event
->part
];
5676 Fcons (Qvertical_scroll_bar
,
5677 Fcons (portion_whole
,
5678 Fcons (make_number (event
->timestamp
),
5679 Fcons (part
, Qnil
)))));
5681 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5683 if (button
>= ASIZE (button_down_location
))
5685 button_down_location
= larger_vector (button_down_location
,
5687 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5690 start_pos_ptr
= &AREF (button_down_location
, button
);
5691 start_pos
= *start_pos_ptr
;
5692 *start_pos_ptr
= Qnil
;
5695 /* On window-system frames, use the value of
5696 double-click-fuzz as is. On other frames, interpret it
5697 as a multiple of 1/8 characters. */
5701 if (WINDOWP (event
->frame_or_window
))
5702 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5703 else if (FRAMEP (event
->frame_or_window
))
5704 f
= XFRAME (event
->frame_or_window
);
5708 if (FRAME_WINDOW_P (f
))
5709 fuzz
= double_click_fuzz
;
5711 fuzz
= double_click_fuzz
/ 8;
5713 is_double
= (button
== last_mouse_button
5714 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5715 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5716 && button_down_time
!= 0
5717 && (EQ (Vdouble_click_time
, Qt
)
5718 || (INTEGERP (Vdouble_click_time
)
5719 && ((int)(event
->timestamp
- button_down_time
)
5720 < XINT (Vdouble_click_time
)))));
5723 last_mouse_button
= button
;
5724 last_mouse_x
= XINT (event
->x
);
5725 last_mouse_y
= XINT (event
->y
);
5727 /* If this is a button press, squirrel away the location, so
5728 we can decide later whether it was a click or a drag. */
5729 if (event
->modifiers
& down_modifier
)
5733 double_click_count
++;
5734 event
->modifiers
|= ((double_click_count
> 2)
5739 double_click_count
= 1;
5740 button_down_time
= event
->timestamp
;
5741 *start_pos_ptr
= Fcopy_alist (position
);
5742 ignore_mouse_drag_p
= 0;
5745 /* Now we're releasing a button - check the co-ordinates to
5746 see if this was a click or a drag. */
5747 else if (event
->modifiers
& up_modifier
)
5749 /* If we did not see a down before this up, ignore the up.
5750 Probably this happened because the down event chose a
5751 menu item. It would be an annoyance to treat the
5752 release of the button that chose the menu item as a
5755 if (!CONSP (start_pos
))
5758 event
->modifiers
&= ~up_modifier
;
5759 #if 0 /* Formerly we treated an up with no down as a click event. */
5760 if (!CONSP (start_pos
))
5761 event
->modifiers
|= click_modifier
;
5766 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5768 /* The third element of every position
5769 should be the (x,y) pair. */
5770 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5772 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5774 xdiff
= XINT (event
->x
) - XINT (XCAR (down
));
5775 ydiff
= XINT (event
->y
) - XINT (XCDR (down
));
5778 if (ignore_mouse_drag_p
)
5780 event
->modifiers
|= click_modifier
;
5781 ignore_mouse_drag_p
= 0;
5783 else if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5784 && ydiff
< double_click_fuzz
&& ydiff
> - double_click_fuzz
5785 /* Maybe the mouse has moved a lot, caused scrolling, and
5786 eventually ended up at the same screen position (but
5787 not buffer position) in which case it is a drag, not
5789 /* FIXME: OTOH if the buffer position has changed
5790 because of a timer or process filter rather than
5791 because of mouse movement, it should be considered as
5792 a click. But mouse-drag-region completely ignores
5793 this case and it hasn't caused any real problem, so
5794 it's probably OK to ignore it as well. */
5795 && EQ (Fcar (Fcdr (start_pos
)), Fcar (Fcdr (position
))))
5796 /* Mouse hasn't moved (much). */
5797 event
->modifiers
|= click_modifier
;
5800 button_down_time
= 0;
5801 event
->modifiers
|= drag_modifier
;
5804 /* Don't check is_double; treat this as multiple
5805 if the down-event was multiple. */
5806 if (double_click_count
> 1)
5807 event
->modifiers
|= ((double_click_count
> 2)
5813 /* Every mouse event should either have the down_modifier or
5814 the up_modifier set. */
5818 /* Get the symbol we should use for the mouse click. */
5821 head
= modify_event_symbol (button
,
5823 Qmouse_click
, Vlispy_mouse_stem
,
5826 XVECTOR (mouse_syms
)->size
);
5827 if (event
->modifiers
& drag_modifier
)
5832 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5835 Fcons (make_number (double_click_count
),
5845 case HORIZ_WHEEL_EVENT
:
5847 Lisp_Object position
;
5850 /* Build the position as appropriate for this mouse click. */
5851 struct frame
*f
= XFRAME (event
->frame_or_window
);
5853 /* Ignore wheel events that were made on frame that have been
5855 if (! FRAME_LIVE_P (f
))
5858 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5861 /* Set double or triple modifiers to indicate the wheel speed. */
5863 /* On window-system frames, use the value of
5864 double-click-fuzz as is. On other frames, interpret it
5865 as a multiple of 1/8 characters. */
5870 if (WINDOWP (event
->frame_or_window
))
5871 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5872 else if (FRAMEP (event
->frame_or_window
))
5873 f
= XFRAME (event
->frame_or_window
);
5877 if (FRAME_WINDOW_P (f
))
5878 fuzz
= double_click_fuzz
;
5880 fuzz
= double_click_fuzz
/ 8;
5882 is_double
= (last_mouse_button
< 0
5883 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5884 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5885 && button_down_time
!= 0
5886 && (EQ (Vdouble_click_time
, Qt
)
5887 || (INTEGERP (Vdouble_click_time
)
5888 && ((int)(event
->timestamp
- button_down_time
)
5889 < XINT (Vdouble_click_time
)))));
5892 double_click_count
++;
5893 event
->modifiers
|= ((double_click_count
> 2)
5899 double_click_count
= 1;
5900 event
->modifiers
|= click_modifier
;
5903 button_down_time
= event
->timestamp
;
5904 /* Use a negative value to distinguish wheel from mouse button. */
5905 last_mouse_button
= -1;
5906 last_mouse_x
= XINT (event
->x
);
5907 last_mouse_y
= XINT (event
->y
);
5913 if (event
->modifiers
& up_modifier
)
5915 /* Emit a wheel-up event. */
5916 event
->modifiers
&= ~up_modifier
;
5919 else if (event
->modifiers
& down_modifier
)
5921 /* Emit a wheel-down event. */
5922 event
->modifiers
&= ~down_modifier
;
5926 /* Every wheel event should either have the down_modifier or
5927 the up_modifier set. */
5930 if (event
->kind
== HORIZ_WHEEL_EVENT
)
5933 /* Get the symbol we should use for the wheel event. */
5934 head
= modify_event_symbol (symbol_num
,
5940 ASIZE (wheel_syms
));
5943 if (event
->modifiers
& (double_modifier
| triple_modifier
))
5946 Fcons (make_number (double_click_count
),
5955 #ifdef USE_TOOLKIT_SCROLL_BARS
5957 /* We don't have down and up events if using toolkit scroll bars,
5958 so make this always a click event. Store in the `part' of
5959 the Lisp event a symbol which maps to the following actions:
5961 `above_handle' page up
5962 `below_handle' page down
5966 `bottom' bottom of buffer
5967 `handle' thumb has been dragged.
5968 `end-scroll' end of interaction with scroll bar
5970 The incoming input_event contains in its `part' member an
5971 index of type `enum scroll_bar_part' which we can use as an
5972 index in scroll_bar_parts to get the appropriate symbol. */
5974 case SCROLL_BAR_CLICK_EVENT
:
5976 Lisp_Object position
, head
, window
, portion_whole
, part
;
5978 window
= event
->frame_or_window
;
5979 portion_whole
= Fcons (event
->x
, event
->y
);
5980 part
= *scroll_bar_parts
[(int) event
->part
];
5984 Fcons (Qvertical_scroll_bar
,
5985 Fcons (portion_whole
,
5986 Fcons (make_number (event
->timestamp
),
5987 Fcons (part
, Qnil
)))));
5989 /* Always treat scroll bar events as clicks. */
5990 event
->modifiers
|= click_modifier
;
5991 event
->modifiers
&= ~up_modifier
;
5993 if (event
->code
>= ASIZE (mouse_syms
))
5994 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
5996 /* Get the symbol we should use for the mouse click. */
5997 head
= modify_event_symbol (event
->code
,
6002 XVECTOR (mouse_syms
)->size
);
6003 return Fcons (head
, Fcons (position
, Qnil
));
6006 #endif /* USE_TOOLKIT_SCROLL_BARS */
6009 case W32_SCROLL_BAR_CLICK_EVENT
:
6011 int button
= event
->code
;
6013 Lisp_Object position
;
6014 Lisp_Object
*start_pos_ptr
;
6015 Lisp_Object start_pos
;
6019 Lisp_Object portion_whole
;
6022 window
= event
->frame_or_window
;
6023 portion_whole
= Fcons (event
->x
, event
->y
);
6024 part
= *scroll_bar_parts
[(int) event
->part
];
6028 Fcons (Qvertical_scroll_bar
,
6029 Fcons (portion_whole
,
6030 Fcons (make_number (event
->timestamp
),
6031 Fcons (part
, Qnil
)))));
6034 /* Always treat W32 scroll bar events as clicks. */
6035 event
->modifiers
|= click_modifier
;
6038 /* Get the symbol we should use for the mouse click. */
6041 head
= modify_event_symbol (button
,
6046 XVECTOR (mouse_syms
)->size
);
6052 #endif /* WINDOWSNT */
6054 case DRAG_N_DROP_EVENT
:
6057 Lisp_Object head
, position
;
6060 f
= XFRAME (event
->frame_or_window
);
6063 /* Ignore mouse events that were made on frames that
6064 have been deleted. */
6065 if (! FRAME_LIVE_P (f
))
6068 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6071 head
= modify_event_symbol (0, event
->modifiers
,
6073 lispy_drag_n_drop_names
,
6074 &drag_n_drop_syms
, 1);
6080 #endif /* HAVE_MOUSE */
6082 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
6083 || defined (USE_GTK)
6084 case MENU_BAR_EVENT
:
6085 if (EQ (event
->arg
, event
->frame_or_window
))
6086 /* This is the prefix key. We translate this to
6087 `(menu_bar)' because the code in keyboard.c for menu
6088 events, which we use, relies on this. */
6089 return Fcons (Qmenu_bar
, Qnil
);
6093 case SELECT_WINDOW_EVENT
:
6094 /* Make an event (select-window (WINDOW)). */
6095 return Fcons (Qselect_window
,
6096 Fcons (Fcons (event
->frame_or_window
, Qnil
),
6099 case TOOL_BAR_EVENT
:
6100 if (EQ (event
->arg
, event
->frame_or_window
))
6101 /* This is the prefix key. We translate this to
6102 `(tool_bar)' because the code in keyboard.c for tool bar
6103 events, which we use, relies on this. */
6104 return Fcons (Qtool_bar
, Qnil
);
6105 else if (SYMBOLP (event
->arg
))
6106 return apply_modifiers (event
->modifiers
, event
->arg
);
6109 case USER_SIGNAL_EVENT
:
6110 /* A user signal. */
6112 char *name
= find_user_signal_name (event
->code
);
6115 return intern (name
);
6118 case SAVE_SESSION_EVENT
:
6119 return Qsave_session
;
6122 case MAC_APPLE_EVENT
:
6124 Lisp_Object spec
[2];
6128 return Fcons (Qmac_apple_event
,
6129 Fcons (Fvector (2, spec
),
6130 Fcons (event
->arg
, Qnil
)));
6135 case GPM_CLICK_EVENT
:
6137 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
6138 Lisp_Object head
, position
;
6139 Lisp_Object
*start_pos_ptr
;
6140 Lisp_Object start_pos
;
6141 int button
= event
->code
;
6143 if (button
>= ASIZE (button_down_location
))
6145 button_down_location
= larger_vector (button_down_location
,
6147 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
6150 start_pos_ptr
= &AREF (button_down_location
, button
);
6151 start_pos
= *start_pos_ptr
;
6153 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6156 if (event
->modifiers
& down_modifier
)
6157 *start_pos_ptr
= Fcopy_alist (position
);
6158 else if (event
->modifiers
& (up_modifier
| drag_modifier
))
6160 if (!CONSP (start_pos
))
6162 event
->modifiers
&= ~up_modifier
;
6165 head
= modify_event_symbol (button
,
6167 Qmouse_click
, Vlispy_mouse_stem
,
6170 XVECTOR (mouse_syms
)->size
);
6172 if (event
->modifiers
& drag_modifier
)
6177 else if (event
->modifiers
& double_modifier
)
6180 Fcons (make_number (2),
6182 else if (event
->modifiers
& triple_modifier
)
6185 Fcons (make_number (3),
6192 #endif /* HAVE_GPM */
6194 /* The 'kind' field of the event is something we don't recognize. */
6200 #if defined(HAVE_MOUSE) || defined(HAVE_GPM)
6203 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
6205 Lisp_Object bar_window
;
6206 enum scroll_bar_part part
;
6210 /* Is it a scroll bar movement? */
6211 if (frame
&& ! NILP (bar_window
))
6213 Lisp_Object part_sym
;
6215 part_sym
= *scroll_bar_parts
[(int) part
];
6216 return Fcons (Qscroll_bar_movement
,
6217 (Fcons (Fcons (bar_window
,
6218 Fcons (Qvertical_scroll_bar
,
6219 Fcons (Fcons (x
, y
),
6220 Fcons (make_number (time
),
6226 /* Or is it an ordinary mouse movement? */
6229 Lisp_Object position
;
6231 position
= make_lispy_position (frame
, &x
, &y
, time
);
6233 return Fcons (Qmouse_movement
,
6239 #endif /* HAVE_MOUSE || HAVE GPM */
6241 /* Construct a switch frame event. */
6243 make_lispy_switch_frame (frame
)
6246 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
6249 /* Manipulating modifiers. */
6251 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
6253 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
6254 SYMBOL's name of the end of the modifiers; the string from this
6255 position is the unmodified symbol name.
6257 This doesn't use any caches. */
6260 parse_modifiers_uncached (symbol
, modifier_end
)
6268 CHECK_SYMBOL (symbol
);
6271 name
= SYMBOL_NAME (symbol
);
6273 for (i
= 0; i
+2 <= SBYTES (name
); )
6275 int this_mod_end
= 0;
6278 /* See if the name continues with a modifier word.
6279 Check that the word appears, but don't check what follows it.
6280 Set this_mod and this_mod_end to record what we find. */
6282 switch (SREF (name
, i
))
6284 #define SINGLE_LETTER_MOD(BIT) \
6285 (this_mod_end = i + 1, this_mod = BIT)
6288 SINGLE_LETTER_MOD (alt_modifier
);
6292 SINGLE_LETTER_MOD (ctrl_modifier
);
6296 SINGLE_LETTER_MOD (hyper_modifier
);
6300 SINGLE_LETTER_MOD (meta_modifier
);
6304 SINGLE_LETTER_MOD (shift_modifier
);
6308 SINGLE_LETTER_MOD (super_modifier
);
6311 #undef SINGLE_LETTER_MOD
6313 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6314 if (i + LEN + 1 <= SBYTES (name) \
6315 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
6317 this_mod_end = i + LEN; \
6322 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6323 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6324 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6328 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6330 #undef MULTI_LETTER_MOD
6334 /* If we found no modifier, stop looking for them. */
6335 if (this_mod_end
== 0)
6338 /* Check there is a dash after the modifier, so that it
6339 really is a modifier. */
6340 if (this_mod_end
>= SBYTES (name
)
6341 || SREF (name
, this_mod_end
) != '-')
6344 /* This modifier is real; look for another. */
6345 modifiers
|= this_mod
;
6346 i
= this_mod_end
+ 1;
6349 /* Should we include the `click' modifier? */
6350 if (! (modifiers
& (down_modifier
| drag_modifier
6351 | double_modifier
| triple_modifier
))
6352 && i
+ 7 == SBYTES (name
)
6353 && strncmp (SDATA (name
) + i
, "mouse-", 6) == 0
6354 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
6355 modifiers
|= click_modifier
;
6363 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6364 prepended to the string BASE[0..BASE_LEN-1].
6365 This doesn't use any caches. */
6367 apply_modifiers_uncached (modifiers
, base
, base_len
, base_len_byte
)
6370 int base_len
, base_len_byte
;
6372 /* Since BASE could contain nulls, we can't use intern here; we have
6373 to use Fintern, which expects a genuine Lisp_String, and keeps a
6376 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
6382 /* Only the event queue may use the `up' modifier; it should always
6383 be turned into a click or drag event before presented to lisp code. */
6384 if (modifiers
& up_modifier
)
6387 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
6388 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
6389 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
6390 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
6391 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
6392 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
6393 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
6394 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
6395 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
6396 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
6397 /* The click modifier is denoted by the absence of other modifiers. */
6401 mod_len
= p
- new_mods
;
6405 Lisp_Object new_name
;
6407 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
6408 mod_len
+ base_len_byte
);
6409 bcopy (new_mods
, SDATA (new_name
), mod_len
);
6410 bcopy (base
, SDATA (new_name
) + mod_len
, base_len_byte
);
6412 return Fintern (new_name
, Qnil
);
6417 static char *modifier_names
[] =
6419 "up", "down", "drag", "click", "double", "triple", 0, 0,
6420 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6421 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6423 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6425 static Lisp_Object modifier_symbols
;
6427 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6429 lispy_modifier_list (modifiers
)
6432 Lisp_Object modifier_list
;
6435 modifier_list
= Qnil
;
6436 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6437 if (modifiers
& (1<<i
))
6438 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
6441 return modifier_list
;
6445 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6446 where UNMODIFIED is the unmodified form of SYMBOL,
6447 MASK is the set of modifiers present in SYMBOL's name.
6448 This is similar to parse_modifiers_uncached, but uses the cache in
6449 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6450 Qevent_symbol_elements property. */
6453 parse_modifiers (symbol
)
6456 Lisp_Object elements
;
6458 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6459 if (CONSP (elements
))
6464 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6465 Lisp_Object unmodified
;
6468 unmodified
= Fintern (make_string (SDATA (SYMBOL_NAME (symbol
)) + end
,
6469 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6472 if (modifiers
& ~INTMASK
)
6474 XSETFASTINT (mask
, modifiers
);
6475 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6477 /* Cache the parsing results on SYMBOL. */
6478 Fput (symbol
, Qevent_symbol_element_mask
,
6480 Fput (symbol
, Qevent_symbol_elements
,
6481 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6483 /* Since we know that SYMBOL is modifiers applied to unmodified,
6484 it would be nice to put that in unmodified's cache.
6485 But we can't, since we're not sure that parse_modifiers is
6492 /* Apply the modifiers MODIFIERS to the symbol BASE.
6493 BASE must be unmodified.
6495 This is like apply_modifiers_uncached, but uses BASE's
6496 Qmodifier_cache property, if present. It also builds
6497 Qevent_symbol_elements properties, since it has that info anyway.
6499 apply_modifiers copies the value of BASE's Qevent_kind property to
6500 the modified symbol. */
6502 apply_modifiers (modifiers
, base
)
6506 Lisp_Object cache
, index
, entry
, new_symbol
;
6508 /* Mask out upper bits. We don't know where this value's been. */
6509 modifiers
&= INTMASK
;
6511 /* The click modifier never figures into cache indices. */
6512 cache
= Fget (base
, Qmodifier_cache
);
6513 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
6514 entry
= assq_no_quit (index
, cache
);
6517 new_symbol
= XCDR (entry
);
6520 /* We have to create the symbol ourselves. */
6521 new_symbol
= apply_modifiers_uncached (modifiers
,
6522 SDATA (SYMBOL_NAME (base
)),
6523 SCHARS (SYMBOL_NAME (base
)),
6524 SBYTES (SYMBOL_NAME (base
)));
6526 /* Add the new symbol to the base's cache. */
6527 entry
= Fcons (index
, new_symbol
);
6528 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6530 /* We have the parsing info now for free, so we could add it to
6532 XSETFASTINT (index, modifiers);
6533 Fput (new_symbol, Qevent_symbol_element_mask,
6534 Fcons (base, Fcons (index, Qnil)));
6535 Fput (new_symbol, Qevent_symbol_elements,
6536 Fcons (base, lispy_modifier_list (modifiers)));
6537 Sadly, this is only correct if `base' is indeed a base event,
6538 which is not necessarily the case. -stef */
6541 /* Make sure this symbol is of the same kind as BASE.
6543 You'd think we could just set this once and for all when we
6544 intern the symbol above, but reorder_modifiers may call us when
6545 BASE's property isn't set right; we can't assume that just
6546 because it has a Qmodifier_cache property it must have its
6547 Qevent_kind set right as well. */
6548 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6552 kind
= Fget (base
, Qevent_kind
);
6554 Fput (new_symbol
, Qevent_kind
, kind
);
6561 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6562 return a symbol with the modifiers placed in the canonical order.
6563 Canonical order is alphabetical, except for down and drag, which
6564 always come last. The 'click' modifier is never written out.
6566 Fdefine_key calls this to make sure that (for example) C-M-foo
6567 and M-C-foo end up being equivalent in the keymap. */
6570 reorder_modifiers (symbol
)
6573 /* It's hopefully okay to write the code this way, since everything
6574 will soon be in caches, and no consing will be done at all. */
6577 parsed
= parse_modifiers (symbol
);
6578 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6583 /* For handling events, we often want to produce a symbol whose name
6584 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6585 to some base, like the name of a function key or mouse button.
6586 modify_event_symbol produces symbols of this sort.
6588 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6589 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6592 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6593 into symbol names, or a string specifying a name stem used to
6594 construct a symbol name or the form `STEM-N', where N is the decimal
6595 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6596 non-nil; otherwise NAME_TABLE is used.
6598 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6599 persist between calls to modify_event_symbol that it can use to
6600 store a cache of the symbols it's generated for this NAME_TABLE
6601 before. The object stored there may be a vector or an alist.
6603 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6605 MODIFIERS is a set of modifier bits (as given in struct input_events)
6606 whose prefixes should be applied to the symbol name.
6608 SYMBOL_KIND is the value to be placed in the event_kind property of
6609 the returned symbol.
6611 The symbols we create are supposed to have an
6612 `event-symbol-elements' property, which lists the modifiers present
6613 in the symbol's name. */
6616 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist_or_stem
,
6617 name_table
, symbol_table
, table_size
)
6620 Lisp_Object symbol_kind
;
6621 Lisp_Object name_alist_or_stem
;
6623 Lisp_Object
*symbol_table
;
6624 unsigned int table_size
;
6627 Lisp_Object symbol_int
;
6629 /* Get rid of the "vendor-specific" bit here. */
6630 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6632 /* Is this a request for a valid symbol? */
6633 if (symbol_num
< 0 || symbol_num
>= table_size
)
6636 if (CONSP (*symbol_table
))
6637 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6639 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6640 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6641 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6642 we've never used that symbol before. */
6645 if (! VECTORP (*symbol_table
)
6646 || XVECTOR (*symbol_table
)->size
!= table_size
)
6650 XSETFASTINT (size
, table_size
);
6651 *symbol_table
= Fmake_vector (size
, Qnil
);
6654 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6657 /* Have we already used this symbol before? */
6660 /* No; let's create it. */
6661 if (CONSP (name_alist_or_stem
))
6662 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6663 else if (STRINGP (name_alist_or_stem
))
6665 int len
= SBYTES (name_alist_or_stem
);
6666 char *buf
= (char *) alloca (len
+ 50);
6667 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6668 (long) XINT (symbol_int
) + 1);
6669 value
= intern (buf
);
6671 else if (name_table
!= 0 && name_table
[symbol_num
])
6672 value
= intern (name_table
[symbol_num
]);
6674 #ifdef HAVE_WINDOW_SYSTEM
6677 char *name
= x_get_keysym_name (symbol_num
);
6679 value
= intern (name
);
6686 sprintf (buf
, "key-%d", symbol_num
);
6687 value
= intern (buf
);
6690 if (CONSP (*symbol_table
))
6691 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6693 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6695 /* Fill in the cache entries for this symbol; this also
6696 builds the Qevent_symbol_elements property, which the user
6698 apply_modifiers (modifiers
& click_modifier
, value
);
6699 Fput (value
, Qevent_kind
, symbol_kind
);
6702 /* Apply modifiers to that symbol. */
6703 return apply_modifiers (modifiers
, value
);
6706 /* Convert a list that represents an event type,
6707 such as (ctrl meta backspace), into the usual representation of that
6708 event type as a number or a symbol. */
6710 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6711 doc
: /* Convert the event description list EVENT-DESC to an event type.
6712 EVENT-DESC should contain one base event type (a character or symbol)
6713 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6714 drag, down, double or triple). The base must be last.
6715 The return value is an event type (a character or symbol) which
6716 has the same base event type and all the specified modifiers. */)
6718 Lisp_Object event_desc
;
6726 while (CONSP (rest
))
6734 /* Given a symbol, see if it is a modifier name. */
6735 if (SYMBOLP (elt
) && CONSP (rest
))
6736 this = parse_solitary_modifier (elt
);
6740 else if (!NILP (base
))
6741 error ("Two bases given in one event");
6747 /* Let the symbol A refer to the character A. */
6748 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6749 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6751 if (INTEGERP (base
))
6753 /* Turn (shift a) into A. */
6754 if ((modifiers
& shift_modifier
) != 0
6755 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6757 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6758 modifiers
&= ~shift_modifier
;
6761 /* Turn (control a) into C-a. */
6762 if (modifiers
& ctrl_modifier
)
6763 return make_number ((modifiers
& ~ctrl_modifier
)
6764 | make_ctrl_char (XINT (base
)));
6766 return make_number (modifiers
| XINT (base
));
6768 else if (SYMBOLP (base
))
6769 return apply_modifiers (modifiers
, base
);
6772 error ("Invalid base event");
6777 /* Try to recognize SYMBOL as a modifier name.
6778 Return the modifier flag bit, or 0 if not recognized. */
6781 parse_solitary_modifier (symbol
)
6784 Lisp_Object name
= SYMBOL_NAME (symbol
);
6786 switch (SREF (name
, 0))
6788 #define SINGLE_LETTER_MOD(BIT) \
6789 if (SBYTES (name) == 1) \
6792 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6793 if (LEN == SBYTES (name) \
6794 && ! strncmp (SDATA (name), NAME, LEN)) \
6798 SINGLE_LETTER_MOD (alt_modifier
);
6802 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6806 SINGLE_LETTER_MOD (ctrl_modifier
);
6810 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6811 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6815 SINGLE_LETTER_MOD (hyper_modifier
);
6819 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6823 SINGLE_LETTER_MOD (meta_modifier
);
6827 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6831 SINGLE_LETTER_MOD (shift_modifier
);
6835 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6836 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6837 SINGLE_LETTER_MOD (super_modifier
);
6841 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6842 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6843 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6847 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6850 #undef SINGLE_LETTER_MOD
6851 #undef MULTI_LETTER_MOD
6857 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6858 Such a list is not valid as an event,
6859 but it can be a Lucid-style event type list. */
6862 lucid_event_type_list_p (object
)
6867 if (! CONSP (object
))
6870 if (EQ (XCAR (object
), Qhelp_echo
)
6871 || EQ (XCAR (object
), Qvertical_line
)
6872 || EQ (XCAR (object
), Qmode_line
)
6873 || EQ (XCAR (object
), Qheader_line
))
6876 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6880 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6887 /* Store into *addr a value nonzero if terminal input chars are available.
6888 Serves the purpose of ioctl (0, FIONREAD, addr)
6889 but works even if FIONREAD does not exist.
6890 (In fact, this may actually read some input.)
6892 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
6893 timer events that are ripe.
6894 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
6895 events (FOCUS_IN_EVENT).
6896 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
6897 movements and toolkit scroll bar thumb drags. */
6900 get_input_pending (addr
, flags
)
6904 /* First of all, have we already counted some input? */
6905 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6907 /* If input is being read as it arrives, and we have none, there is none. */
6908 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6911 /* Try to read some input and see how much we get. */
6913 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6916 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6919 gobble_input (expected
)
6924 if (interrupt_input
)
6927 mask
= sigblock (sigmask (SIGIO
));
6928 read_avail_input (expected
);
6932 #ifdef POLL_FOR_INPUT
6933 /* XXX This condition was (read_socket_hook && !interrupt_input),
6934 but read_socket_hook is not global anymore. Let's pretend that
6936 if (!interrupt_input
&& poll_suppress_count
== 0)
6939 mask
= sigblock (sigmask (SIGALRM
));
6940 read_avail_input (expected
);
6946 read_avail_input (expected
);
6950 /* Put a BUFFER_SWITCH_EVENT in the buffer
6951 so that read_key_sequence will notice the new current buffer. */
6954 record_asynch_buffer_change ()
6956 struct input_event event
;
6960 event
.kind
= BUFFER_SWITCH_EVENT
;
6961 event
.frame_or_window
= Qnil
;
6965 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6966 The purpose of the event is to make read_key_sequence look up the
6967 keymaps again. If we aren't in read_key_sequence, we don't need one,
6968 and the event could cause trouble by messing up (input-pending-p). */
6969 tem
= Fwaiting_for_user_input_p ();
6973 /* We never need these events if we have no asynchronous subprocesses. */
6977 /* Make sure no interrupt happens while storing the event. */
6979 if (interrupt_input
)
6982 mask
= sigblock (sigmask (SIGIO
));
6983 kbd_buffer_store_event (&event
);
6990 kbd_buffer_store_event (&event
);
6997 /* Read any terminal input already buffered up by the system
6998 into the kbd_buffer, but do not wait.
7000 EXPECTED should be nonzero if the caller knows there is some input.
7002 Except on VMS, all input is read by this function.
7003 If interrupt_input is nonzero, this function MUST be called
7004 only when SIGIO is blocked.
7006 Returns the number of keyboard chars read, or -1 meaning
7007 this is a bad time to try to read input. */
7010 read_avail_input (expected
)
7017 /* Store pending user signal events, if any. */
7018 if (store_user_signal_events ())
7021 /* Loop through the available terminals, and call their input hooks. */
7025 struct terminal
*next
= t
->next_terminal
;
7027 if (t
->read_socket_hook
)
7030 struct input_event hold_quit
;
7032 EVENT_INIT (hold_quit
);
7033 hold_quit
.kind
= NO_EVENT
;
7035 /* No need for FIONREAD or fcntl; just say don't wait. */
7036 while (nr
= (*t
->read_socket_hook
) (t
, expected
, &hold_quit
), nr
> 0)
7042 if (nr
== -1) /* Not OK to read input now. */
7046 else if (nr
== -2) /* Non-transient error. */
7048 /* The terminal device terminated; it should be closed. */
7050 /* Kill Emacs if this was our last terminal. */
7051 if (!terminal_list
->next_terminal
)
7052 /* Formerly simply reported no input, but that
7053 sometimes led to a failure of Emacs to terminate.
7054 SIGHUP seems appropriate if we can't reach the
7056 /* ??? Is it really right to send the signal just to
7057 this process rather than to the whole process
7058 group? Perhaps on systems with FIONREAD Emacs is
7059 alone in its group. */
7060 kill (getpid (), SIGHUP
);
7062 /* XXX Is calling delete_terminal safe here? It calls Fdelete_frame. */
7063 if (t
->delete_terminal_hook
)
7064 (*t
->delete_terminal_hook
) (t
);
7066 delete_terminal (t
);
7069 if (hold_quit
.kind
!= NO_EVENT
)
7070 kbd_buffer_store_event (&hold_quit
);
7082 /* This is the tty way of reading available input.
7084 Note that each terminal device has its own `struct terminal' object,
7085 and so this function is called once for each individual termcap
7086 terminal. The first parameter indicates which terminal to read from. */
7089 tty_read_avail_input (struct terminal
*terminal
,
7091 struct input_event
*hold_quit
)
7093 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
7094 the kbd_buffer can really hold. That may prevent loss
7095 of characters on some systems when input is stuffed at us. */
7096 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
7098 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
7101 if (terminal
->deleted
) /* Don't read from a deleted terminal. */
7104 if (terminal
->type
!= output_termcap
)
7107 /* XXX I think the following code should be moved to separate hook
7108 functions in system-dependent files. */
7111 #else /* not WINDOWSNT */
7113 n_to_read
= dos_keysns ();
7117 cbuf
[0] = dos_keyread ();
7120 #else /* not MSDOS */
7122 if (! tty
->term_initted
) /* In case we get called during bootstrap. */
7126 return 0; /* The terminal is suspended. */
7129 if (term_gpm
&& gpm_tty
== tty
->terminal
->id
)
7132 struct input_event hold_quit
;
7135 EVENT_INIT (hold_quit
);
7136 hold_quit
.kind
= NO_EVENT
;
7138 while (gpm
= Gpm_GetEvent (&event
), gpm
== 1) {
7139 nread
+= handle_one_term_event (tty
, &event
, &hold_quit
);
7141 if (hold_quit
.kind
!= NO_EVENT
)
7142 kbd_buffer_store_event (&hold_quit
);
7146 #endif /* HAVE_GPM */
7148 /* Determine how many characters we should *try* to read. */
7150 /* Find out how much input is available. */
7151 if (ioctl (fileno (tty
->input
), FIONREAD
, &n_to_read
) < 0)
7153 if (! noninteractive
)
7154 return -2; /* Close this terminal. */
7160 if (n_to_read
> sizeof cbuf
)
7161 n_to_read
= sizeof cbuf
;
7162 #else /* no FIONREAD */
7163 #if defined (USG) || defined (DGUX) || defined(CYGWIN)
7164 /* Read some input if available, but don't wait. */
7165 n_to_read
= sizeof cbuf
;
7166 fcntl (fileno (tty
->input
), F_SETFL
, O_NDELAY
);
7172 /* Now read; for one reason or another, this will not block.
7173 NREAD is set to the number of chars read. */
7176 nread
= emacs_read (fileno (tty
->input
), cbuf
, n_to_read
);
7177 /* POSIX infers that processes which are not in the session leader's
7178 process group won't get SIGHUP's at logout time. BSDI adheres to
7179 this part standard and returns -1 from read (0) with errno==EIO
7180 when the control tty is taken away.
7181 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
7182 if (nread
== -1 && errno
== EIO
)
7183 return -2; /* Close this terminal. */
7184 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
7185 /* The kernel sometimes fails to deliver SIGHUP for ptys.
7186 This looks incorrect, but it isn't, because _BSD causes
7187 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
7188 and that causes a value other than 0 when there is no input. */
7190 return -2; /* Close this terminal. */
7194 /* We used to retry the read if it was interrupted.
7195 But this does the wrong thing when O_NDELAY causes
7196 an EAGAIN error. Does anybody know of a situation
7197 where a retry is actually needed? */
7199 nread
< 0 && (errno
== EAGAIN
7213 #if defined (USG) || defined (DGUX) || defined (CYGWIN)
7214 fcntl (fileno (tty
->input
), F_SETFL
, 0);
7215 #endif /* USG or DGUX or CYGWIN */
7216 #endif /* no FIONREAD */
7221 #endif /* not MSDOS */
7222 #endif /* not WINDOWSNT */
7224 for (i
= 0; i
< nread
; i
++)
7226 struct input_event buf
;
7228 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7230 if (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80))
7231 buf
.modifiers
= meta_modifier
;
7232 if (tty
->meta_key
!= 2)
7236 /* Set the frame corresponding to the active tty. Note that the
7237 value of selected_frame is not reliable here, redisplay tends
7238 to temporarily change it. */
7239 buf
.frame_or_window
= tty
->top_frame
;
7242 kbd_buffer_store_event (&buf
);
7243 /* Don't look at input that follows a C-g too closely.
7244 This reduces lossage due to autorepeat on C-g. */
7245 if (buf
.kind
== ASCII_KEYSTROKE_EVENT
7246 && buf
.code
== quit_char
)
7252 #endif /* not VMS */
7255 handle_async_input ()
7258 extern int select_alarmed
;
7261 interrupt_input_pending
= 0;
7266 nread
= read_avail_input (1);
7267 /* -1 means it's not ok to read the input now.
7268 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7269 0 means there was no keyboard input available. */
7274 select_alarmed
= 1; /* Force the select emulator back to life */
7279 #ifdef SIGIO /* for entire page */
7280 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7283 input_available_signal (signo
)
7286 /* Must preserve main program's value of errno. */
7287 int old_errno
= errno
;
7288 #if defined (USG) && !defined (POSIX_SIGNALS)
7289 /* USG systems forget handlers when they are used;
7290 must reestablish each time */
7291 signal (signo
, input_available_signal
);
7299 interrupt_input_pending
= 1;
7301 SIGNAL_THREAD_CHECK (signo
);
7304 if (input_available_clear_time
)
7305 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7308 handle_async_input ();
7318 /* Send ourselves a SIGIO.
7320 This function exists so that the UNBLOCK_INPUT macro in
7321 blockinput.h can have some way to take care of input we put off
7322 dealing with, without assuming that every file which uses
7323 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
7325 reinvoke_input_signal ()
7328 handle_async_input ();
7334 /* User signal events. */
7336 struct user_signal_info
7338 /* Signal number. */
7341 /* Name of the signal. */
7344 /* Number of pending signals. */
7347 struct user_signal_info
*next
;
7350 /* List of user signals. */
7351 static struct user_signal_info
*user_signals
= NULL
;
7354 add_user_signal (sig
, name
)
7358 struct user_signal_info
*p
;
7360 for (p
= user_signals
; p
; p
= p
->next
)
7362 /* Already added. */
7365 p
= xmalloc (sizeof (struct user_signal_info
));
7367 p
->name
= xstrdup (name
);
7369 p
->next
= user_signals
;
7372 signal (sig
, handle_user_signal
);
7376 handle_user_signal (sig
)
7379 int old_errno
= errno
;
7380 struct user_signal_info
*p
;
7382 #if defined (USG) && !defined (POSIX_SIGNALS)
7383 /* USG systems forget handlers when they are used;
7384 must reestablish each time */
7385 signal (sig
, handle_user_signal
);
7388 SIGNAL_THREAD_CHECK (sig
);
7390 for (p
= user_signals
; p
; p
= p
->next
)
7395 if (interrupt_input
)
7396 kill (getpid (), SIGIO
);
7400 /* Tell wait_reading_process_output that it needs to wake
7401 up and look around. */
7402 if (input_available_clear_time
)
7403 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7412 find_user_signal_name (sig
)
7415 struct user_signal_info
*p
;
7417 for (p
= user_signals
; p
; p
= p
->next
)
7425 store_user_signal_events ()
7427 struct user_signal_info
*p
;
7428 struct input_event buf
;
7431 for (p
= user_signals
; p
; p
= p
->next
)
7432 if (p
->npending
> 0)
7438 bzero (&buf
, sizeof buf
);
7439 buf
.kind
= USER_SIGNAL_EVENT
;
7440 buf
.frame_or_window
= selected_frame
;
7442 nstored
+= p
->npending
;
7444 mask
= sigblock (sigmask (p
->sig
));
7448 kbd_buffer_store_event (&buf
);
7451 while (p
->npending
> 0);
7459 static void menu_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
7460 static Lisp_Object menu_bar_one_keymap_changed_items
;
7462 /* These variables hold the vector under construction within
7463 menu_bar_items and its subroutines, and the current index
7464 for storing into that vector. */
7465 static Lisp_Object menu_bar_items_vector
;
7466 static int menu_bar_items_index
;
7468 /* Return a vector of menu items for a menu bar, appropriate
7469 to the current buffer. Each item has three elements in the vector:
7472 OLD is an old vector we can optionally reuse, or nil. */
7475 menu_bar_items (old
)
7478 /* The number of keymaps we're scanning right now, and the number of
7479 keymaps we have allocated space for. */
7482 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7483 in the current keymaps, or nil where it is not a prefix. */
7486 Lisp_Object def
, tail
;
7495 /* In order to build the menus, we need to call the keymap
7496 accessors. They all call QUIT. But this function is called
7497 during redisplay, during which a quit is fatal. So inhibit
7498 quitting while building the menus.
7499 We do this instead of specbind because (1) errors will clear it anyway
7500 and (2) this avoids risk of specpdl overflow. */
7501 oquit
= Vinhibit_quit
;
7505 menu_bar_items_vector
= old
;
7507 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
7508 menu_bar_items_index
= 0;
7510 /* Build our list of keymaps.
7511 If we recognize a function key and replace its escape sequence in
7512 keybuf with its symbol, or if the sequence starts with a mouse
7513 click and we need to switch buffers, we jump back here to rebuild
7514 the initial keymaps from the current buffer. */
7518 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7519 if (!NILP (Voverriding_local_map_menu_flag
))
7521 /* Yes, use them (if non-nil) as well as the global map. */
7522 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7524 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7525 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7526 if (!NILP (Voverriding_local_map
))
7527 maps
[nmaps
++] = Voverriding_local_map
;
7531 /* No, so use major and minor mode keymaps and keymap property.
7532 Note that menu-bar bindings in the local-map and keymap
7533 properties may not work reliable, as they are only
7534 recognized when the menu-bar (or mode-line) is updated,
7535 which does not normally happen after every command. */
7538 nminor
= current_minor_maps (NULL
, &tmaps
);
7539 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7541 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7542 maps
[nmaps
++] = tem
;
7543 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
7545 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7547 maps
[nmaps
++] = current_global_map
;
7550 /* Look up in each map the dummy prefix key `menu-bar'. */
7554 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
7555 if (!NILP (maps
[mapno
]))
7557 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
7561 menu_bar_one_keymap_changed_items
= Qnil
;
7562 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
7566 /* Move to the end those items that should be at the end. */
7568 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
7571 int end
= menu_bar_items_index
;
7573 for (i
= 0; i
< end
; i
+= 4)
7574 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7576 Lisp_Object tem0
, tem1
, tem2
, tem3
;
7577 /* Move the item at index I to the end,
7578 shifting all the others forward. */
7579 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
7580 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
7581 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7582 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
7584 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7585 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7586 (end
- i
- 4) * sizeof (Lisp_Object
));
7587 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
7588 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
7589 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
7590 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
7595 /* Add nil, nil, nil, nil at the end. */
7596 i
= menu_bar_items_index
;
7597 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7600 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7601 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7602 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7603 menu_bar_items_vector
= tem
;
7605 /* Add this item. */
7606 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7607 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7608 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7609 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7610 menu_bar_items_index
= i
;
7612 Vinhibit_quit
= oquit
;
7613 return menu_bar_items_vector
;
7616 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7617 If there's already an item for KEY, add this DEF to it. */
7619 Lisp_Object item_properties
;
7622 menu_bar_item (key
, item
, dummy1
, dummy2
)
7623 Lisp_Object key
, item
, dummy1
;
7626 struct gcpro gcpro1
;
7630 if (EQ (item
, Qundefined
))
7632 /* If a map has an explicit `undefined' as definition,
7633 discard any previously made menu bar item. */
7635 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7636 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7638 if (menu_bar_items_index
> i
+ 4)
7639 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7640 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7641 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7642 menu_bar_items_index
-= 4;
7646 /* If this keymap has already contributed to this KEY,
7647 don't contribute to it a second time. */
7648 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7649 if (!NILP (tem
) || NILP (item
))
7652 menu_bar_one_keymap_changed_items
7653 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7655 /* We add to menu_bar_one_keymap_changed_items before doing the
7656 parse_menu_item, so that if it turns out it wasn't a menu item,
7657 it still correctly hides any further menu item. */
7659 i
= parse_menu_item (item
, 0, 1);
7664 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7666 /* Find any existing item for this KEY. */
7667 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7668 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7671 /* If we did not find this KEY, add it at the end. */
7672 if (i
== menu_bar_items_index
)
7674 /* If vector is too small, get a bigger one. */
7675 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7678 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7679 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7680 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7681 menu_bar_items_vector
= tem
;
7684 /* Add this item. */
7685 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7686 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7687 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7688 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7689 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7690 menu_bar_items_index
= i
;
7692 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7696 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7697 /* If the new and the old items are not both keymaps,
7698 the lookup will only find `item'. */
7699 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7700 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7704 /* This is used as the handler when calling menu_item_eval_property. */
7706 menu_item_eval_property_1 (arg
)
7709 /* If we got a quit from within the menu computation,
7710 quit all the way out of it. This takes care of C-] in the debugger. */
7711 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7712 Fsignal (Qquit
, Qnil
);
7717 /* Evaluate an expression and return the result (or nil if something
7718 went wrong). Used to evaluate dynamic parts of menu items. */
7720 menu_item_eval_property (sexpr
)
7723 int count
= SPECPDL_INDEX ();
7725 specbind (Qinhibit_redisplay
, Qt
);
7726 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7727 menu_item_eval_property_1
);
7728 return unbind_to (count
, val
);
7731 /* This function parses a menu item and leaves the result in the
7732 vector item_properties.
7733 ITEM is a key binding, a possible menu item.
7734 If NOTREAL is nonzero, only check for equivalent key bindings, don't
7735 evaluate dynamic expressions in the menu item.
7736 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7738 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7739 parse_menu_item returns true if the item is a menu item and false
7743 parse_menu_item (item
, notreal
, inmenubar
)
7745 int notreal
, inmenubar
;
7747 Lisp_Object def
, tem
, item_string
, start
;
7748 Lisp_Object cachelist
;
7750 Lisp_Object keyhint
;
7761 /* Create item_properties vector if necessary. */
7762 if (NILP (item_properties
))
7764 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7766 /* Initialize optional entries. */
7767 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7768 AREF (item_properties
, i
) = Qnil
;
7769 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7771 /* Save the item here to protect it from GC. */
7772 AREF (item_properties
, ITEM_PROPERTY_ITEM
) = item
;
7774 item_string
= XCAR (item
);
7778 if (STRINGP (item_string
))
7780 /* Old format menu item. */
7781 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7783 /* Maybe help string. */
7784 if (CONSP (item
) && STRINGP (XCAR (item
)))
7786 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7791 /* Maybe key binding cache. */
7792 if (CONSP (item
) && CONSP (XCAR (item
))
7793 && (NILP (XCAR (XCAR (item
)))
7794 || VECTORP (XCAR (XCAR (item
)))))
7796 cachelist
= XCAR (item
);
7800 /* This is the real definition--the function to run. */
7801 AREF (item_properties
, ITEM_PROPERTY_DEF
) = item
;
7803 /* Get enable property, if any. */
7806 tem
= Fget (item
, Qmenu_enable
);
7807 if (!NILP (Venable_disabled_menus_and_buttons
))
7808 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7809 else if (!NILP (tem
))
7810 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7813 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7815 /* New format menu item. */
7816 AREF (item_properties
, ITEM_PROPERTY_NAME
) = XCAR (item
);
7817 start
= XCDR (item
);
7820 /* We have a real binding. */
7821 AREF (item_properties
, ITEM_PROPERTY_DEF
) = XCAR (start
);
7823 item
= XCDR (start
);
7824 /* Is there a cache list with key equivalences. */
7825 if (CONSP (item
) && CONSP (XCAR (item
)))
7827 cachelist
= XCAR (item
);
7831 /* Parse properties. */
7832 while (CONSP (item
) && CONSP (XCDR (item
)))
7837 if (EQ (tem
, QCenable
))
7839 if (!NILP (Venable_disabled_menus_and_buttons
))
7840 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7842 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = XCAR (item
);
7844 else if (EQ (tem
, QCvisible
) && !notreal
)
7846 /* If got a visible property and that evaluates to nil
7847 then ignore this item. */
7848 tem
= menu_item_eval_property (XCAR (item
));
7852 else if (EQ (tem
, QChelp
))
7853 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7854 else if (EQ (tem
, QCfilter
))
7856 else if (EQ (tem
, QCkey_sequence
))
7859 if (NILP (cachelist
)
7860 && (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
)))
7861 /* Be GC protected. Set keyhint to item instead of tem. */
7864 else if (EQ (tem
, QCkeys
))
7867 if (CONSP (tem
) || (STRINGP (tem
) && NILP (cachelist
)))
7868 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7870 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7875 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7877 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7879 AREF (item_properties
, ITEM_PROPERTY_TYPE
)
7886 else if (inmenubar
|| !NILP (start
))
7890 return 0; /* not a menu item */
7892 /* If item string is not a string, evaluate it to get string.
7893 If we don't get a string, skip this item. */
7894 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7895 if (!(STRINGP (item_string
) || notreal
))
7897 item_string
= menu_item_eval_property (item_string
);
7898 if (!STRINGP (item_string
))
7900 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7903 /* If got a filter apply it on definition. */
7904 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7907 def
= menu_item_eval_property (list2 (XCAR (filter
),
7908 list2 (Qquote
, def
)));
7910 AREF (item_properties
, ITEM_PROPERTY_DEF
) = def
;
7913 /* Enable or disable selection of item. */
7914 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7920 tem
= menu_item_eval_property (tem
);
7921 if (inmenubar
&& NILP (tem
))
7922 return 0; /* Ignore disabled items in menu bar. */
7923 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7926 /* If we got no definition, this item is just unselectable text which
7927 is OK in a submenu but not in the menubar. */
7929 return (inmenubar
? 0 : 1);
7931 /* See if this is a separate pane or a submenu. */
7932 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7933 tem
= get_keymap (def
, 0, 1);
7934 /* For a subkeymap, just record its details and exit. */
7937 AREF (item_properties
, ITEM_PROPERTY_MAP
) = tem
;
7938 AREF (item_properties
, ITEM_PROPERTY_DEF
) = tem
;
7942 /* At the top level in the menu bar, do likewise for commands also.
7943 The menu bar does not display equivalent key bindings anyway.
7944 ITEM_PROPERTY_DEF is already set up properly. */
7948 /* This is a command. See if there is an equivalent key binding. */
7949 if (NILP (cachelist
))
7951 /* We have to create a cachelist. */
7952 CHECK_IMPURE (start
);
7953 XSETCDR (start
, Fcons (Fcons (Qnil
, Qnil
), XCDR (start
)));
7954 cachelist
= XCAR (XCDR (start
));
7956 tem
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7957 if (!NILP (keyhint
))
7959 XSETCAR (cachelist
, XCAR (keyhint
));
7962 else if (STRINGP (tem
))
7964 XSETCDR (cachelist
, Fsubstitute_command_keys (tem
));
7965 XSETCAR (cachelist
, Qt
);
7969 tem
= XCAR (cachelist
);
7976 tem
= Fkey_binding (tem
, Qnil
, Qnil
, Qnil
);
7978 prefix
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7981 def
= XCAR (prefix
);
7982 prefix
= XCDR (prefix
);
7985 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7987 if (NILP (XCAR (cachelist
))) /* Have no saved key. */
7989 if (newcache
/* Always check first time. */
7990 /* Should we check everything when precomputing key
7992 /* If something had no key binding before, don't recheck it
7993 because that is too slow--except if we have a list of
7994 rebound commands in Vdefine_key_rebound_commands, do
7995 recheck any command that appears in that list. */
7996 || (CONSP (Vdefine_key_rebound_commands
)
7997 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
))))
8000 /* We had a saved key. Is it still bound to the command? */
8003 /* If the command is an alias for another
8004 (such as lmenu.el set it up), check if the
8005 original command matches the cached command. */
8006 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
8007 chkcache
= 1; /* Need to recompute key binding. */
8011 /* Recompute equivalent key binding. If the command is an alias
8012 for another (such as lmenu.el set it up), see if the original
8013 command name has equivalent keys. Otherwise look up the
8014 specified command itself. We don't try both, because that
8015 makes lmenu menus slow. */
8017 && SYMBOLP (XSYMBOL (def
)->function
)
8018 && ! NILP (Fget (def
, Qmenu_alias
)))
8019 def
= XSYMBOL (def
)->function
;
8020 tem
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qt
);
8021 XSETCAR (cachelist
, tem
);
8024 XSETCDR (cachelist
, Qnil
);
8028 else if (!NILP (keyhint
) && !NILP (XCAR (cachelist
)))
8030 tem
= XCAR (cachelist
);
8034 newcache
= chkcache
;
8037 tem
= Fkey_description (tem
, Qnil
);
8040 if (STRINGP (XCAR (prefix
)))
8041 tem
= concat2 (XCAR (prefix
), tem
);
8042 if (STRINGP (XCDR (prefix
)))
8043 tem
= concat2 (tem
, XCDR (prefix
));
8045 XSETCDR (cachelist
, tem
);
8049 tem
= XCDR (cachelist
);
8050 if (newcache
&& !NILP (tem
))
8052 tem
= concat3 (build_string (" ("), tem
, build_string (")"));
8053 XSETCDR (cachelist
, tem
);
8056 /* If we only want to precompute equivalent key bindings, stop here. */
8060 /* If we have an equivalent key binding, use that. */
8061 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
8063 /* Include this when menu help is implemented.
8064 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
8065 if (!(NILP (tem) || STRINGP (tem)))
8067 tem = menu_item_eval_property (tem);
8070 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
8074 /* Handle radio buttons or toggle boxes. */
8075 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
8077 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
8078 = menu_item_eval_property (tem
);
8085 /***********************************************************************
8087 ***********************************************************************/
8089 /* A vector holding tool bar items while they are parsed in function
8090 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
8093 static Lisp_Object tool_bar_items_vector
;
8095 /* A vector holding the result of parse_tool_bar_item. Layout is like
8096 the one for a single item in tool_bar_items_vector. */
8098 static Lisp_Object tool_bar_item_properties
;
8100 /* Next free index in tool_bar_items_vector. */
8102 static int ntool_bar_items
;
8104 /* The symbols `tool-bar', `:image' and `:rtl'. */
8106 extern Lisp_Object Qtool_bar
;
8107 Lisp_Object QCimage
;
8110 /* Function prototypes. */
8112 static void init_tool_bar_items
P_ ((Lisp_Object
));
8113 static void process_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
8114 static int parse_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
8115 static void append_tool_bar_item
P_ ((void));
8118 /* Return a vector of tool bar items for keymaps currently in effect.
8119 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
8120 tool bar items found. */
8123 tool_bar_items (reuse
, nitems
)
8134 /* In order to build the menus, we need to call the keymap
8135 accessors. They all call QUIT. But this function is called
8136 during redisplay, during which a quit is fatal. So inhibit
8137 quitting while building the menus. We do this instead of
8138 specbind because (1) errors will clear it anyway and (2) this
8139 avoids risk of specpdl overflow. */
8140 oquit
= Vinhibit_quit
;
8143 /* Initialize tool_bar_items_vector and protect it from GC. */
8144 init_tool_bar_items (reuse
);
8146 /* Build list of keymaps in maps. Set nmaps to the number of maps
8149 /* Should overriding-terminal-local-map and overriding-local-map apply? */
8150 if (!NILP (Voverriding_local_map_menu_flag
))
8152 /* Yes, use them (if non-nil) as well as the global map. */
8153 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
8155 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
8156 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
8157 if (!NILP (Voverriding_local_map
))
8158 maps
[nmaps
++] = Voverriding_local_map
;
8162 /* No, so use major and minor mode keymaps and keymap property.
8163 Note that tool-bar bindings in the local-map and keymap
8164 properties may not work reliable, as they are only
8165 recognized when the tool-bar (or mode-line) is updated,
8166 which does not normally happen after every command. */
8169 nminor
= current_minor_maps (NULL
, &tmaps
);
8170 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
8172 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
8173 maps
[nmaps
++] = tem
;
8174 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
8176 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
8179 /* Add global keymap at the end. */
8180 maps
[nmaps
++] = current_global_map
;
8182 /* Process maps in reverse order and look up in each map the prefix
8184 for (i
= nmaps
- 1; i
>= 0; --i
)
8185 if (!NILP (maps
[i
]))
8189 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
8191 map_keymap (keymap
, process_tool_bar_item
, Qnil
, NULL
, 1);
8194 Vinhibit_quit
= oquit
;
8195 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
8196 return tool_bar_items_vector
;
8200 /* Process the definition of KEY which is DEF. */
8203 process_tool_bar_item (key
, def
, data
, args
)
8204 Lisp_Object key
, def
, data
;
8208 extern Lisp_Object Qundefined
;
8209 struct gcpro gcpro1
, gcpro2
;
8211 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
8215 if (EQ (def
, Qundefined
))
8217 /* If a map has an explicit `undefined' as definition,
8218 discard any previously made item. */
8219 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
8221 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
8223 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
8225 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
8226 bcopy (v
+ TOOL_BAR_ITEM_NSLOTS
, v
,
8227 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
8228 * sizeof (Lisp_Object
)));
8229 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
8234 else if (parse_tool_bar_item (key
, def
))
8235 /* Append a new tool bar item to tool_bar_items_vector. Accept
8236 more than one definition for the same key. */
8237 append_tool_bar_item ();
8243 /* Parse a tool bar item specification ITEM for key KEY and return the
8244 result in tool_bar_item_properties. Value is zero if ITEM is
8247 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
8249 CAPTION is the caption of the item, If it's not a string, it is
8250 evaluated to get a string.
8252 BINDING is the tool bar item's binding. Tool-bar items with keymaps
8253 as binding are currently ignored.
8255 The following properties are recognized:
8259 FORM is evaluated and specifies whether the tool bar item is
8260 enabled or disabled.
8264 FORM is evaluated and specifies whether the tool bar item is visible.
8266 - `:filter FUNCTION'
8268 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8269 result is stored as the new binding.
8271 - `:button (TYPE SELECTED)'
8273 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8274 and specifies whether the button is selected (pressed) or not.
8278 IMAGES is either a single image specification or a vector of four
8279 image specifications. See enum tool_bar_item_images.
8281 - `:help HELP-STRING'.
8283 Gives a help string to display for the tool bar item. */
8286 parse_tool_bar_item (key
, item
)
8287 Lisp_Object key
, item
;
8289 /* Access slot with index IDX of vector tool_bar_item_properties. */
8290 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
8292 Lisp_Object filter
= Qnil
;
8293 Lisp_Object caption
;
8296 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
8297 Rule out items that aren't lists, don't start with
8298 `menu-item' or whose rest following `tool-bar-item' is not a
8301 || !EQ (XCAR (item
), Qmenu_item
)
8302 || (item
= XCDR (item
),
8306 /* Create tool_bar_item_properties vector if necessary. Reset it to
8308 if (VECTORP (tool_bar_item_properties
))
8310 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
8314 tool_bar_item_properties
8315 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
8318 PROP (TOOL_BAR_ITEM_KEY
) = key
;
8319 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8321 /* Get the caption of the item. If the caption is not a string,
8322 evaluate it to get a string. If we don't get a string, skip this
8324 caption
= XCAR (item
);
8325 if (!STRINGP (caption
))
8327 caption
= menu_item_eval_property (caption
);
8328 if (!STRINGP (caption
))
8331 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
8333 /* Give up if rest following the caption is not a list. */
8338 /* Store the binding. */
8339 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
8342 /* Ignore cached key binding, if any. */
8343 if (CONSP (item
) && CONSP (XCAR (item
)))
8346 /* Process the rest of the properties. */
8347 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
8349 Lisp_Object key
, value
;
8352 value
= XCAR (XCDR (item
));
8354 if (EQ (key
, QCenable
))
8356 /* `:enable FORM'. */
8357 if (!NILP (Venable_disabled_menus_and_buttons
))
8358 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8360 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
8362 else if (EQ (key
, QCvisible
))
8364 /* `:visible FORM'. If got a visible property and that
8365 evaluates to nil then ignore this item. */
8366 if (NILP (menu_item_eval_property (value
)))
8369 else if (EQ (key
, QChelp
))
8370 /* `:help HELP-STRING'. */
8371 PROP (TOOL_BAR_ITEM_HELP
) = value
;
8372 else if (EQ (key
, QCfilter
))
8373 /* ':filter FORM'. */
8375 else if (EQ (key
, QCbutton
) && CONSP (value
))
8377 /* `:button (TYPE . SELECTED)'. */
8378 Lisp_Object type
, selected
;
8380 type
= XCAR (value
);
8381 selected
= XCDR (value
);
8382 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
8384 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
8385 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
8388 else if (EQ (key
, QCimage
)
8390 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
8391 /* Value is either a single image specification or a vector
8392 of 4 such specifications for the different button states. */
8393 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
8394 else if (EQ (key
, Qrtl
))
8396 PROP (TOOL_BAR_ITEM_RTL_IMAGE
) = value
;
8399 /* If got a filter apply it on binding. */
8401 PROP (TOOL_BAR_ITEM_BINDING
)
8402 = menu_item_eval_property (list2 (filter
,
8404 PROP (TOOL_BAR_ITEM_BINDING
))));
8406 /* See if the binding is a keymap. Give up if it is. */
8407 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
8410 /* Enable or disable selection of item. */
8411 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
8412 PROP (TOOL_BAR_ITEM_ENABLED_P
)
8413 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
8415 /* Handle radio buttons or toggle boxes. */
8416 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
8417 PROP (TOOL_BAR_ITEM_SELECTED_P
)
8418 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
8426 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8427 that can be reused. */
8430 init_tool_bar_items (reuse
)
8433 if (VECTORP (reuse
))
8434 tool_bar_items_vector
= reuse
;
8436 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
8437 ntool_bar_items
= 0;
8441 /* Append parsed tool bar item properties from
8442 tool_bar_item_properties */
8445 append_tool_bar_item ()
8447 Lisp_Object
*to
, *from
;
8449 /* Enlarge tool_bar_items_vector if necessary. */
8450 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
8451 >= XVECTOR (tool_bar_items_vector
)->size
)
8453 Lisp_Object new_vector
;
8454 int old_size
= XVECTOR (tool_bar_items_vector
)->size
;
8456 new_vector
= Fmake_vector (make_number (2 * old_size
), Qnil
);
8457 bcopy (XVECTOR (tool_bar_items_vector
)->contents
,
8458 XVECTOR (new_vector
)->contents
,
8459 old_size
* sizeof (Lisp_Object
));
8460 tool_bar_items_vector
= new_vector
;
8463 /* Append entries from tool_bar_item_properties to the end of
8464 tool_bar_items_vector. */
8465 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
8466 from
= XVECTOR (tool_bar_item_properties
)->contents
;
8467 bcopy (from
, to
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
8468 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
8475 /* Read a character using menus based on maps in the array MAPS.
8476 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
8477 Return t if we displayed a menu but the user rejected it.
8479 PREV_EVENT is the previous input event, or nil if we are reading
8480 the first event of a key sequence.
8482 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
8483 if we used a mouse menu to read the input, or zero otherwise. If
8484 USED_MOUSE_MENU is null, we don't dereference it.
8486 The prompting is done based on the prompt-string of the map
8487 and the strings associated with various map elements.
8489 This can be done with X menus or with menus put in the minibuf.
8490 These are done in different ways, depending on how the input will be read.
8491 Menus using X are done after auto-saving in read-char, getting the input
8492 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8493 and do auto-saving in the inner call of read_char. */
8496 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
8499 Lisp_Object prev_event
;
8500 int *used_mouse_menu
;
8503 register Lisp_Object name
= Qnil
;
8505 if (used_mouse_menu
)
8506 *used_mouse_menu
= 0;
8508 /* Use local over global Menu maps */
8510 if (! menu_prompting
)
8513 /* Optionally disregard all but the global map. */
8514 if (inhibit_local_menu_bar_menus
)
8516 maps
+= (nmaps
- 1);
8520 /* Get the menu name from the first map that has one (a prompt string). */
8521 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8523 name
= Fkeymap_prompt (maps
[mapno
]);
8528 /* If we don't have any menus, just read a character normally. */
8529 if (!STRINGP (name
))
8533 /* If we got to this point via a mouse click,
8534 use a real menu for mouse selection. */
8535 if (EVENT_HAS_PARAMETERS (prev_event
)
8536 && !EQ (XCAR (prev_event
), Qmenu_bar
)
8537 && !EQ (XCAR (prev_event
), Qtool_bar
))
8539 /* Display the menu and get the selection. */
8540 Lisp_Object
*realmaps
8541 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
8545 /* Use the maps that are not nil. */
8546 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8547 if (!NILP (maps
[mapno
]))
8548 realmaps
[nmaps1
++] = maps
[mapno
];
8550 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
8555 record_menu_key (XCAR (value
));
8557 /* If we got multiple events, unread all but
8559 There is no way to prevent those unread events
8560 from showing up later in last_nonmenu_event.
8561 So turn symbol and integer events into lists,
8562 to indicate that they came from a mouse menu,
8563 so that when present in last_nonmenu_event
8564 they won't confuse things. */
8565 for (tem
= XCDR (value
); !NILP (tem
); tem
= XCDR (tem
))
8567 record_menu_key (XCAR (tem
));
8568 if (SYMBOLP (XCAR (tem
))
8569 || INTEGERP (XCAR (tem
)))
8570 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
8573 /* If we got more than one event, put all but the first
8574 onto this list to be read later.
8575 Return just the first event now. */
8576 Vunread_command_events
8577 = nconc2 (XCDR (value
), Vunread_command_events
);
8578 value
= XCAR (value
);
8580 else if (NILP (value
))
8582 if (used_mouse_menu
)
8583 *used_mouse_menu
= 1;
8586 #endif /* HAVE_MENUS */
8590 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8591 We make this bigger when necessary, and never free it. */
8592 static char *read_char_minibuf_menu_text
;
8593 /* Size of that buffer. */
8594 static int read_char_minibuf_menu_width
;
8597 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
8603 register Lisp_Object name
;
8605 /* FIXME: Use the minibuffer's frame width. */
8606 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8609 Lisp_Object rest
, vector
;
8615 if (! menu_prompting
)
8618 /* Make sure we have a big enough buffer for the menu text. */
8619 if (read_char_minibuf_menu_text
== 0)
8621 read_char_minibuf_menu_width
= width
+ 4;
8622 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
8624 else if (width
+ 4 > read_char_minibuf_menu_width
)
8626 read_char_minibuf_menu_width
= width
+ 4;
8627 read_char_minibuf_menu_text
8628 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8630 menu
= read_char_minibuf_menu_text
;
8632 /* Get the menu name from the first map that has one (a prompt string). */
8633 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8635 name
= Fkeymap_prompt (maps
[mapno
]);
8640 /* If we don't have any menus, just read a character normally. */
8641 if (!STRINGP (name
))
8644 /* Prompt string always starts with map's prompt, and a space. */
8645 strcpy (menu
, SDATA (name
));
8646 nlength
= SBYTES (name
);
8647 menu
[nlength
++] = ':';
8648 menu
[nlength
++] = ' ';
8651 /* Start prompting at start of first map. */
8655 /* Present the documented bindings, a line at a time. */
8662 Lisp_Object orig_defn_macro
;
8664 /* Loop over elements of map. */
8669 /* If reached end of map, start at beginning of next map. */
8673 /* At end of last map, wrap around to first map if just starting,
8674 or end this line if already have something on it. */
8678 if (notfirst
|| nobindings
) break;
8683 /* Look at the next element of the map. */
8685 elt
= XVECTOR (vector
)->contents
[idx
];
8687 elt
= Fcar_safe (rest
);
8689 if (idx
< 0 && VECTORP (elt
))
8691 /* If we found a dense table in the keymap,
8692 advanced past it, but start scanning its contents. */
8693 rest
= Fcdr_safe (rest
);
8699 /* An ordinary element. */
8700 Lisp_Object event
, tem
;
8704 event
= Fcar_safe (elt
); /* alist */
8705 elt
= Fcdr_safe (elt
);
8709 XSETINT (event
, idx
); /* vector */
8712 /* Ignore the element if it has no prompt string. */
8713 if (INTEGERP (event
) && parse_menu_item (elt
, 0, -1))
8715 /* 1 if the char to type matches the string. */
8717 Lisp_Object upcased_event
, downcased_event
;
8718 Lisp_Object desc
= Qnil
;
8720 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8722 upcased_event
= Fupcase (event
);
8723 downcased_event
= Fdowncase (event
);
8724 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8725 || XINT (downcased_event
) == SREF (s
, 0));
8727 desc
= Fsingle_key_description (event
, Qnil
);
8729 #if 0 /* It is redundant to list the equivalent key bindings because
8730 the prefix is what the user has already typed. */
8732 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8734 /* Insert equivalent keybinding. */
8735 s
= concat2 (s
, tem
);
8738 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8739 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8741 /* Insert button prefix. */
8742 Lisp_Object selected
8743 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8744 if (EQ (tem
, QCradio
))
8745 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8747 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8748 s
= concat2 (tem
, s
);
8752 /* If we have room for the prompt string, add it to this line.
8753 If this is the first on the line, always add it. */
8754 if ((SCHARS (s
) + i
+ 2
8755 + (char_matches
? 0 : SCHARS (desc
) + 3))
8761 /* Punctuate between strings. */
8764 strcpy (menu
+ i
, ", ");
8770 /* If the char to type doesn't match the string's
8771 first char, explicitly show what char to type. */
8774 /* Add as much of string as fits. */
8775 thiswidth
= SCHARS (desc
);
8776 if (thiswidth
+ i
> width
)
8777 thiswidth
= width
- i
;
8778 bcopy (SDATA (desc
), menu
+ i
, thiswidth
);
8780 strcpy (menu
+ i
, " = ");
8784 /* Add as much of string as fits. */
8785 thiswidth
= SCHARS (s
);
8786 if (thiswidth
+ i
> width
)
8787 thiswidth
= width
- i
;
8788 bcopy (SDATA (s
), menu
+ i
, thiswidth
);
8794 /* If this element does not fit, end the line now,
8795 and save the element for the next line. */
8796 strcpy (menu
+ i
, "...");
8801 /* Move past this element. */
8802 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8803 /* Handle reaching end of dense table. */
8808 rest
= Fcdr_safe (rest
);
8812 /* Prompt with that and read response. */
8813 message2_nolog (menu
, strlen (menu
),
8814 ! NILP (current_buffer
->enable_multibyte_characters
));
8816 /* Make believe its not a keyboard macro in case the help char
8817 is pressed. Help characters are not recorded because menu prompting
8818 is not used on replay.
8820 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
8821 current_kboard
->defining_kbd_macro
= Qnil
;
8823 obj
= read_char (commandflag
, 0, 0, Qt
, 0, NULL
);
8824 while (BUFFERP (obj
));
8825 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
8827 if (!INTEGERP (obj
))
8829 else if (XINT (obj
) == -2)
8834 if (! EQ (obj
, menu_prompt_more_char
)
8835 && (!INTEGERP (menu_prompt_more_char
)
8836 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8838 if (!NILP (current_kboard
->defining_kbd_macro
))
8839 store_kbd_macro_char (obj
);
8842 /* Help char - go round again */
8846 /* Reading key sequences. */
8848 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8849 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8850 keymap, or nil otherwise. Return the index of the first keymap in
8851 which KEY has any binding, or NMAPS if no map has a binding.
8853 If KEY is a meta ASCII character, treat it like meta-prefix-char
8854 followed by the corresponding non-meta character. Keymaps in
8855 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8858 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8861 NEXT may be the same array as CURRENT. */
8864 follow_key (key
, nmaps
, current
, defs
, next
)
8866 Lisp_Object
*current
, *defs
, *next
;
8869 int i
, first_binding
;
8871 first_binding
= nmaps
;
8872 for (i
= nmaps
- 1; i
>= 0; i
--)
8874 if (! NILP (current
[i
]))
8876 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8877 if (! NILP (defs
[i
]))
8884 /* Given the set of bindings we've found, produce the next set of maps. */
8885 if (first_binding
< nmaps
)
8886 for (i
= 0; i
< nmaps
; i
++)
8887 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8889 return first_binding
;
8892 /* Structure used to keep track of partial application of key remapping
8893 such as Vfunction_key_map and Vkey_translation_map. */
8894 typedef struct keyremap
8896 /* This is the map originally specified for this use. */
8898 /* This is a submap reached by looking up, in PARENT,
8899 the events from START to END. */
8901 /* Positions [START, END) in the key sequence buffer
8902 are the key that we have scanned so far.
8903 Those events are the ones that we will replace
8904 if PAREHT maps them into a key sequence. */
8908 /* Lookup KEY in MAP.
8909 MAP is a keymap mapping keys to key vectors or functions.
8910 If the mapping is a function and DO_FUNCTION is non-zero, then
8911 the function is called with PROMPT as parameter and its return
8912 value is used as the return value of this function (after checking
8913 that it is indeed a vector). */
8916 access_keymap_keyremap (map
, key
, prompt
, do_funcall
)
8917 Lisp_Object map
, key
, prompt
;
8922 next
= access_keymap (map
, key
, 1, 0, 1);
8924 /* Handle symbol with autoload definition. */
8925 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8926 && CONSP (XSYMBOL (next
)->function
)
8927 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8928 do_autoload (XSYMBOL (next
)->function
, next
);
8930 /* Handle a symbol whose function definition is a keymap
8932 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8933 && (ARRAYP (XSYMBOL (next
)->function
)
8934 || KEYMAPP (XSYMBOL (next
)->function
)))
8935 next
= XSYMBOL (next
)->function
;
8937 /* If the keymap gives a function, not an
8938 array, then call the function with one arg and use
8939 its value instead. */
8940 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8945 next
= call1 (next
, prompt
);
8946 /* If the function returned something invalid,
8947 barf--don't ignore it.
8948 (To ignore it safely, we would need to gcpro a bunch of
8949 other variables.) */
8950 if (! (VECTORP (next
) || STRINGP (next
)))
8951 error ("Function %s returns invalid key sequence", tem
);
8956 /* Do one step of the key remapping used for function-key-map and
8957 key-translation-map:
8958 KEYBUF is the buffer holding the input events.
8959 BUFSIZE is its maximum size.
8960 FKEY is a pointer to the keyremap structure to use.
8961 INPUT is the index of the last element in KEYBUF.
8962 DOIT if non-zero says that the remapping can actually take place.
8963 DIFF is used to return the number of keys added/removed by the remapping.
8964 PARENT is the root of the keymap.
8965 PROMPT is the prompt to use if the remapping happens through a function.
8966 The return value is non-zero if the remapping actually took place. */
8969 keyremap_step (keybuf
, bufsize
, fkey
, input
, doit
, diff
, prompt
)
8970 Lisp_Object
*keybuf
, prompt
;
8972 int input
, doit
, *diff
, bufsize
;
8974 Lisp_Object next
, key
;
8976 key
= keybuf
[fkey
->end
++];
8978 if (KEYMAPP (fkey
->parent
))
8979 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
8983 /* If keybuf[fkey->start..fkey->end] is bound in the
8984 map and we're in a position to do the key remapping, replace it with
8985 the binding and restart with fkey->start at the end. */
8986 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
8988 int len
= XFASTINT (Flength (next
));
8991 *diff
= len
- (fkey
->end
- fkey
->start
);
8993 if (input
+ *diff
>= bufsize
)
8994 error ("Key sequence too long");
8996 /* Shift the keys that follow fkey->end. */
8998 for (i
= fkey
->end
; i
< input
; i
++)
8999 keybuf
[i
+ *diff
] = keybuf
[i
];
9001 for (i
= input
- 1; i
>= fkey
->end
; i
--)
9002 keybuf
[i
+ *diff
] = keybuf
[i
];
9003 /* Overwrite the old keys with the new ones. */
9004 for (i
= 0; i
< len
; i
++)
9005 keybuf
[fkey
->start
+ i
]
9006 = Faref (next
, make_number (i
));
9008 fkey
->start
= fkey
->end
+= *diff
;
9009 fkey
->map
= fkey
->parent
;
9014 fkey
->map
= get_keymap (next
, 0, 1);
9016 /* If we no longer have a bound suffix, try a new position for
9018 if (!CONSP (fkey
->map
))
9020 fkey
->end
= ++fkey
->start
;
9021 fkey
->map
= fkey
->parent
;
9026 /* Read a sequence of keys that ends with a non prefix character,
9027 storing it in KEYBUF, a buffer of size BUFSIZE.
9029 Return the length of the key sequence stored.
9030 Return -1 if the user rejected a command menu.
9032 Echo starting immediately unless `prompt' is 0.
9034 Where a key sequence ends depends on the currently active keymaps.
9035 These include any minor mode keymaps active in the current buffer,
9036 the current buffer's local map, and the global map.
9038 If a key sequence has no other bindings, we check Vfunction_key_map
9039 to see if some trailing subsequence might be the beginning of a
9040 function key's sequence. If so, we try to read the whole function
9041 key, and substitute its symbolic name into the key sequence.
9043 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
9044 `double-' events into similar click events, if that would make them
9045 bound. We try to turn `triple-' events first into `double-' events,
9048 If we get a mouse click in a mode line, vertical divider, or other
9049 non-text area, we treat the click as if it were prefixed by the
9050 symbol denoting that area - `mode-line', `vertical-line', or
9053 If the sequence starts with a mouse click, we read the key sequence
9054 with respect to the buffer clicked on, not the current buffer.
9056 If the user switches frames in the midst of a key sequence, we put
9057 off the switch-frame event until later; the next call to
9058 read_char will return it.
9060 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
9061 from the selected window's buffer. */
9064 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
9065 can_return_switch_frame
, fix_current_buffer
)
9066 Lisp_Object
*keybuf
;
9069 int dont_downcase_last
;
9070 int can_return_switch_frame
;
9071 int fix_current_buffer
;
9073 volatile Lisp_Object from_string
;
9074 volatile int count
= SPECPDL_INDEX ();
9076 /* How many keys there are in the current key sequence. */
9079 /* The length of the echo buffer when we started reading, and
9080 the length of this_command_keys when we started reading. */
9081 volatile int echo_start
;
9082 volatile int keys_start
;
9084 /* The number of keymaps we're scanning right now, and the number of
9085 keymaps we have allocated space for. */
9087 volatile int nmaps_allocated
= 0;
9089 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
9090 the current keymaps. */
9091 Lisp_Object
*volatile defs
= NULL
;
9093 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
9094 in the current keymaps, or nil where it is not a prefix. */
9095 Lisp_Object
*volatile submaps
= NULL
;
9097 /* The local map to start out with at start of key sequence. */
9098 volatile Lisp_Object orig_local_map
;
9100 /* The map from the `keymap' property to start out with at start of
9102 volatile Lisp_Object orig_keymap
;
9104 /* 1 if we have already considered switching to the local-map property
9105 of the place where a mouse click occurred. */
9106 volatile int localized_local_map
= 0;
9108 /* The index in submaps[] of the first keymap that has a binding for
9109 this key sequence. In other words, the lowest i such that
9110 submaps[i] is non-nil. */
9111 volatile int first_binding
;
9112 /* Index of the first key that has no binding.
9113 It is useless to try fkey.start larger than that. */
9114 volatile int first_unbound
;
9116 /* If t < mock_input, then KEYBUF[t] should be read as the next
9119 We use this to recover after recognizing a function key. Once we
9120 realize that a suffix of the current key sequence is actually a
9121 function key's escape sequence, we replace the suffix with the
9122 function key's binding from Vfunction_key_map. Now keybuf
9123 contains a new and different key sequence, so the echo area,
9124 this_command_keys, and the submaps and defs arrays are wrong. In
9125 this situation, we set mock_input to t, set t to 0, and jump to
9126 restart_sequence; the loop will read keys from keybuf up until
9127 mock_input, thus rebuilding the state; and then it will resume
9128 reading characters from the keyboard. */
9129 volatile int mock_input
= 0;
9131 /* If the sequence is unbound in submaps[], then
9132 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
9133 and fkey.map is its binding.
9135 These might be > t, indicating that all function key scanning
9136 should hold off until t reaches them. We do this when we've just
9137 recognized a function key, to avoid searching for the function
9138 key's again in Vfunction_key_map. */
9139 volatile keyremap fkey
;
9141 /* Likewise, for key_translation_map. */
9142 volatile keyremap keytran
;
9144 /* If we receive a `switch-frame' or `select-window' event in the middle of
9145 a key sequence, we put it off for later.
9146 While we're reading, we keep the event here. */
9147 volatile Lisp_Object delayed_switch_frame
;
9149 /* See the comment below... */
9150 #if defined (GOBBLE_FIRST_EVENT)
9151 Lisp_Object first_event
;
9154 volatile Lisp_Object original_uppercase
;
9155 volatile int original_uppercase_position
= -1;
9157 /* Gets around Microsoft compiler limitations. */
9160 struct buffer
*starting_buffer
;
9162 /* List of events for which a fake prefix key has been generated. */
9163 volatile Lisp_Object fake_prefixed_keys
= Qnil
;
9165 #if defined (GOBBLE_FIRST_EVENT)
9169 struct gcpro gcpro1
;
9171 GCPRO1 (fake_prefixed_keys
);
9172 raw_keybuf_count
= 0;
9174 last_nonmenu_event
= Qnil
;
9176 delayed_switch_frame
= Qnil
;
9181 echo_prompt (prompt
);
9182 else if (cursor_in_echo_area
9183 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9184 && NILP (Fzerop (Vecho_keystrokes
)))
9185 /* This doesn't put in a dash if the echo buffer is empty, so
9186 you don't always see a dash hanging out in the minibuffer. */
9190 /* Record the initial state of the echo area and this_command_keys;
9191 we will need to restore them if we replay a key sequence. */
9193 echo_start
= echo_length ();
9194 keys_start
= this_command_key_count
;
9195 this_single_command_key_start
= keys_start
;
9197 #if defined (GOBBLE_FIRST_EVENT)
9198 /* This doesn't quite work, because some of the things that read_char
9199 does cannot safely be bypassed. It seems too risky to try to make
9202 /* Read the first char of the sequence specially, before setting
9203 up any keymaps, in case a filter runs and switches buffers on us. */
9204 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
9206 #endif /* GOBBLE_FIRST_EVENT */
9208 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9209 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9212 /* We jump here when the key sequence has been thoroughly changed, and
9213 we need to rescan it starting from the beginning. When we jump here,
9214 keybuf[0..mock_input] holds the sequence we should reread. */
9217 /* We may switch keyboards between rescans, so we need to
9218 reinitialize fkey and keytran before each replay. */
9219 fkey
.map
= fkey
.parent
= current_kboard
->Vlocal_function_key_map
;
9220 keytran
.map
= keytran
.parent
= current_kboard
->Vlocal_key_translation_map
;
9221 fkey
.start
= fkey
.end
= 0;
9222 keytran
.start
= keytran
.end
= 0;
9224 starting_buffer
= current_buffer
;
9225 first_unbound
= bufsize
+ 1;
9227 /* Build our list of keymaps.
9228 If we recognize a function key and replace its escape sequence in
9229 keybuf with its symbol, or if the sequence starts with a mouse
9230 click and we need to switch buffers, we jump back here to rebuild
9231 the initial keymaps from the current buffer. */
9234 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
9236 if (2 > nmaps_allocated
)
9238 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9239 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9240 nmaps_allocated
= 2;
9242 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
9243 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
9245 else if (!NILP (Voverriding_local_map
))
9247 if (2 > nmaps_allocated
)
9249 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9250 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9251 nmaps_allocated
= 2;
9253 if (!NILP (Voverriding_local_map
))
9254 submaps
[nmaps
++] = Voverriding_local_map
;
9262 nminor
= current_minor_maps (0, &maps
);
9263 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
9265 if (total
> nmaps_allocated
)
9267 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
9268 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
9269 nmaps_allocated
= total
;
9272 if (!NILP (orig_keymap
))
9273 submaps
[nmaps
++] = orig_keymap
;
9275 bcopy (maps
, (void *) (submaps
+ nmaps
),
9276 nminor
* sizeof (submaps
[0]));
9280 submaps
[nmaps
++] = orig_local_map
;
9282 submaps
[nmaps
++] = current_global_map
;
9284 /* Find an accurate initial value for first_binding. */
9285 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
9286 if (! NILP (submaps
[first_binding
]))
9289 /* Start from the beginning in keybuf. */
9292 /* These are no-ops the first time through, but if we restart, they
9293 revert the echo area and this_command_keys to their original state. */
9294 this_command_key_count
= keys_start
;
9295 if (INTERACTIVE
&& t
< mock_input
)
9296 echo_truncate (echo_start
);
9298 /* If the best binding for the current key sequence is a keymap, or
9299 we may be looking at a function key's escape sequence, keep on
9301 while (first_binding
< nmaps
9302 /* Keep reading as long as there's a prefix binding. */
9303 ? !NILP (submaps
[first_binding
])
9304 /* Don't return in the middle of a possible function key sequence,
9305 if the only bindings we found were via case conversion.
9306 Thus, if ESC O a has a function-key-map translation
9307 and ESC o has a binding, don't return after ESC O,
9308 so that we can translate ESC O plus the next character. */
9309 : (fkey
.start
< t
|| keytran
.start
< t
))
9312 int used_mouse_menu
= 0;
9314 /* Where the last real key started. If we need to throw away a
9315 key that has expanded into more than one element of keybuf
9316 (say, a mouse click on the mode line which is being treated
9317 as [mode-line (mouse-...)], then we backtrack to this point
9319 volatile int last_real_key_start
;
9321 /* These variables are analogous to echo_start and keys_start;
9322 while those allow us to restart the entire key sequence,
9323 echo_local_start and keys_local_start allow us to throw away
9325 volatile int echo_local_start
, keys_local_start
, local_first_binding
;
9327 eassert (fkey
.end
== t
|| (fkey
.end
> t
&& fkey
.end
<= mock_input
));
9328 eassert (fkey
.start
<= fkey
.end
);
9329 eassert (keytran
.start
<= keytran
.end
);
9330 /* key-translation-map is applied *after* function-key-map. */
9331 eassert (keytran
.end
<= fkey
.start
);
9333 if (first_unbound
< fkey
.start
&& first_unbound
< keytran
.start
)
9334 { /* The prefix upto first_unbound has no binding and has
9335 no translation left to do either, so we know it's unbound.
9336 If we don't stop now, we risk staying here indefinitely
9337 (if the user keeps entering fkey or keytran prefixes
9338 like C-c ESC ESC ESC ESC ...) */
9340 for (i
= first_unbound
+ 1; i
< t
; i
++)
9341 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
9342 mock_input
= t
- first_unbound
- 1;
9343 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
9344 fkey
.map
= fkey
.parent
;
9345 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
9346 keytran
.map
= keytran
.parent
;
9347 goto replay_sequence
;
9351 error ("Key sequence too long");
9354 echo_local_start
= echo_length ();
9355 keys_local_start
= this_command_key_count
;
9356 local_first_binding
= first_binding
;
9359 /* These are no-ops, unless we throw away a keystroke below and
9360 jumped back up to replay_key; in that case, these restore the
9361 variables to their original state, allowing us to replay the
9363 if (INTERACTIVE
&& t
< mock_input
)
9364 echo_truncate (echo_local_start
);
9365 this_command_key_count
= keys_local_start
;
9366 first_binding
= local_first_binding
;
9368 /* By default, assume each event is "real". */
9369 last_real_key_start
= t
;
9371 /* Does mock_input indicate that we are re-reading a key sequence? */
9375 add_command_key (key
);
9376 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9377 && NILP (Fzerop (Vecho_keystrokes
)))
9381 /* If not, we should actually read a character. */
9386 KBOARD
*interrupted_kboard
= current_kboard
;
9387 struct frame
*interrupted_frame
= SELECTED_FRAME ();
9389 key
= read_char (NILP (prompt
), nmaps
,
9390 (Lisp_Object
*) submaps
, last_nonmenu_event
,
9391 &used_mouse_menu
, NULL
);
9393 if (INTEGERP (key
) && XINT (key
) == -2) /* wrong_kboard_jmpbuf */
9398 for (k
= all_kboards
; k
; k
= k
->next_kboard
)
9399 if (k
== interrupted_kboard
)
9404 /* Don't touch interrupted_kboard when it's been
9406 delayed_switch_frame
= Qnil
;
9407 goto replay_sequence
;
9410 if (!NILP (delayed_switch_frame
))
9412 interrupted_kboard
->kbd_queue
9413 = Fcons (delayed_switch_frame
,
9414 interrupted_kboard
->kbd_queue
);
9415 delayed_switch_frame
= Qnil
;
9419 interrupted_kboard
->kbd_queue
9420 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
9422 /* If the side queue is non-empty, ensure it begins with a
9423 switch-frame, so we'll replay it in the right context. */
9424 if (CONSP (interrupted_kboard
->kbd_queue
)
9425 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
9426 !(EVENT_HAS_PARAMETERS (key
)
9427 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
9431 XSETFRAME (frame
, interrupted_frame
);
9432 interrupted_kboard
->kbd_queue
9433 = Fcons (make_lispy_switch_frame (frame
),
9434 interrupted_kboard
->kbd_queue
);
9437 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9438 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9439 goto replay_sequence
;
9444 /* read_char returns t when it shows a menu and the user rejects it.
9448 unbind_to (count
, Qnil
);
9453 /* read_char returns -1 at the end of a macro.
9454 Emacs 18 handles this by returning immediately with a
9455 zero, so that's what we'll do. */
9456 if (INTEGERP (key
) && XINT (key
) == -1)
9459 /* The Microsoft C compiler can't handle the goto that
9465 /* If the current buffer has been changed from under us, the
9466 keymap may have changed, so replay the sequence. */
9469 timer_resume_idle ();
9472 /* Reset the current buffer from the selected window
9473 in case something changed the former and not the latter.
9474 This is to be more consistent with the behavior
9475 of the command_loop_1. */
9476 if (fix_current_buffer
)
9478 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9480 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
9481 Fset_buffer (XWINDOW (selected_window
)->buffer
);
9484 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9485 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9486 goto replay_sequence
;
9489 /* If we have a quit that was typed in another frame, and
9490 quit_throw_to_read_char switched buffers,
9491 replay to get the right keymap. */
9493 && XINT (key
) == quit_char
9494 && current_buffer
!= starting_buffer
)
9497 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9501 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9502 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9503 goto replay_sequence
;
9508 if (EVENT_HAS_PARAMETERS (key
)
9509 /* Either a `switch-frame' or a `select-window' event. */
9510 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
9512 /* If we're at the beginning of a key sequence, and the caller
9513 says it's okay, go ahead and return this event. If we're
9514 in the midst of a key sequence, delay it until the end. */
9515 if (t
> 0 || !can_return_switch_frame
)
9517 delayed_switch_frame
= key
;
9523 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9526 /* Clicks in non-text areas get prefixed by the symbol
9527 in their CHAR-ADDRESS field. For example, a click on
9528 the mode line is prefixed by the symbol `mode-line'.
9530 Furthermore, key sequences beginning with mouse clicks
9531 are read using the keymaps of the buffer clicked on, not
9532 the current buffer. So we may have to switch the buffer
9535 When we turn one event into two events, we must make sure
9536 that neither of the two looks like the original--so that,
9537 if we replay the events, they won't be expanded again.
9538 If not for this, such reexpansion could happen either here
9539 or when user programs play with this-command-keys. */
9540 if (EVENT_HAS_PARAMETERS (key
))
9545 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
9546 if (EQ (kind
, Qmouse_click
))
9548 Lisp_Object window
, posn
;
9550 window
= POSN_WINDOW (EVENT_START (key
));
9551 posn
= POSN_POSN (EVENT_START (key
));
9554 || (!NILP (fake_prefixed_keys
)
9555 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
9557 /* We're looking a second time at an event for which
9558 we generated a fake prefix key. Set
9559 last_real_key_start appropriately. */
9561 last_real_key_start
= t
- 1;
9564 /* Key sequences beginning with mouse clicks are
9565 read using the keymaps in the buffer clicked on,
9566 not the current buffer. If we're at the
9567 beginning of a key sequence, switch buffers. */
9568 if (last_real_key_start
== 0
9570 && BUFFERP (XWINDOW (window
)->buffer
)
9571 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
9573 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9577 /* Arrange to go back to the original buffer once we're
9578 done reading the key sequence. Note that we can't
9579 use save_excursion_{save,restore} here, because they
9580 save point as well as the current buffer; we don't
9581 want to save point, because redisplay may change it,
9582 to accommodate a Fset_window_start or something. We
9583 don't want to do this at the top of the function,
9584 because we may get input from a subprocess which
9585 wants to change the selected window and stuff (say,
9587 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
9589 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9591 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
9592 orig_local_map
= get_local_map (PT
, current_buffer
,
9594 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9595 goto replay_sequence
;
9598 /* For a mouse click, get the local text-property keymap
9599 of the place clicked on, rather than point. */
9600 if (last_real_key_start
== 0
9601 && CONSP (XCDR (key
))
9602 && ! localized_local_map
)
9604 Lisp_Object map_here
, start
, pos
;
9606 localized_local_map
= 1;
9607 start
= EVENT_START (key
);
9609 if (CONSP (start
) && POSN_INBUFFER_P (start
))
9611 pos
= POSN_BUFFER_POSN (start
);
9613 && XINT (pos
) >= BEGV
9614 && XINT (pos
) <= ZV
)
9616 map_here
= get_local_map (XINT (pos
),
9617 current_buffer
, Qlocal_map
);
9618 if (!EQ (map_here
, orig_local_map
))
9620 orig_local_map
= map_here
;
9621 ++localized_local_map
;
9624 map_here
= get_local_map (XINT (pos
),
9625 current_buffer
, Qkeymap
);
9626 if (!EQ (map_here
, orig_keymap
))
9628 orig_keymap
= map_here
;
9629 ++localized_local_map
;
9632 if (localized_local_map
> 1)
9637 goto replay_sequence
;
9643 /* Expand mode-line and scroll-bar events into two events:
9644 use posn as a fake prefix key. */
9646 && (NILP (fake_prefixed_keys
)
9647 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9649 if (t
+ 1 >= bufsize
)
9650 error ("Key sequence too long");
9653 keybuf
[t
+ 1] = key
;
9656 /* Record that a fake prefix key has been generated
9657 for KEY. Don't modify the event; this would
9658 prevent proper action when the event is pushed
9659 back into unread-command-events. */
9660 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9662 /* If on a mode line string with a local keymap,
9663 reconsider the key sequence with that keymap. */
9664 if (string
= POSN_STRING (EVENT_START (key
)),
9665 (CONSP (string
) && STRINGP (XCAR (string
))))
9667 Lisp_Object pos
, map
, map2
;
9669 pos
= XCDR (string
);
9670 string
= XCAR (string
);
9672 && XINT (pos
) < SCHARS (string
))
9674 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9676 orig_local_map
= map
;
9677 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9680 if (!NILP (map
) || !NILP (map2
))
9681 goto replay_sequence
;
9687 else if (NILP (from_string
)
9688 && (string
= POSN_STRING (EVENT_START (key
)),
9689 (CONSP (string
) && STRINGP (XCAR (string
)))))
9691 /* For a click on a string, i.e. overlay string or a
9692 string displayed via the `display' property,
9693 consider `local-map' and `keymap' properties of
9695 Lisp_Object pos
, map
, map2
;
9697 pos
= XCDR (string
);
9698 string
= XCAR (string
);
9700 && XINT (pos
) < SCHARS (string
))
9702 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9704 orig_local_map
= map
;
9705 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9709 if (!NILP (map
) || !NILP (map2
))
9711 from_string
= string
;
9714 goto replay_sequence
;
9719 else if (CONSP (XCDR (key
))
9720 && CONSP (EVENT_START (key
))
9721 && CONSP (XCDR (EVENT_START (key
))))
9725 posn
= POSN_POSN (EVENT_START (key
));
9726 /* Handle menu-bar events:
9727 insert the dummy prefix event `menu-bar'. */
9728 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9730 if (t
+ 1 >= bufsize
)
9731 error ("Key sequence too long");
9735 /* Zap the position in key, so we know that we've
9736 expanded it, and don't try to do so again. */
9737 POSN_SET_POSN (EVENT_START (key
),
9738 Fcons (posn
, Qnil
));
9741 goto replay_sequence
;
9743 else if (CONSP (posn
))
9745 /* We're looking at the second event of a
9746 sequence which we expanded before. Set
9747 last_real_key_start appropriately. */
9748 if (last_real_key_start
== t
&& t
> 0)
9749 last_real_key_start
= t
- 1;
9754 /* We have finally decided that KEY is something we might want
9756 first_binding
= (follow_key (key
,
9757 nmaps
- first_binding
,
9758 submaps
+ first_binding
,
9759 defs
+ first_binding
,
9760 submaps
+ first_binding
)
9763 /* If KEY wasn't bound, we'll try some fallbacks. */
9764 if (first_binding
< nmaps
)
9765 /* This is needed for the following scenario:
9766 event 0: a down-event that gets dropped by calling replay_key.
9767 event 1: some normal prefix like C-h.
9768 After event 0, first_unbound is 0, after event 1 fkey.start
9769 and keytran.start are both 1, so when we see that C-h is bound,
9770 we need to update first_unbound. */
9771 first_unbound
= max (t
+ 1, first_unbound
);
9776 /* Remember the position to put an upper bound on fkey.start. */
9777 first_unbound
= min (t
, first_unbound
);
9779 head
= EVENT_HEAD (key
);
9780 if (help_char_p (head
) && t
> 0)
9782 read_key_sequence_cmd
= Vprefix_help_command
;
9784 last_nonmenu_event
= key
;
9785 /* The Microsoft C compiler can't handle the goto that
9793 Lisp_Object breakdown
;
9796 breakdown
= parse_modifiers (head
);
9797 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9798 /* Attempt to reduce an unbound mouse event to a simpler
9799 event that is bound:
9800 Drags reduce to clicks.
9801 Double-clicks reduce to clicks.
9802 Triple-clicks reduce to double-clicks, then to clicks.
9803 Down-clicks are eliminated.
9804 Double-downs reduce to downs, then are eliminated.
9805 Triple-downs reduce to double-downs, then to downs,
9806 then are eliminated. */
9807 if (modifiers
& (down_modifier
| drag_modifier
9808 | double_modifier
| triple_modifier
))
9810 while (modifiers
& (down_modifier
| drag_modifier
9811 | double_modifier
| triple_modifier
))
9813 Lisp_Object new_head
, new_click
;
9814 if (modifiers
& triple_modifier
)
9815 modifiers
^= (double_modifier
| triple_modifier
);
9816 else if (modifiers
& double_modifier
)
9817 modifiers
&= ~double_modifier
;
9818 else if (modifiers
& drag_modifier
)
9819 modifiers
&= ~drag_modifier
;
9822 /* Dispose of this `down' event by simply jumping
9823 back to replay_key, to get another event.
9825 Note that if this event came from mock input,
9826 then just jumping back to replay_key will just
9827 hand it to us again. So we have to wipe out any
9830 We could delete keybuf[t] and shift everything
9831 after that to the left by one spot, but we'd also
9832 have to fix up any variable that points into
9833 keybuf, and shifting isn't really necessary
9836 Adding prefixes for non-textual mouse clicks
9837 creates two characters of mock input, and both
9838 must be thrown away. If we're only looking at
9839 the prefix now, we can just jump back to
9840 replay_key. On the other hand, if we've already
9841 processed the prefix, and now the actual click
9842 itself is giving us trouble, then we've lost the
9843 state of the keymaps we want to backtrack to, and
9844 we need to replay the whole sequence to rebuild
9847 Beyond that, only function key expansion could
9848 create more than two keys, but that should never
9849 generate mouse events, so it's okay to zero
9850 mock_input in that case too.
9852 FIXME: The above paragraph seems just plain
9853 wrong, if you consider things like
9854 xterm-mouse-mode. -stef
9856 Isn't this just the most wonderful code ever? */
9858 /* If mock_input > t + 1, the above simplification
9859 will actually end up dropping keys on the floor.
9860 This is probably OK for now, but even
9861 if mock_input <= t + 1, we need to adjust fkey
9863 Typical case [header-line down-mouse-N]:
9864 mock_input = 2, t = 1, fkey.end = 1,
9865 last_real_key_start = 0. */
9866 if (fkey
.end
> last_real_key_start
)
9868 fkey
.end
= fkey
.start
9869 = min (last_real_key_start
, fkey
.start
);
9870 fkey
.map
= fkey
.parent
;
9871 if (keytran
.end
> last_real_key_start
)
9873 keytran
.end
= keytran
.start
9874 = min (last_real_key_start
, keytran
.start
);
9875 keytran
.map
= keytran
.parent
;
9878 if (t
== last_real_key_start
)
9885 mock_input
= last_real_key_start
;
9886 goto replay_sequence
;
9891 = apply_modifiers (modifiers
, XCAR (breakdown
));
9893 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9895 /* Look for a binding for this new key. follow_key
9896 promises that it didn't munge submaps the
9897 last time we called it, since key was unbound. */
9899 = (follow_key (new_click
,
9900 nmaps
- local_first_binding
,
9901 submaps
+ local_first_binding
,
9902 defs
+ local_first_binding
,
9903 submaps
+ local_first_binding
)
9904 + local_first_binding
);
9906 /* If that click is bound, go for it. */
9907 if (first_binding
< nmaps
)
9912 /* Otherwise, we'll leave key set to the drag event. */
9919 /* Normally, last_nonmenu_event gets the previous key we read.
9920 But when a mouse popup menu is being used,
9921 we don't update last_nonmenu_event; it continues to hold the mouse
9922 event that preceded the first level of menu. */
9923 if (!used_mouse_menu
)
9924 last_nonmenu_event
= key
;
9926 /* Record what part of this_command_keys is the current key sequence. */
9927 this_single_command_key_start
= this_command_key_count
- t
;
9929 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
]))
9930 /* There is a binding and it's not a prefix.
9931 There is thus no function-key in this sequence.
9932 Moving fkey.start is important in this case to allow keytran.start
9933 to go over the sequence before we return (since we keep the
9934 invariant that keytran.end <= fkey.start). */
9937 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
9940 /* If the sequence is unbound, see if we can hang a function key
9941 off the end of it. */
9942 /* Continue scan from fkey.end until we find a bound suffix. */
9943 while (fkey
.end
< t
)
9945 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9948 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9949 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
9950 max (t
, mock_input
),
9951 /* If there's a binding (i.e.
9952 first_binding >= nmaps) we don't want
9953 to apply this function-key-mapping. */
9954 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
9959 mock_input
= diff
+ max (t
, mock_input
);
9960 goto replay_sequence
;
9964 /* Look for this sequence in key-translation-map.
9965 Scan from keytran.end until we find a bound suffix. */
9966 while (keytran
.end
< fkey
.start
)
9968 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9971 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9972 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
9977 mock_input
= diff
+ max (t
, mock_input
);
9978 /* Adjust the function-key-map counters. */
9982 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 an upper case letter
9989 use the corresponding lower-case letter instead. */
9990 if (first_binding
>= nmaps
9991 && fkey
.start
>= t
&& keytran
.start
>= t
9993 && ((((XINT (key
) & 0x3ffff)
9994 < XCHAR_TABLE (current_buffer
->downcase_table
)->size
)
9995 && UPPERCASEP (XINT (key
) & 0x3ffff))
9996 || (XINT (key
) & shift_modifier
)))
9998 Lisp_Object new_key
;
10000 original_uppercase
= key
;
10001 original_uppercase_position
= t
- 1;
10003 if (XINT (key
) & shift_modifier
)
10004 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
10006 XSETINT (new_key
, (DOWNCASE (XINT (key
) & 0x3ffff)
10007 | (XINT (key
) & ~0x3ffff)));
10009 /* We have to do this unconditionally, regardless of whether
10010 the lower-case char is defined in the keymaps, because they
10011 might get translated through function-key-map. */
10012 keybuf
[t
- 1] = new_key
;
10013 mock_input
= max (t
, mock_input
);
10015 goto replay_sequence
;
10017 /* If KEY is not defined in any of the keymaps,
10018 and cannot be part of a function key or translation,
10019 and is a shifted function key,
10020 use the corresponding unshifted function key instead. */
10021 if (first_binding
>= nmaps
10022 && fkey
.start
>= t
&& keytran
.start
>= t
10025 Lisp_Object breakdown
;
10028 breakdown
= parse_modifiers (key
);
10029 modifiers
= XINT (XCAR (XCDR (breakdown
)));
10030 if (modifiers
& shift_modifier
)
10032 Lisp_Object new_key
;
10034 original_uppercase
= key
;
10035 original_uppercase_position
= t
- 1;
10037 modifiers
&= ~shift_modifier
;
10038 new_key
= apply_modifiers (modifiers
,
10041 keybuf
[t
- 1] = new_key
;
10042 mock_input
= max (t
, mock_input
);
10043 fkey
.start
= fkey
.end
= 0;
10044 keytran
.start
= keytran
.end
= 0;
10046 goto replay_sequence
;
10052 read_key_sequence_cmd
= (first_binding
< nmaps
10053 ? defs
[first_binding
]
10056 unread_switch_frame
= delayed_switch_frame
;
10057 unbind_to (count
, Qnil
);
10059 /* Don't downcase the last character if the caller says don't.
10060 Don't downcase it if the result is undefined, either. */
10061 if ((dont_downcase_last
|| first_binding
>= nmaps
)
10063 && t
- 1 == original_uppercase_position
)
10064 keybuf
[t
- 1] = original_uppercase
;
10066 /* Occasionally we fabricate events, perhaps by expanding something
10067 according to function-key-map, or by adding a prefix symbol to a
10068 mouse click in the scroll bar or modeline. In this cases, return
10069 the entire generated key sequence, even if we hit an unbound
10070 prefix or a definition before the end. This means that you will
10071 be able to push back the event properly, and also means that
10072 read-key-sequence will always return a logical unit.
10075 for (; t
< mock_input
; t
++)
10077 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
10078 && NILP (Fzerop (Vecho_keystrokes
)))
10079 echo_char (keybuf
[t
]);
10080 add_command_key (keybuf
[t
]);
10089 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
10090 doc
: /* Read a sequence of keystrokes and return as a string or vector.
10091 The sequence is sufficient to specify a non-prefix command in the
10092 current local and global maps.
10094 First arg PROMPT is a prompt string. If nil, do not prompt specially.
10095 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
10096 as a continuation of the previous key.
10098 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
10099 convert the last event to lower case. (Normally any upper case event
10100 is converted to lower case if the original event is undefined and the lower
10101 case equivalent is defined.) A non-nil value is appropriate for reading
10102 a key sequence to be defined.
10104 A C-g typed while in this function is treated like any other character,
10105 and `quit-flag' is not set.
10107 If the key sequence starts with a mouse click, then the sequence is read
10108 using the keymaps of the buffer of the window clicked in, not the buffer
10109 of the selected window as normal.
10111 `read-key-sequence' drops unbound button-down events, since you normally
10112 only care about the click or drag events which follow them. If a drag
10113 or multi-click event is unbound, but the corresponding click event would
10114 be bound, `read-key-sequence' turns the event into a click event at the
10115 drag's starting position. This means that you don't have to distinguish
10116 between click and drag, double, or triple events unless you want to.
10118 `read-key-sequence' prefixes mouse events on mode lines, the vertical
10119 lines separating windows, and scroll bars with imaginary keys
10120 `mode-line', `vertical-line', and `vertical-scroll-bar'.
10122 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
10123 function will process a switch-frame event if the user switches frames
10124 before typing anything. If the user switches frames in the middle of a
10125 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
10126 is nil, then the event will be put off until after the current key sequence.
10128 `read-key-sequence' checks `function-key-map' for function key
10129 sequences, where they wouldn't conflict with ordinary bindings. See
10130 `function-key-map' for more details.
10132 The optional fifth argument COMMAND-LOOP, if non-nil, means
10133 that this key sequence is being read by something that will
10134 read commands one after another. It should be nil if the caller
10135 will read just one key sequence. */)
10136 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
10138 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
10139 Lisp_Object can_return_switch_frame
, command_loop
;
10141 Lisp_Object keybuf
[30];
10143 struct gcpro gcpro1
;
10144 int count
= SPECPDL_INDEX ();
10146 if (!NILP (prompt
))
10147 CHECK_STRING (prompt
);
10150 specbind (Qinput_method_exit_on_first_char
,
10151 (NILP (command_loop
) ? Qt
: Qnil
));
10152 specbind (Qinput_method_use_echo_area
,
10153 (NILP (command_loop
) ? Qt
: Qnil
));
10155 bzero (keybuf
, sizeof keybuf
);
10156 GCPRO1 (keybuf
[0]);
10157 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10159 if (NILP (continue_echo
))
10161 this_command_key_count
= 0;
10162 this_command_key_count_reset
= 0;
10163 this_single_command_key_start
= 0;
10166 #ifdef HAVE_X_WINDOWS
10167 if (display_hourglass_p
)
10168 cancel_hourglass ();
10171 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10172 prompt
, ! NILP (dont_downcase_last
),
10173 ! NILP (can_return_switch_frame
), 0);
10175 #if 0 /* The following is fine for code reading a key sequence and
10176 then proceeding with a lenghty computation, but it's not good
10177 for code reading keys in a loop, like an input method. */
10178 #ifdef HAVE_X_WINDOWS
10179 if (display_hourglass_p
)
10180 start_hourglass ();
10190 return unbind_to (count
, make_event_array (i
, keybuf
));
10193 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
10194 Sread_key_sequence_vector
, 1, 5, 0,
10195 doc
: /* Like `read-key-sequence' but always return a vector. */)
10196 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
10198 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
10199 Lisp_Object can_return_switch_frame
, command_loop
;
10201 Lisp_Object keybuf
[30];
10203 struct gcpro gcpro1
;
10204 int count
= SPECPDL_INDEX ();
10206 if (!NILP (prompt
))
10207 CHECK_STRING (prompt
);
10210 specbind (Qinput_method_exit_on_first_char
,
10211 (NILP (command_loop
) ? Qt
: Qnil
));
10212 specbind (Qinput_method_use_echo_area
,
10213 (NILP (command_loop
) ? Qt
: Qnil
));
10215 bzero (keybuf
, sizeof keybuf
);
10216 GCPRO1 (keybuf
[0]);
10217 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10219 if (NILP (continue_echo
))
10221 this_command_key_count
= 0;
10222 this_command_key_count_reset
= 0;
10223 this_single_command_key_start
= 0;
10226 #ifdef HAVE_X_WINDOWS
10227 if (display_hourglass_p
)
10228 cancel_hourglass ();
10231 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10232 prompt
, ! NILP (dont_downcase_last
),
10233 ! NILP (can_return_switch_frame
), 0);
10235 #ifdef HAVE_X_WINDOWS
10236 if (display_hourglass_p
)
10237 start_hourglass ();
10246 return unbind_to (count
, Fvector (i
, keybuf
));
10249 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
10250 doc
: /* Execute CMD as an editor command.
10251 CMD must be a symbol that satisfies the `commandp' predicate.
10252 Optional second arg RECORD-FLAG non-nil
10253 means unconditionally put this command in `command-history'.
10254 Otherwise, that is done only if an arg is read using the minibuffer.
10255 The argument KEYS specifies the value to use instead of (this-command-keys)
10256 when reading the arguments; if it is nil, (this-command-keys) is used.
10257 The argument SPECIAL, if non-nil, means that this command is executing
10258 a special event, so ignore the prefix argument and don't clear it. */)
10259 (cmd
, record_flag
, keys
, special
)
10260 Lisp_Object cmd
, record_flag
, keys
, special
;
10262 register Lisp_Object final
;
10263 register Lisp_Object tem
;
10264 Lisp_Object prefixarg
;
10265 struct backtrace backtrace
;
10266 extern int debug_on_next_call
;
10268 debug_on_next_call
= 0;
10270 if (NILP (special
))
10272 prefixarg
= current_kboard
->Vprefix_arg
;
10273 Vcurrent_prefix_arg
= prefixarg
;
10274 current_kboard
->Vprefix_arg
= Qnil
;
10281 tem
= Fget (cmd
, Qdisabled
);
10282 if (!NILP (tem
) && !NILP (Vrun_hooks
))
10284 tem
= Fsymbol_value (Qdisabled_command_function
);
10286 return call1 (Vrun_hooks
, Qdisabled_command_function
);
10292 final
= Findirect_function (cmd
, Qnil
);
10294 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
10296 struct gcpro gcpro1
, gcpro2
;
10298 GCPRO2 (cmd
, prefixarg
);
10299 do_autoload (final
, cmd
);
10306 if (STRINGP (final
) || VECTORP (final
))
10308 /* If requested, place the macro in the command history. For
10309 other sorts of commands, call-interactively takes care of
10311 if (!NILP (record_flag
))
10314 = Fcons (Fcons (Qexecute_kbd_macro
,
10315 Fcons (final
, Fcons (prefixarg
, Qnil
))),
10318 /* Don't keep command history around forever. */
10319 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
10321 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
10323 XSETCDR (tem
, Qnil
);
10327 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
10330 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
10332 backtrace
.next
= backtrace_list
;
10333 backtrace_list
= &backtrace
;
10334 backtrace
.function
= &Qcall_interactively
;
10335 backtrace
.args
= &cmd
;
10336 backtrace
.nargs
= 1;
10337 backtrace
.evalargs
= 0;
10338 backtrace
.debug_on_exit
= 0;
10340 tem
= Fcall_interactively (cmd
, record_flag
, keys
);
10342 backtrace_list
= backtrace
.next
;
10350 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
10352 doc
: /* Read function name, then read its arguments and call it.
10354 To pass a numeric argument to the command you are invoking with, specify
10355 the numeric argument to this command.
10357 Noninteractively, the argument PREFIXARG is the prefix argument to
10358 give to the command you invoke, if it asks for an argument. */)
10360 Lisp_Object prefixarg
;
10362 Lisp_Object function
;
10364 int saved_last_point_position
;
10365 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
10366 Lisp_Object bindings
, value
;
10367 struct gcpro gcpro1
, gcpro2
, gcpro3
;
10368 #ifdef HAVE_X_WINDOWS
10369 /* The call to Fcompleting_read wil start and cancel the hourglass,
10370 but if the hourglass was already scheduled, this means that no
10371 hourglass will be shown for the actual M-x command itself.
10372 So we restart it if it is already scheduled. Note that checking
10373 hourglass_shown_p is not enough, normally the hourglass is not shown,
10374 just scheduled to be shown. */
10375 int hstarted
= hourglass_started ();
10378 saved_keys
= Fvector (this_command_key_count
,
10379 XVECTOR (this_command_keys
)->contents
);
10380 saved_last_point_position_buffer
= last_point_position_buffer
;
10381 saved_last_point_position
= last_point_position
;
10383 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
10385 if (EQ (prefixarg
, Qminus
))
10386 strcpy (buf
, "- ");
10387 else if (CONSP (prefixarg
) && XINT (XCAR (prefixarg
)) == 4)
10388 strcpy (buf
, "C-u ");
10389 else if (CONSP (prefixarg
) && INTEGERP (XCAR (prefixarg
)))
10390 sprintf (buf
, "%ld ", (long) XINT (XCAR (prefixarg
)));
10391 else if (INTEGERP (prefixarg
))
10392 sprintf (buf
, "%ld ", (long) XINT (prefixarg
));
10394 /* This isn't strictly correct if execute-extended-command
10395 is bound to anything else. Perhaps it should use
10396 this_command_keys? */
10397 strcat (buf
, "M-x ");
10399 /* Prompt with buf, and then read a string, completing from and
10400 restricting to the set of all defined commands. Don't provide
10401 any initial input. Save the command read on the extended-command
10403 function
= Fcompleting_read (build_string (buf
),
10404 Vobarray
, Qcommandp
,
10405 Qt
, Qnil
, Qextended_command_history
, Qnil
,
10408 #ifdef HAVE_X_WINDOWS
10409 if (hstarted
) start_hourglass ();
10412 if (STRINGP (function
) && SCHARS (function
) == 0)
10413 error ("No command name given");
10415 /* Set this_command_keys to the concatenation of saved_keys and
10416 function, followed by a RET. */
10421 this_command_key_count
= 0;
10422 this_command_key_count_reset
= 0;
10423 this_single_command_key_start
= 0;
10425 keys
= XVECTOR (saved_keys
)->contents
;
10426 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
10427 add_command_key (keys
[i
]);
10429 for (i
= 0; i
< SCHARS (function
); i
++)
10430 add_command_key (Faref (function
, make_number (i
)));
10432 add_command_key (make_number ('\015'));
10435 last_point_position
= saved_last_point_position
;
10436 last_point_position_buffer
= saved_last_point_position_buffer
;
10440 function
= Fintern (function
, Qnil
);
10441 current_kboard
->Vprefix_arg
= prefixarg
;
10442 Vthis_command
= function
;
10443 real_this_command
= function
;
10445 /* If enabled, show which key runs this command. */
10446 if (!NILP (Vsuggest_key_bindings
)
10447 && NILP (Vexecuting_kbd_macro
)
10448 && SYMBOLP (function
))
10449 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
10455 GCPRO2 (bindings
, value
);
10456 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
10458 /* If the command has a key binding, print it now. */
10459 if (!NILP (bindings
)
10460 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
10463 /* But first wait, and skip the message if there is input. */
10464 Lisp_Object waited
;
10466 /* If this command displayed something in the echo area;
10467 wait a few seconds, then display our suggestion message. */
10468 if (NILP (echo_area_buffer
[0]))
10469 waited
= sit_for (make_number (0), 0, 2);
10470 else if (NUMBERP (Vsuggest_key_bindings
))
10471 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10473 waited
= sit_for (make_number (2), 0, 2);
10475 if (!NILP (waited
) && ! CONSP (Vunread_command_events
))
10477 Lisp_Object binding
;
10479 int message_p
= push_message ();
10480 int count
= SPECPDL_INDEX ();
10482 record_unwind_protect (pop_message_unwind
, Qnil
);
10483 binding
= Fkey_description (bindings
, Qnil
);
10486 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
10489 sprintf (newmessage
, "You can run the command `%s' with %s",
10490 SDATA (SYMBOL_NAME (function
)),
10492 message2_nolog (newmessage
,
10493 strlen (newmessage
),
10494 STRING_MULTIBYTE (binding
));
10495 if (NUMBERP (Vsuggest_key_bindings
))
10496 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10498 waited
= sit_for (make_number (2), 0, 2);
10500 if (!NILP (waited
) && message_p
)
10501 restore_message ();
10503 unbind_to (count
, Qnil
);
10507 RETURN_UNGCPRO (value
);
10511 /* Return nonzero if input events are pending. */
10514 detect_input_pending ()
10516 if (!input_pending
)
10517 get_input_pending (&input_pending
, 0);
10519 return input_pending
;
10522 /* Return nonzero if input events other than mouse movements are
10526 detect_input_pending_ignore_squeezables ()
10528 if (!input_pending
)
10529 get_input_pending (&input_pending
, READABLE_EVENTS_IGNORE_SQUEEZABLES
);
10531 return input_pending
;
10534 /* Return nonzero if input events are pending, and run any pending timers. */
10537 detect_input_pending_run_timers (do_display
)
10540 int old_timers_run
= timers_run
;
10542 if (!input_pending
)
10543 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
10545 if (old_timers_run
!= timers_run
&& do_display
)
10547 redisplay_preserve_echo_area (8);
10548 /* The following fixes a bug when using lazy-lock with
10549 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
10550 from an idle timer function. The symptom of the bug is that
10551 the cursor sometimes doesn't become visible until the next X
10552 event is processed. --gerd. */
10554 Lisp_Object tail
, frame
;
10555 FOR_EACH_FRAME (tail
, frame
)
10556 if (FRAME_RIF (XFRAME (frame
)))
10557 FRAME_RIF (XFRAME (frame
))->flush_display (XFRAME (frame
));
10561 return input_pending
;
10564 /* This is called in some cases before a possible quit.
10565 It cases the next call to detect_input_pending to recompute input_pending.
10566 So calling this function unnecessarily can't do any harm. */
10569 clear_input_pending ()
10574 /* Return nonzero if there are pending requeued events.
10575 This isn't used yet. The hope is to make wait_reading_process_output
10576 call it, and return if it runs Lisp code that unreads something.
10577 The problem is, kbd_buffer_get_event needs to be fixed to know what
10578 to do in that case. It isn't trivial. */
10581 requeued_events_pending_p ()
10583 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
10587 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
10588 doc
: /* Return t if command input is currently available with no wait.
10589 Actually, the value is nil only if we can be sure that no input is available;
10590 if there is a doubt, the value is t. */)
10593 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1
10594 || !NILP (Vunread_post_input_method_events
)
10595 || !NILP (Vunread_input_method_events
))
10598 get_input_pending (&input_pending
,
10599 READABLE_EVENTS_DO_TIMERS_NOW
10600 | READABLE_EVENTS_FILTER_EVENTS
);
10601 return input_pending
> 0 ? Qt
: Qnil
;
10604 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
10605 doc
: /* Return vector of last 300 events, not counting those from keyboard macros. */)
10608 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
10611 if (total_keys
< NUM_RECENT_KEYS
)
10612 return Fvector (total_keys
, keys
);
10615 val
= Fvector (NUM_RECENT_KEYS
, keys
);
10616 bcopy (keys
+ recent_keys_index
,
10617 XVECTOR (val
)->contents
,
10618 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
10620 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
10621 recent_keys_index
* sizeof (Lisp_Object
));
10626 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
10627 doc
: /* Return the key sequence that invoked this command.
10628 However, if the command has called `read-key-sequence', it returns
10629 the last key sequence that has been read.
10630 The value is a string or a vector.
10632 See also `this-command-keys-vector'. */)
10635 return make_event_array (this_command_key_count
,
10636 XVECTOR (this_command_keys
)->contents
);
10639 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
10640 doc
: /* Return the key sequence that invoked this command, as a vector.
10641 However, if the command has called `read-key-sequence', it returns
10642 the last key sequence that has been read.
10644 See also `this-command-keys'. */)
10647 return Fvector (this_command_key_count
,
10648 XVECTOR (this_command_keys
)->contents
);
10651 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
10652 Sthis_single_command_keys
, 0, 0, 0,
10653 doc
: /* Return the key sequence that invoked this command.
10654 More generally, it returns the last key sequence read, either by
10655 the command loop or by `read-key-sequence'.
10656 Unlike `this-command-keys', this function's value
10657 does not include prefix arguments.
10658 The value is always a vector. */)
10661 return Fvector (this_command_key_count
10662 - this_single_command_key_start
,
10663 (XVECTOR (this_command_keys
)->contents
10664 + this_single_command_key_start
));
10667 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
10668 Sthis_single_command_raw_keys
, 0, 0, 0,
10669 doc
: /* Return the raw events that were read for this command.
10670 More generally, it returns the last key sequence read, either by
10671 the command loop or by `read-key-sequence'.
10672 Unlike `this-single-command-keys', this function's value
10673 shows the events before all translations (except for input methods).
10674 The value is always a vector. */)
10677 return Fvector (raw_keybuf_count
,
10678 (XVECTOR (raw_keybuf
)->contents
));
10681 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10682 Sreset_this_command_lengths
, 0, 0, 0,
10683 doc
: /* Make the unread events replace the last command and echo.
10684 Used in `universal-argument-other-key'.
10686 `universal-argument-other-key' rereads the event just typed.
10687 It then gets translated through `function-key-map'.
10688 The translated event has to replace the real events,
10689 both in the value of (this-command-keys) and in echoing.
10690 To achieve this, `universal-argument-other-key' calls
10691 `reset-this-command-lengths', which discards the record of reading
10692 these events the first time. */)
10695 this_command_key_count
= before_command_key_count
;
10696 if (this_command_key_count
< this_single_command_key_start
)
10697 this_single_command_key_start
= this_command_key_count
;
10699 echo_truncate (before_command_echo_length
);
10701 /* Cause whatever we put into unread-command-events
10702 to echo as if it were being freshly read from the keyboard. */
10703 this_command_key_count_reset
= 1;
10708 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10709 Sclear_this_command_keys
, 0, 1, 0,
10710 doc
: /* Clear out the vector that `this-command-keys' returns.
10711 Also clear the record of the last 100 events, unless optional arg
10712 KEEP-RECORD is non-nil. */)
10714 Lisp_Object keep_record
;
10718 this_command_key_count
= 0;
10719 this_command_key_count_reset
= 0;
10721 if (NILP (keep_record
))
10723 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10724 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10726 recent_keys_index
= 0;
10731 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10732 doc
: /* Return the current depth in recursive edits. */)
10736 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10740 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10741 "FOpen dribble file: ",
10742 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10743 If FILE is nil, close any open dribble file. */)
10756 file
= Fexpand_file_name (file
, Qnil
);
10757 dribble
= fopen (SDATA (file
), "w");
10759 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10764 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10765 doc
: /* Discard the contents of the terminal input buffer.
10766 Also end any kbd macro being defined. */)
10769 if (!NILP (current_kboard
->defining_kbd_macro
))
10771 /* Discard the last command from the macro. */
10772 Fcancel_kbd_macro_events ();
10776 update_mode_lines
++;
10778 Vunread_command_events
= Qnil
;
10779 unread_command_char
= -1;
10781 discard_tty_input ();
10783 kbd_fetch_ptr
= kbd_store_ptr
;
10789 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10790 doc
: /* Stop Emacs and return to superior process. You can resume later.
10791 If `cannot-suspend' is non-nil, or if the system doesn't support job
10792 control, run a subshell instead.
10794 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10795 to be read as terminal input by Emacs's parent, after suspension.
10797 Before suspending, run the normal hook `suspend-hook'.
10798 After resumption run the normal hook `suspend-resume-hook'.
10800 Some operating systems cannot stop the Emacs process and resume it later.
10801 On such systems, Emacs starts a subshell instead of suspending. */)
10803 Lisp_Object stuffstring
;
10805 int count
= SPECPDL_INDEX ();
10806 int old_height
, old_width
;
10808 struct gcpro gcpro1
;
10810 if (tty_list
&& tty_list
->next
)
10811 error ("There are other tty frames open; close them before suspending Emacs");
10813 if (!NILP (stuffstring
))
10814 CHECK_STRING (stuffstring
);
10816 /* Run the functions in suspend-hook. */
10817 if (!NILP (Vrun_hooks
))
10818 call1 (Vrun_hooks
, intern ("suspend-hook"));
10820 GCPRO1 (stuffstring
);
10821 get_tty_size (fileno (CURTTY ()->input
), &old_width
, &old_height
);
10822 reset_all_sys_modes ();
10823 /* sys_suspend can get an error if it tries to fork a subshell
10824 and the system resources aren't available for that. */
10825 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object
))) init_all_sys_modes
,
10827 stuff_buffered_input (stuffstring
);
10828 if (cannot_suspend
)
10832 unbind_to (count
, Qnil
);
10834 /* Check if terminal/window size has changed.
10835 Note that this is not useful when we are running directly
10836 with a window system; but suspend should be disabled in that case. */
10837 get_tty_size (fileno (CURTTY ()->input
), &width
, &height
);
10838 if (width
!= old_width
|| height
!= old_height
)
10839 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10841 /* Run suspend-resume-hook. */
10842 if (!NILP (Vrun_hooks
))
10843 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
10849 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10850 Then in any case stuff anything Emacs has read ahead and not used. */
10853 stuff_buffered_input (stuffstring
)
10854 Lisp_Object stuffstring
;
10856 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
10857 register unsigned char *p
;
10859 if (STRINGP (stuffstring
))
10861 register int count
;
10863 p
= SDATA (stuffstring
);
10864 count
= SBYTES (stuffstring
);
10865 while (count
-- > 0)
10870 /* Anything we have read ahead, put back for the shell to read. */
10871 /* ?? What should this do when we have multiple keyboards??
10872 Should we ignore anything that was typed in at the "wrong" kboard?
10874 rms: we should stuff everything back into the kboard
10876 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10879 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10880 kbd_fetch_ptr
= kbd_buffer
;
10881 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10882 stuff_char (kbd_fetch_ptr
->code
);
10884 clear_event (kbd_fetch_ptr
);
10888 #endif /* SIGTSTP */
10892 set_waiting_for_input (time_to_clear
)
10893 EMACS_TIME
*time_to_clear
;
10895 input_available_clear_time
= time_to_clear
;
10897 /* Tell handle_interrupt to throw back to read_char, */
10898 waiting_for_input
= 1;
10900 /* If handle_interrupt was called before and buffered a C-g,
10901 make it run again now, to avoid timing error. */
10902 if (!NILP (Vquit_flag
))
10903 quit_throw_to_read_char ();
10907 clear_waiting_for_input ()
10909 /* Tell handle_interrupt not to throw back to read_char, */
10910 waiting_for_input
= 0;
10911 input_available_clear_time
= 0;
10914 /* The SIGINT handler.
10916 If we have a frame on the controlling tty, we assume that the
10917 SIGINT was generated by C-g, so we call handle_interrupt.
10918 Otherwise, the handler kills Emacs. */
10921 interrupt_signal (signalnum
) /* If we don't have an argument, */
10922 int signalnum
; /* some compilers complain in signal calls. */
10924 /* Must preserve main program's value of errno. */
10925 int old_errno
= errno
;
10926 struct terminal
*terminal
;
10928 #if defined (USG) && !defined (POSIX_SIGNALS)
10929 /* USG systems forget handlers when they are used;
10930 must reestablish each time */
10931 signal (SIGINT
, interrupt_signal
);
10932 signal (SIGQUIT
, interrupt_signal
);
10935 SIGNAL_THREAD_CHECK (signalnum
);
10937 /* See if we have an active terminal on our controlling tty. */
10938 terminal
= get_named_tty ("/dev/tty");
10941 /* If there are no frames there, let's pretend that we are a
10942 well-behaving UN*X program and quit. */
10943 Fkill_emacs (Qnil
);
10947 /* Otherwise, the SIGINT was probably generated by C-g. */
10949 /* Set internal_last_event_frame to the top frame of the
10950 controlling tty, if we have a frame there. We disable the
10951 interrupt key on secondary ttys, so the SIGINT must have come
10952 from the controlling tty. */
10953 internal_last_event_frame
= terminal
->display_info
.tty
->top_frame
;
10955 handle_interrupt ();
10961 /* This routine is called at interrupt level in response to C-g.
10963 It is called from the SIGINT handler or kbd_buffer_store_event.
10965 If `waiting_for_input' is non zero, then unless `echoing' is
10966 nonzero, immediately throw back to read_char.
10968 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10969 eval to throw, when it gets a chance. If quit-flag is already
10970 non-nil, it stops the job right away. */
10973 handle_interrupt ()
10979 /* XXX This code needs to be revised for multi-tty support. */
10980 if (!NILP (Vquit_flag
)
10982 && get_named_tty ("/dev/tty")
10986 /* If SIGINT isn't blocked, don't let us be interrupted by
10987 another SIGINT, it might be harmful due to non-reentrancy
10988 in I/O functions. */
10989 sigblock (sigmask (SIGINT
));
10992 reset_all_sys_modes ();
10994 #ifdef SIGTSTP /* Support possible in later USG versions */
10996 * On systems which can suspend the current process and return to the original
10997 * shell, this command causes the user to end up back at the shell.
10998 * The "Auto-save" and "Abort" questions are not asked until
10999 * the user elects to return to emacs, at which point he can save the current
11000 * job and either dump core or continue.
11005 if (sys_suspend () == -1)
11007 printf ("Not running as a subprocess;\n");
11008 printf ("you can continue or abort.\n");
11010 #else /* not VMS */
11011 /* Perhaps should really fork an inferior shell?
11012 But that would not provide any way to get back
11013 to the original shell, ever. */
11014 printf ("No support for stopping a process on this operating system;\n");
11015 printf ("you can continue or abort.\n");
11016 #endif /* not VMS */
11017 #endif /* not SIGTSTP */
11019 /* We must remain inside the screen area when the internal terminal
11020 is used. Note that [Enter] is not echoed by dos. */
11023 /* It doesn't work to autosave while GC is in progress;
11024 the code used for auto-saving doesn't cope with the mark bit. */
11025 if (!gc_in_progress
)
11027 printf ("Auto-save? (y or n) ");
11029 if (((c
= getchar ()) & ~040) == 'Y')
11031 Fdo_auto_save (Qt
, Qnil
);
11033 printf ("\r\nAuto-save done");
11034 #else /* not MSDOS */
11035 printf ("Auto-save done\n");
11036 #endif /* not MSDOS */
11038 while (c
!= '\n') c
= getchar ();
11042 /* During GC, it must be safe to reenable quitting again. */
11043 Vinhibit_quit
= Qnil
;
11046 #endif /* not MSDOS */
11047 printf ("Garbage collection in progress; cannot auto-save now\r\n");
11048 printf ("but will instead do a real quit after garbage collection ends\r\n");
11053 printf ("\r\nAbort? (y or n) ");
11054 #else /* not MSDOS */
11056 printf ("Abort (and enter debugger)? (y or n) ");
11057 #else /* not VMS */
11058 printf ("Abort (and dump core)? (y or n) ");
11059 #endif /* not VMS */
11060 #endif /* not MSDOS */
11062 if (((c
= getchar ()) & ~040) == 'Y')
11064 while (c
!= '\n') c
= getchar ();
11066 printf ("\r\nContinuing...\r\n");
11067 #else /* not MSDOS */
11068 printf ("Continuing...\n");
11069 #endif /* not MSDOS */
11071 init_all_sys_modes ();
11076 /* If executing a function that wants to be interrupted out of
11077 and the user has not deferred quitting by binding `inhibit-quit'
11078 then quit right away. */
11079 if (immediate_quit
&& NILP (Vinhibit_quit
))
11081 struct gl_state_s saved
;
11082 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
11084 immediate_quit
= 0;
11087 GCPRO4 (saved
.object
, saved
.global_code
,
11088 saved
.current_syntax_table
, saved
.old_prop
);
11089 Fsignal (Qquit
, Qnil
);
11094 /* Else request quit when it's safe */
11098 if (waiting_for_input
&& !echoing
)
11099 quit_throw_to_read_char ();
11102 /* Handle a C-g by making read_char return C-g. */
11105 quit_throw_to_read_char ()
11108 /* Prevent another signal from doing this before we finish. */
11109 clear_waiting_for_input ();
11112 Vunread_command_events
= Qnil
;
11113 unread_command_char
= -1;
11115 #if 0 /* Currently, sit_for is called from read_char without turning
11116 off polling. And that can call set_waiting_for_input.
11117 It seems to be harmless. */
11118 #ifdef POLL_FOR_INPUT
11119 /* May be > 1 if in recursive minibuffer. */
11120 if (poll_suppress_count
== 0)
11124 if (FRAMEP (internal_last_event_frame
)
11125 && !EQ (internal_last_event_frame
, selected_frame
))
11126 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
11129 _longjmp (getcjmp
, 1);
11132 DEFUN ("set-input-interrupt-mode", Fset_input_interrupt_mode
, Sset_input_interrupt_mode
, 1, 1, 0,
11133 doc
: /* Set interrupt mode of reading keyboard input.
11134 If INTERRUPT is non-nil, Emacs will use input interrupts;
11135 otherwise Emacs uses CBREAK mode.
11137 See also `current-input-mode'. */)
11139 Lisp_Object interrupt
;
11141 int new_interrupt_input
;
11143 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11144 #ifdef HAVE_X_WINDOWS
11145 if (x_display_list
!= NULL
)
11147 /* When using X, don't give the user a real choice,
11148 because we haven't implemented the mechanisms to support it. */
11149 #ifdef NO_SOCK_SIGIO
11150 new_interrupt_input
= 0;
11151 #else /* not NO_SOCK_SIGIO */
11152 new_interrupt_input
= 1;
11153 #endif /* NO_SOCK_SIGIO */
11157 new_interrupt_input
= !NILP (interrupt
);
11158 #else /* not SIGIO */
11159 new_interrupt_input
= 0;
11160 #endif /* not SIGIO */
11162 /* Our VMS input only works by interrupts, as of now. */
11164 new_interrupt_input
= 1;
11167 if (new_interrupt_input
!= interrupt_input
)
11169 #ifdef POLL_FOR_INPUT
11173 /* this causes startup screen to be restored and messes with the mouse */
11174 reset_all_sys_modes ();
11176 interrupt_input
= new_interrupt_input
;
11178 init_all_sys_modes ();
11181 #ifdef POLL_FOR_INPUT
11182 poll_suppress_count
= 1;
11189 DEFUN ("set-output-flow-control", Fset_output_flow_control
, Sset_output_flow_control
, 1, 2, 0,
11190 doc
: /* Enable or disable ^S/^Q flow control for output to TERMINAL.
11191 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
11192 C-q in key sequences.
11194 This setting only has an effect on tty terminals and only when
11195 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
11197 See also `current-input-mode'. */)
11199 Lisp_Object flow
, terminal
;
11201 struct terminal
*t
= get_terminal (terminal
, 1);
11202 struct tty_display_info
*tty
;
11203 if (t
== NULL
|| t
->type
!= output_termcap
)
11205 tty
= t
->display_info
.tty
;
11207 if (tty
->flow_control
!= !NILP (flow
))
11210 /* this causes startup screen to be restored and messes with the mouse */
11211 reset_sys_modes (tty
);
11214 tty
->flow_control
= !NILP (flow
);
11217 init_sys_modes (tty
);
11223 DEFUN ("set-input-meta-mode", Fset_input_meta_mode
, Sset_input_meta_mode
, 1, 2, 0,
11224 doc
: /* Enable or disable 8-bit input on TERMINAL.
11225 If META is t, Emacs will accept 8-bit input, and interpret the 8th
11226 bit as the Meta modifier.
11228 If META is nil, Emacs will ignore the top bit, on the assumption it is
11231 Otherwise, Emacs will accept and pass through 8-bit input without
11232 specially interpreting the top bit.
11234 This setting only has an effect on tty terminal devices.
11236 Optional parameter TERMINAL specifies the tty terminal device to use.
11237 It may be a terminal id, a frame, or nil for the terminal used by the
11238 currently selected frame.
11240 See also `current-input-mode'. */)
11242 Lisp_Object meta
, terminal
;
11244 struct terminal
*t
= get_terminal (terminal
, 1);
11245 struct tty_display_info
*tty
;
11248 if (t
== NULL
|| t
->type
!= output_termcap
)
11250 tty
= t
->display_info
.tty
;
11254 else if (EQ (meta
, Qt
))
11259 if (tty
->meta_key
!= new_meta
)
11262 /* this causes startup screen to be restored and messes with the mouse */
11263 reset_sys_modes (tty
);
11266 tty
->meta_key
= new_meta
;
11269 init_sys_modes (tty
);
11275 DEFUN ("set-quit-char", Fset_quit_char
, Sset_quit_char
, 1, 1, 0,
11276 doc
: /* Specify character used for quitting.
11277 QUIT must be an ASCII character.
11279 This function only has an effect on the controlling tty of the Emacs
11282 See also `current-input-mode'. */)
11286 struct terminal
*t
= get_named_tty ("/dev/tty");
11287 struct tty_display_info
*tty
;
11288 if (t
== NULL
|| t
->type
!= output_termcap
)
11290 tty
= t
->display_info
.tty
;
11292 if (NILP (quit
) || !INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400)
11293 error ("QUIT must be an ASCII character");
11296 /* this causes startup screen to be restored and messes with the mouse */
11297 reset_sys_modes (tty
);
11300 /* Don't let this value be out of range. */
11301 quit_char
= XINT (quit
) & (tty
->meta_key
== 0 ? 0177 : 0377);
11304 init_sys_modes (tty
);
11310 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
11311 doc
: /* Set mode of reading keyboard input.
11312 First arg INTERRUPT non-nil means use input interrupts;
11313 nil means use CBREAK mode.
11314 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
11315 (no effect except in CBREAK mode).
11316 Third arg META t means accept 8-bit input (for a Meta key).
11317 META nil means ignore the top bit, on the assumption it is parity.
11318 Otherwise, accept 8-bit input and don't use the top bit for Meta.
11319 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
11320 See also `current-input-mode'. */)
11321 (interrupt
, flow
, meta
, quit
)
11322 Lisp_Object interrupt
, flow
, meta
, quit
;
11324 Fset_input_interrupt_mode (interrupt
);
11325 Fset_output_flow_control (flow
, Qnil
);
11326 Fset_input_meta_mode (meta
, Qnil
);
11328 Fset_quit_char (quit
);
11332 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
11333 doc
: /* Return information about the way Emacs currently reads keyboard input.
11334 The value is a list of the form (INTERRUPT FLOW META QUIT), where
11335 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
11336 nil, Emacs is using CBREAK mode.
11337 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
11338 terminal; this does not apply if Emacs uses interrupt-driven input.
11339 META is t if accepting 8-bit input with 8th bit as Meta flag.
11340 META nil means ignoring the top bit, on the assumption it is parity.
11341 META is neither t nor nil if accepting 8-bit input and using
11342 all 8 bits as the character code.
11343 QUIT is the character Emacs currently uses to quit.
11344 The elements of this list correspond to the arguments of
11345 `set-input-mode'. */)
11348 Lisp_Object val
[4];
11349 struct frame
*sf
= XFRAME (selected_frame
);
11351 val
[0] = interrupt_input
? Qt
: Qnil
;
11352 if (FRAME_TERMCAP_P (sf
))
11354 val
[1] = FRAME_TTY (sf
)->flow_control
? Qt
: Qnil
;
11355 val
[2] = (FRAME_TTY (sf
)->meta_key
== 2
11357 : (CURTTY ()->meta_key
== 1 ? Qt
: Qnil
));
11364 XSETFASTINT (val
[3], quit_char
);
11366 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
11369 DEFUN ("posn-at-x-y", Fposn_at_x_y
, Sposn_at_x_y
, 2, 4, 0,
11370 doc
: /* Return position information for pixel coordinates X and Y.
11371 By default, X and Y are relative to text area of the selected window.
11372 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
11373 If optional fourth arg WHOLE is non-nil, X is relative to the left
11374 edge of the window.
11376 The return value is similar to a mouse click position:
11377 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11378 IMAGE (DX . DY) (WIDTH . HEIGHT))
11379 The `posn-' functions access elements of such lists. */)
11380 (x
, y
, frame_or_window
, whole
)
11381 Lisp_Object x
, y
, frame_or_window
, whole
;
11386 if (NILP (frame_or_window
))
11387 frame_or_window
= selected_window
;
11389 if (WINDOWP (frame_or_window
))
11393 CHECK_LIVE_WINDOW (frame_or_window
);
11395 w
= XWINDOW (frame_or_window
);
11396 XSETINT (x
, (XINT (x
)
11397 + WINDOW_LEFT_EDGE_X (w
)
11399 ? window_box_left_offset (w
, TEXT_AREA
)
11401 XSETINT (y
, WINDOW_TO_FRAME_PIXEL_Y (w
, XINT (y
)));
11402 frame_or_window
= w
->frame
;
11405 CHECK_LIVE_FRAME (frame_or_window
);
11407 return make_lispy_position (XFRAME (frame_or_window
), &x
, &y
, 0);
11410 DEFUN ("posn-at-point", Fposn_at_point
, Sposn_at_point
, 0, 2, 0,
11411 doc
: /* Return position information for buffer POS in WINDOW.
11412 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
11414 Return nil if position is not visible in window. Otherwise,
11415 the return value is similar to that returned by `event-start' for
11416 a mouse click at the upper left corner of the glyph corresponding
11417 to the given buffer position:
11418 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11419 IMAGE (DX . DY) (WIDTH . HEIGHT))
11420 The `posn-' functions access elements of such lists. */)
11422 Lisp_Object pos
, window
;
11427 window
= selected_window
;
11429 tem
= Fpos_visible_in_window_p (pos
, window
, Qt
);
11432 Lisp_Object x
= XCAR (tem
);
11433 Lisp_Object y
= XCAR (XCDR (tem
));
11435 /* Point invisible due to hscrolling? */
11438 tem
= Fposn_at_x_y (x
, y
, window
, Qnil
);
11446 * Set up a new kboard object with reasonable initial values.
11452 kb
->Voverriding_terminal_local_map
= Qnil
;
11453 kb
->Vlast_command
= Qnil
;
11454 kb
->Vreal_last_command
= Qnil
;
11455 kb
->Vkeyboard_translate_table
= Qnil
;
11456 kb
->Vprefix_arg
= Qnil
;
11457 kb
->Vlast_prefix_arg
= Qnil
;
11458 kb
->kbd_queue
= Qnil
;
11459 kb
->kbd_queue_has_data
= 0;
11460 kb
->immediate_echo
= 0;
11461 kb
->echo_string
= Qnil
;
11462 kb
->echo_after_prompt
= -1;
11463 kb
->kbd_macro_buffer
= 0;
11464 kb
->kbd_macro_bufsize
= 0;
11465 kb
->defining_kbd_macro
= Qnil
;
11466 kb
->Vlast_kbd_macro
= Qnil
;
11467 kb
->reference_count
= 0;
11468 kb
->Vsystem_key_alist
= Qnil
;
11469 kb
->system_key_syms
= Qnil
;
11470 kb
->Vlocal_function_key_map
= Fmake_sparse_keymap (Qnil
);
11471 Fset_keymap_parent (kb
->Vlocal_function_key_map
, Vfunction_key_map
);
11472 kb
->Vlocal_key_translation_map
= Fmake_sparse_keymap (Qnil
);
11473 Fset_keymap_parent (kb
->Vlocal_key_translation_map
, Vkey_translation_map
);
11474 kb
->Vdefault_minibuffer_frame
= Qnil
;
11478 * Destroy the contents of a kboard object, but not the object itself.
11479 * We use this just before deleting it, or if we're going to initialize
11480 * it a second time.
11486 if (kb
->kbd_macro_buffer
)
11487 xfree (kb
->kbd_macro_buffer
);
11490 #ifdef MULTI_KBOARD
11492 /* Free KB and memory referenced from it. */
11500 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
11503 *kbp
= kb
->next_kboard
;
11505 /* Prevent a dangling reference to KB. */
11506 if (kb
== current_kboard
11507 && FRAMEP (selected_frame
)
11508 && FRAME_LIVE_P (XFRAME (selected_frame
)))
11510 current_kboard
= FRAME_KBOARD (XFRAME (selected_frame
));
11512 if (current_kboard
== kb
)
11520 #endif /* MULTI_KBOARD */
11525 /* This is correct before outermost invocation of the editor loop */
11526 command_loop_level
= -1;
11527 immediate_quit
= 0;
11528 quit_char
= Ctl ('g');
11529 Vunread_command_events
= Qnil
;
11530 unread_command_char
= -1;
11531 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
11533 recent_keys_index
= 0;
11534 kbd_fetch_ptr
= kbd_buffer
;
11535 kbd_store_ptr
= kbd_buffer
;
11536 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11537 do_mouse_tracking
= Qnil
;
11540 interrupt_input_blocked
= 0;
11541 interrupt_input_pending
= 0;
11543 /* This means that command_loop_1 won't try to select anything the first
11545 internal_last_event_frame
= Qnil
;
11546 Vlast_event_frame
= internal_last_event_frame
;
11548 #ifdef MULTI_KBOARD
11549 current_kboard
= initial_kboard
;
11551 wipe_kboard (current_kboard
);
11552 init_kboard (current_kboard
);
11554 if (!noninteractive
)
11556 /* Before multi-tty support, these handlers used to be installed
11557 only if the current session was a tty session. Now an Emacs
11558 session may have multiple display types, so we always handle
11559 SIGINT. There is special code in interrupt_signal to exit
11560 Emacs on SIGINT when there are no termcap frames on the
11561 controlling terminal. */
11562 signal (SIGINT
, interrupt_signal
);
11563 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
11564 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
11565 SIGQUIT and we can't tell which one it will give us. */
11566 signal (SIGQUIT
, interrupt_signal
);
11567 #endif /* HAVE_TERMIO */
11569 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11571 if (!noninteractive
)
11572 signal (SIGIO
, input_available_signal
);
11575 /* Use interrupt input by default, if it works and noninterrupt input
11576 has deficiencies. */
11578 #ifdef INTERRUPT_INPUT
11579 interrupt_input
= 1;
11581 interrupt_input
= 0;
11584 /* Our VMS input only works by interrupts, as of now. */
11586 interrupt_input
= 1;
11592 if (keyboard_init_hook
)
11593 (*keyboard_init_hook
) ();
11595 #ifdef POLL_FOR_INPUT
11596 poll_suppress_count
= 1;
11601 /* This type's only use is in syms_of_keyboard, to initialize the
11602 event header symbols and put properties on them. */
11603 struct event_head
{
11609 struct event_head head_table
[] = {
11610 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
11611 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
11612 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
11613 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
11614 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
11615 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
11616 /* `select-window' should be handled just like `switch-frame'
11617 in read_key_sequence. */
11618 {&Qselect_window
, "select-window", &Qswitch_frame
}
11622 syms_of_keyboard ()
11624 Vpre_help_message
= Qnil
;
11625 staticpro (&Vpre_help_message
);
11627 Vlispy_mouse_stem
= build_string ("mouse");
11628 staticpro (&Vlispy_mouse_stem
);
11631 QCimage
= intern (":image");
11632 staticpro (&QCimage
);
11634 staticpro (&Qhelp_echo
);
11635 Qhelp_echo
= intern ("help-echo");
11638 Qrtl
= intern (":rtl");
11640 staticpro (&item_properties
);
11641 item_properties
= Qnil
;
11643 staticpro (&tool_bar_item_properties
);
11644 tool_bar_item_properties
= Qnil
;
11645 staticpro (&tool_bar_items_vector
);
11646 tool_bar_items_vector
= Qnil
;
11648 staticpro (&real_this_command
);
11649 real_this_command
= Qnil
;
11651 Qtimer_event_handler
= intern ("timer-event-handler");
11652 staticpro (&Qtimer_event_handler
);
11654 Qdisabled_command_function
= intern ("disabled-command-function");
11655 staticpro (&Qdisabled_command_function
);
11657 Qself_insert_command
= intern ("self-insert-command");
11658 staticpro (&Qself_insert_command
);
11660 Qforward_char
= intern ("forward-char");
11661 staticpro (&Qforward_char
);
11663 Qbackward_char
= intern ("backward-char");
11664 staticpro (&Qbackward_char
);
11666 Qdisabled
= intern ("disabled");
11667 staticpro (&Qdisabled
);
11669 Qundefined
= intern ("undefined");
11670 staticpro (&Qundefined
);
11672 Qpre_command_hook
= intern ("pre-command-hook");
11673 staticpro (&Qpre_command_hook
);
11675 Qpost_command_hook
= intern ("post-command-hook");
11676 staticpro (&Qpost_command_hook
);
11678 Qdeferred_action_function
= intern ("deferred-action-function");
11679 staticpro (&Qdeferred_action_function
);
11681 Qcommand_hook_internal
= intern ("command-hook-internal");
11682 staticpro (&Qcommand_hook_internal
);
11684 Qfunction_key
= intern ("function-key");
11685 staticpro (&Qfunction_key
);
11686 Qmouse_click
= intern ("mouse-click");
11687 staticpro (&Qmouse_click
);
11688 #if defined (WINDOWSNT) || defined (MAC_OS)
11689 Qlanguage_change
= intern ("language-change");
11690 staticpro (&Qlanguage_change
);
11692 Qdrag_n_drop
= intern ("drag-n-drop");
11693 staticpro (&Qdrag_n_drop
);
11695 Qsave_session
= intern ("save-session");
11696 staticpro (&Qsave_session
);
11699 Qmac_apple_event
= intern ("mac-apple-event");
11700 staticpro (&Qmac_apple_event
);
11703 Qmenu_enable
= intern ("menu-enable");
11704 staticpro (&Qmenu_enable
);
11705 Qmenu_alias
= intern ("menu-alias");
11706 staticpro (&Qmenu_alias
);
11707 QCenable
= intern (":enable");
11708 staticpro (&QCenable
);
11709 QCvisible
= intern (":visible");
11710 staticpro (&QCvisible
);
11711 QChelp
= intern (":help");
11712 staticpro (&QChelp
);
11713 QCfilter
= intern (":filter");
11714 staticpro (&QCfilter
);
11715 QCbutton
= intern (":button");
11716 staticpro (&QCbutton
);
11717 QCkeys
= intern (":keys");
11718 staticpro (&QCkeys
);
11719 QCkey_sequence
= intern (":key-sequence");
11720 staticpro (&QCkey_sequence
);
11721 QCtoggle
= intern (":toggle");
11722 staticpro (&QCtoggle
);
11723 QCradio
= intern (":radio");
11724 staticpro (&QCradio
);
11726 Qmode_line
= intern ("mode-line");
11727 staticpro (&Qmode_line
);
11728 Qvertical_line
= intern ("vertical-line");
11729 staticpro (&Qvertical_line
);
11730 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
11731 staticpro (&Qvertical_scroll_bar
);
11732 Qmenu_bar
= intern ("menu-bar");
11733 staticpro (&Qmenu_bar
);
11735 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11736 Qmouse_fixup_help_message
= intern ("mouse-fixup-help-message");
11737 staticpro (&Qmouse_fixup_help_message
);
11740 Qabove_handle
= intern ("above-handle");
11741 staticpro (&Qabove_handle
);
11742 Qhandle
= intern ("handle");
11743 staticpro (&Qhandle
);
11744 Qbelow_handle
= intern ("below-handle");
11745 staticpro (&Qbelow_handle
);
11746 Qup
= intern ("up");
11748 Qdown
= intern ("down");
11749 staticpro (&Qdown
);
11750 Qtop
= intern ("top");
11752 Qbottom
= intern ("bottom");
11753 staticpro (&Qbottom
);
11754 Qend_scroll
= intern ("end-scroll");
11755 staticpro (&Qend_scroll
);
11756 Qratio
= intern ("ratio");
11757 staticpro (&Qratio
);
11759 Qevent_kind
= intern ("event-kind");
11760 staticpro (&Qevent_kind
);
11761 Qevent_symbol_elements
= intern ("event-symbol-elements");
11762 staticpro (&Qevent_symbol_elements
);
11763 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
11764 staticpro (&Qevent_symbol_element_mask
);
11765 Qmodifier_cache
= intern ("modifier-cache");
11766 staticpro (&Qmodifier_cache
);
11768 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
11769 staticpro (&Qrecompute_lucid_menubar
);
11770 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
11771 staticpro (&Qactivate_menubar_hook
);
11773 Qpolling_period
= intern ("polling-period");
11774 staticpro (&Qpolling_period
);
11776 Qinput_method_function
= intern ("input-method-function");
11777 staticpro (&Qinput_method_function
);
11779 Qinput_method_exit_on_first_char
= intern ("input-method-exit-on-first-char");
11780 staticpro (&Qinput_method_exit_on_first_char
);
11781 Qinput_method_use_echo_area
= intern ("input-method-use-echo-area");
11782 staticpro (&Qinput_method_use_echo_area
);
11784 Fset (Qinput_method_exit_on_first_char
, Qnil
);
11785 Fset (Qinput_method_use_echo_area
, Qnil
);
11787 last_point_position_buffer
= Qnil
;
11788 last_point_position_window
= Qnil
;
11791 struct event_head
*p
;
11793 for (p
= head_table
;
11794 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
11797 *p
->var
= intern (p
->name
);
11798 staticpro (p
->var
);
11799 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
11800 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
11804 button_down_location
= Fmake_vector (make_number (1), Qnil
);
11805 staticpro (&button_down_location
);
11806 mouse_syms
= Fmake_vector (make_number (1), Qnil
);
11807 staticpro (&mouse_syms
);
11808 wheel_syms
= Fmake_vector (make_number (4), Qnil
);
11809 staticpro (&wheel_syms
);
11813 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
11815 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
11816 for (i
= 0; i
< len
; i
++)
11817 if (modifier_names
[i
])
11818 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
11819 staticpro (&modifier_symbols
);
11822 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
11823 staticpro (&recent_keys
);
11825 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
11826 staticpro (&this_command_keys
);
11828 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
11829 staticpro (&raw_keybuf
);
11831 Qextended_command_history
= intern ("extended-command-history");
11832 Fset (Qextended_command_history
, Qnil
);
11833 staticpro (&Qextended_command_history
);
11835 accent_key_syms
= Qnil
;
11836 staticpro (&accent_key_syms
);
11838 func_key_syms
= Qnil
;
11839 staticpro (&func_key_syms
);
11841 drag_n_drop_syms
= Qnil
;
11842 staticpro (&drag_n_drop_syms
);
11844 unread_switch_frame
= Qnil
;
11845 staticpro (&unread_switch_frame
);
11847 internal_last_event_frame
= Qnil
;
11848 staticpro (&internal_last_event_frame
);
11850 read_key_sequence_cmd
= Qnil
;
11851 staticpro (&read_key_sequence_cmd
);
11853 menu_bar_one_keymap_changed_items
= Qnil
;
11854 staticpro (&menu_bar_one_keymap_changed_items
);
11856 menu_bar_items_vector
= Qnil
;
11857 staticpro (&menu_bar_items_vector
);
11859 help_form_saved_window_configs
= Qnil
;
11860 staticpro (&help_form_saved_window_configs
);
11862 defsubr (&Scurrent_idle_time
);
11863 defsubr (&Sevent_convert_list
);
11864 defsubr (&Sread_key_sequence
);
11865 defsubr (&Sread_key_sequence_vector
);
11866 defsubr (&Srecursive_edit
);
11867 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11868 defsubr (&Strack_mouse
);
11870 defsubr (&Sinput_pending_p
);
11871 defsubr (&Scommand_execute
);
11872 defsubr (&Srecent_keys
);
11873 defsubr (&Sthis_command_keys
);
11874 defsubr (&Sthis_command_keys_vector
);
11875 defsubr (&Sthis_single_command_keys
);
11876 defsubr (&Sthis_single_command_raw_keys
);
11877 defsubr (&Sreset_this_command_lengths
);
11878 defsubr (&Sclear_this_command_keys
);
11879 defsubr (&Ssuspend_emacs
);
11880 defsubr (&Sabort_recursive_edit
);
11881 defsubr (&Sexit_recursive_edit
);
11882 defsubr (&Srecursion_depth
);
11883 defsubr (&Stop_level
);
11884 defsubr (&Sdiscard_input
);
11885 defsubr (&Sopen_dribble_file
);
11886 defsubr (&Sset_input_interrupt_mode
);
11887 defsubr (&Sset_output_flow_control
);
11888 defsubr (&Sset_input_meta_mode
);
11889 defsubr (&Sset_quit_char
);
11890 defsubr (&Sset_input_mode
);
11891 defsubr (&Scurrent_input_mode
);
11892 defsubr (&Sexecute_extended_command
);
11893 defsubr (&Sposn_at_point
);
11894 defsubr (&Sposn_at_x_y
);
11896 DEFVAR_LISP ("last-command-char", &last_command_char
,
11897 doc
: /* Last input event that was part of a command. */);
11899 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
11900 doc
: /* Last input event that was part of a command. */);
11902 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
11903 doc
: /* Last input event in a command, except for mouse menu events.
11904 Mouse menus give back keys that don't look like mouse events;
11905 this variable holds the actual mouse event that led to the menu,
11906 so that you can determine whether the command was run by mouse or not. */);
11908 DEFVAR_LISP ("last-input-char", &last_input_char
,
11909 doc
: /* Last input event. */);
11911 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
11912 doc
: /* Last input event. */);
11914 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
11915 doc
: /* List of events to be read as the command input.
11916 These events are processed first, before actual keyboard input.
11917 Events read from this list are not normally added to `this-command-keys',
11918 as they will already have been added once as they were read for the first time.
11919 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
11920 Vunread_command_events
= Qnil
;
11922 DEFVAR_INT ("unread-command-char", &unread_command_char
,
11923 doc
: /* If not -1, an object to be read as next command input event. */);
11925 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
11926 doc
: /* List of events to be processed as input by input methods.
11927 These events are processed before `unread-command-events'
11928 and actual keyboard input, but are not given to `input-method-function'. */);
11929 Vunread_post_input_method_events
= Qnil
;
11931 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
11932 doc
: /* List of events to be processed as input by input methods.
11933 These events are processed after `unread-command-events', but
11934 before actual keyboard input.
11935 If there's an active input method, the events are given to
11936 `input-method-function'. */);
11937 Vunread_input_method_events
= Qnil
;
11939 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
11940 doc
: /* Meta-prefix character code.
11941 Meta-foo as command input turns into this character followed by foo. */);
11942 XSETINT (meta_prefix_char
, 033);
11944 DEFVAR_KBOARD ("last-command", Vlast_command
,
11945 doc
: /* The last command executed.
11946 Normally a symbol with a function definition, but can be whatever was found
11947 in the keymap, or whatever the variable `this-command' was set to by that
11950 The value `mode-exit' is special; it means that the previous command
11951 read an event that told it to exit, and it did so and unread that event.
11952 In other words, the present command is the event that made the previous
11955 The value `kill-region' is special; it means that the previous command
11956 was a kill command.
11958 `last-command' has a separate binding for each terminal device.
11959 See Info node `(elisp)Multiple displays'. */);
11961 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
11962 doc
: /* Same as `last-command', but never altered by Lisp code. */);
11964 DEFVAR_LISP ("this-command", &Vthis_command
,
11965 doc
: /* The command now being executed.
11966 The command can set this variable; whatever is put here
11967 will be in `last-command' during the following command. */);
11968 Vthis_command
= Qnil
;
11970 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
11971 doc
: /* The command bound to the current key sequence before remapping.
11972 It equals `this-command' if the original command was not remapped through
11973 any of the active keymaps. Otherwise, the value of `this-command' is the
11974 result of looking up the original command in the active keymaps. */);
11975 Vthis_original_command
= Qnil
;
11977 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
11978 doc
: /* *Number of input events between auto-saves.
11979 Zero means disable autosaving due to number of characters typed. */);
11980 auto_save_interval
= 300;
11982 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
11983 doc
: /* *Number of seconds idle time before auto-save.
11984 Zero or nil means disable auto-saving due to idleness.
11985 After auto-saving due to this many seconds of idle time,
11986 Emacs also does a garbage collection if that seems to be warranted. */);
11987 XSETFASTINT (Vauto_save_timeout
, 30);
11989 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
11990 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
11991 The value may be integer or floating point. */);
11992 Vecho_keystrokes
= make_number (1);
11994 DEFVAR_INT ("polling-period", &polling_period
,
11995 doc
: /* *Interval between polling for input during Lisp execution.
11996 The reason for polling is to make C-g work to stop a running program.
11997 Polling is needed only when using X windows and SIGIO does not work.
11998 Polling is automatically disabled in all other cases. */);
11999 polling_period
= 2;
12001 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
12002 doc
: /* *Maximum time between mouse clicks to make a double-click.
12003 Measured in milliseconds. The value nil means disable double-click
12004 recognition; t means double-clicks have no time limit and are detected
12005 by position only. */);
12006 Vdouble_click_time
= make_number (500);
12008 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
12009 doc
: /* *Maximum mouse movement between clicks to make a double-click.
12010 On window-system frames, value is the number of pixels the mouse may have
12011 moved horizontally or vertically between two clicks to make a double-click.
12012 On non window-system frames, value is interpreted in units of 1/8 characters
12015 This variable is also the threshold for motion of the mouse
12016 to count as a drag. */);
12017 double_click_fuzz
= 3;
12019 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
12020 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
12021 inhibit_local_menu_bar_menus
= 0;
12023 DEFVAR_INT ("num-input-keys", &num_input_keys
,
12024 doc
: /* Number of complete key sequences read as input so far.
12025 This includes key sequences read from keyboard macros.
12026 The number is effectively the number of interactive command invocations. */);
12027 num_input_keys
= 0;
12029 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
12030 doc
: /* Number of input events read from the keyboard so far.
12031 This does not include events generated by keyboard macros. */);
12032 num_nonmacro_input_events
= 0;
12034 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
12035 doc
: /* The frame in which the most recently read event occurred.
12036 If the last event came from a keyboard macro, this is set to `macro'. */);
12037 Vlast_event_frame
= Qnil
;
12039 /* This variable is set up in sysdep.c. */
12040 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
12041 doc
: /* The ERASE character as set by the user with stty. */);
12043 DEFVAR_LISP ("help-char", &Vhelp_char
,
12044 doc
: /* Character to recognize as meaning Help.
12045 When it is read, do `(eval help-form)', and display result if it's a string.
12046 If the value of `help-form' is nil, this char can be read normally. */);
12047 XSETINT (Vhelp_char
, Ctl ('H'));
12049 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
12050 doc
: /* List of input events to recognize as meaning Help.
12051 These work just like the value of `help-char' (see that). */);
12052 Vhelp_event_list
= Qnil
;
12054 DEFVAR_LISP ("help-form", &Vhelp_form
,
12055 doc
: /* Form to execute when character `help-char' is read.
12056 If the form returns a string, that string is displayed.
12057 If `help-form' is nil, the help char is not recognized. */);
12060 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
12061 doc
: /* Command to run when `help-char' character follows a prefix key.
12062 This command is used only when there is no actual binding
12063 for that character after that prefix key. */);
12064 Vprefix_help_command
= Qnil
;
12066 DEFVAR_LISP ("top-level", &Vtop_level
,
12067 doc
: /* Form to evaluate when Emacs starts up.
12068 Useful to set before you dump a modified Emacs. */);
12071 DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table
,
12072 doc
: /* Translate table for local keyboard input, or nil.
12073 If non-nil, the value should be a char-table. Each character read
12074 from the keyboard is looked up in this char-table. If the value found
12075 there is non-nil, then it is used instead of the actual input character.
12077 The value can also be a string or vector, but this is considered obsolete.
12078 If it is a string or vector of length N, character codes N and up are left
12079 untranslated. In a vector, an element which is nil means "no translation".
12081 This is applied to the characters supplied to input methods, not their
12082 output. See also `translation-table-for-input'.
12084 This variable has a separate binding for each terminal. See Info node
12085 `(elisp)Multiple displays'. */);
12087 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
12088 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
12089 \(Even if the operating system has support for stopping a process.\) */);
12090 cannot_suspend
= 0;
12092 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
12093 doc
: /* Non-nil means prompt with menus when appropriate.
12094 This is done when reading from a keymap that has a prompt string,
12095 for elements that have prompt strings.
12096 The menu is displayed on the screen
12097 if X menus were enabled at configuration
12098 time and the previous event was a mouse click prefix key.
12099 Otherwise, menu prompting uses the echo area. */);
12100 menu_prompting
= 1;
12102 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
12103 doc
: /* Character to see next line of menu prompt.
12104 Type this character while in a menu prompt to rotate around the lines of it. */);
12105 XSETINT (menu_prompt_more_char
, ' ');
12107 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
12108 doc
: /* A mask of additional modifier keys to use with every keyboard character.
12109 Emacs applies the modifiers of the character stored here to each keyboard
12110 character it reads. For example, after evaluating the expression
12111 (setq extra-keyboard-modifiers ?\\C-x)
12112 all input characters will have the control modifier applied to them.
12114 Note that the character ?\\C-@, equivalent to the integer zero, does
12115 not count as a control character; rather, it counts as a character
12116 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
12117 cancels any modification. */);
12118 extra_keyboard_modifiers
= 0;
12120 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
12121 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
12122 The command loop sets this to nil before each command,
12123 and tests the value when the command returns.
12124 Buffer modification stores t in this variable. */);
12125 Vdeactivate_mark
= Qnil
;
12127 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
12128 doc
: /* Temporary storage of pre-command-hook or post-command-hook. */);
12129 Vcommand_hook_internal
= Qnil
;
12131 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
12132 doc
: /* Normal hook run before each command is executed.
12133 If an unhandled error happens in running this hook,
12134 the hook value is set to nil, since otherwise the error
12135 might happen repeatedly and make Emacs nonfunctional. */);
12136 Vpre_command_hook
= Qnil
;
12138 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
12139 doc
: /* Normal hook run after each command is executed.
12140 If an unhandled error happens in running this hook,
12141 the hook value is set to nil, since otherwise the error
12142 might happen repeatedly and make Emacs nonfunctional. */);
12143 Vpost_command_hook
= Qnil
;
12146 DEFVAR_LISP ("echo-area-clear-hook", ...,
12147 doc
: /* Normal hook run when clearing the echo area. */);
12149 Qecho_area_clear_hook
= intern ("echo-area-clear-hook");
12150 staticpro (&Qecho_area_clear_hook
);
12151 SET_SYMBOL_VALUE (Qecho_area_clear_hook
, Qnil
);
12153 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
12154 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
12155 Vlucid_menu_bar_dirty_flag
= Qnil
;
12157 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
12158 doc
: /* List of menu bar items to move to the end of the menu bar.
12159 The elements of the list are event types that may have menu bar bindings. */);
12160 Vmenu_bar_final_items
= Qnil
;
12162 DEFVAR_KBOARD ("overriding-terminal-local-map",
12163 Voverriding_terminal_local_map
,
12164 doc
: /* Per-terminal keymap that overrides all other local keymaps.
12165 If this variable is non-nil, it is used as a keymap instead of the
12166 buffer's local map, and the minor mode keymaps and text property keymaps.
12167 It also replaces `overriding-local-map'.
12169 This variable is intended to let commands such as `universal-argument'
12170 set up a different keymap for reading the next command.
12172 `overriding-terminal-local-map' has a separate binding for each
12174 See Info node `(elisp)Multiple displays'. */);
12176 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
12177 doc
: /* Keymap that overrides all other local keymaps.
12178 If this variable is non-nil, it is used as a keymap--replacing the
12179 buffer's local map, the minor mode keymaps, and char property keymaps. */);
12180 Voverriding_local_map
= Qnil
;
12182 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
12183 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
12184 Otherwise, the menu bar continues to reflect the buffer's local map
12185 and the minor mode maps regardless of `overriding-local-map'. */);
12186 Voverriding_local_map_menu_flag
= Qnil
;
12188 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
12189 doc
: /* Keymap defining bindings for special events to execute at low level. */);
12190 Vspecial_event_map
= Fcons (intern ("keymap"), Qnil
);
12192 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
12193 doc
: /* *Non-nil means generate motion events for mouse motion. */);
12195 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
12196 doc
: /* Alist of system-specific X windows key symbols.
12197 Each element should have the form (N . SYMBOL) where N is the
12198 numeric keysym code (sans the \"system-specific\" bit 1<<28)
12199 and SYMBOL is its name.
12201 `system-key-alist' has a separate binding for each terminal device.
12202 See Info node `(elisp)Multiple displays'. */);
12204 DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map
,
12205 doc
: /* Keymap that translates key sequences to key sequences during input.
12206 This is used mainly for mapping ASCII function key sequences into
12207 real Emacs function key events (symbols).
12209 The `read-key-sequence' function replaces any subsequence bound by
12210 `local-function-key-map' with its binding. More precisely, when the
12211 active keymaps have no binding for the current key sequence but
12212 `local-function-key-map' binds a suffix of the sequence to a vector or
12213 string, `read-key-sequence' replaces the matching suffix with its
12214 binding, and continues with the new sequence.
12216 If the binding is a function, it is called with one argument (the prompt)
12217 and its return value (a key sequence) is used.
12219 The events that come from bindings in `local-function-key-map' are not
12220 themselves looked up in `local-function-key-map'.
12222 For example, suppose `local-function-key-map' binds `ESC O P' to [f1].
12223 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
12224 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix key,
12225 typing `ESC O P x' would return [f1 x].
12227 `local-function-key-map' has a separate binding for each terminal
12228 device. See Info node `(elisp)Multiple displays'. If you need to
12229 define a binding on all terminals, change `function-key-map'
12230 instead. Initially, `local-function-key-map' is an empty keymap that
12231 has `function-key-map' as its parent on all terminal devices. */);
12233 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
12234 doc
: /* The parent keymap of all `local-function-key-map' instances.
12235 Function key definitions that apply to all terminal devices should go
12236 here. If a mapping is defined in both the current
12237 `local-function-key-map' binding and this variable, then the local
12238 definition will take precendence. */);
12239 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
12241 DEFVAR_KBOARD ("local-key-translation-map", Vlocal_key_translation_map
,
12242 doc
: /* Keymap of key translations that can override keymaps.
12243 This keymap works like `function-key-map', but comes after that,
12244 and its non-prefix bindings override ordinary bindings.
12246 `key-translation-map' has a separate binding for each terminal device.
12247 (See Info node `(elisp)Multiple displays'.) If you need to set a key
12248 translation on all terminals, change `global-key-translation-map' instead. */);
12250 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
12251 doc
: /* The parent keymap of all `local-key-translation-map' instances.
12252 Key translations that apply to all terminal devices should go here. */);
12253 Vkey_translation_map
= Fmake_sparse_keymap (Qnil
);
12255 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
12256 doc
: /* List of deferred actions to be performed at a later time.
12257 The precise format isn't relevant here; we just check whether it is nil. */);
12258 Vdeferred_action_list
= Qnil
;
12260 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
12261 doc
: /* Function to call to handle deferred actions, after each command.
12262 This function is called with no arguments after each command
12263 whenever `deferred-action-list' is non-nil. */);
12264 Vdeferred_action_function
= Qnil
;
12266 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
12267 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
12268 The value can be a length of time to show the message for.
12269 If the value is non-nil and not a number, we wait 2 seconds. */);
12270 Vsuggest_key_bindings
= Qt
;
12272 DEFVAR_LISP ("timer-list", &Vtimer_list
,
12273 doc
: /* List of active absolute time timers in order of increasing time. */);
12274 Vtimer_list
= Qnil
;
12276 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
12277 doc
: /* List of active idle-time timers in order of increasing time. */);
12278 Vtimer_idle_list
= Qnil
;
12280 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
12281 doc
: /* If non-nil, the function that implements the current input method.
12282 It's called with one argument, a printing character that was just read.
12283 \(That means a character with code 040...0176.)
12284 Typically this function uses `read-event' to read additional events.
12285 When it does so, it should first bind `input-method-function' to nil
12286 so it will not be called recursively.
12288 The function should return a list of zero or more events
12289 to be used as input. If it wants to put back some events
12290 to be reconsidered, separately, by the input method,
12291 it can add them to the beginning of `unread-command-events'.
12293 The input method function can find in `input-method-previous-method'
12294 the previous echo area message.
12296 The input method function should refer to the variables
12297 `input-method-use-echo-area' and `input-method-exit-on-first-char'
12298 for guidance on what to do. */);
12299 Vinput_method_function
= Qnil
;
12301 DEFVAR_LISP ("input-method-previous-message",
12302 &Vinput_method_previous_message
,
12303 doc
: /* When `input-method-function' is called, hold the previous echo area message.
12304 This variable exists because `read-event' clears the echo area
12305 before running the input method. It is nil if there was no message. */);
12306 Vinput_method_previous_message
= Qnil
;
12308 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
12309 doc
: /* If non-nil, the function that implements the display of help.
12310 It's called with one argument, the help string to display. */);
12311 Vshow_help_function
= Qnil
;
12313 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
12314 doc
: /* If non-nil, suppress point adjustment after executing a command.
12316 After a command is executed, if point is moved into a region that has
12317 special properties (e.g. composition, display), we adjust point to
12318 the boundary of the region. But, when a command sets this variable to
12319 non-nil, we suppress the point adjustment.
12321 This variable is set to nil before reading a command, and is checked
12322 just after executing the command. */);
12323 Vdisable_point_adjustment
= Qnil
;
12325 DEFVAR_LISP ("global-disable-point-adjustment",
12326 &Vglobal_disable_point_adjustment
,
12327 doc
: /* *If non-nil, always suppress point adjustment.
12329 The default value is nil, in which case, point adjustment are
12330 suppressed only after special commands that set
12331 `disable-point-adjustment' (which see) to non-nil. */);
12332 Vglobal_disable_point_adjustment
= Qnil
;
12334 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
12335 doc
: /* *How long to display an echo-area message when the minibuffer is active.
12336 If the value is not a number, such messages don't time out. */);
12337 Vminibuffer_message_timeout
= make_number (2);
12339 DEFVAR_LISP ("throw-on-input", &Vthrow_on_input
,
12340 doc
: /* If non-nil, any keyboard input throws to this symbol.
12341 The value of that variable is passed to `quit-flag' and later causes a
12342 peculiar kind of quitting. */);
12343 Vthrow_on_input
= Qnil
;
12345 DEFVAR_LISP ("command-error-function", &Vcommand_error_function
,
12346 doc
: /* If non-nil, function to output error messages.
12347 The arguments are the error data, a list of the form
12348 (SIGNALED-CONDITIONS . SIGNAL-DATA)
12349 such as just as `condition-case' would bind its variable to,
12350 the context (a string which normally goes at the start of the message),
12351 and the Lisp function within which the error was signaled. */);
12352 Vcommand_error_function
= Qnil
;
12354 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
12355 &Venable_disabled_menus_and_buttons
,
12356 doc
: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
12358 Help functions bind this to allow help on disabled menu items
12359 and tool-bar buttons. */);
12360 Venable_disabled_menus_and_buttons
= Qnil
;
12364 keys_of_keyboard ()
12366 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
12367 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
12368 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
12369 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
12370 initial_define_key (meta_map
, 'x', "execute-extended-command");
12372 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
12373 "handle-delete-frame");
12374 /* Here we used to use `ignore-event' which would simple set prefix-arg to
12375 current-prefix-arg, as is done in `handle-switch-frame'.
12376 But `handle-switch-frame is not run from the special-map.
12377 Commands from that map are run in a special way that automatically
12378 preserves the prefix-arg. Restoring the prefix arg here is not just
12379 redundant but harmful:
12381 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
12382 - after the first prompt, the exit-minibuffer-hook is run which may
12383 iconify a frame and thus push a `iconify-frame' event.
12384 - after running exit-minibuffer-hook, current-prefix-arg is
12385 restored to the non-nil value it had before the prompt.
12386 - we enter the second prompt.
12387 current-prefix-arg is non-nil, prefix-arg is nil.
12388 - before running the first real event, we run the special iconify-frame
12389 event, but we pass the `special' arg to execute-command so
12390 current-prefix-arg and prefix-arg are left untouched.
12391 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
12392 - the next key event will have a spuriously non-nil current-prefix-arg. */
12393 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
12395 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
12397 /* Handling it at such a low-level causes read_key_sequence to get
12398 * confused because it doesn't realize that the current_buffer was
12399 * changed by read_char.
12401 * initial_define_lispy_key (Vspecial_event_map, "select-window",
12402 * "handle-select-window"); */
12403 initial_define_lispy_key (Vspecial_event_map
, "save-session",
12404 "handle-save-session");
12407 /* Mark the pointers in the kboard objects.
12408 Called by the Fgarbage_collector. */
12414 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
12416 if (kb
->kbd_macro_buffer
)
12417 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
12419 mark_object (kb
->Voverriding_terminal_local_map
);
12420 mark_object (kb
->Vlast_command
);
12421 mark_object (kb
->Vreal_last_command
);
12422 mark_object (kb
->Vkeyboard_translate_table
);
12423 mark_object (kb
->Vprefix_arg
);
12424 mark_object (kb
->Vlast_prefix_arg
);
12425 mark_object (kb
->kbd_queue
);
12426 mark_object (kb
->defining_kbd_macro
);
12427 mark_object (kb
->Vlast_kbd_macro
);
12428 mark_object (kb
->Vsystem_key_alist
);
12429 mark_object (kb
->system_key_syms
);
12430 mark_object (kb
->Vlocal_function_key_map
);
12431 mark_object (kb
->Vlocal_key_translation_map
);
12432 mark_object (kb
->Vdefault_minibuffer_frame
);
12433 mark_object (kb
->echo_string
);
12436 struct input_event
*event
;
12437 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
12439 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
12440 event
= kbd_buffer
;
12441 if (event
->kind
!= SELECTION_REQUEST_EVENT
12442 && event
->kind
!= SELECTION_CLEAR_EVENT
)
12444 mark_object (event
->x
);
12445 mark_object (event
->y
);
12447 mark_object (event
->frame_or_window
);
12448 mark_object (event
->arg
);
12453 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
12454 (do not change this comment) */