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, 2008 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
;
98 #define KBD_BUFFER_SIZE 4096
101 KBOARD
*initial_kboard
;
102 KBOARD
*current_kboard
;
106 KBOARD the_only_kboard
;
109 /* Non-nil disable property on a command means
110 do not execute it; call disabled-command-function's value instead. */
111 Lisp_Object Qdisabled
, Qdisabled_command_function
;
113 #define NUM_RECENT_KEYS (300)
114 int recent_keys_index
; /* Index for storing next element into recent_keys */
115 int total_keys
; /* Total number of elements stored into recent_keys */
116 Lisp_Object recent_keys
; /* Vector holds the last NUM_RECENT_KEYS keystrokes */
118 /* Vector holding the key sequence that invoked the current command.
119 It is reused for each command, and it may be longer than the current
120 sequence; this_command_key_count indicates how many elements
121 actually mean something.
122 It's easier to staticpro a single Lisp_Object than an array. */
123 Lisp_Object this_command_keys
;
124 int this_command_key_count
;
126 /* 1 after calling Freset_this_command_lengths.
128 int this_command_key_count_reset
;
130 /* This vector is used as a buffer to record the events that were actually read
131 by read_key_sequence. */
132 Lisp_Object raw_keybuf
;
133 int raw_keybuf_count
;
135 #define GROW_RAW_KEYBUF \
136 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
137 raw_keybuf = larger_vector (raw_keybuf, raw_keybuf_count * 2, Qnil) \
139 /* Number of elements of this_command_keys
140 that precede this key sequence. */
141 int this_single_command_key_start
;
143 /* Record values of this_command_key_count and echo_length ()
144 before this command was read. */
145 static int before_command_key_count
;
146 static int before_command_echo_length
;
148 extern int minbuf_level
;
150 extern int message_enable_multibyte
;
152 /* If non-nil, the function that implements the display of help.
153 It's called with one argument, the help string to display. */
155 Lisp_Object Vshow_help_function
;
157 /* If a string, the message displayed before displaying a help-echo
160 Lisp_Object Vpre_help_message
;
162 /* Nonzero means do menu prompting. */
164 static int menu_prompting
;
166 /* Character to see next line of menu prompt. */
168 static Lisp_Object menu_prompt_more_char
;
170 /* For longjmp to where kbd input is being done. */
172 static jmp_buf getcjmp
;
174 /* True while doing kbd input. */
175 int waiting_for_input
;
177 /* True while displaying for echoing. Delays C-g throwing. */
181 /* Non-null means we can start echoing at the next input pause even
182 though there is something in the echo area. */
184 static struct kboard
*ok_to_echo_at_next_pause
;
186 /* The kboard last echoing, or null for none. Reset to 0 in
187 cancel_echoing. If non-null, and a current echo area message
188 exists, and echo_message_buffer is eq to the current message
189 buffer, we know that the message comes from echo_kboard. */
191 struct kboard
*echo_kboard
;
193 /* The buffer used for echoing. Set in echo_now, reset in
196 Lisp_Object echo_message_buffer
;
198 /* Nonzero means disregard local maps for the menu bar. */
199 static int inhibit_local_menu_bar_menus
;
201 /* Nonzero means C-g should cause immediate error-signal. */
204 /* The user's hook function for outputting an error message. */
205 Lisp_Object Vcommand_error_function
;
207 /* The user's ERASE setting. */
208 Lisp_Object Vtty_erase_char
;
210 /* Character to recognize as the help char. */
211 Lisp_Object Vhelp_char
;
213 /* List of other event types to recognize as meaning "help". */
214 Lisp_Object Vhelp_event_list
;
216 /* Form to execute when help char is typed. */
217 Lisp_Object Vhelp_form
;
219 /* Command to run when the help character follows a prefix key. */
220 Lisp_Object Vprefix_help_command
;
222 /* List of items that should move to the end of the menu bar. */
223 Lisp_Object Vmenu_bar_final_items
;
225 /* Non-nil means show the equivalent key-binding for
226 any M-x command that has one.
227 The value can be a length of time to show the message for.
228 If the value is non-nil and not a number, we wait 2 seconds. */
229 Lisp_Object Vsuggest_key_bindings
;
231 /* How long to display an echo-area message when the minibuffer is active.
232 If the value is not a number, such messages don't time out. */
233 Lisp_Object Vminibuffer_message_timeout
;
235 /* Character that causes a quit. Normally C-g.
237 If we are running on an ordinary terminal, this must be an ordinary
238 ASCII char, since we want to make it our interrupt character.
240 If we are not running on an ordinary terminal, it still needs to be
241 an ordinary ASCII char. This character needs to be recognized in
242 the input interrupt handler. At this point, the keystroke is
243 represented as a struct input_event, while the desired quit
244 character is specified as a lispy event. The mapping from struct
245 input_events to lispy events cannot run in an interrupt handler,
246 and the reverse mapping is difficult for anything but ASCII
249 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
253 extern Lisp_Object current_global_map
;
254 extern int minibuf_level
;
256 /* If non-nil, this is a map that overrides all other local maps. */
257 Lisp_Object Voverriding_local_map
;
259 /* If non-nil, Voverriding_local_map applies to the menu bar. */
260 Lisp_Object Voverriding_local_map_menu_flag
;
262 /* Keymap that defines special misc events that should
263 be processed immediately at a low level. */
264 Lisp_Object Vspecial_event_map
;
266 /* Current depth in recursive edits. */
267 int command_loop_level
;
269 /* Total number of times command_loop has read a key sequence. */
270 EMACS_INT num_input_keys
;
272 /* Last input character read as a command. */
273 Lisp_Object last_command_char
;
275 /* Last input character read as a command, not counting menus
276 reached by the mouse. */
277 Lisp_Object last_nonmenu_event
;
279 /* Last input character read for any purpose. */
280 Lisp_Object last_input_char
;
282 /* If not Qnil, a list of objects to be read as subsequent command input. */
283 Lisp_Object Vunread_command_events
;
285 /* If not Qnil, a list of objects to be read as subsequent command input
286 including input method processing. */
287 Lisp_Object Vunread_input_method_events
;
289 /* If not Qnil, a list of objects to be read as subsequent command input
290 but NOT including input method processing. */
291 Lisp_Object Vunread_post_input_method_events
;
293 /* If not -1, an event to be read as subsequent command input. */
294 EMACS_INT unread_command_char
;
296 /* If not Qnil, this is a switch-frame event which we decided to put
297 off until the end of a key sequence. This should be read as the
298 next command input, after any unread_command_events.
300 read_key_sequence uses this to delay switch-frame events until the
301 end of the key sequence; Fread_char uses it to put off switch-frame
302 events until a non-ASCII event is acceptable as input. */
303 Lisp_Object unread_switch_frame
;
305 /* A mask of extra modifier bits to put into every keyboard char. */
306 EMACS_INT extra_keyboard_modifiers
;
308 /* Char to use as prefix when a meta character is typed in.
309 This is bound on entry to minibuffer in case ESC is changed there. */
311 Lisp_Object meta_prefix_char
;
313 /* Last size recorded for a current buffer which is not a minibuffer. */
314 static int last_non_minibuf_size
;
316 /* Number of idle seconds before an auto-save and garbage collection. */
317 static Lisp_Object Vauto_save_timeout
;
319 /* Total number of times read_char has returned. */
320 int num_input_events
;
322 /* Total number of times read_char has returned, outside of macros. */
323 EMACS_INT num_nonmacro_input_events
;
325 /* Auto-save automatically when this many characters have been typed
326 since the last time. */
328 static EMACS_INT auto_save_interval
;
330 /* Value of num_nonmacro_input_events as of last auto save. */
334 /* The command being executed by the command loop.
335 Commands may set this, and the value set will be copied into
336 current_kboard->Vlast_command instead of the actual command. */
337 Lisp_Object Vthis_command
;
339 /* This is like Vthis_command, except that commands never set it. */
340 Lisp_Object real_this_command
;
342 /* If the lookup of the command returns a binding, the original
343 command is stored in this-original-command. It is nil otherwise. */
344 Lisp_Object Vthis_original_command
;
346 /* The value of point when the last command was started. */
347 int last_point_position
;
349 /* The buffer that was current when the last command was started. */
350 Lisp_Object last_point_position_buffer
;
352 /* The window that was selected when the last command was started. */
353 Lisp_Object last_point_position_window
;
355 /* The frame in which the last input event occurred, or Qmacro if the
356 last event came from a macro. We use this to determine when to
357 generate switch-frame events. This may be cleared by functions
358 like Fselect_frame, to make sure that a switch-frame event is
359 generated by the next character. */
360 Lisp_Object internal_last_event_frame
;
362 /* A user-visible version of the above, intended to allow users to
363 figure out where the last event came from, if the event doesn't
364 carry that information itself (i.e. if it was a character). */
365 Lisp_Object Vlast_event_frame
;
367 /* The timestamp of the last input event we received from the X server.
368 X Windows wants this for selection ownership. */
369 unsigned long last_event_timestamp
;
371 Lisp_Object Qself_insert_command
;
372 Lisp_Object Qforward_char
;
373 Lisp_Object Qbackward_char
;
374 Lisp_Object Qundefined
;
375 Lisp_Object Qtimer_event_handler
;
377 /* read_key_sequence stores here the command definition of the
378 key sequence that it reads. */
379 Lisp_Object read_key_sequence_cmd
;
381 /* Echo unfinished commands after this many seconds of pause. */
382 Lisp_Object Vecho_keystrokes
;
384 /* Form to evaluate (if non-nil) when Emacs is started. */
385 Lisp_Object Vtop_level
;
387 /* If non-nil, this implements the current input method. */
388 Lisp_Object Vinput_method_function
;
389 Lisp_Object Qinput_method_function
;
391 /* When we call Vinput_method_function,
392 this holds the echo area message that was just erased. */
393 Lisp_Object Vinput_method_previous_message
;
395 /* Non-nil means deactivate the mark at end of this command. */
396 Lisp_Object Vdeactivate_mark
;
398 /* Menu bar specified in Lucid Emacs fashion. */
400 Lisp_Object Vlucid_menu_bar_dirty_flag
;
401 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
403 Lisp_Object Qecho_area_clear_hook
;
405 /* Hooks to run before and after each command. */
406 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
407 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
408 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
410 /* Parent keymap of terminal-local function-key-map instances. */
411 Lisp_Object Vfunction_key_map
;
413 /* Keymap of key translations that can override keymaps. */
414 Lisp_Object Vkey_translation_map
;
416 /* List of deferred actions to be performed at a later time.
417 The precise format isn't relevant here; we just check whether it is nil. */
418 Lisp_Object Vdeferred_action_list
;
420 /* Function to call to handle deferred actions, when there are any. */
421 Lisp_Object Vdeferred_action_function
;
422 Lisp_Object Qdeferred_action_function
;
424 Lisp_Object Qinput_method_exit_on_first_char
;
425 Lisp_Object Qinput_method_use_echo_area
;
427 /* File in which we write all commands we read. */
430 /* Nonzero if input is available. */
433 extern char *pending_malloc_warning
;
435 /* Circular buffer for pre-read keyboard input. */
437 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
439 /* Pointer to next available character in kbd_buffer.
440 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
441 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
442 next available char is in kbd_buffer[0]. */
443 static struct input_event
*kbd_fetch_ptr
;
445 /* Pointer to next place to store character in kbd_buffer. This
446 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
447 character should go in kbd_buffer[0]. */
448 static struct input_event
* volatile kbd_store_ptr
;
450 /* The above pair of variables forms a "queue empty" flag. When we
451 enqueue a non-hook event, we increment kbd_store_ptr. When we
452 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
453 there is input available if the two pointers are not equal.
455 Why not just have a flag set and cleared by the enqueuing and
456 dequeuing functions? Such a flag could be screwed up by interrupts
457 at inopportune times. */
459 /* If this flag is non-nil, we check mouse_moved to see when the
460 mouse moves, and motion events will appear in the input stream.
461 Otherwise, mouse motion is ignored. */
462 Lisp_Object do_mouse_tracking
;
464 /* Symbols to head events. */
465 Lisp_Object Qmouse_movement
;
466 Lisp_Object Qscroll_bar_movement
;
467 Lisp_Object Qswitch_frame
;
468 Lisp_Object Qdelete_frame
;
469 Lisp_Object Qiconify_frame
;
470 Lisp_Object Qmake_frame_visible
;
471 Lisp_Object Qselect_window
;
472 Lisp_Object Qhelp_echo
;
474 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
475 Lisp_Object Qmouse_fixup_help_message
;
478 /* Symbols to denote kinds of events. */
479 Lisp_Object Qfunction_key
;
480 Lisp_Object Qmouse_click
;
481 #if defined (WINDOWSNT) || defined (MAC_OS)
482 Lisp_Object Qlanguage_change
;
484 Lisp_Object Qdrag_n_drop
;
485 Lisp_Object Qsave_session
;
487 Lisp_Object Qmac_apple_event
;
490 Lisp_Object Qdbus_event
;
492 /* Lisp_Object Qmouse_movement; - also an event header */
494 /* Properties of event headers. */
495 Lisp_Object Qevent_kind
;
496 Lisp_Object Qevent_symbol_elements
;
498 /* menu item parts */
499 Lisp_Object Qmenu_alias
;
500 Lisp_Object Qmenu_enable
;
501 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
502 Lisp_Object QCbutton
, QCtoggle
, QCradio
;
503 extern Lisp_Object Vdefine_key_rebound_commands
;
504 extern Lisp_Object Qmenu_item
;
506 /* An event header symbol HEAD may have a property named
507 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
508 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
509 mask of modifiers applied to it. If present, this is used to help
510 speed up parse_modifiers. */
511 Lisp_Object Qevent_symbol_element_mask
;
513 /* An unmodified event header BASE may have a property named
514 Qmodifier_cache, which is an alist mapping modifier masks onto
515 modified versions of BASE. If present, this helps speed up
517 Lisp_Object Qmodifier_cache
;
519 /* Symbols to use for parts of windows. */
520 Lisp_Object Qmode_line
;
521 Lisp_Object Qvertical_line
;
522 Lisp_Object Qvertical_scroll_bar
;
523 Lisp_Object Qmenu_bar
;
524 extern Lisp_Object Qleft_margin
, Qright_margin
;
525 extern Lisp_Object Qleft_fringe
, Qright_fringe
;
526 extern Lisp_Object QCmap
;
528 Lisp_Object
recursive_edit_unwind (), command_loop ();
529 Lisp_Object
Fthis_command_keys ();
530 Lisp_Object Qextended_command_history
;
531 EMACS_TIME
timer_check ();
533 extern Lisp_Object Vhistory_length
, Vtranslation_table_for_input
;
535 extern char *x_get_keysym_name ();
537 static void record_menu_key ();
538 static int echo_length ();
540 Lisp_Object Qpolling_period
;
542 /* List of absolute timers. Appears in order of next scheduled event. */
543 Lisp_Object Vtimer_list
;
545 /* List of idle time timers. Appears in order of next scheduled event. */
546 Lisp_Object Vtimer_idle_list
;
548 /* Incremented whenever a timer is run. */
551 extern Lisp_Object Vprint_level
, Vprint_length
;
553 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
555 EMACS_TIME
*input_available_clear_time
;
557 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
558 Default is 1 if INTERRUPT_INPUT is defined. */
561 /* Nonzero while interrupts are temporarily deferred during redisplay. */
562 int interrupts_deferred
;
564 /* Allow m- file to inhibit use of FIONREAD. */
565 #ifdef BROKEN_FIONREAD
569 /* We are unable to use interrupts if FIONREAD is not available,
570 so flush SIGIO so we won't try. */
571 #if !defined (FIONREAD)
577 /* If we support a window system, turn on the code to poll periodically
578 to detect C-g. It isn't actually used when doing interrupt input. */
579 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
580 #define POLL_FOR_INPUT
583 /* After a command is executed, if point is moved into a region that
584 has specific properties (e.g. composition, display), we adjust
585 point to the boundary of the region. But, if a command sets this
586 variable to non-nil, we suppress this point adjustment. This
587 variable is set to nil before reading a command. */
589 Lisp_Object Vdisable_point_adjustment
;
591 /* If non-nil, always disable point adjustment. */
593 Lisp_Object Vglobal_disable_point_adjustment
;
595 /* The time when Emacs started being idle. */
597 static EMACS_TIME timer_idleness_start_time
;
599 /* After Emacs stops being idle, this saves the last value
600 of timer_idleness_start_time from when it was idle. */
602 static EMACS_TIME timer_last_idleness_start_time
;
604 /* If non-nil, events produced by disabled menu items and tool-bar
605 buttons are not ignored. Help functions bind this to allow help on
606 those items and buttons. */
607 Lisp_Object Venable_disabled_menus_and_buttons
;
610 /* Global variable declarations. */
612 /* Flags for readable_events. */
613 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
614 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
615 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
617 /* Function for init_keyboard to call with no args (if nonzero). */
618 void (*keyboard_init_hook
) ();
620 static int read_avail_input
P_ ((int));
621 static void get_input_pending
P_ ((int *, int));
622 static int readable_events
P_ ((int));
623 static Lisp_Object read_char_x_menu_prompt
P_ ((int, Lisp_Object
*,
624 Lisp_Object
, int *));
625 static Lisp_Object
read_char_x_menu_prompt ();
626 static Lisp_Object read_char_minibuf_menu_prompt
P_ ((int, int,
628 static Lisp_Object make_lispy_event
P_ ((struct input_event
*));
629 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
630 static Lisp_Object make_lispy_movement
P_ ((struct frame
*, Lisp_Object
,
631 enum scroll_bar_part
,
632 Lisp_Object
, Lisp_Object
,
635 static Lisp_Object modify_event_symbol
P_ ((int, unsigned, Lisp_Object
,
636 Lisp_Object
, char **,
637 Lisp_Object
*, unsigned));
638 static Lisp_Object make_lispy_switch_frame
P_ ((Lisp_Object
));
639 static int parse_solitary_modifier
P_ ((Lisp_Object
));
640 static int parse_solitary_modifier ();
641 static void save_getcjmp
P_ ((jmp_buf));
642 static void save_getcjmp ();
643 static void restore_getcjmp
P_ ((jmp_buf));
644 static Lisp_Object apply_modifiers
P_ ((int, Lisp_Object
));
645 static void clear_event
P_ ((struct input_event
*));
647 static Lisp_Object restore_kboard_configuration
P_ ((Lisp_Object
));
649 static SIGTYPE interrupt_signal
P_ ((int signalnum
));
650 static void handle_interrupt
P_ ((void));
651 static void timer_start_idle
P_ ((void));
652 static void timer_stop_idle
P_ ((void));
653 static void timer_resume_idle
P_ ((void));
654 static SIGTYPE handle_user_signal
P_ ((int));
655 static char *find_user_signal_name
P_ ((int));
656 static int store_user_signal_events
P_ ((void));
658 /* Nonzero means don't try to suspend even if the operating system seems
660 static int cannot_suspend
;
662 extern Lisp_Object Qidentity
, Qonly
;
664 /* Install the string STR as the beginning of the string of echoing,
665 so that it serves as a prompt for the next character.
666 Also start echoing. */
672 current_kboard
->echo_string
= str
;
673 current_kboard
->echo_after_prompt
= SCHARS (str
);
677 /* Add C to the echo string, if echoing is going on.
678 C can be a character, which is printed prettily ("M-C-x" and all that
679 jazz), or a symbol, whose name is printed. */
685 if (current_kboard
->immediate_echo
)
687 int size
= KEY_DESCRIPTION_SIZE
+ 100;
688 char *buffer
= (char *) alloca (size
);
690 Lisp_Object echo_string
;
692 echo_string
= current_kboard
->echo_string
;
694 /* If someone has passed us a composite event, use its head symbol. */
699 ptr
= push_key_description (XINT (c
), ptr
, 1);
701 else if (SYMBOLP (c
))
703 Lisp_Object name
= SYMBOL_NAME (c
);
704 int nbytes
= SBYTES (name
);
706 if (size
- (ptr
- buffer
) < nbytes
)
708 int offset
= ptr
- buffer
;
709 size
= max (2 * size
, size
+ nbytes
);
710 buffer
= (char *) alloca (size
);
711 ptr
= buffer
+ offset
;
714 ptr
+= copy_text (SDATA (name
), ptr
, nbytes
,
715 STRING_MULTIBYTE (name
), 1);
718 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
721 const char *text
= " (Type ? for further options)";
722 int len
= strlen (text
);
724 if (size
- (ptr
- buffer
) < len
)
726 int offset
= ptr
- buffer
;
728 buffer
= (char *) alloca (size
);
729 ptr
= buffer
+ offset
;
732 bcopy (text
, ptr
, len
);
736 /* Replace a dash from echo_dash with a space, otherwise
737 add a space at the end as a separator between keys. */
738 if (STRINGP (echo_string
)
739 && SCHARS (echo_string
) > 1)
741 Lisp_Object last_char
, prev_char
, idx
;
743 idx
= make_number (SCHARS (echo_string
) - 2);
744 prev_char
= Faref (echo_string
, idx
);
746 idx
= make_number (SCHARS (echo_string
) - 1);
747 last_char
= Faref (echo_string
, idx
);
749 /* We test PREV_CHAR to make sure this isn't the echoing
751 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
752 Faset (echo_string
, idx
, make_number (' '));
754 echo_string
= concat2 (echo_string
, build_string (" "));
756 else if (STRINGP (echo_string
))
757 echo_string
= concat2 (echo_string
, build_string (" "));
759 current_kboard
->echo_string
760 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
766 /* Temporarily add a dash to the end of the echo string if it's not
767 empty, so that it serves as a mini-prompt for the very next character. */
772 /* Do nothing if not echoing at all. */
773 if (NILP (current_kboard
->echo_string
))
776 if (!current_kboard
->immediate_echo
777 && SCHARS (current_kboard
->echo_string
) == 0)
780 /* Do nothing if we just printed a prompt. */
781 if (current_kboard
->echo_after_prompt
782 == SCHARS (current_kboard
->echo_string
))
785 /* Do nothing if we have already put a dash at the end. */
786 if (SCHARS (current_kboard
->echo_string
) > 1)
788 Lisp_Object last_char
, prev_char
, idx
;
790 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 2);
791 prev_char
= Faref (current_kboard
->echo_string
, idx
);
793 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 1);
794 last_char
= Faref (current_kboard
->echo_string
, idx
);
796 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
800 /* Put a dash at the end of the buffer temporarily,
801 but make it go away when the next character is added. */
802 current_kboard
->echo_string
= concat2 (current_kboard
->echo_string
,
807 /* Display the current echo string, and begin echoing if not already
813 if (!current_kboard
->immediate_echo
)
816 current_kboard
->immediate_echo
= 1;
818 for (i
= 0; i
< this_command_key_count
; i
++)
822 /* Set before_command_echo_length to the value that would
823 have been saved before the start of this subcommand in
824 command_loop_1, if we had already been echoing then. */
825 if (i
== this_single_command_key_start
)
826 before_command_echo_length
= echo_length ();
828 c
= XVECTOR (this_command_keys
)->contents
[i
];
829 if (! (EVENT_HAS_PARAMETERS (c
)
830 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
834 /* Set before_command_echo_length to the value that would
835 have been saved before the start of this subcommand in
836 command_loop_1, if we had already been echoing then. */
837 if (this_command_key_count
== this_single_command_key_start
)
838 before_command_echo_length
= echo_length ();
840 /* Put a dash at the end to invite the user to type more. */
845 message3_nolog (current_kboard
->echo_string
,
846 SBYTES (current_kboard
->echo_string
),
847 STRING_MULTIBYTE (current_kboard
->echo_string
));
850 /* Record in what buffer we echoed, and from which kboard. */
851 echo_message_buffer
= echo_area_buffer
[0];
852 echo_kboard
= current_kboard
;
854 if (waiting_for_input
&& !NILP (Vquit_flag
))
855 quit_throw_to_read_char ();
858 /* Turn off echoing, for the start of a new command. */
863 current_kboard
->immediate_echo
= 0;
864 current_kboard
->echo_after_prompt
= -1;
865 current_kboard
->echo_string
= Qnil
;
866 ok_to_echo_at_next_pause
= NULL
;
868 echo_message_buffer
= Qnil
;
871 /* Return the length of the current echo string. */
876 return (STRINGP (current_kboard
->echo_string
)
877 ? SCHARS (current_kboard
->echo_string
)
881 /* Truncate the current echo message to its first LEN chars.
882 This and echo_char get used by read_key_sequence when the user
883 switches frames while entering a key sequence. */
886 echo_truncate (nchars
)
889 if (STRINGP (current_kboard
->echo_string
))
890 current_kboard
->echo_string
891 = Fsubstring (current_kboard
->echo_string
,
892 make_number (0), make_number (nchars
));
893 truncate_echo_area (nchars
);
897 /* Functions for manipulating this_command_keys. */
899 add_command_key (key
)
902 #if 0 /* Not needed after we made Freset_this_command_lengths
903 do the job immediately. */
904 /* If reset-this-command-length was called recently, obey it now.
905 See the doc string of that function for an explanation of why. */
906 if (before_command_restore_flag
)
908 this_command_key_count
= before_command_key_count_1
;
909 if (this_command_key_count
< this_single_command_key_start
)
910 this_single_command_key_start
= this_command_key_count
;
911 echo_truncate (before_command_echo_length_1
);
912 before_command_restore_flag
= 0;
916 if (this_command_key_count
>= ASIZE (this_command_keys
))
917 this_command_keys
= larger_vector (this_command_keys
,
918 2 * ASIZE (this_command_keys
),
921 AREF (this_command_keys
, this_command_key_count
) = key
;
922 ++this_command_key_count
;
929 int count
= SPECPDL_INDEX ();
932 if (command_loop_level
> 0)
934 specbind (Qstandard_output
, Qt
);
935 specbind (Qstandard_input
, Qt
);
938 #ifdef HAVE_X_WINDOWS
939 /* The command loop has started an hourglass timer, so we have to
940 cancel it here, otherwise it will fire because the recursive edit
941 can take some time. Do not check for display_hourglass_p here,
942 because it could already be nil. */
946 /* This function may have been called from a debugger called from
947 within redisplay, for instance by Edebugging a function called
948 from fontification-functions. We want to allow redisplay in
949 the debugging session.
951 The recursive edit is left with a `(throw exit ...)'. The `exit'
952 tag is not caught anywhere in redisplay, i.e. when we leave the
953 recursive edit, the original redisplay leading to the recursive
954 edit will be unwound. The outcome should therefore be safe. */
955 specbind (Qinhibit_redisplay
, Qnil
);
958 val
= command_loop ();
960 Fsignal (Qquit
, Qnil
);
961 /* Handle throw from read_minibuf when using minibuffer
962 while it's active but we're in another window. */
964 xsignal1 (Qerror
, val
);
966 return unbind_to (count
, Qnil
);
969 /* When an auto-save happens, record the "time", and don't do again soon. */
974 last_auto_save
= num_nonmacro_input_events
;
977 /* Make an auto save happen as soon as possible at command level. */
980 force_auto_save_soon ()
982 last_auto_save
= - auto_save_interval
- 1;
984 record_asynch_buffer_change ();
987 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
988 doc
: /* Invoke the editor command loop recursively.
989 To get out of the recursive edit, a command can do `(throw 'exit nil)';
990 that tells this function to return.
991 Alternatively, `(throw 'exit t)' makes this function signal an error.
992 This function is called by the editor initialization to begin editing. */)
995 int count
= SPECPDL_INDEX ();
998 /* If we enter while input is blocked, don't lock up here.
999 This may happen through the debugger during redisplay. */
1000 if (INPUT_BLOCKED_P
)
1003 command_loop_level
++;
1004 update_mode_lines
= 1;
1006 if (command_loop_level
1007 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
1008 buffer
= Fcurrent_buffer ();
1012 /* If we leave recursive_edit_1 below with a `throw' for instance,
1013 like it is done in the splash screen display, we have to
1014 make sure that we restore single_kboard as command_loop_1
1015 would have done if it were left normally. */
1016 if (command_loop_level
> 0)
1017 temporarily_switch_to_single_kboard (SELECTED_FRAME ());
1018 record_unwind_protect (recursive_edit_unwind
, buffer
);
1020 recursive_edit_1 ();
1021 return unbind_to (count
, Qnil
);
1025 recursive_edit_unwind (buffer
)
1028 if (BUFFERP (buffer
))
1029 Fset_buffer (buffer
);
1031 command_loop_level
--;
1032 update_mode_lines
= 1;
1037 #if 0 /* These two functions are now replaced with
1038 temporarily_switch_to_single_kboard. */
1043 #if 0 /* Theory: if there's anything in Vunread_command_events,
1044 it will right away be read by read_key_sequence,
1045 and then if we do switch KBOARDS, it will go into the side
1046 queue then. So we don't need to do anything special here -- rms. */
1047 if (CONSP (Vunread_command_events
))
1049 current_kboard
->kbd_queue
1050 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1051 current_kboard
->kbd_queue_has_data
= 1;
1053 Vunread_command_events
= Qnil
;
1059 /* Switch to the single-kboard state, making current_kboard
1060 the only KBOARD from which further input is accepted. */
1063 single_kboard_state ()
1071 /* If we're in single_kboard state for kboard KBOARD,
1075 not_single_kboard_state (kboard
)
1079 if (kboard
== current_kboard
)
1084 /* Maintain a stack of kboards, so other parts of Emacs
1085 can switch temporarily to the kboard of a given frame
1086 and then revert to the previous status. */
1091 struct kboard_stack
*next
;
1094 static struct kboard_stack
*kboard_stack
;
1101 struct kboard_stack
*p
1102 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1104 p
->next
= kboard_stack
;
1105 p
->kboard
= current_kboard
;
1117 struct kboard_stack
*p
= kboard_stack
;
1119 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
1121 if (t
->kboard
== p
->kboard
)
1123 current_kboard
= p
->kboard
;
1130 /* The terminal we remembered has been deleted. */
1131 current_kboard
= FRAME_KBOARD (SELECTED_FRAME ());
1134 kboard_stack
= p
->next
;
1139 /* Switch to single_kboard mode, making current_kboard the only KBOARD
1140 from which further input is accepted. If F is non-nil, set its
1141 KBOARD as the current keyboard.
1143 This function uses record_unwind_protect to return to the previous
1146 If Emacs is already in single_kboard mode, and F's keyboard is
1147 locked, then this function will throw an errow. */
1150 temporarily_switch_to_single_kboard (f
)
1154 int was_locked
= single_kboard
;
1157 if (f
!= NULL
&& FRAME_KBOARD (f
) != current_kboard
)
1158 /* We can not switch keyboards while in single_kboard mode.
1159 In rare cases, Lisp code may call `recursive-edit' (or
1160 `read-minibuffer' or `y-or-n-p') after it switched to a
1161 locked frame. For example, this is likely to happen
1162 when server.el connects to a new terminal while Emacs is in
1163 single_kboard mode. It is best to throw an error instead
1164 of presenting the user with a frozen screen. */
1165 error ("Terminal %d is locked, cannot read from it",
1166 FRAME_TERMINAL (f
)->id
);
1168 /* This call is unnecessary, but helps
1169 `restore_kboard_configuration' discover if somebody changed
1170 `current_kboard' behind our back. */
1171 push_kboard (current_kboard
);
1174 current_kboard
= FRAME_KBOARD (f
);
1176 record_unwind_protect (restore_kboard_configuration
,
1177 (was_locked
? Qt
: Qnil
));
1181 #if 0 /* This function is not needed anymore. */
1183 record_single_kboard_state ()
1186 push_kboard (current_kboard
);
1187 record_unwind_protect (restore_kboard_configuration
,
1188 (single_kboard
? Qt
: Qnil
));
1194 restore_kboard_configuration (was_locked
)
1195 Lisp_Object was_locked
;
1197 if (NILP (was_locked
))
1201 struct kboard
*prev
= current_kboard
;
1204 /* The pop should not change the kboard. */
1205 if (single_kboard
&& current_kboard
!= prev
)
1213 /* Handle errors that are not handled at inner levels
1214 by printing an error message and returning to the editor command loop. */
1220 Lisp_Object old_level
, old_length
;
1221 char macroerror
[50];
1223 #ifdef HAVE_X_WINDOWS
1224 if (display_hourglass_p
)
1225 cancel_hourglass ();
1228 if (!NILP (executing_kbd_macro
))
1230 if (executing_kbd_macro_iterations
== 1)
1231 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1233 sprintf (macroerror
, "After %d kbd macro iterations: ",
1234 executing_kbd_macro_iterations
);
1239 Vstandard_output
= Qt
;
1240 Vstandard_input
= Qt
;
1241 Vexecuting_kbd_macro
= Qnil
;
1242 executing_kbd_macro
= Qnil
;
1243 current_kboard
->Vprefix_arg
= Qnil
;
1244 current_kboard
->Vlast_prefix_arg
= Qnil
;
1247 /* Avoid unquittable loop if data contains a circular list. */
1248 old_level
= Vprint_level
;
1249 old_length
= Vprint_length
;
1250 XSETFASTINT (Vprint_level
, 10);
1251 XSETFASTINT (Vprint_length
, 10);
1252 cmd_error_internal (data
, macroerror
);
1253 Vprint_level
= old_level
;
1254 Vprint_length
= old_length
;
1258 Vinhibit_quit
= Qnil
;
1259 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1261 if (command_loop_level
== 0 && minibuf_level
== 0)
1262 any_kboard_state ();
1266 return make_number (0);
1269 /* Take actions on handling an error. DATA is the data that describes
1272 CONTEXT is a C-string containing ASCII characters only which
1273 describes the context in which the error happened. If we need to
1274 generalize CONTEXT to allow multibyte characters, make it a Lisp
1278 cmd_error_internal (data
, context
)
1282 struct frame
*sf
= SELECTED_FRAME ();
1284 /* The immediate context is not interesting for Quits,
1285 since they are asyncronous. */
1286 if (EQ (XCAR (data
), Qquit
))
1287 Vsignaling_function
= Qnil
;
1292 /* Use user's specified output function if any. */
1293 if (!NILP (Vcommand_error_function
))
1294 call3 (Vcommand_error_function
, data
,
1295 context
? build_string (context
) : empty_unibyte_string
,
1296 Vsignaling_function
);
1297 /* If the window system or terminal frame hasn't been initialized
1298 yet, or we're not interactive, write the message to stderr and exit. */
1299 else if (!sf
->glyphs_initialized_p
1300 || FRAME_INITIAL_P (sf
)
1303 print_error_message (data
, Qexternal_debugging_output
,
1304 context
, Vsignaling_function
);
1305 Fterpri (Qexternal_debugging_output
);
1306 Fkill_emacs (make_number (-1));
1310 clear_message (1, 0);
1312 message_log_maybe_newline ();
1315 print_error_message (data
, Qt
, context
, Vsignaling_function
);
1318 Vsignaling_function
= Qnil
;
1321 Lisp_Object
command_loop_1 ();
1322 Lisp_Object
command_loop_2 ();
1323 Lisp_Object
top_level_1 ();
1325 /* Entry to editor-command-loop.
1326 This level has the catches for exiting/returning to editor command loop.
1327 It returns nil to exit recursive edit, t to abort it. */
1332 if (command_loop_level
> 0 || minibuf_level
> 0)
1335 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1336 executing_kbd_macro
= Qnil
;
1342 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1343 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1344 /* Reset single_kboard in case top-level set it while
1345 evaluating an -f option, or we are stuck there for some
1347 any_kboard_state ();
1349 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1350 executing_kbd_macro
= Qnil
;
1352 /* End of file in -batch run causes exit here. */
1358 /* Here we catch errors in execution of commands within the
1359 editing loop, and reenter the editing loop.
1360 When there is an error, cmd_error runs and returns a non-nil
1361 value to us. A value of nil means that command_loop_1 itself
1362 returned due to end of file (or end of kbd macro). */
1367 register Lisp_Object val
;
1370 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1371 while (!NILP (val
));
1379 return Feval (Vtop_level
);
1385 /* On entry to the outer level, run the startup file */
1386 if (!NILP (Vtop_level
))
1387 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1388 else if (!NILP (Vpurify_flag
))
1389 message ("Bare impure Emacs (standard Lisp code not loaded)");
1391 message ("Bare Emacs (standard Lisp code not loaded)");
1395 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1396 doc
: /* Exit all recursive editing levels. */)
1399 #ifdef HAVE_X_WINDOWS
1400 if (display_hourglass_p
)
1401 cancel_hourglass ();
1404 /* Unblock input if we enter with input blocked. This may happen if
1405 redisplay traps e.g. during tool-bar update with input blocked. */
1406 while (INPUT_BLOCKED_P
)
1409 return Fthrow (Qtop_level
, Qnil
);
1412 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1413 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1416 if (command_loop_level
> 0 || minibuf_level
> 0)
1417 Fthrow (Qexit
, Qnil
);
1419 error ("No recursive edit is in progress");
1423 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1424 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1427 if (command_loop_level
> 0 || minibuf_level
> 0)
1430 error ("No recursive edit is in progress");
1434 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1436 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1437 of this function. */
1440 tracking_off (old_value
)
1441 Lisp_Object old_value
;
1443 do_mouse_tracking
= old_value
;
1444 if (NILP (old_value
))
1446 /* Redisplay may have been preempted because there was input
1447 available, and it assumes it will be called again after the
1448 input has been processed. If the only input available was
1449 the sort that we have just disabled, then we need to call
1451 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW
))
1453 redisplay_preserve_echo_area (6);
1454 get_input_pending (&input_pending
,
1455 READABLE_EVENTS_DO_TIMERS_NOW
);
1461 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
1462 doc
: /* Evaluate BODY with mouse movement events enabled.
1463 Within a `track-mouse' form, mouse motion generates input events that
1464 you can read with `read-event'.
1465 Normally, mouse motion is ignored.
1466 usage: (track-mouse BODY...) */)
1470 int count
= SPECPDL_INDEX ();
1473 record_unwind_protect (tracking_off
, do_mouse_tracking
);
1475 do_mouse_tracking
= Qt
;
1477 val
= Fprogn (args
);
1478 return unbind_to (count
, val
);
1481 /* If mouse has moved on some frame, return one of those frames.
1485 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1486 after resizing the tool-bar window. */
1488 int ignore_mouse_drag_p
;
1493 Lisp_Object tail
, frame
;
1495 if (ignore_mouse_drag_p
)
1497 /* ignore_mouse_drag_p = 0; */
1501 FOR_EACH_FRAME (tail
, frame
)
1503 if (XFRAME (frame
)->mouse_moved
)
1504 return XFRAME (frame
);
1510 #endif /* HAVE_MOUSE || HAVE_GPM */
1512 /* This is the actual command reading loop,
1513 sans error-handling encapsulation. */
1515 static int read_key_sequence
P_ ((Lisp_Object
*, int, Lisp_Object
,
1517 void safe_run_hooks
P_ ((Lisp_Object
));
1518 static void adjust_point_for_property
P_ ((int, int));
1520 /* Cancel hourglass from protect_unwind.
1522 #ifdef HAVE_X_WINDOWS
1524 cancel_hourglass_unwind (arg
)
1527 cancel_hourglass ();
1538 Lisp_Object keybuf
[30];
1540 int prev_modiff
= 0;
1541 struct buffer
*prev_buffer
= NULL
;
1542 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1544 int was_locked
= single_kboard
;
1547 int already_adjusted
= 0;
1549 current_kboard
->Vprefix_arg
= Qnil
;
1550 current_kboard
->Vlast_prefix_arg
= Qnil
;
1551 Vdeactivate_mark
= Qnil
;
1552 waiting_for_input
= 0;
1556 this_command_key_count
= 0;
1557 this_command_key_count_reset
= 0;
1558 this_single_command_key_start
= 0;
1560 if (NILP (Vmemory_full
))
1562 /* Make sure this hook runs after commands that get errors and
1563 throw to top level. */
1564 /* Note that the value cell will never directly contain nil
1565 if the symbol is a local variable. */
1566 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1567 safe_run_hooks (Qpost_command_hook
);
1569 /* If displaying a message, resize the echo area window to fit
1570 that message's size exactly. */
1571 if (!NILP (echo_area_buffer
[0]))
1572 resize_echo_area_exactly ();
1574 if (!NILP (Vdeferred_action_list
))
1575 safe_run_hooks (Qdeferred_action_function
);
1578 /* Do this after running Vpost_command_hook, for consistency. */
1579 current_kboard
->Vlast_command
= Vthis_command
;
1580 current_kboard
->Vreal_last_command
= real_this_command
;
1581 if (!CONSP (last_command_char
))
1582 current_kboard
->Vlast_repeatable_command
= real_this_command
;
1586 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1589 /* Make sure the current window's buffer is selected. */
1590 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1591 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1593 /* Display any malloc warning that just came out. Use while because
1594 displaying one warning can cause another. */
1596 while (pending_malloc_warning
)
1597 display_malloc_warning ();
1599 Vdeactivate_mark
= Qnil
;
1601 /* If minibuffer on and echo area in use,
1602 wait a short time and redraw minibuffer. */
1605 && !NILP (echo_area_buffer
[0])
1606 && EQ (minibuf_window
, echo_area_window
))
1608 /* Bind inhibit-quit to t so that C-g gets read in
1609 rather than quitting back to the minibuffer. */
1610 int count
= SPECPDL_INDEX ();
1611 specbind (Qinhibit_quit
, Qt
);
1613 if (NUMBERP (Vminibuffer_message_timeout
))
1614 sit_for (Vminibuffer_message_timeout
, 0, 2);
1618 /* Clear the echo area. */
1620 safe_run_hooks (Qecho_area_clear_hook
);
1622 unbind_to (count
, Qnil
);
1624 /* If a C-g came in before, treat it as input now. */
1625 if (!NILP (Vquit_flag
))
1628 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1633 /* Select the frame that the last event came from. Usually,
1634 switch-frame events will take care of this, but if some lisp
1635 code swallows a switch-frame event, we'll fix things up here.
1636 Is this a good idea? */
1637 if (FRAMEP (internal_last_event_frame
)
1638 && !EQ (internal_last_event_frame
, selected_frame
))
1639 Fselect_frame (internal_last_event_frame
);
1641 /* If it has changed current-menubar from previous value,
1642 really recompute the menubar from the value. */
1643 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1644 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1645 call0 (Qrecompute_lucid_menubar
);
1647 before_command_key_count
= this_command_key_count
;
1648 before_command_echo_length
= echo_length ();
1650 Vthis_command
= Qnil
;
1651 real_this_command
= Qnil
;
1652 Vthis_original_command
= Qnil
;
1654 /* Read next key sequence; i gets its length. */
1655 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1658 /* A filter may have run while we were reading the input. */
1659 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1661 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1662 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1666 /* Now we have read a key sequence of length I,
1667 or else I is 0 and we found end of file. */
1669 if (i
== 0) /* End of file -- happens only in */
1670 return Qnil
; /* a kbd macro, at the end. */
1671 /* -1 means read_key_sequence got a menu that was rejected.
1672 Just loop around and read another command. */
1676 this_command_key_count
= 0;
1677 this_command_key_count_reset
= 0;
1678 this_single_command_key_start
= 0;
1682 last_command_char
= keybuf
[i
- 1];
1684 /* If the previous command tried to force a specific window-start,
1685 forget about that, in case this command moves point far away
1686 from that position. But also throw away beg_unchanged and
1687 end_unchanged information in that case, so that redisplay will
1688 update the whole window properly. */
1689 if (!NILP (XWINDOW (selected_window
)->force_start
))
1692 XWINDOW (selected_window
)->force_start
= Qnil
;
1693 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1694 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1697 cmd
= read_key_sequence_cmd
;
1698 if (!NILP (Vexecuting_kbd_macro
))
1700 if (!NILP (Vquit_flag
))
1702 Vexecuting_kbd_macro
= Qt
;
1703 QUIT
; /* Make some noise. */
1704 /* Will return since macro now empty. */
1708 /* Do redisplay processing after this command except in special
1709 cases identified below. */
1710 prev_buffer
= current_buffer
;
1711 prev_modiff
= MODIFF
;
1712 last_point_position
= PT
;
1713 last_point_position_window
= selected_window
;
1714 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1716 /* By default, we adjust point to a boundary of a region that
1717 has such a property that should be treated intangible
1718 (e.g. composition, display). But, some commands will set
1719 this variable differently. */
1720 Vdisable_point_adjustment
= Qnil
;
1722 /* Process filters and timers may have messed with deactivate-mark.
1723 reset it before we execute the command. */
1724 Vdeactivate_mark
= Qnil
;
1726 /* Remap command through active keymaps */
1727 Vthis_original_command
= cmd
;
1731 if (cmd1
= Fcommand_remapping (cmd
, Qnil
, Qnil
), !NILP (cmd1
))
1735 /* Execute the command. */
1737 Vthis_command
= cmd
;
1738 real_this_command
= cmd
;
1739 /* Note that the value cell will never directly contain nil
1740 if the symbol is a local variable. */
1741 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1742 safe_run_hooks (Qpre_command_hook
);
1744 already_adjusted
= 0;
1746 if (NILP (Vthis_command
))
1748 /* nil means key is undefined. */
1749 Lisp_Object keys
= Fvector (i
, keybuf
);
1750 keys
= Fkey_description (keys
, Qnil
);
1752 message_with_string ("%s is undefined", keys
, 0);
1753 current_kboard
->defining_kbd_macro
= Qnil
;
1754 update_mode_lines
= 1;
1755 current_kboard
->Vprefix_arg
= Qnil
;
1759 if (NILP (current_kboard
->Vprefix_arg
))
1761 /* In case we jump to directly_done. */
1762 Vcurrent_prefix_arg
= current_kboard
->Vprefix_arg
;
1764 /* Recognize some common commands in common situations and
1765 do them directly. */
1766 if (EQ (Vthis_command
, Qforward_char
) && PT
< ZV
)
1768 struct Lisp_Char_Table
*dp
1769 = window_display_table (XWINDOW (selected_window
));
1770 lose
= FETCH_CHAR (PT_BYTE
);
1772 if (! NILP (Vpost_command_hook
))
1773 /* Put this before calling adjust_point_for_property
1774 so it will only get called once in any case. */
1776 if (current_buffer
== prev_buffer
1777 && last_point_position
!= PT
1778 && NILP (Vdisable_point_adjustment
)
1779 && NILP (Vglobal_disable_point_adjustment
))
1780 adjust_point_for_property (last_point_position
, 0);
1781 already_adjusted
= 1;
1782 if (PT
== last_point_position
+ 1
1784 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1785 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1786 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1787 && (lose
>= 0x20 && lose
< 0x7f)))
1788 : (lose
>= 0x20 && lose
< 0x7f))
1789 /* To extract the case of continuation on
1790 wide-column characters. */
1791 && (WIDTH_BY_CHAR_HEAD (FETCH_BYTE (PT_BYTE
)) == 1)
1792 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1794 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1796 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1798 && !windows_or_buffers_changed
1799 && EQ (current_buffer
->selective_display
, Qnil
)
1800 && !detect_input_pending ()
1801 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1802 && NILP (Vexecuting_kbd_macro
))
1803 direct_output_forward_char (1);
1806 else if (EQ (Vthis_command
, Qbackward_char
) && PT
> BEGV
)
1808 struct Lisp_Char_Table
*dp
1809 = window_display_table (XWINDOW (selected_window
));
1811 lose
= FETCH_CHAR (PT_BYTE
);
1812 if (! NILP (Vpost_command_hook
))
1814 if (current_buffer
== prev_buffer
1815 && last_point_position
!= PT
1816 && NILP (Vdisable_point_adjustment
)
1817 && NILP (Vglobal_disable_point_adjustment
))
1818 adjust_point_for_property (last_point_position
, 0);
1819 already_adjusted
= 1;
1820 if (PT
== last_point_position
- 1
1822 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1823 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1824 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1825 && (lose
>= 0x20 && lose
< 0x7f)))
1826 : (lose
>= 0x20 && lose
< 0x7f))
1827 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1829 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1831 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1833 && !windows_or_buffers_changed
1834 && EQ (current_buffer
->selective_display
, Qnil
)
1835 && !detect_input_pending ()
1836 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1837 && NILP (Vexecuting_kbd_macro
))
1838 direct_output_forward_char (-1);
1841 else if (EQ (Vthis_command
, Qself_insert_command
)
1842 /* Try this optimization only on char keystrokes. */
1843 && NATNUMP (last_command_char
)
1844 && CHAR_VALID_P (XFASTINT (last_command_char
), 0))
1847 = translate_char (Vtranslation_table_for_input
,
1848 XFASTINT (last_command_char
), 0, 0, 0);
1850 if (NILP (Vexecuting_kbd_macro
)
1851 && !EQ (minibuf_window
, selected_window
))
1853 if (!nonundocount
|| nonundocount
>= 20)
1861 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1863 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1865 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1867 || MODIFF
<= SAVE_MODIFF
1868 || windows_or_buffers_changed
1869 || !EQ (current_buffer
->selective_display
, Qnil
)
1870 || detect_input_pending ()
1871 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1872 || !NILP (Vexecuting_kbd_macro
));
1874 value
= internal_self_insert (c
, 0);
1879 if (! NILP (Vpost_command_hook
))
1880 /* Put this before calling adjust_point_for_property
1881 so it will only get called once in any case. */
1884 /* VALUE == 1 when AFTER-CHANGE functions are
1885 installed which is the case most of the time
1886 because FONT-LOCK installs one. */
1887 if (!lose
&& !value
)
1888 direct_output_for_insert (c
);
1893 /* Here for a command that isn't executed directly */
1896 #ifdef HAVE_X_WINDOWS
1897 int scount
= SPECPDL_INDEX ();
1899 if (display_hourglass_p
1900 && NILP (Vexecuting_kbd_macro
))
1902 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1908 if (NILP (current_kboard
->Vprefix_arg
))
1910 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1912 #ifdef HAVE_X_WINDOWS
1913 /* Do not check display_hourglass_p here, because
1914 Fcommand_execute could change it, but we should cancel
1915 hourglass cursor anyway.
1916 But don't cancel the hourglass within a macro
1917 just because a command in the macro finishes. */
1918 if (NILP (Vexecuting_kbd_macro
))
1919 unbind_to (scount
, Qnil
);
1924 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1926 /* Note that the value cell will never directly contain nil
1927 if the symbol is a local variable. */
1928 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1929 safe_run_hooks (Qpost_command_hook
);
1931 /* If displaying a message, resize the echo area window to fit
1932 that message's size exactly. */
1933 if (!NILP (echo_area_buffer
[0]))
1934 resize_echo_area_exactly ();
1936 if (!NILP (Vdeferred_action_list
))
1937 safe_run_hooks (Qdeferred_action_function
);
1939 /* If there is a prefix argument,
1940 1) We don't want Vlast_command to be ``universal-argument''
1941 (that would be dumb), so don't set Vlast_command,
1942 2) we want to leave echoing on so that the prefix will be
1943 echoed as part of this key sequence, so don't call
1945 3) we want to leave this_command_key_count non-zero, so that
1946 read_char will realize that it is re-reading a character, and
1947 not echo it a second time.
1949 If the command didn't actually create a prefix arg,
1950 but is merely a frame event that is transparent to prefix args,
1951 then the above doesn't apply. */
1952 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_char
))
1954 current_kboard
->Vlast_command
= Vthis_command
;
1955 current_kboard
->Vreal_last_command
= real_this_command
;
1956 if (!CONSP (last_command_char
))
1957 current_kboard
->Vlast_repeatable_command
= real_this_command
;
1959 this_command_key_count
= 0;
1960 this_command_key_count_reset
= 0;
1961 this_single_command_key_start
= 0;
1964 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1966 /* Setting transient-mark-mode to `only' is a way of
1967 turning it on for just one command. */
1969 if (EQ (Vtransient_mark_mode
, Qidentity
))
1970 Vtransient_mark_mode
= Qnil
;
1971 if (EQ (Vtransient_mark_mode
, Qonly
))
1972 Vtransient_mark_mode
= Qidentity
;
1974 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
1976 /* We could also call `deactivate'mark'. */
1977 if (EQ (Vtransient_mark_mode
, Qlambda
))
1978 Vtransient_mark_mode
= Qnil
;
1981 current_buffer
->mark_active
= Qnil
;
1982 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
1985 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1986 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1991 if (current_buffer
== prev_buffer
1992 && last_point_position
!= PT
1993 && NILP (Vdisable_point_adjustment
)
1994 && NILP (Vglobal_disable_point_adjustment
)
1995 && !already_adjusted
)
1996 adjust_point_for_property (last_point_position
, MODIFF
!= prev_modiff
);
1998 /* Install chars successfully executed in kbd macro. */
2000 if (!NILP (current_kboard
->defining_kbd_macro
)
2001 && NILP (current_kboard
->Vprefix_arg
))
2002 finalize_kbd_macro_chars ();
2003 #if 0 /* This shouldn't be necessary anymore. --lorentey */
2006 any_kboard_state ();
2012 extern Lisp_Object Qcomposition
, Qdisplay
;
2014 /* Adjust point to a boundary of a region that has such a property
2015 that should be treated intangible. For the moment, we check
2016 `composition', `display' and `invisible' properties.
2017 LAST_PT is the last position of point. */
2019 extern Lisp_Object Qafter_string
, Qbefore_string
;
2020 extern Lisp_Object get_pos_property
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
2023 adjust_point_for_property (last_pt
, modified
)
2028 Lisp_Object val
, overlay
, tmp
;
2029 int check_composition
= 1, check_display
= 1, check_invisible
= 1;
2032 /* FIXME: cycling is probably not necessary because these properties
2033 can't be usefully combined anyway. */
2034 while (check_composition
|| check_display
|| check_invisible
)
2036 if (check_composition
2037 && PT
> BEGV
&& PT
< ZV
2038 && get_property_and_range (PT
, Qcomposition
, &val
, &beg
, &end
, Qnil
)
2039 && COMPOSITION_VALID_P (beg
, end
, val
)
2040 && beg
< PT
/* && end > PT <- It's always the case. */
2041 && (last_pt
<= beg
|| last_pt
>= end
))
2044 SET_PT (PT
< last_pt
? beg
: end
);
2045 check_display
= check_invisible
= 1;
2047 check_composition
= 0;
2049 && PT
> BEGV
&& PT
< ZV
2050 && !NILP (val
= get_char_property_and_overlay
2051 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
2052 && display_prop_intangible_p (val
)
2053 && (!OVERLAYP (overlay
)
2054 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
2055 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
2056 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
2057 && (beg
< PT
/* && end > PT <- It's always the case. */
2058 || (beg
<= PT
&& STRINGP (val
) && SCHARS (val
) == 0)))
2061 SET_PT (PT
< last_pt
2062 ? (STRINGP (val
) && SCHARS (val
) == 0 ? beg
- 1 : beg
)
2064 check_composition
= check_invisible
= 1;
2067 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
2069 int inv
, ellipsis
= 0;
2072 /* Find boundaries `beg' and `end' of the invisible area, if any. */
2074 && !NILP (val
= get_char_property_and_overlay
2075 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
2076 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
2078 ellipsis
= ellipsis
|| inv
> 1
2079 || (OVERLAYP (overlay
)
2080 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
2081 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
2082 tmp
= Fnext_single_char_property_change
2083 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
2084 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
2087 && !NILP (val
= get_char_property_and_overlay
2088 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
2089 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
2091 ellipsis
= ellipsis
|| inv
> 1
2092 || (OVERLAYP (overlay
)
2093 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
2094 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
2095 tmp
= Fprevious_single_char_property_change
2096 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
2097 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
2100 /* Move away from the inside area. */
2101 if (beg
< PT
&& end
> PT
)
2103 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
2104 /* We haven't moved yet (so we don't need to fear
2105 infinite-looping) and we were outside the range
2106 before (so either end of the range still corresponds
2107 to a move in the right direction): pretend we moved
2108 less than we actually did, so that we still have
2109 more freedom below in choosing which end of the range
2111 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
2112 /* We either have moved already or the last point
2113 was already in the range: we don't get to choose
2114 which end of the range we have to go to. */
2115 : (PT
< last_pt
? beg
: end
));
2116 check_composition
= check_display
= 1;
2118 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
2119 the point to something other than its argument, due to
2120 point-motion hooks, intangibility, etc. */
2121 xassert (PT
== beg
|| PT
== end
);
2124 /* Pretend the area doesn't exist if the buffer is not
2126 if (!modified
&& !ellipsis
&& beg
< end
)
2128 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
2129 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
2130 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
2131 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
2132 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
2133 /* We've already moved as far as we can. Trying to go
2134 to the other end would mean moving backwards and thus
2135 could lead to an infinite loop. */
2137 else if (val
= get_pos_property (make_number (PT
),
2139 TEXT_PROP_MEANS_INVISIBLE (val
)
2140 && (val
= get_pos_property
2141 (make_number (PT
== beg
? end
: beg
),
2143 !TEXT_PROP_MEANS_INVISIBLE (val
)))
2144 (check_composition
= check_display
= 1,
2145 SET_PT (PT
== beg
? end
: beg
));
2148 check_invisible
= 0;
2152 /* Subroutine for safe_run_hooks: run the hook HOOK. */
2155 safe_run_hooks_1 (hook
)
2158 if (NILP (Vrun_hooks
))
2160 return call1 (Vrun_hooks
, Vinhibit_quit
);
2163 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
2166 safe_run_hooks_error (data
)
2169 Lisp_Object args
[3];
2170 args
[0] = build_string ("Error in %s: %s");
2171 args
[1] = Vinhibit_quit
;
2174 return Fset (Vinhibit_quit
, Qnil
);
2177 /* If we get an error while running the hook, cause the hook variable
2178 to be nil. Also inhibit quits, so that C-g won't cause the hook
2179 to mysteriously evaporate. */
2182 safe_run_hooks (hook
)
2185 int count
= SPECPDL_INDEX ();
2186 specbind (Qinhibit_quit
, hook
);
2188 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
2190 unbind_to (count
, Qnil
);
2194 /* Number of seconds between polling for input. This is a Lisp
2195 variable that can be bound. */
2197 EMACS_INT polling_period
;
2199 /* Nonzero means polling for input is temporarily suppressed. */
2201 int poll_suppress_count
;
2203 /* Asynchronous timer for polling. */
2205 struct atimer
*poll_timer
;
2208 #ifdef POLL_FOR_INPUT
2210 /* Poll for input, so what we catch a C-g if it comes in. This
2211 function is called from x_make_frame_visible, see comment
2217 if (interrupt_input_blocked
== 0
2218 && !waiting_for_input
)
2219 read_avail_input (0);
2222 /* Timer callback function for poll_timer. TIMER is equal to
2226 poll_for_input (timer
)
2227 struct atimer
*timer
;
2229 if (poll_suppress_count
== 0)
2231 interrupt_input_pending
= 1;
2233 poll_for_input_1 ();
2237 #endif /* POLL_FOR_INPUT */
2239 /* Begin signals to poll for input, if they are appropriate.
2240 This function is called unconditionally from various places. */
2245 #ifdef POLL_FOR_INPUT
2246 /* XXX This condition was (read_socket_hook && !interrupt_input),
2247 but read_socket_hook is not global anymore. Let's pretend that
2249 if (!interrupt_input
)
2251 /* Turn alarm handling on unconditionally. It might have
2252 been turned off in process.c. */
2253 turn_on_atimers (1);
2255 /* If poll timer doesn't exist, are we need one with
2256 a different interval, start a new one. */
2257 if (poll_timer
== NULL
2258 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2260 EMACS_TIME interval
;
2263 cancel_atimer (poll_timer
);
2265 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
2266 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2267 poll_for_input
, NULL
);
2270 /* Let the timer's callback function poll for input
2271 if this becomes zero. */
2272 --poll_suppress_count
;
2277 /* Nonzero if we are using polling to handle input asynchronously. */
2280 input_polling_used ()
2282 #ifdef POLL_FOR_INPUT
2283 /* XXX This condition was (read_socket_hook && !interrupt_input),
2284 but read_socket_hook is not global anymore. Let's pretend that
2286 return !interrupt_input
;
2292 /* Turn off polling. */
2297 #ifdef POLL_FOR_INPUT
2298 /* XXX This condition was (read_socket_hook && !interrupt_input),
2299 but read_socket_hook is not global anymore. Let's pretend that
2301 if (!interrupt_input
)
2302 ++poll_suppress_count
;
2306 /* Set the value of poll_suppress_count to COUNT
2307 and start or stop polling accordingly. */
2310 set_poll_suppress_count (count
)
2313 #ifdef POLL_FOR_INPUT
2314 if (count
== 0 && poll_suppress_count
!= 0)
2316 poll_suppress_count
= 1;
2319 else if (count
!= 0 && poll_suppress_count
== 0)
2323 poll_suppress_count
= count
;
2327 /* Bind polling_period to a value at least N.
2328 But don't decrease it. */
2331 bind_polling_period (n
)
2334 #ifdef POLL_FOR_INPUT
2335 int new = polling_period
;
2340 stop_other_atimers (poll_timer
);
2342 specbind (Qpolling_period
, make_number (new));
2343 /* Start a new alarm with the new period. */
2348 /* Apply the control modifier to CHARACTER. */
2354 /* Save the upper bits here. */
2355 int upper
= c
& ~0177;
2359 /* Everything in the columns containing the upper-case letters
2360 denotes a control character. */
2361 if (c
>= 0100 && c
< 0140)
2365 /* Set the shift modifier for a control char
2366 made from a shifted letter. But only for letters! */
2367 if (oc
>= 'A' && oc
<= 'Z')
2368 c
|= shift_modifier
;
2371 /* The lower-case letters denote control characters too. */
2372 else if (c
>= 'a' && c
<= 'z')
2375 /* Include the bits for control and shift
2376 only if the basic ASCII code can't indicate them. */
2380 /* Replace the high bits. */
2381 c
|= (upper
& ~ctrl_modifier
);
2386 /* Display the help-echo property of the character after the mouse pointer.
2387 Either show it in the echo area, or call show-help-function to display
2388 it by other means (maybe in a tooltip).
2390 If HELP is nil, that means clear the previous help echo.
2392 If HELP is a string, display that string. If HELP is a function,
2393 call it with OBJECT and POS as arguments; the function should
2394 return a help string or nil for none. For all other types of HELP,
2395 evaluate it to obtain a string.
2397 WINDOW is the window in which the help was generated, if any.
2398 It is nil if not in a window.
2400 If OBJECT is a buffer, POS is the position in the buffer where the
2401 `help-echo' text property was found.
2403 If OBJECT is an overlay, that overlay has a `help-echo' property,
2404 and POS is the position in the overlay's buffer under the mouse.
2406 If OBJECT is a string (an overlay string or a string displayed with
2407 the `display' property). POS is the position in that string under
2410 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2411 echo overwrites a keystroke echo currently displayed in the echo
2414 Note: this function may only be called with HELP nil or a string
2415 from X code running asynchronously. */
2418 show_help_echo (help
, window
, object
, pos
, ok_to_overwrite_keystroke_echo
)
2419 Lisp_Object help
, window
, object
, pos
;
2420 int ok_to_overwrite_keystroke_echo
;
2422 if (!NILP (help
) && !STRINGP (help
))
2424 if (FUNCTIONP (help
))
2426 Lisp_Object args
[4];
2431 help
= safe_call (4, args
);
2434 help
= safe_eval (help
);
2436 if (!STRINGP (help
))
2440 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
2441 if (!noninteractive
&& STRINGP (help
))
2443 /* The mouse-fixup-help-message Lisp function can call
2444 mouse_position_hook, which resets the mouse_moved flags.
2445 This causes trouble if we are trying to read a mouse motion
2446 event (i.e., if we are inside a `track-mouse' form), so we
2447 restore the mouse_moved flag. */
2448 FRAME_PTR f
= NILP (do_mouse_tracking
) ? NULL
: some_mouse_moved ();
2449 help
= call1 (Qmouse_fixup_help_message
, help
);
2455 if (STRINGP (help
) || NILP (help
))
2457 if (!NILP (Vshow_help_function
))
2458 call1 (Vshow_help_function
, help
);
2459 else if (/* Don't overwrite minibuffer contents. */
2460 !MINI_WINDOW_P (XWINDOW (selected_window
))
2461 /* Don't overwrite a keystroke echo. */
2462 && (NILP (echo_message_buffer
)
2463 || ok_to_overwrite_keystroke_echo
)
2464 /* Don't overwrite a prompt. */
2465 && !cursor_in_echo_area
)
2469 int count
= SPECPDL_INDEX ();
2471 if (!help_echo_showing_p
)
2472 Vpre_help_message
= current_message ();
2474 specbind (Qmessage_truncate_lines
, Qt
);
2475 message3_nolog (help
, SBYTES (help
),
2476 STRING_MULTIBYTE (help
));
2477 unbind_to (count
, Qnil
);
2479 else if (STRINGP (Vpre_help_message
))
2481 message3_nolog (Vpre_help_message
,
2482 SBYTES (Vpre_help_message
),
2483 STRING_MULTIBYTE (Vpre_help_message
));
2484 Vpre_help_message
= Qnil
;
2490 help_echo_showing_p
= STRINGP (help
);
2496 /* Input of single characters from keyboard */
2498 Lisp_Object
print_help ();
2499 static Lisp_Object
kbd_buffer_get_event ();
2500 static void record_char ();
2502 static Lisp_Object help_form_saved_window_configs
;
2504 read_char_help_form_unwind (arg
)
2506 Lisp_Object window_config
= XCAR (help_form_saved_window_configs
);
2507 help_form_saved_window_configs
= XCDR (help_form_saved_window_configs
);
2508 if (!NILP (window_config
))
2509 Fset_window_configuration (window_config
);
2513 #define STOP_POLLING \
2514 do { if (! polling_stopped_here) stop_polling (); \
2515 polling_stopped_here = 1; } while (0)
2517 #define RESUME_POLLING \
2518 do { if (polling_stopped_here) start_polling (); \
2519 polling_stopped_here = 0; } while (0)
2521 /* read a character from the keyboard; call the redisplay if needed */
2522 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2523 -1 means do not do redisplay, but do do autosaving.
2526 /* The arguments MAPS and NMAPS are for menu prompting.
2527 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2529 PREV_EVENT is the previous input event, or nil if we are reading
2530 the first event of a key sequence (or not reading a key sequence).
2531 If PREV_EVENT is t, that is a "magic" value that says
2532 not to run input methods, but in other respects to act as if
2533 not reading a key sequence.
2535 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2536 if we used a mouse menu to read the input, or zero otherwise. If
2537 USED_MOUSE_MENU is null, we don't dereference it.
2539 Value is -2 when we find input on another keyboard. A second call
2540 to read_char will read it.
2542 If END_TIME is non-null, it is a pointer to an EMACS_TIME
2543 specifying the maximum time to wait until. If no input arrives by
2544 that time, stop waiting and return nil.
2546 Value is t if we showed a menu and the user rejected it. */
2549 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
, end_time
)
2553 Lisp_Object prev_event
;
2554 int *used_mouse_menu
;
2555 EMACS_TIME
*end_time
;
2557 volatile Lisp_Object c
;
2558 int count
, jmpcount
;
2559 jmp_buf local_getcjmp
;
2561 volatile int key_already_recorded
= 0;
2562 Lisp_Object tem
, save
;
2563 volatile Lisp_Object previous_echo_area_message
;
2564 volatile Lisp_Object also_record
;
2565 volatile int reread
;
2566 struct gcpro gcpro1
, gcpro2
;
2567 int polling_stopped_here
= 0;
2568 struct kboard
*orig_kboard
= current_kboard
;
2572 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2573 before_command_key_count
= this_command_key_count
;
2574 before_command_echo_length
= echo_length ();
2577 previous_echo_area_message
= Qnil
;
2579 GCPRO2 (c
, previous_echo_area_message
);
2584 if (CONSP (Vunread_post_input_method_events
))
2586 c
= XCAR (Vunread_post_input_method_events
);
2587 Vunread_post_input_method_events
2588 = XCDR (Vunread_post_input_method_events
);
2590 /* Undo what read_char_x_menu_prompt did when it unread
2591 additional keys returned by Fx_popup_menu. */
2593 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2601 if (unread_command_char
!= -1)
2603 XSETINT (c
, unread_command_char
);
2604 unread_command_char
= -1;
2610 if (CONSP (Vunread_command_events
))
2612 c
= XCAR (Vunread_command_events
);
2613 Vunread_command_events
= XCDR (Vunread_command_events
);
2617 /* Undo what sit-for did when it unread additional keys
2618 inside universal-argument. */
2621 && EQ (XCAR (c
), Qt
))
2627 /* Undo what read_char_x_menu_prompt did when it unread
2628 additional keys returned by Fx_popup_menu. */
2630 && EQ (XCDR (c
), Qdisabled
)
2631 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2634 /* If the queued event is something that used the mouse,
2635 set used_mouse_menu accordingly. */
2637 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
)))
2638 *used_mouse_menu
= 1;
2640 goto reread_for_input_method
;
2643 if (CONSP (Vunread_input_method_events
))
2645 c
= XCAR (Vunread_input_method_events
);
2646 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2648 /* Undo what read_char_x_menu_prompt did when it unread
2649 additional keys returned by Fx_popup_menu. */
2651 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2655 goto reread_for_input_method
;
2658 this_command_key_count_reset
= 0;
2660 if (!NILP (Vexecuting_kbd_macro
))
2662 /* We set this to Qmacro; since that's not a frame, nobody will
2663 try to switch frames on us, and the selected window will
2666 Since this event came from a macro, it would be misleading to
2667 leave internal_last_event_frame set to wherever the last
2668 real event came from. Normally, a switch-frame event selects
2669 internal_last_event_frame after each command is read, but
2670 events read from a macro should never cause a new frame to be
2672 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2674 /* Exit the macro if we are at the end.
2675 Also, some things replace the macro with t
2676 to force an early exit. */
2677 if (EQ (Vexecuting_kbd_macro
, Qt
)
2678 || executing_kbd_macro_index
>= XFASTINT (Flength (Vexecuting_kbd_macro
)))
2684 c
= Faref (Vexecuting_kbd_macro
, make_number (executing_kbd_macro_index
));
2685 if (STRINGP (Vexecuting_kbd_macro
)
2686 && (XINT (c
) & 0x80) && (XUINT (c
) <= 0xff))
2687 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2689 executing_kbd_macro_index
++;
2694 if (!NILP (unread_switch_frame
))
2696 c
= unread_switch_frame
;
2697 unread_switch_frame
= Qnil
;
2699 /* This event should make it into this_command_keys, and get echoed
2700 again, so we do not set `reread'. */
2704 /* if redisplay was requested */
2705 if (commandflag
>= 0)
2707 /* If there is pending input, process any events which are not
2708 user-visible, such as X selection_request events. */
2710 || detect_input_pending_run_timers (0))
2711 swallow_events (0); /* may clear input_pending */
2713 /* Redisplay if no pending input. */
2714 while (!input_pending
)
2716 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2717 redisplay_preserve_echo_area (5);
2722 /* Normal case: no input arrived during redisplay. */
2725 /* Input arrived and pre-empted redisplay.
2726 Process any events which are not user-visible. */
2728 /* If that cleared input_pending, try again to redisplay. */
2732 /* Message turns off echoing unless more keystrokes turn it on again.
2734 The code in 20.x for the condition was
2736 1. echo_area_glyphs && *echo_area_glyphs
2737 2. && echo_area_glyphs != current_kboard->echobuf
2738 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2740 (1) means there's a current message displayed
2742 (2) means it's not the message from echoing from the current
2745 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2746 is set to a non-null value. This is done in read_char and it is
2747 set to echo_area_glyphs after a call to echo_char. That means
2748 ok_to_echo_at_next_pause is either null or
2749 current_kboard->echobuf with the appropriate current_kboard at
2752 So, condition (3) means in clear text ok_to_echo_at_next_pause
2753 must be either null, or the current message isn't from echoing at
2754 all, or it's from echoing from a different kboard than the
2757 if (/* There currently is something in the echo area. */
2758 !NILP (echo_area_buffer
[0])
2759 && (/* And it's either not from echoing. */
2760 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2761 /* Or it's an echo from a different kboard. */
2762 || echo_kboard
!= current_kboard
2763 /* Or we explicitly allow overwriting whatever there is. */
2764 || ok_to_echo_at_next_pause
== NULL
))
2769 /* Try reading a character via menu prompting in the minibuf.
2770 Try this before the sit-for, because the sit-for
2771 would do the wrong thing if we are supposed to do
2772 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2773 after a mouse event so don't try a minibuf menu. */
2775 if (nmaps
> 0 && INTERACTIVE
2776 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2777 /* Don't bring up a menu if we already have another event. */
2778 && NILP (Vunread_command_events
)
2779 && unread_command_char
< 0
2780 && !detect_input_pending_run_timers (0))
2782 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2784 if (INTEGERP (c
) && XINT (c
) == -2)
2785 return c
; /* wrong_kboard_jmpbuf */
2789 key_already_recorded
= 1;
2794 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2795 We will do that below, temporarily for short sections of code,
2796 when appropriate. local_getcjmp must be in effect
2797 around any call to sit_for or kbd_buffer_get_event;
2798 it *must not* be in effect when we call redisplay. */
2800 jmpcount
= SPECPDL_INDEX ();
2801 if (_setjmp (local_getcjmp
))
2803 /* Handle quits while reading the keyboard. */
2804 /* We must have saved the outer value of getcjmp here,
2805 so restore it now. */
2806 restore_getcjmp (save_jump
);
2807 unbind_to (jmpcount
, Qnil
);
2808 XSETINT (c
, quit_char
);
2809 internal_last_event_frame
= selected_frame
;
2810 Vlast_event_frame
= internal_last_event_frame
;
2811 /* If we report the quit char as an event,
2812 don't do so more than once. */
2813 if (!NILP (Vinhibit_quit
))
2818 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2819 if (kb
!= current_kboard
)
2821 Lisp_Object link
= kb
->kbd_queue
;
2822 /* We shouldn't get here if we were in single-kboard mode! */
2827 while (CONSP (XCDR (link
)))
2829 if (!NILP (XCDR (link
)))
2833 kb
->kbd_queue
= Fcons (c
, Qnil
);
2835 XSETCDR (link
, Fcons (c
, Qnil
));
2836 kb
->kbd_queue_has_data
= 1;
2837 current_kboard
= kb
;
2838 /* This is going to exit from read_char
2839 so we had better get rid of this frame's stuff. */
2841 return make_number (-2); /* wrong_kboard_jmpbuf */
2848 /* Start idle timers if no time limit is supplied. We don't do it
2849 if a time limit is supplied to avoid an infinite recursion in the
2850 situation where an idle timer calls `sit-for'. */
2853 timer_start_idle ();
2855 /* If in middle of key sequence and minibuffer not active,
2856 start echoing if enough time elapses. */
2858 if (minibuf_level
== 0
2860 && !current_kboard
->immediate_echo
2861 && this_command_key_count
> 0
2863 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2864 && NILP (Fzerop (Vecho_keystrokes
))
2865 && (/* No message. */
2866 NILP (echo_area_buffer
[0])
2867 /* Or empty message. */
2868 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2869 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2870 /* Or already echoing from same kboard. */
2871 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2872 /* Or not echoing before and echoing allowed. */
2873 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2875 /* After a mouse event, start echoing right away.
2876 This is because we are probably about to display a menu,
2877 and we don't want to delay before doing so. */
2878 if (EVENT_HAS_PARAMETERS (prev_event
))
2884 save_getcjmp (save_jump
);
2885 restore_getcjmp (local_getcjmp
);
2886 tem0
= sit_for (Vecho_keystrokes
, 1, 1);
2887 restore_getcjmp (save_jump
);
2889 && ! CONSP (Vunread_command_events
))
2894 /* Maybe auto save due to number of keystrokes. */
2896 if (commandflag
!= 0
2897 && auto_save_interval
> 0
2898 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2899 && !detect_input_pending_run_timers (0))
2901 Fdo_auto_save (Qnil
, Qnil
);
2902 /* Hooks can actually change some buffers in auto save. */
2906 /* Try reading using an X menu.
2907 This is never confused with reading using the minibuf
2908 because the recursive call of read_char in read_char_minibuf_menu_prompt
2909 does not pass on any keymaps. */
2911 if (nmaps
> 0 && INTERACTIVE
2912 && !NILP (prev_event
)
2913 && EVENT_HAS_PARAMETERS (prev_event
)
2914 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2915 && !EQ (XCAR (prev_event
), Qtool_bar
)
2916 /* Don't bring up a menu if we already have another event. */
2917 && NILP (Vunread_command_events
)
2918 && unread_command_char
< 0)
2920 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2922 /* Now that we have read an event, Emacs is not idle. */
2929 /* Maybe autosave and/or garbage collect due to idleness. */
2931 if (INTERACTIVE
&& NILP (c
))
2933 int delay_level
, buffer_size
;
2935 /* Slow down auto saves logarithmically in size of current buffer,
2936 and garbage collect while we're at it. */
2937 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2938 last_non_minibuf_size
= Z
- BEG
;
2939 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2941 while (buffer_size
> 64)
2942 delay_level
++, buffer_size
-= buffer_size
>> 2;
2943 if (delay_level
< 4) delay_level
= 4;
2944 /* delay_level is 4 for files under around 50k, 7 at 100k,
2945 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2947 /* Auto save if enough time goes by without input. */
2948 if (commandflag
!= 0
2949 && num_nonmacro_input_events
> last_auto_save
2950 && INTEGERP (Vauto_save_timeout
)
2951 && XINT (Vauto_save_timeout
) > 0)
2954 int timeout
= delay_level
* XFASTINT (Vauto_save_timeout
) / 4;
2956 save_getcjmp (save_jump
);
2957 restore_getcjmp (local_getcjmp
);
2958 tem0
= sit_for (make_number (timeout
), 1, 1);
2959 restore_getcjmp (save_jump
);
2962 && ! CONSP (Vunread_command_events
))
2964 Fdo_auto_save (Qnil
, Qnil
);
2966 /* If we have auto-saved and there is still no input
2967 available, garbage collect if there has been enough
2968 consing going on to make it worthwhile. */
2969 if (!detect_input_pending_run_timers (0)
2970 && consing_since_gc
> gc_cons_threshold
/ 2)
2971 Fgarbage_collect ();
2978 /* Notify the caller if an autosave hook, or a timer, sentinel or
2979 filter in the sit_for calls above have changed the current
2980 kboard. This could happen if they use the minibuffer or start a
2981 recursive edit, like the fancy splash screen in server.el's
2982 filter. If this longjmp wasn't here, read_key_sequence would
2983 interpret the next key sequence using the wrong translation
2984 tables and function keymaps. */
2985 if (NILP (c
) && current_kboard
!= orig_kboard
)
2988 return make_number (-2); /* wrong_kboard_jmpbuf */
2991 /* If this has become non-nil here, it has been set by a timer
2992 or sentinel or filter. */
2993 if (CONSP (Vunread_command_events
))
2995 c
= XCAR (Vunread_command_events
);
2996 Vunread_command_events
= XCDR (Vunread_command_events
);
2999 /* Read something from current KBOARD's side queue, if possible. */
3003 if (current_kboard
->kbd_queue_has_data
)
3005 if (!CONSP (current_kboard
->kbd_queue
))
3007 c
= XCAR (current_kboard
->kbd_queue
);
3008 current_kboard
->kbd_queue
3009 = XCDR (current_kboard
->kbd_queue
);
3010 if (NILP (current_kboard
->kbd_queue
))
3011 current_kboard
->kbd_queue_has_data
= 0;
3012 input_pending
= readable_events (0);
3013 if (EVENT_HAS_PARAMETERS (c
)
3014 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
3015 internal_last_event_frame
= XCAR (XCDR (c
));
3016 Vlast_event_frame
= internal_last_event_frame
;
3021 /* If current_kboard's side queue is empty check the other kboards.
3022 If one of them has data that we have not yet seen here,
3023 switch to it and process the data waiting for it.
3025 Note: if the events queued up for another kboard
3026 have already been seen here, and therefore are not a complete command,
3027 the kbd_queue_has_data field is 0, so we skip that kboard here.
3028 That's to avoid an infinite loop switching between kboards here. */
3029 if (NILP (c
) && !single_kboard
)
3032 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3033 if (kb
->kbd_queue_has_data
)
3035 current_kboard
= kb
;
3036 /* This is going to exit from read_char
3037 so we had better get rid of this frame's stuff. */
3039 return make_number (-2); /* wrong_kboard_jmpbuf */
3048 /* Finally, we read from the main queue,
3049 and if that gives us something we can't use yet, we put it on the
3050 appropriate side queue and try again. */
3059 EMACS_GET_TIME (now
);
3060 if (EMACS_TIME_GE (now
, *end_time
))
3064 /* Actually read a character, waiting if necessary. */
3065 save_getcjmp (save_jump
);
3066 restore_getcjmp (local_getcjmp
);
3068 timer_start_idle ();
3069 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
, end_time
);
3070 restore_getcjmp (save_jump
);
3073 if (! NILP (c
) && (kb
!= current_kboard
))
3075 Lisp_Object link
= kb
->kbd_queue
;
3078 while (CONSP (XCDR (link
)))
3080 if (!NILP (XCDR (link
)))
3084 kb
->kbd_queue
= Fcons (c
, Qnil
);
3086 XSETCDR (link
, Fcons (c
, Qnil
));
3087 kb
->kbd_queue_has_data
= 1;
3091 current_kboard
= kb
;
3092 /* This is going to exit from read_char
3093 so we had better get rid of this frame's stuff. */
3095 return make_number (-2);
3100 /* Terminate Emacs in batch mode if at eof. */
3101 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
3102 Fkill_emacs (make_number (1));
3106 /* Add in any extra modifiers, where appropriate. */
3107 if ((extra_keyboard_modifiers
& CHAR_CTL
)
3108 || ((extra_keyboard_modifiers
& 0177) < ' '
3109 && (extra_keyboard_modifiers
& 0177) != 0))
3110 XSETINT (c
, make_ctrl_char (XINT (c
)));
3112 /* Transfer any other modifier bits directly from
3113 extra_keyboard_modifiers to c. Ignore the actual character code
3114 in the low 16 bits of extra_keyboard_modifiers. */
3115 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
3126 if (commandflag
>= 0
3127 && !input_pending
&& !detect_input_pending_run_timers (0))
3135 /* Buffer switch events are only for internal wakeups
3136 so don't show them to the user.
3137 Also, don't record a key if we already did. */
3138 if (BUFFERP (c
) || key_already_recorded
)
3141 /* Process special events within read_char
3142 and loop around to read another event. */
3145 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
3150 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3151 int was_locked
= single_kboard
;
3152 int count
= SPECPDL_INDEX ();
3153 record_single_kboard_state ();
3156 last_input_char
= c
;
3157 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_char
), Qt
);
3159 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
) && !end_time
)
3160 /* We stopped being idle for this event; undo that. This
3161 prevents automatic window selection (under
3162 mouse_autoselect_window from acting as a real input event, for
3163 example banishing the mouse under mouse-avoidance-mode. */
3164 timer_resume_idle ();
3166 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3167 /* Resume allowing input from any kboard, if that was true before. */
3169 any_kboard_state ();
3170 unbind_to (count
, Qnil
);
3176 /* Handle things that only apply to characters. */
3179 /* If kbd_buffer_get_event gave us an EOF, return that. */
3183 if ((STRINGP (current_kboard
->Vkeyboard_translate_table
)
3184 && SCHARS (current_kboard
->Vkeyboard_translate_table
) > (unsigned) XFASTINT (c
))
3185 || (VECTORP (current_kboard
->Vkeyboard_translate_table
)
3186 && XVECTOR (current_kboard
->Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
3187 || (CHAR_TABLE_P (current_kboard
->Vkeyboard_translate_table
)
3188 && CHAR_VALID_P (XINT (c
), 0)))
3191 d
= Faref (current_kboard
->Vkeyboard_translate_table
, c
);
3192 /* nil in keyboard-translate-table means no translation. */
3198 /* If this event is a mouse click in the menu bar,
3199 return just menu-bar for now. Modify the mouse click event
3200 so we won't do this twice, then queue it up. */
3201 if (EVENT_HAS_PARAMETERS (c
)
3203 && CONSP (EVENT_START (c
))
3204 && CONSP (XCDR (EVENT_START (c
))))
3208 posn
= POSN_POSN (EVENT_START (c
));
3209 /* Handle menu-bar events:
3210 insert the dummy prefix event `menu-bar'. */
3211 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
3213 /* Change menu-bar to (menu-bar) as the event "position". */
3214 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
3217 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
3222 /* Store these characters into recent_keys, the dribble file if any,
3223 and the keyboard macro being defined, if any. */
3225 if (! NILP (also_record
))
3226 record_char (also_record
);
3228 /* Wipe the echo area.
3229 But first, if we are about to use an input method,
3230 save the echo area contents for it to refer to. */
3232 && ! NILP (Vinput_method_function
)
3233 && (unsigned) XINT (c
) >= ' '
3234 && (unsigned) XINT (c
) != 127
3235 && (unsigned) XINT (c
) < 256)
3237 previous_echo_area_message
= Fcurrent_message ();
3238 Vinput_method_previous_message
= previous_echo_area_message
;
3241 /* Now wipe the echo area, except for help events which do their
3242 own stuff with the echo area. */
3244 || (!(EQ (Qhelp_echo
, XCAR (c
)))
3245 && !(EQ (Qswitch_frame
, XCAR (c
)))))
3247 if (!NILP (echo_area_buffer
[0]))
3248 safe_run_hooks (Qecho_area_clear_hook
);
3249 clear_message (1, 0);
3252 reread_for_input_method
:
3254 /* Pass this to the input method, if appropriate. */
3256 && ! NILP (Vinput_method_function
)
3257 /* Don't run the input method within a key sequence,
3258 after the first event of the key sequence. */
3259 && NILP (prev_event
)
3260 && (unsigned) XINT (c
) >= ' '
3261 && (unsigned) XINT (c
) != 127
3262 && (unsigned) XINT (c
) < 256)
3265 int key_count
, key_count_reset
;
3266 struct gcpro gcpro1
;
3267 int count
= SPECPDL_INDEX ();
3269 /* Save the echo status. */
3270 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3271 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3272 Lisp_Object saved_echo_string
= current_kboard
->echo_string
;
3273 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3276 if (before_command_restore_flag
)
3278 this_command_key_count
= before_command_key_count_1
;
3279 if (this_command_key_count
< this_single_command_key_start
)
3280 this_single_command_key_start
= this_command_key_count
;
3281 echo_truncate (before_command_echo_length_1
);
3282 before_command_restore_flag
= 0;
3286 /* Save the this_command_keys status. */
3287 key_count
= this_command_key_count
;
3288 key_count_reset
= this_command_key_count_reset
;
3291 keys
= Fcopy_sequence (this_command_keys
);
3296 /* Clear out this_command_keys. */
3297 this_command_key_count
= 0;
3298 this_command_key_count_reset
= 0;
3300 /* Now wipe the echo area. */
3301 if (!NILP (echo_area_buffer
[0]))
3302 safe_run_hooks (Qecho_area_clear_hook
);
3303 clear_message (1, 0);
3306 /* If we are not reading a key sequence,
3307 never use the echo area. */
3310 specbind (Qinput_method_use_echo_area
, Qt
);
3313 /* Call the input method. */
3314 tem
= call1 (Vinput_method_function
, c
);
3316 tem
= unbind_to (count
, tem
);
3318 /* Restore the saved echoing state
3319 and this_command_keys state. */
3320 this_command_key_count
= key_count
;
3321 this_command_key_count_reset
= key_count_reset
;
3323 this_command_keys
= keys
;
3326 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3327 current_kboard
->echo_string
= saved_echo_string
;
3328 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3329 if (saved_immediate_echo
)
3334 /* The input method can return no events. */
3337 /* Bring back the previous message, if any. */
3338 if (! NILP (previous_echo_area_message
))
3339 message_with_string ("%s", previous_echo_area_message
, 0);
3342 /* It returned one event or more. */
3344 Vunread_post_input_method_events
3345 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3350 /* Display help if not echoing. */
3351 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3353 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3354 Lisp_Object help
, object
, position
, window
, tem
;
3356 tem
= Fcdr (XCDR (c
));
3359 window
= Fcar (tem
);
3361 object
= Fcar (tem
);
3363 position
= Fcar (tem
);
3365 show_help_echo (help
, window
, object
, position
, 0);
3367 /* We stopped being idle for this event; undo that. */
3369 timer_resume_idle ();
3373 if ((! reread
|| this_command_key_count
== 0
3374 || this_command_key_count_reset
)
3378 /* Don't echo mouse motion events. */
3379 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3380 && NILP (Fzerop (Vecho_keystrokes
))
3381 && ! (EVENT_HAS_PARAMETERS (c
)
3382 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3385 if (! NILP (also_record
))
3386 echo_char (also_record
);
3387 /* Once we reread a character, echoing can happen
3388 the next time we pause to read a new one. */
3389 ok_to_echo_at_next_pause
= current_kboard
;
3392 /* Record this character as part of the current key. */
3393 add_command_key (c
);
3394 if (! NILP (also_record
))
3395 add_command_key (also_record
);
3398 last_input_char
= c
;
3401 /* Process the help character specially if enabled */
3402 if (!NILP (Vhelp_form
) && help_char_p (c
))
3405 count
= SPECPDL_INDEX ();
3407 help_form_saved_window_configs
3408 = Fcons (Fcurrent_window_configuration (Qnil
),
3409 help_form_saved_window_configs
);
3410 record_unwind_protect (read_char_help_form_unwind
, Qnil
);
3412 tem0
= Feval (Vhelp_form
);
3414 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3419 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3420 if (EVENT_HAS_PARAMETERS (c
)
3421 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_click
))
3422 XSETCAR (help_form_saved_window_configs
, Qnil
);
3424 while (BUFFERP (c
));
3425 /* Remove the help from the frame */
3426 unbind_to (count
, Qnil
);
3429 if (EQ (c
, make_number (040)))
3433 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3434 while (BUFFERP (c
));
3443 /* Record a key that came from a mouse menu.
3444 Record it for echoing, for this-command-keys, and so on. */
3450 /* Wipe the echo area. */
3451 clear_message (1, 0);
3456 before_command_key_count
= this_command_key_count
;
3457 before_command_echo_length
= echo_length ();
3460 /* Don't echo mouse motion events. */
3461 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3462 && NILP (Fzerop (Vecho_keystrokes
)))
3466 /* Once we reread a character, echoing can happen
3467 the next time we pause to read a new one. */
3468 ok_to_echo_at_next_pause
= 0;
3471 /* Record this character as part of the current key. */
3472 add_command_key (c
);
3474 /* Re-reading in the middle of a command */
3475 last_input_char
= c
;
3479 /* Return 1 if should recognize C as "the help character". */
3487 if (EQ (c
, Vhelp_char
))
3489 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3490 if (EQ (c
, XCAR (tail
)))
3495 /* Record the input event C in various ways. */
3503 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3505 /* To avoid filling recent_keys with help-echo and mouse-movement
3506 events, we filter out repeated help-echo events, only store the
3507 first and last in a series of mouse-movement events, and don't
3508 store repeated help-echo events which are only separated by
3509 mouse-movement events. */
3511 Lisp_Object ev1
, ev2
, ev3
;
3514 if ((ix1
= recent_keys_index
- 1) < 0)
3515 ix1
= NUM_RECENT_KEYS
- 1;
3516 ev1
= AREF (recent_keys
, ix1
);
3518 if ((ix2
= ix1
- 1) < 0)
3519 ix2
= NUM_RECENT_KEYS
- 1;
3520 ev2
= AREF (recent_keys
, ix2
);
3522 if ((ix3
= ix2
- 1) < 0)
3523 ix3
= NUM_RECENT_KEYS
- 1;
3524 ev3
= AREF (recent_keys
, ix3
);
3526 if (EQ (XCAR (c
), Qhelp_echo
))
3528 /* Don't record `help-echo' in recent_keys unless it shows some help
3529 message, and a different help than the previously recorded
3531 Lisp_Object help
, last_help
;
3533 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3534 if (!STRINGP (help
))
3536 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3537 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3539 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3540 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3541 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3543 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3544 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3545 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3546 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3549 else if (EQ (XCAR (c
), Qmouse_movement
))
3551 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3552 So additional mouse movement events replace the last element. */
3553 Lisp_Object last_window
, window
;
3555 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3556 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3557 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3558 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3559 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3561 ASET (recent_keys
, ix1
, c
);
3567 store_kbd_macro_char (c
);
3572 ASET (recent_keys
, recent_keys_index
, c
);
3573 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3574 recent_keys_index
= 0;
3576 else if (recorded
< 0)
3578 /* We need to remove one or two events from recent_keys.
3579 To do this, we simply put nil at those events and move the
3580 recent_keys_index backwards over those events. Usually,
3581 users will never see those nil events, as they will be
3582 overwritten by the command keys entered to see recent_keys
3585 while (recorded
++ < 0 && total_keys
> 0)
3587 if (total_keys
< NUM_RECENT_KEYS
)
3589 if (--recent_keys_index
< 0)
3590 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3591 ASET (recent_keys
, recent_keys_index
, Qnil
);
3595 num_nonmacro_input_events
++;
3597 /* Write c to the dribble file. If c is a lispy event, write
3598 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3599 If you, dear reader, have a better idea, you've got the source. :-) */
3605 if (XUINT (c
) < 0x100)
3606 putc (XINT (c
), dribble
);
3608 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3612 Lisp_Object dribblee
;
3614 /* If it's a structured event, take the event header. */
3615 dribblee
= EVENT_HEAD (c
);
3617 if (SYMBOLP (dribblee
))
3619 putc ('<', dribble
);
3620 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3621 SBYTES (SYMBOL_NAME (dribblee
)),
3623 putc ('>', dribble
);
3636 struct buffer
*old
= current_buffer
;
3637 Fprinc (object
, Qnil
);
3638 set_buffer_internal (XBUFFER (Vstandard_output
));
3639 call0 (intern ("help-mode"));
3640 set_buffer_internal (old
);
3644 /* Copy out or in the info on where C-g should throw to.
3645 This is used when running Lisp code from within get_char,
3646 in case get_char is called recursively.
3647 See read_process_output. */
3653 bcopy (getcjmp
, temp
, sizeof getcjmp
);
3657 restore_getcjmp (temp
)
3660 bcopy (temp
, getcjmp
, sizeof getcjmp
);
3663 /* Low level keyboard/mouse input.
3664 kbd_buffer_store_event places events in kbd_buffer, and
3665 kbd_buffer_get_event retrieves them. */
3667 /* Return true if there are any events in the queue that read-char
3668 would return. If this returns false, a read-char would block. */
3670 readable_events (flags
)
3673 if (flags
& READABLE_EVENTS_DO_TIMERS_NOW
)
3676 /* If the buffer contains only FOCUS_IN_EVENT events, and
3677 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3678 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3680 if (flags
& (READABLE_EVENTS_FILTER_EVENTS
3681 #ifdef USE_TOOLKIT_SCROLL_BARS
3682 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3686 struct input_event
*event
;
3688 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3695 #ifdef USE_TOOLKIT_SCROLL_BARS
3696 (flags
& READABLE_EVENTS_FILTER_EVENTS
) &&
3698 event
->kind
== FOCUS_IN_EVENT
)
3699 #ifdef USE_TOOLKIT_SCROLL_BARS
3700 && !((flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3701 && event
->kind
== SCROLL_BAR_CLICK_EVENT
3702 && event
->part
== scroll_bar_handle
3703 && event
->modifiers
== 0)
3708 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3711 while (event
!= kbd_store_ptr
);
3717 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3718 if (!(flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3719 && !NILP (do_mouse_tracking
) && some_mouse_moved ())
3724 if (current_kboard
->kbd_queue_has_data
)
3730 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3731 if (kb
->kbd_queue_has_data
)
3737 /* Set this for debugging, to have a way to get out */
3742 event_to_kboard (event
)
3743 struct input_event
*event
;
3746 frame
= event
->frame_or_window
;
3748 frame
= XCAR (frame
);
3749 else if (WINDOWP (frame
))
3750 frame
= WINDOW_FRAME (XWINDOW (frame
));
3752 /* There are still some events that don't set this field.
3753 For now, just ignore the problem.
3754 Also ignore dead frames here. */
3755 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3758 return FRAME_KBOARD (XFRAME (frame
));
3763 Lisp_Object Vthrow_on_input
;
3765 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3768 kbd_buffer_store_event (event
)
3769 register struct input_event
*event
;
3771 kbd_buffer_store_event_hold (event
, 0);
3774 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3776 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3777 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3778 Else, if EVENT is a quit event, store the quit event
3779 in HOLD_QUIT, and return (thus ignoring further events).
3781 This is used in read_avail_input to postpone the processing
3782 of the quit event until all subsequent input events have been
3783 parsed (and discarded).
3787 kbd_buffer_store_event_hold (event
, hold_quit
)
3788 register struct input_event
*event
;
3789 struct input_event
*hold_quit
;
3791 if (event
->kind
== NO_EVENT
)
3794 if (hold_quit
&& hold_quit
->kind
!= NO_EVENT
)
3797 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3799 register int c
= event
->code
& 0377;
3801 if (event
->modifiers
& ctrl_modifier
)
3802 c
= make_ctrl_char (c
);
3804 c
|= (event
->modifiers
3805 & (meta_modifier
| alt_modifier
3806 | hyper_modifier
| super_modifier
));
3811 KBOARD
*kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
));
3812 struct input_event
*sp
;
3814 if (single_kboard
&& kb
!= current_kboard
)
3817 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3818 Fcons (make_number (c
), Qnil
));
3819 kb
->kbd_queue_has_data
= 1;
3820 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3822 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3825 if (event_to_kboard (sp
) == kb
)
3827 sp
->kind
= NO_EVENT
;
3828 sp
->frame_or_window
= Qnil
;
3838 bcopy (event
, (char *) hold_quit
, sizeof (*event
));
3842 /* If this results in a quit_char being returned to Emacs as
3843 input, set Vlast_event_frame properly. If this doesn't
3844 get returned to Emacs as an event, the next event read
3845 will set Vlast_event_frame again, so this is safe to do. */
3849 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3851 focus
= event
->frame_or_window
;
3852 internal_last_event_frame
= focus
;
3853 Vlast_event_frame
= focus
;
3856 last_event_timestamp
= event
->timestamp
;
3857 handle_interrupt ();
3861 if (c
&& c
== stop_character
)
3867 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3868 Just ignore the second one. */
3869 else if (event
->kind
== BUFFER_SWITCH_EVENT
3870 && kbd_fetch_ptr
!= kbd_store_ptr
3871 && ((kbd_store_ptr
== kbd_buffer
3872 ? kbd_buffer
+ KBD_BUFFER_SIZE
- 1
3873 : kbd_store_ptr
- 1)->kind
) == BUFFER_SWITCH_EVENT
)
3876 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3877 kbd_store_ptr
= kbd_buffer
;
3879 /* Don't let the very last slot in the buffer become full,
3880 since that would make the two pointers equal,
3881 and that is indistinguishable from an empty buffer.
3882 Discard the event if it would fill the last slot. */
3883 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3885 *kbd_store_ptr
= *event
;
3889 /* If we're inside while-no-input, and this event qualifies
3890 as input, set quit-flag to cause an interrupt. */
3891 if (!NILP (Vthrow_on_input
)
3892 && event
->kind
!= FOCUS_IN_EVENT
3893 && event
->kind
!= HELP_EVENT
3894 && event
->kind
!= DEICONIFY_EVENT
)
3896 Vquit_flag
= Vthrow_on_input
;
3897 /* If we're inside a function that wants immediate quits,
3899 if (immediate_quit
&& NILP (Vinhibit_quit
))
3909 /* Put an input event back in the head of the event queue. */
3912 kbd_buffer_unget_event (event
)
3913 register struct input_event
*event
;
3915 if (kbd_fetch_ptr
== kbd_buffer
)
3916 kbd_fetch_ptr
= kbd_buffer
+ KBD_BUFFER_SIZE
;
3918 /* Don't let the very last slot in the buffer become full, */
3919 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3922 *kbd_fetch_ptr
= *event
;
3927 /* Generate HELP_EVENT input_events in BUFP which has room for
3928 SIZE events. If there's not enough room in BUFP, ignore this
3931 HELP is the help form.
3933 FRAME is the frame on which the help is generated. OBJECT is the
3934 Lisp object where the help was found (a buffer, a string, an
3935 overlay, or nil if neither from a string nor from a buffer. POS is
3936 the position within OBJECT where the help was found.
3938 Value is the number of input_events generated. */
3941 gen_help_event (help
, frame
, window
, object
, pos
)
3942 Lisp_Object help
, frame
, object
, window
;
3945 struct input_event event
;
3949 event
.kind
= HELP_EVENT
;
3950 event
.frame_or_window
= frame
;
3952 event
.x
= WINDOWP (window
) ? window
: frame
;
3955 kbd_buffer_store_event (&event
);
3959 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3962 kbd_buffer_store_help_event (frame
, help
)
3963 Lisp_Object frame
, help
;
3965 struct input_event event
;
3967 event
.kind
= HELP_EVENT
;
3968 event
.frame_or_window
= frame
;
3973 kbd_buffer_store_event (&event
);
3977 /* Discard any mouse events in the event buffer by setting them to
3980 discard_mouse_events ()
3982 struct input_event
*sp
;
3983 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3985 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3988 if (sp
->kind
== MOUSE_CLICK_EVENT
3989 || sp
->kind
== WHEEL_EVENT
3990 || sp
->kind
== HORIZ_WHEEL_EVENT
3992 || sp
->kind
== GPM_CLICK_EVENT
3994 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
3996 sp
->kind
= NO_EVENT
;
4002 /* Return non-zero if there are any real events waiting in the event
4003 buffer, not counting `NO_EVENT's.
4005 If DISCARD is non-zero, discard NO_EVENT events at the front of
4006 the input queue, possibly leaving the input queue empty if there
4007 are no real input events. */
4010 kbd_buffer_events_waiting (discard
)
4013 struct input_event
*sp
;
4015 for (sp
= kbd_fetch_ptr
;
4016 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
4019 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
4026 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
4030 /* Clear input event EVENT. */
4034 struct input_event
*event
;
4036 event
->kind
= NO_EVENT
;
4040 /* Read one event from the event buffer, waiting if necessary.
4041 The value is a Lisp object representing the event.
4042 The value is nil for an event that should be ignored,
4043 or that was handled here.
4044 We always read and discard one event. */
4047 kbd_buffer_get_event (kbp
, used_mouse_menu
, end_time
)
4049 int *used_mouse_menu
;
4050 EMACS_TIME
*end_time
;
4059 *kbp
= current_kboard
;
4063 /* Wait until there is input available. */
4066 /* Break loop if there's an unread command event. Needed in
4067 moused window autoselection which uses a timer to insert such
4069 if (CONSP (Vunread_command_events
))
4072 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4074 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4075 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4079 /* If the quit flag is set, then read_char will return
4080 quit_char, so that counts as "available input." */
4081 if (!NILP (Vquit_flag
))
4082 quit_throw_to_read_char ();
4084 /* One way or another, wait until input is available; then, if
4085 interrupt handlers have not read it, read it now. */
4088 wait_for_kbd_input ();
4090 /* Note SIGIO has been undef'd if FIONREAD is missing. */
4094 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4096 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4097 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4102 EMACS_TIME duration
;
4103 EMACS_GET_TIME (duration
);
4104 if (EMACS_TIME_GE (duration
, *end_time
))
4105 return Qnil
; /* finished waiting */
4108 EMACS_SUB_TIME (duration
, *end_time
, duration
);
4109 wait_reading_process_output (EMACS_SECS (duration
),
4110 EMACS_USECS (duration
),
4111 -1, 1, Qnil
, NULL
, 0);
4115 wait_reading_process_output (0, 0, -1, 1, Qnil
, NULL
, 0);
4117 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
4118 /* Pass 1 for EXPECT since we just waited to have input. */
4119 read_avail_input (1);
4120 #endif /* not VMS */
4123 if (CONSP (Vunread_command_events
))
4126 first
= XCAR (Vunread_command_events
);
4127 Vunread_command_events
= XCDR (Vunread_command_events
);
4128 *kbp
= current_kboard
;
4132 /* At this point, we know that there is a readable event available
4133 somewhere. If the event queue is empty, then there must be a
4134 mouse movement enabled and available. */
4135 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4137 struct input_event
*event
;
4139 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4143 last_event_timestamp
= event
->timestamp
;
4146 *kbp
= event_to_kboard (event
);
4148 *kbp
= current_kboard
; /* Better than returning null ptr? */
4150 *kbp
= &the_only_kboard
;
4155 /* These two kinds of events get special handling
4156 and don't actually appear to the command loop.
4157 We return nil for them. */
4158 if (event
->kind
== SELECTION_REQUEST_EVENT
4159 || event
->kind
== SELECTION_CLEAR_EVENT
)
4162 struct input_event copy
;
4164 /* Remove it from the buffer before processing it,
4165 since otherwise swallow_events will see it
4166 and process it again. */
4168 kbd_fetch_ptr
= event
+ 1;
4169 input_pending
= readable_events (0);
4170 x_handle_selection_event (©
);
4172 /* We're getting selection request events, but we don't have
4178 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
4179 else if (event
->kind
== DELETE_WINDOW_EVENT
)
4181 /* Make an event (delete-frame (FRAME)). */
4182 obj
= Fcons (event
->frame_or_window
, Qnil
);
4183 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
4184 kbd_fetch_ptr
= event
+ 1;
4187 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
4188 else if (event
->kind
== ICONIFY_EVENT
)
4190 /* Make an event (iconify-frame (FRAME)). */
4191 obj
= Fcons (event
->frame_or_window
, Qnil
);
4192 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
4193 kbd_fetch_ptr
= event
+ 1;
4195 else if (event
->kind
== DEICONIFY_EVENT
)
4197 /* Make an event (make-frame-visible (FRAME)). */
4198 obj
= Fcons (event
->frame_or_window
, Qnil
);
4199 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
4200 kbd_fetch_ptr
= event
+ 1;
4203 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
4205 /* The value doesn't matter here; only the type is tested. */
4206 XSETBUFFER (obj
, current_buffer
);
4207 kbd_fetch_ptr
= event
+ 1;
4209 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
4210 || defined (USE_GTK)
4211 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
4213 kbd_fetch_ptr
= event
+ 1;
4214 input_pending
= readable_events (0);
4215 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
4216 x_activate_menubar (XFRAME (event
->frame_or_window
));
4219 #if defined (WINDOWSNT) || defined (MAC_OS)
4220 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
4223 /* Make an event (language-change (KEY_SCRIPT)). */
4224 obj
= Fcons (make_number (event
->code
), Qnil
);
4226 /* Make an event (language-change (FRAME CHARSET LCID)). */
4227 obj
= Fcons (event
->frame_or_window
, Qnil
);
4229 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
4230 kbd_fetch_ptr
= event
+ 1;
4233 else if (event
->kind
== SAVE_SESSION_EVENT
)
4235 obj
= Fcons (Qsave_session
, Qnil
);
4236 kbd_fetch_ptr
= event
+ 1;
4238 /* Just discard these, by returning nil.
4239 With MULTI_KBOARD, these events are used as placeholders
4240 when we need to randomly delete events from the queue.
4241 (They shouldn't otherwise be found in the buffer,
4242 but on some machines it appears they do show up
4243 even without MULTI_KBOARD.) */
4244 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
4245 mouse events during a popup-menu call. */
4246 else if (event
->kind
== NO_EVENT
)
4247 kbd_fetch_ptr
= event
+ 1;
4248 else if (event
->kind
== HELP_EVENT
)
4250 Lisp_Object object
, position
, help
, frame
, window
;
4252 frame
= event
->frame_or_window
;
4253 object
= event
->arg
;
4254 position
= make_number (event
->code
);
4257 clear_event (event
);
4259 kbd_fetch_ptr
= event
+ 1;
4260 if (!WINDOWP (window
))
4262 obj
= Fcons (Qhelp_echo
,
4263 list5 (frame
, help
, window
, object
, position
));
4265 else if (event
->kind
== FOCUS_IN_EVENT
)
4267 /* Notification of a FocusIn event. The frame receiving the
4268 focus is in event->frame_or_window. Generate a
4269 switch-frame event if necessary. */
4270 Lisp_Object frame
, focus
;
4272 frame
= event
->frame_or_window
;
4273 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4277 if (!EQ (frame
, internal_last_event_frame
)
4278 && !EQ (frame
, selected_frame
))
4279 obj
= make_lispy_switch_frame (frame
);
4280 internal_last_event_frame
= frame
;
4281 kbd_fetch_ptr
= event
+ 1;
4284 else if (event
->kind
== DBUS_EVENT
)
4286 obj
= make_lispy_event (event
);
4287 kbd_fetch_ptr
= event
+ 1;
4292 /* If this event is on a different frame, return a switch-frame this
4293 time, and leave the event in the queue for next time. */
4297 frame
= event
->frame_or_window
;
4299 frame
= XCAR (frame
);
4300 else if (WINDOWP (frame
))
4301 frame
= WINDOW_FRAME (XWINDOW (frame
));
4303 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4307 if (! EQ (frame
, internal_last_event_frame
)
4308 && !EQ (frame
, selected_frame
))
4309 obj
= make_lispy_switch_frame (frame
);
4310 internal_last_event_frame
= frame
;
4312 /* If we didn't decide to make a switch-frame event, go ahead
4313 and build a real event from the queue entry. */
4317 obj
= make_lispy_event (event
);
4319 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined(MAC_OS) \
4320 || defined (USE_GTK)
4321 /* If this was a menu selection, then set the flag to inhibit
4322 writing to last_nonmenu_event. Don't do this if the event
4323 we're returning is (menu-bar), though; that indicates the
4324 beginning of the menu sequence, and we might as well leave
4325 that as the `event with parameters' for this selection. */
4327 && !EQ (event
->frame_or_window
, event
->arg
)
4328 && (event
->kind
== MENU_BAR_EVENT
4329 || event
->kind
== TOOL_BAR_EVENT
))
4330 *used_mouse_menu
= 1;
4333 /* Wipe out this event, to catch bugs. */
4334 clear_event (event
);
4335 kbd_fetch_ptr
= event
+ 1;
4339 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4340 /* Try generating a mouse motion event. */
4341 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4343 FRAME_PTR f
= some_mouse_moved ();
4344 Lisp_Object bar_window
;
4345 enum scroll_bar_part part
;
4349 *kbp
= current_kboard
;
4350 /* Note that this uses F to determine which terminal to look at.
4351 If there is no valid info, it does not store anything
4352 so x remains nil. */
4355 /* XXX Can f or mouse_position_hook be NULL here? */
4356 if (f
&& FRAME_TERMINAL (f
)->mouse_position_hook
)
4357 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, 0, &bar_window
,
4358 &part
, &x
, &y
, &time
);
4362 /* Decide if we should generate a switch-frame event. Don't
4363 generate switch-frame events for motion outside of all Emacs
4369 frame
= FRAME_FOCUS_FRAME (f
);
4371 XSETFRAME (frame
, f
);
4373 if (! EQ (frame
, internal_last_event_frame
)
4374 && !EQ (frame
, selected_frame
))
4375 obj
= make_lispy_switch_frame (frame
);
4376 internal_last_event_frame
= frame
;
4379 /* If we didn't decide to make a switch-frame event, go ahead and
4380 return a mouse-motion event. */
4381 if (!NILP (x
) && NILP (obj
))
4382 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
4384 #endif /* HAVE_MOUSE || HAVE GPM */
4386 /* We were promised by the above while loop that there was
4387 something for us to read! */
4390 input_pending
= readable_events (0);
4392 Vlast_event_frame
= internal_last_event_frame
;
4397 /* Process any events that are not user-visible,
4398 then return, without reading any user-visible events. */
4401 swallow_events (do_display
)
4406 while (kbd_fetch_ptr
!= kbd_store_ptr
)
4408 struct input_event
*event
;
4410 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4414 last_event_timestamp
= event
->timestamp
;
4416 /* These two kinds of events get special handling
4417 and don't actually appear to the command loop. */
4418 if (event
->kind
== SELECTION_REQUEST_EVENT
4419 || event
->kind
== SELECTION_CLEAR_EVENT
)
4422 struct input_event copy
;
4424 /* Remove it from the buffer before processing it,
4425 since otherwise swallow_events called recursively could see it
4426 and process it again. */
4428 kbd_fetch_ptr
= event
+ 1;
4429 input_pending
= readable_events (0);
4430 x_handle_selection_event (©
);
4432 /* We're getting selection request events, but we don't have
4441 old_timers_run
= timers_run
;
4442 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
4444 if (timers_run
!= old_timers_run
&& do_display
)
4445 redisplay_preserve_echo_area (7);
4448 /* Record the start of when Emacs is idle,
4449 for the sake of running idle-time timers. */
4456 /* If we are already in the idle state, do nothing. */
4457 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4460 EMACS_GET_TIME (timer_idleness_start_time
);
4462 timer_last_idleness_start_time
= timer_idleness_start_time
;
4464 /* Mark all idle-time timers as once again candidates for running. */
4465 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4469 timer
= XCAR (timers
);
4471 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4473 XVECTOR (timer
)->contents
[0] = Qnil
;
4477 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4482 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
4485 /* Resume idle timer from last idle start time. */
4488 timer_resume_idle ()
4490 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4493 timer_idleness_start_time
= timer_last_idleness_start_time
;
4496 /* This is only for debugging. */
4497 struct input_event last_timer_event
;
4499 /* Check whether a timer has fired. To prevent larger problems we simply
4500 disregard elements that are not proper timers. Do not make a circular
4501 timer list for the time being.
4503 Returns the number of seconds to wait until the next timer fires. If a
4504 timer is triggering now, return zero seconds.
4505 If no timer is active, return -1 seconds.
4507 If a timer is ripe, we run it, with quitting turned off.
4509 DO_IT_NOW is now ignored. It used to mean that we should
4510 run the timer directly instead of queueing a timer-event.
4511 Now we always run timers directly. */
4514 timer_check (do_it_now
)
4517 EMACS_TIME nexttime
;
4518 EMACS_TIME now
, idleness_now
;
4519 Lisp_Object timers
, idle_timers
, chosen_timer
;
4520 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4522 EMACS_SET_SECS (nexttime
, -1);
4523 EMACS_SET_USECS (nexttime
, -1);
4525 /* Always consider the ordinary timers. */
4526 timers
= Vtimer_list
;
4527 /* Consider the idle timers only if Emacs is idle. */
4528 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4529 idle_timers
= Vtimer_idle_list
;
4532 chosen_timer
= Qnil
;
4533 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4535 if (CONSP (timers
) || CONSP (idle_timers
))
4537 EMACS_GET_TIME (now
);
4538 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4539 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4542 while (CONSP (timers
) || CONSP (idle_timers
))
4544 Lisp_Object
*vector
;
4545 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4546 EMACS_TIME timer_time
, idle_timer_time
;
4547 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4549 /* Skip past invalid timers and timers already handled. */
4552 timer
= XCAR (timers
);
4553 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4555 timers
= XCDR (timers
);
4558 vector
= XVECTOR (timer
)->contents
;
4560 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4561 || !INTEGERP (vector
[3])
4562 || ! NILP (vector
[0]))
4564 timers
= XCDR (timers
);
4568 if (!NILP (idle_timers
))
4570 timer
= XCAR (idle_timers
);
4571 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4573 idle_timers
= XCDR (idle_timers
);
4576 vector
= XVECTOR (timer
)->contents
;
4578 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4579 || !INTEGERP (vector
[3])
4580 || ! NILP (vector
[0]))
4582 idle_timers
= XCDR (idle_timers
);
4587 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4588 based on the next ordinary timer.
4589 TIMER_DIFFERENCE is the distance in time from NOW to when
4590 this timer becomes ripe (negative if it's already ripe). */
4593 timer
= XCAR (timers
);
4594 vector
= XVECTOR (timer
)->contents
;
4595 EMACS_SET_SECS (timer_time
,
4596 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4597 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4598 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4601 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4602 based on the next idle timer. */
4603 if (!NILP (idle_timers
))
4605 idle_timer
= XCAR (idle_timers
);
4606 vector
= XVECTOR (idle_timer
)->contents
;
4607 EMACS_SET_SECS (idle_timer_time
,
4608 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4609 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4610 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4613 /* Decide which timer is the next timer,
4614 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4615 Also step down the list where we found that timer. */
4617 if (! NILP (timers
) && ! NILP (idle_timers
))
4620 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4621 if (EMACS_TIME_NEG_P (temp
))
4623 chosen_timer
= timer
;
4624 timers
= XCDR (timers
);
4625 difference
= timer_difference
;
4629 chosen_timer
= idle_timer
;
4630 idle_timers
= XCDR (idle_timers
);
4631 difference
= idle_timer_difference
;
4634 else if (! NILP (timers
))
4636 chosen_timer
= timer
;
4637 timers
= XCDR (timers
);
4638 difference
= timer_difference
;
4642 chosen_timer
= idle_timer
;
4643 idle_timers
= XCDR (idle_timers
);
4644 difference
= idle_timer_difference
;
4646 vector
= XVECTOR (chosen_timer
)->contents
;
4648 /* If timer is ripe, run it if it hasn't been run. */
4649 if (EMACS_TIME_NEG_P (difference
)
4650 || (EMACS_SECS (difference
) == 0
4651 && EMACS_USECS (difference
) == 0))
4653 if (NILP (vector
[0]))
4655 int count
= SPECPDL_INDEX ();
4656 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4658 #if 0 /* This shouldn't be necessary anymore. --lorentey */
4659 /* On unbind_to, resume allowing input from any kboard, if that
4661 record_single_kboard_state ();
4663 /* Mark the timer as triggered to prevent problems if the lisp
4664 code fails to reschedule it right. */
4667 specbind (Qinhibit_quit
, Qt
);
4669 call1 (Qtimer_event_handler
, chosen_timer
);
4670 Vdeactivate_mark
= old_deactivate_mark
;
4672 unbind_to (count
, Qnil
);
4674 /* Since we have handled the event,
4675 we don't need to tell the caller to wake up and do it. */
4679 /* When we encounter a timer that is still waiting,
4680 return the amount of time to wait before it is ripe. */
4687 /* No timers are pending in the future. */
4688 /* Return 0 if we generated an event, and -1 if not. */
4693 DEFUN ("current-idle-time", Fcurrent_idle_time
, Scurrent_idle_time
, 0, 0, 0,
4694 doc
: /* Return the current length of Emacs idleness, or nil.
4695 The value when Emacs is idle is a list of three integers. The first has the
4696 most significant 16 bits of the seconds, while the second has the
4697 least significant 16 bits. The third integer gives the microsecond
4700 The value when Emacs is not idle is nil.
4702 The microsecond count is zero on systems that do not provide
4703 resolution finer than a second. */)
4706 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4708 EMACS_TIME now
, idleness_now
;
4710 EMACS_GET_TIME (now
);
4711 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4713 return list3 (make_number ((EMACS_SECS (idleness_now
) >> 16) & 0xffff),
4714 make_number ((EMACS_SECS (idleness_now
) >> 0) & 0xffff),
4715 make_number (EMACS_USECS (idleness_now
)));
4721 /* Caches for modify_event_symbol. */
4722 static Lisp_Object accent_key_syms
;
4723 static Lisp_Object func_key_syms
;
4724 static Lisp_Object mouse_syms
;
4725 static Lisp_Object wheel_syms
;
4726 static Lisp_Object drag_n_drop_syms
;
4728 /* This is a list of keysym codes for special "accent" characters.
4729 It parallels lispy_accent_keys. */
4731 static int lispy_accent_codes
[] =
4733 #ifdef XK_dead_circumflex
4738 #ifdef XK_dead_grave
4743 #ifdef XK_dead_tilde
4748 #ifdef XK_dead_diaeresis
4753 #ifdef XK_dead_macron
4758 #ifdef XK_dead_degree
4763 #ifdef XK_dead_acute
4768 #ifdef XK_dead_cedilla
4773 #ifdef XK_dead_breve
4778 #ifdef XK_dead_ogonek
4783 #ifdef XK_dead_caron
4788 #ifdef XK_dead_doubleacute
4789 XK_dead_doubleacute
,
4793 #ifdef XK_dead_abovedot
4798 #ifdef XK_dead_abovering
4808 #ifdef XK_dead_belowdot
4813 #ifdef XK_dead_voiced_sound
4814 XK_dead_voiced_sound
,
4818 #ifdef XK_dead_semivoiced_sound
4819 XK_dead_semivoiced_sound
,
4835 /* This is a list of Lisp names for special "accent" characters.
4836 It parallels lispy_accent_codes. */
4838 static char *lispy_accent_keys
[] =
4856 "dead-voiced-sound",
4857 "dead-semivoiced-sound",
4863 #define FUNCTION_KEY_OFFSET 0x0
4865 char *lispy_function_keys
[] =
4869 0, /* VK_LBUTTON 0x01 */
4870 0, /* VK_RBUTTON 0x02 */
4871 "cancel", /* VK_CANCEL 0x03 */
4872 0, /* VK_MBUTTON 0x04 */
4874 0, 0, 0, /* 0x05 .. 0x07 */
4876 "backspace", /* VK_BACK 0x08 */
4877 "tab", /* VK_TAB 0x09 */
4879 0, 0, /* 0x0A .. 0x0B */
4881 "clear", /* VK_CLEAR 0x0C */
4882 "return", /* VK_RETURN 0x0D */
4884 0, 0, /* 0x0E .. 0x0F */
4886 0, /* VK_SHIFT 0x10 */
4887 0, /* VK_CONTROL 0x11 */
4888 0, /* VK_MENU 0x12 */
4889 "pause", /* VK_PAUSE 0x13 */
4890 "capslock", /* VK_CAPITAL 0x14 */
4891 "kana", /* VK_KANA/VK_HANGUL 0x15 */
4893 "junja", /* VK_JUNJA 0x17 */
4894 "final", /* VK_FINAL 0x18 */
4895 "kanji", /* VK_KANJI/VK_HANJA 0x19 */
4897 "escape", /* VK_ESCAPE 0x1B */
4898 "convert", /* VK_CONVERT 0x1C */
4899 "non-convert", /* VK_NONCONVERT 0x1D */
4900 "accept", /* VK_ACCEPT 0x1E */
4901 "mode-change", /* VK_MODECHANGE 0x1F */
4902 0, /* VK_SPACE 0x20 */
4903 "prior", /* VK_PRIOR 0x21 */
4904 "next", /* VK_NEXT 0x22 */
4905 "end", /* VK_END 0x23 */
4906 "home", /* VK_HOME 0x24 */
4907 "left", /* VK_LEFT 0x25 */
4908 "up", /* VK_UP 0x26 */
4909 "right", /* VK_RIGHT 0x27 */
4910 "down", /* VK_DOWN 0x28 */
4911 "select", /* VK_SELECT 0x29 */
4912 "print", /* VK_PRINT 0x2A */
4913 "execute", /* VK_EXECUTE 0x2B */
4914 "snapshot", /* VK_SNAPSHOT 0x2C */
4915 "insert", /* VK_INSERT 0x2D */
4916 "delete", /* VK_DELETE 0x2E */
4917 "help", /* VK_HELP 0x2F */
4919 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4921 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4923 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4925 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4927 0, 0, 0, 0, 0, 0, 0, 0, 0,
4928 0, 0, 0, 0, 0, 0, 0, 0, 0,
4929 0, 0, 0, 0, 0, 0, 0, 0,
4931 "lwindow", /* VK_LWIN 0x5B */
4932 "rwindow", /* VK_RWIN 0x5C */
4933 "apps", /* VK_APPS 0x5D */
4936 "kp-0", /* VK_NUMPAD0 0x60 */
4937 "kp-1", /* VK_NUMPAD1 0x61 */
4938 "kp-2", /* VK_NUMPAD2 0x62 */
4939 "kp-3", /* VK_NUMPAD3 0x63 */
4940 "kp-4", /* VK_NUMPAD4 0x64 */
4941 "kp-5", /* VK_NUMPAD5 0x65 */
4942 "kp-6", /* VK_NUMPAD6 0x66 */
4943 "kp-7", /* VK_NUMPAD7 0x67 */
4944 "kp-8", /* VK_NUMPAD8 0x68 */
4945 "kp-9", /* VK_NUMPAD9 0x69 */
4946 "kp-multiply", /* VK_MULTIPLY 0x6A */
4947 "kp-add", /* VK_ADD 0x6B */
4948 "kp-separator", /* VK_SEPARATOR 0x6C */
4949 "kp-subtract", /* VK_SUBTRACT 0x6D */
4950 "kp-decimal", /* VK_DECIMAL 0x6E */
4951 "kp-divide", /* VK_DIVIDE 0x6F */
4952 "f1", /* VK_F1 0x70 */
4953 "f2", /* VK_F2 0x71 */
4954 "f3", /* VK_F3 0x72 */
4955 "f4", /* VK_F4 0x73 */
4956 "f5", /* VK_F5 0x74 */
4957 "f6", /* VK_F6 0x75 */
4958 "f7", /* VK_F7 0x76 */
4959 "f8", /* VK_F8 0x77 */
4960 "f9", /* VK_F9 0x78 */
4961 "f10", /* VK_F10 0x79 */
4962 "f11", /* VK_F11 0x7A */
4963 "f12", /* VK_F12 0x7B */
4964 "f13", /* VK_F13 0x7C */
4965 "f14", /* VK_F14 0x7D */
4966 "f15", /* VK_F15 0x7E */
4967 "f16", /* VK_F16 0x7F */
4968 "f17", /* VK_F17 0x80 */
4969 "f18", /* VK_F18 0x81 */
4970 "f19", /* VK_F19 0x82 */
4971 "f20", /* VK_F20 0x83 */
4972 "f21", /* VK_F21 0x84 */
4973 "f22", /* VK_F22 0x85 */
4974 "f23", /* VK_F23 0x86 */
4975 "f24", /* VK_F24 0x87 */
4977 0, 0, 0, 0, /* 0x88 .. 0x8B */
4978 0, 0, 0, 0, /* 0x8C .. 0x8F */
4980 "kp-numlock", /* VK_NUMLOCK 0x90 */
4981 "scroll", /* VK_SCROLL 0x91 */
4982 /* Not sure where the following block comes from.
4983 Windows headers have NEC and Fujitsu specific keys in
4984 this block, but nothing generic. */
4985 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4986 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4987 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4988 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4989 "kp-end", /* VK_NUMPAD_END 0x96 */
4990 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4991 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4992 "kp-up", /* VK_NUMPAD_UP 0x99 */
4993 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4994 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4995 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4996 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4998 0, 0, /* 0x9E .. 0x9F */
5001 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
5002 * Used only as parameters to GetAsyncKeyState and GetKeyState.
5003 * No other API or message will distinguish left and right keys this way.
5008 /* Multimedia keys. These are handled as WM_APPCOMMAND, which allows us
5009 to enable them selectively, and gives access to a few more functions.
5010 See lispy_multimedia_keys below. */
5011 0, 0, 0, 0, 0, 0, 0, /* 0xA6 .. 0xAC Browser */
5012 0, 0, 0, /* 0xAD .. 0xAF Volume */
5013 0, 0, 0, 0, /* 0xB0 .. 0xB3 Media */
5014 0, 0, 0, 0, /* 0xB4 .. 0xB7 Apps */
5016 /* 0xB8 .. 0xC0 "OEM" keys - all seem to be punctuation. */
5017 0, 0, 0, 0, 0, 0, 0, 0, 0,
5019 /* 0xC1 - 0xDA unallocated, 0xDB-0xDF more OEM keys */
5020 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5021 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5024 "ax", /* VK_OEM_AX 0xE1 */
5025 0, /* VK_OEM_102 0xE2 */
5026 "ico-help", /* VK_ICO_HELP 0xE3 */
5027 "ico-00", /* VK_ICO_00 0xE4 */
5028 0, /* VK_PROCESSKEY 0xE5 */
5029 "ico-clear", /* VK_ICO_CLEAR 0xE6 */
5030 "packet", /* VK_PACKET 0xE7 */
5032 "reset", /* VK_OEM_RESET 0xE9 */
5033 "jump", /* VK_OEM_JUMP 0xEA */
5034 "oem-pa1", /* VK_OEM_PA1 0xEB */
5035 "oem-pa2", /* VK_OEM_PA2 0xEC */
5036 "oem-pa3", /* VK_OEM_PA3 0xED */
5037 "wsctrl", /* VK_OEM_WSCTRL 0xEE */
5038 "cusel", /* VK_OEM_CUSEL 0xEF */
5039 "oem-attn", /* VK_OEM_ATTN 0xF0 */
5040 "finish", /* VK_OEM_FINISH 0xF1 */
5041 "copy", /* VK_OEM_COPY 0xF2 */
5042 "auto", /* VK_OEM_AUTO 0xF3 */
5043 "enlw", /* VK_OEM_ENLW 0xF4 */
5044 "backtab", /* VK_OEM_BACKTAB 0xF5 */
5045 "attn", /* VK_ATTN 0xF6 */
5046 "crsel", /* VK_CRSEL 0xF7 */
5047 "exsel", /* VK_EXSEL 0xF8 */
5048 "ereof", /* VK_EREOF 0xF9 */
5049 "play", /* VK_PLAY 0xFA */
5050 "zoom", /* VK_ZOOM 0xFB */
5051 "noname", /* VK_NONAME 0xFC */
5052 "pa1", /* VK_PA1 0xFD */
5053 "oem_clear", /* VK_OEM_CLEAR 0xFE */
5057 /* Some of these duplicate the "Media keys" on newer keyboards,
5058 but they are delivered to the application in a different way. */
5059 static char *lispy_multimedia_keys
[] =
5067 "browser-favorites",
5104 "toggle-dictate-command",
5110 "media-fast-forward",
5113 "media-channel-down"
5116 #else /* not HAVE_NTGUI */
5118 /* This should be dealt with in XTread_socket now, and that doesn't
5119 depend on the client system having the Kana syms defined. See also
5120 the XK_kana_A case below. */
5123 static char *lispy_kana_keys
[] =
5125 /* X Keysym value */
5126 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
5127 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
5128 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
5129 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
5130 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
5131 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
5132 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
5133 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
5134 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
5135 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
5136 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
5137 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
5138 "kana-i", "kana-u", "kana-e", "kana-o",
5139 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
5140 "prolongedsound", "kana-A", "kana-I", "kana-U",
5141 "kana-E", "kana-O", "kana-KA", "kana-KI",
5142 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
5143 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
5144 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
5145 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
5146 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
5147 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
5148 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
5149 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
5150 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
5151 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
5152 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
5153 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
5155 #endif /* XK_kana_A */
5158 #define FUNCTION_KEY_OFFSET 0xff00
5160 /* You'll notice that this table is arranged to be conveniently
5161 indexed by X Windows keysym values. */
5162 static char *lispy_function_keys
[] =
5164 /* X Keysym value */
5166 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
5167 "backspace", "tab", "linefeed", "clear",
5169 0, 0, 0, "pause", /* 0xff10...1f */
5170 0, 0, 0, 0, 0, 0, 0, "escape",
5172 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
5173 "romaji", "hiragana", "katakana", "hiragana-katakana",
5174 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
5175 "massyo", "kana-lock", "kana-shift", "eisu-shift",
5176 "eisu-toggle", /* 0xff30...3f */
5177 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5178 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
5180 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
5181 "down", "prior", "next", "end",
5182 "begin", 0, 0, 0, 0, 0, 0, 0,
5183 "select", /* 0xff60 */ /* IsMiscFunctionKey */
5194 "break", /* 0xff6b */
5197 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
5198 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
5199 "kp-space", /* 0xff80 */ /* IsKeypadKey */
5200 0, 0, 0, 0, 0, 0, 0, 0,
5201 "kp-tab", /* 0xff89 */
5203 "kp-enter", /* 0xff8d */
5205 "kp-f1", /* 0xff91 */
5209 "kp-home", /* 0xff95 */
5214 "kp-prior", /* kp-page-up */
5215 "kp-next", /* kp-page-down */
5221 0, 0, 0, 0, 0, 0, 0, 0, 0,
5222 "kp-multiply", /* 0xffaa */
5227 "kp-divide", /* 0xffaf */
5228 "kp-0", /* 0xffb0 */
5229 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
5232 "kp-equal", /* 0xffbd */
5233 "f1", /* 0xffbe */ /* IsFunctionKey */
5235 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
5236 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
5237 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
5238 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
5239 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
5240 0, 0, 0, 0, 0, 0, 0, 0,
5241 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
5242 0, 0, 0, 0, 0, 0, 0, "delete"
5245 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
5246 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
5248 static char *iso_lispy_function_keys
[] =
5250 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
5251 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
5252 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
5253 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
5254 "iso-lefttab", /* 0xfe20 */
5255 "iso-move-line-up", "iso-move-line-down",
5256 "iso-partial-line-up", "iso-partial-line-down",
5257 "iso-partial-space-left", "iso-partial-space-right",
5258 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
5259 "iso-release-margin-left", "iso-release-margin-right",
5260 "iso-release-both-margins",
5261 "iso-fast-cursor-left", "iso-fast-cursor-right",
5262 "iso-fast-cursor-up", "iso-fast-cursor-down",
5263 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
5264 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
5267 #endif /* not HAVE_NTGUI */
5269 Lisp_Object Vlispy_mouse_stem
;
5271 static char *lispy_wheel_names
[] =
5273 "wheel-up", "wheel-down", "wheel-left", "wheel-right"
5276 /* drag-n-drop events are generated when a set of selected files are
5277 dragged from another application and dropped onto an Emacs window. */
5278 static char *lispy_drag_n_drop_names
[] =
5283 /* Scroll bar parts. */
5284 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
5285 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
5286 Lisp_Object Qtop
, Qratio
;
5288 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
5289 Lisp_Object
*scroll_bar_parts
[] = {
5290 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
5291 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
5294 /* A vector, indexed by button number, giving the down-going location
5295 of currently depressed buttons, both scroll bar and non-scroll bar.
5297 The elements have the form
5298 (BUTTON-NUMBER MODIFIER-MASK . REST)
5299 where REST is the cdr of a position as it would be reported in the event.
5301 The make_lispy_event function stores positions here to tell the
5302 difference between click and drag events, and to store the starting
5303 location to be included in drag events. */
5305 static Lisp_Object button_down_location
;
5307 /* Information about the most recent up-going button event: Which
5308 button, what location, and what time. */
5310 static int last_mouse_button
;
5311 static int last_mouse_x
;
5312 static int last_mouse_y
;
5313 static unsigned long button_down_time
;
5315 /* The maximum time between clicks to make a double-click, or Qnil to
5316 disable double-click detection, or Qt for no time limit. */
5318 Lisp_Object Vdouble_click_time
;
5320 /* Maximum number of pixels the mouse may be moved between clicks
5321 to make a double-click. */
5323 EMACS_INT double_click_fuzz
;
5325 /* The number of clicks in this multiple-click. */
5327 int double_click_count
;
5329 /* Return position of a mouse click or wheel event */
5332 make_lispy_position (f
, x
, y
, time
)
5338 enum window_part part
;
5339 Lisp_Object posn
= Qnil
;
5340 Lisp_Object extra_info
= Qnil
;
5343 /* Set `window' to the window under frame pixel coordinates (x,y) */
5345 window
= window_from_coordinates (f
, XINT (*x
), XINT (*y
),
5346 &part
, &wx
, &wy
, 0);
5350 if (WINDOWP (window
))
5352 /* It's a click in window window at frame coordinates (x,y) */
5353 struct window
*w
= XWINDOW (window
);
5354 Lisp_Object string_info
= Qnil
;
5355 int textpos
= -1, rx
= -1, ry
= -1;
5356 int dx
= -1, dy
= -1;
5357 int width
= -1, height
= -1;
5358 Lisp_Object object
= Qnil
;
5360 /* Set event coordinates to window-relative coordinates
5361 for constructing the Lisp event below. */
5365 if (part
== ON_TEXT
)
5367 wx
+= WINDOW_LEFT_MARGIN_WIDTH (w
);
5369 else if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
5371 /* Mode line or header line. Look for a string under
5372 the mouse that may have a `local-map' property. */
5376 posn
= part
== ON_MODE_LINE
? Qmode_line
: Qheader_line
;
5378 string
= mode_line_string (w
, part
, &rx
, &ry
, &charpos
,
5379 &object
, &dx
, &dy
, &width
, &height
);
5380 if (STRINGP (string
))
5381 string_info
= Fcons (string
, make_number (charpos
));
5382 if (w
== XWINDOW (selected_window
))
5385 textpos
= XMARKER (w
->pointm
)->charpos
;
5387 else if (part
== ON_VERTICAL_BORDER
)
5389 posn
= Qvertical_line
;
5394 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5399 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5401 string
= marginal_area_string (w
, part
, &rx
, &ry
, &charpos
,
5402 &object
, &dx
, &dy
, &width
, &height
);
5403 if (STRINGP (string
))
5404 string_info
= Fcons (string
, make_number (charpos
));
5405 if (part
== ON_LEFT_MARGIN
)
5408 wx
= window_box_right_offset (w
, TEXT_AREA
) - 1;
5410 else if (part
== ON_LEFT_FRINGE
)
5412 posn
= Qleft_fringe
;
5415 wx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5417 : window_box_width (w
, LEFT_MARGIN_AREA
));
5420 else if (part
== ON_RIGHT_FRINGE
)
5422 posn
= Qright_fringe
;
5425 wx
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5426 + window_box_width (w
, TEXT_AREA
)
5427 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5428 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5434 /* Note: We have no special posn for part == ON_SCROLL_BAR. */
5435 wx
= max (WINDOW_LEFT_MARGIN_WIDTH (w
), wx
);
5440 Lisp_Object string2
, object2
= Qnil
;
5441 struct display_pos p
;
5443 int width2
, height2
;
5444 string2
= buffer_posn_from_coords (w
, &wx
, &wy
, &p
,
5445 &object2
, &dx2
, &dy2
,
5447 textpos
= CHARPOS (p
.pos
);
5448 if (rx
< 0) rx
= wx
;
5449 if (ry
< 0) ry
= wy
;
5450 if (dx
< 0) dx
= dx2
;
5451 if (dy
< 0) dy
= dy2
;
5452 if (width
< 0) width
= width2
;
5453 if (height
< 0) height
= height2
;
5457 posn
= make_number (textpos
);
5458 if (STRINGP (string2
))
5459 string_info
= Fcons (string2
,
5460 make_number (CHARPOS (p
.string_pos
)));
5466 #ifdef HAVE_WINDOW_SYSTEM
5467 if (IMAGEP (object
))
5469 Lisp_Object image_map
, hotspot
;
5470 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5472 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5474 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5475 posn
= XCAR (hotspot
);
5480 extra_info
= Fcons (object
,
5481 Fcons (Fcons (make_number (dx
),
5483 Fcons (Fcons (make_number (width
),
5484 make_number (height
)),
5488 extra_info
= Fcons (string_info
,
5489 Fcons (make_number (textpos
),
5490 Fcons (Fcons (make_number (rx
),
5496 XSETFRAME (window
, f
);
5501 XSETFASTINT (*x
, 0);
5502 XSETFASTINT (*y
, 0);
5505 return Fcons (window
,
5507 Fcons (Fcons (*x
, *y
),
5508 Fcons (make_number (time
),
5512 /* Given a struct input_event, build the lisp event which represents
5513 it. If EVENT is 0, build a mouse movement event from the mouse
5514 movement buffer, which should have a movement event in it.
5516 Note that events must be passed to this function in the order they
5517 are received; this function stores the location of button presses
5518 in order to build drag events when the button is released. */
5521 make_lispy_event (event
)
5522 struct input_event
*event
;
5526 switch (SWITCH_ENUM_CAST (event
->kind
))
5528 /* A simple keystroke. */
5529 case ASCII_KEYSTROKE_EVENT
:
5530 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5532 Lisp_Object lispy_c
;
5533 int c
= event
->code
;
5534 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
5537 eassert (c
== event
->code
);
5538 /* Turn ASCII characters into control characters
5540 if (event
->modifiers
& ctrl_modifier
)
5542 c
= make_ctrl_char (c
);
5543 event
->modifiers
&= ~ctrl_modifier
;
5547 /* Add in the other modifier bits. The shift key was taken care
5548 of by the X code. */
5549 c
|= (event
->modifiers
5550 & (meta_modifier
| alt_modifier
5551 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5552 /* Distinguish Shift-SPC from SPC. */
5553 if ((event
->code
) == 040
5554 && event
->modifiers
& shift_modifier
)
5555 c
|= shift_modifier
;
5556 button_down_time
= 0;
5557 XSETFASTINT (lispy_c
, c
);
5561 /* A function key. The symbol may need to have modifier prefixes
5563 case NON_ASCII_KEYSTROKE_EVENT
:
5564 button_down_time
= 0;
5566 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5567 if (event
->code
== lispy_accent_codes
[i
])
5568 return modify_event_symbol (i
,
5570 Qfunction_key
, Qnil
,
5571 lispy_accent_keys
, &accent_key_syms
,
5572 (sizeof (lispy_accent_keys
)
5573 / sizeof (lispy_accent_keys
[0])));
5577 if (event
->code
>= 0x400 && event
->code
< 0x500)
5578 return modify_event_symbol (event
->code
- 0x400,
5579 event
->modifiers
& ~shift_modifier
,
5580 Qfunction_key
, Qnil
,
5581 lispy_kana_keys
, &func_key_syms
,
5582 (sizeof (lispy_kana_keys
)
5583 / sizeof (lispy_kana_keys
[0])));
5584 #endif /* XK_kana_A */
5587 #ifdef ISO_FUNCTION_KEY_OFFSET
5588 if (event
->code
< FUNCTION_KEY_OFFSET
5589 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5590 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5592 Qfunction_key
, Qnil
,
5593 iso_lispy_function_keys
, &func_key_syms
,
5594 (sizeof (iso_lispy_function_keys
)
5595 / sizeof (iso_lispy_function_keys
[0])));
5598 /* Handle system-specific or unknown keysyms. */
5599 if (event
->code
& (1 << 28)
5600 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5601 || (event
->code
- FUNCTION_KEY_OFFSET
5602 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5603 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5605 /* We need to use an alist rather than a vector as the cache
5606 since we can't make a vector long enuf. */
5607 if (NILP (current_kboard
->system_key_syms
))
5608 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
5609 return modify_event_symbol (event
->code
,
5612 current_kboard
->Vsystem_key_alist
,
5613 0, ¤t_kboard
->system_key_syms
,
5617 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5619 Qfunction_key
, Qnil
,
5620 lispy_function_keys
, &func_key_syms
,
5621 (sizeof (lispy_function_keys
)
5622 / sizeof (lispy_function_keys
[0])));
5625 case MULTIMEDIA_KEY_EVENT
:
5626 if (event
->code
< (sizeof (lispy_multimedia_keys
)
5627 / sizeof (lispy_multimedia_keys
[0]))
5628 && event
->code
> 0 && lispy_multimedia_keys
[event
->code
])
5630 return modify_event_symbol (event
->code
, event
->modifiers
,
5631 Qfunction_key
, Qnil
,
5632 lispy_multimedia_keys
, &func_key_syms
,
5633 (sizeof (lispy_multimedia_keys
)
5634 / sizeof (lispy_multimedia_keys
[0])));
5640 /* A mouse click. Figure out where it is, decide whether it's
5641 a press, click or drag, and build the appropriate structure. */
5642 case MOUSE_CLICK_EVENT
:
5643 #ifndef USE_TOOLKIT_SCROLL_BARS
5644 case SCROLL_BAR_CLICK_EVENT
:
5647 int button
= event
->code
;
5649 Lisp_Object position
;
5650 Lisp_Object
*start_pos_ptr
;
5651 Lisp_Object start_pos
;
5655 /* Build the position as appropriate for this mouse click. */
5656 if (event
->kind
== MOUSE_CLICK_EVENT
)
5658 struct frame
*f
= XFRAME (event
->frame_or_window
);
5659 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5663 /* Ignore mouse events that were made on frame that
5664 have been deleted. */
5665 if (! FRAME_LIVE_P (f
))
5668 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5669 /* EVENT->x and EVENT->y are frame-relative pixel
5670 coordinates at this place. Under old redisplay, COLUMN
5671 and ROW are set to frame relative glyph coordinates
5672 which are then used to determine whether this click is
5673 in a menu (non-toolkit version). */
5674 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5675 &column
, &row
, NULL
, 1);
5677 /* In the non-toolkit version, clicks on the menu bar
5678 are ordinary button events in the event buffer.
5679 Distinguish them, and invoke the menu.
5681 (In the toolkit version, the toolkit handles the menu bar
5682 and Emacs doesn't know about it until after the user
5683 makes a selection.) */
5684 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5685 && (event
->modifiers
& down_modifier
))
5687 Lisp_Object items
, item
;
5692 /* Activate the menu bar on the down event. If the
5693 up event comes in before the menu code can deal with it,
5695 if (! (event
->modifiers
& down_modifier
))
5699 /* Find the menu bar item under `column'. */
5701 items
= FRAME_MENU_BAR_ITEMS (f
);
5702 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5704 Lisp_Object pos
, string
;
5705 string
= AREF (items
, i
+ 1);
5706 pos
= AREF (items
, i
+ 3);
5709 if (column
>= XINT (pos
)
5710 && column
< XINT (pos
) + SCHARS (string
))
5712 item
= AREF (items
, i
);
5717 /* ELisp manual 2.4b says (x y) are window relative but
5718 code says they are frame-relative. */
5720 = Fcons (event
->frame_or_window
,
5722 Fcons (Fcons (event
->x
, event
->y
),
5723 Fcons (make_number (event
->timestamp
),
5726 return Fcons (item
, Fcons (position
, Qnil
));
5728 #endif /* not USE_X_TOOLKIT && not USE_GTK */
5730 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5733 #ifndef USE_TOOLKIT_SCROLL_BARS
5736 /* It's a scrollbar click. */
5738 Lisp_Object portion_whole
;
5741 window
= event
->frame_or_window
;
5742 portion_whole
= Fcons (event
->x
, event
->y
);
5743 part
= *scroll_bar_parts
[(int) event
->part
];
5747 Fcons (Qvertical_scroll_bar
,
5748 Fcons (portion_whole
,
5749 Fcons (make_number (event
->timestamp
),
5750 Fcons (part
, Qnil
)))));
5752 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5754 if (button
>= ASIZE (button_down_location
))
5756 button_down_location
= larger_vector (button_down_location
,
5758 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5761 start_pos_ptr
= &AREF (button_down_location
, button
);
5762 start_pos
= *start_pos_ptr
;
5763 *start_pos_ptr
= Qnil
;
5766 /* On window-system frames, use the value of
5767 double-click-fuzz as is. On other frames, interpret it
5768 as a multiple of 1/8 characters. */
5772 if (WINDOWP (event
->frame_or_window
))
5773 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5774 else if (FRAMEP (event
->frame_or_window
))
5775 f
= XFRAME (event
->frame_or_window
);
5779 if (FRAME_WINDOW_P (f
))
5780 fuzz
= double_click_fuzz
;
5782 fuzz
= double_click_fuzz
/ 8;
5784 is_double
= (button
== last_mouse_button
5785 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5786 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5787 && button_down_time
!= 0
5788 && (EQ (Vdouble_click_time
, Qt
)
5789 || (INTEGERP (Vdouble_click_time
)
5790 && ((int)(event
->timestamp
- button_down_time
)
5791 < XINT (Vdouble_click_time
)))));
5794 last_mouse_button
= button
;
5795 last_mouse_x
= XINT (event
->x
);
5796 last_mouse_y
= XINT (event
->y
);
5798 /* If this is a button press, squirrel away the location, so
5799 we can decide later whether it was a click or a drag. */
5800 if (event
->modifiers
& down_modifier
)
5804 double_click_count
++;
5805 event
->modifiers
|= ((double_click_count
> 2)
5810 double_click_count
= 1;
5811 button_down_time
= event
->timestamp
;
5812 *start_pos_ptr
= Fcopy_alist (position
);
5813 ignore_mouse_drag_p
= 0;
5816 /* Now we're releasing a button - check the co-ordinates to
5817 see if this was a click or a drag. */
5818 else if (event
->modifiers
& up_modifier
)
5820 /* If we did not see a down before this up, ignore the up.
5821 Probably this happened because the down event chose a
5822 menu item. It would be an annoyance to treat the
5823 release of the button that chose the menu item as a
5826 if (!CONSP (start_pos
))
5829 event
->modifiers
&= ~up_modifier
;
5830 #if 0 /* Formerly we treated an up with no down as a click event. */
5831 if (!CONSP (start_pos
))
5832 event
->modifiers
|= click_modifier
;
5837 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5839 /* The third element of every position
5840 should be the (x,y) pair. */
5841 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5843 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5845 xdiff
= XINT (event
->x
) - XINT (XCAR (down
));
5846 ydiff
= XINT (event
->y
) - XINT (XCDR (down
));
5849 if (ignore_mouse_drag_p
)
5851 event
->modifiers
|= click_modifier
;
5852 ignore_mouse_drag_p
= 0;
5854 else if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5855 && ydiff
< double_click_fuzz
&& ydiff
> - double_click_fuzz
5856 /* Maybe the mouse has moved a lot, caused scrolling, and
5857 eventually ended up at the same screen position (but
5858 not buffer position) in which case it is a drag, not
5860 /* FIXME: OTOH if the buffer position has changed
5861 because of a timer or process filter rather than
5862 because of mouse movement, it should be considered as
5863 a click. But mouse-drag-region completely ignores
5864 this case and it hasn't caused any real problem, so
5865 it's probably OK to ignore it as well. */
5866 && EQ (Fcar (Fcdr (start_pos
)), Fcar (Fcdr (position
))))
5867 /* Mouse hasn't moved (much). */
5868 event
->modifiers
|= click_modifier
;
5871 button_down_time
= 0;
5872 event
->modifiers
|= drag_modifier
;
5875 /* Don't check is_double; treat this as multiple
5876 if the down-event was multiple. */
5877 if (double_click_count
> 1)
5878 event
->modifiers
|= ((double_click_count
> 2)
5884 /* Every mouse event should either have the down_modifier or
5885 the up_modifier set. */
5889 /* Get the symbol we should use for the mouse click. */
5892 head
= modify_event_symbol (button
,
5894 Qmouse_click
, Vlispy_mouse_stem
,
5897 XVECTOR (mouse_syms
)->size
);
5898 if (event
->modifiers
& drag_modifier
)
5903 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5906 Fcons (make_number (double_click_count
),
5916 case HORIZ_WHEEL_EVENT
:
5918 Lisp_Object position
;
5921 /* Build the position as appropriate for this mouse click. */
5922 struct frame
*f
= XFRAME (event
->frame_or_window
);
5924 /* Ignore wheel events that were made on frame that have been
5926 if (! FRAME_LIVE_P (f
))
5929 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5932 /* Set double or triple modifiers to indicate the wheel speed. */
5934 /* On window-system frames, use the value of
5935 double-click-fuzz as is. On other frames, interpret it
5936 as a multiple of 1/8 characters. */
5941 if (WINDOWP (event
->frame_or_window
))
5942 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5943 else if (FRAMEP (event
->frame_or_window
))
5944 f
= XFRAME (event
->frame_or_window
);
5948 if (FRAME_WINDOW_P (f
))
5949 fuzz
= double_click_fuzz
;
5951 fuzz
= double_click_fuzz
/ 8;
5953 is_double
= (last_mouse_button
< 0
5954 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5955 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5956 && button_down_time
!= 0
5957 && (EQ (Vdouble_click_time
, Qt
)
5958 || (INTEGERP (Vdouble_click_time
)
5959 && ((int)(event
->timestamp
- button_down_time
)
5960 < XINT (Vdouble_click_time
)))));
5963 double_click_count
++;
5964 event
->modifiers
|= ((double_click_count
> 2)
5970 double_click_count
= 1;
5971 event
->modifiers
|= click_modifier
;
5974 button_down_time
= event
->timestamp
;
5975 /* Use a negative value to distinguish wheel from mouse button. */
5976 last_mouse_button
= -1;
5977 last_mouse_x
= XINT (event
->x
);
5978 last_mouse_y
= XINT (event
->y
);
5984 if (event
->modifiers
& up_modifier
)
5986 /* Emit a wheel-up event. */
5987 event
->modifiers
&= ~up_modifier
;
5990 else if (event
->modifiers
& down_modifier
)
5992 /* Emit a wheel-down event. */
5993 event
->modifiers
&= ~down_modifier
;
5997 /* Every wheel event should either have the down_modifier or
5998 the up_modifier set. */
6001 if (event
->kind
== HORIZ_WHEEL_EVENT
)
6004 /* Get the symbol we should use for the wheel event. */
6005 head
= modify_event_symbol (symbol_num
,
6011 ASIZE (wheel_syms
));
6014 if (event
->modifiers
& (double_modifier
| triple_modifier
))
6017 Fcons (make_number (double_click_count
),
6026 #ifdef USE_TOOLKIT_SCROLL_BARS
6028 /* We don't have down and up events if using toolkit scroll bars,
6029 so make this always a click event. Store in the `part' of
6030 the Lisp event a symbol which maps to the following actions:
6032 `above_handle' page up
6033 `below_handle' page down
6037 `bottom' bottom of buffer
6038 `handle' thumb has been dragged.
6039 `end-scroll' end of interaction with scroll bar
6041 The incoming input_event contains in its `part' member an
6042 index of type `enum scroll_bar_part' which we can use as an
6043 index in scroll_bar_parts to get the appropriate symbol. */
6045 case SCROLL_BAR_CLICK_EVENT
:
6047 Lisp_Object position
, head
, window
, portion_whole
, part
;
6049 window
= event
->frame_or_window
;
6050 portion_whole
= Fcons (event
->x
, event
->y
);
6051 part
= *scroll_bar_parts
[(int) event
->part
];
6055 Fcons (Qvertical_scroll_bar
,
6056 Fcons (portion_whole
,
6057 Fcons (make_number (event
->timestamp
),
6058 Fcons (part
, Qnil
)))));
6060 /* Always treat scroll bar events as clicks. */
6061 event
->modifiers
|= click_modifier
;
6062 event
->modifiers
&= ~up_modifier
;
6064 if (event
->code
>= ASIZE (mouse_syms
))
6065 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
6067 /* Get the symbol we should use for the mouse click. */
6068 head
= modify_event_symbol (event
->code
,
6073 XVECTOR (mouse_syms
)->size
);
6074 return Fcons (head
, Fcons (position
, Qnil
));
6077 #endif /* USE_TOOLKIT_SCROLL_BARS */
6079 case DRAG_N_DROP_EVENT
:
6082 Lisp_Object head
, position
;
6085 f
= XFRAME (event
->frame_or_window
);
6088 /* Ignore mouse events that were made on frames that
6089 have been deleted. */
6090 if (! FRAME_LIVE_P (f
))
6093 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6096 head
= modify_event_symbol (0, event
->modifiers
,
6098 lispy_drag_n_drop_names
,
6099 &drag_n_drop_syms
, 1);
6105 #endif /* HAVE_MOUSE */
6107 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
6108 || defined (USE_GTK)
6109 case MENU_BAR_EVENT
:
6110 if (EQ (event
->arg
, event
->frame_or_window
))
6111 /* This is the prefix key. We translate this to
6112 `(menu_bar)' because the code in keyboard.c for menu
6113 events, which we use, relies on this. */
6114 return Fcons (Qmenu_bar
, Qnil
);
6118 case SELECT_WINDOW_EVENT
:
6119 /* Make an event (select-window (WINDOW)). */
6120 return Fcons (Qselect_window
,
6121 Fcons (Fcons (event
->frame_or_window
, Qnil
),
6124 case TOOL_BAR_EVENT
:
6125 if (EQ (event
->arg
, event
->frame_or_window
))
6126 /* This is the prefix key. We translate this to
6127 `(tool_bar)' because the code in keyboard.c for tool bar
6128 events, which we use, relies on this. */
6129 return Fcons (Qtool_bar
, Qnil
);
6130 else if (SYMBOLP (event
->arg
))
6131 return apply_modifiers (event
->modifiers
, event
->arg
);
6134 case USER_SIGNAL_EVENT
:
6135 /* A user signal. */
6137 char *name
= find_user_signal_name (event
->code
);
6140 return intern (name
);
6143 case SAVE_SESSION_EVENT
:
6144 return Qsave_session
;
6147 case MAC_APPLE_EVENT
:
6149 Lisp_Object spec
[2];
6153 return Fcons (Qmac_apple_event
,
6154 Fcons (Fvector (2, spec
),
6155 Fcons (event
->arg
, Qnil
)));
6162 return Fcons (Qdbus_event
, event
->arg
);
6164 #endif /* HAVE_DBUS */
6167 case GPM_CLICK_EVENT
:
6169 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
6170 Lisp_Object head
, position
;
6171 Lisp_Object
*start_pos_ptr
;
6172 Lisp_Object start_pos
;
6173 int button
= event
->code
;
6175 if (button
>= ASIZE (button_down_location
))
6177 button_down_location
= larger_vector (button_down_location
,
6179 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
6182 start_pos_ptr
= &AREF (button_down_location
, button
);
6183 start_pos
= *start_pos_ptr
;
6185 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6188 if (event
->modifiers
& down_modifier
)
6189 *start_pos_ptr
= Fcopy_alist (position
);
6190 else if (event
->modifiers
& (up_modifier
| drag_modifier
))
6192 if (!CONSP (start_pos
))
6194 event
->modifiers
&= ~up_modifier
;
6197 head
= modify_event_symbol (button
,
6199 Qmouse_click
, Vlispy_mouse_stem
,
6202 XVECTOR (mouse_syms
)->size
);
6204 if (event
->modifiers
& drag_modifier
)
6209 else if (event
->modifiers
& double_modifier
)
6212 Fcons (make_number (2),
6214 else if (event
->modifiers
& triple_modifier
)
6217 Fcons (make_number (3),
6224 #endif /* HAVE_GPM */
6226 /* The 'kind' field of the event is something we don't recognize. */
6232 #if defined(HAVE_MOUSE) || defined(HAVE_GPM)
6235 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
6237 Lisp_Object bar_window
;
6238 enum scroll_bar_part part
;
6242 /* Is it a scroll bar movement? */
6243 if (frame
&& ! NILP (bar_window
))
6245 Lisp_Object part_sym
;
6247 part_sym
= *scroll_bar_parts
[(int) part
];
6248 return Fcons (Qscroll_bar_movement
,
6249 (Fcons (Fcons (bar_window
,
6250 Fcons (Qvertical_scroll_bar
,
6251 Fcons (Fcons (x
, y
),
6252 Fcons (make_number (time
),
6258 /* Or is it an ordinary mouse movement? */
6261 Lisp_Object position
;
6263 position
= make_lispy_position (frame
, &x
, &y
, time
);
6265 return Fcons (Qmouse_movement
,
6271 #endif /* HAVE_MOUSE || HAVE GPM */
6273 /* Construct a switch frame event. */
6275 make_lispy_switch_frame (frame
)
6278 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
6281 /* Manipulating modifiers. */
6283 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
6285 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
6286 SYMBOL's name of the end of the modifiers; the string from this
6287 position is the unmodified symbol name.
6289 This doesn't use any caches. */
6292 parse_modifiers_uncached (symbol
, modifier_end
)
6300 CHECK_SYMBOL (symbol
);
6303 name
= SYMBOL_NAME (symbol
);
6305 for (i
= 0; i
+2 <= SBYTES (name
); )
6307 int this_mod_end
= 0;
6310 /* See if the name continues with a modifier word.
6311 Check that the word appears, but don't check what follows it.
6312 Set this_mod and this_mod_end to record what we find. */
6314 switch (SREF (name
, i
))
6316 #define SINGLE_LETTER_MOD(BIT) \
6317 (this_mod_end = i + 1, this_mod = BIT)
6320 SINGLE_LETTER_MOD (alt_modifier
);
6324 SINGLE_LETTER_MOD (ctrl_modifier
);
6328 SINGLE_LETTER_MOD (hyper_modifier
);
6332 SINGLE_LETTER_MOD (meta_modifier
);
6336 SINGLE_LETTER_MOD (shift_modifier
);
6340 SINGLE_LETTER_MOD (super_modifier
);
6343 #undef SINGLE_LETTER_MOD
6345 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6346 if (i + LEN + 1 <= SBYTES (name) \
6347 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
6349 this_mod_end = i + LEN; \
6354 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6355 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6356 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6360 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6362 #undef MULTI_LETTER_MOD
6366 /* If we found no modifier, stop looking for them. */
6367 if (this_mod_end
== 0)
6370 /* Check there is a dash after the modifier, so that it
6371 really is a modifier. */
6372 if (this_mod_end
>= SBYTES (name
)
6373 || SREF (name
, this_mod_end
) != '-')
6376 /* This modifier is real; look for another. */
6377 modifiers
|= this_mod
;
6378 i
= this_mod_end
+ 1;
6381 /* Should we include the `click' modifier? */
6382 if (! (modifiers
& (down_modifier
| drag_modifier
6383 | double_modifier
| triple_modifier
))
6384 && i
+ 7 == SBYTES (name
)
6385 && strncmp (SDATA (name
) + i
, "mouse-", 6) == 0
6386 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
6387 modifiers
|= click_modifier
;
6395 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6396 prepended to the string BASE[0..BASE_LEN-1].
6397 This doesn't use any caches. */
6399 apply_modifiers_uncached (modifiers
, base
, base_len
, base_len_byte
)
6402 int base_len
, base_len_byte
;
6404 /* Since BASE could contain nulls, we can't use intern here; we have
6405 to use Fintern, which expects a genuine Lisp_String, and keeps a
6408 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
6414 /* Only the event queue may use the `up' modifier; it should always
6415 be turned into a click or drag event before presented to lisp code. */
6416 if (modifiers
& up_modifier
)
6419 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
6420 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
6421 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
6422 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
6423 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
6424 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
6425 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
6426 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
6427 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
6428 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
6429 /* The click modifier is denoted by the absence of other modifiers. */
6433 mod_len
= p
- new_mods
;
6437 Lisp_Object new_name
;
6439 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
6440 mod_len
+ base_len_byte
);
6441 bcopy (new_mods
, SDATA (new_name
), mod_len
);
6442 bcopy (base
, SDATA (new_name
) + mod_len
, base_len_byte
);
6444 return Fintern (new_name
, Qnil
);
6449 static char *modifier_names
[] =
6451 "up", "down", "drag", "click", "double", "triple", 0, 0,
6452 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6453 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6455 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6457 static Lisp_Object modifier_symbols
;
6459 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6461 lispy_modifier_list (modifiers
)
6464 Lisp_Object modifier_list
;
6467 modifier_list
= Qnil
;
6468 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6469 if (modifiers
& (1<<i
))
6470 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
6473 return modifier_list
;
6477 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6478 where UNMODIFIED is the unmodified form of SYMBOL,
6479 MASK is the set of modifiers present in SYMBOL's name.
6480 This is similar to parse_modifiers_uncached, but uses the cache in
6481 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6482 Qevent_symbol_elements property. */
6484 #define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
6487 parse_modifiers (symbol
)
6490 Lisp_Object elements
;
6492 if (INTEGERP (symbol
))
6493 return (Fcons (make_number (KEY_TO_CHAR (symbol
)),
6494 Fcons (make_number (XINT (symbol
) & CHAR_MODIFIER_MASK
),
6496 else if (!SYMBOLP (symbol
))
6499 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6500 if (CONSP (elements
))
6505 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6506 Lisp_Object unmodified
;
6509 unmodified
= Fintern (make_string (SDATA (SYMBOL_NAME (symbol
)) + end
,
6510 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6513 if (modifiers
& ~INTMASK
)
6515 XSETFASTINT (mask
, modifiers
);
6516 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6518 /* Cache the parsing results on SYMBOL. */
6519 Fput (symbol
, Qevent_symbol_element_mask
,
6521 Fput (symbol
, Qevent_symbol_elements
,
6522 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6524 /* Since we know that SYMBOL is modifiers applied to unmodified,
6525 it would be nice to put that in unmodified's cache.
6526 But we can't, since we're not sure that parse_modifiers is
6533 DEFUN ("internal-event-symbol-parse-modifiers", Fevent_symbol_parse_modifiers
,
6534 Sevent_symbol_parse_modifiers
, 1, 1, 0,
6535 doc
: /* Parse the event symbol. For internal use. */)
6539 /* Fill the cache if needed. */
6540 parse_modifiers (symbol
);
6541 /* Ignore the result (which is stored on Qevent_symbol_element_mask)
6542 and use the Lispier representation stored on Qevent_symbol_elements
6544 return Fget (symbol
, Qevent_symbol_elements
);
6547 /* Apply the modifiers MODIFIERS to the symbol BASE.
6548 BASE must be unmodified.
6550 This is like apply_modifiers_uncached, but uses BASE's
6551 Qmodifier_cache property, if present. It also builds
6552 Qevent_symbol_elements properties, since it has that info anyway.
6554 apply_modifiers copies the value of BASE's Qevent_kind property to
6555 the modified symbol. */
6557 apply_modifiers (modifiers
, base
)
6561 Lisp_Object cache
, index
, entry
, new_symbol
;
6563 /* Mask out upper bits. We don't know where this value's been. */
6564 modifiers
&= INTMASK
;
6566 if (INTEGERP (base
))
6567 return make_number (XINT (base
) | modifiers
);
6569 /* The click modifier never figures into cache indices. */
6570 cache
= Fget (base
, Qmodifier_cache
);
6571 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
6572 entry
= assq_no_quit (index
, cache
);
6575 new_symbol
= XCDR (entry
);
6578 /* We have to create the symbol ourselves. */
6579 new_symbol
= apply_modifiers_uncached (modifiers
,
6580 SDATA (SYMBOL_NAME (base
)),
6581 SCHARS (SYMBOL_NAME (base
)),
6582 SBYTES (SYMBOL_NAME (base
)));
6584 /* Add the new symbol to the base's cache. */
6585 entry
= Fcons (index
, new_symbol
);
6586 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6588 /* We have the parsing info now for free, so we could add it to
6590 XSETFASTINT (index, modifiers);
6591 Fput (new_symbol, Qevent_symbol_element_mask,
6592 Fcons (base, Fcons (index, Qnil)));
6593 Fput (new_symbol, Qevent_symbol_elements,
6594 Fcons (base, lispy_modifier_list (modifiers)));
6595 Sadly, this is only correct if `base' is indeed a base event,
6596 which is not necessarily the case. -stef */
6599 /* Make sure this symbol is of the same kind as BASE.
6601 You'd think we could just set this once and for all when we
6602 intern the symbol above, but reorder_modifiers may call us when
6603 BASE's property isn't set right; we can't assume that just
6604 because it has a Qmodifier_cache property it must have its
6605 Qevent_kind set right as well. */
6606 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6610 kind
= Fget (base
, Qevent_kind
);
6612 Fput (new_symbol
, Qevent_kind
, kind
);
6619 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6620 return a symbol with the modifiers placed in the canonical order.
6621 Canonical order is alphabetical, except for down and drag, which
6622 always come last. The 'click' modifier is never written out.
6624 Fdefine_key calls this to make sure that (for example) C-M-foo
6625 and M-C-foo end up being equivalent in the keymap. */
6628 reorder_modifiers (symbol
)
6631 /* It's hopefully okay to write the code this way, since everything
6632 will soon be in caches, and no consing will be done at all. */
6635 parsed
= parse_modifiers (symbol
);
6636 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6641 /* For handling events, we often want to produce a symbol whose name
6642 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6643 to some base, like the name of a function key or mouse button.
6644 modify_event_symbol produces symbols of this sort.
6646 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6647 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6650 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6651 into symbol names, or a string specifying a name stem used to
6652 construct a symbol name or the form `STEM-N', where N is the decimal
6653 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6654 non-nil; otherwise NAME_TABLE is used.
6656 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6657 persist between calls to modify_event_symbol that it can use to
6658 store a cache of the symbols it's generated for this NAME_TABLE
6659 before. The object stored there may be a vector or an alist.
6661 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6663 MODIFIERS is a set of modifier bits (as given in struct input_events)
6664 whose prefixes should be applied to the symbol name.
6666 SYMBOL_KIND is the value to be placed in the event_kind property of
6667 the returned symbol.
6669 The symbols we create are supposed to have an
6670 `event-symbol-elements' property, which lists the modifiers present
6671 in the symbol's name. */
6674 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist_or_stem
,
6675 name_table
, symbol_table
, table_size
)
6678 Lisp_Object symbol_kind
;
6679 Lisp_Object name_alist_or_stem
;
6681 Lisp_Object
*symbol_table
;
6682 unsigned int table_size
;
6685 Lisp_Object symbol_int
;
6687 /* Get rid of the "vendor-specific" bit here. */
6688 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6690 /* Is this a request for a valid symbol? */
6691 if (symbol_num
< 0 || symbol_num
>= table_size
)
6694 if (CONSP (*symbol_table
))
6695 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6697 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6698 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6699 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6700 we've never used that symbol before. */
6703 if (! VECTORP (*symbol_table
)
6704 || XVECTOR (*symbol_table
)->size
!= table_size
)
6708 XSETFASTINT (size
, table_size
);
6709 *symbol_table
= Fmake_vector (size
, Qnil
);
6712 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6715 /* Have we already used this symbol before? */
6718 /* No; let's create it. */
6719 if (CONSP (name_alist_or_stem
))
6720 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6721 else if (STRINGP (name_alist_or_stem
))
6723 int len
= SBYTES (name_alist_or_stem
);
6724 char *buf
= (char *) alloca (len
+ 50);
6725 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6726 (long) XINT (symbol_int
) + 1);
6727 value
= intern (buf
);
6729 else if (name_table
!= 0 && name_table
[symbol_num
])
6730 value
= intern (name_table
[symbol_num
]);
6732 #ifdef HAVE_WINDOW_SYSTEM
6735 char *name
= x_get_keysym_name (symbol_num
);
6737 value
= intern (name
);
6744 sprintf (buf
, "key-%d", symbol_num
);
6745 value
= intern (buf
);
6748 if (CONSP (*symbol_table
))
6749 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6751 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6753 /* Fill in the cache entries for this symbol; this also
6754 builds the Qevent_symbol_elements property, which the user
6756 apply_modifiers (modifiers
& click_modifier
, value
);
6757 Fput (value
, Qevent_kind
, symbol_kind
);
6760 /* Apply modifiers to that symbol. */
6761 return apply_modifiers (modifiers
, value
);
6764 /* Convert a list that represents an event type,
6765 such as (ctrl meta backspace), into the usual representation of that
6766 event type as a number or a symbol. */
6768 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6769 doc
: /* Convert the event description list EVENT-DESC to an event type.
6770 EVENT-DESC should contain one base event type (a character or symbol)
6771 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6772 drag, down, double or triple). The base must be last.
6773 The return value is an event type (a character or symbol) which
6774 has the same base event type and all the specified modifiers. */)
6776 Lisp_Object event_desc
;
6784 while (CONSP (rest
))
6792 /* Given a symbol, see if it is a modifier name. */
6793 if (SYMBOLP (elt
) && CONSP (rest
))
6794 this = parse_solitary_modifier (elt
);
6798 else if (!NILP (base
))
6799 error ("Two bases given in one event");
6805 /* Let the symbol A refer to the character A. */
6806 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6807 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6809 if (INTEGERP (base
))
6811 /* Turn (shift a) into A. */
6812 if ((modifiers
& shift_modifier
) != 0
6813 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6815 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6816 modifiers
&= ~shift_modifier
;
6819 /* Turn (control a) into C-a. */
6820 if (modifiers
& ctrl_modifier
)
6821 return make_number ((modifiers
& ~ctrl_modifier
)
6822 | make_ctrl_char (XINT (base
)));
6824 return make_number (modifiers
| XINT (base
));
6826 else if (SYMBOLP (base
))
6827 return apply_modifiers (modifiers
, base
);
6830 error ("Invalid base event");
6835 /* Try to recognize SYMBOL as a modifier name.
6836 Return the modifier flag bit, or 0 if not recognized. */
6839 parse_solitary_modifier (symbol
)
6842 Lisp_Object name
= SYMBOL_NAME (symbol
);
6844 switch (SREF (name
, 0))
6846 #define SINGLE_LETTER_MOD(BIT) \
6847 if (SBYTES (name) == 1) \
6850 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6851 if (LEN == SBYTES (name) \
6852 && ! strncmp (SDATA (name), NAME, LEN)) \
6856 SINGLE_LETTER_MOD (alt_modifier
);
6860 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6864 SINGLE_LETTER_MOD (ctrl_modifier
);
6868 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6869 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6873 SINGLE_LETTER_MOD (hyper_modifier
);
6877 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6881 SINGLE_LETTER_MOD (meta_modifier
);
6885 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6889 SINGLE_LETTER_MOD (shift_modifier
);
6893 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6894 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6895 SINGLE_LETTER_MOD (super_modifier
);
6899 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6900 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6901 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6905 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6908 #undef SINGLE_LETTER_MOD
6909 #undef MULTI_LETTER_MOD
6915 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6916 Such a list is not valid as an event,
6917 but it can be a Lucid-style event type list. */
6920 lucid_event_type_list_p (object
)
6925 if (! CONSP (object
))
6928 if (EQ (XCAR (object
), Qhelp_echo
)
6929 || EQ (XCAR (object
), Qvertical_line
)
6930 || EQ (XCAR (object
), Qmode_line
)
6931 || EQ (XCAR (object
), Qheader_line
))
6934 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6938 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6945 /* Store into *addr a value nonzero if terminal input chars are available.
6946 Serves the purpose of ioctl (0, FIONREAD, addr)
6947 but works even if FIONREAD does not exist.
6948 (In fact, this may actually read some input.)
6950 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
6951 timer events that are ripe.
6952 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
6953 events (FOCUS_IN_EVENT).
6954 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
6955 movements and toolkit scroll bar thumb drags. */
6958 get_input_pending (addr
, flags
)
6962 /* First of all, have we already counted some input? */
6963 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6965 /* If input is being read as it arrives, and we have none, there is none. */
6966 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6969 /* Try to read some input and see how much we get. */
6971 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6974 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6977 gobble_input (expected
)
6981 /* Check whether a D-Bus message has arrived. */
6982 xd_read_queued_messages ();
6983 #endif /* HAVE_DBUS */
6987 if (interrupt_input
)
6990 mask
= sigblock (sigmask (SIGIO
));
6991 read_avail_input (expected
);
6995 #ifdef POLL_FOR_INPUT
6996 /* XXX This condition was (read_socket_hook && !interrupt_input),
6997 but read_socket_hook is not global anymore. Let's pretend that
6999 if (!interrupt_input
&& poll_suppress_count
== 0)
7002 mask
= sigblock (sigmask (SIGALRM
));
7003 read_avail_input (expected
);
7009 read_avail_input (expected
);
7013 /* Put a BUFFER_SWITCH_EVENT in the buffer
7014 so that read_key_sequence will notice the new current buffer. */
7017 record_asynch_buffer_change ()
7019 struct input_event event
;
7023 event
.kind
= BUFFER_SWITCH_EVENT
;
7024 event
.frame_or_window
= Qnil
;
7028 /* We don't need a buffer-switch event unless Emacs is waiting for input.
7029 The purpose of the event is to make read_key_sequence look up the
7030 keymaps again. If we aren't in read_key_sequence, we don't need one,
7031 and the event could cause trouble by messing up (input-pending-p). */
7032 tem
= Fwaiting_for_user_input_p ();
7036 /* We never need these events if we have no asynchronous subprocesses. */
7040 /* Make sure no interrupt happens while storing the event. */
7042 if (interrupt_input
)
7045 mask
= sigblock (sigmask (SIGIO
));
7046 kbd_buffer_store_event (&event
);
7053 kbd_buffer_store_event (&event
);
7060 /* Read any terminal input already buffered up by the system
7061 into the kbd_buffer, but do not wait.
7063 EXPECTED should be nonzero if the caller knows there is some input.
7065 Except on VMS, all input is read by this function.
7066 If interrupt_input is nonzero, this function MUST be called
7067 only when SIGIO is blocked.
7069 Returns the number of keyboard chars read, or -1 meaning
7070 this is a bad time to try to read input. */
7073 read_avail_input (expected
)
7080 /* Store pending user signal events, if any. */
7081 if (store_user_signal_events ())
7084 /* Loop through the available terminals, and call their input hooks. */
7088 struct terminal
*next
= t
->next_terminal
;
7090 if (t
->read_socket_hook
)
7093 struct input_event hold_quit
;
7095 EVENT_INIT (hold_quit
);
7096 hold_quit
.kind
= NO_EVENT
;
7098 /* No need for FIONREAD or fcntl; just say don't wait. */
7099 while (nr
= (*t
->read_socket_hook
) (t
, expected
, &hold_quit
), nr
> 0)
7105 if (nr
== -1) /* Not OK to read input now. */
7109 else if (nr
== -2) /* Non-transient error. */
7111 /* The terminal device terminated; it should be closed. */
7113 /* Kill Emacs if this was our last terminal. */
7114 if (!terminal_list
->next_terminal
)
7115 /* Formerly simply reported no input, but that
7116 sometimes led to a failure of Emacs to terminate.
7117 SIGHUP seems appropriate if we can't reach the
7119 /* ??? Is it really right to send the signal just to
7120 this process rather than to the whole process
7121 group? Perhaps on systems with FIONREAD Emacs is
7122 alone in its group. */
7123 kill (getpid (), SIGHUP
);
7125 /* XXX Is calling delete_terminal safe here? It calls Fdelete_frame. */
7126 if (t
->delete_terminal_hook
)
7127 (*t
->delete_terminal_hook
) (t
);
7129 delete_terminal (t
);
7132 if (hold_quit
.kind
!= NO_EVENT
)
7133 kbd_buffer_store_event (&hold_quit
);
7145 /* This is the tty way of reading available input.
7147 Note that each terminal device has its own `struct terminal' object,
7148 and so this function is called once for each individual termcap
7149 terminal. The first parameter indicates which terminal to read from. */
7152 tty_read_avail_input (struct terminal
*terminal
,
7154 struct input_event
*hold_quit
)
7156 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
7157 the kbd_buffer can really hold. That may prevent loss
7158 of characters on some systems when input is stuffed at us. */
7159 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
7161 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
7164 if (!terminal
->name
) /* Don't read from a dead terminal. */
7167 if (terminal
->type
!= output_termcap
)
7170 /* XXX I think the following code should be moved to separate hook
7171 functions in system-dependent files. */
7174 #else /* not WINDOWSNT */
7176 n_to_read
= dos_keysns ();
7180 cbuf
[0] = dos_keyread ();
7183 #else /* not MSDOS */
7185 if (! tty
->term_initted
) /* In case we get called during bootstrap. */
7189 return 0; /* The terminal is suspended. */
7195 struct input_event hold_quit
;
7198 EVENT_INIT (hold_quit
);
7199 hold_quit
.kind
= NO_EVENT
;
7201 while (gpm
= Gpm_GetEvent (&event
), gpm
== 1) {
7202 nread
+= handle_one_term_event (tty
, &event
, &hold_quit
);
7204 if (hold_quit
.kind
!= NO_EVENT
)
7205 kbd_buffer_store_event (&hold_quit
);
7209 #endif /* HAVE_GPM */
7211 /* Determine how many characters we should *try* to read. */
7213 /* Find out how much input is available. */
7214 if (ioctl (fileno (tty
->input
), FIONREAD
, &n_to_read
) < 0)
7216 if (! noninteractive
)
7217 return -2; /* Close this terminal. */
7223 if (n_to_read
> sizeof cbuf
)
7224 n_to_read
= sizeof cbuf
;
7225 #else /* no FIONREAD */
7226 #if defined (USG) || defined(CYGWIN)
7227 /* Read some input if available, but don't wait. */
7228 n_to_read
= sizeof cbuf
;
7229 fcntl (fileno (tty
->input
), F_SETFL
, O_NDELAY
);
7235 /* Now read; for one reason or another, this will not block.
7236 NREAD is set to the number of chars read. */
7239 nread
= emacs_read (fileno (tty
->input
), cbuf
, n_to_read
);
7240 /* POSIX infers that processes which are not in the session leader's
7241 process group won't get SIGHUP's at logout time. BSDI adheres to
7242 this part standard and returns -1 from read (0) with errno==EIO
7243 when the control tty is taken away.
7244 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
7245 if (nread
== -1 && errno
== EIO
)
7246 return -2; /* Close this terminal. */
7247 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
7248 /* The kernel sometimes fails to deliver SIGHUP for ptys.
7249 This looks incorrect, but it isn't, because _BSD causes
7250 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
7251 and that causes a value other than 0 when there is no input. */
7253 return -2; /* Close this terminal. */
7257 /* We used to retry the read if it was interrupted.
7258 But this does the wrong thing when O_NDELAY causes
7259 an EAGAIN error. Does anybody know of a situation
7260 where a retry is actually needed? */
7262 nread
< 0 && (errno
== EAGAIN
7276 #if defined (USG) || defined (CYGWIN)
7277 fcntl (fileno (tty
->input
), F_SETFL
, 0);
7278 #endif /* USG or CYGWIN */
7279 #endif /* no FIONREAD */
7284 #endif /* not MSDOS */
7285 #endif /* not WINDOWSNT */
7287 for (i
= 0; i
< nread
; i
++)
7289 struct input_event buf
;
7291 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7293 if (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80))
7294 buf
.modifiers
= meta_modifier
;
7295 if (tty
->meta_key
!= 2)
7299 /* Set the frame corresponding to the active tty. Note that the
7300 value of selected_frame is not reliable here, redisplay tends
7301 to temporarily change it. */
7302 buf
.frame_or_window
= tty
->top_frame
;
7305 kbd_buffer_store_event (&buf
);
7306 /* Don't look at input that follows a C-g too closely.
7307 This reduces lossage due to autorepeat on C-g. */
7308 if (buf
.kind
== ASCII_KEYSTROKE_EVENT
7309 && buf
.code
== quit_char
)
7315 #endif /* not VMS */
7318 handle_async_input ()
7321 extern int select_alarmed
;
7324 interrupt_input_pending
= 0;
7329 nread
= read_avail_input (1);
7330 /* -1 means it's not ok to read the input now.
7331 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7332 0 means there was no keyboard input available. */
7337 select_alarmed
= 1; /* Force the select emulator back to life */
7342 #ifdef SIGIO /* for entire page */
7343 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7346 input_available_signal (signo
)
7349 /* Must preserve main program's value of errno. */
7350 int old_errno
= errno
;
7351 #if defined (USG) && !defined (POSIX_SIGNALS)
7352 /* USG systems forget handlers when they are used;
7353 must reestablish each time */
7354 signal (signo
, input_available_signal
);
7362 interrupt_input_pending
= 1;
7364 SIGNAL_THREAD_CHECK (signo
);
7367 if (input_available_clear_time
)
7368 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7371 handle_async_input ();
7381 /* Send ourselves a SIGIO.
7383 This function exists so that the UNBLOCK_INPUT macro in
7384 blockinput.h can have some way to take care of input we put off
7385 dealing with, without assuming that every file which uses
7386 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
7388 reinvoke_input_signal ()
7391 handle_async_input ();
7397 /* User signal events. */
7399 struct user_signal_info
7401 /* Signal number. */
7404 /* Name of the signal. */
7407 /* Number of pending signals. */
7410 struct user_signal_info
*next
;
7413 /* List of user signals. */
7414 static struct user_signal_info
*user_signals
= NULL
;
7417 add_user_signal (sig
, name
)
7421 struct user_signal_info
*p
;
7423 for (p
= user_signals
; p
; p
= p
->next
)
7425 /* Already added. */
7428 p
= xmalloc (sizeof (struct user_signal_info
));
7430 p
->name
= xstrdup (name
);
7432 p
->next
= user_signals
;
7435 signal (sig
, handle_user_signal
);
7439 handle_user_signal (sig
)
7442 int old_errno
= errno
;
7443 struct user_signal_info
*p
;
7445 #if defined (USG) && !defined (POSIX_SIGNALS)
7446 /* USG systems forget handlers when they are used;
7447 must reestablish each time */
7448 signal (sig
, handle_user_signal
);
7451 SIGNAL_THREAD_CHECK (sig
);
7453 for (p
= user_signals
; p
; p
= p
->next
)
7458 if (interrupt_input
)
7459 kill (getpid (), SIGIO
);
7463 /* Tell wait_reading_process_output that it needs to wake
7464 up and look around. */
7465 if (input_available_clear_time
)
7466 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7475 find_user_signal_name (sig
)
7478 struct user_signal_info
*p
;
7480 for (p
= user_signals
; p
; p
= p
->next
)
7488 store_user_signal_events ()
7490 struct user_signal_info
*p
;
7491 struct input_event buf
;
7494 for (p
= user_signals
; p
; p
= p
->next
)
7495 if (p
->npending
> 0)
7501 bzero (&buf
, sizeof buf
);
7502 buf
.kind
= USER_SIGNAL_EVENT
;
7503 buf
.frame_or_window
= selected_frame
;
7505 nstored
+= p
->npending
;
7507 mask
= sigblock (sigmask (p
->sig
));
7511 kbd_buffer_store_event (&buf
);
7514 while (p
->npending
> 0);
7522 static void menu_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
7523 static Lisp_Object menu_bar_one_keymap_changed_items
;
7525 /* These variables hold the vector under construction within
7526 menu_bar_items and its subroutines, and the current index
7527 for storing into that vector. */
7528 static Lisp_Object menu_bar_items_vector
;
7529 static int menu_bar_items_index
;
7531 /* Return a vector of menu items for a menu bar, appropriate
7532 to the current buffer. Each item has three elements in the vector:
7535 OLD is an old vector we can optionally reuse, or nil. */
7538 menu_bar_items (old
)
7541 /* The number of keymaps we're scanning right now, and the number of
7542 keymaps we have allocated space for. */
7545 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7546 in the current keymaps, or nil where it is not a prefix. */
7549 Lisp_Object def
, tail
;
7558 /* In order to build the menus, we need to call the keymap
7559 accessors. They all call QUIT. But this function is called
7560 during redisplay, during which a quit is fatal. So inhibit
7561 quitting while building the menus.
7562 We do this instead of specbind because (1) errors will clear it anyway
7563 and (2) this avoids risk of specpdl overflow. */
7564 oquit
= Vinhibit_quit
;
7568 menu_bar_items_vector
= old
;
7570 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
7571 menu_bar_items_index
= 0;
7573 /* Build our list of keymaps.
7574 If we recognize a function key and replace its escape sequence in
7575 keybuf with its symbol, or if the sequence starts with a mouse
7576 click and we need to switch buffers, we jump back here to rebuild
7577 the initial keymaps from the current buffer. */
7581 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7582 if (!NILP (Voverriding_local_map_menu_flag
))
7584 /* Yes, use them (if non-nil) as well as the global map. */
7585 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7587 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7588 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7589 if (!NILP (Voverriding_local_map
))
7590 maps
[nmaps
++] = Voverriding_local_map
;
7594 /* No, so use major and minor mode keymaps and keymap property.
7595 Note that menu-bar bindings in the local-map and keymap
7596 properties may not work reliable, as they are only
7597 recognized when the menu-bar (or mode-line) is updated,
7598 which does not normally happen after every command. */
7601 nminor
= current_minor_maps (NULL
, &tmaps
);
7602 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7604 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7605 maps
[nmaps
++] = tem
;
7606 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
7608 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7610 maps
[nmaps
++] = current_global_map
;
7613 /* Look up in each map the dummy prefix key `menu-bar'. */
7617 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
7618 if (!NILP (maps
[mapno
]))
7620 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
7624 menu_bar_one_keymap_changed_items
= Qnil
;
7625 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
7629 /* Move to the end those items that should be at the end. */
7631 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
7634 int end
= menu_bar_items_index
;
7636 for (i
= 0; i
< end
; i
+= 4)
7637 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7639 Lisp_Object tem0
, tem1
, tem2
, tem3
;
7640 /* Move the item at index I to the end,
7641 shifting all the others forward. */
7642 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
7643 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
7644 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7645 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
7647 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7648 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7649 (end
- i
- 4) * sizeof (Lisp_Object
));
7650 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
7651 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
7652 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
7653 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
7658 /* Add nil, nil, nil, nil at the end. */
7659 i
= menu_bar_items_index
;
7660 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7661 menu_bar_items_vector
= larger_vector (menu_bar_items_vector
, 2 * i
, Qnil
);
7662 /* Add this item. */
7663 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7664 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7665 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7666 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7667 menu_bar_items_index
= i
;
7669 Vinhibit_quit
= oquit
;
7670 return menu_bar_items_vector
;
7673 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7674 If there's already an item for KEY, add this DEF to it. */
7676 Lisp_Object item_properties
;
7679 menu_bar_item (key
, item
, dummy1
, dummy2
)
7680 Lisp_Object key
, item
, dummy1
;
7683 struct gcpro gcpro1
;
7687 if (EQ (item
, Qundefined
))
7689 /* If a map has an explicit `undefined' as definition,
7690 discard any previously made menu bar item. */
7692 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7693 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7695 if (menu_bar_items_index
> i
+ 4)
7696 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7697 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7698 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7699 menu_bar_items_index
-= 4;
7703 /* If this keymap has already contributed to this KEY,
7704 don't contribute to it a second time. */
7705 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7706 if (!NILP (tem
) || NILP (item
))
7709 menu_bar_one_keymap_changed_items
7710 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7712 /* We add to menu_bar_one_keymap_changed_items before doing the
7713 parse_menu_item, so that if it turns out it wasn't a menu item,
7714 it still correctly hides any further menu item. */
7716 i
= parse_menu_item (item
, 0, 1);
7721 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7723 /* Find any existing item for this KEY. */
7724 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7725 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7728 /* If we did not find this KEY, add it at the end. */
7729 if (i
== menu_bar_items_index
)
7731 /* If vector is too small, get a bigger one. */
7732 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7733 menu_bar_items_vector
= larger_vector (menu_bar_items_vector
, 2 * i
, Qnil
);
7734 /* Add this item. */
7735 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7736 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7737 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7738 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7739 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7740 menu_bar_items_index
= i
;
7742 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7746 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7747 /* If the new and the old items are not both keymaps,
7748 the lookup will only find `item'. */
7749 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7750 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7754 /* This is used as the handler when calling menu_item_eval_property. */
7756 menu_item_eval_property_1 (arg
)
7759 /* If we got a quit from within the menu computation,
7760 quit all the way out of it. This takes care of C-] in the debugger. */
7761 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7762 Fsignal (Qquit
, Qnil
);
7767 /* Evaluate an expression and return the result (or nil if something
7768 went wrong). Used to evaluate dynamic parts of menu items. */
7770 menu_item_eval_property (sexpr
)
7773 int count
= SPECPDL_INDEX ();
7775 specbind (Qinhibit_redisplay
, Qt
);
7776 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7777 menu_item_eval_property_1
);
7778 return unbind_to (count
, val
);
7781 /* This function parses a menu item and leaves the result in the
7782 vector item_properties.
7783 ITEM is a key binding, a possible menu item.
7784 If NOTREAL is nonzero, only check for equivalent key bindings, don't
7785 evaluate dynamic expressions in the menu item.
7786 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7788 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7789 parse_menu_item returns true if the item is a menu item and false
7793 parse_menu_item (item
, notreal
, inmenubar
)
7795 int notreal
, inmenubar
;
7797 Lisp_Object def
, tem
, item_string
, start
;
7798 Lisp_Object cachelist
;
7800 Lisp_Object keyhint
;
7811 /* Create item_properties vector if necessary. */
7812 if (NILP (item_properties
))
7814 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7816 /* Initialize optional entries. */
7817 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7818 AREF (item_properties
, i
) = Qnil
;
7819 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7821 /* Save the item here to protect it from GC. */
7822 AREF (item_properties
, ITEM_PROPERTY_ITEM
) = item
;
7824 item_string
= XCAR (item
);
7828 if (STRINGP (item_string
))
7830 /* Old format menu item. */
7831 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7833 /* Maybe help string. */
7834 if (CONSP (item
) && STRINGP (XCAR (item
)))
7836 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7841 /* Maybe key binding cache. */
7842 if (CONSP (item
) && CONSP (XCAR (item
))
7843 && (NILP (XCAR (XCAR (item
)))
7844 || VECTORP (XCAR (XCAR (item
)))))
7846 cachelist
= XCAR (item
);
7850 /* This is the real definition--the function to run. */
7851 AREF (item_properties
, ITEM_PROPERTY_DEF
) = item
;
7853 /* Get enable property, if any. */
7856 tem
= Fget (item
, Qmenu_enable
);
7857 if (!NILP (Venable_disabled_menus_and_buttons
))
7858 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7859 else if (!NILP (tem
))
7860 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7863 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7865 /* New format menu item. */
7866 AREF (item_properties
, ITEM_PROPERTY_NAME
) = XCAR (item
);
7867 start
= XCDR (item
);
7870 /* We have a real binding. */
7871 AREF (item_properties
, ITEM_PROPERTY_DEF
) = XCAR (start
);
7873 item
= XCDR (start
);
7874 /* Is there a cache list with key equivalences. */
7875 if (CONSP (item
) && CONSP (XCAR (item
)))
7877 cachelist
= XCAR (item
);
7881 /* Parse properties. */
7882 while (CONSP (item
) && CONSP (XCDR (item
)))
7887 if (EQ (tem
, QCenable
))
7889 if (!NILP (Venable_disabled_menus_and_buttons
))
7890 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7892 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = XCAR (item
);
7894 else if (EQ (tem
, QCvisible
) && !notreal
)
7896 /* If got a visible property and that evaluates to nil
7897 then ignore this item. */
7898 tem
= menu_item_eval_property (XCAR (item
));
7902 else if (EQ (tem
, QChelp
))
7903 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7904 else if (EQ (tem
, QCfilter
))
7906 else if (EQ (tem
, QCkey_sequence
))
7909 if (NILP (cachelist
)
7910 && (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
)))
7911 /* Be GC protected. Set keyhint to item instead of tem. */
7914 else if (EQ (tem
, QCkeys
))
7917 if (CONSP (tem
) || (STRINGP (tem
) && NILP (cachelist
)))
7918 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7920 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7925 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7927 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7929 AREF (item_properties
, ITEM_PROPERTY_TYPE
)
7936 else if (inmenubar
|| !NILP (start
))
7940 return 0; /* not a menu item */
7942 /* If item string is not a string, evaluate it to get string.
7943 If we don't get a string, skip this item. */
7944 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7945 if (!(STRINGP (item_string
) || notreal
))
7947 item_string
= menu_item_eval_property (item_string
);
7948 if (!STRINGP (item_string
))
7950 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7953 /* If got a filter apply it on definition. */
7954 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7957 def
= menu_item_eval_property (list2 (XCAR (filter
),
7958 list2 (Qquote
, def
)));
7960 AREF (item_properties
, ITEM_PROPERTY_DEF
) = def
;
7963 /* Enable or disable selection of item. */
7964 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7970 tem
= menu_item_eval_property (tem
);
7971 if (inmenubar
&& NILP (tem
))
7972 return 0; /* Ignore disabled items in menu bar. */
7973 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7976 /* If we got no definition, this item is just unselectable text which
7977 is OK in a submenu but not in the menubar. */
7979 return (inmenubar
? 0 : 1);
7981 /* See if this is a separate pane or a submenu. */
7982 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7983 tem
= get_keymap (def
, 0, 1);
7984 /* For a subkeymap, just record its details and exit. */
7987 AREF (item_properties
, ITEM_PROPERTY_MAP
) = tem
;
7988 AREF (item_properties
, ITEM_PROPERTY_DEF
) = tem
;
7992 /* At the top level in the menu bar, do likewise for commands also.
7993 The menu bar does not display equivalent key bindings anyway.
7994 ITEM_PROPERTY_DEF is already set up properly. */
7998 /* This is a command. See if there is an equivalent key binding. */
7999 if (NILP (cachelist
))
8001 /* We have to create a cachelist. */
8002 CHECK_IMPURE (start
);
8003 XSETCDR (start
, Fcons (Fcons (Qnil
, Qnil
), XCDR (start
)));
8004 cachelist
= XCAR (XCDR (start
));
8006 tem
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
8007 if (!NILP (keyhint
))
8009 XSETCAR (cachelist
, XCAR (keyhint
));
8012 else if (STRINGP (tem
))
8014 XSETCDR (cachelist
, Fsubstitute_command_keys (tem
));
8015 XSETCAR (cachelist
, Qt
);
8019 tem
= XCAR (cachelist
);
8026 tem
= Fkey_binding (tem
, Qnil
, Qnil
, Qnil
);
8028 prefix
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
8031 def
= XCAR (prefix
);
8032 prefix
= XCDR (prefix
);
8035 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
8037 if (NILP (XCAR (cachelist
))) /* Have no saved key. */
8039 if (newcache
/* Always check first time. */
8040 /* Should we check everything when precomputing key
8042 /* If something had no key binding before, don't recheck it
8043 because that is too slow--except if we have a list of
8044 rebound commands in Vdefine_key_rebound_commands, do
8045 recheck any command that appears in that list. */
8046 || (CONSP (Vdefine_key_rebound_commands
)
8047 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
))))
8050 /* We had a saved key. Is it still bound to the command? */
8053 /* If the command is an alias for another
8054 (such as lmenu.el set it up), check if the
8055 original command matches the cached command. */
8056 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
8057 chkcache
= 1; /* Need to recompute key binding. */
8061 /* Recompute equivalent key binding. If the command is an alias
8062 for another (such as lmenu.el set it up), see if the original
8063 command name has equivalent keys. Otherwise look up the
8064 specified command itself. We don't try both, because that
8065 makes lmenu menus slow. */
8067 && SYMBOLP (XSYMBOL (def
)->function
)
8068 && ! NILP (Fget (def
, Qmenu_alias
)))
8069 def
= XSYMBOL (def
)->function
;
8070 tem
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qt
);
8071 XSETCAR (cachelist
, tem
);
8074 XSETCDR (cachelist
, Qnil
);
8078 else if (!NILP (keyhint
) && !NILP (XCAR (cachelist
)))
8080 tem
= XCAR (cachelist
);
8084 newcache
= chkcache
;
8087 tem
= Fkey_description (tem
, Qnil
);
8090 if (STRINGP (XCAR (prefix
)))
8091 tem
= concat2 (XCAR (prefix
), tem
);
8092 if (STRINGP (XCDR (prefix
)))
8093 tem
= concat2 (tem
, XCDR (prefix
));
8095 XSETCDR (cachelist
, tem
);
8099 tem
= XCDR (cachelist
);
8100 if (newcache
&& !NILP (tem
))
8102 tem
= concat2 (build_string (" "), tem
);
8103 // tem = concat3 (build_string (" ("), tem, build_string (")"));
8104 XSETCDR (cachelist
, tem
);
8107 /* If we only want to precompute equivalent key bindings, stop here. */
8111 /* If we have an equivalent key binding, use that. */
8112 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
8114 /* Include this when menu help is implemented.
8115 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
8116 if (!(NILP (tem) || STRINGP (tem)))
8118 tem = menu_item_eval_property (tem);
8121 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
8125 /* Handle radio buttons or toggle boxes. */
8126 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
8128 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
8129 = menu_item_eval_property (tem
);
8136 /***********************************************************************
8138 ***********************************************************************/
8140 /* A vector holding tool bar items while they are parsed in function
8141 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
8144 static Lisp_Object tool_bar_items_vector
;
8146 /* A vector holding the result of parse_tool_bar_item. Layout is like
8147 the one for a single item in tool_bar_items_vector. */
8149 static Lisp_Object tool_bar_item_properties
;
8151 /* Next free index in tool_bar_items_vector. */
8153 static int ntool_bar_items
;
8155 /* The symbols `tool-bar', `:image' and `:rtl'. */
8157 extern Lisp_Object Qtool_bar
;
8158 Lisp_Object QCimage
;
8161 /* Function prototypes. */
8163 static void init_tool_bar_items
P_ ((Lisp_Object
));
8164 static void process_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
8165 static int parse_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
8166 static void append_tool_bar_item
P_ ((void));
8169 /* Return a vector of tool bar items for keymaps currently in effect.
8170 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
8171 tool bar items found. */
8174 tool_bar_items (reuse
, nitems
)
8185 /* In order to build the menus, we need to call the keymap
8186 accessors. They all call QUIT. But this function is called
8187 during redisplay, during which a quit is fatal. So inhibit
8188 quitting while building the menus. We do this instead of
8189 specbind because (1) errors will clear it anyway and (2) this
8190 avoids risk of specpdl overflow. */
8191 oquit
= Vinhibit_quit
;
8194 /* Initialize tool_bar_items_vector and protect it from GC. */
8195 init_tool_bar_items (reuse
);
8197 /* Build list of keymaps in maps. Set nmaps to the number of maps
8200 /* Should overriding-terminal-local-map and overriding-local-map apply? */
8201 if (!NILP (Voverriding_local_map_menu_flag
))
8203 /* Yes, use them (if non-nil) as well as the global map. */
8204 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
8206 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
8207 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
8208 if (!NILP (Voverriding_local_map
))
8209 maps
[nmaps
++] = Voverriding_local_map
;
8213 /* No, so use major and minor mode keymaps and keymap property.
8214 Note that tool-bar bindings in the local-map and keymap
8215 properties may not work reliable, as they are only
8216 recognized when the tool-bar (or mode-line) is updated,
8217 which does not normally happen after every command. */
8220 nminor
= current_minor_maps (NULL
, &tmaps
);
8221 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
8223 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
8224 maps
[nmaps
++] = tem
;
8225 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
8227 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
8230 /* Add global keymap at the end. */
8231 maps
[nmaps
++] = current_global_map
;
8233 /* Process maps in reverse order and look up in each map the prefix
8235 for (i
= nmaps
- 1; i
>= 0; --i
)
8236 if (!NILP (maps
[i
]))
8240 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
8242 map_keymap (keymap
, process_tool_bar_item
, Qnil
, NULL
, 1);
8245 Vinhibit_quit
= oquit
;
8246 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
8247 return tool_bar_items_vector
;
8251 /* Process the definition of KEY which is DEF. */
8254 process_tool_bar_item (key
, def
, data
, args
)
8255 Lisp_Object key
, def
, data
;
8259 extern Lisp_Object Qundefined
;
8260 struct gcpro gcpro1
, gcpro2
;
8262 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
8266 if (EQ (def
, Qundefined
))
8268 /* If a map has an explicit `undefined' as definition,
8269 discard any previously made item. */
8270 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
8272 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
8274 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
8276 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
8277 bcopy (v
+ TOOL_BAR_ITEM_NSLOTS
, v
,
8278 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
8279 * sizeof (Lisp_Object
)));
8280 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
8285 else if (parse_tool_bar_item (key
, def
))
8286 /* Append a new tool bar item to tool_bar_items_vector. Accept
8287 more than one definition for the same key. */
8288 append_tool_bar_item ();
8294 /* Parse a tool bar item specification ITEM for key KEY and return the
8295 result in tool_bar_item_properties. Value is zero if ITEM is
8298 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
8300 CAPTION is the caption of the item, If it's not a string, it is
8301 evaluated to get a string.
8303 BINDING is the tool bar item's binding. Tool-bar items with keymaps
8304 as binding are currently ignored.
8306 The following properties are recognized:
8310 FORM is evaluated and specifies whether the tool bar item is
8311 enabled or disabled.
8315 FORM is evaluated and specifies whether the tool bar item is visible.
8317 - `:filter FUNCTION'
8319 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8320 result is stored as the new binding.
8322 - `:button (TYPE SELECTED)'
8324 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8325 and specifies whether the button is selected (pressed) or not.
8329 IMAGES is either a single image specification or a vector of four
8330 image specifications. See enum tool_bar_item_images.
8332 - `:help HELP-STRING'.
8334 Gives a help string to display for the tool bar item. */
8337 parse_tool_bar_item (key
, item
)
8338 Lisp_Object key
, item
;
8340 /* Access slot with index IDX of vector tool_bar_item_properties. */
8341 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
8343 Lisp_Object filter
= Qnil
;
8344 Lisp_Object caption
;
8347 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
8348 Rule out items that aren't lists, don't start with
8349 `menu-item' or whose rest following `tool-bar-item' is not a
8352 || !EQ (XCAR (item
), Qmenu_item
)
8353 || (item
= XCDR (item
),
8357 /* Create tool_bar_item_properties vector if necessary. Reset it to
8359 if (VECTORP (tool_bar_item_properties
))
8361 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
8365 tool_bar_item_properties
8366 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
8369 PROP (TOOL_BAR_ITEM_KEY
) = key
;
8370 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8372 /* Get the caption of the item. If the caption is not a string,
8373 evaluate it to get a string. If we don't get a string, skip this
8375 caption
= XCAR (item
);
8376 if (!STRINGP (caption
))
8378 caption
= menu_item_eval_property (caption
);
8379 if (!STRINGP (caption
))
8382 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
8384 /* Give up if rest following the caption is not a list. */
8389 /* Store the binding. */
8390 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
8393 /* Ignore cached key binding, if any. */
8394 if (CONSP (item
) && CONSP (XCAR (item
)))
8397 /* Process the rest of the properties. */
8398 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
8400 Lisp_Object key
, value
;
8403 value
= XCAR (XCDR (item
));
8405 if (EQ (key
, QCenable
))
8407 /* `:enable FORM'. */
8408 if (!NILP (Venable_disabled_menus_and_buttons
))
8409 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8411 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
8413 else if (EQ (key
, QCvisible
))
8415 /* `:visible FORM'. If got a visible property and that
8416 evaluates to nil then ignore this item. */
8417 if (NILP (menu_item_eval_property (value
)))
8420 else if (EQ (key
, QChelp
))
8421 /* `:help HELP-STRING'. */
8422 PROP (TOOL_BAR_ITEM_HELP
) = value
;
8423 else if (EQ (key
, QCfilter
))
8424 /* ':filter FORM'. */
8426 else if (EQ (key
, QCbutton
) && CONSP (value
))
8428 /* `:button (TYPE . SELECTED)'. */
8429 Lisp_Object type
, selected
;
8431 type
= XCAR (value
);
8432 selected
= XCDR (value
);
8433 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
8435 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
8436 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
8439 else if (EQ (key
, QCimage
)
8441 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
8442 /* Value is either a single image specification or a vector
8443 of 4 such specifications for the different button states. */
8444 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
8445 else if (EQ (key
, Qrtl
))
8447 PROP (TOOL_BAR_ITEM_RTL_IMAGE
) = value
;
8450 /* If got a filter apply it on binding. */
8452 PROP (TOOL_BAR_ITEM_BINDING
)
8453 = menu_item_eval_property (list2 (filter
,
8455 PROP (TOOL_BAR_ITEM_BINDING
))));
8457 /* See if the binding is a keymap. Give up if it is. */
8458 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
8461 /* Enable or disable selection of item. */
8462 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
8463 PROP (TOOL_BAR_ITEM_ENABLED_P
)
8464 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
8466 /* Handle radio buttons or toggle boxes. */
8467 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
8468 PROP (TOOL_BAR_ITEM_SELECTED_P
)
8469 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
8477 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8478 that can be reused. */
8481 init_tool_bar_items (reuse
)
8484 if (VECTORP (reuse
))
8485 tool_bar_items_vector
= reuse
;
8487 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
8488 ntool_bar_items
= 0;
8492 /* Append parsed tool bar item properties from
8493 tool_bar_item_properties */
8496 append_tool_bar_item ()
8498 Lisp_Object
*to
, *from
;
8500 /* Enlarge tool_bar_items_vector if necessary. */
8501 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
8502 >= XVECTOR (tool_bar_items_vector
)->size
)
8503 tool_bar_items_vector
8504 = larger_vector (tool_bar_items_vector
,
8505 2 * XVECTOR (tool_bar_items_vector
)->size
, Qnil
);
8507 /* Append entries from tool_bar_item_properties to the end of
8508 tool_bar_items_vector. */
8509 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
8510 from
= XVECTOR (tool_bar_item_properties
)->contents
;
8511 bcopy (from
, to
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
8512 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
8519 /* Read a character using menus based on maps in the array MAPS.
8520 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
8521 Return t if we displayed a menu but the user rejected it.
8523 PREV_EVENT is the previous input event, or nil if we are reading
8524 the first event of a key sequence.
8526 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
8527 if we used a mouse menu to read the input, or zero otherwise. If
8528 USED_MOUSE_MENU is null, we don't dereference it.
8530 The prompting is done based on the prompt-string of the map
8531 and the strings associated with various map elements.
8533 This can be done with X menus or with menus put in the minibuf.
8534 These are done in different ways, depending on how the input will be read.
8535 Menus using X are done after auto-saving in read-char, getting the input
8536 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8537 and do auto-saving in the inner call of read_char. */
8540 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
8543 Lisp_Object prev_event
;
8544 int *used_mouse_menu
;
8547 register Lisp_Object name
= Qnil
;
8549 if (used_mouse_menu
)
8550 *used_mouse_menu
= 0;
8552 /* Use local over global Menu maps */
8554 if (! menu_prompting
)
8557 /* Optionally disregard all but the global map. */
8558 if (inhibit_local_menu_bar_menus
)
8560 maps
+= (nmaps
- 1);
8564 /* Get the menu name from the first map that has one (a prompt string). */
8565 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8567 name
= Fkeymap_prompt (maps
[mapno
]);
8572 /* If we don't have any menus, just read a character normally. */
8573 if (!STRINGP (name
))
8577 /* If we got to this point via a mouse click,
8578 use a real menu for mouse selection. */
8579 if (EVENT_HAS_PARAMETERS (prev_event
)
8580 && !EQ (XCAR (prev_event
), Qmenu_bar
)
8581 && !EQ (XCAR (prev_event
), Qtool_bar
))
8583 /* Display the menu and get the selection. */
8584 Lisp_Object
*realmaps
8585 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
8589 /* Use the maps that are not nil. */
8590 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8591 if (!NILP (maps
[mapno
]))
8592 realmaps
[nmaps1
++] = maps
[mapno
];
8594 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
8599 record_menu_key (XCAR (value
));
8601 /* If we got multiple events, unread all but
8603 There is no way to prevent those unread events
8604 from showing up later in last_nonmenu_event.
8605 So turn symbol and integer events into lists,
8606 to indicate that they came from a mouse menu,
8607 so that when present in last_nonmenu_event
8608 they won't confuse things. */
8609 for (tem
= XCDR (value
); CONSP (tem
); tem
= XCDR (tem
))
8611 record_menu_key (XCAR (tem
));
8612 if (SYMBOLP (XCAR (tem
))
8613 || INTEGERP (XCAR (tem
)))
8614 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
8617 /* If we got more than one event, put all but the first
8618 onto this list to be read later.
8619 Return just the first event now. */
8620 Vunread_command_events
8621 = nconc2 (XCDR (value
), Vunread_command_events
);
8622 value
= XCAR (value
);
8624 else if (NILP (value
))
8626 if (used_mouse_menu
)
8627 *used_mouse_menu
= 1;
8630 #endif /* HAVE_MENUS */
8634 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8635 We make this bigger when necessary, and never free it. */
8636 static char *read_char_minibuf_menu_text
;
8637 /* Size of that buffer. */
8638 static int read_char_minibuf_menu_width
;
8641 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
8647 register Lisp_Object name
;
8649 /* FIXME: Use the minibuffer's frame width. */
8650 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8653 Lisp_Object rest
, vector
;
8659 if (! menu_prompting
)
8662 /* Make sure we have a big enough buffer for the menu text. */
8663 if (read_char_minibuf_menu_text
== 0)
8665 read_char_minibuf_menu_width
= width
+ 4;
8666 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
8668 else if (width
+ 4 > read_char_minibuf_menu_width
)
8670 read_char_minibuf_menu_width
= width
+ 4;
8671 read_char_minibuf_menu_text
8672 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8674 menu
= read_char_minibuf_menu_text
;
8676 /* Get the menu name from the first map that has one (a prompt string). */
8677 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8679 name
= Fkeymap_prompt (maps
[mapno
]);
8684 /* If we don't have any menus, just read a character normally. */
8685 if (!STRINGP (name
))
8688 /* Prompt string always starts with map's prompt, and a space. */
8689 strcpy (menu
, SDATA (name
));
8690 nlength
= SBYTES (name
);
8691 menu
[nlength
++] = ':';
8692 menu
[nlength
++] = ' ';
8695 /* Start prompting at start of first map. */
8699 /* Present the documented bindings, a line at a time. */
8706 Lisp_Object orig_defn_macro
;
8708 /* Loop over elements of map. */
8713 /* If reached end of map, start at beginning of next map. */
8717 /* At end of last map, wrap around to first map if just starting,
8718 or end this line if already have something on it. */
8722 if (notfirst
|| nobindings
) break;
8727 /* Look at the next element of the map. */
8729 elt
= XVECTOR (vector
)->contents
[idx
];
8731 elt
= Fcar_safe (rest
);
8733 if (idx
< 0 && VECTORP (elt
))
8735 /* If we found a dense table in the keymap,
8736 advanced past it, but start scanning its contents. */
8737 rest
= Fcdr_safe (rest
);
8743 /* An ordinary element. */
8744 Lisp_Object event
, tem
;
8748 event
= Fcar_safe (elt
); /* alist */
8749 elt
= Fcdr_safe (elt
);
8753 XSETINT (event
, idx
); /* vector */
8756 /* Ignore the element if it has no prompt string. */
8757 if (INTEGERP (event
) && parse_menu_item (elt
, 0, -1))
8759 /* 1 if the char to type matches the string. */
8761 Lisp_Object upcased_event
, downcased_event
;
8762 Lisp_Object desc
= Qnil
;
8764 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8766 upcased_event
= Fupcase (event
);
8767 downcased_event
= Fdowncase (event
);
8768 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8769 || XINT (downcased_event
) == SREF (s
, 0));
8771 desc
= Fsingle_key_description (event
, Qnil
);
8773 #if 0 /* It is redundant to list the equivalent key bindings because
8774 the prefix is what the user has already typed. */
8776 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8778 /* Insert equivalent keybinding. */
8779 s
= concat2 (s
, tem
);
8782 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8783 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8785 /* Insert button prefix. */
8786 Lisp_Object selected
8787 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8788 if (EQ (tem
, QCradio
))
8789 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8791 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8792 s
= concat2 (tem
, s
);
8796 /* If we have room for the prompt string, add it to this line.
8797 If this is the first on the line, always add it. */
8798 if ((SCHARS (s
) + i
+ 2
8799 + (char_matches
? 0 : SCHARS (desc
) + 3))
8805 /* Punctuate between strings. */
8808 strcpy (menu
+ i
, ", ");
8814 /* If the char to type doesn't match the string's
8815 first char, explicitly show what char to type. */
8818 /* Add as much of string as fits. */
8819 thiswidth
= SCHARS (desc
);
8820 if (thiswidth
+ i
> width
)
8821 thiswidth
= width
- i
;
8822 bcopy (SDATA (desc
), menu
+ i
, thiswidth
);
8824 strcpy (menu
+ i
, " = ");
8828 /* Add as much of string as fits. */
8829 thiswidth
= SCHARS (s
);
8830 if (thiswidth
+ i
> width
)
8831 thiswidth
= width
- i
;
8832 bcopy (SDATA (s
), menu
+ i
, thiswidth
);
8838 /* If this element does not fit, end the line now,
8839 and save the element for the next line. */
8840 strcpy (menu
+ i
, "...");
8845 /* Move past this element. */
8846 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8847 /* Handle reaching end of dense table. */
8852 rest
= Fcdr_safe (rest
);
8856 /* Prompt with that and read response. */
8857 message2_nolog (menu
, strlen (menu
),
8858 ! NILP (current_buffer
->enable_multibyte_characters
));
8860 /* Make believe its not a keyboard macro in case the help char
8861 is pressed. Help characters are not recorded because menu prompting
8862 is not used on replay.
8864 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
8865 current_kboard
->defining_kbd_macro
= Qnil
;
8867 obj
= read_char (commandflag
, 0, 0, Qt
, 0, NULL
);
8868 while (BUFFERP (obj
));
8869 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
8871 if (!INTEGERP (obj
))
8873 else if (XINT (obj
) == -2)
8878 if (! EQ (obj
, menu_prompt_more_char
)
8879 && (!INTEGERP (menu_prompt_more_char
)
8880 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8882 if (!NILP (current_kboard
->defining_kbd_macro
))
8883 store_kbd_macro_char (obj
);
8886 /* Help char - go round again */
8890 /* Reading key sequences. */
8892 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8893 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8894 keymap, or nil otherwise. Return the index of the first keymap in
8895 which KEY has any binding, or NMAPS if no map has a binding.
8897 If KEY is a meta ASCII character, treat it like meta-prefix-char
8898 followed by the corresponding non-meta character. Keymaps in
8899 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8902 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8905 NEXT may be the same array as CURRENT. */
8908 follow_key (key
, nmaps
, current
, defs
, next
)
8910 Lisp_Object
*current
, *defs
, *next
;
8913 int i
, first_binding
;
8915 first_binding
= nmaps
;
8916 for (i
= nmaps
- 1; i
>= 0; i
--)
8918 if (! NILP (current
[i
]))
8920 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8921 if (! NILP (defs
[i
]))
8928 /* Given the set of bindings we've found, produce the next set of maps. */
8929 if (first_binding
< nmaps
)
8930 for (i
= 0; i
< nmaps
; i
++)
8931 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8933 return first_binding
;
8936 /* Structure used to keep track of partial application of key remapping
8937 such as Vfunction_key_map and Vkey_translation_map. */
8938 typedef struct keyremap
8940 /* This is the map originally specified for this use. */
8942 /* This is a submap reached by looking up, in PARENT,
8943 the events from START to END. */
8945 /* Positions [START, END) in the key sequence buffer
8946 are the key that we have scanned so far.
8947 Those events are the ones that we will replace
8948 if PAREHT maps them into a key sequence. */
8952 /* Lookup KEY in MAP.
8953 MAP is a keymap mapping keys to key vectors or functions.
8954 If the mapping is a function and DO_FUNCTION is non-zero, then
8955 the function is called with PROMPT as parameter and its return
8956 value is used as the return value of this function (after checking
8957 that it is indeed a vector). */
8960 access_keymap_keyremap (map
, key
, prompt
, do_funcall
)
8961 Lisp_Object map
, key
, prompt
;
8966 next
= access_keymap (map
, key
, 1, 0, 1);
8968 /* Handle symbol with autoload definition. */
8969 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8970 && CONSP (XSYMBOL (next
)->function
)
8971 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8972 do_autoload (XSYMBOL (next
)->function
, next
);
8974 /* Handle a symbol whose function definition is a keymap
8976 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8977 && (ARRAYP (XSYMBOL (next
)->function
)
8978 || KEYMAPP (XSYMBOL (next
)->function
)))
8979 next
= XSYMBOL (next
)->function
;
8981 /* If the keymap gives a function, not an
8982 array, then call the function with one arg and use
8983 its value instead. */
8984 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8989 next
= call1 (next
, prompt
);
8990 /* If the function returned something invalid,
8991 barf--don't ignore it.
8992 (To ignore it safely, we would need to gcpro a bunch of
8993 other variables.) */
8994 if (! (VECTORP (next
) || STRINGP (next
)))
8995 error ("Function %s returns invalid key sequence", tem
);
9000 /* Do one step of the key remapping used for function-key-map and
9001 key-translation-map:
9002 KEYBUF is the buffer holding the input events.
9003 BUFSIZE is its maximum size.
9004 FKEY is a pointer to the keyremap structure to use.
9005 INPUT is the index of the last element in KEYBUF.
9006 DOIT if non-zero says that the remapping can actually take place.
9007 DIFF is used to return the number of keys added/removed by the remapping.
9008 PARENT is the root of the keymap.
9009 PROMPT is the prompt to use if the remapping happens through a function.
9010 The return value is non-zero if the remapping actually took place. */
9013 keyremap_step (keybuf
, bufsize
, fkey
, input
, doit
, diff
, prompt
)
9014 Lisp_Object
*keybuf
, prompt
;
9016 int input
, doit
, *diff
, bufsize
;
9018 Lisp_Object next
, key
;
9020 key
= keybuf
[fkey
->end
++];
9022 if (KEYMAPP (fkey
->parent
))
9023 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
9027 /* If keybuf[fkey->start..fkey->end] is bound in the
9028 map and we're in a position to do the key remapping, replace it with
9029 the binding and restart with fkey->start at the end. */
9030 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
9032 int len
= XFASTINT (Flength (next
));
9035 *diff
= len
- (fkey
->end
- fkey
->start
);
9037 if (input
+ *diff
>= bufsize
)
9038 error ("Key sequence too long");
9040 /* Shift the keys that follow fkey->end. */
9042 for (i
= fkey
->end
; i
< input
; i
++)
9043 keybuf
[i
+ *diff
] = keybuf
[i
];
9045 for (i
= input
- 1; i
>= fkey
->end
; i
--)
9046 keybuf
[i
+ *diff
] = keybuf
[i
];
9047 /* Overwrite the old keys with the new ones. */
9048 for (i
= 0; i
< len
; i
++)
9049 keybuf
[fkey
->start
+ i
]
9050 = Faref (next
, make_number (i
));
9052 fkey
->start
= fkey
->end
+= *diff
;
9053 fkey
->map
= fkey
->parent
;
9058 fkey
->map
= get_keymap (next
, 0, 1);
9060 /* If we no longer have a bound suffix, try a new position for
9062 if (!CONSP (fkey
->map
))
9064 fkey
->end
= ++fkey
->start
;
9065 fkey
->map
= fkey
->parent
;
9070 /* Read a sequence of keys that ends with a non prefix character,
9071 storing it in KEYBUF, a buffer of size BUFSIZE.
9073 Return the length of the key sequence stored.
9074 Return -1 if the user rejected a command menu.
9076 Echo starting immediately unless `prompt' is 0.
9078 Where a key sequence ends depends on the currently active keymaps.
9079 These include any minor mode keymaps active in the current buffer,
9080 the current buffer's local map, and the global map.
9082 If a key sequence has no other bindings, we check Vfunction_key_map
9083 to see if some trailing subsequence might be the beginning of a
9084 function key's sequence. If so, we try to read the whole function
9085 key, and substitute its symbolic name into the key sequence.
9087 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
9088 `double-' events into similar click events, if that would make them
9089 bound. We try to turn `triple-' events first into `double-' events,
9092 If we get a mouse click in a mode line, vertical divider, or other
9093 non-text area, we treat the click as if it were prefixed by the
9094 symbol denoting that area - `mode-line', `vertical-line', or
9097 If the sequence starts with a mouse click, we read the key sequence
9098 with respect to the buffer clicked on, not the current buffer.
9100 If the user switches frames in the midst of a key sequence, we put
9101 off the switch-frame event until later; the next call to
9102 read_char will return it.
9104 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
9105 from the selected window's buffer. */
9108 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
9109 can_return_switch_frame
, fix_current_buffer
)
9110 Lisp_Object
*keybuf
;
9113 int dont_downcase_last
;
9114 int can_return_switch_frame
;
9115 int fix_current_buffer
;
9117 volatile Lisp_Object from_string
;
9118 volatile int count
= SPECPDL_INDEX ();
9120 /* How many keys there are in the current key sequence. */
9123 /* The length of the echo buffer when we started reading, and
9124 the length of this_command_keys when we started reading. */
9125 volatile int echo_start
;
9126 volatile int keys_start
;
9128 /* The number of keymaps we're scanning right now, and the number of
9129 keymaps we have allocated space for. */
9131 volatile int nmaps_allocated
= 0;
9133 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
9134 the current keymaps. */
9135 Lisp_Object
*volatile defs
= NULL
;
9137 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
9138 in the current keymaps, or nil where it is not a prefix. */
9139 Lisp_Object
*volatile submaps
= NULL
;
9141 /* The local map to start out with at start of key sequence. */
9142 volatile Lisp_Object orig_local_map
;
9144 /* The map from the `keymap' property to start out with at start of
9146 volatile Lisp_Object orig_keymap
;
9148 /* 1 if we have already considered switching to the local-map property
9149 of the place where a mouse click occurred. */
9150 volatile int localized_local_map
= 0;
9152 /* The index in submaps[] of the first keymap that has a binding for
9153 this key sequence. In other words, the lowest i such that
9154 submaps[i] is non-nil. */
9155 volatile int first_binding
;
9156 /* Index of the first key that has no binding.
9157 It is useless to try fkey.start larger than that. */
9158 volatile int first_unbound
;
9160 /* If t < mock_input, then KEYBUF[t] should be read as the next
9163 We use this to recover after recognizing a function key. Once we
9164 realize that a suffix of the current key sequence is actually a
9165 function key's escape sequence, we replace the suffix with the
9166 function key's binding from Vfunction_key_map. Now keybuf
9167 contains a new and different key sequence, so the echo area,
9168 this_command_keys, and the submaps and defs arrays are wrong. In
9169 this situation, we set mock_input to t, set t to 0, and jump to
9170 restart_sequence; the loop will read keys from keybuf up until
9171 mock_input, thus rebuilding the state; and then it will resume
9172 reading characters from the keyboard. */
9173 volatile int mock_input
= 0;
9175 /* If the sequence is unbound in submaps[], then
9176 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
9177 and fkey.map is its binding.
9179 These might be > t, indicating that all function key scanning
9180 should hold off until t reaches them. We do this when we've just
9181 recognized a function key, to avoid searching for the function
9182 key's again in Vfunction_key_map. */
9183 volatile keyremap fkey
;
9185 /* Likewise, for key_translation_map and input-decode-map. */
9186 volatile keyremap keytran
, indec
;
9188 /* If we receive a `switch-frame' or `select-window' event in the middle of
9189 a key sequence, we put it off for later.
9190 While we're reading, we keep the event here. */
9191 volatile Lisp_Object delayed_switch_frame
;
9193 /* See the comment below... */
9194 #if defined (GOBBLE_FIRST_EVENT)
9195 Lisp_Object first_event
;
9198 volatile Lisp_Object original_uppercase
;
9199 volatile int original_uppercase_position
= -1;
9201 /* Gets around Microsoft compiler limitations. */
9204 struct buffer
*starting_buffer
;
9206 /* List of events for which a fake prefix key has been generated. */
9207 volatile Lisp_Object fake_prefixed_keys
= Qnil
;
9209 #if defined (GOBBLE_FIRST_EVENT)
9213 struct gcpro gcpro1
;
9215 GCPRO1 (fake_prefixed_keys
);
9216 raw_keybuf_count
= 0;
9218 last_nonmenu_event
= Qnil
;
9220 delayed_switch_frame
= Qnil
;
9225 echo_prompt (prompt
);
9226 else if (cursor_in_echo_area
9227 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9228 && NILP (Fzerop (Vecho_keystrokes
)))
9229 /* This doesn't put in a dash if the echo buffer is empty, so
9230 you don't always see a dash hanging out in the minibuffer. */
9234 /* Record the initial state of the echo area and this_command_keys;
9235 we will need to restore them if we replay a key sequence. */
9237 echo_start
= echo_length ();
9238 keys_start
= this_command_key_count
;
9239 this_single_command_key_start
= keys_start
;
9241 #if defined (GOBBLE_FIRST_EVENT)
9242 /* This doesn't quite work, because some of the things that read_char
9243 does cannot safely be bypassed. It seems too risky to try to make
9246 /* Read the first char of the sequence specially, before setting
9247 up any keymaps, in case a filter runs and switches buffers on us. */
9248 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
9250 #endif /* GOBBLE_FIRST_EVENT */
9252 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9253 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9256 /* The multi-tty merge moved the code below to right after
9257 `replay_sequence' which caused all these translation maps to be applied
9258 repeatedly, even tho their doc says very clearly they are not applied to
9260 The reason for this move was: "We may switch keyboards between rescans,
9261 so we need to reinitialize fkey and keytran before each replay".
9262 This move was wrong (even if we switch keyboards, keybuf still holds the
9263 keys we've read already from the original keyboard and some of those keys
9264 may have already been translated). So there may still be a bug out there
9266 indec
.map
= indec
.parent
= current_kboard
->Vinput_decode_map
;
9267 fkey
.map
= fkey
.parent
= current_kboard
->Vlocal_function_key_map
;
9268 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
9269 indec
.start
= indec
.end
= 0;
9270 fkey
.start
= fkey
.end
= 0;
9271 keytran
.start
= keytran
.end
= 0;
9273 /* We jump here when the key sequence has been thoroughly changed, and
9274 we need to rescan it starting from the beginning. When we jump here,
9275 keybuf[0..mock_input] holds the sequence we should reread. */
9278 starting_buffer
= current_buffer
;
9279 first_unbound
= bufsize
+ 1;
9281 /* Build our list of keymaps.
9282 If we recognize a function key and replace its escape sequence in
9283 keybuf with its symbol, or if the sequence starts with a mouse
9284 click and we need to switch buffers, we jump back here to rebuild
9285 the initial keymaps from the current buffer. */
9288 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
9290 if (2 > nmaps_allocated
)
9292 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9293 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9294 nmaps_allocated
= 2;
9296 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
9297 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
9299 else if (!NILP (Voverriding_local_map
))
9301 if (2 > nmaps_allocated
)
9303 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9304 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9305 nmaps_allocated
= 2;
9307 if (!NILP (Voverriding_local_map
))
9308 submaps
[nmaps
++] = Voverriding_local_map
;
9316 nminor
= current_minor_maps (0, &maps
);
9317 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
9319 if (total
> nmaps_allocated
)
9321 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
9322 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
9323 nmaps_allocated
= total
;
9326 if (!NILP (orig_keymap
))
9327 submaps
[nmaps
++] = orig_keymap
;
9329 bcopy (maps
, (void *) (submaps
+ nmaps
),
9330 nminor
* sizeof (submaps
[0]));
9334 submaps
[nmaps
++] = orig_local_map
;
9336 submaps
[nmaps
++] = current_global_map
;
9338 /* Find an accurate initial value for first_binding. */
9339 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
9340 if (! NILP (submaps
[first_binding
]))
9343 /* Start from the beginning in keybuf. */
9346 /* These are no-ops the first time through, but if we restart, they
9347 revert the echo area and this_command_keys to their original state. */
9348 this_command_key_count
= keys_start
;
9349 if (INTERACTIVE
&& t
< mock_input
)
9350 echo_truncate (echo_start
);
9352 /* If the best binding for the current key sequence is a keymap, or
9353 we may be looking at a function key's escape sequence, keep on
9355 while (first_binding
< nmaps
9356 /* Keep reading as long as there's a prefix binding. */
9357 ? !NILP (submaps
[first_binding
])
9358 /* Don't return in the middle of a possible function key sequence,
9359 if the only bindings we found were via case conversion.
9360 Thus, if ESC O a has a function-key-map translation
9361 and ESC o has a binding, don't return after ESC O,
9362 so that we can translate ESC O plus the next character. */
9363 : (/* indec.start < t || fkey.start < t || */ keytran
.start
< t
))
9366 int used_mouse_menu
= 0;
9368 /* Where the last real key started. If we need to throw away a
9369 key that has expanded into more than one element of keybuf
9370 (say, a mouse click on the mode line which is being treated
9371 as [mode-line (mouse-...)], then we backtrack to this point
9373 volatile int last_real_key_start
;
9375 /* These variables are analogous to echo_start and keys_start;
9376 while those allow us to restart the entire key sequence,
9377 echo_local_start and keys_local_start allow us to throw away
9379 volatile int echo_local_start
, keys_local_start
, local_first_binding
;
9381 eassert (indec
.end
== t
|| (indec
.end
> t
&& indec
.end
<= mock_input
));
9382 eassert (indec
.start
<= indec
.end
);
9383 eassert (fkey
.start
<= fkey
.end
);
9384 eassert (keytran
.start
<= keytran
.end
);
9385 /* key-translation-map is applied *after* function-key-map
9386 which is itself applied *after* input-decode-map. */
9387 eassert (fkey
.end
<= indec
.start
);
9388 eassert (keytran
.end
<= fkey
.start
);
9390 if (/* first_unbound < indec.start && first_unbound < fkey.start && */
9391 first_unbound
< keytran
.start
)
9392 { /* The prefix upto first_unbound has no binding and has
9393 no translation left to do either, so we know it's unbound.
9394 If we don't stop now, we risk staying here indefinitely
9395 (if the user keeps entering fkey or keytran prefixes
9396 like C-c ESC ESC ESC ESC ...) */
9398 for (i
= first_unbound
+ 1; i
< t
; i
++)
9399 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
9400 mock_input
= t
- first_unbound
- 1;
9401 indec
.end
= indec
.start
-= first_unbound
+ 1;
9402 indec
.map
= indec
.parent
;
9403 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
9404 fkey
.map
= fkey
.parent
;
9405 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
9406 keytran
.map
= keytran
.parent
;
9407 goto replay_sequence
;
9411 error ("Key sequence too long");
9414 echo_local_start
= echo_length ();
9415 keys_local_start
= this_command_key_count
;
9416 local_first_binding
= first_binding
;
9419 /* These are no-ops, unless we throw away a keystroke below and
9420 jumped back up to replay_key; in that case, these restore the
9421 variables to their original state, allowing us to replay the
9423 if (INTERACTIVE
&& t
< mock_input
)
9424 echo_truncate (echo_local_start
);
9425 this_command_key_count
= keys_local_start
;
9426 first_binding
= local_first_binding
;
9428 /* By default, assume each event is "real". */
9429 last_real_key_start
= t
;
9431 /* Does mock_input indicate that we are re-reading a key sequence? */
9435 add_command_key (key
);
9436 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9437 && NILP (Fzerop (Vecho_keystrokes
)))
9441 /* If not, we should actually read a character. */
9446 KBOARD
*interrupted_kboard
= current_kboard
;
9447 struct frame
*interrupted_frame
= SELECTED_FRAME ();
9449 key
= read_char (NILP (prompt
), nmaps
,
9450 (Lisp_Object
*) submaps
, last_nonmenu_event
,
9451 &used_mouse_menu
, NULL
);
9453 if (INTEGERP (key
) && XINT (key
) == -2) /* wrong_kboard_jmpbuf */
9458 for (k
= all_kboards
; k
; k
= k
->next_kboard
)
9459 if (k
== interrupted_kboard
)
9464 /* Don't touch interrupted_kboard when it's been
9466 delayed_switch_frame
= Qnil
;
9467 goto replay_sequence
;
9470 if (!NILP (delayed_switch_frame
))
9472 interrupted_kboard
->kbd_queue
9473 = Fcons (delayed_switch_frame
,
9474 interrupted_kboard
->kbd_queue
);
9475 delayed_switch_frame
= Qnil
;
9479 interrupted_kboard
->kbd_queue
9480 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
9482 /* If the side queue is non-empty, ensure it begins with a
9483 switch-frame, so we'll replay it in the right context. */
9484 if (CONSP (interrupted_kboard
->kbd_queue
)
9485 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
9486 !(EVENT_HAS_PARAMETERS (key
)
9487 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
9491 XSETFRAME (frame
, interrupted_frame
);
9492 interrupted_kboard
->kbd_queue
9493 = Fcons (make_lispy_switch_frame (frame
),
9494 interrupted_kboard
->kbd_queue
);
9497 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9498 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9499 goto replay_sequence
;
9504 /* read_char returns t when it shows a menu and the user rejects it.
9508 unbind_to (count
, Qnil
);
9513 /* read_char returns -1 at the end of a macro.
9514 Emacs 18 handles this by returning immediately with a
9515 zero, so that's what we'll do. */
9516 if (INTEGERP (key
) && XINT (key
) == -1)
9519 /* The Microsoft C compiler can't handle the goto that
9525 /* If the current buffer has been changed from under us, the
9526 keymap may have changed, so replay the sequence. */
9529 timer_resume_idle ();
9532 /* Reset the current buffer from the selected window
9533 in case something changed the former and not the latter.
9534 This is to be more consistent with the behavior
9535 of the command_loop_1. */
9536 if (fix_current_buffer
)
9538 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9540 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
9541 Fset_buffer (XWINDOW (selected_window
)->buffer
);
9544 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9545 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9546 goto replay_sequence
;
9549 /* If we have a quit that was typed in another frame, and
9550 quit_throw_to_read_char switched buffers,
9551 replay to get the right keymap. */
9553 && XINT (key
) == quit_char
9554 && current_buffer
!= starting_buffer
)
9557 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9561 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9562 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9563 goto replay_sequence
;
9568 if (EVENT_HAS_PARAMETERS (key
)
9569 /* Either a `switch-frame' or a `select-window' event. */
9570 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
9572 /* If we're at the beginning of a key sequence, and the caller
9573 says it's okay, go ahead and return this event. If we're
9574 in the midst of a key sequence, delay it until the end. */
9575 if (t
> 0 || !can_return_switch_frame
)
9577 delayed_switch_frame
= key
;
9583 ASET (raw_keybuf
, raw_keybuf_count
++, key
);
9586 /* Clicks in non-text areas get prefixed by the symbol
9587 in their CHAR-ADDRESS field. For example, a click on
9588 the mode line is prefixed by the symbol `mode-line'.
9590 Furthermore, key sequences beginning with mouse clicks
9591 are read using the keymaps of the buffer clicked on, not
9592 the current buffer. So we may have to switch the buffer
9595 When we turn one event into two events, we must make sure
9596 that neither of the two looks like the original--so that,
9597 if we replay the events, they won't be expanded again.
9598 If not for this, such reexpansion could happen either here
9599 or when user programs play with this-command-keys. */
9600 if (EVENT_HAS_PARAMETERS (key
))
9605 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
9606 if (EQ (kind
, Qmouse_click
))
9608 Lisp_Object window
, posn
;
9610 window
= POSN_WINDOW (EVENT_START (key
));
9611 posn
= POSN_POSN (EVENT_START (key
));
9614 || (!NILP (fake_prefixed_keys
)
9615 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
9617 /* We're looking a second time at an event for which
9618 we generated a fake prefix key. Set
9619 last_real_key_start appropriately. */
9621 last_real_key_start
= t
- 1;
9624 /* Key sequences beginning with mouse clicks are
9625 read using the keymaps in the buffer clicked on,
9626 not the current buffer. If we're at the
9627 beginning of a key sequence, switch buffers. */
9628 if (last_real_key_start
== 0
9630 && BUFFERP (XWINDOW (window
)->buffer
)
9631 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
9633 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9637 /* Arrange to go back to the original buffer once we're
9638 done reading the key sequence. Note that we can't
9639 use save_excursion_{save,restore} here, because they
9640 save point as well as the current buffer; we don't
9641 want to save point, because redisplay may change it,
9642 to accommodate a Fset_window_start or something. We
9643 don't want to do this at the top of the function,
9644 because we may get input from a subprocess which
9645 wants to change the selected window and stuff (say,
9647 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
9649 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9651 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
9652 orig_local_map
= get_local_map (PT
, current_buffer
,
9654 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9655 goto replay_sequence
;
9658 /* For a mouse click, get the local text-property keymap
9659 of the place clicked on, rather than point. */
9660 if (last_real_key_start
== 0
9661 && CONSP (XCDR (key
))
9662 && ! localized_local_map
)
9664 Lisp_Object map_here
, start
, pos
;
9666 localized_local_map
= 1;
9667 start
= EVENT_START (key
);
9669 if (CONSP (start
) && POSN_INBUFFER_P (start
))
9671 pos
= POSN_BUFFER_POSN (start
);
9673 && XINT (pos
) >= BEGV
9674 && XINT (pos
) <= ZV
)
9676 map_here
= get_local_map (XINT (pos
),
9677 current_buffer
, Qlocal_map
);
9678 if (!EQ (map_here
, orig_local_map
))
9680 orig_local_map
= map_here
;
9681 ++localized_local_map
;
9684 map_here
= get_local_map (XINT (pos
),
9685 current_buffer
, Qkeymap
);
9686 if (!EQ (map_here
, orig_keymap
))
9688 orig_keymap
= map_here
;
9689 ++localized_local_map
;
9692 if (localized_local_map
> 1)
9697 goto replay_sequence
;
9703 /* Expand mode-line and scroll-bar events into two events:
9704 use posn as a fake prefix key. */
9706 && (NILP (fake_prefixed_keys
)
9707 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9709 if (t
+ 1 >= bufsize
)
9710 error ("Key sequence too long");
9713 keybuf
[t
+ 1] = key
;
9716 /* Record that a fake prefix key has been generated
9717 for KEY. Don't modify the event; this would
9718 prevent proper action when the event is pushed
9719 back into unread-command-events. */
9720 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9722 /* If on a mode line string with a local keymap,
9723 reconsider the key sequence with that keymap. */
9724 if (string
= POSN_STRING (EVENT_START (key
)),
9725 (CONSP (string
) && STRINGP (XCAR (string
))))
9727 Lisp_Object pos
, map
, map2
;
9729 pos
= XCDR (string
);
9730 string
= XCAR (string
);
9732 && XINT (pos
) < SCHARS (string
))
9734 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9736 orig_local_map
= map
;
9737 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9740 if (!NILP (map
) || !NILP (map2
))
9741 goto replay_sequence
;
9747 else if (NILP (from_string
)
9748 && (string
= POSN_STRING (EVENT_START (key
)),
9749 (CONSP (string
) && STRINGP (XCAR (string
)))))
9751 /* For a click on a string, i.e. overlay string or a
9752 string displayed via the `display' property,
9753 consider `local-map' and `keymap' properties of
9755 Lisp_Object pos
, map
, map2
;
9757 pos
= XCDR (string
);
9758 string
= XCAR (string
);
9760 && XINT (pos
) < SCHARS (string
))
9762 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9764 orig_local_map
= map
;
9765 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9769 if (!NILP (map
) || !NILP (map2
))
9771 from_string
= string
;
9774 goto replay_sequence
;
9779 else if (CONSP (XCDR (key
))
9780 && CONSP (EVENT_START (key
))
9781 && CONSP (XCDR (EVENT_START (key
))))
9785 posn
= POSN_POSN (EVENT_START (key
));
9786 /* Handle menu-bar events:
9787 insert the dummy prefix event `menu-bar'. */
9788 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9790 if (t
+ 1 >= bufsize
)
9791 error ("Key sequence too long");
9795 /* Zap the position in key, so we know that we've
9796 expanded it, and don't try to do so again. */
9797 POSN_SET_POSN (EVENT_START (key
),
9798 Fcons (posn
, Qnil
));
9801 goto replay_sequence
;
9803 else if (CONSP (posn
))
9805 /* We're looking at the second event of a
9806 sequence which we expanded before. Set
9807 last_real_key_start appropriately. */
9808 if (last_real_key_start
== t
&& t
> 0)
9809 last_real_key_start
= t
- 1;
9814 /* We have finally decided that KEY is something we might want
9816 first_binding
= (follow_key (key
,
9817 nmaps
- first_binding
,
9818 submaps
+ first_binding
,
9819 defs
+ first_binding
,
9820 submaps
+ first_binding
)
9823 /* If KEY wasn't bound, we'll try some fallbacks. */
9824 if (first_binding
< nmaps
)
9825 /* This is needed for the following scenario:
9826 event 0: a down-event that gets dropped by calling replay_key.
9827 event 1: some normal prefix like C-h.
9828 After event 0, first_unbound is 0, after event 1 indec.start,
9829 fkey.start, and keytran.start are all 1, so when we see that
9830 C-h is bound, we need to update first_unbound. */
9831 first_unbound
= max (t
+ 1, first_unbound
);
9836 /* Remember the position to put an upper bound on indec.start. */
9837 first_unbound
= min (t
, first_unbound
);
9839 head
= EVENT_HEAD (key
);
9840 if (help_char_p (head
) && t
> 0)
9842 read_key_sequence_cmd
= Vprefix_help_command
;
9844 last_nonmenu_event
= key
;
9845 /* The Microsoft C compiler can't handle the goto that
9853 Lisp_Object breakdown
;
9856 breakdown
= parse_modifiers (head
);
9857 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9858 /* Attempt to reduce an unbound mouse event to a simpler
9859 event that is bound:
9860 Drags reduce to clicks.
9861 Double-clicks reduce to clicks.
9862 Triple-clicks reduce to double-clicks, then to clicks.
9863 Down-clicks are eliminated.
9864 Double-downs reduce to downs, then are eliminated.
9865 Triple-downs reduce to double-downs, then to downs,
9866 then are eliminated. */
9867 if (modifiers
& (down_modifier
| drag_modifier
9868 | double_modifier
| triple_modifier
))
9870 while (modifiers
& (down_modifier
| drag_modifier
9871 | double_modifier
| triple_modifier
))
9873 Lisp_Object new_head
, new_click
;
9874 if (modifiers
& triple_modifier
)
9875 modifiers
^= (double_modifier
| triple_modifier
);
9876 else if (modifiers
& double_modifier
)
9877 modifiers
&= ~double_modifier
;
9878 else if (modifiers
& drag_modifier
)
9879 modifiers
&= ~drag_modifier
;
9882 /* Dispose of this `down' event by simply jumping
9883 back to replay_key, to get another event.
9885 Note that if this event came from mock input,
9886 then just jumping back to replay_key will just
9887 hand it to us again. So we have to wipe out any
9890 We could delete keybuf[t] and shift everything
9891 after that to the left by one spot, but we'd also
9892 have to fix up any variable that points into
9893 keybuf, and shifting isn't really necessary
9896 Adding prefixes for non-textual mouse clicks
9897 creates two characters of mock input, and both
9898 must be thrown away. If we're only looking at
9899 the prefix now, we can just jump back to
9900 replay_key. On the other hand, if we've already
9901 processed the prefix, and now the actual click
9902 itself is giving us trouble, then we've lost the
9903 state of the keymaps we want to backtrack to, and
9904 we need to replay the whole sequence to rebuild
9907 Beyond that, only function key expansion could
9908 create more than two keys, but that should never
9909 generate mouse events, so it's okay to zero
9910 mock_input in that case too.
9912 FIXME: The above paragraph seems just plain
9913 wrong, if you consider things like
9914 xterm-mouse-mode. -stef
9916 Isn't this just the most wonderful code ever? */
9918 /* If mock_input > t + 1, the above simplification
9919 will actually end up dropping keys on the floor.
9920 This is probably OK for now, but even
9921 if mock_input <= t + 1, we need to adjust indec,
9923 Typical case [header-line down-mouse-N]:
9924 mock_input = 2, t = 1, fkey.end = 1,
9925 last_real_key_start = 0. */
9926 if (indec
.end
> last_real_key_start
)
9928 indec
.end
= indec
.start
9929 = min (last_real_key_start
, indec
.start
);
9930 indec
.map
= indec
.parent
;
9931 if (fkey
.end
> last_real_key_start
)
9933 fkey
.end
= fkey
.start
9934 = min (last_real_key_start
, fkey
.start
);
9935 fkey
.map
= fkey
.parent
;
9936 if (keytran
.end
> last_real_key_start
)
9938 keytran
.end
= keytran
.start
9939 = min (last_real_key_start
, keytran
.start
);
9940 keytran
.map
= keytran
.parent
;
9944 if (t
== last_real_key_start
)
9951 mock_input
= last_real_key_start
;
9952 goto replay_sequence
;
9957 = apply_modifiers (modifiers
, XCAR (breakdown
));
9959 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9961 /* Look for a binding for this new key. follow_key
9962 promises that it didn't munge submaps the
9963 last time we called it, since key was unbound. */
9965 = (follow_key (new_click
,
9966 nmaps
- local_first_binding
,
9967 submaps
+ local_first_binding
,
9968 defs
+ local_first_binding
,
9969 submaps
+ local_first_binding
)
9970 + local_first_binding
);
9972 /* If that click is bound, go for it. */
9973 if (first_binding
< nmaps
)
9978 /* Otherwise, we'll leave key set to the drag event. */
9985 /* Normally, last_nonmenu_event gets the previous key we read.
9986 But when a mouse popup menu is being used,
9987 we don't update last_nonmenu_event; it continues to hold the mouse
9988 event that preceded the first level of menu. */
9989 if (!used_mouse_menu
)
9990 last_nonmenu_event
= key
;
9992 /* Record what part of this_command_keys is the current key sequence. */
9993 this_single_command_key_start
= this_command_key_count
- t
;
9995 /* Look for this sequence in input-decode-map.
9996 Scan from indec.end until we find a bound suffix. */
9997 while (indec
.end
< t
)
9999 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10002 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
10003 done
= keyremap_step (keybuf
, bufsize
, &indec
, max (t
, mock_input
),
10008 mock_input
= diff
+ max (t
, mock_input
);
10009 goto replay_sequence
;
10013 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
])
10014 && indec
.start
>= t
)
10015 /* There is a binding and it's not a prefix.
10016 (and it doesn't have any input-decode-map translation pending).
10017 There is thus no function-key in this sequence.
10018 Moving fkey.start is important in this case to allow keytran.start
10019 to go over the sequence before we return (since we keep the
10020 invariant that keytran.end <= fkey.start). */
10022 if (fkey
.start
< t
)
10023 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
10026 /* If the sequence is unbound, see if we can hang a function key
10027 off the end of it. */
10028 /* Continue scan from fkey.end until we find a bound suffix. */
10029 while (fkey
.end
< indec
.start
)
10031 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10034 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
10035 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
10036 max (t
, mock_input
),
10037 /* If there's a binding (i.e.
10038 first_binding >= nmaps) we don't want
10039 to apply this function-key-mapping. */
10040 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
10045 mock_input
= diff
+ max (t
, mock_input
);
10046 /* Adjust the input-decode-map counters. */
10048 indec
.start
+= diff
;
10050 goto replay_sequence
;
10054 /* Look for this sequence in key-translation-map.
10055 Scan from keytran.end until we find a bound suffix. */
10056 while (keytran
.end
< fkey
.start
)
10058 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10061 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
10062 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
10067 mock_input
= diff
+ max (t
, mock_input
);
10068 /* Adjust the function-key-map and input-decode-map counters. */
10070 indec
.start
+= diff
;
10072 fkey
.start
+= diff
;
10074 goto replay_sequence
;
10078 /* If KEY is not defined in any of the keymaps,
10079 and cannot be part of a function key or translation,
10080 and is an upper case letter or shifted key,
10081 use the corresponding lower-case/unshifted key instead. */
10082 if (first_binding
>= nmaps
10083 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
)
10085 Lisp_Object breakdown
= parse_modifiers (key
);
10087 = CONSP (breakdown
) ? (XINT (XCAR (XCDR (breakdown
)))) : 0;
10089 if (modifiers
& shift_modifier
10090 /* Treat uppercase keys as shifted. */
10092 && (KEY_TO_CHAR (key
)
10093 < XCHAR_TABLE (current_buffer
->downcase_table
)->size
)
10094 && UPPERCASEP (KEY_TO_CHAR (key
))))
10096 Lisp_Object new_key
10097 = (modifiers
& shift_modifier
10098 ? apply_modifiers (modifiers
& ~shift_modifier
,
10100 : make_number (DOWNCASE (KEY_TO_CHAR (key
)) | modifiers
));
10102 original_uppercase
= key
;
10103 original_uppercase_position
= t
- 1;
10105 /* We have to do this unconditionally, regardless of whether
10106 the lower-case char is defined in the keymaps, because they
10107 might get translated through function-key-map. */
10108 keybuf
[t
- 1] = new_key
;
10109 mock_input
= max (t
, mock_input
);
10110 /* Reset fkey (and consequently keytran) to apply
10111 function-key-map on the result, so that S-backspace is
10112 correctly mapped to DEL (via backspace). OTOH,
10113 input-decode-map doesn't need to go through it again. */
10114 fkey
.start
= fkey
.end
= 0;
10115 keytran
.start
= keytran
.end
= 0;
10117 goto replay_sequence
;
10122 read_key_sequence_cmd
= (first_binding
< nmaps
10123 ? defs
[first_binding
]
10126 unread_switch_frame
= delayed_switch_frame
;
10127 unbind_to (count
, Qnil
);
10129 /* Don't downcase the last character if the caller says don't.
10130 Don't downcase it if the result is undefined, either. */
10131 if ((dont_downcase_last
|| first_binding
>= nmaps
)
10133 && t
- 1 == original_uppercase_position
)
10134 keybuf
[t
- 1] = original_uppercase
;
10136 /* Occasionally we fabricate events, perhaps by expanding something
10137 according to function-key-map, or by adding a prefix symbol to a
10138 mouse click in the scroll bar or modeline. In this cases, return
10139 the entire generated key sequence, even if we hit an unbound
10140 prefix or a definition before the end. This means that you will
10141 be able to push back the event properly, and also means that
10142 read-key-sequence will always return a logical unit.
10145 for (; t
< mock_input
; t
++)
10147 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
10148 && NILP (Fzerop (Vecho_keystrokes
)))
10149 echo_char (keybuf
[t
]);
10150 add_command_key (keybuf
[t
]);
10159 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
10160 doc
: /* Read a sequence of keystrokes and return as a string or vector.
10161 The sequence is sufficient to specify a non-prefix command in the
10162 current local and global maps.
10164 First arg PROMPT is a prompt string. If nil, do not prompt specially.
10165 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
10166 as a continuation of the previous key.
10168 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
10169 convert the last event to lower case. (Normally any upper case event
10170 is converted to lower case if the original event is undefined and the lower
10171 case equivalent is defined.) A non-nil value is appropriate for reading
10172 a key sequence to be defined.
10174 A C-g typed while in this function is treated like any other character,
10175 and `quit-flag' is not set.
10177 If the key sequence starts with a mouse click, then the sequence is read
10178 using the keymaps of the buffer of the window clicked in, not the buffer
10179 of the selected window as normal.
10181 `read-key-sequence' drops unbound button-down events, since you normally
10182 only care about the click or drag events which follow them. If a drag
10183 or multi-click event is unbound, but the corresponding click event would
10184 be bound, `read-key-sequence' turns the event into a click event at the
10185 drag's starting position. This means that you don't have to distinguish
10186 between click and drag, double, or triple events unless you want to.
10188 `read-key-sequence' prefixes mouse events on mode lines, the vertical
10189 lines separating windows, and scroll bars with imaginary keys
10190 `mode-line', `vertical-line', and `vertical-scroll-bar'.
10192 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
10193 function will process a switch-frame event if the user switches frames
10194 before typing anything. If the user switches frames in the middle of a
10195 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
10196 is nil, then the event will be put off until after the current key sequence.
10198 `read-key-sequence' checks `function-key-map' for function key
10199 sequences, where they wouldn't conflict with ordinary bindings. See
10200 `function-key-map' for more details.
10202 The optional fifth argument COMMAND-LOOP, if non-nil, means
10203 that this key sequence is being read by something that will
10204 read commands one after another. It should be nil if the caller
10205 will read just one key sequence. */)
10206 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
10208 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
10209 Lisp_Object can_return_switch_frame
, command_loop
;
10211 Lisp_Object keybuf
[30];
10213 struct gcpro gcpro1
;
10214 int count
= SPECPDL_INDEX ();
10216 if (!NILP (prompt
))
10217 CHECK_STRING (prompt
);
10220 specbind (Qinput_method_exit_on_first_char
,
10221 (NILP (command_loop
) ? Qt
: Qnil
));
10222 specbind (Qinput_method_use_echo_area
,
10223 (NILP (command_loop
) ? Qt
: Qnil
));
10225 bzero (keybuf
, sizeof keybuf
);
10226 GCPRO1 (keybuf
[0]);
10227 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10229 if (NILP (continue_echo
))
10231 this_command_key_count
= 0;
10232 this_command_key_count_reset
= 0;
10233 this_single_command_key_start
= 0;
10236 #ifdef HAVE_X_WINDOWS
10237 if (display_hourglass_p
)
10238 cancel_hourglass ();
10241 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10242 prompt
, ! NILP (dont_downcase_last
),
10243 ! NILP (can_return_switch_frame
), 0);
10245 #if 0 /* The following is fine for code reading a key sequence and
10246 then proceeding with a lenghty computation, but it's not good
10247 for code reading keys in a loop, like an input method. */
10248 #ifdef HAVE_X_WINDOWS
10249 if (display_hourglass_p
)
10250 start_hourglass ();
10260 return unbind_to (count
, make_event_array (i
, keybuf
));
10263 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
10264 Sread_key_sequence_vector
, 1, 5, 0,
10265 doc
: /* Like `read-key-sequence' but always return a vector. */)
10266 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
10268 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
10269 Lisp_Object can_return_switch_frame
, command_loop
;
10271 Lisp_Object keybuf
[30];
10273 struct gcpro gcpro1
;
10274 int count
= SPECPDL_INDEX ();
10276 if (!NILP (prompt
))
10277 CHECK_STRING (prompt
);
10280 specbind (Qinput_method_exit_on_first_char
,
10281 (NILP (command_loop
) ? Qt
: Qnil
));
10282 specbind (Qinput_method_use_echo_area
,
10283 (NILP (command_loop
) ? Qt
: Qnil
));
10285 bzero (keybuf
, sizeof keybuf
);
10286 GCPRO1 (keybuf
[0]);
10287 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10289 if (NILP (continue_echo
))
10291 this_command_key_count
= 0;
10292 this_command_key_count_reset
= 0;
10293 this_single_command_key_start
= 0;
10296 #ifdef HAVE_X_WINDOWS
10297 if (display_hourglass_p
)
10298 cancel_hourglass ();
10301 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10302 prompt
, ! NILP (dont_downcase_last
),
10303 ! NILP (can_return_switch_frame
), 0);
10305 #ifdef HAVE_X_WINDOWS
10306 if (display_hourglass_p
)
10307 start_hourglass ();
10316 return unbind_to (count
, Fvector (i
, keybuf
));
10319 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
10320 doc
: /* Execute CMD as an editor command.
10321 CMD must be a symbol that satisfies the `commandp' predicate.
10322 Optional second arg RECORD-FLAG non-nil
10323 means unconditionally put this command in `command-history'.
10324 Otherwise, that is done only if an arg is read using the minibuffer.
10325 The argument KEYS specifies the value to use instead of (this-command-keys)
10326 when reading the arguments; if it is nil, (this-command-keys) is used.
10327 The argument SPECIAL, if non-nil, means that this command is executing
10328 a special event, so ignore the prefix argument and don't clear it. */)
10329 (cmd
, record_flag
, keys
, special
)
10330 Lisp_Object cmd
, record_flag
, keys
, special
;
10332 register Lisp_Object final
;
10333 register Lisp_Object tem
;
10334 Lisp_Object prefixarg
;
10335 extern int debug_on_next_call
;
10337 debug_on_next_call
= 0;
10339 if (NILP (special
))
10341 prefixarg
= current_kboard
->Vprefix_arg
;
10342 Vcurrent_prefix_arg
= prefixarg
;
10343 current_kboard
->Vprefix_arg
= Qnil
;
10350 tem
= Fget (cmd
, Qdisabled
);
10351 if (!NILP (tem
) && !NILP (Vrun_hooks
))
10353 tem
= Fsymbol_value (Qdisabled_command_function
);
10355 return call1 (Vrun_hooks
, Qdisabled_command_function
);
10361 final
= Findirect_function (cmd
, Qnil
);
10363 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
10365 struct gcpro gcpro1
, gcpro2
;
10367 GCPRO2 (cmd
, prefixarg
);
10368 do_autoload (final
, cmd
);
10375 if (STRINGP (final
) || VECTORP (final
))
10377 /* If requested, place the macro in the command history. For
10378 other sorts of commands, call-interactively takes care of
10380 if (!NILP (record_flag
))
10383 = Fcons (Fcons (Qexecute_kbd_macro
,
10384 Fcons (final
, Fcons (prefixarg
, Qnil
))),
10387 /* Don't keep command history around forever. */
10388 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
10390 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
10392 XSETCDR (tem
, Qnil
);
10396 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
10399 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
10400 /* Don't call Fcall_interactively directly because we want to make
10401 sure the backtrace has an entry for `call-interactively'.
10402 For the same reason, pass `cmd' rather than `final'. */
10403 return call3 (Qcall_interactively
, cmd
, record_flag
, keys
);
10410 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
10412 doc
: /* Read function name, then read its arguments and call it.
10414 To pass a numeric argument to the command you are invoking with, specify
10415 the numeric argument to this command.
10417 Noninteractively, the argument PREFIXARG is the prefix argument to
10418 give to the command you invoke, if it asks for an argument. */)
10420 Lisp_Object prefixarg
;
10422 Lisp_Object function
;
10424 int saved_last_point_position
;
10425 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
10426 Lisp_Object bindings
, value
;
10427 struct gcpro gcpro1
, gcpro2
, gcpro3
;
10428 #ifdef HAVE_X_WINDOWS
10429 /* The call to Fcompleting_read wil start and cancel the hourglass,
10430 but if the hourglass was already scheduled, this means that no
10431 hourglass will be shown for the actual M-x command itself.
10432 So we restart it if it is already scheduled. Note that checking
10433 hourglass_shown_p is not enough, normally the hourglass is not shown,
10434 just scheduled to be shown. */
10435 int hstarted
= hourglass_started ();
10438 saved_keys
= Fvector (this_command_key_count
,
10439 XVECTOR (this_command_keys
)->contents
);
10440 saved_last_point_position_buffer
= last_point_position_buffer
;
10441 saved_last_point_position
= last_point_position
;
10443 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
10445 if (EQ (prefixarg
, Qminus
))
10446 strcpy (buf
, "- ");
10447 else if (CONSP (prefixarg
) && XINT (XCAR (prefixarg
)) == 4)
10448 strcpy (buf
, "C-u ");
10449 else if (CONSP (prefixarg
) && INTEGERP (XCAR (prefixarg
)))
10450 sprintf (buf
, "%ld ", (long) XINT (XCAR (prefixarg
)));
10451 else if (INTEGERP (prefixarg
))
10452 sprintf (buf
, "%ld ", (long) XINT (prefixarg
));
10454 /* This isn't strictly correct if execute-extended-command
10455 is bound to anything else. Perhaps it should use
10456 this_command_keys? */
10457 strcat (buf
, "M-x ");
10459 /* Prompt with buf, and then read a string, completing from and
10460 restricting to the set of all defined commands. Don't provide
10461 any initial input. Save the command read on the extended-command
10463 function
= Fcompleting_read (build_string (buf
),
10464 Vobarray
, Qcommandp
,
10465 Qt
, Qnil
, Qextended_command_history
, Qnil
,
10468 #ifdef HAVE_X_WINDOWS
10469 if (hstarted
) start_hourglass ();
10472 if (STRINGP (function
) && SCHARS (function
) == 0)
10473 error ("No command name given");
10475 /* Set this_command_keys to the concatenation of saved_keys and
10476 function, followed by a RET. */
10481 this_command_key_count
= 0;
10482 this_command_key_count_reset
= 0;
10483 this_single_command_key_start
= 0;
10485 keys
= XVECTOR (saved_keys
)->contents
;
10486 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
10487 add_command_key (keys
[i
]);
10489 for (i
= 0; i
< SCHARS (function
); i
++)
10490 add_command_key (Faref (function
, make_number (i
)));
10492 add_command_key (make_number ('\015'));
10495 last_point_position
= saved_last_point_position
;
10496 last_point_position_buffer
= saved_last_point_position_buffer
;
10500 function
= Fintern (function
, Qnil
);
10501 current_kboard
->Vprefix_arg
= prefixarg
;
10502 Vthis_command
= function
;
10503 real_this_command
= function
;
10505 /* If enabled, show which key runs this command. */
10506 if (!NILP (Vsuggest_key_bindings
)
10507 && NILP (Vexecuting_kbd_macro
)
10508 && SYMBOLP (function
))
10509 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
10515 GCPRO3 (bindings
, value
, function
);
10516 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
10518 /* If the command has a key binding, print it now. */
10519 if (!NILP (bindings
)
10520 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
10523 /* But first wait, and skip the message if there is input. */
10524 Lisp_Object waited
;
10526 /* If this command displayed something in the echo area;
10527 wait a few seconds, then display our suggestion message. */
10528 if (NILP (echo_area_buffer
[0]))
10529 waited
= sit_for (make_number (0), 0, 2);
10530 else if (NUMBERP (Vsuggest_key_bindings
))
10531 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10533 waited
= sit_for (make_number (2), 0, 2);
10535 if (!NILP (waited
) && ! CONSP (Vunread_command_events
))
10537 Lisp_Object binding
;
10539 int message_p
= push_message ();
10540 int count
= SPECPDL_INDEX ();
10542 record_unwind_protect (pop_message_unwind
, Qnil
);
10543 binding
= Fkey_description (bindings
, Qnil
);
10546 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
10549 sprintf (newmessage
, "You can run the command `%s' with %s",
10550 SDATA (SYMBOL_NAME (function
)),
10552 message2_nolog (newmessage
,
10553 strlen (newmessage
),
10554 STRING_MULTIBYTE (binding
));
10555 if (NUMBERP (Vsuggest_key_bindings
))
10556 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10558 waited
= sit_for (make_number (2), 0, 2);
10560 if (!NILP (waited
) && message_p
)
10561 restore_message ();
10563 unbind_to (count
, Qnil
);
10567 RETURN_UNGCPRO (value
);
10571 /* Return nonzero if input events are pending. */
10574 detect_input_pending ()
10576 if (!input_pending
)
10577 get_input_pending (&input_pending
, 0);
10579 return input_pending
;
10582 /* Return nonzero if input events other than mouse movements are
10586 detect_input_pending_ignore_squeezables ()
10588 if (!input_pending
)
10589 get_input_pending (&input_pending
, READABLE_EVENTS_IGNORE_SQUEEZABLES
);
10591 return input_pending
;
10594 /* Return nonzero if input events are pending, and run any pending timers. */
10597 detect_input_pending_run_timers (do_display
)
10600 int old_timers_run
= timers_run
;
10602 if (!input_pending
)
10603 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
10605 if (old_timers_run
!= timers_run
&& do_display
)
10607 redisplay_preserve_echo_area (8);
10608 /* The following fixes a bug when using lazy-lock with
10609 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
10610 from an idle timer function. The symptom of the bug is that
10611 the cursor sometimes doesn't become visible until the next X
10612 event is processed. --gerd. */
10614 Lisp_Object tail
, frame
;
10615 FOR_EACH_FRAME (tail
, frame
)
10616 if (FRAME_RIF (XFRAME (frame
)))
10617 FRAME_RIF (XFRAME (frame
))->flush_display (XFRAME (frame
));
10621 return input_pending
;
10624 /* This is called in some cases before a possible quit.
10625 It cases the next call to detect_input_pending to recompute input_pending.
10626 So calling this function unnecessarily can't do any harm. */
10629 clear_input_pending ()
10634 /* Return nonzero if there are pending requeued events.
10635 This isn't used yet. The hope is to make wait_reading_process_output
10636 call it, and return if it runs Lisp code that unreads something.
10637 The problem is, kbd_buffer_get_event needs to be fixed to know what
10638 to do in that case. It isn't trivial. */
10641 requeued_events_pending_p ()
10643 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
10647 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
10648 doc
: /* Return t if command input is currently available with no wait.
10649 Actually, the value is nil only if we can be sure that no input is available;
10650 if there is a doubt, the value is t. */)
10653 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1
10654 || !NILP (Vunread_post_input_method_events
)
10655 || !NILP (Vunread_input_method_events
))
10658 get_input_pending (&input_pending
,
10659 READABLE_EVENTS_DO_TIMERS_NOW
10660 | READABLE_EVENTS_FILTER_EVENTS
);
10661 return input_pending
> 0 ? Qt
: Qnil
;
10664 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
10665 doc
: /* Return vector of last 300 events, not counting those from keyboard macros. */)
10668 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
10671 if (total_keys
< NUM_RECENT_KEYS
)
10672 return Fvector (total_keys
, keys
);
10675 val
= Fvector (NUM_RECENT_KEYS
, keys
);
10676 bcopy (keys
+ recent_keys_index
,
10677 XVECTOR (val
)->contents
,
10678 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
10680 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
10681 recent_keys_index
* sizeof (Lisp_Object
));
10686 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
10687 doc
: /* Return the key sequence that invoked this command.
10688 However, if the command has called `read-key-sequence', it returns
10689 the last key sequence that has been read.
10690 The value is a string or a vector.
10692 See also `this-command-keys-vector'. */)
10695 return make_event_array (this_command_key_count
,
10696 XVECTOR (this_command_keys
)->contents
);
10699 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
10700 doc
: /* Return the key sequence that invoked this command, as a vector.
10701 However, if the command has called `read-key-sequence', it returns
10702 the last key sequence that has been read.
10704 See also `this-command-keys'. */)
10707 return Fvector (this_command_key_count
,
10708 XVECTOR (this_command_keys
)->contents
);
10711 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
10712 Sthis_single_command_keys
, 0, 0, 0,
10713 doc
: /* Return the key sequence that invoked this command.
10714 More generally, it returns the last key sequence read, either by
10715 the command loop or by `read-key-sequence'.
10716 Unlike `this-command-keys', this function's value
10717 does not include prefix arguments.
10718 The value is always a vector. */)
10721 return Fvector (this_command_key_count
10722 - this_single_command_key_start
,
10723 (XVECTOR (this_command_keys
)->contents
10724 + this_single_command_key_start
));
10727 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
10728 Sthis_single_command_raw_keys
, 0, 0, 0,
10729 doc
: /* Return the raw events that were read for this command.
10730 More generally, it returns the last key sequence read, either by
10731 the command loop or by `read-key-sequence'.
10732 Unlike `this-single-command-keys', this function's value
10733 shows the events before all translations (except for input methods).
10734 The value is always a vector. */)
10737 return Fvector (raw_keybuf_count
,
10738 (XVECTOR (raw_keybuf
)->contents
));
10741 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10742 Sreset_this_command_lengths
, 0, 0, 0,
10743 doc
: /* Make the unread events replace the last command and echo.
10744 Used in `universal-argument-other-key'.
10746 `universal-argument-other-key' rereads the event just typed.
10747 It then gets translated through `function-key-map'.
10748 The translated event has to replace the real events,
10749 both in the value of (this-command-keys) and in echoing.
10750 To achieve this, `universal-argument-other-key' calls
10751 `reset-this-command-lengths', which discards the record of reading
10752 these events the first time. */)
10755 this_command_key_count
= before_command_key_count
;
10756 if (this_command_key_count
< this_single_command_key_start
)
10757 this_single_command_key_start
= this_command_key_count
;
10759 echo_truncate (before_command_echo_length
);
10761 /* Cause whatever we put into unread-command-events
10762 to echo as if it were being freshly read from the keyboard. */
10763 this_command_key_count_reset
= 1;
10768 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10769 Sclear_this_command_keys
, 0, 1, 0,
10770 doc
: /* Clear out the vector that `this-command-keys' returns.
10771 Also clear the record of the last 100 events, unless optional arg
10772 KEEP-RECORD is non-nil. */)
10774 Lisp_Object keep_record
;
10778 this_command_key_count
= 0;
10779 this_command_key_count_reset
= 0;
10781 if (NILP (keep_record
))
10783 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10784 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10786 recent_keys_index
= 0;
10791 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10792 doc
: /* Return the current depth in recursive edits. */)
10796 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10800 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10801 "FOpen dribble file: ",
10802 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10803 If FILE is nil, close any open dribble file. */)
10816 file
= Fexpand_file_name (file
, Qnil
);
10817 dribble
= fopen (SDATA (file
), "w");
10819 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10824 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10825 doc
: /* Discard the contents of the terminal input buffer.
10826 Also end any kbd macro being defined. */)
10829 if (!NILP (current_kboard
->defining_kbd_macro
))
10831 /* Discard the last command from the macro. */
10832 Fcancel_kbd_macro_events ();
10836 update_mode_lines
++;
10838 Vunread_command_events
= Qnil
;
10839 unread_command_char
= -1;
10841 discard_tty_input ();
10843 kbd_fetch_ptr
= kbd_store_ptr
;
10849 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10850 doc
: /* Stop Emacs and return to superior process. You can resume later.
10851 If `cannot-suspend' is non-nil, or if the system doesn't support job
10852 control, run a subshell instead.
10854 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10855 to be read as terminal input by Emacs's parent, after suspension.
10857 Before suspending, run the normal hook `suspend-hook'.
10858 After resumption run the normal hook `suspend-resume-hook'.
10860 Some operating systems cannot stop the Emacs process and resume it later.
10861 On such systems, Emacs starts a subshell instead of suspending. */)
10863 Lisp_Object stuffstring
;
10865 int count
= SPECPDL_INDEX ();
10866 int old_height
, old_width
;
10868 struct gcpro gcpro1
;
10870 if (tty_list
&& tty_list
->next
)
10871 error ("There are other tty frames open; close them before suspending Emacs");
10873 if (!NILP (stuffstring
))
10874 CHECK_STRING (stuffstring
);
10876 /* Run the functions in suspend-hook. */
10877 if (!NILP (Vrun_hooks
))
10878 call1 (Vrun_hooks
, intern ("suspend-hook"));
10880 GCPRO1 (stuffstring
);
10881 get_tty_size (fileno (CURTTY ()->input
), &old_width
, &old_height
);
10882 reset_all_sys_modes ();
10883 /* sys_suspend can get an error if it tries to fork a subshell
10884 and the system resources aren't available for that. */
10885 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object
))) init_all_sys_modes
,
10887 stuff_buffered_input (stuffstring
);
10888 if (cannot_suspend
)
10892 unbind_to (count
, Qnil
);
10894 /* Check if terminal/window size has changed.
10895 Note that this is not useful when we are running directly
10896 with a window system; but suspend should be disabled in that case. */
10897 get_tty_size (fileno (CURTTY ()->input
), &width
, &height
);
10898 if (width
!= old_width
|| height
!= old_height
)
10899 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10901 /* Run suspend-resume-hook. */
10902 if (!NILP (Vrun_hooks
))
10903 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
10909 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10910 Then in any case stuff anything Emacs has read ahead and not used. */
10913 stuff_buffered_input (stuffstring
)
10914 Lisp_Object stuffstring
;
10916 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
10917 register unsigned char *p
;
10919 if (STRINGP (stuffstring
))
10921 register int count
;
10923 p
= SDATA (stuffstring
);
10924 count
= SBYTES (stuffstring
);
10925 while (count
-- > 0)
10930 /* Anything we have read ahead, put back for the shell to read. */
10931 /* ?? What should this do when we have multiple keyboards??
10932 Should we ignore anything that was typed in at the "wrong" kboard?
10934 rms: we should stuff everything back into the kboard
10936 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10939 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10940 kbd_fetch_ptr
= kbd_buffer
;
10941 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10942 stuff_char (kbd_fetch_ptr
->code
);
10944 clear_event (kbd_fetch_ptr
);
10948 #endif /* SIGTSTP */
10952 set_waiting_for_input (time_to_clear
)
10953 EMACS_TIME
*time_to_clear
;
10955 input_available_clear_time
= time_to_clear
;
10957 /* Tell handle_interrupt to throw back to read_char, */
10958 waiting_for_input
= 1;
10960 /* If handle_interrupt was called before and buffered a C-g,
10961 make it run again now, to avoid timing error. */
10962 if (!NILP (Vquit_flag
))
10963 quit_throw_to_read_char ();
10967 clear_waiting_for_input ()
10969 /* Tell handle_interrupt not to throw back to read_char, */
10970 waiting_for_input
= 0;
10971 input_available_clear_time
= 0;
10974 /* The SIGINT handler.
10976 If we have a frame on the controlling tty, we assume that the
10977 SIGINT was generated by C-g, so we call handle_interrupt.
10978 Otherwise, the handler kills Emacs. */
10981 interrupt_signal (signalnum
) /* If we don't have an argument, */
10982 int signalnum
; /* some compilers complain in signal calls. */
10984 /* Must preserve main program's value of errno. */
10985 int old_errno
= errno
;
10986 struct terminal
*terminal
;
10988 #if defined (USG) && !defined (POSIX_SIGNALS)
10989 /* USG systems forget handlers when they are used;
10990 must reestablish each time */
10991 signal (SIGINT
, interrupt_signal
);
10992 signal (SIGQUIT
, interrupt_signal
);
10995 SIGNAL_THREAD_CHECK (signalnum
);
10997 /* See if we have an active terminal on our controlling tty. */
10998 terminal
= get_named_tty ("/dev/tty");
11001 /* If there are no frames there, let's pretend that we are a
11002 well-behaving UN*X program and quit. */
11003 Fkill_emacs (Qnil
);
11007 /* Otherwise, the SIGINT was probably generated by C-g. */
11009 /* Set internal_last_event_frame to the top frame of the
11010 controlling tty, if we have a frame there. We disable the
11011 interrupt key on secondary ttys, so the SIGINT must have come
11012 from the controlling tty. */
11013 internal_last_event_frame
= terminal
->display_info
.tty
->top_frame
;
11015 handle_interrupt ();
11021 /* This routine is called at interrupt level in response to C-g.
11023 It is called from the SIGINT handler or kbd_buffer_store_event.
11025 If `waiting_for_input' is non zero, then unless `echoing' is
11026 nonzero, immediately throw back to read_char.
11028 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
11029 eval to throw, when it gets a chance. If quit-flag is already
11030 non-nil, it stops the job right away. */
11033 handle_interrupt ()
11039 /* XXX This code needs to be revised for multi-tty support. */
11040 if (!NILP (Vquit_flag
)
11042 && get_named_tty ("/dev/tty")
11046 /* If SIGINT isn't blocked, don't let us be interrupted by
11047 another SIGINT, it might be harmful due to non-reentrancy
11048 in I/O functions. */
11049 sigblock (sigmask (SIGINT
));
11052 reset_all_sys_modes ();
11054 #ifdef SIGTSTP /* Support possible in later USG versions */
11056 * On systems which can suspend the current process and return to the original
11057 * shell, this command causes the user to end up back at the shell.
11058 * The "Auto-save" and "Abort" questions are not asked until
11059 * the user elects to return to emacs, at which point he can save the current
11060 * job and either dump core or continue.
11065 if (sys_suspend () == -1)
11067 printf ("Not running as a subprocess;\n");
11068 printf ("you can continue or abort.\n");
11070 #else /* not VMS */
11071 /* Perhaps should really fork an inferior shell?
11072 But that would not provide any way to get back
11073 to the original shell, ever. */
11074 printf ("No support for stopping a process on this operating system;\n");
11075 printf ("you can continue or abort.\n");
11076 #endif /* not VMS */
11077 #endif /* not SIGTSTP */
11079 /* We must remain inside the screen area when the internal terminal
11080 is used. Note that [Enter] is not echoed by dos. */
11083 /* It doesn't work to autosave while GC is in progress;
11084 the code used for auto-saving doesn't cope with the mark bit. */
11085 if (!gc_in_progress
)
11087 printf ("Auto-save? (y or n) ");
11089 if (((c
= getchar ()) & ~040) == 'Y')
11091 Fdo_auto_save (Qt
, Qnil
);
11093 printf ("\r\nAuto-save done");
11094 #else /* not MSDOS */
11095 printf ("Auto-save done\n");
11096 #endif /* not MSDOS */
11098 while (c
!= '\n') c
= getchar ();
11102 /* During GC, it must be safe to reenable quitting again. */
11103 Vinhibit_quit
= Qnil
;
11106 #endif /* not MSDOS */
11107 printf ("Garbage collection in progress; cannot auto-save now\r\n");
11108 printf ("but will instead do a real quit after garbage collection ends\r\n");
11113 printf ("\r\nAbort? (y or n) ");
11114 #else /* not MSDOS */
11116 printf ("Abort (and enter debugger)? (y or n) ");
11117 #else /* not VMS */
11118 printf ("Abort (and dump core)? (y or n) ");
11119 #endif /* not VMS */
11120 #endif /* not MSDOS */
11122 if (((c
= getchar ()) & ~040) == 'Y')
11124 while (c
!= '\n') c
= getchar ();
11126 printf ("\r\nContinuing...\r\n");
11127 #else /* not MSDOS */
11128 printf ("Continuing...\n");
11129 #endif /* not MSDOS */
11131 init_all_sys_modes ();
11136 /* If executing a function that wants to be interrupted out of
11137 and the user has not deferred quitting by binding `inhibit-quit'
11138 then quit right away. */
11139 if (immediate_quit
&& NILP (Vinhibit_quit
))
11141 struct gl_state_s saved
;
11142 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
11144 immediate_quit
= 0;
11147 GCPRO4 (saved
.object
, saved
.global_code
,
11148 saved
.current_syntax_table
, saved
.old_prop
);
11149 Fsignal (Qquit
, Qnil
);
11154 /* Else request quit when it's safe */
11158 if (waiting_for_input
&& !echoing
)
11159 quit_throw_to_read_char ();
11162 /* Handle a C-g by making read_char return C-g. */
11165 quit_throw_to_read_char ()
11168 /* Prevent another signal from doing this before we finish. */
11169 clear_waiting_for_input ();
11172 Vunread_command_events
= Qnil
;
11173 unread_command_char
= -1;
11175 #if 0 /* Currently, sit_for is called from read_char without turning
11176 off polling. And that can call set_waiting_for_input.
11177 It seems to be harmless. */
11178 #ifdef POLL_FOR_INPUT
11179 /* May be > 1 if in recursive minibuffer. */
11180 if (poll_suppress_count
== 0)
11184 if (FRAMEP (internal_last_event_frame
)
11185 && !EQ (internal_last_event_frame
, selected_frame
))
11186 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
11189 _longjmp (getcjmp
, 1);
11192 DEFUN ("set-input-interrupt-mode", Fset_input_interrupt_mode
, Sset_input_interrupt_mode
, 1, 1, 0,
11193 doc
: /* Set interrupt mode of reading keyboard input.
11194 If INTERRUPT is non-nil, Emacs will use input interrupts;
11195 otherwise Emacs uses CBREAK mode.
11197 See also `current-input-mode'. */)
11199 Lisp_Object interrupt
;
11201 int new_interrupt_input
;
11203 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11204 #ifdef HAVE_X_WINDOWS
11205 if (x_display_list
!= NULL
)
11207 /* When using X, don't give the user a real choice,
11208 because we haven't implemented the mechanisms to support it. */
11209 #ifdef NO_SOCK_SIGIO
11210 new_interrupt_input
= 0;
11211 #else /* not NO_SOCK_SIGIO */
11212 new_interrupt_input
= 1;
11213 #endif /* NO_SOCK_SIGIO */
11217 new_interrupt_input
= !NILP (interrupt
);
11218 #else /* not SIGIO */
11219 new_interrupt_input
= 0;
11220 #endif /* not SIGIO */
11222 /* Our VMS input only works by interrupts, as of now. */
11224 new_interrupt_input
= 1;
11227 if (new_interrupt_input
!= interrupt_input
)
11229 #ifdef POLL_FOR_INPUT
11233 /* this causes startup screen to be restored and messes with the mouse */
11234 reset_all_sys_modes ();
11236 interrupt_input
= new_interrupt_input
;
11238 init_all_sys_modes ();
11241 #ifdef POLL_FOR_INPUT
11242 poll_suppress_count
= 1;
11249 DEFUN ("set-output-flow-control", Fset_output_flow_control
, Sset_output_flow_control
, 1, 2, 0,
11250 doc
: /* Enable or disable ^S/^Q flow control for output to TERMINAL.
11251 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
11252 C-q in key sequences.
11254 This setting only has an effect on tty terminals and only when
11255 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
11257 See also `current-input-mode'. */)
11259 Lisp_Object flow
, terminal
;
11261 struct terminal
*t
= get_terminal (terminal
, 1);
11262 struct tty_display_info
*tty
;
11263 if (t
== NULL
|| t
->type
!= output_termcap
)
11265 tty
= t
->display_info
.tty
;
11267 if (tty
->flow_control
!= !NILP (flow
))
11270 /* this causes startup screen to be restored and messes with the mouse */
11271 reset_sys_modes (tty
);
11274 tty
->flow_control
= !NILP (flow
);
11277 init_sys_modes (tty
);
11283 DEFUN ("set-input-meta-mode", Fset_input_meta_mode
, Sset_input_meta_mode
, 1, 2, 0,
11284 doc
: /* Enable or disable 8-bit input on TERMINAL.
11285 If META is t, Emacs will accept 8-bit input, and interpret the 8th
11286 bit as the Meta modifier.
11288 If META is nil, Emacs will ignore the top bit, on the assumption it is
11291 Otherwise, Emacs will accept and pass through 8-bit input without
11292 specially interpreting the top bit.
11294 This setting only has an effect on tty terminal devices.
11296 Optional parameter TERMINAL specifies the tty terminal device to use.
11297 It may be a terminal id, a frame, or nil for the terminal used by the
11298 currently selected frame.
11300 See also `current-input-mode'. */)
11302 Lisp_Object meta
, terminal
;
11304 struct terminal
*t
= get_terminal (terminal
, 1);
11305 struct tty_display_info
*tty
;
11308 if (t
== NULL
|| t
->type
!= output_termcap
)
11310 tty
= t
->display_info
.tty
;
11314 else if (EQ (meta
, Qt
))
11319 if (tty
->meta_key
!= new_meta
)
11322 /* this causes startup screen to be restored and messes with the mouse */
11323 reset_sys_modes (tty
);
11326 tty
->meta_key
= new_meta
;
11329 init_sys_modes (tty
);
11335 DEFUN ("set-quit-char", Fset_quit_char
, Sset_quit_char
, 1, 1, 0,
11336 doc
: /* Specify character used for quitting.
11337 QUIT must be an ASCII character.
11339 This function only has an effect on the controlling tty of the Emacs
11342 See also `current-input-mode'. */)
11346 struct terminal
*t
= get_named_tty ("/dev/tty");
11347 struct tty_display_info
*tty
;
11348 if (t
== NULL
|| t
->type
!= output_termcap
)
11350 tty
= t
->display_info
.tty
;
11352 if (NILP (quit
) || !INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400)
11353 error ("QUIT must be an ASCII character");
11356 /* this causes startup screen to be restored and messes with the mouse */
11357 reset_sys_modes (tty
);
11360 /* Don't let this value be out of range. */
11361 quit_char
= XINT (quit
) & (tty
->meta_key
== 0 ? 0177 : 0377);
11364 init_sys_modes (tty
);
11370 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
11371 doc
: /* Set mode of reading keyboard input.
11372 First arg INTERRUPT non-nil means use input interrupts;
11373 nil means use CBREAK mode.
11374 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
11375 (no effect except in CBREAK mode).
11376 Third arg META t means accept 8-bit input (for a Meta key).
11377 META nil means ignore the top bit, on the assumption it is parity.
11378 Otherwise, accept 8-bit input and don't use the top bit for Meta.
11379 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
11380 See also `current-input-mode'. */)
11381 (interrupt
, flow
, meta
, quit
)
11382 Lisp_Object interrupt
, flow
, meta
, quit
;
11384 Fset_input_interrupt_mode (interrupt
);
11385 Fset_output_flow_control (flow
, Qnil
);
11386 Fset_input_meta_mode (meta
, Qnil
);
11388 Fset_quit_char (quit
);
11392 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
11393 doc
: /* Return information about the way Emacs currently reads keyboard input.
11394 The value is a list of the form (INTERRUPT FLOW META QUIT), where
11395 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
11396 nil, Emacs is using CBREAK mode.
11397 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
11398 terminal; this does not apply if Emacs uses interrupt-driven input.
11399 META is t if accepting 8-bit input with 8th bit as Meta flag.
11400 META nil means ignoring the top bit, on the assumption it is parity.
11401 META is neither t nor nil if accepting 8-bit input and using
11402 all 8 bits as the character code.
11403 QUIT is the character Emacs currently uses to quit.
11404 The elements of this list correspond to the arguments of
11405 `set-input-mode'. */)
11408 Lisp_Object val
[4];
11409 struct frame
*sf
= XFRAME (selected_frame
);
11411 val
[0] = interrupt_input
? Qt
: Qnil
;
11412 if (FRAME_TERMCAP_P (sf
))
11414 val
[1] = FRAME_TTY (sf
)->flow_control
? Qt
: Qnil
;
11415 val
[2] = (FRAME_TTY (sf
)->meta_key
== 2
11417 : (CURTTY ()->meta_key
== 1 ? Qt
: Qnil
));
11424 XSETFASTINT (val
[3], quit_char
);
11426 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
11429 DEFUN ("posn-at-x-y", Fposn_at_x_y
, Sposn_at_x_y
, 2, 4, 0,
11430 doc
: /* Return position information for pixel coordinates X and Y.
11431 By default, X and Y are relative to text area of the selected window.
11432 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
11433 If optional fourth arg WHOLE is non-nil, X is relative to the left
11434 edge of the window.
11436 The return value is similar to a mouse click position:
11437 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11438 IMAGE (DX . DY) (WIDTH . HEIGHT))
11439 The `posn-' functions access elements of such lists. */)
11440 (x
, y
, frame_or_window
, whole
)
11441 Lisp_Object x
, y
, frame_or_window
, whole
;
11446 if (NILP (frame_or_window
))
11447 frame_or_window
= selected_window
;
11449 if (WINDOWP (frame_or_window
))
11453 CHECK_LIVE_WINDOW (frame_or_window
);
11455 w
= XWINDOW (frame_or_window
);
11456 XSETINT (x
, (XINT (x
)
11457 + WINDOW_LEFT_EDGE_X (w
)
11459 ? window_box_left_offset (w
, TEXT_AREA
)
11461 XSETINT (y
, WINDOW_TO_FRAME_PIXEL_Y (w
, XINT (y
)));
11462 frame_or_window
= w
->frame
;
11465 CHECK_LIVE_FRAME (frame_or_window
);
11467 return make_lispy_position (XFRAME (frame_or_window
), &x
, &y
, 0);
11470 DEFUN ("posn-at-point", Fposn_at_point
, Sposn_at_point
, 0, 2, 0,
11471 doc
: /* Return position information for buffer POS in WINDOW.
11472 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
11474 Return nil if position is not visible in window. Otherwise,
11475 the return value is similar to that returned by `event-start' for
11476 a mouse click at the upper left corner of the glyph corresponding
11477 to the given buffer position:
11478 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11479 IMAGE (DX . DY) (WIDTH . HEIGHT))
11480 The `posn-' functions access elements of such lists. */)
11482 Lisp_Object pos
, window
;
11487 window
= selected_window
;
11489 tem
= Fpos_visible_in_window_p (pos
, window
, Qt
);
11492 Lisp_Object x
= XCAR (tem
);
11493 Lisp_Object y
= XCAR (XCDR (tem
));
11495 /* Point invisible due to hscrolling? */
11498 tem
= Fposn_at_x_y (x
, y
, window
, Qnil
);
11506 * Set up a new kboard object with reasonable initial values.
11512 kb
->Voverriding_terminal_local_map
= Qnil
;
11513 kb
->Vlast_command
= Qnil
;
11514 kb
->Vreal_last_command
= Qnil
;
11515 kb
->Vkeyboard_translate_table
= Qnil
;
11516 kb
->Vlast_repeatable_command
= Qnil
;
11517 kb
->Vprefix_arg
= Qnil
;
11518 kb
->Vlast_prefix_arg
= Qnil
;
11519 kb
->kbd_queue
= Qnil
;
11520 kb
->kbd_queue_has_data
= 0;
11521 kb
->immediate_echo
= 0;
11522 kb
->echo_string
= Qnil
;
11523 kb
->echo_after_prompt
= -1;
11524 kb
->kbd_macro_buffer
= 0;
11525 kb
->kbd_macro_bufsize
= 0;
11526 kb
->defining_kbd_macro
= Qnil
;
11527 kb
->Vlast_kbd_macro
= Qnil
;
11528 kb
->reference_count
= 0;
11529 kb
->Vsystem_key_alist
= Qnil
;
11530 kb
->system_key_syms
= Qnil
;
11531 kb
->Vwindow_system
= Qt
; /* Unset. */
11532 kb
->Vinput_decode_map
= Fmake_sparse_keymap (Qnil
);
11533 kb
->Vlocal_function_key_map
= Fmake_sparse_keymap (Qnil
);
11534 Fset_keymap_parent (kb
->Vlocal_function_key_map
, Vfunction_key_map
);
11535 kb
->Vdefault_minibuffer_frame
= Qnil
;
11539 * Destroy the contents of a kboard object, but not the object itself.
11540 * We use this just before deleting it, or if we're going to initialize
11541 * it a second time.
11547 if (kb
->kbd_macro_buffer
)
11548 xfree (kb
->kbd_macro_buffer
);
11551 #ifdef MULTI_KBOARD
11553 /* Free KB and memory referenced from it. */
11561 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
11564 *kbp
= kb
->next_kboard
;
11566 /* Prevent a dangling reference to KB. */
11567 if (kb
== current_kboard
11568 && FRAMEP (selected_frame
)
11569 && FRAME_LIVE_P (XFRAME (selected_frame
)))
11571 current_kboard
= FRAME_KBOARD (XFRAME (selected_frame
));
11573 if (current_kboard
== kb
)
11581 #endif /* MULTI_KBOARD */
11586 /* This is correct before outermost invocation of the editor loop */
11587 command_loop_level
= -1;
11588 immediate_quit
= 0;
11589 quit_char
= Ctl ('g');
11590 Vunread_command_events
= Qnil
;
11591 unread_command_char
= -1;
11592 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
11594 recent_keys_index
= 0;
11595 kbd_fetch_ptr
= kbd_buffer
;
11596 kbd_store_ptr
= kbd_buffer
;
11597 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11598 do_mouse_tracking
= Qnil
;
11601 interrupt_input_blocked
= 0;
11602 interrupt_input_pending
= 0;
11604 /* This means that command_loop_1 won't try to select anything the first
11606 internal_last_event_frame
= Qnil
;
11607 Vlast_event_frame
= internal_last_event_frame
;
11609 #ifdef MULTI_KBOARD
11610 current_kboard
= initial_kboard
;
11612 /* Re-initialize the keyboard again. */
11613 wipe_kboard (current_kboard
);
11614 init_kboard (current_kboard
);
11615 /* A value of nil for Vwindow_system normally means a tty, but we also use
11616 it for the initial terminal since there is no window system there. */
11617 current_kboard
->Vwindow_system
= Qnil
;
11619 if (!noninteractive
)
11621 /* Before multi-tty support, these handlers used to be installed
11622 only if the current session was a tty session. Now an Emacs
11623 session may have multiple display types, so we always handle
11624 SIGINT. There is special code in interrupt_signal to exit
11625 Emacs on SIGINT when there are no termcap frames on the
11626 controlling terminal. */
11627 signal (SIGINT
, interrupt_signal
);
11628 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
11629 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
11630 SIGQUIT and we can't tell which one it will give us. */
11631 signal (SIGQUIT
, interrupt_signal
);
11632 #endif /* HAVE_TERMIO */
11634 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11636 if (!noninteractive
)
11637 signal (SIGIO
, input_available_signal
);
11640 /* Use interrupt input by default, if it works and noninterrupt input
11641 has deficiencies. */
11643 #ifdef INTERRUPT_INPUT
11644 interrupt_input
= 1;
11646 interrupt_input
= 0;
11649 /* Our VMS input only works by interrupts, as of now. */
11651 interrupt_input
= 1;
11657 if (keyboard_init_hook
)
11658 (*keyboard_init_hook
) ();
11660 #ifdef POLL_FOR_INPUT
11661 poll_suppress_count
= 1;
11666 /* This type's only use is in syms_of_keyboard, to initialize the
11667 event header symbols and put properties on them. */
11668 struct event_head
{
11674 struct event_head head_table
[] = {
11675 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
11676 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
11677 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
11678 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
11679 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
11680 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
11681 /* `select-window' should be handled just like `switch-frame'
11682 in read_key_sequence. */
11683 {&Qselect_window
, "select-window", &Qswitch_frame
}
11687 syms_of_keyboard ()
11689 Vpre_help_message
= Qnil
;
11690 staticpro (&Vpre_help_message
);
11692 Vlispy_mouse_stem
= build_string ("mouse");
11693 staticpro (&Vlispy_mouse_stem
);
11696 QCimage
= intern (":image");
11697 staticpro (&QCimage
);
11699 staticpro (&Qhelp_echo
);
11700 Qhelp_echo
= intern ("help-echo");
11703 Qrtl
= intern (":rtl");
11705 staticpro (&item_properties
);
11706 item_properties
= Qnil
;
11708 staticpro (&tool_bar_item_properties
);
11709 tool_bar_item_properties
= Qnil
;
11710 staticpro (&tool_bar_items_vector
);
11711 tool_bar_items_vector
= Qnil
;
11713 staticpro (&real_this_command
);
11714 real_this_command
= Qnil
;
11716 Qtimer_event_handler
= intern ("timer-event-handler");
11717 staticpro (&Qtimer_event_handler
);
11719 Qdisabled_command_function
= intern ("disabled-command-function");
11720 staticpro (&Qdisabled_command_function
);
11722 Qself_insert_command
= intern ("self-insert-command");
11723 staticpro (&Qself_insert_command
);
11725 Qforward_char
= intern ("forward-char");
11726 staticpro (&Qforward_char
);
11728 Qbackward_char
= intern ("backward-char");
11729 staticpro (&Qbackward_char
);
11731 Qdisabled
= intern ("disabled");
11732 staticpro (&Qdisabled
);
11734 Qundefined
= intern ("undefined");
11735 staticpro (&Qundefined
);
11737 Qpre_command_hook
= intern ("pre-command-hook");
11738 staticpro (&Qpre_command_hook
);
11740 Qpost_command_hook
= intern ("post-command-hook");
11741 staticpro (&Qpost_command_hook
);
11743 Qdeferred_action_function
= intern ("deferred-action-function");
11744 staticpro (&Qdeferred_action_function
);
11746 Qcommand_hook_internal
= intern ("command-hook-internal");
11747 staticpro (&Qcommand_hook_internal
);
11749 Qfunction_key
= intern ("function-key");
11750 staticpro (&Qfunction_key
);
11751 Qmouse_click
= intern ("mouse-click");
11752 staticpro (&Qmouse_click
);
11753 #if defined (WINDOWSNT) || defined (MAC_OS)
11754 Qlanguage_change
= intern ("language-change");
11755 staticpro (&Qlanguage_change
);
11757 Qdrag_n_drop
= intern ("drag-n-drop");
11758 staticpro (&Qdrag_n_drop
);
11760 Qsave_session
= intern ("save-session");
11761 staticpro (&Qsave_session
);
11764 Qmac_apple_event
= intern ("mac-apple-event");
11765 staticpro (&Qmac_apple_event
);
11769 Qdbus_event
= intern ("dbus-event");
11770 staticpro (&Qdbus_event
);
11773 Qmenu_enable
= intern ("menu-enable");
11774 staticpro (&Qmenu_enable
);
11775 Qmenu_alias
= intern ("menu-alias");
11776 staticpro (&Qmenu_alias
);
11777 QCenable
= intern (":enable");
11778 staticpro (&QCenable
);
11779 QCvisible
= intern (":visible");
11780 staticpro (&QCvisible
);
11781 QChelp
= intern (":help");
11782 staticpro (&QChelp
);
11783 QCfilter
= intern (":filter");
11784 staticpro (&QCfilter
);
11785 QCbutton
= intern (":button");
11786 staticpro (&QCbutton
);
11787 QCkeys
= intern (":keys");
11788 staticpro (&QCkeys
);
11789 QCkey_sequence
= intern (":key-sequence");
11790 staticpro (&QCkey_sequence
);
11791 QCtoggle
= intern (":toggle");
11792 staticpro (&QCtoggle
);
11793 QCradio
= intern (":radio");
11794 staticpro (&QCradio
);
11796 Qmode_line
= intern ("mode-line");
11797 staticpro (&Qmode_line
);
11798 Qvertical_line
= intern ("vertical-line");
11799 staticpro (&Qvertical_line
);
11800 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
11801 staticpro (&Qvertical_scroll_bar
);
11802 Qmenu_bar
= intern ("menu-bar");
11803 staticpro (&Qmenu_bar
);
11805 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11806 Qmouse_fixup_help_message
= intern ("mouse-fixup-help-message");
11807 staticpro (&Qmouse_fixup_help_message
);
11810 Qabove_handle
= intern ("above-handle");
11811 staticpro (&Qabove_handle
);
11812 Qhandle
= intern ("handle");
11813 staticpro (&Qhandle
);
11814 Qbelow_handle
= intern ("below-handle");
11815 staticpro (&Qbelow_handle
);
11816 Qup
= intern ("up");
11818 Qdown
= intern ("down");
11819 staticpro (&Qdown
);
11820 Qtop
= intern ("top");
11822 Qbottom
= intern ("bottom");
11823 staticpro (&Qbottom
);
11824 Qend_scroll
= intern ("end-scroll");
11825 staticpro (&Qend_scroll
);
11826 Qratio
= intern ("ratio");
11827 staticpro (&Qratio
);
11829 Qevent_kind
= intern ("event-kind");
11830 staticpro (&Qevent_kind
);
11831 Qevent_symbol_elements
= intern ("event-symbol-elements");
11832 staticpro (&Qevent_symbol_elements
);
11833 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
11834 staticpro (&Qevent_symbol_element_mask
);
11835 Qmodifier_cache
= intern ("modifier-cache");
11836 staticpro (&Qmodifier_cache
);
11838 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
11839 staticpro (&Qrecompute_lucid_menubar
);
11840 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
11841 staticpro (&Qactivate_menubar_hook
);
11843 Qpolling_period
= intern ("polling-period");
11844 staticpro (&Qpolling_period
);
11846 Qinput_method_function
= intern ("input-method-function");
11847 staticpro (&Qinput_method_function
);
11849 Qinput_method_exit_on_first_char
= intern ("input-method-exit-on-first-char");
11850 staticpro (&Qinput_method_exit_on_first_char
);
11851 Qinput_method_use_echo_area
= intern ("input-method-use-echo-area");
11852 staticpro (&Qinput_method_use_echo_area
);
11854 Fset (Qinput_method_exit_on_first_char
, Qnil
);
11855 Fset (Qinput_method_use_echo_area
, Qnil
);
11857 last_point_position_buffer
= Qnil
;
11858 last_point_position_window
= Qnil
;
11861 struct event_head
*p
;
11863 for (p
= head_table
;
11864 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
11867 *p
->var
= intern (p
->name
);
11868 staticpro (p
->var
);
11869 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
11870 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
11874 button_down_location
= Fmake_vector (make_number (1), Qnil
);
11875 staticpro (&button_down_location
);
11876 mouse_syms
= Fmake_vector (make_number (1), Qnil
);
11877 staticpro (&mouse_syms
);
11878 wheel_syms
= Fmake_vector (make_number (4), Qnil
);
11879 staticpro (&wheel_syms
);
11883 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
11885 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
11886 for (i
= 0; i
< len
; i
++)
11887 if (modifier_names
[i
])
11888 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
11889 staticpro (&modifier_symbols
);
11892 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
11893 staticpro (&recent_keys
);
11895 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
11896 staticpro (&this_command_keys
);
11898 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
11899 staticpro (&raw_keybuf
);
11901 Qextended_command_history
= intern ("extended-command-history");
11902 Fset (Qextended_command_history
, Qnil
);
11903 staticpro (&Qextended_command_history
);
11905 accent_key_syms
= Qnil
;
11906 staticpro (&accent_key_syms
);
11908 func_key_syms
= Qnil
;
11909 staticpro (&func_key_syms
);
11911 drag_n_drop_syms
= Qnil
;
11912 staticpro (&drag_n_drop_syms
);
11914 unread_switch_frame
= Qnil
;
11915 staticpro (&unread_switch_frame
);
11917 internal_last_event_frame
= Qnil
;
11918 staticpro (&internal_last_event_frame
);
11920 read_key_sequence_cmd
= Qnil
;
11921 staticpro (&read_key_sequence_cmd
);
11923 menu_bar_one_keymap_changed_items
= Qnil
;
11924 staticpro (&menu_bar_one_keymap_changed_items
);
11926 menu_bar_items_vector
= Qnil
;
11927 staticpro (&menu_bar_items_vector
);
11929 help_form_saved_window_configs
= Qnil
;
11930 staticpro (&help_form_saved_window_configs
);
11932 defsubr (&Scurrent_idle_time
);
11933 defsubr (&Sevent_symbol_parse_modifiers
);
11934 defsubr (&Sevent_convert_list
);
11935 defsubr (&Sread_key_sequence
);
11936 defsubr (&Sread_key_sequence_vector
);
11937 defsubr (&Srecursive_edit
);
11938 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11939 defsubr (&Strack_mouse
);
11941 defsubr (&Sinput_pending_p
);
11942 defsubr (&Scommand_execute
);
11943 defsubr (&Srecent_keys
);
11944 defsubr (&Sthis_command_keys
);
11945 defsubr (&Sthis_command_keys_vector
);
11946 defsubr (&Sthis_single_command_keys
);
11947 defsubr (&Sthis_single_command_raw_keys
);
11948 defsubr (&Sreset_this_command_lengths
);
11949 defsubr (&Sclear_this_command_keys
);
11950 defsubr (&Ssuspend_emacs
);
11951 defsubr (&Sabort_recursive_edit
);
11952 defsubr (&Sexit_recursive_edit
);
11953 defsubr (&Srecursion_depth
);
11954 defsubr (&Stop_level
);
11955 defsubr (&Sdiscard_input
);
11956 defsubr (&Sopen_dribble_file
);
11957 defsubr (&Sset_input_interrupt_mode
);
11958 defsubr (&Sset_output_flow_control
);
11959 defsubr (&Sset_input_meta_mode
);
11960 defsubr (&Sset_quit_char
);
11961 defsubr (&Sset_input_mode
);
11962 defsubr (&Scurrent_input_mode
);
11963 defsubr (&Sexecute_extended_command
);
11964 defsubr (&Sposn_at_point
);
11965 defsubr (&Sposn_at_x_y
);
11967 DEFVAR_LISP ("last-command-char", &last_command_char
,
11968 doc
: /* Last input event that was part of a command. */);
11970 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
11971 doc
: /* Last input event that was part of a command. */);
11973 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
11974 doc
: /* Last input event in a command, except for mouse menu events.
11975 Mouse menus give back keys that don't look like mouse events;
11976 this variable holds the actual mouse event that led to the menu,
11977 so that you can determine whether the command was run by mouse or not. */);
11979 DEFVAR_LISP ("last-input-char", &last_input_char
,
11980 doc
: /* Last input event. */);
11982 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
11983 doc
: /* Last input event. */);
11985 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
11986 doc
: /* List of events to be read as the command input.
11987 These events are processed first, before actual keyboard input.
11988 Events read from this list are not normally added to `this-command-keys',
11989 as they will already have been added once as they were read for the first time.
11990 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
11991 Vunread_command_events
= Qnil
;
11993 DEFVAR_INT ("unread-command-char", &unread_command_char
,
11994 doc
: /* If not -1, an object to be read as next command input event. */);
11996 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
11997 doc
: /* List of events to be processed as input by input methods.
11998 These events are processed before `unread-command-events'
11999 and actual keyboard input, but are not given to `input-method-function'. */);
12000 Vunread_post_input_method_events
= Qnil
;
12002 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
12003 doc
: /* List of events to be processed as input by input methods.
12004 These events are processed after `unread-command-events', but
12005 before actual keyboard input.
12006 If there's an active input method, the events are given to
12007 `input-method-function'. */);
12008 Vunread_input_method_events
= Qnil
;
12010 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
12011 doc
: /* Meta-prefix character code.
12012 Meta-foo as command input turns into this character followed by foo. */);
12013 XSETINT (meta_prefix_char
, 033);
12015 DEFVAR_KBOARD ("last-command", Vlast_command
,
12016 doc
: /* The last command executed.
12017 Normally a symbol with a function definition, but can be whatever was found
12018 in the keymap, or whatever the variable `this-command' was set to by that
12021 The value `mode-exit' is special; it means that the previous command
12022 read an event that told it to exit, and it did so and unread that event.
12023 In other words, the present command is the event that made the previous
12026 The value `kill-region' is special; it means that the previous command
12027 was a kill command.
12029 `last-command' has a separate binding for each terminal device.
12030 See Info node `(elisp)Multiple displays'. */);
12032 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
12033 doc
: /* Same as `last-command', but never altered by Lisp code. */);
12035 DEFVAR_KBOARD ("last-repeatable-command", Vlast_repeatable_command
,
12036 doc
: /* Last command that may be repeated.
12037 The last command executed that was not bound to an input event.
12038 This is the command `repeat' will try to repeat. */);
12040 DEFVAR_LISP ("this-command", &Vthis_command
,
12041 doc
: /* The command now being executed.
12042 The command can set this variable; whatever is put here
12043 will be in `last-command' during the following command. */);
12044 Vthis_command
= Qnil
;
12046 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
12047 doc
: /* The command bound to the current key sequence before remapping.
12048 It equals `this-command' if the original command was not remapped through
12049 any of the active keymaps. Otherwise, the value of `this-command' is the
12050 result of looking up the original command in the active keymaps. */);
12051 Vthis_original_command
= Qnil
;
12053 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
12054 doc
: /* *Number of input events between auto-saves.
12055 Zero means disable autosaving due to number of characters typed. */);
12056 auto_save_interval
= 300;
12058 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
12059 doc
: /* *Number of seconds idle time before auto-save.
12060 Zero or nil means disable auto-saving due to idleness.
12061 After auto-saving due to this many seconds of idle time,
12062 Emacs also does a garbage collection if that seems to be warranted. */);
12063 XSETFASTINT (Vauto_save_timeout
, 30);
12065 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
12066 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
12067 The value may be integer or floating point. */);
12068 Vecho_keystrokes
= make_number (1);
12070 DEFVAR_INT ("polling-period", &polling_period
,
12071 doc
: /* *Interval between polling for input during Lisp execution.
12072 The reason for polling is to make C-g work to stop a running program.
12073 Polling is needed only when using X windows and SIGIO does not work.
12074 Polling is automatically disabled in all other cases. */);
12075 polling_period
= 2;
12077 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
12078 doc
: /* *Maximum time between mouse clicks to make a double-click.
12079 Measured in milliseconds. The value nil means disable double-click
12080 recognition; t means double-clicks have no time limit and are detected
12081 by position only. */);
12082 Vdouble_click_time
= make_number (500);
12084 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
12085 doc
: /* *Maximum mouse movement between clicks to make a double-click.
12086 On window-system frames, value is the number of pixels the mouse may have
12087 moved horizontally or vertically between two clicks to make a double-click.
12088 On non window-system frames, value is interpreted in units of 1/8 characters
12091 This variable is also the threshold for motion of the mouse
12092 to count as a drag. */);
12093 double_click_fuzz
= 3;
12095 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
12096 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
12097 inhibit_local_menu_bar_menus
= 0;
12099 DEFVAR_INT ("num-input-keys", &num_input_keys
,
12100 doc
: /* Number of complete key sequences read as input so far.
12101 This includes key sequences read from keyboard macros.
12102 The number is effectively the number of interactive command invocations. */);
12103 num_input_keys
= 0;
12105 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
12106 doc
: /* Number of input events read from the keyboard so far.
12107 This does not include events generated by keyboard macros. */);
12108 num_nonmacro_input_events
= 0;
12110 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
12111 doc
: /* The frame in which the most recently read event occurred.
12112 If the last event came from a keyboard macro, this is set to `macro'. */);
12113 Vlast_event_frame
= Qnil
;
12115 /* This variable is set up in sysdep.c. */
12116 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
12117 doc
: /* The ERASE character as set by the user with stty. */);
12119 DEFVAR_LISP ("help-char", &Vhelp_char
,
12120 doc
: /* Character to recognize as meaning Help.
12121 When it is read, do `(eval help-form)', and display result if it's a string.
12122 If the value of `help-form' is nil, this char can be read normally. */);
12123 XSETINT (Vhelp_char
, Ctl ('H'));
12125 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
12126 doc
: /* List of input events to recognize as meaning Help.
12127 These work just like the value of `help-char' (see that). */);
12128 Vhelp_event_list
= Qnil
;
12130 DEFVAR_LISP ("help-form", &Vhelp_form
,
12131 doc
: /* Form to execute when character `help-char' is read.
12132 If the form returns a string, that string is displayed.
12133 If `help-form' is nil, the help char is not recognized. */);
12136 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
12137 doc
: /* Command to run when `help-char' character follows a prefix key.
12138 This command is used only when there is no actual binding
12139 for that character after that prefix key. */);
12140 Vprefix_help_command
= Qnil
;
12142 DEFVAR_LISP ("top-level", &Vtop_level
,
12143 doc
: /* Form to evaluate when Emacs starts up.
12144 Useful to set before you dump a modified Emacs. */);
12147 DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table
,
12148 doc
: /* Translate table for local keyboard input, or nil.
12149 If non-nil, the value should be a char-table. Each character read
12150 from the keyboard is looked up in this char-table. If the value found
12151 there is non-nil, then it is used instead of the actual input character.
12153 The value can also be a string or vector, but this is considered obsolete.
12154 If it is a string or vector of length N, character codes N and up are left
12155 untranslated. In a vector, an element which is nil means "no translation".
12157 This is applied to the characters supplied to input methods, not their
12158 output. See also `translation-table-for-input'.
12160 This variable has a separate binding for each terminal. See Info node
12161 `(elisp)Multiple displays'. */);
12163 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
12164 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
12165 \(Even if the operating system has support for stopping a process.\) */);
12166 cannot_suspend
= 0;
12168 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
12169 doc
: /* Non-nil means prompt with menus when appropriate.
12170 This is done when reading from a keymap that has a prompt string,
12171 for elements that have prompt strings.
12172 The menu is displayed on the screen
12173 if X menus were enabled at configuration
12174 time and the previous event was a mouse click prefix key.
12175 Otherwise, menu prompting uses the echo area. */);
12176 menu_prompting
= 1;
12178 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
12179 doc
: /* Character to see next line of menu prompt.
12180 Type this character while in a menu prompt to rotate around the lines of it. */);
12181 XSETINT (menu_prompt_more_char
, ' ');
12183 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
12184 doc
: /* A mask of additional modifier keys to use with every keyboard character.
12185 Emacs applies the modifiers of the character stored here to each keyboard
12186 character it reads. For example, after evaluating the expression
12187 (setq extra-keyboard-modifiers ?\\C-x)
12188 all input characters will have the control modifier applied to them.
12190 Note that the character ?\\C-@, equivalent to the integer zero, does
12191 not count as a control character; rather, it counts as a character
12192 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
12193 cancels any modification. */);
12194 extra_keyboard_modifiers
= 0;
12196 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
12197 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
12198 The command loop sets this to nil before each command,
12199 and tests the value when the command returns.
12200 Buffer modification stores t in this variable. */);
12201 Vdeactivate_mark
= Qnil
;
12203 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
12204 doc
: /* Temporary storage of pre-command-hook or post-command-hook. */);
12205 Vcommand_hook_internal
= Qnil
;
12207 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
12208 doc
: /* Normal hook run before each command is executed.
12209 If an unhandled error happens in running this hook,
12210 the hook value is set to nil, since otherwise the error
12211 might happen repeatedly and make Emacs nonfunctional. */);
12212 Vpre_command_hook
= Qnil
;
12214 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
12215 doc
: /* Normal hook run after each command is executed.
12216 If an unhandled error happens in running this hook,
12217 the hook value is set to nil, since otherwise the error
12218 might happen repeatedly and make Emacs nonfunctional. */);
12219 Vpost_command_hook
= Qnil
;
12222 DEFVAR_LISP ("echo-area-clear-hook", ...,
12223 doc
: /* Normal hook run when clearing the echo area. */);
12225 Qecho_area_clear_hook
= intern ("echo-area-clear-hook");
12226 staticpro (&Qecho_area_clear_hook
);
12227 SET_SYMBOL_VALUE (Qecho_area_clear_hook
, Qnil
);
12229 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
12230 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
12231 Vlucid_menu_bar_dirty_flag
= Qnil
;
12233 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
12234 doc
: /* List of menu bar items to move to the end of the menu bar.
12235 The elements of the list are event types that may have menu bar bindings. */);
12236 Vmenu_bar_final_items
= Qnil
;
12238 DEFVAR_KBOARD ("overriding-terminal-local-map",
12239 Voverriding_terminal_local_map
,
12240 doc
: /* Per-terminal keymap that overrides all other local keymaps.
12241 If this variable is non-nil, it is used as a keymap instead of the
12242 buffer's local map, and the minor mode keymaps and text property keymaps.
12243 It also replaces `overriding-local-map'.
12245 This variable is intended to let commands such as `universal-argument'
12246 set up a different keymap for reading the next command.
12248 `overriding-terminal-local-map' has a separate binding for each
12250 See Info node `(elisp)Multiple displays'. */);
12252 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
12253 doc
: /* Keymap that overrides all other local keymaps.
12254 If this variable is non-nil, it is used as a keymap--replacing the
12255 buffer's local map, the minor mode keymaps, and char property keymaps. */);
12256 Voverriding_local_map
= Qnil
;
12258 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
12259 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
12260 Otherwise, the menu bar continues to reflect the buffer's local map
12261 and the minor mode maps regardless of `overriding-local-map'. */);
12262 Voverriding_local_map_menu_flag
= Qnil
;
12264 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
12265 doc
: /* Keymap defining bindings for special events to execute at low level. */);
12266 Vspecial_event_map
= Fcons (intern ("keymap"), Qnil
);
12268 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
12269 doc
: /* *Non-nil means generate motion events for mouse motion. */);
12271 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
12272 doc
: /* Alist of system-specific X windows key symbols.
12273 Each element should have the form (N . SYMBOL) where N is the
12274 numeric keysym code (sans the \"system-specific\" bit 1<<28)
12275 and SYMBOL is its name.
12277 `system-key-alist' has a separate binding for each terminal device.
12278 See Info node `(elisp)Multiple displays'. */);
12280 DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map
,
12281 doc
: /* Keymap that translates key sequences to key sequences during input.
12282 This is used mainly for mapping key sequences into some preferred
12283 key events (symbols).
12285 The `read-key-sequence' function replaces any subsequence bound by
12286 `local-function-key-map' with its binding. More precisely, when the
12287 active keymaps have no binding for the current key sequence but
12288 `local-function-key-map' binds a suffix of the sequence to a vector or
12289 string, `read-key-sequence' replaces the matching suffix with its
12290 binding, and continues with the new sequence.
12292 If the binding is a function, it is called with one argument (the prompt)
12293 and its return value (a key sequence) is used.
12295 The events that come from bindings in `local-function-key-map' are not
12296 themselves looked up in `local-function-key-map'.
12298 For example, suppose `local-function-key-map' binds `ESC O P' to [f1].
12299 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
12300 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix key,
12301 typing `ESC O P x' would return [f1 x].
12303 `local-function-key-map' has a separate binding for each terminal
12304 device. See Info node `(elisp)Multiple displays'. If you need to
12305 define a binding on all terminals, change `function-key-map'
12306 instead. Initially, `local-function-key-map' is an empty keymap that
12307 has `function-key-map' as its parent on all terminal devices. */);
12309 DEFVAR_KBOARD ("input-decode-map", Vinput_decode_map
,
12310 doc
: /* Keymap that decodes input escape sequences.
12311 This is used mainly for mapping ASCII function key sequences into
12312 real Emacs function key events (symbols).
12314 The `read-key-sequence' function replaces any subsequence bound by
12315 `local-function-key-map' with its binding. Contrary to `function-key-map',
12316 this map applies its rebinding regardless of the presence of an ordinary
12317 binding. So it is more like `key-translation-map' except that it applies
12318 before `function-key-map' rather than after.
12320 If the binding is a function, it is called with one argument (the prompt)
12321 and its return value (a key sequence) is used.
12323 The events that come from bindings in `input-decode-map' are not
12324 themselves looked up in `input-decode-map'.
12326 This variable is keyboard-local. */);
12328 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
12329 doc
: /* The parent keymap of all `local-function-key-map' instances.
12330 Function key definitions that apply to all terminal devices should go
12331 here. If a mapping is defined in both the current
12332 `local-function-key-map' binding and this variable, then the local
12333 definition will take precendence. */);
12334 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
12336 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
12337 doc
: /* Keymap of key translations that can override keymaps.
12338 This keymap works like `function-key-map', but comes after that,
12339 and its non-prefix bindings override ordinary bindings.
12340 Another difference is that it is global rather than keyboard-local. */);
12341 Vkey_translation_map
= Fmake_sparse_keymap (Qnil
);
12343 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
12344 doc
: /* List of deferred actions to be performed at a later time.
12345 The precise format isn't relevant here; we just check whether it is nil. */);
12346 Vdeferred_action_list
= Qnil
;
12348 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
12349 doc
: /* Function to call to handle deferred actions, after each command.
12350 This function is called with no arguments after each command
12351 whenever `deferred-action-list' is non-nil. */);
12352 Vdeferred_action_function
= Qnil
;
12354 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
12355 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
12356 The value can be a length of time to show the message for.
12357 If the value is non-nil and not a number, we wait 2 seconds. */);
12358 Vsuggest_key_bindings
= Qt
;
12360 DEFVAR_LISP ("timer-list", &Vtimer_list
,
12361 doc
: /* List of active absolute time timers in order of increasing time. */);
12362 Vtimer_list
= Qnil
;
12364 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
12365 doc
: /* List of active idle-time timers in order of increasing time. */);
12366 Vtimer_idle_list
= Qnil
;
12368 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
12369 doc
: /* If non-nil, the function that implements the current input method.
12370 It's called with one argument, a printing character that was just read.
12371 \(That means a character with code 040...0176.)
12372 Typically this function uses `read-event' to read additional events.
12373 When it does so, it should first bind `input-method-function' to nil
12374 so it will not be called recursively.
12376 The function should return a list of zero or more events
12377 to be used as input. If it wants to put back some events
12378 to be reconsidered, separately, by the input method,
12379 it can add them to the beginning of `unread-command-events'.
12381 The input method function can find in `input-method-previous-method'
12382 the previous echo area message.
12384 The input method function should refer to the variables
12385 `input-method-use-echo-area' and `input-method-exit-on-first-char'
12386 for guidance on what to do. */);
12387 Vinput_method_function
= Qnil
;
12389 DEFVAR_LISP ("input-method-previous-message",
12390 &Vinput_method_previous_message
,
12391 doc
: /* When `input-method-function' is called, hold the previous echo area message.
12392 This variable exists because `read-event' clears the echo area
12393 before running the input method. It is nil if there was no message. */);
12394 Vinput_method_previous_message
= Qnil
;
12396 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
12397 doc
: /* If non-nil, the function that implements the display of help.
12398 It's called with one argument, the help string to display. */);
12399 Vshow_help_function
= Qnil
;
12401 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
12402 doc
: /* If non-nil, suppress point adjustment after executing a command.
12404 After a command is executed, if point is moved into a region that has
12405 special properties (e.g. composition, display), we adjust point to
12406 the boundary of the region. But, when a command sets this variable to
12407 non-nil, we suppress the point adjustment.
12409 This variable is set to nil before reading a command, and is checked
12410 just after executing the command. */);
12411 Vdisable_point_adjustment
= Qnil
;
12413 DEFVAR_LISP ("global-disable-point-adjustment",
12414 &Vglobal_disable_point_adjustment
,
12415 doc
: /* *If non-nil, always suppress point adjustment.
12417 The default value is nil, in which case, point adjustment are
12418 suppressed only after special commands that set
12419 `disable-point-adjustment' (which see) to non-nil. */);
12420 Vglobal_disable_point_adjustment
= Qnil
;
12422 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
12423 doc
: /* *How long to display an echo-area message when the minibuffer is active.
12424 If the value is not a number, such messages don't time out. */);
12425 Vminibuffer_message_timeout
= make_number (2);
12427 DEFVAR_LISP ("throw-on-input", &Vthrow_on_input
,
12428 doc
: /* If non-nil, any keyboard input throws to this symbol.
12429 The value of that variable is passed to `quit-flag' and later causes a
12430 peculiar kind of quitting. */);
12431 Vthrow_on_input
= Qnil
;
12433 DEFVAR_LISP ("command-error-function", &Vcommand_error_function
,
12434 doc
: /* If non-nil, function to output error messages.
12435 The arguments are the error data, a list of the form
12436 (SIGNALED-CONDITIONS . SIGNAL-DATA)
12437 such as just as `condition-case' would bind its variable to,
12438 the context (a string which normally goes at the start of the message),
12439 and the Lisp function within which the error was signaled. */);
12440 Vcommand_error_function
= Qnil
;
12442 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
12443 &Venable_disabled_menus_and_buttons
,
12444 doc
: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
12446 Help functions bind this to allow help on disabled menu items
12447 and tool-bar buttons. */);
12448 Venable_disabled_menus_and_buttons
= Qnil
;
12450 #ifdef MULTI_KBOARD
12451 /* Create the initial keyboard. */
12452 initial_kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
12453 init_kboard (initial_kboard
);
12454 /* Vwindow_system is left at t for now. */
12455 initial_kboard
->next_kboard
= all_kboards
;
12456 all_kboards
= initial_kboard
;
12461 keys_of_keyboard ()
12463 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
12464 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
12465 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
12466 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
12467 initial_define_key (meta_map
, 'x', "execute-extended-command");
12469 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
12470 "handle-delete-frame");
12471 /* Here we used to use `ignore-event' which would simple set prefix-arg to
12472 current-prefix-arg, as is done in `handle-switch-frame'.
12473 But `handle-switch-frame is not run from the special-map.
12474 Commands from that map are run in a special way that automatically
12475 preserves the prefix-arg. Restoring the prefix arg here is not just
12476 redundant but harmful:
12478 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
12479 - after the first prompt, the exit-minibuffer-hook is run which may
12480 iconify a frame and thus push a `iconify-frame' event.
12481 - after running exit-minibuffer-hook, current-prefix-arg is
12482 restored to the non-nil value it had before the prompt.
12483 - we enter the second prompt.
12484 current-prefix-arg is non-nil, prefix-arg is nil.
12485 - before running the first real event, we run the special iconify-frame
12486 event, but we pass the `special' arg to execute-command so
12487 current-prefix-arg and prefix-arg are left untouched.
12488 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
12489 - the next key event will have a spuriously non-nil current-prefix-arg. */
12490 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
12492 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
12494 /* Handling it at such a low-level causes read_key_sequence to get
12495 * confused because it doesn't realize that the current_buffer was
12496 * changed by read_char.
12498 * initial_define_lispy_key (Vspecial_event_map, "select-window",
12499 * "handle-select-window"); */
12500 initial_define_lispy_key (Vspecial_event_map
, "save-session",
12501 "handle-save-session");
12504 /* Define a special event which is raised for dbus callback
12506 initial_define_lispy_key (Vspecial_event_map
, "dbus-event",
12507 "dbus-handle-event");
12511 /* Mark the pointers in the kboard objects.
12512 Called by the Fgarbage_collector. */
12518 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
12520 if (kb
->kbd_macro_buffer
)
12521 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
12523 mark_object (kb
->Voverriding_terminal_local_map
);
12524 mark_object (kb
->Vlast_command
);
12525 mark_object (kb
->Vreal_last_command
);
12526 mark_object (kb
->Vkeyboard_translate_table
);
12527 mark_object (kb
->Vlast_repeatable_command
);
12528 mark_object (kb
->Vprefix_arg
);
12529 mark_object (kb
->Vlast_prefix_arg
);
12530 mark_object (kb
->kbd_queue
);
12531 mark_object (kb
->defining_kbd_macro
);
12532 mark_object (kb
->Vlast_kbd_macro
);
12533 mark_object (kb
->Vsystem_key_alist
);
12534 mark_object (kb
->system_key_syms
);
12535 mark_object (kb
->Vwindow_system
);
12536 mark_object (kb
->Vinput_decode_map
);
12537 mark_object (kb
->Vlocal_function_key_map
);
12538 mark_object (kb
->Vdefault_minibuffer_frame
);
12539 mark_object (kb
->echo_string
);
12542 struct input_event
*event
;
12543 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
12545 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
12546 event
= kbd_buffer
;
12547 if (event
->kind
!= SELECTION_REQUEST_EVENT
12548 && event
->kind
!= SELECTION_CLEAR_EVENT
)
12550 mark_object (event
->x
);
12551 mark_object (event
->y
);
12553 mark_object (event
->frame_or_window
);
12554 mark_object (event
->arg
);
12559 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
12560 (do not change this comment) */